Início Rápido

Ver litesvm-utils no crates.io

Instalação

Certifique-se de que possui todas as dependências necessárias:

cargo add --dev litesvm litesvm-utils

O crate litesvm-utils fornece traits auxiliares essenciais e utilitários que simplificam os testes de programas Solana. Ele reduz o código boilerplate comum de testes de mais de 30 linhas para um código mínimo e legível através de APIs ergonômicas.

Trait TestHelpers

Crie contas com fundos com uma única chamada de método
Configure token mints e token accounts facilmente
Derive PDAs sem boilerplate
Gerencie slots para testes baseados em tempo

Trait AssertionHelpers - Verifique estados de contas (existente, fechada, proprietário) - Valide saldos de token accounts e fornecimento de mints - Verifique saldos de SOL - Valide o tamanho dos dados das contas

Trait TransactionHelpers - Execute instruções com tratamento detalhado de resultados - Verifique o sucesso ou falha de transações - Verifique códigos de erro específicos - Inspecione logs de transações e unidades de computação

LiteSVMBuilder - Padrão builder fluente para configuração do ambiente de testes - Implante programas com encadeamento de métodos - Métodos de fábrica estáticos convenientes

Exemplo Rápido

Aqui está um exemplo completo que demonstra o poder do 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);
}

Principais Benefícios

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

Depois do litesvm-utils

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

Visão Geral dos Traits

TestHelpers

Method	Returns	Description
`create_funded_account(lamports)`	`Result<Keypair>`	Cria um keypair e o financia
`create_funded_accounts(count, lamports)`	`Result<Vec<Keypair>>`	Cria múltiplos keypairs financiados
`create_token_mint(authority, decimals)`	`Result<Keypair>`	Cria um mint de token SPL
`create_token_account(mint, owner)`	`Result<Keypair>`	Cria um token account regular
`create_associated_token_account(mint, owner)`	`Result<Pubkey>`	Cria uma ATA e retorna seu endereço
`mint_to(mint, account, authority, amount)`	`Result<()>`	Emite tokens para uma conta
`derive_pda(seeds, program_id)`	`(Pubkey, u8)`	Deriva um PDA com bump seed
`get_pda(seeds, program_id)`	`Pubkey`	Obtém apenas o endereço do PDA
`get_pda_with_bump(seeds, program_id)`	`(Pubkey, u8)`	Alias para `derive_pda`
`get_current_slot()`	`u64`	Retorna o slot atual
`advance_slot(slots)`	`()`	Avança o tempo em N slots

AssertionHelpers

Method	Description
`assert_account_exists(pubkey)`	Entra em pânico se a conta não existir
`assert_account_closed(pubkey)`	Entra em pânico se a conta existir e tiver dados/lamports
`assert_token_balance(account, amount)`	Verifica o saldo de tokens
`assert_sol_balance(pubkey, lamports)`	Verifica o saldo de SOL
`assert_mint_supply(mint, supply)`	Verifica o fornecimento total do mint
`assert_account_owner(pubkey, owner)`	Verifica o proprietário da conta
`assert_account_data_len(pubkey, len)`	Verifica o comprimento dos dados

TransactionHelpers

Method	Returns	Description
`send_instruction(ix, signers)`	`Result<TransactionResult, TransactionError>`	Envia uma única instrução
`send_instructions(ixs, signers)`	`Result<TransactionResult, TransactionError>`	Envia múltiplas instruções em uma tx
`send_transaction_result(tx)`	`Result<TransactionResult, TransactionError>`	Envia um `Transaction` bruto

Solução de Problemas

Erros Comuns

Erro	Causa	Solução
`AccountNotFound`	Tentativa de usar uma conta que não existe	Use `create_funded_account` primeiro
`InsufficientFunds`	lamports insuficientes para a transação	Aumente o valor de financiamento inicial
`OwnerMismatch`	Conta pertence a um programa incorreto	Verifique o ID do programa correto
`AssertionFailed`	Saldo ou estado não corresponde ao esperado	Verifique a lógica do seu teste