Struct Cheatcodes 

pub struct Cheatcodes<'a> { /* private fields */ }

Direct state manipulation helpers for a running Surfnet.

These bypass normal transaction flow to instantly set account state — perfect for test setup (funding wallets, minting tokens, etc.).

use surfpool_sdk::{Pubkey, Surfnet};
use surfpool_sdk::cheatcodes::builders::SetAccount;

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();

// Fund an account with 5 SOL
let alice: Pubkey = "...".parse().unwrap();
cheats.fund_sol(&alice, 5_000_000_000).unwrap();

// Fund a token account with 1000 USDC
let usdc_mint: Pubkey = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v".parse().unwrap();
cheats.fund_token(&alice, &usdc_mint, 1_000_000_000, None).unwrap();

// Or build a typed cheatcode request:
let custom = Pubkey::new_unique();
let owner = Pubkey::new_unique();
cheats
    .execute(
        SetAccount::new(custom)
            .lamports(42)
            .owner(owner)
            .data(vec![1, 2, 3]),
    )
    .unwrap();

Implementations

impl<'a> Cheatcodes<'a>

pub fn fund_sol(&self, address: &Pubkey, lamports: u64) -> SurfnetResult<()>

Set the SOL balance for an account in lamports.

use surfpool_sdk::{Pubkey, Surfnet};

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();
let recipient = Pubkey::new_unique();

cheats.fund_sol(&recipient, 1_000_000_000).unwrap();

pub fn set_account( &self, address: &Pubkey, lamports: u64, data: &[u8], owner: &Pubkey, ) -> SurfnetResult<()>

Set arbitrary account state for a single account.

This helper updates lamports, owner, and raw account data in one RPC call.

use surfpool_sdk::{Pubkey, Surfnet};

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();
let address = Pubkey::new_unique();
let owner = Pubkey::new_unique();

cheats.set_account(&address, 500, &[1, 2, 3], &owner).unwrap();

pub fn fund_token( &self, owner: &Pubkey, mint: &Pubkey, amount: u64, token_program: Option<&Pubkey>, ) -> SurfnetResult<()>

Fund a token account (creates the ATA if needed).

Uses spl_token program by default. Pass token_program to use Token-2022.

use surfpool_sdk::{Pubkey, Surfnet};

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();
let owner = Pubkey::new_unique();
let mint = Pubkey::new_unique();

cheats.fund_token(&owner, &mint, 1_000, None).unwrap();

pub fn set_token_balance( &self, owner: &Pubkey, mint: &Pubkey, amount: u64, token_program: Option<&Pubkey>, ) -> SurfnetResult<()>

Set the token balance for a wallet/mint pair.

This is an alias for Self::fund_token.

use surfpool_sdk::{Pubkey, Surfnet};

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();
let owner = Pubkey::new_unique();
let mint = Pubkey::new_unique();

cheats.set_token_balance(&owner, &mint, 5_000, None).unwrap();

pub fn get_ata( &self, owner: &Pubkey, mint: &Pubkey, token_program: Option<&Pubkey>, ) -> Pubkey

Get the associated token address for a wallet/mint pair.

use surfpool_sdk::{Pubkey, Surfnet};

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();
let owner = Pubkey::new_unique();
let mint = Pubkey::new_unique();

let ata = cheats.get_ata(&owner, &mint, None);
println!("{ata}");

pub fn fund_sol_many(&self, accounts: &[(&Pubkey, u64)]) -> SurfnetResult<()>

Fund multiple accounts with SOL using repeated surfnet_setAccount calls.

use surfpool_sdk::{Pubkey, Surfnet};

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();
let alice = Pubkey::new_unique();
let bob = Pubkey::new_unique();

cheats
    .fund_sol_many(&[(&alice, 1_000_000), (&bob, 2_000_000)])
    .unwrap();

pub fn fund_token_many( &self, owners: &[&Pubkey], mint: &Pubkey, amount: u64, token_program: Option<&Pubkey>, ) -> SurfnetResult<()>

Fund multiple wallets with the same token and amount.

use surfpool_sdk::{Pubkey, Surfnet};

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();
let alice = Pubkey::new_unique();
let bob = Pubkey::new_unique();
let mint = Pubkey::new_unique();

cheats
    .fund_token_many(&[&alice, &bob], &mint, 1_000, None)
    .unwrap();

pub fn time_travel_to_epoch(&self, epoch: u64) -> SurfnetResult<EpochInfo>

Move Surfnet time forward to an absolute epoch.

use surfpool_sdk::Surfnet;

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();

let epoch_info = cheats.time_travel_to_epoch(10).unwrap();
assert!(epoch_info.epoch >= 10);

pub fn time_travel_to_slot(&self, slot: u64) -> SurfnetResult<EpochInfo>

Move Surfnet time forward to an absolute slot.

use surfpool_sdk::Surfnet;

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();

let epoch_info = cheats.time_travel_to_slot(1_000).unwrap();
assert!(epoch_info.absolute_slot >= 1_000);

pub fn time_travel_to_timestamp( &self, timestamp: u64, ) -> SurfnetResult<EpochInfo>

Move Surfnet time forward to an absolute Unix timestamp in milliseconds.

use surfpool_sdk::Surfnet;

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();

let epoch_info = cheats.time_travel_to_timestamp(1_700_000_000_000).unwrap();
assert!(epoch_info.absolute_slot > 0);

pub fn deploy_program(&self, program_name: &str) -> SurfnetResult<Pubkey>

Deploy a program from local workspace artifacts.

This looks for:

• target/deploy/{program_name}.so
• target/deploy/{program_name}-keypair.json
• target/idl/{program_name}.json (optional)

If an IDL file exists, it is registered after the program bytes are written.

use surfpool_sdk::Surfnet;

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();

let program_id = cheats.deploy_program("my_program").unwrap();
println!("{program_id}");

pub fn deploy(&self, builder: DeployProgram) -> SurfnetResult<Pubkey>

Deploy a program described by a DeployProgram builder.

This writes the program bytes with surfnet_writeProgram and, when present, registers the parsed IDL with surfnet_registerIdl.

use surfpool_sdk::{Pubkey, Surfnet};
use surfpool_sdk::cheatcodes::builders::DeployProgram;

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();
let program_id = Pubkey::new_unique();

let deployed_program = cheats
    .deploy(
        DeployProgram::new(program_id)
            .so_path("target/deploy/my_program.so")
            .idl_path("target/idl/my_program.json"),
    )
    .unwrap();

assert_eq!(deployed_program, program_id);

pub fn execute<B: CheatcodeBuilder>(&self, builder: B) -> SurfnetResult<()>

Execute a typed cheatcode builder.

use surfpool_sdk::{Pubkey, Surfnet};
use surfpool_sdk::cheatcodes::builders::ResetAccount;

let surfnet = Surfnet::start().await.unwrap();
let cheats = surfnet.cheatcodes();
let address = Pubkey::new_unique();

cheats.execute(ResetAccount::new(address)).unwrap();