Démarrage rapide

Voir litesvm-loader sur crates.io

Installation

Assurez-vous d'avoir toutes les dépendances nécessaires :

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

Si votre test invoque directement le programme déployé, ajoutez également les crates d'instructions et de transactions Solana utilisés par votre test :

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

Qu'est-ce que litesvm-loader ?

Le crate litesvm-loader fournit des utilitaires pour déployer des programmes via le chargeur BPF évolutif dans LiteSVM. Utilisez-le lorsque votre test nécessite des program accounts appartenant au chargeur, des program data accounts, ou un comportement d'autorité de mise à niveau plutôt que d'insérer directement un programme avec svm.add_program(...).

Déploiement évolutif

Crée le compte tampon du chargeur
Écrit les octets du programme par blocs
Déploie le program account final avec le chargeur BPF évolutif
Utilise le keypair de programme fourni comme identifiant de programme

Gestion de l'autorité de mise à niveau - Modifie l'autorité de mise à niveau d'un programme déjà déployé - Prend en charge l'attribution d'une nouvelle autorité - Prend en charge le passage de None pour rendre le programme immuable

État réel du chargeur - Exerce le même modèle de compte de chargeur que votre programme voit on-chain - Permet aux tests d'inspecter les program accounts et les program data accounts - Aide à détecter les erreurs masquées par l'insertion directe de programme

Pour la plupart des tests, svm.add_program(program_id, program_bytes) reste la méthode la plus rapide et la plus simple pour charger un programme. Utilisez litesvm-loader lorsque la structure du loader account ou l'autorité de mise à jour fait partie de ce que vous devez tester.

Exemple rapide

Voici un exemple complet qui déploie un programme via le loader évolutif et effectue ensuite une rotation de son autorité :

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

Choisir le keypair du programme

deploy_upgradeable_program utilise l'argument program_kp comme adresse du programme. Si votre programme déclare un ID fixe, chargez le keypair de déploiement généré au lieu de créer un keypair aléatoire :

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

Invoquer le programme déployé

Après le déploiement, appelez le programme de la même manière que vous appelleriez tout programme chargé via LiteSVM. Construisez une instruction pour votre programme, signez la transaction et envoyez-la via la même instance LiteSVM :

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

Composants clés

deploy_upgradeable_program

Argument	Description
`svm`	Instance `LiteSVM` mutable qui reçoit le programme déployé
`payer_kp`	Payeur des frais et autorité de mise à jour initiale
`program_kp`	keypair dont la clé publique devient l'ID du programme
`program_bytes`	Octets du programme SBF compilé, généralement issus de `target/deploy/*.so`

deploy_upgradeable_program crée un tampon de loader, écrit les octets du programme par blocs de 512 octets et déploie le programme en prévoyant la possibilité de futures mises à jour.

set_upgrade_authority

Argument	Description
`svm`	Instance `LiteSVM` mutable contenant le programme déployé
`from_keypair`	Payeur des frais et autorité de signature pour la transaction
`program_address`	ID du programme dont l'autorité doit être modifiée
`current_authority_keypair`	keypair de l'autorité de mise à jour actuelle
`new_authority_address`	Nouvelle adresse d'autorité, ou `None` pour rendre le programme immuable

Dans l'implémentation actuelle du helper, la transaction générée est signée par from_keypair. Passez l'autorité actuelle en tant que from_keypair, ou conservez le payeur et l'autorité actuelle identiques, lors du changement d'autorité de mise à niveau.

Workflows courants

Déployer avec l'ID de programme déclaré

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

Rendre un programme immuable

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

Dépannage

Erreurs courantes

Erreur	Cause	Solution
`ProgramAccountNotFound` ou échecs d'instruction sur un mauvais ID	Le déploiement a utilisé un `Keypair` aléatoire alors que le programme attend un ID déclaré	Lisez `target/deploy/<program>-keypair.json` et passez ce keypair à `deploy_upgradeable_program`
`InsufficientFunds`	Le payeur ne dispose pas de suffisamment de lamports pour le buffer du chargeur et les program accounts	Effectuez un airdrop de lamports supplémentaires avant le déploiement
`MissingRequiredSignature` lors du changement d'autorité	L'autorité actuelle n'a pas signé la transaction	Passez l'autorité actuelle en tant que `from_keypair`, ou conservez le payeur et l'autorité actuelle avec le même keypair
Le déploiement du programme est plus lent que prévu	Le déploiement du chargeur écrit les octets via de vraies instructions de chargeur	Utilisez `svm.add_program(...)` si vous n'avez pas besoin du comportement d'état du chargeur ou d'autorité de mise à niveau

Table des matières