Struct TempoTransactionValidator 

pub struct TempoTransactionValidator<Client> {
    pub(crate) inner: EthTransactionValidator<Client, TempoPooledTransaction, TempoEvmConfig>,
    pub(crate) aa_valid_after_max_secs: u64,
    pub(crate) max_tempo_authorizations: usize,
    pub(crate) amm_liquidity_cache: AmmLiquidityCache,
}

Validator for Tempo transactions.

Fields

inner: EthTransactionValidator<Client, TempoPooledTransaction, TempoEvmConfig>

Inner validator that performs default Ethereum tx validation.

aa_valid_after_max_secs: u64

Maximum allowed valid_after offset for AA txs.

max_tempo_authorizations: usize

Maximum number of authorizations allowed in an AA transaction.

amm_liquidity_cache: AmmLiquidityCache

Cache of AMM liquidity for validator tokens.

Implementations

impl<Client> TempoTransactionValidator<Client>

where Client: ChainSpecProvider<ChainSpec = TempoChainSpec> + StateProviderFactory,

pub fn new( inner: EthTransactionValidator<Client, TempoPooledTransaction, TempoEvmConfig>, aa_valid_after_max_secs: u64, max_tempo_authorizations: usize, amm_liquidity_cache: AmmLiquidityCache, ) -> Self

pub fn amm_liquidity_cache(&self) -> AmmLiquidityCache

Obtains a clone of the shared AmmLiquidityCache.

pub fn client(&self) -> &Client

Returns the configured client

fn validate_keychain_version( &self, transaction: &TempoPooledTransaction, spec: TempoHardfork, ) -> Result<(), TempoPoolTransactionError>

Validates that keychain transactions specify the expected version depending on the current chainspec.

fn validate_spending_limit( &self, transaction: &TempoPooledTransaction, fee_token: Address, remaining_limit: U256, ) -> Result<(), TempoPoolTransactionError>

fn validate_against_keychain( &self, transaction: &TempoPooledTransaction, state_provider: &mut impl StateProvider, fee_payer: Address, fee_token: Address, ) -> Result<Result<(), TempoPoolTransactionError>, ProviderError>

Validates AA transactions against the keychain: signature recovery, key authorization, on-chain key existence/revocation/expiry, and spending limits.

Version checks are handled separately by Self::validate_keychain_version early in the path to ensure permanently invalid signatures trigger proper peer penalties.

fn ensure_authorization_list_size( &self, transaction: &TempoPooledTransaction, ) -> Result<(), TempoPoolTransactionError>

Validates that an AA transaction does not exceed the maximum authorization list size.

fn ensure_valid_conditionals( &self, tx: &TempoTransaction, ) -> Result<(), TempoPoolTransactionError>

Validates AA transaction time-bound conditionals

fn ensure_aa_intrinsic_gas( &self, transaction: &TempoPooledTransaction, spec: TempoHardfork, state_provider: &impl StateProvider, ) -> Result<(), TempoPoolTransactionError>

Validates that the gas limit of an AA transaction is sufficient for its intrinsic gas cost.

This prevents transactions from being admitted to the mempool that would fail during execution due to insufficient gas for:

• Per-call cold account access (2600 gas per call target)
• Calldata gas for ALL calls in the batch
• Signature verification gas (P256/WebAuthn signatures)
• Per-call CREATE costs
• Key authorization costs
• 2D nonce gas (if nonce_key != 0)

Without this validation, malicious transactions could clog the mempool at zero cost by passing pool validation (which only sees the first call’s input) but failing at execution time.

fn ensure_aa_field_limits( &self, transaction: &TempoPooledTransaction, ) -> Result<(), TempoPoolTransactionError>

Validates AA transaction field limits (calls, access list, token limits).

These limits are enforced at the pool level rather than RLP decoding to:

• Keep the core transaction format flexible
• Allow peer penalization for sending bad transactions

fn ensure_min_base_fee( &self, transaction: &TempoPooledTransaction, spec: TempoHardfork, ) -> Result<(), TempoPoolTransactionError>

Validates that a transaction’s max_fee_per_gas is at least the minimum base fee for the current hardfork.

• T0: 10 billion attodollars minimum
• T1+: 20 billion attodollars minimum

fn validate_one( &self, origin: TransactionOrigin, transaction: TempoPooledTransaction, state_provider: impl StateProvider, ) -> TransactionValidationOutcome<TempoPooledTransaction>

Trait Implementations

impl<Client: Debug> Debug for TempoTransactionValidator<Client>

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

Formats the value using the given formatter.

impl<Client> TransactionValidator for TempoTransactionValidator<Client>

where Client: ChainSpecProvider<ChainSpec = TempoChainSpec> + StateProviderFactory,

type Transaction = TempoPooledTransaction

The transaction type to validate.

type Block = Block<TempoTxEnvelope, TempoHeader>

The block type used for new head block notifications.

async fn validate_transaction( &self, origin: TransactionOrigin, transaction: Self::Transaction, ) -> TransactionValidationOutcome<Self::Transaction>

Validates the transaction and returns a [TransactionValidationOutcome] describing the validity of the given transaction.

async fn validate_transactions( &self, transactions: impl IntoIterator<Item = (TransactionOrigin, Self::Transaction), IntoIter: Send> + Send, ) -> Vec<TransactionValidationOutcome<Self::Transaction>>

Validates a batch of transactions.

async fn validate_transactions_with_origin( &self, origin: TransactionOrigin, transactions: impl IntoIterator<Item = Self::Transaction> + Send, ) -> Vec<TransactionValidationOutcome<Self::Transaction>>

Validates a batch of transactions with that given origin.

fn on_new_head_block(&self, new_tip_block: &SealedBlock<Self::Block>)

Invoked when the head block changes.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.