@solana/plugin-interfaces 0.0.0 → 6.1.0-canary-20260216194225

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2025 Anza Technology, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,173 @@
+[![npm][npm-image]][npm-url]
+[![npm-downloads][npm-downloads-image]][npm-url]
+<br />
+[![code-style-prettier][code-style-prettier-image]][code-style-prettier-url]
+
+[code-style-prettier-image]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square
+[code-style-prettier-url]: https://github.com/prettier/prettier
+[npm-downloads-image]: https://img.shields.io/npm/dm/@solana/plugin-interfaces?style=flat
+[npm-image]: https://img.shields.io/npm/v/@solana/plugin-interfaces?style=flat
+[npm-url]: https://www.npmjs.com/package/@solana/plugin-interfaces
+
+# @solana/plugin-interfaces
+
+This package defines common TypeScript interfaces for features that Kit plugins can provide or require. It can be used standalone, but it is also exported as part of Kit [`@solana/kit`](https://github.com/anza-xyz/kit/tree/main/packages/kit).
+
+## Overview
+
+When building Solana applications, different environments require different capabilities. A browser wallet might support signing but not RPC calls. A testing environment might support airdrops. A full client might support everything.
+
+These interfaces serve two purposes:
+
+- **Plugins can provide capabilities**: A plugin can implement these interfaces to add features to a client (e.g., a plugin that adds airdrop support implements `ClientWithAirdrop`).
+- **Plugins can require capabilities**: A plugin can declare which capabilities it needs from the client to function (e.g., a token plugin might require `ClientWithRpc` to fetch account data).
+
+This enables a composable plugin architecture where plugins can build on top of each other's capabilities.
+
+## Installation
+
+```bash
+npm install @solana/plugin-interfaces
+```
+
+## Interfaces
+
+### `ClientWithPayer`
+
+Represents a client that provides a default transaction payer.
+
+```ts
+import { ClientWithPayer } from '@solana/plugin-interfaces';
+
+function memoPlugin() {
+    return <T extends ClientWithPayer>(client: T) => ({
+        ...client,
+        sendMemo: (message: string) => {
+            // Use client.payer as the fee payer for the memo transaction
+            const feePayer = client.payer;
+            // ...
+        },
+    });
+}
+```
+
+### `ClientWithAirdrop`
+
+Represents a client that can request SOL airdrops (typically on devnet/testnet). The airdrop succeeds when the promise resolves. Some implementations (e.g., LiteSVM) update balances directly without a transaction, so no signature is returned in those cases.
+
+```ts
+import { ClientWithAirdrop, ClientWithPayer } from '@solana/plugin-interfaces';
+
+function faucetPlugin() {
+    return <T extends ClientWithAirdrop & ClientWithPayer>(client: T) => ({
+        ...client,
+        fundMyself: async (amount: Lamports) => {
+            await client.airdrop(client.payer.address, amount);
+        },
+    });
+}
+```
+
+### `ClientWithRpc<TRpcMethods>`
+
+Represents a client with access to a Solana RPC endpoint.
+
+```ts
+import { ClientWithRpc } from '@solana/plugin-interfaces';
+import { GetBalanceApi } from '@solana/rpc-api';
+
+function balancePlugin() {
+    return <T extends ClientWithRpc<GetBalanceApi>>(client: T) => ({
+        ...client,
+        getBalance: async (address: Address): Promise<Lamports> => {
+            const { value } = await client.rpc.getBalance(address).send();
+            return value;
+        },
+    });
+}
+```
+
+### `ClientWithRpcSubscriptions<TRpcSubscriptionsMethods>`
+
+Represents a client that provides access to Solana RPC subscriptions for real-time notifications such as account changes, slot updates, and transaction confirmations.
+
+```ts
+import { ClientWithRpcSubscriptions } from '@solana/plugin-interfaces';
+import { AccountNotificationsApi } from '@solana/rpc-subscriptions-api';
+
+function accountWatcherPlugin() {
+    return <T extends ClientWithRpcSubscriptions<AccountNotificationsApi>>(client: T) => ({
+        ...client,
+        onAccountChange: async (address: Address, callback: (lamports: Lamports) => void) => {
+            const subscription = await client.rpcSubscriptions.accountNotifications(address).subscribe();
+            for await (const notification of subscription) {
+                callback(notification.value.lamports);
+            }
+        },
+    });
+}
+```
+
+### `ClientWithTransactionPlanning`
+
+Represents a client that can convert instructions or instruction plans into transaction plans.
+
+```ts
+import { flattenTransactionPlan } from '@solana/instruction-plans';
+import { ClientWithTransactionPlanning } from '@solana/plugin-interfaces';
+
+function transactionCounterPlugin() {
+    return <T extends ClientWithTransactionPlanning>(client: T) => ({
+        ...client,
+        countTransactions: async (instructions: IInstruction[]) => {
+            const plan = await client.planTransactions(instructions);
+            return flattenTransactionPlan(plan).length;
+        },
+    });
+}
+```
+
+### `ClientWithTransactionSending`
+
+Represents a client that can send transactions to the Solana network. It supports flexible input formats including instructions, instruction plans, transaction messages, or transaction plans.
+
+```ts
+import { ClientWithPayer, ClientWithTransactionSending } from '@solana/plugin-interfaces';
+
+function transferPlugin() {
+    return <T extends ClientWithPayer & ClientWithTransactionSending>(client: T) => ({
+        ...client,
+        transfer: async (recipient: Address, amount: Lamports) => {
+            const instruction = getTransferSolInstruction({
+                source: client.payer,
+                destination: recipient,
+                amount,
+            });
+            const result = await client.sendTransaction(instruction);
+            return result.context.signature;
+        },
+    });
+}
+```
+
+## Combining Interfaces
+
+Use TypeScript intersection types to require multiple capabilities from the client:
+
+```ts
+import { ClientWithPayer, ClientWithRpc, ClientWithTransactionSending } from '@solana/plugin-interfaces';
+import { GetAccountInfoApi } from '@solana/rpc-api';
+
+function tokenTransferPlugin() {
+    return <T extends ClientWithPayer & ClientWithRpc<GetAccountInfoApi> & ClientWithTransactionSending>(
+        client: T,
+    ) => ({
+        ...client,
+        transferToken: async (mint: Address, recipient: Address, amount: bigint) => {
+            // Use client.rpc to fetch token accounts
+            // Use client.payer as the token owner
+            // Use client.sendTransaction to execute the transfer
+        },
+    });
+}
+```

package/dist/types/airdrop.d.ts

@@ -0,0 +1,34 @@
+import { Address } from '@solana/addresses';
+import { Signature } from '@solana/keys';
+import { Lamports } from '@solana/rpc-types';
+/**
+ * Represents a client that can request airdrops of SOL to a specified address.
+ *
+ * The airdrop capability is typically available on test networks (devnet, testnet)
+ * and local validators. It allows funding accounts with SOL for testing purposes.
+ *
+ * @example
+ * ```ts
+ * async function fundAccount(client: ClientWithAirdrop, address: Address) {
+ *     const signature = await client.airdrop(address, lamports(1_000_000_000n));
+ *     console.log(`Airdrop confirmed: ${signature ?? '[no signature]'}`);
+ * }
+ * ```
+ */
+export type ClientWithAirdrop = {
+    /**
+     * Requests an airdrop of SOL to the specified address.
+     *
+     * The returned promise resolves when the airdrop succeeds and rejects on failure.
+     * Some implementations (e.g., LiteSVM) update account balances directly without
+     * sending a transaction, in which case no signature is returned.
+     *
+     * @param address - The address to receive the airdrop.
+     * @param amount - The amount of lamports to airdrop.
+     * @param abortSignal - An optional signal to abort the airdrop request.
+     * @returns A promise resolving to the transaction signature if the airdrop was
+     *          performed via a transaction, or `undefined` if no transaction was used.
+     */
+    airdrop: (address: Address, amount: Lamports, abortSignal?: AbortSignal) => Promise<Signature | undefined>;
+};
+//# sourceMappingURL=airdrop.d.ts.map

package/dist/types/airdrop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"airdrop.d.ts","sourceRoot":"","sources":["../../src/airdrop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC5B;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;CAC9G,CAAC"}

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This package defines common TypeScript interfaces for features that Kit plugins
+ * can provide or require. It can be used standalone, but it is also exported as part
+ * of Kit [`@solana/kit`](https://github.com/anza-xyz/kit/tree/main/packages/kit).
+ *
+ * @packageDocumentation
+ */
+export * from './airdrop';
+export * from './instruction-plans';
+export * from './payer';
+export * from './rpc';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC"}

package/dist/types/instruction-plans.d.ts

@@ -0,0 +1,104 @@
+import type { InstructionPlanInput, SingleTransactionPlan, SuccessfulSingleTransactionPlanResult, TransactionPlan, TransactionPlanInput, TransactionPlanResult } from '@solana/instruction-plans';
+type Config = {
+    abortSignal?: AbortSignal;
+};
+/**
+ * Represents a client that can plan transactions from instruction inputs.
+ *
+ * Transaction planning converts high-level instruction plans into concrete
+ * transaction messages, handling concerns like blockhash fetching, transaction
+ * splitting for size limits, and instruction ordering.
+ *
+ * @example
+ * ```ts
+ * async function prepareTransfer(client: ClientWithTransactionPlanning) {
+ *     const instructions = [createTransferInstruction(...)];
+ *
+ *     // Plan a single transaction
+ *     const message = await client.planTransaction(instructions);
+ *
+ *     // Or plan potentially multiple transactions if needed
+ *     const plan = await client.planTransactions(instructions);
+ * }
+ * ```
+ */
+export type ClientWithTransactionPlanning = {
+    /**
+     * Plans a single transaction from the given instruction input.
+     *
+     * Use this when you expect all instructions to fit in a single transaction.
+     *
+     * @param input - The instruction plan input (instructions or instruction plans).
+     * @param config - Optional configuration including an abort signal.
+     * @returns A promise resolving to the planned transaction message.
+     *
+     * @see {@link InstructionPlanInput}
+     */
+    planTransaction: (input: InstructionPlanInput, config?: Config) => Promise<SingleTransactionPlan['message']>;
+    /**
+     * Plans one or more transactions from the given instruction input.
+     *
+     * Use this when instructions might need to be split across multiple
+     * transactions due to size limits.
+     *
+     * @param input - The instruction plan input (instructions or instruction plans).
+     * @param config - Optional configuration including an abort signal.
+     * @returns A promise resolving to the full transaction plan.
+     *
+     * @see {@link InstructionPlanInput}
+     */
+    planTransactions: (input: InstructionPlanInput, config?: Config) => Promise<TransactionPlan>;
+};
+/**
+ * Represents a client that can send transactions to the Solana network.
+ *
+ * Transaction sending handles signing, submission, and confirmation of
+ * transactions. It supports flexible input formats including instructions,
+ * instruction plans, transaction messages or transaction plans.
+ *
+ * @example
+ * ```ts
+ * async function executeTransfer(client: ClientWithTransactionSending) {
+ *     const instructions = [createTransferInstruction(...)];
+ *
+ *     // Send a single transaction
+ *     const result = await client.sendTransaction(instructions);
+ *     console.log(`Transaction confirmed: ${result.context.signature}`);
+ *
+ *     // Or send potentially multiple transactions
+ *     const results = await client.sendTransactions(instructions);
+ * }
+ * ```
+ */
+export type ClientWithTransactionSending = {
+    /**
+     * Sends a single transaction to the network.
+     *
+     * Accepts flexible input: instructions, instruction plans, a single
+     * transaction message or a single transaction plan.
+     *
+     * @param input - Instructions, a transaction plan, or a transaction message.
+     * @param config - Optional configuration including an abort signal.
+     * @returns A promise resolving to the successful transaction result.
+     *
+     * @see {@link InstructionPlanInput}
+     * @see {@link SingleTransactionPlan}
+     */
+    sendTransaction: (input: InstructionPlanInput | SingleTransactionPlan | SingleTransactionPlan['message'], config?: Config) => Promise<SuccessfulSingleTransactionPlanResult>;
+    /**
+     * Sends one or more transactions to the network.
+     *
+     * Accepts flexible input: instructions, instruction plans, transaction messages
+     * or transaction plans.
+     *
+     * @param input - Any instruction or a transaction plan input.
+     * @param config - Optional configuration including an abort signal.
+     * @returns A promise resolving to the results for all transactions.
+     *
+     * @see {@link InstructionPlanInput}
+     * @see {@link TransactionPlanInput}
+     */
+    sendTransactions: (input: InstructionPlanInput | TransactionPlanInput, config?: Config) => Promise<TransactionPlanResult>;
+};
+export {};
+//# sourceMappingURL=instruction-plans.d.ts.map

package/dist/types/instruction-plans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-plans.d.ts","sourceRoot":"","sources":["../../src/instruction-plans.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,oBAAoB,EACpB,qBAAqB,EACrB,qCAAqC,EACrC,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACxB,MAAM,2BAA2B,CAAC;AAEnC,KAAK,MAAM,GAAG;IAAE,WAAW,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,6BAA6B,GAAG;IACxC;;;;;;;;;;OAUG;IACH,eAAe,EAAE,CAAC,KAAK,EAAE,oBAAoB,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC,CAAC;IAE7G;;;;;;;;;;;OAWG;IACH,gBAAgB,EAAE,CAAC,KAAK,EAAE,oBAAoB,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;CAChG,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACvC;;;;;;;;;;;;OAYG;IACH,eAAe,EAAE,CACb,KAAK,EAAE,oBAAoB,GAAG,qBAAqB,GAAG,qBAAqB,CAAC,SAAS,CAAC,EACtF,MAAM,CAAC,EAAE,MAAM,KACd,OAAO,CAAC,qCAAqC,CAAC,CAAC;IAEpD;;;;;;;;;;;;OAYG;IACH,gBAAgB,EAAE,CACd,KAAK,EAAE,oBAAoB,GAAG,oBAAoB,EAClD,MAAM,CAAC,EAAE,MAAM,KACd,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACvC,CAAC"}

package/dist/types/payer.d.ts

@@ -0,0 +1,20 @@
+import { TransactionSigner } from '@solana/signers';
+/**
+ * Represents a client that provides a default transaction payer.
+ *
+ * The payer is a {@link TransactionSigner} used to sign and pay for transactions.
+ * Clients implementing this interface can automatically fund transactions
+ * without requiring callers to specify a fee payer explicitly.
+ *
+ * @example
+ * ```ts
+ * function createTransfer(client: ClientWithPayer, recipient: Address, amount: Lamports) {
+ *     const feePayer = client.payer;
+ *     // Use feePayer.address as the transaction fee payer
+ * }
+ * ```
+ */
+export type ClientWithPayer = {
+    payer: TransactionSigner;
+};
+//# sourceMappingURL=payer.d.ts.map

package/dist/types/payer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payer.d.ts","sourceRoot":"","sources":["../../src/payer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,eAAe,GAAG;IAAE,KAAK,EAAE,iBAAiB,CAAA;CAAE,CAAC"}

package/dist/types/rpc.d.ts

@@ -0,0 +1,53 @@
+import type { Rpc } from '@solana/rpc-spec';
+import type { RpcSubscriptions } from '@solana/rpc-subscriptions-spec';
+/**
+ * Represents a client that provides access to a Solana RPC endpoint.
+ *
+ * The RPC interface allows making JSON-RPC calls to a Solana validator,
+ * such as fetching account data, sending transactions, and querying blockchain state.
+ *
+ * @typeParam TRpcMethods - The RPC methods available on this client. Use specific
+ *            method types from `@solana/rpc-api` for the Solana JSON-RPC API.
+ *
+ * @example
+ * ```ts
+ * import { SolanaRpcApi } from '@solana/rpc-api';
+ *
+ * async function getBalance(client: ClientWithRpc<SolanaRpcApi>, address: Address) {
+ *     const { value: balance } = await client.rpc.getBalance(address).send();
+ *     return balance;
+ * }
+ * ```
+ */
+export type ClientWithRpc<TRpcMethods> = {
+    rpc: Rpc<TRpcMethods>;
+};
+/**
+ * Represents a client that provides access to Solana RPC subscriptions.
+ *
+ * RPC subscriptions enable real-time notifications from the Solana validator,
+ * such as account changes, slot updates, and transaction confirmations.
+ *
+ * @typeParam TRpcSubscriptionsMethods - The subscription methods available on this client.
+ *            Use specific method types from `@solana/rpc-subscriptions-api` for the Solana
+ *            subscription API.
+ *
+ * @example
+ * ```ts
+ * import { SolanaRpcSubscriptionsApi } from '@solana/rpc-subscriptions-api';
+ *
+ * async function subscribeToAccount(
+ *     client: ClientWithRpcSubscriptions<SolanaRpcSubscriptionsApi>,
+ *     address: Address,
+ * ) {
+ *     const subscription = await client.rpcSubscriptions.accountNotifications(address).subscribe();
+ *     for await (const notification of subscription) {
+ *         console.log('Account changed:', notification);
+ *     }
+ * }
+ * ```
+ */
+export type ClientWithRpcSubscriptions<TRpcSubscriptionsMethods> = {
+    rpcSubscriptions: RpcSubscriptions<TRpcSubscriptionsMethods>;
+};
+//# sourceMappingURL=rpc.d.ts.map

package/dist/types/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../src/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,aAAa,CAAC,WAAW,IAAI;IAAE,GAAG,EAAE,GAAG,CAAC,WAAW,CAAC,CAAA;CAAE,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,0BAA0B,CAAC,wBAAwB,IAAI;IAC/D,gBAAgB,EAAE,gBAAgB,CAAC,wBAAwB,CAAC,CAAC;CAChE,CAAC"}

package/package.json

@@ -1,12 +1,60 @@
 {
   "name": "@solana/plugin-interfaces",
-  "version": "0.0.0",
-  "description": "",
-  "license": "ISC",
-  "author": "",
+  "version": "6.1.0-canary-20260216194225",
+  "description": "TypeScript interfaces for building pluggable Solana clients",
+  "homepage": "https://www.solanakit.com/api#solanaplugin-interfaces",
+  "types": "./dist/types/index.d.ts",
   "type": "commonjs",
-  "main": "index.js",
+  "files": [
+    "./dist/"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "blockchain",
+    "solana",
+    "web3"
+  ],
+  "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anza-xyz/kit"
+  },
+  "bugs": {
+    "url": "https://github.com/anza-xyz/kit/issues"
+  },
+  "browserslist": [
+    "supports bigint and not dead",
+    "maintained node versions"
+  ],
+  "dependencies": {
+    "@solana/addresses": "6.1.0-canary-20260216194225",
+    "@solana/instruction-plans": "6.1.0-canary-20260216194225",
+    "@solana/keys": "6.1.0-canary-20260216194225",
+    "@solana/rpc-spec": "6.1.0-canary-20260216194225",
+    "@solana/rpc-subscriptions-spec": "6.1.0-canary-20260216194225",
+    "@solana/rpc-types": "6.1.0-canary-20260216194225",
+    "@solana/signers": "6.1.0-canary-20260216194225"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20.18.0"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "compile:docs": "typedoc",
+    "compile:typedefs": "tsc -p ./tsconfig.declarations.json",
+    "publish-impl": "npm view $npm_package_name@$npm_package_version > /dev/null 2>&1 || (pnpm publish --tag ${PUBLISH_TAG:-canary} --access public --no-git-checks && (([ -n \"${GITHUB_OUTPUT:-}\" ] && echo 'published=true' >> \"$GITHUB_OUTPUT\") || true) && (([ \"$PUBLISH_TAG\" != \"canary\" ] && ../build-scripts/maybe-tag-latest.ts --token \"$GITHUB_TOKEN\" $npm_package_name@$npm_package_version) || true))",
+    "publish-packages": "pnpm prepublishOnly && pnpm publish-impl",
+    "style:fix": "pnpm eslint --fix src && pnpm prettier --log-level warn --ignore-unknown --write ./*",
+    "test:lint": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-lint.config.js --rootDir . --silent",
+    "test:prettier": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-prettier.config.js --rootDir . --silent",
+    "test:typecheck": "tsc --noEmit"
   }
-}
+}