Enum Call 

pub enum Call<T: Config> {
    authorize_code {
        message: MessageToRelay<T::AccountId>,
    },
    apply_authorized_code {
        para_id: ParaId,
        validation_code: Vec<u8>,
    },
    cancel_authorization {
        message: MessageToRelay<T::AccountId>,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

authorize_code

Accept a control-plane message from the parachain’s registrar pallet and authorize the validation code that will follow.

Only callable by a trusted XCM origin (e.g. the Coretime chain), never by users.

A request this pallet will not act on is not an extrinsic failure. Failing would roll back the rejection report along with everything else, and the parachain would sit on a held deposit waiting for news that never comes. So a rejection is applied, reported, and returns Ok.

Fields

message: MessageToRelay<T::AccountId>

apply_authorized_code

Upload the validation code for a pending authorization, onboarding the para.

Needs no signature and pays no fee. Anybody may submit: the pending entry already fixes the exact bytes that will be accepted, and the manager has already paid for them on the parachain.

Fields

para_id: ParaId

validation_code: Vec<u8>

cancel_authorization

Drop the authorization held for a para id, at the parachain’s request.

Only callable by a trusted XCM origin (e.g. the Coretime chain), never by users. This is the only way an authorization that never received its code goes away, and the manager pays for it on the parachain: nothing here expires on its own.

Answered with [MessageToParaV1::CancelResponse], which is what lets the parachain release the deposit. Refused, and reported as such, if the code did land in the meantime and the para is registered: the deposit is then owed after all.

Cancelling something that was never pending is not an error. The request may simply have been rejected here and the report lost, and the parachain still needs an answer it can act on.

Fields

message: MessageToRelay<T::AccountId>

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_authorize_code( message: MessageToRelay<T::AccountId>, ) -> Self

Create a call with the variant authorize_code.

pub fn new_call_variant_apply_authorized_code( para_id: ParaId, validation_code: Vec<u8>, ) -> Self

Create a call with the variant apply_authorized_code.

pub fn new_call_variant_cancel_authorization( message: MessageToRelay<T::AccountId>, ) -> Self

Create a call with the variant cancel_authorization.

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, MessageToRelay<T::AccountId>: 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>

where MessageToRelay<T::AccountId>: DecodeWithMemTracking,

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

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