Enum Preamble

pub enum Preamble<Address, Signature, Extension> {
    Bare(u8),
    Signed(Address, Signature, Extension),
    General(ExtensionVersion, Extension),
}

A “header” for extrinsics leading up to the call itself. Determines the type of extrinsic and holds any necessary specialized data.

Variants

Bare(u8)

An extrinsic without a signature or any extension. This means it’s either an inherent or an old-school “Unsigned” (we don’t use that terminology any more since it’s confusable with the general transaction which is without a signature but does have an extension).

NOTE: In the future, once we remove ValidateUnsigned, this will only serve Inherent extrinsics and thus can be renamed to Inherent.

Signed(Address, Signature, Extension)

An old-school transaction extrinsic which includes a signature of some hard-coded crypto. Available only on extrinsic version 4.

General(ExtensionVersion, Extension)

A new-school transaction extrinsic which does not include a signature by default. The origin authorization, through signatures or other means, is performed by the transaction extension in this extrinsic. Available starting with extrinsic version 5.

Implementations

impl<Address, Signature, Extension> Preamble<Address, Signature, Extension>

pub fn to_signed(self) -> Option<(Address, Signature, Extension)>

Returns Some if this is a signed extrinsic, together with the relevant inner fields.

Trait Implementations

impl<Address: Clone, Signature: Clone, Extension: Clone> Clone for Preamble<Address, Signature, Extension>

fn clone(&self) -> Preamble<Address, Signature, Extension>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Address, Signature, Extension> Debug for Preamble<Address, Signature, Extension>

where Address: Debug, Extension: Debug,

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

Formats the value using the given formatter.

impl<Address, Signature, Extension> Decode for Preamble<Address, Signature, Extension>

where Address: Decode, Signature: Decode, Extension: Decode,

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<Address, Signature, Extension> Encode for Preamble<Address, Signature, Extension>

where Address: Encode, Signature: Encode, Extension: Encode,

fn size_hint(&self) -> usize

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

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

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

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<Address: PartialEq, Signature: PartialEq, Extension: PartialEq> PartialEq for Preamble<Address, Signature, Extension>

fn eq(&self, other: &Preamble<Address, Signature, Extension>) -> 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<Address: Eq, Signature: Eq, Extension: Eq> Eq for Preamble<Address, Signature, Extension>

impl<Address, Signature, Extension> StructuralPartialEq for Preamble<Address, Signature, Extension>