Rust质押池管理库pallet-nomination-pools的使用，实现高效安全的权益质押与委托功能

安装

在项目目录中运行以下Cargo命令：

cargo add pallet-nomination-pools

或者在Cargo.toml中添加以下行：

pallet-nomination-pools = "40.0.0"

使用示例

以下是一个使用pallet-nomination-pools实现质押池管理的完整示例：

use frame_support::traits::{Currency, OnUnbalanced};
use pallet_nomination_pools::{self as pools, PoolId};
use sp_runtime::traits::{AccountIdConversion, Saturating};
use frame_system::Config as SystemConfig;

// 定义你的运行时配置
pub trait Config: pools::Config + SystemConfig {
    // 添加你的运行时特定配置
}

// 创建质押池
fn create_pool<T: Config>(
    depositor: T::AccountId,
    amount: BalanceOf<T>,
    root: T::AccountId,
    nominator: T::AccountId,
    state_toggler: T::AccountId,
) -> Result<PoolId, pools::Error<T>> {
    // 检查余额是否足够
    let min_create_bond = pools::MinCreateBond::<T>::get();
    ensure!(amount >= min_create_bond, pools::Error::<T>::InsufficientBond);
    
    // 创建质押池
    pools::Pallet::<T>::create(
        depositor,
        amount,
        root,
        nominator,
        state_toggler,
    )
}

// 加入质押池
fn join_pool<T: Config>(
    who: T::AccountId,
    pool_id: PoolId,
    amount: BalanceOf<T>,
) -> Result<(), pools::Error<T>> {
    // 检查池是否存在
    ensure!(pools::Pallet::<T>::pool_exists(pool_id), pools::Error::<T>::PoolNotFound);
    
    // 加入池
    pools::Pallet::<T>::join(
        who,
        pool_id,
        amount,
    )
}

// 提名验证人
fn nominate<T: Config>(
    pool_id: PoolId,
    validators: Vec<T::AccountId>,
) -> Result<(), pools::Error<T>> {
    // 获取池账户
    let pool_account = pools::Pallet::<T>::create_pool_account(pool_id);
    
    // 提名验证人
    pools::Pallet::<T>::nominate(
        pool_account,
        validators,
    )
}

// 提取奖励
fn claim_payout<T: Config>(
    member_account: T::AccountId,
) -> Result<(), pools::Error<T>> {
    // 提取奖励
    pools::Pallet::<T>::claim_payout(member_account)
}

// 解质押
fn unbond<T: Config>(
    member_account: T::AccountId,
    unbond_points: BalanceOf<T>,
) -> Result<(), pools::Error<T>> {
    // 解质押
    pools::Pallet::<T>::unbond(
        member_account,
        unbond_points,
    )
}

完整示例代码

use frame_support::{
    assert_ok,
    traits::{Currency, OnUnbalanced},
};
use frame_system::Config as SystemConfig;
use pallet_nomination_pools::{self as pools, BondExtra, PoolId};
use sp_core::H256;
use sp_runtime::{
    testing::Header,
    traits::{AccountIdConversion, BlakeTwo256, IdentityLookup, Saturating},
    Perbill,
};

// 定义测试环境类型
type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
type Block = frame_system::mocking::MockBlock<Test>;

// 配置测试运行时
frame_support::construct_runtime!(
    pub enum Test where
        Block = Block,
        NodeBlock = Block,
        UncheckedExtrinsic = UncheckedExtrinsic,
    {
        System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
        Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
        Staking: pallet_staking::{Pallet, Call, Storage, Config<T>, Event<T>},
        NominationPools: pallet_nomination_pools::{
            Pallet, Call, Storage, Event<T>, Config<T>
        },
    }
);

// 实现系统配置
impl frame_system::Config for Test {
    type BaseCallFilter = frame_support::traits::Everything;
    type BlockWeights = ();
    type BlockLength = ();
    type DbWeight = ();
    type Origin = Origin;
    type Index = u64;
    type BlockNumber = u64;
    type Hash = H256;
    type Call = Call;
    type Hashing = BlakeTwo256;
    type AccountId = u64;
    type Lookup = IdentityLookup<Self::AccountId>;
    type Header = Header;
    type Event = Event;
    type BlockHashCount = ();
    type Version = ();
    type PalletInfo = PalletInfo;
    type AccountData = pallet_balances::AccountData<u64>;
    type OnNewAccount = ();
    type OnKilledAccount = ();
    type SystemWeightInfo = ();
    type SS58Prefix = ();
    type OnSetCode = ();
    type MaxConsumers = frame_support::traits::ConstU32<16>;
}

// 实现余额配置
impl pallet_balances::Config for Test {
    type Balance = u64;
    type DustRemoval = ();
    type Event = Event;
    type ExistentialDeposit = frame_support::traits::ConstU64<1>;
    type AccountStore = System;
    type WeightInfo = ();
    type MaxLocks = ();
    type MaxReserves = ();
    type ReserveIdentifier = [u8; 8];
}

// 实现质押配置
impl pallet_staking::Config for Test {
    type Currency = Balances;
    type UnixTime = ();
    type CurrencyToVote = ();
    type RewardRemainder = ();
    type Event = Event;
    type Slash = ();
    type Reward = ();
    type SessionsPerEra = ();
    type SlashDeferDuration = ();
    type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
    type BondingDuration = frame_support::traits::ConstU32<3>;
    type SessionInterface = ();
    type EraPayout = ();
    type NextNewSession = ();
    type MaxNominatorRewardedPerValidator = frame_support::traits::ConstU32<64>;
    type OffendingValidatorsThreshold = ();
    type WeightInfo = ();
}

// 实现质押池配置
impl pallet_nomination_pools::Config for Test {
    type Event = Event;
    type WeightInfo = ();
    type Currency = Balances;
    type Stake = Staking;
    type PostUnbondingPoolsWindow = frame_support::traits::ConstU32<10>;
    type MaxMetadataLen = frame_support::traits::ConstU32<256>;
    type MaxPools = frame_support::traits::ConstU32<10>;
    type MaxPoolMembers = frame_support::traits::ConstU32<100>;
    type MaxPoolMembersPerPool = frame_support::traits::ConstU32<50>;
    type MinerReward = ();
    type BalanceToU256 = ();
    type U256ToBalance = ();
}

// 测试创建和加入质押池
#[test]
fn test_pool_creation_and_joining() {
    // 初始化测试环境
    let mut ext = sp_io::TestExternalities::new_empty();
    ext.execute_with(|| {
        // 创建初始账户
        let root = 1;
        let depositor = 2;
        let member = 3;
        
        // 设置初始余额
        Balances::make_free_balance_be(&depositor, 1000);
        Balances::make_free_balance_be(&member, 500);
        
        // 创建质押池
        assert_ok!(NominationPools::create(
            Origin::signed(depositor),
            100,  // 质押金额
            root, // 根账户
            root, // 提名账户
            root  // 状态切换账户
        ));
        
        // 获取创建的池ID
        let pool_id = 1;
        
        // 验证池是否存在
        assert!(NominationPools::pool_exists(pool_id));
        
        // 加入质押池
        assert_ok!(NominationPools::join(
            Origin::signed(member),
            pool_id,
            200  // 质押金额
        ));
        
        // 验证成员是否已加入池
        assert!(NominationPools::is_pool_member(&member).is_some());
    });
}

// 测试提名验证人
#[test]
fn test_nominating_validators() {
    let mut ext = sp_io::TestExternalities::new_empty();
    ext.execute_with(|| {
        // 创建初始账户
        let root = 1;
        let depositor = 2;
        let validator = 10;
        
        // 设置初始余额
        Balances::make_free_balance_be(&depositor, 1000);
        
        // 创建质押池
        assert_ok!(NominationPools::create(
            Origin::signed(depositor),
            100,
            root,
            root,
            root
        ));
        
        let pool_id = 1;
        let pool_account = NominationPools::create_pool_account(pool_id);
        
        // 提名验证人
        assert_ok!(NominationPools::nominate(
            Origin::signed(root),
            pool_id,
            vec![validator]
        ));
        
        // 验证提名是否成功
        let nominations = Staking::nominations(pool_account);
        assert!(nominations.targets.contains(&validator));
    });
}

// 测试解质押和提取奖励
#[test]
fn test_unbonding_and_claiming() {
    let mut ext = sp_io::TestExternalities::new_empty();
    ext.execute_with(|| {
        // 创建初始账户
        let root = 1;
        let depositor = 2;
        let member = 3;
        
        // 设置初始余额
        Balances::make_free_balance_be(&depositor, 1000);
        Balances::make_free_balance_be(&member, 500);
        
        // 创建质押池
        assert_ok!(NominationPools::create(
            Origin::signed(depositor),
            100,
            root,
            root,
            root
        ));
        
        let pool_id = 1;
        
        // 加入质押池
        assert_ok!(NominationPools::join(
            Origin::signed(member),
            pool_id,
            200
        ));
        
        // 解质押部分金额
        assert_ok!(NominationPools::unbond(
            Origin::signed(member),
            pool_id,
            50
        ));
        
        // 模拟奖励分配
        
        // 提取奖励
        assert_ok!(NominationPools::claim_payout(
            Origin::signed(member)
        ));
    });
}

功能说明

1. 创建质押池：允许用户创建新的质押池，成为池管理员
2. 加入质押池：其他用户可以将资金存入池中参与质押
3. 提名验证人：池管理员可以提名验证人集合
4. 奖励分配：自动分配质押奖励给池成员
5. 解质押：成员可以解质押他们的资金

安全特性

1. 资金隔离：每个池的资金存储在单独的账户中
2. 角色分离：池管理权限可以分配给不同的角色
3. 最小质押限制：防止小额质押导致的系统过载
4. 解质押冷却期：防止频繁进出质押池