Rust NEAR协议沙盒工具库near-sandbox-utils的使用，为区块链测试提供本地开发环境模拟

Rust NEAR协议沙盒工具库near-sandbox-utils的使用，为区块链测试提供本地开发环境模拟

安装

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

cargo add near-sandbox-utils

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

near-sandbox-utils = "0.15.0"

基本使用示例

near-sandbox-utils提供了一个本地沙盒环境，用于测试NEAR区块链应用程序。下面是一个基本的使用示例：

use near_sandbox_utils::Sandbox;
use near_workspaces::types::NearToken;

#[tokio::test]
async fn test_contract_deployment() -> anyhow::Result<()> {
    // 初始化沙盒环境
    let sandbox = Sandbox::new().await?;
    
    // 创建一个测试账户
    let account = sandbox.create_account("test_account").await?;
    
    // 部署合约
    let contract = account
        .deploy(&std::fs::read("res/contract.wasm")?)
        .await?;
    
    // 调用合约方法
    let result = contract
        .call("some_method")
        .args_json(serde_json::json!({}))?
        .max_gas()
        .deposit(NearToken::from_near(1))
        .transact()
        .await?;
    
    // 验证结果
    assert!(result.is_success());
    
    Ok(())
}

完整示例

以下是一个更完整的示例，展示了如何使用near-sandbox-utils进行合约测试：

use near_sandbox_utils::Sandbox;
use near_workspaces::types::NearToken;
use serde_json::json;

#[tokio::test]
async fn test_counter_contract() -> anyhow::Result<()> {
    // 1. 初始化沙盒环境
    let sandbox = Sandbox::new().await?;
    
    // 2. 创建测试账户
    let owner = sandbox.create_account("owner").await?;
    let alice = sandbox.create_account("alice").await?;
    let bob = sandbox.create_account("bob").await?;
    
    // 3. 部署合约
    let contract = owner
        .deploy(&std::fs::read("res/counter.wasm")?)
        .await?;
    
    // 4. 初始化合约
    let init_result = contract
        .call("init")
        .args_json(json!({ "initial_value": 42 }))?
        .transact()
        .await?;
    assert!(init_result.is_success());
    
    // 5. 测试增加计数器
    let inc_result = alice
        .call(contract.id(), "increment")
        .args_json(json!({ "value": 10 }))?
        .transact()
        .await?;
    assert!(inc_result.is_success());
    
    // 6. 验证计数器值
    let get_result: i32 = contract
        .view("get_counter")
        .args_json(json!({}))?
        .await?
        .json()?;
    assert_eq!(get_result, 52);
    
    // 7. 测试权限控制
    let unauthorized_result = bob
        .call(contract.id(), "reset")
        .args_json(json!({}))?
        .transact()
        .await?;
    assert!(!unauthorized_result.is_success());
    
    Ok(())
}

主要功能

  1. 本地沙盒环境：提供与NEAR主网/测试网兼容的本地测试环境
  2. 账户管理：轻松创建测试账户
  3. 合约部署：支持从wasm文件部署合约
  4. 交易模拟：模拟合约调用和视图方法调用
  5. 状态验证：验证合约状态变化

注意事项

  1. 需要安装NEAR Sandbox二进制文件
  2. 测试需要异步运行时（如tokio）
  3. 适用于单元测试和集成测试场景

文档

更多详细使用方法和API参考，请查看官方文档。


1 回复

Rust NEAR协议沙盒工具库near-sandbox-utils的使用指南

near-sandbox-utils是一个为NEAR区块链协议开发的本地测试工具库，它允许开发者在本地环境中模拟NEAR区块链的行为，方便进行智能合约的测试和开发。

主要功能

  • 提供本地NEAR区块链沙盒环境
  • 支持合约部署和调用
  • 模拟账户创建和交易
  • 提供测试断言工具
  • 支持状态查询和修改

安装方法

在Cargo.toml中添加依赖：

[dependencies]
near-sandbox-utils = "0.1.0"

基本使用方法

1. 初始化沙盒环境

use near_sandbox_utils::{SandboxEnvironment, AccountId};

#[tokio::test]
async fn test_basic_contract() -> anyhow::Result<()> {
    // 创建沙盒环境
    let sandbox = SandboxEnvironment::new().await?;
    
    // 获取根账户
    let root_account = sandbox.root_account()?;
    
    Ok(())
}

2. 创建测试账户

let test_account = root_account
    .create_sub_account("test".parse()?)
    .initial_balance(10_000_000_000_000_000_000) // 10 NEAR
    .transact()
    .await?;

3. 部署和调用合约

// 部署合约
let contract = test_account
    .deploy(include_bytes!("../res/hello_near.wasm"))
    .transact()
    .await?;

// 调用合约方法
let result: String = contract
    .call("greet")
    .args_json(serde_json::json!({"name": "Alice"}))?
    .transact()
    .await?
    .json()?;

assert_eq!(result, "Hello, Alice!");

4. 查询状态

let balance = sandbox.view_account_balance(&test_account.id()).await?;
println!("Account balance: {}", balance);

高级用法

1. 设置区块时间

use near_sandbox_utils::time::Duration;

// 前进10个区块
sandbox.fast_forward(Duration::seconds(10)).await?;

2. 模拟交易失败

use near_sandbox_utils::errors::ExecutionError;

let result = contract
    .call("fail_method")
    .transact()
    .await;

assert!(matches!(result, Err(ExecutionError::ExecutionError(_))));

3. 使用测试断言

use near_sandbox_utils::assertions::*;

assert_balance_eq(&sandbox, &test_account.id(), 10_000_000_000_000_000_000).await?;
assert_contract_code_hash(&sandbox, &contract.id(), expected_hash).await?;

完整示例

use near_sandbox_utils::{SandboxEnvironment, AccountId};
use serde_json::json;

#[tokio::test]
async fn test_counter_contract() -> anyhow::Result<()> {
    // 1. 初始化沙盒
    let sandbox = SandboxEnvironment::new().await?;
    let root = sandbox.root_account()?;
    
    // 2. 创建测试账户
    let alice = root
        .create_sub_account("alice".parse()?)
        .initial_balance(10_000_000_000_000_000_000)
        .transact()
        .await?;
    
    // 3. 部署计数器合约
    let contract = alice
        .deploy(include_bytes!("../res/counter.wasm"))
        .transact()
        .await?;
    
    // 4. 调用合约方法
    let initial: i32 = contract
        .call("get_count")
        .transact()
        .await?
        .json()?;
    assert_eq!(initial, 0);
    
    // 5. 修改状态
    contract
        .call("increment")
        .transact()
        .await?;
    
    // 6. 验证状态变化
    let updated: i32 = contract
        .call("get_count")
        .transact()
        .await?
        .json()?;
    assert_eq!(updated, 1);
    
    Ok(())
}

注意事项

  1. 需要安装NEAR CLI工具链作为前置依赖
  2. 测试运行时会自动启动本地沙盒节点
  3. 每个测试用例运行在独立的环境中
  4. 适合用于单元测试和集成测试

通过near-sandbox-utils，开发者可以方便地在本地环境中测试NEAR智能合约，而无需连接到测试网或主网，大大提高了开发效率。

回到顶部