ethereum.arrow_glacier.forkethereum.gray_glacier.fork

Ethereum Specification ^^^^^^^^^^^^^^^^^^^^^^

.. contents:: Table of Contents :backlinks: none :local:

Introduction

Entry point for the Ethereum specification.

BLOCK_REWARD

67
BLOCK_REWARD = U256(2 * 10**18)

BASE_FEE_MAX_CHANGE_DENOMINATOR

68
BASE_FEE_MAX_CHANGE_DENOMINATOR = Uint(8)

ELASTICITY_MULTIPLIER

69
ELASTICITY_MULTIPLIER = Uint(2)

GAS_LIMIT_ADJUSTMENT_FACTOR

70
GAS_LIMIT_ADJUSTMENT_FACTOR = Uint(1024)

GAS_LIMIT_MINIMUM

71
GAS_LIMIT_MINIMUM = Uint(5000)

MINIMUM_DIFFICULTY

72
MINIMUM_DIFFICULTY = Uint(131072)

MAX_OMMER_DEPTH

73
MAX_OMMER_DEPTH = Uint(6)

BOMB_DELAY_BLOCKS

74
BOMB_DELAY_BLOCKS = 10700000
74
BOMB_DELAY_BLOCKS = 11400000

EMPTY_OMMER_HASH

75
EMPTY_OMMER_HASH = keccak256(rlp.encode([]))

BlockChain

History and current state of the block chain.

78
@dataclass
class BlockChain:

blocks

84
    blocks: List[Block]

state

85
    state: State

chain_id

86
    chain_id: U64

apply_fork

Transforms the state from the previous hard fork (old) into the block chain object for this hard fork and returns it.

When forks need to implement an irregular state transition, this function is used to handle the irregularity. See the :ref:DAO Fork <dao-fork> for an example.

Parameters

old : Previous block chain object.

Returns

new : BlockChain Upgraded block chain object for this hard fork.

def apply_fork(old: BlockChain) -> BlockChain:
90
    """
91
    Transforms the state from the previous hard fork (`old`) into the block
92
    chain object for this hard fork and returns it.
93
94
    When forks need to implement an irregular state transition, this function
95
    is used to handle the irregularity. See the :ref:`DAO Fork <dao-fork>` for
96
    an example.
97
98
    Parameters
99
    ----------
100
    old :
101
        Previous block chain object.
102
103
    Returns
104
    -------
105
    new : `BlockChain`
106
        Upgraded block chain object for this hard fork.
107
    """
108
    return old

get_last_256_block_hashes

Obtain the list of hashes of the previous 256 blocks in order of increasing block number.

This function will return less hashes for the first 256 blocks.

The BLOCKHASH opcode needs to access the latest hashes on the chain, therefore this function retrieves them.

Parameters

chain : History and current state.

Returns

recent_block_hashes : List[Hash32] Hashes of the recent 256 blocks in order of increasing block number.

def get_last_256_block_hashes(chain: BlockChain) -> List[Hash32]:
112
    """
113
    Obtain the list of hashes of the previous 256 blocks in order of
114
    increasing block number.
115
116
    This function will return less hashes for the first 256 blocks.
117
118
    The ``BLOCKHASH`` opcode needs to access the latest hashes on the chain,
119
    therefore this function retrieves them.
120
121
    Parameters
122
    ----------
123
    chain :
124
        History and current state.
125
126
    Returns
127
    -------
128
    recent_block_hashes : `List[Hash32]`
129
        Hashes of the recent 256 blocks in order of increasing block number.
130
    """
131
    recent_blocks = chain.blocks[-255:]
132
    # TODO: This function has not been tested rigorously
133
    if len(recent_blocks) == 0:
134
        return []
135
136
    recent_block_hashes = []
137
138
    for block in recent_blocks:
139
        prev_block_hash = block.header.parent_hash
140
        recent_block_hashes.append(prev_block_hash)
141
142
    # We are computing the hash only for the most recent block and not for
143
    # the rest of the blocks as they have successors which have the hash of
144
    # the current block as parent hash.
145
    most_recent_block_hash = keccak256(rlp.encode(recent_blocks[-1].header))
146
    recent_block_hashes.append(most_recent_block_hash)
147
148
    return recent_block_hashes

state_transition

Attempts to apply a block to an existing block chain.

All parts of the block's contents need to be verified before being added to the chain. Blocks are verified by ensuring that the contents of the block make logical sense with the contents of the parent block. The information in the block's header must also match the corresponding information in the block.

To implement Ethereum, in theory clients are only required to store the most recent 255 blocks of the chain since as far as execution is concerned, only those blocks are accessed. Practically, however, clients should store more blocks to handle reorgs.

Parameters

chain : History and current state. block : Block to apply to chain.

def state_transition(chain: BlockChain, ​​block: Block) -> None:
152
    """
153
    Attempts to apply a block to an existing block chain.
154
155
    All parts of the block's contents need to be verified before being added
156
    to the chain. Blocks are verified by ensuring that the contents of the
157
    block make logical sense with the contents of the parent block. The
158
    information in the block's header must also match the corresponding
159
    information in the block.
160
161
    To implement Ethereum, in theory clients are only required to store the
162
    most recent 255 blocks of the chain since as far as execution is
163
    concerned, only those blocks are accessed. Practically, however, clients
164
    should store more blocks to handle reorgs.
165
166
    Parameters
167
    ----------
168
    chain :
169
        History and current state.
170
    block :
171
        Block to apply to `chain`.
172
    """
173
    validate_header(chain, block.header)
174
    validate_ommers(block.ommers, block.header, chain)
175
176
    block_env = vm.BlockEnvironment(
177
        chain_id=chain.chain_id,
178
        state=chain.state,
179
        block_gas_limit=block.header.gas_limit,
180
        block_hashes=get_last_256_block_hashes(chain),
181
        coinbase=block.header.coinbase,
182
        number=block.header.number,
183
        base_fee_per_gas=block.header.base_fee_per_gas,
184
        time=block.header.timestamp,
185
        difficulty=block.header.difficulty,
186
    )
187
188
    block_output = apply_body(
189
        block_env=block_env,
190
        transactions=block.transactions,
191
        ommers=block.ommers,
192
    )
193
    block_state_root = state_root(block_env.state)
194
    transactions_root = root(block_output.transactions_trie)
195
    receipt_root = root(block_output.receipts_trie)
196
    block_logs_bloom = logs_bloom(block_output.block_logs)
197
198
    if block_output.block_gas_used != block.header.gas_used:
199
        raise InvalidBlock(
200
            f"{block_output.block_gas_used} != {block.header.gas_used}"
201
        )
202
    if transactions_root != block.header.transactions_root:
203
        raise InvalidBlock
204
    if block_state_root != block.header.state_root:
205
        raise InvalidBlock
206
    if receipt_root != block.header.receipt_root:
207
        raise InvalidBlock
208
    if block_logs_bloom != block.header.bloom:
209
        raise InvalidBlock
210
211
    chain.blocks.append(block)
212
    if len(chain.blocks) > 255:
213
        # Real clients have to store more blocks to deal with reorgs, but the
214
        # protocol only requires the last 255
215
        chain.blocks = chain.blocks[-255:]

calculate_base_fee_per_gas

Calculates the base fee per gas for the block.

Parameters

block_gas_limit : Gas limit of the block for which the base fee is being calculated. parent_gas_limit : Gas limit of the parent block. parent_gas_used : Gas used in the parent block. parent_base_fee_per_gas : Base fee per gas of the parent block.

Returns

base_fee_per_gas : Uint Base fee per gas for the block.

def calculate_base_fee_per_gas(block_gas_limit: Uint, ​​parent_gas_limit: Uint, ​​parent_gas_used: Uint, ​​parent_base_fee_per_gas: Uint) -> Uint:
224
    """
225
    Calculates the base fee per gas for the block.
226
227
    Parameters
228
    ----------
229
    block_gas_limit :
230
        Gas limit of the block for which the base fee is being calculated.
231
    parent_gas_limit :
232
        Gas limit of the parent block.
233
    parent_gas_used :
234
        Gas used in the parent block.
235
    parent_base_fee_per_gas :
236
        Base fee per gas of the parent block.
237
238
    Returns
239
    -------
240
    base_fee_per_gas : `Uint`
241
        Base fee per gas for the block.
242
    """
243
    parent_gas_target = parent_gas_limit // ELASTICITY_MULTIPLIER
244
    if not check_gas_limit(block_gas_limit, parent_gas_limit):
245
        raise InvalidBlock
246
247
    if parent_gas_used == parent_gas_target:
248
        expected_base_fee_per_gas = parent_base_fee_per_gas
249
    elif parent_gas_used > parent_gas_target:
250
        gas_used_delta = parent_gas_used - parent_gas_target
251
252
        parent_fee_gas_delta = parent_base_fee_per_gas * gas_used_delta
253
        target_fee_gas_delta = parent_fee_gas_delta // parent_gas_target
254
255
        base_fee_per_gas_delta = max(
256
            target_fee_gas_delta // BASE_FEE_MAX_CHANGE_DENOMINATOR,
257
            Uint(1),
258
        )
259
260
        expected_base_fee_per_gas = (
261
            parent_base_fee_per_gas + base_fee_per_gas_delta
262
        )
263
    else:
264
        gas_used_delta = parent_gas_target - parent_gas_used
265
266
        parent_fee_gas_delta = parent_base_fee_per_gas * gas_used_delta
267
        target_fee_gas_delta = parent_fee_gas_delta // parent_gas_target
268
269
        base_fee_per_gas_delta = (
270
            target_fee_gas_delta // BASE_FEE_MAX_CHANGE_DENOMINATOR
271
        )
272
273
        expected_base_fee_per_gas = (
274
            parent_base_fee_per_gas - base_fee_per_gas_delta
275
        )
276
277
    return Uint(expected_base_fee_per_gas)

validate_header

Verifies a block header.

In order to consider a block's header valid, the logic for the quantities in the header should match the logic for the block itself. For example the header timestamp should be greater than the block's parent timestamp because the block was created after the parent block. Additionally, the block's number should be directly following the parent block's number since it is the next block in the sequence.

Parameters

chain : History and current state. header : Header to check for correctness.

def validate_header(chain: BlockChain, ​​header: Header) -> None:
281
    """
282
    Verifies a block header.
283
284
    In order to consider a block's header valid, the logic for the
285
    quantities in the header should match the logic for the block itself.
286
    For example the header timestamp should be greater than the block's parent
287
    timestamp because the block was created *after* the parent block.
288
    Additionally, the block's number should be directly following the parent
289
    block's number since it is the next block in the sequence.
290
291
    Parameters
292
    ----------
293
    chain :
294
        History and current state.
295
    header :
296
        Header to check for correctness.
297
    """
298
    if header.number < Uint(1):
299
        raise InvalidBlock
300
    parent_header_number = header.number - Uint(1)
301
    first_block_number = chain.blocks[0].header.number
302
    last_block_number = chain.blocks[-1].header.number
303
304
    if (
305
        parent_header_number < first_block_number
306
        or parent_header_number > last_block_number
307
    ):
308
        raise InvalidBlock
309
310
    parent_header = chain.blocks[
311
        parent_header_number - first_block_number
312
    ].header
313
314
    if header.gas_used > header.gas_limit:
315
        raise InvalidBlock
316
317
    expected_base_fee_per_gas = calculate_base_fee_per_gas(
318
        header.gas_limit,
319
        parent_header.gas_limit,
320
        parent_header.gas_used,
321
        parent_header.base_fee_per_gas,
322
    )
323
    if expected_base_fee_per_gas != header.base_fee_per_gas:
324
        raise InvalidBlock
325
326
    parent_has_ommers = parent_header.ommers_hash != EMPTY_OMMER_HASH
327
    if header.timestamp <= parent_header.timestamp:
328
        raise InvalidBlock
329
    if header.number != parent_header.number + Uint(1):
330
        raise InvalidBlock
331
    if len(header.extra_data) > 32:
332
        raise InvalidBlock
333
334
    block_difficulty = calculate_block_difficulty(
335
        header.number,
336
        header.timestamp,
337
        parent_header.timestamp,
338
        parent_header.difficulty,
339
        parent_has_ommers,
340
    )
341
    if header.difficulty != block_difficulty:
342
        raise InvalidBlock
343
344
    block_parent_hash = keccak256(rlp.encode(parent_header))
345
    if header.parent_hash != block_parent_hash:
346
        raise InvalidBlock
347
348
    validate_proof_of_work(header)

generate_header_hash_for_pow

Generate rlp hash of the header which is to be used for Proof-of-Work verification.

In other words, the PoW artefacts mix_digest and nonce are ignored while calculating this hash.

A particular PoW is valid for a single hash, that hash is computed by this function. The nonce and mix_digest are omitted from this hash because they are being changed by miners in their search for a sufficient proof-of-work.

Parameters

header : The header object for which the hash is to be generated.

Returns

hash : Hash32 The PoW valid rlp hash of the passed in header.

def generate_header_hash_for_pow(header: Header) -> Hash32:
352
    """
353
    Generate rlp hash of the header which is to be used for Proof-of-Work
354
    verification.
355
356
    In other words, the PoW artefacts `mix_digest` and `nonce` are ignored
357
    while calculating this hash.
358
359
    A particular PoW is valid for a single hash, that hash is computed by
360
    this function. The `nonce` and `mix_digest` are omitted from this hash
361
    because they are being changed by miners in their search for a sufficient
362
    proof-of-work.
363
364
    Parameters
365
    ----------
366
    header :
367
        The header object for which the hash is to be generated.
368
369
    Returns
370
    -------
371
    hash : `Hash32`
372
        The PoW valid rlp hash of the passed in header.
373
    """
374
    header_data_without_pow_artefacts = (
375
        header.parent_hash,
376
        header.ommers_hash,
377
        header.coinbase,
378
        header.state_root,
379
        header.transactions_root,
380
        header.receipt_root,
381
        header.bloom,
382
        header.difficulty,
383
        header.number,
384
        header.gas_limit,
385
        header.gas_used,
386
        header.timestamp,
387
        header.extra_data,
388
        header.base_fee_per_gas,
389
    )
390
391
    return keccak256(rlp.encode(header_data_without_pow_artefacts))

validate_proof_of_work

Validates the Proof of Work constraints.

In order to verify that a miner's proof-of-work is valid for a block, a mix-digest and result are calculated using the hashimoto_light hash function. The mix digest is a hash of the header and the nonce that is passed through and it confirms whether or not proof-of-work was done on the correct block. The result is the actual hash value of the block.

Parameters

header : Header of interest.

def validate_proof_of_work(header: Header) -> None:
395
    """
396
    Validates the Proof of Work constraints.
397
398
    In order to verify that a miner's proof-of-work is valid for a block, a
399
    ``mix-digest`` and ``result`` are calculated using the ``hashimoto_light``
400
    hash function. The mix digest is a hash of the header and the nonce that
401
    is passed through and it confirms whether or not proof-of-work was done
402
    on the correct block. The result is the actual hash value of the block.
403
404
    Parameters
405
    ----------
406
    header :
407
        Header of interest.
408
    """
409
    header_hash = generate_header_hash_for_pow(header)
410
    # TODO: Memoize this somewhere and read from that data instead of
411
    # calculating cache for every block validation.
412
    cache = generate_cache(header.number)
413
    mix_digest, result = hashimoto_light(
414
        header_hash, header.nonce, cache, dataset_size(header.number)
415
    )
416
    if mix_digest != header.mix_digest:
417
        raise InvalidBlock
418
419
    limit = Uint(U256.MAX_VALUE) + Uint(1)
420
    if Uint.from_be_bytes(result) > (limit // header.difficulty):
421
        raise InvalidBlock

check_transaction

Check if the transaction is includable in the block.

Parameters

block_env : The block scoped environment. block_output : The block output for the current block. tx : The transaction.

Returns

sender_address : The sender of the transaction. effective_gas_price : The price to charge for gas when the transaction is executed.

Raises

InvalidBlock : If the transaction is not includable. GasUsedExceedsLimitError : If the gas used by the transaction exceeds the block's gas limit. NonceMismatchError : If the nonce of the transaction is not equal to the sender's nonce. InsufficientBalanceError : If the sender's balance is not enough to pay for the transaction. InvalidSenderError : If the transaction is from an address that does not exist anymore. PriorityFeeGreaterThanMaxFeeError :PriorityFeeGreaterThanMaxFeeError: If the priority fee is greater than the maximum fee per gas. InsufficientMaxFeePerGasError : If the maximum fee per gas is insufficient for the transaction.

def check_transaction(block_env: ethereum.arrow_glacier.vm.BlockEnvironmentethereum.gray_glacier.vm.BlockEnvironment, ​​block_output: ethereum.arrow_glacier.vm.BlockOutputethereum.gray_glacier.vm.BlockOutput, ​​tx: Transaction) -> Tuple[Address, Uint]:
429
    """
430
    Check if the transaction is includable in the block.
431
432
    Parameters
433
    ----------
434
    block_env :
435
        The block scoped environment.
436
    block_output :
437
        The block output for the current block.
438
    tx :
439
        The transaction.
440
441
    Returns
442
    -------
443
    sender_address :
444
        The sender of the transaction.
445
    effective_gas_price :
446
        The price to charge for gas when the transaction is executed.
447
448
    Raises
449
    ------
450
    InvalidBlock :
451
        If the transaction is not includable.
452
    GasUsedExceedsLimitError :
453
        If the gas used by the transaction exceeds the block's gas limit.
454
    NonceMismatchError :
455
        If the nonce of the transaction is not equal to the sender's nonce.
456
    InsufficientBalanceError :
457
        If the sender's balance is not enough to pay for the transaction.
458
    InvalidSenderError :
459
        If the transaction is from an address that does not exist anymore.
460
    PriorityFeeGreaterThanMaxFeeError :
460
    PriorityFeeGreaterThanMaxFeeError:
461
        If the priority fee is greater than the maximum fee per gas.
462
    InsufficientMaxFeePerGasError :
463
        If the maximum fee per gas is insufficient for the transaction.
464
    """
465
    gas_available = block_env.block_gas_limit - block_output.block_gas_used
466
    if tx.gas > gas_available:
467
        raise GasUsedExceedsLimitError("gas used exceeds limit")
468
    sender_address = recover_sender(block_env.chain_id, tx)
469
    sender_account = get_account(block_env.state, sender_address)
470
471
    if isinstance(tx, FeeMarketTransaction):
472
        if tx.max_fee_per_gas < tx.max_priority_fee_per_gas:
473
            raise PriorityFeeGreaterThanMaxFeeError(
474
                "priority fee greater than max fee"
475
            )
476
        if tx.max_fee_per_gas < block_env.base_fee_per_gas:
477
            raise InsufficientMaxFeePerGasError(
478
                tx.max_fee_per_gas, block_env.base_fee_per_gas
479
            )
480
481
        priority_fee_per_gas = min(
482
            tx.max_priority_fee_per_gas,
483
            tx.max_fee_per_gas - block_env.base_fee_per_gas,
484
        )
485
        effective_gas_price = priority_fee_per_gas + block_env.base_fee_per_gas
486
        max_gas_fee = tx.gas * tx.max_fee_per_gas
487
    else:
488
        if tx.gas_price < block_env.base_fee_per_gas:
489
            raise InvalidBlock
490
        effective_gas_price = tx.gas_price
491
        max_gas_fee = tx.gas * tx.gas_price
492
493
    if sender_account.nonce > Uint(tx.nonce):
494
        raise NonceMismatchError("nonce too low")
495
    elif sender_account.nonce < Uint(tx.nonce):
496
        raise NonceMismatchError("nonce too high")
497
    if Uint(sender_account.balance) < max_gas_fee + Uint(tx.value):
498
        raise InsufficientBalanceError("insufficient sender balance")
499
    if sender_account.code:
500
        raise InvalidSenderError("not EOA")
501
502
    return sender_address, effective_gas_price

make_receipt

Make the receipt for a transaction that was executed.

Parameters

tx : The executed transaction. error : Error in the top level frame of the transaction, if any. cumulative_gas_used : The total gas used so far in the block after the transaction was executed. logs : The logs produced by the transaction.

Returns

receipt : The receipt for the transaction.

def make_receipt(tx: Transaction, ​​error: Optional[EthereumException], ​​cumulative_gas_used: Uint, ​​logs: Tuple[Log, ...]) -> Bytes | Receipt:
511
    """
512
    Make the receipt for a transaction that was executed.
513
514
    Parameters
515
    ----------
516
    tx :
517
        The executed transaction.
518
    error :
519
        Error in the top level frame of the transaction, if any.
520
    cumulative_gas_used :
521
        The total gas used so far in the block after the transaction was
522
        executed.
523
    logs :
524
        The logs produced by the transaction.
525
526
    Returns
527
    -------
528
    receipt :
529
        The receipt for the transaction.
530
    """
531
    receipt = Receipt(
532
        succeeded=error is None,
533
        cumulative_gas_used=cumulative_gas_used,
534
        bloom=logs_bloom(logs),
535
        logs=logs,
536
    )
537
538
    return encode_receipt(tx, receipt)

apply_body

Executes a block.

Many of the contents of a block are stored in data structures called tries. There is a transactions trie which is similar to a ledger of the transactions stored in the current block. There is also a receipts trie which stores the results of executing a transaction, like the post state and gas used. This function creates and executes the block that is to be added to the chain.

Parameters

block_env : The block scoped environment. transactions : Transactions included in the block. ommers : Headers of ancestor blocks which are not direct parents (formerly uncles.)

Returns

block_output : The block output for the current block.

def apply_body(block_env: ethereum.arrow_glacier.vm.BlockEnvironmentethereum.gray_glacier.vm.BlockEnvironment, ​​transactions: Tuple[LegacyTransaction | Bytes, ...], ​​ommers: Tuple[Header, ...]) -> ethereum.arrow_glacier.vm.BlockOutputethereum.gray_glacier.vm.BlockOutput:
546
    """
547
    Executes a block.
548
549
    Many of the contents of a block are stored in data structures called
550
    tries. There is a transactions trie which is similar to a ledger of the
551
    transactions stored in the current block. There is also a receipts trie
552
    which stores the results of executing a transaction, like the post state
553
    and gas used. This function creates and executes the block that is to be
554
    added to the chain.
555
556
    Parameters
557
    ----------
558
    block_env :
559
        The block scoped environment.
560
    transactions :
561
        Transactions included in the block.
562
    ommers :
563
        Headers of ancestor blocks which are not direct parents (formerly
564
        uncles.)
565
566
    Returns
567
    -------
568
    block_output :
569
        The block output for the current block.
570
    """
571
    block_output = vm.BlockOutput()
572
573
    for i, tx in enumerate(map(decode_transaction, transactions)):
574
        process_transaction(block_env, block_output, tx, Uint(i))
575
576
    pay_rewards(block_env.state, block_env.number, block_env.coinbase, ommers)
577
578
    return block_output

validate_ommers

Validates the ommers mentioned in the block.

An ommer block is a block that wasn't canonically added to the blockchain because it wasn't validated as fast as the canonical block but was mined at the same time.

To be considered valid, the ommers must adhere to the rules defined in the Ethereum protocol. The maximum amount of ommers is 2 per block and there cannot be duplicate ommers in a block. Many of the other ommer constraints are listed in the in-line comments of this function.

Parameters

ommers : List of ommers mentioned in the current block. block_header: The header of current block. chain : History and current state.

def validate_ommers(ommers: Tuple[Header, ...], ​​block_header: Header, ​​chain: BlockChain) -> None:
584
    """
585
    Validates the ommers mentioned in the block.
586
587
    An ommer block is a block that wasn't canonically added to the
588
    blockchain because it wasn't validated as fast as the canonical block
589
    but was mined at the same time.
590
591
    To be considered valid, the ommers must adhere to the rules defined in
592
    the Ethereum protocol. The maximum amount of ommers is 2 per block and
593
    there cannot be duplicate ommers in a block. Many of the other ommer
594
    constraints are listed in the in-line comments of this function.
595
596
    Parameters
597
    ----------
598
    ommers :
599
        List of ommers mentioned in the current block.
600
    block_header:
601
        The header of current block.
602
    chain :
603
        History and current state.
604
    """
605
    block_hash = keccak256(rlp.encode(block_header))
606
    if keccak256(rlp.encode(ommers)) != block_header.ommers_hash:
607
        raise InvalidBlock
608
609
    if len(ommers) == 0:
610
        # Nothing to validate
611
        return
612
613
    # Check that each ommer satisfies the constraints of a header
614
    for ommer in ommers:
615
        if Uint(1) > ommer.number or ommer.number >= block_header.number:
616
            raise InvalidBlock
617
        validate_header(chain, ommer)
618
    if len(ommers) > 2:
619
        raise InvalidBlock
620
621
    ommers_hashes = [keccak256(rlp.encode(ommer)) for ommer in ommers]
622
    if len(ommers_hashes) != len(set(ommers_hashes)):
623
        raise InvalidBlock
624
625
    recent_canonical_blocks = chain.blocks[-(MAX_OMMER_DEPTH + Uint(1)) :]
626
    recent_canonical_block_hashes = {
627
        keccak256(rlp.encode(block.header))
628
        for block in recent_canonical_blocks
629
    }
630
    recent_ommers_hashes: Set[Hash32] = set()
631
    for block in recent_canonical_blocks:
632
        recent_ommers_hashes = recent_ommers_hashes.union(
633
            {keccak256(rlp.encode(ommer)) for ommer in block.ommers}
634
        )
635
636
    for ommer_index, ommer in enumerate(ommers):
637
        ommer_hash = ommers_hashes[ommer_index]
638
        if ommer_hash == block_hash:
639
            raise InvalidBlock
640
        if ommer_hash in recent_canonical_block_hashes:
641
            raise InvalidBlock
642
        if ommer_hash in recent_ommers_hashes:
643
            raise InvalidBlock
644
645
        # Ommer age with respect to the current block. For example, an age of
646
        # 1 indicates that the ommer is a sibling of previous block.
647
        ommer_age = block_header.number - ommer.number
648
        if Uint(1) > ommer_age or ommer_age > MAX_OMMER_DEPTH:
649
            raise InvalidBlock
650
        if ommer.parent_hash not in recent_canonical_block_hashes:
651
            raise InvalidBlock
652
        if ommer.parent_hash == block_header.parent_hash:
653
            raise InvalidBlock

pay_rewards

Pay rewards to the block miner as well as the ommers miners.

The miner of the canonical block is rewarded with the predetermined block reward, BLOCK_REWARD, plus a variable award based off of the number of ommer blocks that were mined around the same time, and included in the canonical block's header. An ommer block is a block that wasn't added to the canonical blockchain because it wasn't validated as fast as the accepted block but was mined at the same time. Although not all blocks that are mined are added to the canonical chain, miners are still paid a reward for their efforts. This reward is called an ommer reward and is calculated based on the number associated with the ommer block that they mined.

Parameters

state : Current account state. block_number : Position of the block within the chain. coinbase : Address of account which receives block reward and transaction fees. ommers : List of ommers mentioned in the current block.

def pay_rewards(state: State, ​​block_number: Uint, ​​coinbase: Address, ​​ommers: Tuple[Header, ...]) -> None:
662
    """
663
    Pay rewards to the block miner as well as the ommers miners.
664
665
    The miner of the canonical block is rewarded with the predetermined
666
    block reward, ``BLOCK_REWARD``, plus a variable award based off of the
667
    number of ommer blocks that were mined around the same time, and included
668
    in the canonical block's header. An ommer block is a block that wasn't
669
    added to the canonical blockchain because it wasn't validated as fast as
670
    the accepted block but was mined at the same time. Although not all blocks
671
    that are mined are added to the canonical chain, miners are still paid a
672
    reward for their efforts. This reward is called an ommer reward and is
673
    calculated based on the number associated with the ommer block that they
674
    mined.
675
676
    Parameters
677
    ----------
678
    state :
679
        Current account state.
680
    block_number :
681
        Position of the block within the chain.
682
    coinbase :
683
        Address of account which receives block reward and transaction fees.
684
    ommers :
685
        List of ommers mentioned in the current block.
686
    """
687
    ommer_count = U256(len(ommers))
688
    miner_reward = BLOCK_REWARD + (ommer_count * (BLOCK_REWARD // U256(32)))
689
    create_ether(state, coinbase, miner_reward)
690
691
    for ommer in ommers:
692
        # Ommer age with respect to the current block.
693
        ommer_age = U256(block_number - ommer.number)
694
        ommer_miner_reward = ((U256(8) - ommer_age) * BLOCK_REWARD) // U256(8)
695
        create_ether(state, ommer.coinbase, ommer_miner_reward)

process_transaction

Execute a transaction against the provided environment.

This function processes the actions needed to execute a transaction. It decrements the sender's account after calculating the gas fee and refunds them the proper amount after execution. Calling contracts, deploying code, and incrementing nonces are all examples of actions that happen within this function or from a call made within this function.

Accounts that are marked for deletion are processed and destroyed after execution.

Parameters

block_env : Environment for the Ethereum Virtual Machine. block_output : The block output for the current block. tx : Transaction to execute. index: Index of the transaction in the block.

def process_transaction(block_env: ethereum.arrow_glacier.vm.BlockEnvironmentethereum.gray_glacier.vm.BlockEnvironment, ​​block_output: ethereum.arrow_glacier.vm.BlockOutputethereum.gray_glacier.vm.BlockOutput, ​​tx: Transaction, ​​index: Uint) -> None:
704
    """
705
    Execute a transaction against the provided environment.
706
707
    This function processes the actions needed to execute a transaction.
708
    It decrements the sender's account after calculating the gas fee and
709
    refunds them the proper amount after execution. Calling contracts,
710
    deploying code, and incrementing nonces are all examples of actions that
711
    happen within this function or from a call made within this function.
712
713
    Accounts that are marked for deletion are processed and destroyed after
714
    execution.
715
716
    Parameters
717
    ----------
718
    block_env :
719
        Environment for the Ethereum Virtual Machine.
720
    block_output :
721
        The block output for the current block.
722
    tx :
723
        Transaction to execute.
724
    index:
725
        Index of the transaction in the block.
726
    """
727
    trie_set(
728
        block_output.transactions_trie,
729
        rlp.encode(index),
730
        encode_transaction(tx),
731
    )
732
733
    intrinsic_gas = validate_transaction(tx)
734
735
    (
736
        sender,
737
        effective_gas_price,
738
    ) = check_transaction(
739
        block_env=block_env,
740
        block_output=block_output,
741
        tx=tx,
742
    )
743
744
    sender_account = get_account(block_env.state, sender)
745
746
    effective_gas_fee = tx.gas * effective_gas_price
747
748
    gas = tx.gas - intrinsic_gas
749
    increment_nonce(block_env.state, sender)
750
751
    sender_balance_after_gas_fee = (
752
        Uint(sender_account.balance) - effective_gas_fee
753
    )
754
    set_account_balance(
755
        block_env.state, sender, U256(sender_balance_after_gas_fee)
756
    )
757
758
    access_list_addresses = set()
759
    access_list_storage_keys = set()
760
    if isinstance(tx, (AccessListTransaction, FeeMarketTransaction)):
761
        for access in tx.access_list:
762
            access_list_addresses.add(access.account)
763
            for slot in access.slots:
764
                access_list_storage_keys.add((access.account, slot))
765
766
    tx_env = vm.TransactionEnvironment(
767
        origin=sender,
768
        gas_price=effective_gas_price,
769
        gas=gas,
770
        access_list_addresses=access_list_addresses,
771
        access_list_storage_keys=access_list_storage_keys,
772
        index_in_block=index,
773
        tx_hash=get_transaction_hash(encode_transaction(tx)),
774
        traces=[],
775
    )
776
777
    message = prepare_message(block_env, tx_env, tx)
778
779
    tx_output = process_message_call(message)
780
781
    tx_gas_used_before_refund = tx.gas - tx_output.gas_left
782
    tx_gas_refund = min(
783
        tx_gas_used_before_refund // Uint(5), Uint(tx_output.refund_counter)
784
    )
785
    tx_gas_used_after_refund = tx_gas_used_before_refund - tx_gas_refund
786
    tx_gas_left = tx.gas - tx_gas_used_after_refund
787
    gas_refund_amount = tx_gas_left * effective_gas_price
788
789
    # For non-1559 transactions effective_gas_price == tx.gas_price
790
    priority_fee_per_gas = effective_gas_price - block_env.base_fee_per_gas
791
    transaction_fee = tx_gas_used_after_refund * priority_fee_per_gas
792
793
    # refund gas
794
    sender_balance_after_refund = get_account(
795
        block_env.state, sender
796
    ).balance + U256(gas_refund_amount)
797
    set_account_balance(block_env.state, sender, sender_balance_after_refund)
798
799
    # transfer miner fees
800
    coinbase_balance_after_mining_fee = get_account(
801
        block_env.state, block_env.coinbase
802
    ).balance + U256(transaction_fee)
803
    if coinbase_balance_after_mining_fee != 0:
804
        set_account_balance(
805
            block_env.state,
806
            block_env.coinbase,
807
            coinbase_balance_after_mining_fee,
808
        )
809
    elif account_exists_and_is_empty(block_env.state, block_env.coinbase):
810
        destroy_account(block_env.state, block_env.coinbase)
811
812
    for address in tx_output.accounts_to_delete:
813
        destroy_account(block_env.state, address)
814
815
    destroy_touched_empty_accounts(block_env.state, tx_output.touched_accounts)
816
817
    block_output.block_gas_used += tx_gas_used_after_refund
818
819
    receipt = make_receipt(
820
        tx, tx_output.error, block_output.block_gas_used, tx_output.logs
821
    )
822
823
    receipt_key = rlp.encode(Uint(index))
824
    block_output.receipt_keys += (receipt_key,)
825
826
    trie_set(
827
        block_output.receipts_trie,
828
        receipt_key,
829
        receipt,
830
    )
831
832
    block_output.block_logs += tx_output.logs

check_gas_limit

Validates the gas limit for a block.

The bounds of the gas limit, max_adjustment_delta, is set as the quotient of the parent block's gas limit and the GAS_LIMIT_ADJUSTMENT_FACTOR. Therefore, if the gas limit that is passed through as a parameter is greater than or equal to the sum of the parent's gas and the adjustment delta then the limit for gas is too high and fails this function's check. Similarly, if the limit is less than or equal to the difference of the parent's gas and the adjustment delta or the predefined GAS_LIMIT_MINIMUM then this function's check fails because the gas limit doesn't allow for a sufficient or reasonable amount of gas to be used on a block.

Parameters

gas_limit : Gas limit to validate.

parent_gas_limit : Gas limit of the parent block.

Returns

check : bool True if gas limit constraints are satisfied, False otherwise.

def check_gas_limit(gas_limit: Uint, ​​parent_gas_limit: Uint) -> bool:
836
    """
837
    Validates the gas limit for a block.
838
839
    The bounds of the gas limit, ``max_adjustment_delta``, is set as the
840
    quotient of the parent block's gas limit and the
841
    ``GAS_LIMIT_ADJUSTMENT_FACTOR``. Therefore, if the gas limit that is
842
    passed through as a parameter is greater than or equal to the *sum* of
843
    the parent's gas and the adjustment delta then the limit for gas is too
844
    high and fails this function's check. Similarly, if the limit is less
845
    than or equal to the *difference* of the parent's gas and the adjustment
846
    delta *or* the predefined ``GAS_LIMIT_MINIMUM`` then this function's
847
    check fails because the gas limit doesn't allow for a sufficient or
848
    reasonable amount of gas to be used on a block.
849
850
    Parameters
851
    ----------
852
    gas_limit :
853
        Gas limit to validate.
854
855
    parent_gas_limit :
856
        Gas limit of the parent block.
857
858
    Returns
859
    -------
860
    check : `bool`
861
        True if gas limit constraints are satisfied, False otherwise.
862
    """
863
    max_adjustment_delta = parent_gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
864
    if gas_limit >= parent_gas_limit + max_adjustment_delta:
865
        return False
866
    if gas_limit <= parent_gas_limit - max_adjustment_delta:
867
        return False
868
    if gas_limit < GAS_LIMIT_MINIMUM:
869
        return False
870
871
    return True

calculate_block_difficulty

Computes difficulty of a block using its header and parent header.

The difficulty is determined by the time the block was created after its parent. The offset is calculated using the parent block's difficulty, parent_difficulty, and the timestamp between blocks. This offset is then added to the parent difficulty and is stored as the difficulty variable. If the time between the block and its parent is too short, the offset will result in a positive number thus making the sum of parent_difficulty and offset to be a greater value in order to avoid mass forking. But, if the time is long enough, then the offset results in a negative value making the block less difficult than its parent.

The base standard for a block's difficulty is the predefined value set for the genesis block since it has no parent. So, a block can't be less difficult than the genesis block, therefore each block's difficulty is set to the maximum value between the calculated difficulty and the GENESIS_DIFFICULTY.

Parameters

block_number : Block number of the block. block_timestamp : Timestamp of the block. parent_timestamp : Timestamp of the parent block. parent_difficulty : difficulty of the parent block. parent_has_ommers: does the parent have ommers.

Returns

difficulty : ethereum.base_types.Uint Computed difficulty for a block.

def calculate_block_difficulty(block_number: Uint, ​​block_timestamp: U256, ​​parent_timestamp: U256, ​​parent_difficulty: Uint, ​​parent_has_ommers: bool) -> Uint:
881
    """
882
    Computes difficulty of a block using its header and parent header.
883
884
    The difficulty is determined by the time the block was created after its
885
    parent. The ``offset`` is calculated using the parent block's difficulty,
886
    ``parent_difficulty``, and the timestamp between blocks. This offset is
887
    then added to the parent difficulty and is stored as the ``difficulty``
888
    variable. If the time between the block and its parent is too short, the
889
    offset will result in a positive number thus making the sum of
890
    ``parent_difficulty`` and ``offset`` to be a greater value in order to
891
    avoid mass forking. But, if the time is long enough, then the offset
892
    results in a negative value making the block less difficult than
893
    its parent.
894
895
    The base standard for a block's difficulty is the predefined value
896
    set for the genesis block since it has no parent. So, a block
897
    can't be less difficult than the genesis block, therefore each block's
898
    difficulty is set to the maximum value between the calculated
899
    difficulty and the ``GENESIS_DIFFICULTY``.
900
901
    Parameters
902
    ----------
903
    block_number :
904
        Block number of the block.
905
    block_timestamp :
906
        Timestamp of the block.
907
    parent_timestamp :
908
        Timestamp of the parent block.
909
    parent_difficulty :
910
        difficulty of the parent block.
911
    parent_has_ommers:
912
        does the parent have ommers.
913
914
    Returns
915
    -------
916
    difficulty : `ethereum.base_types.Uint`
917
        Computed difficulty for a block.
918
    """
919
    offset = (
920
        int(parent_difficulty)
921
        // 2048
922
        * max(
923
            (2 if parent_has_ommers else 1)
924
            - int(block_timestamp - parent_timestamp) // 9,
925
            -99,
926
        )
927
    )
928
    difficulty = int(parent_difficulty) + offset
929
    # Historical Note: The difficulty bomb was not present in Ethereum at the
930
    # start of Frontier, but was added shortly after launch. However since the
931
    # bomb has no effect prior to block 200000 we pretend it existed from
932
    # genesis.
933
    # See https://github.com/ethereum/go-ethereum/pull/1588
934
    num_bomb_periods = ((int(block_number) - BOMB_DELAY_BLOCKS) // 100000) - 2
935
    if num_bomb_periods >= 0:
936
        difficulty += 2**num_bomb_periods
937
938
    # Some clients raise the difficulty to `MINIMUM_DIFFICULTY` prior to adding
939
    # the bomb. This bug does not matter because the difficulty is always much
940
    # greater than `MINIMUM_DIFFICULTY` on Mainnet.
941
    return Uint(max(difficulty, int(MINIMUM_DIFFICULTY)))