Enum Call 

pub enum Call<T: Config> {
    reserve {},
    register {
        para_id: ParaId,
        genesis_head: Vec<u8>,
        code_len: u32,
        code_hash: H256,
    },
    cancel_registration {
        para_id: ParaId,
    },
    receive {
        message: MessageToPara,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

reserve

Reserve the next free para id for the caller.

Takes Config::ReservationConsideration. The caller becomes the manager of the new id and is the only account that may Pallet::register against it.

register

Ask the relay chain to register head data and validation code for a reserved para id.

The validation code itself stays here: only code_hash and code_len are sent. The caller uploads the blob to the relay chain separately, which accepts it only if it hashes to code_hash and is exactly code_len bytes long.

Costs

Takes Config::RegistrationConsideration for the head data and the declared code length, on top of the para id reservation. It is returned if the relay chain rejects the registration or if the caller later abandons it.

Fields

para_id: ParaId

genesis_head: Vec<u8>

code_len: u32

code_hash: H256

cancel_registration

Give up on a registration the relay chain never reported on.

Callable from Config::PendingDeadline blocks after the request. Nothing on the relay chain abandons a registration on its own, so this is what ends one whose code never turned up, and the manager pays for the round trip rather than every relay-chain block paying for a sweep.

The deposit is not released here: the relay chain is asked to drop the authorization first, and Pallet::receive releases the deposit when it confirms. Waiting for that answer is the point. A registration that did go through, with a verdict that got lost on the way here, must not have its deposit refunded, and only the relay chain knows which of the two happened.

The para id itself stays reserved either way, so the manager can simply try again.

Fields

para_id: ParaId

receive

Accept a report from the relay chain’s registrar pallet.

Not callable by users: the origin must be the relay chain.

Fields

message: MessageToPara

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_reserve() -> Self

Create a call with the variant reserve.

pub fn new_call_variant_register( para_id: ParaId, genesis_head: Vec<u8>, code_len: u32, code_hash: H256, ) -> Self

Create a call with the variant register.

pub fn new_call_variant_cancel_registration(para_id: ParaId) -> Self

Create a call with the variant cancel_registration.

pub fn new_call_variant_receive(message: MessageToPara) -> Self

Create a call with the variant receive.

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>