1---
2title: "@solana/kit Quick Start"
3description: Quick-start guide for @solana/kit using createClient + .use() plugin composition for RPC, signers, transaction sending, account fetching, and common Solana patterns.
4---
5 
6# @solana/kit Reference
7 
8`@solana/kit` is the JavaScript SDK for building Solana applications. Modular, tree-shakable, full TypeScript support. Clients are built by composing plugins onto `createClient()` via `.use()`.
9 
10## Installation
11 
12```bash
13npm install @solana/kit @solana/kit-plugin-rpc @solana/kit-plugin-signer
14# or: pnpm add @solana/kit @solana/kit-plugin-rpc @solana/kit-plugin-signer
15```
16 
17For LiteSVM testing add `@solana/kit-plugin-litesvm`. For Codama-generated program clients add the relevant `@solana-program/*` package(s).
18 
19Minimum version: Solana Kit v6.8.0.
20 
21## Quick Start
22 
23### Local Development
24 
25```ts
26import { createClient } from '@solana/kit';
27import { solanaLocalRpc } from '@solana/kit-plugin-rpc';
28import { signerFromFile } from '@solana/kit-plugin-signer';
29 
30// `signerFromFile` sets BOTH payer and identity to the loaded keypair (the common case).
31// Other options:
32//   - `signer(existingSigner)`              // explicit signer you already hold
33//   - `generatedSigner()` + `airdropSigner(lamports(n))` // fresh local/devnet signer, funded after RPC is installed
34//   - `payer(...)` + `identity(...)`        // when fees and authority come from different keypairs
35const client = await createClient()
36  .use(signerFromFile('~/.config/solana/id.json'))
37  .use(solanaLocalRpc());
38 
39console.log('Payer:', client.payer.address);
40await client.sendTransaction([myInstruction]);
41```
42 
43### Production (Mainnet/Devnet)
44 
45```ts
46import { createClient } from '@solana/kit';
47import { solanaDevnetRpc, solanaMainnetRpc } from '@solana/kit-plugin-rpc';
48import { signer } from '@solana/kit-plugin-signer';
49 
50const client = createClient()
51  .use(signer(mySigner)) // sets payer + identity; use payer(...) + identity(...) if they differ
52  .use(solanaDevnetRpc()); // or solanaMainnetRpc({ rpcUrl: 'https://...' })
53 
54await client.sendTransaction([myInstruction]);
55```
56 
57`solanaDevnetRpc()` defaults to `https://api.devnet.solana.com` and bundles airdrop. `solanaMainnetRpc({ rpcUrl })` is type-narrowed to a mainnet URL — no devnet-only methods like `airdrop`.
58 
59### Testing with LiteSVM
60 
61```ts
62import { createClient, lamports } from '@solana/kit';
63import { litesvm } from '@solana/kit-plugin-litesvm';
64import { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';
65 
66const client = await createClient()
67  .use(generatedSigner())
68  .use(litesvm())
69  .use(airdropSigner(lamports(1_000_000_000n)));
70 
71client.svm.addProgramFromFile(myProgramAddress, 'program.so');
72await client.sendTransaction([myInstruction]);
73```
74 
75Full documentation: [LiteSVM](https://www.litesvm.com/docs/typescript/getting-started).
76 
77## Client API
78 
79After applying `solanaRpc` / `solanaLocalRpc` / `solanaDevnetRpc` / `solanaMainnetRpc` (or `litesvm`), the client exposes:
80 
81| Property/Method | Description |
82|-----------------|-------------|
83| `client.rpc` | RPC methods (`getBalance`, `getAccountInfo`, etc.) |
84| `client.rpcSubscriptions` | WebSocket subscriptions (RPC plugins only) |
85| `client.payer` | Transaction fee payer signer (set by `signer()` or `payer()`) |
86| `client.identity` | Authority signer (set by `signer()` or `identity()`) |
87| `client.sendTransaction(instructions)` | Plan + sign + send in one call |
88| `client.sendTransactions(plan)` | Execute a planned multi-tx plan |
89| `client.planTransaction(s)` | Plan without executing |
90| `client.getMinimumBalance(dataSize)` | Rent-exempt minimum lamports |
91| `client.airdrop(address, lamports)` | Faucet (devnet/local/litesvm only) |
92| `client.svm` | LiteSVM instance (litesvm plugin only) |
93 
94`solanaRpc({ ... })` accepts `rpcUrl` (required) plus `rpcSubscriptionsUrl`, `transactionConfig` (priority fees), `maxConcurrency`, `skipPreflight`, and the underlying `rpcConfig` / `rpcSubscriptionsConfig`. See [plugins.md](plugins.md) for the full options table, plugin catalog, and custom composition.
95 
96## Core Concepts
97 
98### Branded Types
99 
100```ts
101import { address, lamports, signature } from '@solana/kit';
102 
103const myAddress = address('So11111111111111111111111111111111111111112');
104const myLamports = lamports(1_000_000_000n);
105const mySig = signature('5eykt...');
106```
107 
108### Signers
109 
110```ts
111import { generateKeyPairSigner } from '@solana/kit';
112const signer = await generateKeyPairSigner();
113// signer.address — the public key
114// signer is a TransactionSigner
115```
116 
117### Codec Direction
118 
119- **`encode()`**: values → `Uint8Array`
120- **`decode()`**: `Uint8Array` → values
121 
122Always use native codecs (e.g., `getBase58Codec()`). Never import bs58.
123 
124See [codecs.md](codecs.md) for full codec patterns.
125 
126## Common Patterns
127 
128### Send SOL Transfer
129 
130```ts
131import { createClient, address, lamports } from '@solana/kit';
132import { solanaLocalRpc } from '@solana/kit-plugin-rpc';
133import { signerFromFile } from '@solana/kit-plugin-signer';
134import { getTransferSolInstruction } from '@solana-program/system';
135 
136const client = await createClient()
137  .use(signerFromFile('~/.config/solana/id.json'))
138  .use(solanaLocalRpc());
139 
140const ix = getTransferSolInstruction({
141  source: client.payer,
142  destination: address('recipient...'),
143  amount: lamports(1_000_000_000n),
144});
145 
146await client.sendTransaction([ix]);
147```
148 
149### Fetch Account
150 
151```ts
152import { fetchEncodedAccount, assertAccountExists, decodeAccount } from '@solana/kit';
153 
154const account = await fetchEncodedAccount(client.rpc, myAddress);
155assertAccountExists(account);
156const decoded = decodeAccount(account, myDecoder);
157```
158 
159See [accounts.md](accounts.md) for batch fetching, PDAs, subscriptions, and token queries.
160 
161### Token Operations
162 
163Use the `tokenProgram()` plugin from `@solana-program/token` for a fluent token API. It auto-derives ATAs, auto-creates them if needed, and defaults the payer from the client.
164 
165```ts
166import { createClient, generateKeyPairSigner } from '@solana/kit';
167import { solanaLocalRpc } from '@solana/kit-plugin-rpc';
168import { signerFromFile } from '@solana/kit-plugin-signer';
169import { tokenProgram } from '@solana-program/token';
170 
171const client = await createClient()
172  .use(signerFromFile('~/.config/solana/id.json'))
173  .use(solanaLocalRpc())
174  .use(tokenProgram());
175 
176const mintAuthority = await generateKeyPairSigner();
177const mint = await generateKeyPairSigner();
178 
179// Create a new mint
180await client.token.instructions
181  .createMint({ newMint: mint, decimals: 2, mintAuthority: mintAuthority.address })
182  .sendTransaction();
183 
184// Mint tokens to an owner's ATA (created automatically if needed)
185await client.token.instructions
186  .mintToATA({
187    mint: mint.address,
188    owner: recipientAddress,
189    mintAuthority,
190    amount: 1_000_000n,
191    decimals: 2,
192  })
193  .sendTransaction();
194 
195// Transfer tokens to a recipient's ATA (auto-derives source + destination)
196await client.token.instructions
197  .transferToATA({
198    mint: mint.address,
199    authority: ownerSigner,
200    recipient: recipientAddress,
201    amount: 500n,
202    decimals: 2,
203  })
204  .sendTransaction();
205```
206 
207See [programs/token.md](programs/token.md) for low-level instruction patterns and [programs/token-2022.md](programs/token-2022.md) for Token Extensions.
208 
209### Custom Program Operations
210 
211Programs that ship a Kit plugin follow the same `.use()` pattern:
212 
213```ts
214import { createClient } from '@solana/kit';
215import { solanaDevnetRpc } from '@solana/kit-plugin-rpc';
216import { signer } from '@solana/kit-plugin-signer';
217import { myProgram } from '@my-programs/operations';
218 
219const client = createClient()
220  .use(signer(mySigner))
221  .use(solanaDevnetRpc())
222  .use(myProgram());
223 
224await client.myProgram.instructions
225  .handyInstruction({ /* args */ })
226  .sendTransaction();
227```
228 
229### RPC Queries
230 
231```ts
232// Balance
233const { value: balance } = await client.rpc.getBalance(myAddress).send();
234 
235// Token accounts
236const { value: tokenAccs } = await client.rpc.getTokenAccountsByOwner(
237  owner,
238  { mint: mintAddr },
239  { encoding: 'jsonParsed' },
240).send();
241 
242// Latest blockhash
243const { value: blockhash } = await client.rpc.getLatestBlockhash().send();
244```
245 
246## Codama Program Clients
247 
248`@solana-program/*` packages are Codama-generated, Kit-compatible instruction builders:
249 
250| Package | Purpose |
251|---------|---------|
252| `@solana-program/system` | Account creation, transfers, nonces |
253| `@solana-program/token` | SPL Token operations |
254| `@solana-program/token-2022` | Token Extensions (transfer fees, metadata, etc.) |
255| `@solana-program/compute-budget` | CU limits & priority fees |
256| `@solana-program/memo` | Memo program |
257| `@solana-program/stake` | Staking operations |
258 
259**Note:** These packages export both low-level `get{Name}Instruction()` helpers and higher-level program plugins (e.g., `tokenProgram()`) that attach fluent APIs to the client. ATA functions are in `@solana-program/token` and `@solana-program/token-2022`, not a separate package.
260 
261See [codama.md](codama.md) for naming conventions and patterns.
262 
263## Package Overview
264 
265| Package | Purpose |
266|---------|---------|
267| `@solana/kit` | Main SDK, re-exports all sub-packages, exports `createClient` |
268| `@solana/kit-plugin-rpc` | All-in-one RPC plugins: `solanaRpc`, `solanaMainnetRpc`, `solanaDevnetRpc`, `solanaLocalRpc` (plus low-level `rpc`, `rpcAirdrop`, `rpcTransactionPlanner`, `rpcTransactionPlanExecutor`) |
269| `@solana/kit-plugin-signer` | Signer plugins. Default `signer*` variants set both `payer` and `identity` (`signer`, `generatedSigner`, `signerFromFile`). Use `airdropSigner` to fund an already-installed signer; use `generatedSignerWithSol` only when an airdrop function is already installed. Role-specific `payer*` and `identity*` variants for when the two roles differ. |
270| `@solana/kit-plugin-litesvm` | All-in-one `litesvm` plugin (Node.js only) for in-memory testing |
271| `@solana/kit-plugin-airdrop` | Standalone airdrop plugin (most users get this via `solanaDevnetRpc`/`solanaLocalRpc`) |
272| `@solana/kit-plugin-instruction-plan` | `planAndSendTransactions` and instruction batching primitives |
273| `@solana/addresses` | Address validation |
274| `@solana/accounts` | Account fetching/decoding |
275| `@solana/codecs` | Data encoding/decoding |
276| `@solana/rpc` | JSON RPC client primitives |
277| `@solana/rpc-subscriptions` | WebSocket subscription primitives |
278| `@solana/transactions` | Compile/sign/serialize |
279| `@solana/transaction-messages` | Build tx messages |
280| `@solana/signers` | Signing abstraction |
281| `@solana/keychain` | Common Signing Interface for external signers |
282| `@solana/instruction-plans` | Multi-instruction batching |
283| `@solana/errors` | Error identification/decoding |
284| `@solana/functional` | Pipe and compose utilities |
285| `@solana/react` | React wallet hooks |
286 
287## Best Practices
288 
2891. **Compose with `.use()`** — `createClient().use(signer(...)).use(solanaRpc(...))`; the signer plugin must come before the RPC/litesvm plugin. Use the role-specific `payer()` + `identity()` variants only when fees and authority come from different keypairs.
2902. **Use branded types** — `address()`, `lamports()`, `signature()`.
2913. **Use `@solana-program/*`** instruction builders over hand-rolled instruction data.
2924. **Handle account existence** — `assertAccountExists()` before decode.
2935. **Set compute budget** — pass `transactionConfig` to `solanaRpc({ ... })` or use manual CU estimation for production. See [programs/compute-budget.md](programs/compute-budget.md).
294 
295## Reference Files
296 
297- [plugins.md](plugins.md) — Plugin catalog, custom composition, ordering rules
298- [accounts.md](accounts.md) — Fetching, decoding, batch, PDAs, subscriptions
299- [codecs.md](codecs.md) — Complete codec patterns
300- [react.md](react.md) — React hooks and wallet integration
301- [codama.md](codama.md) — Codama patterns, naming conventions, program clients
302- [gotchas.md](gotchas.md) — Common type errors & fixes
303- [advanced.md](advanced.md) — Manual transaction building, direct RPC, building plugins, custom clients
304- [programs/](programs/) — Program client references (system, token, token-2022, compute-budget)
305