Primeros pasos

Los conjuntos de pruebas de Solana que levantan solana-test-validator tardan segundos por prueba — estás esperando el inicio del proceso, las conexiones RPC y los viajes de ida y vuelta por la red. LiteSVM ejecuta las mismas pruebas en milisegundos. Sin procesos externos, sin red, todo en memoria dentro de tu ejecutor de pruebas.

Probado con: @solana/kit@6.8.0, @solana/kit-plugin-litesvm@0.10.0, @solana/kit-plugin-signer@0.10.0, @solana-program/system@0.12.0, @solana-program/token@0.13.0. Estos paquetes de plugins son nuevos y evolucionan rápidamente — si encuentras una incompatibilidad, consulta testing/package.json para conocer las versiones exactas con las que funcionan los docs y el conjunto de pruebas.

Ensamblas un cliente Kit desde @solana/kit instalando plugins con .use(): un plugin de firmante (@solana/kit-plugin-signer), el plugin de LiteSVM (@solana/kit-plugin-litesvm), y cualquier plugin de programa que necesites. El resultado expone client.sendTransaction(), client.rpc, y acceso directo al estado de cuentas, al reloj y a los sysvars — todo sin salir de tu proceso.

Inicio rápido

Instalar dependencias

pnpm add @solana/kit @solana/kit-plugin-litesvm @solana/kit-plugin-signer @solana-program/system

Crear tu cliente

import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { litesvm } from "@solana/kit-plugin-litesvm";
import { signer } from "@solana/kit-plugin-signer";

// Payer first, then the LiteSVM transport.
const mySigner = await generateKeyPairSigner();
const client = createClient().use(signer(mySigner)).use(litesvm());

// Fund the payer
client.svm.airdrop(client.payer.address, lamports(5_000_000_000n));

// Check the balance
const balance = client.svm.getBalance(client.payer.address);
console.log("Balance:", balance, "lamports");

createClient() devuelve una estructura vacía — cada .use(plugin) añade capacidades sobre ella. El plugin signer() debe ir antes que litesvm() porque el plugin de transporte necesita un pagador al que vincularse. signer(mySigner) es un atajo para instalar el mismo keypair como payer e identity — usa payer() o identity() del mismo paquete si quieres separar esos roles. Este orden es el mismo para solanaRpc() cuando usas una red real.

¿Prefieres una configuración de una sola línea para experimentos rápidos? El bundle litesvm() incluye un airdrop, así que puedes encadenar .use(generatedPayerWithSol(lamports(10_000_000_000n))) de @solana/kit-plugin-signer para generar y fondear automáticamente un pagador.

Entendiendo el cliente

Tras .use(signer(...)).use(litesvm()), el cliente expone:

Propiedad	Descripción
`client.payer`	El `TransactionSigner` que instalaste con el plugin `signer()` (también establecido como `client.identity`)
`client.identity`	El firmante de la billetera que es propietario de cuentas, tokens y autoridades
`client.svm`	Instancia directa de `LiteSVM` para gestión de cuentas, transacciones y configuración
`client.rpc`	Interfaz RPC compatible con Kit (subconjunto: `getAccountInfo`, `getBalance`, `getEpochSchedule`, `getLatestBlockhash`, `getMinimumBalanceForRentExemption`, `getMultipleAccounts`, `getSlot`, `requestAirdrop`)
`client.sendTransaction(s)`	Planifica, firma y envía instrucciones como una transacción
`client.airdrop`	Solicita SOL desde el faucet de LiteSVM
`client.getMinimumBalance`	Calcula el mínimo de lamport para la exención de rent

Uso de client.svm

Acceso directo a LiteSVM para:

Gestión de cuentas (setAccount, getAccount, airdrop)
Ejecución de transacciones (sendTransaction, simulateTransaction)
Configuración (withSigverify, withBlockhashCheck, etc.)
Manipulación del tiempo (warpToSlot, getClock)

import { address, lamports } from "@solana/kit";

// Fund an account
client.svm.airdrop(address, lamports(1_000_000_000n));

// Set account state directly
client.svm.setAccount({
  address: myAddress,
  data: new Uint8Array([1, 2, 3]),
  executable: false,
  lamports: lamports(1_000_000n),
  programAddress: address("11111111111111111111111111111111"),
  space: 3n
});

// Get the latest blockhash
const blockhash = client.svm.latestBlockhash();

Uso de client.rpc

Interfaz RPC compatible con Kit para operaciones estándar:

// Get account info (returns base64-encoded data)
const { value: account } = await client.rpc.getAccountInfo(address).send();

// Get multiple accounts in one call
const { value: accounts } = await client.rpc
  .getMultipleAccounts([addr1, addr2, addr3])
  .send();

// Get latest blockhash
const { value: blockhash } = await client.rpc.getLatestBlockhash().send();

La capa RPC solo admite codificación base64. Solicitar otras codificaciones generará un error.

Configuración

Configura LiteSVM usando métodos de construcción en client.svm:

const client = createClient().use(signer(mySigner)).use(litesvm());

// Configure for testing
client.svm
  .withSigverify(false) // Skip signature verification
  .withBlockhashCheck(false) // Skip blockhash validation
  .withSysvars() // Enable Clock, Rent, etc.
  .withBuiltins() // Enable ed25519, secp256k1
  .withTransactionHistory(100n); // Store transaction history

Envío de transacciones

Añade plugins de programa después del transporte — incorporan constructores de instrucciones al cliente para que nunca tengas que manipular un TransactionMessage directamente:

import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { litesvm } from "@solana/kit-plugin-litesvm";
import { signer } from "@solana/kit-plugin-signer";
import { systemProgram } from "@solana-program/system";

const mySigner = await generateKeyPairSigner();
const client = createClient()
  .use(signer(mySigner))
  .use(litesvm())
  .use(systemProgram());

client.svm.airdrop(client.payer.address, lamports(10_000_000_000n));

const recipient = await generateKeyPairSigner();

// Build and send in one call
await client.system.instructions
  .transferSol({
    source: client.payer,
    destination: recipient.address,
    amount: lamports(1_000_000_000n)
  })
  .sendTransaction();

Flujo SVM → RPC

Puedes establecer estado mediante SVM y leerlo mediante RPC:

import { address, lamports } from "@solana/kit";

// Set account directly via SVM
client.svm.setAccount({
  address: myAddress,
  data: new Uint8Array([0xde, 0xad, 0xbe, 0xef]),
  executable: false,
  lamports: lamports(1_000_000n),
  programAddress: address("11111111111111111111111111111111"),
  space: 4n
});

// Read via RPC (returns base64-encoded data)
const { value } = await client.rpc.getAccountInfo(myAddress).send();
console.log("Data:", value?.data); // ['3q2+7w==', 'base64']

¿Qué sigue?

Esto cubre el cliente principal — crear cuentas, enviar instrucciones y leer estado. Si tus pruebas implican tokens SPL (mints, ATAs, transferencias), la guía de pruebas de tokens muestra cómo el plugin tokenProgram() reduce ~40 líneas de configuración a 3 llamadas. Para una referencia completa de la API, consulta la documentación de la API.

Tabla de Contenidos