Struct TransactionApi

pub struct TransactionApi;

Implementations

impl TransactionApi

pub fn join(&self, amount: Amount, pool_id: PoolId) -> StaticPayload<Join>

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(&self, extra: Extra) -> StaticPayload<BondExtra>

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. See bond_extra_other to bond pending rewards of other members.

pub fn claim_payout(&self) -> StaticPayload<ClaimPayout>

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 their 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”.

See claim_payout_other to claim rewards on behalf of some other pool member.

pub fn unbond( &self, member_account: MemberAccount, unbonding_points: UnbondingPoints, ) -> StaticPayload<Unbond>

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 bouncer. 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. The [StakingInterface::unbond] will implicitly call [Call::pool_withdraw_unbonded] to try to free chunks if necessary (ie. if unbound was called and no unlocking chunks are available). However, it may not be possible to release the current unlocking chunks, in which case, the result of this call will likely be the NoMoreChunks error from the staking system.

pub fn pool_withdraw_unbonded( &self, pool_id: PoolId, num_slashing_spans: NumSlashingSpans, ) -> StaticPayload<PoolWithdrawUnbonded>

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

This is useful if there 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( &self, member_account: MemberAccount, num_slashing_spans: NumSlashingSpans, ) -> StaticPayload<WithdrawUnbonded>

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

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.
• If the pool has any pending slash, we also try to slash the member before letting them withdraw. This calculation adds some weight overhead and is only defensive. In reality, pool slashes must have been already applied via permissionless [Call::apply_slash].

pub fn create( &self, amount: Amount, root: Root, nominator: Nominator, bouncer: Bouncer, ) -> StaticPayload<Create>

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].
• bouncer - The account to set as the [PoolRoles::bouncer].

Note

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

pub fn create_with_pool_id( &self, amount: Amount, root: Root, nominator: Nominator, bouncer: Bouncer, pool_id: PoolId, ) -> StaticPayload<CreateWithPoolId>

Create a new delegation pool with a previously used pool id

Arguments

same as create with the inclusion of

• pool_id - `A valid PoolId.

pub fn nominate( &self, pool_id: PoolId, validators: Validators, ) -> StaticPayload<Nominate>

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.

Note

In addition to a root or nominator role of origin, pool’s depositor needs to have at least depositor_min_bond in the pool to start nominating.

pub fn set_state( &self, pool_id: PoolId, state: State, ) -> StaticPayload<SetState>

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 bouncer, 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( &self, pool_id: PoolId, metadata: Metadata, ) -> StaticPayload<SetMetadata>

Set a new metadata for the pool.

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

pub fn set_configs( &self, min_join_bond: MinJoinBond, min_create_bond: MinCreateBond, max_pools: MaxPools, max_members: MaxMembers, max_members_per_pool: MaxMembersPerPool, global_max_commission: GlobalMaxCommission, ) -> StaticPayload<SetConfigs>

Update configurations for the nomination pools. The origin for this call must be [Config::AdminOrigin].

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].
• global_max_commission - Set [GlobalMaxCommission].

pub fn update_roles( &self, pool_id: PoolId, new_root: NewRoot, new_nominator: NewNominator, new_bouncer: NewBouncer, ) -> StaticPayload<UpdateRoles>

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(&self, pool_id: PoolId) -> StaticPayload<Chill>

Chill on behalf of the pool.

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

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

Conditions for a permissionless dispatch:

• When pool depositor has less than MinNominatorBond staked, otherwise pool members are unable to unbond.

Conditions for permissioned dispatch:

• The caller has a nominator or root role of the pool. This directly forward the call to the staking pallet, on behalf of the pool bonded account.

pub fn bond_extra_other( &self, member: Member, extra: Extra, ) -> StaticPayload<BondExtraOther>

origin bonds funds from extra for some pool member member into their respective pools.

origin can bond extra funds from free balance or pending rewards when origin == other.

In the case of origin != other, origin can only bond extra pending rewards of other members assuming set_claim_permission for the given member is PermissionlessCompound or PermissionlessAll.

pub fn set_claim_permission( &self, permission: Permission, ) -> StaticPayload<SetClaimPermission>

Allows a pool member to set a claim permission to allow or disallow permissionless bonding and withdrawing.

Arguments

• origin - Member of a pool.
• permission - The permission to be applied.

pub fn claim_payout_other( &self, other: Other, ) -> StaticPayload<ClaimPayoutOther>

origin can claim payouts on some pool member other’s behalf.

Pool member other must have a PermissionlessWithdraw or PermissionlessAll claim permission for this call to be successful.

pub fn set_commission( &self, pool_id: PoolId, new_commission: NewCommission, ) -> StaticPayload<SetCommission>

Set the commission of a pool. Both a commission percentage and a commission payee must be provided in the current tuple. Where a current of None is provided, any current commission will be removed.

• If a None is supplied to new_commission, existing commission will be removed.

pub fn set_commission_max( &self, pool_id: PoolId, max_commission: MaxCommission, ) -> StaticPayload<SetCommissionMax>

Set the maximum commission of a pool.

• Initial max can be set to any Perbill, and only smaller values thereafter.
• Current commission will be lowered in the event it is higher than a new max commission.

pub fn set_commission_change_rate( &self, pool_id: PoolId, change_rate: ChangeRate, ) -> StaticPayload<SetCommissionChangeRate>

Set the commission change rate for a pool.

Initial change rate is not bounded, whereas subsequent updates can only be more restrictive than the current.

pub fn claim_commission( &self, pool_id: PoolId, ) -> StaticPayload<ClaimCommission>

Claim pending commission.

The dispatch origin of this call must be signed by the root role of the pool. Pending commission is paid out and added to total claimed commission`. Total pending commission is reset to zero. the current.

pub fn adjust_pool_deposit( &self, pool_id: PoolId, ) -> StaticPayload<AdjustPoolDeposit>

Top up the deficit or withdraw the excess ED from the pool.

When a pool is created, the pool depositor transfers ED to the reward account of the pool. ED is subject to change and over time, the deposit in the reward account may be insufficient to cover the ED deficit of the pool or vice-versa where there is excess deposit to the pool. This call allows anyone to adjust the ED deposit of the pool by either topping up the deficit or claiming the excess.

pub fn set_commission_claim_permission( &self, pool_id: PoolId, permission: Permission, ) -> StaticPayload<SetCommissionClaimPermission>

Set or remove a pool’s commission claim permission.

Determines who can claim the pool’s pending commission. Only the Root role of the pool is able to configure commission claim permissions.

pub fn apply_slash( &self, member_account: MemberAccount, ) -> StaticPayload<ApplySlash>

Apply a pending slash on a member.

Fails unless [crate::pallet::Config::StakeAdapter] is of strategy type: [adapter::StakeStrategyType::Delegate].

The pending slash amount of the member must be equal or more than ExistentialDeposit. This call can be dispatched permissionlessly (i.e. by any account). If the execution is successful, fee is refunded and caller may be rewarded with a part of the slash based on the [crate::pallet::Config::StakeAdapter] configuration.

pub fn migrate_delegation( &self, member_account: MemberAccount, ) -> StaticPayload<MigrateDelegation>

Migrates delegated funds from the pool account to the member_account.

Fails unless [crate::pallet::Config::StakeAdapter] is of strategy type: [adapter::StakeStrategyType::Delegate].

This is a permission-less call and refunds any fee if claim is successful.

If the pool has migrated to delegation based staking, the staked tokens of pool members can be moved and held in their own account. See [adapter::DelegateStake]

pub fn migrate_pool_to_delegate_stake( &self, pool_id: PoolId, ) -> StaticPayload<MigratePoolToDelegateStake>

Migrate pool from [adapter::StakeStrategyType::Transfer] to [adapter::StakeStrategyType::Delegate].

Fails unless [crate::pallet::Config::StakeAdapter] is of strategy type: [adapter::StakeStrategyType::Delegate].

This call can be dispatched permissionlessly, and refunds any fee if successful.

If the pool has already migrated to delegation based staking, this call will fail.