Thực Thi Lệnh

Tổng Quan

Sau khi triển khai chương trình lên LiteSVM, bạn cần thực thi các lệnh để tương tác với chương trình đã triển khai.

LiteSVM cung cấp một API đơn giản để tạo, gửi và mô phỏng các giao dịch hoàn toàn tương thích với mô hình giao dịch của Solana.

Luồng Giao Dịch Cơ Bản

Luồng thông thường để thực thi một lệnh là:

Tạo Lệnh - Xác định chương trình cần gọi và dữ liệu kèm theo
Xây Dựng Message - Kết hợp một hoặc nhiều lệnh
Tạo Giao Dịch - Ký message với các signer yêu cầu
Gửi hoặc Mô Phỏng - Thực thi giao dịch và xử lý kết quả

Tạo Lệnh

Cấu Trúc Lệnh Cơ Bản

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

Xây Dựng và Gửi Giao Dịch

Phương Pháp 1: Giao Dịch Cơ Bản

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

Chức năng của new_signed_with_payer:

Tự động xây dựng Message từ các lệnh của bạn
Tự động ký giao dịch với tất cả các keypair được cung cấp
Trả về giao dịch đã được ký đầy đủ, sẵn sàng để gửi

Phương Pháp 2: Giao Dịch Message Tùy Chỉnh

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

Sử dụng phương pháp này khi bạn cần kiểm soát Message như:

Giao dịch có phiên bản (v0 với lookup table)
Quy trình ký một phần/đa chữ ký
Durable nonce
Mô phỏng hoặc kiểm tra trước khi ký
Logic phí tùy chỉnh
Tối ưu hóa kích thước giao dịch

Giao Dịch Có Phiên Bản

LiteSVM hỗ trợ cả giao dịch legacy và giao dịch có phiên bản:

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

Kết Quả Giao Dịch

Giao Dịch Thành Công

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

Các Trường Metadata Của Giao Dịch

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

Mô Phỏng Giao Dịch

Mô phỏng giao dịch cho phép bạn kiểm tra các giao dịch mà không thay đổi trạng thái:

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

Xử Lý Lỗi

Các Lỗi Giao Dịch Thường Gặp

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

Làm Việc với Log Chương Trình

Truy Cập Log

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

Ví Dụ Đầu Ra Log

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

Cấu Hình Ngân Sách Tính Toán

Thiết Lập Ngân Sách Tính Toán Toàn Cục

use solana_compute_budget::compute_budget::ComputeBudget;

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

Ngân Sách Tính Toán Theo Từng Giao Dịch

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

Hướng Dẫn System Program

LiteSVM bao gồm hỗ trợ 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,
);

Tóm Tắt

Thực thi các lệnh trong LiteSVM tuân theo mô hình giao dịch Solana chuẩn:

Tạo các đối tượng Instruction với ID chương trình, tài khoản và dữ liệu
Xây dựng Transaction với lệnh và các người ký yêu cầu
Sử dụng send_transaction() để thực thi hoặc simulate_transaction() để kiểm tra
Xử lý kết quả bằng cách kiểm tra TransactionMetadata hoặc chi tiết lỗi

LiteSVM cung cấp khả năng thực thi tức thì với log chi tiết và thông tin gỡ lỗi, giúp nó trở nên lý tưởng để kiểm thử các chương trình Solana một cách hiệu quả.

Mục lục