Struct sc_transaction_pool::Transaction

pub struct Transaction<Hash, Extrinsic> {
    pub data: Extrinsic,
    pub bytes: usize,
    pub hash: Hash,
    pub priority: TransactionPriority,
    pub valid_till: TransactionLongevity,
    pub requires: Vec<TransactionTag>,
    pub provides: Vec<TransactionTag>,
    pub propagate: bool,
    pub source: TransactionSource,
}

Immutable transaction

Fields

data: Extrinsic

Raw extrinsic representing that transaction.

bytes: usize

Number of bytes encoding of the transaction requires.

hash: Hash

Transaction hash (unique)

priority: TransactionPriority

Transaction priority (higher = better)

valid_till: TransactionLongevity

At which block the transaction becomes invalid?

requires: Vec<TransactionTag>

Tags required by the transaction.

provides: Vec<TransactionTag>

Tags that this transaction provides.

propagate: bool

Should that transaction be propagated.

source: TransactionSource

Source of that transaction.

Implementations

impl<Hash: Clone, Extrinsic: Clone> Transaction<Hash, Extrinsic>

pub fn duplicate(&self) -> Self

Explicit transaction clone.

Transaction should be cloned only if absolutely necessary && we want every reason to be commented. That’s why we Transaction is not Clone, but there’s explicit duplicate method.

Trait Implementations

impl<Hash, Extrinsic> AsRef<Extrinsic> for Transaction<Hash, Extrinsic>

fn as_ref(&self) -> &Extrinsic

Converts this type into a shared reference of the (usually inferred) input type.

impl<Hash: Clone, Extrinsic: Clone> Clone for Transaction<Hash, Extrinsic>

fn clone(&self) -> Transaction<Hash, Extrinsic>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Hash, Extrinsic> Debug for Transaction<Hash, Extrinsic>

where Hash: Debug, Extrinsic: Debug,

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

Formats the value using the given formatter.

impl<Hash, Extrinsic> InPoolTransaction for Transaction<Hash, Extrinsic>

type Transaction = Extrinsic

Transaction type.

type Hash = Hash

Transaction hash type.

fn data(&self) -> &Extrinsic

Get the reference to the transaction data.

fn hash(&self) -> &Hash

Get hash of the transaction.

fn priority(&self) -> &Priority

Get priority of the transaction.

fn longevity(&self) -> &Longevity

Get longevity of the transaction.

fn requires(&self) -> &[Tag]

Get transaction dependencies.

fn provides(&self) -> &[Tag]

Get tags that transaction provides.

fn is_propagable(&self) -> bool

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

impl<Hash: PartialEq, Extrinsic: PartialEq> PartialEq for Transaction<Hash, Extrinsic>

fn eq(&self, other: &Transaction<Hash, Extrinsic>) -> 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: Eq, Extrinsic: Eq> Eq for Transaction<Hash, Extrinsic>

impl<Hash, Extrinsic> StructuralPartialEq for Transaction<Hash, Extrinsic>