Struct polkadot_service::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, ) -> UncheckedExtrinsic<Address, Call, Signature, Extension>

👎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>

Create an UncheckedExtrinsic from a Preamble and the actual Call.

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

New instance of a bare (ne unsigned) extrinsic.

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

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>

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>

New instance of an 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.

fn unchecked_into_checked_i_know_what_i_am_doing( self, lookup: &Lookup, ) -> Result<<UncheckedExtrinsic<LookupSource, Call, Signature, Extension> as Checkable<Lookup>>::Checked, TransactionValidityError>

Blindly check self.

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

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

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, Call, Signature, Extension> Debug for UncheckedExtrinsic<Address, Call, Signature, Extension>

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> Decode for UncheckedExtrinsic<Address, Call, Signature, Extension>

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

fn decode<I>( input: &mut I, ) -> Result<UncheckedExtrinsic<Address, Call, Signature, Extension>, 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: Decode, Extension: Decode,

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>

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

type Call = Call

fn call(&self) -> &Call

Get the call of the extrinsic.

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

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

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, 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> GetDispatchInfo for UncheckedExtrinsic<Address, Call, Signature, Extension>

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

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: <UncheckedExtrinsic<Address, Call, Signature, Extra> as ExtrinsicCall>::Call, ) -> UncheckedExtrinsic<Address, Call, Signature, Extra>

Create a new inherent from a given call.

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

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

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, Signature, Call, Extension> Serialize for UncheckedExtrinsic<Address, Call, Signature, Extension>

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

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: <UncheckedExtrinsic<Address, Call, Signature, Extension> as ExtrinsicCall>::Call, signed: Address, signature: Signature, tx_ext: Extension, ) -> UncheckedExtrinsic<Address, Call, Signature, Extension>

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> EncodeLike for UncheckedExtrinsic<Address, Call, Signature, Extension>

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

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

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

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