Implantando Programas

Primeiros Passos

let mut svm = LiteSVM::new();

Isso cria a instância de teste litesvm básica, que inclui todos os recursos de tempo de execução habilitados, sysvars padrão, pré-compilações, programas spl, sigverify e todos os programas integrados como o System Program.

Para interagir com qualquer outro programa nos seus testes, você deve implantar esse programa no seu ambiente de teste.

Compile e implante o programa que deseja testar
Encontre todos os programas para os quais o programa acima faz chamadas CPI e implante esses programas

Exemplo: Se o seu programa estiver usando feeds de dados do Pyth, você precisará ter o programa Pyth implantado na sua instância de teste.

Implantação Básica de Programas

Método 1: Implantar a partir de Bytes

Implante programas diretamente de arrays de bytes para a execução de testes mais rápida:

use litesvm::LiteSVM;
use solana_sdk::signature::{read_keypair_file, Signer};

let mut svm = LiteSVM::new();

// Read the program's keypair to get correct ID
let program_keypair = read_keypair_file("target/deploy/my_program-keypair.json")
    .expect("Program keypair file not found");
let program_id = program_keypair.pubkey();

// Include bytes at compile time
let program_bytes = include_bytes!("../target/deploy/my_program.so");

// Deploy from bytes
svm.add_program(program_id, program_bytes)
    .expect("Failed to deploy program");

// Verify deployment
assert!(svm.get_account(&program_id).is_some(), "Program account not created");
assert!(svm.get_account(&program_id).unwrap().executable, "Program not executable");

include_bytes! incorpora o binário diretamente no executável de teste no momento da compilação, eliminando operações de I/O durante a execução dos testes.

✓ Prós

•Mais rápido em tempo de execução (sem leituras de disco)
•Binário de teste autossuficiente
•Funciona mesmo se o arquivo .so for excluído após a compilação

✗ Contras

•Tamanho do binário de teste maior
•É necessário recompilar os testes quando o .so é alterado

Método 2: Implantar a partir de Arquivo (.so)

Carregue programas do sistema de arquivos quando eles mudam com frequência:

use litesvm::LiteSVM;
use solana_sdk::signature::{read_keypair_file, Signer};

let mut svm = LiteSVM::new();

// Read keypair for correct program ID
let program_keypair = read_keypair_file("target/deploy/program-keypair.json").unwrap();
let program_id = program_keypair.pubkey();

// Deploy from file
svm.add_program_from_file(program_id, "target/deploy/program.so")
    .expect("Failed to deploy program from file");

// Always verify
assert!(svm.get_account(&program_id).unwrap().executable);

✓ Vantagens

•Binário de teste menor
•Pode capturar alterações no .so sem recompilar os testes
•Mais flexível para pipelines de CI/CD

✗ Desvantagens

•Mais lento (I/O de disco em tempo de execução)
•Requer que o arquivo .so exista no momento da execução dos testes
•O caminho do arquivo deve estar correto em relação ao diretório de execução dos testes

Obtendo Programas da Mainnet/Devnet

Quando você precisar de um programa para o qual não tem o código-fonte, use a CLI da Solana para exportar programas de clusters ativos e utilizá-los nos testes:

# Dump a program from mainnet
solana program dump gSbePebfvPy7tRqimPoVecS2UsBvYv46ynrzWocc92s pyth.so --url mainnet-beta

# Dump from devnet
solana program dump YourProgramID program.so --url devnet

Em seguida, carregue-o nos seus testes:

svm.add_program_from_file(
    pubkey!("gSbePebfvPy7tRqimPoVecS2UsBvYv46ynrzWocc92s"),
    "pyth.so"
).unwrap();

Boas Práticas

1. Escolha o Método de Implantação Adequado

Use add_program() quando:
- Os programas estão incorporados no binário de teste em tempo de compilação
- Você deseja uma execução de testes mais rápida (sem I/O em tempo de execução)
- Testes autocontidos
Use add_program_from_file() quando:
- Os programas são compilados separadamente (ou seja, obtidos do devnet)
- O programa muda frequentemente durante o desenvolvimento (é possível reexecutar os testes sem recompilar)
- Você tem ambientes de CI/CD onde os arquivos .so são artefatos

Entendendo os keypair de Programas

Quando você compila um programa Solana:

O Anchor cria target/deploy/program-keypair.json
As compilações nativas criam um arquivo keypair junto com o arquivo .so
O endereço on-chain do programa é a chave pública desse keypair, também conhecida como ID do programa.
Para PDAs, find_program_address() requer o ID do programa como seed
Para CPIs, o ID do programa é usado para chamar outros programas

Problemas Comuns e Soluções

Falhas Silenciosas de Implantação

Problema: O programa parece ser implantado, mas as transações falham com "InvalidProgramForExecution".

Causa: O ID do programa não corresponde ao keypair.

Solução:

// Always use the keypair-derived ID
let keypair = read_keypair_file("target/deploy/program-keypair.json").unwrap();
let program_id = keypair.pubkey();

svm.add_program(program_id, &program_bytes).unwrap();

// Verify with detailed checks
let account = svm.get_account(&program_id)
    .expect("Program account doesn't exist");

assert!(account.executable, "Program not executable");
assert_eq!(account.owner, solana_sdk::bpf_loader::id(), "Wrong owner");
assert!(!account.data.is_empty(), "Program data is empty");

println!("✅ Program verified at {}", program_id);

Erro de Programa Não Encontrado

Erro: TransactionError::InvalidProgramForExecution

Causas Comuns:

Programa não implantado
ID de programa incorreto usado na instrução
Incompatibilidade de ID de programa com keypair

Etapas de Depuração:

// Step 1: Check if program exists
if let Some(account) = svm.get_account(&program_id) {
    println!("Program exists");
    println!("  Executable: {}", account.executable);
    println!("  Owner: {}", account.owner);
    println!("  Data length: {}", account.data.len());
} else {
    println!("Program does not exist at {}", program_id);
}

// Step 2: Verify the ID matches keypair
let expected_keypair = read_keypair_file("target/deploy/program-keypair.json").unwrap();
let expected_id = expected_keypair.pubkey();

if program_id != expected_id {
    println!("  ID mismatch!");
    println!("  Used: {}", program_id);
    println!("  Expected: {}", expected_id);
}

// Step 3: Check instruction program ID
println!("Instruction program_id: {}", instruction.program_id);
assert_eq!(instruction.program_id, program_id, "Instruction uses wrong program ID");

CPI para Programas Não Implantados

Problema: Seu programa faz uma chamada CPI para um programa que não está implantado.

Solução: Implante todos os programas de dependência:

// Find all dependency programs and make sure they are deployed
svm.add_program_from_file(
    pubkey!("gSbePebfvPy7tRqimPoVecS2UsBvYv46ynrzWocc92s"),
    "pyth.so"
).unwrap();

Se você precisar obter o programa de um cluster, consulte esta seção.

lamports Insuficientes para Implantação

Nota: O LiteSVM gerencia automaticamente o saldo isento de aluguel para programas.

// No need to manually fund - LiteSVM handles this
svm.add_program(program_id, &program_bytes).unwrap();

// But you can check the rent if needed
let program_len = program_bytes.len();
let required_lamports = svm.minimum_balance_for_rent_exemption(program_len);
println!("Program requires {} lamports for rent exemption", required_lamports);

Lista de Verificação de Implantação

Leia o keypair do programa

let keypair = read_keypair_file("target/deploy/program-keypair.json").unwrap();
let program_id = keypair.pubkey();

Implante com o ID correspondente

svm.add_program(program_id, &program_bytes).unwrap();

Verifique a implantação

assert!(svm.get_account(&program_id).unwrap().executable);

Implante todos os programas que o seu programa chama via CPI na instância de teste litesvm

Próximos Passos

Na próxima seção, aprenderemos como executar instruções de programa e lidar com padrões de transação complexos.

✓ Prós

✗ Contras

✓ Vantagens

✗ Desvantagens

Índice