Enum Era

pub enum Era {
    Immortal,
    Mortal(u64, u64),
}

An era to describe the longevity of a transaction.

Variants

Immortal

The transaction is valid forever. The genesis hash must be present in the signed content.

Mortal(u64, u64)

Period and phase are encoded:

• The period of validity from the block hash found in the signing material.
• The phase in the period that this transaction’s lifetime begins (and, importantly, implies which block hash is included in the signature material). If the period is greater than 1 << 12, then it will be a factor of the times greater than 1<<12 that period is.

When used on FRAME-based runtimes, period cannot exceed BlockHashCount parameter of system module.

Implementations

impl Era

pub fn mortal(period: u64, current: u64) -> Era

Create a new era based on a period (which should be a power of two between 4 and 65536 inclusive) and a block number on which it should start (or, for long periods, be shortly after the start).

If using Era in the context of FRAME runtime, make sure that period does not exceed BlockHashCount parameter passed to system module, since that prunes old blocks and renders transactions immediately invalid.

pub fn immortal() -> Era

Create an “immortal” transaction.

pub fn is_immortal(&self) -> bool

true if this is an immortal transaction.

pub fn birth(self, current: u64) -> u64

Get the block number of the start of the era whose properties this object describes that current belongs to.

pub fn death(self, current: u64) -> u64

Get the block number of the first block at which the era has ended.

Trait Implementations

impl Clone for Era

fn clone(&self) -> Era

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Era

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

Formats the value using the given formatter.

impl Decode for Era

fn decode<I>(input: &mut I) -> Result<Era, Error>

where I: Input,

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<'de> Deserialize<'de> for Era

fn deserialize<__D>( __deserializer: __D, ) -> Result<Era, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for Era

fn encode_to<T>(&self, output: &mut T)

where T: Output + ?Sized,

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

fn size_hint(&self) -> usize

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

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

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.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl PartialEq for Era

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TypeInfo for Era

type Identity = Era

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl Copy for Era

impl DecodeWithMemTracking for Era

impl EncodeLike for Era

impl Eq for Era

impl StructuralPartialEq for Era