@solana/kora 0.2.0-beta.6 → 0.2.1

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,204 +12,21 @@ export declare class KoraClient {
     private rpcUrl;
     private apiKey?;
     private hmacSecret?;
-    private getRecaptchaToken?;
-    /**
-     * 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
-     * @param options.getRecaptchaToken - Optional callback to get reCAPTCHA token for bot protection
-     */
-    constructor({ rpcUrl, apiKey, hmacSecret, getRecaptchaToken }: KoraClientOptions);
+    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 { assertIsAddress, isTransactionSigner } 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,20 +15,10 @@ export class KoraClient {
     rpcUrl;
     apiKey;
     hmacSecret;
-    getRecaptchaToken;
-    /**
-     * 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
-     * @param options.getRecaptchaToken - Optional callback to get reCAPTCHA token for bot protection
-     */
-    constructor({ rpcUrl, apiKey, hmacSecret, getRecaptchaToken }) {
+    constructor({ rpcUrl, apiKey, hmacSecret }) {
         this.rpcUrl = rpcUrl;
         this.apiKey = apiKey;
         this.hmacSecret = hmacSecret;
-        this.getRecaptchaToken = getRecaptchaToken;
     }
     getHmacSignature({ timestamp, body }) {
         if (!this.hmacSecret) {
@@ -47,7 +27,7 @@ export class KoraClient {
         const message = timestamp + body;
         return crypto.createHmac('sha256', this.hmacSecret).update(message).digest('hex');
     }
-    async getHeaders({ body }) {
+    getHeaders({ body }) {
         const headers = {};
         if (this.apiKey) {
             headers['x-api-key'] = this.apiKey;
@@ -58,10 +38,6 @@ export class KoraClient {
             headers['x-timestamp'] = timestamp;
             headers['x-hmac-signature'] = signature;
         }
-        if (this.getRecaptchaToken) {
-            const token = await Promise.resolve(this.getRecaptchaToken());
-            headers['x-recaptcha-token'] = token;
-        }
         return headers;
     }
     async rpcRequest(method, params) {
@@ -71,7 +47,7 @@ export class KoraClient {
             method,
             params,
         });
-        const headers = await this.getHeaders({ body });
+        const headers = this.getHeaders({ body });
         const response = await fetch(this.rpcUrl, {
             body,
             headers: { ...headers, 'Content-Type': 'application/json' },
@@ -84,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
@@ -303,7 +101,9 @@ export class KoraClient {
      * ```
      */
     async getPaymentInstruction({ transaction, fee_token, source_wallet, token_program_id = TOKEN_PROGRAM_ADDRESS, signer_key, sig_verify, }) {
-        assertIsAddress(source_wallet);
+        const sourceIsSigner = typeof source_wallet !== 'string' && isTransactionSigner(source_wallet);
+        const walletAddress = sourceIsSigner ? source_wallet.address : source_wallet;
+        assertIsAddress(walletAddress);
         assertIsAddress(fee_token);
         assertIsAddress(token_program_id);
         const { fee_in_token, payment_address, signer_pubkey } = await this.estimateTransactionFee({
@@ -315,7 +115,7 @@ export class KoraClient {
         assertIsAddress(payment_address);
         const [sourceTokenAccount] = await findAssociatedTokenPda({
             mint: fee_token,
-            owner: source_wallet,
+            owner: walletAddress,
             tokenProgram: token_program_id,
         });
         const [destinationTokenAccount] = await findAssociatedTokenPda({
@@ -323,12 +123,9 @@ 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 paymentInstruction = getTransferInstruction({
             amount: fee_in_token,
-            authority: createNoopSigner(source_wallet),
+            authority: sourceIsSigner ? source_wallet : walletAddress,
             destination: destinationTokenAccount,
             source: sourceTokenAccount,
         });

package/dist/src/index.d.ts

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

package/dist/src/index.js

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

package/dist/src/kit/executor.js

@@ -1,10 +1,5 @@
 import { appendTransactionMessageInstructions, blockhash, createTransactionMessage, createTransactionPlanExecutor, getBase64EncodedWireTransaction, getBase64Encoder, getSignatureFromTransaction, getTransactionDecoder, partiallySignTransactionMessageWithSigners, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signature, } from '@solana/kit';
 import { removePaymentInstruction, updatePaymentInstructionAmount } from './payment.js';
-// TODO: Create a bundle-aware executor (e.g. `createKoraBundlePlanExecutor`) that collects
-// multiple planned transaction messages into a single `signAndSendBundle` call instead of
-// submitting each one individually via `signAndSendTransaction`. This would let users
-// compose Jito bundles through the Kit plan/execute pipeline rather than manually encoding
-// transactions and calling `client.kora.signAndSendBundle()`.
 export function createKoraTransactionPlanExecutor(koraClient, config, payerSigner, payment, resolveProvisoryComputeUnitLimit) {
     return createTransactionPlanExecutor({
         async executeTransactionMessage(_context, transactionMessage) {
@@ -25,13 +20,8 @@ export function createKoraTransactionPlanExecutor(koraClient, config, payerSigne
                     fee_token: config.feeToken,
                     transaction: prePaymentTx,
                 });
-                if (fee_in_token == null) {
-                    console.warn('[kora] fee_in_token is undefined — defaulting to 0. ' +
-                        'If paid pricing is expected, check that the fee token is correctly configured on the server.');
-                }
-                const feeInToken = fee_in_token ?? 0;
-                if (feeInToken < 0) {
-                    throw new Error(`Kora fee estimation returned a negative fee (${feeInToken}). This indicates a server-side error.`);
+                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
@@ -41,8 +31,8 @@ export function createKoraTransactionPlanExecutor(koraClient, config, payerSigne
                         '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 = feeInToken > 0
-                    ? updatePaymentInstructionAmount(currentIxs, config.feePayerWallet, sourceTokenAccount, destinationTokenAccount, feeInToken, config.tokenProgramId)
+                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),
@@ -53,10 +43,7 @@ export function createKoraTransactionPlanExecutor(koraClient, config, payerSigne
             else {
                 finalTx = prePaymentTx;
             }
-            const result = await koraClient.signAndSendTransaction({
-                transaction: finalTx,
-                user_id: config.userId,
-            });
+            const result = await koraClient.signAndSendTransaction({ transaction: finalTx });
             if (result.signature) {
                 return signature(result.signature);
             }

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

@@ -29,18 +29,15 @@ export declare function createKitKoraClient(config: KoraKitClientConfig): Promis
     rpcSubscriptions: import("@solana/kit").RpcSubscriptions<import("@solana/kit").SolanaRpcSubscriptionsApi>;
 } & {
     kora: {
-        estimateBundleFee(request: import("../types/index.js").EstimateBundleFeeRequest): Promise<import("../types/index.js").KitEstimateBundleFeeResponse>;
         estimateTransactionFee(request: import("../types/index.js").EstimateTransactionFeeRequest): Promise<import("../types/index.js").KitEstimateFeeResponse>;
         getBlockhash(): Promise<import("../types/index.js").KitBlockhashResponse>;
         getConfig(): Promise<import("../types/index.js").KitConfigResponse>;
         getPayerSigner(): Promise<import("../types/index.js").KitPayerSignerResponse>;
         getPaymentInstruction(request: import("../types/index.js").GetPaymentInstructionRequest): Promise<import("../types/index.js").KitPaymentInstructionResponse>;
         getSupportedTokens(): Promise<import("../types/index.js").KitSupportedTokensResponse>;
-        getVersion(): Promise<import("../types/index.js").GetVersionResponse>;
-        signAndSendBundle(request: import("../types/index.js").SignAndSendBundleRequest): Promise<import("../types/index.js").KitSignAndSendBundleResponse>;
         signAndSendTransaction(request: import("../types/index.js").SignAndSendTransactionRequest): Promise<import("../types/index.js").KitSignAndSendTransactionResponse>;
-        signBundle(request: import("../types/index.js").SignBundleRequest): Promise<import("../types/index.js").KitSignBundleResponse>;
         signTransaction(request: import("../types/index.js").SignTransactionRequest): Promise<import("../types/index.js").KitSignTransactionResponse>;
+        transferTransaction(request: import("../types/index.js").TransferTransactionRequest): Promise<import("../types/index.js").KitTransferTransactionResponse>;
     };
 } & {
     payer: import("@solana/kit").TransactionSigner;