LiteSVM

Overview

LiteSVM is a fast and lightweight library for testing Solana programs. It works by creating an in-process Solana VM optimized for program developers, making it much faster to run and compile than alternatives like solana-program-test and solana-test-validator. LiteSVM is available in:

Rust - Full-featured testing in Rust
TypeScript/JavaScript - Client-side testing with full SVM access
Python - Testing via the solders library

Key Features

Blazingly Fast - No validator startup time, tests run in milliseconds
Lightweight - Minimal resource usage, compiles quickly
Multi-Language - Use Rust, TypeScript, or Python
Time Travel - Manipulate clock and slots for testing time-dependent logic
Arbitrary Accounts - Write any account data, even impossible states
Real SVM - Tests run against actual Solana VM, not a mock

When to Use LiteSVM

LiteSVM is ideal for:

Unit Testing - Test individual instructions in isolation
Fast Iteration - Rapid test feedback during development
CI/CD Pipelines - Quick test execution in automated builds
Account Manipulation - Testing edge cases with custom account states
Time-Dependent Logic - Programs that use the Clock sysvar

Use solana-test-validator when you need full RPC support or want to test against real validator behavior.

Installation

Tab Title
Tab Title
Tab Title

cargo add litesvm --dev

npm install litesvm --save-dev

# LiteSVM is part of solders
pip install solders

Quick Start

Here’s a simple transfer example to get you started:

Tab Title
Tab Title
Tab Title

use litesvm::LiteSVM;
use solana_sdk::{
    signature::{Keypair, Signer},
    transaction::Transaction,
    system_instruction::transfer,
    message::Message,
};

#[test]
fn test_transfer() {
    let mut svm = LiteSVM::new();
    let from = Keypair::new();
    let to = Keypair::new();
    
    // Airdrop SOL to sender
    svm.airdrop(&from.pubkey(), 10_000_000).unwrap();
    
    // Create transfer instruction
    let ix = transfer(&from.pubkey(), &to.pubkey(), 1_000_000);
    let tx = Transaction::new(
        &[&from],
        Message::new(&[ix], Some(&from.pubkey())),
        svm.latest_blockhash(),
    );
    
    // Send transaction
    svm.send_transaction(tx).unwrap();
    
    // Verify balances
    assert_eq!(svm.get_balance(&to.pubkey()), 1_000_000);
}

import { LiteSVM } from "litesvm";
import {
  Keypair,
  Transaction,
  SystemProgram,
  LAMPORTS_PER_SOL,
} from "@solana/web3.js";

test("transfer SOL", () => {
  const svm = new LiteSVM();
  const from = new Keypair();
  const to = Keypair.generate().publicKey;
  
  // Airdrop SOL to sender
  svm.airdrop(from.publicKey, BigInt(LAMPORTS_PER_SOL));
  
  // Create transfer
  const tx = new Transaction();
  tx.recentBlockhash = svm.latestBlockhash();
  tx.add(
    SystemProgram.transfer({
      fromPubkey: from.publicKey,
      toPubkey: to,
      lamports: 1_000_000n,
    })
  );
  tx.sign(from);
  
  // Send transaction
  svm.sendTransaction(tx);
  
  // Verify balance
  expect(svm.getBalance(to)).toBe(1_000_000n);
});

from solders.keypair import Keypair
from solders.litesvm import LiteSVM
from solders.message import Message
from solders.system_program import transfer
from solders.transaction import VersionedTransaction

def test_transfer():
    svm = LiteSVM()
    from_keypair = Keypair()
    to_pubkey = Keypair().pubkey()
    
    # Airdrop SOL
    svm.airdrop(from_keypair.pubkey(), 1_000_000_000)
    
    # Create transfer
    ix = transfer({
        "from_pubkey": from_keypair.pubkey(),
        "to_pubkey": to_pubkey,
        "lamports": 1_000_000,
    })
    
    msg = Message.new_with_blockhash(
        [ix],
        from_keypair.pubkey(),
        svm.latest_blockhash(),
    )
    tx = VersionedTransaction(msg, [from_keypair])
    
    # Send transaction
    svm.send_transaction(tx)
    
    # Verify balance
    assert svm.get_balance(to_pubkey) == 1_000_000

Testing Anchor Programs

To test an Anchor program with LiteSVM, you need to load the compiled program binary:

Tab Title
Tab Title
Tab Title

use litesvm::LiteSVM;
use solana_sdk::{
    signature::Keypair,
    signer::Signer,
    instruction::{Instruction, AccountMeta},
    transaction::Transaction,
    message::Message,
};

#[test]
fn test_anchor_program() {
    let mut svm = LiteSVM::new();
    let program_id = /* your program ID */;
    
    // Load program from compiled binary
    let program_data = include_bytes!("../../target/deploy/my_program.so");
    svm.add_program(program_id, program_data);
    
    // Set up accounts
    let user = Keypair::new();
    let my_account = Keypair::new();
    svm.airdrop(&user.pubkey(), 10_000_000).unwrap();
    
    // Create instruction (using Anchor IDL)
    let ix = Instruction {
        program_id,
        accounts: vec![
            AccountMeta::new(my_account.pubkey(), true),
            AccountMeta::new(user.pubkey(), true),
            AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
        ],
        data: vec![/* instruction data */],
    };
    
    // Send transaction
    let tx = Transaction::new(
        &[&user, &my_account],
        Message::new(&[ix], Some(&user.pubkey())),
        svm.latest_blockhash(),
    );
    
    let result = svm.send_transaction(tx).unwrap();
    assert!(result.result.is_ok());
}

import { LiteSVM } from "litesvm";
import { Keypair, PublicKey, Transaction, TransactionInstruction } from "@solana/web3.js";
import * as fs from "fs";

test("anchor program", () => {
  const svm = new LiteSVM();
  const programId = new PublicKey("YourProgramID");
  
  // Load program binary
  svm.addProgramFromFile(
    programId,
    "target/deploy/my_program.so"
  );
  
  // Set up accounts
  const user = new Keypair();
  const myAccount = Keypair.generate();
  svm.airdrop(user.publicKey, 10_000_000n);
  
  // Create instruction
  const ix = new TransactionInstruction({
    programId,
    keys: [
      { pubkey: myAccount.publicKey, isSigner: true, isWritable: true },
      { pubkey: user.publicKey, isSigner: true, isWritable: true },
    ],
    data: Buffer.from([/* instruction data */]),
  });
  
  // Send transaction
  const tx = new Transaction();
  tx.recentBlockhash = svm.latestBlockhash();
  tx.add(ix);
  tx.sign(user, myAccount);
  
  const result = svm.sendTransaction(tx);
  expect(result).toBeTruthy();
});

from pathlib import Path
from solders.keypair import Keypair
from solders.litesvm import LiteSVM
from solders.pubkey import Pubkey
from solders.instruction import Instruction, AccountMeta
from solders.message import Message
from solders.transaction import VersionedTransaction

def test_anchor_program():
    svm = LiteSVM()
    program_id = Pubkey.from_string("YourProgramID")
    
    # Load program
    svm.add_program_from_file(
        program_id,
        Path("target/deploy/my_program.so")
    )
    
    # Set up accounts
    user = Keypair()
    my_account = Keypair()
    svm.airdrop(user.pubkey(), 10_000_000)
    
    # Create instruction
    ix = Instruction(
        program_id,
        bytes([]),  # instruction data
        [
            AccountMeta(my_account.pubkey(), is_signer=True, is_writable=True),
            AccountMeta(user.pubkey(), is_signer=True, is_writable=True),
        ],
    )
    
    # Send transaction
    msg = Message.new_with_blockhash([ix], user.pubkey(), svm.latest_blockhash())
    tx = VersionedTransaction(msg, [user, my_account])
    
    result = svm.send_transaction(tx)
    assert result is not None

Time Travel

LiteSVM allows you to manipulate the Clock sysvar to test time-dependent logic:

Tab Title
Tab Title
Tab Title

use litesvm::LiteSVM;
use solana_sdk::clock::Clock;

#[test]
fn test_time_travel() {
    let mut svm = LiteSVM::new();
    
    // Get current clock
    let mut clock = svm.get_sysvar::<Clock>();
    println!("Current time: {}", clock.unix_timestamp);
    
    // Advance time by 1 hour
    clock.unix_timestamp += 3600;
    svm.set_sysvar::<Clock>(&clock);
    
    // Verify new time
    let new_clock = svm.get_sysvar::<Clock>();
    assert_eq!(new_clock.unix_timestamp, clock.unix_timestamp);
}

import { LiteSVM } from "litesvm";

test("time travel", () => {
  const svm = new LiteSVM();
  
  // Get current clock
  const clock = svm.getClock();
  console.log("Current time:", clock.unixTimestamp);
  
  // Advance time by 1 hour
  clock.unixTimestamp = clock.unixTimestamp + 3600n;
  svm.setClock(clock);
  
  // Verify new time
  const newClock = svm.getClock();
  expect(newClock.unixTimestamp).toBe(clock.unixTimestamp);
});

from solders.litesvm import LiteSVM

def test_time_travel():
    svm = LiteSVM()
    
    # Get current clock
    clock = svm.get_clock()
    print(f"Current time: {clock.unix_timestamp}")
    
    # Advance time by 1 hour
    clock.unix_timestamp += 3600
    svm.set_clock(clock)
    
    # Verify new time
    new_clock = svm.get_clock()
    assert new_clock.unix_timestamp == clock.unix_timestamp

You can also jump to a specific slot:

svm.warp_to_slot(1000);

Arbitrary Account States

LiteSVM lets you write any account data, even states that would be impossible to achieve normally. This is useful for testing edge cases:

Tab Title
Tab Title
Tab Title

use litesvm::LiteSVM;
use solana_sdk::{
    account::Account,
    pubkey::Pubkey,
};
use spl_token::state::{Account as TokenAccount, AccountState};

#[test]
fn test_arbitrary_token_balance() {
    let mut svm = LiteSVM::new();
    let owner = Pubkey::new_unique();
    let token_account = Pubkey::new_unique();
    
    // Create token account with arbitrary balance
    let account_data = TokenAccount {
        mint: Pubkey::new_unique(),
        owner,
        amount: 1_000_000_000_000, // 1 trillion tokens!
        delegate: None,
        state: AccountState::Initialized,
        is_native: None,
        delegated_amount: 0,
        close_authority: None,
    };
    
    let mut data = vec![0u8; TokenAccount::LEN];
    TokenAccount::pack(account_data, &mut data).unwrap();
    
    svm.set_account(
        token_account,
        Account {
            lamports: 1_000_000,
            data,
            owner: spl_token::ID,
            executable: false,
            rent_epoch: 0,
        },
    ).unwrap();
    
    // Now test with this account
    let acc = svm.get_account(&token_account).unwrap();
    let token_acc = TokenAccount::unpack(&acc.data).unwrap();
    assert_eq!(token_acc.amount, 1_000_000_000_000);
}

import { LiteSVM } from "litesvm";
import { PublicKey } from "@solana/web3.js";
import { AccountLayout, TOKEN_PROGRAM_ID } from "@solana/spl-token";

test("arbitrary token balance", () => {
  const svm = new LiteSVM();
  const owner = PublicKey.unique();
  const mint = PublicKey.unique();
  const tokenAccount = PublicKey.unique();
  
  // Create token account data
  const accountData = Buffer.alloc(165);
  AccountLayout.encode(
    {
      mint,
      owner,
      amount: 1_000_000_000_000n,
      delegateOption: 0,
      delegate: PublicKey.default,
      state: 1,
      isNativeOption: 0,
      isNative: 0n,
      delegatedAmount: 0n,
      closeAuthorityOption: 0,
      closeAuthority: PublicKey.default,
    },
    accountData
  );
  
  // Set the account
  svm.setAccount(tokenAccount, {
    lamports: 1_000_000,
    data: accountData,
    owner: TOKEN_PROGRAM_ID,
    executable: false,
  });
  
  // Verify
  const acc = svm.getAccount(tokenAccount);
  const decoded = AccountLayout.decode(acc.data);
  expect(decoded.amount).toBe(1_000_000_000_000n);
});

from solders.account import Account
from solders.litesvm import LiteSVM
from solders.pubkey import Pubkey
from solders.token import ID as TOKEN_PROGRAM_ID
from solders.token.state import TokenAccount, TokenAccountState

def test_arbitrary_token_balance():
    svm = LiteSVM()
    owner = Pubkey.new_unique()
    mint = Pubkey.new_unique()
    token_account_pubkey = Pubkey.new_unique()
    
    # Create token account with huge balance
    token_account = TokenAccount(
        mint=mint,
        owner=owner,
        amount=1_000_000_000_000,
        delegate=None,
        state=TokenAccountState.Initialized,
        is_native=None,
        delegated_amount=0,
        close_authority=None,
    )
    
    # Set account in SVM
    svm.set_account(
        token_account_pubkey,
        Account(
            lamports=1_000_000,
            data=bytes(token_account),
            owner=TOKEN_PROGRAM_ID,
            executable=False,
        ),
    )
    
    # Verify
    acc = svm.get_account(token_account_pubkey)
    decoded = TokenAccount.from_bytes(acc.data)
    assert decoded.amount == 1_000_000_000_000

Advanced Features

Compute Budget Control

let mut svm = LiteSVM::new()
    .with_compute_budget(1_000_000); // Set max compute units

Disable Signature Verification

let mut svm = LiteSVM::new()
    .with_sigverify(false); // Skip signature checks (faster tests)

Transaction History

let tx_result = svm.send_transaction(tx).unwrap();
let signature = tx_result.signature;

// Later, retrieve transaction
let stored_tx = svm.get_transaction(signature);

Performance Comparison

Framework	Startup Time	Test Speed	Resource Usage
LiteSVM	~0ms	Fastest	Minimal
solana-program-test	~50ms	Fast	Low
solana-test-validator	~5000ms	Slow	High

Best Practices

Use LiteSVM for unit tests - Test individual instructions quickly
Use test-validator for integration - Test full workflows and RPC interactions
Mock account states - Use arbitrary accounts to test edge cases
Time travel for scheduling - Test time-locked features without waiting
Parallel tests - LiteSVM tests can run in parallel safely

Limitations

No RPC methods - LiteSVM doesn’t expose RPC endpoints
Simplified validator - Doesn’t simulate all validator behaviors
No cross-program invocation limits - May behave differently than production

For testing that requires full validator fidelity, use solana-test-validator.

Next Steps

Learn about [Mollusktesting/mollusk) for even lighter Rust testing
Explore [Testing Overviewtesting/overview) for testing strategies
Check out the LiteSVM GitHub for more examples

Get Started

Core Concepts

Building Programs

Client Libraries

Testing

Token Extensions

Advanced

Overview

Key Features

When to Use LiteSVM

Installation

Quick Start

Testing Anchor Programs

Time Travel

Arbitrary Account States

Advanced Features

Compute Budget Control

Disable Signature Verification

Transaction History

Performance Comparison

Best Practices

Limitations

Next Steps

Build docs developers (and LLMs) love

Get Started

Core Concepts

Building Programs

Client Libraries

Testing

Token Extensions

Advanced

​Overview

​Key Features

​When to Use LiteSVM

​Installation

​Quick Start

​Testing Anchor Programs

​Time Travel

​Arbitrary Account States

​Advanced Features

​Compute Budget Control

​Disable Signature Verification

​Transaction History

​Performance Comparison

​Best Practices

​Limitations

​Next Steps

Build docs developers (and LLMs) love

Overview

Key Features

When to Use LiteSVM

Installation

Quick Start

Testing Anchor Programs

Time Travel

Arbitrary Account States

Advanced Features

Compute Budget Control

Disable Signature Verification

Transaction History

Performance Comparison

Best Practices

Limitations

Next Steps