"""

    Encode a transaction into its RLP or typed transaction format.

    Needed because non-legacy transactions aren't RLP.

    Legacy transactions are returned as-is, while other transaction types

    are prefixed with their type identifier and RLP encoded.

    """

    if isinstance(tx, LegacyTransaction):

        return tx

    elif isinstance(tx, AccessListTransaction):

        return b"\x01" + rlp.encode(tx)

    elif isinstance(tx, FeeMarketTransaction):

        return b"\x02" + rlp.encode(tx)

    elif isinstance(tx, BlobTransaction):

        return b"\x03" + rlp.encode(tx)

    elif isinstance(tx, SetCodeTransaction):

        return b"\x04" + rlp.encode(tx)

    else:

        raise Exception(f"Unable to encode transaction of type {type(tx)}")

    """

    Decode a transaction from its RLP or typed transaction format.

    Needed because non-legacy transactions aren't RLP.

    Accept a ``LegacyTransaction`` object (returned as-is) or raw

    bytes.

    EIP-2718 states that the first byte distinguishes the format:

    [0x00, 0x7f] is a typed transaction, [0xc0, 0xfe] is a legacy

    transaction (RLP list prefix).

    """

    if isinstance(tx, Bytes):

        if tx[0] == 1:

            return rlp.decode_to(AccessListTransaction, tx[1:])

        elif tx[0] == 2:

            return rlp.decode_to(FeeMarketTransaction, tx[1:])

        elif tx[0] == 3:

            return rlp.decode_to(BlobTransaction, tx[1:])

        elif tx[0] == 4:

            return rlp.decode_to(SetCodeTransaction, tx[1:])

        elif tx[0] >= 0xC0:

            assert tx[0] <= 0xFE

            return rlp.decode_to(LegacyTransaction, tx)

        else:

            raise TransactionTypeError(tx[0])

    else:

        return tx

    """

    Verifies a transaction.

    The gas in a transaction gets used to pay for the intrinsic cost of

    operations, therefore if there is insufficient gas then it would not

    be possible to execute a transaction and it will be declared invalid.

    Additionally, the nonce of a transaction must not equal or exceed the

    limit defined in [EIP-2681].

    In practice, defining the limit as ``2**64-1`` has no impact because

    sending ``2**64-1`` transactions is improbable. It's not strictly

    impossible though, ``2**64-1`` transactions is the entire capacity of the

    Ethereum blockchain at 2022 gas limits for a little over 22 years.

    Also, the code size of a contract creation transaction must be within

    limits of the protocol.

    This function takes a transaction and gas_limit as parameters and

    returns the intrinsic gas costs for the transaction after validation.

    It throws an `InsufficientTransactionGasError` exception if the

    transaction does not provide enough gas to cover the intrinsic cost,

    and a `NonceOverflowError` exception if the nonce overflows.

    It also raises an `InitCodeTooLargeError` if the code

    size of a contract creation transaction exceeds the maximum allowed

    size.

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

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

    """

    from .vm.interpreter import MAX_INIT_CODE_SIZE

    intrinsic = calculate_intrinsic_cost(tx)

    intrinsic_gas = intrinsic.regular + intrinsic.state

    if max(intrinsic_gas, intrinsic.calldata_floor) > tx.gas:

        raise InsufficientTransactionGasError("Insufficient gas")

    if max(intrinsic.regular, intrinsic.calldata_floor) > TX_MAX_GAS_LIMIT:

        raise InsufficientTransactionGasError(

            "Intrinsic regular gas or calldata floor exceeds TX_MAX_GAS_LIMIT"

        )

    if U256(tx.nonce) >= U256(U64.MAX_VALUE):

        raise NonceOverflowError("Nonce too high")

    if tx.to == Bytes0(b"") and len(tx.data) > MAX_INIT_CODE_SIZE:

        raise InitCodeTooLargeError("Code size too large")

    return intrinsic

    """

    Calculates the gas that is charged before execution is started.

    The intrinsic cost of the transaction is charged before execution has

    begun. Functions/operations in the EVM cost money to execute so this

    intrinsic cost is for the operations that need to be paid for as part of

    the transaction. Data transfer, for example, is part of this intrinsic

    cost. It costs ether to send data over the wire and that ether is

    accounted for in the intrinsic cost calculated in this function. This

    intrinsic cost must be calculated and paid for before execution in order

    for all operations to be implemented.

    The intrinsic cost includes:

    1. Base cost (`TX_BASE`)

    2. Cost for data (zero and non-zero bytes)

    3. Cost for contract creation (if applicable)

    4. Cost for access list entries (if applicable)

    5. Cost for authorizations (if applicable)

    This function takes a transaction as a parameter and returns the

    intrinsic regular gas cost, intrinsic state gas cost, and the minimum

    gas cost used by the transaction based on the calldata size.

    """

    from .vm.gas import (

        GasCosts,

        StateCosts,

        init_code_cost,

    )

    tokens_in_calldata = count_tokens_in_data(tx.data)

    data_cost = tokens_in_calldata * GasCosts.TX_DATA_TOKEN_STANDARD

    create_regular_gas = Uint(0)

    create_state_gas = Uint(0)

    if tx.to == Bytes0(b""):

        create_state_gas = StateCosts.NEW_ACCOUNT * StateCosts.PER_BYTE

        create_regular_gas = GasCosts.TX_CREATE + init_code_cost(ulen(tx.data))

    access_list_gas = Uint(0)

    tokens_in_access_list = Uint(0)

    if has_access_list(tx):

        for access in tx.access_list:

            access_list_gas += GasCosts.TX_ACCESS_LIST_ADDRESS

            access_list_gas += (

                ulen(access.slots) * GasCosts.TX_ACCESS_LIST_STORAGE_KEY

            )

            tokens_in_access_list += ACCESS_LIST_ADDRESS_FLOOR_TOKENS

            tokens_in_access_list += (

                ulen(access.slots) * ACCESS_LIST_STORAGE_KEY_FLOOR_TOKENS

            )

    # Data token floor cost for access list bytes.

    access_list_gas += tokens_in_access_list * GasCosts.TX_DATA_TOKEN_FLOOR

    auth_regular_gas = Uint(0)

    auth_state_gas = Uint(0)

    if isinstance(tx, SetCodeTransaction):

        auth_regular_gas = GasCosts.PER_AUTH_BASE_COST * ulen(

            tx.authorizations

        )

        auth_state_gas = (

            (StateCosts.NEW_ACCOUNT + StateCosts.AUTH_BASE)

            * StateCosts.PER_BYTE

            * ulen(tx.authorizations)

        )

    # EIP-7976 floor tokens: all calldata bytes count uniformly.

    floor_tokens_in_calldata = ulen(tx.data) * GasCosts.TX_DATA_TOKEN_STANDARD

    # Total floor tokens.

    total_floor_tokens = floor_tokens_in_calldata + tokens_in_access_list

    # Floor gas cost (EIP-7623: minimum gas for data-heavy transactions).

    data_floor_gas_cost = (

        total_floor_tokens * GasCosts.TX_DATA_TOKEN_FLOOR + GasCosts.TX_BASE

    )

    intrinsic_regular_gas = (

        GasCosts.TX_BASE

        + data_cost

        + create_regular_gas

        + access_list_gas

        + auth_regular_gas

    )

    intrinsic_state_gas = create_state_gas + auth_state_gas

    return IntrinsicGasCost(

        regular=intrinsic_regular_gas,

        state=intrinsic_state_gas,

        calldata_floor=data_floor_gas_cost,

    )

    """

    Count the data tokens in arbitrary input bytes.

    Zero bytes count as 1 token; non-zero bytes count as 4 tokens.

    """

    num_zeros = Uint(data.count(0))

    num_non_zeros = ulen(data) - num_zeros

    return num_zeros + num_non_zeros * Uint(4)

    """

    Extracts the sender address from a transaction.

    The v, r, and s values are the three parts that make up the signature

    of a transaction. In order to recover the sender of a transaction the two

    components needed are the signature (``v``, ``r``, and ``s``) and the

    signing hash of the transaction. The sender's public key can be obtained

    with these two values and therefore the sender address can be retrieved.

    This function takes chain_id and a transaction as parameters and returns

    the address of the sender of the transaction. It raises an

    `InvalidSignatureError` if the signature values (r, s, v) are invalid.

    """

    r, s = tx.r, tx.s

    if U256(0) >= r or r >= SECP256K1N:

        raise InvalidSignatureError("bad r")

    if U256(0) >= s or s > SECP256K1N // U256(2):

        raise InvalidSignatureError("bad s")

    if isinstance(tx, LegacyTransaction):

        v = tx.v

        if v == 27 or v == 28:

            public_key = secp256k1_recover(

                r, s, v - U256(27), signing_hash_pre155(tx)

            )

        else:

            chain_id_x2 = U256(chain_id) * U256(2)

            if v != U256(35) + chain_id_x2 and v != U256(36) + chain_id_x2:

                raise InvalidSignatureError("bad v")

            public_key = secp256k1_recover(

                r,

                s,

                v - U256(35) - chain_id_x2,

                signing_hash_155(tx, chain_id),

            )

    elif isinstance(tx, AccessListTransaction):

        if tx.y_parity not in (U256(0), U256(1)):

            raise InvalidSignatureError("bad y_parity")

        public_key = secp256k1_recover(

            r, s, tx.y_parity, signing_hash_2930(tx)

        )

    elif isinstance(tx, FeeMarketTransaction):

        if tx.y_parity not in (U256(0), U256(1)):

            raise InvalidSignatureError("bad y_parity")

        public_key = secp256k1_recover(

            r, s, tx.y_parity, signing_hash_1559(tx)

        )

    elif isinstance(tx, BlobTransaction):

        if tx.y_parity not in (U256(0), U256(1)):

            raise InvalidSignatureError("bad y_parity")

        public_key = secp256k1_recover(

            r, s, tx.y_parity, signing_hash_4844(tx)

        )

    elif isinstance(tx, SetCodeTransaction):

        if tx.y_parity not in (U256(0), U256(1)):

            raise InvalidSignatureError("bad y_parity")

        public_key = secp256k1_recover(

            r, s, tx.y_parity, signing_hash_7702(tx)

        )

    return Address(keccak256(public_key)[12:32])

    """

    Compute the hash of a transaction used in a legacy (pre [EIP-155])

    signature.

    This function takes a legacy transaction as a parameter and returns the

    signing hash of the transaction.

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

    """

    return keccak256(

        rlp.encode(

            (

                tx.nonce,

                tx.gas_price,

                tx.gas,

                tx.to,

                tx.value,

                tx.data,

            )

        )

    )

    """

    Compute the hash of a transaction used in a [EIP-155] signature.

    This function takes a legacy transaction and a chain ID as parameters

    and returns the hash of the transaction used in an [EIP-155] signature.

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

    """

    return keccak256(

        rlp.encode(

            (

                tx.nonce,

                tx.gas_price,

                tx.gas,

                tx.to,

                tx.value,

                tx.data,

                chain_id,

                Uint(0),

                Uint(0),

            )

        )

    )

    """

    Compute the hash of a transaction used in a [EIP-2930] signature.

    This function takes an access list transaction as a parameter

    and returns the hash of the transaction used in an [EIP-2930] signature.

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

    """

    return keccak256(

        b"\x01"

        + rlp.encode(

            (

                tx.chain_id,

                tx.nonce,

                tx.gas_price,

                tx.gas,

                tx.to,

                tx.value,

                tx.data,

                tx.access_list,

            )

        )

    )

    """

    Compute the hash of a transaction used in an [EIP-1559] signature.

    This function takes a fee market transaction as a parameter

    and returns the hash of the transaction used in an [EIP-1559] signature.

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

    """

    return keccak256(

        b"\x02"

        + rlp.encode(

            (

                tx.chain_id,

                tx.nonce,

                tx.max_priority_fee_per_gas,

                tx.max_fee_per_gas,

                tx.gas,

                tx.to,

                tx.value,

                tx.data,

                tx.access_list,

            )

        )

    )

    """

    Compute the hash of a transaction used in an [EIP-4844] signature.

    This function takes a transaction as a parameter and returns the

    signing hash of the transaction used in an [EIP-4844] signature.

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

    """

    return keccak256(

        b"\x03"

        + rlp.encode(

            (

                tx.chain_id,

                tx.nonce,

                tx.max_priority_fee_per_gas,

                tx.max_fee_per_gas,

                tx.gas,

                tx.to,

                tx.value,