Instructies Uitvoeren

Overzicht

Na het implementeren van een programma in LiteSVM moet je instructies uitvoeren om te communiceren met het geïmplementeerde programma.

LiteSVM biedt een eenvoudige API voor het aanmaken, verzenden en simuleren van transacties die volledig compatibel is met het transactiemodel van Solana.

Basisstroom van Transacties

De typische stroom voor het uitvoeren van een instructie is:

Maak een Instructie - Definieer welk programma je wilt aanroepen en met welke gegevens
Bouw een Bericht - Combineer een of meer instructies
Maak een Transactie - Onderteken het bericht met de vereiste ondertekenaars
Verzenden of Simuleren - Voer de transactie uit en verwerk de resultaten

Instructies Aanmaken

Basisstructuur van een Instructie

use solana_instruction::{Instruction, AccountMeta};
use solana_pubkey::Pubkey;

let instruction = Instruction {
    program_id: Pubkey::new_unique(),  // The program to call
    accounts: vec![                     // Accounts the program needs
        AccountMeta::new(account_pubkey, false),        // Writable, not signer
        AccountMeta::new_readonly(readonly_pubkey, false), // Read-only, not signer
        AccountMeta::new(signer_pubkey, true),          // Writable, signer
    ],
    data: vec![0, 1, 2, 3],             // Instruction data (program-specific)
};

Transacties Bouwen en Verzenden

Methode 1: Basistransactie

use litesvm::LiteSVM;
use solana_keypair::Keypair;
use solana_message::Message;
use solana_transaction::Transaction;
use solana_signer::Signer;

let mut svm = LiteSVM::new();
let payer = Keypair::new();

// Airdrop SOL for fees
svm.airdrop(&payer.pubkey(), 1_000_000_000).unwrap();

// Create instruction
let instruction = /* your instruction */;

// Build message with payer
let message = Message::new(&[instruction], Some(&payer.pubkey()));

// Create and sign transaction
let tx = Transaction::new_signed_with_payer(
    &[instruction],                 // Your instructions
    Some(&payer.pubkey()),          // Who pays transaction fees
    &[&payer],                      // All required signers
    svm.latest_blockhash(),         // Recent blockhash
);

// Send transaction
let result = svm.send_transaction(tx);

Wat new_signed_with_payer doet:

Bouwt automatisch een Bericht op basis van je instructies
Ondertekent de transactie automatisch met alle opgegeven keypairs
Geeft een volledig ondertekende, verzendklare transactie terug

Methode 2: Aangepaste Berichttransactie

let payer = Keypair::new();

// Manually construct message
let message = Message::new(&[instruction], Some(&payer.pubkey()));

// Create transaction with signers, message, and blockhash
let tx = Transaction::new(
    &[&payer],
    message,
    svm.latest_blockhash(),
);

let result = svm.send_transaction(tx);

Gebruik deze methode wanneer je controle nodig hebt over de Message zoals:

Versietransacties (v0 met opzoektabellen)
Gedeeltelijke/multi-sig workflows
Duurzame nonces
Simulatie of inspectie vóór ondertekening
Aangepaste logica voor betalende partij
Optimalisatie van transactiegrootte

Versietransacties

LiteSVM ondersteunt zowel verouderde als versietransacties:

use solana_transaction::versioned::VersionedTransaction;
use solana_message::VersionedMessage;

// Legacy transaction (most common)
let legacy_msg = Message::new(&[instruction], Some(&payer.pubkey()));
let versioned_tx = VersionedTransaction::try_new(
    VersionedMessage::Legacy(legacy_msg),
    &[&payer]
).unwrap();

// Send versioned transaction
let result = svm.send_transaction(versioned_tx);

Transactieresultaten

Geslaagde Transactie

match svm.send_transaction(tx) {
    Ok(meta) => {
        println!("Signature: {}", meta.signature);
        println!("Compute units: {}", meta.compute_units_consumed);
        println!("Logs:");
        for log in &meta.logs {
            println!("  {}", log);
        }
    }
    Err(err) => {
        println!("Transaction failed: {:?}", err.err);
        // Logs are still available on failure
        println!("Failure logs: {:?}", err.meta.logs);
    }
}

Metadatavelden van Transacties

pub struct TransactionMetadata {
    pub signature: Signature,
    pub logs: Vec<String>,
    pub inner_instructions: InnerInstructionsList,
    pub compute_units_consumed: u64,
    pub return_data: TransactionReturnData,
    pub fee: u64,
}

Transacties simuleren

Transactie simuleren laat je transacties testen zonder de status te wijzigen:

// Simulate instead of sending
match svm.simulate_transaction(tx) {
    Ok(sim_result) => {
        println!("Simulation successful!");
        println!("Logs: {:?}", sim_result.meta.logs);
        println!("Compute units: {}", sim_result.meta.compute_units_consumed);
    }
    Err(err) => {
        println!("Simulation failed: {:?}", err.err);
    }
}

Foutafhandeling

Veelvoorkomende transactiefouten

use solana_transaction_error::TransactionError;
use solana_instruction::error::InstructionError;

match svm.send_transaction(tx) {
    Err(failed_tx) => {
        match failed_tx.err {
            TransactionError::InsufficientFundsForFee => {
                println!("Not enough SOL for fees");
            }
            TransactionError::InvalidProgramForExecution => {
                println!("Program doesn't exist or isn't executable");
            }
            TransactionError::InstructionError(index, err) => {
                println!("Instruction {} failed: {:?}", index, err);
                match err {
                    InstructionError::Custom(code) => {
                        println!("Custom error code: {}", code);
                    }
                    InstructionError::AccountNotFound => {
                        println!("An account doesn't exist");
                    }
                    _ => {}
                }
            }
            TransactionError::BlockhashNotFound => {
                println!("Blockhash expired or invalid");
            }
            _ => println!("Other error: {:?}", failed_tx.err),
        }
    }
    Ok(_) => {}
}

Werken met programmalogboeken

Logboeken raadplegen

let result = svm.send_transaction(tx).unwrap();

// All logs (including system logs)
for log in &result.logs {
    println!("{}", log);
}

// Pretty-printed logs (formatted)
println!("{}", result.pretty_logs());

Voorbeeld van logboekuitvoer

Program 11111111111111111111111111111111 invoke [1]
Program log: Processing instruction
Program 11111111111111111111111111111111 consumed 2000 compute units
Program 11111111111111111111111111111111 success

Rekenkrachtbudget configureren

Globaal rekenkrachtbudget instellen

use solana_compute_budget::compute_budget::ComputeBudget;

let mut svm = LiteSVM::new()
    .with_compute_budget(ComputeBudget {
        compute_unit_limit: 200_000,
        ..Default::default()
    });

Rekenkrachtbudget per transactie

use solana_compute_budget_interface::ComputeBudgetInstruction;

let instructions = vec![
    // Set compute budget for this transaction
    ComputeBudgetInstruction::set_compute_unit_limit(400_000),
    ComputeBudgetInstruction::set_compute_unit_price(1),

    // Your actual instruction
    your_instruction,
];

System Program-instructies

LiteSVM biedt ondersteuning voor het System Program:

use solana_keypair::Keypair;
use solana_signer::Signer;
use solana_system_interface::instruction as system_instruction;
use solana_transaction::Transaction;

// Transfer SOL
let transfer_ix = system_instruction::transfer(
    &alice.pubkey(),
    &bob.pubkey(),
    1_000_000_000, // 1 SOL
);

// Create new account
let create_ix = system_instruction::create_account(
    &payer_pubkey,
    &new_account_pubkey,
    lamports,
    space as u64,
    &owner_program_id,
);

Samenvatting

Het uitvoeren van instructies in LiteSVM volgt het standaard Solana-transactiemodel:

Maak Instruction-objecten aan met programma-ID, accounts en gegevens
Bouw een Transaction met de instructie en vereiste ondertekenaars
Gebruik send_transaction() om uit te voeren of simulate_transaction() om te testen
Verwerk resultaten door de TransactionMetadata of foutdetails te controleren

LiteSVM biedt directe uitvoering met gedetailleerde logboeken en foutopsporingsinformatie, waardoor het ideaal is voor het efficiënt testen van Solana-programma's.

Inhoudsopgave