Rust（Solana / Anchor）

Anchor 0.30+ · Rust 1.79+

Solana / SVM

无状态程序 + 账户显式传入，性能极高但心智模型与 EVM 完全不同

Solana 程序本身不存储状态，所有状态放在调用方显式传入的账户里。因此「账户列表」就是参数列表的一部分，账户约束（ownership、签名、地址、PDA）必须在代码里显式校验。Anchor 框架用宏把这些约束写成声明式注解，是当前的主流开发方式。

3 个语法章节3 段可复制代码含在线练习

从 Solidity 视角看差异

如果已经会 Solidity，这张表比从头读语法快得多。

差异点	说明
状态位置	EVM 是「合约里存状态」，Solana 是「账户里存状态，程序只负责读写」。
账户模型	每个账户有 owner 程序，只有 owner 能改它的 data 与 lamports；跨程序写别人的账户会被直接拒绝。
指令与交易	一笔交易可包含多条指令，指令之间通过账户读写隐式传递状态，没有跨程序调用栈的 storage 概念。
PDA	程序派生地址（PDA）让程序能「签自己的名」来拥有账户，是 Solana 版「合约内转账」的实现方式。

程序结构与账户约束

1 段代码

Anchor 用 #[derive(Accounts)] 描述指令需要哪些账户，以及每个账户必须满足什么条件。

mut 表示会被修改（可写），缺省是只读；漏写 mut 会直接报 constraint 错误
has_one / seeds / constraint 在反序列化前就完成校验，是防错的第一道闸门
payer 用于创建账户时支付租金（rent）
Signer<'info> 表示该账户必须签名，Missing 签名是链上最常见的失败原因

Anchor 指令与账户校验

Anchor 指令与账户校验Rust

use anchor_lang::prelude::*;

declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");

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

    pub fn initialize(ctx: Context<Initialize>, start: u64) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        counter.authority = ctx.accounts.authority.key();
        counter.value = start;
        counter.bump = ctx.bumps.counter;
        Ok(())
    }

    pub fn increment(ctx: Context<Increment>) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        counter.value = counter.value.checked_add(1).ok_or(ErrorCode::Overflow)?;
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(
        init,
        payer = authority,
        space = 8 + Counter::LEN,
        seeds = [b"counter", authority.key().as_ref()],
        bump
    )]
    pub counter: Account<'info, Counter>,
    #[account(mut)]
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct Increment<'info> {
    #[account(
        mut,
        has_one = authority,
        seeds = [b"counter", authority.key().as_ref()],
        bump = counter.bump
    )]
    pub counter: Account<'info, Counter>,
    pub authority: Signer<'info>,
}

#[account]
pub struct Counter {
    pub authority: Pubkey,
    pub value: u64,
    pub bump: u8,
}

impl Counter {
    // 8 字节 discriminator + 32 + 8 + 1
    pub const LEN: usize = 32 + 8 + 1;
}

#[error_code]
pub enum ErrorCode {
    #[msg("counter overflow")]
    Overflow,
}

space = 8 + 数据长度：前 8 字节是 Anchor 的类型判别符，漏算会导致反序列化失败。

PDA 与 CPI

1 段代码

PDA 由 seeds + program_id 派生，程序可以「用 PDA 身份」转账或调用其他程序。

PDA 不在椭圆曲线上，所以没有私钥，只能由派生它的程序签名
seeds 顺序与内容都必须完全一致，否则派生出不同地址
CPI（跨程序调用）通过 invoke / invoke_signed 完成，后者用于 PDA 签名
被调用的程序必须出现在指令的账户列表里，否则调用失败

PDA 签名转账

PDA 签名转账Rust

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

pub fn payout(ctx: Context<Payout>, amount: u64) -> Result<()> {
    let vault = &ctx.accounts.vault;

    // 用 PDA 的身份签名，把 lamports 从 vault 转给接收方
    let seeds: &[&[u8]] = &[b"vault", ctx.accounts.authority.key.as_ref(), &[vault.bump]];
    let signer = &[seeds];

    system_program::transfer(
        CpiContext::new_with_signer(
            ctx.accounts.system_program.to_account_info(),
            system_program::Transfer {
                from: vault.to_account_info(),
                to: ctx.accounts.receiver.to_account_info(),
            },
            signer,
        ),
        amount,
    )?;

    Ok(())
}

#[derive(Accounts)]
pub struct Payout<'info> {
    #[account(mut, seeds = [b"vault", authority.key().as_ref()], bump = vault.bump)]
    pub vault: Account<'info, Vault>,
    #[account(mut)]
    pub receiver: SystemAccount<'info>,
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[account]
pub struct Vault {
    pub bump: u8,
}

错误处理与溢出

1 段代码

Rust 的 Result 把「可能失败」写进类型签名，链上失败一律回滚整笔交易。

生产代码一律用 checked_add / checked_sub / checked_mul，禁止裸算术
require! / require_eq! 宏可以把断言写成一行
Err 返回即整笔交易回滚，指令之间不会留下部分成功
日志用 msg! 宏，会写进交易日志，可作为调试与索引数据源

Result、require 与日志

Result、require 与日志Rust

pub fn withdraw(ctx: Context<Withdraw>, amount: u64) -> Result<()> {
    let vault = &mut ctx.accounts.vault;

    require!(amount > 0, ErrorCode::ZeroAmount);
    require_gte!(vault.balance, amount, ErrorCode::Insufficient);

    vault.balance = vault
        .balance
        .checked_sub(amount)
        .ok_or(ErrorCode::Underflow)?;

    msg!("withdraw: amount={} remaining={}", amount, vault.balance);

    // 这里若返回 Err，上面的余额修改会一起回滚
    if amount > 1_000_000_000 {
        return Err(ErrorCode::TooLarge.into());
    }

    Ok(())
}

#[error_code]
pub enum ErrorCode {
    #[msg("amount must be greater than zero")]
    ZeroAmount,
    #[msg("insufficient balance")]
    Insufficient,
    #[msg("arithmetic underflow")]
    Underflow,
    #[msg("amount exceeds single-transaction cap")]
    TooLarge,
}

本章练习

这一段要让你看懂：Solana 的账户存储要预先付费（租金押金）：space 少写一个字节，账户会创建失败；写多了，多余的押金就永久躺在账户里。这就是 Anchor 里那句 space = 8 + Counter::LEN 的由来。

▶

试一试 · 算账户空间与租金押金

可直接改代码 · 在浏览器沙箱里真跑

playground.jsJavaScript

// Anchor 的账户布局：前 8 字节是类型判别符（discriminator）
const DISCRIMINATOR = 8;

const FIELD_SIZE = {
  u8: 1, u16: 2, u32: 4, u64: 8, u128: 16,
  i64: 8, bool: 1, pubkey: 32, u8x32: 32,
};

// 租金押金公式（Solana 的 rent-exempt）：(space + 128) * 6960 lamports
function rentExemptLamports(space) {
  return (space + 128) * 6960;
}

function accountSpace(fields) {
  const data = fields.reduce((n, f) => n + (FIELD_SIZE[f.type] ?? 0), 0);
  return { data, total: DISCRIMINATOR + data };
}

const accounts = [
  { name: '系统账户（0 字节数据，最低门槛）', fields: [] },
  { name: 'SPL Token 账户（标准 165 字节）', fields: [{ type: 'u8x32' }], override: 165 },
  {
    name: 'Anchor Counter（authority + value + bump）',
    fields: [{ type: 'pubkey' }, { type: 'u64' }, { type: 'u8' }],
  },
  {
    name: 'Anchor 带 metadata 的 Vault',
    fields: [
      { type: 'pubkey' },   // owner
      { type: 'u64' },      // amount
      { type: 'i64' },      // unlock_at
      { type: 'u8x32' },    // label 或 hash
      { type: 'u8' },       // bump
    ],
  },
];

console.log('账户'.padEnd(46), '数据', '总 space', '押金 (SOL)');
console.log('─'.repeat(84));

for (const a of accounts) {
  const space = a.override ?? accountSpace(a.fields).total;
  const lamports = rentExemptLamports(space);
  console.log(
    a.name.padEnd(44),
    String(a.override ?? accountSpace(a.fields).data).padStart(4),
    String(space).padStart(7),
    (lamports / 1e9).toFixed(8).padStart(13)
  );
}

console.log('\n校验一下：0 字节数据的账户押金 = 0.00089088 SOL，这是 Solana 上开任何账户的地板价。');
console.log('Anchor 里的 space = 8 + Counter::LEN，那个 8 就是上面的 discriminator。');
console.log('space 写小了 = 创建失败；写大了 = 多余押金锁在里面拿不回来。');

运行环境：iframe 沙箱（无 cookie 权限）。只支持纯 JS 片段，不支持 import / require；需要模块请用下方的完整示例复制到项目里。

检查点（跑完后逐条核对）

0 字节账户的押金约为 0.00089088 SOL
SPL Token 账户（165 字节）的押金约为 0.00203928 SOL
Anchor Counter 的数据区 41 字节，总 space 49（含 8 字节判别符）
带 metadata 的 Vault 数据区 81 字节，总 space 89

切换其他语言

Solidity Vyper Move Cairo 标准查询（EIPs）