Rust治理模块pallet-ranked-collective使用指南

完整示例Demo

下面是一个完整的pallet-ranked-collective使用示例，展示了从模块引入到基本操作的全流程：

// 1. 在runtime中引入模块
use frame_support::{dispatch::DispatchResult, traits::EnsureOrigin};
use frame_system::Config as SystemConfig;

// 自定义Polls实现
pub struct DemoPolls;
impl pallet_ranked_collective::Polls for DemoPolls {
    type Index = u32;
    type Votes = u32;
    type Moment = u64;
    type Proposal = Box<<Runtime as frame_system::Config>::RuntimeCall>;
    
    fn create_proposal(proposal: Self::Proposal) -> Result<Self::Index, DispatchError> {
        // 简单实现：使用递增索引
        static mut INDEX: u32 = 0;
        unsafe {
            INDEX += 1;
            Ok(INDEX)
        }
    }
    
    fn vote_weight(index: Self::Index) -> Result<Self::Votes, DispatchError> {
        // 简单实现：每个提案权重相同
        Ok(1)
    }
    
    // ...其他必要方法实现
}

// 配置RankedCollective pallet
impl pallet_ranked_collective::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type PromoteOrigin = frame_system::EnsureRoot<AccountId>;  // 仅root可以晋升成员
    type DemoteOrigin = frame_system::EnsureRoot<AccountId>;   // 仅root可以降级成员
    type Polls = DemoPolls;  // 使用我们自定义的Polls实现
    type WeightInfo = ();
}

// 2. 基本操作示例
fn demo() -> DispatchResult {
    let root = RuntimeOrigin::root();
    let alice = 1;
    let bob = 2;
    let charlie = 3;
    
    // 添加初始成员
    RankedCollective::add_member(root.clone(), alice)?;
    RankedCollective::add_member(root.clone(), bob)?;
    
    // 晋升Alice到等级2
    RankedCollective::promote_member(root.clone(), alice)?;
    
    // Alice创建提案
    let proposal = RuntimeCall::System(frame_system::Call::remark { 
        remark: b"Demo proposal".to_vec() 
    });
    let proposal_hash = proposal.blake2_256();
    RankedCollective::submit_proposal(
        RuntimeOrigin::signed(alice),
        Box::new(proposal),
        2,  // 需要至少等级2的成员投票
    )?;
    
    // Bob投票赞成
    RankedCollective::vote(
        RuntimeOrigin::signed(bob),
        proposal_hash,
        0,
        true,
    )?;
    
    // Charlie加入并尝试投票（会失败，因为Charlie不是成员）
    assert!(RankedCollective::vote(
        RuntimeOrigin::signed(charlie),
        proposal_hash,
        0,
        true,
    ).is_err());
    
    // 执行提案
    RankedCollective::execute_proposal(
        RuntimeOrigin::signed(alice),
        proposal_hash,
        0,
    )?;
    
    Ok(())
}

进阶示例：自定义治理规则

下面展示如何自定义晋升规则和投票权重：

// 自定义晋升规则 - 需要至少3个高级成员批准
pub struct PromoteOrigin;
impl<OuterOrigin, AccountId> EnsureOrigin<OuterOrigin> for PromoteOrigin
where
    OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>> + From<RawOrigin<AccountId>>,
    AccountId: PartialEq + Clone,
{
    type Success = ();
    
    fn try_origin(o: OuterOrigin) -> Result<Self::Success, OuterOrigin> {
        // 实现自定义逻辑：检查是否至少有3个高级成员签名
        // 这里简化实现，实际需要更复杂的检查
        Ok(())
    }
}

// 自定义投票权重 - 基于成员等级
pub struct WeightedPolls;
impl pallet_ranked_collective::Polls for WeightedPolls {
    type Index = u32;
    type Votes = u64;  // 使用更大范围表示权重
    type Moment = u64;
    type Proposal = Box<<Runtime as frame_system::Config>::RuntimeCall>;
    
    fn create_proposal(proposal: Self::Proposal) -> Result<Self::Index, DispatchError> {
        // 提案创建逻辑
        Ok(1)
    }
    
    fn vote_weight(index: Self::Index) -> Result<Self::Votes, DispatchError> {
        // 获取投票者等级，等级越高权重越大
        let voter = frame_system::Pallet::<Runtime>::caller();
        let rank = RankedCollective::rank_of(&voter).unwrap_or(0);
        Ok((rank * rank) as u64)  // 权重=等级²
    }
}

// 配置使用自定义规则
impl pallet_ranked_collective::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type PromoteOrigin = PromoteOrigin;  // 使用自定义晋升规则
    type DemoteOrigin = frame_system::EnsureRoot<AccountId>;
    type Polls = WeightedPolls;  // 使用加权投票
    type WeightInfo = ();
}

测试用例示例

#[test]
fn test_ranked_collective_workflow() {
    new_test_ext().execute_with(|| {
        // 初始化账户
        let root = Origin::root();
        let alice = 1;
        
        // 测试添加成员
        assert_ok!(RankedCollective::add_member(root.clone(), alice));
        assert_eq!(RankedCollective::rank_of(&alice), Some(1));
        
        // 测试提案提交
        let proposal = Box::new(Call::System(frame_system::Call::remark { remark: vec![1] }));
        assert_ok!(RankedCollective::submit_proposal(
            Origin::signed(alice),
            proposal,
            1
        ));
        
        // 测试投票
        let proposal_hash = BlakeTwo256::hash_of(&proposal);
        assert_ok!(RankedCollective::vote(
            Origin::signed(alice),
            proposal_hash,
            0,
            true
        ));
        
        // 测试提案执行
        assert_ok!(RankedCollective::execute_proposal(
            Origin::signed(alice),
            proposal_hash,
            0
        ));
    });
}