ethereum.forks.frontier.transactions

Transactions are atomic units of work created externally to Ethereum and submitted to be executed. If Ethereum is viewed as a state machine, transactions are the events that move between states.

Transaction

Atomic operation performed on the block chain.

25
@slotted_freezable
26
@dataclass
class Transaction:

nonce

A scalar value equal to the number of transactions sent by the sender.

32
    nonce: U256

gas_price

The price of gas for this transaction, in wei.

37
    gas_price: Uint

gas

The maximum amount of gas that can be used by this transaction.

42
    gas: Uint

to

The address of the recipient. If empty, the transaction is a contract creation.

47
    to: Bytes0 | Address

value

The amount of ether (in wei) to send with this transaction.

53
    value: U256

data

The data payload of the transaction, which can be used to call functions on contracts or to create new contracts.

58
    data: Bytes

v

The recovery id of the signature.

64
    v: U256

r

The first part of the signature.

69
    r: U256

s

The second part of the signature.

74
    s: U256

validate_transaction

Verifies a transaction.

The gas in a transaction gets used to pay for the intrinsic cost of operations, therefore if there is insufficient gas then it would not be possible to execute a transaction and it will be declared invalid.

Additionally, the nonce of a transaction must not equal or exceed the limit defined in EIP-2681, applied retroactively. In practice, defining the limit as 2**64-1 has no impact because sending 2**64-1 transactions is improbable. It's not strictly impossible though, 2**64-1 transactions is the entire capacity of the Ethereum blockchain at 2022 gas limits for a little over 22 years.

This function takes a transaction as a parameter and returns the intrinsic gas cost of the transaction after validation. It throws an InsufficientTransactionGasError exception if the transaction does not provide enough gas to cover the intrinsic cost, and a NonceOverflowError exception if the nonce is greater than 2**64 - 2.

def validate_transaction(​tx: Transaction​) -> Uint:
81
    """
82
    Verifies a transaction.
83
84
    The gas in a transaction gets used to pay for the intrinsic cost of
85
    operations, therefore if there is insufficient gas then it would not
86
    be possible to execute a transaction and it will be declared invalid.
87
88
    Additionally, the nonce of a transaction must not equal or exceed the
89
    limit defined in [EIP-2681], applied retroactively.
90
    In practice, defining the limit as ``2**64-1`` has no impact because
91
    sending ``2**64-1`` transactions is improbable. It's not strictly
92
    impossible though, ``2**64-1`` transactions is the entire capacity of the
93
    Ethereum blockchain at 2022 gas limits for a little over 22 years.
94
95
    This function takes a transaction as a parameter and returns the intrinsic
96
    gas cost of the transaction after validation. It throws an
97
    `InsufficientTransactionGasError` exception if the transaction does not
98
    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
99
    exception if the nonce is greater than `2**64 - 2`.
100
101
    [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
102
    """
103
    intrinsic_gas = calculate_intrinsic_cost(tx)
104
    if intrinsic_gas > tx.gas:
105
        raise InsufficientTransactionGasError("Insufficient gas")
106
    if U256(tx.nonce) >= U256(U64.MAX_VALUE):
107
        raise NonceOverflowError("Nonce too high")
108
    return intrinsic_gas

calculate_intrinsic_cost

Calculates the gas that is charged before execution is started.

The intrinsic cost of the transaction is charged before execution has begun. Functions/operations in the EVM cost money to execute so this intrinsic cost is for the operations that need to be paid for as part of the transaction. Data transfer, for example, is part of this intrinsic cost. It costs ether to send data over the wire and that ether is accounted for in the intrinsic cost calculated in this function. This intrinsic cost must be calculated and paid for before execution in order for all operations to be implemented.

The intrinsic cost includes:

  1. Base cost (TX_BASE)

  2. Cost for data (zero and non-zero bytes)

This function takes a transaction as a parameter and returns the intrinsic gas cost of the transaction.

def calculate_intrinsic_cost(​tx: Transaction​) -> Uint:
112
    """
113
    Calculates the gas that is charged before execution is started.
114
115
    The intrinsic cost of the transaction is charged before execution has
116
    begun. Functions/operations in the EVM cost money to execute so this
117
    intrinsic cost is for the operations that need to be paid for as part of
118
    the transaction. Data transfer, for example, is part of this intrinsic
119
    cost. It costs ether to send data over the wire and that ether is
120
    accounted for in the intrinsic cost calculated in this function. This
121
    intrinsic cost must be calculated and paid for before execution in order
122
    for all operations to be implemented.
123
124
    The intrinsic cost includes:
125
    1. Base cost (`TX_BASE`)
126
    2. Cost for data (zero and non-zero bytes)
127
128
    This function takes a transaction as a parameter and returns the intrinsic
129
    gas cost of the transaction.
130
    """
131
    from .vm.gas import GasCosts
132
133
    num_zeros = Uint(tx.data.count(0))
134
    num_non_zeros = ulen(tx.data) - num_zeros
135
    data_cost = (
136
        num_zeros * GasCosts.TX_DATA_PER_ZERO
137
        + num_non_zeros * GasCosts.TX_DATA_PER_NON_ZERO
138
    )
139
140
    return GasCosts.TX_BASE + data_cost

recover_sender

Extracts the sender address from a transaction.

The v, r, and s values are the three parts that make up the signature of a transaction. In order to recover the sender of a transaction the two components needed are the signature (v, r, and s) and the signing hash of the transaction. The sender's public key can be obtained with these two values and therefore the sender address can be retrieved.

This function takes a transaction as a parameter and returns the address of the sender of the transaction. It raises an InvalidSignatureError if the signature values (r, s, v) are invalid.

def recover_sender(​tx: Transaction​) -> Address:
144
    """
145
    Extracts the sender address from a transaction.
146
147
    The v, r, and s values are the three parts that make up the signature
148
    of a transaction. In order to recover the sender of a transaction the two
149
    components needed are the signature (``v``, ``r``, and ``s``) and the
150
    signing hash of the transaction. The sender's public key can be obtained
151
    with these two values and therefore the sender address can be retrieved.
152
153
    This function takes a transaction as a parameter and returns
154
    the address of the sender of the transaction. It raises an
155
    `InvalidSignatureError` if the signature values (r, s, v) are invalid.
156
    """
157
    v, r, s = tx.v, tx.r, tx.s
158
    if v != 27 and v != 28:
159
        raise InvalidSignatureError("bad v")
160
    if U256(0) >= r or r >= SECP256K1N:
161
        raise InvalidSignatureError("bad r")
162
    if U256(0) >= s or s >= SECP256K1N:
163
        raise InvalidSignatureError("bad s")
164
165
    public_key = secp256k1_recover(r, s, v - U256(27), signing_hash(tx))
166
    return Address(keccak256(public_key)[12:32])

signing_hash

Compute the hash of a transaction used in the signature.

The values that are used to compute the signing hash set the rules for a transaction. For example, signing over the gas sets a limit for the amount of money that is allowed to be pulled out of the sender's account.

This function takes a transaction as a parameter and returns the signing hash of the transaction.

def signing_hash(​tx: Transaction​) -> Hash32:
170
    """
171
    Compute the hash of a transaction used in the signature.
172
173
    The values that are used to compute the signing hash set the rules for a
174
    transaction. For example, signing over the gas sets a limit for the
175
    amount of money that is allowed to be pulled out of the sender's account.
176
177
    This function takes a transaction as a parameter and returns the
178
    signing hash of the transaction.
179
    """
180
    return keccak256(
181
        rlp.encode(
182
            (
183
                tx.nonce,
184
                tx.gas_price,
185
                tx.gas,
186
                tx.to,
187
                tx.value,
188
                tx.data,
189
            )
190
        )
191
    )

get_transaction_hash

Compute the hash of a transaction.

This function takes a transaction as a parameter and returns the hash of the transaction.

def get_transaction_hash(​tx: Transaction​) -> Hash32:
195
    """
196
    Compute the hash of a transaction.
197
198
    This function takes a transaction as a parameter and returns the
199
    hash of the transaction.
200
    """
201
    return keccak256(rlp.encode(tx))