Trait pallet_fast_unstake::StakingInterface

source ·

pub trait StakingInterface {
    type Balance: Sub<Self::Balance, Output = Self::Balance> + Ord + PartialEq<Self::Balance> + Default + Copy + MaxEncodedLen + FullCodec + TypeInfo + Saturating;
    type AccountId: Clone + Debug;
    type CurrencyToVote: CurrencyToVote<Self::Balance>;

Show 25 methods    // Required methods
    fn minimum_nominator_bond() -> Self::Balance;
    fn minimum_validator_bond() -> Self::Balance;
    fn stash_by_ctrl(
        controller: &Self::AccountId
    ) -> Result<Self::AccountId, DispatchError>;
    fn bonding_duration() -> u32;
    fn current_era() -> u32;
    fn stake(
        who: &Self::AccountId
    ) -> Result<Stake<Self::Balance>, DispatchError>;
    fn bond(
        who: &Self::AccountId,
        value: Self::Balance,
        payee: &Self::AccountId
    ) -> Result<(), DispatchError>;
    fn nominate(
        who: &Self::AccountId,
        validators: Vec<Self::AccountId, Global>
    ) -> Result<(), DispatchError>;
    fn chill(who: &Self::AccountId) -> Result<(), DispatchError>;
    fn bond_extra(
        who: &Self::AccountId,
        extra: Self::Balance
    ) -> Result<(), DispatchError>;
    fn unbond(
        stash: &Self::AccountId,
        value: Self::Balance
    ) -> Result<(), DispatchError>;
    fn withdraw_unbonded(
        stash: Self::AccountId,
        num_slashing_spans: u32
    ) -> Result<bool, DispatchError>;
    fn desired_validator_count() -> u32;
    fn election_ongoing() -> bool;
    fn force_unstake(who: Self::AccountId) -> Result<(), DispatchError>;
    fn is_exposed_in_era(who: &Self::AccountId, era: &u32) -> bool;
    fn status(
        who: &Self::AccountId
    ) -> Result<StakerStatus<Self::AccountId>, DispatchError>;
    fn add_era_stakers(
        current_era: &u32,
        stash: &Self::AccountId,
        exposures: Vec<(Self::AccountId, Self::Balance), Global>
    );
    fn set_current_era(era: u32);

    // Provided methods
    fn total_stake(
        who: &Self::AccountId
    ) -> Result<Self::Balance, DispatchError> { ... }
    fn active_stake(
        who: &Self::AccountId
    ) -> Result<Self::Balance, DispatchError> { ... }
    fn is_unbonding(who: &Self::AccountId) -> Result<bool, DispatchError> { ... }
    fn fully_unbond(who: &Self::AccountId) -> Result<(), DispatchError> { ... }
    fn is_validator(who: &Self::AccountId) -> bool { ... }
    fn nominations(
        who: &Self::AccountId
    ) -> Option<Vec<Self::AccountId, Global>> { ... }
}

Expand description

A generic representation of a staking implementation.

This interface uses the terminology of NPoS, but it is aims to be generic enough to cover other implementations as well.

Required Associated Types§

source

type Balance: Sub<Self::Balance, Output = Self::Balance> + Ord + PartialEq<Self::Balance> + Default + Copy + MaxEncodedLen + FullCodec + TypeInfo + Saturating

Balance type used by the staking system.

source

type AccountId: Clone + Debug

AccountId type used by the staking system.

source

type CurrencyToVote: CurrencyToVote<Self::Balance>

Means of converting Currency to VoteWeight.

Required Methods§

source

fn minimum_nominator_bond() -> Self::Balance

The minimum amount required to bond in order to set nomination intentions. This does not necessarily mean the nomination will be counted in an election, but instead just enough to be stored as a nominator. In other words, this is the minimum amount to register the intention to nominate.

source

fn minimum_validator_bond() -> Self::Balance

The minimum amount required to bond in order to set validation intentions.

source

fn stash_by_ctrl( controller: &Self::AccountId ) -> Result<Self::AccountId, DispatchError>

Return a stash account that is controlled by a controller.

Note

The controller abstraction is not permanent and might go away. Avoid using this as much as possible.

source

fn bonding_duration() -> u32

Number of eras that staked funds must remain bonded for.

source

fn current_era() -> u32

The current era index.

This should be the latest planned era that the staking system knows about.

source

fn stake(who: &Self::AccountId) -> Result<Stake<Self::Balance>, DispatchError>

Returns the Stake of who.

source

fn bond( who: &Self::AccountId, value: Self::Balance, payee: &Self::AccountId ) -> Result<(), DispatchError>

Bond (lock) value of who’s balance, while forwarding any rewards to payee.

source

fn nominate( who: &Self::AccountId, validators: Vec<Self::AccountId, Global> ) -> Result<(), DispatchError>

Have who nominate validators.

source

fn chill(who: &Self::AccountId) -> Result<(), DispatchError>

Chill who.

source

fn bond_extra( who: &Self::AccountId, extra: Self::Balance ) -> Result<(), DispatchError>

Bond some extra amount in who’s free balance against the active bonded balance of the account. The amount extra actually bonded will never be more than who’s free balance.

source

fn unbond( stash: &Self::AccountId, value: Self::Balance ) -> Result<(), DispatchError>

Schedule a portion of the active bonded balance to be unlocked at era Self::current_era + Self::bonding_duration.

Once the unlock era has been reached, Self::withdraw_unbonded can be called to unlock the funds.

The amount of times this can be successfully called is limited based on how many distinct eras funds are schedule to unlock in. Calling Self::withdraw_unbonded after some unlock schedules have reached their unlocking era should allow more calls to this function.

source