Rust｜Anchor 中文文档

anchor-client crate 是用于与 Anchor 程序进行交互的 Rust 客户端库。你可以在这里找到源代码。

示例

下面的示例演示了如何使用 anchor-client crate 与一个简单的 Anchor 程序进行交互。程序客户端可以使用 declare_program! 宏从程序的 IDL 自动生成。该宏生成无依赖的模块，使您能够与程序的指令和账户进行交互。

该程序有两个指令：

initialize – 创建并初始化一个计数器账户以存储值
increment – 增加存储在计数器账户上的值

lib.rs

use anchor_lang::prelude::*;
 
declare_id!("6khKp4BeJpCjBY1Eh39ybiqbfRnrn2UzWeUARjQLXYRC");
 
#[program]
pub mod example {
    use super::*;
 
    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        let counter = &ctx.accounts.counter;
        msg!("计数器账户已创建！当前计数：{}", counter.count);
        Ok(())
    }
 
    pub fn increment(ctx: Context<Increment>) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        msg!("前一个计数器：{}", counter.count);
 
        counter.count += 1;
        msg!("计数器已增加！当前计数：{}", counter.count);
        Ok(())
    }
}
 
#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,
 
    #[account(
        init,
        payer = payer,
        space = 8 + 8
    )]
    pub counter: Account<'info, Counter>,
    pub system_program: Program<'info, System>,
}
 
#[derive(Accounts)]
pub struct Increment<'info> {
    #[account(mut)]
    pub counter: Account<'info, Counter>,
}
 
#[account]
pub struct Counter {
    pub count: u64,
}

下面是一个与 Anchor 程序交互的 Rust 客户端的示例文件夹结构：

example.json

main.rs

Cargo.toml

程序 IDL 必须在 /idls 文件夹中。declare_program! 宏会在 /idls 文件夹中查找 IDL，以生成客户端模块。

idls/example.json

{
  "address": "6khKp4BeJpCjBY1Eh39ybiqbfRnrn2UzWeUARjQLXYRC",
  "metadata": {
    "name": "example",
    "version": "0.1.0",
    "spec": "0.1.0",
    "description": "使用 Anchor 创建"
  },
  "instructions": [
    {
      "name": "increment",
      "discriminator": [11, 18, 104, 9, 104, 174, 59, 33],
      "accounts": [
        {
          "name": "counter",
          "writable": true
        }
      ],
      "args": []
    },
    {
      "name": "initialize",
      "discriminator": [175, 175, 109, 31, 13, 152, 155, 237],
      "accounts": [
        {
          "name": "payer",
          "writable": true,
          "signer": true
        },
        {
          "name": "counter",
          "writable": true,
          "signer": true
        },
        {
          "name": "system_program",
          "address": "11111111111111111111111111111111"
        }
      ],
      "args": []
    }
  ],
  "accounts": [
    {
      "name": "Counter",
      "discriminator": [255, 176, 4, 245, 188, 253, 124, 25]
    }
  ],
  "types": [
    {
      "name": "Counter",
      "type": {
        "kind": "struct",
        "fields": [
          {
            "name": "count",
            "type": "u64"
          }
        ]
      }
    }
  ]
}

下面是与程序交互的 src/main.rs 文件：

declare_program! 宏 - 使用 IDL 文件为程序生成客户端模块
anchor_client crate - 提供与程序交互的工具，包括：
- 构建程序指令
- 发送交易
- 获取程序账户

src/main.rs

use anchor_client::{
    solana_client::rpc_client::RpcClient,
    solana_sdk::{
        commitment_config::CommitmentConfig, native_token::LAMPORTS_PER_SOL, signature::Keypair,
        signer::Signer, system_program,
    },
    Client, Cluster,
};
use anchor_lang::prelude::*;
use std::rc::Rc;
 
declare_program!(example);
use example::{accounts::Counter, client::accounts, client::args};
 
#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let connection = RpcClient::new_with_commitment(
        "http://127.0.0.1:8899", // 本地验证者 URL
        CommitmentConfig::confirmed(),
    );
 
    // 生成密钥对并请求空投
    let payer = Keypair::new();
    let counter = Keypair::new();
    println!("生成的密钥对：");
    println!("   付款者: {}", payer.pubkey());
    println!("   计数器: {}", counter.pubkey());
 
    println!("\n请求空投 1 SOL 到付款者");
    let airdrop_signature = connection.request_airdrop(&payer.pubkey(), LAMPORTS_PER_SOL)?;
 
    // 等待空投确认
    while !connection.confirm_transaction(&airdrop_signature)? {
        std::thread::sleep(std::time::Duration::from_millis(100));
    }
    println!("   空投已确认！");
 
    // 创建程序客户端
    let provider = Client::new_with_options(
        Cluster::Localnet,
        Rc::new(payer),
        CommitmentConfig::confirmed(),
    );
    let program = provider.program(example::ID)?;
 
    // 构建并发送指令
    println!("\n发送交易，包含 initialize 和 increment 指令");
    let initialize_ix = program
        .request()
        .accounts(accounts::Initialize {
            counter: counter.pubkey(),
            payer: program.payer(),
            system_program: system_program::ID,
        })
        .args(args::Initialize)
        .instructions()?
        .remove(0);
 
    let increment_ix = program
        .request()
        .accounts(accounts::Increment {
            counter: counter.pubkey(),
        })
        .args(args::Increment)
        .instructions()?
        .remove(0);
 
    let signature = program
        .request()
        .instruction(initialize_ix)
        .instruction(increment_ix)
        .signer(&counter)
        .send()
        .await?;
    println!("   交易已确认：{}", signature);
 
    println!("\n获取计数器账户数据");
    let counter_account: Counter = program.account::<Counter>(counter.pubkey()).await?;
    println!("   计数器值：{}", counter_account.count);
    Ok(())
}

下面是 Cargo.toml 文件的依赖项：

Cargo.toml

[package]
name = "rs"
version = "0.1.0"
edition = "2021"
 
[dependencies]
anchor-client = { version = "0.30.1", features = ["async"] }
anchor-lang = "0.30.1"
anyhow = "1.0.93"
tokio = { version = "1.0", features = ["full"] }

Rust

示例

On this page