Kit client

@solana/kit include createClient, un piccolo host che puoi estendere con plugin. Ogni plugin aggiunge una funzionalità — una connessione RPC, un signer, la pianificazione delle transazioni — e il client composto supporta script, route server e interfacce utente allo stesso modo.

Installazione

$ 
npm install @solana/kit @solana/kit-plugin-rpc @solana/kit-plugin-signerCopy

Usa il gestore di pacchetti che preferisci. Kit è v7+ e i pacchetti @solana/kit-plugin-* sono 0.13+.

Creare un client

Componi i plugin con .use(...). Imposta prima un signer, poi la connessione RPC. solanaDevnetRpc() aggiunge client.rpc, le sottoscrizioni, il pianificatore/esecutore di transazioni e l'helper client.sendTransaction — così un'app raramente ha bisogno di collegare questi elementi da sola.

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

const payer = await generateKeyPairSigner();

const client = createClient().use(signer(payer)).use(solanaDevnetRpc());

const slot = await client.rpc.getSlot().send();
console.log("current slot", slot);

Il plugin signer imposta sia il pagatore delle commissioni sia l'identità dell'app. Il bundle RPC richiede che un pagatore sia già configurato, ed è per questo che l'ordine è importante.

Varianti del signer

@solana/kit-plugin-signer espone tre ruoli in modo da concedere solo ciò di cui un client ha bisogno:

• signer(x) — imposta sia client.payer che client.identity.
• payer(x) — solo pagatore delle commissioni.
• identity(x) — solo autorità dell'app.

Ognuno ha le varianti *FromFile(path) (Node), generated*(), generated*WithSol(amount) e airdrop*() per test e script.

Inviare una transazione

Costruisci le istruzioni con un client di programma generato, poi passale a client.sendTransaction. Il pianificatore risolve il blockhash, stima il compute, firma con il payer del client e invia.

import { getTransferSolInstruction } from "@solana-program/system";
import { address, lamports } from "@solana/kit";

const transfer = getTransferSolInstruction({
  source: client.payer,
  destination: address("Fke...address"),
  amount: lamports(10_000_000n) // 0.01 SOL
});

const { context } = await client.sendTransaction([transfer]);
console.log("submitted", context.signature);

sendTransaction restituisce un oggetto risultato; la firma della transazione si trova in result.context.signature. Verifica che il piano rientri in una singola transazione e lancia un'eccezione in caso contrario — usa sendTransactions quando un batch può coprire più transazioni.

Scegliere un bundle RPC

@solana/kit-plugin-rpc include preset per i cluster:

• solanaDevnetRpc() — impostazioni predefinite per devnet, airdrop abilitato (client.airdrop).
• solanaMainnetRpc() — mainnet; l'airdrop genera un errore in fase di compilazione.
• solanaLocalRpc() — http://127.0.0.1:8899 per un validator locale.
• solanaRpc({ rpcUrl }) — qualsiasi endpoint.

import { solanaRpc } from "@solana/kit-plugin-rpc";

const client = createClient()
  .use(signer(payer))
  .use(solanaRpc({ rpcUrl: "https://your-rpc-provider.example" }));

Composizione granulare

I preset raggruppano la connessione RPC, il pianificatore, l'esecutore e gli helper di invio, quindi la maggior parte delle app non avrà mai bisogno dei singoli componenti. Scendi ai plugin granulari solo per personalizzarne uno — ad esempio un pianificatore personalizzato o un canale di sottoscrizione diverso. Questo percorso richiede anche @solana/kit-plugin-instruction-plan, che i preset includono altrimenti per te:

import {
  solanaRpcConnection,
  rpcAirdrop,
  rpcTransactionPlanner,
  rpcTransactionPlanExecutor
} from "@solana/kit-plugin-rpc";
import { planAndSendTransactions } from "@solana/kit-plugin-instruction-plan";

const client = createClient()
  .use(signer(payer))
  .use(solanaRpcConnection({ rpcUrl: "https://api.devnet.solana.com" }))
  .use(rpcAirdrop())
  .use(rpcTransactionPlanner())
  .use(rpcTransactionPlanExecutor())
  .use(planAndSendTransactions());

Aggiungere client di programma

I pacchetti @solana-program/* generati espongono plugin client così le chiamate ai programmi sono disponibili direttamente sul client. Installa il programma di cui hai bisogno e usa .use() con il suo plugin:

import { tokenProgram } from "@solana-program/token";

const client = createClient()
  .use(signer(payer))
  .use(solanaDevnetRpc())
  .use(tokenProgram()); // adds client.token

Firma senza un wallet browser

Esegui in modalità headless in una route API, un worker o uno script? Firma con un servizio di gestione delle chiavi backend invece di un keypair grezzo. Vedi Keychain e Firma in Produzione.

Pattern comuni per gli sviluppatori Solana

• Setup condiviso: Costruisci il client una volta in un modulo core e importalo in script, route server e nella tua UI.
• Letture lato server: Un client con solo signer + solanaRpc (senza plugin wallet) legge account e simula transazioni dal server.
• Test locali: Sostituisci il bundle RPC con .use(litesvm()) da @solana/kit-plugin-litesvm per eseguire test su un validator in memoria (solo Node).
• Testabilità: Il client composto è facile da simulare — sostituisci le risposte RPC o i signer senza che sia presente un wallet browser.