transactions.py (in diffs/shanghai/cancun)

ethereum.forks.shanghai.transactionsethereum.forks.cancun.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, and EIP-4844.

28	@final

29	@slotted_freezable

30	@dataclass

class LegacyTransaction:

nonce ¶

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

42	nonce: U256

gas_price ¶

The price of gas for this transaction, in wei.

47	gas_price: Uint

gas ¶

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

52	gas: Uint

to ¶

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

57	to: Bytes0 \| Address

value ¶

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

63	value: U256

data ¶

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

68	data: Bytes

v ¶

The recovery id of the signature.

74	v: U256

r ¶

The first part of the signature.

79	r: U256

s ¶

The second part of the signature.

84	s: U256

Access ¶

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

90	@final

91	@slotted_freezable

92	@dataclass

class Access:

account ¶

The address of the account that is accessed.

99	account: Address

slots ¶

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

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

110	@final

111	@slotted_freezable

112	@dataclass

class AccessListTransaction:

chain_id ¶

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

124	chain_id: U64

nonce ¶

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

129	nonce: U256

gas_price ¶

The price of gas for this transaction.

134	gas_price: Uint

gas ¶

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

139	gas: Uint

to ¶

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

144	to: Bytes0 \| Address

value ¶

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

150	value: U256

data ¶

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

155	data: Bytes

access_list ¶

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

161	access_list: Tuple[Access, ...]

y_parity ¶

The recovery id of the signature.

167	y_parity: U256

r ¶

The first part of the signature.

172	r: U256

s ¶

The second part of the signature.

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

183	@final

184	@slotted_freezable

185	@dataclass

class FeeMarketTransaction:

chain_id ¶

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

196	chain_id: U64

nonce ¶

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

201	nonce: U256

max_priority_fee_per_gas ¶

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

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

211	max_fee_per_gas: Uint

gas ¶

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

217	gas: Uint

to ¶

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

222	to: Bytes0 \| Address

value ¶

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

228	value: U256

data ¶

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

233	data: Bytes

access_list ¶

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

239	access_list: Tuple[Access, ...]

y_parity ¶

The recovery id of the signature.

245	y_parity: U256

r ¶

The first part of the signature.

250	r: U256

s ¶

The second part of the signature.

255	s: U256

BlobTransaction ¶

The transaction type added in EIP-4844.

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

261	@final

262	@slotted_freezable

263	@dataclass

class BlobTransaction:

chain_id ¶

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

274	chain_id: U64

nonce ¶

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

279	nonce: U256

max_priority_fee_per_gas ¶

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

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

289	max_fee_per_gas: Uint

gas ¶

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

295	gas: Uint

to ¶

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

300	to: Address

value ¶

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

306	value: U256

data ¶

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

311	data: Bytes

access_list ¶

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

317	access_list: Tuple[Access, ...]

max_fee_per_blob_gas ¶

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

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

328	blob_versioned_hashes: Tuple[VersionedHash, ...]

y_parity ¶

The recovery id of the signature.

334	y_parity: U256

r ¶

The first part of the signature.

339	r: U256

s ¶

The second part of the signature.

344	s: U256

Transaction ¶

Union type representing any valid transaction type.

258	Transaction = LegacyTransaction \| AccessListTransaction \| FeeMarketTransaction
350	Transaction = (
351	LegacyTransaction
352	\| AccessListTransaction
353	\| FeeMarketTransaction
354	\| BlobTransaction
355	)

FeeMarketCapableTransaction ¶

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

See FeeMarketTransaction for more details.

361	FeeMarketCapableTransaction = FeeMarketTransaction \| BlobTransaction

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:

373	<snip>
380	if isinstance(tx, LegacyTransaction):
381	return tx
382	elif isinstance(tx, AccessListTransaction):
383	return b"\x01" + rlp.encode(tx)
384	elif isinstance(tx, FeeMarketTransaction):
385	return b"\x02" + rlp.encode(tx)
278	else:
279	raise Exception(f"Unable to encode transaction of type {type(tx)}")
386	elif isinstance(tx, BlobTransaction):
387	return b"\x03" + rlp.encode(tx)
388	else:
389	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:

393	<snip>
400	if isinstance(tx, Bytes):
401	if tx[0] == 1:
402	return rlp.decode_to(AccessListTransaction, tx[1:])
403	elif tx[0] == 2:
404	return rlp.decode_to(FeeMarketTransaction, tx[1:])
295	else:
296	raise TransactionTypeError(tx[0])
405	elif tx[0] == 3:
406	return rlp.decode_to(BlobTransaction, tx[1:])
407	else:
408	raise TransactionTypeError(tx[0])
409	else:
410	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 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.

def validate_transaction(tx: Transaction) -> Uint:

414	<snip>
441	from .vm.interpreter import MAX_INIT_CODE_SIZE
442
443	intrinsic_gas = calculate_intrinsic_cost(tx)
444	if intrinsic_gas > tx.gas:
445	raise InsufficientTransactionGasError("Insufficient gas")
446	if U256(tx.nonce) >= U256(U64.MAX_VALUE):
447	raise NonceOverflowError("Nonce too high")
448	if tx.to == Bytes0(b"") and len(tx.data) > MAX_INIT_CODE_SIZE:
449	raise InitCodeTooLargeError("Code size too large")
450
451	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)
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:

455	<snip>
476	from .vm.gas import GasCosts, init_code_cost
477
478	num_zeros = Uint(tx.data.count(0))
479	num_non_zeros = ulen(tx.data) - num_zeros
480	data_cost = (
481	num_zeros * GasCosts.TX_DATA_PER_ZERO
482	+ num_non_zeros * GasCosts.TX_DATA_PER_NON_ZERO
483	)
484
485	if tx.to == Bytes0(b""):
486	create_cost = GasCosts.TX_CREATE + init_code_cost(ulen(tx.data))
487	else:
488	create_cost = Uint(0)
489
490	access_list_cost = Uint(0)
379	if isinstance(tx, (AccessListTransaction, FeeMarketTransaction)):
491	if isinstance(
492	tx, (AccessListTransaction, FeeMarketTransaction, BlobTransaction)
493	):
494	for access in tx.access_list:
495	access_list_cost += GasCosts.TX_ACCESS_LIST_ADDRESS
496	access_list_cost += (
497	ulen(access.slots) * GasCosts.TX_ACCESS_LIST_STORAGE_KEY
498	)
499
500	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:

504	<snip>
509	if isinstance(tx, LegacyTransaction):
510	if tx.v == 27 or tx.v == 28:
511	return None
512
513	if tx.v < U256(35):
514	raise InvalidSignatureError("bad v")
515
516	return U64((tx.v - U256(35)) >> U256(1))
517	else:
518	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:

522	<snip>
535	r, s = tx.r, tx.s
536	if U256(0) >= r or r >= SECP256K1N:
537	raise InvalidSignatureError("bad r")
538	if U256(0) >= s or s > SECP256K1N // U256(2):
539	raise InvalidSignatureError("bad s")
540
541	if isinstance(tx, LegacyTransaction):
542	v = tx.v
543	if v == 27 or v == 28:
544	public_key = secp256k1_recover(
545	r, s, v - U256(27), signing_hash_pre155(tx)
546	)
547	else:
548	assert v >= U256(35), "call chain_id before recover_sender"
549	tx_chain_id = U64((v - U256(35)) >> U256(1))
550	v = (v - U256(35)) & U256(1)
551	public_key = secp256k1_recover(
552	r,
553	s,
554	v,
555	signing_hash_155(tx, tx_chain_id),
556	)
557	elif isinstance(tx, AccessListTransaction):
558	if tx.y_parity not in (U256(0), U256(1)):
559	raise InvalidSignatureError("bad y_parity")
560	public_key = secp256k1_recover(
561	r, s, tx.y_parity, signing_hash_2930(tx)
562	)
563	elif isinstance(tx, FeeMarketTransaction):
564	if tx.y_parity not in (U256(0), U256(1)):
565	raise InvalidSignatureError("bad y_parity")
566	public_key = secp256k1_recover(
567	r, s, tx.y_parity, signing_hash_1559(tx)
454	)
568	)
569	elif isinstance(tx, BlobTransaction):
570	if tx.y_parity not in (U256(0), U256(1)):
571	raise InvalidSignatureError("bad y_parity")
572	public_key = secp256k1_recover(
573	r, s, tx.y_parity, signing_hash_4844(tx)
574	)
575
576	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:

580	<snip>
589	return keccak256(
590	rlp.encode(
591	(
592	tx.nonce,
593	tx.gas_price,
594	tx.gas,
595	tx.to,
596	tx.value,
597	tx.data,
598	)
599	)
600	)

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:

604	<snip>
612	return keccak256(
613	rlp.encode(
614	(
615	tx.nonce,
616	tx.gas_price,
617	tx.gas,
618	tx.to,
619	tx.value,
620	tx.data,
621	chain_id,
622	Uint(0),
623	Uint(0),
624	)
625	)
626	)

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:

630	<snip>
638	return keccak256(
639	b"\x01"
640	+ rlp.encode(
641	(
642	tx.chain_id,
643	tx.nonce,
644	tx.gas_price,
645	tx.gas,
646	tx.to,
647	tx.value,
648	tx.data,
649	tx.access_list,
650	)
651	)
652	)

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:

656	<snip>
664	return keccak256(
665	b"\x02"
666	+ rlp.encode(
667	(
668	tx.chain_id,
669	tx.nonce,
670	tx.max_priority_fee_per_gas,
671	tx.max_fee_per_gas,
672	tx.gas,
673	tx.to,
674	tx.value,
675	tx.data,
676	tx.access_list,
677	)
678	)
679	)

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:

683	<snip>
691	return keccak256(
692	b"\x03"
693	+ rlp.encode(
694	(
695	tx.chain_id,
696	tx.nonce,
697	tx.max_priority_fee_per_gas,
698	tx.max_fee_per_gas,
699	tx.gas,
700	tx.to,
701	tx.value,
702	tx.data,
703	tx.access_list,
704	tx.max_fee_per_blob_gas,
705	tx.blob_versioned_hashes,
706	)
707	)
708	)

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:

712	<snip>
720	assert isinstance(tx, (LegacyTransaction, Bytes))
721	if isinstance(tx, LegacyTransaction):
722	return keccak256(rlp.encode(tx))
723	else:
724	return keccak256(tx)

Search Results

ethereum.forks.shanghai.transactionsethereum.forks.cancun.transactions