[ { "path": ".agents/skills/changesets/INJECT.md", "content": "---\nheading: Changesets\n---\n\n- Any PR that should trigger a package release MUST include a changeset.\n- Identify affected packages by mapping changed files to their nearest `package.json`.\n- Choose the right bump: `patch` for fixes, `minor` for features, `major` for breaking changes.\n- While a project is pre-1.0, `minor` bumps may be treated as breaking.\n- ALWAYS use `npx changeset add --empty` to generate a new changeset file with a random name. NEVER create changeset files manually.\n- No changeset needed for: docs-only changes, CI config, dev dependency updates, test-only changes.\n" }, { "path": ".agents/skills/changesets/SKILL.md", "content": "---\nname: changesets\ndescription: Generate a changeset file with a changelog entry for package releases. Use when a PR introduces user-facing changes that should trigger a version bump.\nargument-hint: \"[patch|minor|major]\"\nallowed-tools: Bash(npx changeset add --empty)\n---\n\n# Generate Changeset\n\nCreate a new changeset file for the current project using the [changesets CLI](https://github.com/changesets/changesets), then fill it with a proper changelog entry based on recent changes.\n\n## Key Rules\n\n- Any PR that should trigger a package release MUST include a changeset.\n- Identify affected packages by mapping changed files to their nearest `package.json`.\n- Choose the right bump: `patch` for fixes, `minor` for features, `major` for breaking changes.\n- While a project is pre-1.0, `minor` bumps may be treated as breaking.\n- ALWAYS use `npx changeset add --empty` to generate a new changeset file with a random name. NEVER create changeset files manually.\n- No changeset needed for: docs-only changes, CI config, dev dependency updates, test-only changes.\n- Do NOT modify any existing changeset files.\n- Only create one new changeset file per invocation.\n\n## Guidelines\n\n### Changeset Format\n\n```\n---\n'': patch\n'': patch\n---\n\n\n```\n\n### Changelog Entries\n\n- Write a concise but informative changelog entry (1-3 sentences).\n- Start with a verb — e.g. \"Add\", \"Remove\", \"Replace\", \"Fix\", \"Update\".\n- Focus on what changed from the user's perspective, not implementation details.\n- Mention renamed or removed APIs explicitly.\n\n### Breaking Changes\n\nAdd a `**BREAKING CHANGES**` section (bold paragraph, not a header) after the changelog entry when:\n\n- The bump level is `major`, OR\n- The bump level is `minor` AND the current major version is `0` (i.e. pre-1.0)\n\n...and the changes actually introduce breaking changes.\n\nThe breaking changes section should list each breaking change with a bold title summarizing the change, followed by a brief explanation and a `diff` code block showing the before/after migration when applicable. For example:\n\n```\nReplace the `useGranularImports` boolean option with a new `importStrategy` option.\n\n**BREAKING CHANGES**\n\n**`useGranularImports` replaced with `importStrategy`.** The boolean option has been replaced with a string union for finer control.\n\n\\`\\`\\`diff\n- renderVisitor('./output', { useGranularImports: true });\n+ renderVisitor('./output', { importStrategy: 'granular' });\n\\`\\`\\`\n\n**Default import behavior changed.** The default strategy is now `'preferRoot'`, which falls back to granular packages for symbols not on the root entrypoint.\n\n\\`\\`\\`diff\n- renderVisitor('./output'); // equivalent to useGranularImports: false\n+ renderVisitor('./output'); // equivalent to importStrategy: 'preferRoot'\n\\`\\`\\`\n```\n\nNot every breaking change needs a diff — use them when there's a clear before/after code change to show. For type removals or behavioral changes, a text explanation is sufficient.\n\n## Command Process\n\nWhen invoked as a command, follow these steps:\n\n### Arguments\n\n- `[patch|minor|major]` (optional): Override the bump level for all affected packages.\n\n### Steps\n\n1. **Determine the change source.** Check `git status` for uncommitted changes. If there are meaningful working tree changes, use those. Otherwise, use the latest commit(s) on the current branch (compared to the base branch from `.changeset/config.json`).\n2. **Identify which packages changed.** Look at which files were modified and map them to their nearest `package.json` to determine affected packages. Ignore changes that are not relevant to a changeset — e.g. typo fixes in comments, dependency version bumps in `package.json`, changes to CI config, docs-only changes in non-doc packages, etc. Use your judgement to filter out noise.\n3. **Run `npx changeset add --empty`** to generate a new changeset file with a random name.\n4. **Identify the newly created file** — it will be the most recently created `.md` file in `.changeset/` (excluding `README.md`).\n5. **Write the changeset file** with the proper frontmatter listing each affected package and the bump level, followed by the changelog entry.\n" }, { "path": ".agents/skills/shipping-git/INJECT.md", "content": "---\nheading: Shipping (Git)\n---\n\n- NEVER commit, push, create branches, or create PRs without explicit user approval.\n- Before any git operation that creates or modifies a commit, present a review block containing: changeset entry (if applicable), commit title, and commit/PR description. ALWAYS wait for approval.\n- Use standard `git add` and `git commit` workflows. Concise title on the first line, blank line, then description body.\n- Use `gh pr create` for pull requests.\n- Write commit and PR descriptions as natural flowing prose. Do NOT insert hard line breaks mid-paragraph.\n" }, { "path": ".agents/skills/shipping-git/SKILL.md", "content": "---\nname: shipping-git\ndescription: Shipping workflow using standard Git and GitHub CLI. Provides guidance for committing, branching, and creating PRs.\n---\n\n# Ship Code Using Git\n\nGuidance for shipping code using standard Git and the GitHub CLI (`gh`). This skill teaches the agent how to create commits, branches, and pull requests following conventional workflows.\n\n## Key Rules\n\n- NEVER commit, push, create branches, or create PRs without explicit user approval.\n- Before any git operation that creates or modifies a commit, present a review block containing: changeset content (if applicable), commit title, and commit/PR description. ALWAYS wait for approval.\n- Show the proposed changeset entry for review before writing the changeset file.\n- Use standard `git add` and `git commit` workflows. Concise title on the first line, blank line, then description body.\n- Use `gh pr create` for pull requests.\n- Write commit and PR descriptions as natural flowing prose. Do NOT insert hard line breaks mid-paragraph.\n\n## Guidelines\n\n### Creating Commits\n\nFollow conventional commit message format:\n\n```sh\ngit add -A\ngit commit -m \"Commit title\" -m \"Description body explaining what changed and why.\"\n```\n\n- The first `-m` sets the commit title (first line). Keep it concise and descriptive.\n- The second `-m` sets the commit body. Explain what changed and why.\n- Use present tense, imperative mood (e.g. \"Add feature\" not \"Added feature\").\n\n### Creating Branches\n\nCreate a descriptive branch name before committing:\n\n```sh\ngit checkout -b feature/short-description\n```\n\nCommon prefixes: `feature/`, `fix/`, `refactor/`, `docs/`, `chore/`.\n\n### Creating Pull Requests\n\nUse the GitHub CLI to create PRs:\n\n```sh\ngh pr create --title \"PR title\" --body \"Description explaining what changed and why.\"\n```\n\n- If a `.github/PULL_REQUEST_TEMPLATE.md` exists, use it as a guide for structuring the PR description. Fill in sections that are relevant and omit sections that don't apply (e.g. don't add \"Fixes #\" if there's no related issue).\n\n### Pushing Changes\n\nPush the branch and set the upstream:\n\n```sh\ngit push -u origin HEAD\n```\n\n### Review Block Format\n\nBefore any git operation, present this review block and wait for approval:\n\n1. **Changeset entry** (if applicable) — the proposed changelog entry and bump type.\n2. **Commit title** — a concise title for the commit.\n3. **Commit/PR description** — a short description that explains what changed and why.\n" }, { "path": ".agents/skills/shipping-graphite/INJECT.md", "content": "---\nheading: Shipping (Graphite)\n---\n\n- Check if [Graphite](https://graphite.dev/) is installed (`which gt`). Prefer Graphite when available; fall back to the Git shipping workflow otherwise.\n- NEVER commit, push, create branches, or create PRs without explicit user approval.\n- Before any git operation that creates or modifies a commit, present a review block containing: changeset entry (if applicable), commit title, and commit/PR description. ALWAYS wait for approval.\n- Use `gt create -am \"Title\" -m \"Description body\"` for new PRs. The first `-m` sets the commit title; the second sets the PR description.\n- Use `gt modify -a` to amend the current branch with follow-up changes (NEVER create additional commits on the same branch).\n- ALWAYS escape backticks in commit messages with backslashes for shell compatibility (e.g. `\"Update \\`my-package\\` config\"`).\n- Do NOT run `gt submit` after committing. Only run it when the user explicitly asks to submit or push.\n- Write commit and PR descriptions as natural flowing prose. Do NOT insert hard line breaks mid-paragraph.\n" }, { "path": ".agents/skills/shipping-graphite/SKILL.md", "content": "---\nname: shipping-graphite\ndescription: Shipping workflow using Graphite CLI. Provides guidance for committing, branching, and creating PRs with Graphite's single-commit-per-branch model.\n---\n\n# Ship Code Using Graphite\n\nGuidance for shipping code using the [Graphite](https://graphite.dev/) CLI (`gt`). This skill teaches the agent how to create commits, branches, and PRs using Graphite's single-commit-per-branch model.\n\n## Key Rules\n\n- NEVER commit, push, create branches, or create PRs without explicit user approval.\n- Before any git operation that creates or modifies a commit, present a review block containing: changeset content (if applicable), commit title, and commit/PR description. ALWAYS wait for approval.\n- Show the proposed changeset entry for review before writing the changeset file.\n- Use `gt create -am \"Title\" -m \"Description body\"` for new PRs. The first `-m` sets the commit title; the second sets the PR description.\n- Use `gt modify -a` to amend the current branch with follow-up changes (NEVER create additional commits on the same branch).\n- ALWAYS escape backticks in commit messages with backslashes for shell compatibility (e.g. `\"Update \\`my-package\\` config\"`).\n- Write commit and PR descriptions as natural flowing prose. Do NOT insert hard line breaks mid-paragraph.\n\n## Guidelines\n\n### Creating a New PR\n\nUse `gt create` to create a new branch with a single commit:\n\n```sh\ngt create -am \"Commit title\" -m \"Description body explaining what changed and why.\"\n```\n\n- The first `-m` flag sets the commit title (first line of the commit message).\n- The second `-m` flag sets the commit body, which Graphite uses as the PR description when the stack is submitted.\n- Write the body as a concise flowing summary. Avoid excessive blank lines.\n- If a `.github/PULL_REQUEST_TEMPLATE.md` exists, use it as a guide for structuring the PR description. Fill in sections that are relevant and omit sections that don't apply (e.g. don't add \"Fixes #\" if there's no related issue).\n\n### Amending an Existing PR\n\nWhen making follow-up changes to the current branch, ALWAYS amend rather than creating new commits:\n\n```sh\ngt modify -a\n```\n\nThis amends the single commit on the current branch. Since Graphite uses a one-commit-per-branch model, ALWAYS use `gt modify -a` for follow-up changes on the same PR.\n\n### Submitting PRs\n\nDo NOT run `gt submit` (or `gt ss`) after creating or modifying branches. The `gt create` and `gt modify` steps are the end of the workflow unless the user explicitly asks to submit or push.\n\nWhen the user asks to submit, first run `gt sync` to ensure the local stack is up-to-date. This will restack branches from the main branch and prompt to delete any stale (merged) branches. If `gt sync` encounters any issues or conflicts, stop immediately and report the problem to the user before proceeding — await their instructions on how to resolve it.\n\nOnly after a clean sync, run `gt submit` to create or update PRs for all branches in the current stack.\n\n### Shell Escaping\n\nWhen commit titles or descriptions contain backticks (e.g. for package names or code references), escape them with a backslash so the shell passes them through literally:\n\n```sh\ngt create -am \"Align \\`kit-plugins\\` infrastructure\" -m \"This PR updates the shared config.\"\n```\n\n### Review Block Format\n\nBefore any git operation, present this review block and wait for approval:\n\n1. **Changeset entry** (if applicable) — the proposed changelog entry and bump type.\n2. **Commit title** — a concise title for the commit.\n3. **Commit/PR description** — a short description that explains what changed and why.\n" }, { "path": ".agents/skills/ts-docblocks/INJECT.md", "content": "---\nheading: TypeScript Docblocks\n---\n\n- All exported functions, types, interfaces, and constants MUST have JSDoc docblocks.\n- Start with `/**`, use `*` prefix for each line, end with `*/` — each on its own line.\n- Begin with a clear one-to-two line summary. Add a blank line before tags.\n- Include `@param`, `@typeParam`, `@return`, `@throws`, and at least one `@example` when helpful.\n- Use `{@link ...}` to reference related items. Add `@see` tags at the end for related APIs.\n" }, { "path": ".agents/skills/ts-docblocks/SKILL.md", "content": "---\nname: ts-docblocks\ndescription: Add missing JSDoc docblocks to exported symbols in TypeScript projects. Use when writing new exports or when code is missing documentation.\nargument-hint: \"[path] [--all]\"\n---\n\n# Add Missing Docblocks\n\nScan the specified path (or entire repository if no path given) and add missing docblocks to all exported functions, classes, interfaces, types, and constants.\n\n## Key Rules\n\n- All exported functions, types, interfaces, and constants MUST have JSDoc docblocks.\n- Start with `/**`, use `*` prefix for each line, end with `*/` — each on its own line.\n- Begin with a clear one-to-two line summary. Add a blank line before tags.\n- Include `@param`, `@typeParam`, `@return`, `@throws`, and at least one `@example` when helpful.\n- Use `{@link ...}` to reference related items. Add `@see` tags at the end for related APIs.\n- Do NOT modify real code outside of docblocks. Do NOT modify existing docblocks.\n\n## Guidelines\n\n### Style\n\nUse JSDoc format with the following conventions:\n\n- Start with `/**` on its own line.\n- Use `*` prefix for each line.\n- End with `*/` on its own line.\n- Keep descriptions concise but complete.\n- Start your sentences with a capital letter and end with a period.\n- Limit your usage of em dashes but, when you do use them, use spaces on both sides.\n- Begin with a clear one or two line summary (no `@summary` tag needed).\n- Add a blank line after the summary if adding more details.\n- Include `@param` tags for all parameters.\n- Include `@typeParam` tags for all type parameters. Use `@typeParam`, not `@template`.\n- Include `@return` tag briefly describing the return value.\n- Add `@throws` for functions that may throw errors and list these errors.\n- Include at least one `@example` section whenever usage examples would be helpful. If the file is a TypeScript file, use TypeScript syntax in examples. Try to make the examples realistic but concise and pleasant to read. They must illustrate the concepts clearly at first glance. When more than one example is preferred, use multiple `@example` tags and keep the first one as simple as possible to illustrate the basic usage. Never use `any` type in examples. Display the `import` statements required for the example to work when imports from multiple libraries are required. It is acceptable to use placeholder variable names like `myUser` or even `/* ... */` for parts that are not relevant to the example. When multiple example sections are provided, add a brief description before each code block to quickly explain what the example illustrates.\n- In the rare case where more advanced documentation is also needed for the item, use the `@remarks` tag to add this extra information after any example sections. These remarks can include longer explanations and even additional code blocks if necessary.\n- When an item is deprecated, include a `@deprecated` tag with a brief explanation and, if applicable, suggest an alternative.\n- Use `{@link ...}` tags to reference other items in the codebase when relevant.\n- Add `@see` tags at the very end when applicable to point to other related items or documentation. Use `@see {@link ...}` format when linking to other code items.\n\n### Examples\n\n````ts\n/**\n * Creates a retry wrapper around an async function.\n *\n * Retries the given function up to `maxRetries` times with exponential\n * backoff between attempts.\n *\n * @param fn - The async function to retry.\n * @param maxRetries - Maximum number of retry attempts.\n * @param baseDelay - Base delay in milliseconds between retries.\n * @return A wrapped version of `fn` that retries on failure.\n * @throws Throws the last error if all retry attempts are exhausted.\n *\n * @example\n * ```ts\n * const fetchWithRetry = withRetry(fetchData, 3, 1000);\n * const data = await fetchWithRetry('/api/users');\n * ```\n *\n * @example\n * Custom retry configuration for flaky network calls.\n * ```ts\n * const resilientFetch = withRetry(\n * () => fetch('https://api.example.com/data'),\n * 5,\n * 500,\n * );\n * ```\n */\nexport function withRetry(\n fn: (...args: unknown[]) => Promise,\n maxRetries: number,\n baseDelay: number,\n): (...args: unknown[]) => Promise;\n````\n\n````ts\n/**\n * Fixes a `Uint8Array` to the specified length.\n *\n * If the array is longer than the specified length, it is truncated.\n * If the array is shorter than the specified length, it is padded with zeroes.\n *\n * @param bytes - The byte array to truncate or pad.\n * @param length - The desired length of the byte array.\n * @return The byte array truncated or padded to the desired length.\n *\n * @example\n * Truncates the byte array to the desired length.\n * ```ts\n * const bytes = new Uint8Array([0x01, 0x02, 0x03, 0x04]);\n * const fixedBytes = fixBytes(bytes, 2);\n * // ^ [0x01, 0x02]\n * ```\n *\n * @example\n * Adds zeroes to the end of the byte array to reach the desired length.\n * ```ts\n * const bytes = new Uint8Array([0x01, 0x02]);\n * const fixedBytes = fixBytes(bytes, 4);\n * // ^ [0x01, 0x02, 0x00, 0x00]\n * ```\n */\nexport const fixBytes = (\n bytes: ReadonlyUint8Array | Uint8Array,\n length: number,\n): ReadonlyUint8Array | Uint8Array;\n````\n\n````ts\n/**\n * A tree structure representing a set of instructions with execution constraints.\n *\n * Supports parallel execution, sequential execution, and combinations of both\n * through recursive composition of plan nodes.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = parallelPlan([\n * sequentialPlan([instructionA, instructionB]),\n * instructionC,\n * instructionD,\n * ]);\n * ```\n *\n * @see {@link SingleInstructionPlan}\n * @see {@link ParallelInstructionPlan}\n * @see {@link SequentialInstructionPlan}\n */\nexport type InstructionPlan =\n | ParallelInstructionPlan\n | SequentialInstructionPlan\n | SingleInstructionPlan;\n````\n\n## Command Process\n\nWhen invoked as a command, follow these steps:\n\n### Arguments\n\n- `[path]` (optional): Narrow the scan to a specific path (e.g. `src/utils` or `packages/my-lib/src`).\n- `[--all]` (optional): Also scan non-exported items.\n\n### Steps\n\n1. If a path argument is provided, scan only that path; otherwise scan the entire repository.\n2. Look for TypeScript/JavaScript files (`.ts`, `.tsx`, `.js`, `.jsx`).\n3. Identify exported items without docblocks:\n - `export function`\n - `export class`\n - `export interface`\n - `export type`\n - `export const` (for constants and arrow functions)\n4. If `--all` is passed, also identify non-exported items.\n5. For each item missing a docblock:\n - Analyze the code to understand its purpose (this may span multiple files).\n - Examine parameters, return types, and behavior.\n - Generate an appropriate docblock following the style guide.\n6. Present all changes clearly, grouped by file. Apply all changes without requiring further approval.\n" }, { "path": ".agents/skills/ts-readme/INJECT.md", "content": "---\nheading: TypeScript READMEs\n---\n\n- When adding a new public API, add or update the package's README.\n- Structure: brief intro, installation, usage (with code snippet), deep-dive sections.\n- Code snippets must be realistic, concise, and use TypeScript syntax.\n- Focus on the quickest path to success. Developers should feel excited, not overwhelmed.\n" }, { "path": ".agents/skills/ts-readme/SKILL.md", "content": "---\nname: ts-readme\ndescription: Guidelines for writing developer-friendly READMEs for TypeScript libraries. Use when creating a new package, changing a public API, or updating documentation.\nargument-hint: \"[path]\"\n---\n\n# Create or Update README\n\nCreate a new README or update an existing one for a TypeScript package, library, or project.\n\n## Key Rules\n\n- When adding a new public API, add or update the package's README.\n- Structure: brief intro, installation, usage (with code snippet), deep-dive sections.\n- Code snippets must be realistic, concise, and use TypeScript syntax.\n- Focus on the quickest path to success. Developers should feel excited, not overwhelmed.\n- Do NOT update any real code outside of the README file itself. If you identify errors in the codebase, warn the user but do not fix them.\n\n## Guidelines\n\nA deep understanding of the project is necessary to create an effective README. Analyze the codebase, key features, and typical usage patterns to inform the content. If the project relies on other libraries or frameworks, consider how those influence usage and installation.\n\n### Structure\n\nThe layout of a README will vary from project to project, but they should generally follow these guidelines.\n\n#### 1. Intro Section\n\n- Package/library name as the main heading.\n- Badges for tests, package version, downloads, etc. (npm, GitHub, etc.).\n- **Very brief summary (ELI5)** — A single sentence or short paragraph that anyone can understand at first glance.\n- Only update the intro if you can meaningfully improve the summary; otherwise leave it intact.\n\n#### 2. Installation Section\n\n- Keep it extremely concise (1-2 lines of explanation max if necessary).\n- Show the install command in a code block.\n\n#### 3. Usage Section (Most Critical)\n\n- This is where readers' attention lands first after the intro.\n- Show the **quickest path to success** with this library.\n- **Must include a code snippet** illustrating basic usage.\n- Balance between brevity and clarity to create an \"aha moment.\"\n- Optional: Brief text before/after the snippet if it adds clarity.\n- The code snippet should be realistic, concise, and immediately understandable.\n\n#### 4. Deep Dive Sections\n\n- Structure varies case-by-case based on the project.\n- Document key features, concepts, or use cases.\n- Each section should include **at least one code snippet**. Similar guidelines as the Usage section, that is, realistic and concise (shortest path to \"aha moment\").\n- Organize logically (e.g. by feature, by use case, by complexity).\n- Common patterns:\n - **Features**: Individual feature documentation with examples.\n - **API Reference**: Core APIs or functions.\n - **Advanced Usage**: More complex scenarios.\n - **Configuration**: Setup and customization options.\n - **Examples**: Real-world use cases.\n- No need for a \"Requirements\" section for peer dependencies. Just mention them in the \"Installation\" section if necessary to get started.\n\n### Code Snippets\n\n- Use TypeScript syntax for TypeScript projects.\n- Show realistic but concise examples.\n- Include necessary imports when relevant (e.g. when importing from multiple modules).\n- Use descriptive variable names (not `foo`, `bar`).\n- Keep examples focused on one concept at a time when possible.\n- Format for readability (proper indentation, spacing).\n\n### Tone\n\n- Friendly and approachable.\n- Clear and direct.\n- Avoid marketing speak.\n- Focus on practical value.\n- Use active voice.\n- Assume the reader is a developer who wants to get started quickly.\n\n### What to Avoid\n\n- Overly long introductions or preambles.\n- Walls of text without code examples.\n- Complex examples in the Usage section.\n- Unexplained jargon or acronyms.\n- Marketing-heavy language.\n- Duplicating information unnecessarily.\n\n### Monorepo Considerations\n\nWhen working in a monorepo:\n\n- **Package READMEs**: Focus on the specific package — its API, installation, usage, and features. Include an installation note pointing to an umbrella package as an alternative if one exists.\n- **Root README**: Provides an overview of the entire monorepo, links to individual package READMEs for details. Focus on the quick-start experience rather than deep-diving into each package.\n- **Consistency**: When updating a package README, check other package READMEs for structural consistency (heading levels, section order, code example style).\n\n## Command Process\n\nWhen invoked as a command, follow these steps:\n\n### Arguments\n\n- `[path]` (optional): Path to the README file or its parent directory. Defaults to `./README.md`.\n\n### Steps\n\n1. Determine the target README path:\n - If a path argument is provided and ends with `.md`, use it directly.\n - If the argument is a directory path, use `/README.md`.\n - If no argument is provided, use `./README.md`.\n\n2. Check if the README exists:\n - If it exists, read it to understand the current structure.\n - If it doesn't exist, prepare to create one from scratch.\n\n3. Analyze the project context:\n - Examine `package.json` (if exists) for package name, description, dependencies.\n - Look at the source code to understand what the library does.\n - Identify key exports, main functions, and typical usage patterns.\n - Check for existing tests or examples that show usage.\n - Research any related libraries or frameworks that influence usage.\n - If in a monorepo, examine other package READMEs to ensure consistency in style and structure.\n\n4. Create or update the README:\n - **For existing READMEs**: Identify missing sections or areas needing improvement.\n - **For new READMEs**: Build the full structure following the guidelines.\n - Preserve the intro unless improvements are clear.\n - Ensure the Usage section has a strong, clear example.\n - Add or improve deep dive sections as needed.\n - Include realistic code snippets throughout.\n\n5. Present the complete README for review before applying changes.\n" }, { "path": ".bundlemonrc.json", "content": "{\n \"baseDir\": \"./packages/\",\n \"files\": [\n {\n \"friendlyName\": \"@solana/kit production bundle\",\n \"path\": \"kit/dist/index.production.min.js\"\n },\n {\n \"path\": \"**/dist/index.*.mjs\"\n }\n ],\n \"includeCommitMessage\": true,\n \"reportOutput\": [\"github\"]\n}\n" }, { "path": ".changeset/bold-drinks-strive.md", "content": "---\n'@solana/rpc-spec': minor\n'@solana/kit': minor\n---\n\nAdd a `reactiveStore()` method to `PendingRpcRequest`. It fires the request on construction and synchronously returns a `ReactiveActionStore` that holds the request's `idle`/`running`/`success`/`error` lifecycle state. Compatible with `useSyncExternalStore`, Svelte stores, and other reactive primitives. Call `dispatch()` to re-fire the request (e.g. after an error), or `reset()` to abort the in-flight call and return to idle.\n\n```ts\nconst store = rpc.getAccountInfo(address).reactiveStore();\nconst state = useSyncExternalStore(store.subscribe, store.getState);\nif (state.status === 'error') return ;\nif (state.status === 'running' && !state.data) return ;\nreturn ;\n```\n" }, { "path": ".changeset/brown-candles-relax.md", "content": "---\n'@solana/rpc-subscriptions-spec': minor\n'@solana/kit': minor\n---\n\nAdd a `reactiveStore()` method to `PendingRpcSubscriptionsRequest`. Unlike `reactive()`, this variant returns a `ReactiveStore` synchronously and supports `retry()` to reconnect after an error. `reactive()` is now `@deprecated` in favour of `reactiveStore()`.\n\n```ts\nconst store = rpc.accountNotifications(address).reactiveStore({ abortSignal });\nconst state = useSyncExternalStore(store.subscribe, store.getUnifiedState);\nif (state.status === 'error') return ;\n```\n" }, { "path": ".changeset/clever-spies-shout.md", "content": "---\n'@solana/subscribable': minor\n'@solana/errors': minor\n'@solana/kit': minor\n---\n\nAdd `retry()` and `getUnifiedState()` to `ReactiveStore`. The new `getUnifiedState()` returns a discriminated `{ data, error, status }` snapshot with stable identity, so stores can be passed directly to `useSyncExternalStore` without an intermediate wrapper. `getState()` and `getError()` remain on the type but are now `@deprecated` in favour of the unified snapshot.\n\nA new `createReactiveStoreFromDataPublisherFactory` function is also introduced. It accepts a `createDataPublisher: () => Promise` factory rather than a ready-made publisher, which lets the store reconnect via `retry()` after an error. The existing `createReactiveStoreFromDataPublisher` is now `@deprecated`; calling `retry()` on a store it produced throws a new `SolanaError` with code `SOLANA_ERROR__SUBSCRIBABLE__RETRY_NOT_SUPPORTED`.\n\n`createReactiveStoreWithInitialValueAndSlotTracking` (from `@solana/kit`) now supports `retry()`, which re-sends the RPC request and re-subscribes to the subscription with a fresh abort signal while preserving the last known slot and value.\n" }, { "path": ".changeset/config.json", "content": "{\n \"$schema\": \"https://unpkg.com/@changesets/config@3.0.0/schema.json\",\n \"access\": \"public\",\n \"baseBranch\": \"main\",\n \"bumpVersionsWithWorkspaceProtocolOnly\": true,\n \"changelog\": [\n \"@changesets/changelog-github\",\n {\n \"repo\": \"anza-xyz/kit\"\n }\n ],\n \"fixed\": [[\"@solana/!({example-*,*-impl,build-scripts,eslint-config,test-*,tsconfig,web3.js})\"]],\n \"linked\": [],\n \"snapshot\": {\n \"useCalculatedVersion\": true\n },\n \"privatePackages\": {\n \"version\": false,\n \"tag\": false\n },\n \"updateInternalDependencies\": \"patch\"\n}\n" }, { "path": ".changeset/some-views-pick.md", "content": "---\n'@solana/subscribable': minor\n'@solana/rpc-subscriptions-spec': minor\n'@solana/kit': minor\n'@solana/errors': minor\n---\n\nRename `ReactiveStore` to `ReactiveStreamStore`. The old name remains exported as a deprecated alias and will be removed in a future major release.\n" }, { "path": ".changeset/thin-cats-drop.md", "content": "---\n'@solana/subscribable': minor\n---\n\nAdded `createReactiveActionStore` — a framework-agnostic state machine that wraps an async function and exposes a `{ dispatch, dispatchAsync, getState, subscribe, reset }` contract compatible with `useSyncExternalStore`, Svelte stores, Vue's `shallowRef`, and similar reactive primitives. `dispatch` is synchronous and fire-and-forget (safe from UI event handlers); `dispatchAsync` returns a promise that resolves to the wrapped function's result and rejects on failure or supersede — use `isAbortError` from `@solana/promises` to filter aborts. Each call creates a fresh `AbortController` and aborts the previous one, so rapid successive dispatches only produce one final state transition — the outcome of the most recent call.\n" }, { "path": ".github/ISSUE_TEMPLATE/0_bug.md", "content": "---\nname: Report a Bug\nabout: Help us reproduce a bug you've found so that we can fix it\ntitle: ''\nlabels: ['bug']\nassignees: ''\n---\n\n\n\n## Overview\n\n\n\n## Steps to reproduce\n\n\n\n## Description of bug\n\n\n" }, { "path": ".github/ISSUE_TEMPLATE/1_feature.md", "content": "---\nname: Suggest a Feature\nabout: Propose an idea for how to make this library better.\ntitle: ''\nlabels: ['enhancement']\nassignees: ''\n---\n\n\n\n## Motivation\n\n\n\n## Example use case\n\n\n\n## Details\n\n\n" }, { "path": ".github/ISSUE_TEMPLATE/config.yml", "content": "contact_links:\n - about: 'Have a question about using this software, or about Solana in general? Post it on the Solana Stack Exchange.'\n name: Ask a Question\n url: 'https://solana.stackexchange.com/questions/ask'\n - about: 'Start or join a discussion on the Solana Tech Discord.'\n name: Start a Discussion\n url: 'https://solana.com/discord'\n" }, { "path": ".github/PULL_REQUEST_TEMPLATE.md", "content": "#### Problem\n\n\n\n#### Summary of Changes\n\n\n\nFixes #" }, { "path": ".github/dependabot.yml", "content": "# To get started with Dependabot version updates, you'll need to specify which\n# package ecosystems to update and where the package manifests are located.\n# Please see the documentation for all configuration options:\n# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates\n\nversion: 2\nupdates:\n - package-ecosystem: 'npm'\n directory: '/'\n schedule:\n interval: daily\n time: '01:00'\n timezone: America/Los_Angeles\n ignore:\n - dependency-name: '@radix-ui/react-dropdown-menu'\n groups:\n eslint:\n patterns:\n - '@eslint/*'\n - '@typescript-eslint/*'\n - 'typescript'\n solana-program-clients:\n patterns:\n - '@solana-program/*'\n react:\n patterns:\n - 'react'\n - 'react-dom'\n undici:\n patterns:\n - 'undici'\n - 'undici-types'\n - package-ecosystem: 'npm'\n directory: '/docs'\n schedule:\n interval: daily\n time: '01:00'\n timezone: America/Los_Angeles\n groups:\n eslint:\n patterns:\n - 'eslint*'\n - 'typescript'\n solana:\n patterns:\n - '@solana/*'\n solana-program-clients:\n patterns:\n - '@solana-program/*'\n react:\n patterns:\n - 'react'\n - 'react-dom'\n undici:\n patterns:\n - 'undici'\n - 'undici-types'\n" }, { "path": ".github/label-actions.yml", "content": "question:\n issues:\n # Post a comment, `{issue-author}` is an optional placeholder\n comment: >\n Hi @{issue-author},\n\n\n Thanks for your question!\n\n\n We want to make sure to keep signal strong in the GitHub issue tracker – to make sure\n that it remains the best place to track issues that affect the development of the Solana\n JavaScript SDK itself.\n\n\n Questions like yours deserve a purpose-built Q&A forum. Unless there exists evidence that\n this is a bug with the Solana JavaScript SDK itself, please post your question to the Solana \n Stack Exchange using this link: https://solana.stackexchange.com/questions/ask\n\n\n ---\n\n _This\n [automated message](https://github.com/anza-xyz/kit/blob/main/.github/label-actions.yml)\n is a result of having added the ‘question’ tag_.\n\n # Close the issue\n close: true\n" }, { "path": ".github/workflows/actions/install-dependencies/action.yml", "content": "name: Install Dependencies\ndescription: Sets up Node and its package manager, then installs all dependencies\n\ninputs:\n version:\n default: 'lts/*'\n type: string\n\nruns:\n using: composite\n steps:\n - name: Install package manager\n uses: pnpm/action-setup@v4\n with:\n version: 10.24.0\n\n - name: Setup Node\n uses: actions/setup-node@v4\n with:\n cache: 'pnpm'\n node-version: ${{ inputs.version }}\n registry-url: 'https://registry.npmjs.org'\n\n - name: Install dependencies\n shell: bash\n run: pnpm install\n" }, { "path": ".github/workflows/actions/setup-validator/action.yml", "content": "name: Install Solana Test Validator\ndescription: Downloads and caches an install of the latest Solana Test Validator\n\noutputs:\n pid:\n description: The process id of the running test validator\n value: ${{ steps.start-validator.outputs.pid }}\n\nruns:\n using: composite\n steps:\n - name: Get Test Validator Latest Release\n id: get-test-validator-version\n shell: bash\n run: echo \"version=$(./scripts/get-latest-validator-release-version.sh)\" >> $GITHUB_OUTPUT\n\n - name: Cache Test Validator\n id: cache-test-validator\n uses: actions/cache@v4\n with:\n path: .agave\n key: ${{ runner.os }}-test-validator-${{ steps.get-test-validator-version.outputs.version }}\n\n - name: Install Test Validator\n if: steps.cache-test-validator.outputs.cache-hit != 'true'\n shell: bash\n run: ./scripts/setup-test-validator.sh\n\n - name: Start Test Validator\n id: start-validator\n shell: bash\n run: |\n ./scripts/start-shared-test-validator.sh &\n echo \"pid=$!\" >> $GITHUB_OUTPUT\n" }, { "path": ".github/workflows/autolock-inactive-threads.yml", "content": "name: 'Lock inactive threads'\n\non:\n # Chosen to be just before London wakes up and way past San Francisco's bedtime.\n schedule:\n - cron: '0 8 * * 1-5' # This is in UTC.\n workflow_dispatch:\n\npermissions:\n issues: write\n pull-requests: write\n\nconcurrency:\n group: lock\n\njobs:\n autolock-inactive-threads:\n runs-on: ubuntu-latest\n steps:\n - uses: dessant/lock-threads@1bf7ec25051fe7c00bdd17e6a7cf3d7bfb7dc771\n with:\n github-token: ${{ github.token }}\n issue-inactive-days: '7'\n issue-lock-reason: 'resolved'\n issue-comment: >\n Because there has been no activity on this issue for 7 days since it was closed, it has \n been automatically locked. Please open a new issue if it requires a follow up.\n pr-inactive-days: '14'\n pr-lock-reason: 'resolved'\n pr-comment: >\n Because there has been no activity on this PR for 14 days since it was merged, it has \n been automatically locked. Please open a new issue if it requires a follow up.\n process-only: 'issues, prs'\n" }, { "path": ".github/workflows/backport.yml", "content": "name: Backport\non:\n pull_request_target:\n types:\n - closed\n - labeled\n\npermissions:\n contents: write\n pull-requests: write\n\njobs:\n backport:\n name: Backport\n runs-on: ubuntu-latest\n # Only react to merged PRs for security reasons.\n # See https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target.\n if: >\n github.event.pull_request.merged\n && (\n github.event.action == 'closed'\n || (\n github.event.action == 'labeled'\n && contains(github.event.label.name, 'backport')\n )\n )\n steps:\n - uses: tibdex/backport@9565281eda0731b1d20c4025c43339fb0a23812e\n with:\n github_token: ${{ secrets.GITHUB_TOKEN }}\n" }, { "path": ".github/workflows/bundlesize.yml", "content": "name: Compare bundle size\n\non:\n push:\n branches:\n - main\n pull_request:\n types: [synchronize, opened, reopened]\n\npermissions:\n contents: read\n\nenv:\n # Among other things, opts out of Turborepo telemetry\n # See https://consoledonottrack.com/\n DO_NOT_TRACK: '1'\n # Some tasks slow down considerably on GitHub Actions runners when concurrency is high\n TURBO_CONCURRENCY: 1\n # Enables Turborepo Remote Caching.\n TURBO_REMOTE_CACHE_SIGNATURE_KEY: ${{ secrets.TURBO_REMOTE_CACHE_SIGNATURE_KEY }}\n TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}\n TURBO_TEAM: ${{ vars.TURBO_TEAM }}\n\njobs:\n measure-bundlesize:\n permissions:\n pull-requests: write\n runs-on: ubuntu-latest\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n\n - name: Install Dependencies\n uses: ./.github/workflows/actions/install-dependencies\n with:\n version: current\n\n - name: Build\n run: pnpm turbo compile:js --concurrency=${TURBO_CONCURRENCY:-1}\n\n - name: BundleMon\n uses: lironer/bundlemon-action@cadbdd58f86faf1900725ef69d455444124b3748\n env:\n # Always compare to the main branch; prevents stacked PRs from being\n # compared to the wrong mergebase (ie. the PR beneath the current one)\n CI_TARGET_BRANCH: main\n" }, { "path": ".github/workflows/codeql.yml", "content": "# For most projects, this workflow file will not need changing; you simply need\n# to commit it to your repository.\n#\n# You may wish to alter this file to override the set of languages analyzed,\n# or to provide custom queries or build logic.\n#\n# ******** NOTE ********\n# We have attempted to detect the languages in your repository. Please check\n# the `language` matrix defined below to confirm you have the correct set of\n# supported CodeQL languages.\n#\nname: \"CodeQL Advanced\"\n\non:\n push:\n branches:\n - \"main\"\n schedule:\n - cron: \"30 13 * * 0\"\n\njobs:\n analyze:\n name: Analyze (${{ matrix.language }})\n # Runner size impacts CodeQL analysis time. To learn more, please see:\n # - https://gh.io/recommended-hardware-resources-for-running-codeql\n # - https://gh.io/supported-runners-and-hardware-resources\n # - https://gh.io/using-larger-runners (GitHub.com only)\n # Consider using larger runners or machines with greater resources for possible analysis time improvements.\n runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}\n permissions:\n # required for all workflows\n security-events: write\n\n # required to fetch internal or private CodeQL packs\n packages: read\n\n # only required for workflows in private repositories\n actions: read\n contents: read\n\n strategy:\n fail-fast: false\n matrix:\n include:\n - language: actions\n build-mode: none\n - language: javascript-typescript\n build-mode: none\n # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'rust', 'swift'\n # Use `c-cpp` to analyze code written in C, C++ or both\n # Use 'java-kotlin' to analyze code written in Java, Kotlin or both\n # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both\n # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,\n # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.\n # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how\n # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages\n steps:\n - name: Checkout repository\n uses: actions/checkout@v4\n\n # Add any setup steps before running the `github/codeql-action/init` action.\n # This includes steps like installing compilers or runtimes (`actions/setup-node`\n # or others). This is typically only required for manual builds.\n # - name: Setup runtime (example)\n # uses: actions/setup-example@v1\n\n # Initializes the CodeQL tools for scanning.\n - name: Initialize CodeQL\n uses: github/codeql-action/init@v4\n with:\n languages: ${{ matrix.language }}\n build-mode: ${{ matrix.build-mode }}\n # If you wish to specify custom queries, you can do so here or in a config file.\n # By default, queries listed here will override any specified in a config file.\n # Prefix the list here with \"+\" to use these queries and those in the config file.\n\n # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs\n # queries: security-extended,security-and-quality\n\n # If the analyze step fails for one of the languages you are analyzing with\n # \"We were unable to automatically build your code\", modify the matrix above\n # to set the build mode to \"manual\" for that language. Then modify this step\n # to build your code.\n # ℹ️ Command-line programs to run using the OS shell.\n # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun\n - name: Run manual build steps\n if: matrix.build-mode == 'manual'\n shell: bash\n run: |\n echo 'If you are using a \"manual\" build mode for one or more of the' \\\n 'languages you are analyzing, replace this with the commands to build' \\\n 'your code, for example:'\n echo ' make bootstrap'\n echo ' make release'\n exit 1\n\n - name: Perform CodeQL Analysis\n uses: github/codeql-action/analyze@v4\n with:\n category: \"/language:${{matrix.language}}\"\n" }, { "path": ".github/workflows/deploy-docs.yml", "content": "name: Deploy Documentation\n\non:\n workflow_dispatch:\n branches:\n - main\n push:\n branches:\n - main\n\npermissions:\n contents: read\n pull-requests: write\n\nconcurrency:\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\nenv:\n # Among other things, opts out of Turborepo telemetry\n # See https://consoledonottrack.com/\n DO_NOT_TRACK: '1'\n NEXT_TELEMETRY_DISABLED: '1'\n VERCEL_TELEMETRY_DISABLED: '1'\n # Enables Turborepo Remote Caching.\n TURBO_REMOTE_CACHE_SIGNATURE_KEY: ${{ secrets.TURBO_REMOTE_CACHE_SIGNATURE_KEY }}\n TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}\n TURBO_TEAM: ${{ vars.TURBO_TEAM }}\n\njobs:\n deploy-docs:\n runs-on: ubuntu-latest\n name: Deploy Documentation\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n\n - name: Install Dependencies\n uses: ./.github/workflows/actions/install-dependencies\n\n - name: Install Isolated Docs Dependencies\n working-directory: ./docs/\n shell: bash\n run: pnpm install --ignore-workspace\n\n - name: Install Vercel CLI\n run: pnpm install -g vercel\n\n - name: Deploy to Vercel\n shell: bash\n env:\n VERCEL_ORG_ID: ${{ secrets.VERCEL_ORG_ID }}\n VERCEL_PROJECT_ID: ${{ secrets.VERCEL_DOCS_PROJECT_ID }}\n VERCEL_TOKEN: ${{ secrets.VERCEL_TOKEN }}\n run: |\n vercel pull --token=\"$VERCEL_TOKEN\" --yes --environment=production\n vercel build --token=\"$VERCEL_TOKEN\" --prod\n vercel deploy --token=\"$VERCEL_TOKEN\" --archive=tgz --prebuilt --prod\n\n - name: Synchronize InKeep Search Index\n uses: inkeep/pr-commenter-action@84ccc7c74b72f628ec7e2b572e0cb7afd5898594 # v10\n env:\n GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}\n with:\n apiKey: ${{secrets.INKEEP_SEARCH_MANAGEMENT_API_KEY}}\n sourceId: '${{vars.INKEEP_SEARCH_SOURCE_ID}}'\n" }, { "path": ".github/workflows/dismiss-stale-pr-reviews.yml", "content": "name: Dismiss Stale PR Reviews\n\non:\n pull_request_target:\n types: [opened, synchronize, reopened]\n\npermissions:\n actions: read\n contents: read\n pull-requests: write\n\njobs:\n dismiss-stale-approvals:\n runs-on: ubuntu-latest\n steps:\n - name: Dismiss Stale PR Reviews\n if: ${{ !contains('OWNER,MEMBER,COLLABORATOR', github.event.pull_request.author_association) }}\n uses: withgraphite/dismiss-stale-approvals@15571275d9bf7410e51244e259cd8f9f554879c8\n with:\n github-token: ${{ secrets.GITHUB_TOKEN }}\n" }, { "path": ".github/workflows/label-actions.yml", "content": "name: 'Issue Label Actions'\n\non:\n issues:\n types: [labeled, unlabeled]\n\npermissions:\n contents: read\n issues: write\n\njobs:\n label:\n runs-on: ubuntu-latest\n steps:\n - uses: dessant/label-actions@102faf474a544be75fbaf4df54e73d3c515a0e65\n" }, { "path": ".github/workflows/manage-stale-threads.yml", "content": "name: 'Manage stale issues and PRs'\non:\n # Chosen to be just before London wakes up and way past San Francisco's bedtime.\n schedule:\n - cron: '0 8 * * 1-5' # This is in UTC.\n # Do a dry-run (debug-only: true) whenever this workflow itself is changed.\n pull_request:\n paths:\n - .github/workflows/manage-stale-threads.yml\n types:\n - opened\n - synchronize\n\npermissions:\n issues: write\n pull-requests: write\n\njobs:\n manage-stale-threads:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/stale@v6\n with:\n ascending: true # Spend API operations budget on older, more-likely-to-get-closed issues first\n close-issue-message: '' # Leave no comment when closing\n close-pr-message: '' # Leave no comment when closing\n days-before-issue-stale: 365\n days-before-pr-stale: 14\n days-before-close: 7\n debug-only: ${{ github.event_name == 'pull_request' }} # Dry-run when true.\n exempt-all-milestones: true # Milestones can sometimes last a month, so exempt issues attached to a milestone.\n exempt-issue-labels: blocked,do-not-close,feature-gate,security\n exempt-pr-labels: blocked,do-not-close,feature-gate,security\n # No actual changes get made in debug-only mode, so we can raise the operations ceiling.\n operations-per-run: ${{ github.event_name == 'pull_request' && 1000 || 900}}\n stale-issue-label: stale\n stale-issue-message: '' # Leave no comment when marking as stale\n stale-pr-label: stale\n stale-pr-message: '' # Leave no comment when marking as stale\n" }, { "path": ".github/workflows/preview-docs.yml", "content": "name: Preview Documentation\n\non:\n pull_request:\n merge_group:\n\npermissions:\n contents: read\n\nenv:\n # Among other things, opts out of Turborepo telemetry\n # See https://consoledonottrack.com/\n DO_NOT_TRACK: '1'\n NEXT_TELEMETRY_DISABLED: '1'\n VERCEL_TELEMETRY_DISABLED: '1'\n # Some tasks slow down considerably on GitHub Actions runners when concurrency is high\n TURBO_CONCURRENCY: 1\n # Enables Turborepo Remote Caching.\n TURBO_REMOTE_CACHE_SIGNATURE_KEY: ${{ secrets.TURBO_REMOTE_CACHE_SIGNATURE_KEY }}\n TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}\n TURBO_TEAM: ${{ vars.TURBO_TEAM }}\n\njobs:\n preview-docs:\n permissions:\n pull-requests: write\n runs-on: ubuntu-latest\n name: Build Documentation Preview\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n\n - name: Install Dependencies\n uses: ./.github/workflows/actions/install-dependencies\n\n - name: Install Isolated Docs Dependencies\n working-directory: ./docs/\n shell: bash\n run: pnpm install --ignore-workspace\n\n - name: Install Vercel CLI\n run: pnpm install -g vercel\n\n - name: Deploy to Vercel\n if: github.event.pull_request.head.repo.full_name == github.repository && github.actor != 'dependabot[bot]'\n shell: bash\n id: vercel_deploy\n env:\n BRANCH_NAME: ${{ github.head_ref }}\n PR_NUMBER: ${{ github.event.pull_request.number }}\n VERCEL_ORG_ID: ${{ secrets.VERCEL_ORG_ID }}\n VERCEL_PROJECT_ID: ${{ secrets.VERCEL_DOCS_PROJECT_ID }}\n VERCEL_TOKEN: ${{ secrets.VERCEL_TOKEN }}\n run: |\n vercel pull --token=\"$VERCEL_TOKEN\" --yes --environment=preview\n vercel build --token=\"$VERCEL_TOKEN\" --target=preview\n DEPLOY_OUTPUT=$(vercel deploy --token=\"$VERCEL_TOKEN\" --archive=tgz --env GITHUB_PR_NUMBER=\"$PR_NUMBER\" --env GITHUB_PR_BRANCH=\"$BRANCH_NAME\" --prebuilt --target=preview 2>&1)\n DEPLOY_EXIT_CODE=$?\n if [ $DEPLOY_EXIT_CODE -ne 0 ]; then\n echo \"Vercel deploy failed:\"\n echo \"$DEPLOY_OUTPUT\"\n exit $DEPLOY_EXIT_CODE\n fi\n DEPLOY_URL=$(echo \"$DEPLOY_OUTPUT\" | grep -o 'https://[a-zA-Z0-9.-]*\\.vercel\\.app' | tail -1)\n echo \"preview_url=$DEPLOY_URL\" >> $GITHUB_OUTPUT\n\n - name: Comment on PR with Preview URL\n if: steps.vercel_deploy.outcome == 'success'\n env:\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n PR_NUMBER: ${{ github.event.pull_request.number }}\n PREVIEW_URL: '${{ steps.vercel_deploy.outputs.preview_url }}'\n run: |\n gh pr comment $PR_NUMBER --body \"Documentation Preview: $PREVIEW_URL\" --create-if-none --edit-last\n" }, { "path": ".github/workflows/publish-packages.yml", "content": "name: Publish Packages (or Tag Release Manually upon manual dispatch)\n\non:\n workflow_dispatch:\n branches:\n - main\n - backport/**\n inputs:\n version:\n description: 'Version'\n required: true\n type: string\n tag:\n description: 'Tag name'\n required: true\n type: string\n push:\n branches:\n - main\n - backport/**\n\npermissions:\n contents: read\n\nenv:\n # Among other things, opts out of Turborepo telemetry\n # See https://consoledonottrack.com/\n DO_NOT_TRACK: '1'\n # Enables Turborepo Remote Caching.\n TURBO_REMOTE_CACHE_SIGNATURE_KEY: ${{ secrets.TURBO_REMOTE_CACHE_SIGNATURE_KEY }}\n TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}\n TURBO_TEAM: ${{ vars.TURBO_TEAM }}\n\njobs:\n build-and-publish-to-npm:\n permissions:\n contents: write\n id-token: write\n pull-requests: write\n runs-on: ubuntu-latest\n if: github.event_name == 'push'\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n\n - name: Install Dependencies\n uses: ./.github/workflows/actions/install-dependencies\n\n - name: Setup Solana Test Validator\n id: start-test-validator\n uses: ./.github/workflows/actions/setup-validator\n\n - name: Build And Test (bypass cache)\n run: pnpm build --force\n\n - name: Create Changesets Pull Request or Publish to NPM\n id: changesets\n uses: changesets/action@e0145edc7d9d8679003495b11f87bd8ef63c0cba # v1.5.3\n with:\n publish: pnpm changeset:publish\n env:\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n PUBLISH_TAG: latest\n # Some tasks slow down considerably on GitHub Actions runners when concurrency is high\n TURBO_CONCURRENCY: 1\n\n - name: Create GitHub Release\n if: steps.changesets.outputs.published == 'true'\n run: |\n cd ./packages/build-scripts/\n ./create-github-release.ts\n env:\n GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n\n - name: Stop Test Validator\n if: always() && steps.start-test-validator.outcome == 'success'\n run: kill ${{ steps.start-test-validator.outputs.pid }}\n\n build-and-publish-snapshots-to-npm:\n permissions:\n id-token: write\n pull-requests: write\n runs-on: ubuntu-latest\n if: github.event_name == 'push' && github.ref == 'refs/heads/main'\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n\n - name: Install Dependencies\n uses: ./.github/workflows/actions/install-dependencies\n\n - name: Setup Solana Test Validator\n id: start-test-validator\n uses: ./.github/workflows/actions/setup-validator\n\n - name: Run Build Step\n run: pnpm build\n\n - name: Publish Canary Releases\n run: |\n if [ -n \"$(find .changeset -name '*.md')\" ]; then\n pnpm changeset version --snapshot canary\n pnpm changeset:publish\n else\n echo \"No changesets found, skipping canary publish\"\n fi\n env:\n GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n PUBLISH_TAG: canary\n\n - name: Stop Test Validator\n if: always() && steps.start-test-validator.outcome == 'success'\n run: kill ${{ steps.start-test-validator.outputs.pid }}\n\n validate-version-exists:\n permissions:\n contents: read\n runs-on: ubuntu-latest\n if: github.event_name == 'workflow_dispatch'\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n\n - name: Install Dependencies\n uses: ./.github/workflows/actions/install-dependencies\n\n - name: Validate that a package at the given version has already been published\n run: |\n echo '${{ github.event.inputs.version }}' | grep -E \"^([0-9]+\\.){0,2}[0-9]+$\" > /dev/null || echo 'Version must be of the form X.Y.Z'\n pnpm view '@solana/kit@${{ github.event.inputs.version }}'\n\n tag-release-manually:\n permissions:\n contents: write\n id-token: write\n needs: validate-version-exists\n runs-on: ubuntu-latest\n if: github.event_name == 'workflow_dispatch'\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n\n - name: Install Dependencies\n uses: ./.github/workflows/actions/install-dependencies\n\n - name: Tag Release Manually\n run: ./packages/build-scripts/tag-release-manually.ts --version '${{ github.event.inputs.version }}' --tag '${{ github.event.inputs.tag }}'\n" }, { "path": ".github/workflows/pull-requests.yml", "content": "name: Pull requests\n\non:\n pull_request:\n merge_group:\n\npermissions:\n contents: read\n\nenv:\n # Among other things, opts out of Turborepo telemetry\n # See https://consoledonottrack.com/\n DO_NOT_TRACK: '1'\n # Some tasks slow down considerably on GitHub Actions runners when concurrency is high\n TURBO_CONCURRENCY: 1\n # Enables Turborepo Remote Caching.\n TURBO_REMOTE_CACHE_SIGNATURE_KEY: ${{ secrets.TURBO_REMOTE_CACHE_SIGNATURE_KEY }}\n TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}\n TURBO_TEAM: ${{ vars.TURBO_TEAM }}\n\njobs:\n # Needed for grouping check-web3 strategies into one check\n all-web3-checks:\n runs-on: ubuntu-latest\n needs: build-and-test\n steps:\n - run: echo \"Done\"\n\n build-and-test:\n runs-on: ubuntu-latest\n\n strategy:\n matrix:\n node:\n - 'current'\n - 'lts/*'\n\n name: Build & Test on Node ${{ matrix.node }}\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n\n - name: Install Dependencies\n uses: ./.github/workflows/actions/install-dependencies\n with:\n version: ${{ matrix.node }}\n\n - name: Setup Solana Test Validator\n id: start-test-validator\n uses: ./.github/workflows/actions/setup-validator\n\n - name: Build & Test\n run: pnpm build # Don't add --concurrency here; it's already baked in\n\n - name: Stop Test Validator\n if: always() && steps.start-test-validator.outcome == 'success'\n run: kill ${{ steps.start-test-validator.outputs.pid }}\n\n dependabot:\n runs-on: ubuntu-latest\n if: github.event_name == 'pull_request' && github.event.pull_request.user.login == 'dependabot[bot]' && github.repository == 'anza-xyz/kit'\n needs: [build-and-test]\n permissions:\n contents: write\n pull-requests: write\n steps:\n - name: Auto-approve the PR\n run: gh pr review --approve \"$PR_URL\"\n env:\n PR_URL: ${{ github.event.pull_request.html_url }}\n GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n - name: Enable auto-merge\n run: gh pr merge --auto --squash \"$PR_URL\"\n env:\n PR_URL: ${{ github.event.pull_request.html_url }}\n GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n" }, { "path": ".github/workflows/update-docs-lockfile.yml", "content": "name: Update Docs Lockfile\n\non:\n pull_request_target:\n paths:\n - 'docs/package.json'\n\npermissions:\n contents: write\n\njobs:\n update-lockfile:\n runs-on: ubuntu-latest\n permissions:\n id-token: write\n if: github.event.pull_request.user.login == 'dependabot[bot]'\n steps:\n - uses: actions/create-github-app-token@v2\n id: app-token\n with:\n app-id: ${{ vars.APP_ID }}\n private-key: ${{ secrets.PRIVATE_KEY }}\n\n - name: Set git config\n run: |\n git config --global user.email \"github-actions@github.com\"\n git config --global user.name \"github-actions\"\n git config --global url.\"https://x-access-token:${GITHUB_TOKEN}@github.com/\".insteadOf https://github.com/\n env:\n GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}\n\n - name: Checkout PR branch\n uses: actions/checkout@v6\n with:\n token: ${{ steps.app-token.outputs.token }}\n ref: ${{ github.event.pull_request.head.ref }}\n persist-credentials: false\n\n - name: Install Dependencies\n uses: ./.github/workflows/actions/install-dependencies\n\n - name: Update Docs Lockfile\n working-directory: ./docs/\n run: pnpm install --ignore-workspace --no-frozen-lockfile --ignore-scripts\n\n - name: Commit and Push\n run: |\n git add docs/pnpm-lock.yaml\n if git diff --cached --quiet; then\n echo \"No lockfile changes to commit\"\n else\n git commit -m \"Update docs lockfile\"\n git push\n fi\n" }, { "path": ".gitignore", "content": "# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.\n\n# dependencies\nnode_modules\n.pnp\n.pnp.js\n\n# misc\n.DS_Store\n*.pem\n\n# debug\nnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\n.pnpm-debug.log*\n\n# turbo\n.turbo\n\n# Sapling SCM\n.sl\n\n# `solana-test-validator`\n.agave/\ntest-ledger/\n\n# ignore JetBrains IDE\n.idea\n" }, { "path": ".npmrc", "content": "auto-install-peers=true\nengine-strict=true\nworkspaces-update=false" }, { "path": ".prettierignore", "content": ".changeset/\n.github/**.md\n\n# These are autogenerated, so leave them alone\n**/CHANGELOG.md\n\ndeclarations/\ndist/\ndoc/\nlib/\n!docs/src/lib\n\npnpm-lock.yaml\npnpm-workspace.yaml\n" }, { "path": ".skills-inject.json", "content": "{\n \"targets\": [\n \"CLAUDE.md\"\n ],\n \"skillsDirs\": [\n \".agents/skills\",\n \".claude/skills\"\n ]\n}\n" }, { "path": ".vscode/extensions.json", "content": "{\n \"recommendations\": [\n \"esbenp.prettier-vscode\"\n ]\n}" }, { "path": ".vscode/settings.json", "content": "{\n \"editor.defaultFormatter\": \"esbenp.prettier-vscode\"\n}\n" }, { "path": "CLAUDE.md", "content": "# Agent Instructions\n\n## Project Overview\n\nKit (`@solana/kit`) is the official JavaScript SDK for building Solana applications, maintained by Anza. The official documentation lives at https://solanakit.com (docs at `/docs`, API reference at `/api`). The GitHub repo is `anza-xyz/kit`.\n\nThis is a pnpm monorepo with ~57 packages under `packages/`, orchestrated by Turborepo. The main `@solana/kit` package is a facade that re-exports ~20 workspace packages (accounts, addresses, codecs, errors, keys, rpc, signers, transactions, etc.) and adds its own convenience helpers like `sendAndConfirmTransaction`, `airdrop`, and `fetchLookupTables`.\n\nThe documentation website supports an `.mdx` suffix on any page (e.g. `https://solanakit.com/docs/concepts/transactions.mdx`) which returns a cleaner markdown representation suitable for LLM consumption. Use this when you need to look up Kit APIs or concepts.\n\nThere is also a companion [`anza-xyz/kit-plugins`](https://github.com/anza-xyz/kit-plugins) monorepo that builds an abstraction layer on top of Kit by offering composable plugins and ready-to-use clients (which are essentially curated sets of plugins). The plugin system relies on the `@solana/plugin-core` and `@solana/plugin-interfaces` packages defined in this repo. Additionally, `@solana/program-client-core` (re-exported from `@solana/kit/program-client-core`) provides the helpers used by the [Codama JS renderer](https://github.com/codama-idl/renderers-js) to generate Kit-compatible program clients.\n\n## Getting Started\n\n```shell\npnpm install # Install dependencies\npnpm test:setup # Install the Agave test validator (first time only)\n./scripts/start-shared-test-validator.sh # Start shared test validator (needed for some tests)\npnpm build # Build + test all packages\n```\n\nFor single-package development:\n\n```shell\ncd packages/\npnpm turbo compile:js compile:typedefs # Compile the package and its dependencies\npnpm dev # Run tests in watch mode\n```\n\n## Architecture\n\nThe packages form a layered dependency graph. `@solana/errors` is the foundational leaf package with no internal dependencies — nearly every other package depends on it. Core encoding lives in `@solana/codecs-core`, `@solana/codecs-numbers`, `@solana/codecs-strings`, and `@solana/codecs-data-structures`, unified by the `@solana/codecs` facade. `@solana/keys` and `@solana/addresses` build on these codecs and `@solana/nominal-types`. Higher-level packages like `@solana/transactions`, `@solana/rpc`, and `@solana/signers` compose these primitives. `@solana/kit` sits at the top as the consumer-facing umbrella.\n\nFour private \"impl\" packages (`@solana/crypto-impl`, `@solana/text-encoding-impl`, `@solana/ws-impl`, `@solana/event-target-impl`) provide platform-specific implementations and are **inlined at build time** by tsup — they are never published to npm.\n\n## Build System\n\n- **JS compilation**: tsup (esbuild) via configs in `packages/build-scripts/`.\n- **Type declarations**: tsc with per-package `tsconfig.declarations.json`.\n- **Build artifacts per package**: Node CJS + ESM, Browser CJS + ESM, React Native ESM. `@solana/kit` additionally produces IIFE bundles (minified production + development with sourcemaps).\n- **Platform constants** (set at build time): `__BROWSER__`, `__NODEJS__`, `__REACTNATIVE__`, `__VERSION__`. These are mutually exclusive booleans enabling platform-specific code paths to be tree-shaken.\n- **`__DEV__`**: In IIFE builds, statically `true`/`false`. In library builds, replaced with `process.env.NODE_ENV !== 'production'` by the DevFlagPlugin, deferring the decision to the consumer's bundler.\n\n## Testing\n\n- **Framework**: Jest v30 with `@swc/jest` for TypeScript transformation.\n- **Shared config**: `packages/test-config/` (`@solana/test-config`).\n- **File naming**: `*-test.ts` (runs in both environments), `*-test.node.ts` (Node only), `*-test.browser.ts` (browser/jsdom only). Tests live in `src/__tests__/`.\n- **Type tests**: `src/__typetests__/` directories contain compile-time type tests using `satisfies` and `@ts-expect-error`.\n- **Lint/prettier**: Also run through Jest runners (`jest-runner-eslint`, `jest-runner-prettier`).\n- **Commands**: `pnpm test` runs all unit tests. `pnpm lint` runs lint checks. `pnpm style:fix` auto-fixes formatting.\n- **`expect.assertions`**: Only use `expect.assertions(n)` in **async** tests (where you need to guarantee the expected number of assertions ran). Synchronous tests do not need it.\n- **Flushing async state**: When a test needs to wait for queued microtasks or promise chains to settle, prefer `jest.useFakeTimers()` + `await jest.runAllTimersAsync()` over hand-rolled `flushMicrotasks` helpers that `await Promise.resolve()` in a loop. The loop count is fragile and breaks as soon as an extra `.then` is introduced. When enabling fake timers in a scoped `beforeEach` (i.e. not at the top of the file), pair it with an `afterEach(() => { jest.useRealTimers(); })` so subsequent describes don't inherit fake timers.\n- **Placeholder mocks**: When a test mock must satisfy an interface but a particular method shouldn't be called in that test, make the stub throw/reject rather than using a bare `jest.fn()` that silently returns `undefined`. For sync methods use `jest.fn().mockImplementation(() => { throw new Error('not implemented'); })`; for async methods use `jest.fn().mockRejectedValue(new Error('not implemented'))`. An accidental call then fails the test loudly instead of producing `undefined` and a confusing downstream assertion error.\n\n## Error System\n\nAll errors use the `SolanaError` class from `@solana/errors`. Key rules:\n\n- Error codes are numeric constants in `packages/errors/src/codes.ts`, named `SOLANA_ERROR____` (double-underscore separated).\n- Each domain reserves a dedicated numeric range. Never reuse, remove, or reorder error codes.\n- Human-readable messages live in `packages/errors/src/messages.ts` with `$key` context interpolation.\n- In production builds, messages are stripped. Use `npx @solana/errors decode -- ` to decode them.\n- To add a new error: add the constant to `codes.ts`, add it to the `SolanaErrorCode` union, optionally define context in `context.ts`, and add the message to `messages.ts`.\n\n## Coding Conventions\n\n- **TypeScript strict mode**, ESM-first.\n- **Branded/nominal types**: `@solana/nominal-types` provides `Brand` for types like `Address`, `Signature`, `Lamports` — these are branded primitives, not classes.\n- **Functional composition**: Use `pipe()` from `@solana/functional` to compose operations on transaction messages and other data structures.\n- **Platform-specific code**: Use `__BROWSER__`, `__NODEJS__`, `__REACTNATIVE__` guards. The build system will tree-shake unused branches.\n- **Dev-only code**: Guard with `__DEV__` (e.g. verbose error messages, debug assertions).\n- **Formatting**: ESLint via `@solana/eslint-config-solana`, Prettier via `@solana/prettier-config-solana`. Run `pnpm style:fix` to auto-fix.\n- **All publishable packages share a fixed version** (currently in lockstep).\n- **Deferred promises**: Use `Promise.withResolvers()` instead of hand-rolling a `new Promise((resolve, reject) => ...)` with captured externals. Do not reintroduce a `deferred()` helper — `Promise.withResolvers` already returns `{ promise, resolve, reject }`.\n\n## Changesets & Releases\n\n- Use `npx changeset add --empty` to generate changeset files — never create them manually.\n- `patch` for fixes, `minor` for features, `major` for breaking changes (while pre-1.0, `minor` may be treated as breaking).\n- No changeset needed for docs-only changes, CI config, dev dependency updates, or test-only changes.\n- All publishable packages are version-locked via the `fixed` config in `.changeset/config.json`.\n\n## CI\n\n- **PRs**: Build + test on Node `current` and `lts/*`.\n- **Bundle size**: Monitored via BundleMon on every PR.\n- **Publishing**: On merge to `main`, changesets action creates a \"Version Packages\" PR or publishes to npm. Canary snapshots are published on every push to `main`.\n\n\n\n## Skill Instructions\n\nThe following instructions come from installed skills (autogenerated, do not edit manually) and should always be followed.\n\n### Changesets\n\n- Any PR that should trigger a package release MUST include a changeset.\n- Identify affected packages by mapping changed files to their nearest `package.json`.\n- Choose the right bump: `patch` for fixes, `minor` for features, `major` for breaking changes.\n- While a project is pre-1.0, `minor` bumps may be treated as breaking.\n- ALWAYS use `npx changeset add --empty` to generate a new changeset file with a random name. NEVER create changeset files manually.\n- No changeset needed for: docs-only changes, CI config, dev dependency updates, test-only changes.\n\n### Shipping (Git)\n\n- NEVER commit, push, create branches, or create PRs without explicit user approval.\n- Before any git operation that creates or modifies a commit, present a review block containing: changeset entry (if applicable), commit title, and commit/PR description. ALWAYS wait for approval.\n- Use standard `git add` and `git commit` workflows. Concise title on the first line, blank line, then description body.\n- Use `gh pr create` for pull requests.\n- Write commit and PR descriptions as natural flowing prose. Do NOT insert hard line breaks mid-paragraph.\n\n### Shipping (Graphite)\n\n- Check if [Graphite](https://graphite.dev/) is installed (`which gt`). Prefer Graphite when available; fall back to the Git shipping workflow otherwise.\n- NEVER commit, push, create branches, or create PRs without explicit user approval.\n- Before any git operation that creates or modifies a commit, present a review block containing: changeset entry (if applicable), commit title, and commit/PR description. ALWAYS wait for approval.\n- Use `gt create -am \"Title\" -m \"Description body\"` for new PRs. The first `-m` sets the commit title; the second sets the PR description.\n- Use `gt modify -a` to amend the current branch with follow-up changes (NEVER create additional commits on the same branch).\n- ALWAYS escape backticks in commit messages with backslashes for shell compatibility (e.g. `\"Update \\`my-package\\` config\"`).\n- Do NOT run `gt submit` after committing. Only run it when the user explicitly asks to submit or push.\n- Write commit and PR descriptions as natural flowing prose. Do NOT insert hard line breaks mid-paragraph.\n\n### TypeScript Docblocks\n\n- All exported functions, types, interfaces, and constants MUST have JSDoc docblocks.\n- Start with `/**`, use `*` prefix for each line, end with `*/` — each on its own line.\n- Begin with a clear one-to-two line summary. Add a blank line before tags.\n- Include `@param`, `@typeParam`, `@return`, `@throws`, and at least one `@example` when helpful.\n- Use `{@link ...}` to reference related items. Add `@see` tags at the end for related APIs.\n\n### TypeScript READMEs\n\n- When adding a new public API, add or update the package's README.\n- Structure: brief intro, installation, usage (with code snippet), deep-dive sections.\n- Code snippets must be realistic, concise, and use TypeScript syntax.\n- Focus on the quickest path to success. Developers should feel excited, not overwhelmed.\n\n\n" }, { "path": "CONTRIBUTING.md", "content": "Kit is developed in public and we encourage and appreciate contributions.\n\n## Getting Started\n\n1. Install dependencies: `pnpm install`\n2. The first time you build Kit, you will need to install the Agave test validator, which is used for some tests. `pnpm test:setup`\n3. Start a test validator before running tests. `./scripts/start-shared-test-validator.sh`\n4. Build + test all packages: `pnpm build`\n\n## Development Environment\n\nKit is developed as a monorepo using [pnpm](https://pnpm.io/) and [turborepo](https://turborepo.com/).\n\nOften your changes will only apply to a single package. You can run tests for a single package and watch for changes:\n\n```shell\ncd packages/accounts\npnpm turbo compile:js compile:typedefs\npnpm dev\n```\n\n## A Note on AI-Generated Code\n\nWe are supportive of using AI tools to _assist_ your development process (e.g., for boilerplate, optimization suggestions, or debugging).\n\nHowever, we do not accept \"vibe-coded\" or purely AI-generated contributions. You must be able to explain, test, and take full ownership of every line of code you submit.\n\nA good rule of thumb is not to use AI to write the PR description. This tends to be less clear and harder to review.\n\n**Pull requests containing code that the author clearly does not understand will be rejected.** You are the developer, not the prompt engineer. All code must be intentional and understood.\n" }, { "path": "LICENSE", "content": "Copyright (c) 2023 Solana Labs, Inc\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n" }, { "path": "README.md", "content": "[![npm][npm-image]][npm-url]\n[![npm-downloads][npm-downloads-image]][npm-url]\n
\n[![code-style-prettier][code-style-prettier-image]][code-style-prettier-url]\n\n[code-style-prettier-image]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square\n[code-style-prettier-url]: https://github.com/prettier/prettier\n[npm-downloads-image]: https://img.shields.io/npm/dm/@solana/kit?style=flat\n[npm-image]: https://img.shields.io/npm/v/@solana/kit?style=flat\n[npm-url]: https://www.npmjs.com/package/@solana/kit\n\n# Kit\n\nThis is the JavaScript SDK for building Solana apps for Node, web, and React Native.\n\n> [!NOTE]\n> Did you expect to find `@solana/web3.js` here? You're in the right place! We have renamed the 2.x line of `@solana/web3.js` to `@solana/kit`.\n>\n> The code for the 1.x line of `@solana/web3.js` can be found [here](https://github.com/solana-labs/solana-web3.js/tree/maintenance/v1.x) and the documentation [here](https://solana-foundation.github.io/solana-web3.js/).\n\n# Installation\n\nFor use in a Node.js or web application:\n\n```shell\nnpm install --save @solana/kit\n```\n\nFor use in a browser, without a build system:\n\n```html\n\n\n\n\n\n```\n\n# Quick Start\n\nTo get a feel for the API, run and modify the live examples in the `examples/` directory. There, you will find a series of single-purpose Node scripts that demonstrate a specific feature or use case. You will also find a React application that you can run in a browser, that demonstrates being able to create, sign, and send transactions using browser wallets.\n\nFor a fully baked intro, see: [Getting started with Solana kit](https://www.solanakit.com/docs/getting-started)\n\n# What's New in Kit\n\nKit is a response to many of the pain points you have communicated to us when developing Solana applications with web3.js.\n\n## Tree-Shakability\n\nThe object-oriented design of the web3.js (1.x) API prevents optimizing compilers from being able to ‘tree-shake’ unused code from your production builds. No matter how much of the web3.js API you use in your application, you have until now been forced to package all of it.\n\nRead more about tree-shaking here:\n\n- [Mozilla Developer Docs: Tree Shaking](https://developer.mozilla.org/en-US/docs/Glossary/Tree_shaking)\n- [WebPack Docs: Tree Shaking](https://webpack.js.org/guides/tree-shaking/)\n- [Web.Dev Blog Article: Reduce JavaScript Payloads with Tree Shaking](https://web.dev/articles/reduce-javascript-payloads-with-tree-shaking)\n\nOne example of an API that can’t be tree-shaken is the `Connection` class. It has dozens of methods, but because it’s a _class_ you have no choice but to include every method in your application’s final bundle, no matter how many you _actually_ use.\n\nNeedlessly large JavaScript bundles can cause issues with deployments to cloud compute providers like Cloudflare or AWS Lambda. They also impact webapp startup performance because of longer download and JavaScript parse times.\n\nKit is fully tree-shakable and will remain so, enforced by build-time checks. Optimizing compilers can now eliminate those parts of the library that your application does not use.\n\nKit is comprised of several smaller, modular packages under the `@solana` organization, including:\n\n- `@solana/accounts`: For fetching and decoding accounts\n- `@solana/codecs`: For composing data (de)serializers from a set of primitives or building custom ones\n- `@solana/errors`: For identifying and refining coded errors thrown in the `@solana` namespace\n- `@solana/rpc`: For sending RPC requests\n- `@solana/rpc-subscriptions`: For subscribing to RPC notifications\n- `@solana/signers`: For building message and/or transaction signer objects\n- `@solana/sysvars`: For fetching and decoding sysvar accounts\n- `@solana/transaction-messages`: For building and transforming Solana transaction message objects\n- `@solana/transactions`: For compiling and signing transactions for submission to the network\n- And many more!\n\nSome of these packages are themselves composed of smaller packages. For instance, `@solana/rpc` is composed of `@solana/rpc-spec` (for core JSON RPC specification types), `@solana/rpc-api` (for the Solana-specific RPC methods), `@solana/rpc-transport-http` (for the default HTTP transport) and so on.\n\nDevelopers can use the default configurations within the main library (`@solana/kit`) or import any of its subpackages where customization-through-composition is desired.\n\n## Composable Internals\n\nDepending on your use case and your tolerance for certain application behaviours, you may wish to configure your application to make a different set of tradeoffs than another developer. The web3.js (1.x) API imposed a rigid set of common-case defaults on _all_ developers, some of which were impossible to change.\n\nThe inability to customize web3.js up until now has been a source of frustration:\n\n- The Mango team wanted to customize the transaction confirmation strategy, but all of that functionality is hidden away behind `confirmTransaction` – a static method of `Connection`. [Here’s the code for `confirmTransaction` on GitHub](https://github.com/solana-labs/solana-web3.js/blob/69a8ad25ef09f9e6d5bff1ffa8428d9be0bd32ac/packages/library-legacy/src/connection.ts#L3734).\n- Solana developer ‘mPaella’ [wanted us to add a feature in the RPC](https://github.com/solana-labs/solana-web3.js/issues/1143#issuecomment-1435927152) that would failover to a set of backup URLs in case the primary one failed.\n- Solana developer ‘epicfaace’ wanted first-class support for automatic time-windowed batching in the RPC transport. [Here’s their pull request](https://github.com/solana-labs/solana/pull/23628).\n- Multiple folks have expressed the need for custom retry logic for failed requests or transactions. [Here’s a pull request from ‘dafyddd’](https://github.com/solana-labs/solana/pull/11811) and [another from ‘abrkn’](https://github.com/solana-labs/solana-web3.js/issues/1041) attempting to modify retry logic to suit their individual use cases.\n\nKit exposes far more of its internals, particularly where communication with an RPC is concerned, and allows willing developers the ability to compose new implementations from the default ones that manifest a nearly limitless array of customizations.\n\nThe individual modules that make up Kit are assembled in a **default** configuration reminiscent of the legacy library as part of the npm package `@solana/kit`, but those who wish to assemble them in different configurations may do so.\n\nGeneric types are offered in numerous places, allowing you to specify new functionality, to make extensions to each API via composition and supertypes, and to encourage you to create higher-level opinionated abstractions of your own.\n\nIn fact, we expect you to do so, and to open source some of those for use by others with similar needs.\n\n## Modern JavaScript; Zero-Dependency\n\nThe advance of modern JavaScript features presents an opportunity to developers of crypto applications, such as the ability to use native Ed25519 keys and to express large values as native `bigint`.\n\nThe Web Incubator Community Group has advocated for the addition of Ed25519 support to the [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API), and support has already landed in _most_ modern JavaScript runtimes.\n\nEngine support for `bigint` values has also become commonplace. The older `number` primitive in JavaScript has a maximum value of 2^53 - 1, whereas Rust’s `u64` can represent values up to 2^64.\n\nKit eliminates userspace implementations of Ed25519 cryptography, large number polyfills, and more, in favour of custom implementations or the use of native JavaScript features, reducing the size of the library. It has no third-party dependencies.\n\n## Functional Architecture\n\nThe object oriented, class-based architecture of web3.js (1.x) causes unnecessary bundle bloat. Your application has no choice but to bundle _all_ of the functionality and dependencies of a class no matter how many methods you actually use at runtime.\n\nClass-based architecture also presents unique risks to developers who trigger the dual-package hazard. This describes a situation you can find yourself in if you build for both CommonJS and ES modules. It arises when two copies of the same class are present in the dependency tree, causing checks like `instanceof` to fail. This introduces aggravating and difficult to debug problems.\n\nRead more about dual-package hazard:\n\n- [NodeJS: Dual Package Hazard](https://nodejs.org/api/packages.html#dual-package-hazard)\n\nKit implements no classes (with the notable exception of the `SolanaError` class) and implements the thinnest possible interfaces at function boundaries.\n\n## Statistics\n\nConsider these statistical comparisons between Kit and the legacy web3.js 1.x.\n\n| | 1.x (Legacy) | Kit | +/- % |\n| ------------------------------------------------------------------------------------------------------ | ------------ | ---------- | ----- |\n| Total minified size of library | 81 KB | 57.5 KB | -29% |\n| Total minified size of library (when runtime supports Ed25519) | 81 KB | 53 KB | -33% |\n| Bundled size of a web application that executes a transfer of lamports | 111 KB | 23.9 KB | -78% |\n| Bundled size of a web application that executes a transfer of lamports (when runtime supports Ed25519) | 111 KB | 18.2 KB | -83% |\n| Performance of key generation, signing, and verifying signatures (Brave with Experimental API flag) | 700 ops/s | 7000 ops/s | +900% |\n| First-load size for Solana Explorer | 311 KB | 228 KB | -26% |\n\nThe re-engineered library achieves these speedups and reductions in bundle size in large part through use of modern JavaScript APIs.\n\nTo validate our work, we replaced the legacy 1.x library with Kit on the homepage of the Solana Explorer. Total first-load bundle size dropped by 26% without removing a single feature. [Here’s an X thread](https://twitter.com/callum_codes/status/1679124485218226176) by Callum McIntyre if you would like to dig deeper.\n\n# A Tour of the Kit API\n\nHere’s an overview of how to use the new library to interact with the RPC, configure network transports, work with Ed25519 keys, and to serialize data.\n\n## RPC\n\nKit ships with an implementation of the [JSON RPC specification](https://www.jsonrpc.org/specification) and a type spec for the [Solana JSON RPC](https://solana.com/docs/rpc).\n\nThe main package responsible for managing communication with an RPC is `@solana/rpc`. However, this package makes use of more granular packages to break down the RPC logic into smaller pieces. Namely, these packages are:\n\n- `@solana/rpc`: Contains all logic related to sending Solana RPC calls.\n- `@solana/rpc-api`: Describes all Solana RPC methods using types.\n- `@solana/rpc-transport-http`: Provides a concrete implementation of an RPC transport using HTTP requests.\n- `@solana/rpc-spec`: Defines the JSON RPC spec for sending RPC requests.\n- `@solana/rpc-spec-types`: Shared JSON RPC specifications types and helpers that are used by both `@solana/rpc` and `@solana/rpc-subscriptions` (described in the next section).\n- `@solana/rpc-types`: Shared Solana RPC types and helpers that are used by both `@solana/rpc` and `@solana/rpc-subscriptions`.\n\nThe main `@solana/kit` package re-exports the `@solana/rpc` package so, going forward, we will import RPC types and functions from the library directly.\n\n### RPC Calls\n\nYou can use the `createSolanaRpc` function by providing the URL of a Solana JSON RPC server. This will create a default client for interacting with the Solana JSON RPC API.\n\n```ts\nimport { createSolanaRpc } from '@solana/kit';\n\n// Create an RPC client.\nconst rpc = createSolanaRpc('http://127.0.0.1:8899');\n// ^? Rpc\n\n// Send a request.\nconst slot = await rpc.getSlot().send();\n```\n\n### Custom RPC Transports\n\nThe `createSolanaRpc` function communicates with the RPC server using a default HTTP transport that should satisfy most use cases. You can provide your own transport or wrap an existing one to communicate with RPC servers in any way you see fit. In the example below, we explicitly create a transport and use it to create a new RPC client via the `createSolanaRpcFromTransport` function.\n\n```ts\nimport { createSolanaRpcFromTransport, createDefaultRpcTransport } from '@solana/kit';\n\n// Create an HTTP transport or any custom transport of your choice.\nconst transport = createDefaultRpcTransport({ url: 'https://api.devnet.solana.com' });\n\n// Create an RPC client using that transport.\nconst rpc = createSolanaRpcFromTransport(transport);\n// ^? Rpc\n\n// Send a request.\nconst slot = await rpc.getSlot().send();\n```\n\nA custom transport can implement specialized functionality such as coordinating multiple transports, implementing retries, and more. Let's take a look at some concrete examples.\n\n#### Round Robin\n\nA ‘round robin’ transport is one that distributes requests to a list of endpoints in sequence.\n\n```ts\nimport { createDefaultRpcTransport, createSolanaRpcFromTransport, type RpcTransport } from '@solana/kit';\n\n// Create an HTTP transport for each RPC server.\nconst transports = [\n createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-1.com' }),\n createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-2.com' }),\n createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-3.com' }),\n];\n\n// Set up the round-robin transport.\nlet nextTransport = 0;\nasync function roundRobinTransport(...args: Parameters): Promise {\n const transport = transports[nextTransport];\n nextTransport = (nextTransport + 1) % transports.length;\n return await transport(...args);\n}\n\n// Create an RPC client using the round-robin transport.\nconst rpc = createSolanaRpcFromTransport(roundRobinTransport);\n```\n\n#### Sharding\n\nA sharding transport is a kind of distributing transport that sends requests to a particular server based on something about the request itself. Here’s an example that sends requests to different servers depending on the name of the method:\n\n```ts\nimport { createDefaultRpcTransport, createSolanaRpcFromTransport, type RpcTransport } from '@solana/kit';\n\n// Create multiple transports.\nconst transportA = createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-1.com' });\nconst transportB = createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-2.com' });\nconst transportC = createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-3.com' });\nconst transportD = createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-4.com' });\n\n// Function to determine which shard to use based on the request method.\nfunction selectShard(method: string): RpcTransport {\n switch (method) {\n case 'getAccountInfo':\n case 'getBalance':\n return transportA;\n case 'getLatestBlockhash':\n case 'getTransaction':\n return transportB;\n case 'sendTransaction':\n return transportC;\n default:\n return transportD;\n }\n}\n\n// Create a transport that selects the correct transport given the request method name.\nasync function shardingTransport(...args: Parameters): Promise {\n const payload = args[0].payload as { method: string };\n const selectedTransport = selectShard(payload.method);\n return (await selectedTransport(...args)) as TResponse;\n}\n\n// Create an RPC client using the sharding transport.\nconst rpc = createSolanaRpcFromTransport(shardingTransport);\n```\n\n#### Retry\n\nA custom transport is a good place to implement global retry logic for every request:\n\n```ts\nimport { createDefaultRpcTransport, createSolanaRpcFromTransport, type RpcTransport } from '@solana/kit';\n\n// Set the maximum number of attempts to retry a request.\nconst MAX_ATTEMPTS = 4;\n\n// Create the default transport.\nconst defaultTransport = createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-1.com' });\n\n// Sleep function to wait for a given number of milliseconds.\nfunction sleep(ms: number): Promise {\n return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n// Calculate the delay for a given attempt.\nfunction calculateRetryDelay(attempt: number): number {\n // Exponential backoff with a maximum of 1.5 seconds.\n return Math.min(100 * Math.pow(2, attempt), 1500);\n}\n\n// A retrying transport that will retry up to MAX_ATTEMPTS times before failing.\nasync function retryingTransport(...args: Parameters): Promise {\n let requestError;\n for (let attempts = 0; attempts < MAX_ATTEMPTS; attempts++) {\n try {\n return await defaultTransport(...args);\n } catch (err) {\n requestError = err;\n // Only sleep if we have more attempts remaining.\n if (attempts < MAX_ATTEMPTS - 1) {\n const retryDelay = calculateRetryDelay(attempts);\n await sleep(retryDelay);\n }\n }\n }\n throw requestError;\n}\n\n// Create the RPC client using the retrying transport.\nconst rpc = createSolanaRpcFromTransport(retryingTransport);\n```\n\n#### Failover\n\nSupport for handling network failures can be implemented in the transport itself. Here’s an example of some failover logic integrated into a transport:\n\n```ts\nimport { createDefaultRpcTransport, createSolanaRpcFromTransport, type RpcTransport } from '@solana/kit';\n\n// List of RPC endpoints for failover.\nconst rpcEndpoints = [\n 'https://mainnet-beta.my-server-1.com',\n 'https://mainnet-beta.my-server-2.com',\n 'https://mainnet-beta.my-server-3.com',\n 'https://mainnet-beta.my-server-3.com',\n];\n\n// Create an array of transports from the endpoints.\nconst transports = rpcEndpoints.map(url => createDefaultRpcTransport({ url }));\n\n// A failover transport that switches to the next transport on failure.\nasync function failoverTransport(...args: Parameters): Promise {\n let lastError;\n for (const transport of transports) {\n try {\n return await transport(...args);\n } catch (err) {\n lastError = err;\n console.warn(`Transport failed: ${err}. Trying next transport...`);\n }\n }\n // If all transports fail, throw the last error.\n throw lastError;\n}\n\n// Create the RPC client using the failover transport.\nconst rpc = createSolanaRpcFromTransport(failoverTransport);\n```\n\n### Augmenting/Constraining the RPC API\n\nUsing the `createSolanaRpc` or `createSolanaRpcFromTransport` methods, we always get the same API that includes the Solana RPC API methods. Since the RPC API is described using types only, it is possible to augment those types to add your own methods.\n\nWhen constraining the API scope, keep in mind that types don’t affect bundle size. You may still like to constrain the type-spec for a variety of reasons, including reducing TypeScript noise.\n\n#### Constraining by Cluster\n\nIf you're using a specific cluster, you may wrap your RPC URL inside a helper function like `mainnet` or `devnet` to inject that information into the RPC type system.\n\n```ts\nimport { createSolanaRpc, mainnet, devnet } from '@solana/kit';\n\nconst mainnetRpc = createSolanaRpc(mainnet('https://api.mainnet-beta.solana.com'));\n// ^? RpcMainnet\n\nconst devnetRpc = createSolanaRpc(devnet('https://api.devnet.solana.com'));\n// ^? RpcDevnet\n```\n\nIn the example above, `devnetRpc.requestAirdrop(..)` will work, but `mainnetRpc.requestAirdrop(..)` will raise a TypeScript error since `requestAirdrop` is not a valid method of the mainnet cluster.\n\n#### Cherry-Picking API Methods\n\nYou can constrain the API’s type-spec even further so you are left only with the methods you need. The simplest way to do this is to cast the created RPC client to a type that only includes the required methods.\n\n```ts\nimport { createSolanaRpc, type Rpc, type GetAccountInfoApi, type GetMultipleAccountsApi } from '@solana/kit';\n\nconst rpc = createSolanaRpc('http://127.0.0.1:8899') as Rpc;\n```\n\nAlternatively, you can explicitly create the RPC API using the `createSolanaRpcApi` function. You will need to create your own transport and bind the two together using the `createRpc` function.\n\n```ts\nimport {\n createDefaultRpcTransport,\n createRpc,\n createSolanaRpcApi,\n DEFAULT_RPC_CONFIG,\n type GetAccountInfoApi,\n type GetMultipleAccountsApi,\n} from '@solana/kit';\n\nconst api = createSolanaRpcApi(DEFAULT_RPC_CONFIG);\nconst transport = createDefaultRpcTransport({ url: 'http://127.0.0.1:8899' });\n\nconst rpc = createRpc({ api, transport });\n```\n\nNote that the `createSolanaRpcApi` function is a wrapper on top of the `createJsonRpcApi` function which adds some Solana-specific transformers such as setting a default commitment on all methods or throwing an error when an integer overflow is detected.\n\n#### Creating Your Own API Methods\n\nThe new library’s RPC specification supports an _infinite_ number of JSON-RPC methods with **zero increase** in bundle size.\n\nThis means the library can support future additions to the official [Solana JSON RPC](https://docs.solana.com/api), or [custom RPC methods](https://docs.helius.dev/compression-and-das-api/digital-asset-standard-das-api/get-asset) defined by some RPC provider.\n\nHere’s an example of how a developer at might build a custom RPC type-spec for an RPC provider's implementation of the Metaplex Digital Asset Standard's `getAsset` method:\n\n```ts\n// Define the method's response payload.\ntype GetAssetApiResponse = Readonly<{\n interface: DasApiAssetInterface;\n id: Address;\n content: Readonly<{\n files?: readonly {\n mime?: string;\n uri?: string;\n [key: string]: unknown;\n }[];\n json_uri: string;\n links?: readonly {\n [key: string]: unknown;\n }[];\n metadata: DasApiMetadata;\n }>;\n /* ...etc... */\n}>;\n\n// Set up a type spec for the request method.\ntype GetAssetApi = {\n // Define the method's name, parameters and response type\n getAsset(args: { id: Address }): GetAssetApiResponse;\n};\n\n// Export the type spec for downstream users.\nexport type MetaplexDASApi = GetAssetApi;\n```\n\nHere’s how a developer might use it:\n\n```ts\nimport { createDefaultRpcTransport, createRpc, createJsonRpcApi } from '@solana/kit';\n\n// Create the custom API.\nconst api = createJsonRpcApi();\n\n// Set up an HTTP transport to a server that supports the custom API.\nconst transport = createDefaultRpcTransport({\n url: 'https://mainnet.helius-rpc.com/?api-key=',\n});\n\n// Create the RPC client.\nconst metaplexDASRpc = createRpc({ api, transport });\n// ^? Rpc\n```\n\nAs long as a particular JSON RPC method adheres to the [official JSON RPC specification](https://www.jsonrpc.org/specification), it will be supported by Kit.\n\n### Aborting RPC Requests\n\nRPC requests are now abortable with modern `AbortControllers`. When calling an RPC method such as `getSlot`, it will return a `PendingRpcRequest` proxy object that contains a `send` method to send the request to the server.\n\n```ts\nconst pendingRequest: PendingRpcRequest = rpc.getSlot();\n\nconst slot: Slot = await pendingRequest.send();\n```\n\nThe arguments of the `getSlot` method are reserved for the request payload, but the `send` method is where additional arguments such as an `AbortSignal` can be accepted in the context of the request.\n\nAborting RPC requests can be useful for a variety of things such as setting a timeout on a request or cancelling a request when a user navigates away from a page.\n\n```ts\nimport { createSolanaRpc } from '@solana/kit';\n\nconst rpc = createSolanaRpc('http://127.0.0.1:8900');\n\n// Create a new AbortController.\nconst abortController = new AbortController();\n\n// Abort the request when the user navigates away from the current page.\nfunction onUserNavigateAway() {\n abortController.abort();\n}\n\n// The request will be aborted if and only if the user navigates away from the page.\nconst slot = await rpc.getSlot().send({ abortSignal: abortController.signal });\n```\n\nRead more about `AbortController` here:\n\n- [Mozilla Developer Docs: `AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController)\n- [Mozilla Developer Docs: `AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)\n- [JavaScript.info: Fetch: Abort](https://javascript.info/fetch-abort)\n\n## RPC Subscriptions\n\nSubscriptions in the legacy library do not allow custom retry logic and do not allow you to recover from potentially missed messages. The new version does away with silent retries, surfaces transport errors to your application, and gives you the opportunity to recover from gap events.\n\nThe main package responsible for managing communication with RPC subscriptions is `@solana/rpc-subscriptions`. However, similarly to `@solana/rpc`, this package also makes use of more granular packages. These packages are:\n\n- `@solana/rpc-subscriptions`: Contains all logic related to subscribing to Solana RPC notifications.\n- `@solana/rpc-subscriptions-api`: Describes all Solana RPC subscriptions using types.\n- `@solana/rpc-subscriptions-channel-websocket`: Provides a concrete implementation of an RPC Subscriptions channel using WebSockets.\n- `@solana/rpc-subscriptions-spec`: Defines the JSON RPC spec for subscribing to RPC notifications.\n- `@solana/rpc-spec-types`: Shared JSON RPC specifications types and helpers that are used by both `@solana/rpc` and `@solana/rpc-subscriptions`.\n- `@solana/rpc-types`: Shared Solana RPC types and helpers that are used by both `@solana/rpc` and `@solana/rpc-subscriptions`.\n\nSince the main `@solana/kit` library also re-exports the `@solana/rpc-subscriptions` package we will import RPC Subscriptions types and functions directly from the main library going forward.\n\n### Getting Started with RPC Subscriptions\n\nTo get started with RPC Subscriptions, you may use the `createSolanaRpcSubscriptions` function by providing the WebSocket URL of a Solana JSON RPC server. This will create a default client for interacting with Solana RPC Subscriptions.\n\n```ts\nimport { createSolanaRpcSubscriptions } from '@solana/kit';\n\n// Create an RPC Subscriptions client.\nconst rpcSubscriptions = createSolanaRpcSubscriptions('ws://127.0.0.1:8900');\n// ^? RpcSubscriptions\n```\n\n### Subscriptions as `AsyncIterators`\n\nThe new subscriptions API vends subscription notifications as an `AsyncIterator`. The `AsyncIterator` conforms to the [async iterator protocol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols), which allows developers to consume messages using a `for await...of` loop.\n\nHere’s an example of working with a subscription in the new library:\n\n```ts\nimport { address, createSolanaRpcSubscriptions, createDefaultRpcSubscriptionsTransport } from '@solana/kit';\n\n// Create the RPC Subscriptions client.\nconst rpcSubscriptions = createSolanaRpcSubscriptions('ws://127.0.0.1:8900');\n\n// Set up an abort controller.\nconst abortController = new AbortController();\n\n// Subscribe to account notifications.\nconst accountNotifications = await rpcSubscriptions\n .accountNotifications(address('AxZfZWeqztBCL37Mkjkd4b8Hf6J13WCcfozrBY6vZzv3'), { commitment: 'confirmed' })\n .subscribe({ abortSignal: abortController.signal });\n\ntry {\n // Consume messages.\n for await (const notification of accountNotifications) {\n console.log('New balance', notification.value.lamports);\n }\n} catch (e) {\n // The subscription went down.\n // Retry it and then recover from potentially having missed\n // a balance update, here (eg. by making a `getBalance()` call).\n}\n```\n\nYou can read more about `AsyncIterator` at the following links:\n\n- [Mozilla Developer Docs: `AsyncIterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncIterator)\n- [Luciano Mammino (Blog): JavaScript Async Iterators](https://www.nodejsdesignpatterns.com/blog/javascript-async-iterators/)\n\n### Aborting RPC Subscriptions\n\nSimilarly to RPC calls, applications can terminate active subscriptions using an `AbortController` attribute on the `subscribe` method. In fact, this parameter is _required_ for subscriptions to encourage you to clean up subscriptions that your application no longer needs.\n\nLet's take a look at some concrete examples that demonstrate how to abort subscriptions.\n\n#### Subscription Timeout\n\nHere's an example of an `AbortController` used to abort a subscription after a 5-second timeout:\n\n```ts\nimport { createSolanaRpcSubscriptions } from '@solana/kit';\n\nconst rpcSubscriptions = createSolanaRpcSubscriptions('ws://127.0.0.1:8900');\n\n// Subscribe for slot notifications using an AbortSignal that times out after 5 seconds.\nconst slotNotifications = await rpcSubscriptions\n .slotNotifications()\n .subscribe({ abortSignal: AbortSignal.timeout(5000) });\n\n// Log slot notifications.\nfor await (const notification of slotNotifications) {\n console.log('Slot notification', notification);\n}\n\nconsole.log('Done.');\n```\n\nRead more about `AbortController` at the following links:\n\n- [Mozilla Developer Docs: `AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController)\n- [Mozilla Developer Docs: `AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)\n- [JavaScript.info: Fetch: Abort](https://javascript.info/fetch-abort)\n\n#### Cancelling Subscriptions\n\nIt is also possible to abort a subscription inside the `for await...of` loop. This enables us to cancel a subscription based on some condition, such as a change in the state of an account. For instance, the following example cancels a subscription when the owner of an account changes:\n\n```ts\n// Subscribe to account notifications.\nconst accountNotifications = await rpc\n .accountNotifications(address('AxZfZWeqztBCL37Mkjkd4b8Hf6J13WCcfozrBY6vZzv3'), { commitment: 'confirmed' })\n .subscribe({ abortSignal });\n\n// Consume messages.\nlet previousOwner = null;\nfor await (const notification of accountNotifications) {\n const {\n value: { owner },\n } = notification;\n // Check the owner to see if it has changed\n if (previousOwner && owner !== previousOwner) {\n // If so, abort the subscription\n abortController.abort();\n } else {\n console.log(notification);\n }\n previousOwner = owner;\n}\n```\n\n### Failed vs. Aborted Subscriptions\n\nIt is important to note that a subscription failure behaves differently from a subscription abort. A subscription failure occurs when the subscription goes down and will throw an error that can be intercepted in a `try/catch`. However, an aborted subscription will not throw an error, but will instead exit the `for await...of` loop.\n\n```ts\ntry {\n for await (const notification of notifications) {\n // Consume messages.\n }\n // [ABORTED] Reaching this line means the subscription was aborted — i.e. unsubscribed.\n} catch (e) {\n // [FAILED] Reaching this line means the subscription went down.\n // Retry it, then recover from potential missed messages.\n} finally {\n // [ABORTED or FAILED] Whether the subscription failed or was aborted, you can run cleanup code here.\n}\n```\n\n### Message Gap Recovery\n\nOne of the most crucial aspects of any subscription API is managing potential missed messages. Missing messages, such as account state updates, could be catastrophic for an application. That’s why the new library provides native support for recovering missed messages using the `AsyncIterator`.\n\nWhen a connection fails unexpectedly, any messages you miss while disconnected can result in your UI falling behind or becoming corrupt. Because subscription failure is now made explicit in the new API, you can implement ‘catch-up’ logic after re-establishing the subscription.\n\nHere’s an example of such logic:\n\n```ts\ntry {\n for await (const notif of accountNotifications) {\n updateAccountBalance(notif.lamports);\n }\n} catch (e) {\n // The subscription failed.\n // First, re-establish the subscription.\n await setupAccountBalanceSubscription(address);\n // Then make a one-shot request to 'catch up' on any missed balance changes.\n const { value: lamports } = await rpc.getBalance(address).send();\n updateAccountBalance(lamports);\n}\n```\n\n### Using Custom RPC Subscriptions Transports\n\nThe `createSolanaRpcSubscriptions` function communicates with the RPC server using a default `WebSocket` channel that should satisfy most use cases. However, you may here as well provide your own channel creator or decorate existing ones to communicate with RPC servers in any way you see fit. In the example below, we supply a custom `WebSocket` channel creator and use it to create a new RPC Subscriptions client via the `createSolanaRpcSubscriptionsFromTransport` function.\n\n```ts\nimport { createDefaultRpcSubscriptionsTransport, createSolanaRpcSubscriptionsFromTransport } from '@solana/kit';\n\n// Create a transport with a custom channel creator of your choice.\nconst transport = createDefaultRpcSubscriptionsTransport({\n createChannel({ abortSignal }) {\n return createWebSocketChannel({\n maxSubscriptionsPerChannel: 100,\n minChannels: 25,\n sendBufferHighWatermark: 32_768,\n signal: abortSignal,\n url: 'ws://127.0.0.1:8900',\n });\n },\n});\n\n// Create an RPC client using that transport.\nconst rpcSubscriptions = createSolanaRpcSubscriptionsFromTransport(transport);\n// ^? RpcSubscriptions\n```\n\n### Augmenting/Constraining the RPC Subscriptions API\n\nUsing the `createSolanaRpcSubscriptions` or `createSolanaRpcSubscriptionsFromTransport` functions, we always get the same RPC Subscriptions API, including all Solana RPC stable subscriptions. However, since the RPC Subscriptions API is described using types only, it is possible to constrain the API to a specific set of subscriptions or even add your own custom subscriptions.\n\n#### Constraining by Cluster\n\nIf you're using a specific cluster, you may wrap your RPC URL inside a helper function like `mainnet` or `devnet` to inject that information into the RPC type system.\n\n```ts\nimport { createSolanaRpcSubscriptions, mainnet, devnet } from '@solana/kit';\n\nconst mainnetRpc = createSolanaRpcSubscriptions(mainnet('https://api.mainnet-beta.solana.com'));\n// ^? RpcSubscriptionsMainnet\n\nconst devnetRpc = createSolanaRpcSubscriptions(devnet('https://api.devnet.solana.com'));\n// ^? RpcSubscriptionsDevnet\n```\n\n#### Including Unstable Subscriptions\n\nIf your app needs access to [unstable RPC Subscriptions](https://solana.com/docs/rpc/websocket/blocksubscribe) — e.g. `BlockNotificationsApi` or `SlotsUpdatesNotificationsApi` — and your RPC server supports them, you may use the `createSolanaRpcSubscriptions_UNSTABLE` and `createSolanaRpcSubscriptionsFromTransport_UNSTABLE` functions to create an RPC Subscriptions client that includes those subscriptions.\n\n```ts\nimport {\n createDefaultSolanaRpcSubscriptionsChannelCreator,\n createDefaultRpcSubscriptionsTransport,\n createSolanaRpcSubscriptions_UNSTABLE,\n createSolanaRpcSubscriptionsFromTransport_UNSTABLE,\n} from '@solana/kit';\n\n// Using the default WebSocket channel.\nconst rpcSubscriptions = createSolanaRpcSubscriptions_UNSTABLE('ws://127.0.0.1:8900');\n// ^? RpcSubscriptions\n\n// Using a custom transport.\nconst transport = createDefaultRpcSubscriptionsTransport({\n createChannel: createDefaultSolanaRpcSubscriptionsChannelCreator({\n url: 'ws://127.0.0.1:8900',\n }),\n});\nconst rpcSubscriptions = createSolanaRpcSubscriptionsFromTransport_UNSTABLE(transport);\n// ^? RpcSubscriptions\n```\n\n#### Cherry-Picking API Methods\n\nYou may constrain the scope of the Subscription API even further so you are left only with the subscriptions you need. The simplest way to do this is to cast the created RPC client to a type that only includes the methods you need.\n\n```ts\nimport {\n createSolanaRpcSubscriptions,\n type RpcSubscriptions,\n type AccountNotificationsApi,\n type SlotNotificationsApi,\n} from '@solana/kit';\n\nconst rpc = createSolanaRpcSubscriptions('ws://127.0.0.1:8900') as RpcSubscriptions<\n AccountNotificationsApi & SlotNotificationsApi\n>;\n```\n\nAlternatively, you may explicitly create the RPC Subscriptions API using the `createSolanaRpcSubscriptionsApi` function. You will then need to create your own transport explicitly and bind the two together using the `createSubscriptionRpc` function.\n\n```ts\nimport {\n createDefaultSolanaRpcSubscriptionsChannelCreator,\n createDefaultRpcSubscriptionsTransport,\n createSubscriptionRpc,\n createSolanaRpcSubscriptionsApi,\n DEFAULT_RPC_CONFIG,\n type AccountNotificationsApi,\n type SlotNotificationsApi,\n} from '@solana/kit';\n\nconst api = createSolanaRpcSubscriptionsApi(DEFAULT_RPC_CONFIG);\nconst transport = createDefaultRpcSubscriptionsTransport({\n createChannel: createDefaultSolanaRpcSubscriptionsChannelCreator({\n url: 'ws://127.0.0.1:8900',\n }),\n});\nconst rpcSubscriptions = createSubscriptionRpc({ api, transport });\n```\n\nNote that the `createSolanaRpcSubscriptionsApi` function is a wrapper on top of the `createRpcSubscriptionsApi` function which adds some Solana-specific transformers such as setting a default commitment on all methods or throwing an error when an integer overflow is detected.\n\n## Keys\n\nThe new library takes a brand-new approach to Solana key pairs and addresses, which will feel quite different from the classes `PublicKey` and `Keypair` from version 1.x.\n\n### Web Crypto API\n\nAll key operations now use the native Ed25519 implementation in JavaScript’s Web Crypto API.\n\nThe API itself is designed to be a more reliably secure way to manage highly sensitive secret key information, but **developers should still use extreme caution when dealing with secret key bytes in their applications**.\n\nOne thing to note is that many operations from Web Crypto – such as importing, generating, signing, and verifying are now **asynchronous**.\n\nHere’s an example of generating a `CryptoKeyPair` using the Web Crypto API and signing a message:\n\n```ts\nimport { generateKeyPair, signBytes, verifySignature } from '@solana/kit';\n\nconst keyPair: CryptoKeyPair = await generateKeyPair();\n\nconst message = new Uint8Array(8).fill(0);\n\nconst signedMessage = await signBytes(keyPair.privateKey, message);\n// ^? Signature\n\nconst verified = await verifySignature(keyPair.publicKey, signedMessage, message);\n```\n\n### Web Crypto Polyfill\n\nWherever Ed25519 is not supported, we offer a polyfill for Web Crypto’s Ed25519 API.\n\nThis polyfill can be found at `@solana/webcrypto-ed25519-polyfill` and mimics the functionality of the Web Crypto API for Ed25519 key pairs using the same userspace implementation we used in web3.js 1.x. It does not polyfill other algorithms.\n\nDetermine if your target runtime supports Ed25519, and install the polyfill if it does not:\n\n```ts\nimport { install } from '@solana/webcrypto-ed25519-polyfill';\nimport { generateKeyPair, signBytes, verifySignature } from '@solana/kit';\n\ninstall();\nconst keyPair: CryptoKeyPair = await generateKeyPair();\n\n/* Remaining logic */\n```\n\nYou can see where Ed25519 is currently supported in [this GitHub issue](https://github.com/WICG/webcrypto-secure-curves/issues/20) on the Web Crypto repository. Consider sniffing the user-agent when deciding whether or not to deliver the polyfill to browsers.\n\nOperations on `CryptoKey` objects using the Web Crypto API _or_ the polyfill are mostly handled by the `@solana/keys` package.\n\n### String Addresses\n\nAll addresses are now JavaScript strings. They are represented by the opaque type `Address`, which describes exactly what a Solana address actually is.\n\nConsequently, that means no more `PublicKey`.\n\nHere’s what they look like in development:\n\n```ts\nimport { Address, address, getAddressFromPublicKey, generateKeyPair } from '@solana/kit';\n\n// Coerce a string to an `Address`\nconst myOtherAddress = address('AxZfZWeqztBCL37Mkjkd4b8Hf6J13WCcfozrBY6vZzv3');\n\n// Typecast it instead\nconst myAddress =\n 'AxZfZWeqztBCL37Mkjkd4b8Hf6J13WCcfozrBY6vZzv3' as Address<'AxZfZWeqztBCL37Mkjkd4b8Hf6J13WCcfozrBY6vZzv3'>;\n\n// From CryptoKey\nconst keyPair = await generateKeyPair();\nconst myPublicKeyAsAddress = await getAddressFromPublicKey(keyPair.publicKey);\n```\n\nSome tooling for working with base58-encoded addresses can be found in the `@solana/addresses` package.\n\n## Transactions\n\n### Creating Transaction Messages\n\nLike many other familiar aspects of the 1.0 library, transactions have received a makeover.\n\nFor starters, all transaction messages are now version-aware, so there’s no longer a need to juggle two different types (eg. `Transaction` vs. `VersionedTransaction`).\n\nAddress lookups are now completely described inside transaction message instructions, so you don’t have to materialize `addressTableLookups` anymore.\n\nHere’s a simple example of creating a transaction message – notice how its type is refined at each step of the process:\n\n```ts\nimport {\n address,\n createTransactionMessage,\n setTransactionMessageFeePayer,\n setTransactionMessageLifetimeUsingBlockhash,\n Blockhash,\n} from '@solana/kit';\n\nconst recentBlockhash = {\n blockhash: '4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY' as Blockhash,\n lastValidBlockHeight: 196055492n,\n};\nconst feePayer = address('AxZfZWeqztBCL37Mkjkd4b8Hf6J13WCcfozrBY6vZzv3');\n\n// Create a new transaction message\nconst transactionMessage = createTransactionMessage({ version: 0 });\n// ^? V0TransactionMessage\n\n// Set the fee payer\nconst transactionMessageWithFeePayer = setTransactionMessageFeePayer(feePayer, transactionMessage);\n// ^? V0TransactionMessage & TransactionMessageWithFeePayer\n\nconst transactionMessageWithFeePayerAndLifetime = setTransactionMessageLifetimeUsingBlockhash(\n // ^? V0TransactionMessage & TransactionMessageWithFeePayer & TransactionMessageWithBlockhashLifetime\n recentBlockhash,\n transactionMessageWithFeePayer,\n);\n```\n\nAs you can see, each time a transaction message is modified, the type reflects its new shape. If you add a fee payer, you’ll get a type representing a transaction message with a fee payer, and so on.\n\nTransaction message objects are also **frozen by these functions** to prevent them from being mutated in place.\n\n### Signing Transaction Messages\n\nThe `signTransaction(..)` function will raise a type error if your transaction message is not already equipped with a fee payer and a lifetime. This helps you catch errors at author-time instead of runtime.\n\n```ts\nconst feePayer = await generateKeyPair();\nconst feePayerAddress = await getAddressFromPublicKey(feePayer.publicKey);\n\nconst transactionMessage = createTransactionMessage({ version: 'legacy' });\nconst transactionMessageWithFeePayer = setTransactionMessageFeePayer(feePayerAddress, transactionMessage);\n\n// Attempting to sign the transaction message without a lifetime will throw a type error\nconst signedTransaction = await signTransaction([signer], transactionMessageWithFeePayer);\n// => \"Property 'lifetimeConstraint' is missing in type\"\n```\n\n### Calibrating a Transaction Message's Compute Unit Budget\n\nCorrectly budgeting a compute unit limit for your transaction message can increase the probability that your transaction will be accepted for processing. If you don't declare a compute unit limit on your transaction, validators will assume an upper limit of 200K compute units (CU) per instruction.\n\nSince validators have an incentive to pack as many transactions into each block as possible, they may choose to include transactions that they know will fit into the remaining compute budget for the current block over transactions that might not. For this reason, you should set a compute unit limit on each of your transaction messages, whenever possible.\n\nUse these utilities to estimate the actual compute unit cost of a given transaction message and set it on the message.\n\n```ts\nimport { createSolanaRpc, estimateComputeUnitLimitFactory, setTransactionMessageComputeUnitLimit } from '@solana/kit';\n\n// Create an estimator function.\nconst rpc = createSolanaRpc('http://127.0.0.1:8899');\nconst estimateComputeUnitLimit = estimateComputeUnitLimitFactory({ rpc });\n\n// Create your transaction message.\nconst transactionMessage = pipe(\n createTransactionMessage({ version: 'legacy' }),\n /* ... */\n);\n\n// Request an estimate of the actual compute units this message will consume.\nconst computeUnitsEstimate = await estimateComputeUnitLimit(transactionMessage);\n\n// Set the transaction message's compute unit budget.\nconst transactionMessageWithComputeUnitLimit = setTransactionMessageComputeUnitLimit(\n computeUnitsEstimate,\n transactionMessage,\n);\n```\n\n> [!NOTE]\n> For legacy and v0 transactions, if the transaction message does not already have a `SetComputeUnitLimit` instruction, the estimator will add one before simulation. This ensures that the compute unit consumption of the instruction itself is included in the estimate.\n\nAlternatively, use `estimateAndSetComputeUnitLimitFactory` to estimate and set the compute unit limit in a single step. Pair it with `fillTransactionMessageProvisoryComputeUnitLimit` during transaction construction to reserve space for the limit that will later be estimated.\n\n```ts\nimport {\n estimateAndSetComputeUnitLimitFactory,\n estimateComputeUnitLimitFactory,\n fillTransactionMessageProvisoryComputeUnitLimit,\n} from '@solana/kit';\n\n// During construction, reserve space for the compute unit limit.\nconst messageWithProvisoryLimit = fillTransactionMessageProvisoryComputeUnitLimit(transactionMessage);\n\n// Later, estimate and replace the provisory limit.\nconst estimator = estimateComputeUnitLimitFactory({ rpc });\nconst estimateAndSet = estimateAndSetComputeUnitLimitFactory(estimator);\nconst updatedMessage = await estimateAndSet(messageWithProvisoryLimit);\n```\n\n> [!WARNING]\n> The compute unit estimate is just that – an estimate. The compute unit consumption of the actual transaction might be higher or lower than what was observed in simulation. Unless you are confident that your particular transaction message will consume the same or fewer compute units as was estimated, you might like to augment the estimate by either a fixed number of CUs or a multiplier.\n\n> [!NOTE]\n> If you are preparing an _unsigned_ transaction, destined to be signed and submitted to the network by a wallet, you might like to leave it up to the wallet to determine the compute unit limit. Consider that the wallet might have a more global view of how many compute units certain types of transactions consume, and might be able to make better estimates of an appropriate compute unit budget.\n\n### Helpers For Building Transaction Messages\n\nBuilding transaction messages in this manner might feel different from what you’re used to. Also, we certainly wouldn’t want you to have to bind transformed transaction messages to a new variable at each step, so we have released a functional programming library dubbed `@solana/functional` that lets you build transaction messages in **pipelines**. Here’s how it can be used:\n\n```ts\nimport { pipe } from '@solana/functional';\nimport {\n address,\n createTransactionMessage,\n setTransactionMessageFeePayer,\n setTransactionMessageLifetimeUsingBlockhash,\n Blockhash,\n} from '@solana/kit';\n\n// Use `pipe(..)` to create a pipeline of transaction message transformation operations\nconst transactionMessage = pipe(\n createTransactionMessage({ version: 0 }),\n tx => setTransactionMessageFeePayer(feePayer, tx),\n tx => setTransactionMessageLifetimeUsingBlockhash(recentBlockhash, tx),\n);\n```\n\nNote that `pipe(..)` is general-purpose, so it can be used to pipeline any functional transforms.\n\n## Codecs\n\nWe have taken steps to make it easier to write data (de)serializers, especially as they pertain to Rust datatypes and byte buffers.\n\nSolana’s codecs libraries are broken up into modular components so you only need to import the ones you need. They are:\n\n- `@solana/codecs-core`: The core codecs library for working with codecs serializers and creating custom ones\n- `@solana/codecs-numbers`: Used for serialization of numbers (little-endian and big-endian bytes, etc.)\n- `@solana/codecs-strings`: Used for serialization of strings\n- `@solana/codecs-data-structures`: Codecs and serializers for structs\n- `@solana/options`: Designed to build codecs and serializers for types that mimic Rust’s enums, which can include embedded data within their variants such as values, tuples, and structs\n\nThese packages are included in the main `@solana/kit` library but you may also import them from `@solana/codecs` if you only need the codecs.\n\nHere’s an example of encoding and decoding a custom struct with some strings and numbers:\n\n```ts\nimport { addCodecSizePrefix } from '@solana/codecs-core';\nimport { getStructCodec } from '@solana/codecs-data-structures';\nimport { getU32Codec, getU64Codec, getU8Codec } from '@solana/codecs-numbers';\nimport { getUtf8Codec } from '@solana/codecs-strings';\n\n// Equivalent in Rust:\n// struct {\n// amount: u64,\n// decimals: u8,\n// name: String,\n// }\nconst structCodec = getStructCodec([\n ['amount', getU64Codec()],\n ['decimals', getU8Codec()],\n ['name', addCodecSizePrefix(getUtf8Codec(), getU32Codec())],\n]);\n\nconst myToken = {\n amount: 1000000000000000n, // `bigint` or `number` is supported\n decimals: 2,\n name: 'My Token',\n};\n\nconst myEncodedToken: Uint8Array = structCodec.encode(myToken);\nconst myDecodedToken = structCodec.decode(myEncodedToken);\n\nmyDecodedToken satisfies {\n amount: bigint;\n decimals: number;\n name: string;\n};\n```\n\nYou may only need to encode or decode data, but not both. Importing one or the other allows your optimizing compiler to tree-shake the other implementation away:\n\n```ts\nimport { Codec, combineCodec, Decoder, Encoder, addDecoderSizePrefix, addEncoderSizePrefix } from '@solana/codecs-core';\nimport { getStructDecoder, getStructEncoder } from '@solana/codecs-data-structures';\nimport {\n getU8Decoder,\n getU8Encoder,\n getU32Decoder,\n getU32Encoder,\n getU64Decoder,\n getU64Encoder,\n} from '@solana/codecs-numbers';\nimport { getUtf8Decoder, getUtf8Encoder } from '@solana/codecs-strings';\n\nexport type MyToken = {\n amount: bigint;\n decimals: number;\n name: string;\n};\n\nexport type MyTokenArgs = {\n amount: number | bigint;\n decimals: number;\n name: string;\n};\n\nexport const getMyTokenEncoder = (): Encoder =>\n getStructEncoder([\n ['amount', getU64Encoder()],\n ['decimals', getU8Encoder()],\n ['name', addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],\n ]);\n\nexport const getMyTokenDecoder = (): Decoder =>\n getStructDecoder([\n ['amount', getU64Decoder()],\n ['decimals', getU8Decoder()],\n ['name', addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],\n ]);\n\nexport const getMyTokenCodec = (): Codec =>\n combineCodec(getMyTokenEncoder(), getMyTokenDecoder());\n```\n\nYou can read more about codecs in [the official Codec documentation](https://github.com/anza-xyz/kit/blob/main/packages/codecs/README.md).\n\n## Type-Safety\n\nThe new library makes use of some advanced TypeScript features, including generic types, conditional types, `Parameters<..>`, `ReturnType<..>` and more.\n\nWe’ve described the RPC API in detail so that TypeScript can determine the _exact_ type of the result you will receive from the server given a particular input. Change the type of the input, and you will see the return type reflect that change.\n\n### RPC Types\n\nThe RPC methods – both HTTP and subscriptions – are built with multiple overloads and conditional types. The expected HTTP response payload or subscription message format will be reflected in the return type of the function you’re working with when you provide the inputs in your code.\n\nHere’s an example of this in action:\n\n```ts\n// Provide one set of parameters, get a certain type\n// These parameters resolve to return type:\n// {\n// blockhash: Blockhash;\n// blockHeight: bigint;\n// blockTime: UnixTimestamp;\n// parentSlot: bigint;\n// previousBlockhash: Blockhash;\n// }\nconst blockResponse = await rpc\n .getBlock(0n, {\n rewards: false,\n transactionDetails: 'none',\n })\n .send();\n\n// Switch `rewards` to `true`, get `rewards` in the return type\n// {\n// /* ... Previous response */\n// rewards: Reward[];\n// }\nconst blockWithRewardsResponse = await rpc\n .getBlock(0n, {\n rewards: true,\n transactionDetails: 'none',\n })\n .send();\n\n// Switch `transactionDetails` to `full`, get `transactions` in the return type\n// {\n// /* ... Previous response */\n// transactions: TransactionResponse[];\n// }\nconst blockWithRewardsAndTransactionsResponse = await rpc\n .getBlock(0n, {\n rewards: true,\n transactionDetails: 'full',\n })\n .send();\n```\n\n### Catching Compile-Time Bugs with TypeScript\n\nAs previously mentioned, the type coverage in Kit allows developers to catch common bugs at compile time, rather than runtime.\n\nIn the example below, a transaction message is created and then attempted to be signed without setting the fee payer. This would result in a runtime error from the RPC, but instead you will see a type error from TypeScript as you type:\n\n```ts\nconst transactionMessage = pipe(createTransactionMessage({ version: 0 }), tx =>\n setTransactionMessageLifetimeUsingBlockhash(recentBlockhash, tx),\n);\nconst signedTransaction = await signTransaction([keyPair], transactionMessage); // ERROR: Property 'feePayer' is missing in type\n```\n\nConsider another example where a developer is attempting to send a transaction that has not been fully signed. Again, the TypeScript compiler will throw a type error:\n\n```ts\nconst transactionMessage = pipe(\n createTransactionMessage({ version: 0 }),\n tx => setTransactionMessageFeePayer(feePayerAddress, tx),\n tx => setTransactionMessageLifetimeUsingBlockhash(recentBlockhash, tx),\n);\n\nconst signedTransaction = await signTransaction([], transactionMessage);\n\n// Asserts the transaction is a `FullySignedTransaction`\n// Throws an error if any signatures are missing!\nassertIsFullySignedTransaction(signedTransaction);\n\nawait sendAndConfirmTransaction(signedTransaction);\n```\n\nAre you building a nonce transaction and forgot to make `AdvanceNonce` the first instruction? That’s a type error:\n\n```ts\nconst feePayer = await generateKeyPair();\nconst feePayerAddress = await getAddressFromPublicKey(feePayer.publicKey);\n\nconst notNonceTransactionMessage = pipe(createTransactionMessage({ version: 0 }), tx =>\n setTransactionMessageFeePayer(feePayerAddress, tx),\n);\n\nnotNonceTransactionMessage satisfies TransactionMessageWithDurableNonceLifetime;\n// => Property 'lifetimeConstraint' is missing in type\n\nconst nonceConfig = {\n nonce: 'nonce' as Nonce,\n nonceAccountAddress: address('5tLU66bxQ35so2bReGcyf3GfMMAAauZdNA1N4uRnKQu4'),\n nonceAuthorityAddress: address('GDhj8paPg8woUzp9n8fj7eAMocN5P7Ej3A7T9F5gotTX'),\n};\n\nconst stillNotNonceTransactionMessage = {\n lifetimeConstraint: nonceConfig,\n ...notNonceTransactionMessage,\n};\n\nstillNotNonceTransactionMessage satisfies TransactionMessageWithDurableNonceLifetime;\n// => 'readonly Instruction[]' is not assignable to type 'readonly [AdvanceNonceAccountInstruction, ...Instruction[]]'\n\nconst validNonceTransactionMessage = pipe(\n createTransactionMessage({ version: 0 }),\n tx => setTransactionMessageFeePayer(feePayerAddress, tx),\n tx => setTransactionMessageLifetimeUsingDurableNonce(nonceConfig, tx), // Adds the instruction!\n);\n\nvalidNonceTransactionMessage satisfies TransactionMessageWithDurableNonceLifetime; // OK\n```\n\nThe library’s type-checking can even catch you using lamports instead of SOL for a value:\n\n```ts\nconst airdropAmount = 1n; // SOL\nconst signature = rpc.requestAirdrop(myAddress, airdropAmount).send();\n```\n\nIt will force you to cast the numerical value for your airdrop (or transfer, etc.) amount using `lamports()`, which should be a good reminder!\n\n```ts\nconst airdropAmount = lamports(1000000000n);\nconst signature = rpc.requestAirdrop(myAddress, airdropAmount).send();\n```\n\n## Compatibility Layer\n\nYou will have noticed by now that Kit is a complete and total breaking change from the web3.js 1.x line. We want to provide you with a strategy for interacting with web3.js 1.x APIs while building your application using Kit. You need a tool for converting between web3.js 1.x and Kit data types.\n\nThe `@solana/compat` library allows for interoperability between functions and class objects from the legacy library - such as `VersionedTransaction`, `PublicKey`, and `Keypair` - and functions and types of the new library - such as `Address`, `Transaction`, and `CryptoKeyPair`.\n\nHere’s how you can use `@solana/compat` to convert from a legacy `PublicKey` to an `Address`:\n\n```ts\nimport { fromLegacyPublicKey } from '@solana/compat';\n\nconst publicKey = new PublicKey('B3piXWBQLLRuk56XG5VihxR4oe2PSsDM8nTF6s1DeVF5');\nconst address: Address = fromLegacyPublicKey(publicKey);\n```\n\nHere’s how to convert from a legacy `Keypair` to a `CryptoKeyPair`:\n\n```ts\nimport { fromLegacyKeypair } from '@solana/compat';\n\nconst keypairLegacy = Keypair.generate();\nconst cryptoKeyPair: CryptoKeyPair = fromLegacyKeypair(keypair);\n```\n\nHere’s how to convert legacy transaction objects to the new library’s transaction types:\n\n```ts\n// Note that you can only convert `VersionedTransaction` objects\nconst modernTransaction = fromVersionedTransaction(classicTransaction);\n```\n\nTo see more conversions supported by `@solana/compat`, you can check out the package’s [README on GitHub](https://github.com/anza-xyz/kit/blob/main/packages/compat/README.md).\n\n## Program Clients\n\nWriting JavaScript clients for on-chain programs has been done manually up until now. Without an IDL for some of the native programs, this process has been necessarily manual and has resulted in clients that lag behind the actual capabilities of the programs themselves.\n\nWe think that program clients should be _generated_ rather than written. Developers should be able to write Rust programs, compile the program code, and generate all of the JavaScript client-side code to interact with the program.\n\nWe use [Codama](https://github.com/codama-idl/codama) to represent Solana programs and generate clients for them. This includes a JavaScript client compatible with this library. For instance, here is how you’d construct a transaction message composed of instructions from three different core programs.\n\n```ts\nimport { appendTransactionMessageInstructions, createTransactionMessage, pipe } from '@solana/kit';\nimport { getAddMemoInstruction } from '@solana-program/memo';\nimport { getSetComputeUnitLimitInstruction } from '@solana-program/compute-budget';\nimport { getTransferSolInstruction } from '@solana-program/system';\n\nconst instructions = [\n getSetComputeUnitLimitInstruction({ units: 600_000 }),\n getTransferSolInstruction({ source, destination, amount: 1_000_000_000 }),\n getAddMemoInstruction({ memo: \"I'm transferring some SOL!\" }),\n];\n\n// Creates a V0 transaction message with 3 instructions inside.\nconst transactionMessage = pipe(createTransactionMessage({ version: 0 }), tx =>\n appendTransactionMessageInstructions(instructions, tx),\n);\n```\n\nAs you can see, each program now generates its own library allowing you to cherry-pick your dependencies.\n\nNote that asynchronous versions may be available for some instructions which allows them to resolve more inputs on your behalf — such as PDA derivation. For instance, the `CreateLookupTable` instruction offers an asynchronous builder that derives the `address` account and the `bump` argument for us.\n\n```ts\nconst rpc = createSolanaRpc('http://127.0.0.1:8899');\nconst [authority, recentSlot] = await Promise.all([\n generateKeyPairSigner(),\n rpc.getSlot({ commitment: 'finalized' }).send(),\n]);\n\nconst instruction = await getCreateLookupTableInstructionAsync({\n authority,\n recentSlot,\n});\n```\n\nAlternatively, you may use the synchronous builder if you already have all the required inputs at hand.\n\n```ts\nconst [address, bump] = await findAddressLookupTablePda({\n authority: authority.address,\n recentSlot,\n});\n\nconst instruction = getCreateLookupTableInstruction({\n address,\n authority,\n bump,\n recentSlot,\n});\n```\n\nOn top of instruction builders, these clients offer a variety of utilities such as:\n\n- Instruction codecs — e.g. `getTransferSolInstructionDataCodec`.\n- Account types — e.g. `AddressLookupTable`.\n- Account codecs — e.g. `getAddressLookupTableAccountDataCodec`.\n- Account helpers — e.g. `fetchAddressLookupTable`.\n- PDA helpers — e.g. `findAddressLookupTablePda`, `fetchAddressLookupTableFromSeeds`.\n- Defined types and their codecs — e.g. `NonceState`, `getNonceStateCodec`.\n- Program helpers — e.g. `SYSTEM_PROGRAM_ADDRESS`, `SystemAccount` enum, `identifySystemInstruction`.\n- And much more!\n\nHere’s another example that fetches an `AddressLookupTable` PDA from its seeds.\n\n```ts\nconst account = await fetchAddressLookupTableFromSeeds(rpc, {\n authority: authority.address,\n recentSlot,\n});\n\naccount.address; // Address\naccount.lamports; // Lamports\naccount.data.addresses; // Address[]\naccount.data.authority; // Some
\naccount.data.deactivationSlot; // Slot\naccount.data.lastExtendedSlot; // Slot\naccount.data.lastExtendedSlotStartIndex; // number\n```\n\n### How Does This Work?\n\nAll of this code is 100% auto-generated by Codama from a tree of standardized nodes that represent our programs. It contains obvious nodes such as `AccountNode` but also more specified nodes such as `ConditionalValueNode` that allows us to resolve account or argument default values conditionally.\n\nCodama allows us to hydrate our tree of nodes from IDLs which are typically generated by program frameworks such as [Anchor](https://github.com/coral-xyz/anchor) or [Shank](https://github.com/metaplex-foundation/shank). Additionally, visitors can be used on our nodes to expand the knowledge of our programs since the IDL itself doesn’t yet contain that level of information. Finally, special visitors called ‘renderers’ visit our tree to generate clients such as this JavaScript client.\n\nCurrently, there is one other renderer that generates Rust clients but this is only the beginning. In the future, you can expect renderers for auto-generated Python clients, documentation, CLIs, etc.\n\n## Create Solana Program\n\nWe believe the whole ecosystem could benefit from generated program clients. That’s why we introduced a new NPM binary that allows you to create your Solana program — and generate clients for it — in no time. Simply run the following and follow the prompts to get started.\n\n```sh\npnpm create solana-program\n```\n\nThis [`create-solana-program`](https://github.com/solana-program/create-solana-program) installer will create a new repository including:\n\n- An example program using the framework of your choice (Anchor coming soon).\n- Generated clients for any of the selected clients.\n- A set of scripts that allows you to:\n - Start a local validator including all programs and accounts you depend on.\n - Build, lint and test your programs.\n - Generate IDLs from your programs.\n - Generate clients from the generated IDLs.\n - Build and test each of your clients.\n- GitHub Actions pipelines to test your program, test your clients, and even manually publish new packages or crates for your clients. (Coming soon).\n\nWhen selecting the JavaScript client, you will get a fully generated library compatible with Kit much like the `@solana-program` packages showcased above.\n\n## GraphQL\n\nThough not directly related to web3.js, we wanted to hijack your attention to show you something else that we’re working on, of particular interest to frontend developers. It’s a new API for interacting with the RPC: a GraphQL API.\n\nThe `@solana/rpc-graphql` package can be used to make GraphQL queries to Solana RPC endpoints, using the same transports described above (including any customizations).\n\nHere’s an example of retrieving account data with GraphQL:\n\n```ts\nconst source = `\n query myQuery($address: String!) {\n account(address: $address) {\n dataBase58: data(encoding: BASE_58)\n dataBase64: data(encoding: BASE_64)\n lamports\n }\n }\n`;\n\nconst variableValues = {\n address: 'AyGCwnwxQMCqaU4ixReHt8h5W4dwmxU7eM3BEQBdWVca',\n};\n\nconst result = await rpcGraphQL.query(source, variableValues);\n\nexpect(result).toMatchObject({\n data: {\n account: {\n dataBase58: '2Uw1bpnsXxu3e',\n dataBase64: 'dGVzdCBkYXRh',\n lamports: 10290815n,\n },\n },\n});\n```\n\nUsing GraphQL allows developers to only specify which fields they _actually_ need, and do away with the rest of the response.\n\nHowever, GraphQL is also extremely powerful for **nesting queries**, which can be particularly useful if you want to, say, get the **sum** of every lamports balance of every **owner of the owner** of each token account, while discarding any mint accounts.\n\n```ts\nconst source = `\n query getLamportsOfOwnersOfOwnersOfTokenAccounts {\n programAccounts(programAddress: \"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA\") {\n ... on TokenAccount {\n owner {\n ownerProgram {\n lamports\n }\n }\n }\n }\n }\n`;\n\nconst result = await rpcGraphQL.query(source);\n\nconst sumOfAllLamportsOfOwnersOfOwnersOfTokenAccounts = result\n .map(o => o.account.owner.ownerProgram.lamports)\n .reduce((acc, lamports) => acc + lamports, 0);\n```\n\nThe new GraphQL package supports this same style of nested querying on transactions and blocks.\n\n```ts\nconst source = `\n query myQuery($signature: String!, $commitment: Commitment) {\n transaction(signature: $signature, commitment: $commitment) {\n message {\n instructions {\n ... on CreateAccountInstruction {\n lamports\n programId\n space\n }\n }\n }\n }\n }\n`;\n\nconst variableValues = {\n signature: '63zkpxATgAwXRGFQZPDESTw2m4uZQ99sX338ibgKtTcgG6v34E3MSS3zckCwJHrimS71cvei6h1Bn1K1De53BNWC',\n commitment: 'confirmed',\n};\n\nconst result = await rpcGraphQL.query(source, variableValues);\n\nexpect(result).toMatchObject({\n data: {\n transaction: {\n message: {\n instructions: expect.arrayContaining([\n {\n lamports: expect.any(BigInt),\n programId: '11111111111111111111111111111111',\n space: expect.any(BigInt),\n },\n ]),\n },\n },\n },\n});\n```\n\nSee more in the package’s [README on GitHub](https://github.com/anza-xyz/kit/tree/main/packages/rpc-graphql).\n\n## Development\n\nYou can see all development of this library and associated GraphQL tooling in the Kit repository on GitHub.\n\n- https://github.com/anza-xyz/kit\n\nYou can follow along with program client generator development in the `@solana-program` org and the `@codama-idl/codama` repository.\n\n- https://github.com/solana-program/\n- https://github.com/codama-idl/codama\n\nSolana Labs develops these tools in public, as open source. We encourage any and all developers who would like to work on these tools to contribute to the codebase.\n\n## Thank you\n\nWe’re grateful that you have read this far. If you are interested in migrating an existing application to Kit to take advantage of some of the benefits we’ve demonstrated, we want to give you some direct support. Reach out to [@steveluscher](https://t.me/steveluscher/) on Telegram to start a conversation.\n" }, { "path": "SECURITY.md", "content": "# Security Policy\n\n1. [Reporting security problems](#reporting)\n2. [Incident Response Process](#process)\n\n\n\n## Reporting security problems in the Solana JavaScript SDK\n\n**DO NOT CREATE A GITHUB ISSUE** to report a security problem.\n\nInstead please use this [Report a Vulnerability](https://github.com/anza-xyz/kit/security/advisories/new) link. Provide a helpful title, detailed description of the vulnerability and an exploit proof-of-concept. Speculative submissions without proof-of-concept will be closed with no further consideration.\n\nIf you haven't done so already, please **enable two-factor auth** in your GitHub account.\n\n--\n\nIf you do not receive a response in the advisory, send an email to security@anza.xyz with the full URL of the advisory you have created. DO NOT include attachments or provide detail sufficient for exploitation regarding the security issue in this email. **Only provide such details in the advisory**.\n\nIf you do not receive a response from security@anza.xyz please follow up with the team directly. You can do this in the `#js` channel of the [Solana Tech discord server](https://solana.com/discord), by pinging the `Anza` role in the channel and referencing the fact that you submitted a security problem.\n\n\n\n## Incident Response Process\n\nIn case an incident is discovered or reported, the following process will be followed to contain, respond and remediate:\n\n### 1. Accept the new report\n\nIn response to a newly reported security problem, a member of the `anza-xyz/core-contributors` group will accept the report to turn it into a draft advisory. The `anza-xyz/security-incident-response` group should be added to the draft security advisory, and create a private fork of the repository (grey button towards the bottom of the page) if necessary.\n\nIf the advisory is the result of an audit finding, follow the same process as above but add the auditor's github user(s) and begin the title with \"[Audit]\".\n\nIf the report is out of scope, a member of the `anza-xyz/core-contributors` group will comment as such and then close the report.\n\n### 2. Triage\n\nWithin the draft security advisory, discuss and determine the severity of the issue. If necessary, members of the `anza-xyz/security-incident-response` group may add other github users to the advisory to assist. If it is determined that this is not a critical issue then the advisory should be closed and if more follow-up is required a normal Solana public github issue should be created.\n\n### 3. Prepare Fixes\n\nPrepare a fix for the issue and push them to `main` in the private repository associated with the draft security advisory. There is no CI available in the private repository so you must build from source and manually verify fixes. Code review from the reporter is ideal, as well as from multiple members of the core development team.\n\n### 4. Ship the patch\n\nOnce the fix is accepted, a member of the anza-xyz/security-incident-response group should prepare a patch using [`pnpm patch`](https://pnpm.io/cli/patch), [`yarn patch`](https://yarnpkg.com/cli/patch), and [`patch-package`](https://www.npmjs.com/package/patch-package) for developers still using `npm`. Post the patch to an unlisted [GitHub Gist](https://gist.github.com) and disseminate patch instructions privately to as many vulnerable applications as possible.\n\n### 5. Public Disclosure and Release\n\nOnce the fix has been deployed to as large an affected application set as practical, the patches from the security advisory may be merged into the main source repository. A new official release should be shipped, and old affected releases deprecated on NPM using the `npm deprecate` command.\n" }, { "path": "docs/.eslintrc.json", "content": "{\n \"extends\": [\"next/core-web-vitals\", \"next/typescript\"]\n}\n" }, { "path": "docs/.gitignore", "content": "# deps\n/node_modules\n\n# generated content\n.contentlayer\n.content-collections\n.source\n\n# test & build\n/coverage\n/.next/\n/out/\n/build\n*.tsbuildinfo\n\n# misc\n.DS_Store\n*.pem\n/.pnp\n.pnp.js\nnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\n\n# others\n.env*.local\n.vercel\nnext-env.d.ts\n" }, { "path": "docs/.npmrc", "content": "enable-pre-post-scripts = true\n" }, { "path": "docs/.prettierignore", "content": "pnpm-lock.yaml\ncontent/api/" }, { "path": "docs/README.md", "content": "# Kit documentation\n\nDocumentation website for Kit, built with [Fumadocs](https://github.com/fuma-nama/fumadocs).\n\n## Install dependencies\n\nInstall using the `--ignore-workspace` flag to ensure the dependencies of the documentation website are separate from the library dependencies.\n\n```bash\npnpm install --ignore-workspace\n```\n\n## Download necessary environment variables (employees only)\n\n```bash\npnpm vercel link -p kit-docs -S anza-tech --yes\npnpm vercel env pull --environment=development\n```\n\n## Run development server\n\n```bash\npnpm dev\n```\n\nOpen http://localhost:3000 with your browser to see the result.\n\n## Learn more\n\nTo learn more about Next.js and Fumadocs, take a look at the following\nresources:\n\n- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js\n features and API.\n- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.\n- [Fumadocs](https://fumadocs.vercel.app) - learn about Fumadocs\n" }, { "path": "docs/build-api-docs.sh", "content": "#!/usr/bin/env bash\nset -euo pipefail\n\ncd ..\npnpm turbo compile:docs --output-logs=hash-only\n\n# Move generated docs.\necho \"➡️ Moving generated TypeDoc files to docs/content/api...\"\nAPI_DIR=\"$(pwd)/docs/content/api\"\nfind $API_DIR -mindepth 1 -maxdepth 1 -type d -exec rm -rf {} +\nmkdir -p \"$API_DIR\"\n\nfor DOC_PATH in packages/*/.docs; do\n (cd \"$DOC_PATH\" && find . -type f ! -name \"index.mdx\" | while read -r file; do\n mkdir -p \"$API_DIR/$(dirname \"$file\")\"\n cp \"$file\" \"$API_DIR/$file\"\n done)\ndone\n\n# Generate API index.\necho \"📝 Generating API index page from TypeDoc JSON...\"\nnode docs/build-api-index.js\n\n# Regenerate .source to pick up the new index.mdx\necho \"♻️ Regenerating .source files...\"\ncd docs\npnpm fumadocs-mdx\n" }, { "path": "docs/build-api-index.js", "content": "#!/usr/bin/env node\n\n/**\n * Generate API index page using TypeDoc JSON output\n * This script uses TypeDoc's JSON output to get detailed reflection data\n */\n\nconst fs = require('node:fs/promises');\nconst path = require('node:path');\nconst { execFile } = require('node:child_process');\nconst { promisify } = require('node:util');\n\nconst execFileAsync = promisify(execFile);\n\nasync function exists(path) {\n try {\n await fs.access(path);\n return true;\n } catch {\n return false;\n }\n}\n\nconst ROOT_DIR = path.join(__dirname, '..');\nconst PACKAGES_DIR = path.join(ROOT_DIR, 'packages');\nconst OUTPUT_FILE = path.join(ROOT_DIR, 'docs', 'content', 'api', 'index.mdx');\n\n// TypeDoc reflection kinds (from TypeDoc source)\nconst ReflectionKind = {\n Project: 1,\n Module: 2,\n Namespace: 4,\n Enum: 8,\n EnumMember: 16,\n Variable: 32,\n Function: 64,\n Class: 128,\n Interface: 256,\n Constructor: 512,\n Property: 1024,\n Method: 2048,\n CallSignature: 4096,\n IndexSignature: 8192,\n ConstructorSignature: 16384,\n Parameter: 32768,\n TypeLiteral: 65536,\n TypeParameter: 131072,\n Accessor: 262144,\n GetSignature: 524288,\n SetSignature: 1048576,\n ObjectLiteral: 2097152,\n TypeAlias: 4194304,\n Reference: 8388608,\n};\n\nconst API_GROUP_ORDER = ['Classes', 'Enums', 'Types', 'Functions', 'Variables'];\nconst REFLECTION_KIND_DATA = {\n [ReflectionKind.Class]: { group: 'Classes', path: 'classes' },\n [ReflectionKind.Interface]: { group: 'Types', path: 'interfaces' },\n [ReflectionKind.ObjectLiteral]: { group: 'Types', path: 'type-aliases' },\n [ReflectionKind.TypeAlias]: { group: 'Types', path: 'type-aliases' },\n [ReflectionKind.Function]: { group: 'Functions', path: 'functions' },\n [ReflectionKind.Enum]: { group: 'Enums', path: 'enumerations' },\n [ReflectionKind.Variable]: { group: 'Variables', path: 'variables' },\n};\n\nasync function findPackageInfos() {\n const packages = [];\n const packageDirs = await fs.readdir(PACKAGES_DIR);\n\n for (const packageName of packageDirs) {\n const packagePath = path.join(PACKAGES_DIR, packageName);\n const packageJsonPath = path.join(packagePath, 'package.json');\n const srcPath = path.join(packagePath, 'src');\n const indexPath = path.join(srcPath, 'index.ts');\n const typedocConfigPath = path.join(packagePath, 'typedoc.json');\n\n // Skip packages without source, package.json, or typedoc config.\n const artifactsExistence = await Promise.all([\n exists(packageJsonPath),\n exists(srcPath),\n exists(indexPath),\n exists(typedocConfigPath),\n ]);\n if (artifactsExistence.includes(false)) {\n continue;\n }\n\n const pkg = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));\n packages.push({ name: pkg.name, path: packagePath });\n }\n\n return packages.sort((a, b) => a.name.localeCompare(b.name));\n}\n\nasync function generateTypeDocJSON(packageInfo) {\n const { path: packagePath, name } = packageInfo;\n const jsonOutputPath = path.join(packagePath, 'typedoc-output.json');\n\n try {\n // Generate JSON output only (suppress regular output).\n await execFileAsync(\n './node_modules/typedoc/bin/typedoc',\n [\n '--json',\n jsonOutputPath,\n '--tsconfig',\n path.join(packagePath, 'tsconfig.json'),\n '--out',\n '/dev/null',\n '--excludePrivate',\n '--excludeProtected',\n '--excludeInternal',\n path.join(packagePath, 'src', 'index.ts'),\n ],\n { cwd: ROOT_DIR },\n );\n\n if (!(await exists(jsonOutputPath))) {\n console.warn(`⚠️ No JSON output generated for ${name}`);\n return null;\n }\n\n const typeDocJSON = JSON.parse(await fs.readFile(jsonOutputPath, 'utf8'));\n\n // Clean up the temp JSON file\n await fs.unlink(jsonOutputPath);\n\n return typeDocJSON;\n } catch (error) {\n console.error(`❌ Failed to generate JSON for ${name}:`, error.message);\n return null;\n }\n}\n\nfunction processTypeDocJSON(packageInfo, typeDocJSON) {\n const exports = [];\n const dependencies = new Set([]);\n\n if (!typeDocJSON || !typeDocJSON.children) {\n return { ...packageInfo, dependencies, exports };\n }\n\n function processChildren(children) {\n for (const child of children) {\n // Only include relevant kinds in the exports.\n if (REFLECTION_KIND_DATA[child.kind]) {\n const fromPackage = typeDocJSON.symbolIdMap[child.id]?.packageName || typeDocJSON.packageName;\n const isDependency = fromPackage !== typeDocJSON.packageName;\n if (isDependency) {\n dependencies.add(fromPackage);\n } else {\n exports.push({ name: child.name, kind: child.kind });\n }\n }\n\n // Recursively process nested children.\n if (child.children) {\n processChildren(child.children);\n }\n }\n }\n\n processChildren(typeDocJSON.children);\n return { ...packageInfo, dependencies, exports };\n}\n\nfunction generateIndexContent(packages) {\n const totalPackages = packages.length;\n\n let content = `---\ntitle: API Reference\ndescription: Explore packages, functions, types, and more\n---\n\nWelcome to the Solana Kit API Reference! It covers a total of **${totalPackages} packages** most of which are available via the main \\`@solana/kit\\` package.\n\n\n## Need Help?\n\n- Check out our [Getting Started guide](/docs/getting-started/).\n- Learn about key concepts in our [Advanced Guides](/docs/advanced-guides/).\n\n## All Packages\n\n`;\n\n // Sort packages by name but with `@solana/kit` first.\n const sortedPackages = packages.sort((a, b) => {\n if (a.name === '@solana/kit') return -1;\n if (b.name === '@solana/kit') return 1;\n return a.name.localeCompare(b.name);\n });\n\n // Generate entries for each package alphabetically.\n for (const package of sortedPackages) {\n content += `### \\`${package.name}\\`\\n\\n`;\n\n // List exported dependencies.\n if (package.dependencies.size > 0) {\n const dependencies = [...package.dependencies].sort((a, b) => a.localeCompare(b));\n const title = `Packages (${dependencies.length})`;\n content += `${wrapApiGroupTitle(title)}\\n\\n`;\n\n const links = dependencies.map(dependency => `[${dependency}](#${dependency.replace(/(@|\\/)/g, '')})`);\n content += `${wrapLinks(links, dependencies)}\\n\\n`;\n }\n\n // Sort exports into type groups.\n const apiGroups = Object.fromEntries(API_GROUP_ORDER.map(group => [group, { title: group, items: [] }]));\n for (const item of package.exports) {\n if (item.kind && REFLECTION_KIND_DATA[item.kind]) {\n const data = REFLECTION_KIND_DATA[item.kind];\n if (apiGroups[data.group]) {\n apiGroups[data.group].items.push({ ...item, path: data.path });\n }\n }\n }\n\n // Generate sections for each type.\n for (const group of Object.values(apiGroups)) {\n if (group.items.length > 0) {\n const title = `${group.title} (${group.items.length})`;\n content += `${wrapApiGroupTitle(title)}\\n\\n`;\n\n // List items with links.\n const links = group.items\n .sort((a, b) => a.name.localeCompare(b.name))\n .map(item => `[${item.name}](/api/${item.path}/${item.name})`);\n\n // Wrap links in columns when possible.\n const names = group.items.map(item => item.name);\n content += `${wrapLinks(links, names)}\\n\\n`;\n }\n }\n }\n\n content += `\n This documentation is automatically generated from the source code using TypeDoc.\n`;\n\n return content;\n}\n\nfunction wrapApiGroupTitle(content) {\n return `

${content}

`;\n}\n\nfunction wrapLinks(links, names) {\n const maxNameLength = Math.max(...names.map(name => name.length));\n let linkWrapper = content => content;\n if (maxNameLength <= 30) {\n linkWrapper = content => `
\\n\\n${content}\\n\\n
`;\n } else if (maxNameLength <= 60) {\n linkWrapper = content => `
\\n\\n${content}\\n\\n
`;\n }\n\n return linkWrapper(links.join(' \\\\\\n'));\n}\n\n// Main execution\nasync function main() {\n const packageInfos = await findPackageInfos();\n\n const packages = [];\n await Promise.all(\n packageInfos.map(async packageInfo => {\n const typeDocJSON = await generateTypeDocJSON(packageInfo);\n const package = await processTypeDocJSON(packageInfo, typeDocJSON);\n packages.push(package);\n }),\n );\n\n const content = generateIndexContent(packages);\n await fs.writeFile(OUTPUT_FILE, content, 'utf8');\n\n console.log('✅ API index generated successfully!');\n console.log(`├─ Packages: ${packages.length}`);\n console.log(`└─ Output: ${OUTPUT_FILE}`);\n}\n\nif (require.main === module) {\n main().catch(console.error);\n}\n" }, { "path": "docs/cli.json", "content": "{\n \"$schema\": \"node_modules/@fumadocs/cli/dist/schema/src.json\",\n \"aliases\": {\n \"uiDir\": \"./components/ui\",\n \"componentsDir\": \"./components\",\n \"blockDir\": \"./components\",\n \"cssDir\": \"./styles\",\n \"libDir\": \"./lib\"\n },\n \"baseDir\": \"src\",\n \"uiLibrary\": \"radix-ui\",\n \"commands\": {}\n}" }, { "path": "docs/content/.prettierrc", "content": "{\n \"$schema\": \"https://json.schemastore.org/prettierrc\",\n \"tabWidth\": 4,\n \"singleQuote\": true,\n \"printWidth\": 100\n}\n" }, { "path": "docs/content/docs/advanced-guides/codecs.mdx", "content": "---\ntitle: Codecs\ndescription: Encode and decode anything\n---\n\n## Introduction\n\nKit includes a powerful serialisation system called Codecs. Whether you're working with account data, instruction arguments, or custom binary layouts, Codecs give you the tools to transform structured data into bytes — and back again.\n\nCodecs are composable, type-safe, and environment-agnostic. They are designed to provide a flexible and consistent foundation for handling binary data across the Solana stack.\n\n## Installation\n\nCodecs are **included within the `@solana/kit` library** but you may also install them using their standalone package.\n\n```package-install\n@solana/codecs\n```\n\nNote that the `@solana/codecs` package itself is composed of several smaller packages, each providing a different set of codec helpers. Here's the list of all packages containing codecs, should you need to install them individually:\n\n| Package | Description |\n| ------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------- |\n| [`@solana/kit`](https://www.npmjs.com/package/@solana/kit) | Includes `@solana/codecs`. |\n| [`@solana/codecs`](https://www.npmjs.com/package/@solana/codecs) | Includes all codecs packages below. |\n| [`@solana/codecs-core`](https://www.npmjs.com/package/@solana/codecs-core) | Core types and utilities for building codecs. |\n| [`@solana/codecs-numbers`](https://www.npmjs.com/package/@solana/codecs-numbers) | Codecs for numbers of various sizes and characteristics. |\n| [`@solana/codecs-strings`](https://www.npmjs.com/package/@solana/codecs-strings) | Codecs for strings of various encodings and size strategies. |\n| [`@solana/codecs-data-structures`](https://www.npmjs.com/package/@solana/codecs-data-structures) | Codecs for a variety of data structures such as objects, enums, arrays, maps, etc. |\n| [`@solana/options`](https://www.npmjs.com/package/@solana/options) | Codecs for Rust-like `Options` in JavaScript. |\n\n## What is a Codec?\n\nA Codec is an object that knows how to encode a any type into a `Uint8Array` and how to decode a `Uint8Array` back into that value.\n\nNo matter which serialization strategy we use, Codecs abstract away its implementation and offer a simple encode and decode interface. They are also highly composable, allowing us to build complex data structures from simple building blocks.\n\nHere's a quick example that encodes and decodes a simple `Person` type.\n\n```ts twoslash\nimport {\n Codec,\n addCodecSizePrefix,\n getUtf8Codec,\n getU32Codec,\n getStructCodec,\n ReadonlyUint8Array,\n} from '@solana/kit';\n// ---cut-before---\n// Use composable codecs to build complex data structures.\ntype Person = { name: string; age: number };\nconst getPersonCodec = (): Codec =>\n getStructCodec([\n ['name', addCodecSizePrefix(getUtf8Codec(), getU32Codec())],\n ['age', getU32Codec()],\n ]);\n\n// Use your own codecs to encode and decode data.\nconst personCodec = getPersonCodec();\nconst encodedPerson = personCodec.encode({ name: 'John', age: 42 });\nconst decodedPerson = personCodec.decode(encodedPerson);\n```\n\n## Composing codecs\n\nThe easiest way to create your own codecs is to compose the [various codecs](#available-codecs) at your disposal.\n\nFor instance, consider the following codecs available:\n\n- `getStructCodec`: Creates a codec for objects with named fields.\n- `getU32Codec`: Creates a codec for unsigned 32-bit integers.\n- `getUtf8Codec`: Creates a codec for UTF-8 strings.\n- `addCodecSizePrefix`: Creates a codec that prefixes the encoded data with its length.\n- `getBooleanCodec`: Creates a codec for booleans using a single byte.\n\nBy combining them together we can create a custom codec for the following `Person` type.\n\n```ts twoslash\nimport {\n Codec,\n addCodecSizePrefix,\n getUtf8Codec,\n getU32Codec,\n getStructCodec,\n getBooleanCodec,\n} from '@solana/kit';\n// ---cut-before---\ntype Person = {\n name: string;\n age: number;\n verified: boolean;\n};\n\nconst getPersonCodec = (): Codec =>\n getStructCodec([\n ['name', addCodecSizePrefix(getUtf8Codec(), getU32Codec())],\n ['age', getU32Codec()],\n ['verified', getBooleanCodec()],\n ]);\n```\n\nThis function returns a `Codec` object which contains both an `encode` and `decode` function that can be used to convert a `Person` type to and from a `Uint8Array`.\n\n```ts twoslash\nimport {\n Codec,\n addCodecSizePrefix,\n getUtf8Codec,\n getU32Codec,\n getStructCodec,\n getBooleanCodec,\n} from '@solana/kit';\ntype Person = { name: string; age: number; verified: boolean };\nconst getPersonCodec = (): Codec =>\n getStructCodec([\n ['name', addCodecSizePrefix(getUtf8Codec(), getU32Codec())],\n ['age', getU32Codec()],\n ['verified', getBooleanCodec()],\n ]);\n// ---cut-before---\nconst personCodec = getPersonCodec();\nconst bytes = personCodec.encode({ name: 'John', age: 42, verified: true });\nconst person = personCodec.decode(bytes);\n```\n\nThere is a significant library of composable codecs at your disposal, enabling you to compose complex types. Check out the [available codecs](#available-codecs) section for more information. If you need a custom codec that cannot be composed from existing ones, you can always create your own as we will see in the [\"Creating custom codecs\"](#creating-custom-codecs) section below.\n\n## Separate encoders and decoders\n\nWhilst Codecs can both encode and decode, it is possible to only focus on encoding or decoding data, enabling the unused logic to be tree-shaken. For instance, here's our previous example using Encoders only to encode a `Person` type.\n\n```ts twoslash\nimport {\n Encoder,\n addEncoderSizePrefix,\n getUtf8Encoder,\n getU32Encoder,\n getStructEncoder,\n getBooleanEncoder,\n} from '@solana/kit';\ntype Person = { name: string; age: number; verified: boolean };\n// ---cut-before---\nconst getPersonEncoder = (): Encoder =>\n getStructEncoder([\n ['name', addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],\n ['age', getU32Encoder()],\n ['verified', getBooleanEncoder()],\n ]);\n\nconst bytes = getPersonEncoder().encode({ name: 'John', age: 42, verified: true });\n```\n\nThe same can be done for decoding the `Person` type by using Decoders like so.\n\n```ts twoslash\nimport {\n Decoder,\n addDecoderSizePrefix,\n getUtf8Decoder,\n getU32Decoder,\n getStructDecoder,\n getBooleanDecoder,\n} from '@solana/kit';\ntype Person = { name: string; age: number; verified: boolean };\nconst bytes = null as unknown as Uint8Array;\n// ---cut-before---\nconst getPersonDecoder = (): Decoder =>\n getStructDecoder([\n ['name', addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],\n ['age', getU32Decoder()],\n ['verified', getBooleanDecoder()],\n ]);\n\nconst person = getPersonDecoder().decode(bytes);\n```\n\n## Combining encoders and decoders\n\nSeparating Codecs into Encoders and Decoders is particularly good practice for library maintainers as it allows their users to tree-shake any of the encoders and/or decoders they don't need. However, we may still want to offer a codec helper for users who need both for convenience.\n\nThat's why this library offers a `combineCodec` helper that creates a `Codec` instance from a matching `Encoder` and `Decoder`.\n\n```ts twoslash\nimport { Codec, Encoder, Decoder, combineCodec } from '@solana/kit';\ntype Person = { name: string; age: number; verified: boolean };\nconst getPersonEncoder = null as unknown as () => Encoder;\nconst getPersonDecoder = null as unknown as () => Decoder;\n// ---cut-before---\nconst getPersonCodec = (): Codec => combineCodec(getPersonEncoder(), getPersonDecoder());\n```\n\nThis means library maintainers can offer Encoders, Decoders and Codecs for all their types whilst staying efficient and tree-shakeable. In summary, we recommend the following pattern when creating codecs for library types.\n\n```ts\ntype MyType = /* ... */;\nconst getMyTypeEncoder = (): Encoder => { /* ... */ };\nconst getMyTypeDecoder = (): Decoder => { /* ... */ };\nconst getMyTypeCodec = (): Codec => combineCodec(\n getMyTypeEncoder(),\n getMyTypeDecoder(),\n);\n```\n\n## Different `From` and `To` types\n\nWhen creating codecs, the encoded type is allowed to be looser than the decoded type. A good example of that is the u64 number codec:\n\n```ts twoslash\nimport { Codec, getU64Codec } from '@solana/kit';\n// ---cut-before---\nconst u64Codec: Codec = getU64Codec();\n```\n\nAs you can see, the first type parameter is looser since it accepts numbers or big integers, whereas the second type parameter only accepts big integers. That's because when _encoding_ a u64 number, you may provide either a `bigint` or a `number` for convenience. However, when you decode a u64 number, you will always get a `bigint` because not all u64 values can fit in a JavaScript `number` type.\n\n```ts twoslash\nimport { getU64Codec } from '@solana/kit';\nconst u64Codec = getU64Codec();\n// ---cut-before---\nconst bytes = u64Codec.encode(42);\nconst value = u64Codec.decode(bytes); // BigInt(42)\n```\n\nThis relationship between the type we encode “From” and decode “To” can be generalized in TypeScript as `To extends From`.\n\nHere's another example using an object with default values. You can read more about the [transformCodec](#transform-codec) helper below.\n\n```ts twoslash\nimport {\n Codec,\n Encoder,\n Decoder,\n transformEncoder,\n getStructEncoder,\n getStructDecoder,\n addEncoderSizePrefix,\n addDecoderSizePrefix,\n getUtf8Encoder,\n getUtf8Decoder,\n getU32Encoder,\n getU32Decoder,\n combineCodec,\n} from '@solana/kit';\n// ---cut-before---\ntype Person = { name: string; age: number };\ntype PersonInput = { name: string; age?: number };\n\nconst getPersonEncoder = (): Encoder =>\n transformEncoder(\n getStructEncoder([\n ['name', addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],\n ['age', getU32Encoder()],\n ]),\n (input) => ({ ...input, age: input.age ?? 42 }),\n );\n\nconst getPersonDecoder = (): Decoder =>\n getStructDecoder([\n ['name', addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],\n ['age', getU32Decoder()],\n ]);\n\nconst getPersonCodec = (): Codec =>\n combineCodec(getPersonEncoder(), getPersonDecoder());\n```\n\n## Fixed-size and variable-size codecs\n\nIt is also worth noting that Codecs can either be of fixed size or variable size.\n\n`FixedSizeCodecs` have a `fixedSize` number attribute that tells us exactly how big their encoded data is in bytes.\n\n```ts twoslash\nimport { FixedSizeCodec, getU32Codec } from '@solana/kit';\n// ---cut-before---\nconst myCodec = getU32Codec();\nmyCodec satisfies FixedSizeCodec;\nmyCodec.fixedSize; // 4 bytes.\n```\n\nOn the other hand, `VariableSizeCodecs` do not know the size of their encoded data in advance. Instead, they will grab that information either from the provided encoded data or from the value to encode. For the former, we can simply access the length of the `Uint8Array`. For the latter, it provides a `getSizeFromValue` that tells us the encoded byte size of the provided value.\n\n```ts twoslash\nimport { VariableSizeCodec, getUtf8Codec, getU32Codec, addCodecSizePrefix } from '@solana/kit';\n// ---cut-before---\nconst myCodec = addCodecSizePrefix(getUtf8Codec(), getU32Codec());\nmyCodec satisfies VariableSizeCodec;\nmyCodec.getSizeFromValue('hello world'); // 4 + 11 bytes.\n```\n\nAlso note that, if the `VariableSizeCodec` is bounded by a maximum size, it can be provided as a `maxSize` number attribute.\n\nThe following type guards are available to identify and/or assert the size of codecs: `isFixedSize`, `isVariableSize`, `assertIsFixedSize` and `assertIsVariableSize`.\n\nFinally, note that the same is true for `Encoders` and `Decoders`.\n\n- A `FixedSizeEncoder` has a `fixedSize` number attribute.\n- A `VariableSizeEncoder` has a `getSizeFromValue` function and an optional `maxSize` number attribute.\n- A `FixedSizeDecoder` has a `fixedSize` number attribute.\n- A `VariableSizeDecoder` has an optional `maxSize` number attribute.\n\n## Creating custom codecs\n\nIf composing codecs isn't enough for you, you may implement your own codec logic by using the `createCodec` function. This function requires an object with a `read` and a `write` function telling us how to read from and write to an existing byte array.\n\nThe `read` function accepts the `bytes` to decode from and the `offset` at each we should start reading. It returns an array with two items:\n\n- The first item should be the decoded value.\n- The second item should be the next offset to read from.\n\n```ts twoslash\nimport { createCodec, Offset } from '@solana/kit';\nconst write = null as unknown as Parameters>[0]['write'];\nconst fixedSize = null as unknown as 1;\n// ---cut-before---\ncreateCodec({\n read(bytes, offset) {\n const value = bytes[offset];\n return [value, offset + 1];\n },\n write,\n fixedSize,\n});\n```\n\nReciprocally, the `write` function accepts the `value` to encode, the array of `bytes` to write the encoded value to and the `offset` at which it should be written. It should encode the given value, insert it in the byte array, and provide the next offset to write to as the return value.\n\n```ts twoslash\nimport { createCodec } from '@solana/kit';\nconst read = null as unknown as Parameters>[0]['read'];\nconst fixedSize = null as unknown as 1;\n// ---cut-before---\ncreateCodec({\n write(value: number, bytes, offset) {\n bytes.set([value], offset);\n return offset + 1;\n },\n read,\n fixedSize,\n});\n```\n\nAdditionally, we must specify the size of the codec. If we are defining a `FixedSizeCodec`, we must simply provide the `fixedSize` number attribute. For `VariableSizeCodecs`, we must provide the `getSizeFromValue` function as described in the previous section.\n\n```ts twoslash\nimport { createCodec } from '@solana/kit';\ntype Config = Parameters>[0];\nconst read = null as unknown as Config['read'];\nconst write = null as unknown as Config['write'];\n// ---cut-before---\n// FixedSizeCodec.\ncreateCodec({\n fixedSize: 1,\n read,\n write,\n});\n\n// VariableSizeCodec.\ncreateCodec({\n getSizeFromValue: (value: string) => value.length,\n read,\n write,\n});\n```\n\nHere's a concrete example of a custom codec that encodes any unsigned integer in a single byte. Since a single byte can only store integers from 0 to 255, if any other integer is provided it will take its modulo 256 to ensure it fits in a single byte. Because it always requires a single byte, that codec is a `FixedSizeCodec` of size `1`.\n\n```ts twoslash\nimport { createCodec } from '@solana/kit';\n\nconst getModuloU8Codec = () =>\n createCodec({\n fixedSize: 1,\n read(bytes, offset) {\n const value = bytes[offset];\n return [value, offset + 1];\n },\n write(value, bytes, offset) {\n bytes.set([value % 256], offset);\n return offset + 1;\n },\n });\n```\n\nNote that, it is also possible to create custom encoders and decoders separately by using the `createEncoder` and `createDecoder` functions respectively and then use the `combineCodec` function on them just like we were doing with composed codecs.\n\nThis approach is recommended to library maintainers as it allows their users to tree-shake any of the encoders and/or decoders they don't need.\n\nHere's our previous modulo u8 example but split into separate `Encoder`, `Decoder` and `Codec` instances.\n\n```ts twoslash\nimport { createEncoder, createDecoder, combineCodec } from '@solana/kit';\n\nconst getModuloU8Encoder = () =>\n createEncoder({\n fixedSize: 1,\n write(value, bytes, offset) {\n bytes.set([value % 256], offset);\n return offset + 1;\n },\n });\n\nconst getModuloU8Decoder = () =>\n createDecoder({\n fixedSize: 1,\n read(bytes, offset) {\n const value = bytes[offset];\n return [value, offset + 1];\n },\n });\n\nconst getModuloU8Codec = () => combineCodec(getModuloU8Encoder(), getModuloU8Decoder());\n```\n\nHere's another example returning a `VariableSizeCodec`. This one transforms a simple string composed of characters from `a` to `z` to a buffer of numbers from `1` to `26` where `0` bytes are spaces.\n\n```ts twoslash\nimport { createEncoder, createDecoder, combineCodec } from '@solana/kit';\n\nconst alphabet = ' abcdefghijklmnopqrstuvwxyz';\n\nconst getCipherEncoder = () =>\n createEncoder({\n getSizeFromValue: (value) => value.length,\n write(value, bytes, offset) {\n const bytesToAdd = [...value].map((char) => alphabet.indexOf(char));\n bytes.set(bytesToAdd, offset);\n return offset + bytesToAdd.length;\n },\n });\n\nconst getCipherDecoder = () =>\n createDecoder({\n read(bytes, offset) {\n const value = [...bytes.slice(offset)].map((byte) => alphabet.charAt(byte)).join('');\n return [value, bytes.length];\n },\n });\n\nconst getCipherCodec = () => combineCodec(getCipherEncoder(), getCipherDecoder());\n```\n\n## Available codecs\n\n### Core utilities\n\n
\n\n[addCodecSentinel](#add-codec-sentinel) \\\n[addCodecSizePrefix](#add-codec-size-prefix) \\\n[containsBytes](#contains-bytes) \\\n[fixBytes](#fix-bytes) \\\n[fixCodecSize](#fix-codec-size) \\\n[mergeBytes](#merge-bytes) \\\n[offsetCodec](#offset-codec) \\\n[padBytes](#pad-bytes) \\\n[padLeftCodec](#pad-left-codec) \\\n[padRightCodec](#pad-right-codec) \\\n[resizeCodec](#resize-codec) \\\n[reverseCodec](#reverse-codec) \\\n[transformCodec](#transform-codec)\n\n
\n\n### Numbers\n\n
\n\n[getI8Codec](#get-i8-codec) \\\n[getI16Codec](#get-i16-codec) \\\n[getI32Codec](#get-i32-codec) \\\n[getI64Codec](#get-i64-codec) \\\n[getI128Codec](#get-i128-codec) \\\n[getF32Codec](#get-f32-codec) \\\n[getF64Codec](#get-f64-codec) \\\n[getShortU16Codec](#get-short-u16-codec) \\\n[getU8Codec](#get-u8-codec) \\\n[getU16Codec](#get-u16-codec) \\\n[getU32Codec](#get-u32-codec) \\\n[getU64Codec](#get-u64-codec) \\\n[getU128Codec](#get-u128-codec)\n\n
\n\n### Strings\n\n
\n\n[getBase10Codec](#get-base10-codec) \\\n[getBase16Codec](#get-base16-codec) \\\n[getBase58Codec](#get-base58-codec) \\\n[getBase64Codec](#get-base64-codec) \\\n[getBaseXCodec](#get-baseX-codec) \\\n[getBaseXResliceCodec](#get-baseX-reslice-codec) \\\n[getUtf8Codec](#get-utf8-codec)\n\n
\n\n### Data structures\n\n
\n\n[getArrayCodec](#get-array-codec) \\\n[getBitArrayCodec](#get-bit-array-codec) \\\n[getBooleanCodec](#get-boolean-codec) \\\n[getBytesCodec](#get-bytes-codec) \\\n[getConstantCodec](#get-constant-codec) \\\n[getDiscriminatedUnionCodec](#get-discriminated-union-codec) \\\n[getEnumCodec](#get-enum-codec) \\\n[getHiddenPrefixCodec](#get-hidden-prefix-codec) \\\n[getHiddenSuffixCodec](#get-hidden-suffix-codec) \\\n[getLiteralUnionCodec](#get-literal-union-codec) \\\n[getMapCodec](#get-map-codec) \\\n[getNullableCodec](#get-nullable-codec) \\\n[getOptionCodec](#get-option-codec) \\\n[getPatternMatchCodec](#get-pattern-match-codec) \\\n[getPredicateCodec](#get-predicate-codec) \\\n[getSetCodec](#get-set-codec) \\\n[getStructCodec](#get-struct-codec) \\\n[getTupleCodec](#get-tuple-codec) \\\n[getUnionCodec](#get-union-codec) \\\n[getUnitCodec](#get-unit-codec)\n\n
\n\n## Core utilities listing [!toc]\n\n### addCodecSentinel [!toc] [#add-codec-sentinel]\n\nOne way of delimiting the size of a codec is to use sentinels. The `addCodecSentinel` function allows us to add a sentinel to the end of the encoded data and to read until that sentinel is found when decoding. It accepts any codec and a `Uint8Array` sentinel responsible for delimiting the encoded data.\n\n```ts twoslash\nimport { addCodecSentinel, getUtf8Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = addCodecSentinel(getUtf8Codec(), new Uint8Array([255, 255]));\ncodec.encode('hello');\n// 0x68656c6c6fffff\n// | └-- Our sentinel.\n// └-- Our encoded string.\n```\n\nNote that the sentinel _must not_ be present in the encoded data and _must_ be present in the decoded data for this to work. If this is not the case, dedicated errors will be thrown.\n\n```ts twoslash\nimport { addCodecSentinel, getUtf8Codec } from '@solana/kit';\n// ---cut-before---\nconst sentinel = new Uint8Array([108, 108]); // 'll'\nconst codec = addCodecSentinel(getUtf8Codec(), sentinel);\n\ncodec.encode('hello'); // Throws: sentinel is in encoded data.\ncodec.decode(new Uint8Array([1, 2, 3])); // Throws: sentinel missing in decoded data.\n```\n\nSeparate `addEncoderSentinel` and `addDecoderSentinel` functions are also available.\n\n```ts twoslash\nimport {\n addEncoderSentinel,\n addDecoderSentinel,\n getUtf8Encoder,\n getUtf8Decoder,\n} from '@solana/kit';\nconst sentinel = null as unknown as Uint8Array;\n// ---cut-before---\nconst bytes = addEncoderSentinel(getUtf8Encoder(), sentinel).encode('hello');\nconst value = addDecoderSentinel(getUtf8Decoder(), sentinel).decode(bytes);\n```\n\n### addCodecSizePrefix [!toc] [#add-codec-size-prefix]\n\nThe `addCodecSizePrefix` function allows us to store the byte size of any codec as a number prefix, enabling us to contain variable-size codecs to their actual size.\n\nWhen encoding, the size of the encoded data is stored before the encoded data itself. When decoding, the size is read first to know how many bytes to read next.\n\nFor example, say we want to represent a variable-size base-58 string using a `u32` size prefix. Here's how we can use the `addCodecSizePrefix` function to achieve that.\n\n```ts twoslash\nimport { addCodecSizePrefix, getBase58Codec, getU32Codec } from '@solana/kit';\n// ---cut-before---\nconst getU32Base58Codec = () => addCodecSizePrefix(getBase58Codec(), getU32Codec());\n\ngetU32Base58Codec().encode('hello world');\n// 0x0b00000068656c6c6f20776f726c64\n// | └-- Our encoded base-58 string.\n// └-- Our encoded u32 size prefix.\n```\n\nYou may also use the `addEncoderSizePrefix` and `addDecoderSizePrefix` functions to separate your codec logic like so:\n\n```ts twoslash\nimport {\n addEncoderSizePrefix,\n addDecoderSizePrefix,\n getBase58Encoder,\n getBase58Decoder,\n getU32Encoder,\n getU32Decoder,\n combineCodec,\n} from '@solana/kit';\n// ---cut-before---\nconst getU32Base58Encoder = () => addEncoderSizePrefix(getBase58Encoder(), getU32Encoder());\nconst getU32Base58Decoder = () => addDecoderSizePrefix(getBase58Decoder(), getU32Decoder());\nconst getU32Base58Codec = () => combineCodec(getU32Base58Encoder(), getU32Base58Decoder());\n```\n\n### containsBytes [!toc] [#contains-bytes]\n\nChecks if a `Uint8Array` contains another `Uint8Array` at a given offset.\n\n```ts twoslash\nimport { containsBytes } from '@solana/kit';\n// ---cut-before---\ncontainsBytes(new Uint8Array([1, 2, 3, 4]), new Uint8Array([2, 3]), 1); // true\ncontainsBytes(new Uint8Array([1, 2, 3, 4]), new Uint8Array([2, 3]), 2); // false\n```\n\n### fixBytes [!toc] [#fix-bytes]\n\nPads or truncates a `Uint8Array` so it has the specified length.\n\n```ts twoslash\nimport { fixBytes } from '@solana/kit';\n// ---cut-before---\nfixBytes(new Uint8Array([1, 2]), 4); // Uint8Array([1, 2, 0, 0])\nfixBytes(new Uint8Array([1, 2, 3, 4]), 2); // Uint8Array([1, 2])\n```\n\n### fixCodecSize [!toc] [#fix-codec-size]\n\nThe `fixCodecSize` function allows us to bind the size of a given codec to the given fixed size.\n\nFor instance, say we wanted to represent a base-58 string that uses exactly 32 bytes when decoded. Here's how we can use the `fixCodecSize` helper to achieve that.\n\n```ts twoslash\nimport { fixCodecSize, getBase58Codec } from '@solana/kit';\n// ---cut-before---\nconst get32BytesBase58Codec = () => fixCodecSize(getBase58Codec(), 32);\n```\n\nYou may also use the `fixEncoderSize` and `fixDecoderSize` functions to separate your codec logic like so:\n\n```ts twoslash\nimport {\n fixEncoderSize,\n fixDecoderSize,\n getBase58Encoder,\n getBase58Decoder,\n combineCodec,\n} from '@solana/kit';\n// ---cut-before---\nconst get32BytesBase58Encoder = () => fixEncoderSize(getBase58Encoder(), 32);\nconst get32BytesBase58Decoder = () => fixDecoderSize(getBase58Decoder(), 32);\nconst get32BytesBase58Codec = () =>\n combineCodec(get32BytesBase58Encoder(), get32BytesBase58Decoder());\n```\n\n### mergeBytes [!toc] [#merge-bytes]\n\nConcatenates an array of `Uint8Arrays` into a single `Uint8Array`.\n\n```ts twoslash\nimport { mergeBytes } from '@solana/kit';\n// ---cut-before---\nconst bytes1 = new Uint8Array([0x01, 0x02]);\nconst bytes2 = new Uint8Array([]);\nconst bytes3 = new Uint8Array([0x03, 0x04]);\nconst bytes = mergeBytes([bytes1, bytes2, bytes3]);\n// ^ [0x01, 0x02, 0x03, 0x04]\n```\n\n### offsetCodec [!toc] [#offset-codec]\n\nThe `offsetCodec` function is a powerful codec primitive that allows us to move the offset of a given codec forward or backwards. It accepts one or two functions that takes the current offset and returns a new offset.\n\nTo understand how this works, let's take the following `biggerU32Codec` example which encodes a `u32` number inside an 8-byte buffer by using the [resizeCodec](#resize-codec) helper.\n\n```ts twoslash\nimport { resizeCodec, getU32Codec } from '@solana/kit';\n// ---cut-before---\nconst biggerU32Codec = resizeCodec(getU32Codec(), (size) => size + 4);\nbiggerU32Codec.encode(0xffffffff);\n// 0xffffffff00000000\n// | └-- Empty buffer space caused by the resizeCodec function.\n// └-- Our encoded u32 number.\n```\n\nNow, let's say we want to move the offset of that codec 2 bytes forward so that the encoded number sits in the middle of the buffer. To achieve, this we can use the `offsetCodec` helper and provide a `preOffset` function that moves the \"pre-offset\" of the codec 2 bytes forward.\n\n```ts twoslash\nimport { offsetCodec, resizeCodec, getU32Codec } from '@solana/kit';\nconst biggerU32Codec = resizeCodec(getU32Codec(), (size) => size + 4);\n// ---cut-before---\nconst u32InTheMiddleCodec = offsetCodec(biggerU32Codec, {\n preOffset: ({ preOffset }) => preOffset + 2,\n});\nu32InTheMiddleCodec.encode(0xffffffff);\n// 0x0000ffffffff0000\n// └-- Our encoded u32 number is now in the middle of the buffer.\n```\n\nWe refer to this offset as the \"pre-offset\" because, once the inner codec is encoded or decoded, an additional offset will be returned which we refer to as the \"post-offset\". That \"post-offset\" is important as, unless we are reaching the end of our codec, it will be used by any further codecs to continue encoding or decoding data.\n\nBy default, that \"post-offset\" is simply the addition of the \"pre-offset\" and the size of the encoded or decoded inner data.\n\n```ts twoslash\nimport { offsetCodec, resizeCodec, getU32Codec } from '@solana/kit';\nconst biggerU32Codec = resizeCodec(getU32Codec(), (size) => size + 4);\n// ---cut-before---\nconst u32InTheMiddleCodec = offsetCodec(biggerU32Codec, {\n preOffset: ({ preOffset }) => preOffset + 2,\n});\nu32InTheMiddleCodec.encode(0xffffffff);\n// 0x0000ffffffff0000\n// | | └-- Post-offset.\n// | └-- New pre-offset: The original pre-offset + 2.\n// └-- Pre-offset: The original pre-offset before we adjusted it.\n```\n\nHowever, you may also provide a `postOffset` function to adjust the \"post-offset\". For instance, let's push the \"post-offset\" 2 bytes forward as well such that any further codecs will start doing their job at the end of our 8-byte `u32` number.\n\n```ts twoslash\nimport { offsetCodec, resizeCodec, getU32Codec } from '@solana/kit';\nconst biggerU32Codec = resizeCodec(getU32Codec(), (size) => size + 4);\n// ---cut-before---\nconst u32InTheMiddleCodec = offsetCodec(biggerU32Codec, {\n preOffset: ({ preOffset }) => preOffset + 2,\n postOffset: ({ postOffset }) => postOffset + 2,\n});\nu32InTheMiddleCodec.encode(0xffffffff);\n// 0x0000ffffffff0000\n// | | | └-- New post-offset: The original post-offset + 2.\n// | | └-- Post-offset: The original post-offset before we adjusted it.\n// | └-- New pre-offset: The original pre-offset + 2.\n// └-- Pre-offset: The original pre-offset before we adjusted it.\n```\n\nBoth the `preOffset` and `postOffset` functions offer the following attributes:\n\n- `bytes`: The entire byte array being encoded or decoded.\n- `preOffset`: The original and unaltered pre-offset.\n- `wrapBytes`: A helper function that wraps the given offset around the byte array length. E.g. `wrapBytes(-1)` will refer to the last byte of the byte array.\n\nAdditionally, the post-offset function also provides the following attributes:\n\n- `newPreOffset`: The new pre-offset after the pre-offset function has been applied.\n- `postOffset`: The original and unaltered post-offset.\n\nNote that you may also decide to ignore these attributes to achieve absolute offsets. However, relative offsets are usually recommended as they won't break your codecs when composed with other codecs.\n\n```ts twoslash\nimport { offsetCodec, resizeCodec, getU32Codec } from '@solana/kit';\nconst biggerU32Codec = resizeCodec(getU32Codec(), (size) => size + 4);\n// ---cut-before---\nconst u32InTheMiddleCodec = offsetCodec(biggerU32Codec, {\n preOffset: () => 2,\n postOffset: () => 8,\n});\nu32InTheMiddleCodec.encode(0xffffffff);\n// 0x0000ffffffff0000\n```\n\nAlso note that any negative offset or offset that exceeds the size of the byte array will throw a `SolanaError` of code `SOLANA_ERROR__CODECS__OFFSET_OUT_OF_RANGE`.\n\n```ts twoslash\nimport { offsetCodec, resizeCodec, getU32Codec } from '@solana/kit';\nconst biggerU32Codec = resizeCodec(getU32Codec(), (size) => size + 4);\n// ---cut-before---\nconst u32InTheEndCodec = offsetCodec(biggerU32Codec, { preOffset: () => -4 });\nu32InTheEndCodec.encode(0xffffffff);\n// throws new SolanaError(SOLANA_ERROR__CODECS__OFFSET_OUT_OF_RANGE)\n```\n\nTo avoid this, you may use the `wrapBytes` function to wrap the offset around the byte array length. For instance, here's how we can use the `wrapBytes` function to move the pre-offset 4 bytes from the end of the byte array.\n\n```ts twoslash\nimport { offsetCodec, resizeCodec, getU32Codec } from '@solana/kit';\nconst biggerU32Codec = resizeCodec(getU32Codec(), (size) => size + 4);\n// ---cut-before---\nconst u32InTheEndCodec = offsetCodec(biggerU32Codec, {\n preOffset: ({ wrapBytes }) => wrapBytes(-4),\n});\nu32InTheEndCodec.encode(0xffffffff);\n// 0x00000000ffffffff\n```\n\nAs you can see, the `offsetCodec` helper allows you to jump all over the place with your codecs. This non-linear approach to encoding and decoding data allows you to achieve complex serialization strategies that would otherwise be impossible.\n\nThe `offsetEncoder` and `offsetDecoder` functions can also be used to split your codec logic into tree-shakeable functions.\n\n```ts twoslash\nimport {\n offsetEncoder,\n resizeEncoder,\n getU32Encoder,\n offsetDecoder,\n resizeDecoder,\n getU32Decoder,\n combineCodec,\n} from '@solana/kit';\nconst biggerU32Encoder = resizeEncoder(getU32Encoder(), (size) => size + 4);\nconst biggerU32Decoder = resizeDecoder(getU32Decoder(), (size) => size + 4);\n// ---cut-before---\nconst getU32InTheMiddleEncoder = () =>\n offsetEncoder(biggerU32Encoder, { preOffset: ({ preOffset }) => preOffset + 2 });\nconst getU32InTheMiddleDecoder = () =>\n offsetDecoder(biggerU32Decoder, { preOffset: ({ preOffset }) => preOffset + 2 });\nconst getU32InTheMiddleCodec = () =>\n combineCodec(getU32InTheMiddleEncoder(), getU32InTheMiddleDecoder());\n```\n\n### padBytes [!toc] [#pad-bytes]\n\nPads a `Uint8Array` with zeroes (to the right) to the specified length.\n\n```ts twoslash\nimport { padBytes } from '@solana/kit';\n// ---cut-before---\npadBytes(new Uint8Array([1, 2]), 4); // Uint8Array([1, 2, 0, 0])\npadBytes(new Uint8Array([1, 2, 3, 4]), 2); // Uint8Array([1, 2, 3, 4])\n```\n\n### padLeftCodec [!toc] [#pad-left-codec]\n\nThe `padLeftCodec` helper can be used to add padding to the left of a given codec. It accepts an `offset` number that tells us how big the padding should be.\n\n```ts twoslash\nimport { padLeftCodec, getU16Codec } from '@solana/kit';\n// ---cut-before---\nconst leftPaddedCodec = padLeftCodec(getU16Codec(), 4);\nleftPaddedCodec.encode(0xffff);\n// 0x00000000ffff\n// | └-- Our encoded u16 number.\n// └-- Our 4-byte padding.\n```\n\nNote that the `padLeftCodec` function is a simple wrapper around the `offsetCodec` and `resizeCodec` functions. For more complex padding strategies, you may want to use the [offsetCodec](#offset-codec) and [resizeCodec](#resize-codec) functions directly instead.\n\nEncoder-only and decoder-only helpers are available for these padding functions.\n\n```ts twoslash\nimport {\n padLeftEncoder,\n padLeftDecoder,\n getU16Encoder,\n getU16Decoder,\n combineCodec,\n} from '@solana/kit';\n// ---cut-before---\nconst getMyPaddedEncoder = () => padLeftEncoder(getU16Encoder(), 6);\nconst getMyPaddedDecoder = () => padLeftDecoder(getU16Decoder(), 6);\nconst getMyPaddedCodec = () => combineCodec(getMyPaddedEncoder(), getMyPaddedDecoder());\n```\n\n### padRightCodec [!toc] [#pad-right-codec]\n\nThe `padRightCodec` helper can be used to add padding to the right of a given codec. It accepts an `offset` number that tells us how big the padding should be.\n\n```ts twoslash\nimport { padRightCodec, getU16Codec } from '@solana/kit';\n// ---cut-before---\nconst rightPaddedCodec = padRightCodec(getU16Codec(), 4);\nrightPaddedCodec.encode(0xffff);\n// 0xffff00000000\n// | └-- Our 4-byte padding.\n// └-- Our encoded u16 number.\n```\n\nNote that the `padRightCodec` function is a simple wrapper around the `offsetCodec` and `resizeCodec` functions. For more complex padding strategies, you may want to use the [offsetCodec](#offset-codec) and [resizeCodec](#resize-codec) functions directly instead.\n\nEncoder-only and decoder-only helpers are available for these padding functions.\n\n```ts twoslash\nimport {\n padRightEncoder,\n padRightDecoder,\n getU16Encoder,\n getU16Decoder,\n combineCodec,\n} from '@solana/kit';\n// ---cut-before---\nconst getMyPaddedEncoder = () => padRightEncoder(getU16Encoder(), 6);\nconst getMyPaddedDecoder = () => padRightDecoder(getU16Decoder(), 6);\nconst getMyPaddedCodec = () => combineCodec(getMyPaddedEncoder(), getMyPaddedDecoder());\n```\n\n### resizeCodec [!toc] [#resize-codec]\n\nThe `resizeCodec` helper re-defines the size of a given codec by accepting a function that takes the current size of the codec and returns a new size. This works for both fixed-size and variable-size codecs.\n\n```ts twoslash\nimport { resizeCodec, getU32Codec, getUtf8Codec } from '@solana/kit';\n// ---cut-before---\n// Fixed-size codec.\nconst getBiggerU32Codec = () => resizeCodec(getU32Codec(), (size) => size + 4);\ngetBiggerU32Codec().encode(42);\n// 0x2a00000000000000\n// | └-- Empty buffer space caused by the resizeCodec function.\n// └-- Our encoded u32 number.\n\n// Variable-size codec.\nconst getBiggerUtf8Codec = () => resizeCodec(getUtf8Codec(), (size) => size + 4);\ngetBiggerUtf8Codec().encode('ABC');\n// 0x41424300000000\n// | └-- Empty buffer space caused by the resizeCodec function.\n// └-- Our encoded string.\n```\n\nNote that the `resizeCodec` function doesn't change any encoded or decoded bytes, it merely tells the `encode` and `decode` functions how big the `Uint8Array` should be before delegating to their respective `write` and `read` functions. In fact, this is completely bypassed when using the `write` and `read` functions directly. For instance:\n\n```ts twoslash\nimport { resizeCodec, getU32Codec } from '@solana/kit';\n// ---cut-before---\nconst getBiggerU32Codec = () => resizeCodec(getU32Codec(), (size) => size + 4);\n\n// Using the encode function.\ngetBiggerU32Codec().encode(42);\n// 0x2a00000000000000\n\n// Using the lower-level write function.\nconst myCustomBytes = new Uint8Array(4);\ngetBiggerU32Codec().write(42, myCustomBytes, 0);\n// 0x2a000000\n```\n\nSo when would it make sense to use the `resizeCodec` function? This function is particularly useful when combined with the [offsetCodec](#offset-codec) function. Whilst `offsetCodec` may help us push the offset forward — e.g. to skip some padding — it won't change the size of the encoded data which means the last bytes will be truncated by how much we pushed the offset forward. The `resizeCodec` function can be used to fix that. For instance, here's how we can use the `resizeCodec` and the `offsetCodec` functions together to create a struct codec that includes some padding.\n\n```ts twoslash\nimport {\n getStructCodec,\n getUtf8Codec,\n getU32Codec,\n offsetCodec,\n resizeCodec,\n fixCodecSize,\n} from '@solana/kit';\n// ---cut-before---\nconst personCodec = getStructCodec([\n ['name', fixCodecSize(getUtf8Codec(), 8)],\n // There is a 4-byte padding between name and age.\n [\n 'age',\n offsetCodec(\n resizeCodec(getU32Codec(), (size) => size + 4),\n { preOffset: ({ preOffset }) => preOffset + 4 },\n ),\n ],\n]);\n\npersonCodec.encode({ name: 'Alice', age: 42 });\n// 0x416c696365000000000000002a000000\n// | | └-- Our encoded u32 (42).\n// | └-- The 4-bytes of padding we are skipping.\n// └-- Our 8-byte encoded string (\"Alice\").\n```\n\nNote that this can be achieved using the [padLeftCodec](#pad-left-codec) helper which is implemented that way.\n\nThe `resizeEncoder` and `resizeDecoder` functions can also be used to split your codec logic into tree-shakeable functions.\n\n```ts twoslash\nimport {\n resizeEncoder,\n resizeDecoder,\n getU32Encoder,\n getU32Decoder,\n combineCodec,\n} from '@solana/kit';\n// ---cut-before---\nconst getBiggerU32Encoder = () => resizeEncoder(getU32Encoder(), (size) => size + 4);\nconst getBiggerU32Decoder = () => resizeDecoder(getU32Decoder(), (size) => size + 4);\nconst getBiggerU32Codec = () => combineCodec(getBiggerU32Encoder(), getBiggerU32Decoder());\n```\n\n### reverseCodec [!toc] [#reverse-codec]\n\nThe `reverseCodec` helper reverses the bytes of the provided `FixedSizeCodec`.\n\n```ts twoslash\nimport { reverseCodec, getU64Codec } from '@solana/kit';\n// ---cut-before---\nconst getBigEndianU64Codec = () => reverseCodec(getU64Codec());\n```\n\nNote that number codecs can already do that for you via their `endian` option.\n\n```ts twoslash\nimport { getU64Codec, Endian } from '@solana/kit';\n// ---cut-before---\nconst getBigEndianU64Codec = () => getU64Codec({ endian: Endian.Big });\n```\n\nThe `reverseEncoder` and `reverseDecoder` functions can also be used to achieve that.\n\n```ts twoslash\nimport {\n reverseEncoder,\n reverseDecoder,\n getU64Encoder,\n getU64Decoder,\n combineCodec,\n} from '@solana/kit';\n// ---cut-before---\nconst getBigEndianU64Encoder = () => reverseEncoder(getU64Encoder());\nconst getBigEndianU64Decoder = () => reverseDecoder(getU64Decoder());\nconst getBigEndianU64Codec = () => combineCodec(getBigEndianU64Encoder(), getBigEndianU64Decoder());\n```\n\n### transformCodec [!toc] [#transform-codec]\n\nIt is possible to transform a `Codec` to a `Codec` by providing two mapping functions: one that goes from `T` to `U` and one that does the opposite.\n\nFor instance, here's how you would map a `u32` integer into a `string` representation of that number.\n\n```ts twoslash\nimport { transformCodec, getU32Codec } from '@solana/kit';\n// ---cut-before---\nconst getStringU32Codec = () =>\n transformCodec(\n getU32Codec(),\n (integerAsString: string): number => parseInt(integerAsString),\n (integer: number): string => integer.toString(),\n );\n\ngetStringU32Codec().encode('42'); // new Uint8Array([42])\ngetStringU32Codec().decode(new Uint8Array([42])); // \"42\"\n```\n\nIf a `Codec` has [different From and To types](#different-from-and-to-types), say `Codec`, and we want to map it to `Codec`, we must provide functions that map from `NewFrom` to `OldFrom` and from `OldTo` to `NewTo`.\n\nTo illustrate that, let's take our previous `getStringU32Codec` example but make it use a `getU64Codec` codec instead as it returns a `Codec`. Additionally, let's make it so our `getStringU64Codec` function returns a `Codec` so that it also accepts numbers when encoding values. Here's what our mapping functions look like:\n\n```ts twoslash\nimport { transformCodec, getU64Codec } from '@solana/kit';\n// ---cut-before---\nconst getStringU64Codec = () =>\n transformCodec(\n getU64Codec(),\n (integerInput: number | string): number | bigint =>\n typeof integerInput === 'string' ? BigInt(integerInput) : integerInput,\n (integer: bigint): string => integer.toString(),\n );\n```\n\nNote that the second function that maps the decoded type is optional. That means, you can omit it to simply update or loosen the type to encode whilst keeping the decoded type the same.\n\nThis is particularly useful to provide default values to object structures. For instance, here's how we can map a `Person` codec to give a default value to its `age` attribute.\n\n```ts twoslash\nimport { transformCodec, getStructCodec, Codec } from '@solana/kit';\n// ---cut-before---\ntype Person = { name: string; age: number };\ntype PersonInput = { name: string; age?: number };\n// ---cut-start---\nconst getPersonCodec = null as unknown as () => Codec;\n// ---cut-end---\nconst getPersonWithDefaultValueCodec = (): Codec =>\n transformCodec(\n getPersonCodec(),\n (person: PersonInput): Person => ({ ...person, age: person.age ?? 42 }),\n );\n```\n\nSimilar helpers exist to map `Encoder` and `Decoder` instances allowing you to separate your codec logic into tree-shakeable functions. Here's our `getStringU32Codec` written that way.\n\n```ts twoslash\nimport {\n transformEncoder,\n transformDecoder,\n getU32Encoder,\n getU32Decoder,\n combineCodec,\n} from '@solana/kit';\n// ---cut-before---\nconst getStringU32Encoder = () =>\n transformEncoder(getU32Encoder(), (integerAsString: string): number =>\n parseInt(integerAsString),\n );\nconst getStringU32Decoder = () =>\n transformDecoder(getU32Decoder(), (integer: number): string => integer.toString());\nconst getStringU32Codec = () => combineCodec(getStringU32Encoder(), getStringU32Decoder());\n```\n\n## Numbers listing [!toc]\n\n### getI8Codec [!toc] [#get-i8-codec]\n\nEncodes and decodes **signed 8-bit integers**. It supports values from -127 (`-2^7`) to 128 (`2^7 - 1`).\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `number`.\n\n```ts twoslash\nimport { getI8Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getI8Codec();\nconst bytes = codec.encode(-42); // 0xd6\nconst value = codec.decode(bytes); // -42\n```\n\n`getI8Encoder` and `getI8Decoder` functions are also available.\n\n### getI16Codec [!toc] [#get-i16-codec]\n\nEncodes and decodes **signed 16-bit integers**. It supports values from -32,768 (`-2^15`) to 32,767 (`2^15 - 1`).\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `number`. Endianness can be specified using the `endian` option. The default is `Endian.Little`.\n\n```ts twoslash\nimport { getI16Codec, Endian } from '@solana/kit';\n// ---cut-before---\n// Little-endian.\nconst codec = getI16Codec();\nconst bytes = codec.encode(-42); // 0xd6ff\nconst value = codec.decode(bytes); // -42\n\n// Big-endian.\nconst beCodec = getI16Codec({ endian: Endian.Big });\nconst beBytes = beCodec.encode(-42); // 0xffd6\nconst beValue = beCodec.decode(bytes); // -42\n```\n\n`getI16Encoder` and `getI16Decoder` functions are also available.\n\n### getI32Codec [!toc] [#get-i32-codec]\n\nEncodes and decodes **signed 32-bit integers**. It supports values from -2,147,483,648 (`-2^31`) to 2,147,483,647 (`2^31 - 1`).\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `number`. Endianness can be specified using the `endian` option. The default is `Endian.Little`.\n\n```ts twoslash\nimport { getI32Codec, Endian } from '@solana/kit';\n// ---cut-before---\n// Little-endian.\nconst codec = getI32Codec();\nconst bytes = codec.encode(-42); // 0xd6ffffff\nconst value = codec.decode(bytes); // -42\n\n// Big-endian.\nconst beCodec = getI32Codec({ endian: Endian.Big });\nconst beBytes = beCodec.encode(-42); // 0xffffffd6\nconst beValue = beCodec.decode(bytes); // -42\n```\n\n`getI32Encoder` and `getI32Decoder` functions are also available.\n\n### getI64Codec [!toc] [#get-i64-codec]\n\nEncodes and decodes **signed 64-bit integers**. It supports values from `-2^63` to `2^63 - 1`.\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`. Endianness can be specified using the `endian` option. The default is `Endian.Little`.\n\n```ts twoslash\nimport { getI64Codec, Endian } from '@solana/kit';\n// ---cut-before---\n// Little-endian.\nconst codec = getI64Codec();\nconst bytes = codec.encode(-42); // 0xd6ffffffffffffff\nconst value = codec.decode(bytes); // BigInt(-42)\n\n// Big-endian.\nconst beCodec = getI64Codec({ endian: Endian.Big });\nconst beBytes = beCodec.encode(-42); // 0xffffffffffffffd6\nconst beValue = beCodec.decode(bytes); // BigInt(-42)\n```\n\n`getI64Encoder` and `getI64Decoder` functions are also available.\n\n### getI128Codec [!toc] [#get-i128-codec]\n\nEncodes and decodes **signed 128-bit integers**. It supports values from `-2^127` to `2^127 - 1`.\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`. Endianness can be specified using the `endian` option. The default is `Endian.Little`.\n\n```ts twoslash\nimport { getI128Codec, Endian } from '@solana/kit';\n// ---cut-before---\n// Little-endian.\nconst codec = getI128Codec();\nconst bytes = codec.encode(-42); // 0xd6ffffffffffffffffffffffffffffff\nconst value = codec.decode(bytes); // BigInt(-42)\n\n// Big-endian.\nconst beCodec = getI128Codec({ endian: Endian.Big });\nconst beBytes = beCodec.encode(-42); // 0xffffffffffffffffffffffffffffffd6\nconst beValue = beCodec.decode(bytes); // BigInt(-42)\n```\n\n`getI128Encoder` and `getI128Decoder` functions are also available.\n\n### getF32Codec [!toc] [#get-f32-codec]\n\nEncodes and decodes **32-bit floating-point numbers**. Due to the [IEEE 754](https://en.wikipedia.org/wiki/Single-precision_floating-point_format) floating-point representation, some precision loss may occur.\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `number`. Endianness can be specified using the `endian` option. The default is `Endian.Little`.\n\n```ts twoslash\nimport { getF32Codec, Endian } from '@solana/kit';\n// ---cut-before---\n// Little-endian.\nconst codec = getF32Codec();\nconst bytes = codec.encode(-1.5); // 0x0000c0bf\nconst value = codec.decode(bytes); // -1.5\n\n// Big-endian.\nconst beCodec = getF32Codec({ endian: Endian.Big });\nconst beBytes = beCodec.encode(-1.5); // 0xbfc00000\nconst beValue = beCodec.decode(bytes); // -1.5\n```\n\n`getF32Encoder` and `getF32Decoder` functions are also available.\n\n### getF64Codec [!toc] [#get-f64-codec]\n\nEncodes and decodes **64-bit floating-point numbers**. Due to the [IEEE 754](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) floating-point representation, some precision loss may occur.\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `number`. Endianness can be specified using the `endian` option. The default is `Endian.Little`.\n\n```ts twoslash\nimport { getF64Codec, Endian } from '@solana/kit';\n// ---cut-before---\n// Little-endian.\nconst codec = getF64Codec();\nconst bytes = codec.encode(-1.5); // 0x000000000000f8bf\nconst value = codec.decode(bytes); // -1.5\n\n// Big-endian.\nconst beCodec = getF64Codec({ endian: Endian.Big });\nconst beBytes = beCodec.encode(-1.5); // 0xbff8000000000000\nconst beValue = beCodec.decode(bytes); // -1.5\n```\n\n`getF64Encoder` and `getF64Decoder` functions are also available.\n\n### getShortU16Codec [!toc] [#get-short-u16-codec]\n\nEncodes and decodes **unsigned integer using 1 to 3 bytes** based on the encoded value. It supports values from 0 to 4,194,303 (`2^22 - 1`).\n\nThe larger the value, the more bytes it uses.\n\n- If the value is `<= 0x7f` (127), it is stored in a **single byte** and the first bit is set to `0` to indicate the end of the value.\n- Otherwise, the first bit is set to `1` to indicate that the value continues in the next byte, which follows the same pattern.\n- This process repeats until the value is fully encoded in up to 3 bytes. The third and last byte, if needed, uses all 8 bits to store the remaining value.\n\nIn other words, the encoding scheme follows this structure:\n\n```txt\n0XXXXXXX <- Values 0 to 127 (1 byte)\n1XXXXXXX 0XXXXXXX <- Values 128 to 16,383 (2 bytes)\n1XXXXXXX 1XXXXXXX XXXXXXXX <- Values 16,384 to 4,194,303 (3 bytes)\n```\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `number`.\n\n```ts twoslash\nimport { getShortU16Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getShortU16Codec();\nconst bytes1 = codec.encode(42); // 0x2a\nconst bytes2 = codec.encode(128); // 0x8001\nconst bytes3 = codec.encode(16384); // 0x808001\n\ncodec.decode(bytes1); // 42\ncodec.decode(bytes2); // 128\ncodec.decode(bytes3); // 16384\n```\n\n`getShortU16Encoder` and `getShortU16Decoder` functions are also available.\n\n### getU8Codec [!toc] [#get-u8-codec]\n\nEncodes and decodes **unsigned 8-bit integers**. It supports values from 0 to 255 (`2^8 - 1`).\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `number`.\n\n```ts twoslash\nimport { getU8Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getU8Codec();\nconst bytes = codec.encode(42); // 0x2a\nconst value = codec.decode(bytes); // 42\n```\n\n`getU8Encoder` and `getU8Decoder` functions are also available.\n\n### getU16Codec [!toc] [#get-u16-codec]\n\nEncodes and decodes **unsigned 16-bit integers**. It supports values from 0 to 65,535 (`2^16 - 1`).\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `number`. Endianness can be specified using the `endian` option. The default is `Endian.Little`.\n\n```ts twoslash\nimport { getU16Codec, Endian } from '@solana/kit';\n// ---cut-before---\n// Little-endian.\nconst codec = getU16Codec();\nconst bytes = codec.encode(42); // 0x2a00\nconst value = codec.decode(bytes); // 42\n\n// Big-endian.\nconst beCodec = getU16Codec({ endian: Endian.Big });\nconst beBytes = beCodec.encode(42); // 0x002a\nconst beValue = beCodec.decode(bytes); // 42\n```\n\n`getU16Encoder` and `getU16Decoder` functions are also available.\n\n### getU32Codec [!toc] [#get-u32-codec]\n\nEncodes and decodes **unsigned 32-bit integers**. It supports values from 0 to 4,294,967,295 (`2^32 - 1`).\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `number`. Endianness can be specified using the `endian` option. The default is `Endian.Little`.\n\n```ts twoslash\nimport { getU32Codec, Endian } from '@solana/kit';\n// ---cut-before---\n// Little-endian.\nconst codec = getU32Codec();\nconst bytes = codec.encode(42); // 0x2a000000\nconst value = codec.decode(bytes); // 42\n\n// Big-endian.\nconst beCodec = getU32Codec({ endian: Endian.Big });\nconst beBytes = beCodec.encode(42); // 0x0000002a\nconst beValue = beCodec.decode(bytes); // 42\n```\n\n`getU32Encoder` and `getU32Decoder` functions are also available.\n\n### getU64Codec [!toc] [#get-u64-codec]\n\nEncodes and decodes **unsigned 64-bit integers**. It supports values from 0 to `2^64 - 1`.\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`. Endianness can be specified using the `endian` option. The default is `Endian.Little`.\n\n```ts twoslash\nimport { getU64Codec, Endian } from '@solana/kit';\n// ---cut-before---\n// Little-endian.\nconst codec = getU64Codec();\nconst bytes = codec.encode(42); // 0x2a00000000000000\nconst value = codec.decode(bytes); // 42\n\n// Big-endian.\nconst beCodec = getU64Codec({ endian: Endian.Big });\nconst beBytes = beCodec.encode(42); // 0x000000000000002a\nconst beValue = beCodec.decode(bytes); // 42\n```\n\n`getU64Encoder` and `getU64Decoder` functions are also available.\n\n### getU128Codec [!toc] [#get-u128-codec]\n\nEncodes and decodes **unsigned 128-bit integers**. It supports values from 0 to `2^128 - 1`.\n\nValues can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`. Endianness can be specified using the `endian` option. The default is `Endian.Little`.\n\n```ts twoslash\nimport { getU128Codec, Endian } from '@solana/kit';\n// ---cut-before---\n// Little-endian.\nconst codec = getU128Codec();\nconst bytes = codec.encode(42); // 0x2a000000000000000000000000000000\nconst value = codec.decode(bytes); // 42\n\n// Big-endian.\nconst beCodec = getU128Codec({ endian: Endian.Big });\nconst beBytes = beCodec.encode(42); // 0x0000000000000000000000000000002a\nconst beValue = beCodec.decode(bytes); // 42\n```\n\n`getU128Encoder` and `getU128Decoder` functions are also available.\n\n## Strings listing [!toc]\n\n### getBase10Codec [!toc] [#get-base10-codec]\n\nEncodes and decodes **Base 10 strings**.\n\n```ts twoslash\nimport { getBase10Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getBase10Codec();\nconst bytes = codec.encode('1024'); // 0x0400\nconst value = codec.decode(bytes); // \"1024\"\n```\n\nThis codec does not enforce a size boundary. It will encode and decode all bytes necessary to represent the string. To add size constraints to your codec, you may use utility functions such as [`fixCodecSize`](#fix-codec-size), [`addCodecSizePrefix`](#add-codec-size-prefix) or [`addCodecSentinel`](#add-codec-sentinel).\n\n```ts twoslash\nimport {\n getBase10Codec,\n fixCodecSize,\n addCodecSizePrefix,\n getU32Codec,\n addCodecSentinel,\n} from '@solana/kit';\n// ---cut-before---\nfixCodecSize(getBase10Codec(), 4).encode('1024');\n// 0x04000000 (padded to 4 bytes)\n\naddCodecSizePrefix(getBase10Codec(), getU32Codec()).encode('1024');\n// 0x020000000400\n// | └-- The 2 bytes of content.\n// └-- 4-byte prefix telling us to read 2 bytes.\n\naddCodecSentinel(getBase10Codec(), new Uint8Array([0xff, 0xff])).encode('1024');\n// 0x0400ffff\n// | └-- The sentinel signaling the end of the content.\n// └-- The 2 bytes of content.\n```\n\n`getBase10Encoder` and `getBase10Decoder` functions are also available.\n\n### getBase16Codec [!toc] [#get-base16-codec]\n\nEncodes and decodes **Base 16 strings**.\n\n```ts twoslash\nimport { getBase16Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getBase16Codec();\nconst bytes = codec.encode('deadface'); // 0xdeadface\nconst value = codec.decode(bytes); // \"deadface\"\n```\n\nThis codec does not enforce a size boundary. It will encode and decode all bytes necessary to represent the string. To add size constraints to your codec, you may use utility functions such as [`fixCodecSize`](#fix-codec-size), [`addCodecSizePrefix`](#add-codec-size-prefix) or [`addCodecSentinel`](#add-codec-sentinel).\n\n```ts twoslash\nimport {\n getBase16Codec,\n fixCodecSize,\n addCodecSizePrefix,\n getU32Codec,\n addCodecSentinel,\n} from '@solana/kit';\n// ---cut-before---\nfixCodecSize(getBase16Codec(), 2).encode('deadface');\n// 0xdead (truncated to 2 bytes)\n\naddCodecSizePrefix(getBase16Codec(), getU32Codec()).encode('deadface');\n// 0x04000000deadface\n// | └-- The 4 bytes of content.\n// └-- 4-byte prefix telling us to read 4 bytes.\n\naddCodecSentinel(getBase16Codec(), new Uint8Array([0xff, 0xff])).encode('deadface');\n// 0xdeadfaceffff\n// | └-- The sentinel signaling the end of the content.\n// └-- The 4 bytes of content.\n```\n\n`getBase16Encoder` and `getBase16Decoder` functions are also available.\n\n### getBase58Codec [!toc] [#get-base58-codec]\n\nEncodes and decodes **Base 58 strings**.\n\n```ts twoslash\nimport { getBase58Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getBase58Codec();\nconst bytes = codec.encode('heLLo'); // 0x1b6a3070\nconst value = codec.decode(bytes); // \"heLLo\"\n```\n\nThis codec does not enforce a size boundary. It will encode and decode all bytes necessary to represent the string. To add size constraints to your codec, you may use utility functions such as [`fixCodecSize`](#fix-codec-size), [`addCodecSizePrefix`](#add-codec-size-prefix) or [`addCodecSentinel`](#add-codec-sentinel).\n\n```ts twoslash\nimport {\n getBase58Codec,\n fixCodecSize,\n addCodecSizePrefix,\n getU32Codec,\n addCodecSentinel,\n} from '@solana/kit';\n// ---cut-before---\nfixCodecSize(getBase58Codec(), 2).encode('heLLo');\n// 0x1b6a (truncated to 2 bytes)\n\naddCodecSizePrefix(getBase58Codec(), getU32Codec()).encode('heLLo');\n// 0x040000001b6a3070\n// | └-- The 4 bytes of content.\n// └-- 4-byte prefix telling us to read 4 bytes.\n\naddCodecSentinel(getBase58Codec(), new Uint8Array([0xff, 0xff])).encode('heLLo');\n// 0x1b6a3070ffff\n// | └-- The sentinel signaling the end of the content.\n// └-- The 4 bytes of content.\n```\n\n`getBase58Encoder` and `getBase58Decoder` functions are also available.\n\n### getBase64Codec [!toc] [#get-base64-codec]\n\nEncodes and decodes **Base 64 strings**.\n\n```ts twoslash\nimport { getBase64Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getBase64Codec();\nconst bytes = codec.encode('hello+world'); // 0x85e965a3ec28ae57\nconst value = codec.decode(bytes); // \"hello+world\"\n```\n\nThis codec does not enforce a size boundary. It will encode and decode all bytes necessary to represent the string. To add size constraints to your codec, you may use utility functions such as [`fixCodecSize`](#fix-codec-size), [`addCodecSizePrefix`](#add-codec-size-prefix) or [`addCodecSentinel`](#add-codec-sentinel).\n\n```ts twoslash\nimport {\n getBase64Codec,\n fixCodecSize,\n addCodecSizePrefix,\n getU32Codec,\n addCodecSentinel,\n} from '@solana/kit';\n// ---cut-before---\nfixCodecSize(getBase64Codec(), 4).encode('hello+world');\n// 0x85e965a3 (truncated to 4 bytes)\n\naddCodecSizePrefix(getBase64Codec(), getU32Codec()).encode('hello+world');\n// 0x0400000085e965a3ec28ae57\n// | └-- The 8 bytes of content.\n// └-- 4-byte prefix telling us to read 8 bytes.\n\naddCodecSentinel(getBase64Codec(), new Uint8Array([0xff, 0xff])).encode('hello+world');\n// 0x85e965a3ec28ae57ffff\n// | └-- The sentinel signaling the end of the content.\n// └-- The 8 bytes of content.\n```\n\n`getBase64Encoder` and `getBase64Decoder` functions are also available.\n\n### getBaseXCodec [!toc] [#get-baseX-codec]\n\nThe `getBaseXCodec` accepts a custom `alphabet` of `X` characters and **creates a base-X codec using that alphabet**. It does so by iteratively dividing by `X` and handling leading zeros.\n\n```ts twoslash\nimport { getBaseXCodec } from '@solana/kit';\n// ---cut-before---\nconst codec = getBaseXCodec('0ehlo');\nconst bytes = codec.encode('hello'); // 0x05bd\nconst value = codec.decode(bytes); // \"hello\"\n```\n\nThis codec does not enforce a size boundary. It will encode and decode all bytes necessary to represent the string. To add size constraints to your codec, you may use utility functions such as [`fixCodecSize`](#fix-codec-size), [`addCodecSizePrefix`](#add-codec-size-prefix) or [`addCodecSentinel`](#add-codec-sentinel).\n\n```ts twoslash\nimport {\n getBaseXCodec,\n fixCodecSize,\n addCodecSizePrefix,\n getU32Codec,\n addCodecSentinel,\n} from '@solana/kit';\n// ---cut-before---\nconst codec = getBaseXCodec('0ehlo');\n\nfixCodecSize(codec, 4).encode('hello');\n// 0x05bd0000 (padded to 4 bytes)\n\naddCodecSizePrefix(codec, getU32Codec()).encode('hello');\n// 0x0200000005bd\n// | └-- The 2 bytes of content.\n// └-- 4-byte prefix telling us to read 2 bytes.\n\naddCodecSentinel(codec, new Uint8Array([0xff, 0xff])).encode('hello');\n// 0x05bdffff\n// | └-- The sentinel signaling the end of the content.\n// └-- The 2 bytes of content.\n```\n\n`getBaseXEncoder` and `getBaseXDecoder` functions are also available.\n\n### getBaseXResliceCodec [!toc] [#get-baseX-reslice-codec]\n\nThe `getBaseXResliceCodec` accepts a custom `alphabet` of `X` characters and **creates a base-X codec using that alphabet**.\n\nIt does so by re-slicing bytes into custom chunks of bits that are then mapped to the provided `alphabet`. The number of bits per chunk is also provided as the second argument and should typically be set to `log2(alphabet.length)`.\n\nThis is typically used to create codecs whose alphabet's length is a power of 2 such as base-16 or base-64.\n\n```ts twoslash\nimport { getBaseXResliceCodec } from '@solana/kit';\n// ---cut-before---\nconst codec = getBaseXResliceCodec('elho', 2);\nconst bytes = codec.encode('hellolol'); // 0x4aee\nconst value = codec.decode(bytes); // \"hellolol\"\n```\n\nThis codec does not enforce a size boundary. It will encode and decode all bytes necessary to represent the string. To add size constraints to your codec, you may use utility functions such as [`fixCodecSize`](#fix-codec-size), [`addCodecSizePrefix`](#add-codec-size-prefix) or [`addCodecSentinel`](#add-codec-sentinel).\n\n```ts twoslash\nimport {\n getBaseXResliceCodec,\n fixCodecSize,\n addCodecSizePrefix,\n getU32Codec,\n addCodecSentinel,\n} from '@solana/kit';\n// ---cut-before---\nconst codec = getBaseXResliceCodec('elho', 2);\n\nfixCodecSize(codec, 4).encode('hellolol');\n// 0x4aee0000 (padded to 4 bytes)\n\naddCodecSizePrefix(codec, getU32Codec()).encode('hellolol');\n// 0x020000004aee\n// | └-- The 2 bytes of content.\n// └-- 4-byte prefix telling us to read 2 bytes.\n\naddCodecSentinel(codec, new Uint8Array([0xff, 0xff])).encode('hellolol');\n// 0x4aeeffff\n// | └-- The sentinel signaling the end of the content.\n// └-- The 2 bytes of content.\n```\n\n`getBaseXResliceEncoder` and `getBaseXResliceDecoder` functions are also available.\n\n### getUtf8Codec [!toc] [#get-utf8-codec]\n\nEncodes and decodes **UTF-8 strings**.\n\n```ts twoslash\nimport { getUtf8Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getUtf8Codec();\nconst bytes = codec.encode('hello'); // 0x68656c6c6f\nconst value = codec.decode(bytes); // \"hello\"\n```\n\nThis codec does not enforce a size boundary. It will encode and decode all bytes necessary to represent the string. To add size constraints to your codec, you may use utility functions such as [`fixCodecSize`](#fix-codec-size), [`addCodecSizePrefix`](#add-codec-size-prefix) or [`addCodecSentinel`](#add-codec-sentinel).\n\n```ts twoslash\nimport {\n getUtf8Codec,\n fixCodecSize,\n addCodecSizePrefix,\n getU32Codec,\n addCodecSentinel,\n} from '@solana/kit';\n// ---cut-before---\nfixCodecSize(getUtf8Codec(), 4).encode('hello');\n// 0x68656c6c (truncated to 4 bytes)\n\naddCodecSizePrefix(getUtf8Codec(), getU32Codec()).encode('hello');\n// 0x0500000068656c6c6f\n// | └-- The 5 bytes of content.\n// └-- 4-byte prefix telling us to read 5 bytes.\n\naddCodecSentinel(getUtf8Codec(), new Uint8Array([0xff, 0xff])).encode('hello');\n// 0x68656c6c6fffff\n// | └-- The sentinel signaling the end of the content.\n// └-- The 5 bytes of content.\n```\n\n`getUtf8Encoder` and `getUtf8Decoder` functions are also available.\n\n## Data structures listing [!toc]\n\n### getArrayCodec [!toc] [#get-array-codec]\n\nThe `getArrayCodec` function accepts any codec of type `T` and returns a codec of type `Array`.\n\n```ts twoslash\nimport { getArrayCodec, getU8Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getArrayCodec(getU8Codec());\nconst bytes = codec.encode([1, 2, 3]); // 0x03000000010203\nconst array = codec.decode(bytes); // [1, 2, 3]\n```\n\nBy default, the size of the array is stored as a `u32` prefix before encoding the items.\n\n```ts twoslash\nimport { getArrayCodec, getU8Codec } from '@solana/kit';\n// ---cut-before---\ngetArrayCodec(getU8Codec()).encode([1, 2, 3]);\n// 0x03000000010203\n// | └-- 3 items of 1 byte each.\n// └-- 4-byte prefix telling us to read 3 items.\n```\n\nHowever, you may use the `size` option to configure this behaviour. It can be one of the following three strategies:\n\n- `Codec`: When a number codec is provided, that codec will be used to encode and decode the size prefix.\n- `number`: When a number is provided, the codec will expect a fixed number of items in the array. An error will be thrown when trying to encode an array of a different length.\n- `\"remainder\"`: When the string `\"remainder\"` is passed as a size, the codec will use the remainder of the bytes to encode/decode its items. This means the size is not stored or known in advance but simply inferred from the rest of the buffer. For instance, if we have an array of `u16` numbers and 10 bytes remaining, we know there are 5 items in this array.\n\n```ts twoslash\nimport { getArrayCodec, getU8Codec, getU16Codec } from '@solana/kit';\n// ---cut-before---\ngetArrayCodec(getU8Codec(), { size: getU16Codec() }).encode([1, 2, 3]);\n// 0x0300010203\n// | └-- 3 items of 1 byte each.\n// └-- 2-byte prefix telling us to read 3 items.\n\ngetArrayCodec(getU8Codec(), { size: 3 }).encode([1, 2, 3]);\n// 0x010203\n// └-- 3 items of 1 byte each. There must always be 3 items in the array.\n\ngetArrayCodec(getU8Codec(), { size: 'remainder' }).encode([1, 2, 3]);\n// 0x010203\n// └-- 3 items of 1 byte each. The size is inferred from the remainder of the bytes.\n```\n\n`getArrayEncoder` and `getArrayDecoder` functions are also available.\n\n### getBitArrayCodec [!toc] [#get-bit-array-codec]\n\nThe `getBitArrayCodec` function returns a codec that encodes and decodes an array of booleans such that each boolean is represented by a single bit. It requires the size of the codec in bytes and an optional `backward` flag that can be used to reverse the order of the bits.\n\n```ts twoslash\nimport { getBitArrayCodec } from '@solana/kit';\n// ---cut-before---\nconst booleans = [true, false, true, false, true, false, true, false];\n\ngetBitArrayCodec(1).encode(booleans);\n// 0xaa or 0b10101010\n\ngetBitArrayCodec(1, { backward: true }).encode(booleans);\n// 0x55 or 0b01010101\n```\n\n`getBitArrayEncoder` and `getBitArrayDecoder` functions are also available.\n\n### getBooleanCodec [!toc] [#get-boolean-codec]\n\nThe `getBooleanCodec` function returns a `Codec` that stores the boolean as `0` or `1` using a `u8` number by default.\n\n```ts twoslash\nimport { getBooleanCodec } from '@solana/kit';\n// ---cut-before---\nconst codec = getBooleanCodec();\nconst bytes = codec.encode(true); // 0x01\nconst value = codec.decode(bytes); // true\n```\n\nYou may configure that behaviour by providing an explicit number codec as the `size` option of the `getBooleanCodec` function. That number codec will then be used to encode and decode the values `0` and `1` accordingly.\n\n```ts twoslash\nimport { getBooleanCodec, getU16Codec, getU32Codec } from '@solana/kit';\n// ---cut-before---\ngetBooleanCodec({ size: getU16Codec() }).encode(false); // 0x0000\ngetBooleanCodec({ size: getU16Codec() }).encode(true); // 0x0100\n\ngetBooleanCodec({ size: getU32Codec() }).encode(false); // 0x00000000\ngetBooleanCodec({ size: getU32Codec() }).encode(true); // 0x01000000\n```\n\n`getBooleanEncoder` and `getBooleanDecoder` functions are also available.\n\n### getBytesCodec [!toc] [#get-bytes-codec]\n\nThe `getBytesCodec` function returns a `Codec` meaning it converts `Uint8Arrays` to and from… `Uint8Arrays`! Whilst this might seem a bit useless, it can be useful when composed into other codecs. For example, you could use it in a struct codec to say that a particular field should be left unserialised.\n\n```ts twoslash\nimport { getBytesCodec } from '@solana/kit';\n// ---cut-before---\nconst codec = getBytesCodec();\nconst bytes = codec.encode(new Uint8Array([42])); // 0x2a\nconst value = codec.decode(bytes); // 0x2a\n```\n\nThe `getBytesCodec` function will encode and decode `Uint8Arrays` using as many bytes as necessary. If you'd like to restrict the number of bytes used by this codec, you may combine it with utilities such as [`fixCodecSize`](#fix-codec-size), [`addCodecSizePrefix`](#add-codec-size-prefix) or [`addCodecSentinel`](#add-codec-sentinel).\n\n```ts twoslash\nimport {\n getBytesCodec,\n fixCodecSize,\n addCodecSizePrefix,\n getU32Codec,\n addCodecSentinel,\n} from '@solana/kit';\n// ---cut-before---\nconst value = new Uint8Array([42, 43]); // 0x2a2b\n\nfixCodecSize(getBytesCodec(), 4).encode(value);\n// 0x2a2b0000 (padded to 4 bytes)\n\naddCodecSizePrefix(getBytesCodec(), getU32Codec()).encode(value);\n// 0x020000002a2b\n// | └-- The 2 bytes of content.\n// └-- 4-byte prefix telling us to read 2 bytes.\n\naddCodecSentinel(getBytesCodec(), new Uint8Array([0xff, 0xff])).encode(value);\n// 0x2a2bffff\n// | └-- The sentinel signaling the end of the content.\n// └-- The 2 bytes of content.\n```\n\n`getBytesEncoder` and `getBytesDecoder` functions are also available.\n\n### getConstantCodec [!toc] [#get-constant-codec]\n\nThe `getConstantCodec` function accepts any `Uint8Array` and returns a `Codec`. When encoding, it will set the provided `Uint8Array` as-is. When decoding, it will assert that the next bytes contain the provided `Uint8Array` and move the offset forward.\n\n```ts twoslash\nimport { getConstantCodec } from '@solana/kit';\n// ---cut-before---\nconst codec = getConstantCodec(new Uint8Array([1, 2, 3]));\n\ncodec.encode(undefined); // 0x010203\ncodec.decode(new Uint8Array([1, 2, 3])); // undefined\ncodec.decode(new Uint8Array([1, 2, 4])); // Throws an error.\n```\n\n`getConstantEncoder` and `getConstantDecoder` functions are also available.\n\n### getDiscriminatedUnionCodec [!toc] [#get-discriminated-union-codec]\n\nIn Rust, enums are powerful data types whose variants can be one of the following:\n\n- An empty variant — e.g. `enum Message { Quit }`.\n- A tuple variant — e.g. `enum Message { Write(String) }`.\n- A struct variant — e.g. `enum Message { Move { x: i32, y: i32 } }`.\n\nWhilst we do not have such powerful enums in JavaScript, we can emulate them in TypeScript using a union of objects such that each object is differentiated by a specific field. **We call this a discriminated union**.\n\nWe use a special field named `__kind` to distinguish between the different variants of a discriminated union. Additionally, since all variants are objects, we can use a `fields` property to wrap the array of tuple variants. Here is an example.\n\n```ts twoslash\ntype Message =\n | { __kind: 'quit' } // Empty variant.\n | { __kind: 'write'; fields: [string] } // Tuple variant.\n | { __kind: 'move'; x: number; y: number }; // Struct variant.\n```\n\nThe `getDiscriminatedUnionCodec` function helps us encode and decode these discriminated unions.\n\nIt requires the discriminator and codec of each variant as a first argument. Similarly to the [getStructCodec](#get-struct-codec), these are defined as an array of variant tuples where the first item is the discriminator of the variant and the second item is its codec. Since empty variants do not have data to encode, they simply use the [getUnitCodec](#get-unit-codec) which does nothing.\n\nHere is how we can create a discriminated union codec for our previous example.\n\n```ts twoslash\nimport {\n getDiscriminatedUnionCodec,\n getUnitCodec,\n getStructCodec,\n getTupleCodec,\n getUtf8Codec,\n getU32Codec,\n addCodecSizePrefix,\n getI32Codec,\n} from '@solana/kit';\n// ---cut-before---\nconst messageCodec = getDiscriminatedUnionCodec([\n // Empty variant.\n ['quit', getUnitCodec()],\n\n // Tuple variant.\n [\n 'write',\n getStructCodec([\n ['fields', getTupleCodec([addCodecSizePrefix(getUtf8Codec(), getU32Codec())])],\n ]),\n ],\n\n // Struct variant.\n [\n 'move',\n getStructCodec([\n ['x', getI32Codec()],\n ['y', getI32Codec()],\n ]),\n ],\n]);\n```\n\nAnd here's how we can use such a codec to encode discriminated unions. Notice that by default, they use a `u8` number prefix to distinguish between the different types of variants.\n\n```ts twoslash\nimport {\n getDiscriminatedUnionCodec,\n getUnitCodec,\n getStructCodec,\n getTupleCodec,\n getUtf8Codec,\n getU32Codec,\n addCodecSizePrefix,\n getI32Codec,\n} from '@solana/kit';\nconst messageCodec = getDiscriminatedUnionCodec([\n // Empty variant.\n ['quit', getUnitCodec()],\n\n // Tuple variant.\n [\n 'write',\n getStructCodec([\n ['fields', getTupleCodec([addCodecSizePrefix(getUtf8Codec(), getU32Codec())])],\n ]),\n ],\n\n // Struct variant.\n [\n 'move',\n getStructCodec([\n ['x', getI32Codec()],\n ['y', getI32Codec()],\n ]),\n ],\n]);\n// ---cut-before---\nmessageCodec.encode({ __kind: 'quit' });\n// 0x00\n// └-- 1-byte discriminator (Index 0 — the \"quit\" variant).\n\nmessageCodec.encode({ __kind: 'write', fields: ['Hi'] });\n// 0x01020000004869\n// | | └-- utf8 string content (\"Hi\").\n// | └-- u32 string prefix (2 characters).\n// └-- 1-byte discriminator (Index 1 — the \"write\" variant).\n\nmessageCodec.encode({ __kind: 'move', x: 5, y: 6 });\n// 0x020500000006000000\n// | | └-- Field y (6).\n// | └-- Field x (5).\n// └-- 1-byte discriminator (Index 2 — the \"move\" variant).\n```\n\nHowever, you may provide a number codec as the `size` option of the `getDiscriminatedUnionCodec` function to customise that behaviour.\n\n```ts twoslash\nimport {\n getDiscriminatedUnionCodec,\n getUnitCodec,\n getStructCodec,\n getTupleCodec,\n getUtf8Codec,\n getU32Codec,\n addCodecSizePrefix,\n getI32Codec,\n} from '@solana/kit';\nconst quitCodec = getUnitCodec();\nconst writeCodec = getStructCodec([\n ['fields', getTupleCodec([addCodecSizePrefix(getUtf8Codec(), getU32Codec())])],\n]);\nconst moveCodec = getStructCodec([\n ['x', getI32Codec()],\n ['y', getI32Codec()],\n]);\n// ---cut-before---\nconst u32MessageCodec = getDiscriminatedUnionCodec(\n [\n ['quit', quitCodec],\n ['write', writeCodec],\n ['move', moveCodec],\n ],\n { size: getU32Codec() },\n);\n\nu32MessageCodec.encode({ __kind: 'quit' });\n// 0x00000000\n// └------┘ 4-byte discriminator (Index 0).\n\nu32MessageCodec.encode({ __kind: 'write', fields: ['Hi'] });\n// 0x01000000020000004869\n// └------┘ 4-byte discriminator (Index 1).\n\nu32MessageCodec.encode({ __kind: 'move', x: 5, y: 6 });\n// 0x020000000500000006000000\n// └------┘ 4-byte discriminator (Index 2).\n```\n\nYou may also customize the discriminator property — which defaults to `__kind` — by providing the desired property name as the `discriminator` option like so:\n\n```ts twoslash\nimport {\n getDiscriminatedUnionCodec,\n getUnitCodec,\n getStructCodec,\n getTupleCodec,\n getUtf8Codec,\n getU32Codec,\n addCodecSizePrefix,\n getI32Codec,\n} from '@solana/kit';\nconst quitCodec = getUnitCodec();\nconst writeCodec = getStructCodec([\n ['fields', getTupleCodec([addCodecSizePrefix(getUtf8Codec(), getU32Codec())])],\n]);\nconst moveCodec = getStructCodec([\n ['x', getI32Codec()],\n ['y', getI32Codec()],\n]);\n// ---cut-before---\nconst messageCodec = getDiscriminatedUnionCodec(\n [\n ['quit', quitCodec],\n ['write', writeCodec],\n ['move', moveCodec],\n ],\n { discriminator: 'message' },\n);\n\nmessageCodec.encode({ message: 'quit' });\nmessageCodec.encode({ message: 'write', fields: ['Hi'] });\nmessageCodec.encode({ message: 'move', x: 5, y: 6 });\n```\n\nNote that, the discriminator value of a variant may be any scalar value — such as `number`, `bigint`, `boolean`, a JavaScript `enum`, etc. For instance, the following is also valid:\n\n```ts twoslash\nimport {\n getDiscriminatedUnionCodec,\n getUnitCodec,\n getStructCodec,\n getTupleCodec,\n getUtf8Codec,\n getU32Codec,\n addCodecSizePrefix,\n getI32Codec,\n} from '@solana/kit';\nconst quitCodec = getUnitCodec();\nconst writeCodec = getStructCodec([\n ['fields', getTupleCodec([addCodecSizePrefix(getUtf8Codec(), getU32Codec())])],\n]);\nconst moveCodec = getStructCodec([\n ['x', getI32Codec()],\n ['y', getI32Codec()],\n]);\n// ---cut-before---\nenum Message {\n Quit,\n Write,\n Move,\n}\nconst messageCodec = getDiscriminatedUnionCodec([\n [Message.Quit, quitCodec],\n [Message.Write, writeCodec],\n [Message.Move, moveCodec],\n]);\n\nmessageCodec.encode({ __kind: Message.Quit });\nmessageCodec.encode({ __kind: Message.Write, fields: ['Hi'] });\nmessageCodec.encode({ __kind: Message.Move, x: 5, y: 6 });\n```\n\n`getDiscriminatedUnionEncoder` and `getDiscriminatedUnionDecoder` functions are also available.\n\n### getEnumCodec [!toc] [#get-enum-codec]\n\nThe `getEnumCodec` function accepts a JavaScript enum constructor and returns a codec for encoding and decoding values of that enum.\n\n```ts twoslash\nimport { getEnumCodec } from '@solana/kit';\n// ---cut-before---\nenum Direction {\n Left,\n Right,\n}\n\nconst codec = getEnumCodec(Direction);\nconst bytes = codec.encode(Direction.Left); // 0x00\nconst direction = codec.decode(bytes); // Direction.Left\n```\n\nWhen encoding an enum, you may either provide the value of the enum variant — e.g. `Direction.Left` — or its key — e.g. `'Left'`.\n\n```ts twoslash\nimport { getEnumCodec } from '@solana/kit';\nenum Direction {\n Left,\n Right,\n}\n// ---cut-before---\ngetEnumCodec(Direction).encode(Direction.Left); // 0x00\ngetEnumCodec(Direction).encode(Direction.Right); // 0x01\ngetEnumCodec(Direction).encode('Left'); // 0x00\ngetEnumCodec(Direction).encode('Right'); // 0x01\n```\n\nBy default, a `u8` number is being used to store the enum value. However, a number codec may be passed as the `size` option to configure that behaviour.\n\n```ts twoslash\nimport { getEnumCodec, getU32Codec } from '@solana/kit';\nenum Direction {\n Left,\n Right,\n}\n// ---cut-before---\nconst u32DirectionCodec = getEnumCodec(Direction, { size: getU32Codec() });\nu32DirectionCodec.encode(Direction.Left); // 0x00000000\nu32DirectionCodec.encode(Direction.Right); // 0x01000000\n```\n\nThis function also works with lexical enums — e.g. `enum Direction { Left = '←' }` — explicit numerical enums — e.g. `enum Speed { Left = 50 }` — and hybrid enums with a mix of both.\n\n```ts twoslash\nimport { getEnumCodec } from '@solana/kit';\n// ---cut-before---\nenum Numbers {\n One,\n Five = 5,\n Six,\n Nine = 'nine',\n}\n\ngetEnumCodec(Numbers).encode(Numbers.One); // 0x00\ngetEnumCodec(Numbers).encode(Numbers.Five); // 0x01\ngetEnumCodec(Numbers).encode(Numbers.Six); // 0x02\ngetEnumCodec(Numbers).encode(Numbers.Nine); // 0x03\ngetEnumCodec(Numbers).encode('One'); // 0x00\ngetEnumCodec(Numbers).encode('Five'); // 0x01\ngetEnumCodec(Numbers).encode('Six'); // 0x02\ngetEnumCodec(Numbers).encode('Nine'); // 0x03\n```\n\nNotice how, by default, the index of the enum variant is used to encode the value of the enum. For instance, in the example above, `Numbers.Five` is encoded as `0x01` even though its value is `5`. This is also true for lexical enums.\n\nHowever, when dealing with numerical enums that have explicit values, you may use the `useValuesAsDiscriminators` option to encode the value of the enum variant instead of its index.\n\n```ts twoslash\nimport { getEnumCodec } from '@solana/kit';\n// ---cut-before---\nenum Numbers {\n One,\n Five = 5,\n Six,\n Nine = 9,\n}\n\nconst codec = getEnumCodec(Numbers, { useValuesAsDiscriminators: true });\ncodec.encode(Numbers.One); // 0x00\ncodec.encode(Numbers.Five); // 0x05\ncodec.encode(Numbers.Six); // 0x06\ncodec.encode(Numbers.Nine); // 0x09\ncodec.encode('One'); // 0x00\ncodec.encode('Five'); // 0x05\ncodec.encode('Six'); // 0x06\ncodec.encode('Nine'); // 0x09\n```\n\nNote that when using the `useValuesAsDiscriminators` option on an enum that contains a lexical value, an error will be thrown.\n\n```ts twoslash\nimport { getEnumCodec } from '@solana/kit';\n// ---cut-before---\nenum Lexical {\n One,\n Two = 'two',\n}\ngetEnumCodec(Lexical, { useValuesAsDiscriminators: true }); // Throws an error.\n```\n\n`getEnumEncoder` and `getEnumDecoder` functions are also available.\n\n### getHiddenPrefixCodec [!toc] [#get-hidden-prefix-codec]\n\nThe `getHiddenPrefixCodec` function allow us to prepend a list of hidden `Codec` to a given codec.\n\nWhen encoding, the hidden codecs will be encoded before the main codec and the offset will be moved accordingly. When decoding, the hidden codecs will be decoded but only the result of the main codec will be returned. This is particularly helpful when creating data structures that include constant values that should not be included in the final type.\n\n```ts twoslash\nimport { getHiddenPrefixCodec, getConstantCodec, getU16Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getHiddenPrefixCodec(getU16Codec(), [\n getConstantCodec(new Uint8Array([1, 2, 3])),\n getConstantCodec(new Uint8Array([4, 5, 6])),\n]);\n\ncodec.encode(42);\n// 0x0102030405062a00\n// | | └-- Our main u16 codec (value = 42).\n// | └-- Our second hidden prefix codec.\n// └-- Our first hidden prefix codec.\n\ncodec.decode(new Uint8Array([1, 2, 3, 4, 5, 6, 42, 0])); // 42\n```\n\n`getHiddenPrefixEncoder` and `getHiddenPrefixDecoder` functions are also available.\n\n### getHiddenSuffixCodec [!toc] [#get-hidden-suffix-codec]\n\nThe `getHiddenSuffixCodec` function allow us to append a list of hidden `Codec` to a given codec.\n\nWhen encoding, the hidden codecs will be encoded after the main codec and the offset will be moved accordingly. When decoding, the hidden codecs will be decoded but only the result of the main codec will be returned. This is particularly helpful when creating data structures that include constant values that should not be included in the final type.\n\n```ts twoslash\nimport { getHiddenSuffixCodec, getConstantCodec, getU16Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getHiddenSuffixCodec(getU16Codec(), [\n getConstantCodec(new Uint8Array([1, 2, 3])),\n getConstantCodec(new Uint8Array([4, 5, 6])),\n]);\n\ncodec.encode(42);\n// 0x2a00010203040506\n// | | └-- Our second hidden suffix codec.\n// | └-- Our first hidden suffix codec.\n// └-- Our main u16 codec (value = 42).\n\ncodec.decode(new Uint8Array([42, 0, 1, 2, 3, 4, 5, 6])); // 42\n```\n\n`getHiddenSuffixEncoder` and `getHiddenSuffixDecoder` functions are also available.\n\n### getLiteralUnionCodec [!toc] [#get-literal-union-codec]\n\nThe `getLiteralUnionCodec` function accepts an array of literal values — such as `string`, `number`, `boolean`, etc. — and returns a codec that encodes and decodes such values by using their index in the array. It uses TypeScript unions to represent all the possible values.\n\n```ts twoslash\nimport { getLiteralUnionCodec, FixedSizeCodec } from '@solana/kit';\n// ---cut-before---\nconst codec = getLiteralUnionCodec(['left', 'right', 'up', 'down']);\ncodec satisfies FixedSizeCodec<'left' | 'right' | 'up' | 'down'>;\n\nconst bytes = codec.encode('left'); // 0x00\nconst value = codec.decode(bytes); // 'left'\n```\n\nIt uses a `u8` number by default to store the index of the value. However, you may provide a number codec as the `size` option of the `getLiteralUnionCodec` function to customise that behaviour.\n\n```ts twoslash\nimport { getLiteralUnionCodec, getU32Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getLiteralUnionCodec(['left', 'right', 'up', 'down'], {\n size: getU32Codec(),\n});\n\ncodec.encode('left'); // 0x00000000\ncodec.encode('right'); // 0x01000000\ncodec.encode('up'); // 0x02000000\ncodec.encode('down'); // 0x03000000\n```\n\n`getLiteralUnionEncoder` and `getLiteralUnionDecoder` functions are also available.\n\n### getMapCodec [!toc] [#get-map-codec]\n\nThe `getMapCodec` function accepts two codecs of type `K` and `V` and returns a codec of type `Map`.\n\n```ts twoslash\nimport { getMapCodec, getU8Codec, getUtf8Codec, fixCodecSize } from '@solana/kit';\n// ---cut-before---\nconst keyCodec = fixCodecSize(getUtf8Codec(), 8);\nconst valueCodec = getU8Codec();\nconst codec = getMapCodec(keyCodec, valueCodec);\n\nconst bytes = codec.encode(new Map([['alice', 42]])); // 0x01000000616c6963650000002a\nconst map = codec.decode(bytes); // new Map([[\"alice\", 42]])\n```\n\nEach entry (key/value pair) is encoded one after the other with the key first and the value next. By default, the size of the map is stored as a `u32` prefix before encoding the entries.\n\n```ts twoslash\nimport { getMapCodec, getU8Codec, getUtf8Codec, fixCodecSize } from '@solana/kit';\n// ---cut-before---\nconst codec = getMapCodec(fixCodecSize(getUtf8Codec(), 8), getU8Codec());\nconst myMap = new Map();\nmyMap.set('alice', 42);\nmyMap.set('bob', 5);\n\ncodec.encode(myMap);\n// 0x02000000616c6963650000002a626f62000000000005\n// | | | | └-- 2nd entry value (5).\n// | | | └-- 2nd entry key (\"bob\").\n// | | └-- 1st entry value (42).\n// | └-- 1st entry key (\"alice\").\n// └-- 4-byte prefix telling us to read 2 map entries.\n```\n\nHowever, you may use the `size` option to configure this behaviour. It can be one of the following three strategies:\n\n- `Codec`: When a number codec is provided, that codec will be used to encode and decode the size prefix.\n- `number`: When a number is provided, the codec will expect a fixed number of entries in the map. An error will be thrown when trying to encode a map of a different length.\n- `\"remainder\"`: When the string `\"remainder\"` is passed as a size, the codec will use the remainder of the bytes to encode/decode its entries. This means the size is not stored or known in advance but simply inferred from the rest of the buffer. For instance, if we have a map of `u16` numbers and 10 bytes remaining, we know there are 5 entries in this map.\n\n```ts twoslash\nimport { getMapCodec, getU8Codec, getU16Codec, fixCodecSize, getUtf8Codec } from '@solana/kit';\n// ---cut-before---\nconst keyCodec = fixCodecSize(getUtf8Codec(), 8);\nconst valueCodec = getU8Codec();\n\nconst myMap = new Map();\nmyMap.set('alice', 42);\nmyMap.set('bob', 5);\n\ngetMapCodec(keyCodec, valueCodec, { size: getU16Codec() }).encode(myMap);\n// 0x0200616c6963650000002a626f62000000000005\n// | | └-- Second entry.\n// | └-- First entry.\n// └-- 2-byte prefix telling us to read 2 entries.\n\ngetMapCodec(keyCodec, valueCodec, { size: 3 }).encode(myMap);\n// 0x616c6963650000002a626f62000000000005\n// | └-- Second entry.\n// └-- First entry.\n// There must always be 2 entries in the map.\n\ngetMapCodec(keyCodec, valueCodec, { size: 'remainder' }).encode(myMap);\n// 0x616c6963650000002a626f62000000000005\n// | └-- Second entry.\n// └-- First entry.\n// The size is inferred from the remainder of the bytes.\n```\n\n`getMapEncoder` and `getMapDecoder` functions are also available.\n\n### getNullableCodec [!toc] [#get-nullable-codec]\n\nThe `getNullableCodec` function accepts a codec of type `T` and returns a codec of type `T | null`. It stores whether or not the item exists as a boolean prefix using a `u8` by default.\n\n```ts twoslash\nimport { getNullableCodec, getU32Codec, addCodecSizePrefix, getUtf8Codec } from '@solana/kit';\n// ---cut-before---\nconst stringCodec = addCodecSizePrefix(getUtf8Codec(), getU32Codec());\n\ngetNullableCodec(stringCodec).encode('Hi');\n// 0x01020000004869\n// | | └-- utf8 string content (\"Hi\").\n// | └-- u32 string prefix (2 characters).\n// └-- 1-byte prefix (true — The item exists).\n\ngetNullableCodec(stringCodec).encode(null);\n// 0x00\n// └-- 1-byte prefix (false — The item is null).\n```\n\nYou may provide a number codec as the `prefix` option of the `getNullableCodec` function to configure how to store the boolean prefix.\n\n```ts twoslash\nimport { getNullableCodec, getU32Codec, addCodecSizePrefix, getUtf8Codec } from '@solana/kit';\nconst stringCodec = addCodecSizePrefix(getUtf8Codec(), getU32Codec());\n// ---cut-before---\nconst u32NullableStringCodec = getNullableCodec(stringCodec, {\n prefix: getU32Codec(),\n});\n\nu32NullableStringCodec.encode('Hi');\n// 0x01000000020000004869\n// └------┘ 4-byte prefix (true).\n\nu32NullableStringCodec.encode(null);\n// 0x00000000\n// └------┘ 4-byte prefix (false).\n```\n\nAdditionally, if the item is a `FixedSizeCodec`, you may set the `noneValue` option to `\"zeroes\"` to also make the returned nullable codec a `FixedSizeCodec`. To do so, it will pad `null` values with zeroes to match the length of existing values.\n\n```ts twoslash\nimport { getNullableCodec, fixCodecSize, getUtf8Codec } from '@solana/kit';\n// ---cut-before---\nconst fixedNullableStringCodec = getNullableCodec(\n fixCodecSize(getUtf8Codec(), 8), // Only works with fixed-size items.\n { noneValue: 'zeroes' },\n);\n\nfixedNullableStringCodec.encode('Hi');\n// 0x014869000000000000\n// | └-- 8-byte utf8 string content (\"Hi\").\n// └-- 1-byte prefix (true — The item exists).\n\nfixedNullableStringCodec.encode(null);\n// 0x000000000000000000\n// | └-- 8-byte of padding to make a fixed-size codec.\n// └-- 1-byte prefix (false — The item is null).\n```\n\nThe `noneValue` option can also be set to an explicit byte array to use as the padding for `null` values. Note that, in this case, the returned codec will not be a `FixedSizeCodec` as the byte array representing `null` values may be of any length.\n\n```ts twoslash\nimport { getNullableCodec, getUtf8Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getNullableCodec(getUtf8Codec(), {\n noneValue: new Uint8Array([255]), // 0xff means null.\n});\n\ncodec.encode('Hi');\n// 0x014869\n// | └-- 2-byte utf8 string content (\"Hi\").\n// └-- 1-byte prefix (true — The item exists).\n\ncodec.encode(null);\n// 0x00ff\n// | └-- 1-byte representing null (0xff).\n// └-- 1-byte prefix (false — The item is null).\n```\n\nThe `prefix` option of the `getNullableCodec` function can also be set to `null`, meaning no prefix will be used to determine whether the item exists. In this case, the codec will rely on the `noneValue` option to determine whether the item is `null`.\n\n```ts twoslash\nimport { getNullableCodec, getU16Codec } from '@solana/kit';\n// ---cut-before---\nconst codecWithZeroNoneValue = getNullableCodec(getU16Codec(), {\n noneValue: 'zeroes', // 0x0000 means null.\n prefix: null,\n});\ncodecWithZeroNoneValue.encode(42); // 0x2a00\ncodecWithZeroNoneValue.encode(null); // 0x0000\n\nconst codecWithCustomNoneValue = getNullableCodec(getU16Codec(), {\n noneValue: new Uint8Array([255]), // 0xff means null.\n prefix: null,\n});\ncodecWithCustomNoneValue.encode(42); // 0x2a00\ncodecWithCustomNoneValue.encode(null); // 0xff\n```\n\nNote that if `prefix` is set to `null` and no `noneValue` is provided, the codec assumes that the item exists if and only if some remaining bytes are available to decode. This could be useful to describe data structures that may or may not have additional data to the end of the buffer.\n\n```ts\nconst codec = getNullableCodec(getU16Codec(), { prefix: null });\ncodec.encode(42); // 0x2a00\ncodec.encode(null); // Encodes nothing.\ncodec.decode(new Uint8Array([42, 0])); // 42\ncodec.decode(new Uint8Array([])); // null\n```\n\nTo recap, here are all the possible configurations of the `getNullableCodec` function, using a `u16` codec as an example.\n\n| `encode(42)` / `encode(null)` | No `noneValue` (default) | `noneValue: \"zeroes\"` | Custom `noneValue` (`0xff`) |\n| ----------------------------- | ------------------------ | --------------------------- | --------------------------- |\n| `u8` prefix (default) | `0x012a00` / `0x00` | `0x012a00` / `0x000000` | `0x012a00` / `0x00ff` |\n| Custom `prefix` (`u16`) | `0x01002a00` / `0x0000` | `0x01002a00` / `0x00000000` | `0x01002a00` / `0x0000ff` |\n| No `prefix` | `0x2a00` / `0x` | `0x2a00` / `0x0000` | `0x2a00` / `0xff` |\n\nNote that you might be interested in the Rust-like alternative version of nullable codecs, available as the [getOptionCodec](#get-option-codec) function.\n\n`getNullableEncoder` and `getNullableDecoder` functions are also available.\n\n### getOptionCodec [!toc] [#get-option-codec]\n\nThe `getOptionCodec` function accepts a codec of type `T` and returns a codec of type `Option` — as defined in the [`@solana/options`](https://github.com/anza-xyz/kit/tree/main/packages/options) package. Note that, when encoding, `T` or `null` may also be provided directly as input and will be interpreted as `Some(T)` or `None` respectively. However, when decoding, the output will always be an `Option` type.\n\nIt stores whether or not the item exists as a boolean prefix using a `u8` by default.\n\n```ts twoslash\nimport {\n getOptionCodec,\n getU32Codec,\n addCodecSizePrefix,\n getUtf8Codec,\n some,\n none,\n} from '@solana/kit';\n// ---cut-before---\nconst stringCodec = addCodecSizePrefix(getUtf8Codec(), getU32Codec());\n\ngetOptionCodec(stringCodec).encode('Hi');\ngetOptionCodec(stringCodec).encode(some('Hi'));\n// 0x01020000004869\n// | | └-- utf8 string content (\"Hi\").\n// | └-- u32 string prefix (2 characters).\n// └-- 1-byte prefix (Some).\n\ngetOptionCodec(stringCodec).encode(null);\ngetOptionCodec(stringCodec).encode(none());\n// 0x00\n// └-- 1-byte prefix (None).\n```\n\nYou may provide a number codec as the `prefix` option of the `getOptionCodec` function to configure how to store the boolean prefix.\n\n```ts twoslash\nimport {\n getOptionCodec,\n getU32Codec,\n addCodecSizePrefix,\n getUtf8Codec,\n some,\n none,\n} from '@solana/kit';\nconst stringCodec = addCodecSizePrefix(getUtf8Codec(), getU32Codec());\n// ---cut-before---\nconst u32OptionStringCodec = getOptionCodec(stringCodec, {\n prefix: getU32Codec(),\n});\n\nu32OptionStringCodec.encode(some('Hi'));\n// 0x01000000020000004869\n// └------┘ 4-byte prefix (Some).\n\nu32OptionStringCodec.encode(none());\n// 0x00000000\n// └------┘ 4-byte prefix (None).\n```\n\nAdditionally, if the item is a `FixedSizeCodec`, you may set the `noneValue` option to `\"zeroes\"` to also make the returned Option codec a `FixedSizeCodec`. To do so, it will pad `None` values with zeroes to match the length of existing values.\n\n```ts twoslash\nimport { getOptionCodec, fixCodecSize, getUtf8Codec, some, none } from '@solana/kit';\n// ---cut-before---\nconst codec = getOptionCodec(\n fixCodecSize(getUtf8Codec(), 8), // Only works with fixed-size items.\n { noneValue: 'zeroes' },\n);\n\ncodec.encode(some('Hi'));\n// 0x014869000000000000\n// | └-- 8-byte utf8 string content (\"Hi\").\n// └-- 1-byte prefix (Some).\n\ncodec.encode(none());\n// 0x000000000000000000\n// | └-- 8-byte of padding to make a fixed-size codec.\n// └-- 1-byte prefix (None).\n```\n\nThe `noneValue` option can also be set to an explicit byte array to use as the padding for `None` values. Note that, in this case, the returned codec will not be a `FixedSizeCodec` as the byte array representing `None` values may be of any length.\n\n```ts twoslash\nimport { getOptionCodec, getUtf8Codec, some, none } from '@solana/kit';\n// ---cut-before---\nconst codec = getOptionCodec(getUtf8Codec(), {\n noneValue: new Uint8Array([255]), // 0xff means None.\n});\n\ncodec.encode(some('Hi'));\n// 0x014869\n// | └-- 2-byte utf8 string content (\"Hi\").\n// └-- 1-byte prefix (Some).\n\ncodec.encode(none());\n// 0x00ff\n// | └-- 1-byte representing None (0xff).\n// └-- 1-byte prefix (None).\n```\n\nThe `prefix` option of the `getOptionCodec` function can also be set to `null`, meaning no prefix will be used to determine whether the item exists. In this case, the codec will rely on the `noneValue` option to determine whether the item is `None`.\n\n```ts twoslash\nimport { getOptionCodec, getU16Codec, some, none } from '@solana/kit';\n// ---cut-before---\nconst codecWithZeroNoneValue = getOptionCodec(getU16Codec(), {\n noneValue: 'zeroes', // 0x0000 means None.\n prefix: null,\n});\ncodecWithZeroNoneValue.encode(some(42)); // 0x2a00\ncodecWithZeroNoneValue.encode(none()); // 0x0000\n\nconst codecWithCustomNoneValue = getOptionCodec(getU16Codec(), {\n noneValue: new Uint8Array([255]), // 0xff means None.\n prefix: null,\n});\ncodecWithCustomNoneValue.encode(some(42)); // 0x2a00\ncodecWithCustomNoneValue.encode(none()); // 0xff\n```\n\nNote that if `prefix` is set to `null` and no `noneValue` is provided, the codec assume that the item exists if and only if some remaining bytes are available to decode. This could be useful to describe data structures that may or may not have additional data to the end of the buffer.\n\n```ts twoslash\nimport { getOptionCodec, getU16Codec, some, none } from '@solana/kit';\n// ---cut-before---\nconst codec = getOptionCodec(getU16Codec(), { prefix: null });\ncodec.encode(some(42)); // 0x2a00\ncodec.encode(none()); // Encodes nothing.\ncodec.decode(new Uint8Array([42, 0])); // some(42)\ncodec.decode(new Uint8Array([])); // none()\n```\n\nTo recap, here are all the possible configurations of the `getOptionCodec` function, using a `u16` codec as an example.\n\n| `encode(some(42))` / `encode(none())` | No `noneValue` (default) | `noneValue: \"zeroes\"` | Custom `noneValue` (`0xff`) |\n| ------------------------------------- | ------------------------ | --------------------------- | --------------------------- |\n| `u8` prefix (default) | `0x012a00` / `0x00` | `0x012a00` / `0x000000` | `0x012a00` / `0x00ff` |\n| Custom `prefix` (`u16`) | `0x01002a00` / `0x0000` | `0x01002a00` / `0x00000000` | `0x01002a00` / `0x0000ff` |\n| No `prefix` | `0x2a00` / `0x` | `0x2a00` / `0x0000` | `0x2a00` / `0xff` |\n\n`getOptionEncoder` and `getOptionDecoder` functions are also available.\n\n### getPatternMatchCodec [!toc] [#get-pattern-match-codec]\n\nThe `getPatternMatchCodec` function returns a codec that selects which variant codec to use based on pattern matching. It generalises [`getPredicateCodec`](#get-predicate-codec) from two variants to any number of variants.\n\nIt accepts an array of `[encodePredicate, decodePredicate, codec]` triples, where:\n\n- An encode predicate, that takes the value to encode and returns a boolean\n- A decode predicate, that takes a `ReadonlyUint8Array` and returns a boolean\n- A codec, that will be used when the corresponding predicate returns `true`\n\nPredicates are tested in order and the first match is used. If no predicate matches, a `SolanaError` is thrown.\n\n```ts twoslash\nimport { getPatternMatchCodec, getU8Codec, getU16Codec, getU32Codec, Codec } from '@solana/kit';\n\n// ---cut-before---\n\nconst codec: Codec = getPatternMatchCodec([\n [\n (value: number) => value < 256,\n bytes => bytes.length === 1,\n getU8Codec(),\n ],\n [\n (value: number) => value < 2 ** 16,\n bytes => bytes.length === 2,\n getU16Codec(),\n ],\n [\n (value: number) => value < 2 ** 32,\n bytes => bytes.length <= 4,\n getU32Codec(),\n ],\n]);\n\nconst u8Bytes = codec.encode(42) // 0x2a, encoded as u8\ncodec.decode(u8Bytes) // 42, decoded as u8\n\nconst u16Bytes = codec.encode(1000) // 0xe803, encoded as u16\ncodec.decode(u16Bytes) // 1000, decoded as u16\n\nconst u32Bytes = codec.encode(100_000) // 0xa0860100, encoded as u32\ncodec.decode(u32Bytes) // 100_000, decoded as u32\n```\n\n`getPatternMatchEncoder` and `getPatternMatchDecoder` functions are also available.\n\n### getPredicateCodec [!toc] [#get-predicate-codec]\n\nThe `getPredicateCodec` function returns a codec that switches between two different codecs, based on a predicate.\n\nIt accepts the following arguments:\n\n- An encode predicate, that takes a value of a given type and returns a boolean\n- A decode predicate, that takes a `ReadOnlyUint8Array` and returns a boolean \n- A codec, that will be used to encode if the encode predicate is true and will be used to decode if the decode predicate is true\n- A codec, that will be used to encode if the encode predicate is false and will be used to decode if the decode predicate is false\n\n```ts twoslash\nimport { getPredicateCodec, getU8Codec, getU32Codec, Codec } from '@solana/kit';\n\n// ---cut-before---\n\nconst codec: Codec = getPredicateCodec(\n (value: number) => value < 256,\n bytes => bytes.length === 1,\n getU8Codec(),\n getU32Codec(),\n);\n\nconst u8Bytes = codec.encode(42) // 0x2a, used u8 codec\ncodec.decode(u8Bytes) // 42, used u8 codec\n\nconst u32Bytes = codec.encode(1000) // 0xE8030000, used u32 codec\ncodec.decode(u32Bytes) // 1000, used u32 codec\n```\n\n`getPredicateEncoder` and `getPredicateDecoder` functions are also available.\n\n### getSetCodec [!toc] [#get-set-codec]\n\nThe `getSetCodec` function accepts any codec of type `T` and returns a codec of type `Set`.\n\n```ts twoslash\nimport { getSetCodec, getU8Codec } from '@solana/kit';\n// ---cut-before---\nconst codec = getSetCodec(getU8Codec());\nconst bytes = codec.encode(new Set([1, 2, 3])); // 0x03000000010203\nconst value = codec.decode(bytes); // new Set([1, 2, 3])\n```\n\nBy default, the size of the set is stored as a `u32` prefix before encoding the items.\n\n```ts twoslash\nimport { getSetCodec, getU8Codec } from '@solana/kit';\n// ---cut-before---\ngetSetCodec(getU8Codec()).encode(new Set([1, 2, 3]));\n// 0x03000000010203\n// | └-- 3 items of 1 byte each.\n// └-- 4-byte prefix telling us to read 3 items.\n```\n\nHowever, you may use the `size` option to configure this behaviour. It can be one of the following three strategies:\n\n- `Codec`: When a number codec is provided, that codec will be used to encode and decode the size prefix.\n- `number`: When a number is provided, the codec will expect a fixed number of items in the set. An error will be thrown when trying to encode a set of a different length.\n- `\"remainder\"`: When the string `\"remainder\"` is passed as a size, the codec will use the remainder of the bytes to encode/decode its items. This means the size is not stored or known in advance but simply inferred from the rest of the buffer. For instance, if we have a set of `u16` numbers and 10 bytes remaining, we know there are 5 items in this set.\n\n```ts twoslash\nimport { getSetCodec, getU8Codec, getU16Codec } from '@solana/kit';\n// ---cut-before---\ngetSetCodec(getU8Codec(), { size: getU16Codec() }).encode(new Set([1, 2, 3]));\n// 0x0300010203\n// | └-- 3 items of 1 byte each.\n// └-- 2-byte prefix telling us to read 3 items.\n\ngetSetCodec(getU8Codec(), { size: 3 }).encode(new Set([1, 2, 3]));\n// 0x010203\n// └-- 3 items of 1 byte each. There must always be 3 items in the set.\n\ngetSetCodec(getU8Codec(), { size: 'remainder' }).encode(new Set([1, 2, 3]));\n// 0x010203\n// └-- 3 items of 1 byte each. The size is inferred from the remainder of the bytes.\n```\n\n`getSetEncoder` and `getSetDecoder` functions are also available.\n\n### getStructCodec [!toc] [#get-struct-codec]\n\nThe `getStructCodec` function accepts any number of field codecs and returns a codec for an object containing all these fields. Each provided field is an array such that the first item is the name of the field and the second item is the codec used to encode and decode that field type.\n\n```ts twoslash\nimport {\n getStructCodec,\n getU8Codec,\n getUtf8Codec,\n addCodecSizePrefix,\n Codec,\n getU32Codec,\n} from '@solana/kit';\n// ---cut-before---\ntype Person = { name: string; age: number };\nconst personCodec: Codec = getStructCodec([\n ['name', addCodecSizePrefix(getUtf8Codec(), getU32Codec())],\n ['age', getU8Codec()],\n]);\n\nconst bytes = personCodec.encode({ name: 'alice', age: 42 });\n// 0x05000000616c6963652a\n// | └-- Age field.\n// └-- Name field.\n\nconst person = personCodec.decode(bytes);\n// { name: \"alice\", age: 42 }\n```\n\n`getStructEncoder` and `getStructDecoder` functions are also available.\n\n### getTupleCodec [!toc] [#get-tuple-codec]\n\nThe `getTupleCodec` function accepts any number of codecs — `T`, `U`, `V`, etc. — and returns a tuple codec of type `[T, U, V, …]` such that each item is in the order of the provided codecs.\n\n```ts twoslash\nimport {\n getTupleCodec,\n getU8Codec,\n getU64Codec,\n addCodecSizePrefix,\n getUtf8Codec,\n getU32Codec,\n} from '@solana/kit';\n// ---cut-before---\nconst tupleCodec = getTupleCodec([\n addCodecSizePrefix(getUtf8Codec(), getU32Codec()),\n getU8Codec(),\n getU64Codec(),\n]);\n\nconst bytes = tupleCodec.encode(['alice', 42, 123]);\n// 0x05000000616c6963652a7b00000000000000\n// | | └-- 3rd item (123).\n// | └-- 2nd item (42).\n// └-- 1st item (\"alice\").\n\nconst value = tupleCodec.decode(bytes);\n// [\"alice\", 42, 123]\n```\n\n`getTupleEncoder` and `getTupleDecoder` functions are also available.\n\n### getUnionCodec [!toc] [#get-union-codec]\n\nThe `getUnionCodec` is a lower-lever codec helper that can be used to encode/decode any TypeScript union.\n\nIt accepts the following arguments:\n\n- An array of codecs, each defining a variant of the union.\n- A `getIndexFromValue` function which, given a value of the union, returns the index of the codec that should be used to encode that value.\n- A `getIndexFromBytes` function which, given the byte array to decode at a given offset, returns the index of the codec that should be used to decode the next bytes.\n\n```ts twoslash\nimport { getUnionCodec, getU16Codec, getBooleanCodec, Codec } from '@solana/kit';\n// ---cut-before---\nconst codec: Codec = getUnionCodec(\n [getU16Codec(), getBooleanCodec()],\n (value) => (typeof value === 'number' ? 0 : 1),\n (bytes, offset) => (bytes.slice(offset).length > 1 ? 0 : 1),\n);\n\ncodec.encode(42); // 0x2a00\ncodec.encode(true); // 0x01\n```\n\n`getUnionEncoder` and `getUnionDecoder` functions are also available.\n\n### getUnitCodec [!toc] [#get-unit-codec]\n\nThe `getUnitCodec` function returns a `Codec` that encodes `undefined` into an empty `Uint8Array` and returns `undefined` without consuming any bytes when decoding. This is more of a low-level codec that can be used internally by other codecs. For instance, this is how [getDiscriminatedUnionCodec](#get-discriminated-union-codec) describes the codecs of empty variants.\n\n```ts twoslash\nimport { getUnitCodec } from '@solana/kit';\nconst anyBytes = null as unknown as Uint8Array;\n// ---cut-before---\ngetUnitCodec().encode(undefined); // Empty Uint8Array\ngetUnitCodec().decode(anyBytes); // undefined\n```\n\n`getUnitEncoder` and `getUnitDecoder` functions are also available.\n" }, { "path": "docs/content/docs/advanced-guides/errors.mdx", "content": "---\ntitle: Errors\ndescription: Recover from errors in development and production\n---\n\n## Introduction\n\nThe ecosystem of packages based on Kit's error system benefit from strongly typed error data, and descriptive error messages. Its error messages get scrubbed from your production bundles, which means that the library of error messages can grow indefinitely without adding a single byte to your app.\n\n## Installation\n\nErrors are **included within the `@solana/kit` library** but you may also install them using their standalone package.\n\n```package-install\n@solana/errors\n```\n\n## What is a `SolanaError`?\n\nA `SolanaError` is a class made of three components:\n\n- An error **code**; found in the union named [`SolanaErrorCode`](/api/type-aliases/SolanaErrorCode)\n- An error **message**\n- Optional error **context**\n\nHere's an example of some code that responds to various errors, taking advantage of the error context offered by each one:\n\n```ts twoslash\nimport {\n Transaction,\n TransactionWithBlockhashLifetime,\n sendAndConfirmTransactionFactory,\n} from '@solana/kit';\nconst sendAndConfirmTransaction = null as unknown as ReturnType<\n typeof sendAndConfirmTransactionFactory\n>;\nconst transaction = null as unknown as Transaction & TransactionWithBlockhashLifetime;\n// ---cut-before---\nimport {\n assertIsSendableTransaction,\n isSolanaError,\n SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING,\n SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT,\n} from '@solana/kit';\n\ntry {\n assertIsSendableTransaction(transaction);\n await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });\n} catch (e) {\n if (isSolanaError(e, SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING)) {\n console.error(`Missing signatures for ${e.context.addresses.join(', ')}`);\n } else if (isSolanaError(e, SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT)) {\n console.error(\n `Transaction exceeds size limit of ${e.context.transactionSizeLimit} bytes. ` +\n `Actual size: ${e.context.transactionSize}`,\n );\n }\n throw e;\n}\n```\n\n## Catching errors\n\nWhen you encounter an error, you can determine whether it is a `SolanaError` or not using the `isSolanaError()` function:\n\n```ts twoslash\nimport { isSolanaError } from '@solana/kit';\n\ntry {\n // ...\n} catch (e) {\n if (isSolanaError(e)) {\n // A Solana error was thrown\n } else {\n // Something else went wrong\n }\n}\n```\n\nWhen you have a strategy for handling a _particular_ error, you can supply that error's code as the second argument. This will both identify that error by code and refine the type of the `SolanaError` such that the shape of its `context` property becomes known to TypeScript.\n\n```ts twoslash\nimport { SolanaError } from '@solana/kit';\nconst e = null as unknown as SolanaError;\n// ---cut-before---\nimport {\n isSolanaError,\n SolanaErrorCode,\n SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING,\n} from '@solana/kit';\n\ntry {\n // ...\n} catch (e) {\n if (isSolanaError(e, SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING)) {\n // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n console.error(\n // Now TypeScript knows the shape of this error's context\n `Missing signatures for these addresses: [${e.context.addresses.join(', ')}]`,\n // ^^^^^^^^^\n );\n } else {\n // Something else went wrong\n }\n}\n```\n\nSome Solana errors have, as their root cause, another Solana error. One such example is during transaction simulation (preflight):\n\n```ts twoslash\nimport { Base64EncodedWireTransaction, Rpc, SendTransactionApi } from '@solana/kit';\nconst rpc = null as unknown as Rpc;\nconst wireTransaction = null as unknown as Base64EncodedWireTransaction;\n// ---cut-before---\nimport {\n isSolanaError,\n SOLANA_ERROR__INSTRUCTION_ERROR__COMPUTATIONAL_BUDGET_EXCEEDED,\n SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE,\n} from '@solana/kit';\n\ntry {\n const result = await rpc.sendTransaction(wireTransaction, {\n encoding: 'base64',\n skipPreflight: false,\n });\n} catch (e) {\n if (isSolanaError(e, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE)) {\n // Simulation failed, but why?\n const underlyingError = e.cause;\n if (\n isSolanaError(\n underlyingError,\n SOLANA_ERROR__INSTRUCTION_ERROR__COMPUTATIONAL_BUDGET_EXCEEDED,\n )\n ) {\n // Now we know the root cause of the simulation failure, and can advise the user\n }\n }\n}\n```\n\n## Failed transaction errors\n\nWhen a transaction fails to send, Kit raises one of two high-level error codes that wrap whatever actually went wrong with extra context useful for debugging.\n\n### `SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION` [#failed-to-send-transaction]\n\nThis is the error you get back when sending a single transaction fails. The message itself indicates whether the failure happened during preflight or after the transaction was submitted; the context exposes the underlying error, simulation logs, the preflight result when available, and the full `TransactionPlanResult` for deeper inspection.\n\n```ts twoslash\nimport { SolanaError } from '@solana/kit';\nconst error = null as unknown as SolanaError;\n// ---cut-before---\nimport { isSolanaError, SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION } from '@solana/kit';\n\nif (isSolanaError(error, SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION)) {\n console.error(error.message); // Includes \"(preflight)\" or the transaction signature.\n console.error('Cause:', error.cause); // The underlying error that triggered the failure.\n console.error('Logs:', error.context.logs); // Program logs, when available.\n console.error('Preflight:', error.context.preflightData); // Simulation result, when available.\n}\n```\n\nThe full `TransactionPlanResult` is also attached as `error.context.transactionPlanResult`, but it is non-enumerable so it does not pollute serialized errors. Cast it to [`TransactionPlanResult`](/api/type-aliases/TransactionPlanResult) when you need to walk the tree.\n\n### `SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS` [#failed-to-send-transactions]\n\nThe plural variant is raised when sending more than one transaction fails. Its context exposes a `failedTransactions` array — one entry per failure, with the underlying error, its position in the plan, simulation logs, and preflight data — plus the same non-enumerable `transactionPlanResult`.\n\n```ts twoslash\nimport { SolanaError } from '@solana/kit';\nconst error = null as unknown as SolanaError;\n// ---cut-before---\nimport { isSolanaError, SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS } from '@solana/kit';\n\nif (isSolanaError(error, SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS)) {\n for (const { error: cause, index, logs } of error.context.failedTransactions) {\n console.error(`Transaction #${index + 1} failed:`, cause.message);\n if (logs) console.error('Logs:', logs);\n }\n}\n```\n\nEach individual `error` in the array has already been unwrapped from any preflight wrapper, so you can branch on its code directly the same way you would for a standalone `SolanaError`.\n\n## Walking transaction plan results\n\nBoth failed-transaction errors above expose a `transactionPlanResult` you can inspect, and any successful multi-transaction send returns one directly. A [`TransactionPlanResult`](/api/type-aliases/TransactionPlanResult) is a tree that mirrors the original plan, with one of three statuses at each leaf — `successful`, `failed`, or `canceled`. Kit ships a small set of helpers for working with these trees without writing your own recursion.\n\n[`flattenTransactionPlanResult`](/api/functions/flattenTransactionPlanResult) collapses the tree into an array of leaf results, in the order they appear:\n\n```ts twoslash\nimport { TransactionPlanResult } from '@solana/kit';\nconst result = null as unknown as TransactionPlanResult;\n// ---cut-before---\nimport { flattenTransactionPlanResult } from '@solana/kit';\n\nfor (const single of flattenTransactionPlanResult(result)) {\n if (single.status === 'successful') {\n console.log('✅', single.context.signature);\n } else if (single.status === 'failed') {\n console.error('❌', single.error.message);\n } else {\n console.warn('⏭️', 'canceled');\n }\n}\n```\n\n[`summarizeTransactionPlanResult`](/api/functions/summarizeTransactionPlanResult) bucketizes the leaves into successful, failed, and canceled arrays, plus a single `successful` boolean for the overall outcome:\n\n```ts twoslash\nimport { TransactionPlanResult } from '@solana/kit';\nconst result = null as unknown as TransactionPlanResult;\n// ---cut-before---\nimport { summarizeTransactionPlanResult } from '@solana/kit';\n\nconst summary = summarizeTransactionPlanResult(result);\nconsole.log(`${summary.successfulTransactions.length} ok`);\nconsole.log(`${summary.failedTransactions.length} failed`);\nconsole.log(`${summary.canceledTransactions.length} canceled`);\n```\n\n[`getFirstFailedSingleTransactionPlanResult`](/api/functions/getFirstFailedSingleTransactionPlanResult) is a convenience for when you only care about the first failure in a tree — useful for surfacing a single root cause in error UI:\n\n```ts twoslash\nimport { TransactionPlanResult } from '@solana/kit';\nconst result = null as unknown as TransactionPlanResult;\n// ---cut-before---\nimport { getFirstFailedSingleTransactionPlanResult } from '@solana/kit';\n\nconst failed = getFirstFailedSingleTransactionPlanResult(result);\nconsole.error('First failure:', failed.error.message);\n```\n\nBy default, executors throw [`SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN`](/api/variables/SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN) on any failure. If you would rather inspect a partial result without a `try`/`catch`, [`passthroughFailedTransactionPlanExecution`](/api/functions/passthroughFailedTransactionPlanExecution) catches that error and returns the embedded `TransactionPlanResult` instead.\n\n```ts twoslash\nimport { TransactionPlanResult } from '@solana/kit';\nconst sendTransactionsPromise = null as unknown as Promise;\n// ---cut-before---\nimport { passthroughFailedTransactionPlanExecution } from '@solana/kit';\n\nconst result = await passthroughFailedTransactionPlanExecution(sendTransactionsPromise);\n```\n\n## Program-specific errors\n\nCodama-generated program packages export their own error helpers so you can identify and format program-specific failures. The pattern is consistent across packages: an `isXError(error, transactionMessage)` type guard, a `getXErrorMessage(code)` formatter, and an enum-shaped `XError` for individual codes (where `X` is the program name, e.g. `System` for `@solana-program/system`).\n\n```ts twoslash\nimport { SolanaError, TransactionMessage } from '@solana/kit';\nconst error = null as unknown as SolanaError;\nconst transactionMessage = null as unknown as TransactionMessage;\n// ---cut-before---\nimport { getSystemErrorMessage, isSystemError } from '@solana-program/system';\n\nif (isSystemError(error, transactionMessage)) {\n console.error(`System program error: ${getSystemErrorMessage(error.context.code)}`);\n console.error(`Failed instruction index: ${error.context.index}`);\n}\n```\n\nWhen sending a transaction or transaction plan, the program-specific error usually lives a few hops down the chain — typically as the `cause` of `SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION` or as one of the `failedTransactions[i].error` entries on the plural variant. Pair the helpers above with the failed-transaction errors documented earlier to surface actionable error messages to your users.\n\n## Error messages\n\n### In development mode\n\nWhen your bundler sets the constant `__DEV__` to `true`, every error message will be included in the bundle. As such, you will be able to read them in plain language wherever they appear.\n\n\n The size of your JavaScript bundle will increase significantly with the inclusion of every error\n message in development mode. Be sure to build your bundle with `__DEV__` set to `false` when you\n go to production.\n\n\n### In production mode\n\nWhen your bundler sets the constant `__DEV__` to `false`, error messages will be stripped from the bundle to save space. Only the error code will appear in the message when an error is encountered. Follow the instructions in the error message to convert the error code back to the human-readable error message.\n\nFor instance, to recover the error text for the error with code `7050005`:\n\n\n \n ```shell\n $ pnpm dlx @solana/errors decode -- 7050005\n\n [Decoded] Solana error code #7050005\n - Insufficient funds for fee\n ```\n\n \n \n ```shell\n $ npx @solana/errors decode -- 7050005\n\n [Decoded] Solana error code #7050005\n - Insufficient funds for fee\n ```\n\n \n \n ```shell\n $ yarn dlx @solana/errors decode -- 7050005\n\n [Decoded] Solana error code #7050005\n - Insufficient funds for fee\n ```\n\n \n \n ```shell\n $ bunx @solana/errors decode -- 7050005\n\n [Decoded] Solana error code #7050005\n - Insufficient funds for fee\n ```\n\n \n\n" }, { "path": "docs/content/docs/advanced-guides/index.mdx", "content": "---\ntitle: Advanced Guides\ndescription: Deep dives into Kit's fundamental building blocks\n---\n\nThese guides go deep on the core building blocks Kit is built from — transactions, signers, instruction plans, errors, codecs, keypairs, and more. Each one is a reference you can dip into when you want to understand exactly how something works under the hood.\n\nThe [Guides](/docs/guides) section covers the practical, task-oriented workflows most applications need day to day, and [plugin-based clients](/docs/plugins) take care of much of this automatically. Reach for the Advanced Guides when you are debugging an unexpected behavior, building a custom plugin, working without a client, or simply curious about what is happening underneath.\n\nYou can read these guides in any order — start with the topic that is closest to what you are working on.\n" }, { "path": "docs/content/docs/advanced-guides/instruction-plans.mdx", "content": "---\ntitle: Instruction Plans\ndescription: Compose instructions into multi-step operations\n---\n\n## Introduction\n\nInstruction plans describe operations that go beyond a single instruction and may even span multiple transactions.\n\nThey define a set of instructions that must be executed following a specific order. For instance, imagine we wanted to create an instruction plan for a simple escrow transfer between Alice and Bob. First, both would need to deposit their assets into a vault. This could happen in any order. Then and only then, the vault can be activated to switch the assets. Alice and Bob can now both withdraw each other's assets (again, in any order). Here's how we could describe an instruction plan for such an operation.\n\n```ts twoslash\nimport { Instruction, sequentialInstructionPlan, parallelInstructionPlan } from '@solana/kit';\nconst depositFromAlice = {} as unknown as Instruction;\nconst depositFromBob = {} as unknown as Instruction;\nconst activateVault = {} as unknown as Instruction;\nconst withdrawToAlice = {} as unknown as Instruction;\nconst withdrawToBob = {} as unknown as Instruction;\n// ---cut-before---\nconst instructionPlan = sequentialInstructionPlan([\n parallelInstructionPlan([depositFromAlice, depositFromBob]),\n activateVault,\n parallelInstructionPlan([withdrawToAlice, withdrawToBob]),\n]);\n```\n\nAs you can see, instruction plans don't concern themselves with:\n\n- Adding structural instructions — e.g. compute budget limits and prices.\n- Building transaction messages from these instructions. That is, planning how many can fit into a single instruction, adding a fee payer, a lifetime, etc.\n- Compiling, signing and sending transactions to the network.\n\nInstead, they solely focus on describing operations and delegate all that to two components introduced in this package:\n\n- **Transaction planner**: builds transaction messages from an instruction plan and returns an appropriate transaction plan.\n- **Transaction plan executor**: compiles, signs and sends transaction plans and returns a detailed result of this operation.\n\n```ts twoslash\nimport { TransactionPlanner, TransactionPlanExecutor, InstructionPlan } from '@solana/kit';\nconst instructionPlan = {} as unknown as InstructionPlan;\nconst transactionPlanner = {} as unknown as TransactionPlanner;\nconst transactionPlanExecutor = {} as unknown as TransactionPlanExecutor;\n// ---cut-before---\n// Plan instructions into transactions.\nconst transactionPlan = await transactionPlanner(instructionPlan);\n\n// Execute transactions.\nconst transactionPlanResult = await transactionPlanExecutor(transactionPlan);\n```\n\nThis separation of concerns not only improves the developer experience but also allows program maintainers to offer helper functions that go beyond a single instruction, while leaving their consumers to decide how they want these operations to materialise.\n\n## Installation\n\nInstruction plans are **included within the `@solana/kit` library** but you may also install them using their standalone package.\n\n```package-install\n@solana/instruction-plans\n```\n\n## Creating instruction plans\n\nThis package offers several helpers to help you compose your own instruction plans. Let's have a look at them.\n\n### Single instructions\n\nThe most trivial way to create an instruction plan is to use the `singleInstructionPlan` helper to create a plan with only one instruction.\n\n```ts twoslash\nimport { singleInstructionPlan, Instruction } from '@solana/kit';\nconst transferSol = {} as unknown as Instruction;\n// ---cut-before---\nconst instructionPlan = singleInstructionPlan(transferSol);\n```\n\n### Sequential plans\n\nThe `sequentialInstructionPlan` helper allows you to create plans from other plans that must be executed sequentially. Therefore, in the example below, we guarantee that Bob will receive assets from Alice before sending them to Carla.\n\n```ts twoslash\nimport { singleInstructionPlan, sequentialInstructionPlan, Instruction } from '@solana/kit';\nconst transferFromAliceToBob = {} as unknown as Instruction;\nconst transferFromBobToCarla = {} as unknown as Instruction;\n// ---cut-before---\nconst instructionPlan = sequentialInstructionPlan([\n singleInstructionPlan(transferFromAliceToBob),\n singleInstructionPlan(transferFromBobToCarla),\n]);\n```\n\nNote that the `sequentialInstructionPlan` helper also accept `Instruction` objects directly and automatically wraps them in `singleInstructionPlans`. Therefore the following is equivalent to the previous example.\n\n```ts twoslash\nimport { sequentialInstructionPlan, Instruction } from '@solana/kit';\nconst transferFromAliceToBob = {} as unknown as Instruction;\nconst transferFromBobToCarla = {} as unknown as Instruction;\n// ---cut-before---\nconst instructionPlan = sequentialInstructionPlan([transferFromAliceToBob, transferFromBobToCarla]);\n```\n\nA `nonDivisibleSequentialInstructionPlan` helper is also available to define sequential plans whose inner instructions should all be executed atomically. That is, either in a single transaction or in a transaction bundle when not possible.\n\n```ts twoslash\nimport { nonDivisibleSequentialInstructionPlan, Instruction } from '@solana/kit';\nconst createAccount = {} as unknown as Instruction;\nconst initializeMint = {} as unknown as Instruction;\n// ---cut-before---\nconst instructionPlan = nonDivisibleSequentialInstructionPlan([createAccount, initializeMint]);\n```\n\nIn this example, we know that both instruction will either succeed or fail together.\n\n### Parallel plans\n\nThe `parallelInstructionPlan` function can be used to create plans from other plans that can be executed in parallel. This means direct children of this plan can be executed in separate parallel transactions without consequence. For instance, in the example below, Alice can transfer assets to both Bob and Carla in any order without affecting the final outcome.\n\n```ts twoslash\nimport { singleInstructionPlan, parallelInstructionPlan, Instruction } from '@solana/kit';\nconst transferFromAliceToBob = {} as unknown as Instruction;\nconst transferFromAliceToCarla = {} as unknown as Instruction;\n// ---cut-before---\nconst instructionPlan = parallelInstructionPlan([\n singleInstructionPlan(transferFromAliceToBob),\n singleInstructionPlan(transferFromAliceToCarla),\n]);\n```\n\nThe `parallelInstructionPlan` also accepts `Instruction` object directly and therefore the previous example can be simplified as:\n\n```ts twoslash\nimport { parallelInstructionPlan, Instruction } from '@solana/kit';\nconst transferFromAliceToBob = {} as unknown as Instruction;\nconst transferFromAliceToCarla = {} as unknown as Instruction;\n// ---cut-before---\nconst instructionPlan = parallelInstructionPlan([transferFromAliceToBob, transferFromAliceToCarla]);\n```\n\n### Message packer plans\n\nMessage packer plans are a bit special. They can dynamically pack instructions into transaction messages. This is particularly useful when packing instructions whose size will vary based on the available space left on the transaction message being packed.\n\nFor instance, imagine a `write` instruction on a program that gradually write data from instructions into a buffer account. The instruction data used in this case will ideally be as long as the transaction message can fit. Using the `getLinearMessagePackerInstructionPlan` helper, we can create an instruction plan that does just that.\n\n```ts twoslash\nimport { getLinearMessagePackerInstructionPlan, Instruction } from '@solana/kit';\nconst dataToWrite = {} as unknown as Uint8Array;\nconst getWriteInstruction = {} as unknown as (params: {\n offset: number;\n data: Uint8Array;\n}) => Instruction;\n// ---cut-before---\nconst instructionPlan = getLinearMessagePackerInstructionPlan({\n totalLength: dataToWrite.length,\n getInstruction: (offset, length) =>\n getWriteInstruction({\n offset,\n data: dataToWrite.slice(offset, offset + length),\n }),\n});\n```\n\nAs you can see, the `getLinearMessagePackerInstructionPlan` helper accepts a `totalLength` attribute representing the total amount of bytes we eventually want to write to the buffer. The purpose of the `getInstruction` function is then to generate these `write` instructions at the provided positions.\n\nThere also exists a `getReallocMessagePackerInstructionPlan` helper that works similarly but whose purpose is to pack multiple realloc instructions to help resize an account.\n\n```ts twoslash\nimport { getReallocMessagePackerInstructionPlan, Instruction } from '@solana/kit';\nconst additionalDataSize = {} as unknown as number;\nconst getExtendInstruction = {} as unknown as (params: { length: number }) => Instruction;\n// ---cut-before---\nconst instructionPlan = getReallocMessagePackerInstructionPlan({\n totalSize: additionalDataSize,\n getInstruction: (size) => getExtendInstruction({ length: size }),\n});\n```\n\nWhilst these helpers are fairly situational, you can create any custom message packer as long as you implement the following interfaces.\n\n```ts twoslash\nimport { TransactionMessage, TransactionMessageWithFeePayer } from '@solana/kit';\n// ---cut-before---\ntype MessagePackerInstructionPlan = {\n getMessagePacker: () => MessagePacker;\n kind: 'messagePacker';\n};\n\ntype MessagePacker = {\n done: () => boolean;\n packMessageToCapacity: (\n transactionMessage: TransactionMessage & TransactionMessageWithFeePayer,\n ) => TransactionMessage & TransactionMessageWithFeePayer;\n};\n```\n\nMost of your custom logic will live in the `packMessageToCapacity` function whose purpose is to pack the provided message with as many instruction datas as possible or throw when it isn't achievable. The `done` function lets us know if there is any instruction data left to pack. See [`MessagePacker`](/api/type-aliases/MessagePacker) for more information.\n\n### Combining plans\n\nIt is worth noting that more complex operations can be created by combining plans together. For instance, the following plan will:\n\n- Create two accounts in parallel, one Buffer account and one Metadata account.\n - The Buffer account will be written to via multiple parallel `write` instructions.\n - The Metadata account will be created and initialized atomically.\n- Once both of these accounts are created, the data in the Buffer account will be used to set the data in the Metadata account before being closed.\n\n```ts twoslash\nimport {\n sequentialInstructionPlan,\n nonDivisibleSequentialInstructionPlan,\n parallelInstructionPlan,\n Instruction,\n MessagePackerInstructionPlan,\n} from '@solana/kit';\nconst createAccount1 = {} as unknown as Instruction;\nconst createAccount2 = {} as unknown as Instruction;\nconst initializeBuffer = {} as unknown as Instruction;\nconst initializeMetadata = {} as unknown as Instruction;\nconst setMetadataFromBuffer = {} as unknown as Instruction;\nconst closeBuffer = {} as unknown as Instruction;\nconst writeMessagePacker = {} as unknown as MessagePackerInstructionPlan;\n// ---cut-before---\nconst instructionPlan = sequentialInstructionPlan([\n parallelInstructionPlan([\n sequentialInstructionPlan([\n createAccount1,\n initializeBuffer,\n parallelInstructionPlan([writeMessagePacker]),\n ]),\n nonDivisibleSequentialInstructionPlan([createAccount2, initializeMetadata]),\n ]),\n setMetadataFromBuffer,\n closeBuffer,\n]);\n```\n\n## Planning instructions\n\nOnce we have an instruction plan, the first step is to build transaction messages from it in the most optimal way whilst satisfying all the constraints defined in the instruction plan. This is the role of **transaction planners**.\n\n### Transaction planners\n\nTransaction planners are defined as simple abortable functions that transform a given instruction plan into a set of built transaction messages called a **transaction plan**.\n\n```ts twoslash\nimport { TransactionPlanner, InstructionPlan } from '@solana/kit';\nconst transactionPlanner = {} as unknown as TransactionPlanner;\nconst instructionPlan = {} as unknown as InstructionPlan;\nconst abortSignal = {} as unknown as AbortSignal;\n// ---cut-before---\nconst transactionPlan = await transactionPlanner(instructionPlan, { abortSignal });\n```\n\n### Creating a transaction planner\n\nTo spin up a transaction planner, you may use the `createTransactionPlanner` helper. This helper requires a `createTransactionMessage` function that tells us how each new transaction message should be created before being packed with instructions.\n\nFor instance, in the example below we create a new planner such that each planned transaction message will be using version 0 and using the `payer` signer as a fee payer.\n\n```ts twoslash\nimport {\n createTransactionPlanner,\n pipe,\n createTransactionMessage,\n setTransactionMessageFeePayerSigner,\n TransactionSigner,\n} from '@solana/kit';\nconst payer = {} as unknown as TransactionSigner;\n// ---cut-before---\nconst transactionPlanner = createTransactionPlanner({\n createTransactionMessage: () =>\n pipe(\n createTransactionMessage({ version: 0 }),\n (message) => setTransactionMessageFeePayerSigner(payer, message),\n // ...\n ),\n});\n```\n\nAdditionally, the `onTransactionMessageUpdated` function may be provided to update transaction messages during the planning process. This function will be called whenever a transaction message is updated — e.g. when new instructions are added. It accepts the updated transaction message and must return a transaction message back, even if no changes were made.\n\nIn the example below, we check if the packed transaction contains an instruction that transfers SOL and, if so, add a guard instruction that ensures no more than 1 SOL is transferred.\n\n```ts twoslash\nimport {\n appendTransactionMessageInstruction,\n createTransactionPlanner,\n TransactionMessage,\n Instruction,\n} from '@solana/kit';\nconst createTransactionMessage = {} as unknown as Parameters<\n typeof createTransactionPlanner\n>[0]['createTransactionMessage'];\nconst containsTransferSolInstruction = {} as unknown as (message: TransactionMessage) => boolean;\nconst transferSolGuardInstruction = {} as unknown as Instruction;\n// ---cut-before---\nconst transactionPlanner = createTransactionPlanner({\n createTransactionMessage,\n onTransactionMessageUpdated: (message) => {\n if (containsTransferSolInstruction(message)) {\n return appendTransactionMessageInstruction(\n transferSolGuardInstruction,\n message,\n ) as unknown as typeof message;\n }\n\n return message;\n },\n});\n```\n\nCheck out the [Recipes section](#recipes) at this end of this guide for ideas of what can be achieved with this API.\n\n### Transaction plans\n\nSince transaction planners output transaction plans, it may be useful to see what these look like.\n\nThey work similarly to instruction plans but they wrap transaction messages instead of instructions and do not contain message packers.\n\n- [`singleTransactionPlan`](/api/functions/singleTransactionPlan). Wraps a built transaction message.\n- [`sequentialTransactionPlan`](/api/functions/sequentialTransactionPlan): Wraps other transaction plans that must be executed sequentially.\n- [`nonDivisibleSequentialTransactionPlan `](/api/functions/nonDivisibleSequentialTransactionPlan): Wraps other transaction plans that must be executed sequentially and atomically. Since atomicity is at the transaction level, this suggests transaction bundles should be used if possible. Otherwise, the plan should fail to execute.\n- [`parallelTransactionPlan`](/api/functions/parallelTransactionPlan): Wraps other transaction plans that may be executed in parallel.\n\n```ts twoslash\nimport {\n singleTransactionPlan,\n sequentialTransactionPlan,\n parallelTransactionPlan,\n TransactionMessage,\n TransactionMessageWithFeePayer,\n} from '@solana/kit';\nconst messageA = {} as unknown as TransactionMessage & TransactionMessageWithFeePayer;\nconst messageB = {} as unknown as TransactionMessage & TransactionMessageWithFeePayer;\nconst messageC = {} as unknown as TransactionMessage & TransactionMessageWithFeePayer;\n// ---cut-before---\nconst transactionPlan = parallelTransactionPlan([\n sequentialTransactionPlan([singleTransactionPlan(messageA), singleTransactionPlan(messageB)]),\n singleTransactionPlan(messageC),\n]);\n```\n\n### Advanced transaction planners\n\nWhilst the `createTransactionPlanner` helper is designed to suit most projects, it may not suit yours. If so, you may create your own by offering a function that satisfy the following signature.\n\n```ts twoslash\nimport { InstructionPlan, TransactionPlan } from '@solana/kit';\n// ---cut-before---\ntype TransactionPlanner = (\n instructionPlan: InstructionPlan,\n config?: { abortSignal?: AbortSignal },\n) => Promise;\n```\n\n## Executing transactions\n\nNow that we have obtained a transaction plan from our instruction plan, the next and final step is to send these transactions using a **transaction plan executor**.\n\n### Transaction plan executors\n\nTransaction plan executors are defined as abortable functions that transform a given transaction plan into a mirrored data structure that contains the execution status of each transaction. That data structure is called a **transaction plan result**.\n\n```ts twoslash\nimport { TransactionPlanExecutor, TransactionPlan } from '@solana/kit';\nconst transactionPlanExecutor = {} as unknown as TransactionPlanExecutor;\nconst transactionPlan = {} as unknown as TransactionPlan;\nconst abortSignal = {} as unknown as AbortSignal;\n// ---cut-before---\nconst transactionPlanResult = await transactionPlanExecutor(transactionPlan, { abortSignal });\n```\n\n### Creating a transaction plan executor\n\nTo spin up a transaction plan executor, you may use the `createTransactionPlanExecutor` helper. This helper requires an `executeTransactionMessage` function that tells us how each transaction message should be executed when encountered during the execution process.\n\nThe `executeTransactionMessage` callback receives the following arguments:\n\n- **`context`**: A mutable object for storing data during execution — see the [next section](#the-execution-context) for details.\n- **`message`**: The transaction message to execute.\n- **`config`**: An optional configuration object that may include an `abortSignal`.\n\nThe callback must return either a `Signature` or a full `Transaction` object directly.\n\nFor instance, in the example below we create a new executor such that each transaction message will be assigned the latest blockhash lifetime before being signed and sent to the network using the provided RPC client.\n\n```ts twoslash\nimport {\n sendAndConfirmTransactionFactory,\n createTransactionPlanExecutor,\n Rpc,\n SolanaRpcApi,\n RpcSubscriptions,\n SolanaRpcSubscriptionsApi,\n setTransactionMessageLifetimeUsingBlockhash,\n signTransactionMessageWithSigners,\n assertIsSendableTransaction,\n assertIsTransactionWithBlockhashLifetime,\n TransactionMessage,\n TransactionMessageWithFeePayer,\n} from '@solana/kit';\nconst rpc = {} as unknown as Rpc;\nconst rpcSubscriptions = {} as unknown as RpcSubscriptions;\n// ---cut-before---\nconst sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });\n\nconst transactionPlanExecutor = createTransactionPlanExecutor({\n executeTransactionMessage: async (context, message) => {\n const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();\n const messageWithBlockhash = setTransactionMessageLifetimeUsingBlockhash(\n latestBlockhash,\n message,\n );\n context.message = messageWithBlockhash;\n const transaction = await signTransactionMessageWithSigners(messageWithBlockhash);\n context.transaction = transaction;\n assertIsSendableTransaction(transaction);\n assertIsTransactionWithBlockhashLifetime(transaction);\n await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });\n return transaction;\n },\n});\n```\n\n### The execution context\n\nThe `context` object passed to the `executeTransactionMessage` callback is a mutable object that you can populate incrementally as execution progresses. This context is preserved in the resulting `SingleTransactionPlanResult` regardless of the outcome — successful, failed, or canceled.\n\nThis is particularly useful for debugging failures or building recovery plans. If an error is thrown at any point in the callback, any attributes you've already saved to the context will still be available in the `FailedSingleTransactionPlanResult`.\n\nThe context object supports three optional base properties that have semantic meaning:\n\n- **`message`**: The transaction message after any modifications (e.g., after setting a lifetime).\n- **`transaction`**: The signed transaction ready to be sent.\n- **`signature`**: The transaction signature. Note that this is automatically populated when you set the `transaction` property on the context and/or return a `Transaction`.\n\nYou can also add any custom properties you need:\n\n```ts twoslash\nimport {\n createTransactionPlanExecutor,\n setTransactionMessageLifetimeUsingBlockhash,\n signTransactionMessageWithSigners,\n sendAndConfirmTransactionFactory,\n assertIsSendableTransaction,\n assertIsTransactionWithBlockhashLifetime,\n Rpc,\n SolanaRpcApi,\n RpcSubscriptions,\n SolanaRpcSubscriptionsApi,\n} from '@solana/kit';\nconst rpc = {} as unknown as Rpc;\nconst rpcSubscriptions = {} as unknown as RpcSubscriptions;\nconst sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });\n// ---cut-before---\nconst transactionPlanExecutor = createTransactionPlanExecutor({\n executeTransactionMessage: async (context, message) => {\n // Store the start time (custom context).\n context.startedAt = Date.now();\n\n const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();\n const messageWithBlockhash = setTransactionMessageLifetimeUsingBlockhash(\n latestBlockhash,\n message,\n );\n\n // Store the message about to be signed.\n context.message = messageWithBlockhash;\n\n const transaction = await signTransactionMessageWithSigners(messageWithBlockhash);\n\n // Store the transaction about to be sent.\n context.transaction = transaction;\n\n assertIsSendableTransaction(transaction);\n assertIsTransactionWithBlockhashLifetime(transaction);\n await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });\n\n // Store the confirmation time (custom context).\n context.confirmedAt = Date.now();\n\n return transaction;\n },\n});\n```\n\nWhen accessing the context from a result, you can retrieve both the base properties and your custom properties:\n\n```ts twoslash\nimport {\n SingleTransactionPlanResult,\n isSuccessfulSingleTransactionPlanResult,\n isFailedSingleTransactionPlanResult,\n} from '@solana/kit';\nconst result = {} as unknown as SingleTransactionPlanResult<{ startedAt: number }>;\n// ---cut-before---\nif (isSuccessfulSingleTransactionPlanResult(result)) {\n console.log(result.context.signature); // Always available for successful results.\n console.log(result.context.transaction); // Available if you stored it.\n console.log(result.context.startedAt); // Custom context property.\n}\n\nif (isFailedSingleTransactionPlanResult(result)) {\n console.log(result.error); // The error that caused the failure.\n console.log(result.context.message); // Available if stored before the failure.\n console.log(result.context.transaction); // Available if stored before the failure.\n console.log(result.context.startedAt); // Custom context property.\n}\n```\n\nCheck out the [Recipes section](#recipes) at this end of this guide for ideas of what can be achieved with this API.\n\n### Transaction plan results\n\nWhen you execute a transaction plan, you get back a `TransactionPlanResult` that tells you what happened during execution. This result object has the same tree structure as your original transaction plan, but includes execution information for each transaction message.\n\nEach transaction message in your plan can have one of three execution outcomes:\n\n- **Successful** - The transaction was sent and confirmed. You get the original planned message, a context object containing the signature (and optionally the transaction), plus any custom context data.\n- **Failed** - The transaction encountered an error. You get the original planned message, the error that caused the failure, and a context object with any data accumulated before the failure.\n- **Canceled** - The transaction was skipped because an earlier transaction failed or the operation was aborted. You get the original planned message with any context data accumulated before cancellation.\n\nThe result structure mirrors your transaction plan structure:\n\n- Single transaction messages become `SingleTransactionPlanResult` with the original `plannedMessage` plus execution status\n- Sequential plans become `SequentialTransactionPlanResult` containing child results\n- Parallel plans become `ParallelTransactionPlanResult` containing child results\n\nEach `SingleTransactionPlanResult` has a `status` property that is a string literal (`'successful'`, `'failed'`, or `'canceled'`), and properties like `context`, `error` live at the top level of each variant.\n\n```ts twoslash\nimport {\n parallelTransactionPlan,\n singleTransactionPlan,\n parallelTransactionPlanResult,\n successfulSingleTransactionPlanResultFromTransaction,\n failedSingleTransactionPlanResult,\n isSuccessfulSingleTransactionPlanResult,\n isFailedSingleTransactionPlanResult,\n SolanaError,\n TransactionMessage,\n TransactionMessageWithFeePayer,\n Transaction,\n} from '@solana/kit';\nconst messageA = {} as unknown as TransactionMessage & TransactionMessageWithFeePayer;\nconst messageB = {} as unknown as TransactionMessage & TransactionMessageWithFeePayer;\nconst transactionA = {} as unknown as Transaction;\nconst error = {} as unknown as SolanaError;\n// ---cut-before---\n// If your transaction plan looked like this:\nconst plan = parallelTransactionPlan([\n singleTransactionPlan(messageA),\n singleTransactionPlan(messageB),\n]);\n\n// Your result may look like this:\nconst result = parallelTransactionPlanResult([\n successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\n failedSingleTransactionPlanResult(messageB, error),\n]);\n\n// Access the signature from a successful result:\nif (isSuccessfulSingleTransactionPlanResult(result.plans[0])) {\n console.log(result.plans[0].context.signature);\n console.log(result.plans[0].context.transaction); // If available\n}\n\n// Access the error from a failed result:\nif (isFailedSingleTransactionPlanResult(result.plans[1])) {\n console.log(result.plans[1].error);\n console.log(result.plans[1].context.signature); // If available\n console.log(result.plans[1].context.transaction); // If available\n}\n```\n\n### Failed transaction executions\n\nWhen a transaction plan executor — created via the `createTransactionPlanExecutor` helper — encounters a failed transaction, it will cancel all remaining transactions in the plan. The executor will then throw a `SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN` error code.\n\nThis error contains a `transactionPlanResult` property (accessible as a non-enumerable property) that provides detailed information about which transactions succeeded, failed, or were canceled.\n\n```ts twoslash\nimport {\n TransactionPlan,\n TransactionPlanExecutor,\n SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN,\n isSolanaError,\n TransactionPlanResult,\n} from '@solana/kit';\nconst transactionPlan = {} as unknown as TransactionPlan;\nconst transactionPlanExecutor = {} as unknown as TransactionPlanExecutor;\n// ---cut-before---\ntry {\n const result = await transactionPlanExecutor(transactionPlan);\n} catch (error) {\n if (isSolanaError(error, SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN)) {\n // Access the failed `TransactionPlanResult` to understand what happened.\n const result = error.context.transactionPlanResult as TransactionPlanResult;\n }\n}\n```\n\n### Advanced transaction plan executors\n\nWhilst the `createTransactionPlanExecutor` helper is designed to suit most projects, it may not suit yours. If so, you may create your own by offering a function that satisfies the following signature.\n\n```ts twoslash\nimport { TransactionPlan, TransactionPlanResult } from '@solana/kit';\n// ---cut-before---\ntype TransactionPlanExecutor = (\n transactionPlan: TransactionPlan,\n config?: { abortSignal?: AbortSignal },\n) => Promise;\n```\n\nThis allows you to implement custom execution strategies, such as using transaction bundles for atomic execution or adding custom transaction prioritization.\n\n\n Bundled clients such as `solanaRpc` and `litesvm` install ready-to-use planner and executor\n implementations on the client. See [Available plugins](/docs/plugins/available-plugins) for the\n full list, and [Sending multiple transactions](/docs/guides/sending-multiple-transactions) for\n the consumer-facing API they expose.\n\n\n## Recipes\n\nHere are some common patterns and recipes for using instruction plans effectively.\n\n### Setting priority fees\n\nYou can set priority fees by using the [`setTransactionMessageComputeUnitPrice`](/api/functions/setTransactionMessageComputeUnitPrice) helper from `@solana/kit` in your `createTransactionMessage` function. See [Configuring compute and priority fees](/docs/advanced-guides/transactions#configuring-priority-fees) for the full set of fee setters, including the v1 [`setTransactionMessagePriorityFeeLamports`](/api/functions/setTransactionMessagePriorityFeeLamports) variant.\n\n```ts twoslash\nimport {\n createTransactionPlanner,\n pipe,\n createTransactionMessage,\n setTransactionMessageFeePayerSigner,\n TransactionSigner,\n} from '@solana/kit';\nconst payer = {} as unknown as TransactionSigner;\n// ---cut-before---\nimport { setTransactionMessageComputeUnitPrice } from '@solana/kit'; // [!code ++]\n\nconst transactionPlanner = createTransactionPlanner({\n createTransactionMessage: () =>\n pipe(\n createTransactionMessage({ version: 0 }),\n (message) => setTransactionMessageFeePayerSigner(payer, message),\n // [!code ++:2]\n // Set priority fees to 0.01 lamports per compute unit.\n (message) => setTransactionMessageComputeUnitPrice(10_000n, message),\n ),\n});\n```\n\n### Estimating compute units\n\nYou can estimate and set compute unit limits dynamically by using a two-step process:\n\n- First, add a provisory compute unit limit (if missing) in your transaction planner.\n- Then, estimate and update it right before sending the transaction.\n\nThe [`fillTransactionMessageProvisoryComputeUnitLimit`](/api/functions/fillTransactionMessageProvisoryComputeUnitLimit) helper from `@solana/kit` reserves the limit by setting it to a provisory value of `0`, so the planner can account for the resulting compute budget instruction when packing transaction messages. See [Estimating the compute unit limit](/docs/advanced-guides/transactions#configuring-compute-unit-limit-estimation) for the full estimator API.\n\n```ts twoslash\nimport {\n createTransactionPlanner,\n pipe,\n createTransactionMessage,\n setTransactionMessageFeePayerSigner,\n TransactionSigner,\n} from '@solana/kit';\nconst payer = {} as unknown as TransactionSigner;\n// ---cut-before---\nimport { fillTransactionMessageProvisoryComputeUnitLimit } from '@solana/kit'; // [!code ++]\n\nconst transactionPlanner = createTransactionPlanner({\n createTransactionMessage: () =>\n pipe(\n createTransactionMessage({ version: 0 }),\n (message) => setTransactionMessageFeePayerSigner(payer, message),\n (message) => fillTransactionMessageProvisoryComputeUnitLimit(message), // [!code ++]\n ),\n});\n```\n\nThen, pair [`estimateComputeUnitLimitFactory`](/api/functions/estimateComputeUnitLimitFactory) with [`estimateAndSetComputeUnitLimitFactory`](/api/functions/estimateAndSetComputeUnitLimitFactory) in your transaction plan executor to estimate the compute units right before sending the transaction.\n\n```ts twoslash\nimport {\n sendAndConfirmTransactionFactory,\n createTransactionPlanExecutor,\n Rpc,\n SolanaRpcApi,\n RpcSubscriptions,\n SolanaRpcSubscriptionsApi,\n setTransactionMessageLifetimeUsingBlockhash,\n signTransactionMessageWithSigners,\n assertIsSendableTransaction,\n assertIsTransactionWithBlockhashLifetime,\n TransactionMessage,\n TransactionMessageWithFeePayer,\n} from '@solana/kit';\nconst rpc = {} as unknown as Rpc;\nconst rpcSubscriptions = {} as unknown as RpcSubscriptions;\n// ---cut-before---\n// [!code ++:4]\nimport {\n estimateAndSetComputeUnitLimitFactory,\n estimateComputeUnitLimitFactory,\n} from '@solana/kit';\n\nconst sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });\n// [!code ++:2]\nconst estimateCULimit = estimateComputeUnitLimitFactory({ rpc });\nconst estimateAndSetCULimit = estimateAndSetComputeUnitLimitFactory(estimateCULimit);\n\nconst transactionPlanExecutor = createTransactionPlanExecutor({\n executeTransactionMessage: async (context, message) => {\n const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();\n const messageWithBlockhash = setTransactionMessageLifetimeUsingBlockhash(\n latestBlockhash,\n message,\n );\n context.message = messageWithBlockhash;\n const estimatedMessage = await estimateAndSetCULimit(messageWithBlockhash); // [!code ++]\n context.message = estimatedMessage; // [!code ++]\n const transaction = await signTransactionMessageWithSigners(estimatedMessage);\n context.transaction = transaction;\n assertIsSendableTransaction(transaction);\n assertIsTransactionWithBlockhashLifetime(transaction);\n await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });\n return transaction;\n },\n});\n```\n\n### Durable nonce executor\n\nYou may create transaction plans that use durable nonces for offline transaction signing by using the `setTransactionMessageLifetimeUsingDurableNonce` helper in your transaction planner.\n\n```ts twoslash\nimport {\n createTransactionPlanner,\n pipe,\n createTransactionMessage,\n setTransactionMessageFeePayerSigner,\n TransactionSigner,\n} from '@solana/kit';\nconst payer = {} as unknown as TransactionSigner;\nconst config = {} as unknown as Parameters<\n typeof setTransactionMessageLifetimeUsingDurableNonce\n>['0'];\nconst nonce = config.nonce;\nconst nonceAccountAddress = config.nonceAccountAddress;\nconst nonceAuthorityAddress = config.nonceAuthorityAddress;\n// ---cut-before---\nimport { setTransactionMessageLifetimeUsingDurableNonce } from '@solana/kit'; // [!code ++]\n\nconst transactionPlanner = createTransactionPlanner({\n createTransactionMessage: () => {\n return pipe(\n createTransactionMessage({ version: 0 }),\n (message) => setTransactionMessageFeePayerSigner(payer, message),\n // [!code ++:5]\n (message) =>\n setTransactionMessageLifetimeUsingDurableNonce(\n { nonce, nonceAccountAddress, nonceAuthorityAddress },\n message,\n ),\n );\n },\n});\n```\n\nThen, make sure to use the `sendAndConfirmDurableNonceTransactionFactory` helper in your transaction plan executor in order to use the appropriate confirmation strategy for your transactions.\n\n```ts twoslash\nimport {\n createTransactionPlanExecutor,\n Rpc,\n SolanaRpcApi,\n RpcSubscriptions,\n SolanaRpcSubscriptionsApi,\n signTransactionMessageWithSigners,\n assertIsSendableTransaction,\n TransactionMessage,\n TransactionMessageWithFeePayer,\n assertIsTransactionWithDurableNonceLifetime,\n} from '@solana/kit';\nconst rpc = {} as unknown as Rpc;\nconst rpcSubscriptions = {} as unknown as RpcSubscriptions;\n// ---cut-before---\n// [!code ++:4]\nimport {\n assertIsTransactionMessageWithDurableNonceLifetime,\n sendAndConfirmDurableNonceTransactionFactory,\n} from '@solana/kit';\n\n// [!code ++:4]\nconst sendAndConfirmDurableNonceTransaction = sendAndConfirmDurableNonceTransactionFactory({\n rpc,\n rpcSubscriptions,\n});\n\nconst transactionPlanExecutor = createTransactionPlanExecutor({\n executeTransactionMessage: async (context, message) => {\n assertIsTransactionMessageWithDurableNonceLifetime(message); // [!code ++]\n context.message = message;\n const transaction = await signTransactionMessageWithSigners(message);\n context.transaction = transaction;\n assertIsSendableTransaction(transaction);\n assertIsTransactionWithDurableNonceLifetime(transaction);\n await sendAndConfirmDurableNonceTransaction(transaction, { commitment: 'confirmed' }); // [!code ++]\n return transaction;\n },\n});\n```\n" }, { "path": "docs/content/docs/advanced-guides/keypairs.mdx", "content": "---\ntitle: Key pairs\ndescription: Sign and verify messages and transactions using Ed25519 keys\n---\n\n## Introduction\n\nKit uses the primitives built-in to JavaScript’s Web Crypto API to perform cryptography. This keeps your applications small, and confers to them the security and performance characteristics of the runtime's native cryptography functions.\n\nEd25519 keys created or imported using the native APIs are compatible with all of Kit's cryptographic features. Kit also offers several helpers to generate, import, and transform key material.\n\n\n Keys are a low-level primitive. While it's important to know how they work, in a Solana\n application it's often more appropriate to deal with key material in terms of the accounts and\n wallets that sign a transaction or message. The [Signers](/docs/advanced-guides/signers) API\n offers an ergonomic way to build and sign transactions using accounts and their associated keys.\n\n\n## Installation\n\nKey management functions are **included within the `@solana/kit` library** but you may also install them using their standalone package.\n\n```package-install\n@solana/keys\n```\n\n\n When deploying your application to a JavaScript runtime that lacks support for the Ed25519\n digital signature algorithm, [import our polyfill](#polyfill) before invoking any operations\n that create or make use of `CryptoKey` objects.\n\n\n## What is a key pair?\n\nA key pair is a data type composed of 256-bits of random data (the private key) and a Cartesian point (the public key) on the curve that is used to cryptographically sign and verify Solana transactions. The interface definition of `CryptoKeyPair` is:\n\n```ts\ninterface CryptoKeyPair {\n privateKey: CryptoKey;\n publicKey: CryptoKey;\n}\n```\n\nTogether, these keys represent an address on Solana and its owner. The 256-bit address is derived from the coordinates of the public key itself.\n\n## What is a key?\n\nA key is an object native to the JavaScript runtime that supports the [`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey) interface. You can use a `CryptoKey` with the native [`SubtleCrypto` API](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto) to sign messages and to verify signatures. Kit builds on these capabilities to enable the use of `CryptoKey` objects to sign and verify Solana transactions and off-chain messages.\n\n## Managing keys\n\n### Generating new keys\n\nYou can use the native [`SubtleCrypto#generateKey`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey) API, or the [`generateKeyPair()`](/api/functions/generateKeyPair) helper to create a new random key pair.\n\n\n \n ```ts twoslash\n const keyPair = await crypto.subtle.generateKey(\n /* algorithm */ { name: 'Ed25519' },\n /* extractable */ false,\n /* usages */ ['sign', 'verify'],\n );\n ```\n \n \n ```ts twoslash\n import { generateKeyPair } from '@solana/kit';\n const keyPair = await generateKeyPair();\n ```\n \n\n\nThis is useful in cases where you need to sign for the creation of a new account with a random address, using an ephemeral key pair that can be discarded after the account is created and assigned to a program.\n\n### Importing a key\n\nYou can create a `CryptoKeyPair` using the 64 bytes of a pre-generated key. This is possible to do with the native [`SubtleCrypto#importKey`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey) API, but it is more convenient to use the helpers in Kit.\n\n```ts twoslash\nimport { createKeyPairFromBytes } from '@solana/kit';\nconst keyPair = await createKeyPairFromBytes(\n new Uint8Array([\n /* 32 bytes representing the private key */\n /* 32 bytes representing the public key */\n ]),\n);\n```\n\nIn cases where you have only the 32 bytes representing the private key but not its associated public key, you can use a different function that will automatically derive the public key from the private key.\n\n```ts twoslash\nimport { createKeyPairFromPrivateKeyBytes } from '@solana/kit';\nconst keyPair = await createKeyPairFromPrivateKeyBytes(\n new Uint8Array([\n /* 32 bytes representing the private key */\n ]),\n);\n```\n\n### Storing keys\n\n`CryptoKey` objects can be stored locally by runtimes that support the [IndexedDB API](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API).\n\nGiven an instance of an `IDBDatabase` with an object store called `'MyKeyPairStore'`:\n\n```ts twoslash\nconst db = await new Promise((resolve, reject) => {\n const request = indexedDB.open('MyDatabase', 1);\n request.onupgradeneeded = (e) => {\n const db = (e.target as IDBOpenDBRequest).result;\n db.createObjectStore('MyKeyPairStore');\n };\n request.onsuccess = (e) => {\n resolve((e.target as IDBOpenDBRequest).result);\n };\n request.onerror = (e) => {\n reject((e.target as IDBOpenDBRequest).error);\n };\n});\n```\n\nYou can store a key pair like this:\n\n```ts twoslash\nconst db = null as unknown as IDBDatabase;\nconst keyPair = null as unknown as CryptoKeyPair;\n// ---cut-before---\nconst transaction = db.transaction('MyKeyPairStore', 'readwrite');\nconst store = transaction.objectStore('MyKeyPairStore');\nawait new Promise((resolve, reject) => {\n const request = store.put(keyPair, 'myStoredKey');\n request.onsuccess = () => resolve();\n request.onerror = () => reject(request.error);\n});\n```\n\nAnd then later retrieve it like this:\n\n```ts twoslash\nconst db = null as unknown as IDBDatabase;\n// ---cut-before---\nconst transaction = db.transaction('MyKeyPairStore', 'readonly');\nconst store = transaction.objectStore('MyKeyPairStore');\nconst loadedKeyPair = await new Promise((resolve, reject) => {\n const request = store.get('myStoredKey');\n request.onsuccess = () => {\n if (request.result) {\n resolve(request.result);\n } else {\n reject(new Error('Key not found'));\n }\n };\n request.onerror = () => reject(request.error);\n});\n```\n\n\n Keys stored in IndexedDB are local to the host, are subject to its [storage limits and eviction\n criteria](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API#storage_limits_and_eviction_criteria),\n and can not be accessed from a domain other than the one that stored them when the host is a web\n browser. Keys that are evicted from storage or erased by the user can generally not be\n recovered.\n\n\n### Exporting a key\n\nYou can obtain the 32 bytes of any public key like this:\n\n```ts twoslash\nconst keyPair = null as unknown as CryptoKeyPair;\n// ---cut-before---\nconst publicKeyBytes = new Uint8Array(await crypto.subtle.exportKey('raw', keyPair.publicKey));\n```\n\nExporting private key material requires a specially constructed `CryptoKey` with its extractable property set to `true`.\n\n```ts twoslash\nconst keyPair = await crypto.subtle.generateKey(\n /* algorithm */ { name: 'Ed25519' },\n /* extractable */ true,\n // ^^^^\n /* usages */ ['sign', 'verify'],\n);\n```\n\nYou can then use that `CryptoKey` with the [`SubtleCrypto#exportKey`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/exportKey) API. The last 32 bytes of a PKCS#8 export of the key are the private key bytes.\n\n```ts twoslash\nconst keyPair = null as unknown as CryptoKeyPair;\n// ---cut-before---\nconst exportedPrivateKey = await crypto.subtle.exportKey('pkcs8', keyPair.privateKey);\nconst privateKeyBytes = new Uint8Array(exportedPrivateKey, exportedPrivateKey.byteLength - 32, 32);\n```\n\n\n Exporting private key material in JavaScript is not recommended, and you should take extreme\n care when doing so. Private key bytes exported through these APIs are vulnerable to theft (eg.\n by code running in your JavaScript sandbox) and accidental logging (eg. to the console or to a\n third-party logger).\n\n\n## Using private keys\n\nA private key is a `CryptoKey` whose `type` property is set to `'private'` and whose `usages` property includes `'sign'`.\n\nPrivate keys can be used by their owner to produce a digital signature of a specific message. You can think of a signature as representing the key owner's approval of, agreement to, or endorsement of the message. Private key owners must never share the key with anyone.\n\n### Signing messages\n\nAny data that you can serialize as a `Uint8Array` can be signed with a `CryptoKey`.\n\n```ts twoslash\nimport { ReadonlyUint8Array } from '@solana/kit';\n// ---cut-before---\nimport { getU32Encoder, getUtf8Encoder } from '@solana/kit';\nconst messageFromText = getUtf8Encoder().encode('🎉');\nconst messageFromU32 = getU32Encoder().encode(0xdeadbeef);\nconst messageOfBytes = new Uint8Array([1, 2, 3]);\n```\n\nSupply a message and a private key to the [`signBytes()`](/api/functions/signBytes) function to obtain a 64-byte digital signature.\n\n```ts twoslash\nconst bobsKeyPair = null as unknown as CryptoKeyPair;\n// ---cut-before---\nimport { getUtf8Encoder, signBytes } from '@solana/kit';\nconst message = getUtf8Encoder().encode('The meeting is at 6:00pm');\nconst bobsSignature = await signBytes(bobsKeyPair.privateKey, message);\nconsole.log(bobsSignature);\n// @log: Uint8Array(64) [79, 43, 140, 65, 177, 35, 169, 61, 62, 228, 190, 202, 205, 143, 4, 35, 83, 228, 47, 76, 68, 62, 125, 140, 21, 102, 182, 105, 24, 238, 67, 40, 179, 255, 247, 136, 95, 119, 46, 244, 44, 224, 100, 111, 68, 110, 189, 224, 159, 144, 197, 181, 210, 132, 101, 226, 120, 200, 0, 102, 104, 65, 216, 3]\n```\n\n\n The same message and private key might produce a different signature every time you call this\n function. Some runtimes produce randomized signatures as per\n [draft-irtf-cfrg-det-sigs-with-noise](https://datatracker.ietf.org/doc/draft-irtf-cfrg-det-sigs-with-noise/)\n while others produce deterministic signatures as per [RFC\n 8032](https://www.rfc-editor.org/rfc/rfc8032).\n\n\n### Signing transactions\n\nIn Kit, private keys are used to digitally sign transactions on behalf of account owners, to approve spending, transfers, and modifications to account data on the blockchain.\n\n```ts twoslash\nimport { Transaction, TransactionWithLifetime } from '@solana/kit';\nconst transaction = null as unknown as Transaction & TransactionWithLifetime;\nconst bobsKeyPair = null as unknown as CryptoKeyPair;\n// ---cut-before---\nimport { signTransaction } from '@solana/kit';\nconst signedTransaction = await signTransaction([bobsKeyPair], transaction);\n```\n\nIn practice, it's rare to sign transactions like this. Typically, you create a transaction message in your application, specify which accounts are required to sign it using the [Signers API](/docs/advanced-guides/signers), and then call [`signTransactionMessageWithSigners`](/api/functions/signTransactionMessageWithSigners) to turn it into a signed `Transaction`.\n\n## Using public keys\n\nA public key is a `CryptoKey` whose `type` property is set to `'public'` and whose `usages` property includes `'verify'`.\n\nSolana uses public keys to verify that modifications to account data and balances through transactions are approved of by those who hold the private keys required to authorize such modifications. Kit generally only uses public keys to derive the address of their associated accounts, but it can also use public keys to enable your programs to verify arbitrary messages.\n\n### Verifying signatures\n\nThe public key associated with a given private key can be used by anyone to verify that a message was signed by the holder of the associated private key, as described above. The verification function requires the original message, a digital signature, and the public key associated with the owner who is believed to have produced that signature. Successful verification implies that the contents of the message signed by the owner are identical to the contents of the message that was given to the verification function. Key owners are free to share their public key with anyone they would like to grant the ability to verify their digital signatures.\n\nIf someone sends us a message and signature that they claim to be from the example above, we could use Bob's public key to verify that the signature was in fact the one produced by Bob and that the message was not modified in transit.\n\n```ts twoslash\nimport { SignatureBytes } from '@solana/kit';\nconst bobsPublicKey = null as unknown as CryptoKey;\nconst supposedlyBobsSignature = null as unknown as SignatureBytes;\n// ---cut-before---\nimport { getUtf8Encoder, verifySignature } from '@solana/kit';\nconst verificationSucceeded = await verifySignature(\n bobsPublicKey,\n supposedlyBobsSignature,\n getUtf8Encoder().encode('The meeting is at 6:00pm'),\n);\nif (!verificationSucceeded) {\n throw new Error(\n 'Either the message was modified, the signature was not produced by Bob, or both',\n );\n}\n```\n\nVerification protects equally against false claims of who produced the signature as it does against false claims about what message was signed. Both of these will return `false`;\n\n{/* prettier-ignore */}\n```ts twoslash\nimport { SignatureBytes } from '@solana/kit';\nconst bobsPublicKey = null as unknown as CryptoKey;\nconst bobsSignature = null as unknown as SignatureBytes;\nconst mallorysSignature = null as unknown as SignatureBytes;\nconst signature = null as unknown as SignatureBytes;\n// ---cut-before---\nimport { getUtf8Encoder, verifySignature } from '@solana/kit';\n// False claim that Bob signed the message when it was in fact Mallory\nawait verifySignature(\n bobsPublicKey,\n mallorysSignature,\n //^^^^^^^^^^^^^^^^^\n getUtf8Encoder().encode('The meeting is at 6:00pm'),\n);\n// False claim about the contents of the message\nawait verifySignature(\n bobsPublicKey,\n bobsSignature,\n getUtf8Encoder().encode('The meeting is at 6:00am'),\n // ^^^^^^\n);\n```\n\n### Deriving addresses\n\nThe Solana address associated with any public key can be derived using the [`getAddressFromPublicKey()`](/api/functions/getAddressFromPublicKey) function.\n\n```ts twoslash\nconst keyPair = null as unknown as CryptoKeyPair;\n// ---cut-before---\nimport { getAddressFromPublicKey } from '@solana/kit';\nconst address = await getAddressFromPublicKey(keyPair.publicKey);\n```\n\n## Signatures\n\nThe [`SignatureBytes`](/api/type-aliases/SignatureBytes) type represents a 64-byte Ed25519 signature, and the [`Signature`](/api/type-aliases/Signature) type represents such a signature as a base58-encoded string.\n\nWhen you acquire a string that you expect to be a base58-encoded signature (eg. of a transaction) from an untrusted network API or user input you can assert it is in fact a base58-encoded byte array of sufficient length using the [`assertIsSignature()`](/api/functions/assertIsSignature) function.\n\n```ts twoslash\n// @noErrors: 1308\nimport { GetSignatureStatusesApi, Rpc } from '@solana/kit';\nconst rpc = null as unknown as Rpc;\nconst signatureInput = null as unknown as HTMLInputElement;\n// ---cut-before---\nimport { assertIsSignature } from '@solana/kit';\n\n// Imagine a function that asserts whether a user-supplied signature is valid or not.\nfunction handleSubmit() {\n // We know only that what the user typed conforms to the `string` type.\n const signature: string = signatureInput.value;\n try {\n // If this type assertion function doesn't throw, then\n // Typescript will upcast `signature` to `Signature`.\n assertIsSignature(signature);\n // At this point, `signature` is a `Signature` that can be used with the RPC.\n const {\n value: [status],\n } = await rpc.getSignatureStatuses([signature]).send();\n } catch (e) {\n // `signature` turned out not to be a base58-encoded signature\n }\n}\n```\n\nSimilarly, you can use the [`isSignature()`](/api/functions/isSignature) type guard. It will return `true` if the input string conforms to the `Signature` type and will refine the type for use in your program from that point onward. This method does not throw in the opposite case.\n\n```ts twoslash\nimport { GetSignatureStatusesApi, Rpc } from '@solana/kit';\nconst rpc = null as unknown as Rpc;\nconst signature = '';\nfunction setError(s: string) {}\nfunction setSignatureStatus(\n s: ReturnType['value'][number],\n) {}\n// ---cut-before---\nimport { isSignature } from '@solana/kit';\n\nif (isSignature(signature)) {\n // At this point, `signature` has been refined to a\n // `Signature` that can be used with the RPC.\n const {\n value: [status],\n } = await rpc.getSignatureStatuses([signature]).send();\n setSignatureStatus(status);\n} else {\n setError(`${signature} is not a transaction signature`);\n}\n```\n\nThe [`signature()`](/api/functions/signature) helper combines _asserting_ that a string is an Ed25519 signature with _coercing_ it to the `Signature` type. It's best used with untrusted input.\n\n```ts\nimport { signature } from '@solana/kit';\n\nconst signature = signature(userSuppliedSignature);\nconst {\n value: [status],\n} = await rpc.getSignatureStatuses([signature]).send();\n```\n\n## Runtime Support\n\nAll major JavaScript runtimes support the Ed25519 digital signature algorithm required by Solana.\n\n| | Runtime | Min version | Since |\n| -------------------: | -------------------- | ------------- | -------- |\n| **Desktop browsers** | Chrome | v137 | May 2025 |\n| | Edge | v137 | May 2025 |\n| | Firefox | v130 | Sep 2024 |\n| | Safari | v17 | Sep 2023 |\n| **Mobile browsers** | Android browser | v137 | May 2025 |\n| | Firefox for Android | v139 | May 2025 |\n| | Mobile Safari | iOS 17 | Sep 2023 |\n| **Server runtimes** | Bun | v1.2.6 | Mar 2025 |\n| | Cloudflare `workerd` | v1.20230419.0 | Apr 2023 |\n| | Deno | v1.26.1 | Oct 2022 |\n| | Node.js | v18.4.0 | Jun 2022 |\n| | Vercel Edge | v2.3.0 | May 2023 |\n\nFor additional up-to-date details on runtimes' implementation status, visit https://github.com/WICG/webcrypto-secure-curves/issues/20.\n\n### Ed25519 Polyfill [#polyfill]\n\nTo use keys in a runtime without Ed25519 digital signature algorithm support, install the following polyfill.\n\n```package-install\n@solana/webcrypto-ed25519-polyfill\n```\n\nThen import and install it before invoking any operations that create or make use of `CryptoKey` objects.\n\n```ts twoslash\nimport { install } from '@solana/webcrypto-ed25519-polyfill';\n\n// Calling this will shim methods on `SubtleCrypto`, adding Ed25519 support.\ninstall();\n\n// Now you can do this, in environments that do not otherwise support Ed25519.\nconst keyPair = await crypto.subtle.generateKey({ name: 'Ed25519' }, false, ['sign']);\n```\n\nWherever you call `install()`, make sure the call is made only once, and before any key operation requiring Ed25519 support is performed.\n\n\n Because the polyfill's implementation of Ed25519 key generation exists in userspace, it can't\n guarantee that the keys you generate with it are non-exportable. Untrusted code running in your\n JavaScript context may still be able to gain access to and/or exfiltrate secret key material.\n\n\n\n Native `CryptoKeys` can be stored in IndexedDB, but the keys created by this polyfill can not.\n This is because, unlike native `CryptoKeys`, our polyfilled key objects can not implement the\n [structured clone algorithm](https://www.w3.org/TR/WebCryptoAPI/#cryptokey-interface-clone).\n\n" }, { "path": "docs/content/docs/advanced-guides/kit-without-a-client.mdx", "content": "---\ntitle: Kit without a client\ndescription: Use Kit's full power without the client abstraction\n---\n\nThis guide shows how to achieve the same capabilities a [Kit client](/docs/plugins) gives you, but using Kit's primitives directly. The page is organized as a reference: each section takes one piece of what a fully composed client offers and shows the manual equivalent, so you can pick and choose the exact bits you need.\n\n## When to skip the client\n\nGoing client-less is the right choice when you want the smallest possible bundles, full control over every step of the transaction lifecycle, or when you are writing library code that should not assume a Kit client. The cost is a little more boilerplate and a less prescriptive structure. The client model, on the other hand, gives you consistent ergonomics and a curated set of plugin interfaces other plugins can build on.\n\nIf you need ergonomics on top of a curated set of primitives, consider [creating a custom plugin bundle](/docs/plugins/creating-custom-plugins) instead. A bundle plugin is just a regular plugin that composes several smaller ones, so you keep the client model while owning exactly which primitives are wired up.\n\n## Set up RPC\n\nKit ships two factories for talking to a Solana RPC node: `createSolanaRpc` for HTTP requests and `createSolanaRpcSubscriptions` for the WebSocket channel. Both return typed proxies with the full Solana JSON-RPC API surface available on them.\n\n```ts twoslash\nimport { createSolanaRpc, createSolanaRpcSubscriptions } from '@solana/kit';\n\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\nconst rpcSubscriptions = createSolanaRpcSubscriptions('wss://api.devnet.solana.com');\n```\n\nThe objects returned by these factories are exactly what `client.rpc` and `client.rpcSubscriptions` expose under the hood, so any code that takes an `Rpc` or `RpcSubscriptions` works in either setup. See [RPC requests](/docs/guides/rpc) and [RPC subscriptions](/docs/guides/rpc-subscriptions) for the user-facing API.\n\n## Create a signer\n\nThe most common way to create a signer is to generate a fresh in-memory keypair with `generateKeyPairSigner`. The returned object is a `KeyPairSigner` that satisfies both the `TransactionSigner` and `MessageSigner` interfaces.\n\n```ts twoslash\nimport { generateKeyPairSigner } from '@solana/kit';\n\nconst signer = await generateKeyPairSigner();\n```\n\nIf you already have a keypair stored as a JSON byte array — for example, a Solana CLI keypair file — you can rebuild a signer from it with `createKeyPairSignerFromBytes`. See [Setting up signers](/docs/guides/setting-up-signers) for the broader signer setup story and [Advanced guides — Signers](/docs/advanced-guides/signers) for the underlying signer interfaces.\n\n```ts twoslash\nimport { createKeyPairSignerFromBytes } from '@solana/kit';\nimport { readFileSync } from 'node:fs';\n\nconst bytes = JSON.parse(readFileSync('keypair.json', 'utf-8')) as number[];\nconst signer = await createKeyPairSignerFromBytes(new Uint8Array(bytes));\n```\n\n## Build a transaction message\n\nKit transaction messages are immutable: each helper returns a new object with a narrower type, so TypeScript can enforce that required fields are set before the message is signed or sent. The `pipe` helper threads a value through a sequence of transformations and lets the type narrow at each step.\n\n```ts twoslash\nimport {\n appendTransactionMessageInstructions,\n createTransactionMessage,\n Instruction,\n pipe,\n setTransactionMessageFeePayerSigner,\n setTransactionMessageLifetimeUsingBlockhash,\n} from '@solana/kit';\n// ---cut-start---\nimport { createSolanaRpc, generateKeyPairSigner } from '@solana/kit';\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\nconst signer = await generateKeyPairSigner();\nconst instructionA = {} as Instruction;\nconst instructionB = {} as Instruction;\n// ---cut-end---\nconst { value: latestBlockhash } = await rpc.getLatestBlockhash().send();\n\nconst transactionMessage = pipe(\n createTransactionMessage({ version: 0 }),\n (tx) => setTransactionMessageFeePayerSigner(signer, tx),\n (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),\n (tx) => appendTransactionMessageInstructions([instructionA, instructionB], tx),\n);\n```\n\nThis is the same composition the bundled clients use internally. See [Advanced guides — Transactions](/docs/advanced-guides/transactions) for the full transaction message API, including durable-nonce lifetimes and other configuration helpers.\n\n## Estimate compute units\n\nSetting an explicit compute unit limit close to what your transaction actually consumes increases the chance of inclusion, packs more transactions per block, and reduces priority fees. Kit ships everything you need for this without leaving `@solana/kit`: `estimateComputeUnitLimitFactory` simulates the message to estimate the cost, and `estimateAndSetComputeUnitLimitFactory` wraps that estimator to write the result back onto the message in one step.\n\n```ts twoslash\nimport {\n estimateAndSetComputeUnitLimitFactory,\n estimateComputeUnitLimitFactory,\n TransactionMessage,\n TransactionMessageWithFeePayer,\n} from '@solana/kit';\n// ---cut-start---\nimport { createSolanaRpc } from '@solana/kit';\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\nconst transactionMessage = {} as TransactionMessage & TransactionMessageWithFeePayer;\n// ---cut-end---\nconst estimateComputeUnitLimit = estimateComputeUnitLimitFactory({ rpc });\nconst estimateAndSetComputeUnitLimit =\n estimateAndSetComputeUnitLimitFactory(estimateComputeUnitLimit);\n\nconst transactionMessageWithLimit = await estimateAndSetComputeUnitLimit(transactionMessage);\n```\n\nBundled clients such as `solanaRpc` and `litesvm` already do this for you when sending transactions.\n\n## Sign the transaction\n\nOnce a transaction message is fully configured, `signTransactionMessageWithSigners` extracts every signer attached to it (the fee payer plus any signer-typed instruction inputs) and produces a signed `Transaction`.\n\n```ts twoslash\nimport {\n signTransactionMessageWithSigners,\n TransactionMessage,\n TransactionMessageWithFeePayer,\n} from '@solana/kit';\n// ---cut-start---\nconst transactionMessage = {} as TransactionMessage & TransactionMessageWithFeePayer;\n// ---cut-end---\nconst signedTransaction = await signTransactionMessageWithSigners(transactionMessage);\n```\n\nTwo assertions are typically useful at this point: `assertIsSendableTransaction` verifies the transaction has every required signature and fits within the size limit, and `assertIsTransactionWithBlockhashLifetime` narrows the lifetime so it can be passed to `sendAndConfirmTransactionFactory` below. The transaction identifier on Solana is the fee payer's signature, which is fully determined as soon as the fee payer signs — `getSignatureFromTransaction(signedTransaction)` returns that identifier directly, without needing to send the transaction first.\n\n## Send and confirm a transaction\n\n`sendAndConfirmTransactionFactory` builds a function that sends a signed transaction and waits for the configured commitment. It needs both an `rpc` and an `rpcSubscriptions` because confirmation listens to slot and signature notifications.\n\n```ts twoslash\nimport {\n SendableTransaction,\n sendAndConfirmTransactionFactory,\n Transaction,\n TransactionWithBlockhashLifetime,\n} from '@solana/kit';\n// ---cut-start---\nimport { createSolanaRpc, createSolanaRpcSubscriptions } from '@solana/kit';\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\nconst rpcSubscriptions = createSolanaRpcSubscriptions('wss://api.devnet.solana.com');\nconst signedTransaction = {} as Transaction &\n SendableTransaction &\n TransactionWithBlockhashLifetime;\n// ---cut-end---\nconst sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });\nawait sendAndConfirmTransaction(signedTransaction, { commitment: 'confirmed' });\n```\n\nFor durable-nonce transactions, use `sendAndConfirmDurableNonceTransactionFactory` instead, which knows how to confirm against a nonce account instead of a recent blockhash. If you don't need confirmation at all, `sendTransactionWithoutConfirmingFactory` returns a fire-and-forget sender. All three return `Promise`; pair them with `getSignatureFromTransaction` to obtain the signature for logging or display.\n\n## Fetch and decode accounts\n\nTo read onchain state, `fetchEncodedAccount` wraps `getAccountInfo` and returns a `MaybeEncodedAccount` whose shape is consistent regardless of whether the account exists. `assertAccountExists` narrows the result so the rest of your code can rely on a fully populated account.\n\n```ts twoslash\nimport { address, assertAccountExists, fetchEncodedAccount } from '@solana/kit';\n// ---cut-start---\nimport { createSolanaRpc } from '@solana/kit';\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\n// ---cut-end---\nconst account = await fetchEncodedAccount(\n rpc,\n address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ'),\n);\nassertAccountExists(account);\n\naccount.data satisfies Uint8Array;\n```\n\nFor typed reads, the `@solana-program/*` packages export `fetchX` and `decodeX` standalone helpers that take any `Rpc` and return decoded `Account` values without needing a Kit client. See [Fetching accounts](/docs/guides/fetching-accounts) for the full helper line-up and [Codecs](/docs/advanced-guides/codecs) for decoding raw bytes when no helper is available.\n\n## Next steps\n\n- [Plugins](/docs/plugins) — opt back in to the client model when you want it.\n- [Plugins — Creating custom plugins](/docs/plugins/creating-custom-plugins) — wrap a curated set of primitives into a reusable bundle.\n- [Advanced guides — Transactions](/docs/advanced-guides/transactions) — the full transaction message API.\n- [Advanced guides — Signers](/docs/advanced-guides/signers) — the signer interfaces in depth.\n" }, { "path": "docs/content/docs/advanced-guides/meta.json", "content": "{\n \"title\": \"Advanced Guides\",\n \"defaultOpen\": true,\n \"pages\": [\"kit-without-a-client\", \"...\"]\n}\n" }, { "path": "docs/content/docs/advanced-guides/offchain-messages.mdx", "content": "---\ntitle: Offchain messages\ndescription: Build, compile, sign, and verify messages offchain\n---\n\n## Introduction\n\nAny time you want one or more parties to approve of something that is not governed by an onchain program, you can prepare a message for them to sign offchain. Such messages can contain arbitrary contents, like the text of a plain-language contract, or some data encoded as text. Each offchain message contains a list of one or more signers that must provide a signature over that encoded message. Only when all of the required signers provide an authentic signature over the message are its contents considered to be ratified. You can use Kit to create, sign, verify, encode, and decode offchain messages.\n\n## Installation\n\nOffchain message utilities are **included within the `@solana/kit` library** but you may also install them using their standalone packages.\n\nTo install the offchain message utilities:\n\n```package-install\n@solana/offchain-messages\n```\n\n## What is an offchain message?\n\nAn offchain message consists of some UTF-8 message text, and a list of one or more required signers. The message is considered ratified when all of the signers provide a signature over the encoded message.\n\nHere is an example of a contract being proposed by one person as an offchain message, and ratified by another.\n\n\n \n ```ts twoslash\n const ursulaKeypair = null as unknown as CryptoKeyPair;\n // ---cut-before---\n import {\n Address,\n createSignerFromKeyPair,\n getOffchainMessageEnvelopeEncoder,\n OffchainMessage,\n partiallySignOffchainMessageWithSigners,\n } from '@solana/kit';\n\n // Ursula creates the contract as an offchain message.\n const ursulaSigner = await createSignerFromKeyPair(ursulaKeypair);\n const offchainMessage: OffchainMessage = {\n content:\n \"Ursula grants Ariel three days as a human, in exchange for Ariel's voice, on the \" +\n 'condition that Ariel secures a kiss of true love from Prince Eric before the third ' +\n 'sunset to remain human permanently. If Ariel fails, she reverts to a mermaid and ' +\n \"becomes Ursula's property.\",\n requiredSignatories: [\n ursulaSigner,\n { address: 'ARiEL3q7uXvN9yZK8s2a5GfpHmQdR7cBv' as Address },\n ],\n version: 1,\n };\n\n // Ursula partially signs the message, producing an offchain message envelope.\n const offchainMessageEnvelope =\n await partiallySignOffchainMessageWithSigners(offchainMessage);\n\n // Ursula encodes the offchain message envelope to share with Ariel.\n const offchainMessageEnvelopeBytes =\n getOffchainMessageEnvelopeEncoder().encode(offchainMessageEnvelope);\n ```\n \n \n ```ts twoslash\n import { ReadonlyUint8Array } from '@solana/kit';\n const arielKeypair = null as unknown as CryptoKeyPair;\n const offchainMessageEnvelopeBytes = null as unknown as ReadonlyUint8Array;\n // ---cut-before---\n import { getOffchainMessageEnvelopeCodec, signOffchainMessageEnvelope } from '@solana/kit';\n\n // Ariel decodes the offchain message envelope received from Ursula.\n const offchainMessageEnvelope =\n getOffchainMessageEnvelopeCodec().decode(offchainMessageEnvelopeBytes);\n\n // To ratify the contract, she signs the message.\n const fullySignedOffchainMessageEnvelope =\n await signOffchainMessageEnvelope([arielKeypair], offchainMessageEnvelope);\n\n // Ariel encodes the fully signed offchain message envelope to share with Ursula.\n const fullySignedOffchainMessageEnvelopeBytes =\n getOffchainMessageEnvelopeCodec().encode(fullySignedOffchainMessageEnvelope);\n ```\n \n\n \n ```ts twoslash\n import { ReadonlyUint8Array, OffchainMessageEnvelope } from '@solana/kit';\n const offchainMessageEnvelope = null as unknown as OffchainMessageEnvelope;\n const receivedOffchainMessageEnvelopeBytes = null as unknown as ReadonlyUint8Array;\n // ---cut-before---\n import {\n bytesEqual,\n getOffchainMessageEnvelopeDecoder,\n isSolanaError,\n verifyOffchainMessageEnvelope,\n SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE,\n } from '@solana/kit';\n\n // Upon receipt of the signed message envelope bytes from Ariel, Ursula decodes them.\n const receivedOffchainMessageEnvelope =\n getOffchainMessageEnvelopeDecoder().decode(receivedOffchainMessageEnvelopeBytes);\n\n // For good measure, Ursula verifies that the message bytes are the exact ones she sent.\n if (!bytesEqual(receivedOffchainMessageEnvelope.content, offchainMessageEnvelope.content)) {\n throw new Error('I do not accept this modified contract');\n }\n\n // Ursula then verifies the signatures on the envelope.\n try {\n await verifyOffchainMessageEnvelope(receivedOffchainMessageEnvelope);\n console.log('We have a deal!');\n } catch(e) {\n if (isSolanaError(e, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE)) {\n console.error('We do not have a deal!');\n } else {\n throw e;\n }\n }\n ```\n \n\n\n\n## Building offchain messages\n\nUse the [`OffchainMessage`](/api/type-aliases/OffchainMessage) type to help you create an offchain message.\n\n### Specifying the version\n\nSpecify the `version` property to select the schema and capabilities of the message. The latest version is version `1` which corresponds to the specification found in [sRFC 3](https://github.com/solana-foundation/SRFCs/discussions/3).\n\n```ts twoslash\n// @noErrors: 2322\nimport { address, OffchainMessage } from '@solana/kit';\n\nconst offchainMessage: OffchainMessage = {\n // [!code ++:1]\n version: 1,\n /* ... */\n};\n```\n\n\n The format and construction of v0 messages is beyond the scope of this guide. You can read the\n v0 specification [here](https://docs.solanalabs.com/proposals/off-chain-message-signing).\n\n\n### Required signatories\n\nEach message must specify a list of addresses belonging to accounts that must sign the message in order for it to be considered valid.\n\n#### Using a signer [!toc]\n\nYou can declare one or more required signatories using a [`MessageSigner`](/api/interfaces/MessageSigner).\n\n```ts twoslash\nconst myKeyPair = null as unknown as CryptoKeyPair;\n// ---cut-before---\n// @noErrors: 2322\nimport { createSignerFromKeyPair, OffchainMessage } from '@solana/kit';\n\nconst messageSigner = await createSignerFromKeyPair(myKeyPair);\nconst offchainMessage: OffchainMessage = {\n version: 1,\n // [!code ++:1]\n requiredSignatories: [messageSigner],\n /* ... */\n};\n```\n\nWhen you do so, the message will have the capability to self-sign using the [`signOffchainMessageWithSigners`](/api/functions/signOffchainMessageWithSigners) method. Follow the [instructions for signing offchain message envelopes with `CryptoKeyPairs`](#signing-offchain-message-envelopes) to sign it.\n\n#### Using an address [!toc]\n\nYou can declare one or more required signatories for whom you don't control the private key using the addresses of their accounts.\n\n```ts twoslash\nconst myKeyPair = null as unknown as CryptoKeyPair;\n// ---cut-before---\n// @noErrors: 2322\nimport { address, OffchainMessage } from '@solana/kit';\n\nconst offchainMessage: OffchainMessage = {\n version: 1,\n // [!code ++:1]\n requiredSignatories: [{ address: address('EkMpZ4tPqt7LgNCWjbNQ4WhuzFuitdwp8JPxSbCWXy9x') }],\n /* ... */\n};\n```\n\n### Defining the message content\n\nEach message must contain some non-empty UTF-8 text the signatories must agree upon.\n\n#### Using text [!toc]\n\nThe content can be a string of UTF-8 text.\n\n```ts twoslash\nconst myKeyPair = null as unknown as CryptoKeyPair;\n// ---cut-before---\nimport { address, createSignerFromKeyPair, OffchainMessage } from '@solana/kit';\n\nconst messageSigner = await createSignerFromKeyPair(myKeyPair);\nconst offchainMessage: OffchainMessage = {\n version: 1,\n requiredSignatories: [\n messageSigner,\n { address: address('r5FsobNdd53imrHH4rrdAt1MNkkJUjNPBTNqvKe9igR') },\n ],\n // [!code ++:1]\n content: '🥓 Crispy bacon is better than floppy bacon.',\n};\n```\n\n#### Using data [!toc]\n\nYou can also encode arbitrary data as text using an encoding such as base-64.\n\n```ts twoslash\nimport { ReadonlyUint8Array } from '@solana/kit';\nconst bytes = null as unknown as ReadonlyUint8Array;\nconst myKeyPair = null as unknown as CryptoKeyPair;\n// ---cut-before---\nimport { address, createSignerFromKeyPair, getBase64Decoder, OffchainMessage } from '@solana/kit';\n\nconst messageSigner = await createSignerFromKeyPair(myKeyPair);\nconst offchainMessage: OffchainMessage = {\n version: 1,\n requiredSignatories: [\n messageSigner,\n { address: address('r5FsobNdd53imrHH4rrdAt1MNkkJUjNPBTNqvKe9igR') },\n ],\n // [!code ++:1]\n content: getBase64Decoder().decode(bytes),\n};\n```\n\n## Signing offchain messages\n\nIn order to be considered ratified an offchain message must be signed by all of the private keys belonging to accounts that are required signatories of the message.\n\n- [`FullySignedOffchainMessageEnvelope`](/api/type-aliases/FullySignedOffchainMessageEnvelope): An offchain message that is signed by all of its required signatories.\n- [`OffchainMessageEnvelope`](/api/interfaces/OffchainMessageEnvelope): A compiled offchain message encoded as bytes, paired with a map between its required signatory addresses and their provided signatures, if any.\n\nOffchain messages whose signers are specified using `MessageSigner` objects have the ability to self-sign. This is because signers encapsulate both the address of the signing account as well as an implementation of the signing algorithm for the private key associated with that account.\n\nThe [`signOffchainMessageWithSigners`](/api/functions/signOffchainMessageWithSigners) method will return a new signed offchain message envelope of type `FullySignedOffchainMessageEnvelope`.\n\n```ts twoslash\nimport { OffchainMessage } from '@solana/kit';\nconst offchainMessage = null as unknown as OffchainMessage;\n// ---cut-before---\nimport {\n SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING,\n isSolanaError,\n signOffchainMessageWithSigners,\n} from '@solana/kit';\n\ntry {\n const fullySignedOffchainMessageEnvelope =\n await signOffchainMessageWithSigners(offchainMessage);\n} catch (e) {\n if (isSolanaError(e, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING)) {\n console.error('Missing signers for the following addresses:', e.context.addresses);\n } else {\n throw e;\n }\n}\n```\n\n\n This function will throw if the offchain message does not carry a `MessageSigner` implementation\n for every required signer. To partially sign a message that you know to carry a strict subset of\n the required `MessageSigners`, use the\n [`partiallySignOffchainMessageWithSigners`](/api/functions/partiallySignOffchainMessageWithSigners)\n method.\n\n\nBuilding offchain messages using `MessageSigners` is the recommended way to create self-signable offchain messages. To sign with a `CryptoKey` directly, you first have to compile the offchain message.\n\n```ts twoslash\nimport { OffchainMessage } from '@solana/kit';\nconst offchainMessage = null as unknown as OffchainMessage;\n// ---cut-before---\nimport { compileOffchainMessageEnvelope } from '@solana/kit';\n\nconst offchainMessageEnvelope = compileOffchainMessageEnvelope(offchainMessage);\n```\n\nThis produces an unsigned offchain message envelope. Follow the [instructions for signing offchain message envelopes with `CryptoKeyPairs`](#signing-offchain-message-envelopes) to sign it.\n\n\n If the version of the offchain message is known, use the compile function specific to that\n version, such as\n [`compileOffchainMessageV1Envelope`](/api/functions/compileOffchainMessageV1Envelope). This will\n prevent you from bundling compilers you don't need, saving space in your JavaScript bundle.\n\n\n## Signing offchain message envelopes\n\nWherever you have a `OffchainMessageEnvelope` instead of an `OffchainMessage` you can add or replace a signature using the `signOffchainMessageEnvelope` method and one or more `CryptoKeyPairs`.\n\n```ts twoslash\nimport { OffchainMessageEnvelope } from '@solana/kit';\nconst keyPair = null as unknown as CryptoKeyPair;\nconst offchainMessageEnvelope = null as unknown as OffchainMessageEnvelope;\n// ---cut-before---\nimport {\n SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING,\n isSolanaError,\n signOffchainMessageEnvelope,\n} from '@solana/kit';\n\ntry {\n const fullySignedOffchainMessageEnvelope = await signOffchainMessageEnvelope(\n [keyPair],\n offchainMessageEnvelope,\n );\n} catch (e) {\n if (isSolanaError(e, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING)) {\n console.error('Missing signers for the following addresses:', e.context.addresses);\n } else {\n throw e;\n }\n}\n```\n\n\n This function will throw if the resultant offchain message envelope is missing a signature for\n one of the offchain message's required signers. To partially sign an offchain message envelope,\n use the\n [`partiallySignOffchainMessageEnvelope`](/api/functions/partiallySignOffchainMessageEnvelope)\n method.\n\n\n## Verifying an offchain message\n\nGiven an offchain message envelope, you can verify that it has been signed by all of its required signatories using the [`verifyOffchainMessageEnvelope`](/api/functions/verifyOffchainMessageEnvelope) method.\n\n```ts twoslash\nimport { OffchainMessageEnvelope } from '@solana/kit';\nconst receivedOffchainMessageEnvelope = null as unknown as OffchainMessageEnvelope;\n// ---cut-before---\nimport {\n isSolanaError,\n verifyOffchainMessageEnvelope,\n SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE,\n} from '@solana/kit';\n\ntry {\n await verifyOffchainMessageEnvelope(receivedOffchainMessageEnvelope);\n} catch (e) {\n if (isSolanaError(e, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE)) {\n if (e.context.signatoriesWithInvalidSignatures.length) {\n console.error(\n 'The signatures for the following addresses are invalid',\n e.context.signatoriesWithInvalidSignatures,\n );\n }\n if (e.context.signatoriesWithMissingSignatures.length) {\n console.error(\n 'The following required signatories have not signed this message',\n e.context.signatoriesWithMissingSignatures,\n );\n }\n } else {\n throw e;\n }\n}\n```\n\n\n Verifying an offchain message will tell you if its content has been signed by all required\n signatories, but it will _not_ ensure that the content of the message nor its list of required\n signatories is what you expect it to be. Take special care to inspect the content of the message\n before accepting it. If you have the original bytes of the message, you can compare them to the\n `content` of the envelope you are verifying. Otherwise, see [deserializing offchain\n messages](#deserializing-offchain-messages) for instructions on how to decode the envelope's\n `content` for inspection.\n\n\n## Serializing offchain messages\n\nIf you would like to share an offchain message envelope with someone, you can serialize it to bytes using an encoder.\n\n```ts twoslash\nimport { OffchainMessageEnvelope } from '@solana/kit';\nconst offchainMessageEnvelope = null as unknown as OffchainMessageEnvelope;\n// ---cut-before---\nimport { getOffchainMessageEnvelopeEncoder } from '@solana/kit';\n\nconst offchainMessageEnvelopeBytes =\n getOffchainMessageEnvelopeEncoder().encode(offchainMessageEnvelope);\n```\n\n## Deserializing offchain messages\n\nDecoding the bytes of an encoded offchain message envelope yields an `OffchainMessageEnvelope` object. This takes the form of a compiled offchain message encoded as [`OffchainMessageBytes`](/api/type-aliases/OffchainMessageBytes), paired with a map between its required signatory addresses and their provided signatures, if any.\n\n```ts twoslash\nimport { ReadonlyUint8Array } from '@solana/kit';\nconst offchainMessageEnvelopeBytes = null as unknown as ReadonlyUint8Array;\n// ---cut-before---\nimport { getOffchainMessageEnvelopeDecoder } from '@solana/kit';\nconst offchainMessageEnvelope = getOffchainMessageEnvelopeDecoder().decode(\n offchainMessageEnvelopeBytes,\n);\n```\n\nDecoding the bytes of the offchain message envelope will yield an object containing an offchain message in its **compiled** form – a message in a form suitable for signing and transmitting over a network. Decompiling a compiled message will yield an `OffchainMessage` object. This is the most common form of offchain message that you will encounter when using Kit to build an application.\n\n```ts twoslash\nimport { OffchainMessageEnvelope } from '@solana/kit';\nconst offchainMessageEnvelope = null as unknown as OffchainMessageEnvelope;\n// ---cut-before---\nimport { getOffchainMessageDecoder } from '@solana/kit';\nconst offchainMessage = getOffchainMessageDecoder().decode(offchainMessageEnvelope.content);\n```\n" }, { "path": "docs/content/docs/advanced-guides/signers.mdx", "content": "---\ntitle: Signers\ndescription: Accounts with signing capabilities\n---\n\n## Introduction\n\nSigners are an abstraction that combines an account with an implementation that computes signatures on behalf of that account. No matter what actually computes the signature – a wallet app, a network API, the `SubtleCrypto` API, or a userspace implementation – so long as it implements the correct signer interface for your intended purpose, you can use it with all of Kit's signer-aware functions.\n\nSigners are designed to make it easier to build, sign, and send transactions by taking the guesswork out of which accounts' key pairs need to sign a transaction. Signer-aware APIs allow you to associate signer objects with each transaction instruction that requires them, enabling Kit's transaction planning, signing, and sending functions to automatically collect and invoke them.\n\n## Installation\n\nSigners are **included within the `@solana/kit` library** but you may also install them using their standalone package.\n\n```package-install\n@solana/signers\n```\n\n## What is a signer?\n\nAll signers are wrappers around an [`Address`](/api/type-aliases/Address). This means that most APIs that require an `Address` can be made to accept a signer. Each specific type of signer adds one or more capabilities, such as the ability to sign a message or a transaction on behalf of the account with that address. Some even add the ability to sign _and_ send a transaction, which is common for wallets that you use in your browser or on your phone.\n\n```ts twoslash\n// @noErrors: 2769\nimport {\n createSignableMessage,\n createTransactionMessage,\n generateKeyPairSigner,\n pipe,\n setTransactionMessageFeePayerSigner,\n signTransactionMessageWithSigners,\n} from '@solana/kit';\n\n// Generate a key pair signer.\nconst mySigner = await generateKeyPairSigner();\nmySigner.address; // The address of the account\n\n// Sign one or multiple messages.\nconst myMessage = createSignableMessage('Hello world!');\nconst [messageSignatures] = await mySigner.signMessages([myMessage]);\n// ^^^^^^^^\n\n// Sign to pay fees for a transaction message\nconst myTransactionMessage = pipe(\n createTransactionMessage({ version: 0 }),\n (m) => setTransactionMessageFeePayerSigner(mySigner, m),\n // ^^^^^^^^\n // Add instructions, lifetime, etc.\n);\nconst signedTransaction = await signTransactionMessageWithSigners(myTransactionMessage);\n```\n\nAs you can see, this provides a consistent API regardless of how things are being signed behind the scenes. If tomorrow we need to use a browser wallet instead, we'd simply need to swap the `generateKeyPairSigner()` function with the signer factory of our choice.\n\n## Types of signers\n\nThis package offers a total of five different types of signers that may be used in combination when applicable. Three of them allow us to sign transactions whereas the other two are used for regular message signing.\n\nThey are separated into three categories:\n\n- **Partial signers**: Given a message or transaction, provide one or more signatures for it. These signers are not able to modify the given data which allows us to run many of them in parallel.\n- **Modifying signers**: Can choose to modify a message or transaction before signing it with zero or more private keys. Because modifying a message or transaction invalidates any pre-existing signatures over it, modifying signers must do their work before any other signer.\n- **Sending signers**: Given a transaction, signs it and sends it immediately to the blockchain. When applicable, the signer may also decide to modify the provided transaction before signing it. This interface accommodates wallets that simply cannot sign a transaction without sending it at the same time. This category of signers does not apply to regular messages.\n\nThus, we end up with the following interfaces.\n\n| | Partial signers | Modifying signers | Sending signers |\n| ---------------------------------------------------------- | ------------------------------------------------------------------------ | ---------------------------------------------------------------------------- | ------------------------------------------------------------------------ |\n| [`TransactionSigner`](/api/type-aliases/TransactionSigner) | [`TransactionPartialSigner`](/api/type-aliases/TransactionPartialSigner) | [`TransactionModifyingSigner`](/api/type-aliases/TransactionModifyingSigner) | [`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner) |\n| [`MessageSigner`](/api/type-aliases/MessageSigner) | [`MessagePartialSigner`](/api/type-aliases/MessagePartialSigner) | [`MessageModifyingSigner`](/api/type-aliases/MessageModifyingSigner) | N/A |\n\nWe will go through each of these five signer interfaces and their respective characteristics in the documentation below.\n\n## Signing transactions\n\n### Partial signers [#transaction-partial-signers]\n\n[`TransactionPartialSigner`](/api/type-aliases/TransactionPartialSigner) is an interface that signs an array of [`Transactions`](/api/type-aliases/Transaction) without modifying their content. It defines a `signTransactions` function that returns a [`SignatureDictionary`](/api/type-aliases/SignatureDictionary) for each provided transaction. Such signature dictionaries are expected to be merged with the existing ones if any.\n\n```ts twoslash\n// @noErrors: 2355\nimport { address, SignatureDictionary, Transaction, TransactionPartialSigner } from '@solana/kit';\n// ---cut-before---\nconst myTransactionPartialSigner: TransactionPartialSigner<'1234..5678'> = {\n address: address('1234..5678'),\n signTransactions: async (transactions): Promise => {\n // My custom signing logic.\n },\n};\n```\n\n**Characteristics**:\n\n- **Parallel**. It returns a signature dictionary for each provided transaction without modifying them, making it possible for multiple partial signers to sign the same transaction in parallel.\n- **Flexible order**. The order in which we use these signers for a given transaction doesn’t matter.\n\n### Modifying signers\n\n[`TransactionModifyingSigner`](/api/type-aliases/TransactionModifyingSigner) is an interface that potentially modifies the provided [`Transactions`](/api/type-aliases/Transaction) before signing them. E.g. this enables wallets to inject additional instructions into the transaction before signing them. For each transaction, instead of returning a [`SignatureDictionary`](/api/type-aliases/SignatureDictionary), its `modifyAndSignTransactions` function returns an updated [`Transaction`](/api/type-aliases/Transaction) with a potentially modified set of instructions and signature dictionary.\n\n```ts twoslash\n// @noErrors: 2355\nimport {\n address,\n Transaction,\n TransactionModifyingSigner,\n TransactionWithinSizeLimit,\n TransactionWithLifetime,\n} from '@solana/kit';\n// ---cut-before---\nconst myTransactionModifyingSigner: TransactionModifyingSigner<'1234..5678'> = {\n address: address('1234..5678'),\n modifyAndSignTransactions: async (\n transactions: readonly Transaction[],\n ): Promise => {\n // My custom signing logic.\n },\n};\n```\n\n**Characteristics**:\n\n- **Sequential**. Contrary to partial signers, these cannot be executed in parallel as each call can modify the provided transactions.\n- **First signers**. For a given transaction, a modifying signer must always be used before a partial signer as the former will likely modify the transaction and thus impact the outcome of the latter.\n- **Potential conflicts**. If more than one modifying signer is provided, the second signer may invalidate the signature of the first one. However, modifying signers may decide not to modify a transaction based on the existence of signatures for that transaction.\n\n### Sending signers\n\n[`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner) is an interface that signs one or multiple transactions before sending them immediately to the blockchain. It defines a `signAndSendTransactions` function that returns the transaction signature (i.e. its identifier) for each provided [`Transaction`](/api/type-aliases/Transaction). This interface is required for PDA wallets and other types of wallets that don't provide an interface for signing transactions without sending them.\n\nNote that it is also possible for such signers to modify the provided transactions before signing and sending them. This enables use cases where the modified transactions cannot be shared with the app and thus must be sent directly.\n\n```ts twoslash\n// @noErrors: 2355\nimport { address, SignatureBytes, Transaction, TransactionSendingSigner } from '@solana/kit';\n// ---cut-before---\nconst myTransactionSendingSigner: TransactionSendingSigner<'1234..5678'> = {\n address: address('1234..5678'),\n signAndSendTransactions: async (transactions: Transaction[]): Promise => {\n // My custom signing logic.\n },\n};\n```\n\n**Characteristics**:\n\n- **Single signer**. Since this signer also sends the provided transactions, we can only use a single [`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner) for a given set of transactions.\n- **Last signer**. Trivially, that signer must also be the last one used.\n- **Potential conflicts**. Since signers may decide to modify the given transactions before sending them, they may invalidate previous signatures. However, signers may decide not to modify a transaction based on the existence of signatures for that transaction.\n- **Potential confirmation**. Whilst this is not required by this interface, it is also worth noting that most wallets will also wait for the transaction to be confirmed (typically with a `confirmed` commitment) before notifying the app that they are done.\n\n## Signing messages\n\n### Signable messages\n\n[`SignableMessage`](/api/type-aliases/SignableMessage) defines a message with any of the signatures that might have already been provided by other signers. This interface allows modifying signers to decide on whether or not they should modify the provided message depending on whether or not signatures already exist for such message. It also helps create a more consistent API by providing a structure analogous to transactions which also keep track of their signature dictionary.\n\n```ts twoslash\nimport { SignatureDictionary } from '@solana/kit';\n// ---cut-before---\ntype SignableMessage = {\n content: Uint8Array;\n signatures: SignatureDictionary; // Record\n};\n```\n\nYou can use the [`createSignableMessage`](/api/functions/createSignableMessage) function to create a [`SignableMessage`](/api/type-aliases/SignableMessage) from a `Uint8Array` or UTF-8 string. It optionally accepts a signature dictionary if the message already contains signatures.\n\n```ts twoslash\nimport { address, createSignableMessage, SignatureBytes } from '@solana/kit';\n// ---cut-before--\nconst myMessage = createSignableMessage(new Uint8Array([1, 2, 3]));\nconst myMessageFromText = createSignableMessage('Hello world!');\nconst myMessageWithSignatures = createSignableMessage('Hello world!', {\n [address('1234..5678')]: new Uint8Array([1, 2, 3]) as SignatureBytes,\n});\n```\n\n### Partial signers\n\n[`MessagePartialSigner`](/api/type-aliases/MessagePartialSigner) is an interface that signs an array of [`SignableMessages`](/api/type-aliases/SignableMessage) without modifying their content. It defines a `signMessages` function that returns a [`SignatureDictionary`](/api/type-aliases/SignatureDictionary) for each provided message. Such signature dictionaries are expected to be merged with the existing ones if any.\n\n```ts twoslash\n// @noErrors: 2355\nimport { address, MessagePartialSigner, SignableMessage, SignatureDictionary } from '@solana/kit';\n// ---cut-before---\nconst myMessagePartialSigner: MessagePartialSigner<'1234..5678'> = {\n address: address('1234..5678'),\n signMessages: async (messages: SignableMessage[]): Promise => {\n // My custom signing logic.\n },\n};\n```\n\n**Characteristics**:\n\n- **Parallel**. When multiple signers sign the same message, we can perform this operation in parallel to obtain all their signatures.\n- **Flexible order**. The order in which we use these signers for a given message doesn’t matter.\n\n### Modifying signers\n\n[`MessageModifyingSigner`](/api/type-aliases/MessageModifyingSigner) is an interface that potentially modifies the content of the provided [`SignableMessages`](/api/type-aliases/SignableMessage) before signing them. E.g. this enables wallets to prefix or suffix nonces to the messages they sign. For each message, instead of returning a [`SignatureDictionary`](/api/type-aliases/SignatureDictionary), its `modifyAndSignMessages` function returns its updated [`SignableMessage`](/api/type-aliases/SignableMessage) with a potentially modified content and signature dictionary.\n\n```ts twoslash\n// @noErrors: 2355\nimport { address, MessageModifyingSigner, SignableMessage } from '@solana/kit';\n// ---cut-before---\nconst myMessageModifyingSigner: MessageModifyingSigner<'1234..5678'> = {\n address: address('1234..5678'),\n modifyAndSignMessages: async (messages: SignableMessage[]): Promise => {\n // My custom signing logic.\n },\n};\n```\n\n**Characteristics**:\n\n- **Sequential**. Contrary to partial signers, these cannot be executed in parallel as each call can modify the content of the message.\n- **First signers**. For a given message, a modifying signer must always be used before a partial signer as the former will likely modify the message and thus impact the outcome of the latter.\n- **Potential conflicts**. If more than one modifying signer is provided, the second signer may invalidate the signature of the first one. However, modifying signers may decide not to modify a message based on the existence of signatures for that message.\n\n## Available signers\n\n### No-op signers\n\nFor a given address, a no-op signer can be created to offer an implementation of both the `MessagePartialSigner` and `TransactionPartialSigner` interfaces such that they do not sign anything. Namely, signing a transaction or a message with a `NoopSigner` will return an empty `SignatureDictionary`.\n\nThis signer may be useful:\n\n- For testing purposes.\n- For indicating that a given account is a signer and taking the responsibility to provide the signature for that account ourselves. For instance, if we need to send the transaction to a server that will sign it and send it for us.\n\n```ts twoslash\nimport {\n address,\n SignableMessage,\n Transaction,\n TransactionWithinSizeLimit,\n TransactionWithLifetime,\n} from '@solana/kit';\nconst myMessage = null as unknown as SignableMessage;\nconst myTransaction = null as unknown as Transaction &\n TransactionWithinSizeLimit &\n TransactionWithLifetime;\n// ---cut-before---\nimport { createNoopSigner } from '@solana/kit';\n\nconst myNoopSigner = createNoopSigner(address('1234..5678'));\nconst [myMessageSignatures] = await myNoopSigner.signMessages([myMessage]); // <- Empty signature dictionary.\nconst [myTransactionSignatures] = await myNoopSigner.signTransactions([myTransaction]); // <- Empty signature dictionary.\n```\n\n### Key pair signers\n\nA key pair signer uses a `CryptoKeyPair` to sign messages and transactions. It implements both the `MessagePartialSigner` and `TransactionPartialSigner` interfaces and keeps track of the `CryptoKeyPair` instance used to sign messages and transactions.\n\n
\n\n[createSignerFromKeyPair](#create-signer-from-key-pair)\n[generateKeyPairSigner](#generate-key-pair-signer)\n[createKeyPairSignerFromBytes](#create-key-pair-signer-from-bytes)\n[createKeyPairSignerFromPrivateKeyBytes](#create-key-pair-signer-from-private-key-bytes)\n\n
\n\n#### createSignerFromKeyPair [!toc] [#create-signer-from-key-pair]\n\nCreates a `KeyPairSigner` from a provided Crypto KeyPair. The `signMessages` and `signTransactions` functions of the returned signer will use the private key of the provided key pair to sign messages and transactions. Note that both the `signMessages` and `signTransactions` implementations are parallelized, meaning that they will sign all provided messages and transactions in parallel.\n\n```ts twoslash\nimport { createSignerFromKeyPair, generateKeyPair, KeyPairSigner } from '@solana/kit';\n\nconst myKeyPair: CryptoKeyPair = await generateKeyPair();\nconst myKeyPairSigner: KeyPairSigner = await createSignerFromKeyPair(myKeyPair);\n```\n\n#### generateKeyPairSigner [!toc] [#generate-key-pair-signer]\n\nA convenience function that generates a new Crypto KeyPair and immediately creates a `KeyPairSigner` from it.\n\n```ts twoslash\nimport { generateKeyPairSigner } from '@solana/kit';\n\nconst myKeyPairSigner = await generateKeyPairSigner();\n```\n\n#### createKeyPairSignerFromBytes [!toc] [#create-key-pair-signer-from-bytes]\n\nA convenience function that creates a new KeyPair from a 64-bytes `Uint8Array` secret key and immediately creates a `KeyPairSigner` from it.\n\n```ts twoslash\nimport fs from 'fs';\nimport { createKeyPairSignerFromBytes } from '@solana/kit';\n\n// Get bytes from local keypair file.\nconst keypairFile = fs.readFileSync('~/.config/solana/id.json');\nconst keypairBytes = new Uint8Array(JSON.parse(keypairFile.toString()));\n\n// Create a KeyPairSigner from the bytes.\nconst signer = await createKeyPairSignerFromBytes(keypairBytes);\n```\n\n#### createKeyPairSignerFromPrivateKeyBytes [!toc] [#create-key-pair-signer-from-private-key-bytes]\n\nA convenience function that creates a new KeyPair from a 32-bytes `Uint8Array` private key and immediately creates a `KeyPairSigner` from it.\n\n```ts twoslash\nimport { createKeyPairSignerFromPrivateKeyBytes, getUtf8Encoder } from '@solana/kit';\n\nconst message = getUtf8Encoder().encode('Hello, World!');\nconst seed = new Uint8Array(await crypto.subtle.digest('SHA-256', message));\n\nconst derivedSigner = await createKeyPairSignerFromPrivateKeyBytes(seed);\n```\n\n### Wallet account signers\n\nWallet account signers bridge between [Wallet Standard](https://github.com/wallet-standard/wallet-standard) accounts and Kit's signer interfaces. They live in the [`@solana/wallet-account-signer`](https://www.npmjs.com/package/@solana/wallet-account-signer) package and let any wallet that exposes the standard Solana features participate in signing transactions and messages.\n\n```package-install\n@solana/wallet-account-signer\n```\n\n
\n\n[createSignerFromWalletAccount](#create-signer-from-wallet-account)\n[createTransactionSignerFromWalletAccount](#create-transaction-signer-from-wallet-account)\n[createTransactionSendingSignerFromWalletAccount](#create-transaction-sending-signer-from-wallet-account)\n[createMessageSignerFromWalletAccount](#create-message-signer-from-wallet-account)\n\n
\n\n#### createSignerFromWalletAccount [!toc] [#create-signer-from-wallet-account]\n\nInspects the wallet account's available features and returns a single signer object combining whichever capabilities the wallet supports — `modifyAndSignTransactions`, `signAndSendTransactions`, and/or `modifyAndSignMessages`. Use this when you do not know in advance which features a wallet exposes.\n\n```ts twoslash\nimport { UiWalletAccount } from '@wallet-standard/ui';\nconst walletAccount = null as unknown as UiWalletAccount;\n// ---cut-before---\nimport { createSignerFromWalletAccount } from '@solana/wallet-account-signer';\n\nconst signer = createSignerFromWalletAccount(walletAccount, 'solana:devnet');\n```\n\n#### createTransactionSignerFromWalletAccount [!toc] [#create-transaction-signer-from-wallet-account]\n\nReturns a [`TransactionModifyingSigner`](/api/type-aliases/TransactionModifyingSigner) that signs transactions with the wallet via the `solana:signTransaction` feature. The signer is allowed to modify the transaction before signing, which lets the wallet inject guard instructions or priority fees if it wants to.\n\n```ts twoslash\nimport { UiWalletAccount } from '@wallet-standard/ui';\nconst walletAccount = null as unknown as UiWalletAccount;\n// ---cut-before---\nimport { createTransactionSignerFromWalletAccount } from '@solana/wallet-account-signer';\n\nconst signer = createTransactionSignerFromWalletAccount(walletAccount, 'solana:devnet');\n```\n\n#### createTransactionSendingSignerFromWalletAccount [!toc] [#create-transaction-sending-signer-from-wallet-account]\n\nReturns a [`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner) that uses the `solana:signAndSendTransaction` feature to sign and immediately submit the transaction to the network. This is the right shape for wallets that do not let the dapp inspect or relay the signed transaction itself.\n\n```ts twoslash\nimport { UiWalletAccount } from '@wallet-standard/ui';\nconst walletAccount = null as unknown as UiWalletAccount;\n// ---cut-before---\nimport { createTransactionSendingSignerFromWalletAccount } from '@solana/wallet-account-signer';\n\nconst signer = createTransactionSendingSignerFromWalletAccount(walletAccount, 'solana:devnet');\n```\n\n#### createMessageSignerFromWalletAccount [!toc] [#create-message-signer-from-wallet-account]\n\nReturns a [`MessageModifyingSigner`](/api/type-aliases/MessageModifyingSigner) that signs arbitrary messages via the `solana:signMessage` feature. This is the wallet-backed counterpart to a key pair signer's message-signing capability.\n\n```ts twoslash\nimport { UiWalletAccount } from '@wallet-standard/ui';\nconst walletAccount = null as unknown as UiWalletAccount;\n// ---cut-before---\nimport { createMessageSignerFromWalletAccount } from '@solana/wallet-account-signer';\n\nconst signer = createMessageSignerFromWalletAccount(walletAccount);\n```\n\n## Signing with signers\n\nKit provides helper functions that use [`TransactionSigner`](/api/type-aliases/TransactionSigner) objects to sign and optionally send transactions. There are two families of signing functions:\n\n- **Transaction message functions** extract signers from the transaction message — either from the fee payer or from account metas — and handle compilation and signing automatically.\n- **Transaction functions** accept an explicit array of signers alongside a compiled [`Transaction`](/api/type-aliases/Transaction), giving you full control over which signers are used.\n\n### Signing transaction messages\n\nThe following functions extract [`TransactionSigners`](/api/type-aliases/TransactionSigner) from a transaction message's account metas, compile the message into a [`Transaction`](/api/type-aliases/Transaction), and use those signers to sign it.\n\n#### partiallySignTransactionMessageWithSigners [!toc] [#partially-sign-transaction-message-with-signers]\n\nSigns a transaction message without requiring all signatures to be present. This is useful when you know the message only carries a subset of the required signers and you plan to add more signatures later.\n\n```ts twoslash\nimport {\n TransactionMessage,\n TransactionMessageWithFeePayer,\n TransactionMessageWithSigners,\n} from '@solana/kit';\nconst transactionMessage = null as unknown as TransactionMessage &\n TransactionMessageWithFeePayer &\n TransactionMessageWithSigners;\n// ---cut-before---\nimport { partiallySignTransactionMessageWithSigners } from '@solana/kit';\n\nconst signedTransaction = await partiallySignTransactionMessageWithSigners(transactionMessage);\n```\n\n\n This function ignores any\n [`TransactionSendingSigners`](/api/type-aliases/TransactionSendingSigner) in the message since\n it does not send the transaction. Use\n [`signAndSendTransactionMessageWithSigners`](#sign-and-send-transaction-message-with-signers) if\n you need to sign and send in a single step.\n\n\n#### signTransactionMessageWithSigners [!toc] [#sign-transaction-message-with-signers]\n\nSigns a transaction message and asserts that all required signatures are present. The returned transaction satisfies the [`FullySignedTransaction`](/api/type-aliases/FullySignedTransaction) type.\n\n```ts twoslash\nimport {\n TransactionMessage,\n TransactionMessageWithFeePayer,\n TransactionMessageWithSigners,\n} from '@solana/kit';\nconst transactionMessage = null as unknown as TransactionMessage &\n TransactionMessageWithFeePayer &\n TransactionMessageWithSigners;\n// ---cut-before---\nimport { signTransactionMessageWithSigners } from '@solana/kit';\n\nconst fullySignedTransaction = await signTransactionMessageWithSigners(transactionMessage);\n```\n\n\n This function will throw if the transaction message does not carry a\n [`TransactionSigner`](/api/type-aliases/TransactionSigner) implementation for every required\n signer. To partially sign a message that you know to carry a strict subset of the required\n signers, use\n [`partiallySignTransactionMessageWithSigners`](#partially-sign-transaction-message-with-signers).\n\n\n#### signAndSendTransactionMessageWithSigners [!toc] [#sign-and-send-transaction-message-with-signers]\n\nSigns a transaction message and sends it to the network via the [`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner) found in the message's account metas. Returns the transaction signature as [`SignatureBytes`](/api/type-aliases/SignatureBytes).\n\n```ts twoslash\nimport {\n TransactionMessage,\n TransactionMessageWithFeePayer,\n TransactionMessageWithSigners,\n TransactionMessageWithSingleSendingSigner,\n} from '@solana/kit';\nconst transactionMessage = null as unknown as TransactionMessage &\n TransactionMessageWithFeePayer &\n TransactionMessageWithSigners &\n TransactionMessageWithSingleSendingSigner;\n// ---cut-before---\nimport { signAndSendTransactionMessageWithSigners } from '@solana/kit';\n\nconst signature = await signAndSendTransactionMessageWithSigners(transactionMessage);\n```\n\nThe message must contain exactly one resolvable [`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner). You can check this ahead of time using [`isTransactionMessageWithSingleSendingSigner`](/api/functions/isTransactionMessageWithSingleSendingSigner) to provide a fallback strategy:\n\n```ts twoslash\n// @noErrors: 2345\nimport {\n Rpc,\n RpcSubscriptions,\n SolanaRpcApi,\n SolanaRpcSubscriptionsApi,\n TransactionMessage,\n TransactionMessageWithBlockhashLifetime,\n TransactionMessageWithFeePayer,\n TransactionMessageWithSigners,\n} from '@solana/kit';\nconst transactionMessage = null as unknown as TransactionMessage &\n TransactionMessageWithBlockhashLifetime &\n TransactionMessageWithFeePayer &\n TransactionMessageWithSigners;\nconst rpc = null as unknown as Rpc;\nconst rpcSubscriptions = null as unknown as RpcSubscriptions;\n// ---cut-before---\nimport {\n isTransactionMessageWithSingleSendingSigner,\n sendAndConfirmTransactionFactory,\n signAndSendTransactionMessageWithSigners,\n signTransactionMessageWithSigners,\n} from '@solana/kit';\n\nif (isTransactionMessageWithSingleSendingSigner(transactionMessage)) {\n // A sending signer is available — sign and send in one step.\n const signature = await signAndSendTransactionMessageWithSigners(transactionMessage);\n} else {\n // No sending signer — sign locally and use sendAndConfirmTransaction.\n const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);\n const sendAndConfirm = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });\n await sendAndConfirm(signedTransaction, { commitment: 'confirmed' });\n}\n```\n\n### Signing compiled transactions\n\nWhen you already have a compiled [`Transaction`](/api/type-aliases/Transaction) and an explicit set of signers — for example, when signers are not embedded in the transaction message or when working with an externally provided transaction — you can use the following lower-level functions.\n\n#### partiallySignTransactionWithSigners [!toc] [#partially-sign-transaction-with-signers]\n\nSigns a compiled transaction using the provided [`TransactionModifyingSigners`](/api/type-aliases/TransactionModifyingSigner) and [`TransactionPartialSigners`](/api/type-aliases/TransactionPartialSigner) without requiring all signatures to be present.\n\n```ts twoslash\nimport {\n Transaction,\n TransactionWithLifetime,\n TransactionPartialSigner,\n TransactionModifyingSigner,\n} from '@solana/kit';\nconst compiledTransaction = null as unknown as Transaction & TransactionWithLifetime;\nconst signerA = null as unknown as TransactionPartialSigner;\nconst signerB = null as unknown as TransactionPartialSigner;\n// ---cut-before---\nimport { partiallySignTransactionWithSigners } from '@solana/kit';\n\nconst signedTransaction = await partiallySignTransactionWithSigners(\n [signerA, signerB],\n compiledTransaction,\n);\n```\n\n\n This function ignores any\n [`TransactionSendingSigners`](/api/type-aliases/TransactionSendingSigner) in the provided array.\n Use [`signAndSendTransactionWithSigners`](#sign-and-send-transaction-with-signers) if you need\n to sign and send.\n\n\n#### signTransactionWithSigners [!toc] [#sign-transaction-with-signers]\n\nSigns a compiled transaction using the provided signers and asserts that all required signatures are present. The returned transaction satisfies the [`FullySignedTransaction`](/api/type-aliases/FullySignedTransaction) type.\n\n```ts twoslash\nimport { Transaction, TransactionWithLifetime, TransactionPartialSigner } from '@solana/kit';\nconst compiledTransaction = null as unknown as Transaction & TransactionWithLifetime;\nconst signerA = null as unknown as TransactionPartialSigner;\nconst signerB = null as unknown as TransactionPartialSigner;\n// ---cut-before---\nimport { signTransactionWithSigners } from '@solana/kit';\n\nconst fullySignedTransaction = await signTransactionWithSigners(\n [signerA, signerB],\n compiledTransaction,\n);\n```\n\n\n This function will throw if the resultant transaction is missing a signature for one of its\n required signers. To partially sign, use\n [`partiallySignTransactionWithSigners`](#partially-sign-transaction-with-signers).\n\n\n#### signAndSendTransactionWithSigners [!toc] [#sign-and-send-transaction-with-signers]\n\nSigns a compiled transaction using the provided signers and sends it to the network via the [`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner) found in the array. Returns the transaction signature as [`SignatureBytes`](/api/type-aliases/SignatureBytes).\n\n```ts twoslash\nimport {\n Transaction,\n TransactionWithLifetime,\n TransactionPartialSigner,\n TransactionSendingSigner,\n} from '@solana/kit';\nconst compiledTransaction = null as unknown as Transaction & TransactionWithLifetime;\nconst partialSigner = null as unknown as TransactionPartialSigner;\nconst sendingSigner = null as unknown as TransactionSendingSigner;\n// ---cut-before---\nimport { signAndSendTransactionWithSigners } from '@solana/kit';\n\nconst signature = await signAndSendTransactionWithSigners(\n [partialSigner, sendingSigner],\n compiledTransaction,\n);\n```\n\nThe provided signers must contain exactly one resolvable [`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner). You can validate this ahead of time using [`assertContainsResolvableTransactionSendingSigner`](#assert-contains-resolvable-transaction-sending-signer).\n\n#### assertContainsResolvableTransactionSendingSigner [!toc] [#assert-contains-resolvable-transaction-sending-signer]\n\nAsserts that an array of signers contains at least one [`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner) that can be unambiguously resolved. This is useful for validating your signers before calling [`signAndSendTransactionWithSigners`](#sign-and-send-transaction-with-signers).\n\n```ts twoslash\nimport { TransactionSigner } from '@solana/kit';\nconst mySigners = null as unknown as TransactionSigner[];\n// ---cut-before---\nimport { assertContainsResolvableTransactionSendingSigner } from '@solana/kit';\n\n// Throws if no resolvable sending signer is found or if\n// multiple sending-only signers conflict with each other.\nassertContainsResolvableTransactionSendingSigner(mySigners);\n```\n\n### How composite signers are resolved\n\nWhen a signer implements multiple interfaces (e.g. both [`TransactionPartialSigner`](/api/type-aliases/TransactionPartialSigner) and [`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner)), the signing functions automatically resolve it to the most appropriate role:\n\n1. **[`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner)** — Used if no other signer exclusively implements the sending interface. Only one sending signer can be active.\n2. **[`TransactionModifyingSigner`](/api/type-aliases/TransactionModifyingSigner)** — Used if no other signer exclusively implements the modifying interface. Modifying signers run sequentially before all others.\n3. **[`TransactionPartialSigner`](/api/type-aliases/TransactionPartialSigner)** — The fallback. Partial signers run in parallel after all modifying signers have finished.\n\nThis means a composite signer is always demoted to the least powerful interface that avoids conflicts with other signers.\n" }, { "path": "docs/content/docs/advanced-guides/transactions.mdx", "content": "---\ntitle: Transactions\ndescription: Build and compile transaction messages\n---\n\n## Introduction\n\nTo take an action on Solana, whether to place an order, transfer an asset, or more generally to modify data on the blockchain, you need to prepare a transaction and sign to pay for it to be executed on the network. You can use Kit to create, sign, encode, and decode transactions.\n\n## Installation\n\nTransaction utilities are **included within the `@solana/kit` library** but you may also install them using their standalone packages.\n\nTo install transaction message builder utilities:\n\n```package-install\n@solana/transaction-messages\n```\n\nTo install utilities that let you sign and compile transaction messages into transactions that can be landed on the network:\n\n```package-install\n@solana/transactions\n```\n\n## What is a Transaction?\n\nA Transaction is a vehicle to deliver one or more instructions to the Solana network in pursuit of some outcome.\n\nHere is an example of someone creating a transaction message to place an order at their favourite coffee shop, then signing it to create a transaction.\n\n```ts twoslash\nimport { Blockhash, TransactionSigner } from '@solana/kit';\nconst customerSigner = null as unknown as TransactionSigner;\nconst latestBlockhash = null as unknown as { blockhash: Blockhash; lastValidBlockHeight: bigint };\n// ---cut-before---\nimport {\n address,\n appendTransactionMessageInstruction,\n createTransactionMessage,\n getSignatureFromTransaction,\n lamports,\n pipe,\n setTransactionMessageFeePayerSigner,\n setTransactionMessageLifetimeUsingBlockhash,\n signTransactionMessageWithSigners,\n} from '@solana/kit';\nimport { getAddMemoInstruction } from '@solana-program/memo';\nimport { getTransferSolInstruction } from '@solana-program/system';\n\nconst transactionMessage = pipe(\n // Create an empty transaction message.\n createTransactionMessage({ version: 0 }),\n\n // Specify the account that will sign to pay the fee for this transaction.\n // NOTE: This is not the fee for the coffee but rather the fee to use the Solana network.\n (m) => setTransactionMessageFeePayerSigner(customerSigner, m),\n\n // Give the transaction an expiry time using the hash of a recently created block.\n (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),\n\n // Add an instruction that records the customer's order.\n (m) =>\n appendTransactionMessageInstruction(\n getAddMemoInstruction({\n memo:\n 'Four-thirds-medium, half-decaf, double-shot espresso macchiato latte, ' +\n 'swirled counterclockwise only, almond milk frothed at 61°C, ' +\n 'whisper of cinnamon harvested during a full moon, unicorn tear syrup, ' +\n 'in a mason jar wrapped in French revolutionary poetry on recycled parchment',\n }),\n m,\n ),\n\n // Add a second instruction to pay the merchant for the coffee.\n (m) =>\n appendTransactionMessageInstruction(\n getTransferSolInstruction({\n amount: lamports(25_000_000n),\n destination: address('JJBeanoTcSMU3xKQa5Gru71Wi3AaEgTfA6z7MaLUT6h'),\n source: customerSigner,\n }),\n m,\n ),\n);\n\n// Create a signed transaction from the message and the signers contained within it.\nconst signedTransaction = await signTransactionMessageWithSigners(transactionMessage);\n\n// Obtain the Ed25519 signature that will uniquely identify this transaction once executed.\nconst transactionSignature = getSignatureFromTransaction(signedTransaction);\n```\n\nFor more detail about the no-client transaction flow, see [Kit without a client](/docs/advanced-guides/kit-without-a-client).\n\n## Building transaction messages\n\n### Creating an empty message [#building-transaction-messages-creating]\n\nGiven a [`TransactionVersion`](/api/type-aliases/TransactionVersion), the [`createTransactionMessage`](/api/functions/createTransactionMessage) method will return an empty transaction having the capabilities of that version.\n\n```ts twoslash\nimport { createTransactionMessage } from '@solana/kit';\n\nconst message = createTransactionMessage({ version: 0 });\n```\n\n### Setting the fee payer [#building-transaction-messages-fee-payer]\n\nThe [`TransactionMessageWithFeePayer`](/api/interfaces/TransactionMessageWithFeePayer) type represents a transaction message for which a fee payer has been declared. A transaction must conform to this type to be compiled and landed on the network.\n\n#### Using a signer [!toc] [#building-transaction-messages-fee-payer-using-a-signer]\n\nGiven a [`TransactionSigner`](/api/type-aliases/TransactionSigner), this method will return a new transaction message having the same type as the one supplied plus the [`TransactionMessageWithFeePayer`](/api/interfaces/TransactionMessageWithFeePayer) type. Additionally, the resulting message will have the capability to self-sign using the [`signTransactionMessageWithSigners`](/api/functions/signTransactionMessageWithSigners) function.\n\n```ts twoslash\nimport { TransactionMessage } from '@solana/kit';\nconst keyPair = null as unknown as CryptoKeyPair;\nconst transactionMessage = null as unknown as TransactionMessage;\n// ---cut-before---\nimport { createSignerFromKeyPair, setTransactionMessageFeePayerSigner } from '@solana/kit';\n\nconst mySigner = await createSignerFromKeyPair(keyPair);\nconst transactionMessagePaidByMe = setTransactionMessageFeePayerSigner(\n mySigner,\n transactionMessage,\n);\n```\n\n#### Using an address [!toc] [#building-transaction-messages-fee-payer-using-an-address]\n\nGiven a base58-encoded address of a system account, this method will return a new transaction message having the same type as the one supplied plus the [`TransactionMessageWithFeePayer`](/api/interfaces/TransactionMessageWithFeePayer) type.\n\n```ts twoslash\nimport { TransactionMessage } from '@solana/kit';\nconst transactionMessage = null as unknown as TransactionMessage;\n// ---cut-before---\nimport { address, setTransactionMessageFeePayer } from '@solana/kit';\n\nconst myAddress = address('mpngsFd4tmbUfzDYJayjKZwZcaR7aWb2793J6grLsGu');\nconst transactionMessagePaidByMe = setTransactionMessageFeePayer(myAddress, transactionMessage);\n```\n\n### Defining the lifetime [#building-transaction-messages-lifetime]\n\nA signed transaction can be only be landed on the network if certain conditions are met:\n\n- It includes the hash of a recent block\n- Or it includes the value of an unused nonce known to the network\n\nThese conditions define a transaction's lifetime, after which it can no longer be landed, even if signed. The lifetime must be added to the transaction message before it is compiled to be sent.\n\n#### Using a recent blockhash [!toc] [#building-transaction-messages-lifetime-using-a-recent-blockhash]\n\nThe [`TransactionMessageWithBlockhashLifetime`](/api/interfaces/TransactionMessageWithBlockhashLifetime) type represents a transaction message whose expiry is tied to the age of a block. Such a transaction can only be landed on the network if the current block height of the network is less than or equal to the value of `TransactionMessageWithBlockhashLifetime.lifetimeConstraint.lastValidBlockHeight`.\n\nGiven a blockhash and the last block height at which that blockhash is considered usable to land transactions, the [`setTransactionMessageLifetimeUsingBlockhash`](/api/functions/setTransactionMessageLifetimeUsingBlockhash) method will return a new transaction message having the same type as the one supplied plus the [`TransactionMessageWithBlockhashLifetime`](/api/interfaces/TransactionMessageWithBlockhashLifetime) type.\n\n```ts twoslash\nimport { Rpc, GetLatestBlockhashApi, TransactionMessage } from '@solana/kit';\nconst rpc = null as unknown as Rpc;\nconst transactionMessage = null as unknown as TransactionMessage;\n// ---cut-before---\nimport { setTransactionMessageLifetimeUsingBlockhash } from '@solana/kit';\n\nconst { value: latestBlockhash } = await rpc.getLatestBlockhash().send();\nconst txMessageWithBlockhashLifetime = setTransactionMessageLifetimeUsingBlockhash(\n latestBlockhash,\n transactionMessage,\n);\n```\n\n#### Using a durable nonce [!toc] [#building-transaction-messages-lifetime-using-a-durable-nonce]\n\nThe [`TransactionMessageWithDurableNonceLifetime`](/api/interfaces/TransactionMessageWithDurableNonceLifetime) type represents a transaction message whose lifetime is defined by the value of a nonce account onchain. Such a transaction can only be landed on the network if the nonce value in the transaction message matches the one in the nonce account at the time the transaction executes.\n\nGiven a nonce, the account where the value of the nonce is stored, and the address of the account authorized to consume that nonce, this method will return a new transaction having the same type as the one supplied plus the [`TransactionMessageWithDurableNonceLifetime`](/api/interfaces/TransactionMessageWithDurableNonceLifetime) type.\n\n```ts twoslash\nimport { TransactionMessage, address, Rpc, GetAccountInfoApi } from '@solana/kit';\nconst rpc = null as unknown as Rpc;\nconst transactionMessage = null as unknown as TransactionMessage;\n// ---cut-before---\nimport { Nonce, setTransactionMessageLifetimeUsingDurableNonce } from '@solana/kit';\nimport { fetchNonce } from '@solana-program/system';\n\nconst nonceAccountAddress = address('EGtMh4yvXswwHhwVhyPxGrVV2TkLTgUqGodbATEPvojZ');\nconst nonceAuthorityAddress = address('4KD1Rdrd89NG7XbzW3xsX9Aqnx2EExJvExiNme6g9iAT');\n\nconst {\n data: { blockhash },\n} = await fetchNonce(rpc, nonceAccountAddress);\nconst nonce = blockhash as string as Nonce;\n\nconst durableNonceTransactionMessage = setTransactionMessageLifetimeUsingDurableNonce(\n { nonce, nonceAccountAddress, nonceAuthorityAddress },\n transactionMessage,\n);\n```\n\nIn particular, this method _prepends_ an instruction to the transaction message designed to consume (or ‘advance’) the nonce in the same transaction whose lifetime is defined by it.\n\n```ts twoslash\nimport { TransactionMessageWithDurableNonceLifetime } from '@solana/kit';\nconst durableNonceTransactionMessage =\n null as unknown as TransactionMessageWithDurableNonceLifetime<\n 'EGtMh4yvXswwHhwVhyPxGrVV2TkLTgUqGodbATEPvojZ',\n '4KD1Rdrd89NG7XbzW3xsX9Aqnx2EExJvExiNme6g9iAT'\n >;\n// ---cut-before---\nconst [\n // An 'advance nonce' instruction gets prepended to the instruction list\n advanceNonceInstruction,\n ...otherInstructions\n] = durableNonceTransactionMessage.instructions;\n```\n\n### Adding instructions [#building-transaction-messages-instructions]\n\nThere are three types that correspond to the different parts of an instruction. Any given instruction may conform to one or more of these types, but must conform in every case to the `Instruction` type.\n\n- [`Instruction`](/api/interfaces/Instruction): An instruction having a `programAddress` property that is the base58-encoded address of the program to invoke.\n- [`InstructionWithAccounts`](/api/interfaces/InstructionWithAccounts): An instruction that specifies a list of accounts that a program may read from, write to, or require be signers of the transaction itself. Objects that conform to this type have an `accounts` property that is an array of `AccountMeta | AccountLookupMeta` in the order the instruction requires.\n- [`InstructionWithData`](/api/interfaces/InstructionWithData): An instruction that supplies some data as input to the program. Objects that conform to this type have a `data` property that can be any type of `Uint8Array`.\n\nGiven an instruction, the [`appendTransactionMessageInstruction`](/api/functions/appendTransactionMessageInstruction) method will return a new transaction message with that instruction having been added to the end of the list of existing instructions.\n\n```ts twoslash\nimport { TransactionMessage } from '@solana/kit';\nconst transactionMessage = null as unknown as TransactionMessage;\n// ---cut-before---\nimport { address, appendTransactionMessageInstruction, getUtf8Encoder } from '@solana/kit';\nimport { getAddMemoInstruction } from '@solana-program/memo';\n\nconst memoTransactionMessage = appendTransactionMessageInstruction(\n getAddMemoInstruction({ memo: 'Hello world!' }),\n transactionMessage,\n);\n```\n\nTo add an instruction to the beginning of the list instead, see [`prependTransactionMessageInstruction`](/api/functions/prependTransactionMessageInstruction)\n\nTo add an array of instructions to a transaction message, see [`appendTransactionMessageInstructions`](/api/functions/appendTransactionMessageInstructions) and [`prependTransactionMessageInstructions`](/api/functions/prependTransactionMessageInstructions).\n\n## Configuring compute and priority fees\n\nEvery transaction has a compute budget — a maximum number of compute units (CUs) it is allowed to consume. The Solana network also lets you attach a priority fee to influence inclusion ordering. Kit exposes these as first-class configuration setters on the transaction message, so you do not need to add or update Compute Budget program instructions yourself.\n\n### Setting the compute unit limit [#configuring-compute-unit-limit]\n\nThe compute unit limit caps how many CUs the transaction may consume. Setting it close to what your transaction actually uses increases the chance of inclusion, packs more transactions per block, and reduces the amount of priority fees you pay.\n\n```ts twoslash\nimport { TransactionMessage } from '@solana/kit';\nconst transactionMessage = null as unknown as TransactionMessage;\n// ---cut-before---\nimport { setTransactionMessageComputeUnitLimit } from '@solana/kit';\n\nconst transactionMessageWithLimit = setTransactionMessageComputeUnitLimit(\n 50_000,\n transactionMessage,\n);\n```\n\nTo remove the limit, pass `undefined` as the first argument. The matching reader [`getTransactionMessageComputeUnitLimit`](/api/functions/getTransactionMessageComputeUnitLimit) returns the limit currently set on a message, or `undefined` if none is set.\n\n### Estimating the compute unit limit [#configuring-compute-unit-limit-estimation]\n\nA good way to size the compute unit limit is to simulate the transaction and use the result. Kit ships [`estimateComputeUnitLimitFactory`](/api/functions/estimateComputeUnitLimitFactory) for the simulation step and [`estimateAndSetComputeUnitLimitFactory`](/api/functions/estimateAndSetComputeUnitLimitFactory) for the common case of estimating and writing the result back onto the message in one call.\n\n```ts twoslash\nimport {\n Rpc,\n SimulateTransactionApi,\n TransactionMessage,\n TransactionMessageWithFeePayer,\n} from '@solana/kit';\nconst rpc = null as unknown as Rpc;\nconst transactionMessage = null as unknown as TransactionMessage & TransactionMessageWithFeePayer;\n// ---cut-before---\nimport {\n estimateAndSetComputeUnitLimitFactory,\n estimateComputeUnitLimitFactory,\n} from '@solana/kit';\n\nconst estimateComputeUnitLimit = estimateComputeUnitLimitFactory({ rpc });\nconst estimateAndSetComputeUnitLimit =\n estimateAndSetComputeUnitLimitFactory(estimateComputeUnitLimit);\n\nconst transactionMessageWithLimit = await estimateAndSetComputeUnitLimit(transactionMessage);\n```\n\nThe estimator simulates the transaction with the maximum allowed limit so the simulation itself never runs out of budget; the returned value is the compute unit count actually consumed. `estimateAndSetComputeUnitLimitFactory` only updates the message if no explicit limit is already set or if the existing limit is the provisory `0` value, leaving messages with manually configured limits untouched.\n\nWhen constructing a message that you intend to estimate later, [`fillTransactionMessageProvisoryComputeUnitLimit`](/api/functions/fillTransactionMessageProvisoryComputeUnitLimit) reserves space for the limit by setting it to a provisory value of `0`.\n\n### Setting the priority fee [#configuring-priority-fees]\n\nPriority fees boost the chance that your transaction is included sooner. The exact knob depends on the transaction version: legacy and v0 transactions express priority fees as a price per compute unit, while v1 transactions express them as a single total amount in lamports.\n\n```ts twoslash\nimport { TransactionMessage } from '@solana/kit';\nconst v0TransactionMessage = null as unknown as TransactionMessage & { version: 0 };\nconst v1TransactionMessage = null as unknown as TransactionMessage & { version: 1 };\n// ---cut-before---\nimport {\n setTransactionMessageComputeUnitPrice,\n setTransactionMessagePriorityFeeLamports,\n} from '@solana/kit';\n\n// Legacy or v0: 10,000 micro-lamports per compute unit.\nconst v0WithPriorityFee = setTransactionMessageComputeUnitPrice(10_000n, v0TransactionMessage);\n\n// v1: 50,000 lamports total, regardless of compute unit usage.\nconst v1WithPriorityFee = setTransactionMessagePriorityFeeLamports(50_000n, v1TransactionMessage);\n```\n\nBoth setters accept `undefined` to clear the configuration. The matching readers [`getTransactionMessageComputeUnitPrice`](/api/functions/getTransactionMessageComputeUnitPrice) and [`getTransactionMessagePriorityFeeLamports`](/api/functions/getTransactionMessagePriorityFeeLamports) return the current value or `undefined` when none is set.\n\n\n Bundled clients such as `solanaRpc` and `litesvm` estimate the compute unit limit when sending\n transactions for you. Reach for the setters above when you build messages by hand or when you\n want to override what a client would do automatically.\n\n\n## Compressing transaction messages\n\nEvery transaction message must include a reference to the account addresses it will read from and write to. One alternative to storing these addresses in the message itself is to store them in an onchain account called an **address lookup table**. This lets you save space in the message by replacing many 32-byte account addresses with one or more 32-byte address lookup table account addresses then a 1-byte index into those tables for each address.\n\n\n Addresses that are required signers of a transaction message can not be looked up in an address\n lookup table; they must be encoded in the message in the conventional way.\n\n\nGiven a transaction message and a mapping of lookup tables to the ordered addresses stored in them, the [`compressTransactionMessageUsingAddressLookupTables`](/api/functions/compressTransactionMessageUsingAddressLookupTables) function will return a new transaction message with the same instructions but with all non-signer accounts that are found in the given lookup tables represented by an [`AccountLookupMeta`](/api/interfaces/AccountLookupMeta) instead of an [`AccountMeta`](/api/interfaces/AccountMeta).\n\n```ts twoslash\nimport {\n AddressesByLookupTableAddress,\n Rpc,\n GetAccountInfoApi,\n TransactionMessage,\n} from '@solana/kit';\nconst rpc = null as unknown as Rpc;\nconst transactionMessage = null as unknown as Extract;\n// ---cut-before---\nimport { address, compressTransactionMessageUsingAddressLookupTables } from '@solana/kit';\nimport { fetchAddressLookupTable } from '@solana-program/address-lookup-table';\n\nconst lookupTableAddress = address('4QwSwNriKPrz8DLW4ju5uxC2TN5cksJx6tPUPj7DGLAW');\nconst {\n data: { addresses },\n} = await fetchAddressLookupTable(rpc, lookupTableAddress);\nconst addressesByAddressLookupTable: AddressesByLookupTableAddress = {\n [lookupTableAddress]: addresses,\n};\n\nconst compressedTransactionMessage = compressTransactionMessageUsingAddressLookupTables(\n transactionMessage,\n addressesByAddressLookupTable,\n);\n```\n\nConsider how compressing transaction messages creates more space for instructions. This might enable you to prepare more complex transactions, or to execute the same number of instructions over fewer transactions thereby saving on network fees.\n\n\n This technique can not be applied to transaction messages having the version `'legacy'`.\n\n\n## Signing transaction messages\n\nIn order to be executed a transaction message must be signed by all of the private keys belonging to accounts that are required signers of the transaction, and must not exceed the size allowable by the network. You may encounter these types when using functions that send transactions.\n\n- [`FullySignedTransaction`](/api/type-aliases/FullySignedTransaction): A transaction that is signed by all of its required signers.\n- [`TransactionWithinSizeLimit`](/api/type-aliases/TransactionWithinSizeLimit): A transaction that is under or equal to the maximum size limit for transactions on the Solana network.\n- [`SendableTransaction`](/api/type-aliases/SendableTransaction): A union of `FullySignedTransaction` and `TransactionWithinSizeLimit`\n\nTransaction messages whose signers are specified using `TransactionSigner` objects have the ability to self-sign. This is because signers encapsulate both the address of the signing account as well as an implementation of the signing algorithm for the private key associated with that account.\n\nThe [`signTransactionMessageWithSigners`](/api/functions/signTransactionMessageWithSigners) method will return a new signed transaction of type `FullySignedTransaction`.\n\n```ts twoslash\nimport {\n TransactionMessage,\n TransactionMessageWithFeePayer,\n TransactionMessageWithSigners,\n} from '@solana/kit';\nconst transactionMessage = null as unknown as TransactionMessage &\n TransactionMessageWithFeePayer &\n TransactionMessageWithSigners;\n// ---cut-before---\nimport {\n SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING,\n isSolanaError,\n signTransactionMessageWithSigners,\n} from '@solana/kit';\n\ntry {\n const fullySignedTransaction = await signTransactionMessageWithSigners(transactionMessage);\n} catch (e) {\n if (isSolanaError(e, SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING)) {\n console.error('Missing signers for the following addresses:', e.context.addresses);\n } else {\n throw e;\n }\n}\n```\n\n\n This function will throw if the transaction message does not carry a `TransactionSigner`\n implementation for every required signer. To partially sign a message that you know to carry a\n strict subset of the required `TransactionSigners`, use the\n [`partiallySignTransactionMessageWithSigners`](/api/functions/partiallySignTransactionMessageWithSigners)\n method.\n\n\n\n If exactly one of the `TransactionSigners` in the message is a\n [`TransactionSendingSigner`](/api/type-aliases/TransactionSendingSigner) then you can use the\n [`signAndSendTransactionMessageWithSigners`](/api/functions/signAndSendTransactionMessageWithSigners)\n method to sign and send the transaction in a single step.\n\n\nFor a comprehensive guide on all signing functions — including the lower-level [`partiallySignTransactionWithSigners`](/api/functions/partiallySignTransactionWithSigners), [`signTransactionWithSigners`](/api/functions/signTransactionWithSigners), and [`signAndSendTransactionWithSigners`](/api/functions/signAndSendTransactionWithSigners) functions that accept an explicit array of signers and a compiled transaction — see the [Signing with signers](/docs/advanced-guides/signers#signing-with-signers) section.\n\nBuilding transaction messages using `TransactionSigners` is the recommended way to create self-signable transaction messages. To sign with a `CryptoKey` directly, you first have to compile the transaction message.\n\n```ts twoslash\nimport {\n TransactionMessage,\n TransactionMessageWithFeePayer,\n TransactionMessageWithSigners,\n} from '@solana/kit';\nconst transactionMessage = null as unknown as TransactionMessage &\n TransactionMessageWithFeePayer &\n TransactionMessageWithSigners;\n// ---cut-before---\nimport { compileTransaction } from '@solana/kit';\n\nconst transaction = compileTransaction(transactionMessage);\n```\n\nThis produces an unsigned transaction. Follow the [instructions for signing transactions with `CryptoKeyPairs`](#signing-transactions) to sign it.\n\n## Signing transactions\n\nWherever you have a `Transaction` instead of a `TransactionMessage` you can add or replace a signature using the [`signTransaction`](/api/functions/signTransaction) method and one or more `CryptoKeyPairs`.\n\n```ts twoslash\nimport { Transaction, TransactionWithLifetime } from '@solana/kit';\nconst keyPair = null as unknown as CryptoKeyPair;\nconst transaction = null as unknown as Transaction & TransactionWithLifetime;\n// ---cut-before---\nimport {\n SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING,\n isSolanaError,\n signTransaction,\n} from '@solana/kit';\n\ntry {\n const fullySignedTransaction = await signTransaction([keyPair], transaction);\n} catch (e) {\n if (isSolanaError(e, SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING)) {\n console.error('Missing signers for the following addresses:', e.context.addresses);\n } else {\n throw e;\n }\n}\n```\n\n\n This function will throw if the resultant transaction is missing a signature for one of the\n transaction's required signers. To partially sign a transaction, use the\n [`partiallySignTransaction`](/api/functions/partiallySignTransaction) method.\n\n\n\n If you have [`TransactionSigner`](/api/type-aliases/TransactionSigner) objects rather than raw\n `CryptoKeyPairs`, you can use\n [`signTransactionWithSigners`](/api/functions/signTransactionWithSigners) and\n [`partiallySignTransactionWithSigners`](/api/functions/partiallySignTransactionWithSigners)\n instead. See the [Signing with\n signers](/docs/advanced-guides/signers#signing-compiled-transactions) section for details.\n\n\n## Serializing transactions\n\nIf you would like to send a transaction to the network manually, you must first serialize it in a particular way. The [`Base64EncodedWireTransaction`](/api/type-aliases/Base64EncodedWireTransaction) represents the wire format of a transaction as a base64-encoded string.\n\nGiven a transaction, the [`getBase64EncodedWireTransaction`](/api/functions/getBase64EncodedWireTransaction) method returns the transaction as a string that conforms to the `Base64EncodedWireTransaction` type.\n\n```ts twoslash\nimport { Transaction, Rpc, SendTransactionApi } from '@solana/kit';\nconst rpc = null as unknown as Rpc;\nconst signedTransaction = null as unknown as Transaction;\n// ---cut-before---\nimport { getBase64EncodedWireTransaction, signTransaction } from '@solana/kit';\n\nconst serializedTransaction = getBase64EncodedWireTransaction(signedTransaction);\nconst signature = await rpc.sendTransaction(serializedTransaction, { encoding: 'base64' }).send();\n```\n\n\n Typically you would not serialize and send transactions to the network manually. See [Kit\n without a client](/docs/advanced-guides/kit-without-a-client) for the full no-client transaction\n flow.\n\n\n## Deserializing transactions\n\nYou can fetch the raw bytes of a transaction from the network using an RPC server.\n\n```ts twoslash\nimport { createSolanaRpc, getBase64Encoder, Signature } from '@solana/kit';\nconst rpc = createSolanaRpc('...');\n// ---cut-before---\nconst response = await rpc\n .getTransaction(\n '3atZVDiLEjXmddxLbH2AWHtFdXmHRocnA4vNyvkPRcd7WnzCtoVshFCvGtxfGYWs9C6ptucY6Jd84BerDnzQpJEH' as Signature,\n { encoding: 'base64' },\n )\n .send();\nif (!response) {\n throw new Error('Could not find transaction');\n}\nconst {\n transaction: [base64EncodedTransaction],\n} = response;\nconst transactionBytes = getBase64Encoder().encode(base64EncodedTransaction);\n```\n\nDecoding the wire transaction bytes yields a `Transaction` object. This takes the form of a transaction message encoded as a byte array, and a list of signatures of those bytes created by those who must authorize the message and pay for it to be executed on Solana.\n\n```ts twoslash\nimport { ReadonlyUint8Array } from '@solana/kit';\nconst transactionBytes = new Uint8Array() as ReadonlyUint8Array;\n// ---cut-before---\nimport { getTransactionDecoder } from '@solana/kit';\nconst transaction = getTransactionDecoder().decode(transactionBytes);\n```\n\nDecoding the network wire format bytes of the message will yield a transaction message in its **compiled** form – a message in a form suitable for execution on the network. Encountering a compiled message in your application is rare, but it's important to know that they exist.\n\n```ts twoslash\nimport { Transaction } from '@solana/kit';\nconst transaction = null as unknown as Transaction;\n// ---cut-before---\nimport { getCompiledTransactionMessageDecoder } from '@solana/kit';\nconst compiledTransactionMessage = getCompiledTransactionMessageDecoder().decode(\n transaction.messageBytes,\n);\n```\n\nFinally, decompiling a compiled message will yield a `TransactionMessage` object. This is the most common form of transaction message that you will encounter when using Kit to build an application.\n\n```ts twoslash\nimport { CompiledTransactionMessage, CompiledTransactionMessageWithLifetime } from '@solana/kit';\nconst compiledTransactionMessage = null as unknown as CompiledTransactionMessage &\n CompiledTransactionMessageWithLifetime;\n// ---cut-before---\nimport { decompileTransactionMessage } from '@solana/kit';\nconst transactionMessage = decompileTransactionMessage(compiledTransactionMessage);\n```\n\n\n You can not fully reconstruct a source message from a compiled message without extra\n information. In particular, supporting details about the lifetime constraint and the concrete\n addresses of accounts sourced from account lookup tables are lost to compilation, but can be\n supplied in the `config` argument of the `decompileTransactionMessage` or\n `decompileTransactionMessageFetchingLookupTables` methods.\n\n" }, { "path": "docs/content/docs/getting-started.mdx", "content": "---\ntitle: Getting started\ndescription: Build your first Solana app with Kit\n---\n\nIn this tutorial, we'll build a small Solana app with Kit. We'll create a devnet signer, fund it with devnet SOL, create a token mint, and read its data back — all with a plugin-composed Kit client.\n\n## Install dependencies\n\nFirst, let's install Kit and the plugins for connecting to Solana via RPC and loading a signer.\n\n```package-install\n@solana/kit @solana/kit-plugin-rpc @solana/kit-plugin-signer\n```\n\nThen install the program plugins for the Solana programs you want to interact with. For this tutorial, we'll use the Token program to create and read a token mint.\n\n```package-install\n@solana-program/token\n```\n\n## Create a devnet signer\n\nBefore we start, let's create a signer that we can reuse across this tutorial. This one-time setup script grinds a small vanity address, makes the keypair extractable, and writes it to a local file in the same JSON format used by Solana CLI keypairs.\n\n```ts twoslash title=\"create-signer.ts\"\nimport { grindKeyPairSigner, writeKeyPairSigner } from '@solana/kit';\n\nconst signer = await grindKeyPairSigner({\n extractable: true,\n matches: /^kit/i,\n});\n\nawait writeKeyPairSigner(signer, './kit-getting-started-keypair.json');\n\nconsole.log(`✨ Created devnet signer ${signer.address}`);\nconsole.log('🔐 Wrote ./kit-getting-started-keypair.json');\nconsole.log('✅ Add this file to .gitignore before committing your project.');\n```\n\nRun this script once, then remove it from your project. We'll keep the generated `kit-getting-started-keypair.json` file locally for the rest of this tutorial. Be sure to add it to `.gitignore` if you are planning on committing these changes.\n\n\n Already have a Solana CLI keypair? You can skip this script and use\n `signerFromFile('~/.config/solana/id.json')` instead. See [Setting Up\n Signers](/docs/guides/setting-up-signers) for more signer options.\n\n\n## Create a client\n\nNow let's create a client connected to devnet and load the signer from the file we just wrote.\n\n```ts twoslash\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signerFromFile } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\n\nconst client = await createClient()\n .use(signerFromFile('./kit-getting-started-keypair.json'))\n .use(solanaDevnetRpc())\n .use(tokenProgram());\n```\n\nHere's what each piece does:\n\n- `createClient()` creates an empty Kit client that can be extended with plugins.\n- `.use(signerFromFile(...))` loads our keypair file and sets it as both the client's payer (who pays fees) and identity (who owns assets).\n- `.use(solanaDevnetRpc())` connects to devnet and adds RPC, subscriptions, airdrops, minimum balance helpers, and transaction sending.\n- `.use(tokenProgram())` adds typed access to the Token program's instructions and accounts.\n\nBecause we just created a fresh devnet signer, it won't have any SOL yet. Let's fund it with a devnet airdrop before moving on. If you're reusing a signer that already has devnet SOL, you can skip this step.\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signerFromFile } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(signerFromFile('./kit-getting-started-keypair.json'))\n .use(solanaDevnetRpc())\n .use(tokenProgram());\n// ---cut-before---\nconst airdropSignature = await client.airdrop(client.payer.address, lamports(1_000_000_000n));\n\nconsole.log(`💸 Funded ${client.payer.address} with 1 SOL`);\nif (airdropSignature) {\n console.log(`🔎 https://explorer.solana.com/tx/${airdropSignature}?cluster=devnet`);\n}\n```\n\n\n Airdrops are only available on test networks like devnet and localhost. Run the airdrop once,\n then remove or comment out those lines before continuing so we do not hit devnet faucet rate\n limits. If the airdrop fails, wait a moment and try again, or request devnet SOL from the\n [Solana Faucet](https://faucet.solana.com).\n\n\n## Send a transaction\n\nLet's create a token mint onchain. In Solana, every transaction contains one or more instructions: small commands that tell programs what to do. Some tasks, like creating a mint, require multiple instructions that should stay together. Kit represents that kind of multi-step operation as an **instruction plan**.\n\nThe Token program plugin gives us one of these plans via `client.token.instructions.createMint(...)`. Under the hood, it creates a new account for the provided mint address with enough lamports to be rent-exempt (system program's `createAccount` instruction) and initializes it as a Token program mint (token program's `initializeMint` instruction). We pass the new mint as a signer (since we initialize a new account), choose `9` decimals, and set our client identity as the mint authority.\n\n```ts twoslash\nimport { createClient, generateKeyPairSigner } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signerFromFile } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(signerFromFile('./kit-getting-started-keypair.json'))\n .use(solanaDevnetRpc())\n .use(tokenProgram());\n// ---cut-before---\nconst mint = await generateKeyPairSigner();\n\nconst createMintPlan = client.token.instructions.createMint({\n newMint: mint,\n decimals: 9,\n mintAuthority: client.identity.address,\n});\n\nconst createMintResult = await client.sendTransaction([createMintPlan]);\nconst createMintSignature = createMintResult.context.signature;\n\nconsole.log(`🎉 Created token mint ${mint.address}`);\nconsole.log(`🔎 https://explorer.solana.com/tx/${createMintSignature}?cluster=devnet`);\n```\n\n`client.sendTransaction([...])` accepts an array of instructions and instruction plans and sends them as a single transaction. If one part fails, the whole transaction fails. This is the most common way to send transactions with a client, especially when we want to combine several instructions or plans.\n\nFor simple one-off operations, program instruction helpers also include a `.sendTransaction()` shortcut. The following sends the same `createMint` instruction plan as a single transaction without explicitly calling `client.sendTransaction([...])`.\n\n```ts twoslash\nimport { createClient, generateKeyPairSigner } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signerFromFile } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(signerFromFile('./kit-getting-started-keypair.json'))\n .use(solanaDevnetRpc())\n .use(tokenProgram());\nconst mint = await generateKeyPairSigner();\n// ---cut-before---\nconst createMintResult = await client.token.instructions\n .createMint({\n newMint: mint,\n decimals: 9,\n mintAuthority: client.identity.address,\n })\n .sendTransaction();\n```\n\nFor error handling, priority fees, and more advanced patterns, see the [Sending Transactions](/docs/guides/sending-transactions) guide.\n\n## Fetch an account\n\nNow let's read the mint account we just created.\n\nProgram plugins provide typed fetch helpers that decode account data automatically. The `mintAccount.data` object gives us the full `Mint` structure with fields like `decimals`, `mintAuthority`, `supply`, and `freezeAuthority`.\n\n```ts twoslash\nimport { createClient, generateKeyPairSigner } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signerFromFile } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(signerFromFile('./kit-getting-started-keypair.json'))\n .use(solanaDevnetRpc())\n .use(tokenProgram());\nconst mint = await generateKeyPairSigner();\n// ---cut-before---\nconst mintAccount = await client.token.accounts.mint.fetch(mint.address);\n\nconsole.log('✅ Mint account decoded');\nconsole.log(` Address: ${mint.address}`);\nconsole.log(` Decimals: ${mintAccount.data.decimals}`);\nconsole.log(' Mint authority:', mintAccount.data.mintAuthority);\nconsole.log(` Supply: ${mintAccount.data.supply}`);\n```\n\nFor raw account fetching and manual decoding, see the [Fetching Accounts](/docs/guides/fetching-accounts) guide.\n\n## Full example\n\nHere's the complete script you can copy and run after creating `kit-getting-started-keypair.json`.\n\n```ts twoslash\nimport { createClient, generateKeyPairSigner, lamports } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signerFromFile } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\n\nconst client = await createClient()\n .use(signerFromFile('./kit-getting-started-keypair.json'))\n .use(solanaDevnetRpc())\n .use(tokenProgram());\n\n// Run this once, then remove or comment it out to avoid devnet faucet rate limits.\nconst airdropSignature = await client.airdrop(client.payer.address, lamports(1_000_000_000n));\nconsole.log(`💸 Funded ${client.payer.address} with 1 SOL`);\nif (airdropSignature) {\n console.log(`🔎 https://explorer.solana.com/tx/${airdropSignature}?cluster=devnet`);\n}\n\nconst mint = await generateKeyPairSigner();\nconst createMintPlan = client.token.instructions.createMint({\n newMint: mint,\n decimals: 9,\n mintAuthority: client.identity.address,\n});\n\nconst createMintResult = await client.sendTransaction([createMintPlan]);\nconst createMintSignature = createMintResult.context.signature;\n\nconsole.log(`🎉 Created token mint ${mint.address}`);\nconsole.log(`🔎 https://explorer.solana.com/tx/${createMintSignature}?cluster=devnet`);\n\nconst mintAccount = await client.token.accounts.mint.fetch(mint.address);\n\nconsole.log('✅ Mint account decoded');\nconsole.log(` Address: ${mint.address}`);\nconsole.log(` Decimals: ${mintAccount.data.decimals}`);\nconsole.log(' Mint authority:', mintAccount.data.mintAuthority);\nconsole.log(` Supply: ${mintAccount.data.supply}`);\n```\n\n## Next steps\n\nWe've connected to devnet, funded a signer, created a token mint, and read its data. Here's where to go next:\n\n- [Setting Up Signers](/docs/guides/setting-up-signers) — load signers from keypair files, wallet standard, and more.\n- [Sending Transactions](/docs/guides/sending-transactions) — error handling, priority fees, and instruction plans.\n- [Fetching Accounts](/docs/guides/fetching-accounts) — program plugin fetch helpers, batch fetching, and decoding.\n- [Using Program Plugins](/docs/guides/using-program-plugins) — typed access to any Solana program.\n- [Plugins](/docs/plugins) — understand and extend the plugin system.\n" }, { "path": "docs/content/docs/guides/fetching-accounts.mdx", "content": "---\ntitle: Fetching accounts\ndescription: Read and decode onchain account data\n---\n\nReading data from Solana usually means fetching one or more accounts and decoding their data into something your application can use. This guide walks through the helpers Kit provides at each step, from the raw RPC call all the way to typed account objects.\n\n## Fetch raw account data\n\nThe `fetchEncodedAccount` helper wraps the `getAccountInfo` RPC method and returns a `MaybeEncodedAccount`. The result always has the same shape regardless of whether the account exists, which makes it easier to handle than the raw RPC response.\n\n```ts twoslash\nimport { address, fetchEncodedAccount } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\nconst wallet = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst account = await fetchEncodedAccount(client.rpc, wallet);\n```\n\nWhen the account exists, you get back its address, lamports, owner program, and a `data` field containing the raw bytes as a `Uint8Array`. When it does not, the same object is returned with `exists: false` and just the address.\n\n## Handle missing accounts\n\nA `MaybeEncodedAccount` is a discriminated union: TypeScript narrows the type once you check `account.exists`. You can branch on that flag, or use `assertAccountExists` when you would rather throw if the account is not present.\n\n```ts twoslash\nimport { address, assertAccountExists, fetchEncodedAccount } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\nconst wallet = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst account = await fetchEncodedAccount(client.rpc, wallet);\nassertAccountExists(account);\n\n// `account` is now `EncodedAccount`, with `data` typed as `Uint8Array`.\naccount.data satisfies Uint8Array;\n```\n\nAsserting up front lets the rest of your function rely on a fully populated account, which is convenient for scripts and tests. In application code, branching on `account.exists` is usually a better fit so you can show a sensible empty state. When working with several accounts at once, `assertAccountsExist(accounts)` performs the same check across an entire array in one call.\n\n## Fetch multiple accounts\n\nWhen you need several accounts at once, `fetchEncodedAccounts` batches them into a single `getMultipleAccounts` RPC request and returns a parallel array of `MaybeEncodedAccount` values.\n\n```ts twoslash\nimport { address, fetchEncodedAccounts } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\nconst accounts = await fetchEncodedAccounts(client.rpc, [\n address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ'),\n address('Ay1zdJ3VDbhrAtkRiqBUJgKLHYbgFZN5BXk7svtMowif'),\n]);\n```\n\nEach returned account already carries its own address, so you do not need to zip arrays together to figure out which result belongs to which input. The same `exists` flag works on every entry, and `assertAccountsExist(accounts)` is the multi-account counterpart of `assertAccountExists`.\n\n## Decode accounts manually\n\nOnce you have an encoded account, the `decodeAccount` helper turns it into a typed `Account` (or `MaybeAccount`) by running its `data` through any `Decoder`. The [Codecs guide](/docs/advanced-guides/codecs) covers how to build these decoders.\n\n```ts twoslash\nimport { address, decodeAccount, fetchEncodedAccount } from '@solana/kit';\nimport {\n addDecoderSizePrefix,\n Decoder,\n getStructDecoder,\n getU32Decoder,\n getU8Decoder,\n getUtf8Decoder,\n} from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\n\ntype Person = { name: string; age: number };\nconst personDecoder: Decoder = getStructDecoder([\n ['name', addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],\n ['age', getU8Decoder()],\n]);\n\nconst wallet = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst encodedAccount = await fetchEncodedAccount(client.rpc, wallet);\nconst decodedAccount = decodeAccount(encodedAccount, personDecoder);\n```\n\n`decodeAccount` preserves the `MaybeAccount` shape: a missing account stays missing, and a present account gets its `data` swapped from raw bytes to your decoded type. This means you can keep narrowing with `account.exists` exactly like before.\n\n## Decode using program helpers\n\nFor most popular Solana programs you will not need to write a decoder yourself. The `@solana-program/*` packages include generated helpers that handle decoding for every account they define, exposed as `decodeX`, `fetchX`, and `fetchMaybeX` functions where `X` is the account name.\n\n```ts twoslash\nimport { address } from '@solana/kit';\nimport { fetchMint } from '@solana-program/token';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\nconst mint = await fetchMint(client.rpc, address('So11111111111111111111111111111111111111112'));\nmint.data.decimals; // typed as `number`\n```\n\nEach program package follows the same naming convention: `fetchMint` and `fetchMaybeMint` for the `Mint` account, `fetchToken` and `fetchMaybeToken` for the `Token` account, and so on. The standalone `decodeMint` and `decodeToken` helpers work on encoded accounts you have already fetched. If you would rather access these through a typed `client.token.accounts.*` namespace, see the [Using program plugins](/docs/guides/using-program-plugins) guide.\n\n## Subscribe to account changes\n\nIf you need live updates rather than a one-off read, pair an account fetch with an account subscription. The subscription notifies you whenever the account's data changes onchain, and the same address is used in both calls.\n\n```ts twoslash\nimport { address } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\nconst wallet = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst accountNotifications = await client.rpcSubscriptions\n .accountNotifications(wallet, { commitment: 'confirmed' })\n .subscribe({ abortSignal: AbortSignal.timeout(60_000) });\n\nfor await (const notification of accountNotifications) {\n console.log('Account changed:', notification.value);\n}\n```\n\nSee the [RPC subscriptions](/docs/guides/rpc-subscriptions) guide for more on cancellation, error handling, and the async iterator model.\n\n## Choose the right fetch helper\n\nEach helper trades a different amount of structure and convenience. The table below summarizes when each one shines.\n\n| Helper | Returns | Best for |\n| ------------------------------------- | --------------------------------- | -------------------------------------- |\n| `client.rpc.getAccountInfo(...)` | raw RPC response | one-off reads with custom encoding |\n| `client.rpc.getMultipleAccounts(...)` | raw RPC response | bulk reads with custom encoding |\n| `fetchEncodedAccount(...)` | `MaybeEncodedAccount` | unified handling of single accounts |\n| `fetchEncodedAccounts(...)` | `MaybeEncodedAccount[]` | unified batch reads |\n| `decodeAccount(...)` | `Account` / `MaybeAccount` | turning raw bytes into typed data |\n| `fetchMint`, `fetchToken`, ... | `Account` / `MaybeAccount` | typed reads for known program accounts |\n| `accountNotifications(...)` | async iterator of account updates | live updates instead of one-off reads |\n\nIn practice you can pick any of them in isolation, or combine them to match the access pattern you need.\n\n## Next steps\n\n- [Codecs](/docs/advanced-guides/codecs) — learn how to build custom decoders.\n- [RPC requests](/docs/guides/rpc) — explore the rest of the RPC API.\n- [Using program plugins](/docs/guides/using-program-plugins) — read typed accounts through `client.token.accounts.mint.fetch(...)` and friends.\n" }, { "path": "docs/content/docs/guides/index.mdx", "content": "---\ntitle: Guides\ndescription: Practical guides for common tasks with Kit\n---\n\nThe pages in this section cover the most common tasks you will run into when building Solana applications with Kit. Each guide focuses on a single topic and can be read independently, so you can dip in when a specific question comes up rather than reading them in order.\n\n## How to use these guides\n\nIf you are completely new to Kit, start with the [Getting started](/docs/getting-started) tutorial. It walks through a small end-to-end project so the rest of the documentation has something concrete to reference.\n\nOnce you have shipped your first transaction, the guides below are designed to be your day-to-day companion. They focus on practical workflows — composing a client, sending transactions, fetching accounts, testing locally, and so on — and link to the [Advanced guides](/docs/advanced-guides) when you want to learn what is happening under the hood.\n" }, { "path": "docs/content/docs/guides/meta.json", "content": "{\n \"title\": \"Guides\",\n \"defaultOpen\": true,\n \"pages\": [\n \"setting-up-signers\",\n \"rpc\",\n \"rpc-subscriptions\",\n \"sending-transactions\",\n \"sending-multiple-transactions\",\n \"fetching-accounts\",\n \"using-program-plugins\",\n \"testing-and-local-development\"\n ]\n}\n" }, { "path": "docs/content/docs/guides/rpc-subscriptions.mdx", "content": "---\ntitle: RPC subscriptions\ndescription: Get notified of changes to the blockchain\n---\n\nRPC subscriptions let your application receive live updates from the network instead of polling for them. They are delivered over a WebSocket endpoint and surface as async iterators in Kit, which fit naturally into modern JavaScript control flow.\n\nKit aims to support every method documented in the [Solana RPC WebSocket methods](https://solana.com/docs/rpc/websocket) docs. As with HTTP RPC, you can either browse the methods in the official documentation or rely on TypeScript autocompletion in your editor.\n\n## Installation\n\nYou will typically install Kit alongside the RPC plugin package, which provides both HTTP and WebSocket connectivity.\n\n```package-install\n@solana/kit @solana/kit-plugin-rpc\n```\n\nIf you only need subscriptions and prefer not to use a Kit client, the lower-level `createSolanaRpcSubscriptions` function is available directly from `@solana/kit`.\n\n## Create a subscriptions client\n\nThe bundle plugins from `@solana/kit-plugin-rpc` install both `client.rpc` and `client.rpcSubscriptions` in one step. You do not need to manage two separate transports.\n\n```ts twoslash\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\n\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n```\n\nBy default, the WebSocket endpoint is derived from the HTTP endpoint by swapping `http`/`https` for `ws`/`wss`. If your provider hosts the two endpoints at different URLs, pass `rpcSubscriptionsUrl` explicitly in the plugin configuration.\n\n## Subscribe to slot notifications\n\nSubscriptions return an async iterator. The most idiomatic way to consume one is a `for await` loop, which keeps reading notifications until the underlying subscription ends.\n\n```ts twoslash\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\nconst slotNotifications = await client.rpcSubscriptions\n .slotNotifications()\n .subscribe({ abortSignal: AbortSignal.timeout(10_000) });\n\nfor await (const notification of slotNotifications) {\n console.log('The network advanced to slot', notification.slot);\n}\n```\n\nThe `.subscribe({ abortSignal })` step is mandatory because every subscription must be tied to an `AbortSignal`. This forces you to think up front about when the subscription should end and prevents leaks.\n\n## Cancel subscriptions\n\nYou may want to cancel a subscription before it ends naturally — for example, when a component unmounts in a UI. Pass an `AbortController` so that calling `.abort()` from anywhere in your code stops the iterator gracefully.\n\n```ts twoslash\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\nconst abortController = new AbortController();\nconst slotNotifications = await client.rpcSubscriptions\n .slotNotifications()\n .subscribe({ abortSignal: abortController.signal });\n\n// Stop receiving notifications after the user navigates away.\nabortController.abort();\n```\n\n`AbortSignal.timeout(ms)` is a convenient shortcut when you simply want a fixed duration. For one-off subscriptions, that single line is often all you need.\n\n## Subscribe to account changes\n\nAccount subscriptions notify you whenever an account's data changes onchain. The shape of the notification mirrors the response of `getAccountInfo`, so the same encoding and commitment options apply.\n\n```ts twoslash\nimport { address } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\nconst wallet = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst accountNotifications = await client.rpcSubscriptions\n .accountNotifications(wallet, { commitment: 'confirmed' })\n .subscribe({ abortSignal: AbortSignal.timeout(60_000) });\n\nfor await (const notification of accountNotifications) {\n console.log('Account changed:', notification.value);\n}\n```\n\nIf you only need a one-off read of an account, [`fetchEncodedAccount`](/docs/guides/fetching-accounts) is usually a better fit. Use subscriptions for live, ongoing updates.\n\n## Handle disconnects and errors\n\nLong-lived subscriptions can disconnect for many reasons — flaky networks, server restarts, or connection limits — and errors can be raised at any point during iteration. Wrap the iteration in a `try`/`catch` so your application can react gracefully.\n\n```ts twoslash\nimport { address } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\nconst wallet = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst accountNotifications = await client.rpcSubscriptions\n .accountNotifications(wallet, { commitment: 'confirmed' })\n .subscribe({ abortSignal: AbortSignal.timeout(60_000) });\n\ntry {\n for await (const notification of accountNotifications) {\n console.log('Account changed:', notification.value);\n }\n} catch (error) {\n // Reconnect, log, surface a UI error, etc.\n}\n```\n\nDepending on your application, you may want to recreate the subscription with a fresh `AbortSignal` after a disconnect, possibly using a small backoff to avoid thrashing the server.\n\n## Use subscriptions without a client\n\nIf you do not need a Kit client, you can build an `RpcSubscriptions` object directly with `createSolanaRpcSubscriptions`. This is the lower-level building block the plugins use under the hood.\n\n```ts twoslash\nimport { createSolanaRpcSubscriptions, mainnet } from '@solana/kit';\n\nconst rpcSubscriptions = createSolanaRpcSubscriptions(mainnet('wss://api.mainnet-beta.solana.com'));\nconst slotNotifications = await rpcSubscriptions\n .slotNotifications()\n .subscribe({ abortSignal: AbortSignal.timeout(10_000) });\n```\n\nThis is useful when you want maximum tree-shaking, when you are writing a library that should not assume a client, or when you only need a tiny subset of the subscriptions API.\n\n## Choose a WebSocket endpoint\n\nFor light development or personal use, the public WebSocket endpoints maintained by the Solana Foundation work the same way as their HTTP counterparts.\n\n- `wss://api.mainnet-beta.solana.com`\n- `wss://api.testnet.solana.com`\n- `wss://api.devnet.solana.com`\n\nIn production, your HTTP and WebSocket endpoints should match — both clusters and providers — to avoid subtle mismatches between the data each transport returns. Most RPC providers offer paired endpoints; consult their documentation for the exact URLs they expect you to use.\n\n## Next steps\n\n- [RPC requests](/docs/guides/rpc) — read state and submit one-off requests over HTTP.\n- [Fetching accounts](/docs/guides/fetching-accounts) — pair subscriptions with a baseline read.\n- [Sending transactions](/docs/guides/sending-transactions) — submit work to the network.\n" }, { "path": "docs/content/docs/guides/rpc.mdx", "content": "---\ntitle: RPC requests\ndescription: Read and write data to the blockchain\n---\n\nSolana applications interact with the network through a JSON-RPC server. RPC requests are how your code reads onchain state, simulates transactions, and submits transactions to be processed. Kit ships a fully typed RPC client and exposes it on Kit clients via plugins, so the same RPC API is available whether you compose a client or use the lower-level building blocks directly.\n\nKit aims to support every method documented in the [Solana RPC HTTP methods](https://solana.com/docs/rpc/http) docs. You can either browse the methods in the official documentation or rely on TypeScript autocompletion in your editor.\n\n## Installation\n\nYou will typically install Kit alongside the RPC plugin package.\n\n```package-install\n@solana/kit @solana/kit-plugin-rpc\n```\n\nThe `@solana/kit-plugin-rpc` package contains the plugins that install RPC connectivity on a client. The `@solana/kit` package contains the lower-level RPC primitives those plugins are built on top of, so you can also use it standalone if you prefer not to use a client.\n\n## Create an RPC client\n\nThe most convenient way to make RPC requests is to compose a Kit client with one of the bundle plugins, which install both `client.rpc` and `client.rpcSubscriptions` in one call.\n\n```ts twoslash\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\n\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n```\n\nThe bundle plugins also wire up minimum balance computation, transaction planning, and transaction sending, which you will use in the other guides. If you only need to make read-only RPC requests, you can drop the signer plugin and use `solanaRpcConnection(...)` instead, which only installs `client.rpc` and `client.rpcSubscriptions`.\n\n## Send your first RPC request\n\nOnce you have an RPC client, you build a request by calling the corresponding method on `client.rpc` and finalize it with `.send()`. Most RPC responses come back wrapped in a `{ context, value }` object, so destructuring `value` is a common pattern.\n\n```ts twoslash\nimport { address } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\n\nconst wallet = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst { value: balance } = await client.rpc.getBalance(wallet).send();\n```\n\nAlthough `client.rpc` looks like a regular object, it is actually a [`Proxy`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) that constructs RPC requests on demand. TypeScript provides type safety for every method based on the API installed by your plugin, which makes the available methods discoverable from your editor while keeping the bundle small.\n\n## Use cluster-specific RPC bundles\n\nThe `@solana/kit-plugin-rpc` package ships several bundle plugins, each tailored to a specific use case. The cluster-typed variants type the RPC API to match what is available on that cluster, which prevents accidents like calling `airdrop` against mainnet at compile time.\n\n| Plugin | Default endpoint | Adds to the client |\n| ----------------------- | ------------------------------- | ----------------------------------------------------------- |\n| `solanaRpc(config)` | provided via `rpcUrl` | RPC, subscriptions, planning, sending |\n| `solanaMainnetRpc(...)` | provided via `rpcUrl` | mainnet-typed RPC, subscriptions, planning, sending |\n| `solanaDevnetRpc(...)` | `https://api.devnet.solana.com` | devnet-typed RPC, subscriptions, planning, sending, airdrop |\n| `solanaLocalRpc(...)` | `http://127.0.0.1:8899` | localnet RPC, subscriptions, planning, sending, airdrop |\n\nIf you need to talk to a custom RPC provider, pass its URL through `solanaRpc({ rpcUrl: '...' })` or `solanaMainnetRpc({ rpcUrl: '...' })`. The other settings on `SolanaRpcConfig` cover advanced options such as transport configuration and transaction planner overrides.\n\n## Pass request options\n\nMost RPC methods accept a configuration object as their final argument. This is where you control things like the requested commitment level, encoding, or pagination, depending on the method.\n\n```ts twoslash\nimport { address } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n// ---cut-end---\n\nconst wallet = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst { value: balance } = await client.rpc.getBalance(wallet, { commitment: 'confirmed' }).send();\n```\n\nThe `.send(...)` call itself accepts an optional `abortSignal` that lets you cancel the request in flight.\n\n## Use RPC without a client\n\nIf you do not need a Kit client, you can build an `Rpc` object directly with `createSolanaRpc`. This is useful when you want maximum tree-shaking, when you are writing a library that should not assume a client, or when you simply want to keep your dependency surface small.\n\n```ts twoslash\nimport { address, createSolanaRpc } from '@solana/kit';\n\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\nconst wallet = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst { value: balance } = await rpc.getBalance(wallet).send();\n```\n\nThe standalone `Rpc` object exposes the exact same API as `client.rpc`, so any code that takes an `Rpc` will work in either setup. See the [Kit without a client](/docs/advanced-guides/kit-without-a-client) guide for more on this approach.\n\n## Choose an RPC endpoint\n\nFor light development or personal use, the public RPC endpoints maintained by the Solana Foundation are a fine starting point.\n\n- `https://api.mainnet-beta.solana.com`\n- `https://api.testnet.solana.com`\n- `https://api.devnet.solana.com`\n\nThese endpoints are heavily rate-limited and should not be used for anything close to production traffic. When you ship to production, lease an RPC node from a provider or [run your own](https://docs.anza.xyz/operations/setup-an-rpc-node). Some RPC providers also expose extra methods on top of the standard JSON-RPC API; many of them ship a Kit-compatible SDK that you can layer on top of `createSolanaRpc(...)` to merge their additional methods into the typed RPC object.\n\n## Next steps\n\n- [RPC subscriptions](/docs/guides/rpc-subscriptions) — receive live updates from a WebSocket endpoint.\n- [Fetching accounts](/docs/guides/fetching-accounts) — go from raw account bytes to typed data.\n- [Sending transactions](/docs/guides/sending-transactions) — submit transactions through your client.\n" }, { "path": "docs/content/docs/guides/sending-multiple-transactions.mdx", "content": "---\ntitle: Sending multiple transactions\ndescription: Plan and execute work across several transactions\n---\n\nWhen an operation cannot fit in a single transaction — too many instructions, too much data, or work that should run in parallel — you need to split it across several transactions. Kit clients support this through the same `client.sendTransactions(...)` and `client.planTransactions(...)` methods you used in [Sending transactions](/docs/guides/sending-transactions), but plural.\n\n## Prerequisites\n\nThis guide assumes a transaction-ready client, like the one set up in [Sending transactions](/docs/guides/sending-transactions). The same bundle plugins from `@solana/kit-plugin-rpc` and `@solana/kit-plugin-litesvm` install everything `client.sendTransactions(...)` needs out of the box.\n\n## Instruction plans\n\nAn instruction plan describes an operation made of several instructions together with constraints on how they can run — some steps must happen sequentially, others may run in parallel, and some must stay atomic. Kit represents this as a tree, so simple operations stay simple while more complex flows can nest sequential and parallel branches inside each other. The plan is then handed to a [transaction planner](/docs/advanced-guides/instruction-plans) that decides how to pack it into transaction messages, and then to a [transaction plan executor](/docs/advanced-guides/instruction-plans) that sends those transactions.\n\nKit's planners can divide work, batch it into transactions, and even pack variable-sized data into the available space. For most cases you only need to know about three building blocks: `singleInstructionPlan`, `sequentialInstructionPlan`, and `parallelInstructionPlan`. The [Instruction plans](/docs/advanced-guides/instruction-plans) advanced guide goes much deeper.\n\n## Run work sequentially\n\nUse `sequentialInstructionPlan(...)` when each step depends on the previous one — for example, creating an account before initializing it.\n\n```ts twoslash\nimport { Instruction, sequentialInstructionPlan } from '@solana/kit';\nconst createAccount = {} as Instruction;\nconst initializeAccount = {} as Instruction;\n// ---cut-before---\nconst instructionPlan = sequentialInstructionPlan([createAccount, initializeAccount]);\n```\n\nSequential plans accept either raw instructions or other instruction plans, so you can compose larger flows from smaller ones. A `nonDivisibleSequentialInstructionPlan(...)` variant also exists for steps that must run atomically inside a single transaction (or transaction bundle when not possible).\n\n## Run work in parallel\n\nUse `parallelInstructionPlan(...)` when independent steps can run in any order. The planner is then free to pack them into separate transactions and send them concurrently.\n\n```ts twoslash\nimport { Instruction, parallelInstructionPlan } from '@solana/kit';\nconst transferToBob = {} as Instruction;\nconst transferToCarla = {} as Instruction;\n// ---cut-before---\nconst instructionPlan = parallelInstructionPlan([transferToBob, transferToCarla]);\n```\n\nThe two helpers compose freely: a sequential plan can contain parallel children and vice versa. This is how you describe operations like \"set up these two accounts in parallel, then run the operation that depends on both of them\".\n\n## Plan multiple transactions\n\nWhen you only want to inspect or persist the planned transactions, `client.planTransactions(plan)` runs the planner without executing anything and returns the resulting `TransactionPlan` tree.\n\n```ts twoslash\nimport { lamports, parallelInstructionPlan } from '@solana/kit';\nimport { getTransferSolInstruction } from '@solana-program/system';\n// ---cut-start---\nimport { address } from '@solana/kit';\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(10_000_000_000n)));\nconst bob = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst carla = address('Ay1zdJ3VDbhrAtkRiqBUJgKLHYbgFZN5BXk7svtMowif');\n// ---cut-end---\nconst instructionPlan = parallelInstructionPlan([\n getTransferSolInstruction({\n source: client.payer,\n destination: bob,\n amount: lamports(500_000n),\n }),\n getTransferSolInstruction({\n source: client.payer,\n destination: carla,\n amount: lamports(500_000n),\n }),\n]);\n\nconst transactionPlan = await client.planTransactions(instructionPlan);\n```\n\nThe returned `TransactionPlan` keeps the same sequential and parallel structure as the original instruction plan, but its leaves are the concrete transaction messages the planner chose to pack the work into. This is useful for dry runs, debugging, or feeding a custom executor.\n\n## Send multiple transactions\n\nTo plan and send in one call, use `client.sendTransactions(plan)`. The result is a `TransactionPlanResult` tree that mirrors the original plan, with one leaf per transaction.\n\n```ts twoslash\nimport { lamports, parallelInstructionPlan } from '@solana/kit';\nimport { getTransferSolInstruction } from '@solana-program/system';\n// ---cut-start---\nimport { address } from '@solana/kit';\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(10_000_000_000n)));\nconst bob = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\nconst carla = address('Ay1zdJ3VDbhrAtkRiqBUJgKLHYbgFZN5BXk7svtMowif');\n// ---cut-end---\nconst instructionPlan = parallelInstructionPlan([\n getTransferSolInstruction({\n source: client.payer,\n destination: bob,\n amount: lamports(500_000n),\n }),\n getTransferSolInstruction({\n source: client.payer,\n destination: carla,\n amount: lamports(500_000n),\n }),\n]);\n\nconst result = await client.sendTransactions(instructionPlan);\n```\n\n`client.sendTransactions(...)` is the multi-transaction counterpart of `client.sendTransaction(...)`. The single-transaction version asserts that the plan resolves to exactly one transaction and unwraps its result — a convenience for the common case. The plural version preserves the full tree, which you can walk to see what happened.\n\n## Understand transaction plan results\n\nEvery leaf in the result tree is a `SingleTransactionPlanResult` with one of three statuses:\n\n- `successful` — the transaction was sent and confirmed; `context.signature` is always present.\n- `failed` — the transaction was attempted but failed during preflight, simulation, or execution. `error` carries the underlying error.\n- `canceled` — the transaction was never attempted, typically because a prior transaction in a sequential branch failed first.\n\n```ts twoslash\nimport { TransactionPlanResult } from '@solana/kit';\nconst result = {} as TransactionPlanResult;\n// ---cut-before---\nif (result.kind === 'single') {\n if (result.status === 'successful') {\n console.log('Signature:', result.context.signature);\n } else if (result.status === 'failed') {\n console.error('Failed:', result.error);\n } else {\n console.warn('Canceled before being sent');\n }\n}\n```\n\nBranch nodes use `kind: 'parallel'` or `kind: 'sequential'`, with their child results in `plans`. You usually do not need to walk the tree by hand — the helpers in the next sections cover the common cases.\n\n## Summarize results\n\n`summarizeTransactionPlanResult(...)` flattens the tree and bucketizes the results so you can quickly check whether everything succeeded.\n\n```ts twoslash\nimport { summarizeTransactionPlanResult, TransactionPlanResult } from '@solana/kit';\nconst result = {} as TransactionPlanResult;\n// ---cut-before---\nconst summary = summarizeTransactionPlanResult(result);\n\nif (summary.successful) {\n console.log(`✅ ${summary.successfulTransactions.length} transactions confirmed`);\n} else {\n console.warn(\n `${summary.successfulTransactions.length} ok, ` +\n `${summary.failedTransactions.length} failed, ` +\n `${summary.canceledTransactions.length} canceled`,\n );\n}\n```\n\nThis is usually the first thing to reach for after `client.sendTransactions(...)` — it gives you a quick health check without writing any tree-walking code.\n\n## Continue after failures\n\nBy default, `client.sendTransactions(...)` throws as soon as any transaction in the plan fails. That behaviour is convenient for small operations, but counterproductive when you are running a large batch and want to inspect partial results. The `passthroughFailedTransactionPlanExecution(...)` helper turns that thrown error back into a `TransactionPlanResult`.\n\n```ts twoslash\nimport { InstructionPlan, passthroughFailedTransactionPlanExecution } from '@solana/kit';\nconst instructionPlan = {} as InstructionPlan;\n// ---cut-start---\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(10_000_000_000n)));\n// ---cut-end---\nconst result = await passthroughFailedTransactionPlanExecution(\n client.sendTransactions(instructionPlan),\n);\n```\n\nAfter this call, `result` is the same tree you would have received on full success — but with `failed` and `canceled` leaves where the issues occurred. You can then summarize it, walk it, or react however you need.\n\n## Handle partial success\n\nWhen you want to react to each transaction individually, `flattenTransactionPlanResult(...)` collapses the tree into an array of leaf results in the order they appear.\n\n```ts twoslash\nimport { flattenTransactionPlanResult, TransactionPlanResult } from '@solana/kit';\nconst result = {} as TransactionPlanResult;\n// ---cut-before---\nfor (const single of flattenTransactionPlanResult(result)) {\n if (single.status === 'successful') {\n console.log('✅', single.context.signature);\n } else if (single.status === 'failed') {\n console.error('❌', single.error.message);\n } else {\n console.warn('⏭️', 'canceled');\n }\n}\n```\n\nCombined with `passthroughFailedTransactionPlanExecution(...)`, this is enough to drive a UI that shows per-transaction status, retry buttons, or detailed error messages for a long-running multi-transaction operation.\n\n## Next steps\n\n- [Sending transactions](/docs/guides/sending-transactions) — single-transaction basics.\n- [Advanced guides — Instruction plans](/docs/advanced-guides/instruction-plans) — the full instruction plan API.\n- [Advanced guides — Errors](/docs/advanced-guides/errors) — recover from `SolanaError` failures.\n" }, { "path": "docs/content/docs/guides/sending-transactions.mdx", "content": "---\ntitle: Sending transactions\ndescription: Send single transactions with a Kit client\n---\n\nA Kit client can take a list of instructions and turn it into a fully signed, sent, and confirmed transaction in a single call. This guide covers the basics of sending one transaction at a time. When an operation needs to span multiple transactions, see [Sending multiple transactions](/docs/guides/sending-multiple-transactions).\n\n## Create a transaction-ready client\n\nSending transactions requires a client that exposes a `sendTransaction` method. At the lowest level, this means installing the [`planAndSendTransactions`](/docs/plugins/available-plugins) plugin from `@solana/kit-plugin-instruction-plan` on top of a custom `transactionPlanner` and `transactionPlanExecutor`. In practice, you almost always pick a higher-level bundle that does this for you.\n\n```ts twoslash\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\n\nconst client = await createClient().use(generatedSigner()).use(solanaLocalRpc());\n```\n\nThe bundle plugins from `@solana/kit-plugin-rpc` (`solanaRpc`, `solanaMainnetRpc`, `solanaDevnetRpc`, `solanaLocalRpc`) and the `litesvm` plugin from `@solana/kit-plugin-litesvm` all install a working planner and executor out of the box. Community plugins that target other backends should follow the same pattern, so the rest of this guide works the same way regardless of where transactions are actually sent.\n\nThe signer plugin must be installed before the bundle, because the bundle's transaction planner needs a `payer` on the client to plan transactions. See [Setting up signers](/docs/guides/setting-up-signers) for the full set of signer options.\n\n## Send instructions\n\nOnce your client is ready, `client.sendTransaction([...])` accepts an array of instructions and turns them into a single transaction. The client takes care of fetching a recent blockhash, estimating compute units when applicable, setting the fee payer, signing with all attached signers, sending the transaction, and waiting for confirmation.\n\n```ts twoslash\nimport { address, lamports } from '@solana/kit';\nimport { getTransferSolInstruction } from '@solana-program/system';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)));\n// ---cut-end---\nconst recipient = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\n\nconst result = await client.sendTransaction([\n getTransferSolInstruction({\n source: client.payer,\n destination: recipient,\n amount: lamports(500_000n),\n }),\n getTransferSolInstruction({\n source: client.payer,\n destination: recipient,\n amount: lamports(500_000n),\n }),\n]);\n```\n\nA single `client.sendTransaction([...])` call always produces exactly one transaction onchain, which means every instruction succeeds together or fails together. If you have so many instructions that they cannot fit in one transaction, use [`client.sendTransactions(...)`](/docs/guides/sending-multiple-transactions) instead.\n\n## Plan before sending\n\nSometimes you do not want to send the transaction immediately. You may want to inspect the planned message before signing, log it for debugging, or take over the rest of the lifecycle yourself. The `client.planTransaction([...])` method returns the planned transaction message and stops there, leaving signing and sending to you.\n\n```ts twoslash\nimport { address, lamports } from '@solana/kit';\nimport { getTransferSolInstruction } from '@solana-program/system';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)));\n// ---cut-end---\nconst recipient = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\n\nconst transactionMessage = await client.planTransaction([\n getTransferSolInstruction({\n source: client.payer,\n destination: recipient,\n amount: lamports(500_000n),\n }),\n]);\n```\n\nThis gives you full control over what happens next: you can sign the message with [`signTransactionMessageWithSigners`](/docs/advanced-guides/signers), encode it for transmission to another service, or pass it to a custom executor. Note that the executor used by `client.sendTransaction([...])` may further mutate the planned message before sending — for example by attaching a fresh blockhash or refreshing the compute unit limit — so the message you inspect here is not guaranteed to be byte-identical to what would land onchain. The [Kit without a client](/docs/advanced-guides/kit-without-a-client) guide goes deeper into building and sending transactions step by step.\n\n## Handle transaction errors\n\nWhen a transaction fails, `client.sendTransaction(...)` throws a [`SolanaError`](/docs/advanced-guides/errors) with the `SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION` code. The error message identifies whether the failure happened in preflight or onchain, and the `cause` carries the underlying error you can branch on.\n\n```ts twoslash\nimport {\n address,\n isSolanaError,\n lamports,\n SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION,\n} from '@solana/kit';\nimport { getTransferSolInstruction } from '@solana-program/system';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)));\nconst recipient = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\n// ---cut-end---\ntry {\n await client.sendTransaction([\n getTransferSolInstruction({\n source: client.payer,\n destination: recipient,\n amount: lamports(500_000n),\n }),\n ]);\n} catch (error) {\n if (isSolanaError(error, SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION)) {\n console.error(error.message);\n console.error('Logs:', error.context.logs);\n } else {\n throw error;\n }\n}\n```\n\nThe same `error.context` object also exposes the underlying `transactionPlanResult`, which is particularly useful when you want to inspect the failed transaction message or its signature. Program-specific errors (such as System program or SPL Token program errors) live deeper inside `error.cause`. The [Errors](/docs/advanced-guides/errors) guide covers how to identify and handle them.\n\n## Inspect transaction signatures\n\nA successful `client.sendTransaction(...)` resolves with a result object whose `context` carries the transaction `signature` and the original transaction message. You can use the signature to log a link to a block explorer or store it for later reference.\n\n```ts twoslash\nimport { address, lamports } from '@solana/kit';\nimport { getTransferSolInstruction } from '@solana-program/system';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)));\nconst recipient = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\n// ---cut-end---\nconst result = await client.sendTransaction([\n getTransferSolInstruction({\n source: client.payer,\n destination: recipient,\n amount: lamports(500_000n),\n }),\n]);\n\nconsole.log(`✅ ${result.context.signature}`);\n```\n\nTransaction signatures are deterministic, so the signature is known as soon as the fee payer signs the transaction — you do not need to wait for confirmation to learn what it will be. If you build and sign your own transactions, the [`getSignatureFromTransaction`](/docs/advanced-guides/transactions) helper exposes the same value.\n\n## Next steps\n\n- [Sending multiple transactions](/docs/guides/sending-multiple-transactions) — plan and execute work that does not fit in a single transaction.\n- [Using program plugins](/docs/guides/using-program-plugins) — discover the `.sendTransaction()` shortcut on typed program helpers.\n- [Advanced guides — Transactions](/docs/advanced-guides/transactions) — learn the full transaction lifecycle.\n- [Advanced guides — Errors](/docs/advanced-guides/errors) — handle failures with `SolanaError`.\n" }, { "path": "docs/content/docs/guides/setting-up-signers.mdx", "content": "---\ntitle: Setting up signers\ndescription: Authorize transactions, pay fees, and own onchain assets\n---\n\nMost Kit applications need at least one signer. Signers represent the accounts that authorize transactions, pay fees, and own onchain assets such as tokens or program authorities. This guide covers the different ways you can attach signers to a Kit client and the situations each one is best suited for.\n\n## Installation\n\nYou will need Kit and the signer plugin package.\n\n```package-install\n@solana/kit @solana/kit-plugin-signer\n```\n\nSome examples below also use `@solana/kit-plugin-rpc` or `@solana/kit-plugin-litesvm` to fund signers in local environments.\n\n## What is a signer?\n\nA signer is an object that carries an `Address` and knows how to produce a signature for that address. Where the underlying private key actually lives — in memory, in a keypair file, in a browser wallet, on a hardware device, or behind a remote signing service — is an implementation detail. As long as the signer implements one of Kit's signer interfaces, it can be plugged into the same APIs.\n\nThis means you can swap a generated keypair for a wallet-backed signer without changing the rest of your code. The [Advanced guides — Signers](/docs/advanced-guides/signers) page goes into the different signer interfaces and when each one applies.\n\n## Payer and identity\n\nKit clients hold two distinct signer roles:\n\n- **`payer`** — the signer that pays transaction fees and storage costs (the rent reserved when creating new accounts).\n- **`identity`** — the signer that represents the wallet your application acts on behalf of, typically the authority over accounts, tokens, or other onchain assets.\n\nIn most apps these roles are filled by the same signer, but they can be separated when you want a sponsored fee payer, a custodial backend, or any setup where authority and fee payment do not belong to the same key.\n\n## Install signers on your client\n\nThe most common way to install a signer is to use the `signer(...)` plugin, which sets the same signer as both the `payer` and the `identity` of the client.\n\n```ts twoslash\nimport { createClient, generateKeyPairSigner } from '@solana/kit';\nimport { signer } from '@solana/kit-plugin-signer';\n\nconst mySigner = await generateKeyPairSigner();\nconst client = createClient().use(signer(mySigner));\n```\n\nThe `signer(...)` plugin accepts any object that implements the `TransactionSigner` interface, so a signer obtained from somewhere else in your code — a library, a hook, a custom factory — can be passed in directly without any wrapping.\n\nIf your application needs a sponsored fee payer or otherwise wants to set the two roles independently, you may use the `payer(...)` and `identity(...)` plugins instead. They have the exact same shape as `signer(...)` but install only one role each.\n\n```ts twoslash\nimport { createClient, generateKeyPairSigner } from '@solana/kit';\nimport { identity, payer } from '@solana/kit-plugin-signer';\n\nconst feePayer = await generateKeyPairSigner();\nconst owner = await generateKeyPairSigner();\n\nconst client = createClient().use(payer(feePayer)).use(identity(owner));\n```\n\n## Load a signer from a file\n\nMost Solana CLI keypairs are stored as a JSON byte array on disk. The `signerFromFile(...)` plugin reads such a file and installs the resulting signer on both the `payer` and `identity` roles.\n\n```ts twoslash\nimport { createClient } from '@solana/kit';\nimport { signerFromFile } from '@solana/kit-plugin-signer';\n\nconst client = await createClient().use(signerFromFile('~/.config/solana/id.json'));\n```\n\nThis is convenient for command-line tools, scripts, and backend services that already use a Solana CLI keypair. As with the in-memory plugins above, `payerFromFile(path)` and `identityFromFile(path)` are available if you only want to install a single role.\n\n\n The file-based signer plugins read from the local filesystem and therefore only work in Node.js\n environments. They throw an error in browsers and React Native. Make sure your keypair files are\n excluded from version control and from any production build artifact.\n\n\n## Use a browser wallet signer\n\nA dedicated wallet signer plugin is on its way and will be documented here once it lands. It will use the [Wallet Standard](https://github.com/wallet-standard/wallet-standard) under the hood and expose a framework-agnostic reactive layer, so it can be used from any UI framework — not just React.\n\nUntil then, the [`@solana/react`](/api) hooks can produce a `TransactionSigner` from a connected wallet account, and you can install that signer on a Kit client with the `signer(...)`, `payer(...)`, or `identity(...)` plugins shown above.\n\n## Generate signers for tests\n\nWhen writing tests, generating a fresh signer per run keeps each scenario isolated and avoids leaking state between tests. The `generatedSigner()` plugin creates a brand new keypair signer and installs it on both roles.\n\n```ts twoslash\nimport { createClient } from '@solana/kit';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\n\nconst client = await createClient().use(generatedSigner());\n```\n\n`generatedPayer()` and `generatedIdentity()` follow the same pattern when you only want to generate one of the two roles. Generated signers are great for tests but should not be used as long-lived production identities, since the keypair only exists for the lifetime of the client.\n\n## Fund signers in local environments\n\nGenerated signers start with no SOL, so they can not pay fees or rent until they have been funded. The typical local pattern is to install a generated signer first, then install a local environment that ships an `airdrop` capability — either `solanaLocalRpc()` or `litesvm()` — and finally airdrop SOL to the signer with the `airdropSigner(...)` plugin.\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)));\n```\n\nThe order matters: the signer must exist before the RPC bundle is added (so the bundle can wire the signer into transaction planning), and the airdrop function must be available before `airdropSigner(...)` runs (which `solanaLocalRpc()` and `litesvm()` both provide). `airdropPayer(...)` and `airdropIdentity(...)` are available if you split roles between two different signers.\n\n\n Airdrops only work on test clusters such as devnet, testnet, and local validators. Mainnet does\n not have a faucet, and `solanaMainnetRpc(...)` will refuse to type-check an `airdrop` call.\n\n\n## Next steps\n\n- [Sending transactions](/docs/guides/sending-transactions) — use your client to send and confirm transactions.\n- [Testing and local development](/docs/guides/testing-and-local-development) — set up local validators or LiteSVM for testing.\n- [Advanced guides — Signers](/docs/advanced-guides/signers) — learn the signer interfaces in depth.\n" }, { "path": "docs/content/docs/guides/testing-and-local-development.mdx", "content": "---\ntitle: Testing & local development\ndescription: Test your Solana applications locally\n---\n\nLocal development and testing benefit hugely from Kit's plugin system: the same application code can run against devnet, a local validator, or an in-process [LiteSVM](https://github.com/litesvm/litesvm) instance, depending on which bundle plugin you install. This guide walks through the three options and the small patterns that make tests easy to write and maintain.\n\n## Choose a local environment\n\nEach environment shines in a different situation. The table below summarizes when to reach for each.\n\n| Environment | Best for | Tradeoffs |\n| --------------- | ---------------------------------------------------- | --------------------------------------------------------- |\n| Devnet | shared/manual testing | faucet limits, network latency, shared state across tests |\n| Local validator | integration testing, full RPC API | requires a separate process, shared state across tests |\n| LiteSVM | fast unit tests, manipulating account state per test | Node.js only, RPC subset, in-memory only state |\n\nYou do not have to commit to one environment for the whole project. It is common to use LiteSVM for fast unit tests, a local validator for integration tests, and devnet for manual exploration.\n\n## Use devnet for shared testing\n\nDevnet is the easiest way to share a Solana environment with your team. The `solanaDevnetRpc()` plugin defaults to the public devnet endpoint and bundles an `airdrop` capability for funding accounts.\n\n```ts twoslash\nimport { address, createClient, lamports } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signerFromFile } from '@solana/kit-plugin-signer';\n\nconst client = await createClient()\n .use(signerFromFile('~/.config/solana/id.json'))\n .use(solanaDevnetRpc());\n\nawait client.airdrop(client.payer.address, lamports(1_000_000_000n));\n```\n\nDevnet is great for one-off scripts and manual exploration, but the public faucet has tight rate limits. For automated tests, prefer one of the local options.\n\n## Use a local validator\n\nA local validator runs the same software as mainnet but on your own machine. You can install the `solana-test-validator` binary by following the [Anza installation guide](https://docs.anza.xyz/cli/install) and start it with a single command.\n\n```shell\nsolana-test-validator\n```\n\nOnce the validator is running, the `solanaLocalRpc()` plugin connects to its default endpoints (`http://127.0.0.1:8899` and `ws://127.0.0.1:8900`) and ships the same `airdrop` capability as devnet — without any rate limits.\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)));\n```\n\nUse this setup for integration tests that need the full Solana RPC API or to load deployed programs the way a real validator would. Make sure the validator is running before your tests start; otherwise, the first RPC call will fail with a connection error.\n\n## Use LiteSVM for fast tests\n\nLiteSVM runs the Solana virtual machine in-process, with no validator and no network. It is significantly faster than a local validator and is ideal for unit tests. The `litesvm()` plugin from `@solana/kit-plugin-litesvm` installs a LiteSVM-backed client that exposes the same `client.rpc`, `client.airdrop`, `client.sendTransaction`, and `client.sendTransactions` APIs as the RPC bundles.\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { litesvm } from '@solana/kit-plugin-litesvm';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(litesvm())\n .use(airdropSigner(lamports(1_000_000_000n)));\n```\n\nEach LiteSVM-backed client owns its own in-memory SVM instance, so every test can have a completely isolated state. This is particularly useful for unit tests where one test should never affect the state observed by another.\n\n\n LiteSVM runs natively in Node.js. It will throw if you try to use it in a browser or in React\n Native. The exposed RPC also covers a subset of the full API — enough for most tests, but worth\n double-checking against the [`@solana/kit-plugin-litesvm`\n README](https://github.com/anza-xyz/kit-plugins/tree/main/packages/kit-plugin-litesvm#readme)\n for the methods you rely on.\n\n\n## Create a funded test client\n\nFor most tests you want a fresh, funded signer for every run. The pattern is the same regardless of the chosen environment: install a generated signer, install the environment, and airdrop SOL.\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { litesvm } from '@solana/kit-plugin-litesvm';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(litesvm())\n .use(airdropSigner(lamports(10_000_000_000n)));\n```\n\nSwapping `litesvm()` for `solanaLocalRpc()` is a one-line change and the rest of your test code stays the same. This is one of the main benefits of the plugin model: the surface your tests interact with is a `client`, not a particular environment.\n\n## Reuse setup across tests\n\nWrap the client creation in a small factory so every test starts from a clean state. Adding any program plugins or extra setup to the factory keeps tests focused on what they are actually testing.\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { litesvm } from '@solana/kit-plugin-litesvm';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nimport { tokenProgram } from '@solana-program/token';\n\nasync function createTestClient() {\n return await createClient()\n .use(generatedSigner())\n .use(litesvm())\n .use(airdropSigner(lamports(10_000_000_000n)))\n .use(systemProgram())\n .use(tokenProgram());\n}\n```\n\nBecause Kit clients are immutable, you do not need to worry about leaking state between tests as long as you do not share a single client instance across them.\n\n## Seed accounts and programs\n\nLiteSVM exposes the underlying SVM through `client.svm`, which lets you preload accounts and programs before your test code runs. This is the quickest way to set up a specific scenario without chaining a series of transactions.\n\n```ts twoslash\nimport { address, EncodedAccount, lamports } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { litesvm } from '@solana/kit-plugin-litesvm';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nconst client = await createClient().use(generatedSigner()).use(litesvm());\n// ---cut-end---\nconst myAccount: EncodedAccount = {\n address: address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ'),\n data: new Uint8Array([1, 2, 3]),\n executable: false,\n lamports: lamports(1_000_000_000n),\n programAddress: address('11111111111111111111111111111111'),\n space: 3n,\n};\nclient.svm.setAccount(myAccount);\n\nclient.svm.addProgramFromFile(\n address('MyProgram111111111111111111111111111111111'),\n './my_program.so',\n);\n```\n\nA local validator supports similar workflows through its CLI flags (`--account`, `--bpf-program`, etc.), which you can pass when starting `solana-test-validator`. See [`@solana/kit-plugin-litesvm`](/docs/plugins/available-plugins) and the [Anza CLI documentation](https://docs.anza.xyz/cli/) for the exact APIs.\n\n## Troubleshooting\n\nA few issues come up often when wiring up local environments:\n\n- **Faucet rate limits on devnet** — switch to `solanaLocalRpc()` or `litesvm()` for repeated runs, or top up your devnet signer manually from the [Solana Faucet](https://faucet.solana.com).\n- **Validator not running** — `solana-test-validator` must be running before tests start; check the process and the default port (`8899`).\n- **WebSocket endpoint mismatch** — when overriding `rpcUrl`, also set `rpcSubscriptionsUrl` if your provider uses a different URL for WebSocket traffic.\n- **`litesvm()` errors in browser tests** — LiteSVM is Node.js only; run those tests in a Node.js environment or pick a different bundle.\n\n## Next steps\n\n- [Sending transactions](/docs/guides/sending-transactions) — exercise your client end-to-end.\n- [Using program plugins](/docs/guides/using-program-plugins) — add typed program access to your tests.\n- [Available plugins](/docs/plugins/available-plugins) — explore the LiteSVM and RPC plugin packages.\n" }, { "path": "docs/content/docs/guides/using-program-plugins.mdx", "content": "---\ntitle: Using program plugins\ndescription: Add typed program APIs to your client\n---\n\nProgram plugins are how Kit clients gain typed access to a specific Solana program. They install a typed namespace under the client — `client.system`, `client.token`, and so on — and expose the program's accounts and instructions through it. This guide walks through adding program plugins to a client and using them, alongside the standalone helpers that the same packages also expose.\n\n## Installation\n\nMost popular Solana programs ship a Codama-generated package that doubles as a Kit program plugin. Install one for each program you want to interact with.\n\n```package-install\n@solana-program/system @solana-program/token\n```\n\nThe [Available plugins](/docs/plugins/available-plugins) page lists the program plugins available today. Once installed, apply each plugin with `.use(...)` after your signer and bundle plugins, and the client gains a new typed namespace named after the program.\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nimport { tokenProgram } from '@solana-program/token';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(10_000_000_000n)))\n .use(systemProgram())\n .use(tokenProgram());\n```\n\n`client.system` and `client.token` now expose `accounts` and `instructions` namespaces typed against the System and Token programs. Multiple program plugins compose freely — installing more of them simply adds more namespaces to the client.\n\n## What is a program plugin?\n\nA program plugin is a function from a Codama-generated package that adds a typed namespace for one program's accounts and instructions to a Kit client. The same package also exports standalone helpers — `getXInstruction`, `fetchX`, `decodeX`, and so on, where `X` is the instruction or account name — for cases where you do not want a client.\n\n```ts twoslash\nimport { systemProgram } from '@solana-program/system';\nimport { tokenProgram } from '@solana-program/token';\n```\n\nYou can think of a program plugin as a typed adapter on top of these standalone helpers. The plugin handles the wiring — passing the client's RPC and payer where needed — so your code can focus on what the program does. This is great for developer experience and program discoverability, but the tradeoff is tree-shakability: pulling an entire program namespace into your client tends to produce a larger bundle than importing only the standalone helpers you actually use.\n\n## Fetch typed accounts\n\nEach `accounts` namespace exposes one entry per account type defined by the program, with `fetch`, `fetchMaybe`, `fetchAll`, and `fetchAllMaybe` methods that already know the codec to use.\n\n```ts twoslash\nimport { address } from '@solana/kit';\n// ---cut-start---\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(10_000_000_000n)))\n .use(tokenProgram());\n// ---cut-end---\nconst mint = await client.token.accounts.mint.fetch(\n address('So11111111111111111111111111111111111111112'),\n);\nmint.data.decimals; // typed as `number`\n```\n\nBecause the account namespace is generated from the program's IDL, every field on `mint.data` is fully typed — autocompletion and refactors flow through naturally. See [Fetching accounts](/docs/guides/fetching-accounts) for raw account fetching that doesn't depend on a program plugin.\n\n## Create typed instructions\n\nThe matching `instructions` namespace exposes one builder per instruction the program defines. The builders accept a typed input and return an instruction ready to be sent.\n\n```ts twoslash\nimport { address, lamports } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(10_000_000_000n)))\n .use(systemProgram());\nconst recipient = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\n// ---cut-end---\nconst transferSol = client.system.instructions.transferSol({\n source: client.payer,\n destination: recipient,\n amount: lamports(500_000n),\n});\n```\n\n## Use the `.sendTransaction()` shortcut\n\nEach typed instruction returned by a program plugin also exposes a `.sendTransaction()` method that wraps `client.sendTransaction([instruction])`. This is the most concise way to send a one-off transaction.\n\n```ts twoslash\nimport { address, lamports } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(10_000_000_000n)))\n .use(systemProgram());\nconst recipient = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\n// ---cut-end---\nconst result = await client.system.instructions\n .transferSol({\n source: client.payer,\n destination: recipient,\n amount: lamports(500_000n),\n })\n .sendTransaction();\n```\n\nThe same returned object also exposes `.sendTransactions()`, `.planTransaction()`, and `.planTransactions()` shortcuts that wrap the matching client methods. The shortcut shines for single-instruction operations where the rest of the transaction would just be ceremony. When you want to combine several instructions into one transaction or compose larger operations, [`client.sendTransaction([...])`](/docs/guides/sending-transactions) is the more flexible primitive.\n\n## Use instruction plans from program plugins\n\nSome operations naturally span more than one instruction — creating and initializing a token mint is a classic example. Program plugins expose these as instruction plans rather than raw instructions, which means they can also be combined into larger plans.\n\n```ts twoslash\nimport { generateKeyPairSigner } from '@solana/kit';\n// ---cut-start---\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(10_000_000_000n)))\n .use(tokenProgram());\n// ---cut-end---\nconst newMint = await generateKeyPairSigner();\nconst createMintPlan = client.token.instructions.createMint({\n newMint,\n decimals: 9,\n mintAuthority: client.identity.address,\n});\n```\n\nThe returned plan can be sent on its own with `.sendTransaction()` or `.sendTransactions()`, fed into [`client.sendTransaction([...])`](/docs/guides/sending-transactions) alongside other work, or combined with [`sequentialInstructionPlan(...)`](/docs/guides/sending-multiple-transactions) and [`parallelInstructionPlan(...)`](/docs/guides/sending-multiple-transactions) helpers when building larger operations.\n\n## Use program libraries without a client\n\nEvery program package also exports standalone helpers that work on a plain `Rpc` object or with raw `Instruction`s. This is useful for libraries that should not assume a Kit client, or when you want maximum tree-shaking.\n\n```ts twoslash\nimport { address, createSolanaRpc, generateKeyPairSigner, lamports } from '@solana/kit';\nimport { fetchMint } from '@solana-program/token';\nimport { getTransferSolInstruction } from '@solana-program/system';\n\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\n\nconst mint = await fetchMint(rpc, address('So11111111111111111111111111111111111111112'));\n\nconst source = await generateKeyPairSigner();\nconst transferSol = getTransferSolInstruction({\n source,\n destination: address('Ay1zdJ3VDbhrAtkRiqBUJgKLHYbgFZN5BXk7svtMowif'),\n amount: lamports(500_000n),\n});\n```\n\nBecause the standalone helpers and the plugin-based namespaces are generated from the same IDL, the input shapes match exactly. You can move from one style to the other without rewriting the data your application passes around.\n\n## Generate plugins for your own programs\n\nAny program with a Codama IDL can be turned into a Kit-compatible package, with both standalone helpers and a program plugin, using the [Codama JS renderer](https://github.com/codama-idl/renderers-js). The renderer reads the IDL, emits TypeScript bindings, and wires them up through the same `@solana/program-client-core` primitives the `@solana-program/*` packages use.\n\nIf your program is built with Anchor, you can convert its Anchor IDL to a Codama IDL first, which means program plugin generation works for Anchor programs as well. See [Generating program plugins](/docs/plugins/generating-program-plugins) for a step-by-step walkthrough.\n\n## Next steps\n\n- [Available plugins](/docs/plugins/available-plugins) — browse the program plugins available today.\n- [Generating program plugins](/docs/plugins/generating-program-plugins) — generate a plugin for your own program.\n- [Fetching accounts](/docs/guides/fetching-accounts) — combine typed accounts with raw RPC reads.\n- [Sending transactions](/docs/guides/sending-transactions) — use typed instructions with `client.sendTransaction([...])`.\n" }, { "path": "docs/content/docs/index.mdx", "content": "---\ntitle: Installation\ndescription: Get started with Kit\n---\n\nKit is a JavaScript SDK for building Solana apps across environments like Node, the web, and React Native. It provides a comprehensive set of data types and helper functions, forming the foundation for interacting with Solana in JavaScript.\n\n\n Check out our [Upgrade guide](/docs/upgrade-guide) to see how Kit compares to Web3.js.\n\n\n## Quick start\n\nChoose the client setup that fits your environment:\n\n\n\n\n\n\n\n### Install packages\n\nInstall Kit and the plugins for RPC connectivity and signer management.\n\n```package-install\n@solana/kit @solana/kit-plugin-rpc @solana/kit-plugin-signer\n```\n\n\n\n\n### Install program plugins\n\nInstall plugins for any Solana program you want to interact with. You can find a full list on the [Available Plugins](/docs/plugins/available-plugins) page.\n\n```package-install\n@solana-program/system @solana-program/token\n```\n\n\n\n\n### Create your client\n\n```ts twoslash\nimport { createClient } from '@solana/kit';\nimport { solanaMainnetRpc } from '@solana/kit-plugin-rpc';\nimport { signerFromFile } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nimport { tokenProgram } from '@solana-program/token';\n\nconst client = await createClient()\n .use(signerFromFile('~/.config/solana/id.json'))\n .use(solanaMainnetRpc({ rpcUrl: 'https://api.mainnet-beta.solana.com' }))\n .use(systemProgram())\n .use(tokenProgram());\n\n// Here are some of the things you can do with your client:\n// client.rpc.getBalance(address).send();\n// client.system.instructions.transferSol({...}).sendTransaction();\n// client.token.accounts.mint.fetch(address);\n// client.sendTransaction(instructions);\n// And more...\n```\n\nThis example loads the default Solana CLI keypair. See [Setting Up Signers](/docs/guides/setting-up-signers) for other production signer options such as using a wallet.\n\n\n\n\n\n\n\n\n\n\n### Install packages\n\nInstall Kit and the plugins for local RPC connectivity and signer management.\n\n```package-install\n@solana/kit @solana/kit-plugin-rpc @solana/kit-plugin-signer\n```\n\n\n\n\n### Install program plugins\n\nInstall plugins for any Solana program you want to interact with. You can find a full list on the [Available Plugins](/docs/plugins/available-plugins) page.\n\n```package-install\n@solana-program/system @solana-program/token\n```\n\n\n\n\n### Start a test validator\n\nMake sure you have a local Solana validator running before using your client.\n\n```shell\nsolana-test-validator\n```\n\n\n\n\n### Create your client\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nimport { tokenProgram } from '@solana-program/token';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(100_000_000_000n)))\n .use(systemProgram())\n .use(tokenProgram());\n\n// Signer is auto-generated and funded with SOL.\n// Here are some of the things you can do with your client:\n// client.rpc.getBalance(address).send();\n// client.system.instructions.transferSol({...}).sendTransaction();\n// client.token.accounts.mint.fetch(address);\n// client.sendTransaction(instructions);\n// And more...\n```\n\n\n\n\n\n\n\n\n\n\n### Install packages\n\nInstall Kit and the plugins for LiteSVM and signer management.\n\n```package-install\n@solana/kit @solana/kit-plugin-litesvm @solana/kit-plugin-signer\n```\n\n\n\n\n### Install program plugins\n\nInstall plugins for any Solana program you want to interact with. You can find a full list on the [Available Plugins](/docs/plugins/available-plugins) page.\n\n```package-install\n@solana-program/system @solana-program/token\n```\n\n\n\n\n### Create your client\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { litesvm } from '@solana/kit-plugin-litesvm';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nimport { tokenProgram } from '@solana-program/token';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(litesvm())\n .use(airdropSigner(lamports(100_000_000_000n)))\n .use(systemProgram())\n .use(tokenProgram());\n\n// Here are some of the things you can do with your client:\n// client.rpc.getBalance(address).send();\n// client.system.instructions.transferSol({...}).sendTransaction();\n// client.token.accounts.mint.fetch(address);\n// client.sendTransaction(instructions);\n// And more...\n```\n\n\n\n\n\n\n\n\n\n\n### Install Kit\n\n```package-install\n@solana/kit\n```\n\n\n\n\n### Install program libraries\n\nInstall Kit-compatible libraries for any program you want to interact with. For example, to interact with the System program, install the `@solana-program/system` package. You can find a [list of available program plugins here](/docs/plugins/available-plugins).\n\n```package-install\n@solana-program/system @solana-program/token\n```\n\n\n\n\n### Set up your project\n\n```ts twoslash\nimport { address, createSolanaRpc } from '@solana/kit';\n\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\nconst { value: balance } = await rpc\n .getBalance(address('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb'))\n .send();\nconsole.log(`Balance: ${balance} lamports`);\n```\n\nSee [Kit Without a Client](/docs/advanced-guides/kit-without-a-client) for the full guide on sending transactions, signing, and more without a client.\n\n\n\n\n\n\n\nReady to build? Check out the [Getting Started](/docs/getting-started) tutorial to build your first app, or explore the [Guides](/docs/guides) for specific topics.\n" }, { "path": "docs/content/docs/meta.json", "content": "{\n \"title\": \"Documentation\",\n \"defaultOpen\": true,\n \"root\": true,\n \"pages\": [\n \"index\",\n \"getting-started\",\n \"upgrade-guide\",\n \"...\",\n \"guides\",\n \"plugins\",\n \"advanced-guides\"\n ]\n}\n" }, { "path": "docs/content/docs/plugins/available-plugins.mdx", "content": "---\ntitle: Available plugins\ndescription: Directory of plugins for Kit clients\n---\n\nThis page lists the Kit plugins published today. Anyone can author and publish a plugin; if you have one you'd like added here, open a PR against [`anza-xyz/kit`](https://github.com/anza-xyz/kit) to be listed alongside the others.\n\nThe tables below group plugins by category. Within each category, generic plugins from Anza are listed first because they target the broadest range of use cases, followed by community plugins in alphabetical order. When a single package contains plugins with materially different purposes, those plugins are split across multiple rows so each description stays targeted.\n\n## Signer plugins\n\nSigner plugins install a `TransactionSigner` on the client as the `payer`, the `identity`, or both. See [Setting up signers](/docs/guides/setting-up-signers) for an overview of when each variant fits.\n\n| Maintainer | Package | Plugins | Description |\n| ----------------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ---------------------------------------------------------------- |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-signer`](https://www.npmjs.com/package/@solana/kit-plugin-signer) | `signer`, `payer`, `identity` | Install an existing `TransactionSigner` on the client. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-signer`](https://www.npmjs.com/package/@solana/kit-plugin-signer) | `signerFromFile`, `payerFromFile`, `identityFromFile` | Load a Solana CLI keypair from a JSON file (Node.js only). |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-signer`](https://www.npmjs.com/package/@solana/kit-plugin-signer) | `generatedSigner`, `generatedPayer`, `generatedIdentity` | Generate a fresh in-memory keypair, useful for tests. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-signer`](https://www.npmjs.com/package/@solana/kit-plugin-signer) | `generatedSignerWithSol`, `generatedPayerWithSol`, `generatedIdentityWithSol` | Generate a signer and airdrop SOL to it in one step. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-signer`](https://www.npmjs.com/package/@solana/kit-plugin-signer) | `airdropSigner`, `airdropPayer`, `airdropIdentity` | Airdrop SOL to a signer that is already installed on the client. |\n\n## RPC plugins\n\nRPC plugins install Solana RPC connectivity on the client. LiteSVM is included here because it implements a subset of the same RPC API in-process, with no network involved.\n\n| Maintainer | Package | Plugins | Description |\n| ---------------------------------- | --------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-rpc`](https://www.npmjs.com/package/@solana/kit-plugin-rpc) | `solanaRpc`, `solanaMainnetRpc`, `solanaDevnetRpc`, `solanaLocalRpc` | Bundle plugins that wire up RPC, subscriptions, planning, and sending in one step. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-rpc`](https://www.npmjs.com/package/@solana/kit-plugin-rpc) | `solanaRpcConnection` | Install `client.rpc` and `client.rpcSubscriptions` from a cluster URL. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-rpc`](https://www.npmjs.com/package/@solana/kit-plugin-rpc) | `rpcAirdrop` | Add `client.airdrop` for devnet, testnet, and local validators. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-rpc`](https://www.npmjs.com/package/@solana/kit-plugin-rpc) | `rpcGetMinimumBalance` | Add `client.getMinimumBalance` using the matching RPC method. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-litesvm`](https://www.npmjs.com/package/@solana/kit-plugin-litesvm) | `litesvm` | Bundle plugin that runs an in-process Solana VM with full transaction sending support. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-litesvm`](https://www.npmjs.com/package/@solana/kit-plugin-litesvm) | `litesvmConnection` | Install `client.svm` and a subset of `client.rpc` backed by an in-process VM. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-litesvm`](https://www.npmjs.com/package/@solana/kit-plugin-litesvm) | `litesvmAirdrop` | Add `client.airdrop` against the in-process VM. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-litesvm`](https://www.npmjs.com/package/@solana/kit-plugin-litesvm) | `litesvmGetMinimumBalance` | Add `client.getMinimumBalance` against the in-process VM. |\n| [@amilz](https://github.com/amilz) | [`local-validator`](https://github.com/amilz/kit-helpers/tree/main/plugins/local-validator) (unpublished) | `localValidatorPlugin` | Manage the lifecycle of a local `solana-test-validator` (start, stop, restart). |\n\n## Instruction plan plugins\n\nInstruction plan plugins install transaction planning and sending capabilities on the client. The RPC and LiteSVM packages are listed here too because they ship default planner and executor implementations on top of their respective backends — including the bundle plugins, which install everything needed to call `client.planTransaction(s)` and `client.sendTransaction(s)` in one step.\n\n| Maintainer | Package | Plugins | Description |\n| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-instruction-plan`](https://www.npmjs.com/package/@solana/kit-plugin-instruction-plan) | `transactionPlanner` | Install a custom transaction planner on the client. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-instruction-plan`](https://www.npmjs.com/package/@solana/kit-plugin-instruction-plan) | `transactionPlanExecutor` | Install a custom transaction plan executor on the client. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-instruction-plan`](https://www.npmjs.com/package/@solana/kit-plugin-instruction-plan) | `planAndSendTransactions` | Add `client.planTransaction(s)` and `client.sendTransaction(s)` on top of an existing planner and executor. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-rpc`](https://www.npmjs.com/package/@solana/kit-plugin-rpc) | `solanaRpc`, `solanaMainnetRpc`, `solanaDevnetRpc`, `solanaLocalRpc` | Bundle plugins that wire up RPC, subscriptions, planning, and sending in one step. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-rpc`](https://www.npmjs.com/package/@solana/kit-plugin-rpc) | `rpcTransactionPlanner`, `rpcTransactionPlanExecutor` | Default transaction planner and executor backed by RPC. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-litesvm`](https://www.npmjs.com/package/@solana/kit-plugin-litesvm) | `litesvm` | Bundle plugin that runs an in-process Solana VM with full transaction sending support. |\n| [Anza](https://www.anza.xyz/) | [`@solana/kit-plugin-litesvm`](https://www.npmjs.com/package/@solana/kit-plugin-litesvm) | `litesvmTransactionPlanner`, `litesvmTransactionPlanExecutor` | Default transaction planner and executor backed by LiteSVM. |\n| [@amilz](https://github.com/amilz) | [`transaction-builder`](https://github.com/amilz/kit-helpers/tree/main/plugins/transaction-builder) (unpublished) | `transactionBuilderPlugin` | Helpers for constructing, signing, and sending transactions. |\n\n## Program plugins\n\nProgram plugins are generated from program IDLs and install a typed `client.` namespace with `accounts` and `instructions` helpers. See [Using program plugins](/docs/guides/using-program-plugins) for usage and [Generating program plugins](/docs/plugins/generating-program-plugins) for authoring new ones.\n\n| Maintainer | Package | Plugins | Description |\n| ---------------------------------- | ------------------------------------------------------------------------------------------------------------ | --------------------------------- | ----------------------------------------------------------------------------- |\n| [Anza](https://www.anza.xyz/) | [`@solana-program/address-lookup-table`](https://www.npmjs.com/package/@solana-program/address-lookup-table) | _Plugin coming soon_ | Address Lookup Table program. |\n| [Anza](https://www.anza.xyz/) | [`@solana-program/compute-budget`](https://www.npmjs.com/package/@solana-program/compute-budget) | _Plugin coming soon_ | Compute Budget program: priority fees and compute unit limits. |\n| [Anza](https://www.anza.xyz/) | [`@solana-program/memo`](https://www.npmjs.com/package/@solana-program/memo) | _Plugin coming soon_ | Memo program. |\n| [Anza](https://www.anza.xyz/) | [`@solana-program/stake`](https://www.npmjs.com/package/@solana-program/stake) | _Plugin coming soon_ | Stake program. |\n| [Anza](https://www.anza.xyz/) | [`@solana-program/system`](https://www.npmjs.com/package/@solana-program/system) | `systemProgram` | Native System program: account creation, transfers, nonce accounts, and more. |\n| [Anza](https://www.anza.xyz/) | [`@solana-program/token`](https://www.npmjs.com/package/@solana-program/token) | `tokenProgram` | SPL Token program: mints, token accounts, and ATAs. |\n| [Anza](https://www.anza.xyz/) | [`@solana-program/token-2022`](https://www.npmjs.com/package/@solana-program/token-2022) | _Plugin coming soon_ | SPL Token Extension program (Token-2022). |\n| [@amilz](https://github.com/amilz) | [`airdrop-token`](https://github.com/amilz/kit-helpers/tree/main/plugins/airdrop-token) (unpublished) | `airdropToken`, `testTokenPlugin` | Helpers for creating mints, ATAs, and minting tokens for tests. |\n\n## Other plugins\n\nPlugins that don't fit into the categories above land here. Nothing has been listed yet — open a PR against [`anza-xyz/kit`](https://github.com/anza-xyz/kit) to add yours.\n\n## Next steps\n\n- [Creating custom plugins](/docs/plugins/creating-custom-plugins) — write your own plugin and publish it.\n- [Generating program plugins](/docs/plugins/generating-program-plugins) — generate a typed plugin for a Solana program.\n- [Using program plugins](/docs/guides/using-program-plugins) — consume program plugins from a Kit client.\n" }, { "path": "docs/content/docs/plugins/creating-custom-plugins.mdx", "content": "---\ntitle: Creating custom plugins\ndescription: Write your own plugins to extend Kit clients\n---\n\nPlugins are small, focused functions that extend a Kit client with new capabilities. This page walks through writing a plugin from scratch, declaring its prerequisites, handling asynchronous setup, registering cleanup logic, and composing several plugins into a higher-level bundle.\n\n## The `ClientPlugin` shape\n\nA plugin is a function that takes a client and returns a new client object. The recommended way to add properties is the `extendClient(client, additions)` helper from `@solana/kit`, which preserves property descriptors (getters, symbol-keyed properties) that a plain object spread would flatten.\n\n```ts twoslash\nimport { createClient, extendClient } from '@solana/kit';\n\nfunction apple() {\n return (client: T) => extendClient(client, { fruit: 'apple' as const });\n}\n\nconst client = createClient().use(apple());\nclient.fruit; // 'apple'\n```\n\nWrapping the plugin in a small factory function (`apple()` rather than `apple`) is the convention across Kit plugins. It gives you somewhere to accept configuration without changing the shape of the function returned to `.use(...)`.\n\n## Add prerequisites with TypeScript generics\n\nPlugins can require capabilities from the input client by constraining the input type. If a consumer applies your plugin in the wrong order, TypeScript reports a compile-time error rather than letting it fail at runtime.\n\n```ts twoslash\n// @errors: 2345\nimport { createClient, extendClient } from '@solana/kit';\n\nfunction appleTart() {\n return (client: T) =>\n extendClient(client, { dessert: 'appleTart' as const });\n}\n\ncreateClient().use(appleTart()); // ❌ Missing `fruit: 'apple'`.\n```\n\nThe same mechanism is what makes the official plugins compose so cleanly: `airdropPayer()` requires `ClientWithPayer & ClientWithAirdrop`, `solanaRpc(...)` requires `ClientWithPayer`, and so on. Adopting the same pattern in your own plugins keeps users honest about the order of operations.\n\n## Use the standard interfaces\n\nWhenever possible, declare your prerequisites and additions using the standard interfaces from `@solana/plugin-interfaces` (re-exported from `@solana/kit`). This lets your plugin compose with any other plugin that targets the same shape, regardless of its package.\n\nThe most common interfaces are:\n\n- `ClientWithPayer` and `ClientWithIdentity` for signer roles.\n- `ClientWithRpc` and `ClientWithRpcSubscriptions` for transports.\n- `ClientWithAirdrop` and `ClientWithGetMinimumBalance` for funding helpers.\n- `ClientWithTransactionPlanning` and `ClientWithTransactionSending` for the transaction lifecycle.\n\nIf your plugin's capability does not match any existing interface, define your own type and export it. If you think the capability is generally useful and there is a gap in the standard interfaces, consider opening a PR against [`anza-xyz/kit`](https://github.com/anza-xyz/kit) so other plugins can adopt it too. Treating capabilities as named interfaces makes them addressable from other code without naming the specific plugin that installed them.\n\n## Asynchronous plugins\n\nPlugins can return a `Promise` instead of a `Client`. The `.use(...)` chain awaits async plugins automatically, so you only need a single `await` at the end of the chain.\n\n```ts twoslash\nimport {\n createClient,\n createKeyPairSignerFromBytes,\n extendClient,\n KeyPairSigner,\n} from '@solana/kit';\nimport { readFile } from 'node:fs/promises';\n\nfunction signerFromBytesFile(path: string) {\n return async (client: T) => {\n const bytes = JSON.parse(await readFile(path, 'utf-8')) as number[];\n const signer: KeyPairSigner = await createKeyPairSignerFromBytes(new Uint8Array(bytes));\n return extendClient(client, { payer: signer, identity: signer });\n };\n}\n\nconst client = await createClient().use(signerFromBytesFile('./keypair.json'));\n```\n\nAsync and sync plugins can be mixed freely in the same chain. Once any async plugin is involved, the `.use(...)` chain returns an `AsyncClient` that you await once at the end.\n\n## Release resources on disposal\n\nPlugins that hold disposable resources — WebSocket connections, intervals, file handles — can register a cleanup function with `withCleanup(...)`. The returned client implements `Disposable`, so a `using` declaration runs the cleanup when the client goes out of scope.\n\n```ts twoslash\nimport { extendClient, withCleanup } from '@solana/kit';\n\nfunction liveFeed(url: string) {\n return (client: T) => {\n const socket = new WebSocket(url);\n return withCleanup(extendClient(client, { socket }), () => socket.close());\n };\n}\n```\n\n`withCleanup` chains existing dispose logic, so you can call it more than once across plugins without overriding earlier cleanup. Reach for it whenever your plugin owns a resource the user would otherwise have to remember to release manually.\n\n## Compose smaller plugins into a bundle\n\nA bundle plugin is just a regular plugin that applies several smaller plugins one after another. The `pipe(...)` helper from `@solana/kit` makes the composition concise and the resulting type predictable.\n\n```ts twoslash\n// @noErrors\nimport { ClientWithPayer, pipe } from '@solana/kit';\nimport {\n rpcAirdrop,\n rpcGetMinimumBalance,\n solanaRpcConnection,\n SolanaRpcConnectionConfig,\n} from '@solana/kit-plugin-rpc';\n\nfunction myDevnetBundle(config: SolanaRpcConnectionConfig) {\n return (client: T) =>\n pipe(client, solanaRpcConnection(config), rpcGetMinimumBalance(), rpcAirdrop());\n}\n```\n\nThe bundle accepts an existing client rather than calling `createClient()` itself. That keeps your bundle composable: callers stay in control of their own client and can apply additional plugins before or after yours. It is also what lets the official `solanaRpc`, `solanaDevnetRpc`, `solanaLocalRpc`, and `litesvm` bundles drop into any client the same way a single plugin would.\n\n## Publish your plugin\n\nA few small conventions go a long way once a plugin lands on npm:\n\n- Name the factory function after the capability it installs (e.g. `signer`, `rpcAirdrop`, `tokenProgram`) rather than the package, and make sure it reads well at the call site — `use(tokenProgram())` should sound like the sentence you would write to describe what it does.\n- Document the standard interfaces your plugin requires and provides; this is what other plugin authors will read first.\n- Keep the public surface minimal — one factory function per concept — and prefer composition over bigger plugins that try to do everything.\n\nOnce your plugin is published, open a PR against [`anza-xyz/kit`](https://github.com/anza-xyz/kit) to be listed on the [Available plugins](/docs/plugins/available-plugins) page so other developers can find it.\n\n## Next steps\n\n- [Plugins](/docs/plugins) — revisit the client model and standard interfaces.\n- [Available plugins](/docs/plugins/available-plugins) — see how published plugins describe themselves.\n- [Generating program plugins](/docs/plugins/generating-program-plugins) — let Codama write a program plugin for you.\n" }, { "path": "docs/content/docs/plugins/generating-program-plugins.mdx", "content": "---\ntitle: Generating program plugins\ndescription: Generate typed plugins for your Solana programs using Codama\n---\n\nProgram plugins are generated from program IDLs by [Codama](https://github.com/codama-idl/codama). Codama's CLI is the quickest path to a working plugin: two commands set up a configuration file in your repo and emit a Kit-compatible package containing both standalone helpers and a typed program plugin.\n\nThis page focuses on how the generated output fits into the Kit ecosystem. Codama itself has comprehensive docs that go much deeper into IDLs, visitors, and renderer configuration.\n\n## What Codama generates\n\nFor every program, the JavaScript renderer emits two things side by side: standalone helpers for use without a client, and a program plugin that installs a typed namespace on a Kit client.\n\n```ts\n// Standalone helpers, one per instruction and account defined in the IDL.\nimport { decodeMyAccount, fetchMyAccount, getMyInstruction } from '@your-scope/your-program';\n\n// Program plugin — installs `client.yourProgram.accounts` and `client.yourProgram.instructions`.\nimport { yourProgram } from '@your-scope/your-program';\n```\n\nBoth forms are generated automatically from your IDL. The standalone helpers tree-shake well and keeps JS bundles small, while the program plugin is the most ergonomic way to use the program from a Kit client.\n\n## Set up Codama with `codama init`\n\nInstall Codama as a dev dependency and run `codama init`. The CLI prompts you for the path to your IDL and writes a `codama.json` configuration file at the root of your project. Make sure to select the JS client option to generate a Kit-compatible program library.\n\n```sh\npnpm install codama\ncodama init\n```\n\nThe CLI auto-detects Anchor IDLs and configures the conversion step for you, so this same flow works for both native programs (with a Codama IDL) and Anchor programs (with an Anchor IDL).\n\n## Generate the plugin with `codama run js`\n\nOnce the configuration file exists, generating the JavaScript client is a single command. Codama installs the renderer the first time it runs and writes the generated files to the path declared in the configuration.\n\n```sh\ncodama run js\n```\n\nThe output includes the standalone helpers, the program plugin, and the supporting types. Importing it from a Kit client looks the same as any other program plugin:\n\n```ts twoslash\n// @noErrors\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\nimport { yourProgram } from '@your-scope/your-program';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaDevnetRpc())\n .use(yourProgram());\n```\n\n## Configure the renderer\n\nThe `codama.json` file generated by `codama init` controls where the output lands and which visitors run before the renderer. You can edit it to rename accounts, add custom transformations, or change the output directory. See the [Codama JS renderer docs](https://github.com/codama-idl/renderers-js) for the full list of configuration options.\n\nIf you need more than one client (for example, both JavaScript and Rust), additional renderers can be added to the same configuration file and run with `codama run --all`.\n\n## Publish your generated plugin\n\nOnce your plugin is generating cleanly, publishing it follows the same pattern as the official `@solana-program/*` packages. A few conventions worth keeping in mind:\n\n- Use a `@/` package layout, with a single entry point that re-exports both the standalone helpers and the `programName()` plugin.\n- Once published, open a PR against [`anza-xyz/kit`](https://github.com/anza-xyz/kit) to list your plugin on the [Available plugins](/docs/plugins/available-plugins) page so other developers can find it.\n\n## Next steps\n\n- [Using program plugins](/docs/guides/using-program-plugins) — consume program plugins from a Kit client.\n- [Available plugins](/docs/plugins/available-plugins) — browse program plugins published today.\n- [Creating custom plugins](/docs/plugins/creating-custom-plugins) — write a plugin that is not generated from an IDL.\n" }, { "path": "docs/content/docs/plugins/index.mdx", "content": "---\ntitle: Plugins\ndescription: Understand Kit's plugin ecosystem\n---\n\nPlugins are how Kit clients gain capabilities. Everything from RPC connectivity, wallet signers, transaction sending, and even typed access to Solana programs is delivered as a plugin you opt into. This page explains the underlying client model and the conventions plugins follow.\n\n## What is a Kit client?\n\nA Kit client is a frozen, typed JavaScript object created with `createClient()` from `@solana/kit` and extended by chaining `.use(plugin())` calls. Each call applies a plugin, and the returned client is a brand new immutable object — the previous one is left untouched.\n\n```ts twoslash\nimport { createClient } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { generatedSigner } from '@solana/kit-plugin-signer';\n\nconst client = await createClient().use(generatedSigner()).use(solanaDevnetRpc());\n```\n\nBecause the client is immutable, you cannot accidentally mutate it from somewhere else in your application: `client` always reflects the exact set of plugins you applied at creation time.\n\n## What is a plugin?\n\nA plugin is a function that takes a client object and returns either a new client object or a promise resolving to one. The shape is captured by the `ClientPlugin` type.\n\n```ts twoslash\nimport { ClientPlugin, extendClient } from '@solana/kit';\n\nconst apple = (): ClientPlugin => (client) =>\n extendClient(client, { fruit: 'apple' as const });\n```\n\nMost plugins follow the same convention: they are exported as small factory functions (so you can pass configuration to them) that return the actual `ClientPlugin` function. Asynchronous plugins are supported too; the `.use(...)` chain awaits them automatically, so you only need a single `await` at the end.\n\n## Plugin requirements and ordering\n\nPlugins can require capabilities from the input client by constraining the input type. This means installing them in the wrong order produces a TypeScript error rather than a runtime surprise.\n\n```ts twoslash\n// @errors: 2345\nimport { ClientWithPayer, createClient, extendClient } from '@solana/kit';\n\nfunction airdropPayer() {\n return (client: T) => extendClient(client, { airdropped: true });\n}\n\n// Requires a `payer` to be installed first; this fails at compile time.\nconst client = createClient().use(airdropPayer());\n```\n\nAdding `payer(...)` (or any other plugin that satisfies `ClientWithPayer`) before `airdropPayer()` makes the chain type-check. The TypeScript compiler walks the whole chain and verifies that each plugin's input requirements are met by the time it is applied.\n\n## Standard plugin interfaces\n\nKit ships a small set of standard interfaces in `@solana/plugin-interfaces` (re-exported from `@solana/kit`) so plugins from different packages can interoperate. A plugin that installs `client.rpc` declares it provides `ClientWithRpc<...>`; a plugin that needs a payer constrains its input with `ClientWithPayer`. The most common interfaces are:\n\n- `ClientWithPayer` — installs `client.payer`.\n- `ClientWithIdentity` — installs `client.identity`.\n- `ClientWithRpc` — installs `client.rpc`.\n- `ClientWithRpcSubscriptions` — installs `client.rpcSubscriptions`.\n- `ClientWithAirdrop` — installs `client.airdrop`.\n- `ClientWithGetMinimumBalance` — installs `client.getMinimumBalance`.\n- `ClientWithTransactionPlanning` — installs `client.planTransaction(s)`.\n- `ClientWithTransactionSending` — installs `client.sendTransaction(s)`.\n\nSticking to these interfaces lets plugins from any source compose freely with each other — and lets your application code take a `ClientWithRpc` rather than caring which specific plugin produced the RPC capability.\n\n## Next steps\n\n- [Available plugins](/docs/plugins/available-plugins) — browse the plugins published today.\n- [Creating custom plugins](/docs/plugins/creating-custom-plugins) — write your own plugin.\n- [Generating program plugins](/docs/plugins/generating-program-plugins) — generate a typed plugin for a Solana program.\n" }, { "path": "docs/content/docs/plugins/meta.json", "content": "{\n \"title\": \"Plugins\",\n \"defaultOpen\": true,\n \"pages\": [\"available-plugins\", \"creating-custom-plugins\", \"generating-program-plugins\"]\n}\n" }, { "path": "docs/content/docs/tree-shaking.tsx", "content": "import { ImageZoom } from 'fumadocs-ui/components/image-zoom';\n\nexport default function TreeShaking() {\n return (\n
\n \n \n Tree-shaking illustration\n \n The left side shows a bunch of imports from Web3.js all being bundled\n despite only a couple being used. The right side shows an equivalent set of\n imports for Kit but only the used functions are bundled.\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
\n );\n}\n" }, { "path": "docs/content/docs/upgrade-guide.mdx", "content": "---\ntitle: Upgrade guide\ndescription: Upgrade your Web3.js project to Kit\n---\n\nimport TreeShaking from './tree-shaking';\n\n## Why upgrade?\n\nKit is a complete rewrite of [the Web3.js library](https://github.com/solana-labs/solana-web3.js/). It is designed to be more composable, customizable, and efficient than its predecessor. Its functional design enables the entire library to be tree-shaken, drastically reducing your bundle size. It also takes advantage of modern JavaScript features — such as native Ed25519 key support and `bigint` for large values — resulting in an even smaller bundle, better performance and most importantly, a reduced attack surface for your application.\n\n\n \n\n\nUnlike Web3.js, Kit doesn't rely on JavaScript classes or other non-tree-shakeable features. This brings us to our first key difference.\n\n## Where's my `Connection` class?\n\nIn Web3.js, the `Connection` class serves as a central entry point, making the library's API easier to discover via a single object. However, this comes at a cost: using the `Connection` class forces you to bundle every method it provides, even if you only use a few. As a result, your users must download the entire library, even when most of it goes unused.\n\nTo avoid this, **Kit does not include a single entry-point class like `Connection`**. Instead, it offers a set of functions that you can import and use as needed. Two key functions replace most of the `Connection` class's functionality: `createSolanaRpc` and `createSolanaRpcSubscriptions`.\n\nThe former, `createSolanaRpc`, returns an `Rpc` object for making RPC requests to a specified endpoint. [Read more about RPCs here](/docs/guides/rpc).\n\n\n
\n\n```ts title=\"Web3.js\"\nimport { Connection, PublicKey } from '@solana/web3.js';\n\n// Create a `Connection` object.\nconst connection = new Connection('https://api.devnet.solana.com', {\n commitment: 'confirmed',\n});\n\n// Send RPC requests.\nconst wallet = new PublicKey('1234..5678');\nconst balance = await connection.getBalance(wallet);\n```\n\n```ts twoslash title=\"Kit\"\nimport { address, createSolanaRpc } from '@solana/kit';\n\n// Create an RPC proxy object.\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\n\n// Send RPC requests.\nconst wallet = address('1234..5678');\nconst { value: balance } = await rpc.getBalance(wallet).send();\n```\n\n
\n\n\nThe latter, `createSolanaRpcSubscriptions`, returns an `RpcSubscriptions` object, which lets you to subscribe to events on the Solana network. [Read more about RPC Subscriptions here](/docs/guides/rpc-subscriptions).\n\n\n
\n\n```ts title=\"Web3.js\"\nimport { Connection, PublicKey } from '@solana/web3.js';\n\n// Create a `Connection` object with a WebSocket endpoint.\nconst connection = new Connection('https://api.devnet.solana.com', {\n wsEndpoint: 'wss://api.devnet.solana.com',\n commitment: 'confirmed',\n});\n\n// Subscribe to RPC events and listen to notifications.\nconst wallet = new PublicKey('1234..5678');\nconnection.onAccountChange(wallet, (accountInfo) => {\n console.log(accountInfo);\n});\n```\n\n```ts twoslash title=\"Kit\"\nimport { address, createSolanaRpcSubscriptions } from '@solana/kit';\n\n// Create an RPC subscriptions proxy object.\nconst rpcSubscriptions = createSolanaRpcSubscriptions('wss://api.devnet.solana.com');\n\n// Use an `AbortController` to cancel the subscriptions.\nconst abortController = new AbortController();\n\n// Subscribe to RPC events.\nconst wallet = address('1234..5678');\nconst accountNotifications = await rpcSubscriptions\n .accountNotifications(wallet, { commitment: 'confirmed' })\n .subscribe({ abortSignal: abortController.signal });\n\ntry {\n // Listen to event notifications.\n for await (const accountInfo of accountNotifications) {\n console.log(accountInfo);\n }\n} catch (e) {\n // Gracefully handle subscription disconnects.\n}\n```\n\n
\n\n\nNote that, although `Rpc` and `RpcSubscriptions` look like classes, they are actually [`Proxy` objects](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy). This means they dynamically construct RPC requests or subscriptions based on method names and parameters. TypeScript is then used to provide type safety for the RPC API, making it easy to discover available RPC methods while keeping the library lightweight. Regardless of whether your RPC supports 1 method or 100, the bundle size remains unchanged.\n\n## Introducing Kit clients\n\nThe functional approach above gives you maximum treeshakability, but it can feel verbose compared to Web3.js's `Connection`. Kit addresses this with **plugin-based clients** — a single object that bundles the functionality you need while still letting you choose what goes in. You cherry-pick plugins, so you typically only bundle what you actually use.\n\n\n
\n\n```ts title=\"Web3.js\"\nimport { Connection, PublicKey } from '@solana/web3.js';\n\n// Create a `Connection` object.\nconst connection = new Connection('https://api.devnet.solana.com');\n\n// Use the connection.\nconst wallet = new PublicKey('1234..5678');\nconst balance = await connection.getBalance(wallet);\n```\n\n```ts twoslash title=\"Kit\"\nimport { address, createClient, generateKeyPairSigner } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signer } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\n\n// Create a client with the plugins you need.\nconst payer = await generateKeyPairSigner();\nconst client = createClient().use(signer(payer)).use(solanaDevnetRpc()).use(systemProgram());\n\n// Use the client.\nconst wallet = address('1234..5678');\nconst { value: balance } = await client.rpc.getBalance(wallet).send();\n```\n\n
\n\n\nA Kit client is an immutable JavaScript object built by chaining `.use()` calls. Each plugin adds capabilities to the client — like signer roles, RPC access, transaction sending, or typed program instructions. Start with `createClient()` from `@solana/kit`, add signer plugins such as `signer(payer)`, then apply RPC bundles like `solanaDevnetRpc()` to install RPC, subscriptions, transaction planning, sending, and devnet airdrops. You may then extend it with program plugins like `systemProgram()` and `tokenProgram()` to add typed access to the accounts and instructions of those programs.\n\nThe rest of this guide uses a client for the Kit examples. To learn more about the plugin system, see [Plugins](/docs/plugins).\n\n## Fetching and decoding accounts\n\nFetching onchain accounts is as simple as calling the appropriate RPC method on the client. Kit also provides helper functions like `fetchEncodedAccount`, which returns a `MaybeAccount` object with an `exists` boolean to indicate whether the account is present onchain:\n\n\n
\n\n```ts title=\"Web3.js\"\nimport { PublicKey } from '@solana/web3.js';\n\nconst wallet = new PublicKey('1234..5678');\nconst account = await connection.getAccountInfo(wallet);\n```\n\n```ts twoslash title=\"Kit\"\nimport { address, assertAccountExists, fetchEncodedAccount } from '@solana/kit';\n// ---cut-start---\nimport { createClient, generateKeyPairSigner } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signer } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nconst payer = await generateKeyPairSigner();\nconst client = createClient().use(signer(payer)).use(solanaDevnetRpc()).use(systemProgram());\n// ---cut-end---\n\nconst wallet = address('1234..5678');\nconst account = await fetchEncodedAccount(client.rpc, wallet);\nassertAccountExists(account);\naccount.data satisfies Uint8Array;\n```\n\n
\n\n\nTo decode raw account data, Kit provides a composable serialization library called **codecs**. You can define a codec for any account type by combining primitives:\n\n```ts twoslash title=\"Kit\"\nimport {\n address,\n Address,\n addCodecSizePrefix,\n getAddressCodec,\n getStructCodec,\n getU32Codec,\n getU8Codec,\n getUtf8Codec,\n} from '@solana/kit';\n\ntype Person = {\n age: number;\n discriminator: number;\n name: string;\n wallet: Address;\n};\n\nconst personCodec = getStructCodec([\n ['discriminator', getU8Codec()], // A single-byte account discriminator.\n ['wallet', getAddressCodec()], // A 32-byte account address.\n ['age', getU8Codec()], // An 8-bit unsigned integer.\n ['name', addCodecSizePrefix(getUtf8Codec(), getU32Codec())], // A UTF-8 string with a 32-bit length prefix.\n]);\n\nconst bytes = personCodec.encode({\n age: 42,\n discriminator: 0,\n name: 'Alice',\n wallet: address('1234..5678'),\n});\n```\n\n[You can read more about codecs here](/docs/advanced-guides/codecs).\n\nOnce you have a codec, you can use `decodeAccount` to transform an encoded account into a decoded one:\n\n```ts twoslash title=\"Kit\"\nimport { address, decodeAccount, fetchEncodedAccount } from '@solana/kit';\n// ---cut-start---\nimport {\n Address,\n createSolanaRpc,\n addCodecSizePrefix,\n getAddressCodec,\n getStructCodec,\n getU32Codec,\n getU8Codec,\n getUtf8Codec,\n} from '@solana/kit';\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\ntype Person = {\n age: number;\n discriminator: number;\n name: string;\n wallet: Address;\n};\nconst personCodec = getStructCodec([\n ['discriminator', getU8Codec()],\n ['wallet', getAddressCodec()],\n ['age', getU8Codec()],\n ['name', addCodecSizePrefix(getUtf8Codec(), getU32Codec())],\n]);\n// ---cut-end---\n\nconst wallet = address('1234..5678');\nconst account = await fetchEncodedAccount(rpc, wallet);\nconst decodedAccount = decodeAccount(account, personCodec);\n\nif (decodedAccount.exists) {\n decodedAccount.data satisfies Person;\n}\n```\n\n## Using program libraries\n\nFortunately, you don't need to create a custom codec for every account. Kit provides client libraries for many popular Solana programs, [generated via Codama](https://github.com/codama-idl/codama), ensuring a consistent structure across them. These libraries can be used as standalone imports or as client plugins.\n\nAs client plugins, they add typed `.accounts` and `.instructions` namespaces to your client. For example, here's how to fetch and decode a `Nonce` account using the System program:\n\n\n
\n\n```ts title=\"Web3.js\"\nimport { NonceAccount, PublicKey } from '@solana/web3.js';\n\nconst wallet = new PublicKey('1234..5678');\nconst accountInfo = await connection.getAccountInfo(wallet);\nconst nonce = NonceAccount.fromAccountData(accountInfo.data);\n```\n\n```ts twoslash title=\"Kit\"\nimport { address } from '@solana/kit';\n// ---cut-start---\nimport { createClient, generateKeyPairSigner } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signer } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nconst payer = await generateKeyPairSigner();\nconst client = createClient().use(signer(payer)).use(solanaDevnetRpc()).use(systemProgram());\n// ---cut-end---\n\nconst nonce = await client.system.accounts.nonce.fetch(address('1234..5678'));\n```\n\n
\n\n\nThey can also be used as standalone functions without a client:\n\n```ts twoslash title=\"Kit\"\nimport { address } from '@solana/kit';\nimport { fetchNonce } from '@solana-program/system';\n// ---cut-start---\nimport { createSolanaRpc } from '@solana/kit';\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\n// ---cut-end---\n\nconst account = await fetchNonce(rpc, address('1234..5678'));\n```\n\n[Check out the \"Available plugins\" page](/docs/plugins/available-plugins) for a list of available program libraries compatible with Kit.\n\n## Creating instructions\n\nProgram libraries also provide functions for creating instructions. With a client, you can create instructions through the program's typed namespace:\n\n\n
\n\n```ts title=\"Web3.js\"\nimport { PublicKey, SystemProgram } from '@solana/web3.js';\n\nconst transferSol = SystemProgram.transfer({\n fromPubkey: new PublicKey('2222..2222'),\n toPubkey: new PublicKey('3333..3333'),\n lamports: 1_000_000_000, // 1 SOL.\n});\n```\n\n```ts twoslash title=\"Kit\"\nimport { address } from '@solana/kit';\n// ---cut-start---\nimport { createClient, generateKeyPairSigner } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signer } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nconst payer = await generateKeyPairSigner();\nconst client = createClient().use(signer(payer)).use(solanaDevnetRpc()).use(systemProgram());\n// ---cut-end---\n\nconst transferSol = client.system.instructions.transferSol({\n source: client.payer,\n destination: address('3333..3333'),\n amount: 1_000_000_000, // 1 SOL.\n});\n```\n\n
\n\n\nWithout a client, you can use the standalone instruction helpers directly. In this case, Kit uses `TransactionSigner` objects for accounts that need to sign. This allows signers to be extracted from built transactions later, enabling automatic transaction signing without manually tracking which keys need to sign.\n\n```ts twoslash title=\"Kit\"\nimport { address, generateKeyPairSigner } from '@solana/kit';\nimport { getTransferSolInstruction } from '@solana-program/system';\n\nconst source = await generateKeyPairSigner();\nconst transferSol = getTransferSolInstruction({\n source,\n destination: address('3333..3333'),\n amount: 1_000_000_000, // 1 SOL.\n});\n```\n\n## Sending transactions\n\nIn Web3.js, sending a transaction involves creating a `Transaction` object, adding instructions, signing it, and sending it. Kit clients reduce this to a single call:\n\n\n
\n\n```ts title=\"Web3.js\"\nimport {\n Keypair,\n PublicKey,\n sendAndConfirmTransaction,\n SystemProgram,\n Transaction,\n} from '@solana/web3.js';\n\nconst payer = Keypair.generate();\n\nconst transaction = new Transaction().add(\n SystemProgram.transfer({\n fromPubkey: payer.publicKey,\n toPubkey: new PublicKey('3333..3333'),\n lamports: 1_000_000_000,\n }),\n);\n\nconst signature = await sendAndConfirmTransaction(connection, transaction, [payer]);\n```\n\n```ts twoslash title=\"Kit\"\nimport { address } from '@solana/kit';\n// ---cut-start---\nimport { createClient, generateKeyPairSigner } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signer } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nconst payer = await generateKeyPairSigner();\nconst client = createClient().use(signer(payer)).use(solanaDevnetRpc()).use(systemProgram());\n// ---cut-end---\n\nconst result = await client.system.instructions\n .transferSol({\n source: client.payer,\n destination: address('3333..3333'),\n amount: 1_000_000_000,\n })\n .sendTransaction();\n\nconst signature = result.context.signature;\n```\n\n
\n\n\nWith a client, building the transaction message, setting the fee payer, fetching a recent blockhash, signing, sending, and confirming are all handled for you.\n\nYou can also send multiple instructions as a single atomic transaction using `client.sendTransaction([...])`:\n\n```ts twoslash title=\"Kit\"\nimport { address } from '@solana/kit';\n// ---cut-start---\nimport { createClient, generateKeyPairSigner } from '@solana/kit';\nimport { solanaDevnetRpc } from '@solana/kit-plugin-rpc';\nimport { signer } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nconst payer = await generateKeyPairSigner();\nconst client = createClient().use(signer(payer)).use(solanaDevnetRpc()).use(systemProgram());\n// ---cut-end---\n\nawait client.sendTransaction([\n client.system.instructions.transferSol({\n source: client.payer,\n destination: address('3333..3333'),\n amount: 500_000_000,\n }),\n client.system.instructions.transferSol({\n source: client.payer,\n destination: address('4444..4444'),\n amount: 500_000_000,\n }),\n]);\n```\n\nFor full control over each of these steps, you can build transactions manually. Kit uses an immutable transaction model where each helper returns a new transaction object with an updated type. The `pipe` function lets you chain these helpers together:\n\n```ts twoslash title=\"Kit\"\nimport {\n appendTransactionMessageInstructions,\n assertIsTransactionWithBlockhashLifetime,\n createTransactionMessage,\n getSignatureFromTransaction,\n pipe,\n sendAndConfirmTransactionFactory,\n setTransactionMessageFeePayerSigner,\n setTransactionMessageLifetimeUsingBlockhash,\n signTransactionMessageWithSigners,\n} from '@solana/kit';\nimport { getCreateAccountInstruction } from '@solana-program/system';\nimport { getInitializeMintInstruction, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';\n// ---cut-start---\nimport {\n address,\n createSolanaRpc,\n createSolanaRpcSubscriptions,\n generateKeyPairSigner,\n} from '@solana/kit';\nconst rpc = createSolanaRpc('https://api.devnet.solana.com');\nconst rpcSubscriptions = createSolanaRpcSubscriptions('wss://api.devnet.solana.com');\nconst space = null as unknown as Parameters[0]['space'];\nconst lamports = null as unknown as Parameters[0]['lamports'];\n// ---cut-end---\n\n// Create signers — Kit uses the native CryptoKeyPair API for secure key management.\nconst [payer, mint] = await Promise.all([generateKeyPairSigner(), generateKeyPairSigner()]);\n\n// Create instructions — signers are attached directly to instructions.\nconst createAccount = getCreateAccountInstruction({\n payer,\n newAccount: mint,\n space,\n lamports,\n programAddress: TOKEN_PROGRAM_ADDRESS,\n});\nconst initializeMint = getInitializeMintInstruction({\n mint: mint.address,\n mintAuthority: address('1234..5678'),\n decimals: 2,\n});\n\n// Build the transaction message.\nconst { value: latestBlockhash } = await rpc.getLatestBlockhash().send();\nconst transactionMessage = pipe(\n createTransactionMessage({ version: 0 }),\n (tx) => setTransactionMessageFeePayerSigner(payer, tx),\n (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),\n (tx) => appendTransactionMessageInstructions([createAccount, initializeMint], tx),\n);\n\n// Sign — signers are extracted automatically from the transaction message.\nconst signedTransaction = await signTransactionMessageWithSigners(transactionMessage);\n\n// Send and confirm.\nassertIsTransactionWithBlockhashLifetime(signedTransaction);\nconst sendAndConfirm = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });\nconst signature = getSignatureFromTransaction(signedTransaction);\nawait sendAndConfirm(signedTransaction, { commitment: 'confirmed' });\n```\n\nA few things to note about the manual approach:\n\n- **Signers**: Kit uses `TransactionSigner` objects (highlighted above) instead of raw keypairs. Since signers are attached to instructions and the fee payer, `signTransactionMessageWithSigners` can sign the transaction automatically without needing to pass signers separately. [Read more about signers here](/docs/advanced-guides/signers).\n- **Immutability**: Each transaction helper returns a new object with a narrower type, ensuring that required fields (fee payer, lifetime, etc.) are set before the transaction can be signed or sent. The `pipe` function chains these transformations together.\n- **Signatures**: Transaction signatures are deterministically known before sending. The `getSignatureFromTransaction` helper extracts the signature from the signed transaction, and `sendAndConfirm` does not return it.\n\n## Closing words\n\nWe've now explored the key differences between Web3.js and Kit, giving you a solid foundation for upgrading your project. Since Kit is a complete rewrite, there's no simple step-by-step migration guide, and the process may take some time.\n\nTo ease the transition, Kit provides a `@solana/compat` package, which allows for incremental migration. This package includes functions that convert core types — such as public keys and transactions — between Web3.js and Kit. This means you can start integrating Kit without having to refactor your entire project at once.\n\n```ts twoslash title=\"Kit\"\nimport { Keypair, PublicKey } from '@solana/web3.js';\nimport { createSignerFromKeyPair } from '@solana/kit';\nimport {\n fromLegacyKeypair,\n fromLegacyPublicKey,\n fromLegacyTransactionInstruction,\n fromVersionedTransaction,\n} from '@solana/compat';\n// ---cut-start---\nconst transactionInstruction = null as unknown as Parameters<\n typeof fromLegacyTransactionInstruction\n>[0];\nconst versionedTransaction = null as unknown as Parameters[0];\n// ---cut-end---\n\n// Convert `PublicKeys`.\nconst address = fromLegacyPublicKey(new PublicKey('1234..5678'));\n\n// Convert `Keypairs`.\nconst cryptoKeypair = await fromLegacyKeypair(Keypair.generate());\nconst signer = await createSignerFromKeyPair(cryptoKeypair);\n\n// Convert `TransactionInstruction`.\nconst instruction = fromLegacyTransactionInstruction(transactionInstruction);\n\n// Convert `VersionedTransaction`.\nconst transaction = fromVersionedTransaction(versionedTransaction);\n```\n\nIf you're using a Kit client, the upgrade is even more straightforward — the client-based API is conceptually closer to Web3.js's `Connection` model while still giving you the benefits of Kit's modular architecture. Check out the [Getting Started](/docs/getting-started) tutorial to see the client-based approach in action or explore [Plugins](/docs/plugins) to learn more about the plugin system.\n" }, { "path": "docs/content/home/example-codecs.mdx", "content": "---\ntitle: Codecs Example\n---\n\n{/* Please keep visible code between 4 to 8 lines of code. */}\n\n```ts\nconst personCodec = getStructCodec([\n ['age', getU8Codec()],\n ['name', addCodecSizePrefix(getUtf8Codec(), getU16Codec())],\n]);\n\nconst bytes = personCodec.encode({ age: 30, name: 'Alice' });\nconst person = personCodec.decode(bytes);\n```\n" }, { "path": "docs/content/home/example-rpc-subscriptions.mdx", "content": "---\ntitle: RPC Subscriptions Example\n---\n\n{/* Please keep visible code between 4 to 8 lines of code. */}\n\n```ts\nconst rpcSubscriptions = createSolanaRpcSubscriptions('ws://api.mainnet-beta.solana.com');\nconst accountNotifications = await rpcSubscriptions\n .accountNotifications(myAccount, { commitment: 'confirmed' })\n .subscribe({ abortSignal: abortController.signal });\n\nfor await (const accountNotification of accountNotifications) {\n console.log(accountNotification);\n}\n```\n" }, { "path": "docs/content/home/example-rpc.mdx", "content": "---\ntitle: RPC Example\n---\n\n{/* Please keep visible code between 4 to 8 lines of code. */}\n\n```ts\nconst rpc = createSolanaRpc('https://api.mainnet-beta.solana.com');\n\nconst { value: balance } = await rpc.getBalance(myWallet).send();\nconst { value: accountInfo } = await rpc.getAccountInfo(myAccount).send();\nconst { value: latestBlockhash } = await rpc.getLatestBlockhash().send();\n```\n" }, { "path": "docs/content/home/example-signers.mdx", "content": "---\ntitle: Signers Example\n---\n\n{/* Please keep visible code between 4 to 8 lines of code. */}\n\n```ts\nconst keypairSigner = await generateKeyPairSigner();\n\nconst walletSigner = useWalletAccountTransactionSigner(wallet, 'solana:mainnet-beta');\n\nconst noopSigner = createNoopSigner(myAddress);\n```\n" }, { "path": "docs/content/home/example-solana-programs.mdx", "content": "---\ntitle: Solana Programs Example\n---\n\n{/* Please keep visible code between 4 to 8 lines of code. */}\n\n```ts\nimport { getTransferSolInstruction } from '@solana-program/system';\nconst transferSol = getTransferSolInstruction({ source, destination, amount });\n\nimport { fetchMint } from '@solana-program/token';\nconst mintAccount = await fetchMint(rpc, mintAddress);\n```\n" }, { "path": "docs/content/home/example-transactions.mdx", "content": "---\ntitle: Transactions Example\n---\n\n{/* Please keep visible code between 4 to 8 lines of code. */}\n\n```ts\nconst transactionMessage = pipe(\n createTransactionMessage({ version: 0 }),\n (tx) => setTransactionMessageFeePayerSigner(payer, tx),\n (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),\n (tx) => appendTransactionMessageInstructions([createAccountIx, initializeMintIx], tx),\n);\n```\n" }, { "path": "docs/content/recipes/airdropping-tokens.mdx", "content": "---\ntitle: Airdropping tokens\ndescription: Airdrop tokens to many wallets using parallel transaction plans\n---\n\nThis recipe airdrops a freshly minted SPL token to many recipient wallets at once. It demonstrates how to compose an [instruction plan](/docs/guides/sending-multiple-transactions) that creates the mint sequentially first and then mints to every recipient in parallel — letting Kit pack the work into as few transactions as possible and send the parallel batches concurrently.\n\n## Set up a client\n\nInstall Kit and the plugins you need.\n\n```package-install\n@solana/kit @solana/kit-plugin-rpc @solana/kit-plugin-signer @solana-program/token\n```\n\nCompose a client with a generated signer, a local RPC connection, an airdrop to fund the signer, and the Token program plugin. Make sure a local validator is running (`solana-test-validator`) before this code executes.\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(100_000_000_000n)))\n .use(tokenProgram());\n```\n\nThe signer is funded with 100 SOL because creating ATAs costs a small amount of rent for each recipient.\n\n## Generate the recipients\n\nFor the demo, generate 100 random destination addresses up front. In a real airdrop, this list would come from a database, a CSV, or some other source.\n\n```ts twoslash\nimport { generateKeyPairSigner } from '@solana/kit';\n\nconst recipients = await Promise.all(\n Array.from({ length: 100 }, async () => (await generateKeyPairSigner()).address),\n);\n```\n\n## Build the airdrop plan\n\nCompose the work as a `sequentialInstructionPlan` whose first child creates the mint and whose second child is a `parallelInstructionPlan` containing one mint-to-ATA plan per recipient.\n\n```ts twoslash\nimport {\n Address,\n generateKeyPairSigner,\n parallelInstructionPlan,\n sequentialInstructionPlan,\n} from '@solana/kit';\nconst recipients = null as unknown as Address[];\n// ---cut-start---\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(100_000_000_000n)))\n .use(tokenProgram());\n// ---cut-end---\nconst mint = await generateKeyPairSigner();\n\nconst instructionPlan = sequentialInstructionPlan([\n client.token.instructions.createMint({\n newMint: mint,\n decimals: 6,\n mintAuthority: client.identity.address,\n }),\n parallelInstructionPlan(\n await Promise.all(\n recipients.map((owner) =>\n client.token.instructions.mintToATA({\n mint: mint.address,\n owner,\n mintAuthority: client.identity,\n amount: 1_000n * 10n ** 6n, // 1,000 tokens\n decimals: 6,\n }),\n ),\n ),\n ),\n]);\n```\n\nThe mint must exist before any recipient can receive tokens, which is why the outer plan is sequential. Each `mintToATA` is independent of the others, so wrapping them in a `parallelInstructionPlan` lets Kit run them concurrently. The Token plugin's `mintToATA` is asynchronous because it derives each recipient's ATA address up front, so wrap the whole list in a single `Promise.all`.\n\n## Send and inspect the results\n\n`client.sendTransactions(plan)` plans, signs, sends, and confirms every transaction in the tree. Wrap the call in [`passthroughFailedTransactionPlanExecution`](/docs/advanced-guides/errors#walking-transaction-plan-results) so a failure on one transaction does not throw — you keep the full result tree and can decide what to do per recipient.\n\n```ts twoslash\nimport {\n flattenTransactionPlanResult,\n InstructionPlan,\n passthroughFailedTransactionPlanExecution,\n} from '@solana/kit';\nconst instructionPlan = null as unknown as InstructionPlan;\n// ---cut-start---\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(100_000_000_000n)))\n .use(tokenProgram());\n// ---cut-end---\nconst result = await passthroughFailedTransactionPlanExecution(\n client.sendTransactions(instructionPlan),\n);\n\nfor (const [index, single] of flattenTransactionPlanResult(result).entries()) {\n if (single.status === 'successful') {\n console.log(`#${index} ✅ ${single.context.signature}`);\n } else if (single.status === 'failed') {\n console.error(`#${index} ❌ ${single.error.message}`);\n } else {\n console.warn(`#${index} ⏭️ canceled`);\n }\n}\n```\n\n`flattenTransactionPlanResult` collapses the tree into one entry per transaction in the order they were planned, so iterating the array is enough to log each outcome individually. For a single bottom-line view across the whole airdrop, [`summarizeTransactionPlanResult`](/docs/advanced-guides/errors#walking-transaction-plan-results) returns success/failure/cancellation counts and a top-level `successful` boolean.\n\n## Next steps\n\n- [Sending multiple transactions](/docs/guides/sending-multiple-transactions) — the full guide on multi-transaction operations and instruction plan composition.\n- [Advanced guides — Errors](/docs/advanced-guides/errors) — deep dive on `TransactionPlanResult`, walking failed trees, and program-specific errors.\n- [Creating a token](/recipes/creating-a-token) — the simpler single-recipient version of this flow.\n" }, { "path": "docs/content/recipes/creating-a-token.mdx", "content": "---\ntitle: Creating a token\ndescription: Create a new SPL token mint, mint tokens, and transfer them\n---\n\nThis recipe walks through the full lifecycle of an SPL token: creating a mint, minting tokens to your own associated token account (ATA), and transferring some to another wallet. It runs against a local validator so you can experiment without spending mainnet SOL.\n\n## Set up a client\n\nInstall Kit and the plugins you need.\n\n```package-install\n@solana/kit @solana/kit-plugin-rpc @solana/kit-plugin-signer @solana-program/token\n```\n\nCompose a client with a generated signer, a local RPC connection, an airdrop to fund the signer, and the Token program plugin. Make sure a local validator is running (`solana-test-validator`) before this code executes.\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)))\n .use(tokenProgram());\n```\n\n## Create the mint\n\nGenerate a fresh signer for the mint account and ask the Token program plugin to build a `createMint` instruction plan. The plan creates the mint account, funds it for rent exemption, and initializes it as a Token mint — all in one atomic operation.\n\n```ts twoslash\nimport { generateKeyPairSigner } from '@solana/kit';\n// ---cut-start---\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)))\n .use(tokenProgram());\n// ---cut-end---\nconst mint = await generateKeyPairSigner();\n\nawait client.token.instructions\n .createMint({\n newMint: mint,\n decimals: 9,\n mintAuthority: client.identity.address,\n })\n .sendTransaction();\n\nconsole.log(`🎉 Mint created: ${mint.address}`);\n```\n\nThe mint authority is the signer allowed to mint new tokens later. Setting it to `client.identity.address` makes the current client's identity the authority, which is what you want for a recipe like this one.\n\n## Mint tokens to your ATA\n\nTokens live in associated token accounts (ATAs) — one ATA per `(owner, mint)` pair. The plugin's `mintToATA` helper derives the ATA address, creates it if it does not exist yet, and mints tokens to it in a single instruction plan.\n\n```ts twoslash\nimport { Address } from '@solana/kit';\nconst mintAddress = null as unknown as Address;\n// ---cut-start---\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)))\n .use(tokenProgram());\n// ---cut-end---\nawait client.token.instructions\n .mintToATA({\n mint: mintAddress,\n owner: client.identity.address,\n mintAuthority: client.identity,\n amount: 1_000n * 10n ** 9n, // 1,000 tokens with 9 decimals\n decimals: 9,\n })\n .sendTransaction();\n```\n\n`mintToATA` is asynchronous because it derives the ATA address before building the plan, but the `.sendTransaction()` shortcut is exposed on the returned promise itself — a single `await` on the call is enough. Pass the same `decimals` you used when creating the mint; the plugin uses it as a safety check to make sure you are minting against the mint you think you are.\n\n## Transfer tokens to a recipient\n\nSending tokens to another wallet follows the same pattern as minting: the plugin derives both the source and destination ATAs, creates the destination if it doesn't exist, and issues the transfer.\n\n```ts twoslash\nimport { address, Address } from '@solana/kit';\nconst mintAddress = null as unknown as Address;\n// ---cut-start---\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { tokenProgram } from '@solana-program/token';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)))\n .use(tokenProgram());\n// ---cut-end---\nconst recipient = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\n\nawait client.token.instructions\n .transferToATA({\n mint: mintAddress,\n authority: client.identity,\n recipient,\n amount: 100n * 10n ** 9n, // 100 tokens\n decimals: 9,\n })\n .sendTransaction();\n```\n\nThe `authority` is the owner of the source tokens, which here is the same identity that minted them. The plugin pulls tokens out of `authority`'s ATA for the given mint, creates the recipient's ATA if needed, and deposits the tokens.\n\n## Next steps\n\n- [Using program plugins](/docs/guides/using-program-plugins) — explore everything `client.token` and other program namespaces expose.\n- [Fetching accounts](/docs/guides/fetching-accounts) — read the mint and token account balances back from the chain.\n- [Airdropping tokens](/recipes/airdropping-tokens) — extend this recipe to many recipients in parallel.\n" }, { "path": "docs/content/recipes/index.mdx", "content": "---\ntitle: Recipes\ndescription: Quick how-to guides for common Solana tasks\n---\n\nRecipes are short, copy-pasteable walkthroughs for specific tasks. Each one starts with a working setup, then walks through the steps you need to ship a feature — sending SOL, creating a token, airdropping tokens to many wallets, and so on.\n\nIf you are new to Kit, start with the [Getting started](/docs/getting-started) tutorial first. If you are looking for deeper, reference-style coverage, the [Guides](/docs/guides) section is the next step. Recipes sit between the two: focused, end-to-end snippets you can drop into a project today.\n" }, { "path": "docs/content/recipes/meta.json", "content": "{\n \"title\": \"Recipes\",\n \"root\": true,\n \"pages\": [\"...\", \"transferring-sol\", \"creating-a-token\", \"airdropping-tokens\"]\n}\n" }, { "path": "docs/content/recipes/transferring-sol.mdx", "content": "---\ntitle: Transferring SOL\ndescription: Send SOL from one account to another with error handling\n---\n\nThis recipe walks through sending SOL from your client's payer to another address. It uses a local validator so you can run it end-to-end without touching real funds, and shows how to surface a useful error when a transfer fails.\n\n## Set up a client\n\nInstall Kit and the plugins you need.\n\n```package-install\n@solana/kit @solana/kit-plugin-rpc @solana/kit-plugin-signer @solana-program/system\n```\n\nCompose a client with a generated signer, a local RPC connection, an airdrop to fund the signer, and the System program plugin. Make sure a local validator is running (`solana-test-validator`) before this code executes.\n\n```ts twoslash\nimport { createClient, lamports } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\n\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)))\n .use(systemProgram());\n```\n\n## Send the transfer\n\nUse `client.system.instructions.transferSol` to build the transfer instruction, then call `.sendTransaction()` to plan, sign, send, and confirm it in one step.\n\n```ts twoslash\nimport { address, lamports } from '@solana/kit';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)))\n .use(systemProgram());\n// ---cut-end---\nconst recipient = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\n\nconst result = await client.system.instructions\n .transferSol({\n source: client.payer,\n destination: recipient,\n amount: lamports(10_000_000n), // 0.01 SOL\n })\n .sendTransaction();\n\nconsole.log(`✅ ${result.context.signature}`);\n```\n\nThe shortcut is equivalent to passing the instruction to `client.sendTransaction([...])`. Reach for the array form when you want to combine several instructions into a single atomic transaction.\n\n## Handle errors\n\nWhen a transfer fails, `client.sendTransaction(...)` throws a [`SolanaError`](/docs/advanced-guides/errors) with the `SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION` code. Wrapping the call lets you surface a useful message and inspect the underlying program error.\n\n```ts twoslash\nimport {\n address,\n isSolanaError,\n lamports,\n SingleTransactionPlanResult,\n SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION,\n} from '@solana/kit';\nimport { getSystemErrorMessage, isSystemError } from '@solana-program/system';\n// ---cut-start---\nimport { createClient } from '@solana/kit';\nimport { solanaLocalRpc } from '@solana/kit-plugin-rpc';\nimport { airdropSigner, generatedSigner } from '@solana/kit-plugin-signer';\nimport { systemProgram } from '@solana-program/system';\nconst client = await createClient()\n .use(generatedSigner())\n .use(solanaLocalRpc())\n .use(airdropSigner(lamports(1_000_000_000n)))\n .use(systemProgram());\nconst recipient = address('GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ');\n// ---cut-end---\ntry {\n await client.system.instructions\n .transferSol({\n source: client.payer,\n destination: recipient,\n amount: lamports(10_000_000n),\n })\n .sendTransaction();\n} catch (e) {\n if (!isSolanaError(e, SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION)) throw e;\n\n const result = e.context.transactionPlanResult as SingleTransactionPlanResult;\n const transactionMessage = result.context.message ?? result.plannedMessage;\n const cause = e.cause as Error;\n\n if (isSystemError(cause, transactionMessage)) {\n console.error(`System program error: ${getSystemErrorMessage(cause.context.code)}`);\n } else {\n console.error('Transfer failed:', e.message);\n }\n}\n```\n\n`error.cause` carries the underlying error, and `error.context.transactionPlanResult` carries the planned transaction message. Pairing them with `isSystemError` and `getSystemErrorMessage` from `@solana-program/system` turns an opaque program error code into a human-readable message — invaluable when something like an underfunded source account causes the transfer to fail.\n\n## Next steps\n\n- [Sending transactions](/docs/guides/sending-transactions) — the full guide on single transactions, including planning and configuration.\n- [Advanced guides — Errors](/docs/advanced-guides/errors) — deep dive on `SolanaError` codes and program-specific error parsing.\n" }, { "path": "docs/next.config.mjs", "content": "import { createMDX } from 'fumadocs-mdx/next';\n\nconst withMDX = createMDX();\n\nconst docsRouteRedirects = [\n ['compatible-clients', 'plugins/available-plugins'],\n ['concepts', 'advanced-guides'],\n ['concepts/codecs', 'advanced-guides/codecs'],\n ['concepts/errors', 'advanced-guides/errors'],\n ['concepts/instruction-plans', 'advanced-guides/instruction-plans'],\n ['concepts/keypairs', 'advanced-guides/keypairs'],\n ['concepts/offchain-messages', 'advanced-guides/offchain-messages'],\n ['concepts/rpc', 'guides/rpc'],\n ['concepts/rpc-subscriptions', 'guides/rpc-subscriptions'],\n ['concepts/signers', 'advanced-guides/signers'],\n ['concepts/transactions', 'advanced-guides/transactions'],\n ['getting-started/setup', 'advanced-guides/kit-without-a-client'],\n ['getting-started/signers', 'advanced-guides/kit-without-a-client'],\n ['getting-started/instructions', 'advanced-guides/kit-without-a-client'],\n ['getting-started/build-transaction', 'advanced-guides/kit-without-a-client'],\n ['getting-started/send-transaction', 'advanced-guides/kit-without-a-client'],\n ['getting-started/fetch-account', 'advanced-guides/kit-without-a-client'],\n];\n\nconst createDocsRedirects = () =>\n docsRouteRedirects.flatMap(([sourcePath, destinationPath]) => [\n {\n source: `/docs/${sourcePath}`,\n destination: `/docs/${destinationPath}`,\n permanent: true,\n },\n {\n source: `/docs/${sourcePath}.mdx`,\n destination: `/docs/${destinationPath}.mdx`,\n permanent: true,\n },\n ]);\n\n/** @type {import('next').NextConfig} */\nconst config = {\n redirects: async () => createDocsRedirects(),\n reactStrictMode: true,\n serverExternalPackages: ['twoslash', 'typescript'],\n rewrites: async () => {\n return [\n {\n source: '/api/:path*.mdx',\n destination: '/llms.mdx/api/:path*',\n },\n {\n source: '/docs/:path*.mdx',\n destination: '/llms.mdx/docs/:path*',\n },\n {\n source: '/recipes/:path*.mdx',\n destination: '/llms.mdx/recipes/:path*',\n },\n ];\n },\n};\n\nexport default withMDX(config);\n" }, { "path": "docs/package.json", "content": "{\n \"name\": \"@solana/kit-docs\",\n \"version\": \"0.0.0\",\n \"private\": true,\n \"scripts\": {\n \"build\": \"NODE_OPTIONS='--max-old-space-size=8192' next build\",\n \"dev\": \"NODE_OPTIONS=\\\"--no-experimental-webstorage\\\" next dev --turbo\",\n \"start\": \"next start\",\n \"postinstall\": \"fumadocs-mdx\",\n \"prebuild\": \"./build-api-docs.sh\",\n \"predev\": \"./build-api-docs.sh\"\n },\n \"dependencies\": {\n \"@inkeep/cxkit-react\": \"^0.5.116\",\n \"@radix-ui/react-popover\": \"^1.1.15\",\n \"class-variance-authority\": \"^0.7.1\",\n \"fumadocs-core\": \"15.2.10\",\n \"fumadocs-docgen\": \"^2.1.0\",\n \"fumadocs-mdx\": \"12.0.3\",\n \"fumadocs-twoslash\": \"^3.1.1\",\n \"fumadocs-ui\": \"15.2.10\",\n \"lucide-react\": \"^0.563.0\",\n \"next\": \"^16.1.7\",\n \"react\": \"^19.2.4\",\n \"react-dom\": \"^19.2.4\",\n \"tailwind-merge\": \"^3.4.0\",\n \"twoslash\": \"^0.3.6\"\n },\n \"devDependencies\": {\n \"@solana-program/address-lookup-table\": \"^0.11.0\",\n \"@solana-program/compute-budget\": \"^0.15.0\",\n \"@solana-program/memo\": \"^0.11.0\",\n \"@solana-program/system\": \"^0.12.0\",\n \"@solana-program/token\": \"^0.12.0\",\n \"@solana/compat\": \"6.8.0\",\n \"@solana/kit\": \"6.8.0\",\n \"@solana/kit-plugin-litesvm\": \"^0.10.0\",\n \"@solana/kit-plugin-rpc\": \"^0.11.0\",\n \"@solana/kit-plugin-signer\": \"^0.10.0\",\n \"@solana/react\": \"6.8.0\",\n \"@solana/wallet-account-signer\": \"6.8.0\",\n \"@solana/web3.js\": \"^1.98.4\",\n \"@solana/webcrypto-ed25519-polyfill\": \"6.8.0\",\n \"@wallet-standard/ui\": \"^1.0.2\",\n \"@tailwindcss/postcss\": \"^4.2.2\",\n \"@types/mdx\": \"^2.0.13\",\n \"@types/node\": \"25.4.0\",\n \"@types/react\": \"^19.2.14\",\n \"@types/react-dom\": \"^19.2.3\",\n \"eslint\": \"^10\",\n \"eslint-config-next\": \"^16.1.6\",\n \"postcss\": \"^8.5.14\",\n \"tailwindcss\": \"^4.2.1\",\n \"typescript\": \"^5.9.3\",\n \"vercel\": \"^50.22.1\"\n },\n \"pnpm\": {\n \"overrides\": {\n \"js-yaml@<3.14.2\": \"^3.14.2\",\n \"@vercel/node>path-to-regexp\": \"^6.3.0\",\n \"@vercel/remix-builder>path-to-regexp\": \"^6.3.0\"\n }\n },\n \"packageManager\": \"pnpm@10.4.1\"\n}\n" }, { "path": "docs/postcss.config.mjs", "content": "export default {\n plugins: {\n '@tailwindcss/postcss': {},\n },\n};\n" }, { "path": "docs/source.config.ts", "content": "import { rehypeCodeDefaultOptions } from 'fumadocs-core/mdx-plugins';\nimport { remarkInstall } from 'fumadocs-docgen';\nimport { defineConfig, defineDocs } from 'fumadocs-mdx/config';\nimport { transformerTwoslash } from 'fumadocs-twoslash';\n\nexport const api = defineDocs({\n dir: 'content/api',\n docs: {\n postprocess: {\n includeProcessedMarkdown: true,\n },\n },\n});\n\nexport const docs = defineDocs({\n dir: 'content/docs',\n docs: {\n postprocess: {\n includeProcessedMarkdown: true,\n },\n },\n});\n\nexport const recipes = defineDocs({\n dir: 'content/recipes',\n docs: {\n postprocess: {\n includeProcessedMarkdown: true,\n },\n },\n});\n\nexport const home = defineDocs({\n dir: 'content/home',\n});\n\nexport default defineConfig({\n mdxOptions: {\n rehypeCodeOptions: {\n langs: [\n // FIXME(#403): If a popup itself contains a code fence in any language other than\n // `ts`, the Shiki highlighter will throw an error that it hasn't loaded that\n // language. Until we figure this out, preemptively load the `js` language.\n 'js',\n ],\n themes: {\n dark: 'github-dark',\n light: 'github-light',\n },\n transformers: [...(rehypeCodeDefaultOptions.transformers ?? []), transformerTwoslash()],\n },\n remarkPlugins: [() => remarkInstall({ persist: { id: 'package-install' } })],\n },\n});\n" }, { "path": "docs/src/app/(home)/layout.tsx", "content": "import type { ReactNode } from 'react';\nimport { HomeLayout, HomeLayoutProps } from 'fumadocs-ui/layouts/home';\nimport { baseOptions } from '@/app/layout.config';\n\nexport default function Layout({ children }: { children: ReactNode }) {\n const homeProps: HomeLayoutProps = {\n ...baseOptions,\n };\n\n return {children};\n}\n" }, { "path": "docs/src/app/(home)/page/code.tsx", "content": "'use client';\n\nimport React, { useContext } from 'react';\nimport { ExampleContext } from './example-context';\nimport { Play } from 'lucide-react';\n\ntype Props = Readonly<{\n examples: Record;\n}>;\n\nexport default function CodeSection({ examples }: Props) {\n const { example, progress, paused, resume } = useContext(ExampleContext);\n\n return (\n
\n
\n \n
\n {paused && (\n \n \n \n )}\n {examples[example]}\n \n \n
\n );\n}\n" }, { "path": "docs/src/app/(home)/page/cta.tsx", "content": "import { ThemedImage } from '@/lib/ThemedImage';\nimport DarkMascotInquisitiveImage from '@/public/mascots/dark-mascot-inquisitive.svg';\nimport LightMascotInquisitiveImage from '@/public/mascots/light-mascot-inquisitive.svg';\nimport { Link } from 'fumadocs-core/framework';\n\nexport default function CtaSection() {\n return (\n
\n
\n
\n \n
\n
\n

Would you like a tour?

\n

\n If you'd like to learn more about Kit but don't know where to start, worry not! A\n guided tour is available to help you get acquainted with the library and its main features.\n Through this tour, you'll end up setting your environment, creating a token account and\n fetching its data.\n

\n \n Get started\n \n
\n
\n
\n );\n}\n" }, { "path": "docs/src/app/(home)/page/example-context.tsx", "content": "'use client';\n\nimport { createContext, useEffect, useMemo, useRef, useState } from 'react';\n\nconst EXAMPLES = ['rpc', 'codecs', 'signers', 'transactions', 'rpc-subscriptions', 'solana-programs'] as const;\nconst TIMER_INTERVAL = 8000; // 8 seconds\n\nexport type ExampleKey = (typeof EXAMPLES)[number];\n\nexport const ExampleContext = createContext<{\n example: ExampleKey;\n setExample: (example: ExampleKey) => void;\n progress: number;\n resume: () => void;\n paused: boolean;\n}>({\n example: EXAMPLES[0],\n setExample: () => {},\n progress: 0,\n resume: () => {},\n paused: false,\n});\n\nexport function ExampleProvider({\n children,\n defaultExample,\n}: {\n children: React.ReactNode;\n defaultExample?: ExampleKey;\n}) {\n const [example, setExample] = useState(defaultExample ?? EXAMPLES[0]);\n const [progress, setProgress] = useState(0);\n const [paused, setPaused] = useState(false);\n\n const exampleIndex = useMemo(() => EXAMPLES.findIndex(e => e === example), [example]);\n const startTimeRef = useRef(performance.now());\n const rafRef = useRef(null);\n\n useEffect(() => {\n if (!paused) {\n function tick() {\n const now = performance.now();\n const elapsed = now - startTimeRef.current;\n const newProgress = Math.min(elapsed / TIMER_INTERVAL, 1);\n setProgress(newProgress);\n\n if (newProgress >= 1) {\n const nextIndex = (exampleIndex + 1) % EXAMPLES.length;\n setExample(EXAMPLES[nextIndex]);\n startTimeRef.current = now;\n setProgress(0);\n }\n\n rafRef.current = requestAnimationFrame(tick);\n }\n rafRef.current = requestAnimationFrame(tick);\n }\n return () => {\n if (rafRef.current !== null) {\n cancelAnimationFrame(rafRef.current);\n rafRef.current = null;\n }\n };\n }, [exampleIndex, paused]);\n\n const setExampleAndPause = (newExample: ExampleKey) => {\n setExample(newExample);\n setProgress(0);\n setPaused(true);\n startTimeRef.current = performance.now();\n };\n\n const resume = () => {\n startTimeRef.current = performance.now();\n setPaused(false);\n };\n\n return (\n \n {children}\n \n );\n}\n" }, { "path": "docs/src/app/(home)/page/features.tsx", "content": "'use client';\n\nimport { ThemedImage } from '@/lib/ThemedImage';\nimport DarkCodecsImage from '@/public/features/dark-codecs.png';\nimport DarkRpcSubscriptionsImage from '@/public/features/dark-rpc-subscriptions.png';\nimport DarkRpcImage from '@/public/features/dark-rpc.png';\nimport DarkSignersImage from '@/public/features/dark-signers.png';\nimport DarkSolanaProgramsImage from '@/public/features/dark-solana-programs.png';\nimport DarkTransactionsImage from '@/public/features/dark-transactions.png';\nimport LightCodecsImage from '@/public/features/light-codecs.png';\nimport LightRpcSubscriptionsImage from '@/public/features/light-rpc-subscriptions.png';\nimport LightRpcImage from '@/public/features/light-rpc.png';\nimport LightSignersImage from '@/public/features/light-signers.png';\nimport LightSolanaProgramsImage from '@/public/features/light-solana-programs.png';\nimport LightTransactionsImage from '@/public/features/light-transactions.png';\nimport { Link } from 'fumadocs-core/framework';\nimport { cn } from 'fumadocs-ui/utils/cn';\nimport { useContext } from 'react';\nimport { ExampleContext, ExampleKey } from './example-context';\nimport { StaticImageData } from 'next/image';\n\ntype Feature = {\n key: ExampleKey;\n label: string;\n description: string;\n href: string;\n image: Readonly<{\n dark: StaticImageData;\n light: StaticImageData;\n }>;\n};\n\nconst features: Feature[] = [\n {\n key: 'rpc',\n label: 'RPC',\n description: 'Configure your Solana RPC and send requests to send transactions or fetch data.',\n href: '/docs/guides/rpc',\n image: {\n dark: DarkRpcImage,\n light: LightRpcImage,\n },\n },\n {\n key: 'codecs',\n label: 'Codecs',\n description: 'Compose codecs together to encode and decode any value to and from a byte array.',\n href: '/docs/advanced-guides/codecs',\n image: {\n dark: DarkCodecsImage,\n light: LightCodecsImage,\n },\n },\n {\n key: 'signers',\n label: 'Signers',\n description: 'Create signer objects to sign transactions and/or messages with your wallets.',\n href: '/docs/advanced-guides/signers',\n image: {\n dark: DarkSignersImage,\n light: LightSignersImage,\n },\n },\n {\n key: 'transactions',\n label: 'Transactions',\n description: 'Gradually build transaction messages before compiling and sending them to the network.',\n href: '/docs/advanced-guides/transactions',\n image: {\n dark: DarkTransactionsImage,\n light: LightTransactionsImage,\n },\n },\n {\n key: 'rpc-subscriptions',\n label: 'RPC Subscriptions',\n description: 'Subscribe to RPC notifications such as account changes, slot updates, and more.',\n href: '/docs/guides/rpc-subscriptions',\n image: {\n dark: DarkRpcSubscriptionsImage,\n light: LightRpcSubscriptionsImage,\n },\n },\n {\n key: 'solana-programs',\n label: 'Solana Programs',\n description: 'Interact with various Solana programs using their Codama-generated SDKs.',\n href: '/docs/plugins/available-plugins',\n image: {\n dark: DarkSolanaProgramsImage,\n light: LightSolanaProgramsImage,\n },\n },\n];\n\nexport default function FeaturesSection() {\n const { example, setExample } = useContext(ExampleContext);\n const set = (key: ExampleKey) => () => setExample(key);\n\n return (\n
\n
\n {features.map(feature => (\n
\n \n \n
\n
\n \n {feature.label}\n \n

{feature.description}

\n
\n \n Learn more\n \n
\n
\n
\n ))}\n \n \n And many more...\n \n
\n );\n}\n" }, { "path": "docs/src/app/(home)/page/footer.tsx", "content": "import { ThemedImage } from '@/lib/ThemedImage';\nimport DarkFooter from '@/public/footer/dark-footer.svg';\nimport LightFooter from '@/public/footer/light-footer.svg';\nimport { Link } from 'fumadocs-core/framework';\n\nexport default function FooterSection() {\n const linkClassName = 'text-linen-600 hover:text-linen-800 dark:text-mauve-300 dark:hover:text-mauve-100';\n return (\n
\n
\n
\n \n Documentation\n \n \n API Reference\n \n \n Maintained by Anza\n \n
\n
\n \n
\n );\n}\n" }, { "path": "docs/src/app/(home)/page/hero.tsx", "content": "import { ThemedImage } from '@/lib/ThemedImage';\nimport DarkHeader from '@/public/header/dark-header.jpg';\nimport LightHeader from '@/public/header/light-header.jpg';\nimport Link from 'fumadocs-core/link';\n\nexport default function HeroSection() {\n return (\n
\n \n
\n
\n

\n Your JavaScript\n
\n SDK for Solana\n

\n \n Get started with Kit\n \n
\n
\n
\n );\n}\n" }, { "path": "docs/src/app/(home)/page.tsx", "content": "import { home } from '@/.source';\nimport React from 'react';\n\nimport { mdxComponents } from '../layout.config';\nimport HeroSection from './page/hero';\nimport CodeSection from './page/code';\nimport FeaturesSection from './page/features';\nimport CtaSection from './page/cta';\nimport FooterSection from './page/footer';\nimport { ExampleProvider } from './page/example-context';\n\nfunction getExamples(): Record {\n const examples: Record = {};\n home.docs.forEach(doc => {\n const match = doc.info.path.match(/^example-(.*)\\.mdx$/);\n if (match) {\n const MDXContent = doc.body;\n examples[match[1]] = ;\n }\n });\n return examples;\n}\n\nexport default function HomePage() {\n const examples = getExamples();\n return (\n
\n \n \n \n \n \n \n \n
\n );\n}\n" }, { "path": "docs/src/app/api/[[...slug]]/page.tsx", "content": "import { mdxComponents } from '@/app/layout.config';\nimport { LLMCopyButton, ViewOptions } from '@/components/page-actions';\nimport { apiSource } from '@/lib/source';\nimport { DocsBody, DocsDescription, DocsPage, DocsTitle } from 'fumadocs-ui/page';\nimport { notFound } from 'next/navigation';\n\nexport default async function Page(props: { params: Promise<{ slug?: string[] }> }) {\n const params = await props.params;\n const page = apiSource.getPage(params.slug);\n if (!page) notFound();\n\n const MDX = page.data.body;\n\n return (\n \n {page.data.title}\n {page.data.description}\n
\n \n \n
\n \n \n \n \n );\n}\n\nexport async function generateStaticParams() {\n return apiSource.generateParams();\n}\n\nexport async function generateMetadata(props: { params: Promise<{ slug?: string[] }> }) {\n const params = await props.params;\n const page = apiSource.getPage(params.slug);\n if (!page) notFound();\n\n return {\n title: page.data.title,\n description: page.data.description,\n };\n}\n" }, { "path": "docs/src/app/api/layout.tsx", "content": "import { DocsLayout, DocsLayoutProps } from 'fumadocs-ui/layouts/docs';\nimport type { ReactNode } from 'react';\nimport { baseOptions } from '@/app/layout.config';\nimport { apiSource } from '@/lib/source';\nimport { Sidebar } from '../docs/sidebar';\nimport { Navbar } from '../docs/navbar';\n\nexport default function Layout({ children }: { children: ReactNode }) {\n const baseProps: DocsLayoutProps = {\n ...baseOptions,\n tree: apiSource.pageTree,\n };\n\n const apiProps: DocsLayoutProps = {\n ...baseProps,\n sidebar: { ...baseProps.sidebar, component: Sidebar(baseProps) },\n nav: { ...baseProps.nav, component: Navbar(baseProps) },\n };\n\n return {children};\n}\n" }, { "path": "docs/src/app/docs/[[...slug]]/page.tsx", "content": "import { mdxComponents } from '@/app/layout.config';\nimport { LLMCopyButton, ViewOptions } from '@/components/page-actions';\nimport { overridenMdxComponents } from '@/lib/Overrides';\nimport { docsSource } from '@/lib/source';\nimport { getPageTreePeers } from 'fumadocs-core/server';\nimport { DocsBody, DocsDescription, DocsPage, DocsTitle } from 'fumadocs-ui/page';\nimport { notFound } from 'next/navigation';\n\nexport default async function Page(props: { params: Promise<{ slug?: string[] }> }) {\n const params = await props.params;\n const page = docsSource.getPage(params.slug);\n if (!page) notFound();\n\n const MDX = page.data.body;\n const hasCategory = page.file.name === 'index' && page.slugs.length > 0;\n\n return (\n \n {page.data.title}\n\n {page.data.description}\n
\n \n \n
\n\n \n \n \n {hasCategory && (\n \n {getPageTreePeers(docsSource.pageTree, page.url).map(peer => (\n \n {peer.description}\n \n ))}\n \n )}\n \n );\n}\n\nexport async function generateStaticParams() {\n return docsSource.generateParams();\n}\n\nexport async function generateMetadata(props: { params: Promise<{ slug?: string[] }> }) {\n const params = await props.params;\n const page = docsSource.getPage(params.slug);\n if (!page) notFound();\n\n return {\n title: page.data.title,\n description: page.data.description,\n };\n}\n" }, { "path": "docs/src/app/docs/layout.tsx", "content": "import { baseOptions } from '@/app/layout.config';\nimport { docsSource } from '@/lib/source';\nimport { DocsLayout, DocsLayoutProps } from 'fumadocs-ui/layouts/docs';\nimport type { ReactNode } from 'react';\nimport { Sidebar } from './sidebar';\nimport { Navbar } from './navbar';\n\nexport default function Layout({ children }: { children: ReactNode }) {\n const baseProps: DocsLayoutProps = {\n ...baseOptions,\n tree: docsSource.pageTree,\n };\n\n const docsProps: DocsLayoutProps = {\n ...baseProps,\n sidebar: { ...baseProps.sidebar, component: Sidebar(baseProps) },\n nav: { ...baseProps.nav, component: Navbar(baseProps) },\n };\n\n return {children};\n}\n" }, { "path": "docs/src/app/docs/navbar.tsx", "content": "import Link from 'fumadocs-core/link';\nimport { SearchToggle } from 'fumadocs-ui/components/layout/search-toggle';\nimport { buttonVariants } from 'fumadocs-ui/components/ui/button';\nimport { DocsLayoutProps } from 'fumadocs-ui/layouts/docs';\nimport { Navbar as BaseNavbar, NavbarSidebarTrigger } from 'fumadocs-ui/layouts/docs-client';\nimport { cn } from 'fumadocs-ui/utils/cn';\nimport { Sidebar as SidebarIcon } from 'lucide-react';\nimport { Logo } from '../logo';\n\nexport function Navbar({\n nav = {},\n sidebar: { enabled: sidebarEnabled = true } = {},\n searchToggle = {},\n}: DocsLayoutProps) {\n return (\n \n {searchToggle.enabled !== false &&\n (searchToggle.components?.sm ?? )}\n \n \n \n {sidebarEnabled && (\n \n \n \n )}\n \n );\n}\n" }, { "path": "docs/src/app/docs/sidebar.tsx", "content": "import Link from 'fumadocs-core/link';\nimport { RootToggle } from 'fumadocs-ui/components/layout/root-toggle';\nimport { LargeSearchToggle } from 'fumadocs-ui/components/layout/search-toggle';\nimport {\n CollapsibleSidebar,\n SidebarCollapseTrigger,\n SidebarFooter,\n SidebarHeader,\n SidebarPageTree,\n SidebarViewport,\n} from 'fumadocs-ui/components/layout/sidebar';\nimport { ThemeToggle } from 'fumadocs-ui/components/layout/theme-toggle';\nimport { LanguageToggle } from 'fumadocs-ui/components/layout/language-toggle';\nimport { buttonVariants } from 'fumadocs-ui/components/ui/button';\nimport { CollapsibleControl, DocsLayoutProps } from 'fumadocs-ui/layouts/docs';\nimport { getSidebarTabsFromOptions, SidebarLinkItem } from 'fumadocs-ui/layouts/docs/shared';\nimport { BaseLinkItem, IconItemType } from 'fumadocs-ui/layouts/links';\nimport { getLinks } from 'fumadocs-ui/layouts/shared';\nimport { cn } from 'fumadocs-ui/utils/cn';\nimport { Languages, SidebarIcon } from 'lucide-react';\nimport { useMemo } from 'react';\nimport { LogoWithSolana } from '../logo';\n\nexport function Sidebar({\n nav = {},\n sidebar: {\n tabs: sidebarTabs,\n footer: sidebarFooter,\n banner: sidebarBanner,\n components: sidebarComponents,\n ...sidebarProps\n } = {},\n searchToggle = {},\n themeSwitch = { enabled: true },\n i18n = false,\n ...props\n}: DocsLayoutProps) {\n const tabs = useMemo(() => getSidebarTabsFromOptions(sidebarTabs, props.tree) ?? [], [sidebarTabs, props.tree]);\n const links = getLinks(props.links ?? [], props.githubUrl);\n const iconLinks = links.filter((item): item is IconItemType => item.type === 'icon');\n\n const header = (\n \n
\n \n \n \n\n \n \n \n
\n {searchToggle.enabled !== false &&\n (searchToggle.components?.lg ?? (\n \n ))}\n {tabs.length > 0 && }\n\n {sidebarBanner}\n \n );\n\n const viewport = (\n \n {links\n .filter(v => v.type !== 'icon')\n .map((item, i, list) => (\n \n ))}\n \n \n );\n\n const footer = (\n \n
\n {iconLinks.map((item, i) => (\n \n {item.icon}\n \n ))}\n {i18n ? (\n \n \n \n ) : null}\n {themeSwitch.enabled !== false &&\n (themeSwitch.component ?? )}\n
\n {sidebarFooter}\n \n );\n\n return (\n <>\n
\n \n
\n \n {header}\n {viewport}\n {footer}\n \n \n );\n}\n" }, { "path": "docs/src/app/global.css", "content": "@import 'tailwindcss';\n\n/* Fumadocs imports. */\n@import 'fumadocs-ui/css/neutral.css';\n@import 'fumadocs-ui/css/preset.css';\n@import 'fumadocs-twoslash/twoslash.css';\n@source '../../node_modules/fumadocs-ui/dist/**/*.js';\n\n/* App imports. */\n@import '../../src/app/styles/brand.css';\n@import '../../src/app/styles/typography.css';\n@import '../../src/app/styles/fumadocs-overrides.css';\n" }, { "path": "docs/src/app/layout.config.tsx", "content": "import { CardTab, CardTabs } from '@/components/card-tabs';\nimport { overridenMdxComponents } from '@/lib/Overrides';\nimport { Spread } from '@/lib/Spread';\nimport { Popup, PopupContent, PopupTrigger } from 'fumadocs-twoslash/ui';\nimport { ImageZoom } from 'fumadocs-ui/components/image-zoom';\nimport { Step, Steps } from 'fumadocs-ui/components/steps';\nimport type { BaseLayoutProps } from 'fumadocs-ui/layouts/shared';\nimport defaultMdxComponents from 'fumadocs-ui/mdx';\nimport { BookTextIcon, CookingPotIcon, LibraryBigIcon } from 'lucide-react';\nimport { Logo, LogoWithSolana } from './logo';\nimport { MDXComponents } from 'mdx/types';\n\n/**\n * Shared layout configurations\n *\n * you can customise layouts individually from:\n * Home Layout: app/(home)/layout.tsx\n * Docs Layout: app/docs/layout.tsx\n */\nexport const baseOptions: BaseLayoutProps = {\n nav: {\n title: (\n
\n \n \n
\n ),\n },\n links: [\n {\n text: 'Documentation',\n url: '/docs',\n active: 'nested-url',\n icon: ,\n },\n {\n text: 'Recipes',\n url: '/recipes',\n active: 'nested-url',\n icon: ,\n },\n {\n text: 'API Reference',\n url: '/api',\n active: 'nested-url',\n icon: ,\n },\n ],\n};\n\nexport const mdxComponents: MDXComponents = {\n ...defaultMdxComponents,\n ...overridenMdxComponents,\n img: props => ,\n CardTab,\n CardTabs,\n Popup,\n PopupContent,\n PopupTrigger,\n Spread,\n Step,\n Steps,\n};\n" }, { "path": "docs/src/app/layout.tsx", "content": "import './global.css';\n\nimport InKeepSearchDialog from '@/lib/InKeepSearchDialog';\nimport { RootProvider } from 'fumadocs-ui/provider';\nimport type { ReactNode } from 'react';\n\nexport default function Layout({ children }: { children: ReactNode }) {\n return (\n \n \n \n \n \n \n {children}\n \n \n \n );\n}\n" }, { "path": "docs/src/app/llms-full.txt/route.ts", "content": "import { apiSource, docsSource, recipesSource } from '@/lib/source';\nimport { getLLMText } from '@/lib/get-llm-text';\n\n// cached forever\nexport const revalidate = false;\n\nexport async function GET() {\n const scan = [...docsSource.getPages(), ...recipesSource.getPages(), ...apiSource.getPages()].map(getLLMText);\n const scanned = await Promise.all(scan);\n return new Response(scanned.join('\\n\\n'));\n}\n" }, { "path": "docs/src/app/llms.mdx/api/[[...slug]]/route.ts", "content": "import { getLLMText } from '@/lib/get-llm-text';\nimport { apiSource } from '@/lib/source';\nimport { notFound } from 'next/navigation';\n\nexport const revalidate = false;\n\nexport async function GET(_req: Request, { params }: RouteContext<'/llms.mdx/api/[[...slug]]'>) {\n const { slug } = await params;\n const page = apiSource.getPage(slug);\n if (!page) notFound();\n\n return new Response(await getLLMText(page), {\n headers: {\n 'Content-Type': 'text/markdown',\n },\n });\n}\n\nexport function generateStaticParams() {\n return apiSource.generateParams();\n}\n" }, { "path": "docs/src/app/llms.mdx/docs/[[...slug]]/route.ts", "content": "import { getLLMText } from '@/lib/get-llm-text';\nimport { docsSource } from '@/lib/source';\nimport { notFound } from 'next/navigation';\n\nexport const revalidate = false;\n\nexport async function GET(_req: Request, { params }: RouteContext<'/llms.mdx/docs/[[...slug]]'>) {\n const { slug } = await params;\n const page = docsSource.getPage(slug);\n if (!page) notFound();\n\n return new Response(await getLLMText(page), {\n headers: {\n 'Content-Type': 'text/markdown',\n },\n });\n}\n\nexport function generateStaticParams() {\n return docsSource.generateParams();\n}\n" }, { "path": "docs/src/app/llms.mdx/recipes/[[...slug]]/route.ts", "content": "import { getLLMText } from '@/lib/get-llm-text';\nimport { recipesSource } from '@/lib/source';\nimport { notFound } from 'next/navigation';\n\nexport const revalidate = false;\n\nexport async function GET(_req: Request, { params }: RouteContext<'/llms.mdx/recipes/[[...slug]]'>) {\n const { slug } = await params;\n const page = recipesSource.getPage(slug);\n if (!page) notFound();\n\n return new Response(await getLLMText(page), {\n headers: {\n 'Content-Type': 'text/markdown',\n },\n });\n}\n\nexport function generateStaticParams() {\n return recipesSource.generateParams();\n}\n" }, { "path": "docs/src/app/logo.tsx", "content": "import { cn } from 'fumadocs-ui/utils/cn';\n\nexport function LogoWithSolana({\n className,\n solanaClassName,\n}: React.ComponentProps<'svg'> & { solanaClassName?: string }) {\n return (\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n );\n}\n\nexport function Logo({ className }: React.ComponentProps<'svg'>) {\n return (\n \n \n \n \n \n \n );\n}\n" }, { "path": "docs/src/app/recipes/[[...slug]]/page.tsx", "content": "import { mdxComponents } from '@/app/layout.config';\nimport { LLMCopyButton, ViewOptions } from '@/components/page-actions';\nimport { overridenMdxComponents } from '@/lib/Overrides';\nimport { recipesSource } from '@/lib/source';\nimport { getPageTreePeers } from 'fumadocs-core/server';\nimport { DocsBody, DocsDescription, DocsPage, DocsTitle } from 'fumadocs-ui/page';\nimport { notFound } from 'next/navigation';\n\nexport default async function Page(props: { params: Promise<{ slug?: string[] }> }) {\n const params = await props.params;\n const page = recipesSource.getPage(params.slug);\n if (!page) notFound();\n\n const MDX = page.data.body;\n const hasCategory = page.file.name === 'index' && page.slugs.length > 0;\n\n return (\n \n {page.data.title}\n\n {page.data.description}\n
\n \n \n
\n\n \n \n \n {hasCategory && (\n \n {getPageTreePeers(recipesSource.pageTree, page.url).map(peer => (\n \n {peer.description}\n \n ))}\n \n )}\n \n );\n}\n\nexport async function generateStaticParams() {\n return recipesSource.generateParams();\n}\n\nexport async function generateMetadata(props: { params: Promise<{ slug?: string[] }> }) {\n const params = await props.params;\n const page = recipesSource.getPage(params.slug);\n if (!page) notFound();\n\n return {\n title: page.data.title,\n description: page.data.description,\n };\n}\n" }, { "path": "docs/src/app/recipes/layout.tsx", "content": "import { baseOptions } from '@/app/layout.config';\nimport { recipesSource } from '@/lib/source';\nimport { DocsLayout, DocsLayoutProps } from 'fumadocs-ui/layouts/docs';\nimport type { ReactNode } from 'react';\nimport { Sidebar } from '../docs/sidebar';\nimport { Navbar } from '../docs/navbar';\n\nexport default function Layout({ children }: { children: ReactNode }) {\n const baseProps: DocsLayoutProps = {\n ...baseOptions,\n tree: recipesSource.pageTree,\n };\n\n const recipesProps: DocsLayoutProps = {\n ...baseProps,\n sidebar: { ...baseProps.sidebar, component: Sidebar(baseProps) },\n nav: { ...baseProps.nav, component: Navbar(baseProps) },\n };\n\n return {children};\n}\n" }, { "path": "docs/src/app/styles/brand.css", "content": "@theme {\n /* ---------*/\n /* Colours. */\n /* ---------*/\n\n /* Linen scale. */\n --color-linen-50: #f9f6f1;\n --color-linen-100: #f4eee5; /* Brand color. */\n --color-linen-200: #eae1da; /* Brand color. */\n --color-linen-300: #d6beac; /* Brand color. */\n --color-linen-400: #b2927c; /* Brand color. */\n --color-linen-500: #8a6b5b;\n --color-linen-600: #715346;\n --color-linen-700: #513a30;\n --color-linen-800: #2f2420;\n --color-linen-900: #14131d; /* Brand color. */\n\n /* Coral scale. */\n --color-coral-50: #fff4ef;\n --color-coral-100: #ffe3d6;\n --color-coral-200: #ffc1ac;\n --color-coral-300: #ffa184;\n --color-coral-400: #f5814e; /* Brand color. */\n --color-coral-500: #d8582b; /* Brand color. */\n --color-coral-600: #b94727;\n --color-coral-700: #933923;\n --color-coral-800: #6b2a1f;\n --color-coral-900: #421b1a;\n\n /* Mauve scale. */\n --color-mauve-50: #fbf9fb;\n --color-mauve-100: #f5edf3;\n --color-mauve-200: #e2d8e0;\n --color-mauve-300: #c6b4c4;\n --color-mauve-400: #9b8196; /* Brand color. */\n --color-mauve-450: #8b79ad; /* Brand color. */\n --color-mauve-500: #83617d; /* Brand color. */\n --color-mauve-600: #6b4e66;\n --color-mauve-700: #533b4f;\n --color-mauve-800: #392938;\n --color-mauve-900: #1f1721;\n\n /* -------*/\n /* Fonts. */\n /* -------*/\n\n --font-sans: 'corbel', 'sans-serif';\n --font-title: 'neulis-neue', 'sans-serif';\n\n /* -------*/\n /* Sizes. */\n /* -------*/\n\n --spacing-home-container: 1000px;\n}\n" }, { "path": "docs/src/app/styles/fumadocs-overrides.css", "content": "/* -------- */\n/* Colours. */\n/* -------- */\n\n@theme {\n --color-fd-background: var(--color-linen-100);\n --color-fd-foreground: var(--color-linen-900);\n --color-fd-border: var(--color-linen-300);\n --color-fd-muted: var(--color-linen-200);\n --color-fd-muted-foreground: var(--color-linen-500);\n --color-fd-popover: var(--color-linen-200);\n --color-fd-popover-foreground: var(--color-linen-900);\n --color-fd-card: var(--color-linen-200);\n --color-fd-card-foreground: var(--color-linen-800);\n --color-fd-primary: var(--color-coral-400);\n --color-fd-primary-foreground: var(--color-linen-100);\n --color-fd-secondary: var(--color-mauve-400);\n --color-fd-secondary-foreground: var(--color-linen-100);\n --color-fd-accent: var(--color-linen-300);\n --color-fd-accent-foreground: var(--color-linen-900);\n}\n\n.dark {\n --color-fd-background: var(--color-mauve-900);\n --color-fd-foreground: var(--color-mauve-100);\n --color-fd-border: var(--color-linen-700);\n --color-fd-muted: var(--color-linen-800);\n --color-fd-muted-foreground: var(--color-linen-400);\n --color-fd-popover: var(--color-mauve-900);\n --color-fd-popover-foreground: var(--color-linen-50);\n --color-fd-card: var(--color-linen-800);\n --color-fd-card-foreground: var(--color-linen-200);\n --color-fd-primary: var(--color-coral-400);\n --color-fd-primary-foreground: var(--color-linen-100);\n --color-fd-secondary: var(--color-linen-800);\n --color-fd-card-foreground: var(--color-linen-200);\n --color-fd-accent: var(--color-linen-500);\n --color-fd-accent-foreground: var(--color-linen-300);\n}\n\n/* ------- */\n/* Navbar. */\n/* ------- */\n\n#nd-nav {\n --spacing-fd-container: var(--spacing-home-container);\n --color-fd-secondary: var(--color-fd-background);\n left: 0; /* overrides: left-1/2 */\n max-width: 100%; /* overrides: max-w-fd-container */\n translate: none; /* overrides: -translate-x-1/2 */\n margin: 0; /* overrides: lg:mt-2 */\n width: 100%; /* overrides: w-full lg:w-[calc(100%-1rem)] */\n border: none; /* overrides: lg:border border-b border-fd-foreground/10 */\n border-bottom: 1px solid var(--color-fd-border);\n box-shadow: none; /* overrides: lg:shadow */\n border-radius: 0; /* overrides: lg:rounded-2xl */\n}\n\n#nd-home-layout {\n @apply pt-14 md:pt-18; /* overrides: pt-14 */\n}\n\n#nd-nav nav {\n @apply h-14 md:h-18; /* overrides: h-14 */\n}\n\n#nd-nav > div:first-child {\n @apply max-w-fd-container mx-auto;\n}\n\n/* -------- */\n/* Sidebar. */\n/* -------- */\n\n#nd-sidebar {\n background-color: var(--color-fd-background);\n}\n\n.dark #nd-sidebar {\n --color-fd-muted-foreground: var(--color-linen-400);\n}\n\n/* --------------- */\n/* Search buttons. */\n/* --------------- */\n\n#nd-sidebar button[data-search-full],\n#nd-nav button[data-search-full] {\n @apply bg-linen-200 hover:bg-linen-50 dark:bg-mauve-800 dark:hover:bg-mauve-900;\n}\n\n/* ----- */\n/* Tabs. */\n/* ----- */\n\n.fd-tabs {\n background-color: inherit;\n --color-fd-border: var(--color-mauve-400);\n --color-fd-secondary: var(--color-mauve-400);\n --color-fd-muted-foreground: var(--color-mauve-200);\n}\n\n.fd-tabs > div[role='tablist'] {\n --color-fd-primary: var(--color-linen-100);\n --color-fd-accent-foreground: var(--color-linen-100);\n}\n\n.dark .fd-tabs {\n --color-fd-border: var(--color-mauve-700);\n --color-fd-secondary: var(--color-mauve-700);\n --color-fd-muted-foreground: var(--color-mauve-200);\n}\n\n.dark .fd-tabs > div[role='tablist'] {\n --color-fd-primary: var(--color-linen-100);\n --color-fd-accent-foreground: var(--color-linen-100);\n}\n\n/* ----- */\n/* Code. */\n/* ----- */\n\n.fd-codeblock {\n --color-fd-muted: var(--color-mauve-400);\n --color-fd-muted-foreground: var(--color-linen-100);\n --color-fd-secondary: var(--color-mauve-200);\n --color-fd-border: var(--color-mauve-400);\n}\n\n.dark .fd-codeblock {\n --color-fd-muted: var(--color-mauve-700);\n --color-fd-muted-foreground: var(--color-linen-200);\n --color-fd-secondary: var(--color-mauve-800);\n --color-fd-border: var(--color-mauve-700);\n}\n\n#hero-code .fd-codeblock pre {\n @apply p-4 md:p-6 lg:p-6;\n}\n\n#hero-code .fd-codeblock pre > code {\n @apply text-sm md:text-base lg:text-base;\n}\n\n/* ------ */\n/* Steps. */\n/* ------ */\n\n.fd-steps {\n --color-fd-border: var(--color-linen-300);\n}\n\n.fd-step::before {\n font-family: var(--font-title);\n font-size: 0.85rem;\n --color-fd-secondary: var(--color-linen-400);\n}\n\n.dark .fd-steps {\n --color-fd-border: var(--color-linen-700);\n}\n\n.dark .fd-step::before {\n --color-fd-secondary: var(--color-linen-600);\n}\n\n/* ------ */\n/* Cards. */\n/* ------ */\n\n.fd-card {\n @apply bg-linen-200 hover:bg-linen-300 dark:bg-linen-800 dark:hover:bg-linen-700;\n}\n\n/* ------------------ */\n/* Prev/Next Buttons. */\n/* ------------------ */\n\n#nd-page > article > div:last-child > a {\n @apply bg-linen-100 hover:bg-linen-200 dark:bg-mauve-900 dark:hover:bg-linen-800;\n}\n" }, { "path": "docs/src/app/styles/typography.css", "content": "/* ------ */\n/* Fonts. */\n/* ------ */\n\nh1,\nh2,\nh3 {\n font-family: var(--font-title);\n font-weight: 700;\n}\n\n.prose :where(strong):not(:where([class~='not-prose'], [class~='not-prose'] *)) {\n font-weight: 700;\n}\n\n.prose :where(code):not(:where([class~='not-prose'], [class~='not-prose'] *)) {\n font-weight: inherit;\n}\n\n/* -------- */\n/* Spacing. */\n/* -------- */\n\n.prose :where(h2):not(:where([class~='not-prose'], [class~='not-prose'] *, :first-child)) {\n margin-top: 4em;\n}\n\n.prose :where(h3):not(:where([class~='not-prose'], [class~='not-prose'] *)) {\n margin-top: 3em;\n}\n\n/* ------- */\n/* Tables. */\n/* ------- */\n\n.prose :where(table):not(:where([class~='not-prose'], [class~='not-prose'] *)) {\n background-color: inherit;\n}\n" }, { "path": "docs/src/components/card-tabs.tsx", "content": "'use client';\n\nimport { Tabs, TabsContent, TabsList, TabsTrigger } from 'fumadocs-ui/components/ui/tabs';\nimport { createContext, useContext, useLayoutEffect, useMemo, useState, type ReactNode } from 'react';\nimport { cn } from 'fumadocs-ui/utils/cn';\nimport { FlaskConicalIcon, GlobeIcon, LaptopIcon, PuzzleIcon, type LucideIcon } from 'lucide-react';\n\nconst iconMap: Record = {\n globe: GlobeIcon,\n laptop: LaptopIcon,\n 'flask-conical': FlaskConicalIcon,\n puzzle: PuzzleIcon,\n};\n\ninterface CardDefinition {\n title: string;\n description: string;\n icon?: string;\n}\n\ninterface CardTabsProps {\n cards: CardDefinition[];\n groupId?: string;\n persist?: boolean;\n children: ReactNode;\n}\n\nfunction toValue(title: string): string {\n return title.toLowerCase().replace(/\\s+/g, '-');\n}\n\nconst CardTabContext = createContext<{ values: string[]; register: () => number }>({\n values: [],\n register: () => 0,\n});\n\n/**\n * Renders a tab list as a grid of selectable cards.\n *\n * @param props - Card tab configuration and tab panel children.\n * @return A card-styled tab group.\n */\nexport function CardTabs({ cards, groupId, persist = false, children }: CardTabsProps) {\n const values = useMemo(() => cards.map(c => toValue(c.title)), [cards]);\n const [value, setValue] = useState(values[0]);\n\n useLayoutEffect(() => {\n if (!groupId) return;\n const stored = persist ? localStorage.getItem(groupId) : sessionStorage.getItem(groupId);\n if (stored && values.includes(stored)) {\n setValue(stored);\n }\n }, [groupId, persist, values]);\n\n function handleChange(v: string) {\n setValue(v);\n if (groupId) {\n if (persist) localStorage.setItem(groupId, v);\n else sessionStorage.setItem(groupId, v);\n }\n }\n\n // Collection pattern: each CardTab calls register() during render\n // to get its index. The counter resets on each render cycle.\n const collectionRef = useMemo(() => ({ current: 0 }), []);\n collectionRef.current = 0;\n\n const ctx = useMemo(\n () => ({\n values,\n register: () => collectionRef.current++,\n }),\n [values, collectionRef],\n );\n\n return (\n \n \n {cards.map((card, i) => {\n const Icon = card.icon ? iconMap[card.icon] : undefined;\n return (\n \n
\n {Icon && (\n \n )}\n
\n
\n {card.title}\n
\n
{card.description}
\n
\n
\n \n );\n })}\n \n {children}\n \n );\n}\n\n/**\n * Renders one panel within a {@link CardTabs} group.\n *\n * @param props - The tab panel children to render.\n * @return A tab panel associated with the next card in the parent group.\n * @throws Throws if there are more `CardTab` children than card definitions.\n */\nexport function CardTab({ children }: { children: ReactNode }) {\n const ctx = useContext(CardTabContext);\n const index = ctx.register();\n const value = ctx.values[index];\n\n if (!value) {\n throw new Error(\n `CardTab at index ${index} does not have a matching card definition. ` +\n `Make sure the number of CardTab children matches the number of cards.`,\n );\n }\n\n return (\n \n {children}\n \n );\n}\n" }, { "path": "docs/src/components/page-actions.tsx", "content": "'use client';\nimport { useMemo, useState } from 'react';\nimport { Check, ChevronDown, Copy, ExternalLinkIcon } from 'lucide-react';\nimport { cn } from '../lib/cn';\nimport { useCopyButton } from 'fumadocs-ui/utils/use-copy-button';\nimport { buttonVariants } from './ui/button';\nimport { Popover, PopoverContent, PopoverTrigger } from './ui/popover';\nimport { cva } from 'class-variance-authority';\n\nconst cache = new Map();\n\nexport function LLMCopyButton({\n /**\n * A URL to fetch the raw Markdown/MDX content of page\n */\n markdownUrl,\n}: {\n markdownUrl: string;\n}) {\n const [isLoading, setLoading] = useState(false);\n const [checked, onClick] = useCopyButton(async () => {\n const cached = cache.get(markdownUrl);\n if (cached) return navigator.clipboard.writeText(cached);\n\n setLoading(true);\n\n try {\n await navigator.clipboard.write([\n new ClipboardItem({\n 'text/plain': fetch(markdownUrl).then(async (res) => {\n const content = await res.text();\n cache.set(markdownUrl, content);\n\n return content;\n }),\n }),\n ]);\n } finally {\n setLoading(false);\n }\n });\n\n return (\n \n {checked ? : }\n Copy Markdown\n \n );\n}\n\nconst optionVariants = cva(\n 'text-sm p-2 rounded-lg inline-flex items-center gap-2 hover:text-fd-accent-foreground hover:bg-fd-accent [&_svg]:size-4',\n);\n\nexport function ViewOptions({\n markdownUrl,\n githubUrl,\n}: {\n /**\n * A URL to the raw Markdown/MDX content of page\n */\n markdownUrl: string;\n\n /**\n * Source file URL on GitHub\n */\n githubUrl: string;\n}) {\n const items = useMemo(() => {\n const fullMarkdownUrl =\n typeof window !== 'undefined' ? new URL(markdownUrl, window.location.origin) : 'loading';\n const q = `Read ${fullMarkdownUrl}, I want to ask questions about it.`;\n\n return [\n {\n title: 'Open in GitHub',\n href: githubUrl,\n icon: (\n \n GitHub\n \n \n ),\n },\n {\n title: 'Open in Scira AI',\n href: `https://scira.ai/?${new URLSearchParams({\n q,\n })}`,\n icon: (\n \n Scira AI\n \n \n \n \n \n \n \n \n ),\n },\n {\n title: 'Open in ChatGPT',\n href: `https://chatgpt.com/?${new URLSearchParams({\n hints: 'search',\n q,\n })}`,\n icon: (\n \n OpenAI\n \n \n ),\n },\n {\n title: 'Open in Claude',\n href: `https://claude.ai/new?${new URLSearchParams({\n q,\n })}`,\n icon: (\n \n Anthropic\n \n \n ),\n },\n {\n title: 'Open in Cursor',\n icon: (\n \n Cursor\n \n \n ),\n href: `https://cursor.com/link/prompt?${new URLSearchParams({\n text: q,\n })}`,\n },\n ];\n }, [githubUrl, markdownUrl]);\n\n return (\n \n \n Open\n \n \n \n {items.map((item) => (\n \n {item.icon}\n {item.title}\n \n \n ))}\n \n \n );\n}\n" }, { "path": "docs/src/components/ui/button.tsx", "content": "import { cva, type VariantProps } from 'class-variance-authority';\n\nconst variants = {\n primary:\n 'bg-fd-primary text-fd-primary-foreground hover:bg-fd-primary/80 disabled:bg-fd-secondary disabled:text-fd-secondary-foreground',\n outline: 'border hover:bg-fd-accent hover:text-fd-accent-foreground',\n ghost: 'hover:bg-fd-accent hover:text-fd-accent-foreground',\n secondary:\n 'border bg-linen-200 text-linen-700 hover:bg-linen-300 dark:bg-fd-secondary dark:text-fd-secondary-foreground dark:hover:bg-fd-accent dark:hover:text-fd-accent-foreground',\n} as const;\n\nexport const buttonVariants = cva(\n 'inline-flex items-center justify-center rounded-md p-2 text-sm font-medium transition-colors duration-100 cursor-pointer disabled:pointer-events-none disabled:opacity-50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fd-ring',\n {\n variants: {\n variant: variants,\n // fumadocs use `color` instead of `variant`\n color: variants,\n size: {\n sm: 'gap-1 px-2 py-1.5 text-xs',\n icon: 'p-1.5 [&_svg]:size-5',\n 'icon-sm': 'p-1.5 [&_svg]:size-4.5',\n 'icon-xs': 'p-1 [&_svg]:size-4',\n },\n },\n },\n);\n\nexport type ButtonProps = VariantProps;\n" }, { "path": "docs/src/components/ui/popover.tsx", "content": "'use client';\nimport * as PopoverPrimitive from '@radix-ui/react-popover';\nimport * as React from 'react';\nimport { cn } from '../../lib/cn';\n\nconst Popover = PopoverPrimitive.Root;\n\nconst PopoverTrigger = PopoverPrimitive.Trigger;\n\nconst PopoverContent = React.forwardRef<\n React.ComponentRef,\n React.ComponentPropsWithoutRef\n>(({ className, align = 'center', sideOffset = 4, ...props }, ref) => (\n \n \n \n));\nPopoverContent.displayName = PopoverPrimitive.Content.displayName;\n\nconst PopoverClose = PopoverPrimitive.PopoverClose;\n\nexport { Popover, PopoverTrigger, PopoverContent, PopoverClose };\n" }, { "path": "docs/src/lib/InKeepSearchDialog.tsx", "content": "'use client';\n\nimport { type InkeepModalSearchAndChatProps } from '@inkeep/cxkit-react';\nimport type { SharedProps } from 'fumadocs-ui/components/dialog/search';\nimport dynamic from 'next/dynamic';\n\nconst InkeepModalSearchAndChat = dynamic(\n () => import('@inkeep/cxkit-react').then(({ InkeepModalSearchAndChat }) => InkeepModalSearchAndChat),\n { ssr: false },\n);\nconst AI_ASSISTANT_NAME = 'Kit';\n\nexport default function InKeepSearchDialog(props: SharedProps) {\n const { open, onOpenChange } = props;\n const config: InkeepModalSearchAndChatProps = {\n baseSettings: {\n apiKey:\n /**\n * Need to use search in development?\n *\n * ```shell\n * pnpm vercel link -p kit-docs -S anza-tech --yes\n * pnpm vercel env pull --environment=development\n * ```\n */\n process.env.NEXT_PUBLIC_INKEEP_SEARCH_API_KEY,\n colorMode: {\n sync: {\n target: globalThis.document?.documentElement,\n attributes: ['class'],\n isDarkMode: attributes => !!attributes.class?.includes('dark'),\n },\n },\n ...(process.env.NODE_ENV === 'development' ? { env: 'development' } : null),\n organizationDisplayName: 'Kit',\n primaryBrandColor: (() => {\n if (typeof globalThis.getComputedStyle === 'undefined') {\n return '#ff0000'; // Should never appear.\n }\n const rootStyles = getComputedStyle(document.documentElement);\n return rootStyles.getPropertyValue('--color-coral-400').trim();\n })(),\n privacyPreferences: {\n optOutAnalyticalCookies: true,\n },\n transformSource(source) {\n const detectedTabs: string[] = [];\n if (source.url.startsWith('https://solana.stackexchange.com/')) {\n detectedTabs.push('Q & A');\n } else if (source.contentType === 'documentation') {\n detectedTabs.push(source.breadcrumbs[0] === 'API' ? 'API' : 'Docs');\n } else if (source.breadcrumbs.length === 0 && source.tabs?.includes('GitHub')) {\n // InKeep does not yet produce breadcrumbs for GitHub results, so we synthesize\n // them here.\n const match = source.url.match(/\\/(issues|pull)\\/(\\d+)/);\n if (match) {\n const [\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n _,\n model,\n number,\n ] = match;\n source.breadcrumbs = [model === 'pull' ? 'Pull Request' : 'Issue', number];\n }\n }\n return {\n ...source,\n tabs: Array.from(new Set([...(source.tabs ?? []), ...detectedTabs])),\n url:\n // Strip absolute URLs from the search results because InKeep will not\n // consider doc site articles as being first-party from the perspective of\n // the main domain in all environments (eg. development, staging).\n [/^https:\\/\\/[\\w-]+\\.vercel\\.app\\//, /^https:\\/\\/solanakit\\.com\\//].reduce(\n (url, regex) => url.replace(regex, '/'),\n source.url,\n ),\n };\n },\n },\n modalSettings: {\n isOpen: open,\n onOpenChange,\n },\n searchSettings: {\n debounceTimeMs: 250,\n tabs: ['All', ['API', { isAlwaysVisible: true }], ['Docs', { isAlwaysVisible: true }], 'Q & A', 'GitHub'],\n },\n aiChatSettings: {\n aiAssistantAvatar: {\n dark: '/mascots/dark-mascot-3-4.svg',\n light: '/mascots/light-mascot-3-4.svg',\n },\n aiAssistantName: AI_ASSISTANT_NAME,\n conversationVisibility: 'private',\n disclaimerSettings: {\n isEnabled: true,\n label: 'Disclaimer',\n tooltip: 'These AI-generated responses may be inaccurate or incomplete.',\n },\n exampleQuestions: [\n 'I have a 64-byte secret key. Can I use it to sign messages and transactions with Kit?',\n 'Show me how to subscribe for updates to the data of an account',\n 'How can I fetch all transaction in a given block?',\n ],\n introMessage: `Hi!\\n\\nI'm an AI assistant trained on the docs and API reference on this site.\\n\\nAsk me anything about \\`${AI_ASSISTANT_NAME}\\`.`,\n placeholder: 'Ask me a question',\n },\n };\n\n return ;\n}\n" }, { "path": "docs/src/lib/Overrides.tsx", "content": "import { Card as BaseCard, Cards as BaseCards } from 'fumadocs-ui/components/card';\nimport { Tab as BaseTab, Tabs as BaseTabs } from 'fumadocs-ui/components/tabs';\nimport { Callout as BaseCallout } from 'fumadocs-ui/components/callout';\n\nexport const Callout = (props => ) as typeof BaseCallout;\n\nexport const Card: typeof BaseCard = props => ;\nexport const Cards: typeof BaseCards = BaseCards;\n\nexport const Tab: typeof BaseTab = BaseTab;\nexport const Tabs: typeof BaseTabs = props => ;\n\nexport const overridenMdxComponents = { Callout, Card, Cards, Tab, Tabs };\n" }, { "path": "docs/src/lib/Spread.tsx", "content": "import { ReactNode } from 'react';\n\nexport function Spread({ children }: { children: ReactNode }) {\n return (\n
\n {children}\n
\n );\n}\n" }, { "path": "docs/src/lib/ThemedImage.tsx", "content": "import { cn } from 'fumadocs-ui/utils/cn';\nimport Image, { ImageProps, StaticImageData } from 'next/image';\n\nexport function ThemedImage({\n alt,\n className,\n src,\n ...props\n}: Omit & {\n src: Readonly<{\n dark: StaticImageData;\n light: StaticImageData;\n }>;\n}) {\n const {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n blurWidth: _1,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n blurHeight: _2,\n ...darkSrc\n } = src.dark;\n const {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n blurWidth: _3,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n blurHeight: _4,\n ...lightSrc\n } = src.light;\n return (\n <>\n {alt}\n {alt}\n \n );\n}\n" }, { "path": "docs/src/lib/cn.ts", "content": "export { twMerge as cn } from 'tailwind-merge';\n" }, { "path": "docs/src/lib/get-llm-text.ts", "content": "import { apiSource, docsSource } from '@/lib/source';\nimport type { InferPageType } from 'fumadocs-core/source';\n\nexport async function getLLMText(page: InferPageType) {\n const processed = await page.data.getText('processed');\n\n return `# ${page.data.title} (${page.url})\n${processed}`;\n}\n" }, { "path": "docs/src/lib/source.ts", "content": "import { api, docs, recipes } from '@/.source';\nimport { loader } from 'fumadocs-core/source';\n\nexport const apiSource = loader({\n baseUrl: '/api',\n source: api.toFumadocsSource(),\n});\n\nexport const docsSource = loader({\n baseUrl: '/docs',\n source: docs.toFumadocsSource(),\n});\n\nexport const recipesSource = loader({\n baseUrl: '/recipes',\n source: recipes.toFumadocsSource(),\n});\n" }, { "path": "docs/tsconfig.json", "content": "{\n \"compilerOptions\": {\n \"baseUrl\": \".\",\n \"target\": \"ESNext\",\n \"lib\": [\"dom\", \"dom.iterable\", \"esnext\"],\n \"allowJs\": true,\n \"skipLibCheck\": true,\n \"strict\": true,\n \"forceConsistentCasingInFileNames\": true,\n \"noEmit\": true,\n \"esModuleInterop\": true,\n \"module\": \"esnext\",\n \"moduleResolution\": \"bundler\",\n \"resolveJsonModule\": true,\n \"isolatedModules\": true,\n \"jsx\": \"react-jsx\",\n \"incremental\": true,\n \"paths\": {\n \"@/.source\": [\"./.source/index.ts\"],\n \"@/public/*\": [\"./public/*\"],\n \"@/*\": [\"./src/*\"]\n },\n \"plugins\": [\n {\n \"name\": \"next\"\n }\n ]\n },\n \"include\": [\"next-env.d.ts\", \"**/*.ts\", \"**/*.tsx\", \".next/types/**/*.ts\", \".next/dev/types/**/*.ts\"],\n \"exclude\": [\"node_modules\"]\n}\n" }, { "path": "eslint.config.mjs", "content": "export { default } from '@solana/eslint-config/eslint.config.mjs';\n" }, { "path": "examples/README.md", "content": "# Examples\n\n## One-time setup\n\nStart by installing all dependencies.\n\n```shell\npnpm install\n```\n\nMost examples use a local test Solana validator. Install one by running the following command in the root of this monorepo.\n\n```shell\npnpm test:setup\n```\n\n## Run an example\n\nIn the directory of a given example, run its start script.\n\n```shell\npnpm start\n```\n" }, { "path": "examples/deserialize-transaction/LICENSE", "content": "Copyright (c) 2023 Solana Labs, Inc\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n" }, { "path": "examples/deserialize-transaction/package.json", "content": "{\n \"name\": \"@solana/example-deserialize-transaction\",\n \"private\": true,\n \"type\": \"module\",\n \"scripts\": {\n \"prestart\": \"turbo --output-logs=errors-only compile:js compile:typedefs\",\n \"run:example\": \"tsx src/example.ts\",\n \"start\": \"start-server-and-test '../../scripts/start-shared-test-validator.sh' http://127.0.0.1:8899/health run:example\",\n \"style:fix\": \"pnpm eslint --fix src && pnpm prettier --log-level warn --ignore-unknown --write ./*\",\n \"test:lint\": \"TERM_OVERRIDE=\\\"${TURBO_HASH:+dumb}\\\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-lint.config.js --rootDir . --silent --testMatch 'src/**/*.{ts,tsx}'\",\n \"test:prettier\": \"TERM_OVERRIDE=\\\"${TURBO_HASH:+dumb}\\\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-prettier.config.js --rootDir . --silent\",\n \"test:typecheck\": \"tsc\"\n },\n \"dependencies\": {\n \"@solana-program/address-lookup-table\": \"^0.11.0\",\n \"@solana-program/memo\": \"^0.11.0\",\n \"@solana-program/system\": \"^0.12.0\",\n \"@solana/example-utils\": \"workspace:*\",\n \"@solana/kit\": \"workspace:*\"\n },\n \"devDependencies\": {\n \"start-server-and-test\": \"^2.1.5\",\n \"tsx\": \"^4.21.0\"\n }\n}\n" }, { "path": "examples/deserialize-transaction/src/example.ts", "content": "/**\n * EXAMPLE\n * Deserialize and inspect a transaction with @solana/kit\n *\n * Before running any of the examples in this monorepo, make sure to set up a test validator by\n * running `pnpm test:setup` in the root directory.\n *\n * To run this example, execute `pnpm start` in this directory.\n */\nimport { createLogger } from '@solana/example-utils/createLogger.js';\nimport {\n Address,\n appendTransactionMessageInstructions,\n assertIsInstructionWithAccounts,\n assertIsInstructionWithData,\n compressTransactionMessageUsingAddressLookupTables,\n createKeyPairSignerFromBytes,\n createSolanaRpc,\n createTransactionMessage,\n decompileTransactionMessageFetchingLookupTables,\n getBase64EncodedWireTransaction,\n getBase64Encoder,\n getCompiledTransactionMessageDecoder,\n getPublicKeyFromAddress,\n getTransactionDecoder,\n lamports,\n partiallySignTransactionMessageWithSigners,\n pipe,\n setTransactionMessageFeePayer,\n setTransactionMessageLifetimeUsingBlockhash,\n verifySignature,\n} from '@solana/kit';\nimport { fetchAddressLookupTable } from '@solana-program/address-lookup-table';\nimport { getAddMemoInstruction, MEMO_PROGRAM_ADDRESS, parseAddMemoInstruction } from '@solana-program/memo';\nimport {\n getTransferSolInstruction,\n identifySystemInstruction,\n parseTransferSolInstruction,\n SystemInstruction,\n} from '@solana-program/system';\n\nconst log = createLogger('Deserialize');\n\n/**\n * SETUP: LOOKUP TABLE ADDRESS\n * Our fixtures include a lookup table, which we're going to use for this transaction\n * This is the address of the lookup table account from `scripts/fixtures/example-deserialize-transaction-address-lookup-table.json`\n */\nconst LOOKUP_TABLE_ADDRESS = 'DUbh3qSh4Vvxa52LGtCBCcuvAEMh62FLNkupnsBjhrCc' as Address;\nlog.info({ address: LOOKUP_TABLE_ADDRESS }, '[setup] Setting lookup table address');\n\n/**\n * SETUP: RPC CONNECTION\n * While in this example we won't send the transaction, we will use the remote procedure call (RPC) server to:\n * - fetch the blockhash for the transaction lifetime\n * - fetch the address lookup table used in the transaction\n *\n * This example uses your local test validator which must be running before you run this script.\n */\nconst rpc = createSolanaRpc('http://127.0.0.1:8899');\n\n/**\n * SETUP: TRANSACTION LIFETIME\n * We will fetch the latest blockhash, which we will use as the transaction's lifetime\n * See `examples/transfer-lamports` for more detail on transaction lifetime\n */\nconst { value: latestBlockhash } = await rpc.getLatestBlockhash().send();\nlog.info(latestBlockhash, '[setup] Got a blockhash');\n\n/**\n * SETUP: CREATE A TRANSACTION MESSAGE\n * We create a transaction that sends lamports from a source account to a destination account,\n * where the destination account is in the lookup table.\n * We will then serialize this transaction, and then explore how to deserialize and inspect it.\n * See the `transfer-lamports` example for more detailed documentation on creating, signing and sending a transaction.\n */\nconst SOURCE_ACCOUNT_SIGNER = await createKeyPairSignerFromBytes(\n /**\n * These are the bytes that we saved at the time this account's key pair was originally\n * generated. Here, they are inlined into the source code, but you can also imagine them being\n * loaded from disk or, better yet, read from an environment variable.\n */\n new Uint8Array(\n // prettier-ignore\n [2, 194, 94, 194, 31, 15, 34, 248, 159, 9, 59, 156, 194, 152, 79, 148, 81, 17, 63, 53, 245, 175, 37, 0, 134, 90, 111, 236, 245, 160, 3, 50, 196, 59, 123, 60, 59, 151, 65, 255, 27, 247, 241, 230, 52, 54, 143, 136, 108, 160, 7, 128, 4, 14, 232, 119, 234, 61, 47, 158, 9, 241, 48, 140],\n ), // Address: ED1WqT2hWJLSZtj4TtTdoovmpMrr7zpkUdbfxmcJR1Fq\n);\nlog.info({ address: SOURCE_ACCOUNT_SIGNER.address }, '[setup] Loaded key pair for source account');\n\n// This is the first address in the lookup table\nconst DESTINATION_ADDRESS = 'F1Vc6AGoxXLwGB7QV8f4So3C5d8SXEk3KKGHxKGEJ8qn' as Address;\nlog.info({ address: DESTINATION_ADDRESS }, '[setup] Setting destination address');\n\n/**\n * This is an arbitrary address that we set as the fee payer\n * In this example we won't send the transaction so it doesn't matter if this account is funded\n */\nconst FEE_PAYER_ADDRESS = '9xaf9RQvmr47tcKZ2y8KdpcSn6KyymGU6PZAFC9AKjPd' as Address;\nlog.info({ address: FEE_PAYER_ADDRESS }, '[setup] Setting fee payer address');\n\nconst transactionMessage = pipe(\n createTransactionMessage({ version: 0 }),\n tx => setTransactionMessageFeePayer(FEE_PAYER_ADDRESS, tx),\n tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),\n tx =>\n appendTransactionMessageInstructions(\n [\n getTransferSolInstruction({\n amount: lamports(12345678n),\n destination: DESTINATION_ADDRESS,\n source: SOURCE_ACCOUNT_SIGNER,\n }),\n getAddMemoInstruction({\n memo: 'hello from @solana/kit',\n }),\n ],\n tx,\n ),\n);\nlog.info('[setup] Created the transaction message');\n\n/**\n * SETUP: COMPRESS WITH LOOKUP TABLE\n * As the destination of our transfer SOL instruction is in our lookup table, we can use the\n * lookup table to compress the transaction.\n *\n * This will modify the accounts referred to in the transaction, so that where possible they\n * refer to an index of an address lookup table instead of an address directly. This makes the\n * transaction smaller when it is compiled, particularly if many addresses can use a lookup table.\n */\n\n// We fetch the JSON parsed representation of the lookup table from the RPC\nconst lookupTableAccount = await fetchAddressLookupTable(rpc, LOOKUP_TABLE_ADDRESS);\n\nconst transactionMessageWithLookupTables = compressTransactionMessageUsingAddressLookupTables(transactionMessage, {\n [LOOKUP_TABLE_ADDRESS]: lookupTableAccount.data.addresses,\n});\nlog.info(`[setup] Compressed the transaction message using lookup table ${LOOKUP_TABLE_ADDRESS}`);\n\n/**\n * SETUP: PARTIALLY SIGN THE TRANSACTION\n * A Solana transaction can have multiple signers that must sign before it is sent to the network.\n * In our case the fee payer and the source account would both need to sign the transaction\n * We used a signer for the source account, so it will sign it when we call `signTransactionMessageWithSigners`\n * But we only used an address for the fee payer, and we don't have its private key to sign the transaction\n * So we will use `partiallySignTransactionMessageWithSigners` to get a transaction that has been signed by\n * the source account, but not by the fee payer.\n */\nconst signedTransaction = await partiallySignTransactionMessageWithSigners(transactionMessageWithLookupTables);\nlog.info(`[setup] Partially signed the transaction with a signature from ${SOURCE_ACCOUNT_SIGNER.address}`);\n\n/**\n * SETUP: ENCODE THE TRANSACTION AS BASE64\n * This is a common format to send a transaction between different systems\n * If you wanted to convert it to a byte array instead, you could do this:\n *\n * ```ts\n * const transactionEncoder = getTransactionEncoder();\n * const transactionBytes = transactionEncoder.encode(signedTransaction);\n * ```\n */\nconst base64EncodedTransaction = getBase64EncodedWireTransaction(signedTransaction);\nlog.info(`[setup] Encoded the transaction as base64: ${base64EncodedTransaction.slice(0, 64)}...`);\n\n/**\n * SETUP COMPLETE\n * At this point, imagine we've received `base64EncodedTransaction` as input and don't know anything about it\n * Let's use web3js to decode and inspect it\n */\n\n/**\n * STEP 1: DECODE TO TRANSACTION\n * @solana/kit has encoders/decoders for many Solana data structures and common data formats,\n * including both base64 strings and our `Transaction` data structure\n * To convert between these, we first encode to a byte array, and then decode to the\n * desired data structure.\n * In our case we first encode the `base64EncodedTransaction` to a byte array, and then\n * decode to a `Transaction`.\n * If we had instead received a byte array `transactionBytes` then we would just skip\n * the base64 encode step\n */\nconst base64Encoder = getBase64Encoder();\nconst transactionBytes = base64Encoder.encode(base64EncodedTransaction);\n\nconst transactionDecoder = getTransactionDecoder();\nconst decodedTransaction = transactionDecoder.decode(transactionBytes);\nlog.info('[step 1] Decoded the transaction');\n\n/**\n * First let's inspect the signatures on our decoded transaction\n * `signatures` is a map from `Address` to `SignatureBytes | null`\n * If the address has signed the transaction then we can access their signature\n * If not then `null` will be stored\n */\n\nfor (const [address, maybeSignature] of Object.entries(decodedTransaction.signatures)) {\n if (maybeSignature) {\n log.info(`[step 1] ${address} has signed the transaction`);\n } else {\n log.info(`[step 1] ${address} is required to sign the transaction but hasn't yet`);\n }\n}\n\n// Now we know that we have a signature for `ED1WqT2hWJLSZtj4TtTdoovmpMrr7zpkUdbfxmcJR1Fq`\n// Let's verify that it's correct\nconst signedByAddress = 'ED1WqT2hWJLSZtj4TtTdoovmpMrr7zpkUdbfxmcJR1Fq' as Address;\nconst signedBySignature = decodedTransaction.signatures[signedByAddress]!;\n// We create a public Ed25519 key with that address (a `CryptoKey` object with the role `verify`)\nconst signedByPublicKey = await getPublicKeyFromAddress(signedByAddress);\n// Now we can verify the signature using that key\nconst verifiedSignature = await verifySignature(signedByPublicKey, signedBySignature, decodedTransaction.messageBytes);\nlog.info(\n `[step 1] The signature for ${signedByAddress} is ${verifiedSignature ? 'valid' : 'not valid'} for the transaction`,\n);\n\n/**\n * STEP 2: DECODE TO COMPILED TRANSACTION MESSAGE\n * We verified the signature is valid for the `messageBytes` field of the Transaction. This is a byte array\n * representing the compiled version of the `TransactionMessage`. If we decode this we can see some information\n * about the transaction. Let's do that next.\n */\n\n// Again we have a decoder to convert from bytes to a Solana data structure, in this case the `CompiledTransactionMessage`\nconst compiledTransactionMessageDecoder = getCompiledTransactionMessageDecoder();\nconst compiledTransactionMessage = compiledTransactionMessageDecoder.decode(decodedTransaction.messageBytes);\n\n// This gives us the data structure `CompiledTransactionMessage`. This is the format that transactions are\n// compiled before the entire transaction is encoded to base64 to be sent to the Solana network.\n\n// Let's inspect some fields of `compiledTransactionMessage`\n// We can see its version:\nlog.info(`[step 2] The transaction is version ${compiledTransactionMessage.version}`);\n\n// We can see the lifetime token, though we don't have enough context yet to know if it's a blockhash or a durable nonce\nlog.info(\n `[step 2] We can see the transaction lifetime token, but we don't know if it's a blockhash or durable nonce: ${compiledTransactionMessage.lifetimeToken}`,\n);\n\n// We can see the static accounts:\nlog.info(compiledTransactionMessage.staticAccounts, '[step 2] Static accounts of the transaction');\n\n// Note that the destination address (F1Vc6AGoxXLwGB7QV8f4So3C5d8SXEk3KKGHxKGEJ8qn) is not here, as it comes from the lookup table\n\n// The `addressLookupTables` field is only included for v0 transactions\n// Here we tell Typescript to narrow the type to exclude legacy transactions\nif (compiledTransactionMessage.version !== 0) {\n throw new Error('We compiled with version: 0');\n}\n\n// Now we can view address lookup tables:\nlog.info(compiledTransactionMessage.addressTableLookups, '[step 2] Address lookup tables for the transaction');\n\n// We see that the transaction uses our address lookup table.\n\n// Let's look at a compiled instruction\nlog.info(\n { ...compiledTransactionMessage.instructions[0], data: '(removed for brevity)' },\n '[step 2] The first instruction of the compiled transaction message',\n);\n\n/**\n * This is the SOL transfer instruction\n * The program account index is 2, which matches the system program (1111...) in our static accounts\n * The first account index is 1, which matches the signer we used as the source address\n * But the second account index is 4, which is outside our array of static accounts.\n * We need to resolve the lookup table in order to know what address this actually is\n */\n\n/**\n * STEP 3: DECOMPILING THE TRANSACTION MESSAGE\n * Let's decompile the transaction message into a structure that is easier to inspect and parse\n * To decompile this transaction message, we need to know the addresses in this lookup table\n * If we already have the addresses in this lookup table fetched, then we can pass them to\n * `decompileTransactionMessage` without fetching them again. Like so:\n *\n * ```ts\n * const decompiledTransactionMessage = decompileTransactionMessage(compiledTransactionMessage, {\n * addressesByLookupTableAddress: {\n * [LOOKUP_TABLE_ADDRESS]: lookupTableAccount.data.addresses,\n * },\n * });\n * ```\n *\n * But let's pretend that we don't already have that data fetched, we've just received the\n * transaction and need to decompile it. We will use `decompileTransactionMessageFetchingLookupTables`\n * instead\n *\n * This will use the RPC to fetch the address lookup table data for us, and then use it to\n * decompile the transaction message.\n */\n\nconst decompiledTransactionMessage = await decompileTransactionMessageFetchingLookupTables(\n compiledTransactionMessage,\n rpc,\n);\n\n// This is our `TransactionMessage` structure, which is much easier to understand and parse\n// This is the same data structure that was created before we first signed the transaction\n\n// We can see the fee payer:\nlog.info(`[step 3] The transaction fee payer is ${decompiledTransactionMessage.feePayer.address}`);\n\n// And the lifetime constraint:\nlog.info(decompiledTransactionMessage.lifetimeConstraint, '[step 3] The transaction lifetime constraint');\n\n/**\n * Here we can see that the lifetime constraint is actually a blockhash\n * The `decompileTransactionMessage` call inspects the transaction and can distinguish\n * between blockhash and nonce for us\n * We can also narrow this type with typescript\n */\nif ('blockhash' in decompiledTransactionMessage.lifetimeConstraint) {\n log.info(`[step 3] The transaction blockhash is ${decompiledTransactionMessage.lifetimeConstraint.blockhash}`);\n}\n\n/**\n * Note that the `lastValidBlockHeight` won't necessarily match that used when the transaction\n * was first created. This is not encoded into the transaction, so we can't decode it back out\n * By default `decompileTransactionMessageFetchingLookupTables` and `decompileTransactionMessage`\n * will set it to U64 MAX. But if you know the correct value,\n * you can pass it like so:\n *\n * ```ts\n * const decompiledTransactionMessage = await decompileTransactionMessageFetchingLookupTables(compiledTransactionMessage, rpc, {\n * lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,\n * })\n * ```\n */\n\n// We can also view the decompiled instructions here\nlog.info(\n { ...decompiledTransactionMessage.instructions[0], data: '(removed for brevity)' },\n '[step 3] The first decoded instruction',\n);\n\n/**\n * We can see the programAddress is `11111111111111111111111111111111`\n * We no longer need to look this up in a list of accounts from an index\n *\n * We also see the address of each account\n * For the second account, we have its address, as well as the lookup table it comes from\n * Decompiling the transaction message unpacks all the lookup accounts for us\n */\n\n// We removed the data array for brevity when we logged the instructions, but let's take a look at it now\nlog.info(decompiledTransactionMessage.instructions[0].data, '[step 3] The data bytes of the first instruction');\n\n// This is opaque, it's just a byte array, but it encodes exactly what the instruction is actually doing\n// Let's look next at how we can make sense of it\n\n/**\n * STEP 4: PARSING THE INSTRUCTIONS\n * To understand what is actually happening in each instruction, we need to decode the data field\n * We will do this by using the generated `@solana-program/system` client, which can decode data\n * from the @solana/kit instruction data structure for the System program\n * We know from the program address (11111111111111111111111111111111) that the first instruction\n * is to the system program\n * You can generate such a client for any Solana program using Codama\n * See https://github.com/codama-idl/codama for more information on Codama\n */\n\nconst firstInstruction = decompiledTransactionMessage.instructions[0];\n// Narrow the type, the `identifySystemInstruction` requires data to identify an instruction\nassertIsInstructionWithData(firstInstruction);\nconst identifiedInstruction = identifySystemInstruction(firstInstruction);\n\n// We can compare the `identifiedInstruction` to the enum values, like this\nif (identifiedInstruction === SystemInstruction.TransferSol) {\n log.info('[step 4] The first instruction calls the TransferSol instruction of the system program');\n // Narrow the type again, the instruction must have accounts to be parsed as a transfer SOL instruction\n assertIsInstructionWithAccounts(firstInstruction);\n\n // TODO: This can just be `parseTransferSolInstruction(firstInstruction)` when the client is updated\n // with the `@solana/kit` version that changes the instruction data type to `ReadonlyUint8Array`\n const parsedFirstInstruction = parseTransferSolInstruction({\n ...firstInstruction,\n data: firstInstruction.data as unknown as Uint8Array,\n });\n log.info(parsedFirstInstruction, '[step 4] The parsed Transfer SOL instruction');\n\n // This gives us an understanding of what exactly is happening in the instruction\n // We can see the source address, the destination address, and the amount of lamports\n const { accounts, data } = parsedFirstInstruction;\n log.info(\n `[step 4] In the first instruction, ${accounts.source.address} transfers ${data.amount.toLocaleString()} lamports to ${accounts.destination.address}`,\n );\n}\n\n// Now let's do the same with the second instruction\nconst secondInstruction = decompiledTransactionMessage.instructions[1];\nlog.info(`[step 4] The second instruction calls the ${secondInstruction.programAddress} program`);\n\n// We know that the second instruction is to the memo program, but we can also programmatically check this\n// Each generated client exposes its program address as a constant\nif (secondInstruction.programAddress === MEMO_PROGRAM_ADDRESS) {\n log.info(`[step 4] The second instruction calls the memo program`);\n}\n\n// The memo program only has one instruction, so there is no `identify` function\n// We know it's always an addMemo instruction\n\nassertIsInstructionWithData(secondInstruction);\n\n// TODO: This can just be `parseAddMemoInstruction(secondInstruction)` when the client is updated\n// with the `@solana/kit` version that changes the instruction data type to `ReadonlyUint8Array`\nconst parsedSecondInstruction = parseAddMemoInstruction({\n ...secondInstruction,\n data: secondInstruction.data as unknown as Uint8Array,\n});\nlog.info(parsedSecondInstruction, '[step 4] The parsed Add Memo instruction');\nlog.info(`[step 4] The second instruction adds a memo with message \"${parsedSecondInstruction.data.memo}\"`);\n\n// We've now parsed both instructions, and we know exactly what the transaction does\n" }, { "path": "examples/deserialize-transaction/tsconfig.json", "content": "{\n \"$schema\": \"https://json.schemastore.org/tsconfig\",\n \"compilerOptions\": {\n \"module\": \"NodeNext\",\n \"moduleResolution\": \"NodeNext\",\n \"noEmit\": true,\n \"target\": \"ESNext\"\n },\n \"display\": \"@solana/example-deserialize-transaction\",\n \"extends\": \"../../packages/tsconfig/base.json\",\n \"include\": [\"src\"]\n}\n" }, { "path": "examples/react-app/.gitignore", "content": "# Logs\nlogs\n*.log\nnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\npnpm-debug.log*\nlerna-debug.log*\n\nnode_modules\ndist\ndist-ssr\n*.local\n\n# Editor directories and files\n.vscode/*\n!.vscode/extensions.json\n.idea\n.DS_Store\n*.suo\n*.ntvs*\n*.njsproj\n*.sln\n*.sw?\n" }, { "path": "examples/react-app/LICENSE", "content": "Copyright (c) 2023 Solana Labs, Inc\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n" }, { "path": "examples/react-app/README.md", "content": "# @solana/example-react-app\n\nThis is an example of how to use `@solana/kit` and `@solana/react` to build a React web application.\n\n## Features\n\n- Connects to browser wallets that support the Wallet Standard; one or more at a time\n- Fetches and subscribes to the balance of the selected wallet\n- Allows you to sign an arbitrary message using a wallet account\n- Allows you to make a transfer from the selected wallet to any other connected wallet\n\n## Developing\n\nStart a server in development mode.\n\n```shell\npnpm install\npnpm turbo compile:js compile:typedefs\npnpm dev\n```\n\nPress o + Enter to open the app in a browser. Edits to the source code will automatically reload the app.\n\n## Building for deployment\n\nBuild a static bundle and HTML for deployment to a webserver.\n\n```shell\npnpm install\npnpm turbo build\n```\n\nThe contents of the `dist/` directory can now be uploaded to a webserver.\n\n## Enabling Mainnet-Beta\n\nAccess to this cluster is typically blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) rules, so it is disabled in the example app by default. To enable it, start the server or compile the application with the `REACT_EXAMPLE_APP_ENABLE_MAINNET` environment variable set to `\"true\"`.\n\n```shell\nREACT_EXAMPLE_APP_ENABLE_MAINNET=true pnpm dev\nREACT_EXAMPLE_APP_ENABLE_MAINNET=true pnpm build\n```\n" }, { "path": "examples/react-app/eslint.config.mjs", "content": "import solanaReactConfig from '@solana/eslint-config/eslint.config.react.mjs';\nimport reactRefreshPlugin from 'eslint-plugin-react-refresh';\nimport globals from 'globals';\n\nexport default [\n {\n ignores: ['**/dist', '**/*.css'],\n },\n ...solanaReactConfig,\n {\n languageOptions: {\n globals: {\n ...globals.browser,\n ...globals.es2020,\n },\n },\n plugins: {\n 'react-refresh': reactRefreshPlugin,\n },\n rules: {\n '@typescript-eslint/no-misused-promises': 'off',\n '@typescript-eslint/no-unsafe-argument': 'off',\n '@typescript-eslint/no-unsafe-assignment': 'off',\n '@typescript-eslint/restrict-template-expressions': 'error',\n 'react-refresh/only-export-components': [\n 'warn',\n {\n allowConstantExport: true,\n },\n ],\n },\n },\n];\n" }, { "path": "examples/react-app/index.html", "content": "\n\n \n \n \n \n Solana React Example App\n \n \n
\n \n \n\n" }, { "path": "examples/react-app/package.json", "content": "{\n \"name\": \"@solana/example-react-app\",\n \"private\": true,\n \"version\": \"0.0.0\",\n \"type\": \"module\",\n \"scripts\": {\n \"dev\": \"vite\",\n \"compile:js\": \"vite build\",\n \"preview\": \"vite preview\",\n \"style:fix\": \"pnpm eslint --fix src && pnpm prettier --log-level warn --ignore-unknown --write ./*\",\n \"test:lint\": \"TERM_OVERRIDE=\\\"${TURBO_HASH:+dumb}\\\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-lint.config.js --rootDir . --silent --testMatch 'src/**/*.{ts,tsx}'\",\n \"test:prettier\": \"TERM_OVERRIDE=\\\"${TURBO_HASH:+dumb}\\\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-prettier.config.js --rootDir . --silent\",\n \"test:typecheck\": \"tsc\"\n },\n \"dependencies\": {\n \"@radix-ui/react-dropdown-menu\": \"2.1.6\",\n \"@radix-ui/react-icons\": \"1.3.2\",\n \"@radix-ui/themes\": \"3.3.0\",\n \"@solana-program/system\": \"^0.12.0\",\n \"@solana/kit\": \"workspace:*\",\n \"@solana/react\": \"workspace:*\",\n \"@wallet-standard/core\": \"^1.1.1\",\n \"@wallet-standard/react\": \"^1.0.1\",\n \"react\": \"^19.2.6\",\n \"react-dom\": \"^19.2.6\",\n \"react-error-boundary\": \"^5.0.0\",\n \"swr\": \"^2.4.1\"\n },\n \"devDependencies\": {\n \"@solana/eslint-config\": \"workspace:*\",\n \"@solana/wallet-standard-features\": \"^1.3.0\",\n \"@types/react\": \"^19.2.14\",\n \"@types/react-dom\": \"^19.2.3\",\n \"@vitejs/plugin-react-swc\": \"^4.2.3\",\n \"eslint\": \"^9.39.2\",\n \"eslint-plugin-react-refresh\": \"^0.5.2\",\n \"globals\": \"^17.6.0\",\n \"jest\": \"^30.0.0-alpha.6\",\n \"vite\": \"^8.0.10\"\n }\n}\n" }, { "path": "examples/react-app/src/components/AirdropButton.tsx", "content": "import { Blockquote, Button, Dialog, Flex, Link, Text } from '@radix-ui/themes';\nimport { Address, airdropFactory, lamports, Rpc, Signature, SolanaRpcApi } from '@solana/kit';\nimport { useCallback, useContext, useMemo, useRef, useState } from 'react';\n\nimport { ChainContext } from '../context/ChainContext';\nimport { RpcContext } from '../context/RpcContext';\nimport { ErrorDialog } from './ErrorDialog';\n\nexport function AirdropButton({ address }: { address: Address }) {\n const { current: NO_ERROR } = useRef(Symbol());\n const { chain } = useContext(ChainContext);\n const { rpc, rpcSubscriptions } = useContext(RpcContext);\n const [error, setError] = useState(NO_ERROR);\n const [lastSignature, setLastSignature] = useState();\n\n const isMainnet = chain === 'solana:mainnet';\n\n // Cast RPC for airdrop, this is safe because we disable the airdrop button on mainnet\n const airdrop = useMemo(\n () => airdropFactory({ rpc: rpc as Rpc, rpcSubscriptions }),\n [rpc, rpcSubscriptions],\n );\n const [loading, setLoading] = useState(false);\n\n const handleAirdrop = useCallback(async () => {\n try {\n if (isMainnet) throw new Error('Airdrops are not available on mainnet');\n setLoading(true);\n const signature = await airdrop({\n commitment: 'confirmed',\n lamports: lamports(1_000_000_000n),\n recipientAddress: address,\n });\n setLastSignature(signature);\n setError(NO_ERROR);\n } catch (e) {\n setError(e);\n } finally {\n setLoading(false);\n }\n }, [airdrop, address, setLoading, NO_ERROR, isMainnet]);\n\n return (\n <>\n {\n if (!open) {\n setLastSignature(undefined);\n }\n }}\n >\n \n \n Airdrop to fee payer\n \n \n {lastSignature ? (\n {\n e.stopPropagation();\n }}\n >\n Airdrop successful!\n \n Signature:\n
{lastSignature}
\n \n \n View this transaction\n {' '}\n on Explorer\n \n \n \n \n \n \n \n \n ) : null}\n \n\n {error !== NO_ERROR ? (\n setError(NO_ERROR)}\n title=\"Airdrop failed\"\n />\n ) : null}\n \n );\n}\n" }, { "path": "examples/react-app/src/components/Balance.tsx", "content": "import { ExclamationTriangleIcon } from '@radix-ui/react-icons';\nimport { Text, Tooltip } from '@radix-ui/themes';\nimport { address } from '@solana/kit';\nimport type { UiWalletAccount } from '@wallet-standard/react';\nimport { useContext, useMemo } from 'react';\nimport useSWRSubscription from 'swr/subscription';\n\nimport { ChainContext } from '../context/ChainContext';\nimport { RpcContext } from '../context/RpcContext';\nimport { getErrorMessage } from '../errors';\nimport { balanceSubscribe } from '../functions/balance';\nimport { ErrorDialog } from './ErrorDialog';\n\ntype Props = Readonly<{\n account: UiWalletAccount;\n}>;\n\nconst seenErrors = new WeakSet();\n\nexport function Balance({ account }: Props) {\n const { chain } = useContext(ChainContext);\n const { rpc, rpcSubscriptions } = useContext(RpcContext);\n const subscribe = useMemo(() => balanceSubscribe.bind(null, rpc, rpcSubscriptions), [rpc, rpcSubscriptions]);\n const { data: lamports, error } = useSWRSubscription({ address: address(account.address), chain }, subscribe);\n if (error && !seenErrors.has(error)) {\n return (\n <>\n {\n seenErrors.add(error);\n }}\n title=\"Failed to fetch account balance\"\n />\n \n Could not fetch balance: {getErrorMessage(error, 'Unknown reason')}}>\n \n \n \n \n );\n } else if (lamports == null) {\n return –;\n } else {\n const formattedSolValue = new Intl.NumberFormat(undefined, { maximumFractionDigits: 5 }).format(\n // @ts-expect-error This format string is 100% allowed now.\n `${lamports}E-9`,\n );\n return {`${formattedSolValue} \\u25CE`};\n }\n}\n" }, { "path": "examples/react-app/src/components/BaseSignMessageFeaturePanel.tsx", "content": "import { Pencil1Icon } from '@radix-ui/react-icons';\nimport { Blockquote, Box, Button, Code, DataList, Dialog, Flex, TextField } from '@radix-ui/themes';\nimport { getBase64Decoder } from '@solana/kit';\nimport type { ReadonlyUint8Array } from '@wallet-standard/core';\nimport type { SyntheticEvent } from 'react';\nimport { useRef, useState } from 'react';\n\nimport { ErrorDialog } from '../components/ErrorDialog';\n\ntype Props = Readonly<{\n signMessage(message: ReadonlyUint8Array): Promise;\n}>;\n\nexport function BaseSignMessageFeaturePanel({ signMessage }: Props) {\n const { current: NO_ERROR } = useRef(Symbol());\n const [isSigningMessage, setIsSigningMessage] = useState(false);\n const [error, setError] = useState(NO_ERROR);\n const [lastSignature, setLastSignature] = useState();\n const [text, setText] = useState();\n return (\n \n {\n e.preventDefault();\n setError(NO_ERROR);\n setIsSigningMessage(true);\n try {\n const signature = await signMessage(new TextEncoder().encode(text));\n setLastSignature(signature);\n } catch (e) {\n setLastSignature(undefined);\n setError(e);\n } finally {\n setIsSigningMessage(false);\n }\n }}\n >\n \n ) => setText(e.currentTarget.value)}\n value={text}\n >\n \n \n \n \n \n {\n if (!open) {\n setLastSignature(undefined);\n }\n }}\n >\n \n \n Sign Message\n \n \n {lastSignature ? (\n {\n e.stopPropagation();\n }}\n >\n You Signed a Message!\n \n \n Message\n \n
{text}
\n \n \n \n Signature\n \n {getBase64Decoder().decode(lastSignature)}\n \n \n \n \n \n \n \n \n \n ) : null}\n \n {error !== NO_ERROR ? (\n setError(NO_ERROR)} title=\"Failed to sign message\" />\n ) : null}\n \n \n );\n}\n" }, { "path": "examples/react-app/src/components/ConnectWalletMenu.tsx", "content": "import { ExclamationTriangleIcon } from '@radix-ui/react-icons';\nimport { Button, Callout, DropdownMenu } from '@radix-ui/themes';\nimport { useSelectedWalletAccount } from '@solana/react';\nimport { StandardConnect, StandardDisconnect } from '@wallet-standard/core';\nimport type { UiWallet } from '@wallet-standard/react';\nimport { uiWalletAccountBelongsToUiWallet } from '@wallet-standard/react';\nimport { useRef, useState } from 'react';\nimport { ErrorBoundary } from 'react-error-boundary';\n\nimport { ConnectWalletMenuItem } from './ConnectWalletMenuItem';\nimport { ErrorDialog } from './ErrorDialog';\nimport { UnconnectableWalletMenuItem } from './UnconnectableWalletMenuItem';\nimport { WalletAccountIcon } from './WalletAccountIcon';\n\ntype Props = Readonly<{\n children: React.ReactNode;\n}>;\n\nexport function ConnectWalletMenu({ children }: Props) {\n const { current: NO_ERROR } = useRef(Symbol());\n const [selectedWalletAccount, setSelectedWalletAccount, wallets] = useSelectedWalletAccount();\n const [error, setError] = useState(NO_ERROR);\n const [forceClose, setForceClose] = useState(false);\n function renderItem(wallet: UiWallet) {\n return (\n }\n key={`wallet:${wallet.name}`}\n >\n {\n setSelectedWalletAccount(account);\n setForceClose(true);\n }}\n onDisconnect={wallet => {\n if (selectedWalletAccount && uiWalletAccountBelongsToUiWallet(selectedWalletAccount, wallet)) {\n setSelectedWalletAccount(undefined);\n }\n }}\n onError={setError}\n wallet={wallet}\n />\n \n );\n }\n const walletsThatSupportStandardConnect = [];\n const unconnectableWallets = [];\n for (const wallet of wallets) {\n if (wallet.features.includes(StandardConnect) && wallet.features.includes(StandardDisconnect)) {\n walletsThatSupportStandardConnect.push(wallet);\n } else {\n unconnectableWallets.push(wallet);\n }\n }\n return (\n <>\n \n \n \n \n \n {wallets.length === 0 ? (\n \n \n \n \n This browser has no wallets installed.\n \n ) : (\n <>\n {walletsThatSupportStandardConnect.map(renderItem)}\n {unconnectableWallets.length ? (\n <>\n \n {unconnectableWallets.map(renderItem)}\n \n ) : null}\n \n )}\n \n \n {error !== NO_ERROR ? setError(NO_ERROR)} /> : null}\n \n );\n}\n" }, { "path": "examples/react-app/src/components/ConnectWalletMenuItem.tsx", "content": "import { DropdownMenu } from '@radix-ui/themes';\nimport { useSelectedWalletAccount } from '@solana/react';\nimport type { UiWallet, UiWalletAccount } from '@wallet-standard/react';\nimport { uiWalletAccountsAreSame, useConnect, useDisconnect } from '@wallet-standard/react';\nimport { useCallback } from 'react';\n\nimport { WalletMenuItemContent } from './WalletMenuItemContent';\n\ntype Props = Readonly<{\n onAccountSelect(account: UiWalletAccount | undefined): void;\n onDisconnect(wallet: UiWallet): void;\n onError(err: unknown): void;\n wallet: UiWallet;\n}>;\n\nexport function ConnectWalletMenuItem({ onAccountSelect, onDisconnect, onError, wallet }: Props) {\n const [isConnecting, connect] = useConnect(wallet);\n const [isDisconnecting, disconnect] = useDisconnect(wallet);\n const isPending = isConnecting || isDisconnecting;\n const isConnected = wallet.accounts.length > 0;\n const [selectedWalletAccount] = useSelectedWalletAccount();\n const handleConnectClick = useCallback(async () => {\n try {\n const existingAccounts = [...wallet.accounts];\n const nextAccounts = await connect();\n // Try to choose the first never-before-seen account.\n for (const nextAccount of nextAccounts) {\n if (!existingAccounts.some(existingAccount => uiWalletAccountsAreSame(nextAccount, existingAccount))) {\n onAccountSelect(nextAccount);\n return;\n }\n }\n // Failing that, choose the first account in the list.\n if (nextAccounts[0]) {\n onAccountSelect(nextAccounts[0]);\n }\n } catch (e) {\n onError(e);\n }\n }, [connect, onAccountSelect, onError, wallet.accounts]);\n return (\n \n \n \n \n \n Accounts\n \n {wallet.accounts.map(account => (\n {\n onAccountSelect(account);\n }}\n >\n {account.address.slice(0, 8)}…\n \n ))}\n \n \n {\n e.preventDefault();\n await handleConnectClick();\n }}\n >\n Connect More\n \n {\n e.preventDefault();\n try {\n await disconnect();\n onDisconnect(wallet);\n } catch (e) {\n onError(e);\n }\n }}\n >\n Disconnect\n \n \n \n );\n}\n" }, { "path": "examples/react-app/src/components/DisconnectButton.tsx", "content": "import { ExclamationTriangleIcon, ExitIcon } from '@radix-ui/react-icons';\nimport { Button, Tooltip } from '@radix-ui/themes';\nimport type { UiWallet } from '@wallet-standard/react';\nimport { useDisconnect } from '@wallet-standard/react';\nimport { useState } from 'react';\n\nimport { NO_ERROR } from '../errors';\n\ntype Props = Readonly<{\n wallet: UiWallet;\n}>;\n\nexport function DisconnectButton({\n wallet,\n ...buttonProps\n}: Omit, 'color' | 'loading' | 'onClick'> & Props) {\n const [isDisconnecting, disconnect] = useDisconnect(wallet);\n const [lastError, setLastError] = useState(NO_ERROR);\n return (\n \n Error:{' '}\n {lastError && typeof lastError === 'object' && 'message' in lastError\n ? lastError.message\n : String(lastError)}\n \n }\n open={lastError !== NO_ERROR}\n side=\"left\"\n >\n {\n setLastError(NO_ERROR);\n try {\n await disconnect();\n } catch (e) {\n setLastError(e);\n }\n }}\n variant=\"outline\"\n >\n {lastError === NO_ERROR ? : }\n Disconnect\n \n \n );\n}\n" }, { "path": "examples/react-app/src/components/ErrorDialog.tsx", "content": "import { AlertDialog, Blockquote, Button, Flex } from '@radix-ui/themes';\nimport { useState } from 'react';\n\nimport { getErrorMessage } from '../errors';\n\ntype Props = Readonly<{\n error: unknown;\n onClose?(): false | void;\n title?: string;\n}>;\n\nexport function ErrorDialog({ error, onClose, title }: Props) {\n const [isOpen, setIsOpen] = useState(true);\n return (\n {\n if (!open) {\n if (!onClose || onClose() !== false) {\n setIsOpen(false);\n }\n }\n }}\n >\n \n {title ?? 'We encountered the following error'}\n \n
{getErrorMessage(error, 'Unknown')}
\n \n \n \n \n \n \n \n \n );\n}\n" }, { "path": "examples/react-app/src/components/FeatureNotSupportedCallout.tsx", "content": "import { ExclamationTriangleIcon } from '@radix-ui/react-icons';\nimport { Callout } from '@radix-ui/themes';\nimport React from 'react';\nimport type { FallbackProps } from 'react-error-boundary';\n\nimport { getErrorMessage } from '../errors';\n\ninterface Props extends Callout.RootProps, FallbackProps {}\n\nexport function FeatureNotSupportedCallout({\n error,\n resetErrorBoundary: _,\n ...rootProps\n}: Props): React.ReactElement {\n return (\n \n \n \n \n {getErrorMessage(error, 'This account does not support this feature')}\n \n );\n}\n" }, { "path": "examples/react-app/src/components/FeaturePanel.tsx", "content": "import { DataList } from '@radix-ui/themes';\nimport React from 'react';\n\ntype Props = Readonly<{\n children: React.ReactNode;\n label: React.ReactNode;\n}>;\n\nexport function FeaturePanel({ children, label }: Props) {\n return (\n \n {label}\n {children}\n \n );\n}\n" }, { "path": "examples/react-app/src/components/Nav.tsx", "content": "import { Badge, Box, DropdownMenu, Flex, Heading } from '@radix-ui/themes';\nimport { useContext } from 'react';\n\nimport { ChainContext } from '../context/ChainContext';\nimport { ConnectWalletMenu } from './ConnectWalletMenu';\nimport { SignInMenu } from './SignInMenu';\n\nexport function Nav() {\n const { displayName: currentChainName, chain, setChain } = useContext(ChainContext);\n const currentChainBadge = (\n \n {currentChainName}\n \n );\n return (\n \n \n \n \n Solana React App{' '}\n {setChain ? (\n \n {currentChainBadge}\n \n {\n setChain(value as 'solana:${string}');\n }}\n value={chain}\n >\n {process.env.REACT_EXAMPLE_APP_ENABLE_MAINNET === 'true' ? (\n \n Mainnet Beta\n \n ) : null}\n Devnet\n Testnet\n \n \n \n ) : (\n currentChainBadge\n )}\n \n \n Connect Wallet\n Sign In\n \n \n );\n}\n" }, { "path": "examples/react-app/src/components/SignInMenu.tsx", "content": "import { ExclamationTriangleIcon } from '@radix-ui/react-icons';\nimport { Button, Callout, DropdownMenu } from '@radix-ui/themes';\nimport { useSelectedWalletAccount } from '@solana/react';\nimport { SolanaSignIn } from '@solana/wallet-standard-features';\nimport type { UiWallet } from '@wallet-standard/react';\nimport { useRef, useState } from 'react';\nimport { ErrorBoundary } from 'react-error-boundary';\n\nimport { ErrorDialog } from './ErrorDialog';\nimport { SignInMenuItem } from './SignInMenuItem';\nimport { UnconnectableWalletMenuItem } from './UnconnectableWalletMenuItem';\n\ntype Props = Readonly<{\n children: React.ReactNode;\n}>;\n\nexport function SignInMenu({ children }: Props) {\n const { current: NO_ERROR } = useRef(Symbol());\n const [, setSelectedWalletAccount, wallets] = useSelectedWalletAccount();\n const [error, setError] = useState(NO_ERROR);\n const [forceClose, setForceClose] = useState(false);\n function renderItem(wallet: UiWallet) {\n return (\n }\n key={`wallet:${wallet.name}`}\n >\n {\n setSelectedWalletAccount(account);\n setForceClose(true);\n }}\n onError={setError}\n wallet={wallet}\n />\n \n );\n }\n const walletsThatSupportSignInWithSolana = [];\n for (const wallet of wallets) {\n if (wallet.features.includes(SolanaSignIn)) {\n walletsThatSupportSignInWithSolana.push(wallet);\n }\n }\n return (\n <>\n \n \n \n \n \n {walletsThatSupportSignInWithSolana.length === 0 ? (\n \n \n \n \n \n This browser has no wallets installed that support{' '}\n \n Sign In With Solana\n \n .\n \n \n ) : (\n walletsThatSupportSignInWithSolana.map(renderItem)\n )}\n \n \n {error !== NO_ERROR ? setError(NO_ERROR)} /> : null}\n \n );\n}\n" }, { "path": "examples/react-app/src/components/SignInMenuItem.tsx", "content": "import { DropdownMenu } from '@radix-ui/themes';\nimport { useSignIn } from '@solana/react';\nimport type { UiWallet, UiWalletAccount } from '@wallet-standard/react';\nimport React, { useCallback, useState } from 'react';\n\nimport { WalletMenuItemContent } from './WalletMenuItemContent';\n\ntype Props = Readonly<{\n onError(err: unknown): void;\n onSignIn(account: UiWalletAccount | undefined): void;\n wallet: UiWallet;\n}>;\n\nexport function SignInMenuItem({ onSignIn, onError, wallet }: Props) {\n const signIn = useSignIn(wallet);\n const [isSigningIn, setIsSigningIn] = useState(false);\n const handleSignInClick = useCallback(\n async (e: React.MouseEvent) => {\n e.preventDefault();\n try {\n setIsSigningIn(true);\n try {\n const { account } = await signIn({\n statement: 'You will enjoy being signed in.',\n });\n onSignIn(account);\n } finally {\n setIsSigningIn(false);\n }\n } catch (e) {\n onError(e);\n }\n },\n [signIn, onSignIn, onError],\n );\n return (\n \n \n \n );\n}\n" }, { "path": "examples/react-app/src/components/SlotIndicator.tsx", "content": "import { Link, Text } from '@radix-ui/themes';\nimport { useContext, useEffect, useState, useSyncExternalStore } from 'react';\n\nimport { ChainContext } from '../context/ChainContext';\nimport { RpcContext } from '../context/RpcContext';\n\ntype SlotNotification = Readonly<{\n parent: bigint;\n root: bigint;\n slot: bigint;\n}>;\n\ntype ReactiveStore = {\n getError(): unknown;\n getState(): T | undefined;\n subscribe(callback: () => void): () => void;\n};\n\nfunction createNoopStore(error?: unknown): ReactiveStore {\n return {\n getError: () => error,\n getState: () => undefined,\n subscribe: () => () => { },\n };\n}\n\nconst slotFormatter = new Intl.NumberFormat();\n\nexport function SlotIndicator() {\n const { rpcSubscriptions } = useContext(RpcContext);\n const { chain, solanaExplorerClusterName } = useContext(ChainContext);\n const [store, setStore] = useState>(createNoopStore);\n\n useEffect(() => {\n const abortController = new AbortController();\n rpcSubscriptions\n .slotNotifications()\n .reactive({ abortSignal: abortController.signal })\n .then(setStore)\n .catch(e => setStore(createNoopStore(e)));\n return () => abortController.abort();\n }, [rpcSubscriptions, chain]);\n\n const slot = useSyncExternalStore(store.subscribe, () => {\n if (store.getError()) throw store.getError();\n return store.getState();\n });\n\n if (!slot) {\n return {'\\u2013'};\n }\n\n return (\n \n {slotFormatter.format(slot.slot)}\n \n );\n}\n" }, { "path": "examples/react-app/src/components/SolanaPartialSignTransactionFeaturePanel.tsx", "content": "import { Blockquote, Box, Button, Dialog, Flex, Link, Select, Text, TextField } from '@radix-ui/themes';\nimport {\n Address,\n address,\n appendTransactionMessageInstruction,\n assertIsSendableTransaction,\n assertIsTransactionWithBlockhashLifetime,\n createKeyPairFromBytes,\n createTransactionMessage,\n getBase58Encoder,\n getSignatureFromTransaction,\n getTransactionDecoder,\n getTransactionEncoder,\n lamports,\n pipe,\n SendableTransaction,\n sendAndConfirmTransactionFactory,\n setTransactionMessageFeePayerSigner,\n setTransactionMessageLifetimeUsingBlockhash,\n Signature,\n SignatureBytes,\n signTransaction,\n signTransactionMessageWithSigners,\n Transaction,\n TransactionPartialSigner,\n TransactionWithBlockhashLifetime,\n} from '@solana/kit';\nimport { useWalletAccountTransactionSigner } from '@solana/react';\nimport { getTransferSolInstruction } from '@solana-program/system';\nimport { ReadonlyUint8Array } from '@wallet-standard/core';\nimport { getUiWalletAccountStorageKey, type UiWalletAccount, useWallets } from '@wallet-standard/react';\nimport type { SyntheticEvent } from 'react';\nimport { useContext, useId, useMemo, useRef, useState } from 'react';\nimport { useSWRConfig } from 'swr';\n\nimport { ChainContext } from '../context/ChainContext';\nimport { RpcContext } from '../context/RpcContext';\nimport signerBytes from '../signerBytes.json' with { type: 'json' };\nimport { AirdropButton } from './AirdropButton';\nimport { ErrorDialog } from './ErrorDialog';\nimport { WalletMenuItemContent } from './WalletMenuItemContent';\n\ntype Props = Readonly<{\n account: UiWalletAccount;\n}>;\n\nfunction solStringToLamports(solQuantityString: string) {\n if (Number.isNaN(parseFloat(solQuantityString))) {\n throw new Error('Could not parse token quantity: ' + String(solQuantityString));\n }\n const formatter = new Intl.NumberFormat('en-US', { useGrouping: false });\n const bigIntLamports = BigInt(\n // @ts-expect-error - scientific notation is supported by `Intl.NumberFormat` but the types are wrong\n formatter.format(`${solQuantityString}E9`).split('.')[0],\n );\n return lamports(bigIntLamports);\n}\n\ntype SignTransactionState =\n | {\n kind: 'creating-transaction';\n }\n | {\n kind: 'inputs-form-active';\n }\n | {\n kind: 'ready-to-send';\n recipientAddress: Address;\n transaction: SendableTransaction & Transaction & TransactionWithBlockhashLifetime;\n }\n | {\n kind: 'sending-transaction';\n };\n\nasync function mockApiRequest(serializedTransaction: ReadonlyUint8Array): Promise {\n const keypair = await createKeyPairFromBytes(new Uint8Array(signerBytes));\n const transaction = getTransactionDecoder().decode(serializedTransaction);\n const signedTransaction = await signTransaction([keypair], transaction);\n return getBase58Encoder().encode(getSignatureFromTransaction(signedTransaction)) as SignatureBytes;\n}\n\nexport function SolanaPartialSignTransactionFeaturePanel({ account }: Props) {\n const { mutate } = useSWRConfig();\n const { current: NO_ERROR } = useRef(Symbol());\n const { rpc, rpcSubscriptions } = useContext(RpcContext);\n const sendAndConfirmTransaction = useMemo(\n () => sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions }),\n [rpc, rpcSubscriptions],\n );\n const wallets = useWallets();\n const [error, setError] = useState(NO_ERROR);\n const [lastSignature, setLastSignature] = useState();\n const [solQuantityString, setSolQuantityString] = useState('');\n const [recipientAccountStorageKey, setRecipientAccountStorageKey] = useState();\n const recipientAccount = useMemo(() => {\n if (recipientAccountStorageKey) {\n for (const wallet of wallets) {\n for (const account of wallet.accounts) {\n if (getUiWalletAccountStorageKey(account) === recipientAccountStorageKey) {\n return account;\n }\n }\n }\n }\n }, [recipientAccountStorageKey, wallets]);\n const { chain: currentChain, solanaExplorerClusterName } = useContext(ChainContext);\n const transactionSigner = useWalletAccountTransactionSigner(account, currentChain);\n const lamportsInputId = useId();\n const recipientSelectId = useId();\n const [signTransactionState, setSignTransactionState] = useState({\n kind: 'inputs-form-active',\n });\n const formDisabled = signTransactionState.kind !== 'inputs-form-active';\n const formLoading =\n signTransactionState.kind === 'creating-transaction' || signTransactionState.kind === 'sending-transaction';\n\n const feePayerAddress = address('HWJowarVUwY7ewUMeFCBqwkin9RPmkmfsVPYrUszNHDV');\n const transactionEncoder = getTransactionEncoder();\n const feePayerSigner: TransactionPartialSigner = {\n address: feePayerAddress,\n async signTransactions(transactions) {\n return await Promise.all(\n transactions.map(async transaction => {\n const serializedTransaction = transactionEncoder.encode(transaction);\n const signatureBytes = await mockApiRequest(serializedTransaction);\n return { [feePayerAddress]: signatureBytes };\n }),\n );\n },\n };\n\n async function handleCreateTransaction(event: React.FormEvent) {\n event.preventDefault();\n setError(NO_ERROR);\n setSignTransactionState({ kind: 'creating-transaction' });\n try {\n const amount = solStringToLamports(solQuantityString);\n if (!recipientAccount) {\n throw new Error('The address of the recipient could not be found');\n }\n const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();\n const message = pipe(\n createTransactionMessage({ version: 0 }),\n m => setTransactionMessageFeePayerSigner(feePayerSigner, m),\n m => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),\n m =>\n appendTransactionMessageInstruction(\n getTransferSolInstruction({\n amount,\n destination: address(recipientAccount.address),\n source: transactionSigner,\n }),\n m,\n ),\n );\n const transaction = await signTransactionMessageWithSigners(message);\n assertIsSendableTransaction(transaction);\n assertIsTransactionWithBlockhashLifetime(transaction);\n setSignTransactionState({\n kind: 'ready-to-send',\n recipientAddress: recipientAccount.address as Address,\n transaction,\n });\n } catch (e) {\n setLastSignature(undefined);\n setError(e);\n setSignTransactionState({ kind: 'inputs-form-active' });\n }\n }\n\n async function handleSendTransaction(\n {\n recipientAddress,\n transaction,\n }: {\n recipientAddress: Address;\n transaction: SendableTransaction & Transaction & TransactionWithBlockhashLifetime;\n },\n event: React.FormEvent,\n ) {\n event.preventDefault();\n setError(NO_ERROR);\n setSignTransactionState({ kind: 'sending-transaction' });\n try {\n const signature = getSignatureFromTransaction(transaction);\n await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });\n void mutate({ address: transactionSigner.address, chain: currentChain });\n void mutate({ address: recipientAddress, chain: currentChain });\n setLastSignature(signature);\n setSolQuantityString('');\n setSignTransactionState({ kind: 'inputs-form-active' });\n } catch (e) {\n setLastSignature(undefined);\n setError(e);\n setSignTransactionState({ kind: 'inputs-form-active' });\n }\n }\n\n return (\n \n \n \n \n \n ) =>\n setSolQuantityString(e.currentTarget.value)\n }\n style={{ width: 'auto' }}\n type=\"number\"\n value={solQuantityString}\n >\n {'\\u25ce'}\n \n \n \n \n To Account\n \n \n \n \n \n {wallets.flatMap(wallet =>\n wallet.accounts\n .filter(({ chains }) => chains.includes(currentChain))\n .map(account => {\n const key = getUiWalletAccountStorageKey(account);\n return (\n \n \n {account.address}\n \n \n );\n }),\n )}\n \n \n \n \n\n \n\n {\n if (!open) {\n setLastSignature(undefined);\n }\n }}\n >\n \n \n {signTransactionState.kind === 'ready-to-send' ? 'Send' : 'Sign'}\n \n \n {lastSignature ? (\n {\n e.stopPropagation();\n }}\n >\n You transferred tokens!\n \n Signature:\n
{lastSignature}
\n \n \n View this transaction\n {' '}\n on Explorer\n \n \n \n \n \n \n \n \n ) : null}\n \n {error !== NO_ERROR ? (\n setError(NO_ERROR)} title=\"Transfer failed\" />\n ) : null}\n \n \n );\n}\n" }, { "path": "examples/react-app/src/components/SolanaSignAndSendTransactionFeaturePanel.tsx", "content": "import { Blockquote, Box, Button, Dialog, Flex, Link, Select, Text, TextField } from '@radix-ui/themes';\nimport {\n address,\n appendTransactionMessageInstruction,\n assertIsTransactionMessageWithSingleSendingSigner,\n createTransactionMessage,\n getBase58Decoder,\n lamports,\n pipe,\n setTransactionMessageFeePayerSigner,\n setTransactionMessageLifetimeUsingBlockhash,\n signAndSendTransactionMessageWithSigners,\n} from '@solana/kit';\nimport { useWalletAccountTransactionSendingSigner } from '@solana/react';\nimport { getTransferSolInstruction } from '@solana-program/system';\nimport { getUiWalletAccountStorageKey, type UiWalletAccount, useWallets } from '@wallet-standard/react';\nimport type { SyntheticEvent } from 'react';\nimport { useContext, useId, useMemo, useRef, useState } from 'react';\nimport { useSWRConfig } from 'swr';\n\nimport { ChainContext } from '../context/ChainContext';\nimport { RpcContext } from '../context/RpcContext';\nimport { ErrorDialog } from './ErrorDialog';\nimport { WalletMenuItemContent } from './WalletMenuItemContent';\n\ntype Props = Readonly<{\n account: UiWalletAccount;\n}>;\n\nfunction solStringToLamports(solQuantityString: string) {\n if (Number.isNaN(parseFloat(solQuantityString))) {\n throw new Error('Could not parse token quantity: ' + String(solQuantityString));\n }\n const formatter = new Intl.NumberFormat('en-US', { useGrouping: false });\n const bigIntLamports = BigInt(\n // @ts-expect-error - scientific notation is supported by `Intl.NumberFormat` but the types are wrong\n formatter.format(`${solQuantityString}E9`).split('.')[0],\n );\n return lamports(bigIntLamports);\n}\n\nexport function SolanaSignAndSendTransactionFeaturePanel({ account }: Props) {\n const { mutate } = useSWRConfig();\n const { current: NO_ERROR } = useRef(Symbol());\n const { rpc } = useContext(RpcContext);\n const wallets = useWallets();\n const [isSendingTransaction, setIsSendingTransaction] = useState(false);\n const [error, setError] = useState(NO_ERROR);\n const [lastSignature, setLastSignature] = useState();\n const [solQuantityString, setSolQuantityString] = useState('');\n const [recipientAccountStorageKey, setRecipientAccountStorageKey] = useState();\n const recipientAccount = useMemo(() => {\n if (recipientAccountStorageKey) {\n for (const wallet of wallets) {\n for (const account of wallet.accounts) {\n if (getUiWalletAccountStorageKey(account) === recipientAccountStorageKey) {\n return account;\n }\n }\n }\n }\n }, [recipientAccountStorageKey, wallets]);\n const { chain: currentChain, solanaExplorerClusterName } = useContext(ChainContext);\n const transactionSendingSigner = useWalletAccountTransactionSendingSigner(account, currentChain);\n const lamportsInputId = useId();\n const recipientSelectId = useId();\n return (\n \n {\n e.preventDefault();\n setError(NO_ERROR);\n setIsSendingTransaction(true);\n try {\n const amount = solStringToLamports(solQuantityString);\n if (!recipientAccount) {\n throw new Error('The address of the recipient could not be found');\n }\n const { value: latestBlockhash } = await rpc\n .getLatestBlockhash({ commitment: 'confirmed' })\n .send();\n const message = pipe(\n createTransactionMessage({ version: 0 }),\n m => setTransactionMessageFeePayerSigner(transactionSendingSigner, m),\n m => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),\n m =>\n appendTransactionMessageInstruction(\n getTransferSolInstruction({\n amount,\n destination: address(recipientAccount.address),\n source: transactionSendingSigner,\n }),\n m,\n ),\n );\n assertIsTransactionMessageWithSingleSendingSigner(message);\n const signature = await signAndSendTransactionMessageWithSigners(message);\n void mutate({ address: transactionSendingSigner.address, chain: currentChain });\n void mutate({ address: recipientAccount.address, chain: currentChain });\n setLastSignature(signature);\n setSolQuantityString('');\n } catch (e) {\n setLastSignature(undefined);\n setError(e);\n } finally {\n setIsSendingTransaction(false);\n }\n }}\n >\n \n \n \n ) =>\n setSolQuantityString(e.currentTarget.value)\n }\n style={{ width: 'auto' }}\n type=\"number\"\n value={solQuantityString}\n >\n {'\\u25ce'}\n \n \n \n \n To Account\n \n \n \n \n \n {wallets.flatMap(wallet =>\n wallet.accounts\n .filter(({ chains }) => chains.includes(currentChain))\n .map(account => {\n const key = getUiWalletAccountStorageKey(account);\n return (\n \n \n {account.address}\n \n \n );\n }),\n )}\n \n \n \n \n {\n if (!open) {\n setLastSignature(undefined);\n }\n }}\n >\n \n \n Transfer\n \n \n {lastSignature ? (\n {\n e.stopPropagation();\n }}\n >\n You transferred tokens!\n \n Signature:\n
{getBase58Decoder().decode(lastSignature)}
\n \n \n View this transaction\n {' '}\n on Explorer\n \n \n \n \n \n \n \n \n ) : null}\n \n {error !== NO_ERROR ? (\n setError(NO_ERROR)} title=\"Transfer failed\" />\n ) : null}\n \n \n );\n}\n" }, { "path": "examples/react-app/src/components/SolanaSignMessageFeaturePanel.tsx", "content": "import type { Address } from '@solana/kit';\nimport { useWalletAccountMessageSigner } from '@solana/react';\nimport type { ReadonlyUint8Array } from '@wallet-standard/core';\nimport type { UiWalletAccount } from '@wallet-standard/react';\nimport { useCallback } from 'react';\n\nimport { BaseSignMessageFeaturePanel } from './BaseSignMessageFeaturePanel';\n\ntype Props = Readonly<{\n account: UiWalletAccount;\n}>;\n\nexport function SolanaSignMessageFeaturePanel({ account }: Props) {\n const messageSigner = useWalletAccountMessageSigner(account);\n const signMessage = useCallback(\n async (message: ReadonlyUint8Array) => {\n const [result] = await messageSigner.modifyAndSignMessages([\n {\n content: message as Uint8Array,\n signatures: {},\n },\n ]);\n const signature = result?.signatures[account.address as Address];\n if (!signature) {\n throw new Error();\n }\n return signature as ReadonlyUint8Array;\n },\n [account.address, messageSigner],\n );\n return ;\n}\n" }, { "path": "examples/react-app/src/components/SolanaSignTransactionFeaturePanel.tsx", "content": "import { Blockquote, Box, Button, Dialog, Flex, Link, Select, Text, TextField } from '@radix-ui/themes';\nimport {\n Address,\n address,\n appendTransactionMessageInstruction,\n assertIsSendableTransaction,\n assertIsTransactionWithBlockhashLifetime,\n createTransactionMessage,\n getSignatureFromTransaction,\n lamports,\n pipe,\n SendableTransaction,\n sendAndConfirmTransactionFactory,\n setTransactionMessageFeePayerSigner,\n setTransactionMessageLifetimeUsingBlockhash,\n Signature,\n signTransactionMessageWithSigners,\n Transaction,\n TransactionWithBlockhashLifetime,\n} from '@solana/kit';\nimport { useWalletAccountTransactionSigner } from '@solana/react';\nimport { getTransferSolInstruction } from '@solana-program/system';\nimport { getUiWalletAccountStorageKey, type UiWalletAccount, useWallets } from '@wallet-standard/react';\nimport type { SyntheticEvent } from 'react';\nimport { useContext, useId, useMemo, useRef, useState } from 'react';\nimport { useSWRConfig } from 'swr';\n\nimport { ChainContext } from '../context/ChainContext';\nimport { RpcContext } from '../context/RpcContext';\nimport { ErrorDialog } from './ErrorDialog';\nimport { WalletMenuItemContent } from './WalletMenuItemContent';\n\ntype Props = Readonly<{\n account: UiWalletAccount;\n}>;\n\nfunction solStringToLamports(solQuantityString: string) {\n if (Number.isNaN(parseFloat(solQuantityString))) {\n throw new Error('Could not parse token quantity: ' + String(solQuantityString));\n }\n const formatter = new Intl.NumberFormat('en-US', { useGrouping: false });\n const bigIntLamports = BigInt(\n // @ts-expect-error - scientific notation is supported by `Intl.NumberFormat` but the types are wrong\n formatter.format(`${solQuantityString}E9`).split('.')[0],\n );\n return lamports(bigIntLamports);\n}\n\ntype SignTransactionState =\n | {\n kind: 'creating-transaction';\n }\n | {\n kind: 'inputs-form-active';\n }\n | {\n kind: 'ready-to-send';\n recipientAddress: Address;\n transaction: SendableTransaction & Transaction & TransactionWithBlockhashLifetime;\n }\n | {\n kind: 'sending-transaction';\n };\n\nexport function SolanaSignTransactionFeaturePanel({ account }: Props) {\n const { mutate } = useSWRConfig();\n const { current: NO_ERROR } = useRef(Symbol());\n const { rpc, rpcSubscriptions } = useContext(RpcContext);\n const sendAndConfirmTransaction = useMemo(\n () => sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions }),\n [rpc, rpcSubscriptions],\n );\n const wallets = useWallets();\n const [error, setError] = useState(NO_ERROR);\n const [lastSignature, setLastSignature] = useState();\n const [solQuantityString, setSolQuantityString] = useState('');\n const [recipientAccountStorageKey, setRecipientAccountStorageKey] = useState();\n const recipientAccount = useMemo(() => {\n if (recipientAccountStorageKey) {\n for (const wallet of wallets) {\n for (const account of wallet.accounts) {\n if (getUiWalletAccountStorageKey(account) === recipientAccountStorageKey) {\n return account;\n }\n }\n }\n }\n }, [recipientAccountStorageKey, wallets]);\n const { chain: currentChain, solanaExplorerClusterName } = useContext(ChainContext);\n const transactionSigner = useWalletAccountTransactionSigner(account, currentChain);\n const lamportsInputId = useId();\n const recipientSelectId = useId();\n const [signTransactionState, setSignTransactionState] = useState({\n kind: 'inputs-form-active',\n });\n const formDisabled = signTransactionState.kind !== 'inputs-form-active';\n const formLoading =\n signTransactionState.kind === 'creating-transaction' || signTransactionState.kind === 'sending-transaction';\n\n async function handleCreateTransaction(event: React.FormEvent) {\n event.preventDefault();\n setError(NO_ERROR);\n setSignTransactionState({ kind: 'creating-transaction' });\n try {\n const amount = solStringToLamports(solQuantityString);\n if (!recipientAccount) {\n throw new Error('The address of the recipient could not be found');\n }\n const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();\n const message = pipe(\n createTransactionMessage({ version: 0 }),\n m => setTransactionMessageFeePayerSigner(transactionSigner, m),\n m => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),\n m =>\n appendTransactionMessageInstruction(\n getTransferSolInstruction({\n amount,\n destination: address(recipientAccount.address),\n source: transactionSigner,\n }),\n m,\n ),\n );\n const transaction = await signTransactionMessageWithSigners(message);\n assertIsSendableTransaction(transaction);\n assertIsTransactionWithBlockhashLifetime(transaction);\n setSignTransactionState({\n kind: 'ready-to-send',\n recipientAddress: recipientAccount.address as Address,\n transaction,\n });\n } catch (e) {\n setLastSignature(undefined);\n setError(e);\n setSignTransactionState({ kind: 'inputs-form-active' });\n }\n }\n\n async function handleSendTransaction(\n {\n recipientAddress,\n transaction,\n }: {\n recipientAddress: Address;\n transaction: SendableTransaction & Transaction & TransactionWithBlockhashLifetime;\n },\n event: React.FormEvent,\n ) {\n event.preventDefault();\n setError(NO_ERROR);\n setSignTransactionState({ kind: 'sending-transaction' });\n try {\n const signature = getSignatureFromTransaction(transaction);\n await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });\n void mutate({ address: transactionSigner.address, chain: currentChain });\n void mutate({ address: recipientAddress, chain: currentChain });\n setLastSignature(signature);\n setSolQuantityString('');\n setSignTransactionState({ kind: 'inputs-form-active' });\n } catch (e) {\n setLastSignature(undefined);\n setError(e);\n setSignTransactionState({ kind: 'inputs-form-active' });\n }\n }\n\n return (\n \n \n \n \n \n ) =>\n setSolQuantityString(e.currentTarget.value)\n }\n style={{ width: 'auto' }}\n type=\"number\"\n value={solQuantityString}\n >\n {'\\u25ce'}\n \n \n \n \n To Account\n \n \n \n \n \n {wallets.flatMap(wallet =>\n wallet.accounts\n .filter(({ chains }) => chains.includes(currentChain))\n .map(account => {\n const key = getUiWalletAccountStorageKey(account);\n return (\n \n \n {account.address}\n \n \n );\n }),\n )}\n \n \n \n \n {\n if (!open) {\n setLastSignature(undefined);\n }\n }}\n >\n \n \n {signTransactionState.kind === 'ready-to-send' ? 'Send' : 'Sign'}\n \n \n {lastSignature ? (\n {\n e.stopPropagation();\n }}\n >\n You transferred tokens!\n \n Signature:\n
{lastSignature}
\n \n \n View this transaction\n {' '}\n on Explorer\n \n \n \n \n \n \n \n \n ) : null}\n \n {error !== NO_ERROR ? (\n setError(NO_ERROR)} title=\"Transfer failed\" />\n ) : null}\n \n \n );\n}\n" }, { "path": "examples/react-app/src/components/UnconnectableWalletMenuItem.tsx", "content": "import { ExclamationTriangleIcon } from '@radix-ui/react-icons';\nimport { Box, DropdownMenu, Text } from '@radix-ui/themes';\nimport type { UiWallet } from '@wallet-standard/react';\nimport { useState } from 'react';\n\nimport { ErrorDialog } from './ErrorDialog';\nimport { WalletMenuItemContent } from './WalletMenuItemContent';\n\ntype Props = Readonly<{\n error: unknown;\n wallet: UiWallet;\n}>;\n\nexport function UnconnectableWalletMenuItem({ error, wallet }: Props) {\n const [dialogIsOpen, setDialogIsOpen] = useState(false);\n return (\n <>\n setDialogIsOpen(true)}>\n \n {wallet.name}\n \n \n \n \n \n {dialogIsOpen ? (\n setDialogIsOpen(false)} title=\"Unconnectable wallet\" />\n ) : null}\n \n );\n}\n" }, { "path": "examples/react-app/src/components/WalletAccountIcon.tsx", "content": "import type { UiWalletAccount } from '@wallet-standard/react';\nimport { uiWalletAccountBelongsToUiWallet, useWallets } from '@wallet-standard/react';\nimport React from 'react';\n\ntype Props = React.ComponentProps<'img'> &\n Readonly<{\n account: UiWalletAccount;\n }>;\n\nexport function WalletAccountIcon({ account, ...imgProps }: Props) {\n const wallets = useWallets();\n let icon;\n if (account.icon) {\n icon = account.icon;\n } else {\n for (const wallet of wallets) {\n if (uiWalletAccountBelongsToUiWallet(account, wallet)) {\n icon = wallet.icon;\n break;\n }\n }\n }\n return icon ? : null;\n}\n" }, { "path": "examples/react-app/src/components/WalletMenuItemContent.tsx", "content": "import { Avatar, Flex, Spinner, Text } from '@radix-ui/themes';\nimport type { UiWallet } from '@wallet-standard/react';\nimport React from 'react';\n\ntype Props = Readonly<{\n children?: React.ReactNode;\n loading?: boolean;\n wallet: UiWallet;\n}>;\n\nexport function WalletMenuItemContent({ children, loading, wallet }: Props) {\n return (\n \n \n {wallet.name.slice(0, 1)}}\n radius=\"none\"\n src={wallet.icon}\n style={{ height: 18, width: 18 }}\n />\n \n {children ?? wallet.name}\n \n );\n}\n" }, { "path": "examples/react-app/src/context/ChainContext.tsx", "content": "import type { ClusterUrl } from '@solana/kit';\nimport { devnet } from '@solana/kit';\nimport { createContext } from 'react';\n\nexport type ChainContext = Readonly<{\n chain: `solana:${string}`;\n displayName: string;\n setChain?(chain: `solana:${string}`): void;\n solanaExplorerClusterName: 'devnet' | 'mainnet-beta' | 'testnet';\n solanaRpcSubscriptionsUrl: ClusterUrl;\n solanaRpcUrl: ClusterUrl;\n}>;\n\nexport const DEFAULT_CHAIN_CONFIG = Object.freeze({\n chain: 'solana:devnet',\n displayName: 'Devnet',\n solanaExplorerClusterName: 'devnet',\n solanaRpcSubscriptionsUrl: devnet('wss://api.devnet.solana.com'),\n solanaRpcUrl: devnet('https://api.devnet.solana.com'),\n});\n\nexport const ChainContext = createContext(DEFAULT_CHAIN_CONFIG);\n" }, { "path": "examples/react-app/src/context/ChainContextProvider.tsx", "content": "import { mainnet, testnet } from '@solana/kit';\nimport { useMemo, useState } from 'react';\n\nimport { ChainContext, DEFAULT_CHAIN_CONFIG } from './ChainContext';\n\nconst STORAGE_KEY = 'solana-example-react-app:selected-chain';\n\nexport function ChainContextProvider({ children }: { children: React.ReactNode }) {\n const [chain, setChain] = useState(() => localStorage.getItem(STORAGE_KEY) ?? 'solana:devnet');\n const contextValue = useMemo(() => {\n switch (chain) {\n // @ts-expect-error Intentional fall through\n case 'solana:mainnet':\n if (process.env.REACT_EXAMPLE_APP_ENABLE_MAINNET === 'true') {\n return {\n chain: 'solana:mainnet',\n displayName: 'Mainnet Beta',\n solanaExplorerClusterName: 'mainnet-beta',\n solanaRpcSubscriptionsUrl: mainnet('wss://api.mainnet-beta.solana.com'),\n solanaRpcUrl: mainnet('https://api.mainnet-beta.solana.com'),\n };\n }\n // falls through\n case 'solana:testnet':\n return {\n chain: 'solana:testnet',\n displayName: 'Testnet',\n solanaExplorerClusterName: 'testnet',\n solanaRpcSubscriptionsUrl: testnet('wss://api.testnet.solana.com'),\n solanaRpcUrl: testnet('https://api.testnet.solana.com'),\n };\n case 'solana:devnet':\n default:\n if (chain !== 'solana:devnet') {\n localStorage.removeItem(STORAGE_KEY);\n console.error(`Unrecognized chain \\`${chain}\\``);\n }\n return DEFAULT_CHAIN_CONFIG;\n }\n }, [chain]);\n return (\n ({\n ...contextValue,\n setChain(chain) {\n localStorage.setItem(STORAGE_KEY, chain);\n setChain(chain);\n },\n }),\n [contextValue],\n )}\n >\n {children}\n \n );\n}\n" }, { "path": "examples/react-app/src/context/RpcContext.tsx", "content": "import type { Rpc, RpcSubscriptions, SolanaRpcApiMainnet, SolanaRpcSubscriptionsApi } from '@solana/kit';\nimport { createSolanaRpc, createSolanaRpcSubscriptions, devnet } from '@solana/kit';\nimport { createContext } from 'react';\n\nexport const RpcContext = createContext<{\n rpc: Rpc; // Limit the API to only those methods found on Mainnet (ie. not `requestAirdrop`)\n rpcSubscriptions: RpcSubscriptions;\n}>({\n rpc: createSolanaRpc(devnet('https://api.devnet.solana.com')),\n rpcSubscriptions: createSolanaRpcSubscriptions(devnet('wss://api.devnet.solana.com')),\n});\n" }, { "path": "examples/react-app/src/context/RpcContextProvider.tsx", "content": "import { createSolanaRpc, createSolanaRpcSubscriptions } from '@solana/kit';\nimport { ReactNode, useContext, useMemo } from 'react';\n\nimport { ChainContext } from './ChainContext';\nimport { RpcContext } from './RpcContext';\n\ntype Props = Readonly<{\n children: ReactNode;\n}>;\n\nexport function RpcContextProvider({ children }: Props) {\n const { solanaRpcSubscriptionsUrl, solanaRpcUrl } = useContext(ChainContext);\n return (\n ({\n rpc: createSolanaRpc(solanaRpcUrl),\n rpcSubscriptions: createSolanaRpcSubscriptions(solanaRpcSubscriptionsUrl),\n }),\n [solanaRpcSubscriptionsUrl, solanaRpcUrl],\n )}\n >\n {children}\n \n );\n}\n" }, { "path": "examples/react-app/src/errors.tsx", "content": "import { Code, Flex, Text } from '@radix-ui/themes';\nimport { isSolanaError, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE } from '@solana/kit';\nimport {\n isWalletStandardError,\n WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_CHAIN_UNSUPPORTED,\n WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_FEATURE_UNIMPLEMENTED,\n WALLET_STANDARD_ERROR__FEATURES__WALLET_FEATURE_UNIMPLEMENTED,\n} from '@wallet-standard/core';\nimport React from 'react';\n\nexport const NO_ERROR = Symbol();\n\nexport function getErrorMessage(err: unknown, fallbackMessage: React.ReactNode): React.ReactNode {\n if (isWalletStandardError(err, WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_FEATURE_UNIMPLEMENTED)) {\n return (\n <>\n This account does not support the {err.context.featureName} feature\n \n );\n } else if (isWalletStandardError(err, WALLET_STANDARD_ERROR__FEATURES__WALLET_FEATURE_UNIMPLEMENTED)) {\n return (\n \n \n The wallet '{err.context.walletName}' (\n {err.context.supportedChains.sort().map((chain, ii, { length }) => (\n \n {chain}\n {ii === length - 1 ? null : ', '}\n \n ))}\n ) does not support the {err.context.featureName} feature.\n \n \n Features supported:\n
    \n {err.context.supportedFeatures.sort().map(featureName => (\n
  • \n {featureName}\n
    • \n ))}\n
\n \n \n );\n } else if (isWalletStandardError(err, WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_CHAIN_UNSUPPORTED)) {\n return (\n \n \n This account does not support the chain {err.context.chain}.\n \n \n Chains supported:\n
    \n {err.context.supportedChains.sort().map(chain => (\n
  • \n {chain}\n
    • \n ))}\n
\n \n \n );\n } else if (isSolanaError(err, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE)) {\n return (\n \n {err.message}\n \n Transaction logs:\n
    \n {Object.entries(err.context.logs ?? []).map(([key, value]) => (\n
  1. {String(value)}
    2. \n ))}\n
\n \n \n );\n } else if (err && typeof err === 'object' && 'message' in err) {\n return String(err.message);\n }\n return fallbackMessage;\n}\n" }, { "path": "examples/react-app/src/functions/balance.ts", "content": "import {\n AccountNotificationsApi,\n Address,\n createReactiveStoreWithInitialValueAndSlotTracking,\n GetBalanceApi,\n Lamports,\n Rpc,\n RpcSubscriptions,\n} from '@solana/kit';\nimport { SWRSubscription } from 'swr/subscription';\n\n/**\n * This is an example of a strategy to fetch some account data and to keep it up to date over time.\n * It's implemented as an SWR subscription function (https://swr.vercel.app/docs/subscription) but\n * the approach is generalizable.\n *\n * It uses {@link createReactiveStoreWithInitialValueAndSlotTracking} to combine an initial RPC fetch with an\n * ongoing subscription, using slot-based comparison to ensure only the latest value is published.\n */\nexport function balanceSubscribe(\n rpc: Rpc,\n rpcSubscriptions: RpcSubscriptions,\n ...subscriptionArgs: Parameters>\n) {\n const [{ address }, { next }] = subscriptionArgs;\n const abortController = new AbortController();\n const store = createReactiveStoreWithInitialValueAndSlotTracking({\n abortSignal: abortController.signal,\n rpcRequest: rpc.getBalance(address, { commitment: 'confirmed' }),\n rpcSubscriptionRequest: rpcSubscriptions.accountNotifications(address),\n rpcSubscriptionValueMapper: ({ lamports }) => lamports,\n rpcValueMapper: lamports => lamports,\n });\n store.subscribe(() => {\n const error = store.getError();\n if (error) {\n next(error as Error);\n } else {\n next(null, store.getState()?.value);\n }\n });\n return () => {\n abortController.abort();\n };\n}\n" }, { "path": "examples/react-app/src/hooks/useStable.ts", "content": "/* eslint-disable react-hooks/refs */\nimport { useRef } from 'react';\n\nconst UNRESOLVED = Symbol();\n\nexport function useStable(getValue: () => T): T {\n const ref = useRef(UNRESOLVED);\n if (ref.current === UNRESOLVED) {\n ref.current = getValue();\n }\n return ref.current;\n}\n" }, { "path": "examples/react-app/src/index.css", "content": "@import './reset.css';\n" }, { "path": "examples/react-app/src/main.tsx", "content": "import './index.css';\nimport '@radix-ui/themes/styles.css';\n\nimport { Flex, Section, Theme } from '@radix-ui/themes';\nimport { SelectedWalletAccountContextProvider } from '@solana/react';\nimport type { UiWallet } from '@wallet-standard/react';\nimport { StrictMode } from 'react';\nimport { createRoot } from 'react-dom/client';\n\nimport { Nav } from './components/Nav.tsx';\nimport { ChainContextProvider } from './context/ChainContextProvider.tsx';\nimport { RpcContextProvider } from './context/RpcContextProvider.tsx';\nimport Root from './routes/root.tsx';\n\nconst STORAGE_KEY = 'solana-wallet-standard-example-react:selected-wallet-and-address';\nconst stateSync = {\n deleteSelectedWallet: () => localStorage.removeItem(STORAGE_KEY),\n getSelectedWallet: () => localStorage.getItem(STORAGE_KEY),\n storeSelectedWallet: (accountKey: string) => localStorage.setItem(STORAGE_KEY, accountKey),\n};\n\nconst rootNode = document.getElementById('root')!;\nconst root = createRoot(rootNode);\nroot.render(\n \n \n \n true} stateSync={stateSync}>\n \n \n