ethereum.forks.shanghai.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.

LegacyTransaction

Atomic operation performed on the block chain. This represents the original transaction format used before EIP-1559, and EIP-2930.

31
@final
32
@slotted_freezable
33
@dataclass
class LegacyTransaction:

nonce

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

43
    nonce: U256

gas_price

The price of gas for this transaction, in wei.

48
    gas_price: Uint

gas

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

53
    gas: Uint

to

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

58
    to: Bytes0 | Address

value

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

64
    value: U256

data

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

69
    data: Bytes

v

The recovery id of the signature.

75
    v: U256

r

The first part of the signature.

80
    r: U256

s

The second part of the signature.

85
    s: U256

Access

A mapping from account address to storage slots that are pre-warmed as part of a transaction.

91
@final
92
@slotted_freezable
93
@dataclass
class Access:

account

The address of the account that is accessed.

100
    account: Address

slots

A tuple of storage slots that are accessed in the account.

105
    slots: Tuple[Bytes32, ...]

AccessListTransaction

The transaction type added in EIP-2930 to support access lists.

This transaction type extends the legacy transaction with an access list and chain ID. The access list specifies which addresses and storage slots the transaction will access.

111
@final
112
@slotted_freezable
113
@dataclass
class AccessListTransaction:

chain_id

The ID of the chain on which this transaction is executed.

125
    chain_id: U64

nonce

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

130
    nonce: U256

gas_price

The price of gas for this transaction.

135
    gas_price: Uint

gas

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

140
    gas: Uint

to

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

145
    to: Bytes0 | Address

value

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

151
    value: U256

data

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

156
    data: Bytes

access_list

A tuple of Access objects that specify which addresses and storage slots are accessed in the transaction.

162
    access_list: Tuple[Access, ...]

y_parity

The recovery id of the signature.

168
    y_parity: U256

r

The first part of the signature.

173
    r: U256

s

The second part of the signature.

178
    s: U256

FeeMarketTransaction

The transaction type added in EIP-1559.

This transaction type introduces a new fee market mechanism with two gas price parameters: max_priority_fee_per_gas and max_fee_per_gas.

184
@final
185
@slotted_freezable
186
@dataclass
class FeeMarketTransaction:

chain_id

The ID of the chain on which this transaction is executed.

197
    chain_id: U64

nonce

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

202
    nonce: U256

max_priority_fee_per_gas

The maximum priority fee per gas that the sender is willing to pay.

207
    max_priority_fee_per_gas: Uint

max_fee_per_gas

The maximum fee per gas that the sender is willing to pay, including the base fee and priority fee.

212
    max_fee_per_gas: Uint

gas

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

218
    gas: Uint

to

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

223
    to: Bytes0 | Address

value

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

229
    value: U256

data

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

234
    data: Bytes

access_list

A tuple of Access objects that specify which addresses and storage slots are accessed in the transaction.

240
    access_list: Tuple[Access, ...]

y_parity

The recovery id of the signature.

246
    y_parity: U256

r

The first part of the signature.

251
    r: U256

s

The second part of the signature.

256
    s: U256

Transaction

Union type representing any valid transaction type.

262
Transaction = LegacyTransaction | AccessListTransaction | FeeMarketTransaction

encode_transaction

Encode a transaction into its RLP or typed transaction format. Needed because non-legacy transactions aren't RLP.

Legacy transactions are returned as-is, while other transaction types are prefixed with their type identifier and RLP encoded.

def encode_transaction(​tx: Transaction​) -> LegacyTransaction | Bytes:
269
    <snip>
276
    if isinstance(tx, LegacyTransaction):
277
        return tx
278
    elif isinstance(tx, AccessListTransaction):
279
        return b"\x01" + rlp.encode(tx)
280
    elif isinstance(tx, FeeMarketTransaction):
281
        return b"\x02" + rlp.encode(tx)
282
    else:
283
        raise Exception(f"Unable to encode transaction of type {type(tx)}")

decode_transaction

Decode a transaction from its RLP or typed transaction format. Needed because non-legacy transactions aren't RLP.

Legacy transactions are returned as-is, while other transaction types are decoded based on their type identifier prefix.

def decode_transaction(​tx: LegacyTransaction | Bytes​) -> Transaction:
287
    <snip>
294
    if isinstance(tx, Bytes):
295
        if tx[0] == 1:
296
            return rlp.decode_to(AccessListTransaction, tx[1:])
297
        elif tx[0] == 2:
298
            return rlp.decode_to(FeeMarketTransaction, tx[1:])
299
        else:
300
            raise TransactionTypeError(tx[0])
301
    else:
302
        return tx

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.

Also, the code size of a contract creation transaction must be within limits of the protocol.

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. It also raises an InitCodeTooLargeError if the code size of a contract creation transaction exceeds the maximum allowed size, and a PriorityFeeGreaterThanMaxFeeError if the maximum priority fee per gas of a fee market transaction exceeds its maximum fee per gas.

def validate_transaction(​tx: Transaction​) -> Uint:
306
    <snip>
335
    from .vm.interpreter import MAX_INIT_CODE_SIZE
336
337
    intrinsic_gas = calculate_intrinsic_cost(tx)
338
    if intrinsic_gas > tx.gas:
339
        raise InsufficientTransactionGasError("Insufficient gas")
340
    if tx.to == Bytes0(b"") and len(tx.data) > MAX_INIT_CODE_SIZE:
341
        raise InitCodeTooLargeError("Code size too large")
342
    if U256(tx.nonce) >= U256(U64.MAX_VALUE):
343
        raise NonceOverflowError("Nonce too high")
344
    if isinstance(tx, FeeMarketTransaction):
345
        if tx.max_fee_per_gas < tx.max_priority_fee_per_gas:
346
            raise PriorityFeeGreaterThanMaxFeeError(
347
                "priority fee greater than max fee"
348
            )
349
350
    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)

  3. Cost for contract creation (if applicable)

  4. Cost for access list entries (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:
354
    <snip>
375
    from .vm.gas import GasCosts, init_code_cost
376
377
    num_zeros = Uint(tx.data.count(0))
378
    num_non_zeros = ulen(tx.data) - num_zeros
379
    data_cost = (
380
        num_zeros * GasCosts.TX_DATA_PER_ZERO
381
        + num_non_zeros * GasCosts.TX_DATA_PER_NON_ZERO
382
    )
383
384
    if tx.to == Bytes0(b""):
385
        create_cost = GasCosts.TX_CREATE + init_code_cost(ulen(tx.data))
386
    else:
387
        create_cost = Uint(0)
388
389
    access_list_cost = Uint(0)
390
    if isinstance(tx, (AccessListTransaction, FeeMarketTransaction)):
391
        for access in tx.access_list:
392
            access_list_cost += GasCosts.TX_ACCESS_LIST_ADDRESS
393
            access_list_cost += (
394
                ulen(access.slots) * GasCosts.TX_ACCESS_LIST_STORAGE_KEY
395
            )
396
397
    return GasCosts.TX_BASE + data_cost + create_cost + access_list_cost

chain_id

Extract the chain identifier from a transaction. See EIP-155.

def chain_id(​tx: Transaction​) -> None | U64:
401
    <snip>
406
    if isinstance(tx, LegacyTransaction):
407
        if tx.v == 27 or tx.v == 28:
408
            return None
409
410
        if tx.v < U256(35):
411
            raise InvalidSignatureError("bad v")
412
413
        return U64((tx.v - U256(35)) >> U256(1))
414
    else:
415
        return tx.chain_id

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(​tx: Transaction​) -> Address:
419
    <snip>
432
    r, s = tx.r, tx.s
433
    if U256(0) >= r or r >= SECP256K1N:
434
        raise InvalidSignatureError("bad r")
435
    if U256(0) >= s or s > SECP256K1N // U256(2):
436
        raise InvalidSignatureError("bad s")
437
438
    if isinstance(tx, LegacyTransaction):
439
        v = tx.v
440
        if v == 27 or v == 28:
441
            public_key = secp256k1_recover(
442
                r, s, v - U256(27), signing_hash_pre155(tx)
443
            )
444
        else:
445
            assert v >= U256(35), "call chain_id before recover_sender"
446
            tx_chain_id = U64((v - U256(35)) >> U256(1))
447
            v = (v - U256(35)) & U256(1)
448
            public_key = secp256k1_recover(
449
                r,
450
                s,
451
                v,
452
                signing_hash_155(tx, tx_chain_id),
453
            )
454
    elif isinstance(tx, AccessListTransaction):
455
        if tx.y_parity not in (U256(0), U256(1)):
456
            raise InvalidSignatureError("bad y_parity")
457
        public_key = secp256k1_recover(
458
            r, s, tx.y_parity, signing_hash_2930(tx)
459
        )
460
    elif isinstance(tx, FeeMarketTransaction):
461
        if tx.y_parity not in (U256(0), U256(1)):
462
            raise InvalidSignatureError("bad y_parity")
463
        public_key = secp256k1_recover(
464
            r, s, tx.y_parity, signing_hash_1559(tx)
465
        )
466
467
    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 legacy transaction as a parameter and returns the signing hash of the transaction.

def signing_hash_pre155(​tx: LegacyTransaction​) -> Hash32:
471
    <snip>
480
    return keccak256(
481
        rlp.encode(
482
            (
483
                tx.nonce,
484
                tx.gas_price,
485
                tx.gas,
486
                tx.to,
487
                tx.value,
488
                tx.data,
489
            )
490
        )
491
    )

signing_hash_155

Compute the hash of a transaction used in a EIP-155 signature.

This function takes a legacy transaction and a chain ID as parameters and returns the hash of the transaction used in an EIP-155 signature.

def signing_hash_155(​tx: LegacyTransaction, ​​chain_id: U64​) -> Hash32:
495
    <snip>
503
    return keccak256(
504
        rlp.encode(
505
            (
506
                tx.nonce,
507
                tx.gas_price,
508
                tx.gas,
509
                tx.to,
510
                tx.value,
511
                tx.data,
512
                chain_id,
513
                Uint(0),
514
                Uint(0),
515
            )
516
        )
517
    )

signing_hash_2930

Compute the hash of a transaction used in a EIP-2930 signature.

This function takes an access list transaction as a parameter and returns the hash of the transaction used in an EIP-2930 signature.

def signing_hash_2930(​tx: AccessListTransaction​) -> Hash32:
521
    <snip>
529
    return keccak256(
530
        b"\x01"
531
        + rlp.encode(
532
            (
533
                tx.chain_id,
534
                tx.nonce,
535
                tx.gas_price,
536
                tx.gas,
537
                tx.to,
538
                tx.value,
539
                tx.data,
540
                tx.access_list,
541
            )
542
        )
543
    )

signing_hash_1559

Compute the hash of a transaction used in an EIP-1559 signature.

This function takes a fee market transaction as a parameter and returns the hash of the transaction used in an EIP-1559 signature.

def signing_hash_1559(​tx: FeeMarketTransaction​) -> Hash32:
547
    <snip>
555
    return keccak256(
556
        b"\x02"
557
        + rlp.encode(
558
            (
559
                tx.chain_id,
560
                tx.nonce,
561
                tx.max_priority_fee_per_gas,
562
                tx.max_fee_per_gas,
563
                tx.gas,
564
                tx.to,
565
                tx.value,
566
                tx.data,
567
                tx.access_list,
568
            )
569
        )
570
    )

get_transaction_hash

Compute the hash of a transaction.

This function takes a transaction as a parameter and returns the keccak256 hash of the transaction. It can handle both legacy transactions and typed transactions (AccessListTransaction, FeeMarketTransaction, etc.).

def get_transaction_hash(​tx: Bytes | LegacyTransaction​) -> Hash32:
574
    <snip>
582
    assert isinstance(tx, (LegacyTransaction, Bytes))
583
    if isinstance(tx, LegacyTransaction):
584
        return keccak256(rlp.encode(tx))
585
    else:
586
        return keccak256(tx)