Enum Call 

pub enum Call<T: Config> {
    set_custom_validation_head_data {
        custom_header: Vec<u8>,
    },
    read_and_write_child_tries {},
    read_and_write_big_value {},
    store_values_in_map {
        max_key: u32,
    },
    remove_value_from_map {
        key: u32,
    },
    send_n_upward_messages {
        n: u32,
    },
    send_upward_message_of_size {
        size: u32,
    },
    queue_hrmp_messages {
        n: u32,
        recipient: ParaId,
    },
    queue_hrmp_messages_to_n_recipients {
        n: u32,
        first_recipient: ParaId,
    },
    schedule_weight_registration {},
    set_inherent_weight_consume {
        weight: Weight,
    },
    consume_weight_inherent {},
    use_more_weight_than_announced {
        must_be_first_block_in_core: bool,
    },
    set_use_full_core {},
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

set_custom_validation_head_data

A test dispatchable for setting a custom head data in validate_block.

Fields

custom_header: Vec<u8>

read_and_write_child_tries

A dispatchable that first reads two values from two different child tries, asserts they are the expected values (if the values exist in the state) and then writes two different values to these child tries.

read_and_write_big_value

Reads a key and writes a big value under this key.

At genesis this key is empty and thus, will only be set in consequent blocks.

store_values_in_map

Stores () in TestMap for keys from 0 up to max_key.

Fields

max_key: u32

remove_value_from_map

Removes the value associated with key from TestMap.

Fields

key: u32

send_n_upward_messages

Directly sets n small UMP messages in PendingUpwardMessages.

Fields

n: u32

send_upward_message_of_size

Sends a UMP message of specific size (in bytes).

Fields

size: u32

queue_hrmp_messages

Queues n small HRMP messages to recipient.

Fields

n: u32

recipient: ParaId

queue_hrmp_messages_to_n_recipients

Queues one HRMP message each to n consecutive recipients starting from first_recipient.

Fields

n: u32

first_recipient: ParaId

schedule_weight_registration

Schedule a 1 second weight registration in the next on_initialize.

set_inherent_weight_consume

Set the weight to be consumed by the next inherent call.

Fields

weight: Weight

consume_weight_inherent

Consume weight via inherent call (clears the storage after consuming).

use_more_weight_than_announced

This function registers a high weight usage manually, while it actually only announces to use a weight of 0 :)

Uses the TestTransactionExtension logic to ensure the transaction is only accepted when we can fit the 1s weight into the block.

Fields

must_be_first_block_in_core: bool

set_use_full_core

Deposits the UseFullCore digest item to signal that this block should use the full core.

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_set_custom_validation_head_data( custom_header: Vec<u8>, ) -> Self

Create a call with the variant set_custom_validation_head_data.

pub fn new_call_variant_read_and_write_child_tries() -> Self

Create a call with the variant read_and_write_child_tries.

pub fn new_call_variant_read_and_write_big_value() -> Self

Create a call with the variant read_and_write_big_value.

pub fn new_call_variant_store_values_in_map(max_key: u32) -> Self

Create a call with the variant store_values_in_map.

pub fn new_call_variant_remove_value_from_map(key: u32) -> Self

Create a call with the variant remove_value_from_map.

pub fn new_call_variant_send_n_upward_messages(n: u32) -> Self

Create a call with the variant send_n_upward_messages.

pub fn new_call_variant_send_upward_message_of_size(size: u32) -> Self

Create a call with the variant send_upward_message_of_size.

pub fn new_call_variant_queue_hrmp_messages(n: u32, recipient: ParaId) -> Self

Create a call with the variant queue_hrmp_messages.

pub fn new_call_variant_queue_hrmp_messages_to_n_recipients( n: u32, first_recipient: ParaId, ) -> Self

Create a call with the variant queue_hrmp_messages_to_n_recipients.

pub fn new_call_variant_schedule_weight_registration() -> Self

Create a call with the variant schedule_weight_registration.

pub fn new_call_variant_set_inherent_weight_consume(weight: Weight) -> Self

Create a call with the variant set_inherent_weight_consume.

pub fn new_call_variant_consume_weight_inherent() -> Self

Create a call with the variant consume_weight_inherent.

pub fn new_call_variant_use_more_weight_than_announced( must_be_first_block_in_core: bool, ) -> Self

Create a call with the variant use_more_weight_than_announced.

pub fn new_call_variant_set_use_full_core() -> Self

Create a call with the variant set_use_full_core.

Trait Implementations

impl<T: Config> Authorize for Call<T>

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<T: Config> CheckIfFeeless for Call<T>

type Origin = <T 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<T: Config> Clone for Call<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Config> Debug for Call<T>

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

Formats the value using the given formatter.

impl<T: Config> Decode for Call<T>

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<T: Config> Encode for Call<T>

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<T: Config> GetCallIndex for Call<T>

fn get_call_index(&self) -> u8

Return the index of this Call.

fn get_call_indices() -> &'static [u8]

Return all call indices in the same order as GetCallName.

impl<T: Config> GetCallName for Call<T>

fn get_call_name(&self) -> &'static str

Return the function name of the Call.

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

Return all function names in the same order as GetCallIndex.

impl<T: Config> GetDispatchInfo for Call<T>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Config> PartialEq for Call<T>

fn eq(&self, other: &Self) -> 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<T> TypeInfo for Call<T>

where PhantomData<(T,)>: TypeInfo + 'static, T: Config + 'static,

type Identity = Call<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> UnfilteredDispatchable for Call<T>

type RuntimeOrigin = <T as Config>::RuntimeOrigin

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

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

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

impl<T: Config> DecodeWithMemTracking for Call<T>

impl<T: Config> EncodeLike for Call<T>

impl<T: Config> Eq for Call<T>