Struct sp_runtime::generic::UncheckedExtrinsic

pub struct UncheckedExtrinsic<Address, Call, Signature, Extra>
where
    Extra: SignedExtension,
{
    pub signature: Option<(Address, Signature, Extra)>,
    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

signature: Option<(Address, Signature, Extra)>

The signature, address, number of extrinsics have come before from the same signer and an era describing the longevity of this transaction, if this is a signed extrinsic.

None if it is unsigned or an inherent.

function: Call

The function that should be called.

Implementations

impl<Address, Call, Signature, Extra: SignedExtension> UncheckedExtrinsic<Address, Call, Signature, Extra>

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

New instance of a signed extrinsic aka “transaction”.

pub fn new_unsigned(function: Call) -> Self

New instance of an unsigned extrinsic aka “inherent”.

Trait Implementations

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

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

type Checked = CheckedExtrinsic<AccountId, Call, Extra>

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, Extra> Clone for UncheckedExtrinsic<Address, Call, Signature, Extra>

where Extra: SignedExtension + Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

where Address: Debug, Call: Debug, Extra: SignedExtension,

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

Formats the value using the given formatter.

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

where Address: Decode, Signature: Decode, Call: Decode, Extra: SignedExtension,

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

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, Extra> Encode for UncheckedExtrinsic<Address, Call, Signature, Extra>

where Address: Encode, Signature: Encode, Call: Encode, Extra: SignedExtension,

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, Extra: SignedExtension + TypeInfo> Extrinsic for UncheckedExtrinsic<Address, Call, Signature, Extra>

type Call = Call

The function call.

type SignaturePayload = (Address, Signature, Extra)

The payload we carry for signed extrinsics.

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

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

fn new( function: Call, signed_data: Option<Self::SignaturePayload> ) -> Option<Self>

Create new instance of the extrinsic.

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

where Extra: SignedExtension,

const VERSION: u8 = 4u8

The format version of the Extrinsic.

type SignedExtensions = Extra

Signed extensions attached to this Extrinsic.

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

where Address: Encode, Signature: Encode, Call: Encode, Extra: SignedExtension,

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

Converts to this type from the input type.

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

where Extra: SignedExtension + PartialEq,

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

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, Extra> TypeInfo for UncheckedExtrinsic<Address, Call, Signature, Extra>

where Address: StaticTypeInfo, Call: StaticTypeInfo, Signature: StaticTypeInfo, Extra: SignedExtension + 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, Extra>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

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

where Address: Encode, Signature: Encode, Call: Encode, Extra: SignedExtension,

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

where Extra: SignedExtension + Eq,

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

where Extra: SignedExtension,