Struct sc_transaction_pool::Transaction

pub struct Transaction<Hash, Extrinsic> {
    pub data: Extrinsic,
    pub bytes: usize,
    pub hash: Hash,
    pub priority: Priority,
    pub valid_till: Longevity,
    pub requires: Vec<Tag>,
    pub provides: Vec<Tag>,
    pub propagate: bool,
    pub source: Source,
}

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: Priority

Transaction priority (higher = better)

valid_till: Longevity

At which block the transaction becomes invalid?

requires: Vec<Tag>

Tags required by the transaction.

provides: Vec<Tag>

Tags that this transaction provides.

propagate: bool

Should that transaction be propagated.

source: Source

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, 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, Extrinsic> MallocSizeOf for Transaction<Hash, Extrinsic>where
    Hash: MallocSizeOf,
    Extrinsic: MallocSizeOf,

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself. If T::size_of is a constant, consider implementing constant_size as well.

fn constant_size() -> Option<usize>where
    Self: Sized,

Used to optimize MallocSizeOf implementation for collections like Vec and HashMap to avoid iterating over them unnecessarily. The Self: Sized bound is for object safety.

impl<Hash: PartialEq, Extrinsic: PartialEq> PartialEq<Transaction<Hash, Extrinsic>> 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> StructuralEq for Transaction<Hash, Extrinsic>

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