Kit cliente

@solana/kit incluye createClient, un pequeño host que se amplía con plugins. Cada plugin añade una capacidad — una conexión RPC, un firmante, planificación de transacciones — y el cliente compuesto respalda scripts, rutas de servidor e interfaces de usuario por igual.

Instalación

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

Usa el gestor de paquetes que prefieras. Kit es v7+ y los paquetes @solana/kit-plugin-* son 0.13+.

Crear un cliente

Compón plugins con .use(...). Establece primero un firmante y luego la conexión RPC. solanaDevnetRpc() añade client.rpc, suscripciones, el planificador/ejecutor de transacciones y el helper client.sendTransaction — por lo que una app raramente necesita conectar esas piezas por sí misma.

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

El plugin signer establece tanto el pagador de comisiones como la identidad de la app. El bundle RPC requiere que haya un pagador configurado de antemano, por eso el orden importa.

Variantes de firmante

@solana/kit-plugin-signer expone tres roles para que solo otorgues lo que un cliente necesita:

• signer(x) — establece tanto client.payer como client.identity.
• payer(x) — solo pagador de comisiones.
• identity(x) — solo autoridad de la app.

Cada uno dispone de variantes *FromFile(path) (Node), generated*(), generated*WithSol(amount) y airdrop*() para pruebas y scripts.

Enviar una transacción

Construye instrucciones con un cliente de programa generado y luego pásalas a client.sendTransaction. El planificador resuelve el blockhash, estima el cómputo, firma con el pagador del cliente y lo envía.

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 resuelve en un objeto de resultado; la firma de la transacción se encuentra en result.context.signature. Verifica que el plan quepa en una sola transacción y lanza un error en caso contrario — usa sendTransactions cuando un lote pueda abarcar múltiples transacciones.

Elegir un bundle RPC

@solana/kit-plugin-rpc incluye presets de clúster:

• solanaDevnetRpc() — valores predeterminados de devnet, airdrop habilitado (client.airdrop).
• solanaMainnetRpc() — mainnet; el airdrop es un error en tiempo de compilación.
• solanaLocalRpc() — http://127.0.0.1:8899 para un validator local.
• solanaRpc({ rpcUrl }) — cualquier endpoint.

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

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

Composición granular

Los presets agrupan la conexión RPC, el planificador, el ejecutor y los helpers de envío, por lo que la mayoría de las apps nunca necesitan las piezas de forma individual. Recurre a los plugins granulares solo para personalizar uno — por ejemplo, un planificador personalizado o un canal de suscripción diferente. Este camino también requiere @solana/kit-plugin-instruction-plan, que los presets incluyen por ti:

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

Añadir clientes de programa

Los paquetes @solana-program/* generados exponen plugins de cliente para que las llamadas al programa cuelguen del cliente. Instala el programa que necesites y aplica .use() con su plugin:

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

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

Firma sin una billetera de navegador

¿Ejecutando sin interfaz en una ruta de API, un worker o un script? Firma con un servicio de gestión de claves en el backend en lugar de un keypair en bruto. Consulta Keychain y Firma en Producción.

Patrones comunes para desarrolladores de Solana

• Configuración compartida: Construye el cliente una sola vez en un módulo central e impórtalo en scripts, rutas de servidor y tu interfaz de usuario.
• Lecturas del lado del servidor: Un cliente con solo signer + solanaRpc (sin plugin de billetera) lee cuentas y simula transacciones desde el servidor.
• Pruebas locales: Reemplaza el bundle RPC por .use(litesvm()) de @solana/kit-plugin-litesvm para ejecutar contra un validator en memoria (solo Node).
• Capacidad de prueba: El cliente compuesto es fácil de simular — stub de respuestas RPC o firmantes sin necesidad de una billetera de navegador.