Struct Pool 

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

A shareable, generic, customizable TransactionPool implementation.

Implementations

impl<V, T, S> Pool<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 fn config(&self) -> &PoolConfig

Get the config the pool was configured with.

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 blob_store(&self) -> &S

Returns the configured blob store.

impl<Client, S> Pool<TransactionValidationTaskExecutor<EthTransactionValidator<Client, EthPooledTransaction>>, CoinbaseTipOrdering<EthPooledTransaction>, S>

where Client: ChainSpecProvider<ChainSpec: EthereumHardforks> + StateProviderFactory + Clone + 'static, S: BlobStore,

pub fn eth_pool( validator: TransactionValidationTaskExecutor<EthTransactionValidator<Client, EthPooledTransaction>>, blob_store: S, config: PoolConfig, ) -> Self

Returns a new Pool that uses the default TransactionValidationTaskExecutor when validating EthPooledTransactions and ords via CoinbaseTipOrdering

Example

use reth_chainspec::MAINNET;
use reth_storage_api::StateProviderFactory;
use reth_tasks::TokioTaskExecutor;
use reth_chainspec::ChainSpecProvider;
use reth_transaction_pool::{
    blobstore::InMemoryBlobStore, Pool, TransactionValidationTaskExecutor,
};
use reth_chainspec::EthereumHardforks;
let blob_store = InMemoryBlobStore::default();
let pool = Pool::eth_pool(
    TransactionValidationTaskExecutor::eth(
        client,
        blob_store.clone(),
        TokioTaskExecutor::default(),
    ),
    blob_store,
    Default::default(),
);

Trait Implementations

impl<V, T: TransactionOrdering, S> Clone for Pool<V, T, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug, T: Debug + TransactionOrdering, S: Debug> Debug for Pool<V, T, S>

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

Formats the value using the given formatter.

impl<V, T, S> TransactionPool for Pool<V, T, S>

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

implements the TransactionPool interface for various transaction pool API consumers.

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

Returns all pending transactions filtered by TransactionOrigin

type Transaction = <T as TransactionOrdering>::Transaction

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 multiple unvalidated transactions with individual origins.

fn transaction_event_listener( &self, tx_hash: TxHash, ) -> 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<TxHash>

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<TxHash>

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

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

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<TxHash>, limit: GetPooledTransactionLimit, ) -> Vec<<<V as TransactionValidator>::Transaction as PoolTransaction>::Pooled>

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

fn get_pooled_transaction_element( &self, tx_hash: TxHash, ) -> Option<Recovered<<<V as TransactionValidator>::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, best_transactions_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<TxHash>

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

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

Removes all transactions corresponding to the given hashes.

fn remove_transactions_and_descendants( &self, hashes: Vec<TxHash>, ) -> 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 retain_unknown<A>(&self, announcement: &mut A)

where A: HandleMempoolData,

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 get( &self, tx_hash: &TxHash, ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>>

Returns the transaction for the given hash.

fn get_all( &self, txs: Vec<TxHash>, ) -> 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 unique_senders(&self) -> HashSet<Address>

Returns a set of all senders of transactions in the pool

fn get_blob( &self, tx_hash: TxHash, ) -> 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<TxHash>, ) -> Result<Vec<(TxHash, 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<TxHash>, ) -> 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 add_external_transaction( &self, transaction: Self::Transaction, ) -> impl Future<Output = PoolResult<AddedTransactionOutcome>> + Send

Imports an external transaction.

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

Imports all external transactions

fn add_consensus_transaction( &self, tx: Recovered<<Self::Transaction as PoolTransaction>::Consensus>, origin: TransactionOrigin, ) -> impl Future<Output = PoolResult<AddedTransactionOutcome>> + 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 = PoolResult<TransactionEvents>> + Send

Submit a consensus transaction and subscribe to event stream

fn pending_transactions_listener(&self) -> Receiver<TxHash>

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 remove_transaction( &self, hash: TxHash, ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>>

Removes a single transaction corresponding to the given hash.

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

Returns if the transaction for the given hash is already included in this 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<V, T, S> TransactionPoolExt for Pool<V, T, S>

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

fn set_block_info(&self, info: BlockInfo)

Sets the current block info for the pool.

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

where B: 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: TxHash)

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

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

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