Inicio Rápido

Ver litesvm-utils en crates.io

Instalación

Asegúrate de tener todas las dependencias necesarias:

cargo add --dev litesvm litesvm-utils

El crate litesvm-utils proporciona traits auxiliares esenciales y utilidades que simplifican las pruebas de programas en Solana. Reduce el código repetitivo habitual en pruebas de más de 30 líneas a un código mínimo y legible mediante APIs ergonómicas.

Trait TestHelpers

Crea cuentas con fondos con una sola llamada a método
Configura token mints y token accounts fácilmente
Deriva PDAs sin código repetitivo
Gestiona slots para pruebas basadas en tiempo

Trait AssertionHelpers - Verifica estados de cuentas (existencia, cierre, propietario) - Comprueba balances de tokens y suministros de mints - Revisa balances de SOL - Valida longitudes de datos de cuentas

Trait TransactionHelpers - Ejecuta instrucciones con manejo enriquecido de resultados - Confirma el éxito o fallo de transacciones - Comprueba códigos de error específicos - Inspecciona logs de transacciones y unidades de cómputo

LiteSVMBuilder

Patrón builder fluido para configurar el entorno de pruebas
Despliega programas con encadenamiento de métodos
Métodos de fábrica estáticos convenientes

Ejemplo Rápido

Aquí tienes un ejemplo completo que muestra el potencial 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);
}

Beneficios Clave

Antes de 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();

Después de litesvm-utils

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

Descripción General de Traits

TestHelpers

Method	Returns	Description
`create_funded_account(lamports)`	`Result<Keypair>`	Crea un keypair y lo fondea
`create_funded_accounts(count, lamports)`	`Result<Vec<Keypair>>`	Crea múltiples keypairs fondeados
`create_token_mint(authority, decimals)`	`Result<Keypair>`	Crea un mint de token SPL
`create_token_account(mint, owner)`	`Result<Keypair>`	Crea un token account regular
`create_associated_token_account(mint, owner)`	`Result<Pubkey>`	Crea una ATA y devuelve su dirección
`mint_to(mint, account, authority, amount)`	`Result<()>`	Acuña tokens en una cuenta
`derive_pda(seeds, program_id)`	`(Pubkey, u8)`	Deriva un PDA con bump seed
`get_pda(seeds, program_id)`	`Pubkey`	Obtiene solo la dirección del PDA
`get_pda_with_bump(seeds, program_id)`	`(Pubkey, u8)`	Alias de `derive_pda`
`get_current_slot()`	`u64`	Devuelve el slot actual
`advance_slot(slots)`	`()`	Avanza el tiempo N slots

AssertionHelpers

Method	Description
`assert_account_exists(pubkey)`	Lanza pánico si la cuenta no existe
`assert_account_closed(pubkey)`	Lanza pánico si la cuenta existe y tiene datos/lamports
`assert_token_balance(account, amount)`	Verifica el saldo de tokens
`assert_sol_balance(pubkey, lamports)`	Verifica el saldo en SOL
`assert_mint_supply(mint, supply)`	Verifica el suministro total del mint
`assert_account_owner(pubkey, owner)`	Verifica el propietario de la cuenta
`assert_account_data_len(pubkey, len)`	Verifica la longitud de los datos

TransactionHelpers

Method	Returns	Description
`send_instruction(ix, signers)`	`Result<TransactionResult, TransactionError>`	Envía una sola instrucción
`send_instructions(ixs, signers)`	`Result<TransactionResult, TransactionError>`	Envía múltiples instrucciones en una tx
`send_transaction_result(tx)`	`Result<TransactionResult, TransactionError>`	Envía un `Transaction` sin procesar

Solución de problemas

Errores comunes

Error	Causa	Solución
`AccountNotFound`	Intentar usar una cuenta que no existe	Usar `create_funded_account` primero
`InsufficientFunds`	No hay suficientes lamports para la transacción	Aumentar el monto de financiación inicial
`OwnerMismatch`	Cuenta perteneciente a un programa incorrecto	Verificar el ID de programa correcto
`AssertionFailed`	El saldo o el estado no coincide con lo esperado	Revisar la lógica de tu prueba