@solana/kora 0.2.0-beta.3 → 0.2.0

package/README.md

@@ -1,8 +1,35 @@
 # Kora TypeScript SDK
 
-A TypeScript SDK for interacting with the Kora RPC server. This SDK provides a type-safe interface to all Kora RPC methods.
+A TypeScript SDK for interacting with the Kora RPC server. This SDK provides a type-safe interface to all Kora RPC methods (requires a Kora RPC server to be running).
 
-## Development
+
+## Installation
+
+```bash
+pnpm install @solana/kora
+```
+
+## Quick Start
+
+```typescript
+import { KoraClient } from '@solana/kora';
+
+// Initialize the client with your RPC endpoint
+const client = new KoraClient({ rpcUrl: 'http://localhost:8080' });
+
+// Example: Get Kora to sign a transaction
+const result = await client.signTransaction({
+  transaction: 'myBase64EncodedTransaction'
+});
+
+// Access the signed transaction (base64 encoded)
+console.log('Signed transaction:', result.signed_transaction);
+```
+
+**[→ API Reference](https://launch.solana.com/docs/kora/json-rpc-api)**
+**[→ Quick Start](https://launch.solana.com/docs/kora/getting-started/quick-start)**
+
+## Local Development
 
 ### Building from Source
 
@@ -33,28 +60,3 @@ pnpm test:ci:integration
 
 This will start a local test validator and run all tests.
 
-
-## Quick Start
-
-```typescript
-import { KoraClient } from '@solana/kora';
-
-// Initialize the client with your RPC endpoint
-const client = new KoraClient({ rpcUrl: 'http://localhost:8080' });
-
-// Example: Transfer tokens
-const result = await client.transferTransaction({
-  amount: 1000000, // 1 USDC (6 decimals)
-  token: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC mint
-  source: "sourceAddress",
-  destination: "destinationAddress"
-});
-
-// Access the base64 encoded transaction, base64 encoded message, and parsed instructions directly
-console.log('Transaction:', result.transaction);
-console.log('Message:', result.message);
-console.log('Instructions:', result.instructions);
-```
-
-**[→ API Reference](https://launch.solana.com/docs/kora/json-rpc-api)**
-**[→ Quick Start](https://launch.solana.com/docs/kora/getting-started/quick-start)**

package/dist/src/client.d.ts

@@ -1,21 +1,10 @@
-import { Config, EstimateBundleFeeRequest, EstimateBundleFeeResponse, EstimateTransactionFeeRequest, EstimateTransactionFeeResponse, GetBlockhashResponse, GetPayerSignerResponse, GetPaymentInstructionRequest, GetPaymentInstructionResponse, GetSupportedTokensResponse, GetVersionResponse, KoraClientOptions, SignAndSendBundleRequest, SignAndSendBundleResponse, SignAndSendTransactionRequest, SignAndSendTransactionResponse, SignBundleRequest, SignBundleResponse, SignTransactionRequest, SignTransactionResponse } from './types/index.js';
+import { Config, EstimateTransactionFeeRequest, EstimateTransactionFeeResponse, GetBlockhashResponse, GetPayerSignerResponse, GetPaymentInstructionRequest, GetPaymentInstructionResponse, GetSupportedTokensResponse, KoraClientOptions, SignAndSendTransactionRequest, SignAndSendTransactionResponse, SignTransactionRequest, SignTransactionResponse, TransferTransactionRequest, TransferTransactionResponse } from './types/index.js';
 /**
  * Kora RPC client for interacting with the Kora paymaster service.
  *
- * Provides methods to estimate fees, sign transactions, and perform gasless transfers
- * on Solana as specified by the Kora paymaster operator.
- *
- * @example Kora Initialization
+ * @example
  * ```typescript
- * const client = new KoraClient({
- *   rpcUrl: 'http://localhost:8080',
- *   // apiKey may be required by some operators
- *   // apiKey: 'your-api-key',
- *   // hmacSecret may be required by some operators
- *   // hmacSecret: 'your-hmac-secret'
- * });
- *
- * // Sample usage: Get config
+ * const client = new KoraClient({ rpcUrl: 'http://localhost:8080' });
  * const config = await client.getConfig();
  * ```
  */
@@ -23,202 +12,21 @@ export declare class KoraClient {
     private rpcUrl;
     private apiKey?;
     private hmacSecret?;
-    /**
-     * Creates a new Kora client instance.
-     * @param options - Client configuration options
-     * @param options.rpcUrl - The Kora RPC server URL
-     * @param options.apiKey - Optional API key for authentication
-     * @param options.hmacSecret - Optional HMAC secret for signature-based authentication
-     */
     constructor({ rpcUrl, apiKey, hmacSecret }: KoraClientOptions);
     private getHmacSignature;
     private getHeaders;
     private rpcRequest;
-    /**
-     * Retrieves the current Kora server configuration.
-     * @returns The server configuration including fee payer address and validation rules
-     * @throws {Error} When the RPC call fails
-     *
-     * @example
-     * ```typescript
-     * const config = await client.getConfig();
-     * console.log('Fee payer:', config.fee_payer);
-     * console.log('Validation config:', JSON.stringify(config.validation_config, null, 2));
-     * ```
-     */
     getConfig(): Promise<Config>;
-    /**
-     * Retrieves the payer signer and payment destination from the Kora server.
-     * @returns Object containing the payer signer and payment destination
-     * @throws {Error} When the RPC call fails
-     *
-     * @example
-     */
     getPayerSigner(): Promise<GetPayerSignerResponse>;
-    /**
-     * Gets the latest blockhash from the Solana RPC that the Kora server is connected to.
-     * @returns Object containing the current blockhash
-     * @throws {Error} When the RPC call fails
-     *
-     * @example
-     * ```typescript
-     * const { blockhash } = await client.getBlockhash();
-     * console.log('Current blockhash:', blockhash);
-     * ```
-     */
     getBlockhash(): Promise<GetBlockhashResponse>;
-    /**
-     * Gets the version of the Kora server.
-     * @returns Object containing the server version
-     * @throws {Error} When the RPC call fails
-     *
-     * @example
-     * ```typescript
-     * const { version } = await client.getVersion();
-     * console.log('Server version:', version);
-     * ```
-     */
-    getVersion(): Promise<GetVersionResponse>;
-    /**
-     * Retrieves the list of tokens supported for fee payment.
-     * @returns Object containing an array of supported token mint addresses
-     * @throws {Error} When the RPC call fails
-     *
-     * @example
-     * ```typescript
-     * const { tokens } = await client.getSupportedTokens();
-     * console.log('Supported tokens:', tokens);
-     * // Output: ['EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', ...]
-     * ```
-     */
     getSupportedTokens(): Promise<GetSupportedTokensResponse>;
-    /**
-     * Estimates the transaction fee in both lamports and the specified token.
-     * @param request - Fee estimation request parameters
-     * @param request.transaction - Base64-encoded transaction to estimate fees for
-     * @param request.fee_token - Mint address of the token to calculate fees in
-     * @returns Fee amounts in both lamports and the specified token
-     * @throws {Error} When the RPC call fails, the transaction is invalid, or the token is not supported
-     *
-     * @example
-     * ```typescript
-     * const fees = await client.estimateTransactionFee({
-     *   transaction: 'base64EncodedTransaction',
-     *   fee_token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' // USDC
-     * });
-     * console.log('Fee in lamports:', fees.fee_in_lamports);
-     * console.log('Fee in USDC:', fees.fee_in_token);
-     * ```
-     */
     estimateTransactionFee(request: EstimateTransactionFeeRequest): Promise<EstimateTransactionFeeResponse>;
-    /**
-     * Estimates the bundle fee in both lamports and the specified token.
-     * @param request - Bundle fee estimation request parameters
-     * @param request.transactions - Array of base64-encoded transactions to estimate fees for
-     * @param request.fee_token - Mint address of the token to calculate fees in
-     * @returns Total fee amounts across all transactions in both lamports and the specified token
-     * @throws {Error} When the RPC call fails, the bundle is invalid, or the token is not supported
-     *
-     * @example
-     * ```typescript
-     * const fees = await client.estimateBundleFee({
-     *   transactions: ['base64EncodedTransaction1', 'base64EncodedTransaction2'],
-     *   fee_token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' // USDC
-     * });
-     * console.log('Total fee in lamports:', fees.fee_in_lamports);
-     * console.log('Total fee in USDC:', fees.fee_in_token);
-     * ```
-     */
-    estimateBundleFee(request: EstimateBundleFeeRequest): Promise<EstimateBundleFeeResponse>;
-    /**
-     * Signs a transaction with the Kora fee payer without broadcasting it.
-     * @param request - Sign request parameters
-     * @param request.transaction - Base64-encoded transaction to sign
-     * @returns Signature and the signed transaction
-     * @throws {Error} When the RPC call fails or transaction validation fails
-     *
-     * @example
-     * ```typescript
-     * const result = await client.signTransaction({
-     *   transaction: 'base64EncodedTransaction'
-     * });
-     * console.log('Signature:', result.signature);
-     * console.log('Signed tx:', result.signed_transaction);
-     * ```
-     */
     signTransaction(request: SignTransactionRequest): Promise<SignTransactionResponse>;
-    /**
-     * Signs a transaction and immediately broadcasts it to the Solana network.
-     * @param request - Sign and send request parameters
-     * @param request.transaction - Base64-encoded transaction to sign and send
-     * @returns Signature and the signed transaction
-     * @throws {Error} When the RPC call fails, validation fails, or broadcast fails
-     *
-     * @example
-     * ```typescript
-     * const result = await client.signAndSendTransaction({
-     *   transaction: 'base64EncodedTransaction'
-     * });
-     * console.log('Transaction signature:', result.signature);
-     * ```
-     */
     signAndSendTransaction(request: SignAndSendTransactionRequest): Promise<SignAndSendTransactionResponse>;
+    transferTransaction(request: TransferTransactionRequest): Promise<TransferTransactionResponse>;
     /**
-     * Signs a bundle of transactions with the Kora fee payer without broadcasting.
-     * @param request - Sign bundle request parameters
-     * @param request.transactions - Array of base64-encoded transactions to sign
-     * @param request.signer_key - Optional signer address for the transactions
-     * @param request.sig_verify - Optional signature verification (defaults to false)
-     * @param request.sign_only_indices - Optional indices of transactions to sign (defaults to all)
-     * @returns Array of signed transactions and signer public key
-     * @throws {Error} When the RPC call fails or validation fails
-     *
-     * @example
-     * ```typescript
-     * const result = await client.signBundle({
-     *   transactions: ['base64Tx1', 'base64Tx2']
-     * });
-     * console.log('Signed transactions:', result.signed_transactions);
-     * console.log('Signer:', result.signer_pubkey);
-     * ```
-     */
-    signBundle(request: SignBundleRequest): Promise<SignBundleResponse>;
-    /**
-     * Signs a bundle of transactions and sends them to Jito block engine.
-     * @param request - Sign and send bundle request parameters
-     * @param request.transactions - Array of base64-encoded transactions to sign and send
-     * @param request.signer_key - Optional signer address for the transactions
-     * @param request.sig_verify - Optional signature verification (defaults to false)
-     * @param request.sign_only_indices - Optional indices of transactions to sign (defaults to all)
-     * @returns Array of signed transactions, signer public key, and Jito bundle UUID
-     * @throws {Error} When the RPC call fails, validation fails, or Jito submission fails
-     *
-     * @example
-     * ```typescript
-     * const result = await client.signAndSendBundle({
-     *   transactions: ['base64Tx1', 'base64Tx2']
-     * });
-     * console.log('Bundle UUID:', result.bundle_uuid);
-     * console.log('Signed transactions:', result.signed_transactions);
-     * ```
-     */
-    signAndSendBundle(request: SignAndSendBundleRequest): Promise<SignAndSendBundleResponse>;
-    /**
-     * Creates a payment instruction to append to a transaction for fee payment to the Kora paymaster.
-     *
-     * This method estimates the required fee and generates a token transfer instruction
-     * from the source wallet to the Kora payment address. The server handles decimal
-     * conversion internally, so the raw token amount is used directly.
-     *
-     * @param request - Payment instruction request parameters
-     * @param request.transaction - Base64-encoded transaction to estimate fees for
-     * @param request.fee_token - Mint address of the token to use for payment
-     * @param request.source_wallet - Public key of the wallet paying the fees
-     * @param request.token_program_id - Optional token program ID (defaults to TOKEN_PROGRAM_ADDRESS)
-     * @param request.signer_key - Optional signer address for the transaction
-     * @param request.sig_verify - Optional signer verification during transaction simulation (defaults to false)
-     * @returns Payment instruction details including the instruction, amount, and addresses
-     * @throws {Error} When the token is not supported, payment is not required, or invalid addresses are provided
+     * Estimates the fee and builds a payment transfer instruction from the source wallet
+     * to the Kora payment address. The server handles decimal conversion internally.
      *
      * @example
      * ```typescript

package/dist/src/client.js

@@ -1,23 +1,13 @@
 import { assertIsAddress, createNoopSigner } from '@solana/kit';
 import { findAssociatedTokenPda, getTransferInstruction, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
 import crypto from 'crypto';
+import { getInstructionsFromBase64Message } from './utils/transaction.js';
 /**
  * Kora RPC client for interacting with the Kora paymaster service.
  *
- * Provides methods to estimate fees, sign transactions, and perform gasless transfers
- * on Solana as specified by the Kora paymaster operator.
- *
- * @example Kora Initialization
+ * @example
  * ```typescript
- * const client = new KoraClient({
- *   rpcUrl: 'http://localhost:8080',
- *   // apiKey may be required by some operators
- *   // apiKey: 'your-api-key',
- *   // hmacSecret may be required by some operators
- *   // hmacSecret: 'your-hmac-secret'
- * });
- *
- * // Sample usage: Get config
+ * const client = new KoraClient({ rpcUrl: 'http://localhost:8080' });
  * const config = await client.getConfig();
  * ```
  */
@@ -25,13 +15,6 @@ export class KoraClient {
     rpcUrl;
     apiKey;
     hmacSecret;
-    /**
-     * Creates a new Kora client instance.
-     * @param options - Client configuration options
-     * @param options.rpcUrl - The Kora RPC server URL
-     * @param options.apiKey - Optional API key for authentication
-     * @param options.hmacSecret - Optional HMAC secret for signature-based authentication
-     */
     constructor({ rpcUrl, apiKey, hmacSecret }) {
         this.rpcUrl = rpcUrl;
         this.apiKey = apiKey;
@@ -77,213 +60,35 @@ export class KoraClient {
         }
         return json.result;
     }
-    /**
-     * Retrieves the current Kora server configuration.
-     * @returns The server configuration including fee payer address and validation rules
-     * @throws {Error} When the RPC call fails
-     *
-     * @example
-     * ```typescript
-     * const config = await client.getConfig();
-     * console.log('Fee payer:', config.fee_payer);
-     * console.log('Validation config:', JSON.stringify(config.validation_config, null, 2));
-     * ```
-     */
     async getConfig() {
         return await this.rpcRequest('getConfig', undefined);
     }
-    /**
-     * Retrieves the payer signer and payment destination from the Kora server.
-     * @returns Object containing the payer signer and payment destination
-     * @throws {Error} When the RPC call fails
-     *
-     * @example
-     */
     async getPayerSigner() {
         return await this.rpcRequest('getPayerSigner', undefined);
     }
-    /**
-     * Gets the latest blockhash from the Solana RPC that the Kora server is connected to.
-     * @returns Object containing the current blockhash
-     * @throws {Error} When the RPC call fails
-     *
-     * @example
-     * ```typescript
-     * const { blockhash } = await client.getBlockhash();
-     * console.log('Current blockhash:', blockhash);
-     * ```
-     */
     async getBlockhash() {
         return await this.rpcRequest('getBlockhash', undefined);
     }
-    /**
-     * Gets the version of the Kora server.
-     * @returns Object containing the server version
-     * @throws {Error} When the RPC call fails
-     *
-     * @example
-     * ```typescript
-     * const { version } = await client.getVersion();
-     * console.log('Server version:', version);
-     * ```
-     */
-    async getVersion() {
-        return await this.rpcRequest('getVersion', undefined);
-    }
-    /**
-     * Retrieves the list of tokens supported for fee payment.
-     * @returns Object containing an array of supported token mint addresses
-     * @throws {Error} When the RPC call fails
-     *
-     * @example
-     * ```typescript
-     * const { tokens } = await client.getSupportedTokens();
-     * console.log('Supported tokens:', tokens);
-     * // Output: ['EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', ...]
-     * ```
-     */
     async getSupportedTokens() {
         return await this.rpcRequest('getSupportedTokens', undefined);
     }
-    /**
-     * Estimates the transaction fee in both lamports and the specified token.
-     * @param request - Fee estimation request parameters
-     * @param request.transaction - Base64-encoded transaction to estimate fees for
-     * @param request.fee_token - Mint address of the token to calculate fees in
-     * @returns Fee amounts in both lamports and the specified token
-     * @throws {Error} When the RPC call fails, the transaction is invalid, or the token is not supported
-     *
-     * @example
-     * ```typescript
-     * const fees = await client.estimateTransactionFee({
-     *   transaction: 'base64EncodedTransaction',
-     *   fee_token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' // USDC
-     * });
-     * console.log('Fee in lamports:', fees.fee_in_lamports);
-     * console.log('Fee in USDC:', fees.fee_in_token);
-     * ```
-     */
     async estimateTransactionFee(request) {
         return await this.rpcRequest('estimateTransactionFee', request);
     }
-    /**
-     * Estimates the bundle fee in both lamports and the specified token.
-     * @param request - Bundle fee estimation request parameters
-     * @param request.transactions - Array of base64-encoded transactions to estimate fees for
-     * @param request.fee_token - Mint address of the token to calculate fees in
-     * @returns Total fee amounts across all transactions in both lamports and the specified token
-     * @throws {Error} When the RPC call fails, the bundle is invalid, or the token is not supported
-     *
-     * @example
-     * ```typescript
-     * const fees = await client.estimateBundleFee({
-     *   transactions: ['base64EncodedTransaction1', 'base64EncodedTransaction2'],
-     *   fee_token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' // USDC
-     * });
-     * console.log('Total fee in lamports:', fees.fee_in_lamports);
-     * console.log('Total fee in USDC:', fees.fee_in_token);
-     * ```
-     */
-    async estimateBundleFee(request) {
-        return await this.rpcRequest('estimateBundleFee', request);
-    }
-    /**
-     * Signs a transaction with the Kora fee payer without broadcasting it.
-     * @param request - Sign request parameters
-     * @param request.transaction - Base64-encoded transaction to sign
-     * @returns Signature and the signed transaction
-     * @throws {Error} When the RPC call fails or transaction validation fails
-     *
-     * @example
-     * ```typescript
-     * const result = await client.signTransaction({
-     *   transaction: 'base64EncodedTransaction'
-     * });
-     * console.log('Signature:', result.signature);
-     * console.log('Signed tx:', result.signed_transaction);
-     * ```
-     */
     async signTransaction(request) {
         return await this.rpcRequest('signTransaction', request);
     }
-    /**
-     * Signs a transaction and immediately broadcasts it to the Solana network.
-     * @param request - Sign and send request parameters
-     * @param request.transaction - Base64-encoded transaction to sign and send
-     * @returns Signature and the signed transaction
-     * @throws {Error} When the RPC call fails, validation fails, or broadcast fails
-     *
-     * @example
-     * ```typescript
-     * const result = await client.signAndSendTransaction({
-     *   transaction: 'base64EncodedTransaction'
-     * });
-     * console.log('Transaction signature:', result.signature);
-     * ```
-     */
     async signAndSendTransaction(request) {
         return await this.rpcRequest('signAndSendTransaction', request);
     }
-    /**
-     * Signs a bundle of transactions with the Kora fee payer without broadcasting.
-     * @param request - Sign bundle request parameters
-     * @param request.transactions - Array of base64-encoded transactions to sign
-     * @param request.signer_key - Optional signer address for the transactions
-     * @param request.sig_verify - Optional signature verification (defaults to false)
-     * @param request.sign_only_indices - Optional indices of transactions to sign (defaults to all)
-     * @returns Array of signed transactions and signer public key
-     * @throws {Error} When the RPC call fails or validation fails
-     *
-     * @example
-     * ```typescript
-     * const result = await client.signBundle({
-     *   transactions: ['base64Tx1', 'base64Tx2']
-     * });
-     * console.log('Signed transactions:', result.signed_transactions);
-     * console.log('Signer:', result.signer_pubkey);
-     * ```
-     */
-    async signBundle(request) {
-        return await this.rpcRequest('signBundle', request);
-    }
-    /**
-     * Signs a bundle of transactions and sends them to Jito block engine.
-     * @param request - Sign and send bundle request parameters
-     * @param request.transactions - Array of base64-encoded transactions to sign and send
-     * @param request.signer_key - Optional signer address for the transactions
-     * @param request.sig_verify - Optional signature verification (defaults to false)
-     * @param request.sign_only_indices - Optional indices of transactions to sign (defaults to all)
-     * @returns Array of signed transactions, signer public key, and Jito bundle UUID
-     * @throws {Error} When the RPC call fails, validation fails, or Jito submission fails
-     *
-     * @example
-     * ```typescript
-     * const result = await client.signAndSendBundle({
-     *   transactions: ['base64Tx1', 'base64Tx2']
-     * });
-     * console.log('Bundle UUID:', result.bundle_uuid);
-     * console.log('Signed transactions:', result.signed_transactions);
-     * ```
-     */
-    async signAndSendBundle(request) {
-        return await this.rpcRequest('signAndSendBundle', request);
+    async transferTransaction(request) {
+        const response = await this.rpcRequest('transferTransaction', request);
+        response.instructions = getInstructionsFromBase64Message(response.message || '');
+        return response;
     }
     /**
-     * Creates a payment instruction to append to a transaction for fee payment to the Kora paymaster.
-     *
-     * This method estimates the required fee and generates a token transfer instruction
-     * from the source wallet to the Kora payment address. The server handles decimal
-     * conversion internally, so the raw token amount is used directly.
-     *
-     * @param request - Payment instruction request parameters
-     * @param request.transaction - Base64-encoded transaction to estimate fees for
-     * @param request.fee_token - Mint address of the token to use for payment
-     * @param request.source_wallet - Public key of the wallet paying the fees
-     * @param request.token_program_id - Optional token program ID (defaults to TOKEN_PROGRAM_ADDRESS)
-     * @param request.signer_key - Optional signer address for the transaction
-     * @param request.sig_verify - Optional signer verification during transaction simulation (defaults to false)
-     * @returns Payment instruction details including the instruction, amount, and addresses
-     * @throws {Error} When the token is not supported, payment is not required, or invalid addresses are provided
+     * Estimates the fee and builds a payment transfer instruction from the source wallet
+     * to the Kora payment address. The server handles decimal conversion internally.
      *
      * @example
      * ```typescript
@@ -316,12 +121,10 @@ export class KoraClient {
             owner: payment_address,
             tokenProgram: token_program_id,
         });
-        if (fee_in_token === undefined) {
-            throw new Error('Fee token was specified but fee_in_token was not returned from server');
-        }
+        const signer = createNoopSigner(source_wallet);
         const paymentInstruction = getTransferInstruction({
             amount: fee_in_token,
-            authority: createNoopSigner(source_wallet),
+            authority: signer,
             destination: destinationTokenAccount,
             source: sourceTokenAccount,
         });
@@ -331,6 +134,7 @@ export class KoraClient {
             payment_amount: fee_in_token,
             payment_instruction: paymentInstruction,
             payment_token: fee_token,
+            signer,
             signer_address: signer_pubkey,
         };
     }

package/dist/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from './types/index.js';
 export { KoraClient } from './client.js';
-export { koraPlugin, type KoraApi } from './plugin.js';
+export { koraPlugin, type KoraPlugin } from './kit/plugin.js';
+export { createKitKoraClient, type KoraKitClient } from './kit/index.js';

package/dist/src/index.js

@@ -1,3 +1,4 @@
 export * from './types/index.js';
 export { KoraClient } from './client.js';
-export { koraPlugin } from './plugin.js';
+export { koraPlugin } from './kit/plugin.js';
+export { createKitKoraClient } from './kit/index.js';

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

@@ -0,0 +1,7 @@
+import { type Address, type TransactionMessage, type TransactionMessageWithFeePayer, type TransactionSigner } from '@solana/kit';
+import { KoraClient } from '../client.js';
+import type { KoraKitClientConfig } from '../types/index.js';
+export declare function createKoraTransactionPlanExecutor(koraClient: KoraClient, config: KoraKitClientConfig, payerSigner: TransactionSigner, payment: {
+    destinationTokenAccount: Address;
+    sourceTokenAccount: Address;
+} | undefined, resolveProvisoryComputeUnitLimit: (<T extends TransactionMessage & TransactionMessageWithFeePayer>(transactionMessage: T) => Promise<T>) | undefined): import("@solana/kit").TransactionPlanExecutor<import("@solana/kit").TransactionPlanResultContext>;

package/dist/src/kit/executor.js

@@ -0,0 +1,55 @@
+import { appendTransactionMessageInstructions, blockhash, createTransactionMessage, createTransactionPlanExecutor, getBase64EncodedWireTransaction, getBase64Encoder, getSignatureFromTransaction, getTransactionDecoder, partiallySignTransactionMessageWithSigners, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signature, } from '@solana/kit';
+import { removePaymentInstruction, updatePaymentInstructionAmount } from './payment.js';
+export function createKoraTransactionPlanExecutor(koraClient, config, payerSigner, payment, resolveProvisoryComputeUnitLimit) {
+    return createTransactionPlanExecutor({
+        async executeTransactionMessage(_context, transactionMessage) {
+            // Kora manages blockhash validity; set max height to avoid premature client-side expiry checks
+            const { blockhash: bh } = await koraClient.getBlockhash();
+            const msgWithLifetime = setTransactionMessageLifetimeUsingBlockhash({
+                blockhash: blockhash(bh),
+                lastValidBlockHeight: BigInt(Number.MAX_SAFE_INTEGER),
+            }, transactionMessage);
+            const msgForEstimation = resolveProvisoryComputeUnitLimit
+                ? await resolveProvisoryComputeUnitLimit(msgWithLifetime)
+                : msgWithLifetime;
+            const prePaymentTx = getBase64EncodedWireTransaction(await partiallySignTransactionMessageWithSigners(msgForEstimation));
+            let finalTx;
+            if (payment) {
+                const { sourceTokenAccount, destinationTokenAccount } = payment;
+                const { fee_in_token } = await koraClient.estimateTransactionFee({
+                    fee_token: config.feeToken,
+                    transaction: prePaymentTx,
+                });
+                if (fee_in_token < 0) {
+                    throw new Error(`Kora fee estimation returned a negative fee (${fee_in_token}). This indicates a server-side error.`);
+                }
+                const currentIxs = 'instructions' in msgForEstimation
+                    ? msgForEstimation.instructions
+                    : undefined;
+                if (!currentIxs) {
+                    throw new Error('Cannot extract instructions from transaction message. ' +
+                        'The message structure may be incompatible with this version of the Kora SDK.');
+                }
+                // Replace placeholder with real fee amount, or strip it if fee is 0
+                const finalIxs = fee_in_token > 0
+                    ? updatePaymentInstructionAmount(currentIxs, config.feePayerWallet, sourceTokenAccount, destinationTokenAccount, fee_in_token, config.tokenProgramId)
+                    : removePaymentInstruction(currentIxs, sourceTokenAccount, destinationTokenAccount, config.feePayerWallet, config.tokenProgramId);
+                const resolvedMsg = pipe(createTransactionMessage({ version: 0 }), m => setTransactionMessageFeePayerSigner(payerSigner, m), m => setTransactionMessageLifetimeUsingBlockhash({
+                    blockhash: blockhash(bh),
+                    lastValidBlockHeight: BigInt(Number.MAX_SAFE_INTEGER),
+                }, m), m => appendTransactionMessageInstructions(finalIxs, m));
+                finalTx = getBase64EncodedWireTransaction(await partiallySignTransactionMessageWithSigners(resolvedMsg));
+            }
+            else {
+                finalTx = prePaymentTx;
+            }
+            const result = await koraClient.signAndSendTransaction({ transaction: finalTx });
+            if (result.signature) {
+                return signature(result.signature);
+            }
+            const signedTxBytes = getBase64Encoder().encode(result.signed_transaction);
+            const decodedTx = getTransactionDecoder().decode(signedTxBytes);
+            return getSignatureFromTransaction(decodedTx);
+        },
+    });
+}