Enum polkadot_runtime_parachains::paras::pallet::Call

pub enum Call<T: Config> {
    force_set_current_code {
        para: Id,
        new_code: ValidationCode,
    },
    force_set_current_head {
        para: Id,
        new_head: HeadData,
    },
    force_schedule_code_upgrade {
        para: Id,
        new_code: ValidationCode,
        relay_parent_number: BlockNumberFor<T>,
    },
    force_note_new_head {
        para: Id,
        new_head: HeadData,
    },
    force_queue_action {
        para: Id,
    },
    add_trusted_validation_code {
        validation_code: ValidationCode,
    },
    poke_unused_validation_code {
        validation_code_hash: ValidationCodeHash,
    },
    include_pvf_check_statement {
        stmt: PvfCheckStatement,
        signature: ValidatorSignature,
    },
    force_set_most_recent_context {
        para: Id,
        context: BlockNumberFor<T>,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

force_set_current_code

Set the storage for the parachain validation code immediately.

Fields

para: Id

new_code: ValidationCode

force_set_current_head

Set the storage for the current parachain head data immediately.

Fields

para: Id

new_head: HeadData

force_schedule_code_upgrade

Schedule an upgrade as if it was scheduled in the given relay parent block.

Fields

para: Id

new_code: ValidationCode

relay_parent_number: BlockNumberFor<T>

force_note_new_head

Note a new block head for para within the context of the current block.

Fields

para: Id

new_head: HeadData

force_queue_action

Put a parachain directly into the next session’s action queue. We can’t queue it any sooner than this without going into the initializer…

Fields

para: Id

add_trusted_validation_code

Adds the validation code to the storage.

The code will not be added if it is already present. Additionally, if PVF pre-checking is running for that code, it will be instantly accepted.

Otherwise, the code will be added into the storage. Note that the code will be added into storage with reference count 0. This is to account the fact that there are no users for this code yet. The caller will have to make sure that this code eventually gets used by some parachain or removed from the storage to avoid storage leaks. For the latter prefer to use the poke_unused_validation_code dispatchable to raw storage manipulation.

This function is mainly meant to be used for upgrading parachains that do not follow the go-ahead signal while the PVF pre-checking feature is enabled.

Fields

validation_code: ValidationCode

poke_unused_validation_code

Remove the validation code from the storage iff the reference count is 0.

This is better than removing the storage directly, because it will not remove the code that was suddenly got used by some parachain while this dispatchable was pending dispatching.

Fields

validation_code_hash: ValidationCodeHash

include_pvf_check_statement

Includes a statement for a PVF pre-checking vote. Potentially, finalizes the vote and enacts the results if that was the last vote before achieving the supermajority.

Fields

stmt: PvfCheckStatement

signature: ValidatorSignature

force_set_most_recent_context

Set the storage for the current parachain head data immediately.

Fields

para: Id

context: BlockNumberFor<T>

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_force_set_current_code( para: ParaId, new_code: ValidationCode, ) -> Self

Create a call with the variant force_set_current_code.

pub fn new_call_variant_force_set_current_head( para: ParaId, new_head: HeadData, ) -> Self

Create a call with the variant force_set_current_head.

pub fn new_call_variant_force_schedule_code_upgrade( para: ParaId, new_code: ValidationCode, relay_parent_number: BlockNumberFor<T>, ) -> Self

Create a call with the variant force_schedule_code_upgrade.

pub fn new_call_variant_force_note_new_head( para: ParaId, new_head: HeadData, ) -> Self

Create a call with the variant force_note_new_head.

pub fn new_call_variant_force_queue_action(para: ParaId) -> Self

Create a call with the variant force_queue_action.

pub fn new_call_variant_add_trusted_validation_code( validation_code: ValidationCode, ) -> Self

Create a call with the variant add_trusted_validation_code.

pub fn new_call_variant_poke_unused_validation_code( validation_code_hash: ValidationCodeHash, ) -> Self

Create a call with the variant poke_unused_validation_code.

pub fn new_call_variant_include_pvf_check_statement( stmt: PvfCheckStatement, signature: ValidatorSignature, ) -> Self

Create a call with the variant include_pvf_check_statement.

pub fn new_call_variant_force_set_most_recent_context( para: ParaId, context: BlockNumberFor<T>, ) -> Self

Create a call with the variant force_set_most_recent_context.

Trait Implementations

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

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<T> TypeInfo for Call<T>

where PhantomData<(T,)>: TypeInfo + 'static, BlockNumberFor<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> EncodeLike for Call<T>

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