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.

pub 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.

impl Default for ValidTransaction

fn default() -> Self

Returns the “default value” for a type.

impl Encode for ValidTransaction

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

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

pub fn size_hint(&self) -> usize

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

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

Convert self to an owned vector.

pub 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.

impl EncodeLike<ValidTransaction> for ValidTransaction

impl Eq for ValidTransaction

impl From<ValidTransactionBuilder> for ValidTransaction

fn from(builder: ValidTransactionBuilder) -> Self

Performs the conversion.

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: &ValidTransaction) -> bool

This method tests for !=.

impl StructuralEq for ValidTransaction

impl StructuralPartialEq for ValidTransaction