Struct TempoTransactionPool 

pub struct TempoTransactionPool<Client> {
    protocol_pool: Pool<TransactionValidationTaskExecutor<TempoTransactionValidator<Client>>, CoinbaseTipOrdering<TempoPooledTransaction>, InMemoryBlobStore>,
    aa_2d_pool: Arc<RwLock<AA2dPool>>,
}

Tempo transaction pool that routes based on nonce_key

Fields

protocol_pool: Pool<TransactionValidationTaskExecutor<TempoTransactionValidator<Client>>, CoinbaseTipOrdering<TempoPooledTransaction>, InMemoryBlobStore>

Vanilla pool for all standard transactions and AA transactions with regular nonce.

aa_2d_pool: Arc<RwLock<AA2dPool>>

Minimal pool for 2D nonces (nonce_key > 0)

Implementations

impl<Client> TempoTransactionPool<Client>

pub fn new( protocol_pool: Pool<TransactionValidationTaskExecutor<TempoTransactionValidator<Client>>, CoinbaseTipOrdering<TempoPooledTransaction>, InMemoryBlobStore>, aa_2d_pool: AA2dPool, ) -> Self

impl<Client> TempoTransactionPool<Client>

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

pub fn amm_liquidity_cache(&self) -> AmmLiquidityCache

Obtains a clone of the shared AmmLiquidityCache.

pub fn client(&self) -> &Client

Returns the configured client

pub(crate) fn notify_aa_pool_on_state_updates( &self, state: &AddressMap<BundleAccount>, )

Updates the 2d nonce pool with the given state changes.

pub(crate) fn reset_2d_nonces_from_state( &self, seq_ids: Vec<AASequenceId>, block_hash: B256, ) -> Result<(), ProviderError>

Resets the nonce state for the given 2D nonce sequence IDs by reading from a specific block’s state. Used during reorgs to correct the pool’s nonce tracking for slots that were modified in the old chain but not in the new chain.

pub(crate) fn remove_included_expiring_nonce_txs<'a>( &self, tx_hashes: impl Iterator<Item = &'a TxHash>, )

Removes expiring nonce transactions that were included in a block.

This is called with the transaction hashes from mined blocks to clean up expiring nonce transactions on inclusion, rather than waiting for expiry.

pub fn evict_invalidated_transactions( &self, updates: &TempoPoolUpdates, ) -> Vec<TxHash>

Evicts transactions that are no longer valid due to on-chain events.

This performs a single scan of all pooled transactions and checks for:

1. Revoked keychain keys: AA transactions signed with keys that have been revoked
2. Spending limit updates: AA transactions signed with keys whose spending limit changed for a token matching the transaction’s fee token 2b. Spending limit spends: AA transactions whose remaining spending limit (re-read from state) is now insufficient after included keychain txs decremented it
3. Validator token changes: Transactions that would fail due to insufficient liquidity in the new (user_token, validator_token) AMM pool

All checks are combined into one scan to avoid iterating the pool multiple times per block.

fn add_validated_transaction( &self, origin: TransactionOrigin, transaction: TransactionValidationOutcome<TempoPooledTransaction>, ) -> PoolResult<AddedTransactionOutcome>

Trait Implementations

impl<Client> Clone for TempoTransactionPool<Client>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Client> Debug for TempoTransactionPool<Client>

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

Formats the value using the given formatter.

impl<Client> TransactionPool for TempoTransactionPool<Client>

where Client: StateProviderFactory + ChainSpecProvider<ChainSpec = TempoChainSpec> + Send + Sync + 'static, TempoPooledTransaction: EthPoolTransaction,

type Transaction = TempoPooledTransaction

The transaction type of the pool

fn pool_size(&self) -> PoolSize

Returns stats about the pool and all sub-pools.

fn block_info(&self) -> BlockInfo

Returns the block the pool is currently tracking.

async fn add_transaction_and_subscribe( &self, origin: TransactionOrigin, transaction: Self::Transaction, ) -> PoolResult<TransactionEvents>

Adds an unvalidated transaction into the pool and subscribe to state changes.

async fn add_transaction( &self, origin: TransactionOrigin, transaction: Self::Transaction, ) -> PoolResult<AddedTransactionOutcome>

Adds an unvalidated transaction into the pool.

async fn add_transactions( &self, origin: TransactionOrigin, transactions: Vec<Self::Transaction>, ) -> Vec<PoolResult<AddedTransactionOutcome>>

Adds the given unvalidated transactions into the pool.

async fn add_transactions_with_origins( &self, transactions: Vec<(TransactionOrigin, Self::Transaction)>, ) -> Vec<PoolResult<AddedTransactionOutcome>>

Adds the given unvalidated transactions into the pool.

fn transaction_event_listener(&self, tx_hash: B256) -> Option<TransactionEvents>

Returns a new transaction change event stream for the given transaction.

fn all_transactions_event_listener( &self, ) -> AllTransactionsEvents<Self::Transaction>

Returns a new transaction change event stream for all transactions in the pool.

fn pending_transactions_listener_for( &self, kind: TransactionListenerKind, ) -> Receiver<B256>

Returns a new [Receiver] that yields transactions hashes for new pending transactions inserted into the pending pool depending on the given [TransactionListenerKind] argument.

fn blob_transaction_sidecars_listener(&self) -> Receiver<NewBlobSidecar>

Returns a new [Receiver] that yields blob “sidecars” (blobs w/ assoc. kzg commitments/proofs) for eip-4844 transactions inserted into the pool

fn new_transactions_listener_for( &self, kind: TransactionListenerKind, ) -> Receiver<NewTransactionEvent<Self::Transaction>>

Returns a new stream that yields new valid transactions added to the pool depending on the given [TransactionListenerKind] argument.

fn pooled_transaction_hashes(&self) -> Vec<B256>

Returns the hashes of all transactions in the pool that are allowed to be propagated.

fn pooled_transaction_hashes_max(&self, max: usize) -> Vec<B256>

Returns only the first max hashes of transactions in the pool.

fn pooled_transactions( &self, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns the full transaction objects all transactions in the pool that are allowed to be propagated.

fn pooled_transactions_max( &self, max: usize, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns only the first max transactions in the pool.

fn get_pooled_transaction_elements( &self, tx_hashes: Vec<B256>, limit: GetPooledTransactionLimit, ) -> Vec<<Self::Transaction as PoolTransaction>::Pooled>

Returns converted [PooledTransactionVariant] for the given transaction hashes that are allowed to be propagated.

fn append_pooled_transaction_elements( &self, tx_hashes: &[B256], limit: GetPooledTransactionLimit, out: &mut Vec<<Self::Transaction as PoolTransaction>::Pooled>, )

Extends the given vector with pooled transactions for the given hashes that are allowed to be propagated.

fn get_pooled_transaction_element( &self, tx_hash: B256, ) -> Option<Recovered<<Self::Transaction as PoolTransaction>::Pooled>>

Returns the pooled transaction variant for the given transaction hash.

fn best_transactions( &self, ) -> Box<dyn BestTransactions<Item = Arc<ValidPoolTransaction<Self::Transaction>>>>

Returns an iterator that yields transactions that are ready for block production.

fn best_transactions_with_attributes( &self, _attributes: BestTransactionsAttributes, ) -> Box<dyn BestTransactions<Item = Arc<ValidPoolTransaction<Self::Transaction>>>>

Returns an iterator that yields transactions that are ready for block production with the given base fee and optional blob fee attributes.

fn pending_transactions( &self, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all transactions that can be included in the next block.

fn pending_transactions_max( &self, max: usize, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns first max transactions that can be included in the next block. See https://github.com/paradigmxyz/reth/issues/12767#issuecomment-2493223579

fn queued_transactions( &self, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all transactions that can be included in future blocks.

fn pending_and_queued_txn_count(&self) -> (usize, usize)

Returns the number of transactions that are ready for inclusion in the next block and the number of transactions that are ready for inclusion in future blocks: (pending, queued).

fn all_transactions(&self) -> AllPoolTransactions<Self::Transaction>

Returns all transactions that are currently in the pool grouped by whether they are ready for inclusion in the next block or not.

fn all_transaction_hashes(&self) -> Vec<B256>

Returns the hashes of all transactions regardless of whether they can be propagated or not.

fn remove_transactions( &self, hashes: Vec<B256>, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Removes all transactions corresponding to the given hashes.

fn remove_transactions_and_descendants( &self, hashes: Vec<B256>, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Removes all transactions corresponding to the given hashes.

fn remove_transactions_by_sender( &self, sender: Address, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Removes all transactions from the given sender

fn prune_transactions( &self, hashes: Vec<TxHash>, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Prunes all transactions corresponding to the given hashes from the pool.

fn retain_unknown<A: HandleMempoolData>(&self, announcement: &mut A)

Retains only those hashes that are unknown to the pool. In other words, removes all transactions from the given set that are currently present in the pool. Returns hashes already known to the pool.

fn contains(&self, tx_hash: &B256) -> bool

Returns if the transaction for the given hash is already included in this pool.

fn get( &self, tx_hash: &B256, ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns the transaction for the given hash.

fn get_all( &self, txs: Vec<B256>, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all transactions objects for the given hashes.

fn on_propagated(&self, txs: PropagatedTransactions)

Notify the pool about transactions that are propagated to peers.

fn get_transactions_by_sender( &self, sender: Address, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all transactions sent by a given user

fn get_pending_transactions_with_predicate( &self, predicate: impl FnMut(&ValidPoolTransaction<Self::Transaction>) -> bool, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all pending transactions filtered by predicate

fn get_pending_transactions_by_sender( &self, sender: Address, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all pending transactions sent by a given user

fn get_queued_transactions_by_sender( &self, sender: Address, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all queued transactions sent by a given user

fn get_highest_transaction_by_sender( &self, sender: Address, ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns the highest transaction sent by a given user

fn get_highest_consecutive_transaction_by_sender( &self, sender: Address, on_chain_nonce: u64, ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns the transaction with the highest nonce that is executable given the on chain nonce. In other words the highest non nonce gapped transaction.

fn get_transaction_by_sender_and_nonce( &self, sender: Address, nonce: u64, ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns a transaction sent by a given user and a nonce

fn get_transactions_by_origin( &self, origin: TransactionOrigin, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all transactions that where submitted with the given [TransactionOrigin]

fn get_pending_transactions_by_origin( &self, origin: TransactionOrigin, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all pending transactions filtered by [TransactionOrigin]

fn unique_senders(&self) -> AddressSet

Returns a set of all senders of transactions in the pool

fn get_blob( &self, tx_hash: B256, ) -> Result<Option<Arc<BlobTransactionSidecarVariant>>, BlobStoreError>

Returns the [BlobTransactionSidecarVariant] for the given transaction hash if it exists in the blob store.

fn get_all_blobs( &self, tx_hashes: Vec<B256>, ) -> Result<Vec<(B256, Arc<BlobTransactionSidecarVariant>)>, BlobStoreError>

Returns all [BlobTransactionSidecarVariant] for the given transaction hashes if they exists in the blob store.

fn get_all_blobs_exact( &self, tx_hashes: Vec<B256>, ) -> Result<Vec<Arc<BlobTransactionSidecarVariant>>, BlobStoreError>

Returns the exact [BlobTransactionSidecarVariant] for the given transaction hashes in the order they were requested.

fn get_blobs_for_versioned_hashes_v1( &self, versioned_hashes: &[B256], ) -> Result<Vec<Option<BlobAndProofV1>>, BlobStoreError>

Return the [BlobAndProofV1]s for a list of blob versioned hashes.

fn get_blobs_for_versioned_hashes_v2( &self, versioned_hashes: &[B256], ) -> Result<Option<Vec<BlobAndProofV2>>, BlobStoreError>

Return the [BlobAndProofV2]s for a list of blob versioned hashes. Blobs and proofs are returned only if they are present for all of the requested versioned hashes.

fn get_blobs_for_versioned_hashes_v3( &self, versioned_hashes: &[B256], ) -> Result<Vec<Option<BlobAndProofV2>>, BlobStoreError>

Return the [BlobAndProofV2]s for a list of blob versioned hashes.

fn add_external_transaction( &self, transaction: Self::Transaction, ) -> impl Future<Output = Result<AddedTransactionOutcome, PoolError>> + Send

Imports an external transaction.

fn add_external_transactions( &self, transactions: Vec<Self::Transaction>, ) -> impl Future<Output = Vec<Result<AddedTransactionOutcome, PoolError>>> + Send

Imports all external transactions

fn add_consensus_transaction( &self, tx: Recovered<<Self::Transaction as PoolTransaction>::Consensus>, origin: TransactionOrigin, ) -> impl Future<Output = Result<AddedTransactionOutcome, PoolError>> + Send

Submit a consensus transaction directly to the pool

fn add_consensus_transaction_and_subscribe( &self, tx: Recovered<<Self::Transaction as PoolTransaction>::Consensus>, origin: TransactionOrigin, ) -> impl Future<Output = Result<TransactionEvents, PoolError>> + Send

Submit a consensus transaction and subscribe to event stream

fn pending_transactions_listener(&self) -> Receiver<FixedBytes<32>>

Returns a new Stream that yields transactions hashes for new pending transactions inserted into the pool that are allowed to be propagated.

fn new_transactions_listener( &self, ) -> Receiver<NewTransactionEvent<Self::Transaction>>

Returns a new stream that yields new valid transactions added to the pool.

fn new_pending_pool_transactions_listener( &self, ) -> NewSubpoolTransactionStream<Self::Transaction>

Returns a new Stream that yields new transactions added to the pending sub-pool.

fn new_basefee_pool_transactions_listener( &self, ) -> NewSubpoolTransactionStream<Self::Transaction>

Returns a new Stream that yields new transactions added to the basefee sub-pool.

fn new_queued_transactions_listener( &self, ) -> NewSubpoolTransactionStream<Self::Transaction>

Returns a new Stream that yields new transactions added to the queued-pool.

fn new_blob_pool_transactions_listener( &self, ) -> NewSubpoolTransactionStream<Self::Transaction>

Returns a new Stream that yields new transactions added to the blob sub-pool.

fn get_pending_transaction_by_sender_and_nonce( &self, sender: Address, nonce: u64, ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns a pending transaction if it exists and is ready for immediate execution (i.e., has the lowest nonce among the sender’s pending transactions).

fn remove_transaction( &self, hash: FixedBytes<32>, ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>>

Removes a single transaction corresponding to the given hash.

fn prune_transaction( &self, hash: FixedBytes<32>, ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>>

Prunes a single transaction from the pool.

fn get_local_transactions( &self, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all transactions that where submitted as [TransactionOrigin::Local]

fn get_private_transactions( &self, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all transactions that where submitted as [TransactionOrigin::Private]

fn get_external_transactions( &self, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all transactions that where submitted as [TransactionOrigin::External]

fn get_local_pending_transactions( &self, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all pending transactions that where submitted as [TransactionOrigin::Local]

fn get_private_pending_transactions( &self, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all pending transactions that where submitted as [TransactionOrigin::Private]

fn get_external_pending_transactions( &self, ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns all pending transactions that where submitted as [TransactionOrigin::External]

impl<Client> TransactionPoolExt for TempoTransactionPool<Client>

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

type Block = Block<TempoTxEnvelope, TempoHeader>

The block type used for chain tip updates.

fn set_block_info(&self, info: BlockInfo)

Sets the current block info for the pool.

fn on_canonical_state_change( &self, update: CanonicalStateUpdate<'_, Self::Block>, )

Event listener for when the pool needs to be updated.

fn update_accounts(&self, accounts: Vec<ChangedAccount>)

Updates the accounts in the pool

fn delete_blob(&self, tx: B256)

Deletes the blob sidecar for the given transaction from the blob store

fn delete_blobs(&self, txs: Vec<B256>)

Deletes multiple blob sidecars from the blob store

fn cleanup_blobs(&self)

Maintenance function to cleanup blobs that are no longer needed.

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