Ausführen von Anweisungen

Übersicht

Nach dem Deployen eines Programms in LiteSVM müssen Sie Anweisungen ausführen, um mit dem deployten Programm zu interagieren.

LiteSVM bietet eine einfache API zum Erstellen, Senden und Simulieren von Transaktionen, die vollständig mit Solanas Transaktionsmodell kompatibel ist.

Grundlegender Transaktionsablauf

Der typische Ablauf zum Ausführen einer Anweisung ist:

Eine Anweisung erstellen - Festlegen, welches Programm mit welchen Daten aufgerufen werden soll
Eine Nachricht aufbauen - Eine oder mehrere Anweisungen kombinieren
Eine Transaktion erstellen - Die Nachricht mit den erforderlichen Signern signieren
Senden oder Simulieren - Die Transaktion ausführen und Ergebnisse verarbeiten

Anweisungen erstellen

Grundlegende Anweisungsstruktur

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)
};

Transaktionen aufbauen und senden

Methode 1: Einfache Transaktion

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);

Was new_signed_with_payer bewirkt:

Erstellt automatisch eine Nachricht aus Ihren Anweisungen
Signiert die Transaktion automatisch mit allen angegebenen keypairs
Gibt eine vollständig signierte, versandfertige Transaktion zurück

Methode 2: Transaktion mit benutzerdefinierter Nachricht

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);

Verwenden Sie diese Methode, wenn Sie die Kontrolle über Message benötigen, z. B.:

Versionierte Transaktionen (v0 mit Lookup-Tabellen)
Partial-/Multi-Sig-Workflows
Dauerhafte Nonces
Simulation oder Inspektion vor der Signierung
Benutzerdefinierte Fee-Payer-Logik
Optimierung der Transaktionsgröße

Versionierte Transaktionen

LiteSVM unterstützt sowohl Legacy- als auch versionierte Transaktionen:

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);

Transaktionsergebnisse

Erfolgreiche Transaktion

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);
    }
}

Metadatenfelder der Transaktion

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,
}

Transaktionen simulieren

Die Transaktionssimulation ermöglicht es, Transaktionen zu testen, ohne den Zustand zu ändern:

// 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);
    }
}

Fehlerbehandlung

Häufige Transaktionsfehler

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(_) => {}
}

Arbeiten mit Programm-Logs

Zugriff auf Logs

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

Beispiel einer Log-Ausgabe

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

Konfiguration des Compute-Budgets

Globales Compute-Budget festlegen

use solana_compute_budget::compute_budget::ComputeBudget;

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

Compute-Budget pro Transaktion

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 Anweisungen

LiteSVM beinhaltet System Program-Unterstützung:

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,
);

Zusammenfassung

Die Ausführung von Anweisungen in LiteSVM folgt dem standardmäßigen Solana-Transaktionsmodell:

Erstelle Instruction-Objekte mit Programm-ID, Konten und Daten
Erstelle eine Transaction mit der Anweisung und den erforderlichen Signer
Verwende send_transaction() zur Ausführung oder simulate_transaction() zum Testen
Verarbeite Ergebnisse durch Überprüfung der TransactionMetadata oder der Fehlerdetails

LiteSVM bietet sofortige Ausführung mit detaillierten Logs und Debugging-Informationen und ist damit ideal für das effiziente Testen von Solana-Programmen.

Inhaltsverzeichnis