Struct AA2dPool 

pub struct AA2dPool {
    submission_id: u64,
    independent_transactions: HashMap<AASequenceId, PendingTransaction<CoinbaseTipOrdering<TempoPooledTransaction>>>,
    by_id: BTreeMap<AA2dTransactionId, Arc<AA2dInternalTransaction>>,
    by_hash: HashMap<TxHash, Arc<ValidPoolTransaction<TempoPooledTransaction>>>,
    expiring_nonce_txs: HashMap<B256, PendingTransaction<CoinbaseTipOrdering<TempoPooledTransaction>>>,
    slot_to_seq_id: U256Map<AASequenceId>,
    seq_id_to_slot: HashMap<AASequenceId, U256>,
    config: AA2dPoolConfig,
    metrics: AA2dPoolMetrics,
    by_eviction_order: BTreeSet<EvictionKey>,
    txs_by_sender: AddressMap<usize>,
}

A sub-pool that keeps track of 2D nonce transactions.

It maintains both pending and queued transactions.

A 2d nonce transaction is pending if it dosn’t have a nonce gap for its nonce key, and is queued if its nonce key set has nonce gaps.

This pool relies on state changes to track the nonces.

Limitations

• We assume new AA transactions either create a new nonce key (nonce 0) or use an existing nonce key. To keep track of the known keys by accounts this pool relies on state changes to promote transactions to pending.

Fields

submission_id: u64

Keeps track of transactions inserted in the pool.

This way we can determine when transactions were submitted to the pool.

independent_transactions: HashMap<AASequenceId, PendingTransaction<CoinbaseTipOrdering<TempoPooledTransaction>>>

independent, pending, executable transactions, one per sequence id.

by_id: BTreeMap<AA2dTransactionId, Arc<AA2dInternalTransaction>>

All transactions that are currently inside the pool grouped by their unique identifier.

by_hash: HashMap<TxHash, Arc<ValidPoolTransaction<TempoPooledTransaction>>>

All transactions by hash.

expiring_nonce_txs: HashMap<B256, PendingTransaction<CoinbaseTipOrdering<TempoPooledTransaction>>>

Expiring nonce transactions, keyed by expiring nonce hash (always pending/independent). These use expiring nonce replay protection instead of sequential nonces.

slot_to_seq_id: U256Map<AASequenceId>

Reverse index for the storage slot of an account’s nonce

 mapping(address => mapping(uint256 => uint64)) public nonces

This identifies the account and nonce key based on the slot in the NonceManager.

seq_id_to_slot: HashMap<AASequenceId, U256>

Reverse index for cleaning up slots_to_seq_id.

config: AA2dPoolConfig

Settings for this sub-pool.

metrics: AA2dPoolMetrics

Metrics for tracking pool statistics

by_eviction_order: BTreeSet<EvictionKey>

All transactions ordered by eviction priority (lowest priority first).

Since Tempo has a constant base fee, priority never changes after insertion, so we can maintain this ordering incrementally. At eviction time, we scan this set checking is_pending to find queued or pending transactions.

txs_by_sender: AddressMap<usize>

Tracks the number of transactions per sender for DoS protection.

Bounded by pool size (max unique senders = pending_limit + queued_limit). Entries are removed when count reaches 0 via decrement_sender_count.

Implementations

impl AA2dPool

fn expiring_nonce_hash( transaction: &Arc<ValidPoolTransaction<TempoPooledTransaction>>, ) -> B256

pub fn new(config: AA2dPoolConfig) -> Self

Creates a new instance with the givenconfig and nonce keys

fn update_metrics(&self)

Updates all metrics to reflect the current state of the pool

pub(crate) fn add_transaction( &mut self, transaction: Arc<ValidPoolTransaction<TempoPooledTransaction>>, on_chain_nonce: u64, hardfork: TempoHardfork, ) -> PoolResult<AddedTransaction<TempoPooledTransaction>>

Entrypoint for adding a 2d AA transaction.

on_chain_nonce is expected to be the nonce of the sender at the time of validation. If transaction is using 2D nonces, this is expected to be the nonce corresponding to the transaction’s nonce key.

hardfork indicates the active Tempo hardfork. When T1 or later, expiring nonce transactions (nonce_key == U256::MAX) are handled specially. Otherwise, they are treated as regular 2D nonce transactions.

fn add_expiring_nonce_transaction( &mut self, transaction: Arc<ValidPoolTransaction<TempoPooledTransaction>>, hardfork: TempoHardfork, ) -> PoolResult<AddedTransaction<TempoPooledTransaction>>

Adds an expiring nonce transaction to the pool.

Expiring nonce transactions use the expiring nonce hash as their unique identifier instead of (sender, nonce_key, nonce). They are always immediately pending since they don’t have sequential nonce dependencies.

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

Returns how many pending and queued transactions are in the pool.

pub(crate) fn get_transactions_by_origin_iter( &self, origin: TransactionOrigin, ) -> impl Iterator<Item = Arc<ValidPoolTransaction<TempoPooledTransaction>>> + '_

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

pub(crate) fn get_pending_transactions_by_origin_iter( &self, origin: TransactionOrigin, ) -> impl Iterator<Item = Arc<ValidPoolTransaction<TempoPooledTransaction>>> + '_

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

pub(crate) fn get_transactions_by_sender_iter( &self, sender: Address, ) -> impl Iterator<Item = Arc<ValidPoolTransaction<TempoPooledTransaction>>> + '_

Returns all transactions of the address

pub(crate) fn all_transaction_hashes_iter(&self) -> impl Iterator<Item = TxHash>

Returns an iterator over all transaction hashes in this pool

pub(crate) fn queued_transactions( &self, ) -> impl Iterator<Item = Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Returns all transactions from that are queued.

pub(crate) fn pending_transactions( &self, ) -> impl Iterator<Item = Arc<ValidPoolTransaction<TempoPooledTransaction>>> + '_

Returns all transactions that are pending.

pub(crate) fn best_transactions(&self) -> BestAA2dTransactions

Returns the best, executable transactions for this sub-pool

pub(crate) fn get( &self, tx_hash: &TxHash, ) -> Option<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Returns the transaction by hash.

pub(crate) fn get_all<'a, I>( &self, tx_hashes: I, ) -> Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

where I: Iterator<Item = &'a TxHash> + 'a,

Returns the transaction by hash.

pub(crate) fn append_pooled_transaction_elements<'a>( &self, tx_hashes: impl IntoIterator<Item = &'a TxHash>, limit: GetPooledTransactionLimit, accumulated_size: &mut usize, out: &mut Vec<<TempoPooledTransaction as PoolTransaction>::Pooled>, )

Returns pooled transaction elements for the given hashes while respecting the size limit.

This method collects transactions from the pool, converts them to pooled format, and tracks the accumulated size. It stops collecting when the limit is exceeded.

The accumulated_size is updated with the total encoded size of returned transactions.

pub(crate) fn senders_iter(&self) -> impl Iterator<Item = &Address>

Returns an iterator over all senders in this pool.

fn descendant_txs<'a, 'b: 'a>( &'a self, id: &'b AA2dTransactionId, ) -> impl Iterator<Item = (&'a AA2dTransactionId, &'a Arc<AA2dInternalTransaction>)> + 'a

Returns all transactions that follow after the given id but have the same sender.

NOTE: The range is inclusive: if the transaction that belongs to id it will be the first value.

fn descendant_txs_exclusive<'a, 'b: 'a>( &'a self, id: &'b AA2dTransactionId, ) -> impl Iterator<Item = (&'a AA2dTransactionId, &'a Arc<AA2dInternalTransaction>)> + 'a

Returns all transactions that follow after the given id and have the same sender.

NOTE: The range is exclusive

fn remove_transaction_by_id( &mut self, id: &AA2dTransactionId, ) -> Option<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Removes the transaction with the given id from all sets.

This does not shift the independent transaction forward or mark descendants as pending.

fn decrement_sender_count(&mut self, sender: Address)

Decrements the transaction count for a sender, removing the entry if it reaches zero.

fn remove_independent( &mut self, id: &AA2dTransactionId, ) -> Option<PendingTransaction<CoinbaseTipOrdering<TempoPooledTransaction>>>

Removes the independent transaction if it matches the given id.

pub(crate) fn remove_transactions<'a, I>( &mut self, tx_hashes: I, ) -> Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

where I: Iterator<Item = &'a TxHash> + 'a,

Removes the transaction by its hash from all internal sets.

This batches demotion by seq_id to avoid O(N*N) complexity when removing many transactions from the same sequence.

fn remove_transaction_by_hash( &mut self, tx_hash: &B256, ) -> Option<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Removes the transaction by its hash from all internal sets.

This does not shift the independent transaction forward but it does demote descendants to queued status since removing a transaction creates a nonce gap.

fn remove_transaction_by_hash_no_demote( &mut self, tx_hash: &B256, ) -> Option<(Arc<ValidPoolTransaction<TempoPooledTransaction>>, Option<AA2dTransactionId>)>

Internal helper that removes a transaction without demoting descendants.

Returns the removed transaction and its AA2dTransactionId (if it was a 2D nonce tx).

fn demote_descendants(&mut self, id: &AA2dTransactionId)

Demotes all descendants of the given transaction to queued status (is_pending = false).

This should be called after removing a transaction to ensure descendants don’t remain marked as pending when they’re no longer executable due to the nonce gap.

fn demote_from_nonce(&self, seq_id: &AASequenceId, min_nonce: u64)

Demotes all transactions for a seq_id with nonce > min_nonce to queued status.

This is used both for single-tx removal (demote_descendants) and batch removal where we want to demote once per seq_id starting from the minimum removed nonce.

pub(crate) fn remove_transactions_and_descendants<'a, I>( &mut self, hashes: I, ) -> Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

where I: Iterator<Item = &'a TxHash> + 'a,

Removes and returns all matching transactions and their dependent transactions from the pool.

pub(crate) fn remove_transactions_by_sender( &mut self, sender_id: Address, ) -> Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Removes all transactions from the given sender.

fn remove_descendants( &mut self, tx: &AA2dTransactionId, removed: &mut Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>, )

Removes only the descendants of the given transaction from this pool.

All removed transactions are added to the removed vec.

pub(crate) fn on_nonce_changes( &mut self, on_chain_ids: HashMap<AASequenceId, u64>, ) -> (Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>, Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>)

Updates the internal state based on the state changes of the NonceManager NONCE_PRECOMPILE_ADDRESS.

This takes a vec of changed AASequenceId with their current on chain nonce.

This will prune mined transactions and promote unblocked transactions if any, returns (promoted, mined)

fn discard(&mut self) -> Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Removes lowest-priority transactions if the pool is above capacity.

This evicts transactions with the lowest priority (based on [CoinbaseTipOrdering]) to prevent DoS attacks where adversaries use vanity addresses with many leading zeroes to avoid eviction.

Evicts queued transactions first (up to queued_limit), then pending if needed. Counts are computed lazily by scanning the eviction set.

Note: Only max_txs is enforced here; max_size is intentionally not checked for 2D pools since the protocol pool already enforces size-based limits as a primary defense.

fn evict_lowest_priority( &mut self, count: usize, evict_pending: bool, ) -> Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Evicts the lowest-priority transactions from the pool.

Scans the single eviction set (ordered by priority) and filters by is_pending to find queued or pending transactions to evict. This is a best-effort scan that checks a bool for each transaction.

fn evict_one_pending( &mut self, ) -> Option<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Evicts one pending transaction, considering both regular 2D and expiring nonce txs. Evicts the transaction with lowest priority; ties broken by submission order (newer first).

fn evict_2d_pending_tx( &mut self, id: &AA2dTransactionId, ) -> Option<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Evicts a regular 2D pending transaction by ID.

fn evict_expiring_nonce_tx( &mut self, expiring_hash: &B256, ) -> Option<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Evicts an expiring nonce transaction by hash.

pub fn metrics(&self) -> &AA2dPoolMetrics

Returns a reference to the metrics for this pool

pub(crate) fn remove_included_expiring_nonce_txs<'a>( &mut self, tx_hashes: impl Iterator<Item = &'a TxHash>, ) -> Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Removes expiring nonce transactions that were included in a block.

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

pub(crate) fn contains(&self, tx_hash: &TxHash) -> bool

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

pub(crate) fn pooled_transactions_hashes_iter( &self, ) -> impl Iterator<Item = TxHash>

Returns hashes of transactions in the pool that can be propagated.

pub(crate) fn pooled_transactions_iter( &self, ) -> impl Iterator<Item = Arc<ValidPoolTransaction<TempoPooledTransaction>>>

Returns transactions in the pool that can be propagated

const fn next_id(&mut self) -> u64

fn record_2d_slot(&mut self, transaction: &TempoPooledTransaction)

Caches the 2D nonce key slot for the given sender and nonce key.

pub(crate) fn on_state_updates( &mut self, state: &AddressMap<BundleAccount>, ) -> (Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>, Vec<Arc<ValidPoolTransaction<TempoPooledTransaction>>>)

Processes state updates and updates internal state accordingly.

Trait Implementations

impl Debug for AA2dPool

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

Formats the value using the given formatter.

impl Default for AA2dPool

fn default() -> Self

Returns the “default value” for a type.

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