Enum subxt::rpc::types::SubstrateTxStatus

pub enum SubstrateTxStatus<Hash, BlockHash> {
    Future,
    Ready,
    Broadcast(Vec<String>),
    InBlock(BlockHash),
    Retracted(BlockHash),
    FinalityTimeout(BlockHash),
    Finalized(BlockHash),
    Usurped(Hash),
    Dropped,
    Invalid,
}

Possible transaction status events.

Note

This is copied from sp-transaction-pool to avoid a dependency on that crate. Therefore it must be kept compatible with that type from the target substrate version.

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.

Trait Implementations

impl<Hash: Clone, BlockHash: Clone> Clone for SubstrateTxStatus<Hash, BlockHash>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Hash: Debug, BlockHash: Debug> Debug for SubstrateTxStatus<Hash, BlockHash>

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

Formats the value using the given formatter.

impl<'de, Hash, BlockHash> Deserialize<'de> for SubstrateTxStatus<Hash, BlockHash>where
    Hash: Deserialize<'de>,
    BlockHash: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Hash: PartialEq, BlockHash: PartialEq> PartialEq<SubstrateTxStatus<Hash, BlockHash>> for SubstrateTxStatus<Hash, BlockHash>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<Hash, BlockHash> Serialize for SubstrateTxStatus<Hash, BlockHash>where
    Hash: Serialize,
    BlockHash: Serialize,

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

Serialize this value into the given Serde serializer.

impl<Hash: Eq, BlockHash: Eq> Eq for SubstrateTxStatus<Hash, BlockHash>

impl<Hash, BlockHash> StructuralEq for SubstrateTxStatus<Hash, BlockHash>

impl<Hash, BlockHash> StructuralPartialEq for SubstrateTxStatus<Hash, BlockHash>