[][src]Struct sr_primitives::transaction_validity::ValidTransaction

pub struct ValidTransaction {
    pub priority: TransactionPriority,
    pub requires: Vec<TransactionTag>,
    pub provides: Vec<TransactionTag>,
    pub longevity: TransactionLongevity,
    pub propagate: bool,

Information concerning a valid transaction.


priority: TransactionPriority

Priority of the transaction.

Priority determines the ordering of two transactions that have all their dependencies (required tags) satisfied.

requires: Vec<TransactionTag>

Transaction dependencies

A non-empty list signifies that some other transactions which provide given tags are required to be included before that one.

provides: Vec<TransactionTag>

Provided tags

A list of tags this transaction provides. Successfully importing the transaction will enable other transactions that depend on (require) those tags to be included as well. Provided and required tags allow Substrate to build a dependency graph of transactions and import them in the right (linear) order.

longevity: TransactionLongevity

Transaction longevity

Longevity describes minimum number of blocks the validity is correct. After this period transaction should be removed from the pool or revalidated.

propagate: bool

A flag indicating if the transaction should be propagated to other peers.

By setting false here the transaction will still be considered for including in blocks that are authored on the current node, but will never be sent to other peers.


impl ValidTransaction[src]

pub fn combine_with(self, other: ValidTransaction) -> Self[src]

Combine two instances into one, as a best effort. This will take the superset of each of the provides and requires tags, it will sum the priorities, take the minimum longevity and the logic And of the propagate flags.

Trait Implementations

impl Eq for ValidTransaction[src]

impl Default for ValidTransaction[src]

impl Clone for ValidTransaction[src]

impl PartialEq<ValidTransaction> for ValidTransaction[src]

impl Debug for ValidTransaction[src]

impl Encode for ValidTransaction[src]

impl Decode for ValidTransaction[src]

impl EncodeLike<ValidTransaction> for ValidTransaction[src]

Auto Trait Implementations

impl Send for ValidTransaction

impl Unpin for ValidTransaction

impl Sync for ValidTransaction

impl UnwindSafe for ValidTransaction

impl RefUnwindSafe for ValidTransaction

Blanket Implementations

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

impl<T> SaturatedConversion for T[src]

impl<T> CheckedConversion for T[src]

impl<T> Clear for T where
    T: PartialEq<T> + Eq + Default

impl<T> Member for T where
    T: 'static + MaybeDebug + Send + Sync + PartialEq<T> + Eq + Clone

impl<T> MaybeDebug for T where
    T: Debug

impl<T> ToOwned for T where
    T: Clone

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> Into<U> for T where
    U: From<T>, 

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

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

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

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

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

impl<T, X> Encode for X where
    T: Encode + ?Sized,
    X: WrapperTypeEncode<Target = T>, 

impl<T, X> Decode for X where
    T: Decode + Into<X>,
    X: WrapperTypeDecode<Wrapped = T>, 

impl<S> Codec for S where
    S: Encode + Decode

impl<'_, T> EncodeLike<&'_ T> for T where
    T: Encode

impl<T> KeyedVec for T where
    T: Codec

impl<T> DecodeAll for T where
    T: Decode

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

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

Get a reference to the inner from the outer.

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

Get a mutable reference to the inner from the outer.

impl<S, T> UncheckedInto<T> for S where
    T: UncheckedFrom<S>, 

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

type Output = T

Should always be Self

impl<T> Clear for T where
    T: InitializableFromZeroed + ?Sized

impl<T> InitializableFromZeroed for T where
    T: Default

impl<T> Erased for T[src]

impl<T> MaybeDebug for T where
    T: Debug

impl<T> MaybeDebug for T where
    T: Debug

impl<T> MaybeDebug for T where
    T: Debug

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