Zestaw klienta

@solana/kit dostarcza createClient — niewielki kontener, który rozszerzasz wtyczkami. Każda wtyczka dodaje nową możliwość — połączenie RPC, sygnatariusza, planowanie transakcji — a złożony klient obsługuje zarówno skrypty, trasy serwerowe, jak i interfejsy użytkownika.

Instalacja

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

Użyj dowolnego menedżera pakietów. Kit jest w wersji v7+, a pakiety @solana/kit-plugin-* są w wersji 0.13+.

Tworzenie klienta

Łącz wtyczki za pomocą .use(...). Najpierw ustaw sygnatariusza, a następnie połączenie RPC. solanaDevnetRpc() dodaje client.rpc, subskrypcje, planistę/executor transakcji oraz pomocnika client.sendTransaction — dzięki czemu aplikacja rzadko musi samodzielnie łączyć te elementy.

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

Wtyczka signer ustawia zarówno płatnika opłat, jak i tożsamość aplikacji. Pakiet RPC wymaga, aby płatnik był już ustawiony, dlatego kolejność ma znaczenie.

Warianty sygnatariusza

@solana/kit-plugin-signer udostępnia trzy role, dzięki czemu przyznajesz klientowi tylko niezbędne uprawnienia:

• signer(x) — ustawia zarówno client.payer, jak i client.identity.
• payer(x) — wyłącznie płatnik opłat.
• identity(x) — wyłącznie uprawnienie aplikacji.

Każda z nich posiada warianty *FromFile(path) (Node), generated*(), generated*WithSol(amount) oraz airdrop*() przeznaczone do testów i skryptów.

Wysyłanie transakcji

Buduj instrukcje przy użyciu wygenerowanego klienta programu, a następnie przekaż je do client.sendTransaction. Planista rozwiązuje blockhash, szacuje compute, podpisuje przy użyciu płatnika klienta i przesyła transakcję.

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 zwraca obiekt wynikowy; sygnatura transakcji znajduje się pod result.context.signature. Metoda potwierdza, że plan mieści się w jednej transakcji i w przeciwnym razie zgłasza wyjątek — użyj sendTransactions, gdy partia może obejmować wiele transakcji.

Wybór pakietu RPC

@solana/kit-plugin-rpc dostarcza presety klastrów:

• solanaDevnetRpc() — domyślne ustawienia devnet, airdrop włączony (client.airdrop).
• solanaMainnetRpc() — mainnet; airdrop jest błędem czasu kompilacji.
• solanaLocalRpc() — http://127.0.0.1:8899 dla lokalnego validator.
• solanaRpc({ rpcUrl }) — dowolny endpoint.

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

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

Szczegółowe składanie

Presety łączą połączenie RPC, planistę, executor i pomocniki wysyłania, więc większość aplikacji nigdy nie potrzebuje tych elementów osobno. Przejdź do szczegółowych wtyczek tylko wtedy, gdy chcesz dostosować jeden z nich — na przykład niestandardowego planistę lub inny kanał subskrypcji. Ta ścieżka wymaga również @solana/kit-plugin-instruction-plan, który presety w przeciwnym razie dołączają automatycznie:

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

Dodawanie klientów programów

Wygenerowane pakiety @solana-program/* udostępniają wtyczki klienta, dzięki czemu wywołania programów są dostępne bezpośrednio z klienta. Zainstaluj potrzebny program i dołącz jego wtyczkę przez .use():

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

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

Podpisywanie bez portfela przeglądarki

Uruchamiasz headless w trasie API, workerze lub skrypcie? Podpisuj przy użyciu backendowej usługi zarządzania kluczami zamiast surowego keypair. Zobacz Keychain i Podpisywanie na Produkcji.

Typowe wzorce dla deweloperów Solana

• Współdzielona konfiguracja: Zbuduj klienta raz w module podstawowym i importuj go do skryptów, tras serwerowych i interfejsu użytkownika.
• Odczyty po stronie serwera: Klient z samym signer + solanaRpc (bez wtyczki portfela) odczytuje konta i symuluje transakcje po stronie serwera.
• Testowanie lokalne: Zamień pakiet RPC na .use(litesvm()) z @solana/kit-plugin-litesvm, aby uruchomić w oparciu o validator działający w pamięci (tylko Node).
• Testowalność: Złożony klient jest łatwy do mockowania — podstawiaj odpowiedzi RPC lub sygnatariuszy bez konieczności posiadania portfela przeglądarki.