Rust核心成员库pallet-core-fellowship的使用：实现Substrate区块链治理与身份管理功能

完整示例demo

下面是一个完整的runtime集成示例，展示了如何使用pallet-core-fellowship实现完整的治理系统：

// runtime/src/lib.rs

// 1. 引入必要的依赖和模块
pub use pallet_core_fellowship as fellowship;
pub use pallet_ranked_collective as collective;

// 2. 配置runtime实现
impl fellowship::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type Members = collective::Instance1;  // 使用ranked collective实例
    type Balance = Balance;  // 使用runtime定义的Balance类型
    type ParamsOrigin = EnsureRoot<AccountId>;  // 只有root可以修改参数
    type InductOrigin = EnsureRoot<AccountId>;  // 只有root可以初始化成员
    type ApproveOrigin = EnsureRoot<AccountId>;  // 只有root可以批准成员
    type PromoteOrigin = EnsureRoot<AccountId>;  // 只有root可以提升成员等级
    type EvidenceSize = ConstU32<65536>;  // 证据大小限制
    type MaxRank = ConstU32<9>;  // 最大等级设为9级
    
    // 自定义特权分配
    fn get_privileges(rank: u16) -> Vec<Privilege> {
        match rank {
            1 => vec![Privilege::Vote],  // 1级成员只有投票权
            3 => vec![Privilege::Vote, Privilege::Propose],  // 3级成员可以提案
            5 => vec![Privilege::Vote, Privilege::Propose, Privilege::Veto],  // 5级成员有否决权
            _ => vec![],  // 其他等级无特权
        }
    }
}

// 3. 在construct_runtime!宏中添加pallet
construct_runtime!(
    pub enum Runtime where
        Block = Block,
        NodeBlock = opaque::Block,
        UncheckedExtrinsic = UncheckedExtrinsic,
    {
        // 系统基础pallet
        System: frame_system,
        Timestamp: pallet_timestamp,
        
        // 治理相关pallet
        Collective: pallet_ranked_collective::<Instance1>,
        CoreFellowship: pallet_core_fellowship,
        
        // 其他pallet...
    }
);

// 4. 实现自定义成员管理逻辑
pub mod fellowship_extension {
    use super::*;
    use frame_support::{dispatch::DispatchResult, traits::Get};
    
    // 检查成员是否有特定特权
    pub fn has_privilege(who: &AccountId, privilege: Privilege) -> bool {
        if let Some(info) = CoreFellowship::member(who) {
            fellowship::Pallet::<Runtime>::get_privileges(info.rank)
                .contains(&privilege)
        } else {
            false
        }
    }
    
    // 带证据的成员申请
    pub fn apply_with_evidence(
        origin: OriginFor<Runtime>,
        evidence: Vec<u8>,
    ) -> DispatchResult {
        let who = ensure_signed(origin)?;
        
        // 验证证据大小
        ensure!(
            evidence.len() <= T::EvidenceSize::get() as usize,
            Error::<Runtime>::EvidenceTooLarge
        );
        
        // 存储申请证据
        PendingApplications::<Runtime>::insert(&who, evidence);
        
        // 触发申请事件
        Self::deposit_event(Event::Applied { who });
        
        Ok(())
    }
    
    // 自动晋升符合条件的成员
    pub fn auto_promote(origin: OriginFor<Runtime>) -> DispatchResult {
        // 只有root可以调用
        ensure_root(origin)?;
        
        // 遍历所有成员
        for (who, info) in Members::<Runtime>::iter() {
            // 检查是否符合晋升条件
            if meets_promotion_criteria(&who, &info) {
                CoreFellowship::promote(RawOrigin::Root.into(), who)?;
            }
        }
        
        Ok(())
    }
    
    // 晋升条件检查
    fn meets_promotion_criteria(who: &AccountId, info: &MemberInfo<Balance, BlockNumber>) -> bool {
        // 实现自定义晋升逻辑
        // 例如：检查活跃度、贡献度等
        true
    }
}

完整治理系统实现

下面是一个完整的治理投票系统实现示例：

// governance/src/lib.rs

use frame_support::{
    dispatch::DispatchResult,
    ensure,
    traits::{Currency, Get},
};
use frame_system::pallet_prelude::*;
use sp_std::prelude::*;

// 治理提案结构
#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
pub struct Proposal<AccountId, Hash, BlockNumber> {
    proposer: AccountId,
    hash: Hash,
    created: BlockNumber,
    votes: Vec<(AccountId, u64)>,  // (投票者, 投票权重)
    status: ProposalStatus,
}

#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
pub enum ProposalStatus {
    Active,
    Approved,
    Rejected,
}

// 治理模块实现
impl<T: Config> Pallet<T> {
    // 创建新提案
    pub fn propose(
        origin: OriginFor<T>,
        proposal_hash: T::Hash,
    ) -> DispatchResult {
        let who = ensure_signed(origin)?;
        
        // 检查提案者是否是核心成员且有提案权
        ensure!(
            fellowship_extension::has_privilege(&who, Privilege::Propose),
            Error::<T>::NoProposalRight
        );
        
        // 创建新提案
        let proposal = Proposal {
            proposer: who.clone(),
            hash: proposal_hash,
            created: frame_system::Pallet::<T>::block_number(),
            votes: vec![],
            status: ProposalStatus::Active,
        };
        
        // 存储提案
        Proposals::<T>::insert(&proposal_hash, proposal);
        
        Ok(())
    }
    
    // 提交投票
    pub fn vote(
        origin: OriginFor<T>,
        proposal_hash: T::Hash,
        approve: bool,
    ) -> DispatchResult {
        let who = ensure_signed(origin)?;
        
        // 检查投票者是否是核心成员
        ensure!(
            CoreFellowship::is_member(&who),
            Error::<T>::NotMember
        );
        
        // 获取成员信息和投票权重
        let member_info = CoreFellowship::member(&who)
            .ok_or(Error::<T>::NotMember)?;
        let vote_weight = member_info.rank as u64;
        
        // 更新提案投票状态
        Proposals::<T>::mutate(proposal_hash, |maybe_proposal| {
            if let Some(proposal) = maybe_proposal {
                // 记录投票
                proposal.votes.push((who.clone(), vote_weight));
                
                // 检查投票结果
                let total_weight: u64 = proposal.votes.iter()
                    .map(|(_, weight)| weight)
                    .sum();
                
                let approval_weight: u64 = proposal.votes.iter()
                    .filter(|(_, approve)| *approve)
                    .map(|(_, weight)| weight)
                    .sum();
                
                // 更新提案状态
                if approval_weight * 2 > total_weight {
                    proposal.status = ProposalStatus::Approved;
                } else if (total_weight - approval_weight) * 2 > total_weight {
                    proposal.status = ProposalStatus::Rejected;
                }
            }
        });
        
        Ok(())
    }
    
    // 执行已批准的提案
    pub fn execute_proposal(
        origin: OriginFor<T>,
        proposal_hash: T::Hash,
    ) -> DispatchResult {
        // 检查提案状态
        if let Some(proposal) = Proposals::<T>::get(proposal_hash) {
            ensure!(
                proposal.status == ProposalStatus::Approved,
                Error::<T>::ProposalNotApproved
            );
            
            // 执行提案逻辑
            // ...
            
            // 移除已执行的提案
            Proposals::<T>::remove(proposal_hash);
        }
        
        Ok(())
    }
}

测试用例

#[cfg(test)]
mod tests {
    use super::*;
    use frame_support::{
        assert_ok, assert_err,
        traits::{OnInitialize, Currency}
    };
    use sp_core::H256;
    use crate::mock::{new_test_ext, Test, Origin};
    
    #[test]
    fn test_member_management() {
        new_test_ext().execute_with(|| {
            // 初始化测试账户
            let root = Origin::root();
            let alice = 1u64;
            let bob = 2u64;
            
            // 初始化成员
            assert_ok!(CoreFellowship::induct(root.clone(), alice, 1));
            assert_ok!(CoreFellowship::induct(root.clone(), bob, 1));
            
            // 检查成员状态
            assert!(CoreFellowship::is_member(&alice));
            assert_eq!(CoreFellowship::member(&alice).unwrap().rank, 1);
            
            // 提升成员等级
            assert_ok!(CoreFellowship::promote(root.clone(), alice));
            assert_eq!(CoreFellowship::member(&alice).unwrap().rank, 2);
            
            // 测试特权
            assert!(fellowship_extension::has_privilege(&alice, Privilege::Vote));
            assert!(!fellowship_extension::has_privilege(&alice, Privilege::Propose));
        });
    }
    
    #[test]
    fn test_governance() {
        new_test_ext().execute_with(|| {
            // 初始化测试账户
            let root = Origin::root();
            let alice = 1u64;
            let bob = 2u64;
            let proposal_hash = H256::random();
            
            // 初始化高级成员
            assert_ok!(CoreFellowship::induct(root.clone(), alice, 3));
            assert_ok!(CoreFellowship::induct(root.clone(), bob, 1));
            
            // 创建提案
            assert_ok!(Governance::propose(Origin::signed(alice), proposal_hash));
            
            // 投票
            assert_ok!(Governance::vote(Origin::signed(alice), proposal_hash, true));
            assert_ok!(Governance::vote(Origin::signed(bob), proposal_hash, false));
            
            // 检查提案状态
            let proposal = Governance::proposals(proposal_hash).unwrap();
            assert_eq!(proposal.votes.len(), 2);
            assert_eq!(proposal.status, ProposalStatus::Active);
        });
    }
}

总结

这个完整示例展示了如何：

1. 在runtime中集成pallet-core-fellowship
2. 配置成员管理参数
3. 实现自定义特权分配
4. 构建基于成员等级的治理系统
5. 编写测试用例验证功能

通过这种方式，你可以构建一个灵活且安全的区块链治理系统，其中成员权限和投票权重由他们的等级决定。