Per Iniziare

Le suite di test Solana che avviano solana-test-validator richiedono secondi per ogni test — si attende l'avvio del processo, le connessioni RPC e i round-trip di rete. LiteSVM esegue gli stessi test in millisecondi. Nessun processo esterno, nessuna rete, tutto in memoria all'interno del tuo test runner.

Testato 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. Questi pacchetti plugin sono nuovi e in rapida evoluzione — in caso di incompatibilità, controlla testing/package.json per le versioni esatte utilizzate dalla documentazione e dalla suite di test.

Assembli un client Kit da @solana/kit installando plugin tramite .use(): un plugin per la firma (@solana/kit-plugin-signer), il plugin LiteSVM (@solana/kit-plugin-litesvm), e qualsiasi plugin di programma necessario. Il risultato espone client.sendTransaction(), client.rpc, e accesso diretto allo stato degli account, al clock e alle sysvars — tutto senza uscire dal tuo processo.

Avvio Rapido

Installa le Dipendenze

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

Crea il Tuo Client

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() restituisce una struttura vuota — ogni .use(plugin) aggiunge funzionalità su di essa. Il plugin signer() deve venire prima di litesvm() perché il plugin di trasporto ha bisogno di un pagante a cui collegarsi. signer(mySigner) è una scorciatoia per installare lo stesso keypair sia come payer che come identity — usa payer() o identity() dallo stesso pacchetto se vuoi separare questi ruoli. Questo ordine è lo stesso per solanaRpc() quando sei su una rete reale.

Preferisci una configurazione in una riga per esperimenti rapidi? Il bundle litesvm() include un airdrop, quindi puoi concatenare .use(generatedPayerWithSol(lamports(10_000_000_000n))) da @solana/kit-plugin-signer per generare automaticamente e finanziare un pagante.

Comprendere il Client

Dopo .use(signer(...)).use(litesvm()), il client espone:

Proprietà	Descrizione
`client.payer`	Il `TransactionSigner` installato con il plugin `signer()` (impostato anche come `client.identity`)
`client.identity`	Il wallet signer che possiede account, token e autorità
`client.svm`	Istanza diretta di `LiteSVM` per la gestione degli account, le transazioni e la configurazione
`client.rpc`	Interfaccia RPC compatibile con Kit (sottoinsieme: `getAccountInfo`, `getBalance`, `getEpochSchedule`, `getLatestBlockhash`, `getMinimumBalanceForRentExemption`, `getMultipleAccounts`, `getSlot`, `requestAirdrop`)
`client.sendTransaction(s)`	Pianifica, firma e invia istruzioni come transazione
`client.airdrop`	Richiedi SOL dal faucet LiteSVM
`client.getMinimumBalance`	Calcola il numero minimo di lamport per l'esenzione dal rent

Utilizzo di client.svm

Accesso diretto a LiteSVM per:

Gestione degli account (setAccount, getAccount, airdrop)
Esecuzione di transazioni (sendTransaction, simulateTransaction)
Configurazione (withSigverify, withBlockhashCheck, ecc.)
Manipolazione del tempo (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();

Utilizzo di client.rpc

Interfaccia RPC compatibile con Kit per operazioni standard:

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

Il layer RPC supporta solo la codifica base64. La richiesta di altre codifiche genererà un errore.

Configurazione

Configura LiteSVM utilizzando i metodi builder su 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

Invio di Transazioni

Aggiungi plugin di programma dopo il transport — questi collegano i builder di istruzioni al client così da non dover mai manipolare direttamente un TransactionMessage:

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

Flusso SVM → RPC

Puoi impostare lo stato tramite SVM e leggerlo tramite 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']

Prossimi Passi

Questa sezione copre il client principale — creazione di account, invio di istruzioni e lettura dello stato. Se i tuoi test coinvolgono token SPL (mint, ATA, trasferimenti), la guida al testing dei token mostra come il plugin tokenProgram() riduce ~40 righe di configurazione a 3 chiamate. Per un riferimento completo all'API, consulta la documentazione API.

Indice dei contenuti