Talimatları Yürütme

Genel Bakış

Bir programı LiteSVM'e dağıttıktan sonra, dağıtılan programla etkileşim kurmak için talimatları yürütmeniz gerekecektir.

LiteSVM, Solana'nın işlem modeliyle tam uyumlu olan işlem oluşturma, gönderme ve simüle etme için basit bir API sunar.

Temel İşlem Akışı

Bir talimatı yürütmek için tipik akış şu şekildedir:

Talimat Oluşturma - Hangi programın çağrılacağını ve hangi verilerle çağrılacağını tanımlayın
Mesaj Oluşturma - Bir veya daha fazla talimatı birleştirin
İşlem Oluşturma - Mesajı gerekli imzacılarla imzalayın
Gönderme veya Simüle Etme - İşlemi yürütün ve sonuçları işleyin

Talimat Oluşturma

Temel Talimat Yapısı

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

İşlem Oluşturma ve Gönderme

Yöntem 1: Temel İşlem

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'in işlevi:

Talimatlarınızdan otomatik olarak bir Mesaj oluşturur
İşlemi sağlanan tüm keypair'lerle otomatik olarak imzalar
Tamamen imzalanmış, gönderilmeye hazır bir işlem döndürür

Yöntem 2: Özel Mesaj İşlemi

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 üzerinde kontrol sahibi olmanız gerektiğinde bu yöntemi kullanın:

Sürümlü işlemler (arama tablolarıyla v0)
Kısmi/çoklu imza iş akışları
Kalıcı nonce'lar
İmza öncesi simülasyon veya inceleme
Özel ücret ödeyen mantığı
İşlem boyutu optimizasyonu

Sürümlü İşlemler

LiteSVM hem eski hem de sürümlü işlemleri destekler:

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

İşlem Sonuçları

Başarılı İşlem

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

İşlem Meta Veri Alanları

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

İşlemleri Simüle Etme

İşlem simülasyonu, durumu değiştirmeden işlemleri test etmenizi sağlar:

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

Hata Yönetimi

Yaygın İşlem Hataları

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

Program Günlükleriyle Çalışma

Günlüklere Erişim

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

Günlük Çıktısı Örneği

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

Hesaplama Bütçesi Yapılandırması

Global Hesaplama Bütçesini Ayarlama

use solana_compute_budget::compute_budget::ComputeBudget;

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

İşlem Başına Hesaplama Bütçesi

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 Talimatları

LiteSVM, system program desteği içerir:

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

Özet

LiteSVM'de talimat yürütme, standart Solana işlem modelini takip eder:

Program kimliği, hesaplar ve verilerle Instruction nesneleri oluşturun
Talimat ve gerekli imzacılarla bir Transaction oluşturun
Yürütmek için send_transaction(), test etmek için simulate_transaction() kullanın
TransactionMetadata veya hata ayrıntılarını kontrol ederek sonuçları işleyin

LiteSVM, ayrıntılı günlükler ve hata ayıklama bilgileriyle anında yürütme imkânı sunarak Solana programlarını verimli biçimde test etmek için ideal bir araçtır.

İçindekiler