Enum Call 

pub enum Call<T: Config<I>, I: 'static = ()> {
    set_owner {
        new_owner: Option<T::AccountId>,
    },
    set_operating_mode {
        operating_mode: MessagesOperatingMode,
    },
    receive_messages_proof {
        relayer_id_at_bridged_chain: AccountIdOf<BridgedChainOf<T, I>>,
        proof: Box<FromBridgedChainMessagesProof<HashOf<BridgedChainOf<T, I>>, T::LaneId>>,
        messages_count: u32,
        dispatch_weight: Weight,
    },
    receive_messages_delivery_proof {
        proof: FromBridgedChainMessagesDeliveryProof<HashOf<BridgedChainOf<T, I>>, T::LaneId>,
        relayers_state: UnrewardedRelayersState,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

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/some pallet operations.

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

Fields

operating_mode: MessagesOperatingMode

receive_messages_proof

Receive messages proof from bridged chain.

The weight of the call assumes that the transaction always brings outbound lane state update. Because of that, the submitter (relayer) has no benefit of not including this data in the transaction, so reward confirmations lags should be minimal.

The call fails if:

• the pallet is halted;

• the call origin is not Signed(_);

• there are too many messages in the proof;

• the proof verification procedure returns an error - e.g. because header used to craft proof is not imported by the associated finality pallet;

• the dispatch_weight argument is not sufficient to dispatch all bundled messages.

The call may succeed, but some messages may not be delivered e.g. if they are not fit into the unrewarded relayers vector.

Fields

relayer_id_at_bridged_chain: AccountIdOf<BridgedChainOf<T, I>>

proof: Box<FromBridgedChainMessagesProof<HashOf<BridgedChainOf<T, I>>, T::LaneId>>

messages_count: u32

dispatch_weight: Weight

receive_messages_delivery_proof

Receive messages delivery proof from bridged chain.

Fields

proof: FromBridgedChainMessagesDeliveryProof<HashOf<BridgedChainOf<T, I>>, T::LaneId>

relayers_state: UnrewardedRelayersState

Implementations

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

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: MessagesOperatingMode, ) -> Self

Create a call with the variant set_operating_mode.

pub fn new_call_variant_receive_messages_proof( relayer_id_at_bridged_chain: AccountIdOf<BridgedChainOf<T, I>>, proof: Box<FromBridgedChainMessagesProof<HashOf<BridgedChainOf<T, I>>, T::LaneId>>, messages_count: u32, dispatch_weight: Weight, ) -> Self

Create a call with the variant receive_messages_proof.

pub fn new_call_variant_receive_messages_delivery_proof( proof: FromBridgedChainMessagesDeliveryProof<HashOf<BridgedChainOf<T, I>>, T::LaneId>, relayers_state: UnrewardedRelayersState, ) -> Self

Create a call with the variant receive_messages_delivery_proof.

Trait Implementations

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

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

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

where PhantomData<(T, I)>: TypeInfo + 'static, Option<T::AccountId>: TypeInfo + 'static, AccountIdOf<BridgedChainOf<T, I>>: TypeInfo + 'static, Box<FromBridgedChainMessagesProof<HashOf<BridgedChainOf<T, I>>, T::LaneId>>: TypeInfo + 'static, FromBridgedChainMessagesDeliveryProof<HashOf<BridgedChainOf<T, I>>, T::LaneId>: 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> DecodeWithMemTracking for Call<T, I>

where Option<T::AccountId>: DecodeWithMemTracking, AccountIdOf<BridgedChainOf<T, I>>: DecodeWithMemTracking, Box<FromBridgedChainMessagesProof<HashOf<BridgedChainOf<T, I>>, T::LaneId>>: DecodeWithMemTracking, FromBridgedChainMessagesDeliveryProof<HashOf<BridgedChainOf<T, I>>, T::LaneId>: DecodeWithMemTracking,

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

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