Struct subxt::tx::TxProgress

pub struct TxProgress<T: Config, C> { /* private fields */ }

This struct represents a subscription to the progress of some transaction.

Implementations

impl<T: Config, C> TxProgress<T, C>

pub fn new(
    sub: Subscription<SubstrateTxStatus<T::Hash, T::Hash>>,
    client: C,
    ext_hash: T::Hash
) -> Self

Instantiate a new TxProgress from a custom subscription.

pub fn extrinsic_hash(&self) -> T::Hash

Return the hash of the extrinsic.

impl<T, C> TxProgress<T, C>where
    T: Config,
    C: OnlineClientT<T>,

pub async fn next_item(&mut self) -> Option<Result<TxStatus<T, C>, Error>>

Return the next transaction status when it’s emitted. This just delegates to the futures::Stream implementation for TxProgress, but allows you to avoid importing that trait if you don’t otherwise need it.

pub async fn wait_for_in_block(self) -> Result<TxInBlock<T, C>, Error>

Wait for the transaction to be in a block (but not necessarily finalized), and return an TxInBlock instance when this happens, or an error if there was a problem waiting for this to happen.

Note: consumes self. If you’d like to perform multiple actions as the state of the transaction progresses, use TxProgress::next_item() instead.

Note: transaction statuses like Invalid and Usurped are ignored, because while they may well indicate with some probability that the transaction will not make it into a block, there is no guarantee that this is true. Thus, we prefer to “play it safe” here. Use the lower level TxProgress::next_item() API if you’d like to handle these statuses yourself.

pub async fn wait_for_finalized(self) -> Result<TxInBlock<T, C>, Error>

Wait for the transaction to be finalized, and return a TxInBlock instance when it is, or an error if there was a problem waiting for finalization.

Note: consumes self. If you’d like to perform multiple actions as the state of the transaction progresses, use TxProgress::next_item() instead.

Note: transaction statuses like Invalid and Usurped are ignored, because while they may well indicate with some probability that the transaction will not make it into a block, there is no guarantee that this is true. Thus, we prefer to “play it safe” here. Use the lower level TxProgress::next_item() API if you’d like to handle these statuses yourself.

pub async fn wait_for_finalized_success(
    self
) -> Result<ExtrinsicEvents<T>, Error>

Wait for the transaction to be finalized, and for the transaction events to indicate that the transaction was successful. Returns the events associated with the transaction, as well as a couple of other details (block hash and extrinsic hash).

Note: consumes self. If you’d like to perform multiple actions as progress is made, use TxProgress::next_item() instead.

Note: transaction statuses like Invalid and Usurped are ignored, because while they may well indicate with some probability that the transaction will not make it into a block, there is no guarantee that this is true. Thus, we prefer to “play it safe” here. Use the lower level TxProgress::next_item() API if you’d like to handle these statuses yourself.

Trait Implementations

impl<T: Config, C> Debug for TxProgress<T, C>where
    C: Debug,

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

Formats the value using the given formatter.

impl<T: Config, C: OnlineClientT<T>> Stream for TxProgress<T, C>

type Item = Result<TxStatus<T, C>, Error>

Values yielded by the stream.

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<T: Config, C> Unpin for TxProgress<T, C>