Snelstart

Bekijk litesvm-utils op crates.io

Installatie

Zorg ervoor dat je alle benodigde afhankelijkheden hebt:

cargo add --dev litesvm litesvm-utils

De litesvm-utils crate biedt essentiële hulptraits en hulpprogramma's die het testen van Solana-programma's vereenvoudigen. Het reduceert veelvoorkomende testboilerplate van 30+ regels naar minimale, leesbare code via ergonomische API's.

TestHelpers Trait

Maak gefinancierde accounts aan met één methodeaanroep
Stel eenvoudig token mints en token accounts in
Leid PDAs af zonder boilerplate
Beheer slots voor tijdgebaseerde tests

AssertionHelpers Trait - Controleer accountstatussen (bestaat, gesloten, eigenaar) - Verifieer token-saldi en mint-voorraden - Controleer SOL-saldi - Valideer accountdatalengtes

TransactionHelpers Trait - Voer instructies uit met uitgebreide resultaatverwerking - Bevestig transactiesucces of -mislukking - Controleer op specifieke foutcodes - Inspecteer transactielogboeken en compute units

LiteSVMBuilder - Vloeiend builderpatroon voor het instellen van de testomgeving - Implementeer programma's met method chaining - Handige statische fabrieksmethoden

Snel voorbeeld

Hier is een volledig voorbeeld dat de kracht van litesvm-utils toont:

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);
}

Belangrijkste voordelen

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

Na litesvm-utils

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

Trait-overzicht

TestHelpers

Method	Returns	Description
`create_funded_account(lamports)`	`Result<Keypair>`	Maakt een keypair aan en financiert het
`create_funded_accounts(count, lamports)`	`Result<Vec<Keypair>>`	Maakt meerdere gefinancierde keypairs aan
`create_token_mint(authority, decimals)`	`Result<Keypair>`	Maakt een SPL token mint aan
`create_token_account(mint, owner)`	`Result<Keypair>`	Maakt een gewone token account aan
`create_associated_token_account(mint, owner)`	`Result<Pubkey>`	Maakt een ATA aan en geeft het adres terug
`mint_to(mint, account, authority, amount)`	`Result<()>`	Mint tokens naar een account
`derive_pda(seeds, program_id)`	`(Pubkey, u8)`	Leidt een PDA af met bump seed
`get_pda(seeds, program_id)`	`Pubkey`	Geeft alleen het PDA-adres terug
`get_pda_with_bump(seeds, program_id)`	`(Pubkey, u8)`	Alias voor `derive_pda`
`get_current_slot()`	`u64`	Geeft de huidige slot terug
`advance_slot(slots)`	`()`	Zet de tijd N slots vooruit

AssertionHelpers

Method	Description
`assert_account_exists(pubkey)`	Geeft een foutmelding als het account niet bestaat
`assert_account_closed(pubkey)`	Geeft een foutmelding als het account bestaat en data/lamports heeft
`assert_token_balance(account, amount)`	Verifieert het tokensaldo
`assert_sol_balance(pubkey, lamports)`	Verifieert het SOL-saldo
`assert_mint_supply(mint, supply)`	Verifieert de totale voorraad van de mint
`assert_account_owner(pubkey, owner)`	Verifieert de accounteigenaar
`assert_account_data_len(pubkey, len)`	Verifieert de gegevenslengte

TransactionHelpers

Method	Returns	Description
`send_instruction(ix, signers)`	`Result<TransactionResult, TransactionError>`	Verstuurt één instructie
`send_instructions(ixs, signers)`	`Result<TransactionResult, TransactionError>`	Verstuurt meerdere instructies in één transactie
`send_transaction_result(tx)`	`Result<TransactionResult, TransactionError>`	Verstuurt een ruwe `Transaction`

Probleemoplossing

Veelvoorkomende fouten

Fout	Oorzaak	Oplossing
`AccountNotFound`	Proberen een account te gebruiken dat niet bestaat	Gebruik eerst `create_funded_account`
`InsufficientFunds`	Niet genoeg lamports voor de transactie	Vergroot het initiële financieringsbedrag
`OwnerMismatch`	Account eigendom van verkeerd programma	Controleer het juiste programma-ID
`AssertionFailed`	Saldo of status komt niet overeen met verwacht	Controleer je testlogica