Struct PoolInner 

pub struct PoolInner<V, T, S>
where
    T: TransactionOrdering,
{ /* private fields */ }

Transaction pool internals.

Implementations

impl<V, T, S> PoolInner<V, T, S>

where V: TransactionValidator, T: TransactionOrdering<Transaction = <V as TransactionValidator>::Transaction>, S: BlobStore,

pub fn new(validator: V, ordering: T, blob_store: S, config: PoolConfig) -> Self

Create a new transaction pool instance.

pub const fn blob_store(&self) -> &S

Returns the configured blob store.

pub fn size(&self) -> PoolSize

Returns stats about the size of the pool.

pub fn block_info(&self) -> BlockInfo

Returns the currently tracked block

pub fn set_block_info(&self, info: BlockInfo)

Sets the currently tracked block

pub fn get_sender_id(&self, addr: Address) -> SenderId

Returns the internal SenderId for this address

pub fn get_sender_ids( &self, addrs: impl IntoIterator<Item = Address>, ) -> Vec<SenderId>

Returns the internal SenderIds for the given addresses.

pub fn unique_senders(&self) -> HashSet<Address>

Returns all senders in the pool

pub const fn config(&self) -> &PoolConfig

Get the config the pool was configured with.

pub const fn validator(&self) -> &V

Get the validator reference.

pub fn add_pending_listener( &self, kind: TransactionListenerKind, ) -> Receiver<TxHash>

Adds a new transaction listener to the pool that gets notified about every new pending transaction inserted into the pool

pub fn add_new_transaction_listener( &self, kind: TransactionListenerKind, ) -> Receiver<NewTransactionEvent<T::Transaction>>

Adds a new transaction listener to the pool that gets notified about every new transaction.

pub fn add_blob_sidecar_listener(&self) -> Receiver<NewBlobSidecar>

Adds a new blob sidecar listener to the pool that gets notified about every new eip4844 transaction’s blob sidecar.

pub fn add_transaction_event_listener( &self, tx_hash: TxHash, ) -> Option<TransactionEvents>

If the pool contains the transaction, this adds a new listener that gets notified about transaction events.

pub fn add_all_transactions_event_listener( &self, ) -> AllTransactionsEvents<T::Transaction>

Adds a listener for all transaction events.

pub fn get_pool_data(&self) -> RwLockReadGuard<'_, TxPool<T>>

Returns a read lock to the pool’s data.

pub fn pooled_transactions_hashes(&self) -> Vec<TxHash>

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

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

Returns transactions in the pool that can be propagated

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

Returns only the first max transactions in the pool that can be propagated.

pub fn get_pooled_transaction_elements( &self, tx_hashes: Vec<TxHash>, limit: GetPooledTransactionLimit, ) -> Vec<<<V as TransactionValidator>::Transaction as PoolTransaction>::Pooled>

where <V as TransactionValidator>::Transaction: EthPoolTransaction,

Returns pooled transactions for the given transaction hashes that are allowed to be propagated.

pub fn get_pooled_transaction_element( &self, tx_hash: TxHash, ) -> Option<Recovered<<<V as TransactionValidator>::Transaction as PoolTransaction>::Pooled>>

where <V as TransactionValidator>::Transaction: EthPoolTransaction,

Returns converted pooled transaction for the given transaction hash.

pub fn on_canonical_state_change<B>(&self, update: CanonicalStateUpdate<'_, B>)

where B: Block,

Updates the entire pool after a new block was executed.

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

Performs account updates on the pool.

This will either promote or discard transactions based on the new account state.

This should be invoked when the pool drifted and accounts are updated manually

pub fn add_transaction_and_subscribe( &self, origin: TransactionOrigin, tx: TransactionValidationOutcome<T::Transaction>, ) -> PoolResult<TransactionEvents>

Adds a transaction and returns the event stream.

pub fn add_transactions_with_origins( &self, transactions: impl IntoIterator<Item = (TransactionOrigin, TransactionValidationOutcome<T::Transaction>)>, ) -> Vec<PoolResult<AddedTransactionOutcome>>

Adds all transactions in the iterator to the pool, each with its individual origin, returning a list of results.

Note: A large batch may lock the pool for a long time that blocks important operations like updating the pool on canonical state changes. The caller should consider having a max batch size to balance transaction insertions with other updates.

pub fn add_transactions( &self, origin: TransactionOrigin, transactions: impl IntoIterator<Item = TransactionValidationOutcome<T::Transaction>>, ) -> Vec<PoolResult<AddedTransactionOutcome>>

Adds all transactions in the iterator to the pool, returning a list of results.

Note: A large batch may lock the pool for a long time that blocks important operations like updating the pool on canonical state changes. The caller should consider having a max batch size to balance transaction insertions with other updates.

pub fn best_transactions(&self) -> BestTransactions<T>

Returns an iterator that yields transactions that are ready to be included in the block.

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

Returns an iterator that yields transactions that are ready to be included in the block with the given base fee and optional blob fee attributes.

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

Returns only the first max transactions in the pending pool.

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

Returns all transactions from the pending sub-pool

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

Returns all transactions from parked pools

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

Returns all transactions in the pool

pub fn all_transaction_hashes(&self) -> Vec<TxHash>

Returns all transactions in the pool

pub fn remove_transactions( &self, hashes: Vec<TxHash>, ) -> Vec<Arc<ValidPoolTransaction<T::Transaction>>>

Removes and returns all matching transactions from the pool.

This behaves as if the transactions got discarded (not mined), effectively introducing a nonce gap for the given transactions.

pub fn remove_transactions_and_descendants( &self, hashes: Vec<TxHash>, ) -> Vec<Arc<ValidPoolTransaction<T::Transaction>>>

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

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

Removes and returns all transactions by the specified sender from the pool.

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

where A: HandleMempoolData,

Removes and returns all transactions that are present in the pool.

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

Returns the transaction by hash.

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

Returns all transactions of the address

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

Returns all queued transactions of the address by sender

pub fn pending_transactions_with_predicate( &self, predicate: impl FnMut(&ValidPoolTransaction<T::Transaction>) -> bool, ) -> Vec<Arc<ValidPoolTransaction<T::Transaction>>>

Returns all pending transactions filtered by predicate

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

Returns all pending transactions of the address by sender

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

Returns the highest transaction of the address

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

Returns the transaction with the highest nonce that is executable given the on chain nonce.

pub fn get_transaction_by_transaction_id( &self, transaction_id: &TransactionId, ) -> Option<Arc<ValidPoolTransaction<T::Transaction>>>

Returns the transaction given a TransactionId

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

Returns all transactions that where submitted with the given TransactionOrigin

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

Returns all pending transactions filtered by TransactionOrigin

pub fn get_all( &self, txs: Vec<TxHash>, ) -> Vec<Arc<ValidPoolTransaction<T::Transaction>>>

Returns all the transactions belonging to the hashes.

If no transaction exists, it is skipped.

pub fn on_propagated(&self, txs: PropagatedTransactions)

Notify about propagated transactions.

pub fn len(&self) -> usize

Number of transactions in the entire pool

pub fn is_empty(&self) -> bool

Whether the pool is empty

pub fn is_exceeded(&self) -> bool

Returns whether or not the pool is over its configured size and transaction count limits.

pub fn delete_blob(&self, blob: TxHash)

Delete a blob from the blob store

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

Delete all blobs from the blob store

pub fn cleanup_blobs(&self)

Cleans up the blob store

Trait Implementations

impl<V, T: TransactionOrdering, S> Debug for PoolInner<V, T, S>

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

Formats the value using the given formatter.

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.