Struct sc_transaction_graph::Pool

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

Extrinsics pool that performs validation.

Methods

impl<B: ChainApi> Pool<B>

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

Create a new transaction pool.

pub async fn submit_at<'_, '_, T>(
    &'_ self,
    at: &'_ BlockId<B::Block>,
    source: TransactionSource,
    xts: T,
    force: bool
) -> Result<Vec<Result<ExHash<B>, B::Error>>, B::Error> where
    T: IntoIterator<Item = ExtrinsicFor<B>>, 

Imports a bunch of unverified extrinsics to the pool

pub async fn submit_one<'_, '_>(
    &'_ self,
    at: &'_ BlockId<B::Block>,
    source: TransactionSource,
    xt: ExtrinsicFor<B>
) -> Result<ExHash<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<ExHash<B>, BlockHash<B>>, B::Error>

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

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

Resubmit some transaction that were validated elsewhere.

pub fn prune_known(
    &self,
    at: &BlockId<B::Block>,
    hashes: &[ExHash<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 = ExHash<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>) -> ExHash<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
    B::Hash: MallocSizeOf,
    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.