Configuration de l'environnement

Toutes les méthodes de configuration utilisent le pattern builder avec LiteSVM::default().

with_compute_budget

pub fn with_compute_budget(self, compute_budget: ComputeBudget) -> Self

Définir les limites d'unités de calcul et la taille du tas.

use solana_compute_budget::compute_budget::ComputeBudget;

let mut svm = LiteSVM::default()
    .with_compute_budget(ComputeBudget {
        compute_unit_limit: 1_400_000,
        heap_size: 256 * 1024,
        ..ComputeBudget::default()
    });

with_sigverify

pub fn with_sigverify(self, sigverify: bool) -> Self

Activer ou désactiver la vérification des signatures. Par défaut : true.

// Disable for faster tests
let mut svm = LiteSVM::default()
    .with_sigverify(false);

with_blockhash_check

pub fn with_blockhash_check(self, check: bool) -> Self

Activer ou désactiver la validation du blockhash. Par défaut : true.

// Disable to use any blockhash
let mut svm = LiteSVM::default()
    .with_blockhash_check(false);

with_transaction_history

pub fn with_transaction_history(self, capacity: usize) -> Self

Définir le nombre de transactions à conserver dans l'historique. Par défaut : 0.

// Keep last 100 transactions
let mut svm = LiteSVM::default()
    .with_transaction_history(100);

with_log_bytes_limit

pub fn with_log_bytes_limit(self, limit: Option<usize>) -> Self

Définir le nombre maximal d'octets pour les journaux de transactions. Par défaut : Some(10_000).

// Unlimited logs
let mut svm = LiteSVM::default()
    .with_log_bytes_limit(None);

// Custom limit (50KB)
let mut svm = LiteSVM::default()
    .with_log_bytes_limit(Some(50_000));

with_lamports

pub fn with_lamports(self, lamports: u64) -> Self

Définit les lamports initiaux pour la collecte des frais. Par défaut : 1_000_000_000.

let mut svm = LiteSVM::default()
    .with_lamports(10_000_000_000);

with_default_programs

pub fn with_default_programs(self) -> Self

Inclut les programmes SPL par défaut (Token, Associated Token, etc.).

let mut svm = LiteSVM::default()
    .with_default_programs();

with_sysvars

pub fn with_sysvars(self) -> Self

Inclut les sysvars par défaut (Clock, Rent, EpochSchedule, SlotHashes, StakeHistory, etc.).

let mut svm = LiteSVM::default()
    .with_sysvars();

with_feature_set

pub fn with_feature_set(self, feature_set: FeatureSet) -> Self

Configure l'ensemble de fonctionnalités Solana pour tester des fonctions d'exécution spécifiques.

use agave_feature_set::FeatureSet;

let mut svm = LiteSVM::default()
    .with_feature_set(FeatureSet::all_enabled());

with_precompiles

#[cfg(feature = "precompiles")]
pub fn with_precompiles(self) -> Self

Inclut les programmes précompilés standard (ed25519, secp256k1, secp256r1).

let mut svm = LiteSVM::default()
    .with_precompiles();

Nécessite le flag de fonctionnalité precompiles :

[dev-dependencies]
litesvm = { version = "0.11", features = ["precompiles"] }

with_feature_accounts

pub fn with_feature_accounts(self) -> Self

Inclut les comptes de portail de fonctionnalités dans l'environnement de test. Cela garantit que le comportement d'exécution de Solana conditionné par les fonctionnalités est fidèlement reflété dans vos tests.

let mut svm = LiteSVM::default()
    .with_feature_accounts();

Fonctionnalité register-tracing

La fonctionnalité register-tracing permet un traçage détaillé des registres SBF lors de l'exécution des transactions. Elle implique la fonctionnalité invocation-inspect-callback.

[dev-dependencies]
litesvm = { version = "0.11", features = ["register-tracing"] }

Utilisez LiteSVM::new_debuggable(true) pour créer une instance avec le traçage des registres activé :

#[cfg(feature = "register-tracing")]
let mut svm = LiteSVM::new_debuggable(true);

Lorsqu'il est activé, définissez la variable d'environnement SBF_TRACE_DISASSEMBLE pour également afficher la sortie de désassemblage en parallèle des traces de registres :

SBF_TRACE_DISASSEMBLE=1 cargo test

set_invocation_inspect_callback

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

Enregistrez un callback qui se déclenche avant et après chaque invocation de programme. Nécessite la fonctionnalité invocation-inspect-callback.

[dev-dependencies]
litesvm = { version = "0.11", features = ["invocation-inspect-callback"] }

use litesvm::{LiteSVM, types::InvocationInspectCallback};
use solana_svm::invoke_context::InvokeContext;
use solana_svm_transaction::svm_message::SVMMessage;

struct MyInspector;

impl InvocationInspectCallback for MyInspector {
    fn before_invocation(
        &self,
        _svm: &LiteSVM,
        _tx: &impl SVMMessage,
        _program_indices: &[u16],
        _invoke_context: &InvokeContext,
    ) {
        println!("Before program invocation");
    }

    fn after_invocation(
        &self,
        _svm: &LiteSVM,
        _invoke_context: &InvokeContext,
        _enable_register_tracing: bool,
    ) {
        println!("After program invocation");
    }
}

let mut svm = LiteSVM::new();
svm.set_invocation_inspect_callback(MyInspector);

Table des matières