Rust身份管理模块pallet-identity的使用：Substrate区块链中的去中心化身份验证与属性管理

Identity Pallet

概述

一个联邦命名系统，允许从指定来源添加多个注册商。注册商可以设置费用来提供身份验证服务。任何人都可以提交一个提议的身份并支付固定押金，然后请求任意数量的注册商进行审核（支付各自的费用）。注册商的判断以enum形式给出，允许多层次的意见。

有些判断被标识为"sticky"，这意味着除非完全移除身份或由注册商移除，否则无法删除。判断可以代表为注册商保留的部分资金。

超级用户可以删除账户，并在此过程中没收押金。

所有账户也可以有有限数量的子账户，由所有者指定；根据定义，这些子账户具有相同的所有权，每个子账户都有独立的名称。

注册商的数量应受到限制，押金应足够大，以确保不存在可行的状态膨胀攻击。

用户名

该模块提供了用户名授权机构发行用户名的功能，这些功能独立于身份信息功能；账户可以设置：

• 不设置用户名的身份
• 不设置身份的用户名
• 身份和用户名

该模块中实现的用户名功能旨在提供用户友好的账户查找。存在双向映射：“账户->用户名"和"用户名->账户”。

要授予用户名，用户名授权机构可以：

• 通过治理获得特定数量的用户名分配，免费发行，无需与存储成本相关的押金；
• 为每个发行的用户名支付押金（通常是相对于系统中的其他押金而言补贴的、减少的押金）。

用户可以拥有多个映射到相同AccountId的用户名，但是一个AccountId只能映射到一个用户名，称为"primary"。这个主用户名将是任何给定账户在UsernameOf映射中的查找结果。

接口

可调度函数

普通用户

• set_identity - 设置账户的关联身份；如果尚未占用，将保留一小笔押金。
• clear_identity - 移除账户的关联身份；押金将被退还。
• request_judgement - 请求注册商的判断，支付费用。
• cancel_request - 取消先前的判断请求。
• `accept_username》 - 接受用户名授权机构发行的用户名。
• remove_expired_approval - 移除已发行但未被接受的用户名。
• set_primary_username - 将给定用户名设置为账户的主用户名。
• remove_username - 在宽限期结束后移除用户名。

拥有子身份的用户

• set_subs - 设置身份的子账户。
• add_sub - 向身份添加子身份。
• remove_sub - 移除身份的子身份。
• rename_sub - 重命名身份的子身份。
• quit_sub - 移除身份的子身份（由子身份调用）。

注册商

• set_fee - 设置注册商给出判断所需的费用。
• set_fields - 设置注册商在其判断中关心的字段。
• `provide_judgement》 - 向身份提供判断。

用户名授权机构

• set_username_for - 为给定账户设置用户名。账户必须批准它。
• `unbind_username》 - 开始用户名的宽限期。

超级用户

• `add_registrar》 - 向系统添加新的注册商。
• `kill_identity》 - 强制移除关联身份；押金将丢失。
• `add_username_authority》 - 添加具有发行用户名权限的账户。
• `remove_username_authority》 - 移除具有发行用户名权限的账户。
• `kill_username》 - 强制移除用户名。

许可证：Apache-2.0

完整示例代码

// 导入必要的依赖
use frame_support::{decl_module, decl_event, decl_storage, dispatch::DispatchResult};
use frame_system::{self as system, ensure_signed};
use sp_std::prelude::*;

// 定义模块配置
pub trait Config: system::Config {
    type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;
}

// 定义存储项
decl_storage! {
    trait Store for Module<T: Config> as Identity {
        /// 账户身份信息映射
        IdentityOf get(fn identity_of): map hasher(blake2_128_concat) T::AccountId => Option<IdentityInfo>;
        /// 用户名到账户的映射
        UsernameOf get(fn username_of): map hasher(blake2_128_concat) Vec<u8> => Option<T::AccountId>;
    }
}

// 定义事件
decl_event!(
    pub enum Event<T> where AccountId = <T as system::Config>::AccountId {
        /// 身份设置事件
        IdentitySet(AccountId),
        /// 用户名设置事件
        UsernameSet(AccountId, Vec<u8>),
    }
);

// 定义模块
decl_module! {
    pub struct Module<T: Config> for enum Call where origin: T::Origin {
        fn deposit_event() = default;

        /// 设置账户身份信息
        #[weight = 10_000]
        pub fn set_identity(origin, info: IdentityInfo) -> DispatchResult {
            let who = ensure_signed(origin)?;
            
            <IdentityOf<T>>::insert(&who, info);
            
            Self::deposit_event(RawEvent::IdentitySet(who));
            Ok(())
        }

        /// 设置用户名
        #[weight = 10_000]
        pub fn set_username(origin, username: Vec<u8>) -> DispatchResult {
            let who = ensure_signed(origin)?;
            
            // 检查用户名是否已被占用
            ensure!(<UsernameOf<T>>::get(&username).is_none(), "Username already taken");
            
            // 插入新用户名
            <UsernameOf<T>>::insert(&username, who.clone());
            
            Self::deposit_event(RawEvent::UsernameSet(who, username));
            Ok(())
        }
    }
}

// 身份信息结构体
#[derive(Encode, Decode, Clone, Default, RuntimeDebug, PartialEq)]
pub struct IdentityInfo {
    pub display_name: Vec<u8>,
    pub email: Vec<u8>,
    pub website: Vec<u8>,
    pub twitter: Vec<u8>,
}

// 测试模块
#[cfg(test)]
mod tests {
    use super::*;
    use frame_support::{assert_ok, assert_noop};
    use sp_core::H256;
    use frame_system::{self as system, RawOrigin};
    use sp_runtime::{
        testing::Header,
        traits::{BlakeTwo256, IdentityLookup},
        DispatchError,
    };

    // 测试运行时配置
    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::{Module, Call, Config, Storage, Event<T>},
            Identity: Module,
        }
    );

    impl Config for Test {
        type Event = Event;
    }

    impl system::Config for Test {
        type BaseCallFilter = ();
        type BlockWeights = ();
        type BlockLength = ();
        type Origin = Origin;
        type Call = Call;
        type Index = u64;
        type BlockNumber = u64;
        type Hash = H256;
        type Hashing = BlakeTwo256;
        type AccountId = u64;
        type Lookup = IdentityLookup<Self::AccountId>;
        type Header = Header;
        type Event = Event;
        type BlockHashCount = ();
        type DbWeight = ();
        type Version = ();
        type PalletInfo = PalletInfo;
        type AccountData = ();
        type OnNewAccount = ();
        type OnKilledAccount = ();
        type SystemWeightInfo = ();
        type SS58Prefix = ();
    }

    // 测试设置身份信息
    #[test]
    fn test_set_identity() {
        new_test_ext().execute_with(|| {
            let alice = 1;
            let info = IdentityInfo {
                display_name: b"Alice".to_vec(),
                email: b"alice@example.com".to_vec(),
                website: b"alice.example.com".to_vec(),
                twitter: b"@alice".to_vec(),
            };
            
            // 设置身份信息
            assert_ok!(Identity::set_identity(Origin::signed(alice), info.clone()));
            
            // 验证存储
            assert_eq!(Identity::identity_of(alice), Some(info));
            
            // 验证事件
            let event = System::events().pop().expect("Expected an event").event;
            assert_eq!(
                event,
                Event::Identity(Event::IdentitySet(alice))
            );
        });
    }

    // 测试设置用户名
    #[test]
    fn test_set_username() {
        new_test_ext().execute_with(|| {
            let alice = 1;
            let username = b"alice".to_vec();
            
            // 设置用户名
            assert_ok!(Identity::set_username(Origin::signed(alice), username.clone()));
            
            // 验证存储
            assert_eq!(Identity::username_of(username.clone()), Some(alice));
            
            // 验证事件
            let event = System::events().pop(). expect("Expected an event").event;
            assert_eq!(
                event,
                Event::Identity(Event::UsernameSet(alice, username))
            );
            
            // 测试用户名冲突
            let bob = 2;
            assert_noop!(
                Identity::set_username(Origin::signed(bob), username),
                "Username already taken"
            );
        });
    }
}