Struct TempoPooledTransaction 

pub struct TempoPooledTransaction {
    inner: EthPooledTransaction<TempoTxEnvelope>,
    fee_token_cost: U256,
    is_payment: bool,
    expiring_nonce_hash: Option<B256>,
    nonce_key_slot: OnceLock<Option<U256>>,
    expiring_nonce_slot: OnceLock<Option<U256>>,
    tx_env: OnceLock<TempoTxEnv>,
    key_expiry: OnceLock<Option<u64>>,
    resolved_fee_token: OnceLock<Address>,
    key_authorization_signer_subject: OnceLock<Option<KeychainSubject>>,
    key_authorization_target_subject: OnceLock<Option<KeyAuthorizationTargetSubject>>,
    fee_balance_slot: OnceLock<Option<(Address, U256)>>,
}

Tempo pooled transaction representation.

This is a wrapper around the regular ethereum [EthPooledTransaction], but with tempo specific implementations.

Fields

inner: EthPooledTransaction<TempoTxEnvelope>

fee_token_cost: U256

Cached cost of the transaction in the fee token.

is_payment: bool

Cached T5+ payment classification for efficient block building.

expiring_nonce_hash: Option<B256>

Precomputed sender-scoped hash used to deduplicate expiring nonce transactions.

nonce_key_slot: OnceLock<Option<U256>>

Cached slot of the 2D nonce, if any.

expiring_nonce_slot: OnceLock<Option<U256>>

Cached expiring_nonce_seen storage slot for expiring nonce transactions.

tx_env: OnceLock<TempoTxEnv>

Cached prepared TempoTxEnv for payload building.

key_expiry: OnceLock<Option<u64>>

Keychain key expiry timestamp (set during validation for keychain-signed txs).

Some(expiry) for keychain transactions where expiry < u64::MAX (finite expiry). None for non-keychain transactions or keys that never expire.

resolved_fee_token: OnceLock<Address>

Resolved fee token cached at validation time.

Used by keychain_subject() so pool maintenance matches against the same token that was validated without requiring state access.

key_authorization_signer_subject: OnceLock<Option<KeychainSubject>>

Cached keychain subject for the signer of an inline KeyAuthorization.

key_authorization_target_subject: OnceLock<Option<KeyAuthorizationTargetSubject>>

Cached target key of an inline KeyAuthorization.

fee_balance_slot: OnceLock<Option<(Address, U256)>>

Cached TIP20 balance storage slot for the fee payer.

Stores (fee_token, balance_slot) so the payload builder’s state-aware iterator can check if the fee payer’s balance was modified without recomputing the keccak.

Implementations

impl TempoPooledTransaction

pub fn new(transaction: Recovered<TempoTxEnvelope>) -> Self

Create new instance of Self from the given consensus transactions and the encoded size.

fn new_with( transaction: Recovered<TempoTxEnvelope>, expiring_nonce_hash: Option<B256>, encoded_length: usize, ) -> Self

Create a new pooled transaction with optional precomputed transaction metadata.

Raw transaction recovery can compute the signer and expiring nonce hash in one pass for expiring AA transactions, and it already knows the encoded byte length. This constructor preserves those values while keeping Self::new as the default path for callers that already have a recovered transaction.

pub const fn fee_token_cost(&self) -> U256

Get the cost of the transaction in the fee token.

pub fn inner(&self) -> &Recovered<TempoTxEnvelope>

Returns a reference to inner TempoTxEnvelope.

pub fn fee_payer(&self) -> Result<Address, RecoveryError>

Resolves the transaction fee payer.

This reuses the cached transaction environment once validation has prepared it, so repeated pool-maintenance checks do not recover the fee payer again.

pub fn is_aa(&self) -> bool

Returns true if this is an AA transaction

pub fn nonce_key(&self) -> Option<U256>

Returns the nonce key of this transaction if it’s an AASigned transaction.

pub fn nonce_key_slot(&self) -> Option<U256>

Returns the storage slot for the nonce key of this transaction.

pub fn is_payment(&self) -> bool

Returns whether this is a payment transaction according to the T5+ builder criteria.

pub fn is_aa_2d(&self) -> bool

Returns true if this transaction belongs into the 2D nonce pool:

• AA transaction with a nonce key != 0 (includes expiring nonce txs)

pub fn is_expiring_nonce(&self) -> bool

Returns true if this is an expiring nonce transaction.

pub fn keychain_subject(&self) -> Option<KeychainSubject>

Extracts the keychain subject (account, key_id, fee_token) from this transaction.

Returns None if:

• This is not an AA transaction
• The signature is not a keychain signature
• The key_id cannot be recovered from the signature

Used for matching transactions against revocation and spending limit events.

pub fn key_authorization_signer_subject(&self) -> Option<KeychainSubject>

Extracts the keychain subject for the signer of an inline KeyAuthorization.

Used for revocation matching: if the access key that signed an inline authorization is revoked while the transaction is still in the pool, the transaction must be revalidated.

pub fn key_authorization_target_subject( &self, ) -> Option<KeyAuthorizationTargetSubject>

Extracts the target key of an inline KeyAuthorization.

Used for matching pending authorizations against key status changes emitted by already-included authorizations or revocations.

pub fn key_authorization_witness_subject( &self, ) -> Option<KeyAuthorizationWitnessSubject>

Extracts the TIP-1053 key-authorization witness carried by this transaction, if any.

pub fn aa_transaction_id(&self) -> Option<AA2dTransactionId>

Returns the unique identifier for this AA transaction.

pub(crate) fn tx_env_slow(&self) -> TempoTxEnv

Computes the TempoTxEnv for this transaction.

pub fn tx_env(&self) -> &TempoTxEnv

Pre-computes and caches the TempoTxEnv.

This should be called during validation to prepare the transaction environment ahead of time, avoiding it during payload building.

pub(crate) fn cached_tx_env(&self) -> Option<&TempoTxEnv>

Returns the cached TempoTxEnv if already prepared.

pub(crate) fn cache_tx_env(&self, tx_env: TempoTxEnv)

Attempts to cache a prepared TempoTxEnv.

pub fn clone_tx_env(&self) -> TempoTxEnv

Returns a cloned TempoTxEnv for this transaction.

This uses the cached value prepared by Self::tx_env when available, and computes it on-demand otherwise.

pub fn executable(&self) -> (TempoTxEnv, &Recovered<TempoTxEnvelope>)

Returns a tuple that can be passed to block executor.

pub fn clone_into_with_tx_env( &self, ) -> WithTxEnv<TempoTxEnv, Recovered<TempoTxEnvelope>>

Returns a [WithTxEnv] wrapper by cloning the cached TempoTxEnv and recovered transaction.

This avoids cloning the full pooled transaction when the caller only needs an owned executable transaction.

pub fn into_with_tx_env( self, ) -> WithTxEnv<TempoTxEnv, Recovered<TempoTxEnvelope>>

Returns a [WithTxEnv] wrapper containing the cached TempoTxEnv.

If the TempoTxEnv was pre-computed via Self::tx_env, the cached value is used. Otherwise, it is computed on-demand.

pub fn set_key_expiry(&self, expiry: Option<u64>)

Sets the keychain key expiry timestamp for this transaction.

Called during validation when we read the AuthorizedKey from state. Pass Some(expiry) for keys with finite expiry, None for non-keychain txs or keys that never expire.

pub fn key_expiry(&self) -> Option<u64>

Returns the keychain key expiry timestamp, if set during validation.

Returns Some(expiry) for keychain transactions with finite expiry. Returns None if not a keychain tx, key never expires, or not yet validated.

pub fn set_resolved_fee_token(&self, fee_token: Address)

Caches the effective fee token determined during transaction validation.

The validator sets this after EVM validation resolves the token from the transaction’s explicit fee_token field or from fee-manager state. Pool maintenance code should not call this directly.

pub fn resolved_fee_token(&self) -> Option<Address>

Returns the fee token cached during transaction validation, if available.

This is None for transactions that have not completed validation through the pool validator. Prefer Self::effective_fee_token in maintenance code that needs the token a transaction will actually use to pay fees.

pub fn effective_fee_token(&self) -> Address

Returns the effective fee token for pool maintenance and accounting.

This prefers the token cached by validation, then falls back to the raw transaction fee_token field, and finally to DEFAULT_FEE_TOKEN. This fallback covers non-AA transactions and AA transactions without an explicit fee token. Use this when checking liquidity, token pause state, balances, or transfer policies. Use the raw fee_token field only when the code specifically needs to know whether the transaction explicitly supplied a token.

pub fn fee_balance_slot(&self) -> Option<(Address, U256)>

Returns the (fee_token, balance_slot) pair for this transaction’s fee payer, lazily computed and cached on first access.

pub(crate) fn is_sender_paid_fee(&self) -> bool

Returns true when the transaction fee is paid by the transaction sender.

Invalid fee payer recovery is treated as sender-paid so maintenance never skips a conservative sender-scoped invalidation for malformed pooled state.

pub fn expiring_nonce_hash(&self) -> Option<B256>

Returns the sender-scoped expiring nonce hash for AA transactions.

Expiring nonce transactions use the precomputed value from construction; other AA transactions compute on demand to preserve the helper’s existing behavior.

pub(crate) fn precomputed_expiring_nonce_hash(&self) -> B256

Returns the precomputed hash for transactions already classified as expiring nonce.

pub fn expiring_nonce_slot(&self) -> Option<U256>

Returns the cached expiring_nonce_seen storage slot for this transaction.

pub fn precalculate_keccak_slots(&self)

Warms the global keccak cache with storage slot hashes that will be accessed during payment execution after pool validation.

Fee-path slots like balances[fee_payer], user_reward_info[fee_payer], user_tokens[fee_payer], and expiring_nonce_seen[hash] are already cached from EVM validation. validator_tokens[beneficiary] depends on the block producer, which is unknown at validation time.

Trait Implementations

impl Clone for TempoPooledTransaction

fn clone(&self) -> TempoPooledTransaction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TempoPooledTransaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Encodable2718 for TempoPooledTransaction

fn type_flag(&self) -> Option<u8>

Return the type flag (if any).

fn encode_2718_len(&self) -> usize

The length of the 2718 encoded envelope. This is the length of the type flag + the length of the inner encoding.

fn encode_2718(&self, out: &mut dyn BufMut)

Encode the transaction according to EIP-2718 rules. First a 1-byte type flag in the range 0x0-0x7f, then the body of the transaction.

fn encoded_2718(&self) -> Vec<u8>

Encode the transaction according to [EIP-2718] rules. First a 1-byte type flag in the range 0x0-0x7f, then the body of the transaction.

fn trie_hash(&self) -> FixedBytes<32>

Compute the hash as committed to in the MPT trie. This hash is used ONLY by the Ethereum merkle-patricia trie and associated proofs. Do not call this method unless you are building a full or light client.

fn seal(self) -> Sealed<Self>

Seal the encodable, by encoding and hashing it.

fn into_encoded(self) -> WithEncoded<Self>

A convenience function that encodes the value in the 2718 format and wraps it in a [WithEncoded] wrapper.

fn network_len(&self) -> usize

The length of the 2718 encoded envelope in network format. This is the length of the header + the length of the type flag and inner encoding.

fn network_encode(&self, out: &mut dyn BufMut)

Encode in the network format. The network format is used ONLY by the Ethereum p2p protocol. Do not call this method unless you are building a p2p protocol client.

impl EthPoolTransaction for TempoPooledTransaction

fn take_blob(&mut self) -> EthBlobTransactionSidecar

Extracts the blob sidecar from the transaction.

fn try_into_pooled_eip4844( self, _sidecar: Arc<BlobTransactionSidecarVariant>, ) -> Option<Recovered<Self::Pooled>>

A specialization for the EIP-4844 transaction type. Tries to reattach the blob sidecar to the transaction.

fn try_from_eip4844( _tx: Recovered<Self::Consensus>, _sidecar: BlobTransactionSidecarVariant, ) -> Option<Self>

Tries to convert the Consensus type with a blob sidecar into the Pooled type.

fn validate_blob( &self, _sidecar: &BlobTransactionSidecarVariant, _settings: &KzgSettings, ) -> Result<(), BlobTransactionValidationError>

Validates the blob sidecar of the transaction with the given settings.

impl InMemorySize for TempoPooledTransaction

fn size(&self) -> usize

Returns a heuristic for the in-memory size of a struct.

impl PoolTransaction for TempoPooledTransaction

type TryFromConsensusError = Infallible

Associated error type for the try_from_consensus method.

type Consensus = TempoTxEnvelope

Associated type representing the raw consensus variant of the transaction.

type Pooled = TempoTxEnvelope

Associated type representing the recovered pooled variant of the transaction.

fn clone_into_consensus(&self) -> Recovered<Self::Consensus>

Clone the transaction into a consensus variant.

fn consensus_ref(&self) -> Recovered<&Self::Consensus>

Returns a reference to the consensus transaction with the recovered sender.

fn into_consensus(self) -> Recovered<Self::Consensus>

Define a method to convert from the Self type to Consensus

fn from_pooled(tx: Recovered<Self::Pooled>) -> Self

Define a method to convert from the Pooled type to Self

fn recover_raw_transaction(data: &[u8]) -> Result<Self, RawPoolTransactionError>

Decodes and recovers a raw transaction into this pool transaction type.

fn hash(&self) -> &TxHash

Hash of the transaction.

fn sender(&self) -> Address

The Sender of the transaction.

fn sender_ref(&self) -> &Address

Reference to the Sender of the transaction.

fn cost(&self) -> &U256

Returns the cost that this transaction is allowed to consume:

fn encoded_length(&self) -> usize

Returns the length of the rlp encoded transaction object

fn requires_nonce_check(&self) -> bool

Allows to communicate to the pool that the transaction doesn’t require a nonce check.

fn try_from_consensus( tx: Recovered<Self::Consensus>, ) -> Result<Self, Self::TryFromConsensusError>

Define a method to convert from the Consensus type to Self

fn into_consensus_with2718(self) -> WithEncoded<Recovered<Self::Consensus>>

Converts the transaction into consensus format while preserving the EIP-2718 encoded bytes. This is used to optimize transaction execution by reusing cached encoded bytes instead of re-encoding the transaction. The cached bytes are particularly useful in payload building where the same transaction may be executed multiple times.

fn try_into_pooled( self, ) -> Result<Recovered<Self::Pooled>, Self::TryFromConsensusError>

Tries to convert the Consensus type into the Pooled type.

fn clone_into_pooled( &self, ) -> Result<Recovered<Self::Pooled>, Self::TryFromConsensusError>

Clones the consensus transactions and tries to convert the Consensus type into the Pooled type.

fn pooled_into_consensus(tx: Self::Pooled) -> Self::Consensus

Converts the Pooled type into the Consensus type.

fn ensure_max_init_code_size( &self, max_init_code_size: usize, ) -> Result<(), InvalidPoolTransactionError>

Ensures that the transaction’s code size does not exceed the provided max_init_code_size.

impl Transaction for TempoPooledTransaction

fn chain_id(&self) -> Option<u64>

Get chain_id.

fn nonce(&self) -> u64

Get nonce.

fn gas_limit(&self) -> u64

Get gas_limit.

fn gas_price(&self) -> Option<u128>

Get gas_price.

fn max_fee_per_gas(&self) -> u128

For dynamic fee transactions returns the maximum fee per gas the caller is willing to pay.

fn max_priority_fee_per_gas(&self) -> Option<u128>

For dynamic fee transactions returns the Priority fee the caller is paying to the block author.

fn max_fee_per_blob_gas(&self) -> Option<u128>

Max fee per blob gas for EIP-4844 transaction.

fn priority_fee_or_price(&self) -> u128

Return the max priority fee per gas if the transaction is a dynamic fee transaction, and otherwise return the gas price.

fn effective_gas_price(&self, base_fee: Option<u64>) -> u128

Returns the effective gas price for the given base fee.

fn is_dynamic_fee(&self) -> bool

Returns true if the transaction supports dynamic fees.

fn kind(&self) -> TxKind

Returns the transaction kind.

fn is_create(&self) -> bool

Returns true if the transaction is a contract creation. We don’t provide a default implementation via kind as it copies the 21-byte [TxKind] for this simple check. A proper implementation shouldn’t allocate.

fn value(&self) -> U256

Get value.

fn input(&self) -> &Bytes

Get data.

fn access_list(&self) -> Option<&AccessList>

Returns the EIP-2930 access_list for the particular transaction type. Returns None for older transaction types.

fn blob_versioned_hashes(&self) -> Option<&[B256]>

Blob versioned hashes for eip4844 transaction. For previous transaction types this is None.

fn authorization_list(&self) -> Option<&[SignedAuthorization]>

Returns the [SignedAuthorization] list of the transaction.

fn effective_tip_per_gas(&self, base_fee: u64) -> Option<u128>

Returns the effective tip for this transaction.

fn to(&self) -> Option<Address>

Get the transaction’s address of the contract that will be called, or the address that will receive the transfer.

fn function_selector(&self) -> Option<&FixedBytes<4>>

Returns the first 4bytes of the calldata for a function call.

fn blob_count(&self) -> Option<u64>

Returns the number of blobs of this transaction.

fn blob_gas_used(&self) -> Option<u64>

Returns the total gas for all blobs in this transaction.

fn authorization_count(&self) -> Option<u64>

Returns the number of [SignedAuthorization]s in this transactions

impl Typed2718 for TempoPooledTransaction

fn ty(&self) -> u8

Returns the EIP-2718 type flag.

fn is_type(&self, ty: u8) -> bool

Returns true if the type matches the given type.

fn is_legacy(&self) -> bool

Returns true if the type is a legacy transaction.

fn is_eip2930(&self) -> bool

Returns true if the type is an EIP-2930 transaction.

fn is_eip1559(&self) -> bool

Returns true if the type is an EIP-1559 transaction.

fn is_eip4844(&self) -> bool

Returns true if the type is an EIP-4844 transaction.

fn is_eip7702(&self) -> bool

Returns true if the type is an EIP-7702 transaction.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1920 bytes