Struct TransactionId

pub struct TransactionId {
    pub sender: SenderId,
    pub nonce: u64,
}

A unique identifier of a transaction of a Sender.

This serves as an identifier for dependencies of a transaction: A transaction with a nonce higher than the current state nonce depends on tx.nonce - 1.

Fields

sender: SenderId

Sender of this transaction

nonce: u64

Nonce of this transaction

Implementations

impl TransactionId

pub const fn new(sender: SenderId, nonce: u64) -> Self

Create a new identifier pair

pub fn ancestor( transaction_nonce: u64, on_chain_nonce: u64, sender: SenderId, ) -> Option<Self>

Returns the TransactionId this transaction depends on.

This returns transaction_nonce - 1 if transaction_nonce is higher than the on_chain_nonce

pub fn unchecked_ancestor(&self) -> Option<Self>

Returns the TransactionId that would come before this transaction.

pub const fn descendant(&self) -> Self

Returns the TransactionId that directly follows this transaction: self.nonce + 1

pub const fn next_nonce(&self) -> u64

Returns the nonce that follows immediately after this one.

Trait Implementations

impl Clone for TransactionId

fn clone(&self) -> TransactionId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionId

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

Formats the value using the given formatter.

impl Hash for TransactionId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for TransactionId

fn cmp(&self, other: &TransactionId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for TransactionId

fn eq(&self, other: &TransactionId) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for TransactionId

fn partial_cmp(&self, other: &TransactionId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for TransactionId

impl Eq for TransactionId

impl StructuralPartialEq for TransactionId

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes