Enum TransactionExpiration 

pub enum TransactionExpiration {
    None,
    Epoch(EpochId),
    ValidDuring {
        min_epoch: Option<EpochId>,
        max_epoch: Option<EpochId>,
        min_timestamp: Option<u64>,
        max_timestamp: Option<u64>,
        chain: ChainIdentifier,
        nonce: u32,
    },
    Validity {
        min_epoch: Option<EpochId>,
        max_epoch: Option<EpochId>,
        min_timestamp: Option<u64>,
        max_timestamp: Option<u64>,
        chain: ChainIdentifier,
        nonce: u32,
        allowed_proposers: Option<AllowedProposers>,
    },
}

Variants

None

The transaction has no expiration

Epoch(EpochId)

Validators wont sign a transaction unless the expiration Epoch is greater than or equal to the current epoch

ValidDuring

ValidDuring enables gas payments from address balances.

When transactions use address balances for gas payment instead of explicit gas coins, we lose the natural transaction uniqueness and replay prevention that comes from mutation of gas coin objects.

By bounding expiration and providing a nonce, validators must only retain executed digests for the maximum possible expiry range to differentiate retries from unique transactions with otherwise identical inputs.

Fields

min_epoch: Option<EpochId>

Transaction invalid before this epoch. Must equal current epoch.

max_epoch: Option<EpochId>

Transaction expires after this epoch. Must equal current epoch

min_timestamp: Option<u64>

Future support for sub-epoch timing (not yet implemented)

max_timestamp: Option<u64>

Future support for sub-epoch timing (not yet implemented)

chain: ChainIdentifier

Network identifier to prevent cross-chain replay

nonce: u32

User-provided uniqueness identifier to differentiate otherwise identical transactions

Validity

Everything in ValidDuring, plus a restriction on which validators may propose the transaction in consensus.

Fields

min_epoch: Option<EpochId>

Transaction invalid before this epoch. Must equal current epoch.

max_epoch: Option<EpochId>

Transaction expires after this epoch. Must equal current epoch

min_timestamp: Option<u64>

Future support for sub-epoch timing (not yet implemented)

max_timestamp: Option<u64>

Future support for sub-epoch timing (not yet implemented)

chain: ChainIdentifier

Network identifier to prevent cross-chain replay

nonce: u32

User-provided uniqueness identifier to differentiate otherwise identical transactions

allowed_proposers: Option<AllowedProposers>

The validators allowed to propose this transaction in consensus, if it restricts them.

Implementations

impl TransactionExpiration

pub fn is_replay_protected(&self) -> bool

Validators remember all executed transaction digests from the current and previous epoch. Therefore, a one or two epoch validity window provides replay protection. Either the transaction is statically invalid (current epoch not within range) or the validator will remember if the transaction was already executed.

pub fn allowed_proposers(&self, epoch: EpochId) -> Option<&AllowedProposers>

The validators allowed to propose this transaction in consensus during epoch.

A set recorded for any other epoch indexes into a committee that is not the one deciding this transaction, so it is ignored entirely and the transaction is treated as naming no proposers. The incentive to record the current epoch is on the signer, who is the party the restriction protects; transactions without a usable set may in future be subject to submission delays to limit amplification.

pub fn restricts_proposers(&self, epoch: EpochId) -> bool

Whether the transaction restricts its proposers during epoch. Only such a transaction has its consensus amplification bounded by validity_check.

pub fn is_allowed_proposer(&self, proposer: u32, epoch: EpochId) -> bool

Whether proposer (an index into epoch’s committee) may propose this transaction in consensus.

Trait Implementations

impl Clone for TransactionExpiration

fn clone(&self) -> TransactionExpiration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionExpiration

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TransactionExpiration

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<TransactionExpiration> for TransactionExpiration

fn from(value: TransactionExpiration) -> Self

Converts to this type from the input type.

impl From<TransactionExpiration> for TransactionExpiration

fn from(value: TransactionExpiration) -> Self

Converts to this type from the input type.

impl From<TransactionExpiration> for TransactionExpiration

fn from(value: TransactionExpiration) -> Self

Converts to this type from the input type.

impl Hash for TransactionExpiration

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 PartialEq for TransactionExpiration

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&TransactionExpiration> for TransactionExpiration

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: &TransactionExpiration) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for TransactionExpiration

impl StructuralPartialEq for TransactionExpiration