Struct Mempool 

pub struct Mempool { /* private fields */ }

Implementations

impl Mempool

pub fn new(max_mempool_size: usize) -> Self

pub fn with_max_blob_mempool_size(self, max_blob_mempool_size: usize) -> Self

Override the blob sub-pool capacity (defaults to MAX_BLOB_MEMPOOL_SIZE). Builder-style; intended for configuration and tests.

pub fn add_transaction( &self, hash: H256, sender: Address, transaction: MempoolTransaction, ) -> Result<(), StoreError>

Add transaction to the pool without doing validity checks

pub fn get_txs_for_broadcast( &self, ) -> Result<Vec<MempoolTransaction>, StoreError>

pub fn remove_broadcasted_txs(&self, hashes: &[H256]) -> Result<(), StoreError>

pub fn blob_txs(&self) -> Result<Vec<(H256, Address, u64)>, StoreError>

(hash, sender, nonce) for every blob tx in the pool. blobs_bundle_pool is keyed by blob-tx hash, so its keys are exactly the held blob txs.

pub fn add_blobs_bundle( &self, tx_hash: H256, blobs_bundle: BlobsBundle, ) -> Result<(), StoreError>

Add a blobs bundle to the pool by its blob transaction hash

pub fn get_blobs_bundle( &self, tx_hash: H256, ) -> Result<Option<BlobsBundle>, StoreError>

Get a blobs bundle to the pool given its blob transaction hash

pub fn remove_transaction(&self, hash: &H256) -> Result<(), StoreError>

Remove a transaction from the pool

pub fn filter_transactions( &self, filter: &PendingTxFilter, ) -> Result<FxHashMap<Address, Vec<MempoolTransaction>>, StoreError>

Applies the filter and returns a set of suitable transactions from the mempool. These transactions will be grouped by sender and sorted by nonce

pub fn get_all_txs_by_sender( &self, ) -> Result<FxHashMap<Address, Vec<MempoolTransaction>>, StoreError>

Gets all the transactions in the mempool

pub fn filter_transactions_with_filter_fn( &self, filter: &dyn Fn(&Transaction) -> bool, ) -> Result<FxHashMap<Address, Vec<MempoolTransaction>>, StoreError>

Applies the filter and returns a set of suitable transactions from the mempool. These transactions will be grouped by sender and sorted by nonce

pub fn reserve_unknown_hashes( &self, hashes: &[H256], types: &[u8], sizes: &[usize], announcer: H256, ) -> Result<Vec<H256>, StoreError>

Filters hashes to those not already in the mempool or in-flight, and atomically marks the returned hashes as in-flight under a single write lock so that concurrent peer handlers cannot request the same hashes.

For hashes that get filtered out because they’re already in-flight from another peer, records announcer as a fallback so the request can be retried against this peer if the original responder fails. New hashes that the caller is about to request do not need an alternates entry yet: the caller is the primary, and one will be created only if some other peer later announces the same hash while it’s in-flight. Reserve hashes the caller wants to request, returning only those that are neither already in-flight nor already in the pool. Any hash filtered out because it’s in-flight from another peer is registered with the caller’s own (type, size) metadata as an alternate, so a later retry can validate the response against this announcer’s announcement.

hashes, types, and sizes must be the same length (one entry per announced hash).

pub fn clear_in_flight_txs(&self, hashes: &[H256]) -> Result<(), StoreError>

Removes transaction hashes from the in-flight set, typically called when the GetPooledTransactions response arrives (or the connection drops).

pub fn pop_alternate(&self, hash: H256) -> Result<Option<Alternate>, StoreError>

Pops the next alternate announcer for the given hash, if any. Returns Ok(None) when no alternates remain. The caller uses the popped Alternate to look up the peer connection and build a retry request against that peer’s own announcement metadata.

pub fn prune_alternates(&self, ttl: Duration) -> Result<(), StoreError>

Drop alternates entries that haven’t been touched in the last ttl. Called periodically to bound the size of the alternates map when announced txs never make it into the pool.

pub fn get_transaction_by_hash( &self, transaction_hash: H256, ) -> Result<Option<Transaction>, StoreError>

pub fn get_nonce(&self, address: &Address) -> Result<Option<u64>, MempoolError>

pub fn get_mempool_size(&self) -> Result<(u64, u64), MempoolError>

pub fn content(&self) -> Result<Vec<Transaction>, MempoolError>

Returns all transactions currently in the pool

pub fn get_blobs_bundle_pool(&self) -> Result<Vec<BlobsBundle>, MempoolError>

Returns all blobs bundles currently in the pool

pub fn get_blobs_data_by_versioned_hashes( &self, versioned_hashes: &[H256], ) -> Result<Vec<Option<BlobTuple>>, MempoolError>

Returns blobs data (blob, commitment, proof) associated with the versioned hashes

pub fn status(&self) -> Result<u64, MempoolError>

Returns the status of the mempool, which is the number of transactions currently in the pool. Until we add “queue” transactions.

pub fn contains_sender_nonce( &self, sender: Address, nonce: u64, received_hash: H256, ) -> Result<Option<MempoolTransaction>, MempoolError>

pub fn contains_tx(&self, tx_hash: H256) -> Result<bool, MempoolError>

pub fn find_tx_to_replace( &self, sender: Address, nonce: u64, tx: &Transaction, ) -> Result<Option<H256>, MempoolError>

Trait Implementations

impl Debug for Mempool

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

Formats the value using the given formatter.

impl Default for Mempool

fn default() -> Mempool

Returns the “default value” for a type.