Rust提名池运行时API库pallet-nomination-pools-runtime-api的使用

概述

pallet-nomination-pools-runtime-api是Substrate区块链框架中的一个重要组件，它为提名池(nomination pools)功能提供了运行时API接口。这个库使得开发者可以在Substrate链上实现提名质押功能，允许用户将他们的代币汇集在一起进行质押，共享奖励。

主要功能

• 提供提名池的创建和管理接口
• 实现代币的质押和奖励分配机制
• 支持池成员的加入和退出
• 提供池状态查询功能

使用方法

1. 添加依赖

首先，你需要在项目的Cargo.toml文件中添加依赖：

[dependencies]
pallet-nomination-pools-runtime-api = { git = "https://github.com/paritytech/substrate.git", branch = "master" }

2. 实现Runtime API

在你的运行时中实现提名池的Runtime API：

use pallet_nomination_pools_runtime_api::{NominationPoolsApi, Error};

impl NominationPoolsApi<Block> for Runtime {
    fn pool_member_status(
        who: &AccountId,
    ) -> Result<PoolMember<Balance>, Error> {
        NominationPools::pool_member_status(who)
    }

    fn pool_points(
        pool_id: PoolId,
    ) -> Result<PoolPoints, Error> {
        NominationPools::pool_points(pool_id)
    }
}

3. 创建提名池

use frame_support::dispatch::DispatchResult;

pub fn create_pool(
    origin: OriginFor<T>,
    amount: BalanceOf<T>,
    root: T::AccountId,
    nominator: T::AccountId,
    state_toggler: T::AccountId,
) -> DispatchResult {
    // 调用提名池模块的创建函数
    pallet_nomination_pools::Pallet::<T>::create(
        origin,
        amount,
        root,
        nominator,
        state_toggler,
    )
}

4. 加入提名池

pub fn join_pool(
    origin: OriginFor<T>,
    pool_id: PoolId,
    amount: BalanceOf<T>,
) -> DispatchResult {
    pallet_nomination-pools::Pallet::<T>::join(
        origin,
        pool_id,
        amount,
    )
}

5. 查询池信息

use pallet_nomination_pools_runtime_api::PoolMember;

pub fn get_pool_member(
    who: T::AccountId,
) -> Result<PoolMember<BalanceOf<T>>, Error> {
    <Runtime as NominationPoolsApi<Block>>::pool_member_status(&who)
}

示例代码

下面是一个完整的示例，展示如何使用提名池API：

use frame_support::{decl_module, decl_storage, dispatch::DispatchResult};
use frame_system::ensure_signed;
use pallet_nomination_pools_runtime_api::{NominationPoolsApi, PoolMember, Error};

pub trait Config: frame_system::Config + pallet_nomination_pools::Config {}

decl_storage! {
    trait Store for Module<T: Config> as NominationPoolsExample {
        // 可以添加自定义存储项
    }
}

decl_module! {
    pub struct Module<T: Config> for enum Call where origin: T::Origin {
        /// 创建新的提名池
        #[weight = 10_000]
        pub fn create_pool(
            origin,
            amount: T::Balance,
            root: T::AccountId,
            nominator: T::AccountId,
            state_toggler: T::AccountId,
        ) -> DispatchResult {
            let who = ensure_signed(origin)?;
            
            pallet_nomination_pools::Pallet::<T>::create(
                who.into(),
                amount,
                root,
                nominator,
                state_toggler,
            )
        }

        /// 查询池成员状态
        #[weight = 10_000]
        pub fn get_member_status(
            origin,
            member: T::AccountId,
        ) -> Result<PoolMember<T::Balance>, Error> {
            let _ = ensure_signed(origin)?;
            
            <Runtime as NominationPoolsApi<Block>>::pool_member_status(&member)
        }
    }
}

完整示例代码

以下是一个更完整的示例，展示如何集成提名池API到运行时中：

//! 提名池运行时API集成示例

use frame_support::{
    construct_runtime, parameter_types,
    traits::{ConstU32, ConstU64},
    weights::Weight,
};
use frame_system::EnsureRoot;
use pallet_nomination_pools::{
    BondExtra, BondedPools, Config, CurrentEra, LastPoolId, MaxPoolMembers,
    MaxPoolMembersPerPool, MaxPools, MinCreateBond, MinJoinBond, Pallet as NominationPools,
    PoolMembers, PoolRoles, RewardPools, SubPoolsStorage,
};
use sp_runtime::{
    traits::{AccountIdConversion, BlakeTwo256, IdentifyAccount, Verify},
    MultiSignature, RuntimeDebug,
};

// 运行时配置
pub struct Runtime;

parameter_types! {
    pub const MaxNominations: u32 = 16;
    pub const MaxUnlockingChunks: u32 = 32;
    pub const MaxPools: u32 = 1_000;
    pub const MaxPoolMembers: u32 = 10_000;
    pub const MaxPoolMembersPerPool: u32 = 1_000;
    pub const MinCreateBond: Balance = 10 * DOLLARS;
    pub const MinJoinBond: Balance = 1 * DOLLARS;
}

impl Config for Runtime {
    type Event = Event;
    type WeightInfo = ();
    type Currency = Balances;
    type RewardCounter = RewardCounter;
    type BalanceToU256 = BalanceToU256;
    type U256ToBalance = U256ToBalance;
    type PostUnbondingPoolsWindow = PostUnbondingPoolsWindow;
    type MaxUnbonding = MaxUnbonding;
    type MaxPointsToBalance = MaxPointsToBalance;
    type MaxPools = MaxPools;
    type MaxPoolMembers = MaxPoolMembers;
    type MaxPoolMembersPerPool = MaxPoolMembersPerPool;
    type MinCreateBond = MinCreateBond;
    type MinJoinBond = MinJoinBond;
    type PalletId = PalletsPoolId;
    type AdminOrigin = EnsureRoot<AccountId>;
}

// 实现NominationPoolsApi
impl pallet_nomination_pools_runtime_api::NominationPoolsApi<Block> for Runtime {
    fn pool_member_status(who: &AccountId) -> Result<PoolMember<Balance>, Error> {
        NominationPools::pool_member_status(who)
    }

    fn pool_points(pool_id: PoolId) -> Result<PoolPoints, Error> {
        NominationPools::pool_points(pool_id)
    }
}

// 创建提名池的调用示例
pub fn create_pool_example() -> DispatchResult {
    let root = AccountId::new([1u8; 32]);
    let nominator = AccountId::new([2u8; 32]);
    let state_toggler = AccountId::new([3u8; 32]);
    let initial_amount = 100 * DOLLARS;

    NominationPools::<Runtime>::create(
        RawOrigin::Signed(root.clone()).into(),
        initial_amount,
        root,
        nominator,
        state_toggler,
    )
}

// 加入提名池的调用示例
pub fn join_pool_example(who: AccountId, pool_id: PoolId, amount: Balance) -> DispatchResult {
    NominationPools::<Runtime>::join(
        RawOrigin::Signed(who).into(),
        pool_id,
        amount,
    )
}

// 查询池成员状态的调用示例
pub fn get_pool_member_example(who: AccountId) -> Result<PoolMember<Balance>, Error> {
    <Runtime as pallet_nomination_pools_runtime_api::NominationPoolsApi<Block>>::pool_member_status(&who)
}

注意事项

1. 使用前确保你的链已经正确配置了pallet-nomination-pools
2. 提名池功能通常需要与Staking模块配合使用
3. 注意权限控制，特别是池的创建和管理操作
4. 考虑池成员的最小和最大数量限制
5. 注意奖励分配机制的公平性

通过pallet-nomination-pools-runtime-api，开发者可以方便地在Substrate链上实现提名质押功能，为用户提供更灵活的质押选项。