"""

    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.

    """

    return old

    """

    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.

    """

    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

    """

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

    """

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

        raise InvalidBlock("Block rlp size exceeds MAX_RLP_BLOCK_SIZE")

    validate_header(chain, block.header)

    if block.ommers != ():

        raise InvalidBlock

    block_env = vm.BlockEnvironment(

        chain_id=chain.chain_id,

        state=chain.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,

        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_output = apply_body(

        block_env=block_env,

        transactions=block.transactions,

        withdrawals=block.withdrawals,

    )

    block_state_root = state_root(block_env.state)

    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)

    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

    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

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

    """

    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.

    """

    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)

    """

    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.

    """

    if header.number < Uint(1):

        raise InvalidBlock

    parent_header = chain.blocks[-1].header

    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

    """

    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.

    blob_versioned_hashes :

        The blob versioned hashes of the transaction.

    tx_blob_gas_used:

        The blob gas used by the transaction.

    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 :

        If the priority fee is greater than the maximum fee per gas.

    InsufficientMaxFeePerGasError :

        If the maximum fee per gas is insufficient for the transaction.

    InsufficientMaxFeePerBlobGasError :

        If the maximum fee per blob gas is insufficient for the transaction.

    BlobGasLimitExceededError :

        If the blob gas used by the transaction exceeds the block's blob gas

        limit.

    InvalidBlobVersionedHashError :

        If the transaction contains a blob versioned hash with an invalid

        version.

    NoBlobDataError :

        If the transaction is a type 3 but has no blobs.

    BlobCountExceededError :

        If the transaction is a type 3 and has more blobs than the limit.

    TransactionTypeContractCreationError:

        If the transaction type is not allowed to create contracts.

    EmptyAuthorizationListError :

        If the transaction is a SetCodeTransaction and the authorization list

        is empty.

    """

    gas_available = block_env.block_gas_limit - block_output.block_gas_used

    blob_gas_available = MAX_BLOB_GAS_PER_BLOCK - block_output.blob_gas_used

    if tx.gas > gas_available:

        raise GasUsedExceedsLimitError("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_address = recover_sender(block_env.chain_id, tx)

    sender_account = get_account(block_env.state, sender_address)

    if isinstance(

        tx, (FeeMarketTransaction, BlobTransaction, SetCodeTransaction)

    ):

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

    if sender_account.code and not is_valid_delegation(sender_account.code):

        raise InvalidSenderError("not EOA")

    return (

        sender_address,

        effective_gas_price,

        blob_versioned_hashes,

        tx_blob_gas_used,

    )

    """

    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.

    """

    receipt = Receipt(

        succeeded=error is None,

        cumulative_gas_used=cumulative_gas_used,

        bloom=logs_bloom(logs),

        logs=logs,

    )

    return encode_receipt(tx, receipt)

    """

    Process a system transaction with the given code.

    Prefer calling `process_checked_system_transaction` or

    `process_unchecked_system_transaction` depending on whether missing code or

    an execution error should cause the block to be rejected.

    Parameters

    ----------

    block_env :

        The block scoped environment.

    target_address :

        Address of the contract to call.

    system_contract_code :

        Code of the contract to call.

    data :

        Data to pass to the contract.

    Returns

    -------

    system_tx_output : `MessageCallOutput`

        Output of processing the system transaction.

    """

    tx_env = vm.TransactionEnvironment(

        origin=SYSTEM_ADDRESS,

        gas_price=block_env.base_fee_per_gas,

        gas=SYSTEM_TRANSACTION_GAS,

        access_list_addresses=set(),

        access_list_storage_keys=set(),

        transient_storage=TransientStorage(),

        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,

        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)

    return system_tx_output

    """

    Process a system transaction and raise an error if the contract does not

    contain code or if the transaction fails.

    Parameters

    ----------

    block_env :

        The block scoped environment.

    target_address :

        Address of the contract to call.

    data :

        Data to pass to the contract.

    Returns

    -------

    system_tx_output : `MessageCallOutput`

        Output of processing the system transaction.

    """

    system_contract_code = get_account(block_env.state, target_address).code

    if len(system_contract_code) == 0:

        raise InvalidBlock(

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

            "contain code"

        )

    system_tx_output = process_system_transaction(

        block_env,

        target_address,

        system_contract_code,

        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

    """

    Process a system transaction without checking if the contract contains code

    or if the transaction fails.

    Parameters

    ----------

    block_env :

        The block scoped environment.

    target_address :

        Address of the contract to call.

    data :

        Data to pass to the contract.

    Returns

    -------

    system_tx_output : `MessageCallOutput`

        Output of processing the system transaction.

    """

    system_contract_code = get_account(block_env.state, target_address).code

    return process_system_transaction(

        block_env,

        target_address,

        system_contract_code,

        data,

    )

    """

    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.

    withdrawals :

        Withdrawals to be processed in the current block.

    Returns

    -------

    block_output :

        The block output for the current block.

    """

    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

    )