Struct TestContext 

pub struct TestContext {
    pub svm: LiteSVM,
    pub pending_instructions: Vec<Instruction>,
    pub snapshot: Option<SvmSnapshot>,
    pub dirty_tracker: DirtyTracker,
    pub sigverify: bool,
    /* private fields */
}

Fields

svm: LiteSVM

pending_instructions: Vec<Instruction>

snapshot: Option<SvmSnapshot>

Snapshot of initial state for fast restore (always-on in fuzz mode)

dirty_tracker: DirtyTracker

Tracks dirty accounts across all transactions in an iteration

sigverify: bool

Whether signature verification is enabled on the SVM. When false (default for fuzzing), transactions use dummy signatures to skip ed25519 computation (~77µs per tx).

Implementations

impl TestContext

pub fn create_mock_pyth_oracle(&mut self) -> MockPythOracleBuilder<'_>

Create a mock Pyth oracle builder

Example

let oracle = ctx.create_mock_pyth_oracle()
    .price(100_00000000)  // $100
    .exponent(-8)
    .build()?;

pub fn update_pyth_price( &mut self, oracle: &Pubkey, price: i64, exponent: i32, ) -> Result<()>

Update the price on an existing Pyth oracle

Arguments

• oracle - The oracle account pubkey
• price - New price value
• exponent - Price exponent (typically -8)

pub fn refresh_pyth_oracle(&mut self, oracle: &Pubkey) -> Result<()>

Refresh a Pyth oracle’s timestamp and slot to make it “fresh” Use this before operations that check oracle staleness

impl TestContext

pub fn new() -> Self

pub fn with_invocation_callback<C: InvocationInspectCallback + 'static>( callback: C, ) -> Self

pub fn with_compute_budget(self, compute_unit_limit: u64) -> Self

pub fn analyze_program_coverage(program_data: &[u8]) -> Option<(usize, usize)>

Analyze a program binary and return (total_edges, total_instructions). Only counts reachable code from the program entrypoint via BFS. Only counts edges from conditional jump instructions (matching runtime tracking). Used for coverage percentage calculation.

pub fn add_program( &mut self, program_id: &Pubkey, program_path: &str, ) -> Result<()>

pub fn add_program_from_bytes( &mut self, program_id: &Pubkey, program_data: &[u8], ) -> Result<()>

Load a program from raw ELF bytes into the SVM.

Same as add_program() but takes &[u8] instead of a file path. Runs coverage analysis and stores program data for debuggable SVM reloading.

pub fn from_svm(svm: LiteSVM) -> Self

pub fn into_svm(self) -> LiteSVM

pub fn clone_with_invocation_callback<C: InvocationInspectCallback + 'static>( &self, callback: C, ) -> Self

Clone this context and set an invocation callback for coverage tracking. The source SVM must have been created with debuggable mode (via CRUCIBLE_FUZZ_DEBUGGABLE env var) for register tracing to work. Cloning preserves the debuggable state and loaded programs.

NOTE: For better performance in fuzzing loops, prefer using set_invocation_callback after cloning the fixture instead of this method. This method performs an additional SVM clone beyond the fixture clone, which can be expensive.

pub fn set_invocation_callback<C: InvocationInspectCallback + 'static>( &mut self, callback: C, )

Set an invocation callback for coverage tracking on this context. Unlike clone_with_invocation_callback, this modifies the context in place without performing an additional SVM clone.

The SVM must have been created with debuggable mode (via CRUCIBLE_FUZZ_DEBUGGABLE env var) for register tracing to work.

Usage pattern for fuzzing loops:

let mut fixture = template_fixture.clone();  // Single clone
fixture.ctx.set_invocation_callback(callback);  // No additional clone

pub fn track_account(&mut self, pubkey: Pubkey)

Track an account pubkey so it gets copied when cloning with invocation callback. Called internally by account builders.

pub fn tracked_accounts_count(&self) -> usize

Get count of tracked accounts (for debugging)

pub fn programs_count(&self) -> usize

Get count of loaded programs (for debugging)

pub fn svm_account_count(&self) -> usize

Get total number of accounts in the SVM’s internal HashMap. Used to detect unbounded account growth across fuzzing iterations.

pub fn account_exists(&self, pubkey: &Pubkey) -> bool

Check if a specific account exists in the SVM (for debugging)

pub fn get_program_coverage_totals(&self) -> &HashMap<Pubkey, (usize, usize)>

Get the total CFG edge and instruction counts for all loaded programs. Returns HashMap<Pubkey, (total_edges, total_instructions)> Used by the fuzzer to calculate coverage percentages.

pub fn get_program_binaries(&self) -> HashMap<Pubkey, Vec<u8>>

Get program binaries for CFG analysis. Returns a map from program pubkey to binary data. Used by the fuzzer for per-instruction CFG divergence analysis.

pub fn get_program_binary(&self, pubkey: &Pubkey) -> Option<&[u8]>

Get program binary by pubkey (for CFG analysis).

pub fn take_snapshot(&mut self)

Take a snapshot of ALL accounts in the SVM. Called once after setup, before the fuzz loop begins.

pub fn begin_iteration(&mut self)

Prepare for a new iteration: clear dirty tracker and pending state. Called at the start of each fuzzing iteration.

pub fn restore_snapshot(&mut self) -> usize

Restore only dirty accounts from snapshot. Returns count restored. Much faster than full SVM clone when only ~5-20 accounts were modified.

pub fn has_snapshot(&self) -> bool

Whether a snapshot has been taken.

pub fn dirty_tracker(&self) -> &DirtyTracker

Get the dirty tracker for the current iteration.

pub fn create_account(&mut self) -> GenericAccountBuilder<'_>

Account Creation Helpers

pub fn create_mint(&mut self) -> MintAccountBuilder<'_>

pub fn create_token_account(&mut self) -> TokenAccountBuilder<'_>

pub fn transfer_tokens( &mut self, from: &Pubkey, to: &Pubkey, owner: &Keypair, amount: u64, ) -> Result<()>

Transfer tokens between accounts

pub fn mint_to( &mut self, mint: &Pubkey, destination: &Pubkey, amount: u64, authority: &Rc<Keypair>, ) -> Result<()>

pub fn warp_to_slot(&mut self, slot: u64)

pub fn advance_slots(&mut self, slots: u64)

pub fn set_sysvar<T>(&mut self, sysvar: &T)

where T: SysvarSerialize,

pub fn slot(&self) -> u64

Getters

pub fn next_slot(&self) -> u64

Returns the slot that the next transaction will likely see (current + 1)

pub fn account_has_data(&self, pubkey: &Pubkey, min_size: usize) -> bool

Check if account exists AND has at least min_size bytes of data

pub fn get_account(&self, address: &Pubkey) -> Result<Account>

pub fn read_account(&self, address: &Pubkey) -> Result<Account>

pub fn read_anchor_account<T: AnchorDeserialize + Discriminator>( &self, address: &Pubkey, ) -> Result<T>

Read anchor account at address and deserialize the data. Uses the type’s DISCRIMINATOR to determine how many bytes to skip.

pub fn read_account_with_discriminator<T: AnchorDeserialize>( &self, address: &Pubkey, discriminator_len: usize, ) -> Result<T>

Read account with explicit discriminator length (for non-standard accounts).

pub fn token_balance(&self, token_account: &Pubkey) -> u64

pub fn write_account( &mut self, address: &Pubkey, account: Account, ) -> Result<()>

Setters

pub fn write_anchor_account<T: AnchorSerialize + Discriminator>( &mut self, address: &Pubkey, data: &T, ) -> Result<()>

pub fn read_zero_copy_account<T: Pod>(&self, address: &Pubkey) -> Result<T>

Read a zero-copy account (skips 8-byte discriminator).

Read a zero-copy account with standard 8-byte discriminator.

Use this for accounts with #[account(zero_copy)] attribute which use bytemuck for serialization instead of Borsh.

Example

let reserve: Reserve = ctx.read_zero_copy_account(&reserve_addr)?;
println!("Reserve slot: {}", reserve.last_update.slot);

pub fn read_zero_copy_account_with_discriminator<T: Pod>( &self, address: &Pubkey, discriminator_len: usize, ) -> Result<T>

Read a zero-copy account with explicit discriminator length.

Use this for accounts with non-standard discriminator sizes.

Example

// For accounts with 1-byte discriminator
let vault: StarVault = ctx.read_zero_copy_account_with_discriminator(&vault_addr, 1)?;

pub fn write_zero_copy_account<T: Pod>( &mut self, address: &Pubkey, data: &T, ) -> Result<()>

Write a zero-copy account (preserves 8-byte discriminator).

Use this for accounts with #[account(zero_copy)] attribute which use bytemuck for serialization instead of Borsh.

Example

let mut reserve: Reserve = ctx.read_zero_copy_account(&reserve_addr)?;
reserve.last_update.mark_fresh(current_slot);
ctx.write_zero_copy_account(&reserve_addr, &reserve)?;

pub fn write_zero_copy_account_with_discriminator<T: Pod>( &mut self, address: &Pubkey, data: &T, discriminator_len: usize, ) -> Result<()>

Write a zero-copy account with explicit discriminator length.

pub fn update_account<F>(&mut self, pubkey: &Pubkey, f: F) -> Result<()>

where F: FnOnce(&mut Vec<u8>),

Update account data using a closure. Enables atomic read-modify-write pattern.

Example

ctx.update_account(&reserve_pubkey, |data| {
    // Modify data in place (e.g., using bytemuck)
    let reserve: &mut Reserve = bytemuck::from_bytes_mut(&mut data[8..]);
    reserve.config.loan_to_value_pct = 80;
})?;

pub fn raw_call(&mut self, instruction: Instruction) -> InstructionBuilder<'_>

Callers - each returns a builder

pub fn program(&mut self, program_id: Pubkey) -> ProgramBuilder<'_>

pub fn transaction(&mut self) -> TransactionBuilder<'_>

pub fn send_batch(&mut self) -> Result<Option<TxOutcome>>

Trait Implementations

impl Clone for TestContext

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.