Enum Era

pub enum Era {
    Immortal,
    Mortal {
        period: u64,
        phase: 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

The transaction will expire. Use Era::mortal to construct this with correct values.

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

Fields

period: u64

The number of blocks that the tx will be valid for after the checkpoint block hash found in the signer payload.

phase: u64

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.

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.

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, f: &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.

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 Default for Era

fn default() -> Era

Returns the “default value” for a 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.

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 EncodeAsType for Era

fn encode_as_type_to<ScaleEncodeResolver: TypeResolver>( &self, __encode_as_type_type_id: ScaleEncodeResolver::TypeId, __encode_as_type_types: &ScaleEncodeResolver, __encode_as_type_out: &mut Vec<u8>, ) -> Result<(), Error>

Given some type_id, types, a context and some output target for the SCALE encoded bytes, attempt to SCALE encode the current value into the type given by type_id.

fn encode_as_type<R>( &self, type_id: <R as TypeResolver>::TypeId, types: &R, ) -> Result<Vec<u8>, Error>

where R: TypeResolver,

This is a helper function which internally calls EncodeAsType::encode_as_type_to. Prefer to implement that instead.

impl IntoVisitor for Era

type AnyVisitor<ScaleDecodeTypeResolver: TypeResolver> = Visitor<ScaleDecodeTypeResolver>

The visitor type used to decode SCALE encoded bytes to Self.

fn into_visitor<ScaleDecodeTypeResolver: TypeResolver>() -> Self::AnyVisitor<ScaleDecodeTypeResolver>

A means of obtaining this visitor.

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::Ok, __S::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 Eq for Era

impl StructuralPartialEq for Era