Enum pallet_parachain_staking::pallet::Call

pub enum Call<T: Config> {
    set_staking_expectations {
        expectations: Range<BalanceOf<T>>,
    },
    set_inflation {
        schedule: Range<Perbill>,
    },
    set_parachain_bond_account {
        new: T::AccountId,
    },
    set_parachain_bond_reserve_percent {
        new: Percent,
    },
    set_total_selected {
        new: u32,
    },
    set_collator_commission {
        new: Perbill,
    },
    set_blocks_per_round {
        new: u32,
    },
    join_candidates {
        bond: BalanceOf<T>,
        candidate_count: u32,
    },
    schedule_leave_candidates {
        candidate_count: u32,
    },
    execute_leave_candidates {
        candidate: T::AccountId,
        candidate_delegation_count: u32,
    },
    cancel_leave_candidates {
        candidate_count: u32,
    },
    go_offline {},
    go_online {},
    candidate_bond_more {
        more: BalanceOf<T>,
    },
    schedule_candidate_bond_less {
        less: BalanceOf<T>,
    },
    execute_candidate_bond_less {
        candidate: T::AccountId,
    },
    cancel_candidate_bond_less {},
    delegate {
        candidate: T::AccountId,
        amount: BalanceOf<T>,
        candidate_delegation_count: u32,
        delegation_count: u32,
    },
    delegate_with_auto_compound {
        candidate: T::AccountId,
        amount: BalanceOf<T>,
        auto_compound: Percent,
        candidate_delegation_count: u32,
        candidate_auto_compounding_delegation_count: u32,
        delegation_count: u32,
    },
    removed_call_19 {},
    removed_call_20 {},
    removed_call_21 {},
    schedule_revoke_delegation {
        collator: T::AccountId,
    },
    delegator_bond_more {
        candidate: T::AccountId,
        more: BalanceOf<T>,
    },
    schedule_delegator_bond_less {
        candidate: T::AccountId,
        less: BalanceOf<T>,
    },
    execute_delegation_request {
        delegator: T::AccountId,
        candidate: T::AccountId,
    },
    cancel_delegation_request {
        candidate: T::AccountId,
    },
    set_auto_compound {
        candidate: T::AccountId,
        value: Percent,
        candidate_auto_compounding_delegation_count_hint: u32,
        delegation_count_hint: u32,
    },
    hotfix_remove_delegation_requests_exited_candidates {
        candidates: Vec<T::AccountId>,
    },
    notify_inactive_collator {
        collator: T::AccountId,
    },
    enable_marking_offline {
        value: bool,
    },
    force_join_candidates {
        account: T::AccountId,
        bond: BalanceOf<T>,
        candidate_count: u32,
    },
    set_inflation_distribution_config {
        new: InflationDistributionConfig<T::AccountId>,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

set_staking_expectations

Fields

expectations: Range<BalanceOf<T>>

Set the expectations for total staked. These expectations determine the issuance for the round according to logic in fn compute_issuance

set_inflation

Fields

schedule: Range<Perbill>

Set the annual inflation rate to derive per-round inflation

set_parachain_bond_account

Fields

new: T::AccountId

Deprecated: please use set_inflation_distribution_config instead.

Set the account that will hold funds set aside for parachain bond

set_parachain_bond_reserve_percent

Fields

new: Percent

Deprecated: please use set_inflation_distribution_config instead.

Set the percent of inflation set aside for parachain bond

set_total_selected

Fields

new: u32

Set the total number of collator candidates selected per round

• changes are not applied until the start of the next round

set_collator_commission

Fields

new: Perbill

Set the commission for all collators

set_blocks_per_round

Fields

new: u32

Set blocks per round

• if called with new less than length of current round, will transition immediately in the next block
• also updates per-round inflation config

join_candidates

Fields

bond: BalanceOf<T>

candidate_count: u32

Join the set of collator candidates

schedule_leave_candidates

Fields

candidate_count: u32

Request to leave the set of candidates. If successful, the account is immediately removed from the candidate pool to prevent selection as a collator.

execute_leave_candidates

Fields

candidate: T::AccountId

candidate_delegation_count: u32

Execute leave candidates request

cancel_leave_candidates

Fields

candidate_count: u32

Cancel open request to leave candidates

• only callable by collator account
• result upon successful call is the candidate is active in the candidate pool

go_offline

Temporarily leave the set of collator candidates without unbonding

go_online

Rejoin the set of collator candidates if previously had called go_offline

candidate_bond_more

Fields

more: BalanceOf<T>

Increase collator candidate self bond by more

schedule_candidate_bond_less

Fields

less: BalanceOf<T>

Request by collator candidate to decrease self bond by less

execute_candidate_bond_less

Fields

candidate: T::AccountId

Execute pending request to adjust the collator candidate self bond

cancel_candidate_bond_less

Cancel pending request to adjust the collator candidate self bond

delegate

Fields

candidate: T::AccountId

amount: BalanceOf<T>

candidate_delegation_count: u32

delegation_count: u32

DEPRECATED use delegateWithAutoCompound If caller is not a delegator and not a collator, then join the set of delegators If caller is a delegator, then makes delegation to change their delegation state

delegate_with_auto_compound

Fields

candidate: T::AccountId

amount: BalanceOf<T>

auto_compound: Percent

candidate_delegation_count: u32

candidate_auto_compounding_delegation_count: u32

delegation_count: u32

If caller is not a delegator and not a collator, then join the set of delegators If caller is a delegator, then makes delegation to change their delegation state Sets the auto-compound config for the delegation

removed_call_19

REMOVED, was schedule_leave_delegators

removed_call_20

REMOVED, was execute_leave_delegators

removed_call_21

REMOVED, was cancel_leave_delegators

schedule_revoke_delegation

Fields

collator: T::AccountId

Request to revoke an existing delegation. If successful, the delegation is scheduled to be allowed to be revoked via the execute_delegation_request extrinsic. The delegation receives no rewards for the rounds while a revoke is pending. A revoke may not be performed if any other scheduled request is pending.

delegator_bond_more

Fields

candidate: T::AccountId

more: BalanceOf<T>

Bond more for delegators wrt a specific collator candidate.

schedule_delegator_bond_less

Fields

candidate: T::AccountId

less: BalanceOf<T>

Request bond less for delegators wrt a specific collator candidate. The delegation’s rewards for rounds while the request is pending use the reduced bonded amount. A bond less may not be performed if any other scheduled request is pending.

execute_delegation_request

Fields

delegator: T::AccountId

candidate: T::AccountId

Execute pending request to change an existing delegation

cancel_delegation_request

Fields

candidate: T::AccountId

Cancel request to change an existing delegation.

set_auto_compound

Fields

candidate: T::AccountId

value: Percent

candidate_auto_compounding_delegation_count_hint: u32

delegation_count_hint: u32

Sets the auto-compounding reward percentage for a delegation.

hotfix_remove_delegation_requests_exited_candidates

Fields

candidates: Vec<T::AccountId>

Hotfix to remove existing empty entries for candidates that have left.

notify_inactive_collator

Fields

collator: T::AccountId

Notify a collator is inactive during MaxOfflineRounds

enable_marking_offline

Fields

value: bool

Enable/Disable marking offline feature

force_join_candidates

Fields

account: T::AccountId

bond: BalanceOf<T>

candidate_count: u32

Force join the set of collator candidates. It will skip the minimum required bond check.

set_inflation_distribution_config

Fields

new: InflationDistributionConfig<T::AccountId>

Set the inflation distribution configuration.

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_set_staking_expectations( expectations: Range<BalanceOf<T>> ) -> Self

Create a call with the variant set_staking_expectations.

pub fn new_call_variant_set_inflation(schedule: Range<Perbill>) -> Self

Create a call with the variant set_inflation.

pub fn new_call_variant_set_parachain_bond_account(new: T::AccountId) -> Self

Create a call with the variant set_parachain_bond_account.

pub fn new_call_variant_set_parachain_bond_reserve_percent(new: Percent) -> Self

Create a call with the variant set_parachain_bond_reserve_percent.

pub fn new_call_variant_set_total_selected(new: u32) -> Self

Create a call with the variant set_total_selected.

pub fn new_call_variant_set_collator_commission(new: Perbill) -> Self

Create a call with the variant set_collator_commission.

pub fn new_call_variant_set_blocks_per_round(new: u32) -> Self

Create a call with the variant set_blocks_per_round.

pub fn new_call_variant_join_candidates( bond: BalanceOf<T>, candidate_count: u32 ) -> Self

Create a call with the variant join_candidates.

pub fn new_call_variant_schedule_leave_candidates(candidate_count: u32) -> Self

Create a call with the variant schedule_leave_candidates.

pub fn new_call_variant_execute_leave_candidates( candidate: T::AccountId, candidate_delegation_count: u32 ) -> Self

Create a call with the variant execute_leave_candidates.

pub fn new_call_variant_cancel_leave_candidates(candidate_count: u32) -> Self

Create a call with the variant cancel_leave_candidates.

pub fn new_call_variant_go_offline() -> Self

Create a call with the variant go_offline.

pub fn new_call_variant_go_online() -> Self

Create a call with the variant go_online.

pub fn new_call_variant_candidate_bond_more(more: BalanceOf<T>) -> Self

Create a call with the variant candidate_bond_more.

pub fn new_call_variant_schedule_candidate_bond_less(less: BalanceOf<T>) -> Self

Create a call with the variant schedule_candidate_bond_less.

pub fn new_call_variant_execute_candidate_bond_less( candidate: T::AccountId ) -> Self

Create a call with the variant execute_candidate_bond_less.

pub fn new_call_variant_cancel_candidate_bond_less() -> Self

Create a call with the variant cancel_candidate_bond_less.

pub fn new_call_variant_delegate( candidate: T::AccountId, amount: BalanceOf<T>, candidate_delegation_count: u32, delegation_count: u32 ) -> Self

Create a call with the variant delegate.

pub fn new_call_variant_delegate_with_auto_compound( candidate: T::AccountId, amount: BalanceOf<T>, auto_compound: Percent, candidate_delegation_count: u32, candidate_auto_compounding_delegation_count: u32, delegation_count: u32 ) -> Self

Create a call with the variant delegate_with_auto_compound.

pub fn new_call_variant_removed_call_19() -> Self

Create a call with the variant removed_call_19.

pub fn new_call_variant_removed_call_20() -> Self

Create a call with the variant removed_call_20.

pub fn new_call_variant_removed_call_21() -> Self

Create a call with the variant removed_call_21.

pub fn new_call_variant_schedule_revoke_delegation( collator: T::AccountId ) -> Self

Create a call with the variant schedule_revoke_delegation.

pub fn new_call_variant_delegator_bond_more( candidate: T::AccountId, more: BalanceOf<T> ) -> Self

Create a call with the variant delegator_bond_more.

pub fn new_call_variant_schedule_delegator_bond_less( candidate: T::AccountId, less: BalanceOf<T> ) -> Self

Create a call with the variant schedule_delegator_bond_less.

pub fn new_call_variant_execute_delegation_request( delegator: T::AccountId, candidate: T::AccountId ) -> Self

Create a call with the variant execute_delegation_request.

pub fn new_call_variant_cancel_delegation_request( candidate: T::AccountId ) -> Self

Create a call with the variant cancel_delegation_request.

pub fn new_call_variant_set_auto_compound( candidate: T::AccountId, value: Percent, candidate_auto_compounding_delegation_count_hint: u32, delegation_count_hint: u32 ) -> Self

Create a call with the variant set_auto_compound.

pub fn new_call_variant_hotfix_remove_delegation_requests_exited_candidates( candidates: Vec<T::AccountId> ) -> Self

Create a call with the variant hotfix_remove_delegation_requests_exited_candidates.

pub fn new_call_variant_notify_inactive_collator(collator: T::AccountId) -> Self

Create a call with the variant notify_inactive_collator.

pub fn new_call_variant_enable_marking_offline(value: bool) -> Self

Create a call with the variant enable_marking_offline.

pub fn new_call_variant_force_join_candidates( account: T::AccountId, bond: BalanceOf<T>, candidate_count: u32 ) -> Self

Create a call with the variant force_join_candidates.

pub fn new_call_variant_set_inflation_distribution_config( new: InflationDistributionConfig<T::AccountId> ) -> Self

Create a call with the variant set_inflation_distribution_config.

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, Range<BalanceOf<T>>: TypeInfo + 'static, T::AccountId: TypeInfo + 'static, BalanceOf<T>: TypeInfo + 'static, Vec<T::AccountId>: TypeInfo + 'static, InflationDistributionConfig<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>