Struct txpool::Pool

pub struct Pool<T: VerifiedTransaction, S: Scoring<T>, L = NoopListener> { /* private fields */ }

A transaction pool.

Implementations

impl<T: VerifiedTransaction, S: Scoring<T> + Default> Pool<T, S>

pub fn with_options(options: Options) -> Self

Creates a new Pool with given options and default Scoring and Listener.

impl<T: VerifiedTransaction, S: Scoring<T>> Pool<T, S>

pub fn with_scoring(scoring: S, options: Options) -> Self

Creates a new Pool with given Scoring and options.

impl<T, S, L> Pool<T, S, L> where
    T: VerifiedTransaction,
    S: Scoring<T>,
    L: Listener<T>, 

pub fn new(listener: L, scoring: S, options: Options) -> Self

Creates new Pool with given Scoring, Listener and options.

pub fn import(
    &mut self,
    transaction: T,
    replace: &dyn ShouldReplace<T>
) -> Result<Arc<T>, Error<T::Hash>>

Attempts to import new transaction to the pool, returns a Arc<T> or an Error.

NOTE: Since Readyness is separate from the pool it’s possible to import stalled transactions. It’s the caller responsibility to make sure that’s not the case.

NOTE: The transaction may push out some other transactions from the pool either because of limits (see Options) or because Scoring decides that the transaction replaces an existing transaction from that sender.

If any limit is reached the transaction with the lowest Score will be compared with the new transaction via the supplied ShouldReplace implementation and may be evicted.

The Listener will be informed on any drops or rejections.

pub fn clear(&mut self)

Clears pool from all transactions. This causes a listener notification that all transactions were dropped. NOTE: the drop-notification order will be arbitrary.

pub fn remove(&mut self, hash: &T::Hash, is_invalid: bool) -> Option<Arc<T>>

Removes single transaction from the pool. Depending on the is_invalid flag the listener will either get a cancelled or invalid notification.

pub fn cull<R: Ready<T>>(
    &mut self,
    senders: Option<&[T::Sender]>,
    ready: R
) -> usize

Removes all stalled transactions from given sender list (or from all senders).

pub fn find(&self, hash: &T::Hash) -> Option<Arc<T>>

Returns a transaction if it’s part of the pool or None otherwise.

pub fn worst_transaction(&self) -> Option<Arc<T>>

Returns worst transaction in the queue (if any).

pub fn is_full(&self) -> bool

Returns true if the pool is at it’s capacity.

pub fn senders(&self) -> impl Iterator<Item = &T::Sender>

Returns senders ordered by priority of their transactions.

pub fn pending<R: Ready<T>>(
    &self,
    ready: R,
    includable_boundary: S::Score
) -> PendingIterator<'_, T, R, S, L>

Returns an iterator of pending (ready) transactions.

pub fn pending_from_sender<R: Ready<T>>(
    &self,
    ready: R,
    sender: &T::Sender,
    includable_boundary: S::Score
) -> PendingIterator<'_, T, R, S, L>

Returns pending (ready) transactions from given sender.

pub fn unordered_pending<R: Ready<T>>(
    &self,
    ready: R,
    includable_boundary: S::Score
) -> UnorderedIterator<'_, T, R, S>

Returns unprioritized list of ready transactions.

pub fn update_scores(&mut self, sender: &T::Sender, event: S::Event)

Update score of transactions of a particular sender.

pub fn status<R: Ready<T>>(&self, ready: R) -> Status

Computes the full status of the pool (including readiness).

pub fn light_status(&self) -> LightStatus

Returns light status of the pool.

pub fn options(&self) -> Options

Returns current pool options.

pub fn listener(&self) -> &L

Borrows listener instance.

pub fn scoring(&self) -> &S

Borrows scoring instance.

pub fn set_scoring(&mut self, scoring: S, event: S::Event)

Set scoring instance.

pub fn listener_mut(&mut self) -> &mut L

Borrows listener mutably.

Trait Implementations

impl<T: Debug + VerifiedTransaction, S: Debug + Scoring<T>, L: Debug> Debug for Pool<T, S, L> where
    T::Sender: Debug,
    T::Hash: Debug,
    S::Score: Debug,
    S::Score: Debug, 

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

Formats the value using the given formatter.

impl<T: VerifiedTransaction, S: Scoring<T> + Default> Default for Pool<T, S>

fn default() -> Self

Returns the “default value” for a type.