Avvio Rapido

Visualizza litesvm-utils su crates.io

Installazione

Assicurati di avere tutte le dipendenze necessarie:

cargo add --dev litesvm litesvm-utils

Il crate litesvm-utils fornisce trait helper essenziali e utilità che semplificano il testing dei programmi Solana. Riduce il codice boilerplate comune nei test da 30+ righe a codice minimale e leggibile tramite API ergonomiche.

Trait TestHelpers

Crea account finanziati con una singola chiamata al metodo
Configura facilmente mint di token e token account
Deriva PDA senza boilerplate
Gestisci gli slot per i test basati sul tempo

Trait AssertionHelpers - Verifica gli stati degli account (esistente, chiuso, proprietario) - Controlla i saldi dei token e le forniture dei mint - Controlla i saldi SOL - Valida le lunghezze dei dati degli account

Trait TransactionHelpers - Esegui istruzioni con gestione avanzata dei risultati - Verifica il successo o il fallimento delle transazioni - Controlla codici di errore specifici - Ispeziona i log delle transazioni e le unità di calcolo

LiteSVMBuilder

Pattern builder fluente per la configurazione dell'ambiente di test
Distribuisci programmi con method chaining
Pratici metodi factory statici

Esempio Rapido

Ecco un esempio completo che mostra la potenza di litesvm-utils:

use litesvm_utils::{AssertionHelpers, LiteSVM, Signer, TestHelpers, TransactionHelpers};
use solana_sdk::{native_token::LAMPORTS_PER_SOL, system_instruction};

#[test]
fn test_with_utils() {
    let mut svm = LiteSVM::new();

    // Create funded accounts in one line
    let alice = svm.create_funded_account(10 * LAMPORTS_PER_SOL).unwrap();
    let bob = svm.create_funded_account(0).unwrap();

    // Create a token mint easily
    let mint = svm.create_token_mint(&alice, 9).unwrap();

    // Create associated token accounts (returns Pubkey)
    let alice_ata = svm.create_associated_token_account(&mint.pubkey(), &alice).unwrap();
    let bob_ata = svm.create_associated_token_account(&mint.pubkey(), &bob).unwrap();

    // Mint tokens
    svm.mint_to(&mint.pubkey(), &alice_ata, &alice, 1000).unwrap();

    // Assert balances
    svm.assert_token_balance(&alice_ata, 1000);
    svm.assert_token_balance(&bob_ata, 0);

    // Execute a SOL transfer with rich result handling
    let transfer_ix = system_instruction::transfer(
        &alice.pubkey(),
        &bob.pubkey(),
        LAMPORTS_PER_SOL,
    );

    let result = svm.send_instruction(transfer_ix, &[&alice]).unwrap();
    result.assert_success();

    // Verify the transfer
    svm.assert_sol_balance(&bob.pubkey(), LAMPORTS_PER_SOL);
}

Vantaggi Principali

Prima di litesvm-utils

// Creating a funded account manually
let keypair = Keypair::new();
let airdrop_tx = Transaction::new_signed_with_payer(
    &[system_instruction::transfer(
        &payer.pubkey(),
        &keypair.pubkey(),
        lamports,
    )],
    Some(&payer.pubkey()),
    &[&payer],
    svm.latest_blockhash(),
);
svm.send_transaction(airdrop_tx).unwrap();

Dopo litesvm-utils

// One line to create a funded account
let keypair = svm.create_funded_account(lamports).unwrap();

Panoramica dei Trait

TestHelpers

Metodo	Restituisce	Descrizione
`create_funded_account(lamports)`	`Result<Keypair>`	Crea un keypair e lo finanzia
`create_funded_accounts(count, lamports)`	`Result<Vec<Keypair>>`	Crea più keypair finanziati
`create_token_mint(authority, decimals)`	`Result<Keypair>`	Crea un mint di token SPL
`create_token_account(mint, owner)`	`Result<Keypair>`	Crea un token account regolare
`create_associated_token_account(mint, owner)`	`Result<Pubkey>`	Crea un ATA e restituisce il suo indirizzo
`mint_to(mint, account, authority, amount)`	`Result<()>`	Conia token su un account
`derive_pda(seeds, program_id)`	`(Pubkey, u8)`	Deriva un PDA con bump seed
`get_pda(seeds, program_id)`	`Pubkey`	Ottiene solo l'indirizzo del PDA
`get_pda_with_bump(seeds, program_id)`	`(Pubkey, u8)`	Alias per `derive_pda`
`get_current_slot()`	`u64`	Restituisce lo slot corrente
`advance_slot(slots)`	`()`	Avanza il tempo di N slot

AssertionHelpers

Metodo	Descrizione
`assert_account_exists(pubkey)`	Va in panic se l'account non esiste
`assert_account_closed(pubkey)`	Va in panic se l'account esiste e ha dati/lamport
`assert_token_balance(account, amount)`	Verifica il saldo del token
`assert_sol_balance(pubkey, lamports)`	Verifica il saldo SOL
`assert_mint_supply(mint, supply)`	Verifica la fornitura totale del mint
`assert_account_owner(pubkey, owner)`	Verifica il proprietario dell'account
`assert_account_data_len(pubkey, len)`	Verifica la lunghezza dei dati

TransactionHelpers

Metodo	Restituisce	Descrizione
`send_instruction(ix, signers)`	`Result<TransactionResult, TransactionError>`	Invia una singola istruzione
`send_instructions(ixs, signers)`	`Result<TransactionResult, TransactionError>`	Invia più istruzioni in una sola tx
`send_transaction_result(tx)`	`Result<TransactionResult, TransactionError>`	Invia una `Transaction` grezza

Risoluzione dei problemi

Errori comuni

Errore	Causa	Soluzione
`AccountNotFound`	Tentativo di utilizzare un account inesistente	Usare prima `create_funded_account`
`InsufficientFunds`	lamport insufficienti per la transazione	Aumentare l'importo di finanziamento iniziale
`OwnerMismatch`	Account di proprietà del programma errato	Verificare l'ID del programma corretto
`AssertionFailed`	Il saldo o lo stato non corrisponde al valore atteso	Controllare la logica del test