Kit cliente

@solana/kit fornece createClient, um host pequeno que você estende com plugins. Cada plugin adiciona uma capacidade — uma conexão RPC, um assinador, planejamento de transações — e o cliente composto serve tanto scripts, rotas de servidor e interfaces gráficas.

Instalação

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

Use qualquer gerenciador de pacotes. O Kit é v7+ e os pacotes @solana/kit-plugin-* são 0.13+.

Criar um cliente

Componha plugins com .use(...). Defina um assinador primeiro, depois a conexão RPC. solanaDevnetRpc() adiciona client.rpc, assinaturas, o planejador/executor de transações e o helper client.sendTransaction — portanto, um app raramente precisa conectar essas peças manualmente.

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

O plugin signer define tanto o pagador de taxas quanto a identidade do app. O bundle RPC exige que um pagador esteja configurado antes, por isso a ordem é importante.

Variantes de assinador

@solana/kit-plugin-signer expõe três funções para que você conceda apenas o que um cliente precisa:

• signer(x) — define tanto client.payer quanto client.identity.
• payer(x) — somente pagador de taxas.
• identity(x) — somente autoridade do app.

Cada um possui variantes *FromFile(path) (Node), generated*(), generated*WithSol(amount) e airdrop*() para testes e scripts.

Enviar uma transação

Construa instruções com um cliente de programa gerado e, em seguida, passe-as para client.sendTransaction. O planejador resolve o blockhash, estima o compute, assina com o pagador do cliente e envia.

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 retorna um objeto de resultado; a assinatura da transação está em result.context.signature. Ele verifica se o plano cabe em uma única transação e lança um erro caso contrário — use sendTransactions quando um lote puder abranger múltiplas transações.

Escolher um bundle RPC

@solana/kit-plugin-rpc fornece presets de cluster:

• solanaDevnetRpc() — configurações padrão da devnet, airdrop habilitado (client.airdrop).
• solanaMainnetRpc() — mainnet; airdrop resulta em erro de compilação.
• solanaLocalRpc() — http://127.0.0.1:8899 para um validator local.
• solanaRpc({ rpcUrl }) — qualquer endpoint.

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

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

Composição granular

Os presets agrupam a conexão RPC, o planejador, o executor e os helpers de envio, portanto a maioria dos apps nunca precisará das peças individualmente. Recorra aos plugins granulares apenas para personalizar algum deles — por exemplo, um planejador customizado ou um canal de assinatura diferente. Esse caminho também requer @solana/kit-plugin-instruction-plan, que os presets já incluem automaticamente:

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

Adicionar clientes de programa

Os pacotes @solana-program/* gerados expõem plugins de cliente para que as chamadas de programa fiquem vinculadas ao cliente. Instale o programa que você precisa e use .use() com seu plugin:

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

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

Assinar sem uma carteira de navegador

Executando de forma headless em uma rota de API, worker ou script? Assine com um serviço de gerenciamento de chaves no backend em vez de um keypair bruto. Consulte Keychain e Assinatura em Produção.

Padrões comuns para desenvolvedores Solana

• Configuração compartilhada: Construa o cliente uma vez em um módulo central e importe-o em scripts, rotas de servidor e sua interface gráfica.
• Leituras no servidor: Um cliente com apenas signer + solanaRpc (sem plugin de carteira) lê contas e simula transações a partir do servidor.
• Testes locais: Substitua o bundle RPC por .use(litesvm()) do @solana/kit-plugin-litesvm para executar contra um validator em memória (somente Node).
• Testabilidade: O cliente composto é fácil de mockar — simule respostas RPC ou assinadores sem precisar de uma carteira de navegador.