Solana 文档开发程序测试程序

Mollusk

Mollusk 是一个轻量级的测试工具，用于测试 Solana 程序。它为在精简的 Solana 虚拟机 (SVM) 环境中测试 Solana 程序指令提供了一个简单的接口。所有测试账户都必须明确定义，以确保测试的确定性和可重复性。

安装

在 mollusk-svm 中添加 Cargo.toml 作为依赖项：

Terminal
$ 
cargo add mollusk-svm --dev
Cargo.toml
[dev-dependencies]

mollusk-svm = "0.7"

为了基准测试计算单元的使用，在 Cargo.toml 中添加 mollusk-svm-bencher 作为依赖项：

Terminal
$ 
cargo add mollusk-svm-bencher --dev
Cargo.toml
[dev-dependencies]

mollusk-svm-bencher = "0.7"

要使用 token program、token2022 program（token extensions）和 associated token program 进行测试，在 Cargo.toml 中添加 mollusk-svm-programs-token 作为依赖项：

Terminal
$ 
cargo add mollusk-svm-programs-token --dev
Cargo.toml
[dev-dependencies]

mollusk-svm-programs-token = "0.7"

Mollusk SVM

以下示例展示了使用 Mollusk 测试一个基本 Solana 程序的最小设置。

Hello World 程序

此示例演示了如何使用 Mollusk 测试一个基本的 Solana 程序。该程序在被调用时会将 "Hello, world!" 打印到程序日志中。

运行 cargo build-sbf 会在 /target/deploy/<program_name>.so 生成已编译的程序。

src/lib.rs
use solana_program::{

    account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, msg, pubkey::Pubkey,

};



entrypoint!(process_instruction);



pub fn process_instruction(

    _program_id: &Pubkey,

    _accounts: &[AccountInfo],

    _instruction_data: &[u8],

) -> ProgramResult {

    msg!("Hello, world!");

    Ok(())

}



#[cfg(test)]

mod tests {

    use mollusk_svm::{result::Check, Mollusk};

    use solana_sdk::{instruction::Instruction, pubkey::Pubkey};



    #[test]

    fn test_hello_world() {

        let program_id = Pubkey::new_unique();

        let mollusk = Mollusk::new(&program_id, "target/deploy/hello_world");



        let instruction = Instruction::new_with_bytes(program_id, &[], vec![]);



        mollusk.process_and_validate_instruction(&instruction, &[], &[Check::success()]);

    }

}

使用 Mollusk 测试 Solana 程序的步骤：

  1. 创建一个 Mollusk 实例 - 使用程序 ID 和已编译程序的路径（.so 文件）初始化 Mollusk
  2. 构建指令 - 创建一个调用程序的指令
  3. 处理并验证 - 使用 Mollusk 处理指令并验证结果
src/lib.rs
#[cfg(test)]

mod tests {

    use mollusk_svm::{result::Check, Mollusk};

    use solana_sdk::{instruction::Instruction, pubkey::Pubkey};



    #[test]

    fn test_hello_world() {

        let program_id = Pubkey::new_unique();

        let mollusk = Mollusk::new(&program_id, "target/deploy/hello_world");



        let instruction = Instruction::new_with_bytes(program_id, &[], vec![]);



        mollusk.process_and_validate_instruction(&instruction, &[], &[Check::success()]);

    }

}

要执行测试，请运行 cargo test。

当测试成功运行时，您将看到类似以下的输出：

Terminal
running 1 test

[2025-09-22T19:25:50.427685000Z DEBUG solana_runtime::message_processor::stable_log] Program 11157t3sqMV725NVRLrVQbAu98Jjfk1uCKehJnXXQs invoke [1]

[2025-09-22T19:25:50.429669000Z DEBUG solana_runtime::message_processor::stable_log] Program log: Hello, world!

[2025-09-22T19:25:50.429690000Z DEBUG solana_runtime::message_processor::stable_log] Program 11157t3sqMV725NVRLrVQbAu98Jjfk1uCKehJnXXQs consumed 211 of 1400000 compute units

[2025-09-22T19:25:50.429726000Z DEBUG solana_runtime::message_processor::stable_log] Program 11157t3sqMV725NVRLrVQbAu98Jjfk1uCKehJnXXQs success

test tests::test_hello_world ... ok



test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s



   Doc-tests hello_world

Hello World 程序

此示例演示了如何使用 Mollusk 测试一个基本的 Solana 程序。该程序在被调用时会将 "Hello, world!" 打印到程序日志中。

运行 cargo build-sbf 会在 /target/deploy/<program_name>.so 生成已编译的程序。

使用 Mollusk 测试 Solana 程序的步骤：

  1. 创建一个 Mollusk 实例 - 使用程序 ID 和已编译程序的路径（.so 文件）初始化 Mollusk
  2. 构建指令 - 创建一个调用程序的指令
  3. 处理并验证 - 使用 Mollusk 处理指令并验证结果
src/lib.rs
#[cfg(test)]

mod tests {

    use mollusk_svm::{result::Check, Mollusk};

    use solana_sdk::{instruction::Instruction, pubkey::Pubkey};



    #[test]

    fn test_hello_world() {

        let program_id = Pubkey::new_unique();

        let mollusk = Mollusk::new(&program_id, "target/deploy/hello_world");



        let instruction = Instruction::new_with_bytes(program_id, &[], vec![]);



        mollusk.process_and_validate_instruction(&instruction, &[], &[Check::success()]);

    }

}

要执行测试，请运行 cargo test。

当测试成功运行时，您将看到类似以下的输出：

Terminal
running 1 test

[2025-09-22T19:25:50.427685000Z DEBUG solana_runtime::message_processor::stable_log] Program 11157t3sqMV725NVRLrVQbAu98Jjfk1uCKehJnXXQs invoke [1]

[2025-09-22T19:25:50.429669000Z DEBUG solana_runtime::message_processor::stable_log] Program log: Hello, world!

[2025-09-22T19:25:50.429690000Z DEBUG solana_runtime::message_processor::stable_log] Program 11157t3sqMV725NVRLrVQbAu98Jjfk1uCKehJnXXQs consumed 211 of 1400000 compute units

[2025-09-22T19:25:50.429726000Z DEBUG solana_runtime::message_processor::stable_log] Program 11157t3sqMV725NVRLrVQbAu98Jjfk1uCKehJnXXQs success

test tests::test_hello_world ... ok



test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s



   Doc-tests hello_world
lib.rs
hello_world.so
Cargo.toml
use solana_program::{

    account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, msg, pubkey::Pubkey,

};



entrypoint!(process_instruction);



pub fn process_instruction(

    _program_id: &Pubkey,

    _accounts: &[AccountInfo],

    _instruction_data: &[u8],

) -> ProgramResult {

    msg!("Hello, world!");

    Ok(())

}



#[cfg(test)]

mod tests {

    use mollusk_svm::{result::Check, Mollusk};

    use solana_sdk::{instruction::Instruction, pubkey::Pubkey};



    #[test]

    fn test_hello_world() {

        let program_id = Pubkey::new_unique();

        let mollusk = Mollusk::new(&program_id, "target/deploy/hello_world");



        let instruction = Instruction::new_with_bytes(program_id, &[], vec![]);



        mollusk.process_and_validate_instruction(&instruction, &[], &[Check::success()]);

    }

}

Mollusk 结构体为测试 Solana 程序提供了一个简单的接口。所有字段都可以通过一些辅助方法进行操作，但如果用户需要更多控制，也可以直接访问和修改它们。

要使用默认实例初始化 Mollusk，请使用 Mollusk::default 方法。

Example
// Default instance with no custom programs

let mollusk = Mollusk::default();

要使用特定程序初始化 Mollusk，请使用 Mollusk::new 方法。

Example
// Initialize Mollusk with a specific program from a file path

let program_id = Pubkey::new_unique();

let mollusk = Mollusk::new(&program_id, "target/deploy/my_program");

要向 Mollusk 添加程序，请使用 Mollusk::add_program 方法。

Example
let mollusk = Mollusk::default();

let program_id = Pubkey::new_unique();



// Add a program to Mollusk

mollusk.add_program(

    &program_id,

    "target/deploy/my_program",

    &bpf_loader_upgradeable::id(),

);

提供文件路径时，不要包含 .so 扩展名。例如， "path/to/my_program" 是正确的，而 "path/to/my_program.so" 是不正确的。

处理指令

Mollusk 提供了四种主要方法来处理指令：

方法描述
process_instruction处理一条指令并返回结果。
process_and_validate_instruction处理一条指令并对结果执行一系列检查，如果任何检查失败则会中止。
process_instruction_chain处理多条指令并返回结果。
process_and_validate_instruction_chain处理多条指令并对每个结果执行一系列检查，如果任何检查失败则会中止。

InstructionResult 包含了已处理指令的详细信息。

单条指令

使用 process_instruction 方法处理单条指令，而不对结果进行检查。您可以在处理后手动验证结果。

Method Signature
pub fn process_instruction(

    &self,

    instruction: &Instruction,

    accounts: &[(Pubkey, Account)],

) -> InstructionResult

以下示例处理了一条 SOL 转账指令，而未进行验证检查。

以下示例在 main 函数中运行 Mollusk，用于演示目的。实际使用中，您通常会在带有 #[test] 属性注解的测试模块中使用 Mollusk。

Single Instruction
use mollusk_svm::Mollusk;

use solana_sdk::{account::Account, pubkey::Pubkey};

use solana_system_interface::{instruction::transfer, program::ID as SYSTEM_PROGRAM_ID};



fn main() {

    // Initialize Mollusk

    let mollusk = Mollusk::default();



    // Set up accounts

    let sender = Pubkey::new_unique();

    let recipient = Pubkey::new_unique();



    let initial_lamports = 1_000_000;

    let transfer_amount = 250_000;



    // Create transfer instruction

    let instruction = transfer(&sender, &recipient, transfer_amount);



    // Define initial account states

    let accounts = vec![

        (

            sender,

            Account {

                lamports: initial_lamports,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

        (

            recipient,

            Account {

                lamports: 0,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

    ];



    // Process the instruction

    let result = mollusk.process_instruction(&instruction, &accounts);

    println!("{:#?}", result);



    // Check the result

    assert!(result.program_result.is_ok());

    assert_eq!(result.get_account(&sender).unwrap().lamports, 750_000);

    assert_eq!(result.get_account(&recipient).unwrap().lamports, 250_000);

}
Console
Click to execute the code.

单条指令与检查

使用 process_and_validate_instruction 方法处理单条指令并进行验证检查。如果任何检查失败，该方法将会触发 panic。

Method Signature
pub fn process_and_validate_instruction(

    &self,

    instruction: &Instruction,

    accounts: &[(Pubkey, Account)],

    checks: &[Check],

) -> InstructionResult

以下示例处理一条带有验证检查的 SOL 转账指令。

With Validation
use {

    mollusk_svm::{result::Check, Mollusk},

    solana_sdk::{account::Account, pubkey::Pubkey},

    solana_system_interface::{instruction::transfer, program::ID as SYSTEM_PROGRAM_ID},

};



fn main() {

    let mollusk = Mollusk::default();



    let sender = Pubkey::new_unique();

    let recipient = Pubkey::new_unique();



    let initial_lamports = 1_000_000;

    let transfer_amount = 250_000;



    let instruction = transfer(&sender, &recipient, transfer_amount);



    let accounts = vec![

        (

            sender,

            Account {

                lamports: initial_lamports,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

        (

            recipient,

            Account {

                lamports: 0,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

    ];



    // Define validation checks

    let checks = vec![

        Check::success(),

        Check::account(&sender).lamports(750_000).build(),

        Check::account(&recipient).lamports(250_000).build(),

    ];



    // Process and validate (will panic if any check fails)

    let result = mollusk.process_and_validate_instruction(&instruction, &accounts, &checks);

    println!("{:#?}", result);

}
Console
Click to execute the code.

多条指令

使用 process_instruction_chain 方法顺序处理多条指令，无需验证检查。

Method Signature
pub fn process_instruction_chain(

    &self,

    instructions: &[Instruction],

    accounts: &[(Pubkey, Account)],

) -> InstructionResult

以下示例处理两条不带验证检查的 SOL 转账指令。

Multiple Instructions
use {

    mollusk_svm::Mollusk,

    solana_sdk::{account::Account, pubkey::Pubkey},

    solana_system_interface::{instruction::transfer, program::ID as SYSTEM_PROGRAM_ID},

};



fn main() {

    let mollusk = Mollusk::default();



    // Set up accounts

    let alice = Pubkey::new_unique();

    let bob = Pubkey::new_unique();

    let charlie = Pubkey::new_unique();



    let initial_lamports = 1_000_000;



    // Create chain of transfers

    let instructions = vec![

        transfer(&alice, &bob, 300_000),   // Alice -> Bob

        transfer(&bob, &charlie, 100_000), // Bob -> Charlie

    ];



    let accounts = vec![

        (

            alice,

            Account {

                lamports: initial_lamports,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

        (

            bob,

            Account {

                lamports: 0,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

        (

            charlie,

            Account {

                lamports: 0,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

    ];



    // Process the instruction chain

    let result = mollusk.process_instruction_chain(&instructions, &accounts);

    println!("{:#?}", result);



    // Final balances: Alice=700K, Bob=200K, Charlie=100K

    assert_eq!(result.get_account(&alice).unwrap().lamports, 700_000);

    assert_eq!(result.get_account(&bob).unwrap().lamports, 200_000);

    assert_eq!(result.get_account(&charlie).unwrap().lamports, 100_000);

}
Console
Click to execute the code.

多条指令与检查

使用 process_and_validate_instruction_chain 方法处理多条指令，并在每条指令后进行验证检查。每条指令都有其必须通过的检查集。

Method Signature
pub fn process_and_validate_instruction_chain(

    &self,

    instructions: &[(&Instruction, &[Check])],

    accounts: &[(Pubkey, Account)],

) -> InstructionResult

以下示例处理一系列两条带有验证检查的 SOL 转账指令，每条指令后都会进行验证检查。

With Validation
use {

    mollusk_svm::{result::Check, Mollusk},

    solana_sdk::{account::Account, pubkey::Pubkey},

    solana_system_interface::{instruction::transfer, program::ID as SYSTEM_PROGRAM_ID},

};



fn main() {

    let mollusk = Mollusk::default();



    // Create accounts

    let alice = Pubkey::new_unique();

    let bob = Pubkey::new_unique();

    let charlie = Pubkey::new_unique();



    let initial_lamports = 1_000_000;



    // Create transfer instructions

    let transfer1 = transfer(&alice, &bob, 300_000);

    let transfer2 = transfer(&bob, &charlie, 100_000);



    // Initial accounts

    let accounts = vec![

        (

            alice,

            Account {

                lamports: initial_lamports,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

        (

            bob,

            Account {

                lamports: 0,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

        (

            charlie,

            Account {

                lamports: 0,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

    ];



    // Define checks for each instruction

    let checks_after_transfer1 = vec![

        Check::success(),

        Check::account(&alice)

            .lamports(700_000) // 1M - 300K

            .build(),

        Check::account(&bob)

            .lamports(300_000) // 0 + 300K

            .build(),

        Check::account(&charlie)

            .lamports(0) // Unchanged

            .build(),

    ];



    let checks_after_transfer2 = vec![

        Check::success(),

        Check::account(&alice)

            .lamports(700_000) // Unchanged from previous

            .build(),

        Check::account(&bob)

            .lamports(200_000) // 300K - 100K

            .build(),

        Check::account(&charlie)

            .lamports(100_000) // 0 + 100K

            .build(),

    ];



    // Process with validation at each step

    let instruction_and_checks = [

        (&transfer1, checks_after_transfer1.as_slice()),

        (&transfer2, checks_after_transfer2.as_slice()),

    ];



    // Execute chain (panics if any check fails)

    let result = mollusk.process_and_validate_instruction_chain(&instruction_and_checks, &accounts);



    println!("{:#?}", result);

}
Console
Click to execute the code.

验证检查

Mollusk 提供了一组 辅助方法 用于检查已处理指令的结果。

Example
use mollusk_svm::result::Check;

使用以下方法验证指令结果：

Example
// Program execution succeeded

Check::success()



// Program returned specific error

Check::err(ProgramError::InvalidArgument)



// Instruction level error

Check::instruction_err(InstructionError::InsufficientFunds)



// Check with specific program result

Check::program_result(ProgramResult::Success)



// Compute units consumed

Check::compute_units(1000)



// Execution time

Check::time(100)



// Return data from instruction execution

Check::return_data(&[1, 2, 3, 4])

使用以下方法验证账户状态：

Example
// Single account validation

Check::account(&pubkey)

    .lamports(1_000_000)           // Exact lamports

    .owner(&program_id)            // Account owner

    .data(&expected_data)          // Exact data match

    .data_slice(8, &[1, 2, 3])     // Partial data match at offset

    .executable(false)             // Executable flag

    .space(100)                    // Account data size

    .closed()                      // Account is closed (0 lamports)

    .rent_exempt()                 // Account is rent-exempt

    .build()



// Check all accounts are rent exempt

Check::all_rent_exempt()

持久化账户状态

MolluskContext 是一个围绕 Mollusk 的封装器，通过其 account_store 在多个指令调用中维护账户状态。处理指令的方法与 Mollusk 相同。

与 Mollusk 不同，它需要为每个方法传递 accounts（例如 process_instruction），MolluskContext 通过其 account_store 内部管理账户。这消除了在处理指令时需要 accounts 参数的需求。

使用 with_context 方法创建一个 account_store：

Example
use std::collections::HashMap;

use solana_sdk::{account::Account, pubkey::Pubkey};

use solana_system_interface::program::ID as SYSTEM_PROGRAM_ID;

use mollusk_svm::Mollusk;



let mollusk = Mollusk::default();

let account_address = Pubkey::new_unique();



let mut account_store = HashMap::new();

account_store.insert(

    account_address,

    Account {

        lamports: 1_000_000,

        data: vec![],

        owner: SYSTEM_PROGRAM_ID,

        executable: false,

        rent_epoch: 0,

    },

);



let context = mollusk.with_context(account_store);

以下示例通过 account_store 在指令之间保持持久化账户状态，处理了两个单独的 SOL 转账指令。

Stateful Testing
use {

    mollusk_svm::Mollusk,

    solana_sdk::{account::Account, pubkey::Pubkey},

    solana_system_interface::{instruction::transfer, program::ID as SYSTEM_PROGRAM_ID},

    std::collections::HashMap,

};



fn main() {

    // Initialize Mollusk

    let mollusk = Mollusk::default();



    // Create accounts

    let sender = Pubkey::new_unique();

    let recipient = Pubkey::new_unique();



    // Create account store with initial balances

    let mut account_store = HashMap::new();

    account_store.insert(

        sender,

        Account {

            lamports: 1_000_000,

            data: vec![],

            owner: SYSTEM_PROGRAM_ID,

            executable: false,

            rent_epoch: 0,

        },

    );

    account_store.insert(

        recipient,

        Account {

            lamports: 0,

            data: vec![],

            owner: SYSTEM_PROGRAM_ID,

            executable: false,

            rent_epoch: 0,

        },

    );



    // Create a stateful context

    let context = mollusk.with_context(account_store);



    // First transfer: 200,000 lamports

    let instruction1 = transfer(&sender, &recipient, 200_000);

    context.process_instruction(&instruction1);



    // Second transfer: 100,000 lamports (state persists from first transfer)

    let instruction2 = transfer(&sender, &recipient, 100_000);

    context.process_instruction(&instruction2);



    // Check final balances

    let store = context.account_store.borrow();

    let sender_account = store.get(&sender).unwrap();

    let recipient_account = store.get(&recipient).unwrap();

    println!("Sender: {:#?}", sender_account);

    println!("Recipient: {:#?}", recipient_account);

}
Console
Click to execute the code.

Mollusk 系统变量

Mollusk 提供了一个自定义的 Sysvars 结构，用于修改其值以进行测试。

使用 warp_to_slot 方法更新系统变量时钟，以模拟向前或向后移动到特定的 slot。

Warp to Slot
use mollusk_svm::Mollusk;



fn main() {

    // Initialize Mollusk

    let mut mollusk = Mollusk::default();



    // Show initial slot

    println!("Initial slot: {}", mollusk.sysvars.clock.slot);



    // Warp to slot 1000

    mollusk.warp_to_slot(100);

    println!("After warp: {}", mollusk.sysvars.clock.slot);



    // Warp to slot 10

    mollusk.warp_to_slot(10);

    println!("After second warp: {}", mollusk.sysvars.clock.slot);

}
Console
Click to execute the code.

以下示例通过访问 sysvars 字段直接修改 Mollusk 系统变量以更改 rent 参数。您可以以相同的方式修改其他系统变量值。

Modify Sysvars
use {mollusk_svm::Mollusk, solana_sdk::rent::Rent};



fn main() {

    let mut mollusk = Mollusk::default();



    // Show default rent

    println!(

        "Default rent exemption for 1000 bytes: {} lamports",

        mollusk.sysvars.rent.minimum_balance(1000)

    );



    // Customize rent parameters

    mollusk.sysvars.rent = Rent {

        lamports_per_byte_year: 1,

        exemption_threshold: 1.0,

        burn_percent: 0,

    };



    // Show custom rent

    println!(

        "Custom rent exemption for 1000 bytes: {} lamports",

        mollusk.sysvars.rent.minimum_balance(1000)

    );

}
Console
Click to execute the code.

计算单元基准测试

MolluskComputeUnitBencher 用于跟踪程序指令的计算单元使用情况。结果将写入一个 markdown 文件中。

需要将 mollusk-svm-bencher 作为依赖项。

以下示例对 SOL 转账指令的计算单元使用情况进行了基准测试。

Benchmark Compute Units
use {

    mollusk_svm::Mollusk,

    mollusk_svm_bencher::MolluskComputeUnitBencher,

    solana_sdk::{account::Account, pubkey::Pubkey},

    solana_system_interface::{instruction::transfer, program::ID as SYSTEM_PROGRAM_ID},

};



fn main() {

    // Initialize Mollusk

    let mollusk = Mollusk::default();



    // Create test accounts

    let sender = Pubkey::new_unique();

    let receiver = Pubkey::new_unique();



    // Transfer instruction

    let transfer = transfer(&sender, &receiver, 100_000);

    let accounts = vec![

        (

            sender,

            Account {

                lamports: 1_000_000,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

        (

            receiver,

            Account {

                lamports: 0,

                data: vec![],

                owner: SYSTEM_PROGRAM_ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

    ];



    // Run benchmark

    MolluskComputeUnitBencher::new(mollusk)

        .bench(("transfer", &transfer, &accounts))

        .must_pass(true)

        .out_dir("./target/benches")

        .execute();

}

基准测试结果将写入指定的 out_dir，作为一个名为 compute_units.md 的 markdown 文件。

comput_units.md
#### 2025-09-19 22:28:53.691839 UTC



Solana CLI Version: solana-cli 2.2.20 (src:dabc99a5; feat:3073396398,

client:Agave)



| Name     | CUs | Delta   |

| -------- | --- | ------- |

| transfer | 150 | - new - |

Token Program 测试

使用 mollusk-svm-programs-token crate 添加 token program、token2022 program（token extensions）和 associated token program 到 Mollusk 进行测试。

Example
use {

    mollusk_svm::Mollusk,

    mollusk_svm_programs_token::{associated_token, token, token2022},

};



let mut mollusk = Mollusk::default();



// Add SPL Token Program

token::add_program(&mut mollusk);

// Add SPL Token-2022 Program

token2022::add_program(&mut mollusk);

// Add Associated Token Account Program

associated_token::add_program(&mut mollusk);

以下示例演示了使用 Mollusk 测试 token 转账。

以下示例手动定义了测试账户以供演示。 mollusk-svm-programs-token 还包括用于创建 mint 和 token 账户的辅助函数。

Token Transfer Example
use {

    mollusk_svm::{result::Check, Mollusk},

    mollusk_svm_programs_token::token,

    solana_sdk::{account::Account, program_pack::Pack, pubkey::Pubkey},

    spl_token_interface::{

        instruction::transfer_checked,

        state::{Account as TokenAccount, AccountState, Mint},

    },

};



fn main() {

    // Initialize Mollusk with Token program

    let mut mollusk = Mollusk::default();

    token::add_program(&mut mollusk);



    // Create account keys

    let mint = Pubkey::new_unique();

    let source = Pubkey::new_unique();

    let destination = Pubkey::new_unique();

    let authority = Pubkey::new_unique();



    // Token configuration

    let decimals = 6;

    let transfer_amount = 1_000_000; // 1 token with 6 decimals

    let initial_balance = 10_000_000; // 10 tokens



    // Calculate rent-exempt minimums

    let mint_rent = mollusk.sysvars.rent.minimum_balance(Mint::LEN);

    let account_rent = mollusk.sysvars.rent.minimum_balance(TokenAccount::LEN);



    // Create mint account

    let mut mint_data = vec![0u8; Mint::LEN];

    Mint::pack(

        Mint {

            mint_authority: Some(authority).into(),

            supply: initial_balance,

            decimals,

            is_initialized: true,

            freeze_authority: None.into(),

        },

        &mut mint_data,

    )

    .unwrap();



    // Create source token account

    let mut source_data = vec![0u8; TokenAccount::LEN];

    TokenAccount::pack(

        TokenAccount {

            mint,

            owner: authority,

            amount: initial_balance,

            delegate: None.into(),

            state: AccountState::Initialized,

            is_native: None.into(),

            delegated_amount: 0,

            close_authority: None.into(),

        },

        &mut source_data,

    )

    .unwrap();



    // Create destination token account

    let mut destination_data = vec![0u8; TokenAccount::LEN];

    TokenAccount::pack(

        TokenAccount {

            mint,

            owner: Pubkey::new_unique(),

            amount: 0,

            delegate: None.into(),

            state: AccountState::Initialized,

            is_native: None.into(),

            delegated_amount: 0,

            close_authority: None.into(),

        },

        &mut destination_data,

    )

    .unwrap();



    // Setup accounts for transfer_checked

    let accounts = vec![

        (

            source,

            Account {

                lamports: account_rent,

                data: source_data,

                owner: token::ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

        (

            mint,

            Account {

                lamports: mint_rent,

                data: mint_data,

                owner: token::ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

        (

            destination,

            Account {

                lamports: account_rent,

                data: destination_data,

                owner: token::ID,

                executable: false,

                rent_epoch: 0,

            },

        ),

        (

            authority,

            Account {

                lamports: 1_000_000,

                data: vec![],

                owner: Pubkey::default(),

                executable: false,

                rent_epoch: 0,

            },

        ),

    ];



    // Create transfer_checked instruction

    let instruction = transfer_checked(

        &token::ID,

        &source,

        &mint,

        &destination,

        &authority,

        &[],

        transfer_amount,

        decimals,

    )

    .unwrap();



    // Expected balances after transfer

    let expected_source_balance = (initial_balance - transfer_amount).to_le_bytes();

    let expected_dest_balance = transfer_amount.to_le_bytes();



    // Define validation checks

    let checks = vec![

        Check::success(),

        Check::account(&source)

            .data_slice(64, &expected_source_balance) // Token amount is at offset 64

            .build(),

        Check::account(&destination)

            .data_slice(64, &expected_dest_balance)

            .build(),

    ];



    // Process and validate the instruction

    let result = mollusk.process_and_validate_instruction(&instruction, &accounts, &checks);

    println!("{:#?}", result);



    // Deserialize token account data

    let source_account = result.get_account(&source).unwrap();

    let source_token = TokenAccount::unpack(&source_account.data).unwrap();

    println!("Source Token Account: {:#?}", source_token);



    let destination_account = result.get_account(&destination).unwrap();

    let dest_token = TokenAccount::unpack(&destination_account.data).unwrap();

    println!("Destination Token Account: {:#?}", dest_token);

}
Console
Click to execute the code.

Is this page helpful?

上一页

程序结构

下一页

部署程序

Table of Contents

Edit Page

管理者

©️ 2025 Solana 基金会版权所有
Solana
取得联系