Struct TempoPooledTransaction 

pub struct TempoPooledTransaction {
    inner: EthPooledTransaction<TempoTxEnvelope>,
    is_payment: bool,
    is_expiring_nonce: bool,
    nonce_key_slot: OnceLock<Option<U256>>,
    tx_env: OnceLock<TempoTxEnv>,
    key_expiry: OnceLock<Option<u64>>,
    resolved_fee_token: OnceLock<Address>,
}

Tempo pooled transaction representation.

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

Fields

inner: EthPooledTransaction<TempoTxEnvelope>

is_payment: bool

Cached payment classification for efficient block building

is_expiring_nonce: bool

Cached expiring nonce classification

nonce_key_slot: OnceLock<Option<U256>>

Cached slot of the 2D nonce, if any.

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.

Implementations

impl TempoPooledTransaction

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

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

pub 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 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.

Uses strict classification: TIP-20 prefix AND recognized calldata.

pub(crate) 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(crate) 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(crate) fn aa_transaction_id(&self) -> Option<AA2dTransactionId>

Returns the unique identifier for this AA transaction.

fn tx_env_slow(&self) -> TempoTxEnv

Computes the TempoTxEnv for this transaction.

pub fn prepare_tx_env(&self)

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 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::prepare_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 resolved fee token determined during validation.

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

Returns the expiring nonce hash for AA expiring nonce transactions.

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 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: 1424 bytes