本教程将介绍 Solana Anchor 程序在交易中转移 SOL 的机制。

与 Ethereum（以太坊）不同，在 Ethereum 中，钱包将 msg.value 指定为交易的一部分并将 ETH “推（push）”给合约，而 Solana 程序则是从钱包中“拉（pull）”取 SOL。

因此，这里不存在 “payable” 函数或 “msg.value” 这样的概念。

在下方，我们创建了一个名为 sol_splitter 的新 Anchor 项目，并编写了用于将 SOL 从发送方转移到接收方的 Rust 代码。

当然，如果发送方直接发送 SOL 而不是通过程序来进行，效率会更高，但我们只是想演示一下它是如何实现的：

Copy
use anchor_lang::prelude::*;
use anchor_lang::system_program;

declare_id!("9qnGx9FgLensJQy1hSB4b8TaRae6oWuNDveUrxoYatr7");

#[program]
pub mod sol_splitter {
    use super::*;

    pub fn send_sol(ctx: Context<SendSol>, amount: u64) -> Result<()> {

        let cpi_context = CpiContext::new(
            ctx.accounts.system_program.to_account_info(), 

            system_program::Transfer {
                from: ctx.accounts.signer.to_account_info(),
                to: ctx.accounts.recipient.to_account_info(),
            }
        );

        let res = system_program::transfer(cpi_context, amount);

        if res.is_ok() {
            return Ok(());
        } else {
            return err!(Errors::TransferFailed);
        }
    }
}

#[error_code]
pub enum Errors {
    #[msg("transfer failed")]
    TransferFailed,
}

#[derive(Accounts)]
pub struct SendSol<'info> {
    /// CHECK: we do not read or write the data of this account
    #[account(mut)]
    recipient: UncheckedAccount<'info>,
    
    system_program: Program<'info, System>,

    #[account(mut)]
    signer: Signer<'info>,
}

这里有很多内容需要解释。

介绍 CPI：跨程序调用 (Cross Program Invocation)

在 Ethereum 中，转移 ETH 只需要在 msg.value 字段中指定一个值即可。而在 Solana 中，由一个名为 system program 的内置程序负责将 SOL 从一个账户转移到另一个账户。这就是为什么当我们在初始化账户并支付初始化费用时，它总是会频繁出现的原因。

你可以粗略地将 system program 视为 Ethereum 中的预编译合约。想象它的行为有点类似于内置于协议中并作为原生货币使用的 ERC-20 代币。而且它有一个名为 transfer 的公开函数。

CPI 交易的 Context

每当调用 Solana 程序函数时，都必须提供一个 Context。该 Context 包含了程序将要交互的所有账户。

调用 system program 也不例外。system program 需要一个包含 from 和 to 账户的 Context。转移的 amount 则是作为“常规”参数传递的——它不是 Context 的一部分（因为 “amount” 不是一个账户，它只是一个值）。

我们现在可以解释下面的代码片段了：

我们正在构建一个新的 CpiContext，其第一个参数包含了我们将要调用的程序（绿框），并且包含了将作为该交易一部分的账户（黄框）。这里没有提供 amount 参数，因为 amount 不是一个账户。

既然我们已经构建了 cpi_context，我们就可以对 system program 进行跨程序调用（橙框），同时指定金额。

这会返回一个 Result<()> 类型，就像我们 Anchor 程序中的公开函数所做的那样。

不要忽略跨程序调用的返回值

要检查跨程序调用是否成功，我们只需检查返回值是否为 Ok。Rust 的 is_ok() 方法让这一切变得非常简单：

Copy
        let res = system_program::transfer(cpi_context, amount);

        if res.is_ok() {
            return Ok(());
        } else {
            return err!(Errors::TransferFailed);
        }
    }
}

#[error_code]
pub enum Errors {
    #[msg("transfer failed")]
    TransferFailed,
}

只有签名者可以作为 “from”

如果你在调用 system program 时，from 账户不是一个 Signer，那么 system program 将拒绝该调用。没有签名，system program 就无法知道你是否授权了这次调用。

Typescript 代码：

Copy
import * as anchor from "@coral-xyz/anchor";
import { Program } from "@coral-xyz/anchor";
import { SolSplitter } from "../target/types/sol_splitter";

describe("sol_splitter", () => {
  // Configure the client to use the local cluster.
  anchor.setProvider(anchor.AnchorProvider.env());

  const program = anchor.workspace.SolSplitter as Program<SolSplitter>;

  async function printAccountBalance(account) {
    const balance = await anchor.getProvider().connection.getBalance(account);
    console.log(`${account} has ${balance / anchor.web3.LAMPORTS_PER_SOL} SOL`);
  }

  it("Transmit SOL", async () => {
    // generate a new wallet
    const recipient = anchor.web3.Keypair.generate();

    await printAccountBalance(recipient.publicKey);

    // send the account 1 SOL via the program
    let amount = new anchor.BN(1 * anchor.web3.LAMPORTS_PER_SOL);
    await program.methods.sendSol(amount)
      .accounts({recipient: recipient.publicKey})
      .rpc();

    await printAccountBalance(recipient.publicKey);
  });
});

需要注意的几点：

• 我们创建了一个辅助函数 printAccountBalance 来显示转移前后的余额
• 我们使用 anchor.web3.Keypair.generate() 生成了接收方钱包
• 我们向新账户转移了 1 个 SOL

当我们运行代码时，预期结果如下。打印语句显示的是接收方地址在转移前后的余额：

练习：构建一个 Solana 程序，将传入的 SOL 均匀分配给两个接收方。你无法通过函数参数来实现这一点，这些账户需要放在 Context 结构体中。

构建支付拆分器：通过 remaining_accounts 使用任意数量的账户

我们可以看到，如果想将 SOL 分配给几个不同的账户，必须像下面这样去指定 Context 结构体会显得相当笨拙：

Copy
#[derive(Accounts)]
pub struct SendSol<'info> {
    /// CHECK: we do not read or write the data of this account
    #[account(mut)]
    recipient1: UncheckedAccount<'info>,

    /// CHECK: we do not read or write the data of this account
    #[account(mut)]
    recipient2: UncheckedAccount<'info>,

    /// CHECK: we do not read or write the data of this account
    #[account(mut)]
    recipient3: UncheckedAccount<'info>,

    // ...

    /// CHECK: we do not read or write the data of this account
    #[account(mut)]
    recipientn: UncheckedAccount<'info>,
    
    system_program: Program<'info, System>,

    #[account(mut)]
    signer: Signer<'info>,
}

为了解决这个问题，Anchor 在 Context 结构体中添加了一个 remaining_accounts 字段。

下面的代码演示了如何使用该特性：

Copy
use anchor_lang::prelude::*;
use anchor_lang::system_program;

declare_id!("9qnGx9FgLensJQy1hSB4b8TaRae6oWuNDveUrxoYatr7");

#[program]
pub mod sol_splitter {
    use super::*;

    // 'a, 'b, 'c are Rust lifetimes, ignore them for now
    pub fn split_sol<'a, 'b, 'c, 'info>(
        ctx: Context<'a, 'b, 'c, 'info, SplitSol<'info>>,
        amount: u64,
    ) -> Result<()> {

        let amount_each_gets = amount / ctx.remaining_accounts.len() as u64;
        let system_program = &ctx.accounts.system_program;

        // note the keyword `remaining_accounts`
        for recipient in ctx.remaining_accounts {
            let cpi_accounts = system_program::Transfer {
                from: ctx.accounts.signer.to_account_info(),
                to: recipient.to_account_info(),
            };
            let cpi_program = system_program.to_account_info();
            let cpi_context = CpiContext::new(cpi_program, cpi_accounts);

            let res = system_program::transfer(cpi_context, amount_each_gets);
            if !res.is_ok() {
                return err!(Errors::TransferFailed);
            }
        }

        Ok(())
    }
}

#[error_code]
pub enum Errors {
    #[msg("transfer failed")]
    TransferFailed,
}

#[derive(Accounts)]
pub struct SplitSol<'info> {
    #[account(mut)]
    signer: Signer<'info>,
    system_program: Program<'info, System>,
}

下面是 Typescript 代码：

Copy
import * as anchor from "@coral-xyz/anchor";
import { Program } from "@coral-xyz/anchor";
import { SolSplitter } from "../target/types/sol_splitter";

describe("sol_splitter", () => {
  // Configure the client to use the local cluster.
  anchor.setProvider(anchor.AnchorProvider.env());

  const program = anchor.workspace.SolSplitter as Program<SolSplitter>;

  async function printAccountBalance(account) {
    const balance = await anchor.getProvider().connection.getBalance(account);
    console.log(`${account} has ${balance / anchor.web3.LAMPORTS_PER_SOL} SOL`);
  }

  it("Split SOL", async () => {
    const recipient1 = anchor.web3.Keypair.generate();
    const recipient2 = anchor.web3.Keypair.generate();
    const recipient3 = anchor.web3.Keypair.generate();

    await printAccountBalance(recipient1.publicKey);
    await printAccountBalance(recipient2.publicKey);
    await printAccountBalance(recipient3.publicKey);

    const accountMeta1 = {pubkey: recipient1.publicKey, isWritable: true, isSigner: false};
    const accountMeta2 = {pubkey: recipient2.publicKey, isWritable: true, isSigner: false};
    const accountMeta3 = {pubkey: recipient3.publicKey, isWritable: true, isSigner: false};

    let amount = new anchor.BN(1 * anchor.web3.LAMPORTS_PER_SOL);
    await program.methods.splitSol(amount)
      .remainingAccounts([accountMeta1, accountMeta2, accountMeta3])
      .rpc();

    await printAccountBalance(recipient1.publicKey);
    await printAccountBalance(recipient2.publicKey);
    await printAccountBalance(recipient3.publicKey);
  });
});

运行测试将显示前后的余额：

以下是有关该 Rust 代码的一些注释说明：

Rust 生命周期 (Rust Lifetimes)

在 split_sol 的函数声明中，引入了一些奇怪的语法：

Copy
pub fn split_sol<'a, 'b, 'c, 'info>(
    ctx: Context<'a, 'b, 'c, 'info, SplitSol<'info>>,
    amount: u64,
) -> Result<()>

其中 'a、'b 和 'c 是 Rust 的生命周期（Lifetimes）。Rust 生命周期是一个复杂的话题，我们目前暂且跳过。但在宏观层面上解释，Rust 代码需要确保传递到 for recipient in ctx.remaining_accounts 循环中的资源在整个循环期间都将一直存在。

ctx.remaining_accounts

代码通过 for recipient in ctx.remaining_accounts 进行了循环遍历。remaining_accounts 关键字是 Anchor 机制的一部分，用于传入任意数量的账户，而无需在 Context 结构体中创建大量的键（keys）。

在 Typescript 测试中，我们可以像这样将 remaining_accounts 添加到交易中：

Copy
await program.methods.splitSol(amount)
  .remainingAccounts([accountMeta1, accountMeta2, accountMeta3])
  .rpc();

通过 RareSkills 了解更多

请查阅我们的 Solana 课程 以获取其余的 Solana 教程。

原文发布于 2024 年 3 月 2 日