transactions.py (in src/ethereum/forks/prague)

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

IntrinsicGasCost ¶

Intrinsic gas costs for a transaction, split by gas type.

28	@final

29	@dataclass

class IntrinsicGasCost:

regular ¶

Regular execution gas (calldata, base cost, access list, etc.).

33	regular: Uint

calldata_floor ¶

Minimum gas cost based on calldata size per EIP-7623.

36	calldata_floor: Uint

LegacyTransaction ¶

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

44	@final

45	@slotted_freezable

46	@dataclass

class LegacyTransaction:

nonce ¶

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

59	nonce: U256

gas_price ¶

The price of gas for this transaction, in wei.

64	gas_price: Uint

gas ¶

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

69	gas: Uint

to ¶

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

74	to: Bytes0 \| Address

value ¶

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

80	value: U256

data ¶

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

85	data: Bytes

v ¶

The recovery id of the signature.

91	v: U256

r ¶

The first part of the signature.

96	r: U256

s ¶

The second part of the signature.

101	s: U256

Access ¶

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

107	@final

108	@slotted_freezable

109	@dataclass

class Access:

account ¶

The address of the account that is accessed.

116	account: Address

slots ¶

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

121	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.

127	@final

128	@slotted_freezable

129	@dataclass

class AccessListTransaction:

chain_id ¶

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

141	chain_id: U64

nonce ¶

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

146	nonce: U256

gas_price ¶

The price of gas for this transaction.

151	gas_price: Uint

gas ¶

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

156	gas: Uint

to ¶

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

161	to: Bytes0 \| Address

value ¶

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

167	value: U256

data ¶

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

172	data: Bytes

access_list ¶

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

178	access_list: Tuple[Access, ...]

y_parity ¶

The recovery id of the signature.

184	y_parity: U256

r ¶

The first part of the signature.

189	r: U256

s ¶

The second part of the signature.

194	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.

200	@final

201	@slotted_freezable

202	@dataclass

class FeeMarketTransaction:

chain_id ¶

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

213	chain_id: U64

nonce ¶

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

218	nonce: U256

max_priority_fee_per_gas ¶

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

223	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.

228	max_fee_per_gas: Uint

gas ¶

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

234	gas: Uint

to ¶

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

239	to: Bytes0 \| Address

value ¶

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

245	value: U256

data ¶

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

250	data: Bytes

access_list ¶

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

256	access_list: Tuple[Access, ...]

y_parity ¶

The recovery id of the signature.

262	y_parity: U256

r ¶

The first part of the signature.

267	r: U256

s ¶

The second part of the signature.

272	s: U256

BlobTransaction ¶

The transaction type added in EIP-4844.

This transaction type extends the fee market transaction to support blob-carrying transactions.

278	@final

279	@slotted_freezable

280	@dataclass

class BlobTransaction:

chain_id ¶

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

291	chain_id: U64

nonce ¶

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

296	nonce: U256

max_priority_fee_per_gas ¶

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

301	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.

306	max_fee_per_gas: Uint

gas ¶

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

312	gas: Uint

to ¶

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

317	to: Address

value ¶

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

323	value: U256

data ¶

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

328	data: Bytes

access_list ¶

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

334	access_list: Tuple[Access, ...]

max_fee_per_blob_gas ¶

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

340	max_fee_per_blob_gas: U256

blob_versioned_hashes ¶

A tuple of objects that represent the versioned hashes of the blobs included in the transaction.

345	blob_versioned_hashes: Tuple[VersionedHash, ...]

y_parity ¶

The recovery id of the signature.

351	y_parity: U256

r ¶

The first part of the signature.

356	r: U256

s ¶

The second part of the signature.

361	s: U256

SetCodeTransaction ¶

The transaction type added in EIP-7702.

This transaction type allows Ethereum Externally Owned Accounts (EOAs) to set code on their account, enabling them to act as smart contracts.

367	@final

368	@slotted_freezable

369	@dataclass

class SetCodeTransaction:

chain_id ¶

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

380	chain_id: U64

nonce ¶

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

385	nonce: U64

max_priority_fee_per_gas ¶

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

390	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.

395	max_fee_per_gas: Uint

gas ¶

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

401	gas: Uint

to ¶

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

406	to: Address

value ¶

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

412	value: U256

data ¶

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

417	data: Bytes

access_list ¶

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

423	access_list: Tuple[Access, ...]

authorizations ¶

A tuple of Authorization objects that specify what code the signer desires to execute in the context of their EOA.

429	authorizations: Tuple[Authorization, ...]

y_parity ¶

The recovery id of the signature.

435	y_parity: U256

r ¶

The first part of the signature.

440	r: U256

s ¶

The second part of the signature.

445	s: U256

Transaction ¶

Union type representing any valid transaction type.

451	Transaction = (
452	LegacyTransaction
453	\| AccessListTransaction
454	\| FeeMarketTransaction
455	\| BlobTransaction
456	\| SetCodeTransaction
457	)

AccessListCapableTransaction ¶

Transaction types that include an EIP-2930-style access list.

See has_access_list and Access for more details.

463	AccessListCapableTransaction = (
464	AccessListTransaction
465	\| FeeMarketTransaction
466	\| BlobTransaction
467	\| SetCodeTransaction
468	)

FeeMarketCapableTransaction ¶

Transaction types that include the EIP-1559-style fee structure.

See FeeMarketTransaction for more details.

480	FeeMarketCapableTransaction = (
481	FeeMarketTransaction \| BlobTransaction \| SetCodeTransaction
482	)

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:

494	<snip>
501	if isinstance(tx, LegacyTransaction):
502	return tx
503	elif isinstance(tx, AccessListTransaction):
504	return b"\x01" + rlp.encode(tx)
505	elif isinstance(tx, FeeMarketTransaction):
506	return b"\x02" + rlp.encode(tx)
507	elif isinstance(tx, BlobTransaction):
508	return b"\x03" + rlp.encode(tx)
509	elif isinstance(tx, SetCodeTransaction):
510	return b"\x04" + rlp.encode(tx)
511	else:
512	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:

516	<snip>
523	if isinstance(tx, Bytes):
524	if tx[0] == 1:
525	return rlp.decode_to(AccessListTransaction, tx[1:])
526	elif tx[0] == 2:
527	return rlp.decode_to(FeeMarketTransaction, tx[1:])
528	elif tx[0] == 3:
529	return rlp.decode_to(BlobTransaction, tx[1:])
530	elif tx[0] == 4:
531	return rlp.decode_to(SetCodeTransaction, tx[1:])
532	else:
533	raise TransactionTypeError(tx[0])
534	else:
535	return tx

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 and the minimum calldata gas cost for 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.

def validate_transaction(tx: Transaction) -> IntrinsicGasCost:

539	<snip>
567	from .vm.interpreter import MAX_INIT_CODE_SIZE
568
569	intrinsic = calculate_intrinsic_cost(tx)
570	if max(intrinsic.regular, intrinsic.calldata_floor) > tx.gas:
571	raise InsufficientTransactionGasError("Insufficient gas")
572	if U256(tx.nonce) >= U256(U64.MAX_VALUE):
573	raise NonceOverflowError("Nonce too high")
574	if tx.to == Bytes0(b"") and len(tx.data) > MAX_INIT_CODE_SIZE:
575	raise InitCodeTooLargeError("Code size too large")
576
577	return intrinsic

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)
Cost for access list entries (if applicable)
Cost for authorizations (if applicable)

This function takes a transaction as a parameter and returns the intrinsic gas cost of the transaction and the minimum gas cost used by the transaction based on the calldata size.

def calculate_intrinsic_cost(tx: Transaction) -> IntrinsicGasCost:

581	<snip>
605	from .vm.gas import GasCosts, init_code_cost
606
607	num_zeros = Uint(tx.data.count(0))
608	num_non_zeros = ulen(tx.data) - num_zeros
609
610	tokens_in_calldata = num_zeros + num_non_zeros * Uint(4)
611	# EIP-7623 floor price (note: no EVM costs)
612	calldata_floor_gas_cost = (
613	tokens_in_calldata * GasCosts.TX_DATA_TOKEN_FLOOR + GasCosts.TX_BASE
614	)
615
616	data_cost = tokens_in_calldata * GasCosts.TX_DATA_TOKEN_STANDARD
617
618	if tx.to == Bytes0(b""):
619	create_cost = GasCosts.TX_CREATE + init_code_cost(ulen(tx.data))
620	else:
621	create_cost = Uint(0)
622
623	access_list_cost = Uint(0)
624	if has_access_list(tx):
625	for access in tx.access_list:
626	access_list_cost += GasCosts.TX_ACCESS_LIST_ADDRESS
627	access_list_cost += (
628	ulen(access.slots) * GasCosts.TX_ACCESS_LIST_STORAGE_KEY
629	)
630
631	auth_cost = Uint(0)
632	if isinstance(tx, SetCodeTransaction):
633	auth_cost += Uint(
634	GasCosts.AUTH_PER_EMPTY_ACCOUNT * len(tx.authorizations)
635	)
636
637	return IntrinsicGasCost(
638	regular=Uint(
639	GasCosts.TX_BASE
640	+ data_cost
641	+ create_cost
642	+ access_list_cost
643	+ auth_cost
644	),
645	calldata_floor=calldata_floor_gas_cost,
646	)

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:

650	<snip>
663	r, s = tx.r, tx.s
664	if U256(0) >= r or r >= SECP256K1N:
665	raise InvalidSignatureError("bad r")
666	if U256(0) >= s or s > SECP256K1N // U256(2):
667	raise InvalidSignatureError("bad s")
668
669	if isinstance(tx, LegacyTransaction):
670	v = tx.v
671	if v == 27 or v == 28:
672	public_key = secp256k1_recover(
673	r, s, v - U256(27), signing_hash_pre155(tx)
674	)
675	else:
676	chain_id_x2 = U256(chain_id) * U256(2)
677	if v != U256(35) + chain_id_x2 and v != U256(36) + chain_id_x2:
678	raise InvalidSignatureError("bad v")
679	public_key = secp256k1_recover(
680	r,
681	s,
682	v - U256(35) - chain_id_x2,
683	signing_hash_155(tx, chain_id),
684	)
685	elif isinstance(tx, AccessListTransaction):
686	if tx.y_parity not in (U256(0), U256(1)):
687	raise InvalidSignatureError("bad y_parity")
688	public_key = secp256k1_recover(
689	r, s, tx.y_parity, signing_hash_2930(tx)
690	)
691	elif isinstance(tx, FeeMarketTransaction):
692	if tx.y_parity not in (U256(0), U256(1)):
693	raise InvalidSignatureError("bad y_parity")
694	public_key = secp256k1_recover(
695	r, s, tx.y_parity, signing_hash_1559(tx)
696	)
697	elif isinstance(tx, BlobTransaction):
698	if tx.y_parity not in (U256(0), U256(1)):
699	raise InvalidSignatureError("bad y_parity")
700	public_key = secp256k1_recover(
701	r, s, tx.y_parity, signing_hash_4844(tx)
702	)
703	elif isinstance(tx, SetCodeTransaction):
704	if tx.y_parity not in (U256(0), U256(1)):
705	raise InvalidSignatureError("bad y_parity")
706	public_key = secp256k1_recover(
707	r, s, tx.y_parity, signing_hash_7702(tx)
708	)
709
710	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:

714	<snip>
723	return keccak256(
724	rlp.encode(
725	(
726	tx.nonce,
727	tx.gas_price,
728	tx.gas,
729	tx.to,
730	tx.value,
731	tx.data,
732	)
733	)
734	)

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:

738	<snip>
746	return keccak256(
747	rlp.encode(
748	(
749	tx.nonce,
750	tx.gas_price,
751	tx.gas,
752	tx.to,
753	tx.value,
754	tx.data,
755	chain_id,
756	Uint(0),
757	Uint(0),
758	)
759	)
760	)

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:

764	<snip>
772	return keccak256(
773	b"\x01"
774	+ rlp.encode(
775	(
776	tx.chain_id,
777	tx.nonce,
778	tx.gas_price,
779	tx.gas,
780	tx.to,
781	tx.value,
782	tx.data,
783	tx.access_list,
784	)
785	)
786	)

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:

790	<snip>
798	return keccak256(
799	b"\x02"
800	+ rlp.encode(
801	(
802	tx.chain_id,
803	tx.nonce,
804	tx.max_priority_fee_per_gas,
805	tx.max_fee_per_gas,
806	tx.gas,
807	tx.to,
808	tx.value,
809	tx.data,
810	tx.access_list,
811	)
812	)
813	)

signing_hash_4844 ¶

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

This function takes a transaction as a parameter and returns the signing hash of the transaction used in an EIP-4844 signature.

def signing_hash_4844(tx: BlobTransaction) -> Hash32:

817	<snip>
825	return keccak256(
826	b"\x03"
827	+ rlp.encode(
828	(
829	tx.chain_id,
830	tx.nonce,
831	tx.max_priority_fee_per_gas,
832	tx.max_fee_per_gas,
833	tx.gas,
834	tx.to,
835	tx.value,
836	tx.data,
837	tx.access_list,
838	tx.max_fee_per_blob_gas,
839	tx.blob_versioned_hashes,
840	)
841	)
842	)

signing_hash_7702 ¶

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

This function takes a transaction as a parameter and returns the signing hash of the transaction used in a EIP-7702 signature.

def signing_hash_7702(tx: SetCodeTransaction) -> Hash32:

846	<snip>
854	return keccak256(
855	b"\x04"
856	+ rlp.encode(
857	(
858	tx.chain_id,
859	tx.nonce,
860	tx.max_priority_fee_per_gas,
861	tx.max_fee_per_gas,
862	tx.gas,
863	tx.to,
864	tx.value,
865	tx.data,
866	tx.access_list,
867	tx.authorizations,
868	)
869	)
870	)

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:

874	<snip>
882	assert isinstance(tx, (LegacyTransaction, Bytes))
883	if isinstance(tx, LegacyTransaction):
884	return keccak256(rlp.encode(tx))
885	else:
886	return keccak256(tx)

has_access_list ¶

Return whether the transaction has an EIP-2930-style access list.

def has_access_list(tx: Transaction) -> TypeGuard[AccessListCapableTransaction]:

892	<snip>
897	return isinstance(
898	tx,
899	AccessListCapableTransaction,
900	)

Search Results

ethereum.forks.prague.transactions