@solana/plugin-interfaces 6.4.0 → 6.5.0-canary-20260319134241

package/README.md

@@ -37,17 +37,18 @@ npm install @solana/plugin-interfaces
 Represents a client that provides a default transaction payer.
 
 ```ts
+import { extendClient } from '@solana/plugin-core';
 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;
-            // ...
-        },
-    });
+    return <T extends ClientWithPayer>(client: T) =>
+        extendClient(client, {
+            sendMemo: (message: string) => {
+                // Use client.payer as the fee payer for the memo transaction
+                const feePayer = client.payer;
+                // ...
+            },
+        });
 }
 ```
 
@@ -56,15 +57,38 @@ function memoPlugin() {
 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 { extendClient } from '@solana/plugin-core';
 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);
-        },
-    });
+    return <T extends ClientWithAirdrop & ClientWithPayer>(client: T) =>
+        extendClient(client, {
+            fundMyself: async (amount: Lamports) => {
+                await client.airdrop(client.payer.address, amount);
+            },
+        });
+}
+```
+
+### `ClientWithGetMinimumBalance`
+
+Represents a client that can compute the minimum balance required for an account to be exempt from deletion. Different implementations may compute this differently — for example, by calling the `getMinimumBalanceForRentExemption` RPC method, or by using a locally cached value.
+
+By default, the 128-byte account header is added on top of the provided `space`. Pass `{ withoutHeader: true }` to skip adding the header bytes.
+
+```ts
+import { extendClient } from '@solana/plugin-core';
+import { ClientWithGetMinimumBalance } from '@solana/plugin-interfaces';
+
+function accountCreationPlugin() {
+    return <T extends ClientWithGetMinimumBalance>(client: T) =>
+        extendClient(client, {
+            getAccountCreationCost: async (dataSize: number) => {
+                const minimumBalance = await client.getMinimumBalance(dataSize);
+                console.log(`Minimum balance for ${dataSize} bytes: ${minimumBalance} lamports`);
+                return minimumBalance;
+            },
+        });
 }
 ```
 
@@ -73,17 +97,18 @@ function faucetPlugin() {
 Represents a client with access to a Solana RPC endpoint.
 
 ```ts
+import { extendClient } from '@solana/plugin-core';
 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;
-        },
-    });
+    return <T extends ClientWithRpc<GetBalanceApi>>(client: T) =>
+        extendClient(client, {
+            getBalance: async (address: Address): Promise<Lamports> => {
+                const { value } = await client.rpc.getBalance(address).send();
+                return value;
+            },
+        });
 }
 ```
 
@@ -92,19 +117,20 @@ function balancePlugin() {
 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 { extendClient } from '@solana/plugin-core';
 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);
-            }
-        },
-    });
+    return <T extends ClientWithRpcSubscriptions<AccountNotificationsApi>>(client: T) =>
+        extendClient(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);
+                }
+            },
+        });
 }
 ```
 
@@ -114,16 +140,17 @@ Represents a client that can convert instructions or instruction plans into tran
 
 ```ts
 import { flattenTransactionPlan } from '@solana/instruction-plans';
+import { extendClient } from '@solana/plugin-core';
 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;
-        },
-    });
+    return <T extends ClientWithTransactionPlanning>(client: T) =>
+        extendClient(client, {
+            countTransactions: async (instructions: IInstruction[]) => {
+                const plan = await client.planTransactions(instructions);
+                return flattenTransactionPlan(plan).length;
+            },
+        });
 }
 ```
 
@@ -132,21 +159,22 @@ function transactionCounterPlugin() {
 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 { extendClient } from '@solana/plugin-core';
 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;
-        },
-    });
+    return <T extends ClientWithPayer & ClientWithTransactionSending>(client: T) =>
+        extendClient(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;
+            },
+        });
 }
 ```
 
@@ -155,19 +183,18 @@ function transferPlugin() {
 Use TypeScript intersection types to require multiple capabilities from the client:
 
 ```ts
+import { extendClient } from '@solana/plugin-core';
 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
-        },
-    });
+    return <T extends ClientWithPayer & ClientWithRpc<GetAccountInfoApi> & ClientWithTransactionSending>(client: T) =>
+        extendClient(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/get-minimum-balance.d.ts

@@ -0,0 +1,47 @@
+import { Lamports } from '@solana/rpc-types';
+/**
+ * Configuration options for {@link ClientWithGetMinimumBalance.getMinimumBalance}.
+ */
+export type GetMinimumBalanceConfig = {
+    /**
+     * When `true`, the 128-byte account header is not added to the provided `space` value.
+     *
+     * By default, the account header (128 bytes) is included in the minimum balance computation
+     * on top of the provided `space`. Set this to `true` if the provided `space` already accounts
+     * for the header or if you want the minimum balance for the data portion only.
+     *
+     * @see {@link @solana/accounts#BASE_ACCOUNT_SIZE | BASE_ACCOUNT_SIZE} for the account header size constant.
+     */
+    withoutHeader?: boolean;
+};
+/**
+ * Represents a client that can compute the minimum balance required for an account to be
+ * exempt from deletion.
+ *
+ * Different implementations may compute this value differently — for example, by calling the
+ * `getMinimumBalanceForRentExemption` RPC method, or by using a locally cached value.
+ *
+ * @example
+ * ```ts
+ * async function logAccountCost(client: ClientWithGetMinimumBalance, dataSize: number) {
+ *     const minimumBalance = await client.getMinimumBalance(dataSize);
+ *     console.log(`Minimum balance for ${dataSize} bytes: ${minimumBalance} lamports`);
+ * }
+ * ```
+ */
+export type ClientWithGetMinimumBalance = {
+    /**
+     * Computes the minimum lamports required for an account with the given data size.
+     *
+     * By default, the 128-byte account header is added on top of the provided `space`. Pass
+     * `{ withoutHeader: true }` to skip adding the header bytes.
+     *
+     * @param space - The number of bytes of account data.
+     * @param config - Optional configuration for the computation.
+     * @returns A promise resolving to the minimum {@link Lamports} required.
+     *
+     * @see {@link @solana/accounts#BASE_ACCOUNT_SIZE | BASE_ACCOUNT_SIZE} for the account header size constant.
+     */
+    getMinimumBalance: (space: number, config?: GetMinimumBalanceConfig) => Promise<Lamports>;
+};
+//# sourceMappingURL=get-minimum-balance.d.ts.map

package/dist/types/get-minimum-balance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-minimum-balance.d.ts","sourceRoot":"","sources":["../../src/get-minimum-balance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG;IAClC;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACtC;;;;;;;;;;;OAWG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,uBAAuB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC7F,CAAC"}

package/dist/types/index.d.ts

@@ -7,6 +7,7 @@
  */
 export * from './airdrop';
 export * from './instruction-plans';
+export * from './get-minimum-balance';
 export * from './payer';
 export * from './rpc';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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"}
+{"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,uBAAuB,CAAC;AACtC,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/plugin-interfaces",
-  "version": "6.4.0",
+  "version": "6.5.0-canary-20260319134241",
   "description": "TypeScript interfaces for building pluggable Solana clients",
   "homepage": "https://www.solanakit.com/api#solanaplugin-interfaces",
   "types": "./dist/types/index.d.ts",
@@ -29,13 +29,13 @@
     "maintained node versions"
   ],
   "dependencies": {
-    "@solana/addresses": "6.4.0",
-    "@solana/keys": "6.4.0",
-    "@solana/instruction-plans": "6.4.0",
-    "@solana/rpc-spec": "6.4.0",
-    "@solana/rpc-subscriptions-spec": "6.4.0",
-    "@solana/rpc-types": "6.4.0",
-    "@solana/signers": "6.4.0"
+    "@solana/addresses": "6.5.0-canary-20260319134241",
+    "@solana/instruction-plans": "6.5.0-canary-20260319134241",
+    "@solana/keys": "6.5.0-canary-20260319134241",
+    "@solana/rpc-spec": "6.5.0-canary-20260319134241",
+    "@solana/rpc-subscriptions-spec": "6.5.0-canary-20260319134241",
+    "@solana/rpc-types": "6.5.0-canary-20260319134241",
+    "@solana/signers": "6.5.0-canary-20260319134241"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/get-minimum-balance.ts

@@ -0,0 +1,48 @@
+import { Lamports } from '@solana/rpc-types';
+
+/**
+ * Configuration options for {@link ClientWithGetMinimumBalance.getMinimumBalance}.
+ */
+export type GetMinimumBalanceConfig = {
+    /**
+     * When `true`, the 128-byte account header is not added to the provided `space` value.
+     *
+     * By default, the account header (128 bytes) is included in the minimum balance computation
+     * on top of the provided `space`. Set this to `true` if the provided `space` already accounts
+     * for the header or if you want the minimum balance for the data portion only.
+     *
+     * @see {@link @solana/accounts#BASE_ACCOUNT_SIZE | BASE_ACCOUNT_SIZE} for the account header size constant.
+     */
+    withoutHeader?: boolean;
+};
+
+/**
+ * Represents a client that can compute the minimum balance required for an account to be
+ * exempt from deletion.
+ *
+ * Different implementations may compute this value differently — for example, by calling the
+ * `getMinimumBalanceForRentExemption` RPC method, or by using a locally cached value.
+ *
+ * @example
+ * ```ts
+ * async function logAccountCost(client: ClientWithGetMinimumBalance, dataSize: number) {
+ *     const minimumBalance = await client.getMinimumBalance(dataSize);
+ *     console.log(`Minimum balance for ${dataSize} bytes: ${minimumBalance} lamports`);
+ * }
+ * ```
+ */
+export type ClientWithGetMinimumBalance = {
+    /**
+     * Computes the minimum lamports required for an account with the given data size.
+     *
+     * By default, the 128-byte account header is added on top of the provided `space`. Pass
+     * `{ withoutHeader: true }` to skip adding the header bytes.
+     *
+     * @param space - The number of bytes of account data.
+     * @param config - Optional configuration for the computation.
+     * @returns A promise resolving to the minimum {@link Lamports} required.
+     *
+     * @see {@link @solana/accounts#BASE_ACCOUNT_SIZE | BASE_ACCOUNT_SIZE} for the account header size constant.
+     */
+    getMinimumBalance: (space: number, config?: GetMinimumBalanceConfig) => Promise<Lamports>;
+};

package/src/index.ts

@@ -7,5 +7,6 @@
  */
 export * from './airdrop';
 export * from './instruction-plans';
+export * from './get-minimum-balance';
 export * from './payer';
 export * from './rpc';