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,
    cached_evm_env: RwLock<EvmEnv<TempoHardfork, TempoBlockEnv>>,
    cached_state: RwLock<(B256, Arc<StateCache>)>,
    active_hardfork: AtomicU8,
}

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.

cached_evm_env: RwLock<EvmEnv<TempoHardfork, TempoBlockEnv>>

Cached EVM environment from the latest tip block, updated on each on_new_head_block.

cached_state: RwLock<(B256, Arc<StateCache>)>

Tip hash and cache of state reads shared across validation calls, replaced on each on_new_head_block.

active_hardfork: AtomicU8

The Tempo hardfork active at the current tip, stored as an index into TempoHardfork::VARIANTS and updated on each on_new_head_block.

Cached here so hot paths can resolve the active hardfork with a single atomic load instead of walking the chain spec’s fork schedule.

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

where Client: BlockReaderIdExt<Header = TempoHeader>,

pub fn active_hardfork(&self) -> TempoHardfork

Returns the Tempo hardfork active at the current tip.

Updated on each on_new_head_block.

pub fn amm_liquidity_cache(&self) -> AmmLiquidityCache

Obtains a clone of the shared AmmLiquidityCache.

pub fn client(&self) -> &Client

Returns the configured client

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

Pool-only time-bound admission checks.

These enforce propagation-liveness constraints that are stricter than the EVM’s block-timestamp checks:

• valid_before must be far enough in the future (propagation buffer)
• valid_after must not be too far in the future (wall-clock bound)

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_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 validate_batch<P: StateProvider>( &self, state_provider: P, cached_state: Arc<StateCache>, transactions: impl IntoIterator<Item = (TransactionOrigin, TempoPooledTransaction)>, ) -> Vec<TransactionValidationOutcome<TempoPooledTransaction>>

Validates a batch of transactions against the same state snapshot.

All transactions share one throwaway TempoEvm (journaled writes are discarded after each transaction while loaded state stays warm) and the validator’s tip-scoped StateCache, so repeated state reads are served from memory across transactions and across concurrent validation calls.

fn latest_state_provider_and_cache( &self, ) -> ProviderResult<(StateProviderBox, Arc<StateCache>)>

Returns the latest state provider and a state cache valid for the provider’s tip.

fn state_cache_for_tip(&self, tip_hash: B256) -> Arc<StateCache>

Returns the shared cache if it matches tip_hash, otherwise an empty ephemeral cache.

A mismatch can happen when .latest() observes state for a newer canonical tip before on_new_head_block has refreshed the validator’s cached state for that tip.

fn validate_one_with_evm<DB>( &self, origin: TransactionOrigin, transaction: TempoPooledTransaction, evm: &mut TempoEvm<DB>, ) -> TransactionValidationOutcome<TempoPooledTransaction>

where DB: Database<Error = ProviderError> + DatabaseRef<Error = ProviderError>,

Validates one transaction with the given throwaway EVM.

The caller is responsible for discarding the journaled writes afterwards.

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.