"""

    Strip the Solidity ABI framing from a `DepositEvent` payload and return

    the concatenated raw fields in the order consumed by the consensus

    layer: public key, withdrawal credentials, amount, signature, and

    deposit index.

    Because each field has a fixed length, every well-formed event has an

    identical byte layout. Any deviation indicates a misbehaving or

    compromised deposit contract, so this function raises [`InvalidBlock`]

    rather than silently accepting unexpected data.

    [`InvalidBlock`]: ref:ethereum.exceptions.InvalidBlock

    """

    if ulen(data) != DEPOSIT_EVENT_LENGTH:

        raise InvalidBlock("Invalid deposit event data length")

    # Check that all the offsets are in order

    pubkey_offset = Uint.from_be_bytes(data[0:32])

    if pubkey_offset != PUBKEY_OFFSET:

        raise InvalidBlock("Invalid pubkey offset in deposit log")

    withdrawal_credentials_offset = Uint.from_be_bytes(data[32:64])

    if withdrawal_credentials_offset != WITHDRAWAL_CREDENTIALS_OFFSET:

        raise InvalidBlock(

            "Invalid withdrawal credentials offset in deposit log"

        )

    amount_offset = Uint.from_be_bytes(data[64:96])

    if amount_offset != AMOUNT_OFFSET:

        raise InvalidBlock("Invalid amount offset in deposit log")

    signature_offset = Uint.from_be_bytes(data[96:128])

    if signature_offset != SIGNATURE_OFFSET:

        raise InvalidBlock("Invalid signature offset in deposit log")

    index_offset = Uint.from_be_bytes(data[128:160])

    if index_offset != INDEX_OFFSET:

        raise InvalidBlock("Invalid index offset in deposit log")

    # Check that all the sizes are in order

    pubkey_size = Uint.from_be_bytes(

        data[pubkey_offset : pubkey_offset + Uint(32)]

    )

    if pubkey_size != PUBKEY_SIZE:

        raise InvalidBlock("Invalid pubkey size in deposit log")

    pubkey = data[

        pubkey_offset + Uint(32) : pubkey_offset + Uint(32) + PUBKEY_SIZE

    ]

    withdrawal_credentials_size = Uint.from_be_bytes(

        data[

            withdrawal_credentials_offset : withdrawal_credentials_offset

            + Uint(32)

        ],

    )

    if withdrawal_credentials_size != WITHDRAWAL_CREDENTIALS_SIZE:

        raise InvalidBlock(

            "Invalid withdrawal credentials size in deposit log"

        )

    withdrawal_credentials = data[

        withdrawal_credentials_offset

        + Uint(32) : withdrawal_credentials_offset

        + Uint(32)

        + WITHDRAWAL_CREDENTIALS_SIZE

    ]

    amount_size = Uint.from_be_bytes(

        data[amount_offset : amount_offset + Uint(32)]

    )

    if amount_size != AMOUNT_SIZE:

        raise InvalidBlock("Invalid amount size in deposit log")

    amount = data[

        amount_offset + Uint(32) : amount_offset + Uint(32) + AMOUNT_SIZE

    ]

    signature_size = Uint.from_be_bytes(

        data[signature_offset : signature_offset + Uint(32)]

    )

    if signature_size != SIGNATURE_SIZE:

        raise InvalidBlock("Invalid signature size in deposit log")

    signature = data[

        signature_offset + Uint(32) : signature_offset

        + Uint(32)

        + SIGNATURE_SIZE

    ]

    index_size = Uint.from_be_bytes(

        data[index_offset : index_offset + Uint(32)]

    )

    if index_size != INDEX_SIZE:

        raise InvalidBlock("Invalid index size in deposit log")

    index = data[

        index_offset + Uint(32) : index_offset + Uint(32) + INDEX_SIZE

    ]

    return pubkey + withdrawal_credentials + amount + signature + index

    """

    Walk the receipts produced during block execution, concatenating the

    raw payload of every valid deposit event into a single byte string.

    A log is considered a deposit when it originates from

    [`DEPOSIT_CONTRACT_ADDRESS`][addr] and its first topic matches

    [`DEPOSIT_EVENT_SIGNATURE_HASH`][sig]. The returned bytes are the

    direct concatenation of the unframed deposit fields, ready to be

    prefixed with [`DEPOSIT_REQUEST_TYPE`][dt] before being appended to

    the block's request list.

    [addr]: ref:ethereum.forks.bpo1.requests.DEPOSIT_CONTRACT_ADDRESS

    [sig]: ref:ethereum.forks.bpo1.requests.DEPOSIT_EVENT_SIGNATURE_HASH

    [dt]: ref:ethereum.forks.bpo1.requests.DEPOSIT_REQUEST_TYPE

    """

    deposit_requests: Bytes = b""

    for key in block_output.receipt_keys:

        receipt = trie_get(block_output.receipts_trie, key)

        assert receipt is not None

        decoded_receipt = decode_receipt(receipt)

        for log in decoded_receipt.logs:

            if log.address == DEPOSIT_CONTRACT_ADDRESS:

                if (

                    len(log.topics) > 0

                    and log.topics[0] == DEPOSIT_EVENT_SIGNATURE_HASH

                ):

                    request = extract_deposit_data(log.data)

                    deposit_requests += request

    return deposit_requests

    """

    Compute the [SHA2-256] commitment over an ordered list of

    type-prefixed requests, as defined by [EIP-7685].

    The commitment is the SHA2-256 hash of the concatenation of the

    SHA2-256 hashes of each individual request. This is what the

    execution header's [`requests_hash`][rh] stores, and what the

    consensus layer re-derives to validate that both layers observed the

    same set of requests.

    [EIP-7685]: https://eips.ethereum.org/EIPS/eip-7685

    [SHA2-256]: https://en.wikipedia.org/wiki/SHA-2

    [rh]: ref:ethereum.forks.bpo1.blocks.Header.requests_hash

    """

    m = sha256()

    for request in requests:

        m.update(sha256(request).digest())

    return m.digest()