Enum TransactionStatus

pub enum TransactionStatus<Hash: Encode + Decode, BlockHash: Encode + Decode> {
    Future,
    Ready,
    Broadcast(Vec<String>),
    InBlock(BlockHash),
    Retracted(BlockHash),
    FinalityTimeout(BlockHash),
    Finalized(BlockHash),
    Usurped(Hash),
    Dropped,
    Invalid,
}

Possible transaction status events.

Variants

Future

Transaction is part of the future queue.

Ready

Transaction is part of the ready queue.

Broadcast(Vec<String>)

The transaction has been broadcast to the given peers.

InBlock(BlockHash)

Transaction has been included in block with given hash.

Retracted(BlockHash)

The block this transaction was included in has been retracted.

FinalityTimeout(BlockHash)

Maximum number of finality watchers has been reached, old watchers are being removed.

Finalized(BlockHash)

Transaction has been finalized by a finality-gadget, e.g GRANDPA

Usurped(Hash)

Transaction has been replaced in the pool, by another transaction that provides the same tags. (e.g. same (sender, nonce)).

Dropped

Transaction has been dropped from the pool because of the limit.

Invalid

Transaction is no longer valid in the current state.

Implementations

impl<Hash: Encode + Decode, BlockHash: Encode + Decode> TransactionStatus<Hash, BlockHash>

pub fn as_u8(&self) -> u8

pub fn is_expected(&self) -> Result<()>

pub fn reached_status(&self, status: XtStatus) -> bool

Returns true if the input status has been reached (or overreached) and false in case the status is not yet on the expected level.

pub fn get_maybe_block_hash(&self) -> Option<&BlockHash>

pub fn is_final(&self) -> bool

Returns true if the Transaction reached its final Status

Trait Implementations

impl<Hash: Clone + Encode + Decode, BlockHash: Clone + Encode + Decode> Clone for TransactionStatus<Hash, BlockHash>

fn clone(&self) -> TransactionStatus<Hash, BlockHash>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Hash: Debug + Encode + Decode, BlockHash: Debug + Encode + Decode> Debug for TransactionStatus<Hash, BlockHash>

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

Formats the value using the given formatter.

impl<Hash, BlockHash> Decode for TransactionStatus<Hash, BlockHash>

where BlockHash: Decode + Encode + Decode, Hash: Decode + Encode + Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<'de, Hash, BlockHash> Deserialize<'de> for TransactionStatus<Hash, BlockHash>

where Hash: Deserialize<'de> + Encode + Decode, BlockHash: Deserialize<'de> + Encode + Decode,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Hash, BlockHash> Encode for TransactionStatus<Hash, BlockHash>

where BlockHash: Encode + Encode + Decode, Hash: Encode + Encode + Decode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<Hash: PartialEq + Encode + Decode, BlockHash: PartialEq + Encode + Decode> PartialEq for TransactionStatus<Hash, BlockHash>

fn eq(&self, other: &TransactionStatus<Hash, BlockHash>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Hash, BlockHash> Serialize for TransactionStatus<Hash, BlockHash>

where Hash: Serialize + Encode + Decode, BlockHash: Serialize + Encode + Decode,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Hash, BlockHash> EncodeLike for TransactionStatus<Hash, BlockHash>

where BlockHash: Encode + Encode + Decode, Hash: Encode + Encode + Decode,

impl<Hash: Encode + Decode, BlockHash: Encode + Decode> StructuralPartialEq for TransactionStatus<Hash, BlockHash>