<snip>

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

    <snip>

    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

    <snip>

    from .vm.interpreter import MAX_INIT_CODE_SIZE

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

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

                )

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

    intrinsic = calculate_intrinsic_cost(tx, sender)

    intrinsic_gas = Uint(intrinsic.execution)

    if intrinsic_gas > tx.gas:

        raise InsufficientTransactionGasError("Insufficient intrinsic gas")

    if intrinsic.calldata_floor > tx.gas:

        raise InsufficientTransactionGasError("Insufficient calldata floor")

    if intrinsic.execution > TX_MAX_GAS_LIMIT:

        raise InsufficientTransactionGasError(

            "Intrinsic execution gas exceeds TX_MAX_GAS_LIMIT"

        )

    if intrinsic.calldata_floor > TX_MAX_GAS_LIMIT:

        raise InsufficientTransactionGasError(

            "Intrinsic calldata floor exceeds TX_MAX_GAS_LIMIT"

        )

    return intrinsic

    <snip>

    from .vm.gas import GasCosts, init_code_cost

    tokens_in_calldata = count_tokens_in_data(tx.data)

    data_cost = tokens_in_calldata * GasCosts.TX_DATA_TOKEN_STANDARD

    is_create = tx.to == Bytes0(b"")

    is_self_transfer = tx.to == sender

    recipient_execution_gas = Uint(0)

    init_code_gas = Uint(0)

    if is_create:

        recipient_execution_gas = GasCosts.CREATE_ACCESS

        init_code_gas = init_code_cost(ulen(tx.data))

    elif not is_self_transfer:

        recipient_execution_gas = GasCosts.COLD_ACCOUNT_ACCESS

        if tx.value > U256(0):

            recipient_execution_gas += GasCosts.TX_VALUE_COST

    access_list_cost = Uint(0)

    tokens_in_access_list = Uint(0)

    if has_access_list(tx):

        for access in tx.access_list:

            access_list_cost += GasCosts.TX_ACCESS_LIST_ADDRESS

            access_list_cost += (

                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_cost += tokens_in_access_list * GasCosts.TX_DATA_TOKEN_FLOOR

    auth_cost = Uint(0)

    if isinstance(tx, SetCodeTransaction):

        auth_cost = GasCosts.EXECUTION_PER_AUTH_BASE_COST * 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

    # Decomposed execution-gas intrinsic base (EIP-2780), which also

    # anchors the calldata floor.

    base_execution_gas = GasCosts.TX_BASE + recipient_execution_gas

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

    data_floor_gas_cost = (

        total_floor_tokens * GasCosts.TX_DATA_TOKEN_FLOOR + base_execution_gas

    )

    return IntrinsicGasCost(

        execution=ExecutionGas(

            base_execution_gas

            + init_code_gas

            + data_cost

            + access_list_cost

            + auth_cost

        ),

        calldata_floor=ExecutionGas(data_floor_gas_cost),

    )

    <snip>

    num_zeros = Uint(data.count(0))

    num_non_zeros = ulen(data) - num_zeros

    return num_zeros + num_non_zeros * Uint(4)

    <snip>

    if isinstance(tx, FeeMarketCapableTransaction):

        if tx.max_fee_per_gas < base_fee_per_gas:

            raise InsufficientMaxFeePerGasError(

                tx.max_fee_per_gas, base_fee_per_gas

            )

        priority_fee_per_gas = min(

            tx.max_priority_fee_per_gas,

            tx.max_fee_per_gas - base_fee_per_gas,

        )

        return priority_fee_per_gas + base_fee_per_gas

    if tx.gas_price < base_fee_per_gas:

        raise InvalidBlock

    return tx.gas_price

    <snip>

    if isinstance(tx, FeeMarketCapableTransaction):

        return gas_limit * tx.max_fee_per_gas

    return gas_limit * tx.gas_price

    <snip>

    if sender_nonce > Uint(tx.nonce):

        raise NonceMismatchError("nonce too low")

    elif sender_nonce < Uint(tx.nonce):

        raise NonceMismatchError("nonce too high")

    <snip>

    if isinstance(tx, LegacyTransaction):

        if tx.v == 27 or tx.v == 28:

            return None

        if tx.v < U256(35):

            raise InvalidSignatureError("bad v")

        return U64((tx.v - U256(35)) >> U256(1))

    else:

        return tx.chain_id

    <snip>

    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:

            assert v >= U256(35), "call chain_id before recover_sender"

            tx_chain_id = U64((v - U256(35)) >> U256(1))

            v = (v - U256(35)) & U256(1)

            public_key = secp256k1_recover(

                r,

                s,

                v,

                signing_hash_155(tx, 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])

    <snip>

    return keccak256(

        rlp.encode(

            (

                tx.nonce,

                tx.gas_price,

                tx.gas,

                tx.to,

                tx.value,

                tx.data,

            )

        )

    )

    <snip>

    return keccak256(

        rlp.encode(

            (

                tx.nonce,

                tx.gas_price,

                tx.gas,

                tx.to,

                tx.value,

                tx.data,

                chain_id,

                Uint(0),

                Uint(0),

            )

        )

    )

    <snip>

    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,

            )

        )

    )

    <snip>

    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,

            )

        )

    )

    <snip>

    return keccak256(

        b"\x03"

        + rlp.encode(

            (

                tx.chain_id,