Enum pallet_bridge_parachains::pallet::Call

pub enum Call<T: Config<I>, I: 'static = ()> {
    submit_parachain_heads {
        at_relay_block: (RelayBlockNumber, RelayBlockHash),
        parachains: Vec<(ParaId, ParaHash)>,
        parachain_heads_proof: ParaHeadsProof,
    },
    set_owner {
        new_owner: Option<T::AccountId>,
    },
    set_operating_mode {
        operating_mode: BasicOperatingMode,
    },
    submit_parachain_heads_ex {
        at_relay_block: (RelayBlockNumber, RelayBlockHash),
        parachains: Vec<(ParaId, ParaHash)>,
        parachain_heads_proof: ParaHeadsProof,
        is_free_execution_expected: bool,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

submit_parachain_heads

Submit proof of one or several parachain heads.

The proof is supposed to be proof of some Heads entries from the polkadot-runtime-parachains::paras pallet instance, deployed at the bridged chain. The proof is supposed to be crafted at the relay_header_hash that must already be imported by corresponding GRANDPA pallet at this chain.

The call fails if:

• the pallet is halted;

• the relay chain block at_relay_block is not imported by the associated bridge GRANDPA pallet.

The call may succeed, but some heads may not be updated e.g. because pallet knows better head or it isn’t tracked by the pallet.

Fields

at_relay_block: (RelayBlockNumber, RelayBlockHash)

parachains: Vec<(ParaId, ParaHash)>

parachain_heads_proof: ParaHeadsProof

set_owner

Change PalletOwner.

May only be called either by root, or by PalletOwner.

Fields

new_owner: Option<T::AccountId>

set_operating_mode

Halt or resume all pallet operations.

May only be called either by root, or by PalletOwner.

Fields

operating_mode: BasicOperatingMode

submit_parachain_heads_ex

Submit proof of one or several parachain heads.

The proof is supposed to be proof of some Heads entries from the polkadot-runtime-parachains::paras pallet instance, deployed at the bridged chain. The proof is supposed to be crafted at the relay_header_hash that must already be imported by corresponding GRANDPA pallet at this chain.

The call fails if:

• the pallet is halted;

• the relay chain block at_relay_block is not imported by the associated bridge GRANDPA pallet.

The call may succeed, but some heads may not be updated e.g. because pallet knows better head or it isn’t tracked by the pallet.

The is_free_execution_expected parameter is not really used inside the call. It is used by the transaction extension, which should be registered at the runtime level. If this parameter is true, the transaction will be treated as invalid, if the call won’t be executed for free. If transaction extension is not used by the runtime, this parameter is not used at all.

Fields

at_relay_block: (RelayBlockNumber, RelayBlockHash)

parachains: Vec<(ParaId, ParaHash)>

parachain_heads_proof: ParaHeadsProof

is_free_execution_expected: bool

Implementations

impl<T: Config<I>, I: 'static> Call<T, I>

pub fn new_call_variant_submit_parachain_heads( at_relay_block: (RelayBlockNumber, RelayBlockHash), parachains: Vec<(ParaId, ParaHash)>, parachain_heads_proof: ParaHeadsProof, ) -> Self

Create a call with the variant submit_parachain_heads.

pub fn new_call_variant_set_owner(new_owner: Option<T::AccountId>) -> Self

Create a call with the variant set_owner.

pub fn new_call_variant_set_operating_mode( operating_mode: BasicOperatingMode, ) -> Self

Create a call with the variant set_operating_mode.

pub fn new_call_variant_submit_parachain_heads_ex( at_relay_block: (RelayBlockNumber, RelayBlockHash), parachains: Vec<(ParaId, ParaHash)>, parachain_heads_proof: ParaHeadsProof, is_free_execution_expected: bool, ) -> Self

Create a call with the variant submit_parachain_heads_ex.

Trait Implementations

impl<T: Config<I>, I: 'static> CheckIfFeeless for Call<T, I>

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<I>, I: 'static> Clone for Call<T, I>

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<I>, I: 'static> Debug for Call<T, I>

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

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

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<I>, I: 'static> Encode for Call<T, I>

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<I>, I: 'static> GetCallIndex for Call<T, I>

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<I>, I: 'static> GetCallName for Call<T, I>

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<I>, I: 'static> GetDispatchInfo for Call<T, I>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Config<I>, I: 'static> PartialEq for Call<T, I>

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

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

type Identity = Call<T, I>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config<I>, I: 'static> UnfilteredDispatchable for Call<T, I>

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<I>, I: 'static> EncodeLike for Call<T, I>

impl<T: Config<I>, I: 'static> Eq for Call<T, I>