Enum Call

pub enum Call<T: Config> {
    build_ring_manual {
        ring_index: RingIndex,
        limit: Option<u32>,
    },
    onboard_people_manual {},
    merge_rings {
        base_ring_index: RingIndex,
        target_ring_index: RingIndex,
    },
    under_alias {
        call: Box<<T as Config>::RuntimeCall>,
    },
    set_alias_account {
        account: T::AccountId,
        call_valid_at: BlockNumberFor<T>,
    },
    unset_alias_account {},
    force_recognize_personhood {
        people: Vec<MemberOf<T>>,
    },
    set_personal_id_account {
        account: T::AccountId,
        call_valid_at: BlockNumberFor<T>,
    },
    unset_personal_id_account {},
    migrate_included_key {
        new_key: MemberOf<T>,
    },
    migrate_onboarding_key {
        new_key: MemberOf<T>,
    },
    set_onboarding_size {
        onboarding_size: u32,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

build_ring_manual

Build a ring root by including registered people.

This task is performed automatically by the pallet through the on_idle hook whenever there is leftover weight in a block. This call is meant to be a backup in case of extreme congestion and should be submitted by signed origins.

Fields

ring_index: RingIndex

limit: Option<u32>

onboard_people_manual

Onboard people into a ring by taking their keys from the onboarding queue and registering them into the ring. This does not compute the root, that is done using build_ring.

This task is performed automatically by the pallet through the on_idle hook whenever there is leftover weight in a block. This call is meant to be a backup in case of extreme congestion and should be submitted by signed origins.

merge_rings

Merge the people in two rings into a single, new ring. In order for the rings to be eligible for merging, they must be below 1/2 of max capacity, have no pending suspensions and not be the top ring used for onboarding.

Fields

base_ring_index: RingIndex

target_ring_index: RingIndex

under_alias

Dispatch a call under an alias using the account <-> alias mapping.

This is a call version of the transaction extension AsPersonalAliasWithAccount. It is recommended to use the transaction extension instead when suitable.

Fields

call: Box<<T as Config>::RuntimeCall>

set_alias_account

This transaction is refunded if successful and no alias was previously set.

The call is valid from call_valid_at until call_valid_at + account_setup_time_tolerance. account_setup_time_tolerance is a constant available in the metadata.

Parameters:

• account: The account to set the alias for.
• call_valid_at: The block number when the call becomes valid.

Fields

account: T::AccountId

call_valid_at: BlockNumberFor<T>

unset_alias_account

Remove the mapping from a particular alias to its registered account.

force_recognize_personhood

Recognize a set of people without any additional checks.

The people are identified by the provided list of keys and will each be assigned, in order, the next available personal ID.

The origin for this call must have root privileges.

Fields

people: Vec<MemberOf<T>>

set_personal_id_account

Set a personal id account.

The account can then be used to sign transactions on behalf of the personal id, and provide replay protection with the nonce.

This transaction is refunded if successful and no account was previously set for the personal id.

The call is valid from call_valid_at until call_valid_at + account_setup_time_tolerance. account_setup_time_tolerance is a constant available in the metadata.

Parameters:

• account: The account to set the alias for.
• call_valid_at: The block number when the call becomes valid.

Fields

account: T::AccountId

call_valid_at: BlockNumberFor<T>

unset_personal_id_account

Unset the personal id account.

migrate_included_key

Migrate the key for a person who was onboarded and is currently included in a ring. The migration is not instant as the key replacement and subsequent inclusion in a new ring root will happen only after the next mutation session.

Fields

new_key: MemberOf<T>

migrate_onboarding_key

Migrate the key for a person who is currently onboarding. The operation is instant, replacing the old key in the onboarding queue.

Fields

new_key: MemberOf<T>

set_onboarding_size

Force set the onboarding size for new people. This call requires root privileges.

Fields

onboarding_size: u32

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_build_ring_manual( ring_index: RingIndex, limit: Option<u32>, ) -> Self

Create a call with the variant build_ring_manual.

pub fn new_call_variant_onboard_people_manual() -> Self

Create a call with the variant onboard_people_manual.

pub fn new_call_variant_merge_rings( base_ring_index: RingIndex, target_ring_index: RingIndex, ) -> Self

Create a call with the variant merge_rings.

pub fn new_call_variant_under_alias( call: Box<<T as Config>::RuntimeCall>, ) -> Self

Create a call with the variant under_alias.

pub fn new_call_variant_set_alias_account( account: T::AccountId, call_valid_at: BlockNumberFor<T>, ) -> Self

Create a call with the variant set_alias_account.

pub fn new_call_variant_unset_alias_account() -> Self

Create a call with the variant unset_alias_account.

pub fn new_call_variant_force_recognize_personhood( people: Vec<MemberOf<T>>, ) -> Self

Create a call with the variant force_recognize_personhood.

pub fn new_call_variant_set_personal_id_account( account: T::AccountId, call_valid_at: BlockNumberFor<T>, ) -> Self

Create a call with the variant set_personal_id_account.

pub fn new_call_variant_unset_personal_id_account() -> Self

Create a call with the variant unset_personal_id_account.

pub fn new_call_variant_migrate_included_key(new_key: MemberOf<T>) -> Self

Create a call with the variant migrate_included_key.

pub fn new_call_variant_migrate_onboarding_key(new_key: MemberOf<T>) -> Self

Create a call with the variant migrate_onboarding_key.

pub fn new_call_variant_set_onboarding_size(onboarding_size: u32) -> Self

Create a call with the variant set_onboarding_size.

Trait Implementations

impl<T: Config> Authorize for Call<T>

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

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

where PhantomData<(T,)>: TypeInfo + 'static, Box<<T as Config>::RuntimeCall>: TypeInfo + 'static, T::AccountId: TypeInfo + 'static, BlockNumberFor<T>: TypeInfo + 'static, Vec<MemberOf<T>>: TypeInfo + 'static, MemberOf<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> DecodeWithMemTracking for Call<T>

where Box<<T as Config>::RuntimeCall>: DecodeWithMemTracking, T::AccountId: DecodeWithMemTracking, BlockNumberFor<T>: DecodeWithMemTracking, Vec<MemberOf<T>>: DecodeWithMemTracking, MemberOf<T>: DecodeWithMemTracking,

impl<T: Config> EncodeLike for Call<T>

impl<T: Config> Eq for Call<T>