Enum sc_rpc_spec_v2::transaction::event::TransactionEvent

pub enum TransactionEvent<Hash> {
    Validated,
    Broadcasted(TransactionBroadcasted),
    BestChainBlockIncluded(Option<TransactionBlock<Hash>>),
    Finalized(TransactionBlock<Hash>),
    Error(TransactionError),
    Invalid(TransactionError),
    Dropped(TransactionDropped),
}

Possible transaction status events.

The status events can be grouped based on their kinds as:

1. Runtime validated the transaction: - Validated

2. Inside the Ready queue: - Broadcast

3. Leaving the pool: - BestChainBlockIncluded - Invalid

4. Block finalized: - Finalized

5. At any time: - Dropped - Error

The subscription’s stream is considered finished whenever the following events are received: Finalized, Error, Invalid or Dropped. However, the user is allowed to unsubscribe at any moment.

Variants

Validated

The transaction was validated by the runtime.

Broadcasted(TransactionBroadcasted)

The transaction was broadcasted to a number of peers.

BestChainBlockIncluded(Option<TransactionBlock<Hash>>)

The transaction was included in a best block of the chain.

Note

This may contain None if the block is no longer a best block of the chain.

Finalized(TransactionBlock<Hash>)

The transaction was included in a finalized block.

Error(TransactionError)

The transaction could not be processed due to an error.

Invalid(TransactionError)

The transaction is marked as invalid.

Dropped(TransactionDropped)

The client was not capable of keeping track of this transaction.

Trait Implementations

impl<Hash: Clone> Clone for TransactionEvent<Hash>

fn clone(&self) -> TransactionEvent<Hash>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Hash: Debug> Debug for TransactionEvent<Hash>

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

Formats the value using the given formatter.

impl<'de, Hash> Deserialize<'de> for TransactionEvent<Hash>where Hash: Deserialize<'de> + Clone,

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

Deserialize this value from the given Serde deserializer.

impl<Hash> From<Error> for TransactionEvent<Hash>

fn from(e: Error) -> Self

Converts to this type from the input type.

impl<Hash: PartialEq> PartialEq<TransactionEvent<Hash>> for TransactionEvent<Hash>

fn eq(&self, other: &TransactionEvent<Hash>) -> 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> Serialize for TransactionEvent<Hash>where Hash: Serialize + Clone,

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

Serialize this value into the given Serde serializer.

impl<Hash> StructuralPartialEq for TransactionEvent<Hash>