Εκτέλεση Εντολών

Επισκόπηση

Αφού αναπτύξετε ένα πρόγραμμα στο LiteSVM, θα χρειαστεί να εκτελέσετε εντολές για αλληλεπίδραση με το αναπτυγμένο πρόγραμμα.

Το LiteSVM παρέχει ένα απλό API για τη δημιουργία, αποστολή και προσομοίωση συναλλαγών που είναι πλήρως συμβατό με το μοντέλο συναλλαγών του Solana.

Βασική Ροή Συναλλαγών

Η τυπική ροή για την εκτέλεση μιας εντολής είναι:

Δημιουργία Εντολής - Ορίστε ποιο πρόγραμμα θα καλέσετε και με ποια δεδομένα
Κατασκευή Μηνύματος - Συνδυάστε μία ή περισσότερες εντολές
Δημιουργία Συναλλαγής - Υπογράψτε το μήνυμα με τους απαιτούμενους υπογράφοντες
Αποστολή ή Προσομοίωση - Εκτελέστε τη συναλλαγή και διαχειριστείτε τα αποτελέσματα

Δημιουργία Εντολών

Βασική Δομή Εντολής

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

Κατασκευή και Αποστολή Συναλλαγών

Μέθοδος 1: Βασική Συναλλαγή

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

Τι κάνει η new_signed_with_payer:

Δημιουργεί αυτόματα ένα Μήνυμα από τις εντολές σας
Υπογράφει αυτόματα τη συναλλαγή με όλα τα παρεχόμενα keypairs
Επιστρέφει μια πλήρως υπογεγραμμένη, έτοιμη προς αποστολή συναλλαγή

Μέθοδος 2: Συναλλαγή με Προσαρμοσμένο Μήνυμα

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

Χρησιμοποιήστε αυτή τη μέθοδο όταν χρειάζεστε έλεγχο του Message όπως:

Εκδοσιοποιημένες συναλλαγές (v0 με πίνακες αναζήτησης)
Ροές εργασίας μερικής/πολλαπλής υπογραφής
Ανθεκτικά nonces
Προσομοίωση ή επιθεώρηση πριν την υπογραφή
Προσαρμοσμένη λογική καταβολής τελών
Βελτιστοποίηση μεγέθους συναλλαγής

Εκδοσιοποιημένες Συναλλαγές

Το LiteSVM υποστηρίζει τόσο παλαιού τύπου όσο και εκδοσιοποιημένες συναλλαγές:

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

Αποτελέσματα Συναλλαγών

Επιτυχής Συναλλαγή

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

Πεδία Μεταδεδομένων Συναλλαγής

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

Προσομοίωση Συναλλαγών

Η προσομοίωση συναλλαγής σάς επιτρέπει να δοκιμάζετε συναλλαγές χωρίς να αλλάζετε την κατάσταση:

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

Διαχείριση Σφαλμάτων

Συνηθισμένα Σφάλματα Συναλλαγών

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

Εργασία με Αρχεία Καταγραφής Προγράμματος

Πρόσβαση στα Αρχεία Καταγραφής

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

Παράδειγμα Εξόδου Αρχείου Καταγραφής

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

Διαμόρφωση Υπολογιστικού Προϋπολογισμού

Ορισμός Καθολικού Υπολογιστικού Προϋπολογισμού

use solana_compute_budget::compute_budget::ComputeBudget;

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

Υπολογιστικός Προϋπολογισμός ανά Συναλλαγή

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

Το LiteSVM περιλαμβάνει υποστήριξη 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,
);

Σύνοψη

Η εκτέλεση εντολών στο LiteSVM ακολουθεί το τυπικό μοντέλο συναλλαγών Solana:

Δημιουργήστε αντικείμενα Instruction με το αναγνωριστικό προγράμματος, τους λογαριασμούς και τα δεδομένα
Δημιουργήστε ένα Transaction με την εντολή και τους απαιτούμενους υπογράφοντες
Χρησιμοποιήστε send_transaction() για εκτέλεση ή simulate_transaction() για δοκιμή
Διαχειριστείτε τα αποτελέσματα ελέγχοντας το TransactionMetadata ή τις λεπτομέρειες του σφάλματος

Το LiteSVM παρέχει άμεση εκτέλεση με λεπτομερή αρχεία καταγραφής και πληροφορίες εντοπισμού σφαλμάτων, καθιστώντας το ιδανικό για αποτελεσματικό έλεγχο προγραμμάτων Solana.

Πίνακας Περιεχομένων