Inicio Rápido

Ver litesvm-loader en crates.io

Instalación

Asegúrate de tener todas las dependencias necesarias:

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

Si tu prueba invoca directamente el programa desplegado, añade también los crates de instrucciones y transacciones de Solana que utiliza tu prueba:

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

El crate litesvm-loader proporciona utilidades para desplegar programas a través del cargador BPF actualizable dentro de LiteSVM. Úsalo cuando tu prueba necesite program accounts y program data accounts gestionadas por el cargador, o cuando necesites simular el comportamiento de la autoridad de actualización en lugar de insertar un programa directamente con svm.add_program(...).

Despliegue Actualizable

Crea la cuenta de búfer del cargador
Escribe los bytes del programa en fragmentos
Despliega el program account final con el cargador BPF actualizable
Usa el keypair de programa proporcionado como ID del programa

Gestión de la Autoridad de Actualización - Cambia la autoridad de actualización de un programa ya desplegado - Permite asignar una nueva autoridad - Permite pasar None para hacer el programa inmutable

Estado Real del Cargador - Ejercita el mismo modelo de cuentas del cargador que tu programa ve en la cadena - Permite que las pruebas inspeccionen el program account y el program data account - Ayuda a detectar errores ocultos por la inserción directa de programas

Para la mayoría de las pruebas, svm.add_program(program_id, program_bytes) sigue siendo la forma más rápida y sencilla de cargar un programa. Usa litesvm-loader cuando el diseño de la cuenta del cargador o la autoridad de actualización formen parte de lo que necesitas probar.

Ejemplo rápido

Aquí tienes un ejemplo completo que despliega un programa a través del cargador actualizable y luego rota su autoridad:

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

Elección del keypair del programa

deploy_upgradeable_program utiliza el argumento program_kp como la dirección del programa. Si tu programa declara un ID fijo, carga el keypair de despliegue generado en lugar de crear un keypair aleatorio:

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

Invocación del programa desplegado

Tras el despliegue, llama al programa de la misma forma en que llamarías a cualquier programa cargado con LiteSVM. Construye una instrucción para tu programa, firma la transacción y envíala a través de la misma instancia de 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();

Componentes clave

deploy_upgradeable_program

Argumento	Descripción
`svm`	Instancia mutable de `LiteSVM` que recibe el programa desplegado
`payer_kp`	Pagador de comisiones y autoridad de actualización inicial
`program_kp`	keypair cuya clave pública se convierte en el ID del programa
`program_bytes`	Bytes del programa SBF compilado, normalmente obtenidos de `target/deploy/*.so`

deploy_upgradeable_program crea un búfer del cargador, escribe los bytes del programa en fragmentos de 512 bytes y despliega el programa con espacio para futuras actualizaciones.

set_upgrade_authority

Argumento	Descripción
`svm`	Instancia mutable de `LiteSVM` que contiene el programa desplegado
`from_keypair`	Pagador de comisiones y autoridad firmante de la transacción
`program_address`	ID del programa cuya autoridad debe cambiar
`current_authority_keypair`	keypair de la autoridad de actualización actual
`new_authority_address`	Nueva dirección de autoridad, o `None` para hacer el programa inmutable

En la implementación actual del helper, la transacción generada es firmada por from_keypair. Pase la autoridad actual como from_keypair, o mantenga el pagador y la autoridad actual iguales, al cambiar la autoridad de actualización.

Flujos de trabajo comunes

Desplegar con el ID de programa declarado

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

Hacer un programa inmutable

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

Solución de problemas

Errores comunes

Error	Causa	Solución
`ProgramAccountNotFound` o fallos de instrucción contra el ID incorrecto	El despliegue utilizó un `Keypair` aleatorio mientras el programa espera un ID declarado	Lea `target/deploy/<program>-keypair.json` y pase ese keypair a `deploy_upgradeable_program`
`InsufficientFunds`	El pagador no tiene suficientes lamports para el buffer del cargador y los program account	Transfiera más lamports antes del despliegue
`MissingRequiredSignature` al cambiar la autoridad	La autoridad actual no firmó la transacción	Pase la autoridad actual como `from_keypair`, o mantenga el pagador y la autoridad actual como el mismo keypair
El despliegue del programa es más lento de lo esperado	El despliegue del cargador escribe bytes a través de instrucciones reales del cargador	Use `svm.add_program(...)` cuando no necesite el estado del cargador ni el comportamiento de autoridad de actualización