Struct pallet_nomination_pools::pallet::Pallet

pub struct Pallet<T>(_);

The pallet implementing the on-chain logic.

Implementations

impl<T: Config> Pallet<T>

pub fn join(
    origin: OriginFor<T>,
    amount: BalanceOf<T>,
    pool_id: PoolId
) -> DispatchResult

Stake funds with a pool. The amount to bond is transferred from the member to the pools account and immediately increases the pools bond.

Note

• An account can only be a member of a single pool.
• An account cannot join the same pool multiple times.
• This call will not dust the member account, so the member must have at least existential deposit + amount in their account.
• Only a pool with PoolState::Open can be joined

pub fn bond_extra(
    origin: OriginFor<T>,
    extra: BondExtra<BalanceOf<T>>
) -> DispatchResult

Bond extra more funds from origin into the pool to which they already belong.

Additional funds can come from either the free balance of the account, of from the accumulated rewards, see BondExtra.

Bonding extra funds implies an automatic payout of all pending rewards as well.

pub fn claim_payout(origin: OriginFor<T>) -> DispatchResult

A bonded member can use this to claim their payout based on the rewards that the pool has accumulated since their last claimed payout (OR since joining if this is there first time claiming rewards). The payout will be transferred to the member’s account.

The member will earn rewards pro rata based on the members stake vs the sum of the members in the pools stake. Rewards do not “expire”.

pub fn unbond(
    origin: OriginFor<T>,
    member_account: <<T as Config>::Lookup as StaticLookup>::Source,
    unbonding_points: BalanceOf<T>
) -> DispatchResult

Unbond up to unbonding_points of the member_account’s funds from the pool. It implicitly collects the rewards one last time, since not doing so would mean some rewards would be forfeited.

Under certain conditions, this call can be dispatched permissionlessly (i.e. by any account).

Conditions for a permissionless dispatch.

• The pool is blocked and the caller is either the root or state-toggler. This is refereed to as a kick.
• The pool is destroying and the member is not the depositor.
• The pool is destroying, the member is the depositor and no other members are in the pool.

Conditions for permissioned dispatch (i.e. the caller is also the

member_account):

• The caller is not the depositor.
• The caller is the depositor, the pool is destroying and no other members are in the pool.

Note

If there are too many unlocking chunks to unbond with the pool account, Call::pool_withdraw_unbonded can be called to try and minimize unlocking chunks. If there are too many unlocking chunks, the result of this call will likely be the NoMoreChunks error from the staking system.

pub fn pool_withdraw_unbonded(
    origin: OriginFor<T>,
    pool_id: PoolId,
    num_slashing_spans: u32
) -> DispatchResult

Call withdraw_unbonded for the pools account. This call can be made by any account.

This is useful if their are too many unlocking chunks to call unbond, and some can be cleared by withdrawing. In the case there are too many unlocking chunks, the user would probably see an error like NoMoreChunks emitted from the staking system when they attempt to unbond.

pub fn withdraw_unbonded(
    origin: OriginFor<T>,
    member_account: <<T as Config>::Lookup as StaticLookup>::Source,
    num_slashing_spans: u32
) -> DispatchResultWithPostInfo

Withdraw unbonded funds from member_account. If no bonded funds can be unbonded, an error is returned.

Under certain conditions, this call can be dispatched permissionlessly (i.e. by any account).

Conditions for a permissionless dispatch

• The pool is in destroy mode and the target is not the depositor.
• The target is the depositor and they are the only member in the sub pools.
• The pool is blocked and the caller is either the root or state-toggler.

Conditions for permissioned dispatch

• The caller is the target and they are not the depositor.

Note

If the target is the depositor, the pool will be destroyed.

pub fn create(
    origin: OriginFor<T>,
    amount: BalanceOf<T>,
    root: <<T as Config>::Lookup as StaticLookup>::Source,
    nominator: <<T as Config>::Lookup as StaticLookup>::Source,
    state_toggler: <<T as Config>::Lookup as StaticLookup>::Source
) -> DispatchResult

Create a new delegation pool.

Arguments

• amount - The amount of funds to delegate to the pool. This also acts of a sort of deposit since the pools creator cannot fully unbond funds until the pool is being destroyed.
• index - A disambiguation index for creating the account. Likely only useful when creating multiple pools in the same extrinsic.
• root - The account to set as PoolRoles::root.
• nominator - The account to set as the PoolRoles::nominator.
• state_toggler - The account to set as the PoolRoles::state_toggler.

Note

In addition to amount, the caller will transfer the existential deposit; so the caller needs at have at least amount + existential_deposit transferrable.

pub fn nominate(
    origin: OriginFor<T>,
    pool_id: PoolId,
    validators: Vec<T::AccountId>
) -> DispatchResult

Nominate on behalf of the pool.

The dispatch origin of this call must be signed by the pool nominator or the pool root role.

This directly forward the call to the staking pallet, on behalf of the pool bonded account.

pub fn set_state(
    origin: OriginFor<T>,
    pool_id: PoolId,
    state: PoolState
) -> DispatchResult

Set a new state for the pool.

If a pool is already in the Destroying state, then under no condition can its state change again.

The dispatch origin of this call must be either:

1. signed by the state toggler, or the root role of the pool,
2. if the pool conditions to be open are NOT met (as described by ok_to_be_open), and then the state of the pool can be permissionlessly changed to Destroying.

pub fn set_metadata(
    origin: OriginFor<T>,
    pool_id: PoolId,
    metadata: Vec<u8>
) -> DispatchResult

Set a new metadata for the pool.

The dispatch origin of this call must be signed by the state toggler, or the root role of the pool.

pub fn set_configs(
    origin: OriginFor<T>,
    min_join_bond: ConfigOp<BalanceOf<T>>,
    min_create_bond: ConfigOp<BalanceOf<T>>,
    max_pools: ConfigOp<u32>,
    max_members: ConfigOp<u32>,
    max_members_per_pool: ConfigOp<u32>
) -> DispatchResult

Update configurations for the nomination pools. The origin for this call must be Root.

Arguments

• min_join_bond - Set MinJoinBond.
• min_create_bond - Set MinCreateBond.
• max_pools - Set MaxPools.
• max_members - Set MaxPoolMembers.
• max_members_per_pool - Set MaxPoolMembersPerPool.

pub fn update_roles(
    origin: OriginFor<T>,
    pool_id: PoolId,
    new_root: ConfigOp<T::AccountId>,
    new_nominator: ConfigOp<T::AccountId>,
    new_state_toggler: ConfigOp<T::AccountId>
) -> DispatchResult

Update the roles of the pool.

The root is the only entity that can change any of the roles, including itself, excluding the depositor, who can never change.

It emits an event, notifying UIs of the role change. This event is quite relevant to most pool members and they should be informed of changes to pool roles.

pub fn chill(origin: OriginFor<T>, pool_id: PoolId) -> DispatchResult

Chill on behalf of the pool.

The dispatch origin of this call must be signed by the pool nominator or the pool root role, same as Pallet::nominate.

This directly forward the call to the staking pallet, on behalf of the pool bonded account.

impl<T: Config> Pallet<T>

pub fn pending_rewards(member_account: T::AccountId) -> Option<BalanceOf<T>>

Returns the pending rewards for the specified member_account.

In the case of error, None is returned.

pub fn dissolve_pool(bonded_pool: BondedPool<T>)

Remove everything related to the given bonded pool.

Metadata and all of the sub-pools are also deleted. All accounts are dusted and the leftover of the reward account is returned to the depositor.

pub fn create_bonded_account(id: PoolId) -> T::AccountId

Create the main, bonded account of a pool with the given id.

pub fn create_reward_account(id: PoolId) -> T::AccountId

Create the reward account of a pool with the given id.

pub fn do_try_state(level: u8) -> Result<(), &'static str>

Ensure the correctness of the state of this pallet.

This should be valid before or after each state transition of this pallet.

Invariants:

First, let’s consider pools:

• BondedPools and RewardPools must all have the EXACT SAME key-set.
• SubPoolsStorage must be a subset of the above superset.
• Metadata keys must be a subset of the above superset.
• the count of the above set must be less than MaxPools.

Then, considering members as well:

• each BondedPool.member_counter must be:
  • correct (compared to actual count of member who have .pool_id this pool)
  • less than MaxPoolMembersPerPool.
• each member.pool_id must correspond to an existing BondedPool.id (which implies the existence of the reward pool as well).
• count of all members must be less than MaxPoolMembers.

Then, considering unbonding members:

for each pool:

• sum of the balance that’s tracked in all unbonding pools must be the same as the unbonded balance of the main account, as reported by the staking interface.
• sum of the balance that’s tracked in all unbonding pools, plus the bonded balance of the main account should be less than or qual to the total balance of the main account.

Sanity check level

To cater for tests that want to escape parts of these checks, this function is split into multiple levels, where the higher the level, the more checks we performs. So, try_state(255) is the strongest sanity check, and 0 performs no checks.

pub fn fully_unbond(origin: OriginFor<T>, member: T::AccountId) -> DispatchResult

Fully unbond the shares of member, when executed from origin.

This is useful for backwards compatibility with the majority of tests that only deal with full unbonding, not partial unbonding.

Trait Implementations

impl<T: Config> Callable<T> for Pallet<T>

type Call = Call<T>

impl<T> Clone for Pallet<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> Debug for Pallet<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Config> GetStorageVersion for Pallet<T>

fn current_storage_version() -> StorageVersion

Returns the current storage version as supported by the pallet.

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.

impl<T: Config> Hooks<<T as Config>::BlockNumber> for Pallet<T>

fn integrity_test()

Run integrity test.

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

This will be run when the block is being finalized (before on_finalize). Implement to have something happen using the remaining weight. Will not fire if the remaining weight is 0. Return the weight used, the hook will subtract it from current weight used and pass the result to the next on_idle hook if it exists.

fn on_initialize(_n: BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn try_state(_n: BlockNumber) -> Result<(), &'static str>

Execute the sanity checks of this pallet, per block.

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime upgrade.

fn offchain_worker(_n: BlockNumber)

Implementing this function on a module allows you to perform long-running tasks that make (by default) validators generate transactions that feed results of those long-running computations back on chain.

impl<T: Config> IntegrityTest for Pallet<T>

fn integrity_test()

Run integrity test.

impl<T: Config> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T>

fn offchain_worker(n: <T as Config>::BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Config> OnFinalize<<T as Config>::BlockNumber> for Pallet<T>

fn on_finalize(n: <T as Config>::BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Config> OnGenesis for Pallet<T>

fn on_genesis()

Something that should happen at genesis.

impl<T: Config> OnIdle<<T as Config>::BlockNumber> for Pallet<T>

fn on_idle(n: <T as Config>::BlockNumber, remaining_weight: Weight) -> Weight

The block is being finalized. Implement to have something happen in case there is leftover weight. Check the passed remaining_weight to make sure it is high enough to allow for your pallet’s extra computation.

impl<T: Config> OnInitialize<<T as Config>::BlockNumber> for Pallet<T>

fn on_initialize(n: <T as Config>::BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

impl<T: Config> OnRuntimeUpgrade for Pallet<T>

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime upgrade.

impl<T: Config> OnStakerSlash<<T as Config>::AccountId, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance> for Pallet<T>

fn on_slash(
    pool_account: &T::AccountId,
    slashed_bonded: BalanceOf<T>,
    slashed_unlocking: &BTreeMap<EraIndex, BalanceOf<T>>
)

A hook for any operations to perform when a staker is slashed.

impl<T: Config> PalletInfoAccess for Pallet<T>

fn index() -> usize

Index of the pallet as configured in the runtime.

fn name() -> &'static str

Name of the pallet as configured in the runtime.

fn module_name() -> &'static str

Name of the Rust module containing the pallet.

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.

impl<T: Config> PalletsInfoAccess for Pallet<T>

fn count() -> usize

The number of pallets’ information that this type represents.

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.

impl<T> PartialEq<Pallet<T>> for Pallet<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: Config> StorageInfoTrait for Pallet<T>

fn storage_info() -> Vec<StorageInfo>

impl<T> Eq for Pallet<T>