Enum Preamble 

pub enum Preamble<Address, Signature, ExtensionV0, ExtensionOtherVersions = InvalidVersion> {
    Bare(u8),
    Signed(Address, Signature, ExtensionV0),
    General(ExtensionVariant<ExtensionV0, ExtensionOtherVersions>),
}

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

Bare extrinsics and signed extrinsics are extended with the transaction extension version 0, specified by the generic parameter ExtensionV0.

General extrinsics support multiple transaction extension version, specified by both ExtensionV0 and ExtensionOtherVersions, by default ExtensionOtherVersions is set to invalid version, making ExtensionV0 the only supported version. If you want to support more versions, you need to specify the ExtensionOtherVersions parameter.

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

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

General(ExtensionVariant<ExtensionV0, ExtensionOtherVersions>)

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, ExtensionV0, ExtensionOtherVersions> Preamble<Address, Signature, ExtensionV0, ExtensionOtherVersions>

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

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

Trait Implementations

impl<Address: Clone, Signature: Clone, ExtensionV0: Clone, ExtensionOtherVersions: Clone> Clone for Preamble<Address, Signature, ExtensionV0, ExtensionOtherVersions>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Address, Signature, ExtensionV0, ExtensionOtherVersions> Debug for Preamble<Address, Signature, ExtensionV0, ExtensionOtherVersions>

where Address: Debug, ExtensionV0: Debug, ExtensionOtherVersions: Debug,

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

Formats the value using the given formatter.

impl<Address, Signature, ExtensionV0, ExtensionOtherVersions> Decode for Preamble<Address, Signature, ExtensionV0, ExtensionOtherVersions>

where Address: Decode, Signature: Decode, ExtensionV0: Decode, ExtensionOtherVersions: DecodeWithVersion,

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

where Address: Encode, Signature: Encode, ExtensionV0: Encode, ExtensionOtherVersions: Encode + PipelineVersion,

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

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

where Address: DecodeWithMemTracking, Signature: DecodeWithMemTracking, ExtensionV0: DecodeWithMemTracking, ExtensionOtherVersions: DecodeWithVersionWithMemTracking,

impl<Address: Eq, Signature: Eq, ExtensionV0: Eq, ExtensionOtherVersions: Eq> Eq for Preamble<Address, Signature, ExtensionV0, ExtensionOtherVersions>

impl<Address, Signature, ExtensionV0, ExtensionOtherVersions> StructuralPartialEq for Preamble<Address, Signature, ExtensionV0, ExtensionOtherVersions>