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

    chain_context = ChainContext(

        chain_id=chain.chain_id,

        block_hashes=get_last_256_block_hashes(chain),

        parent_header=chain.blocks[-1].header,

    )

    block_diff = execute_block(block, chain.state, chain_context)

    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>

    if len(rlp.encode(block)) > MAX_RLP_BLOCK_SIZE:

        raise InvalidBlock("Block rlp size exceeds MAX_RLP_BLOCK_SIZE")

    parent_header = chain_context.parent_header

    validate_header(parent_header, block.header)

    if block.ommers != ():

        raise InvalidBlock

    block_state = BlockState(pre_state=pre_state)

    block_env = vm.BlockEnvironment(

        chain_id=chain_context.chain_id,

        state=block_state,

        block_gas_limit=block.header.gas_limit,

        block_hashes=chain_context.block_hashes,

        coinbase=block.header.coinbase,

        number=block.header.number,

        base_fee_per_gas=block.header.base_fee_per_gas,

        time=block.header.timestamp,

        prev_randao=block.header.prev_randao,

        excess_blob_gas=block.header.excess_blob_gas,

        parent_beacon_block_root=block.header.parent_beacon_block_root,

        block_access_list_builder=BlockAccessListBuilder(),

        slot_number=block.header.slot_number,

    )

    block_output = apply_body(

        block_env=block_env,

        transactions=block.transactions,

        withdrawals=block.withdrawals,

    )

    block_diff = extract_block_diff(block_state)

    block_state_root, _ = pre_state.compute_state_root_and_trie_changes(

        block_diff.account_changes, block_diff.storage_changes

    )

    transactions_root = root(block_output.transactions_trie)

    receipt_root = root(block_output.receipts_trie)

    block_logs_bloom = logs_bloom(block_output.block_logs)

    withdrawals_root = root(block_output.withdrawals_trie)

    requests_hash = compute_requests_hash(block_output.requests)

    computed_block_access_list_hash = hash_block_access_list(

        block_output.block_access_list

    )

    block_gas_used = max(

        block_output.block_gas_used,

        block_output.block_state_gas_used,

    )

    if block_gas_used != block.header.gas_used:

        raise InvalidBlock(f"{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

    if withdrawals_root != block.header.withdrawals_root:

        raise InvalidBlock

    if block_output.blob_gas_used != block.header.blob_gas_used:

        raise InvalidBlock

    if requests_hash != block.header.requests_hash:

        raise InvalidBlock

    if computed_block_access_list_hash != block.header.block_access_list_hash:

        raise InvalidBlock("Invalid block access list hash")

    return block_diff

    <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

    excess_blob_gas = calculate_excess_blob_gas(parent_header)

    if header.excess_blob_gas != excess_blob_gas:

        raise InvalidBlock

    if header.gas_used > header.gas_limit:

        raise InvalidBlock

    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

    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

    if header.difficulty != 0:

        raise InvalidBlock

    if header.nonce != b"\x00\x00\x00\x00\x00\x00\x00\x00":

        raise InvalidBlock

    if header.ommers_hash != EMPTY_OMMER_HASH:

        raise InvalidBlock

    block_parent_hash = keccak256(rlp.encode(parent_header))

    if header.parent_hash != block_parent_hash:

        raise InvalidBlock

    <snip>

    regular_gas_available = (

        block_env.block_gas_limit - block_output.block_gas_used

    )

    state_gas_available = (

        block_env.block_gas_limit - block_output.block_state_gas_used

    )

    blob_gas_available = MAX_BLOB_GAS_PER_BLOCK - block_output.blob_gas_used

    # EIP-8037 per-dimension inclusion check.

    if min(TX_MAX_GAS_LIMIT, tx.gas) > regular_gas_available:

        raise GasUsedExceedsLimitError("regular gas used exceeds limit")

    if tx.gas > state_gas_available:

        raise GasUsedExceedsLimitError("state gas used exceeds limit")

    tx_blob_gas_used = calculate_total_blob_gas(tx)

    if tx_blob_gas_used > blob_gas_available:

        raise BlobGasLimitExceededError("blob gas limit exceeded")

    sender_account = get_account(tx_state, sender)

    if isinstance(tx, FeeMarketCapableTransaction):

        if tx.max_fee_per_gas < tx.max_priority_fee_per_gas:

            raise PriorityFeeGreaterThanMaxFeeError(

                "priority fee greater than max fee"

            )

        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 isinstance(tx, BlobTransaction):

        blob_count = len(tx.blob_versioned_hashes)

        if blob_count == 0:

            raise NoBlobDataError("no blob data in transaction")

        if blob_count > BLOB_COUNT_LIMIT:

            raise BlobCountExceededError(

                f"Tx has {blob_count} blobs. Max allowed: {BLOB_COUNT_LIMIT}"

            )

        for blob_versioned_hash in tx.blob_versioned_hashes:

            if blob_versioned_hash[0:1] != VERSIONED_HASH_VERSION_KZG:

                raise InvalidBlobVersionedHashError(

                    "invalid blob versioned hash"

                )

        blob_gas_price = calculate_blob_gas_price(block_env.excess_blob_gas)

        if Uint(tx.max_fee_per_blob_gas) < blob_gas_price:

            raise InsufficientMaxFeePerBlobGasError(

                "insufficient max fee per blob gas"

            )

        max_gas_fee += Uint(calculate_total_blob_gas(tx)) * Uint(

            tx.max_fee_per_blob_gas

        )

        blob_versioned_hashes = tx.blob_versioned_hashes

    else:

        blob_versioned_hashes = ()

    if isinstance(tx, (BlobTransaction, SetCodeTransaction)):

        if not isinstance(tx.to, Address):

            raise TransactionTypeContractCreationError(tx)

    if isinstance(tx, SetCodeTransaction):

        if not any(tx.authorizations):

            raise EmptyAuthorizationListError("empty authorization list")

    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")

    sender_code = get_code(tx_state, sender_account.code_hash)

    if sender_account.code_hash != EMPTY_CODE_HASH and not is_valid_delegation(

        sender_code

    ):

        raise InvalidSenderError("not EOA")

    return (

        effective_gas_price,

        blob_versioned_hashes,

        tx_blob_gas_used,

    )

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

    # Pre-check that the system contract has code. We use a throwaway

    # TransactionState here that is *never* propagated back to BlockState

    # (no incorporate_tx_into_block call); the same get_account / get_code

    # lookups are performed and properly tracked by

    # process_unchecked_system_transaction below, which this function

    # always calls. Reading via a TransactionState (rather than directly

    # against pre_state) lets us see system contracts deployed earlier in

    # the same block — see EIP-7002 and EIP-7251 for this edge case.

    untracked_state = TransactionState(parent=block_env.state)

    system_contract_code = get_code(

        untracked_state,

        get_account(untracked_state, target_address).code_hash,

    )

    if len(system_contract_code) == 0:

        raise InvalidBlock(

            f"System contract address {target_address.hex()} does not "

            "contain code"

        )

    system_tx_output = process_unchecked_system_transaction(

        block_env,

        target_address,

        data,

    )

    if system_tx_output.error:

        raise InvalidBlock(

            f"System contract ({target_address.hex()}) call failed: "

            f"{system_tx_output.error}"

        )

    return system_tx_output

    <snip>

    system_tx_state = TransactionState(parent=block_env.state)

    system_contract_code = get_code(

        system_tx_state,

        get_account(system_tx_state, target_address).code_hash,

    )

    tx_env = vm.TransactionEnvironment(

        origin=SYSTEM_ADDRESS,

        recipient=target_address,

        value=U256(0),

        gas_price=block_env.base_fee_per_gas,

        gas=SYSTEM_TRANSACTION_GAS,

        state_gas_reservoir=(

            StateGasCosts.STORAGE_SET * SYSTEM_MAX_SSTORES_PER_CALL

        ),

        access_list_addresses=set(),

        access_list_storage_keys=set(),

        state=system_tx_state,

        blob_versioned_hashes=(),

        authorizations=(),

        index_in_block=None,

        tx_hash=None,

    )

    system_tx_message = Message(

        block_env=block_env,

        tx_env=tx_env,

        caller=SYSTEM_ADDRESS,

        target=target_address,

        gas=SYSTEM_TRANSACTION_GAS,

        state_gas_reservoir=(

            StateGasCosts.STORAGE_SET * SYSTEM_MAX_SSTORES_PER_CALL

        ),

        value=U256(0),

        data=data,

        code=system_contract_code,

        depth=Uint(0),

        current_target=target_address,

        code_address=target_address,

        should_transfer_value=False,

        is_static=False,

        accessed_addresses=set(),

        accessed_storage_keys=set(),

        disable_precompiles=False,

        parent_evm=None,

    )

    system_tx_output = process_message_call(system_tx_message)

    incorporate_tx_into_block(

        system_tx_state, block_env.block_access_list_builder

    )

    return system_tx_output

    <snip>

    block_output = vm.BlockOutput()

    process_unchecked_system_transaction(

        block_env=block_env,

        target_address=BEACON_ROOTS_ADDRESS,

        data=block_env.parent_beacon_block_root,

    )

    process_unchecked_system_transaction(

        block_env=block_env,

        target_address=HISTORY_STORAGE_ADDRESS,

        data=block_env.block_hashes[-1],  # The parent hash

    )

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

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

    # EIP-7928: Post-execution operations use index N+1

    block_env.block_access_list_builder.block_access_index = BlockAccessIndex(

        ulen(transactions) + Uint(1)

    )

    process_withdrawals(block_env, block_output, withdrawals)

    process_general_purpose_requests(

        block_env=block_env,

        block_output=block_output,

    )

    block_output.block_access_list = build_block_access_list(

        block_env.block_access_list_builder, block_env.state

    )

    # Validate block access list gas limit constraint (EIP-7928)

    validate_block_access_list_gas_limit(

        block_access_list=block_output.block_access_list,

        block_gas_limit=block_env.block_gas_limit,

    )

    return block_output

    <snip>

    # Requests are to be in ascending order of request type

    deposit_requests = parse_deposit_requests(block_output)

    requests_from_execution = block_output.requests

    if len(deposit_requests) > 0:

        requests_from_execution.append(DEPOSIT_REQUEST_TYPE + deposit_requests)

    system_withdrawal_tx_output = process_checked_system_transaction(

        block_env=block_env,

        target_address=WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS,

        data=b"",

    )

    if len(system_withdrawal_tx_output.return_data) > 0:

        requests_from_execution.append(

            WITHDRAWAL_REQUEST_TYPE + system_withdrawal_tx_output.return_data

        )

    system_consolidation_tx_output = process_checked_system_transaction(

        block_env=block_env,

        target_address=CONSOLIDATION_REQUEST_PREDEPLOY_ADDRESS,

        data=b"",

    )

    if len(system_consolidation_tx_output.return_data) > 0:

        requests_from_execution.append(

            CONSOLIDATION_REQUEST_TYPE

            + system_consolidation_tx_output.return_data

        )

    system_builder_deposit_tx_output = process_checked_system_transaction(

        block_env=block_env,

        target_address=BUILDER_DEPOSIT_CONTRACT_ADDRESS,

        data=b"",

    )

    if len(system_builder_deposit_tx_output.return_data) > 0:

        requests_from_execution.append(

            BUILDER_DEPOSIT_REQUEST_TYPE

            + system_builder_deposit_tx_output.return_data