Solana 运行时与账户模型

// 一笔 SPL Token 转账的指令构成
let ix = spl_token::instruction::transfer(
    &spl_token::id(),          // 程序 id
    &source_token_account,     // 读写的来源账户
    &destination_token_account,// 读写的目标账户
    &owner_authority,          // 签名者
    &[],                       // 多签额外签名者
    amount,
)?;

hash(seeds..., program_id, bump_seed) 落在曲线外

// 派生一个全局配置账户
let seeds = &[b"config".as_ref()];
let (config_pda, bump) = Pubkey::find_program_address(seeds, program_id);
// bump 必须持久化，否则每次验证都要重算

#[derive(Accounts)]
pub struct UpdateConfig<'info> {
    #[account(
        mut,
        seeds = [b"config"],
        bump = config.bump,     // 从账户数据里读取已存的 bump
    )]
    pub config: Account<'info, Config>,
    #[account(mut)]
    pub authority: Signer<'info>,
}

// 场景一：普通 CPI，签名者由外层交易提供
invoke(
    &token_instruction,
    &[source.clone(), mint.clone(), authority.clone(), token_program.clone()],
)?;

// 场景二：程序代表自己的 PDA 签名
let seeds = &[b"vault".as_ref(), &[vault_bump]];
invoke_signed(
    &transfer_ix,
    &[vault_token.clone(), dest_token.clone(), vault_pda.clone(), token_program.clone()],
    &[seeds],   // 用种子「冒充」PDA 的签名
)?;

// 创建并扩展一张查找表
let slot = connection.get_slot()?;
let (create_ix, table_address) = AddressLookupTableProgram::create_lookup_table(
    authority.pubkey(),
    authority.pubkey(),
    slot,
);
let extend_ix = AddressLookupTableProgram::extend_lookup_table(
    table_address,
    authority.pubkey(),
    vec![authority.pubkey()],
    &[token_program, system_program, associated_token_program],
);

// 组装版本化交易
let message = v0::Message::try_compile(
    &payer.pubkey(),
    &instructions,
    &[lookup_table_account],
    recent_blockhash,
)?;
let tx = VersionedTransaction::try_new(VersionedMessage::V0(message), &[payer])?;

let modify_ix = ComputeBudgetInstruction::set_compute_unit_limit(400_000);
let price_ix = ComputeBudgetInstruction::set_compute_unit_price(10_000); // 微 lamports/CU
tx.add(modify_ix).add(price_ix);

solana rent 165        # 一个 SPL Token 账户所需的最低 lamports
# 输出示例：0.00203928 SOL

#[account(mut, close = authority)]
pub temp_account: Account<'info, TempData>,

use anchor_lang::prelude::*;

declare_id!("Counter111111111111111111111111111111111111");

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

    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        counter.authority = ctx.accounts.authority.key();
        counter.value = 0;
        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).unwrap();
        msg!("counter now {}", counter.value);
        Ok(())
    }

    pub fn close_counter(_ctx: Context<CloseCounter>) -> Result<()> {
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(
        init,
        payer = authority,
        space = 8 + 32 + 8 + 1,
        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)]
    pub counter: Account<'info, Counter>,
    pub authority: Signer<'info>,
}

#[derive(Accounts)]
pub struct CloseCounter<'info> {
    #[account(mut, has_one = authority, close = authority)]
    pub counter: Account<'info, Counter>,
    pub authority: Signer<'info>,
}

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

import * as anchor from "@coral-xyz/anchor";

const provider = anchor.AnchorProvider.env();
anchor.setProvider(provider);
const program = anchor.workspace.Counter as anchor.Program<Counter>;

const [counterPda] = anchor.web3.PublicKey.findProgramAddressSync(
  [Buffer.from("counter"), provider.wallet.publicKey.toBuffer()],
  program.programId
);

await program.methods
  .initialize()
  .accounts({ authority: provider.wallet.publicKey })
  .rpc();

await program.methods
  .increment()
  .accounts({ authority: provider.wallet.publicKey })
  .rpc();

const acct = await program.account.counter.fetch(counterPda);
console.log("value =", acct.value.toString());