Démarrage rapide

Voir litesvm-utils sur crates.io

Installation

Assurez-vous d'avoir toutes les dépendances nécessaires :

cargo add --dev litesvm litesvm-utils

La crate litesvm-utils fournit des traits utilitaires et des outils essentiels qui simplifient les tests de programmes Solana. Elle réduit le code passe-partout courant des tests de plus de 30 lignes à un code minimal et lisible grâce à des API ergonomiques.

Trait TestHelpers

Créer des comptes financés avec un seul appel de méthode
Configurer facilement des mints de token et des token accounts
Dériver des PDAs sans code passe-partout
Gérer les slots pour les tests basés sur le temps

Trait AssertionHelpers - Vérifier les états de compte (existant, fermé, propriétaire) - Contrôler les soldes de token et les approvisionnements de mint - Vérifier les soldes SOL - Valider les longueurs des données de compte

Trait TransactionHelpers - Exécuter des instructions avec une gestion riche des résultats - Affirmer le succès ou l'échec d'une transaction - Vérifier des codes d'erreur spécifiques - Inspecter les journaux de transaction et les unités de calcul

LiteSVMBuilder

Patron de conception builder fluide pour la configuration de l'environnement de test
Déployer des programmes par chaînage de méthodes
Méthodes de fabrique statiques pratiques

Exemple rapide

Voici un exemple complet illustrant la puissance de 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);
}

Principaux avantages

Avant 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();

Après litesvm-utils

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

Aperçu des traits

TestHelpers

Method	Returns	Description
`create_funded_account(lamports)`	`Result<Keypair>`	Crée un keypair et l'approvisionne
`create_funded_accounts(count, lamports)`	`Result<Vec<Keypair>>`	Crée plusieurs keypairs approvisionnés
`create_token_mint(authority, decimals)`	`Result<Keypair>`	Crée un mint de token SPL
`create_token_account(mint, owner)`	`Result<Keypair>`	Crée un token account standard
`create_associated_token_account(mint, owner)`	`Result<Pubkey>`	Crée un ATA et retourne son adresse
`mint_to(mint, account, authority, amount)`	`Result<()>`	Émet des tokens vers un compte
`derive_pda(seeds, program_id)`	`(Pubkey, u8)`	Dérive un PDA avec bump seed
`get_pda(seeds, program_id)`	`Pubkey`	Retourne uniquement l'adresse du PDA
`get_pda_with_bump(seeds, program_id)`	`(Pubkey, u8)`	Alias pour `derive_pda`
`get_current_slot()`	`u64`	Retourne le slot actuel
`advance_slot(slots)`	`()`	Avance le temps de N slots

AssertionHelpers

Method	Description
`assert_account_exists(pubkey)`	Échoue si le compte n'existe pas
`assert_account_closed(pubkey)`	Échoue si le compte existe et possède des données/lamports
`assert_token_balance(account, amount)`	Vérifie le solde de tokens
`assert_sol_balance(pubkey, lamports)`	Vérifie le solde SOL
`assert_mint_supply(mint, supply)`	Vérifie l'offre totale du mint
`assert_account_owner(pubkey, owner)`	Vérifie le propriétaire du compte
`assert_account_data_len(pubkey, len)`	Vérifie la longueur des données

TransactionHelpers

Method	Returns	Description
`send_instruction(ix, signers)`	`Result<TransactionResult, TransactionError>`	Envoie une instruction unique
`send_instructions(ixs, signers)`	`Result<TransactionResult, TransactionError>`	Envoie plusieurs instructions en une seule tx
`send_transaction_result(tx)`	`Result<TransactionResult, TransactionError>`	Envoie un `Transaction` brut

Résolution des problèmes

Erreurs courantes

Erreur	Cause	Solution
`AccountNotFound`	Tentative d'utilisation d'un compte inexistant	Utilisez `create_funded_account` en premier
`InsufficientFunds`	Pas assez de lamports pour la transaction	Augmentez le montant du financement initial
`OwnerMismatch`	Compte appartenant à un mauvais programme	Vérifiez l'identifiant du programme correct
`AssertionFailed`	Le solde ou l'état ne correspond pas à ce qui est attendu	Vérifiez votre logique de test