Assertions

Account Existence

Verify whether accounts exist or have been closed.

Assert Account Exists

use litesvm::LiteSVM;
use litesvm_utils::{TestHelpers, AssertionHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

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

    let alice = svm.create_funded_account(10 * LAMPORTS_PER_SOL);

    // This will pass - account exists
    svm.assert_account_exists(&alice.pubkey());
}

Assert Account Closed

use litesvm::LiteSVM;
use litesvm_utils::{TestHelpers, AssertionHelpers};
use solana_sdk::pubkey::Pubkey;

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

    // A random pubkey that was never created
    let nonexistent = Pubkey::new_unique();

    // This will pass - account doesn't exist
    svm.assert_account_closed(&nonexistent);
}

assert_account_closed passes when an account either doesn't exist, has zero lamports, or has empty data. Use this to verify cleanup after closing accounts.

Balance Assertions

Verify SOL and token balances.

Assert SOL Balance

use litesvm::LiteSVM;
use litesvm_utils::{TestHelpers, AssertionHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

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

    let alice = svm.create_funded_account(10 * LAMPORTS_PER_SOL);

    // Verify Alice has 10 SOL
    svm.assert_sol_balance(&alice.pubkey(), 10 * LAMPORTS_PER_SOL);
}

Assert Token Balance

use litesvm::LiteSVM;
use litesvm_utils::{TestHelpers, AssertionHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

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

    let authority = svm.create_funded_account(10 * LAMPORTS_PER_SOL);
    let user = svm.create_funded_account(5 * LAMPORTS_PER_SOL);

    // Create mint and token account
    let mint = svm.create_token_mint(&authority, 9);
    let user_ata = svm.create_associated_token_account(&mint, &user);

    // Mint tokens
    svm.mint_to(&mint, &user_ata, &authority, 5000);

    // Verify balance
    svm.assert_token_balance(&user_ata, 5000);
}

Assert Mint Supply

use litesvm::LiteSVM;
use litesvm_utils::{TestHelpers, AssertionHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

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

    let authority = svm.create_funded_account(10 * LAMPORTS_PER_SOL);
    let user1 = svm.create_funded_account(5 * LAMPORTS_PER_SOL);
    let user2 = svm.create_funded_account(5 * LAMPORTS_PER_SOL);

    // Create mint
    let mint = svm.create_token_mint(&authority, 9);

    // Create ATAs and mint tokens
    let user1_ata = svm.create_associated_token_account(&mint, &user1);
    let user2_ata = svm.create_associated_token_account(&mint, &user2);

    svm.mint_to(&mint, &user1_ata, &authority, 1000);
    svm.mint_to(&mint, &user2_ata, &authority, 2000);

    // Verify total supply
    svm.assert_mint_supply(&mint, 3000);
}

Account Properties

Verify account ownership and data properties.

Assert Account Owner

use litesvm::LiteSVM;
use litesvm_utils::{TestHelpers, AssertionHelpers};
use solana_sdk::{native_token::LAMPORTS_PER_SOL, system_program};

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

    let alice = svm.create_funded_account(10 * LAMPORTS_PER_SOL);

    // Regular accounts are owned by the System Program
    svm.assert_account_owner(&alice.pubkey(), &system_program::id());
}

use litesvm::LiteSVM;
use litesvm_utils::{TestHelpers, AssertionHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

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

    let authority = svm.create_funded_account(10 * LAMPORTS_PER_SOL);
    let user = svm.create_funded_account(5 * LAMPORTS_PER_SOL);

    let mint = svm.create_token_mint(&authority, 9);
    let user_ata = svm.create_associated_token_account(&mint, &user);

    // Token accounts are owned by the Token Program
    svm.assert_account_owner(&user_ata, &spl_token::id());
}

Assert Account Data Length

use litesvm::LiteSVM;
use litesvm_utils::{TestHelpers, AssertionHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

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

    let authority = svm.create_funded_account(10 * LAMPORTS_PER_SOL);
    let user = svm.create_funded_account(5 * LAMPORTS_PER_SOL);

    let mint = svm.create_token_mint(&authority, 9);
    let user_ata = svm.create_associated_token_account(&mint, &user);

    // Token mint accounts are 82 bytes
    svm.assert_account_data_len(&mint, 82);

    // Token accounts are 165 bytes
    svm.assert_account_data_len(&user_ata, 165);
}

Common account sizes:

Mint Account: 82 bytes
Token Account: 165 bytes
System Account: 0 bytes (just lamports)

Complete Example

Here's a comprehensive test demonstrating multiple assertions:

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

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

    // Setup
    let admin = svm.create_funded_account(100 * LAMPORTS_PER_SOL);
    let alice = svm.create_funded_account(10 * LAMPORTS_PER_SOL);
    let bob = svm.create_funded_account(0);

    // Verify initial SOL balances
    svm.assert_sol_balance(&admin.pubkey(), 100 * LAMPORTS_PER_SOL);
    svm.assert_sol_balance(&alice.pubkey(), 10 * LAMPORTS_PER_SOL);
    svm.assert_sol_balance(&bob.pubkey(), 0);

    // Transfer SOL from Alice to Bob
    let transfer_ix = system_instruction::transfer(
        &alice.pubkey(),
        &bob.pubkey(),
        5 * LAMPORTS_PER_SOL,
    );
    svm.send_instruction(transfer_ix, &[&alice]).assert_success();

    // Verify balances after transfer (Alice paid fees too)
    svm.assert_sol_balance(&bob.pubkey(), 5 * LAMPORTS_PER_SOL);

    // Create token infrastructure
    let mint = svm.create_token_mint(&admin, 6);
    let alice_ata = svm.create_associated_token_account(&mint, &alice);
    let bob_ata = svm.create_associated_token_account(&mint, &bob);

    // Verify account properties
    svm.assert_account_exists(&mint);
    svm.assert_account_exists(&alice_ata);
    svm.assert_account_owner(&mint, &spl_token::id());
    svm.assert_account_data_len(&mint, 82);
    svm.assert_account_data_len(&alice_ata, 165);

    // Mint and verify
    svm.mint_to(&mint, &alice_ata, &admin, 1_000_000);
    svm.mint_to(&mint, &bob_ata, &admin, 500_000);

    svm.assert_token_balance(&alice_ata, 1_000_000);
    svm.assert_token_balance(&bob_ata, 500_000);
    svm.assert_mint_supply(&mint, 1_500_000);

    println!("All assertions passed!");
}

Handling Assertion Failures

When an assertion fails, it will panic with a descriptive message:

// This will panic with a message like:
// "Expected token balance 1000, but got 500"
svm.assert_token_balance(&some_ata, 1000); // when balance is actually 500

Assertions are designed to fail fast with clear error messages. Use them liberally throughout your tests to catch issues early.

Assertions

On this page