Enum RuntimeCall

pub enum RuntimeCall {
    System(CallableCallFor<System, Runtime>),
    Babe(CallableCallFor<Babe, Runtime>),
    SubstrateTest(CallableCallFor<SubstrateTest, Runtime>),
    Utility(CallableCallFor<Utility, Runtime>),
    Balances(CallableCallFor<Balances, Runtime>),
}

The aggregated runtime call type.

Variants

System(CallableCallFor<System, Runtime>)

Babe(CallableCallFor<Babe, Runtime>)

SubstrateTest(CallableCallFor<SubstrateTest, Runtime>)

Utility(CallableCallFor<Utility, Runtime>)

Balances(CallableCallFor<Balances, Runtime>)

Trait Implementations

impl Authorize for RuntimeCall

fn authorize( &self, source: TransactionSource, ) -> Option<Result<(ValidTransaction, Weight), TransactionValidityError>>

The authorize function.

fn weight_of_authorize(&self) -> Weight

The weight of the authorization function.

impl CheckIfFeeless for RuntimeCall

type Origin = <Runtime as Config>::RuntimeOrigin

The Origin type of the runtime.

fn is_feeless(&self, origin: &Self::Origin) -> bool

Checks if the dispatchable satisfies the feeless condition as defined by #[pallet::feeless_if]

impl Clone for RuntimeCall

fn clone(&self) -> RuntimeCall

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RuntimeCall

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

Formats the value using the given formatter.

impl Decode for RuntimeCall

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> 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 Dispatchable for RuntimeCall

type RuntimeOrigin = RuntimeOrigin

Every function call from your runtime has an origin, which specifies where the extrinsic was generated from. In the case of a signed extrinsic (transaction), the origin contains an identifier for the caller. The origin can be empty in the case of an inherent extrinsic.

type Config = RuntimeCall

…

type Info = DispatchInfo

An opaque set of information attached to the transaction. This could be constructed anywhere down the line in a runtime. The current Substrate runtime uses a struct with the same name to represent the dispatch class and weight.

type PostInfo = PostDispatchInfo

Additional information that is returned by dispatch. Can be used to supply the caller with information about a Dispatchable that is only known post dispatch.

fn dispatch(self, origin: RuntimeOrigin) -> DispatchResultWithPostInfo

Actually dispatch this call and return the result of it.

impl Encode for RuntimeCall

fn size_hint(&self) -> usize

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

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

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 From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall

fn from(call: CallableCallFor<System, Runtime>) -> Self

Converts to this type from the input type.

impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall

fn from(call: CallableCallFor<Babe, Runtime>) -> Self

Converts to this type from the input type.

impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall

fn from(call: CallableCallFor<SubstrateTest, Runtime>) -> Self

Converts to this type from the input type.

impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall

fn from(call: CallableCallFor<Utility, Runtime>) -> Self

Converts to this type from the input type.

impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall

fn from(call: CallableCallFor<Balances, Runtime>) -> Self

Converts to this type from the input type.

impl GetCallMetadata for RuntimeCall

fn get_call_metadata(&self) -> CallMetadata

Return a CallMetadata, containing function and pallet name of the Call.

fn get_module_names() -> &'static [&'static str]

Return all module names.

fn get_call_names(module: &str) -> &'static [&'static str]

Return all function names for the given module.

impl GetDispatchInfo for RuntimeCall

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl IsSubType<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall

fn is_sub_type(&self) -> Option<&CallableCallFor<System, Runtime>>

Returns Some(_) if self is an instance of sub type T.

impl IsSubType<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall

fn is_sub_type(&self) -> Option<&CallableCallFor<Babe, Runtime>>

Returns Some(_) if self is an instance of sub type T.

impl IsSubType<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall

fn is_sub_type(&self) -> Option<&CallableCallFor<SubstrateTest, Runtime>>

Returns Some(_) if self is an instance of sub type T.

impl IsSubType<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall

fn is_sub_type(&self) -> Option<&CallableCallFor<Utility, Runtime>>

Returns Some(_) if self is an instance of sub type T.

impl IsSubType<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall

fn is_sub_type(&self) -> Option<&CallableCallFor<Balances, Runtime>>

Returns Some(_) if self is an instance of sub type T.

impl PartialEq for RuntimeCall

fn eq(&self, other: &RuntimeCall) -> 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 TransactionExtension<RuntimeCall> for CheckSubstrateCall

const IDENTIFIER: &'static str = "CheckSubstrateCall"

Unique identifier of this signed extension.

type Implicit = ()

Any additional data which was known at the time of transaction construction and can be useful in authenticating the transaction. This is determined dynamically in part from the on-chain environment using the implicit function and not directly contained in the transaction itself and therefore is considered “implicit”.

type Pre = ()

The type that encodes information that can be passed from prepare to post_dispatch.

type Val = ()

The type that encodes information that can be passed from validate to prepare.

fn weight(&self, _call: &RuntimeCall) -> Weight

The weight consumed by executing this extension instance fully during transaction dispatch.

fn prepare( self, _val: Self::Val, _origin: &DispatchOriginOf<RuntimeCall>, _call: &RuntimeCall, _info: &DispatchInfoOf<RuntimeCall>, _len: usize, ) -> Result<Self::Pre, TransactionValidityError>

Do any pre-flight stuff for a transaction after validation.

fn validate( &self, origin: <RuntimeCall as Dispatchable>::RuntimeOrigin, call: &RuntimeCall, _info: &DispatchInfoOf<RuntimeCall>, _len: usize, _self_implicit: Self::Implicit, _inherited_implication: &impl Encode, _source: TransactionSource, ) -> Result<(ValidTransaction, Self::Val, <RuntimeCall as Dispatchable>::RuntimeOrigin), TransactionValidityError>

Validate a transaction for the transaction queue.

fn implicit(&self) -> Result<Self::Implicit, TransactionValidityError>

Determine any additional data which was known at the time of transaction construction and can be useful in authenticating the transaction. The expected usage of this is to include in any data which is signed and verified as part of transaction validation. Also perform any pre-signature-verification checks and return an error if needed.

fn metadata() -> Vec<TransactionExtensionMetadata>

Returns the metadata for this extension.

fn post_dispatch_details( _pre: Self::Pre, _info: &<Call as Dispatchable>::Info, _post_info: &<Call as Dispatchable>::PostInfo, _len: usize, _result: &Result<(), DispatchError>, ) -> Result<Weight, TransactionValidityError>

Do any post-flight stuff for an extrinsic.

fn post_dispatch( pre: Self::Pre, info: &<Call as Dispatchable>::Info, post_info: &mut <Call as Dispatchable>::PostInfo, len: usize, result: &Result<(), DispatchError>, ) -> Result<(), TransactionValidityError>

A wrapper for post_dispatch_details that refunds the unspent weight consumed by this extension into the post dispatch information.

fn bare_validate( _call: &Call, _info: &<Call as Dispatchable>::Info, _len: usize, ) -> Result<ValidTransaction, TransactionValidityError>

Validation logic for bare extrinsics.

fn bare_validate_and_prepare( _call: &Call, _info: &<Call as Dispatchable>::Info, _len: usize, ) -> Result<(), TransactionValidityError>

All pre-flight logic run before dispatching bare extrinsics.

fn bare_post_dispatch( _info: &<Call as Dispatchable>::Info, _post_info: &mut <Call as Dispatchable>::PostInfo, _len: usize, _result: &Result<(), DispatchError>, ) -> Result<(), TransactionValidityError>

Post dispatch logic run after dispatching bare extrinsics.

impl TypeInfo for RuntimeCall

type Identity = RuntimeCall

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl UnfilteredDispatchable for RuntimeCall

type RuntimeOrigin = RuntimeOrigin

The origin type of the runtime, (i.e. frame_system::Config::RuntimeOrigin).

fn dispatch_bypass_filter( self, origin: RuntimeOrigin, ) -> DispatchResultWithPostInfo

Dispatch this call but do not check the filter in origin.

impl DecodeWithMemTracking for RuntimeCall

impl EncodeLike for RuntimeCall

impl Eq for RuntimeCall

impl StructuralPartialEq for RuntimeCall