ethereum.forks.constantinople.transactionsethereum.forks.istanbul.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 | @final |
|---|
| 26 | @slotted_freezable |
|---|
| 27 | @dataclass |
|---|
class Transaction:
nonce¶
A scalar value equal to the number of transactions sent by the sender.
| 33 | nonce: U256 |
|---|
gas_price¶
The price of gas for this transaction, in wei.
| 38 | gas_price: Uint |
|---|
gas¶
The maximum amount of gas that can be used by this transaction.
| 43 | gas: Uint |
|---|
to¶
The address of the recipient. If empty, the transaction is a contract creation.
| 48 | to: Bytes0 | Address |
|---|
value¶
The amount of ether (in wei) to send with this transaction.
| 54 | value: U256 |
|---|
data¶
The data payload of the transaction, which can be used to call functions on contracts or to create new contracts.
| 59 | data: Bytes |
|---|
v¶
The recovery id of the signature.
| 65 | v: U256 |
|---|
r¶
The first part of the signature.
| 70 | r: U256 |
|---|
s¶
The second part of the signature.
| 75 | 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.
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:
| 82 | <snip> |
|---|---|
| 104 | intrinsic_gas = calculate_intrinsic_cost(tx) |
| 105 | if intrinsic_gas > tx.gas: |
| 106 | raise InsufficientTransactionGasError("Insufficient gas") |
| 107 | if U256(tx.nonce) >= U256(U64.MAX_VALUE): |
| 108 | raise NonceOverflowError("Nonce too high") |
| 109 | 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:
Base cost (
TX_BASE)Cost for data (zero and non-zero bytes)
Cost for contract creation (if applicable)
This function takes a transaction as a parameter and returns the intrinsic gas cost of the transaction.
def calculate_intrinsic_cost(tx: Transaction) -> Uint:
| 113 | <snip> |
|---|---|
| 133 | from .vm.gas import GasCosts |
| 134 | |
| 135 | num_zeros = Uint(tx.data.count(0)) |
| 136 | num_non_zeros = ulen(tx.data) - num_zeros |
| 137 | data_cost = ( |
| 138 | num_zeros * GasCosts.TX_DATA_PER_ZERO |
| 139 | + num_non_zeros * GasCosts.TX_DATA_PER_NON_ZERO |
| 140 | ) |
| 141 | |
| 142 | if tx.to == Bytes0(b""): |
| 143 | create_cost = GasCosts.TX_CREATE |
| 144 | else: |
| 145 | create_cost = Uint(0) |
| 146 | |
| 147 | return GasCosts.TX_BASE + data_cost + create_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 chain_id and a transaction as parameters 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(chain_id: U64, tx: Transaction) -> Address:
| 151 | <snip> |
|---|---|
| 164 | v, r, s = tx.v, tx.r, tx.s |
| 165 | if U256(0) >= r or r >= SECP256K1N: |
| 166 | raise InvalidSignatureError("bad r") |
| 167 | if U256(0) >= s or s > SECP256K1N // U256(2): |
| 168 | raise InvalidSignatureError("bad s") |
| 169 | |
| 170 | if v == 27 or v == 28: |
| 171 | public_key = secp256k1_recover( |
| 172 | r, s, v - U256(27), signing_hash_pre155(tx) |
| 173 | ) |
| 174 | else: |
| 175 | chain_id_x2 = U256(chain_id) * U256(2) |
| 176 | if v != U256(35) + chain_id_x2 and v != U256(36) + chain_id_x2: |
| 177 | raise InvalidSignatureError("bad v") |
| 178 | public_key = secp256k1_recover( |
| 179 | r, s, v - U256(35) - chain_id_x2, signing_hash_155(tx, chain_id) |
| 180 | ) |
| 181 | |
| 182 | return Address(keccak256(public_key)[12:32]) |
signing_hash_pre155 ¶
Compute the hash of a transaction used in a legacy (pre EIP-155) signature.
This function takes a transaction as a parameter and returns the signing hash of the transaction.
signing_hash_155 ¶
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:
| 236 | <snip> |
|---|---|
| 242 | return keccak256(rlp.encode(tx)) |