Enum tp_runtime::generic::Era

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

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, Phase)

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) -> Self

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() -> Self

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.

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

Performs copy-assignment from source.

impl Copy for Era

impl Debug for Era

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

Formats the value using the given formatter.

impl Decode for Era

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

Attempt to deserialise the value from input.

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

Attempt to skip the encoded value from input.

pub 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<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Encode for Era

fn encode_to<T: Output + ?Sized>(&self, output: &mut T)

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

pub fn size_hint(&self) -> usize

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

pub fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

pub 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.

pub fn encoded_size(&self) -> usize

Calculates the encoded size.

impl EncodeLike<Era> for Era

impl Eq for Era

impl PartialEq<Era> for Era

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for Era

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

Serialize this value into the given Serde serializer.

impl StructuralEq for Era

impl StructuralPartialEq for Era