"""

    Encode a transaction. Needed because non-legacy transactions aren't RLP.

    """

    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)

    else:

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

    """

    Decode a transaction. Needed because non-legacy transactions aren't RLP.

    """

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

        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 <https://eips.ethereum.org/EIPS/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.

    Parameters

    ----------

    tx :

        Transaction to validate.

    Returns

    -------

    verified : `bool`

        True if the transaction can be executed, or False otherwise.

    """

    from .vm.interpreter import MAX_CODE_SIZE

    if calculate_intrinsic_cost(tx) > tx.gas:

        return False

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

        return False

    if tx.to == Bytes0(b"") and len(tx.data) > 2 * MAX_CODE_SIZE:

        return False

    return True

    """

    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.

    Parameters

    ----------

    tx :

        Transaction to compute the intrinsic cost of.

    Returns

    -------

    verified : `ethereum.base_types.Uint`

        The intrinsic cost of the transaction.

    """

    from .vm.gas import init_code_cost

    data_cost = 0

    for byte in tx.data:

        if byte == 0:

            data_cost += TX_DATA_COST_PER_ZERO

        else:

            data_cost += TX_DATA_COST_PER_NON_ZERO

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

        create_cost = TX_CREATE_COST + int(init_code_cost(Uint(len(tx.data))))

    else:

        create_cost = 0

    access_list_cost = 0

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

        for _address, keys in tx.access_list:

            access_list_cost += TX_ACCESS_LIST_ADDRESS_COST

            access_list_cost += len(keys) * TX_ACCESS_LIST_STORAGE_KEY_COST

    return Uint(TX_BASE_COST + data_cost + create_cost + access_list_cost)

    """

    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.

    Parameters

    ----------

    tx :

        Transaction of interest.

    chain_id :

        ID of the executing chain.

    Returns

    -------

    sender : `ethereum.fork_types.Address`

        The address of the account that signed the transaction.

    """

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

        public_key = secp256k1_recover(

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

        )

    elif isinstance(tx, FeeMarketTransaction):

        public_key = secp256k1_recover(

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

        )

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

    """

    Compute the hash of a transaction used in a legacy (pre EIP 155) signature.

    Parameters

    ----------

    tx :

        Transaction of interest.

    Returns

    -------

    hash : `ethereum.crypto.hash.Hash32`

        Hash of the transaction.

    """

    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.

    Parameters

    ----------

    tx :

        Transaction of interest.

    chain_id :

        The id of the current chain.

    Returns

    -------

    hash : `ethereum.crypto.hash.Hash32`

        Hash of the transaction.

    """

    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.

    Parameters

    ----------

    tx :

        Transaction of interest.

    Returns

    -------

    hash : `ethereum.crypto.hash.Hash32`

        Hash of the transaction.

    """

    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 a EIP 1559 signature.

    Parameters

    ----------

    tx :

        Transaction of interest.

    Returns

    -------

    hash : `ethereum.crypto.hash.Hash32`

        Hash of the transaction.

    """

    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,

            )

        )

    )