Struct sc_transaction_graph::Pool

pub struct Pool<B: ChainApi> { /* private fields */ }

Extrinsics pool that performs validation.

Implementations

impl<B: ChainApi> Pool<B>

pub fn new(options: Options, is_validator: IsValidator, api: Arc<B>) -> Self

Create a new transaction pool.

pub async fn submit_at(
    &self,
    at: &BlockId<B::Block>,
    source: TransactionSource,
    xts: impl IntoIterator<Item = ExtrinsicFor<B>>
) -> Result<Vec<Result<ExtrinsicHash<B>, B::Error>>, B::Error>

Imports a bunch of unverified extrinsics to the pool

pub async fn resubmit_at(
    &self,
    at: &BlockId<B::Block>,
    source: TransactionSource,
    xts: impl IntoIterator<Item = ExtrinsicFor<B>>
) -> Result<Vec<Result<ExtrinsicHash<B>, B::Error>>, B::Error>

Resubmit the given extrinsics to the pool.

This does not check if a transaction is banned, before we verify it again.

pub async fn submit_one(
    &self,
    at: &BlockId<B::Block>,
    source: TransactionSource,
    xt: ExtrinsicFor<B>
) -> Result<ExtrinsicHash<B>, B::Error>

Imports one unverified extrinsic to the pool

pub async fn submit_and_watch(
    &self,
    at: &BlockId<B::Block>,
    source: TransactionSource,
    xt: ExtrinsicFor<B>
) -> Result<Watcher<ExtrinsicHash<B>, ExtrinsicHash<B>>, B::Error>

Import a single extrinsic and starts to watch their progress in the pool.

pub fn resubmit(
    &self,
    revalidated_transactions: HashMap<ExtrinsicHash<B>, ValidatedTransaction<ExtrinsicHash<B>, ExtrinsicFor<B>, <B as ChainApi>::Error>>
)

Resubmit some transaction that were validated elsewhere.

pub fn prune_known(
    &self,
    at: &BlockId<B::Block>,
    hashes: &[ExtrinsicHash<B>]
) -> Result<(), B::Error>

Prunes known ready transactions.

Used to clear the pool from transactions that were part of recently imported block. The main difference from the prune is that we do not revalidate any transactions and ignore unknown passed hashes.

pub async fn prune(
    &self,
    at: &BlockId<B::Block>,
    parent: &BlockId<B::Block>,
    extrinsics: &[ExtrinsicFor<B>]
) -> Result<(), B::Error>

Prunes ready transactions.

Used to clear the pool from transactions that were part of recently imported block. To perform pruning we need the tags that each extrinsic provides and to avoid calling into runtime too often we first lookup all extrinsics that are in the pool and get their provided tags from there. Otherwise we query the runtime at the parent block.

pub async fn prune_tags(
    &self,
    at: &BlockId<B::Block>,
    tags: impl IntoIterator<Item = Tag>,
    known_imported_hashes: impl IntoIterator<Item = ExtrinsicHash<B>> + Clone
) -> Result<(), B::Error>

Prunes ready transactions that provide given list of tags.

Given tags are assumed to be always provided now, so all transactions in the Future Queue that require that particular tag (and have other requirements satisfied) are promoted to Ready Queue.

Moreover for each provided tag we remove transactions in the pool that:

1. Provide that tag directly
2. Are a dependency of pruned transaction.

Returns transactions that have been removed from the pool and must be reverified before reinserting to the pool.

By removing predecessor transactions as well we might actually end up pruning too much, so all removed transactions are reverified against the runtime (validate_transaction) to make sure they are invalid.

However we avoid revalidating transactions that are contained within the second parameter of known_imported_hashes. These transactions (if pruned) are not revalidated and become temporarily banned to prevent importing them in the (near) future.

pub fn hash_of(&self, xt: &ExtrinsicFor<B>) -> ExtrinsicHash<B>

Returns transaction hash

pub fn validated_pool(&self) -> &ValidatedPool<B>

get a reference to the underlying validated pool.

Trait Implementations

impl<B: ChainApi> Clone for Pool<B>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: ChainApi> MallocSizeOf for Pool<B> where
    ExtrinsicFor<B>: MallocSizeOf, 

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself. If T::size_of is a constant, consider implementing constant_size as well.

fn constant_size() -> Option<usize>

Used to optimize MallocSizeOf implementation for collections like Vec and HashMap to avoid iterating over them unnecessarily. The Self: Sized bound is for object safety.