Kit client

@solana/kit fournit createClient, un hôte léger que vous étendez avec des plugins. Chaque plugin ajoute une capacité — une connexion RPC, un signataire, la planification des transactions — et le client composé sert aussi bien les scripts, les routes serveur que les interfaces utilisateur.

Installation

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

Utilisez n'importe quel gestionnaire de paquets. Kit est en v7+ et les paquets @solana/kit-plugin-* sont en 0.13+.

Créer un client

Composez les plugins avec .use(...). Définissez d'abord un signataire, puis la connexion RPC. solanaDevnetRpc() ajoute client.rpc, les abonnements, le planificateur/exécuteur de transactions et l'assistant client.sendTransaction — une application n'a donc rarement besoin de câbler ces éléments elle-même.

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

Le plugin signer définit à la fois le payeur des frais et l'identité de l'application. Le bundle RPC exige qu'un payeur soit en place au préalable, c'est pourquoi l'ordre est important.

Variantes de signataire

@solana/kit-plugin-signer expose trois rôles afin que vous n'accordiez que ce dont un client a besoin :

• signer(x) — définit à la fois client.payer et client.identity.
• payer(x) — payeur des frais uniquement.
• identity(x) — autorité de l'application uniquement.

Chacun dispose de variantes *FromFile(path) (Node), generated*(), generated*WithSol(amount) et airdrop*() pour les tests et les scripts.

Envoyer une transaction

Construisez les instructions avec un client de programme généré, puis confiez-les à client.sendTransaction. Le planificateur résout le blockhash, estime le calcul, signe avec le payeur du client et soumet la transaction.

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 se résout en un objet de résultat ; la signature de transaction se trouve dans result.context.signature. Il vérifie que le plan tient dans une seule transaction et lève une exception sinon — utilisez sendTransactions lorsqu'un lot peut s'étendre sur plusieurs transactions.

Choisir un bundle RPC

@solana/kit-plugin-rpc fournit des préréglages de cluster :

• solanaDevnetRpc() — paramètres devnet par défaut, airdrop activé (client.airdrop).
• solanaMainnetRpc() — mainnet ; l'airdrop est une erreur à la compilation.
• solanaLocalRpc() — http://127.0.0.1:8899 pour un validator local.
• solanaRpc({ rpcUrl }) — n'importe quel endpoint.

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

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

Composer de façon granulaire

Les préréglages regroupent la connexion RPC, le planificateur, l'exécuteur et les assistants d'envoi, de sorte que la plupart des applications n'ont jamais besoin des éléments individuellement. Passez aux plugins granulaires uniquement pour en personnaliser un — par exemple un planificateur personnalisé ou un canal d'abonnement différent. Cette approche nécessite également @solana/kit-plugin-instruction-plan, que les préréglages incluent autrement pour vous :

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

Ajouter des clients de programme

Les paquets @solana-program/* générés exposent des plugins client afin que les appels de programme soient rattachés au client. Installez le programme dont vous avez besoin et appelez .use() avec son plugin :

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

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

Signer sans portefeuille navigateur

Vous exécutez en mode headless dans une route API, un worker ou un script ? Signez avec un service de gestion de clés backend plutôt qu'avec un keypair brut. Consultez Keychain et Signature en production.

Modèles courants pour les développeurs Solana

• Configuration partagée : Construisez le client une seule fois dans un module central et importez-le dans les scripts, les routes serveur et votre interface utilisateur.
• Lectures côté serveur : Un client avec uniquement signer + solanaRpc (sans plugin de portefeuille) lit les comptes et simule les transactions depuis le serveur.
• Tests locaux : Remplacez le bundle RPC par .use(litesvm()) depuis @solana/kit-plugin-litesvm pour exécuter contre un validator en mémoire (Node uniquement).
• Testabilité : Le client composé est facile à simuler — remplacez les réponses RPC ou les signataires sans avoir besoin d'un portefeuille navigateur.