<snip>

    return old

    <snip>

    recent_blocks = chain.blocks[-255:]

    # TODO: This function has not been tested rigorously

    if len(recent_blocks) == 0:

        return []

    recent_block_hashes = []

    for block in recent_blocks:

        prev_block_hash = block.header.parent_hash

        recent_block_hashes.append(prev_block_hash)

    # We are computing the hash only for the most recent block and not for

    # the rest of the blocks as they have successors which have the hash of

    # the current block as parent hash.

    most_recent_block_hash = keccak256(rlp.encode(recent_blocks[-1].header))

    recent_block_hashes.append(most_recent_block_hash)

    return recent_block_hashes

    <snip>

    validate_header(chain, block.header)

    validate_ommers(block.ommers, block.header, chain)

    block_state = BlockState(pre_state=chain.state)

    block_env = vm.BlockEnvironment(

        chain_id=chain.chain_id,

        state=block_state,

        block_gas_limit=block.header.gas_limit,

        block_hashes=get_last_256_block_hashes(chain),

        coinbase=block.header.coinbase,

        number=block.header.number,

        base_fee_per_gas=block.header.base_fee_per_gas,

        time=block.header.timestamp,

        difficulty=block.header.difficulty,

    )

    block_output = apply_body(

        block_env=block_env,

        transactions=block.transactions,

        ommers=block.ommers,

    )

    block_diff = extract_block_diff(block_state)

    block_state_root = chain.state.compute_state_root(block_diff)

    transactions_root = root(block_output.transactions_trie)

    receipt_root = root(block_output.receipts_trie)

    block_logs_bloom = logs_bloom(block_output.block_logs)

    if block_output.block_gas_used != block.header.gas_used:

        raise InvalidBlock(

            f"{block_output.block_gas_used} != {block.header.gas_used}"

        )

    if transactions_root != block.header.transactions_root:

        raise InvalidBlock

    if block_state_root != block.header.state_root:

        raise InvalidBlock

    if receipt_root != block.header.receipt_root:

        raise InvalidBlock

    if block_logs_bloom != block.header.bloom:

        raise InvalidBlock

    apply_changes_to_state(chain.state, block_diff)

    chain.blocks.append(block)

    if len(chain.blocks) > 255:

        # Real clients have to store more blocks to deal with reorgs, but the

        # protocol only requires the last 255

        chain.blocks = chain.blocks[-255:]

    <snip>

    parent_gas_target = parent_gas_limit // ELASTICITY_MULTIPLIER

    if not check_gas_limit(block_gas_limit, parent_gas_limit):

        raise InvalidBlock

    if parent_gas_used == parent_gas_target:

        expected_base_fee_per_gas = parent_base_fee_per_gas

    elif parent_gas_used > parent_gas_target:

        gas_used_delta = parent_gas_used - parent_gas_target

        parent_fee_gas_delta = parent_base_fee_per_gas * gas_used_delta

        target_fee_gas_delta = parent_fee_gas_delta // parent_gas_target

        base_fee_per_gas_delta = max(

            target_fee_gas_delta // BASE_FEE_MAX_CHANGE_DENOMINATOR,

            Uint(1),

        )

        expected_base_fee_per_gas = (

            parent_base_fee_per_gas + base_fee_per_gas_delta

        )

    else:

        gas_used_delta = parent_gas_target - parent_gas_used

        parent_fee_gas_delta = parent_base_fee_per_gas * gas_used_delta

        target_fee_gas_delta = parent_fee_gas_delta // parent_gas_target

        base_fee_per_gas_delta = (

            target_fee_gas_delta // BASE_FEE_MAX_CHANGE_DENOMINATOR

        )

        expected_base_fee_per_gas = (

            parent_base_fee_per_gas - base_fee_per_gas_delta

        )

    return Uint(expected_base_fee_per_gas)

    <snip>

    if header.number < Uint(1):

        raise InvalidBlock

    parent_header_number = header.number - Uint(1)

    first_block_number = chain.blocks[0].header.number

    last_block_number = chain.blocks[-1].header.number

    if (

        parent_header_number < first_block_number

        or parent_header_number > last_block_number

    ):

        raise InvalidBlock

    parent_header = chain.blocks[

        parent_header_number - first_block_number

    ].header

    if header.gas_used > header.gas_limit:

        raise InvalidBlock

    assert isinstance(FORK_CRITERIA, ByBlockNumber)

    expected_base_fee_per_gas = INITIAL_BASE_FEE

    if header.number != FORK_CRITERIA.block_number:

        # For every block except the first, calculate the base fee per gas

        # based on the parent block.

        expected_base_fee_per_gas = calculate_base_fee_per_gas(

            header.gas_limit,

            parent_header.gas_limit,

            parent_header.gas_used,

            parent_header.base_fee_per_gas,

        )

    if expected_base_fee_per_gas != header.base_fee_per_gas:

        raise InvalidBlock

    parent_has_ommers = parent_header.ommers_hash != EMPTY_OMMER_HASH

    if header.timestamp <= parent_header.timestamp:

        raise InvalidBlock

    if header.number != parent_header.number + Uint(1):

        raise InvalidBlock

    if len(header.extra_data) > 32:

        raise InvalidBlock

    block_difficulty = calculate_block_difficulty(

        header.number,

        header.timestamp,

        parent_header.timestamp,

        parent_header.difficulty,

        parent_has_ommers,

    )

    if header.difficulty != block_difficulty:

        raise InvalidBlock

    block_parent_hash = keccak256(rlp.encode(parent_header))

    if header.parent_hash != block_parent_hash:

        raise InvalidBlock

    validate_proof_of_work(header)

    <snip>

    header_data_without_pow_artefacts = (

        header.parent_hash,

        header.ommers_hash,

        header.coinbase,

        header.state_root,

        header.transactions_root,

        header.receipt_root,

        header.bloom,

        header.difficulty,

        header.number,

        header.gas_limit,

        header.gas_used,

        header.timestamp,

        header.extra_data,

        header.base_fee_per_gas,

    )

    return keccak256(rlp.encode(header_data_without_pow_artefacts))

    <snip>

    header_hash = generate_header_hash_for_pow(header)

    # TODO: Memoize this somewhere and read from that data instead of

    # calculating cache for every block validation.

    cache = generate_cache(header.number)

    mix_digest, result = hashimoto_light(

        header_hash, header.nonce, cache, dataset_size(header.number)

    )

    if mix_digest != header.mix_digest:

        raise InvalidBlock

    limit = Uint(U256.MAX_VALUE) + Uint(1)

    if Uint.from_be_bytes(result) > (limit // header.difficulty):

        raise InvalidBlock

    <snip>

    gas_available = block_env.block_gas_limit - block_output.block_gas_used

    if tx.gas > gas_available:

        raise GasUsedExceedsLimitError("gas used exceeds limit")

    tx_chain_id = chain_id(tx)

    if tx_chain_id is not None and tx_chain_id != block_env.chain_id:

        raise WrongChainIdError(

            expected=block_env.chain_id,

            actual=tx_chain_id,

        )

    sender_address = recover_sender(tx)

    sender_account = get_account(tx_state, sender_address)

    if isinstance(tx, FeeMarketTransaction):

        if tx.max_fee_per_gas < block_env.base_fee_per_gas:

            raise InsufficientMaxFeePerGasError(

                tx.max_fee_per_gas, block_env.base_fee_per_gas

            )

        priority_fee_per_gas = min(

            tx.max_priority_fee_per_gas,

            tx.max_fee_per_gas - block_env.base_fee_per_gas,

        )

        effective_gas_price = priority_fee_per_gas + block_env.base_fee_per_gas

        max_gas_fee = tx.gas * tx.max_fee_per_gas

    else:

        if tx.gas_price < block_env.base_fee_per_gas:

            raise InvalidBlock

        effective_gas_price = tx.gas_price

        max_gas_fee = tx.gas * tx.gas_price

    if sender_account.nonce > Uint(tx.nonce):

        raise NonceMismatchError("nonce too low")

    elif sender_account.nonce < Uint(tx.nonce):

        raise NonceMismatchError("nonce too high")

    if Uint(sender_account.balance) < max_gas_fee + Uint(tx.value):

        raise InsufficientBalanceError("insufficient sender balance")

    if sender_account.code_hash != EMPTY_CODE_HASH:

        raise InvalidSenderError("not EOA")

    return sender_address, effective_gas_price

    <snip>

    receipt = Receipt(

        succeeded=error is None,

        cumulative_gas_used=cumulative_gas_used,

        bloom=logs_bloom(logs),

        logs=logs,

    )

    return encode_receipt(tx, receipt)

    <snip>

    block_output = vm.BlockOutput()

    for i, tx in enumerate(map(decode_transaction, transactions)):

        process_transaction(block_env, block_output, tx, Uint(i))

    pay_rewards(block_env, ommers)

    return block_output

    <snip>

    block_hash = keccak256(rlp.encode(block_header))

    if keccak256(rlp.encode(ommers)) != block_header.ommers_hash:

        raise InvalidBlock

    if len(ommers) == 0:

        # Nothing to validate

        return

    # Check that each ommer satisfies the constraints of a header

    for ommer in ommers:

        if Uint(1) > ommer.number or ommer.number >= block_header.number:

            raise InvalidBlock

        validate_header(chain, ommer)

    if len(ommers) > 2:

        raise InvalidBlock

    ommers_hashes = [keccak256(rlp.encode(ommer)) for ommer in ommers]

    if len(ommers_hashes) != len(set(ommers_hashes)):

        raise InvalidBlock

    recent_canonical_blocks = chain.blocks[-(MAX_OMMER_DEPTH + Uint(1)) :]

    recent_canonical_block_hashes = {

        keccak256(rlp.encode(block.header))

        for block in recent_canonical_blocks

    }

    recent_ommers_hashes: Set[Hash32] = set()

    for block in recent_canonical_blocks:

        recent_ommers_hashes = recent_ommers_hashes.union(

            {keccak256(rlp.encode(ommer)) for ommer in block.ommers}

        )

    for ommer_index, ommer in enumerate(ommers):

        ommer_hash = ommers_hashes[ommer_index]

        if ommer_hash == block_hash:

            raise InvalidBlock

        if ommer_hash in recent_canonical_block_hashes:

            raise InvalidBlock

        if ommer_hash in recent_ommers_hashes:

            raise InvalidBlock

        # Ommer age with respect to the current block. For example, an age of

        # 1 indicates that the ommer is a sibling of previous block.

        ommer_age = block_header.number - ommer.number

        if Uint(1) > ommer_age or ommer_age > MAX_OMMER_DEPTH:

            raise InvalidBlock

        if ommer.parent_hash not in recent_canonical_block_hashes:

            raise InvalidBlock

        if ommer.parent_hash == block_header.parent_hash:

            raise InvalidBlock

    <snip>

    rewards_state = TransactionState(parent=block_env.state)

    ommer_count = U256(len(ommers))

    miner_reward = BLOCK_REWARD + (ommer_count * (BLOCK_REWARD // U256(32)))

    create_ether(rewards_state, block_env.coinbase, miner_reward)

    for ommer in ommers:

        # Ommer age with respect to the current block.

        ommer_age = U256(block_env.number - ommer.number)

        ommer_miner_reward = ((U256(8) - ommer_age) * BLOCK_REWARD) // U256(8)

        create_ether(rewards_state, ommer.coinbase, ommer_miner_reward)

    incorporate_tx_into_block(rewards_state)

    <snip>

    tx_state = TransactionState(parent=block_env.state)

    trie_set(

        block_output.transactions_trie,

        rlp.encode(index),

        encode_transaction(tx),

    )

    intrinsic_gas = validate_transaction(tx)

    (

        sender,

        effective_gas_price,

    ) = check_transaction(

        block_env=block_env,

        block_output=block_output,

        tx=tx,

        tx_state=tx_state,

    )

    sender_account = get_account(tx_state, sender)

    effective_gas_fee = tx.gas * effective_gas_price

    gas = tx.gas - intrinsic_gas

    increment_nonce(tx_state, sender)

    sender_balance_after_gas_fee = (

        Uint(sender_account.balance) - effective_gas_fee

    )

    set_account_balance(tx_state, sender, U256(sender_balance_after_gas_fee))

    access_list_addresses = set()

    access_list_storage_keys = set()

    if isinstance(tx, (AccessListTransaction, FeeMarketTransaction)):

        for access in tx.access_list:

            access_list_addresses.add(access.account)

            for slot in access.slots:

                access_list_storage_keys.add((access.account, slot))

    tx_env = vm.TransactionEnvironment(

        origin=sender,

        gas_price=effective_gas_price,

        gas=gas,

        access_list_addresses=access_list_addresses,

        access_list_storage_keys=access_list_storage_keys,

        state=tx_state,

        index_in_block=index,

        tx_hash=get_transaction_hash(encode_transaction(tx)),

    )

    message = prepare_message(block_env, tx_env, tx)

    tx_output = process_message_call(message)

    tx_gas_used_before_refund = tx.gas - tx_output.gas_left

    tx_gas_refund = min(

        tx_gas_used_before_refund // Uint(5), Uint(tx_output.refund_counter)

    )

    tx_gas_used_after_refund = tx_gas_used_before_refund - tx_gas_refund

    tx_gas_left = tx.gas - tx_gas_used_after_refund

    gas_refund_amount = tx_gas_left * effective_gas_price

    # For non-1559 transactions effective_gas_price == tx.gas_price

    priority_fee_per_gas = effective_gas_price - block_env.base_fee_per_gas

    transaction_fee = tx_gas_used_after_refund * priority_fee_per_gas

    # refund gas

    create_ether(tx_state, sender, U256(gas_refund_amount))

    # transfer miner fees

    coinbase_balance_after_mining_fee = get_account(

        tx_state, block_env.coinbase

    ).balance + U256(transaction_fee)

    if coinbase_balance_after_mining_fee != 0:

        set_account_balance(

            tx_state,

            block_env.coinbase,

            coinbase_balance_after_mining_fee,

        )

    elif account_exists_and_is_empty(tx_state, block_env.coinbase):

        destroy_account(tx_state, block_env.coinbase)

    for address in tx_output.accounts_to_delete:

        destroy_account(tx_state, address)

    destroy_touched_empty_accounts(tx_state, tx_output.touched_accounts)

    block_output.block_gas_used += tx_gas_used_after_refund

    receipt = make_receipt(

        tx, tx_output.error, block_output.block_gas_used, tx_output.logs

    )

    receipt_key = rlp.encode(Uint(index))

    block_output.receipt_keys += (receipt_key,)

    trie_set(

        block_output.receipts_trie,

        receipt_key,

        receipt,

    )

    block_output.block_logs += tx_output.logs

    incorporate_tx_into_block(tx_state)

    <snip>

    max_adjustment_delta = parent_gas_limit // GasCosts.LIMIT_ADJUSTMENT_FACTOR

    if gas_limit >= parent_gas_limit + max_adjustment_delta:

        return False

    if gas_limit <= parent_gas_limit - max_adjustment_delta:

        return False

    if gas_limit < GasCosts.LIMIT_MINIMUM:

        return False

    return True

    <snip>

    offset = (

        int(parent_difficulty)

        // 2048

        * max(

            (2 if parent_has_ommers else 1)

            - int(block_timestamp - parent_timestamp) // 9,

            -99,

        )

    )

    difficulty = int(parent_difficulty) + offset

    # Historical Note: The difficulty bomb was not present in Ethereum at the

    # start of Frontier, but was added shortly after launch. However since the

    # bomb has no effect prior to block 200000 we pretend it existed from

    # genesis.

    # See https://github.com/ethereum/go-ethereum/pull/1588

    num_bomb_periods = ((int(block_number) - BOMB_DELAY_BLOCKS) // 100000) - 2

    if num_bomb_periods >= 0:

        difficulty += 2**num_bomb_periods

    # Some clients raise the difficulty to `MINIMUM_DIFFICULTY` prior to adding

    # the bomb. This bug does not matter because the difficulty is always much

    # greater than `MINIMUM_DIFFICULTY` on Mainnet.

    return Uint(max(difficulty, int(MINIMUM_DIFFICULTY)))