Enum polkadot_runtime_parachains::hrmp::pallet::Call

pub enum Call<T: Config> {
    hrmp_init_open_channel {
        recipient: Id,
        proposed_max_capacity: u32,
        proposed_max_message_size: u32,
    },
    hrmp_accept_open_channel {
        sender: Id,
    },
    hrmp_close_channel {
        channel_id: HrmpChannelId,
    },
    force_clean_hrmp {
        para: Id,
        num_inbound: u32,
        num_outbound: u32,
    },
    force_process_hrmp_open {
        channels: u32,
    },
    force_process_hrmp_close {
        channels: u32,
    },
    hrmp_cancel_open_request {
        channel_id: HrmpChannelId,
        open_requests: u32,
    },
    force_open_hrmp_channel {
        sender: Id,
        recipient: Id,
        max_capacity: u32,
        max_message_size: u32,
    },
    establish_system_channel {
        sender: Id,
        recipient: Id,
    },
    poke_channel_deposits {
        sender: Id,
        recipient: Id,
    },
    establish_channel_with_system {
        target_system_chain: Id,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

hrmp_init_open_channel

Initiate opening a channel from a parachain to a given recipient with given channel parameters.

• proposed_max_capacity - specifies how many messages can be in the channel at once.
• proposed_max_message_size - specifies the maximum size of the messages.

These numbers are a subject to the relay-chain configuration limits.

The channel can be opened only after the recipient confirms it and only on a session change.

Fields

recipient: Id

proposed_max_capacity: u32

proposed_max_message_size: u32

hrmp_accept_open_channel

Accept a pending open channel request from the given sender.

The channel will be opened only on the next session boundary.

Fields

sender: Id

hrmp_close_channel

Initiate unilateral closing of a channel. The origin must be either the sender or the recipient in the channel being closed.

The closure can only happen on a session change.

Fields

channel_id: HrmpChannelId

force_clean_hrmp

This extrinsic triggers the cleanup of all the HRMP storage items that a para may have. Normally this happens once per session, but this allows you to trigger the cleanup immediately for a specific parachain.

Number of inbound and outbound channels for para must be provided as witness data.

Origin must be the ChannelManager.

Fields

para: Id

num_inbound: u32

num_outbound: u32

force_process_hrmp_open

Force process HRMP open channel requests.

If there are pending HRMP open channel requests, you can use this function to process all of those requests immediately.

Total number of opening channels must be provided as witness data.

Origin must be the ChannelManager.

Fields

channels: u32

force_process_hrmp_close

Force process HRMP close channel requests.

If there are pending HRMP close channel requests, you can use this function to process all of those requests immediately.

Total number of closing channels must be provided as witness data.

Origin must be the ChannelManager.

Fields

channels: u32

hrmp_cancel_open_request

This cancels a pending open channel request. It can be canceled by either of the sender or the recipient for that request. The origin must be either of those.

The cancellation happens immediately. It is not possible to cancel the request if it is already accepted.

Total number of open requests (i.e. HrmpOpenChannelRequestsList) must be provided as witness data.

Fields

channel_id: HrmpChannelId

open_requests: u32

force_open_hrmp_channel

Open a channel from a sender to a recipient ParaId. Although opened by governance, the max_capacity and max_message_size are still subject to the Relay Chain’s configured limits.

Expected use is when one (and only one) of the ParaIds involved in the channel is governed by the system, e.g. a system parachain.

Origin must be the ChannelManager.

Fields

sender: Id

recipient: Id

max_capacity: u32

max_message_size: u32

establish_system_channel

Establish an HRMP channel between two system chains. If the channel does not already exist, the transaction fees will be refunded to the caller. The system does not take deposits for channels between system chains, and automatically sets the message number and size limits to the maximum allowed by the network’s configuration.

Arguments:

• sender: A system chain, ParaId.
• recipient: A system chain, ParaId.

Any signed origin can call this function, but both inputs MUST be system chains. If the channel does not exist yet, there is no fee.

Fields

sender: Id

recipient: Id

poke_channel_deposits

Update the deposits held for an HRMP channel to the latest Configuration. Channels with system chains do not require a deposit.

Arguments:

• sender: A chain, ParaId.
• recipient: A chain, ParaId.

Any signed origin can call this function.

Fields

sender: Id

recipient: Id

establish_channel_with_system

Establish a bidirectional HRMP channel between a parachain and a system chain.

Arguments:

• target_system_chain: A system chain, ParaId.

The origin needs to be the parachain origin.

Fields

target_system_chain: Id

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_hrmp_init_open_channel( recipient: ParaId, proposed_max_capacity: u32, proposed_max_message_size: u32, ) -> Self

Create a call with the variant hrmp_init_open_channel.

pub fn new_call_variant_hrmp_accept_open_channel(sender: ParaId) -> Self

Create a call with the variant hrmp_accept_open_channel.

pub fn new_call_variant_hrmp_close_channel(channel_id: HrmpChannelId) -> Self

Create a call with the variant hrmp_close_channel.

pub fn new_call_variant_force_clean_hrmp( para: ParaId, num_inbound: u32, num_outbound: u32, ) -> Self

Create a call with the variant force_clean_hrmp.

pub fn new_call_variant_force_process_hrmp_open(channels: u32) -> Self

Create a call with the variant force_process_hrmp_open.

pub fn new_call_variant_force_process_hrmp_close(channels: u32) -> Self

Create a call with the variant force_process_hrmp_close.

pub fn new_call_variant_hrmp_cancel_open_request( channel_id: HrmpChannelId, open_requests: u32, ) -> Self

Create a call with the variant hrmp_cancel_open_request.

pub fn new_call_variant_force_open_hrmp_channel( sender: ParaId, recipient: ParaId, max_capacity: u32, max_message_size: u32, ) -> Self

Create a call with the variant force_open_hrmp_channel.

pub fn new_call_variant_establish_system_channel( sender: ParaId, recipient: ParaId, ) -> Self

Create a call with the variant establish_system_channel.

pub fn new_call_variant_poke_channel_deposits( sender: ParaId, recipient: ParaId, ) -> Self

Create a call with the variant poke_channel_deposits.

pub fn new_call_variant_establish_channel_with_system( target_system_chain: ParaId, ) -> Self

Create a call with the variant establish_channel_with_system.

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