Struct sp_runtime::generic::UncheckedExtrinsic

pub struct UncheckedExtrinsic<Address, Call, Signature, Extension> {
    pub preamble: Preamble<Address, Signature, Extension>,
    pub function: Call,
}

An extrinsic right from the external world. This is unchecked and so can contain a signature.

An extrinsic is formally described as any external data that is originating from the outside of the runtime and fed into the runtime as a part of the block-body.

Inherents are special types of extrinsics that are placed into the block by the block-builder. They are unsigned because the assertion is that they are “inherently true” by virtue of getting past all validators.

Transactions are all other statements provided by external entities that the chain deems values and decided to include in the block. This value is typically in the form of fee payment, but it could in principle be any other interaction. Transactions are either signed or unsigned. A sensible transaction pool should ensure that only transactions that are worthwhile are considered for block-building.

flowchart TD
    E(Extrinsic) ---> I(Inherent);
    E --> T(Transaction)
    T --> ST("Signed (aka. Transaction)")
    T --> UT(Unsigned)

This type is by no means enforced within Substrate, but given its genericness, it is highly likely that for most use-cases it will suffice. Thus, the encoding of this type will dictate exactly what bytes should be sent to a runtime to transact with it.

This can be checked using Checkable, yielding a CheckedExtrinsic, which is the counterpart of this type after its signature (and other non-negotiable validity checks) have passed.

Fields

preamble: Preamble<Address, Signature, Extension>

Information regarding the type of extrinsic this is (inherent or transaction) as well as associated extension (Extension) data if it’s a transaction and a possible signature.

function: Call

The function that should be called.

Implementations

impl<Address, Call, Signature, Extension> UncheckedExtrinsic<Address, Call, Signature, Extension>

pub fn new_unsigned(function: Call) -> Self

👎Deprecated: Use new_bare instead

New instance of a bare (ne unsigned) extrinsic. This could be used for an inherent or an old-school “unsigned transaction” (which are new being deprecated in favour of general transactions).

pub fn is_inherent(&self) -> bool

Returns true if this extrinsic instance is an inherent, `false`` otherwise.

pub fn is_signed(&self) -> bool

Returns true if this extrinsic instance is an old-school signed transaction, false otherwise.

pub fn from_parts( function: Call, preamble: Preamble<Address, Signature, Extension>, ) -> Self

Create an UncheckedExtrinsic from a Preamble and the actual Call.

pub fn new_bare(function: Call) -> Self

New instance of a bare (ne unsigned) extrinsic.

pub fn new_bare_legacy(function: Call) -> Self

New instance of a bare (ne unsigned) extrinsic on extrinsic format version 4.

pub fn new_signed( function: Call, signed: Address, signature: Signature, tx_ext: Extension, ) -> Self

New instance of an old-school signed transaction on extrinsic format version 4.

pub fn new_transaction(function: Call, tx_ext: Extension) -> Self

New instance of an new-school unsigned transaction.

impl<Address, Call: Dispatchable, Signature, Extension: TransactionExtension<Call>> UncheckedExtrinsic<Address, Call, Signature, Extension>

pub fn extension_weight(&self) -> Weight

Returns the weight of the extension of this transaction, if present. If the transaction doesn’t use any extension, the weight returned is equal to zero.

Trait Implementations

impl<LookupSource, AccountId, Call, Signature, Extension, Lookup> Checkable<Lookup> for UncheckedExtrinsic<LookupSource, Call, Signature, Extension>

where LookupSource: Member + MaybeDisplay, Call: Encode + Member + Dispatchable, Signature: Member + Verify, <Signature as Verify>::Signer: IdentifyAccount<AccountId = AccountId>, Extension: Encode + TransactionExtension<Call>, AccountId: Member + MaybeDisplay, Lookup: Lookup<Source = LookupSource, Target = AccountId>,

type Checked = CheckedExtrinsic<AccountId, Call, Extension>

Returned if check succeeds.

fn check( self, lookup: &Lookup, ) -> Result<Self::Checked, TransactionValidityError>

Check self, given an instance of Context.

fn unchecked_into_checked_i_know_what_i_am_doing( self, lookup: &Lookup, ) -> Result<Self::Checked, TransactionValidityError>

Blindly check self.

impl<Address: Clone, Call: Clone, Signature: Clone, Extension: Clone> Clone for UncheckedExtrinsic<Address, Call, Signature, Extension>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Address: Debug, Call: Debug, Signature: Debug, Extension: Debug> Debug for UncheckedExtrinsic<Address, Call, Signature, Extension>

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

Formats the value using the given formatter.

impl<Address, Call, Signature, Extension> Decode for UncheckedExtrinsic<Address, Call, Signature, Extension>

where Address: Decode, Signature: Decode, Call: 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<'a, Address: Decode, Signature: Decode, Call: Decode, Extension: Decode> Deserialize<'a> for UncheckedExtrinsic<Address, Call, Signature, Extension>

fn deserialize<D>(de: D) -> Result<Self, D::Error>

where D: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl<Address, Call, Signature, Extension> Encode for UncheckedExtrinsic<Address, Call, Signature, Extension>

where Preamble<Address, Signature, Extension>: Encode, Call: Encode, Extension: Encode,

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

Convert self to an owned vector.

fn size_hint(&self) -> usize

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

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

where T: Output + ?Sized,

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

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: TypeInfo, Call: TypeInfo, Signature: TypeInfo, Extension: TypeInfo> ExtrinsicLike for UncheckedExtrinsic<Address, Call, Signature, Extension>

fn is_bare(&self) -> bool

Returns true if this Extrinsic is bare.

fn is_signed(&self) -> Option<bool>

👎Deprecated: Use and implement !is_bare() instead

Is this Extrinsic signed? If no information are available about signed/unsigned, None should be returned.

impl<Address, Call: Dispatchable, Signature, Extension: TransactionExtension<Call>> ExtrinsicMetadata for UncheckedExtrinsic<Address, Call, Signature, Extension>

const VERSIONS: &'static [u8] = _

The format versions of the Extrinsic.

type TransactionExtensions = Extension

Transaction extensions attached to this Extrinsic.

impl<Address, Call, Signature, Extension> From<UncheckedExtrinsic<Address, Call, Signature, Extension>> for OpaqueExtrinsic

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

fn from( extrinsic: UncheckedExtrinsic<Address, Call, Signature, Extension>, ) -> Self

Converts to this type from the input type.

impl<Address: PartialEq, Call: PartialEq, Signature: PartialEq, Extension: PartialEq> PartialEq for UncheckedExtrinsic<Address, Call, Signature, Extension>

fn eq( &self, other: &UncheckedExtrinsic<Address, Call, Signature, Extension>, ) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Address: Encode, Signature: Encode, Call: Encode, Extension: Encode> Serialize for UncheckedExtrinsic<Address, Call, Signature, Extension>

fn serialize<S>(&self, seq: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<Address, Call, Signature, Extension> TypeInfo for UncheckedExtrinsic<Address, Call, Signature, Extension>

where Address: StaticTypeInfo, Call: StaticTypeInfo, Signature: StaticTypeInfo, Extension: StaticTypeInfo,

Manual [TypeInfo] implementation because of custom encoding. The data is a valid encoded Vec<u8>, but requires some logic to extract the signature and payload.

See UncheckedExtrinsic::encode and UncheckedExtrinsic::decode.

type Identity = UncheckedExtrinsic<Address, Call, Signature, Extension>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<Address, Call, Signature, Extension> EncodeLike for UncheckedExtrinsic<Address, Call, Signature, Extension>

where Address: Encode, Signature: Encode, Call: Encode + Dispatchable, Extension: TransactionExtension<Call>,

impl<Address: Eq, Call: Eq, Signature: Eq, Extension: Eq> Eq for UncheckedExtrinsic<Address, Call, Signature, Extension>

impl<Address, Call, Signature, Extension> StructuralPartialEq for UncheckedExtrinsic<Address, Call, Signature, Extension>