Rust NEAR协议代币库near-token的使用 - NEAR生态中代币创建与管理的Rust解决方案

概述

near-token是一个用于NEAR协议生态系统的Rust库，它简化了在NEAR区块链上创建和管理代币的过程。这个库为开发者提供了与NEAR代币标准(NEP-141)交互的工具，使得在Rust中实现代币功能变得更加容易。

主要功能

1. 代币创建和初始化
2. 代币转账功能
3. 余额查询
4. 元数据管理
5. 跨合约调用支持

完整示例代码

以下是基于near-token库创建完整代币合约的示例：

use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LazyOption;
use near_sdk::json_types::U128;
use near_sdk::{env, near_bindgen, AccountId, Balance, PanicOnDefault, Promise};
use near_token::Token;

// 代币元数据结构
#[derive(BorshDeserialize, BorshSerialize)]
pub struct TokenMetadata {
    pub spec: String,
    pub name: String,
    pub symbol: String,
    pub icon: Option<String>,
    pub reference: Option<String>,
    pub reference_hash: Option<[u8; 32]>,
    pub decimals: u8,
}

// 主合约结构
#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]
pub struct MyToken {
    token: Token,
    metadata: LazyOption<TokenMetadata>,
}

#[near_bindgen]
impl MyToken {
    // 初始化合约
    #[init]
    pub fn new(
        owner_id: AccountId,
        name: String,
        symbol: String,
        decimals: u8,
        icon: Option<String>,
        reference: Option<String>,
        reference_hash: Option<String>,
    ) -> Self {
        // 初始化代币
        let mut token = Token::new(
            name.clone(),
            symbol.clone(),
            decimals,
            owner_id.clone(),
        );
        
        // 设置初始元数据
        let metadata = TokenMetadata {
            spec: "nep-141".to_string(),
            name,
            symbol,
            icon,
            reference,
            reference_hash: reference_hash.map(|s| {
                let mut hash = [0u8; 32];
                hex::decode_to_slice(s, &mut hash).unwrap();
                hash
            }),
            decimals,
        };
        
        Self {
            token,
            metadata: LazyOption::new(b"m", Some(metadata)),
        }
    }

    // 转账功能
    pub fn transfer(&mut self, receiver_id: AccountId, amount: U128) {
        self.token.transfer(
            &env::predecessor_account_id(),
            &receiver_id,
            amount.into(),
        );
    }

    // 带消息的转账（用于跨合约调用）
    pub fn transfer_call(
        &mut self,
        receiver_id: AccountId,
        amount: U128,
        msg: String,
    ) -> Promise {
        self.token.transfer_call(
            &env::predecessor_account_id(),
            &receiver_id,
            amount.into(),
            msg,
        )
    }

    // 查询余额
    pub fn ft_balance_of(&self, account_id: AccountId) -> U128 {
        self.token.balance_of(&account_id).into()
    }

    // 铸造新代币（仅所有者可调用）
    pub fn mint(&mut self, account_id: AccountId, amount: U128) {
        assert_eq!(
            env::predecessor_account_id(),
            self.token.owner_id(),
            "Only owner can mint"
        );
        self.token.mint(&account_id, amount.into());
    }

    // 销毁代币
    pub fn burn(&mut self, amount: U128) {
        self.token.burn(&env::predecessor_account_id(), amount.into());
    }

    // 获取元数据
    pub fn ft_metadata(&self) -> TokenMetadata {
        self.metadata.get().unwrap()
    }

    // 更改所有者（仅当前所有者可调用）
    pub fn change_owner(&mut self, new_owner: AccountId) {
        assert_eq!(
            env::predecessor_account_id(),
            self.token.owner_id(),
            "Only owner can change owner"
        );
        self.token.change_owner(new_owner);
    }
}

// 实现NEP-141标准的方法
impl MyToken {
    pub fn ft_transfer(&mut self, receiver_id: AccountId, amount: U128, memo: Option<String>) {
        self.transfer(receiver_id, amount);
        if let Some(memo) = memo {
            env::log_str(&format!("Memo: {}", memo));
        }
    }

    pub fn ft_transfer_call(
        &mut self,
        receiver_id: AccountId,
        amount: U128,
        memo: Option<String>,
        msg: String,
    ) -> Promise {
        if let Some(memo) = memo {
            env::log_str(&format!("Memo: {}", memo));
        }
        self.transfer_call(receiver_id, amount, msg)
    }

    pub fn ft_total_supply(&self) -> U128 {
        self.token.total_supply().into()
    }
}

部署和测试

使用near-cli部署和测试合约：

# 编译合约
RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release

# 创建子账户
near create-account token.myaccount.testnet --masterAccount myaccount.testnet

# 部署合约
near deploy --wasmFile target/wasm32-unknown-unknown/release/my_token.wasm --accountId token.myaccount.testnet

# 初始化合约
near call token.myaccount.testnet new '{
  "owner_id": "myaccount.testnet",
  "name": "My Token",
  "symbol": "MTK",
  "decimals": 24,
  "icon": null,
  "reference": null,
  "reference_hash": null
}' --accountId myaccount.testnet

# 铸造代币
near call token.myaccount.testnet mint '{
  "account_id": "myaccount.testnet",
  "amount": "1000000"
}' --accountId myaccount.testnet

# 查询余额
near view token.myaccount.testnet ft_balance_of '{"account_id": "myaccount.testnet"}'

总结

这个完整示例展示了如何使用near-token库实现一个符合NEP-141标准的代币合约，包括：

• 代币创建和初始化
• 转账功能实现
• 余额查询
• 元数据管理
• 跨合约调用支持
• 权限控制

near-token库提供了构建NEAR生态代币所需的核心功能，开发者可以在此基础上进一步扩展业务逻辑。