[][src]Struct sc_transaction_graph::Pool

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

Extrinsics pool that performs validation.

Implementations

impl<B: ChainApi> Pool<B>[src]

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

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>
[src]

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>
[src]

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>
[src]

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>
[src]

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>>
)
[src]

Resubmit some transaction that were validated elsewhere.

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

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>
[src]

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>
[src]

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>[src]

Returns transaction hash

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

get a reference to the underlying validated pool.

Trait Implementations

impl<B: ChainApi> Clone for Pool<B>[src]

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

Auto Trait Implementations

impl<B> !RefUnwindSafe for Pool<B>[src]

impl<B> Send for Pool<B> where
    <<B as ChainApi>::Block as Block>::Extrinsic: Send + Sync,
    <<B as ChainApi>::Block as Block>::Hash: Send + Sync
[src]

impl<B> Sync for Pool<B> where
    <<B as ChainApi>::Block as Block>::Extrinsic: Send + Sync,
    <<B as ChainApi>::Block as Block>::Hash: Send + Sync
[src]

impl<B> Unpin for Pool<B>[src]

impl<B> !UnwindSafe for Pool<B>[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> CheckedConversion for T[src]

impl<T> DynClone for T where
    T: Clone
[src]

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, Outer> IsWrappedBy<Outer> for T where
    T: From<Outer>,
    Outer: AsRef<T> + AsMut<T> + From<T>, 
[src]

pub fn from_ref(outer: &Outer) -> &T[src]

Get a reference to the inner from the outer.

pub fn from_mut(outer: &mut Outer) -> &mut T[src]

Get a mutable reference to the inner from the outer.

impl<T> MallocSizeOfExt for T where
    T: MallocSizeOf, 

impl<T> MaybeMallocSizeOf for T where
    T: MallocSizeOf, 
[src]

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> SaturatedConversion for T[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<S, T> UncheckedInto<T> for S where
    T: UncheckedFrom<S>, 
[src]

impl<T, S> UniqueSaturatedInto<T> for S where
    T: Bounded,
    S: TryInto<T>, 
[src]

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 

impl<T> WithSubscriber for T[src]