Solana 中的 SOL 转移与分割：取代 msg.value 的设计

0xE
发布于 1天前
阅读 222

本文介绍 Solana Anchor 程序如何通过交易转移 SOL。

本文介绍 Solana Anchor 程序如何通过交易转移 SOL。不同于 Solidity 的 msg.value 将 ETH “推送”至合约，Solana 程序通过跨程序调用（CPI）从签名者账户“拉取” SOL。因此，Solana 无 payable 函数和 msg.value 类似的内容。

我们将创建 sol_splitter 项目，展示单账户转账及多账户分割的实现。

---

## **单账户 SOL 转移**

### **Rust 实现**

以下代码将 SOL 从签名者转移至单一接收者：

```rust
use anchor_lang::prelude::*;
use anchor_lang::system_program;

declare_id!("DoDAytTn6aFcUjS3hxLGs5CgaHyMvwGaZeQnLNA6bpiY");

#[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>,
}
```

### **关键点解析**

1. **CPI 机制**：
    - Solana 使用内置 SystemProgram 执行 SOL 转移，类似以太坊的预编译合约。
    - system_program::transfer 是其核心函数。
2. **上下文构建**：
    - CpiContext 指定调用目标（system_program）及账户（from 和 to）。
    - amount 作为参数传递，因其非账户。
3. **签名者要求**：
    - from 必须是 Signer，否则 SystemProgram 拒绝调用，确保转账授权。
4. **错误处理**：
    - 使用 ? 操作符简化 Result 检查，失败时返回 TransferFailed。

### **Typescript 测试**

```jsx
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);
  });
});
```

**输出**：

```
  sol_splitter
4e9F7AWMNwyMPZCycs2NU8MLRY6xHa6QbkQ2z33sqLq7 has 0 SOL
4e9F7AWMNwyMPZCycs2NU8MLRY6xHa6QbkQ2z33sqLq7 has 1 SOL
    ✔ Transmit SOL (415ms)
```

---

## **构建 SOL 分割器**

### **Rust 实现**

以下代码将 SOL 均分至多个接收者，使用 remaining_accounts 处理动态账户列表：

```rust
use anchor_lang::prelude::*;
use anchor_lang::system_program;

declare_id!("DoDAytTn6aFcUjS3hxLGs5CgaHyMvwGaZeQnLNA6bpiY");

#[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>,
}
```

### **关键点解析**

1. **remaining_accounts**：
    - Anchor 的 Context 支持 remaining_accounts，允许动态指定接收者，避免硬编码多个账户。
    - 通过循环遍历实现均分。
2. **分割逻辑**：
    - per_amount 计算每份金额，整数除法截断余数。
    - 建议实际应用中检查 len() > 0 避免除零。
3. **生命周期**：
    - 函数签名中的 'a, 'b, 'c 是 Rust 生命周期，确保 remaining_accounts 在循环中有效，初学者可暂不深究。

### **Typescript 测试**

```jsx
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>;

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);

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);
  });
});
```

**输出**：

```
  sol_splitter
CqjE9cxeJLp1PQzUGYtd5KvpxzW3TmibnpSSjZHk7Nnz has 0 SOL
9kUdPQTfNN3SMoiiBTDB1HMvGCvNQZKCUcj8iSuZGr4H has 0 SOL
nToQAPSdMcQabZ5XNcBaGCrJ1H62YeoD17o28Yc8Fo4 has 0 SOL
CqjE9cxeJLp1PQzUGYtd5KvpxzW3TmibnpSSjZHk7Nnz has 0.333333333 SOL
9kUdPQTfNN3SMoiiBTDB1HMvGCvNQZKCUcj8iSuZGr4H has 0.333333333 SOL
nToQAPSdMcQabZ5XNcBaGCrJ1H62YeoD17o28Yc8Fo4 has 0.333333333 SOL
    ✔ Split SOL (606ms)
```

---

### **与 Solidity 的对比**

- **Solidity**：msg.value 随交易推送 ETH，合约被动接收。
- **Solana**：程序通过 SystemProgram 主动拉取 SOL，需显式指定账户。
- **效率**：Solidity 无 CPI 开销，Solana 稍复杂但更灵活。

---    
【笔记配套代码】
 https://github.com/0xE1337/rareskills_evm_to_solana
【参考资料】
 https://learnblockchain.cn/column/119
 https://www.rareskills.io/solana-tutorial

我们将创建 sol_splitter 项目，展示单账户转账及多账户分割的实现。

单账户 SOL 转移

Rust 实现

以下代码将 SOL 从签名者转移至单一接收者：

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

declare_id!("DoDAytTn6aFcUjS3hxLGs5CgaHyMvwGaZeQnLNA6bpiY");

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

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

        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&lt;'info> {
    /// CHECK: we do not read or write the data of this account
    #[account(mut)]
    recipient: UncheckedAccount&lt;'info>,

    system_program: Program&lt;'info, System>,

    #[account(mut)]
    signer: Signer&lt;'info>,
}

关键点解析

CPI 机制：
- Solana 使用内置 SystemProgram 执行 SOL 转移，类似以太坊的预编译合约。
- system_program::transfer 是其核心函数。
上下文构建：
- CpiContext 指定调用目标（system_program）及账户（from 和 to）。
- amount 作为参数传递，因其非账户。
签名者要求：
- from 必须是 Signer，否则 SystemProgram 拒绝调用，确保转账授权。
错误处理：
- 使用 ? 操作符简化 Result 检查，失败时返回 TransferFailed。

Typescript 测试

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&lt;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);
  });
});

输出：

  sol_splitter
4e9F7AWMNwyMPZCycs2NU8MLRY6xHa6QbkQ2z33sqLq7 has 0 SOL
4e9F7AWMNwyMPZCycs2NU8MLRY6xHa6QbkQ2z33sqLq7 has 1 SOL
    ✔ Transmit SOL (415ms)

构建 SOL 分割器

Rust 实现

以下代码将 SOL 均分至多个接收者，使用 remaining_accounts 处理动态账户列表：

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

declare_id!("DoDAytTn6aFcUjS3hxLGs5CgaHyMvwGaZeQnLNA6bpiY");

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

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

        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&lt;'info> {
    #[account(mut)]
    signer: Signer&lt;'info>,
    system_program: Program&lt;'info, System>,
}

关键点解析

remaining_accounts：
- Anchor 的 Context 支持 remaining_accounts，允许动态指定接收者，避免硬编码多个账户。
- 通过循环遍历实现均分。
分割逻辑：
- per_amount 计算每份金额，整数除法截断余数。
- 建议实际应用中检查 len() > 0 避免除零。
生命周期：
- 函数签名中的 'a, 'b, 'c 是 Rust 生命周期，确保 remaining_accounts 在循环中有效，初学者可暂不深究。

Typescript 测试

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&lt;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);
  });
});

输出：

  sol_splitter
CqjE9cxeJLp1PQzUGYtd5KvpxzW3TmibnpSSjZHk7Nnz has 0 SOL
9kUdPQTfNN3SMoiiBTDB1HMvGCvNQZKCUcj8iSuZGr4H has 0 SOL
nToQAPSdMcQabZ5XNcBaGCrJ1H62YeoD17o28Yc8Fo4 has 0 SOL
CqjE9cxeJLp1PQzUGYtd5KvpxzW3TmibnpSSjZHk7Nnz has 0.333333333 SOL
9kUdPQTfNN3SMoiiBTDB1HMvGCvNQZKCUcj8iSuZGr4H has 0.333333333 SOL
nToQAPSdMcQabZ5XNcBaGCrJ1H62YeoD17o28Yc8Fo4 has 0.333333333 SOL
    ✔ Split SOL (606ms)