Cheatcodes

Les cheatcodes sont des mutations d'état qui contournent le flux de transaction normal. Ils s'exécutent instantanément sans consommer de blockhash ni payer de frais, ce qui est exactement ce dont vous avez besoin pour la configuration des tests.

En Rust, les cheatcodes se trouvent sous Surfnet::cheatcodes(). En JS, ce sont des méthodes directement sur l'instance Surfnet.

Approvisionner en SOL

fundSol / fund_sol définit le solde en lamport sur n'importe quel compte, en créant le compte s'il n'existe pas.

use surfpool_sdk::{Pubkey, Surfnet};

let surfnet = Surfnet::start().await?;
let cheats = surfnet.cheatcodes();
let wallet = Pubkey::new_unique();

cheats.fund_sol(&wallet, 1_000_000_000)?;

// Fund several accounts in one call.
let bob = Pubkey::new_unique();
let carol = Pubkey::new_unique();
cheats.fund_sol_many(&[(&bob, 2_000_000_000), (&carol, 3_000_000_000)])?;

Approvisionner en tokens

fundToken / fund_token crée des tokens dans un portefeuille en calculant le token account associé, en le créant si nécessaire, et en définissant le montant.

Mints Token-2022

Par défaut, fundToken utilise le Token Program SPL classique. Pour les mints Token-2022, passez l'ID du programme Token-2022 (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb) comme dernier argument.

use surfpool_sdk::{Pubkey, Surfnet};

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

let wallet = Pubkey::new_unique();
let mint: Pubkey = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    .parse()
    .unwrap();

// Classic SPL Token mint.
cheats.fund_token(&wallet, &mint, 5_000_000, None)?;

// Token-2022 mint — pass the program id explicitly.
let token_2022: Pubkey = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
    .parse()
    .unwrap();
cheats.fund_token(&wallet, &mint, 5_000_000, Some(&token_2022))?;

// Fund many wallets with the same mint.
let mob = vec![Pubkey::new_unique(), Pubkey::new_unique()];
cheats.fund_token_many(&mob.iter().collect::<Vec<_>>(), &mint, 1_000_000, None)?;

Pour dériver l'ATA sans approvisionner, utilisez getAta / get_ata :

let ata = cheats.get_ata(&wallet, &mint, None);

Définir un état de compte arbitraire

La méthode setAccount écrit les lamports, le propriétaire et les octets de données brutes pour n'importe quel compte en un seul appel. Le SDK Rust expose également un builder SetAccount pour des champs plus avancés tels que rent_epoch et executable.

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

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

let address = Pubkey::new_unique();
let owner = Pubkey::new_unique();

// Direct method.
cheats.set_account(&address, 500_000, &[1, 2, 3], &owner)?;

// Builder when you need finer control.
cheats.execute(
    SetAccount::new(address)
        .lamports(500_000)
        .owner(owner)
        .data(vec![1, 2, 3])
        .rent_epoch(0)
        .executable(false),
)?;

Modifier les champs d'un token account

setTokenAccount met à jour les champs avancés d'un token account existant — délégué, état, autorité de fermeture, montant délégué. Utilisez-le lorsque fundToken seul ne suffit pas.

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

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

let owner = Pubkey::new_unique();
let mint: Pubkey = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v".parse()?;
let delegate = Pubkey::new_unique();

cheats.execute(
    SetTokenAccount::new(owner, mint)
        .amount(2_000_000)
        .delegate(delegate)
        .delegated_amount(500_000)
        .state("initialized"),
)?;

// Later: clear the delegation.
cheats.execute(SetTokenAccount::new(owner, mint).clear_delegate())?;

Réinitialiser les comptes à l'état amont

resetAccount annule toutes les mutations locales et récupère le compte depuis le RPC amont. Passez includeOwnedAccounts: true pour réinitialiser également tous les comptes possédés par la cible — utile lors de la réinitialisation d'un programme et de tous ses PDAs.

Nécessite `remoteRpcUrl` pour récupérer les données

Sur un Surfnet hors ligne, resetAccount efface la copie locale mais n'a pas de source amont depuis laquelle récupérer les données. Configurez remoteRpcUrl au démarrage pour que les réinitialisations restaurent l'état amont.

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

let cheats = Surfnet::start().await?.cheatcodes();
let token_program: Pubkey = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA".parse()?;

cheats.execute(
    ResetAccount::new(token_program).include_owned_accounts(true),
)?;

Diffuser les comptes en direct

streamAccount enregistre un compte pour une interrogation en arrière-plan depuis le RPC amont. La copie locale de Surfnet reste synchronisée avec le mainnet sans que le test ait besoin d'interroger explicitement. Combinez avec includeOwnedAccounts pour diffuser tous les PDAs possédés par un programme.

Nécessite `remoteRpcUrl`

streamAccount fonctionne uniquement sur un Surfnet démarré avec remoteRpcUrl (ou remote_rpc_url en Rust). Sans RPC amont, il n'y a rien à diffuser et l'appel retournera une erreur.

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

let cheats = Surfnet::builder()
    .remote_rpc_url("https://api.mainnet-beta.solana.com")
    .start()
    .await?
    .cheatcodes();

let oracle: Pubkey = "H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG".parse()?;

cheats.execute(StreamAccount::new(oracle).include_owned_accounts(false))?;

Constructeurs de cheatcodes (Rust)

Le SDK Rust expose des constructeurs typés sous surfpool_sdk::cheatcodes::builders pour les cas où les méthodes pratiques ne suffisent pas. Chaque constructeur implémente le trait CheatcodeBuilder et est exécuté via cheats.execute(builder).

Builder	Constructeur	Setters communs
`SetAccount`	`new(address: Pubkey)`	`lamports`, `data`, `owner`, `rent_epoch`, `executable`
`SetTokenAccount`	`new(owner: Pubkey, mint: Pubkey)`	`amount`, `delegate`, `clear_delegate`, `state`, `delegated_amount`, `close_authority`, `clear_close_authority`, `token_program`
`ResetAccount`	`new(address: Pubkey)`	`include_owned_accounts(bool)`
`StreamAccount`	`new(address: Pubkey)`	`include_owned_accounts(bool)`
`DeployProgram`	`new(program_id: Pubkey)`, `from_keypair_path(path)`	`so_path`, `so_bytes`, `idl_path`

Pour la surface JS complète, consultez Référence JS. Pour la surface Rust complète, consultez Référence Rust.

Table des matières