transactions.py (in diffs/bpo3/bpo4)

ethereum.forks.bpo3.transactionsethereum.forks.bpo4.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.

32	@final

33	@dataclass

class IntrinsicGasCost:

regular ¶

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

37	regular: Uint

calldata_floor ¶

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

40	calldata_floor: Uint

TX_MAX_GAS_LIMIT ¶

44	TX_MAX_GAS_LIMIT = Uint(16_777_216)

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.

47	@final

48	@slotted_freezable

49	@dataclass

class LegacyTransaction:

nonce ¶

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

62	nonce: U256

gas_price ¶

The price of gas for this transaction, in wei.

67	gas_price: Uint

gas ¶

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

72	gas: Uint

to ¶

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

77	to: Bytes0 \| Address

value ¶

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

83	value: U256

data ¶

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

88	data: Bytes

v ¶

The recovery id of the signature.

94	v: U256

r ¶

The first part of the signature.

99	r: U256

s ¶

The second part of the signature.

104	s: U256

Access ¶

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

110	@final

111	@slotted_freezable

112	@dataclass

class Access:

account ¶

The address of the account that is accessed.

119	account: Address

slots ¶

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

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

130	@final

131	@slotted_freezable

132	@dataclass

class AccessListTransaction:

chain_id ¶

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

144	chain_id: U64

nonce ¶

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

149	nonce: U256

gas_price ¶

The price of gas for this transaction.

154	gas_price: Uint

gas ¶

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

159	gas: Uint

to ¶

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

164	to: Bytes0 \| Address

value ¶

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

170	value: U256

data ¶

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

175	data: Bytes

access_list ¶

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

181	access_list: Tuple[Access, ...]

y_parity ¶

The recovery id of the signature.

187	y_parity: U256

r ¶

The first part of the signature.

192	r: U256

s ¶

The second part of the signature.

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

203	@final

204	@slotted_freezable

205	@dataclass

class FeeMarketTransaction:

chain_id ¶

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

216	chain_id: U64

nonce ¶

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

221	nonce: U256

max_priority_fee_per_gas ¶

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

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

231	max_fee_per_gas: Uint

gas ¶

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

237	gas: Uint

to ¶

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

242	to: Bytes0 \| Address

value ¶

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

248	value: U256

data ¶

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

253	data: Bytes

access_list ¶

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

259	access_list: Tuple[Access, ...]

y_parity ¶

The recovery id of the signature.

265	y_parity: U256

r ¶

The first part of the signature.

270	r: U256

s ¶

The second part of the signature.

275	s: U256

BlobTransaction ¶

The transaction type added in EIP-4844.

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

281	@final

282	@slotted_freezable

283	@dataclass

class BlobTransaction:

chain_id ¶

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

294	chain_id: U64

nonce ¶

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

299	nonce: U256

max_priority_fee_per_gas ¶

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

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

309	max_fee_per_gas: Uint

gas ¶

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

315	gas: Uint

to ¶

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

320	to: Address

value ¶

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

326	value: U256

data ¶

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

331	data: Bytes

access_list ¶

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

337	access_list: Tuple[Access, ...]

max_fee_per_blob_gas ¶

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

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

348	blob_versioned_hashes: Tuple[VersionedHash, ...]

y_parity ¶

The recovery id of the signature.

354	y_parity: U256

r ¶

The first part of the signature.

359	r: U256

s ¶

The second part of the signature.

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

370	@final

371	@slotted_freezable

372	@dataclass

class SetCodeTransaction:

chain_id ¶

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

383	chain_id: U64

nonce ¶

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

388	nonce: U64

max_priority_fee_per_gas ¶

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

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

398	max_fee_per_gas: Uint

gas ¶

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

404	gas: Uint

to ¶

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

409	to: Address

value ¶

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

415	value: U256

data ¶

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

420	data: Bytes

access_list ¶

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

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

432	authorizations: Tuple[Authorization, ...]

y_parity ¶

The recovery id of the signature.

438	y_parity: U256

r ¶

The first part of the signature.

443	r: U256

s ¶

The second part of the signature.

448	s: U256

Transaction ¶

Union type representing any valid transaction type.

454	Transaction = (
455	LegacyTransaction
456	\| AccessListTransaction
457	\| FeeMarketTransaction
458	\| BlobTransaction
459	\| SetCodeTransaction
460	)

AccessListCapableTransaction ¶

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

See has_access_list and Access for more details.

466	AccessListCapableTransaction = (
467	AccessListTransaction
468	\| FeeMarketTransaction
469	\| BlobTransaction
470	\| SetCodeTransaction
471	)

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:

484	<snip>
491	if isinstance(tx, LegacyTransaction):
492	return tx
493	elif isinstance(tx, AccessListTransaction):
494	return b"\x01" + rlp.encode(tx)
495	elif isinstance(tx, FeeMarketTransaction):
496	return b"\x02" + rlp.encode(tx)
497	elif isinstance(tx, BlobTransaction):
498	return b"\x03" + rlp.encode(tx)
499	elif isinstance(tx, SetCodeTransaction):
500	return b"\x04" + rlp.encode(tx)
501	else:
502	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:

506	<snip>
513	if isinstance(tx, Bytes):
514	if tx[0] == 1:
515	return rlp.decode_to(AccessListTransaction, tx[1:])
516	elif tx[0] == 2:
517	return rlp.decode_to(FeeMarketTransaction, tx[1:])
518	elif tx[0] == 3:
519	return rlp.decode_to(BlobTransaction, tx[1:])
520	elif tx[0] == 4:
521	return rlp.decode_to(SetCodeTransaction, tx[1:])
522	else:
523	raise TransactionTypeError(tx[0])
524	else:
525	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:

529	<snip>
557	from .vm.interpreter import MAX_INIT_CODE_SIZE
558
559	intrinsic = calculate_intrinsic_cost(tx)
560	if max(intrinsic.regular, intrinsic.calldata_floor) > tx.gas:
561	raise InsufficientTransactionGasError("Insufficient gas")
562	if U256(tx.nonce) >= U256(U64.MAX_VALUE):
563	raise NonceOverflowError("Nonce too high")
564	if tx.to == Bytes0(b"") and len(tx.data) > MAX_INIT_CODE_SIZE:
565	raise InitCodeTooLargeError("Code size too large")
566	if tx.gas > TX_MAX_GAS_LIMIT:
567	raise TransactionGasLimitExceededError("Gas limit too high")
568
569	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:

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

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:

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

706	<snip>
715	return keccak256(
716	rlp.encode(
717	(
718	tx.nonce,
719	tx.gas_price,
720	tx.gas,
721	tx.to,
722	tx.value,
723	tx.data,
724	)
725	)
726	)

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:

730	<snip>
738	return keccak256(
739	rlp.encode(
740	(
741	tx.nonce,
742	tx.gas_price,
743	tx.gas,
744	tx.to,
745	tx.value,
746	tx.data,
747	chain_id,
748	Uint(0),
749	Uint(0),
750	)
751	)
752	)

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:

756	<snip>
764	return keccak256(
765	b"\x01"
766	+ rlp.encode(
767	(
768	tx.chain_id,
769	tx.nonce,
770	tx.gas_price,
771	tx.gas,
772	tx.to,
773	tx.value,
774	tx.data,
775	tx.access_list,
776	)
777	)
778	)

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:

782	<snip>
790	return keccak256(
791	b"\x02"
792	+ rlp.encode(
793	(
794	tx.chain_id,
795	tx.nonce,
796	tx.max_priority_fee_per_gas,
797	tx.max_fee_per_gas,
798	tx.gas,
799	tx.to,
800	tx.value,
801	tx.data,
802	tx.access_list,
803	)
804	)
805	)

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:

809	<snip>
817	return keccak256(
818	b"\x03"
819	+ rlp.encode(
820	(
821	tx.chain_id,
822	tx.nonce,
823	tx.max_priority_fee_per_gas,
824	tx.max_fee_per_gas,
825	tx.gas,
826	tx.to,
827	tx.value,
828	tx.data,
829	tx.access_list,
830	tx.max_fee_per_blob_gas,
831	tx.blob_versioned_hashes,
832	)
833	)
834	)

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:

838	<snip>
846	return keccak256(
847	b"\x04"
848	+ rlp.encode(
849	(
850	tx.chain_id,
851	tx.nonce,
852	tx.max_priority_fee_per_gas,
853	tx.max_fee_per_gas,
854	tx.gas,
855	tx.to,
856	tx.value,
857	tx.data,
858	tx.access_list,
859	tx.authorizations,
860	)
861	)
862	)

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:

866	<snip>
874	assert isinstance(tx, (LegacyTransaction, Bytes))
875	if isinstance(tx, LegacyTransaction):
876	return keccak256(rlp.encode(tx))
877	else:
878	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]:

884	<snip>
889	return isinstance(
890	tx,
891	AccessListCapableTransaction,
892	)

Search Results

ethereum.forks.bpo3.transactionsethereum.forks.bpo4.transactions