Account Management

pub fn airdrop(&mut self, pubkey: &Pubkey, lamports: u64) -> TransactionResult

let keypair = Keypair::new();

// Option 1: Ignore result if you don't care about tx details
svm.airdrop(&keypair.pubkey(), 10_000_000_000).unwrap();

// Option 2: Check transaction metadata
match svm.airdrop(&keypair.pubkey(), 10_000_000_000) {
    Ok(meta) => {
        println!("Airdrop successful");
        println!("Compute units: {}", meta.compute_units_consumed);
    }
    Err(e) => {
        println!("Airdrop failed: {:?}", e.err);
    }
}

pub fn get_account(&self, pubkey: &Pubkey) -> Option<Account>

let account = svm.get_account(&pubkey)?;
println!("Lamports: {}", account.lamports);
println!("Owner: {}", account.owner);
println!("Data length: {}", account.data.len());

pub fn set_account(&mut self, pubkey: Pubkey, account: Account) -> Result<(), LiteSVMError>

use solana_sdk::account::Account;

svm.set_account(pubkey, Account {
    lamports: 1_000_000,
    data: vec![0; 100],
    owner: program_id,
    executable: false,
    rent_epoch: 0,
}).unwrap();

pub fn get_balance(&self, pubkey: &Pubkey) -> Option<u64>

// Check if account exists and get balance
if let Some(balance) = svm.get_balance(&pubkey) {
    println!("Balance: {} lamports", balance);
} else {
    println!("Account doesn't exist");
}

// Or use unwrap_or for default
let balance = svm.get_balance(&pubkey).unwrap_or(0);
println!("Balance: {} lamports", balance);

pub fn minimum_balance_for_rent_exemption(&self, data_len: usize) -> u64

let data_len = 100;
let min_balance = svm.minimum_balance_for_rent_exemption(data_len);

svm.set_account(pubkey, Account {
    lamports: min_balance,
    data: vec![0; data_len],
    owner: program_id,
    executable: false,
    rent_epoch: 0,
}).unwrap();

// Slow - individual operations
for i in 0..100 {
    let account = Keypair::new();
    svm.airdrop(&account.pubkey(), 1_000_000_000).unwrap();
}

// Fast - batch with set_account
let accounts: Vec<_> = (0..100)
    .map(|_| {
        let keypair = Keypair::new();
        svm.set_account(keypair.pubkey(), Account {
            lamports: 1_000_000_000,
            data: vec![],
            owner: solana_sdk::system_program::id(),
            executable: false,
            rent_epoch: 0,
        }).unwrap();
        keypair
    })
    .collect();

// Before transaction
let before = svm.get_account(&pubkey).unwrap();

// Execute
svm.send_transaction(tx).unwrap();

// After transaction
let after = svm.get_account(&pubkey).unwrap();

// Compare
assert_ne!(before.lamports, after.lamports);
assert_ne!(before.data, after.data);