Snel starten

Bekijk litesvm-loader op crates.io

Installatie

Zorg ervoor dat je alle benodigde afhankelijkheden hebt:

cargo add --dev litesvm litesvm-loader solana-keypair solana-signer

Als je test het geïmplementeerde programma rechtstreeks aanroept, voeg dan ook de Solana-instructie- en transactiecrates toe die door je test worden gebruikt:

cargo add --dev solana-instruction solana-message solana-transaction

De litesvm-loader crate biedt hulpfuncties voor het implementeren van programma's via de BPF upgradeable loader binnen LiteSVM. Gebruik het wanneer je test loader-owned program accounts, program data accounts of upgrade authority-gedrag nodig heeft, in plaats van een programma rechtstreeks in te voegen met svm.add_program(...).

Upgradeable implementatie

Maakt het loader-bufferaccount aan
Schrijft programma-bytes in stukken
Implementeert het uiteindelijke program account met de BPF upgradeable loader
Gebruikt het opgegeven program keypair als programma-ID

Beheer van upgrade-autoriteit - Wijzigt de upgrade-autoriteit voor een al geïmplementeerd programma - Ondersteunt het toewijzen van een nieuwe autoriteit - Ondersteunt het doorgeven van None om het programma onveranderlijk te maken

Echte loader-status - Oefent hetzelfde loader-accountmodel uit dat je programma on-chain ziet - Laat tests program accounts en program data accounts inspecteren - Helpt fouten op te sporen die verborgen blijven bij directe programma-invoeging

Voor de meeste tests is svm.add_program(program_id, program_bytes) nog steeds de snelste en eenvoudigste manier om een programma te laden. Gebruik litesvm-loader wanneer de indeling van het loader-account of de upgrade-autoriteit deel uitmaakt van wat je wilt testen.

Snel voorbeeld

Hier is een volledig voorbeeld dat een programma implementeert via de upgradeable loader en vervolgens de autoriteit roteert:

use litesvm::LiteSVM;
use litesvm_loader::{deploy_upgradeable_program, set_upgrade_authority};
use solana_keypair::Keypair;
use solana_signer::Signer;

#[test]
fn test_upgradeable_deployment() {
    let mut svm = LiteSVM::new();

    let payer = Keypair::new();
    svm.airdrop(&payer.pubkey(), 10_000_000_000).unwrap();

    // Use the keypair that should own the program ID.
    // For Anchor programs, this is usually target/deploy/<program>-keypair.json.
    let program = Keypair::new();
    let program_bytes = include_bytes!("../target/deploy/my_program.so");

    deploy_upgradeable_program(&mut svm, &payer, &program, program_bytes).unwrap();

    let program_account = svm.get_account(&program.pubkey()).unwrap();
    assert!(program_account.executable);

    let new_authority = Keypair::new();
    set_upgrade_authority(
        &mut svm,
        &payer,
        &program.pubkey(),
        &payer,
        Some(&new_authority.pubkey()),
    )
    .unwrap();
}

Het program keypair kiezen

deploy_upgradeable_program gebruikt het program_kp argument als het programmaadres. Als je programma een vast ID declareert, laad dan het gegenereerde deploy-keypair in plaats van een willekeurig keypair aan te maken:

use solana_keypair::read_keypair_file;

let program = read_keypair_file("target/deploy/my_program-keypair.json").unwrap();
deploy_upgradeable_program(&mut svm, &payer, &program, program_bytes).unwrap();

Het geïmplementeerde programma aanroepen

Na de implementatie roep je het programma op dezelfde manier aan als elk LiteSVM-geladen programma. Bouw een instructie voor je programma, onderteken de transactie en verstuur deze via dezelfde LiteSVM instantie:

use solana_instruction::Instruction;
use solana_message::Message;
use solana_transaction::Transaction;

let instruction = Instruction::new_with_bytes(
    program.pubkey(),
    &[],  // instruction data for your program
    vec![], // account metas for your program
);

let message = Message::new(&[instruction], Some(&payer.pubkey()));
let tx = Transaction::new(&[&payer], message, svm.latest_blockhash());

svm.send_transaction(tx).unwrap();

Belangrijkste onderdelen

deploy_upgradeable_program

Argument	Beschrijving
`svm`	Veranderlijke `LiteSVM` instantie die het geïmplementeerde programma ontvangt
`payer_kp`	Vergoedingsbetaler en initiële upgrade-autoriteit
`program_kp`	keypair waarvan de publieke sleutel het programma-ID wordt
`program_bytes`	Gecompileerde SBF-programma-bytes, meestal afkomstig van `target/deploy/*.so`

deploy_upgradeable_program maakt een loader-buffer aan, schrijft de programma-bytes in stukken van 512 bytes en implementeert het programma met ruimte voor toekomstige upgrades.

set_upgrade_authority

Argument	Beschrijving
`svm`	Veranderlijke `LiteSVM` instantie met het geïmplementeerde programma
`from_keypair`	Vergoedingsbetaler en ondertekeningsautoriteit voor de transactie
`program_address`	Programma-ID waarvan de autoriteit moet worden gewijzigd
`current_authority_keypair`	Huidig keypair van de upgrade-autoriteit
`new_authority_address`	Nieuw autoriteitadres, of `None` om het programma onveranderlijk te maken

In de huidige helper-implementatie wordt de gegenereerde transactie ondertekend door from_keypair. Geef de huidige autoriteit door als from_keypair, of houd de betaler en huidige autoriteit hetzelfde, bij het wijzigen van de upgrade-autoriteit.

Veelgebruikte workflows

Implementeren met het gedeclareerde programma-ID

use solana_keypair::read_keypair_file;

let program = read_keypair_file("target/deploy/my_program-keypair.json").unwrap();
let program_bytes = include_bytes!("../target/deploy/my_program.so");

deploy_upgradeable_program(&mut svm, &payer, &program, program_bytes).unwrap();

Een programma onveranderlijk maken

set_upgrade_authority(
    &mut svm,
    &payer,
    &program.pubkey(),
    &payer,
    None,
)
.unwrap();

Probleemoplossing

Veelvoorkomende fouten

Fout	Oorzaak	Oplossing
`ProgramAccountNotFound` of instructiefouten met het verkeerde ID	Bij de implementatie werd een willekeurig `Keypair` gebruikt terwijl het programma een gedeclareerd ID verwacht	Lees `target/deploy/<program>-keypair.json` en geef dat keypair door aan `deploy_upgradeable_program`
`InsufficientFunds`	De betaler heeft niet genoeg lamports voor loader-buffer en program accounts	Airdrop meer lamports vóór de implementatie
`MissingRequiredSignature` bij het wijzigen van autoriteit	De huidige autoriteit heeft de transactie niet ondertekend	Geef de huidige autoriteit door als `from_keypair`, of houd de betaler en huidige autoriteit als hetzelfde keypair
Programma-implementatie is trager dan verwacht	Loader-implementatie schrijft bytes via echte loader-instructies	Gebruik `svm.add_program(...)` wanneer u geen loader-status of upgrade-autoriteitsgedrag nodig heeft