ethereum.muir_glacier.transactionsethereum.berlin.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.

TX_BASE_COST

Base cost of a transaction in gas units. This is the minimum amount of gas required to execute a transaction.

25
TX_BASE_COST = Uint(21000)

TX_DATA_COST_PER_NON_ZERO

Gas cost per non-zero byte in the transaction data.

31
TX_DATA_COST_PER_NON_ZERO = Uint(16)

TX_DATA_COST_PER_ZERO

Gas cost per zero byte in the transaction data.

36
TX_DATA_COST_PER_ZERO = Uint(4)

TX_CREATE_COST

Additional gas cost for creating a new contract.

41
TX_CREATE_COST = Uint(32000)

TX_ACCESS_LIST_ADDRESS_COST

Gas cost for including an address in the access list of a transaction.

46
TX_ACCESS_LIST_ADDRESS_COST = Uint(2400)

TX_ACCESS_LIST_STORAGE_KEY_COST

Gas cost for including a storage key in the access list of a transaction.

51
TX_ACCESS_LIST_STORAGE_KEY_COST = Uint(1900)

LegacyTransaction

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

57
@slotted_freezable
58
@dataclass
class LegacyTransaction:

nonce

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

67
    nonce: U256

gas_price

The price of gas for this transaction, in wei.

72
    gas_price: Uint

gas

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

77
    gas: Uint

to

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

82
    to: Bytes0 | Address

value

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

88
    value: U256

data

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

93
    data: Bytes

v

The recovery id of the signature.

99
    v: U256

r

The first part of the signature.

104
    r: U256

s

The second part of the signature.

109
    s: U256

Access

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

115
@slotted_freezable
116
@dataclass
class Access:

account

The address of the account that is accessed.

123
    account: Address

slots

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

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

134
@slotted_freezable
135
@dataclass
class AccessListTransaction:

chain_id

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

147
    chain_id: U64

nonce

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

152
    nonce: U256

gas_price

The price of gas for this transaction.

157
    gas_price: Uint

gas

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

162
    gas: Uint

to

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

167
    to: Bytes0 | Address

value

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

173
    value: U256

data

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

178
    data: Bytes

access_list

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

184
    access_list: Tuple[Access, ...]

y_parity

The recovery id of the signature.

190
    y_parity: U256

r

The first part of the signature.

195
    r: U256

s

The second part of the signature.

200
    s: U256

Transaction

Atomic operation performed on the block chain.

45
@slotted_freezable
46
@dataclass
class Transaction:

nonce

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

52
    nonce: U256

gas_price

The price of gas for this transaction, in wei.

57
    gas_price: Uint

gas

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

62
    gas: Uint

to

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

67
    to: Bytes0 | Address

value

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

73
    value: U256

data

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

78
    data: Bytes

v

The recovery id of the signature.

84
    v: U256

r

The first part of the signature.

89
    r: U256

s

The second part of the signature.

94
    s: U256

Transaction

Union type representing any valid transaction type.

206
Transaction = LegacyTransaction | AccessListTransaction

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:
213
    """
214
    Encode a transaction into its RLP or typed transaction format.
215
    Needed because non-legacy transactions aren't RLP.
216
217
    Legacy transactions are returned as-is, while other transaction types
218
    are prefixed with their type identifier and RLP encoded.
219
    """
220
    if isinstance(tx, LegacyTransaction):
221
        return tx
222
    elif isinstance(tx, AccessListTransaction):
223
        return b"\x01" + rlp.encode(tx)
224
    else:
225
        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:
229
    """
230
    Decode a transaction from its RLP or typed transaction format.
231
    Needed because non-legacy transactions aren't RLP.
232
233
    Legacy transactions are returned as-is, while other transaction types
234
    are decoded based on their type identifier prefix.
235
    """
236
    if isinstance(tx, Bytes):
237
        if tx[0] != 1:
238
            raise TransactionTypeError(tx[0])
239
        return rlp.decode_to(AccessListTransaction, tx[1:])
240
    else:
241
        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.

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:
245
    """
246
    Verifies a transaction.
247
248
    The gas in a transaction gets used to pay for the intrinsic cost of
249
    operations, therefore if there is insufficient gas then it would not
250
    be possible to execute a transaction and it will be declared invalid.
251
252
    Additionally, the nonce of a transaction must not equal or exceed the
253
    limit defined in [EIP-2681].
254
    In practice, defining the limit as ``2**64-1`` has no impact because
255
    sending ``2**64-1`` transactions is improbable. It's not strictly
256
    impossible though, ``2**64-1`` transactions is the entire capacity of the
257
    Ethereum blockchain at 2022 gas limits for a little over 22 years.
258
259
    This function takes a transaction as a parameter and returns the intrinsic
260
    gas cost of the transaction after validation. It throws an
261
    `InsufficientTransactionGasError` exception if the transaction does not
262
    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
263
    exception if the nonce is greater than `2**64 - 2`.
264
265
    [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
266
    """
267
    intrinsic_gas = calculate_intrinsic_cost(tx)
268
    if intrinsic_gas > tx.gas:
269
        raise InsufficientTransactionGasError("Insufficient gas")
270
    if U256(tx.nonce) >= U256(U64.MAX_VALUE):
271
        raise NonceOverflowError("Nonce too high")
272
    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_COST)

  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:
276
    """
277
    Calculates the gas that is charged before execution is started.
278
279
    The intrinsic cost of the transaction is charged before execution has
280
    begun. Functions/operations in the EVM cost money to execute so this
281
    intrinsic cost is for the operations that need to be paid for as part of
282
    the transaction. Data transfer, for example, is part of this intrinsic
283
    cost. It costs ether to send data over the wire and that ether is
284
    accounted for in the intrinsic cost calculated in this function. This
285
    intrinsic cost must be calculated and paid for before execution in order
286
    for all operations to be implemented.
287
288
    The intrinsic cost includes:
289
    1. Base cost (`TX_BASE_COST`)
290
    2. Cost for data (zero and non-zero bytes)
291
    3. Cost for contract creation (if applicable)
292
    4. Cost for access list entries (if applicable)
293
294
    This function takes a transaction as a parameter and returns the intrinsic
295
    gas cost of the transaction.
296
    """
297
    data_cost = Uint(0)
298
299
    for byte in tx.data:
300
        if byte == 0:
301
            data_cost += TX_DATA_COST_PER_ZERO
302
        else:
303
            data_cost += TX_DATA_COST_PER_NON_ZERO
304
305
    if tx.to == Bytes0(b""):
306
        create_cost = TX_CREATE_COST
307
    else:
308
        create_cost = Uint(0)
309
165
    return TX_BASE_COST + data_cost + create_cost
310
    access_list_cost = Uint(0)
311
    if isinstance(tx, AccessListTransaction):
312
        for access in tx.access_list:
313
            access_list_cost += TX_ACCESS_LIST_ADDRESS_COST
314
            access_list_cost += (
315
                ulen(access.slots) * TX_ACCESS_LIST_STORAGE_KEY_COST
316
            )
317
318
    return TX_BASE_COST + data_cost + create_cost + access_list_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:
322
    """
323
    Extracts the sender address from a transaction.
324
325
    The v, r, and s values are the three parts that make up the signature
326
    of a transaction. In order to recover the sender of a transaction the two
327
    components needed are the signature (``v``, ``r``, and ``s``) and the
328
    signing hash of the transaction. The sender's public key can be obtained
329
    with these two values and therefore the sender address can be retrieved.
330
331
    This function takes chain_id and a transaction as parameters and returns
332
    the address of the sender of the transaction. It raises an
333
    `InvalidSignatureError` if the signature values (r, s, v) are invalid.
334
    """
182
    v, r, s = tx.v, tx.r, tx.s
335
    r, s = tx.r, tx.s
336
    if U256(0) >= r or r >= SECP256K1N:
337
        raise InvalidSignatureError("bad r")
338
    if U256(0) >= s or s > SECP256K1N // U256(2):
339
        raise InvalidSignatureError("bad s")
340
188
    if v == 27 or v == 28:
189
        public_key = secp256k1_recover(
190
            r, s, v - U256(27), signing_hash_pre155(tx)
191
        )
192
    else:
193
        chain_id_x2 = U256(chain_id) * U256(2)
194
        if v != U256(35) + chain_id_x2 and v != U256(36) + chain_id_x2:
195
            raise InvalidSignatureError("bad v")
196
        public_key = secp256k1_recover(
197
            r, s, v - U256(35) - chain_id_x2, signing_hash_155(tx, chain_id)
198
        )
341
    if isinstance(tx, LegacyTransaction):
342
        v = tx.v
343
        if v == 27 or v == 28:
344
            public_key = secp256k1_recover(
345
                r, s, v - U256(27), signing_hash_pre155(tx)
346
            )
347
        else:
348
            chain_id_x2 = U256(chain_id) * U256(2)
349
            if v != U256(35) + chain_id_x2 and v != U256(36) + chain_id_x2:
350
                raise InvalidSignatureError("bad v")
351
            public_key = secp256k1_recover(
352
                r,
353
                s,
354
                v - U256(35) - chain_id_x2,
355
                signing_hash_155(tx, chain_id),
356
            )
357
    elif isinstance(tx, AccessListTransaction):
358
        if tx.y_parity not in (U256(0), U256(1)):
359
            raise InvalidSignatureError("bad y_parity")
360
        public_key = secp256k1_recover(
361
            r, s, tx.y_parity, signing_hash_2930(tx)
362
        )
363
364
    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.hash of the transaction used in a legacy signature.

def signing_hash_pre155(tx: Transaction) -> Hash32:
368
    """
369
    Compute the hash of a transaction used in a legacy (pre [EIP-155])
370
    signature.
371
372
    This function takes a transaction as a parameter and returns the
209
    signing hash of the transaction.
373
    hash of the transaction used in a legacy signature.
374
375
    [EIP-155]: https://eips.ethereum.org/EIPS/eip-155
376
    """
377
    return keccak256(
378
        rlp.encode(
379
            (
380
                tx.nonce,
381
                tx.gas_price,
382
                tx.gas,
383
                tx.to,
384
                tx.value,
385
                tx.data,
386
            )
387
        )
388
    )

signing_hash_155

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

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

def signing_hash_155(tx: Transaction, ​​chain_id: U64) -> Hash32:
392
    """
393
    Compute the hash of a transaction used in a [EIP-155] signature.
394
395
    This function takes a transaction and chain ID as parameters and returns
396
    the hash of the transaction used in a [EIP-155] signature.
397
398
    [EIP-155]: https://eips.ethereum.org/EIPS/eip-155
399
    """
400
    return keccak256(
401
        rlp.encode(
402
            (
403
                tx.nonce,
404
                tx.gas_price,
405
                tx.gas,
406
                tx.to,
407
                tx.value,
408
                tx.data,
409
                chain_id,
410
                Uint(0),
411
                Uint(0),
412
            )
413
        )
414
    )

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:
418
    """
419
    Compute the hash of a transaction used in a [EIP-2930] signature.
420
421
    This function takes an access list transaction as a parameter
422
    and returns the hash of the transaction used in an [EIP-2930] signature.
423
424
    [EIP-2930]: https://eips.ethereum.org/EIPS/eip-2930
425
    """
426
    return keccak256(
427
        b"\x01"
428
        + rlp.encode(
429
            (
430
                tx.chain_id,
431
                tx.nonce,
432
                tx.gas_price,
433
                tx.gas,
434
                tx.to,
435
                tx.value,
436
                tx.data,
437
                tx.access_list,
438
            )
439
        )
440
    )

get_transaction_hash

Compute the hash of a transaction.

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

def get_transaction_hash(tx: TransactionBytes | LegacyTransaction) -> Hash32:
444
    """
445
    Compute the hash of a transaction.
446
447
    This function takes a transaction as a parameter and returns the
258
    hash of the transaction.
448
    keccak256 hash of the transaction. It can handle both legacy transactions
449
    and typed transactions (eg. `AccessListTransaction`).
450
    """
260
    return keccak256(rlp.encode(tx))
451
    assert isinstance(tx, (LegacyTransaction, Bytes))
452
    if isinstance(tx, LegacyTransaction):
453
        return keccak256(rlp.encode(tx))
454
    else:
455
        return keccak256(tx)