Struct PendingPool

pub struct PendingPool<T>
where
    T: TransactionOrdering,
{ /* private fields */ }

A pool of validated and gapless transactions that are ready to be executed on the current state and are waiting to be included in a block.

This pool distinguishes between independent transactions and pending transactions. A transaction is independent, if it is in the pending pool, and it has the current on chain nonce of the sender. Meaning independent transactions can be executed right away, other pending transactions depend on at least one independent transaction.

Once an independent transaction was executed it unlocks the next nonce, if this transaction is also pending, then this will be moved to the independent queue.

Implementations

impl<T> PendingPool<T>

where T: TransactionOrdering,

pub fn new(ordering: T) -> PendingPool<T>

Create a new pool instance.

pub fn add_transaction( &mut self, tx: Arc<ValidPoolTransaction<<T as TransactionOrdering>::Transaction>>, base_fee: u64, )

Adds a new transactions to the pending queue.

Panics

if the transaction is already included

pub fn remove_to_limit( &mut self, limit: &SubPoolLimit, remove_locals: bool, end_removed: &mut Vec<Arc<ValidPoolTransaction<<T as TransactionOrdering>::Transaction>>>, )

Traverses the pool, starting at the highest nonce set, removing the transactions which would put the pool under the specified limits.

This attempts to remove transactions by roughly the same amount for each sender. This is done by removing the highest-nonce transactions for each sender.

If the remove_locals flag is unset, transactions will be removed per-sender until a local transaction is the highest nonce transaction for that sender. If all senders have a local highest-nonce transaction, the pool will not be truncated further.

Otherwise, if the remove_locals flag is set, transactions will be removed per-sender until the pool is under the given limits.

Any removed transactions will be added to the end_removed vector.

pub fn truncate_pool( &mut self, limit: SubPoolLimit, ) -> Vec<Arc<ValidPoolTransaction<<T as TransactionOrdering>::Transaction>>>

Truncates the pool to the given SubPoolLimit, removing transactions until the subpool limits are met.

This attempts to remove transactions by roughly the same amount for each sender. For more information on this exact process see docs for remove_to_limit.

This first truncates all of the non-local transactions in the pool. If the subpool is still not under the limit, this truncates the entire pool, including non-local transactions. The removed transactions are returned.

Trait Implementations

impl<T> Clone for PendingPool<T>

where T: Clone + TransactionOrdering,

fn clone(&self) -> PendingPool<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for PendingPool<T>

where T: Debug + TransactionOrdering,

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

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.