Enum pallet_collator_selection::pallet::Call

pub enum Call<T: Config> {
    set_invulnerables {
        new: Vec<T::AccountId>,
    },
    set_desired_candidates {
        max: u32,
    },
    set_candidacy_bond {
        bond: <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance,
    },
    register_as_candidate {},
    leave_intent {},
    add_invulnerable {
        who: T::AccountId,
    },
    remove_invulnerable {
        who: T::AccountId,
    },
    update_bond {
        new_deposit: <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance,
    },
    take_candidate_slot {
        deposit: <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance,
        target: T::AccountId,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

set_invulnerables

Fields

new: Vec<T::AccountId>

Set the list of invulnerable (fixed) collators. These collators must do some preparation, namely to have registered session keys.

The call will remove any accounts that have not registered keys from the set. That is, it is non-atomic; the caller accepts all AccountIds passed in new individually as acceptable Invulnerables, and is not proposing a set of new Invulnerables.

This call does not maintain mutual exclusivity of Invulnerables and Candidates. It is recommended to use a batch of add_invulnerable and remove_invulnerable instead. A batch_all can also be used to enforce atomicity. If any candidates are included in new, they should be removed with remove_invulnerable_candidate after execution.

Must be called by the UpdateOrigin.

set_desired_candidates

Fields

max: u32

Set the ideal number of non-invulnerable collators. If lowering this number, then the number of running collators could be higher than this figure. Aside from that edge case, there should be no other way to have more candidates than the desired number.

The origin for this call must be the UpdateOrigin.

set_candidacy_bond

Fields

bond: <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance

Set the candidacy bond amount.

If the candidacy bond is increased by this call, all current candidates which have a deposit lower than the new bond will be kicked from the list and get their deposits back.

The origin for this call must be the UpdateOrigin.

register_as_candidate

Register this account as a collator candidate. The account must (a) already have registered session keys and (b) be able to reserve the CandidacyBond.

This call is not available to Invulnerable collators.

leave_intent

Deregister origin as a collator candidate. Note that the collator can only leave on session change. The CandidacyBond will be unreserved immediately.

This call will fail if the total number of candidates would drop below MinEligibleCollators.

add_invulnerable

Fields

who: T::AccountId

Add a new account who to the list of Invulnerables collators. who must have registered session keys. If who is a candidate, they will be removed.

The origin for this call must be the UpdateOrigin.

remove_invulnerable

Fields

who: T::AccountId

Remove an account who from the list of Invulnerables collators. Invulnerables must be sorted.

The origin for this call must be the UpdateOrigin.

update_bond

Fields

new_deposit: <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance

Update the candidacy bond of collator candidate origin to a new amount new_deposit.

Setting a new_deposit that is lower than the current deposit while origin is occupying a top-DesiredCandidates slot is not allowed.

This call will fail if origin is not a collator candidate, the updated bond is lower than the minimum candidacy bond, and/or the amount cannot be reserved.

take_candidate_slot

Fields

deposit: <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance

target: T::AccountId

The caller origin replaces a candidate target in the collator candidate list by reserving deposit. The amount deposit reserved by the caller must be greater than the existing bond of the target it is trying to replace.

This call will fail if the caller is already a collator candidate or invulnerable, the caller does not have registered session keys, the target is not a collator candidate, and/or the deposit amount cannot be reserved.

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_set_invulnerables(new: Vec<T::AccountId>) -> Self

Create a call with the variant set_invulnerables.

pub fn new_call_variant_set_desired_candidates(max: u32) -> Self

Create a call with the variant set_desired_candidates.

pub fn new_call_variant_set_candidacy_bond( bond: <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance ) -> Self

Create a call with the variant set_candidacy_bond.

pub fn new_call_variant_register_as_candidate() -> Self

Create a call with the variant register_as_candidate.

pub fn new_call_variant_leave_intent() -> Self

Create a call with the variant leave_intent.

pub fn new_call_variant_add_invulnerable(who: T::AccountId) -> Self

Create a call with the variant add_invulnerable.

pub fn new_call_variant_remove_invulnerable(who: T::AccountId) -> Self

Create a call with the variant remove_invulnerable.

pub fn new_call_variant_update_bond( new_deposit: <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance ) -> Self

Create a call with the variant update_bond.

pub fn new_call_variant_take_candidate_slot( deposit: <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance, target: T::AccountId ) -> Self

Create a call with the variant take_candidate_slot.

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, Vec<T::AccountId>: TypeInfo + 'static, <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance: TypeInfo + 'static, T::AccountId: 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>