Struct sp_runtime::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.

Fields

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.

Implementations

impl ValidTransaction

pub fn with_tag_prefix(prefix: &'static str) -> ValidTransactionBuilder

Initiate ValidTransaction builder object with a particular prefix for tags.

To avoid conflicts between different parts in runtime it’s recommended to build requires and provides tags with a unique prefix.

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

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 Clone for ValidTransaction

fn clone(&self) -> ValidTransaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ValidTransaction

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

Formats the value using the given formatter.

impl Decode for ValidTransaction

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 Default for ValidTransaction

fn default() -> Self

Returns the “default value” for a type.

impl Encode for ValidTransaction

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

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

fn size_hint(&self) -> usize

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

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

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere 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 From<ValidTransactionBuilder> for ValidTransaction

fn from(builder: ValidTransactionBuilder) -> Self

Converts to this type from the input type.

impl PartialEq<ValidTransaction> for ValidTransaction

fn eq(&self, other: &ValidTransaction) -> 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 TypeInfo for ValidTransaction

type Identity = ValidTransaction

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike<ValidTransaction> for ValidTransaction

impl Eq for ValidTransaction

impl StructuralEq for ValidTransaction

impl StructuralPartialEq for ValidTransaction