Enum pallet_state_trie_migration::pallet::Call

pub enum Call<T: Config> {
    control_auto_migration {
        maybe_config: Option<MigrationLimits>,
    },
    continue_migrate {
        limits: MigrationLimits,
        real_size_upper: u32,
        witness_task: MigrationTask<T>,
    },
    migrate_custom_top {
        keys: Vec<Vec<u8>>,
        witness_size: u32,
    },
    migrate_custom_child {
        root: Vec<u8>,
        child_keys: Vec<Vec<u8>>,
        total_size: u32,
    },
    set_signed_max_limits {
        limits: MigrationLimits,
    },
    force_set_progress {
        progress_top: ProgressOf<T>,
        progress_child: ProgressOf<T>,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

control_auto_migration

Control the automatic migration.

The dispatch origin of this call must be Config::ControlOrigin.

Fields

maybe_config: Option<MigrationLimits>

continue_migrate

Continue the migration for the given limits.

The dispatch origin of this call can be any signed account.

This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit, Upon successful execution, the transaction fee is returned.

The (potentially over-estimated) of the byte length of all the data read must be provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing that executing the current MigrationTask with the given limits will not exceed real_size_upper bytes of read data.

The witness_task is merely a helper to prevent the caller from being slashed or generally trigger a migration that they do not intend. This parameter is just a message from caller, saying that they believed witness_task was the last state of the migration, and they only wish for their transaction to do anything, if this assumption holds. In case witness_task does not match, the transaction fails.

Based on the documentation of MigrationTask::migrate_until_exhaustion, the recommended way of doing this is to pass a limit that only bounds count, as the size limit can always be overwritten.

Fields

limits: MigrationLimits

real_size_upper: u32

witness_task: MigrationTask<T>

migrate_custom_top

Migrate the list of top keys by iterating each of them one by one.

This does not affect the global migration process tracker (MigrationProcess), and should only be used in case any keys are leftover due to a bug.

Fields

keys: Vec<Vec<u8>>

witness_size: u32

migrate_custom_child

Migrate the list of child keys by iterating each of them one by one.

All of the given child keys must be present under one child_root.

This does not affect the global migration process tracker (MigrationProcess), and should only be used in case any keys are leftover due to a bug.

Fields

root: Vec<u8>

child_keys: Vec<Vec<u8>>

total_size: u32

set_signed_max_limits

Set the maximum limit of the signed migration.

Fields

limits: MigrationLimits

force_set_progress

Forcefully set the progress the running migration.

This is only useful in one case: the next key to migrate is too big to be migrated with a signed account, in a parachain context, and we simply want to skip it. A reasonable example of this would be :code:, which is both very expensive to migrate, and commonly used, so probably it is already migrated.

In case you mess things up, you can also, in principle, use this to reset the migration process.

Fields

progress_top: ProgressOf<T>

progress_child: ProgressOf<T>

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_control_auto_migration( maybe_config: Option<MigrationLimits>, ) -> Self

Create a call with the variant control_auto_migration.

pub fn new_call_variant_continue_migrate( limits: MigrationLimits, real_size_upper: u32, witness_task: MigrationTask<T>, ) -> Self

Create a call with the variant continue_migrate.

pub fn new_call_variant_migrate_custom_top( keys: Vec<Vec<u8>>, witness_size: u32, ) -> Self

Create a call with the variant migrate_custom_top.

pub fn new_call_variant_migrate_custom_child( root: Vec<u8>, child_keys: Vec<Vec<u8>>, total_size: u32, ) -> Self

Create a call with the variant migrate_custom_child.

pub fn new_call_variant_set_signed_max_limits(limits: MigrationLimits) -> Self

Create a call with the variant set_signed_max_limits.

pub fn new_call_variant_force_set_progress( progress_top: ProgressOf<T>, progress_child: ProgressOf<T>, ) -> Self

Create a call with the variant force_set_progress.

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, MigrationTask<T>: TypeInfo + 'static, ProgressOf<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>