Struct UncheckedExtrinsic 

pub struct UncheckedExtrinsic<Address, Call, Signature, Extension, const MAX_CALL_SIZE: usize = subsoil::::runtime::generic::unchecked_extrinsic::UncheckedExtrinsic::{constant#0}> {
    pub preamble: Preamble<Address, Signature, Extension>,
    pub function: Call,
    pub encoded_call: Option<Vec<u8>>,
}

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.

encoded_call: Option<Vec<u8>>

Stores the raw encoded call.

This is mainly interesting if this extrinsic was created by decoding it from bytes. In this case this field should be set to Some holding the original bytes used to decode the Self::function. This is done to protect against decode implementations of Call that are not bijective (encodes to the exact same bytes it was encoded from). If this field is set, it is being used when re-encoding this transaction.

Implementations

impl<Address, Call, Signature, Extension, const MAX_CALL_SIZE: usize> UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

pub fn new_unsigned( function: Call, ) -> UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

👎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>, ) -> UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

Create an UncheckedExtrinsic from a Preamble and the actual Call.

pub fn new_bare( function: Call, ) -> UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

New instance of a bare (ne unsigned) extrinsic.

pub fn new_bare_legacy( function: Call, ) -> UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

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, ) -> UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

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

pub fn new_transaction( function: Call, tx_ext: Extension, ) -> UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

New instance of a new-school unsigned transaction.

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

where Call: Dispatchable, Extension: TransactionExtension<Call>,

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<<UncheckedExtrinsic<LookupSource, Call, Signature, Extension> as Checkable<Lookup>>::Checked, TransactionValidityError>

Check self, given an instance of Context.

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

where Address: Clone, Call: Clone, Signature: Clone, Extension: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where Address: Debug, Call: Debug, Signature: Debug, Extension: Debug,

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

Formats the value using the given formatter.

impl<Address, Call, Signature, Extension, const MAX_CALL_SIZE: usize> Decode for UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

where Address: Decode, Signature: Decode, Call: DecodeWithMemTracking, Extension: Decode,

fn decode<I>( input: &mut I, ) -> Result<UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>, Error>

where I: Input,

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

where Address: Decode, Signature: Decode, Call: DecodeWithMemTracking, Extension: Decode,

Available on crate feature serde only.

fn deserialize<D>( de: D, ) -> Result<UncheckedExtrinsic<Address, Call, Signature, Extension>, <D as Deserializer<'a>>::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, Call, Signature, Extra> ExtrinsicCall for UncheckedExtrinsic<Address, Call, Signature, Extra>

type Call = Call

The type of the call.

fn call(&self) -> &Call

Get a reference to the call of the extrinsic.

fn into_call( self, ) -> <UncheckedExtrinsic<Address, Call, Signature, Extra> as ExtrinsicCall>::Call

Convert the extrinsic into its call.

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

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.

fn is_bare(&self) -> bool

Returns true if this Extrinsic is bare.

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

where Call: Dispatchable, Extension: TransactionExtension<Call>,

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

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

Converts to this type from the input type.

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

where Call: GetDispatchInfo + Dispatchable,

Implementation for unchecked extrinsic.

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<Address, Call, Signature, Extra> InherentBuilder for UncheckedExtrinsic<Address, Call, Signature, Extra>

where Address: TypeInfo, Call: TypeInfo, Signature: TypeInfo, Extra: TypeInfo,

fn new_inherent(call: Self::Call) -> Self

Create a new inherent from a given call.

impl<Address, Call, Signature, Extension, const MAX_CALL_SIZE: usize> LazyExtrinsic for UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

where Preamble<Address, Signature, Extension>: Decode, Call: DecodeWithMemTracking,

fn decode_unprefixed( data: &[u8], ) -> Result<UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>, Error>

Try to decode the lazy extrinsic.

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

where Address: PartialEq, Call: PartialEq, Signature: PartialEq, Extension: PartialEq,

fn eq( &self, other: &UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>, ) -> 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, Call, Extension> Serialize for UncheckedExtrinsic<Address, Call, Signature, Extension>

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

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

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

where Address: TypeInfo, Call: TypeInfo, Signature: TypeInfo, Extension: TypeInfo,

type Address = Address

type Signature = Signature

type Extension = Extension

fn new_signed_transaction( call: Self::Call, signed: Address, signature: Signature, tx_ext: Extension, ) -> Self

Create a new signed transaction from a given call and extension using the provided signature data.

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, const MAX_CALL_SIZE: usize> DecodeWithMemTracking for UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

where Address: DecodeWithMemTracking, Call: DecodeWithMemTracking, Signature: DecodeWithMemTracking, Extension: DecodeWithMemTracking,

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, Call, Signature, Extension, const MAX_CALL_SIZE: usize> Eq for UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>

where Address: Eq, Call: Eq, Signature: Eq, Extension: Eq,