@solana/kora 0.2.0-beta.6 → 0.2.1

package/dist/src/kit/index.js

@@ -4,10 +4,10 @@ import { payer } from '@solana/kit-plugin-payer';
 import { rpc } from '@solana/kit-plugin-rpc';
 import { estimateAndUpdateProvisoryComputeUnitLimitFactory, estimateComputeUnitLimitFactory, } from '@solana-program/compute-budget';
 import { KoraClient } from '../client.js';
-import { koraPlugin } from '../plugin.js';
 import { createKoraTransactionPlanExecutor } from './executor.js';
 import { buildPlaceholderPaymentInstruction, koraPaymentAddress } from './payment.js';
 import { buildComputeBudgetInstructions, createKoraTransactionPlanner } from './planner.js';
+import { koraPlugin } from './plugin.js';
 /**
  * Creates a Kora Kit client composed from Kit plugins.
  *
@@ -31,14 +31,9 @@ import { buildComputeBudgetInstructions, createKoraTransactionPlanner } from './
  * const result = await client.sendTransaction([myInstruction]);
  * ```
  */
-// TODO: Bundle support — the plan/execute pipeline currently handles single transactions only.
-// For Jito bundles, users must manually encode transactions and call `client.kora.signAndSendBundle()`.
-// A future `createKitKoraBundleClient` (or a bundle-aware executor plugin) could extend this to
-// plan multiple transaction messages and submit them as a single bundle.
 export async function createKitKoraClient(config) {
     const koraClient = new KoraClient({
         apiKey: config.apiKey,
-        getRecaptchaToken: config.getRecaptchaToken,
         hmacSecret: config.hmacSecret,
         rpcUrl: config.endpoint,
     });
@@ -63,10 +58,7 @@ export async function createKitKoraClient(config) {
         : undefined, resolveProvisoryComputeUnitLimit);
     return createEmptyClient()
         .use(rpc(config.rpcUrl))
-        .use(koraPlugin({
-        endpoint: config.endpoint,
-        koraClient,
-    }))
+        .use(koraPlugin({ apiKey: config.apiKey, endpoint: config.endpoint, hmacSecret: config.hmacSecret }))
         .use(payer(payerSigner))
         .use(koraPaymentAddress(paymentAddr))
         .use(transactionPlannerPlugin(koraTransactionPlanner))

package/dist/src/kit/payment.js

@@ -27,7 +27,7 @@ export async function buildPlaceholderPaymentInstruction(feePayerWallet, payment
         authority: feePayerWallet,
         destination: destinationTokenAccount,
         source: sourceTokenAccount,
-    }, { programAddress: tokenProgram });
+    });
     return { destinationTokenAccount, instruction, sourceTokenAccount };
 }
 function isPlaceholderPaymentInstruction(ix, sourceTokenAccount, destinationTokenAccount, feePayerWallet, tokenProgramId) {
@@ -50,13 +50,12 @@ export function updatePaymentInstructionAmount(instructions, feePayerWallet, sou
             return ix;
         }
         replaced = true;
-        const tokenProgram = tokenProgramId ?? TOKEN_PROGRAM_ADDRESS;
         return getTransferInstruction({
             amount,
             authority: feePayerWallet,
             destination: destinationTokenAccount,
             source: sourceTokenAccount,
-        }, { programAddress: tokenProgram });
+        });
     });
     if (!replaced) {
         throw new Error('Failed to update payment instruction: no matching placeholder transfer instruction found. ' +

package/dist/src/kit/plugin.d.ts

@@ -0,0 +1,31 @@
+import type { EstimateTransactionFeeRequest, GetPaymentInstructionRequest, KitBlockhashResponse, KitConfigResponse, KitEstimateFeeResponse, KitPayerSignerResponse, KitPaymentInstructionResponse, KitSignAndSendTransactionResponse, KitSignTransactionResponse, KitSupportedTokensResponse, KitTransferTransactionResponse, KoraPluginConfig, SignAndSendTransactionRequest, SignTransactionRequest, TransferTransactionRequest } from '../types/index.js';
+/**
+ * Kit plugin that adds `.kora` namespace with all Kora RPC methods.
+ * Responses are cast to Kit types (Address, Blockhash, Signature).
+ *
+ * Requires `@solana/kit` v5.4.0+ for the `createEmptyClient().use()` pattern.
+ *
+ * @example
+ * ```typescript
+ * const client = createEmptyClient()
+ *   .use(koraPlugin({ endpoint: 'https://kora.example.com' }));
+ *
+ * const config = await client.kora.getConfig();
+ * const { signer_pubkey } = await client.kora.signTransaction({ transaction: tx });
+ * ```
+ */
+export declare function koraPlugin(config: KoraPluginConfig): <T extends object>(c: T) => T & {
+    kora: {
+        estimateTransactionFee(request: EstimateTransactionFeeRequest): Promise<KitEstimateFeeResponse>;
+        getBlockhash(): Promise<KitBlockhashResponse>;
+        getConfig(): Promise<KitConfigResponse>;
+        getPayerSigner(): Promise<KitPayerSignerResponse>;
+        getPaymentInstruction(request: GetPaymentInstructionRequest): Promise<KitPaymentInstructionResponse>;
+        getSupportedTokens(): Promise<KitSupportedTokensResponse>;
+        signAndSendTransaction(request: SignAndSendTransactionRequest): Promise<KitSignAndSendTransactionResponse>;
+        signTransaction(request: SignTransactionRequest): Promise<KitSignTransactionResponse>;
+        transferTransaction(request: TransferTransactionRequest): Promise<KitTransferTransactionResponse>;
+    };
+};
+/** Type representing the Kora plugin namespace on the client. */
+export type KoraPlugin = ReturnType<ReturnType<typeof koraPlugin>>['kora'];

package/dist/src/{plugin.js → kit/plugin.js}

@@ -1,61 +1,29 @@
 import { address, blockhash, signature } from '@solana/kit';
-import { KoraClient } from './client.js';
+import { KoraClient } from '../client.js';
 /**
- * Creates a Kora Kit plugin that adds Kora paymaster functionality to a Kit client.
+ * Kit plugin that adds `.kora` namespace with all Kora RPC methods.
+ * Responses are cast to Kit types (Address, Blockhash, Signature).
  *
- * The plugin exposes all Kora RPC methods with Kit-typed responses (Address, Blockhash).
- *
- * **Note:** The plugin pattern with `createEmptyClient().use()` requires `@solana/kit` v5.4.0+.
- * For older kit versions, use `KoraClient` directly instead.
- *
- * @param config - Plugin configuration
- * @param config.endpoint - Kora RPC endpoint URL
- * @param config.apiKey - Optional API key for authentication
- * @param config.hmacSecret - Optional HMAC secret for signature-based authentication
- * @returns A Kit plugin function that adds `.kora` to the client
+ * Requires `@solana/kit` v5.4.0+ for the `createEmptyClient().use()` pattern.
  *
  * @example
  * ```typescript
- * import { createEmptyClient } from '@solana/kit';
- * import { koraPlugin } from '@solana/kora';
- *
  * const client = createEmptyClient()
  *   .use(koraPlugin({ endpoint: 'https://kora.example.com' }));
  *
- * // All responses have Kit-typed fields
  * const config = await client.kora.getConfig();
- * // config.fee_payers is Address[] not string[]
- *
  * const { signer_pubkey } = await client.kora.signTransaction({ transaction: tx });
- * // signer_pubkey is Address not string
  * ```
  */
 export function koraPlugin(config) {
-    const client = config.koraClient ??
-        new KoraClient({
-            apiKey: config.apiKey,
-            getRecaptchaToken: config.getRecaptchaToken,
-            hmacSecret: config.hmacSecret,
-            rpcUrl: config.endpoint,
-        });
+    const client = new KoraClient({
+        apiKey: config.apiKey,
+        hmacSecret: config.hmacSecret,
+        rpcUrl: config.endpoint,
+    });
     return (c) => ({
         ...c,
         kora: {
-            /**
-             * Estimates the bundle fee with Kit-typed addresses.
-             */
-            async estimateBundleFee(request) {
-                const result = await client.estimateBundleFee(request);
-                return {
-                    fee_in_lamports: result.fee_in_lamports,
-                    fee_in_token: result.fee_in_token,
-                    payment_address: address(result.payment_address),
-                    signer_pubkey: address(result.signer_pubkey),
-                };
-            },
-            /**
-             * Estimates the transaction fee with Kit-typed addresses.
-             */
             async estimateTransactionFee(request) {
                 const result = await client.estimateTransactionFee(request);
                 return {
@@ -65,18 +33,12 @@ export function koraPlugin(config) {
                     signer_pubkey: address(result.signer_pubkey),
                 };
             },
-            /**
-             * Gets the latest blockhash with Kit Blockhash type.
-             */
             async getBlockhash() {
                 const result = await client.getBlockhash();
                 return {
                     blockhash: blockhash(result.blockhash),
                 };
             },
-            /**
-             * Retrieves the current Kora server configuration with Kit-typed addresses.
-             */
             async getConfig() {
                 const result = await client.getConfig();
                 return {
@@ -91,9 +53,6 @@ export function koraPlugin(config) {
                     },
                 };
             },
-            /**
-             * Retrieves the payer signer and payment destination with Kit-typed addresses.
-             */
             async getPayerSigner() {
                 const result = await client.getPayerSigner();
                 return {
@@ -101,9 +60,6 @@ export function koraPlugin(config) {
                     signer_address: address(result.signer_address),
                 };
             },
-            /**
-             * Creates a payment instruction with Kit-typed response.
-             */
             async getPaymentInstruction(request) {
                 const result = await client.getPaymentInstruction(request);
                 return {
@@ -115,35 +71,12 @@ export function koraPlugin(config) {
                     signer_address: address(result.signer_address),
                 };
             },
-            /**
-             * Retrieves the list of tokens supported for fee payment with Kit-typed addresses.
-             */
             async getSupportedTokens() {
                 const result = await client.getSupportedTokens();
                 return {
                     tokens: result.tokens.map(addr => address(addr)),
                 };
             },
-            /**
-             * Gets the version of the Kora server.
-             */
-            async getVersion() {
-                return await client.getVersion();
-            },
-            /**
-             * Signs and sends a bundle of transactions via Jito with Kit-typed response.
-             */
-            async signAndSendBundle(request) {
-                const result = await client.signAndSendBundle(request);
-                return {
-                    bundle_uuid: result.bundle_uuid,
-                    signed_transactions: result.signed_transactions,
-                    signer_pubkey: address(result.signer_pubkey),
-                };
-            },
-            /**
-             * Signs and sends a transaction with Kit-typed response.
-             */
             async signAndSendTransaction(request) {
                 const result = await client.signAndSendTransaction(request);
                 return {
@@ -152,24 +85,21 @@ export function koraPlugin(config) {
                     signer_pubkey: address(result.signer_pubkey),
                 };
             },
-            /**
-             * Signs a bundle of transactions with Kit-typed response.
-             */
-            async signBundle(request) {
-                const result = await client.signBundle(request);
+            async signTransaction(request) {
+                const result = await client.signTransaction(request);
                 return {
-                    signed_transactions: result.signed_transactions,
+                    signed_transaction: result.signed_transaction,
                     signer_pubkey: address(result.signer_pubkey),
                 };
             },
-            /**
-             * Signs a transaction with Kit-typed response.
-             */
-            async signTransaction(request) {
-                const result = await client.signTransaction(request);
+            async transferTransaction(request) {
+                const result = await client.transferTransaction(request);
                 return {
-                    signed_transaction: result.signed_transaction,
+                    blockhash: blockhash(result.blockhash),
+                    instructions: result.instructions,
+                    message: result.message,
                     signer_pubkey: address(result.signer_pubkey),
+                    transaction: result.transaction,
                 };
             },
         },

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

@@ -1,7 +1,22 @@
-import { Instruction, type MicroLamports, type TransactionSigner } from '@solana/kit';
+import { Instruction, TransactionSigner } from '@solana/kit';
 /**
  * Request Types
  */
+/**
+ * Parameters for creating a token transfer transaction.
+ */
+export interface TransferTransactionRequest {
+    /** Amount to transfer in the token's smallest unit (e.g., lamports for SOL) */
+    amount: number;
+    /** Public key of the destination wallet (not token account) */
+    destination: string;
+    /** Optional signer address for the transaction */
+    signer_key?: string;
+    /** Public key of the source wallet (not token account) */
+    source: string;
+    /** Mint address of the token to transfer */
+    token: string;
+}
 /**
  * Parameters for signing a transaction.
  */
@@ -12,8 +27,6 @@ export interface SignTransactionRequest {
     signer_key?: string;
     /** Base64-encoded transaction to sign */
     transaction: string;
-    /** Optional user ID for usage tracking (required when pricing is free and usage tracking is enabled) */
-    user_id?: string;
 }
 /**
  * Parameters for signing and sending a transaction.
@@ -25,45 +38,13 @@ export interface SignAndSendTransactionRequest {
     signer_key?: string;
     /** Base64-encoded transaction to sign and send */
     transaction: string;
-    /** Optional user ID for usage tracking (required when pricing is free and usage tracking is enabled) */
-    user_id?: string;
-}
-/**
- * Parameters for signing a bundle of transactions.
- */
-export interface SignBundleRequest {
-    /** Optional signer verification during transaction simulation (defaults to false) */
-    sig_verify?: boolean;
-    /** Optional indices of transactions to sign (defaults to all if not specified) */
-    sign_only_indices?: number[];
-    /** Optional signer address for the transactions */
-    signer_key?: string;
-    /** Array of base64-encoded transactions to sign */
-    transactions: string[];
-    /** Optional user ID for usage tracking (required when pricing is free and usage tracking is enabled) */
-    user_id?: string;
-}
-/**
- * Parameters for signing and sending a bundle of transactions via Jito.
- */
-export interface SignAndSendBundleRequest {
-    /** Optional signer verification during transaction simulation (defaults to false) */
-    sig_verify?: boolean;
-    /** Optional indices of transactions to sign (defaults to all if not specified) */
-    sign_only_indices?: number[];
-    /** Optional signer address for the transactions */
-    signer_key?: string;
-    /** Array of base64-encoded transactions to sign and send */
-    transactions: string[];
-    /** Optional user ID for usage tracking (required when pricing is free and usage tracking is enabled) */
-    user_id?: string;
 }
 /**
  * Parameters for estimating transaction fees.
  */
 export interface EstimateTransactionFeeRequest {
     /** Mint address of the token to calculate fees in */
-    fee_token?: string;
+    fee_token: string;
     /** Optional signer verification during transaction simulation (defaults to false) */
     sig_verify?: boolean;
     /** Optional signer address for the transaction */
@@ -71,21 +52,6 @@ export interface EstimateTransactionFeeRequest {
     /** Base64-encoded transaction to estimate fees for */
     transaction: string;
 }
-/**
- * Parameters for estimating bundle fees.
- */
-export interface EstimateBundleFeeRequest {
-    /** Mint address of the token to calculate fees in */
-    fee_token?: string;
-    /** Optional signer verification during transaction simulation (defaults to false) */
-    sig_verify?: boolean;
-    /** Optional indices of transactions to estimate fees for (defaults to all if not specified) */
-    sign_only_indices?: number[];
-    /** Optional signer address for the transactions */
-    signer_key?: string;
-    /** Array of base64-encoded transactions to estimate fees for */
-    transactions: string[];
-}
 /**
  * Parameters for getting a payment instruction.
  */
@@ -96,8 +62,11 @@ export interface GetPaymentInstructionRequest {
     sig_verify?: boolean;
     /** Optional signer address for the transaction */
     signer_key?: string;
-    /** The wallet owner (not token account) that will be making the token payment */
-    source_wallet: string;
+    /** The wallet owner that will be making the token payment.
+     *  Accepts a plain address string or a TransactionSigner. When a TransactionSigner is provided,
+     *  it is used as the transfer authority on the payment instruction, preserving signer identity
+     *  and avoiding conflicts with other instructions that reference the same address. */
+    source_wallet: TransactionSigner | string;
     /** The token program id to use for the payment (defaults to TOKEN_PROGRAM_ID) */
     token_program_id?: string;
     /** Base64-encoded transaction to estimate fees for */
@@ -106,6 +75,21 @@ export interface GetPaymentInstructionRequest {
 /**
  * Response Types
  */
+/**
+ * Response from creating a transfer transaction.
+ */
+export interface TransferTransactionResponse {
+    /** Recent blockhash used in the transaction */
+    blockhash: string;
+    /** Parsed instructions from the transaction message */
+    instructions: Instruction[];
+    /** Base64-encoded message */
+    message: string;
+    /** Public key of the signer used to send the transaction */
+    signer_pubkey: string;
+    /** Base64-encoded signed transaction */
+    transaction: string;
+}
 /**
  * Response from signing a transaction.
  */
@@ -126,26 +110,6 @@ export interface SignAndSendTransactionResponse {
     /** Public key of the signer used to send the transaction */
     signer_pubkey: string;
 }
-/**
- * Response from signing a bundle of transactions.
- */
-export interface SignBundleResponse {
-    /** Array of base64-encoded signed transactions */
-    signed_transactions: string[];
-    /** Public key of the signer used to sign the transactions */
-    signer_pubkey: string;
-}
-/**
- * Response from signing and sending a bundle of transactions via Jito.
- */
-export interface SignAndSendBundleResponse {
-    /** UUID of the submitted Jito bundle */
-    bundle_uuid: string;
-    /** Array of base64-encoded signed transactions */
-    signed_transactions: string[];
-    /** Public key of the signer used to sign the transactions */
-    signer_pubkey: string;
-}
 /**
  * Response containing the latest blockhash.
  */
@@ -153,13 +117,6 @@ export interface GetBlockhashResponse {
     /** Base58-encoded blockhash */
     blockhash: string;
 }
-/**
- * Response containing the server version.
- */
-export interface GetVersionResponse {
-    /** Server version string */
-    version: string;
-}
 /**
  * Response containing supported token mint addresses.
  */
@@ -176,22 +133,7 @@ export interface EstimateTransactionFeeResponse {
     /**
      * Transaction fee in the requested token (in decimals value of the token, e.g. 10^6 for USDC)
      */
-    fee_in_token?: number;
-    /** Public key of the payment destination */
-    payment_address: string;
-    /** Public key of the signer used to estimate the fee */
-    signer_pubkey: string;
-}
-/**
- * Response containing estimated bundle fees.
- */
-export interface EstimateBundleFeeResponse {
-    /** Total bundle fee in lamports across all transactions */
-    fee_in_lamports: number;
-    /**
-     * Total bundle fee in the requested token (in decimals value of the token, e.g. 10^6 for USDC)
-     */
-    fee_in_token?: number;
+    fee_in_token: number;
     /** Public key of the payment destination */
     payment_address: string;
     /** Public key of the signer used to estimate the fee */
@@ -283,28 +225,18 @@ export type PriceConfig = PriceModel;
  * Enabled status for methods for the Kora server.
  */
 export interface EnabledMethods {
-    /** Whether the estimate_bundle_fee method is enabled (requires bundle.enabled = true) */
-    estimate_bundle_fee: boolean;
     /** Whether the estimate_transaction_fee method is enabled */
     estimate_transaction_fee: boolean;
     /** Whether the get_blockhash method is enabled */
     get_blockhash: boolean;
     /** Whether the get_config method is enabled */
     get_config: boolean;
-    /** Whether the get_payer_signer method is enabled */
-    get_payer_signer: boolean;
     /** Whether the get_supported_tokens method is enabled */
     get_supported_tokens: boolean;
-    /** Whether the get_version method is enabled */
-    get_version: boolean;
     /** Whether the liveness method is enabled */
     liveness: boolean;
-    /** Whether the sign_and_send_bundle method is enabled (requires bundle.enabled = true) */
-    sign_and_send_bundle: boolean;
     /** Whether the sign_and_send_transaction method is enabled */
     sign_and_send_transaction: boolean;
-    /** Whether the sign_bundle method is enabled (requires bundle.enabled = true) */
-    sign_bundle: boolean;
     /** Whether the sign_transaction method is enabled */
     sign_transaction: boolean;
     /** Whether the transfer_transaction method is enabled */
@@ -361,12 +293,6 @@ export interface SplTokenInstructionPolicy {
     allow_close_account: boolean;
     /** Allow fee payer to freeze SPL token accounts */
     allow_freeze_account: boolean;
-    /** Allow fee payer to initialize SPL token accounts */
-    allow_initialize_account: boolean;
-    /** Allow fee payer to initialize SPL token mints */
-    allow_initialize_mint: boolean;
-    /** Allow fee payer to initialize SPL multisig accounts */
-    allow_initialize_multisig: boolean;
     /** Allow fee payer to mint SPL tokens */
     allow_mint_to: boolean;
     /** Allow fee payer to revoke SPL token delegates */
@@ -390,12 +316,6 @@ export interface Token2022InstructionPolicy {
     allow_close_account: boolean;
     /** Allow fee payer to freeze Token2022 accounts */
     allow_freeze_account: boolean;
-    /** Allow fee payer to initialize Token2022 accounts */
-    allow_initialize_account: boolean;
-    /** Allow fee payer to initialize Token2022 mints */
-    allow_initialize_mint: boolean;
-    /** Allow fee payer to initialize Token2022 multisig accounts */
-    allow_initialize_multisig: boolean;
     /** Allow fee payer to mint Token2022 tokens */
     allow_mint_to: boolean;
     /** Allow fee payer to revoke Token2022 delegates */
@@ -452,8 +372,6 @@ export interface AuthenticationHeaders {
     'x-api-key'?: string;
     /** HMAC SHA256 signature of timestamp + body */
     'x-hmac-signature'?: string;
-    /** reCAPTCHA v3 token for bot protection */
-    'x-recaptcha-token'?: string;
     /** Unix timestamp for HMAC authentication */
     'x-timestamp'?: string;
 }
@@ -463,13 +381,6 @@ export interface AuthenticationHeaders {
 export interface KoraClientOptions {
     /** Optional API key for authentication */
     apiKey?: string;
-    /**
-     * Optional callback to get a reCAPTCHA v3 token for bot protection.
-     * Called for every request when provided; server determines which methods require it.
-     * @example Browser: `() => grecaptcha.execute('site-key', { action: 'sign' })`
-     * @example Testing: `() => 'test-token'`
-     */
-    getRecaptchaToken?: () => Promise<string> | string;
     /** Optional HMAC secret for signature-based authentication */
     hmacSecret?: string;
     /** URL of the Kora RPC server */
@@ -478,25 +389,15 @@ export interface KoraClientOptions {
 /**
  * Plugin Types - Kit-typed responses for the Kora plugin
  */
-import type { Address, Base64EncodedWireTransaction, Blockhash, Instruction as KitInstruction, Signature } from '@solana/kit';
-import { KoraClient } from '../client.js';
+import type { Address, Base64EncodedWireTransaction, Blockhash, Instruction as KitInstruction, MicroLamports, Signature } from '@solana/kit';
 /** Configuration options for the Kora Kit plugin */
 export interface KoraPluginConfig {
     /** Optional API key for authentication */
     apiKey?: string;
     /** Kora RPC endpoint URL */
     endpoint: string;
-    /**
-     * Optional callback to get a reCAPTCHA v3 token for bot protection.
-     * Called for every request when provided; server determines which methods require it.
-     * @example Browser: `() => grecaptcha.execute('site-key', { action: 'sign' })`
-     * @example Testing: `() => 'test-token'`
-     */
-    getRecaptchaToken?: () => Promise<string> | string;
     /** Optional HMAC secret for signature-based authentication */
     hmacSecret?: string;
-    /** Existing Kora Client for reusing existing instance */
-    koraClient?: KoraClient;
 }
 /** Plugin response for getPayerSigner with Kit Address types */
 export interface KitPayerSignerResponse {
@@ -520,7 +421,7 @@ export interface KitEstimateFeeResponse {
     /** Transaction fee in lamports */
     fee_in_lamports: number;
     /** Transaction fee in the requested token */
-    fee_in_token?: number;
+    fee_in_token: number;
     /** Public key of the payment destination */
     payment_address: Address;
     /** Public key of the signer used to estimate the fee */
@@ -542,6 +443,19 @@ export interface KitSignAndSendTransactionResponse {
     /** Public key of the signer used to send the transaction */
     signer_pubkey: Address;
 }
+/** Plugin response for transferTransaction with Kit types */
+export interface KitTransferTransactionResponse {
+    /** Recent blockhash used in the transaction */
+    blockhash: Blockhash;
+    /** Parsed instructions from the transaction message */
+    instructions: KitInstruction[];
+    /** Base64-encoded message */
+    message: string;
+    /** Public key of the signer used to send the transaction */
+    signer_pubkey: Address;
+    /** Base64-encoded signed transaction */
+    transaction: Base64EncodedWireTransaction;
+}
 /** Plugin response for getPaymentInstruction with Kit types */
 export interface KitPaymentInstructionResponse {
     /** Base64-encoded original transaction */
@@ -566,33 +480,6 @@ export interface KitConfigResponse {
     /** Validation rules and constraints */
     validation_config: KitValidationConfig;
 }
-/** Plugin response for estimateBundleFee with Kit types */
-export interface KitEstimateBundleFeeResponse {
-    /** Total bundle fee in lamports across all transactions */
-    fee_in_lamports: number;
-    /** Total bundle fee in the requested token */
-    fee_in_token?: number;
-    /** Public key of the payment destination */
-    payment_address: Address;
-    /** Public key of the signer used to estimate the fee */
-    signer_pubkey: Address;
-}
-/** Plugin response for signBundle with Kit types */
-export interface KitSignBundleResponse {
-    /** Array of base64-encoded signed transactions */
-    signed_transactions: Base64EncodedWireTransaction[];
-    /** Public key of the signer used to sign the transactions */
-    signer_pubkey: Address;
-}
-/** Plugin response for signAndSendBundle with Kit types */
-export interface KitSignAndSendBundleResponse {
-    /** UUID of the submitted Jito bundle */
-    bundle_uuid: string;
-    /** Array of base64-encoded signed transactions */
-    signed_transactions: Base64EncodedWireTransaction[];
-    /** Public key of the signer used to sign the transactions */
-    signer_pubkey: Address;
-}
 /** Plugin validation config with Kit Address types */
 export interface KitValidationConfig {
     /** List of allowed Solana program IDs */
@@ -617,19 +504,41 @@ export interface KitValidationConfig {
     token2022: Token2022Config;
 }
 /**
- * Kit Client Types
+ * Configuration for creating a Kora Kit client.
+ *
+ * @example
+ * ```ts
+ * const client = await createKitKoraClient({
+ *   endpoint: 'https://kora.example.com',
+ *   rpcUrl: 'https://api.mainnet-beta.solana.com',
+ *   feeToken: address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
+ *   feePayerWallet: myWalletSigner, // TransactionSigner that authorizes SPL fee payment
+ * });
+ * ```
  */
-/** Configuration for {@link createKitKoraClient}. */
 export interface KoraKitClientConfig {
+    /** Optional API key for authentication */
     readonly apiKey?: string;
+    /** Optional compute unit limit (uses provisory/simulation if not set) */
     readonly computeUnitLimit?: number;
+    /** Optional priority fee in micro-lamports */
     readonly computeUnitPrice?: MicroLamports;
+    /** Kora RPC endpoint URL */
     readonly endpoint: string;
+    /** Wallet signer paying SPL fees (must be a real signer so the payment transfer is authorized) */
     readonly feePayerWallet: TransactionSigner;
+    /** SPL mint address for fee payment */
     readonly feeToken: Address;
-    readonly getRecaptchaToken?: () => Promise<string> | string;
+    /** Optional HMAC secret for signature-based authentication */
     readonly hmacSecret?: string;
+    /**
+     * Solana RPC URL used for compute unit estimation and program plugin compatibility.
+     * The client simulates transactions against this RPC node to determine optimal
+     * compute unit limits (resulting in lower fees), and exposes it as `ClientWithRpc`
+     * so Kit program plugins like `tokenProgram()` work out of the box.
+     * This must be a direct Solana RPC URL (not the Kora endpoint).
+     */
     readonly rpcUrl: string;
+    /** Token program ID for fee payment (defaults to TOKEN_PROGRAM_ADDRESS; use TOKEN_2022_PROGRAM_ADDRESS for Token-2022) */
     readonly tokenProgramId?: Address;
-    readonly userId?: string;
 }