Enum pallet_bridge_grandpa::pallet::Call

pub enum Call<T: Config<I>, I: 'static = ()> {
    submit_finality_proof {
        finality_target: Box<BridgedHeader<T, I>>,
        justification: GrandpaJustification<BridgedHeader<T, I>>,
    },
    initialize {
        init_data: InitializationData<BridgedHeader<T, I>>,
    },
    set_owner {
        new_owner: Option<T::AccountId>,
    },
    set_operating_mode {
        operating_mode: BasicOperatingMode,
    },
    submit_finality_proof_ex {
        finality_target: Box<BridgedHeader<T, I>>,
        justification: GrandpaJustification<BridgedHeader<T, I>>,
        current_set_id: SetId,
        is_free_execution_expected: bool,
    },
    force_set_pallet_state {
        new_current_set_id: SetId,
        new_authorities: AuthorityList,
        new_best_header: Box<BridgedHeader<T, I>>,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

submit_finality_proof

This call is deprecated and will be removed around May 2024. Use the submit_finality_proof_ex instead. Semantically, this call is an equivalent of the submit_finality_proof_ex call without current authority set id check.

Fields

finality_target: Box<BridgedHeader<T, I>>

justification: GrandpaJustification<BridgedHeader<T, I>>

initialize

Bootstrap the bridge pallet with an initial header and authority set from which to sync.

The initial configuration provided does not need to be the genesis header of the bridged chain, it can be any arbitrary header. You can also provide the next scheduled set change if it is already know.

This function is only allowed to be called from a trusted origin and writes to storage with practically no checks in terms of the validity of the data. It is important that you ensure that valid data is being passed in.

Fields

init_data: InitializationData<BridgedHeader<T, I>>

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_finality_proof_ex

Verify a target header is finalized according to the given finality proof. The proof is assumed to be signed by GRANDPA authorities set with current_set_id id.

It will use the underlying storage pallet to fetch information about the current authorities and best finalized header in order to verify that the header is finalized.

If successful in verification, it will write the target header to the underlying storage pallet.

The call fails if:

• the pallet is halted;

• the pallet knows better header than the finality_target;

• the id of best GRANDPA authority set, known to the pallet is not equal to the current_set_id;

• verification is not optimized or invalid;

• header contains forced authorities set change or change with non-zero delay.

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

finality_target: Box<BridgedHeader<T, I>>

justification: GrandpaJustification<BridgedHeader<T, I>>

current_set_id: SetId

is_free_execution_expected: bool

force_set_pallet_state

Set current authorities set and best finalized bridged header to given values (almost) without any checks. This call can fail only if:

• the call origin is not a root or a pallet owner;

• there are too many authorities in the new set.

No other checks are made. Previously imported headers stay in the storage and are still accessible after the call.

Fields

new_current_set_id: SetId

new_authorities: AuthorityList

new_best_header: Box<BridgedHeader<T, I>>

Implementations

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

pub fn new_call_variant_submit_finality_proof( finality_target: Box<BridgedHeader<T, I>>, justification: GrandpaJustification<BridgedHeader<T, I>>, ) -> Self

Create a call with the variant submit_finality_proof.

pub fn new_call_variant_initialize( init_data: InitializationData<BridgedHeader<T, I>>, ) -> Self

Create a call with the variant initialize.

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_finality_proof_ex( finality_target: Box<BridgedHeader<T, I>>, justification: GrandpaJustification<BridgedHeader<T, I>>, current_set_id: SetId, is_free_execution_expected: bool, ) -> Self

Create a call with the variant submit_finality_proof_ex.

pub fn new_call_variant_force_set_pallet_state( new_current_set_id: SetId, new_authorities: AuthorityList, new_best_header: Box<BridgedHeader<T, I>>, ) -> Self

Create a call with the variant force_set_pallet_state.

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, Box<BridgedHeader<T, I>>: TypeInfo + 'static, GrandpaJustification<BridgedHeader<T, I>>: TypeInfo + 'static, InitializationData<BridgedHeader<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>