@solana/kora 0.2.0-beta.0 → 0.2.0-beta.2

package/dist/src/client.d.ts

@@ -1,4 +1,4 @@
-import { Config, EstimateTransactionFeeRequest, EstimateTransactionFeeResponse, GetBlockhashResponse, GetSupportedTokensResponse, SignAndSendTransactionRequest, SignAndSendTransactionResponse, SignTransactionRequest, SignTransactionResponse, TransferTransactionRequest, TransferTransactionResponse, KoraClientOptions, GetPayerSignerResponse, GetPaymentInstructionRequest, GetPaymentInstructionResponse } from './types/index.js';
+import { Config, EstimateTransactionFeeRequest, EstimateTransactionFeeResponse, EstimateBundleFeeRequest, EstimateBundleFeeResponse, GetBlockhashResponse, GetSupportedTokensResponse, GetVersionResponse, SignAndSendTransactionRequest, SignAndSendTransactionResponse, SignTransactionRequest, SignTransactionResponse, SignBundleRequest, SignBundleResponse, SignAndSendBundleRequest, SignAndSendBundleResponse, TransferTransactionRequest, TransferTransactionResponse, KoraClientOptions, GetPayerSignerResponse, GetPaymentInstructionRequest, GetPaymentInstructionResponse } from './types/index.js';
 /**
  * Kora RPC client for interacting with the Kora paymaster service.
  *
@@ -67,6 +67,18 @@ export declare class KoraClient {
      * ```
      */
     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
@@ -99,6 +111,25 @@ export declare class KoraClient {
      * ```
      */
     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
@@ -133,13 +164,55 @@ export declare class KoraClient {
      */
     signAndSendTransaction(request: SignAndSendTransactionRequest): Promise<SignAndSendTransactionResponse>;
     /**
-     * Creates a token transfer transaction with Kora as the fee payer.
+     * 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)
+     * @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)
+     * @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 an unsigned transfer transaction.
+     *
+     * @deprecated Use `getPaymentInstruction` instead for fee payment flows.
+     *
      * @param request - Transfer request parameters
      * @param request.amount - Amount to transfer (in token's smallest unit)
      * @param request.token - Mint address of the token to transfer
      * @param request.source - Source wallet public key
      * @param request.destination - Destination wallet public key
-     * @returns Base64-encoded signed transaction, base64-encoded message, blockhash, and parsed instructions
+     * @param request.signer_key - Optional signer key to select specific Kora signer
+     * @returns Unsigned transaction, message, blockhash, and signer info
      * @throws {Error} When the RPC call fails or token is not supported
      *
      * @example
@@ -148,11 +221,9 @@ export declare class KoraClient {
      *   amount: 1000000, // 1 USDC (6 decimals)
      *   token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
      *   source: 'sourceWalletPublicKey',
-     *   destination: 'destinationWalletPublicKey'
+     *   destination: 'destinationWalletPublicKey',
      * });
-     * console.log('Transaction:', transfer.transaction);
-     * console.log('Message:', transfer.message);
-     * console.log('Instructions:', transfer.instructions);
+     * console.log('Signer:', transfer.signer_pubkey);
      * ```
      */
     transferTransaction(request: TransferTransactionRequest): Promise<TransferTransactionResponse>;

package/dist/src/client.js

@@ -1,7 +1,7 @@
 import { assertIsAddress, createNoopSigner } from '@solana/kit';
 import crypto from 'crypto';
-import { getInstructionsFromBase64Message } from './utils/transaction.js';
 import { findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS, getTransferInstruction } from '@solana-program/token';
+import { getInstructionsFromBase64Message } from './utils/transaction.js';
 /**
  * Kora RPC client for interacting with the Kora paymaster service.
  *
@@ -117,6 +117,20 @@ export class KoraClient {
     async getBlockhash() {
         return 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 this.rpcRequest('getVersion', undefined);
+    }
     /**
      * Retrieves the list of tokens supported for fee payment.
      * @returns Object containing an array of supported token mint addresses
@@ -153,6 +167,27 @@ export class KoraClient {
     async estimateTransactionFee(request) {
         return 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 this.rpcRequest('estimateBundleFee', request);
+    }
     /**
      * Signs a transaction with the Kora fee payer without broadcasting it.
      * @param request - Sign request parameters
@@ -191,13 +226,59 @@ export class KoraClient {
         return this.rpcRequest('signAndSendTransaction', request);
     }
     /**
-     * Creates a token transfer transaction with Kora as the fee payer.
+     * 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)
+     * @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 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)
+     * @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 this.rpcRequest('signAndSendBundle', request);
+    }
+    /**
+     * Creates an unsigned transfer transaction.
+     *
+     * @deprecated Use `getPaymentInstruction` instead for fee payment flows.
+     *
      * @param request - Transfer request parameters
      * @param request.amount - Amount to transfer (in token's smallest unit)
      * @param request.token - Mint address of the token to transfer
      * @param request.source - Source wallet public key
      * @param request.destination - Destination wallet public key
-     * @returns Base64-encoded signed transaction, base64-encoded message, blockhash, and parsed instructions
+     * @param request.signer_key - Optional signer key to select specific Kora signer
+     * @returns Unsigned transaction, message, blockhash, and signer info
      * @throws {Error} When the RPC call fails or token is not supported
      *
      * @example
@@ -206,11 +287,9 @@ export class KoraClient {
      *   amount: 1000000, // 1 USDC (6 decimals)
      *   token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
      *   source: 'sourceWalletPublicKey',
-     *   destination: 'destinationWalletPublicKey'
+     *   destination: 'destinationWalletPublicKey',
      * });
-     * console.log('Transaction:', transfer.transaction);
-     * console.log('Message:', transfer.message);
-     * console.log('Instructions:', transfer.instructions);
+     * console.log('Signer:', transfer.signer_pubkey);
      * ```
      */
     async transferTransaction(request) {
@@ -268,6 +347,9 @@ export class KoraClient {
             tokenProgram: token_program_id,
             mint: fee_token,
         });
+        if (fee_in_token === undefined) {
+            throw new Error('Fee token was specified but fee_in_token was not returned from server');
+        }
         const paymentInstruction = getTransferInstruction({
             source: sourceTokenAccount,
             destination: destinationTokenAccount,

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

@@ -3,7 +3,8 @@ import { Instruction } from '@solana/kit';
  * Request Types
  */
 /**
- * Parameters for creating a token transfer transaction.
+ * Parameters for creating a transfer transaction.
+ * @deprecated Use `getPaymentInstruction` instead for fee payment flows.
  */
 export interface TransferTransactionRequest {
     /** Amount to transfer in the token's smallest unit (e.g., lamports for SOL) */
@@ -14,7 +15,7 @@ export interface TransferTransactionRequest {
     source: string;
     /** Public key of the destination wallet (not token account) */
     destination: string;
-    /** Optional signer address for the transaction */
+    /** Optional signer key to select a specific Kora signer */
     signer_key?: string;
 }
 /**
@@ -39,6 +40,28 @@ export interface SignAndSendTransactionRequest {
     /** Optional signer verification during transaction simulation (defaults to false) */
     sig_verify?: boolean;
 }
+/**
+ * Parameters for signing a bundle of transactions.
+ */
+export interface SignBundleRequest {
+    /** Array of base64-encoded transactions to sign */
+    transactions: string[];
+    /** Optional signer address for the transactions */
+    signer_key?: string;
+    /** Optional signer verification during transaction simulation (defaults to false) */
+    sig_verify?: boolean;
+}
+/**
+ * Parameters for signing and sending a bundle of transactions via Jito.
+ */
+export interface SignAndSendBundleRequest {
+    /** Array of base64-encoded transactions to sign and send */
+    transactions: string[];
+    /** Optional signer address for the transactions */
+    signer_key?: string;
+    /** Optional signer verification during transaction simulation (defaults to false) */
+    sig_verify?: boolean;
+}
 /**
  * Parameters for estimating transaction fees.
  */
@@ -46,12 +69,25 @@ export interface EstimateTransactionFeeRequest {
     /** Base64-encoded transaction to estimate fees for */
     transaction: string;
     /** Mint address of the token to calculate fees in */
-    fee_token: string;
+    fee_token?: string;
     /** Optional signer address for the transaction */
     signer_key?: string;
     /** Optional signer verification during transaction simulation (defaults to false) */
     sig_verify?: boolean;
 }
+/**
+ * Parameters for estimating bundle fees.
+ */
+export interface EstimateBundleFeeRequest {
+    /** Array of base64-encoded transactions to estimate fees for */
+    transactions: string[];
+    /** Mint address of the token to calculate fees in */
+    fee_token?: string;
+    /** Optional signer address for the transactions */
+    signer_key?: string;
+    /** Optional signer verification during transaction simulation (defaults to false) */
+    sig_verify?: boolean;
+}
 /**
  * Parameters for getting a payment instruction.
  */
@@ -74,15 +110,17 @@ export interface GetPaymentInstructionRequest {
  */
 /**
  * Response from creating a transfer transaction.
+ * The transaction is unsigned.
+ * @deprecated Use `getPaymentInstruction` instead for fee payment flows.
  */
 export interface TransferTransactionResponse {
-    /** Base64-encoded signed transaction */
+    /** Base64-encoded unsigned transaction */
     transaction: string;
-    /** Base64-encoded message */
+    /** Base64-encoded unsigned message */
     message: string;
     /** Recent blockhash used in the transaction */
     blockhash: string;
-    /** Public key of the signer used to send the transaction */
+    /** Public key of the Kora signer (fee payer) */
     signer_pubkey: string;
     /** Parsed instructions from the transaction message */
     instructions: Instruction[];
@@ -107,6 +145,26 @@ 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 {
+    /** Array of base64-encoded signed transactions */
+    signed_transactions: string[];
+    /** Public key of the signer used to sign the transactions */
+    signer_pubkey: string;
+    /** UUID of the submitted Jito bundle */
+    bundle_uuid: string;
+}
 /**
  * Response containing the latest blockhash.
  */
@@ -114,6 +172,13 @@ 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.
  */
@@ -130,7 +195,22 @@ 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;
+    fee_in_token?: number;
+    /** Public key of the signer used to estimate the fee */
+    signer_pubkey: string;
+    /** Public key of the payment destination */
+    payment_address: 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;
     /** Public key of the signer used to estimate the fee */
     signer_pubkey: string;
     /** Public key of the payment destination */
@@ -226,8 +306,12 @@ export interface EnabledMethods {
     liveness: boolean;
     /** Whether the estimate_transaction_fee method is enabled */
     estimate_transaction_fee: boolean;
+    /** Whether the estimate_bundle_fee method is enabled (requires bundle.enabled = true) */
+    estimate_bundle_fee: boolean;
     /** Whether the get_supported_tokens method is enabled */
     get_supported_tokens: boolean;
+    /** Whether the get_payer_signer method is enabled */
+    get_payer_signer: boolean;
     /** Whether the sign_transaction method is enabled */
     sign_transaction: boolean;
     /** Whether the sign_and_send_transaction method is enabled */
@@ -238,6 +322,12 @@ export interface EnabledMethods {
     get_blockhash: boolean;
     /** Whether the get_config method is enabled */
     get_config: boolean;
+    /** Whether the get_version method is enabled */
+    get_version: boolean;
+    /** Whether the sign_and_send_bundle method is enabled (requires bundle.enabled = true) */
+    sign_and_send_bundle: boolean;
+    /** Whether the sign_bundle method is enabled (requires bundle.enabled = true) */
+    sign_bundle: boolean;
 }
 /**
  * Kora server configuration.
@@ -296,6 +386,12 @@ export interface SplTokenInstructionPolicy {
     allow_set_authority: boolean;
     /** Allow fee payer to mint SPL tokens */
     allow_mint_to: boolean;
+    /** Allow fee payer to initialize SPL token mints */
+    allow_initialize_mint: boolean;
+    /** Allow fee payer to initialize SPL token accounts */
+    allow_initialize_account: boolean;
+    /** Allow fee payer to initialize SPL multisig accounts */
+    allow_initialize_multisig: boolean;
     /** Allow fee payer to freeze SPL token accounts */
     allow_freeze_account: boolean;
     /** Allow fee payer to thaw SPL token accounts */
@@ -319,6 +415,12 @@ export interface Token2022InstructionPolicy {
     allow_set_authority: boolean;
     /** Allow fee payer to mint Token2022 tokens */
     allow_mint_to: boolean;
+    /** Allow fee payer to initialize Token2022 mints */
+    allow_initialize_mint: boolean;
+    /** Allow fee payer to initialize Token2022 accounts */
+    allow_initialize_account: boolean;
+    /** Allow fee payer to initialize Token2022 multisig accounts */
+    allow_initialize_multisig: boolean;
     /** Allow fee payer to freeze Token2022 accounts */
     allow_freeze_account: boolean;
     /** Allow fee payer to thaw Token2022 accounts */

package/dist/test/integration.test.js

@@ -1,32 +1,34 @@
 import setupTestSuite from './setup.js';
 import { runAuthenticationTests } from './auth-setup.js';
-import { generateKeyPairSigner, getBase64EncodedWireTransaction, getBase64Encoder, getTransactionDecoder, signTransaction, } from '@solana/kit';
-import { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+import { getBase64Decoder, getBase64Encoder, getTransactionDecoder, getTransactionEncoder, partiallySignTransaction, } from '@solana/kit';
+import { findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
 function transactionFromBase64(base64) {
     const encoder = getBase64Encoder();
     const decoder = getTransactionDecoder();
     const messageBytes = encoder.encode(base64);
     return decoder.decode(messageBytes);
 }
+function transactionToBase64(transaction) {
+    const txEncoder = getTransactionEncoder();
+    const txBytes = txEncoder.encode(transaction);
+    const base64Decoder = getBase64Decoder();
+    return base64Decoder.decode(txBytes);
+}
 const AUTH_ENABLED = process.env.ENABLE_AUTH === 'true';
 const KORA_SIGNER_TYPE = process.env.KORA_SIGNER_TYPE || 'memory';
 describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without auth'} | signer type: ${KORA_SIGNER_TYPE})`, () => {
     let client;
     let testWallet;
     let testWalletAddress;
-    let destinationAddress;
     let usdcMint;
     let koraAddress;
-    let koraRpcUrl;
     beforeAll(async () => {
         const testSuite = await setupTestSuite();
         client = testSuite.koraClient;
         testWallet = testSuite.testWallet;
         testWalletAddress = testWallet.address;
-        destinationAddress = testSuite.destinationAddress;
         usdcMint = testSuite.usdcMint;
         koraAddress = testSuite.koraAddress;
-        koraRpcUrl = testSuite.koraRpcUrl;
     }, 90000); // allow adequate time for airdrops and token initialization
     // Run authentication tests only when auth is enabled
     if (AUTH_ENABLED) {
@@ -91,6 +93,7 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
             expect(config.enabled_methods.transfer_transaction).toBeDefined();
             expect(config.enabled_methods.get_blockhash).toBeDefined();
             expect(config.enabled_methods.get_config).toBeDefined();
+            expect(config.enabled_methods.get_version).toBeDefined();
         });
         it('should get payer signer', async () => {
             const { signer_address, payment_address } = await client.getPayerSigner();
@@ -110,43 +113,29 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
             expect(blockhash.length).toBeGreaterThanOrEqual(43);
             expect(blockhash.length).toBeLessThanOrEqual(44); // Base58 encoded hash length
         });
+        it('should get version', async () => {
+            const { version } = await client.getVersion();
+            expect(version).toBeDefined();
+            expect(typeof version).toBe('string');
+            expect(version.length).toBeGreaterThan(0);
+            // Version should follow semver format (e.g., "2.1.0" or "2.1.0-beta.0")
+            expect(version).toMatch(/^\d+\.\d+\.\d+/);
+        });
     });
     describe('Transaction Operations', () => {
-        it('should create transfer transaction', async () => {
-            const request = {
-                amount: 1000000, // 1 USDC
-                token: usdcMint,
-                source: testWalletAddress,
-                destination: destinationAddress,
-            };
-            const response = await client.transferTransaction(request);
-            expect(response).toBeDefined();
-            expect(response.transaction).toBeDefined();
-            expect(response.blockhash).toBeDefined();
-            expect(response.message).toBeDefined();
-            expect(response.instructions).toBeDefined();
-            // since setup created ATA for destination, we should not expect ata instruction, only transfer instruction
-            expect(response.instructions?.length).toBe(1);
-            expect(response.instructions?.[0].programAddress).toBe(TOKEN_PROGRAM_ADDRESS);
-        });
-        it('should create transfer transaction to address with no ATA', async () => {
-            const randomDestination = await generateKeyPairSigner();
+        it('should create transfer transaction (DEPRECATED endpoint)', async () => {
             const request = {
                 amount: 1000000, // 1 USDC
                 token: usdcMint,
                 source: testWalletAddress,
-                destination: randomDestination.address,
+                destination: koraAddress, // user specifies destination
             };
             const response = await client.transferTransaction(request);
             expect(response).toBeDefined();
             expect(response.transaction).toBeDefined();
             expect(response.blockhash).toBeDefined();
             expect(response.message).toBeDefined();
-            expect(response.instructions).toBeDefined();
-            // since setup created ATA for destination, we should not expect ata instruction, only transfer instruction
-            expect(response.instructions?.length).toBe(2);
-            expect(response.instructions?.[0].programAddress).toBe(ASSOCIATED_TOKEN_PROGRAM_ADDRESS);
-            expect(response.instructions?.[1].programAddress).toBe(TOKEN_PROGRAM_ADDRESS);
+            expect(response.signer_pubkey).toBeDefined();
         });
         it('should estimate transaction fee', async () => {
             // First create a transaction
@@ -154,7 +143,7 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
                 amount: 1000000,
                 token: usdcMint,
                 source: testWalletAddress,
-                destination: testWalletAddress,
+                destination: koraAddress,
             };
             const { transaction } = await client.transferTransaction(transferRequest);
             const fee = await client.estimateTransactionFee({ transaction, fee_token: usdcMint });
@@ -165,13 +154,11 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
             expect(fee.fee_in_token).toBeGreaterThan(0);
         });
         it('should sign transaction', async () => {
-            const config = await client.getConfig();
-            const paymentAddress = config.fee_payers[0];
             const transferRequest = {
                 amount: 1000000,
                 token: usdcMint,
                 source: testWalletAddress,
-                destination: paymentAddress,
+                destination: koraAddress,
             };
             const { transaction } = await client.transferTransaction(transferRequest);
             const signResult = await client.signTransaction({
@@ -181,19 +168,18 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
             expect(signResult.signed_transaction).toBeDefined();
         });
         it('should sign and send transaction', async () => {
-            const config = await client.getConfig();
-            const paymentAddress = config.fee_payers[0];
             const transferRequest = {
                 amount: 1000000,
                 token: usdcMint,
                 source: testWalletAddress,
-                destination: paymentAddress,
+                destination: koraAddress,
             };
             const { transaction: transactionString } = await client.transferTransaction(transferRequest);
             const transaction = transactionFromBase64(transactionString);
-            // Sign transaction with test wallet before sending
-            const signedTransaction = await signTransaction([testWallet.keyPair], transaction);
-            const base64SignedTransaction = getBase64EncodedWireTransaction(signedTransaction);
+            // Partially sign transaction with test wallet before sending
+            // Kora will add fee payer signature via signAndSendTransaction
+            const signedTransaction = await partiallySignTransaction([testWallet.keyPair], transaction);
+            const base64SignedTransaction = transactionToBase64(signedTransaction);
             const signResult = await client.signAndSendTransaction({
                 transaction: base64SignedTransaction,
             });
@@ -205,7 +191,7 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
                 amount: 1000000,
                 token: usdcMint,
                 source: testWalletAddress,
-                destination: destinationAddress,
+                destination: koraAddress,
             };
             const [expectedSenderAta] = await findAssociatedTokenPda({
                 owner: testWalletAddress,
@@ -236,13 +222,81 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
             expect(original_transaction).toBe(transaction);
         });
     });
+    describe('Bundle Operations', () => {
+        it('should sign bundle of transactions', async () => {
+            // Create two transfer transactions for the bundle
+            const transferRequest1 = {
+                amount: 1000000,
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: koraAddress,
+            };
+            const transferRequest2 = {
+                amount: 500000,
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: koraAddress,
+            };
+            const { transaction: tx1String } = await client.transferTransaction(transferRequest1);
+            const { transaction: tx2String } = await client.transferTransaction(transferRequest2);
+            // Partially sign both transactions with test wallet
+            const tx1 = transactionFromBase64(tx1String);
+            const tx2 = transactionFromBase64(tx2String);
+            const signedTx1 = await partiallySignTransaction([testWallet.keyPair], tx1);
+            const signedTx2 = await partiallySignTransaction([testWallet.keyPair], tx2);
+            const base64Tx1 = transactionToBase64(signedTx1);
+            const base64Tx2 = transactionToBase64(signedTx2);
+            const result = await client.signBundle({
+                transactions: [base64Tx1, base64Tx2],
+            });
+            expect(result).toBeDefined();
+            expect(result.signed_transactions).toBeDefined();
+            expect(Array.isArray(result.signed_transactions)).toBe(true);
+            expect(result.signed_transactions.length).toBe(2);
+            expect(result.signer_pubkey).toBeDefined();
+        });
+        it('should sign and send bundle of transactions', async () => {
+            // Create two transfer transactions for the bundle
+            const transferRequest1 = {
+                amount: 1000000,
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: koraAddress,
+            };
+            const transferRequest2 = {
+                amount: 500000,
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: koraAddress,
+            };
+            const { transaction: tx1String } = await client.transferTransaction(transferRequest1);
+            const { transaction: tx2String } = await client.transferTransaction(transferRequest2);
+            // Partially sign both transactions with test wallet
+            const tx1 = transactionFromBase64(tx1String);
+            const tx2 = transactionFromBase64(tx2String);
+            const signedTx1 = await partiallySignTransaction([testWallet.keyPair], tx1);
+            const signedTx2 = await partiallySignTransaction([testWallet.keyPair], tx2);
+            const base64Tx1 = transactionToBase64(signedTx1);
+            const base64Tx2 = transactionToBase64(signedTx2);
+            const result = await client.signAndSendBundle({
+                transactions: [base64Tx1, base64Tx2],
+            });
+            expect(result).toBeDefined();
+            expect(result.signed_transactions).toBeDefined();
+            expect(Array.isArray(result.signed_transactions)).toBe(true);
+            expect(result.signed_transactions.length).toBe(2);
+            expect(result.signer_pubkey).toBeDefined();
+            expect(result.bundle_uuid).toBeDefined();
+            expect(typeof result.bundle_uuid).toBe('string');
+        });
+    });
     describe('Error Handling', () => {
         it('should handle invalid token address', async () => {
             const request = {
                 amount: 1000000,
                 token: 'InvalidTokenAddress',
                 source: testWalletAddress,
-                destination: destinationAddress,
+                destination: koraAddress,
             };
             await expect(client.transferTransaction(request)).rejects.toThrow();
         });
@@ -251,7 +305,7 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
                 amount: -1, // Invalid amount
                 token: usdcMint,
                 source: testWalletAddress,
-                destination: destinationAddress,
+                destination: koraAddress,
             };
             await expect(client.transferTransaction(request)).rejects.toThrow();
         });
@@ -268,7 +322,7 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
                 amount: 1000000,
                 token: usdcMint,
                 source: testWalletAddress,
-                destination: destinationAddress,
+                destination: koraAddress,
             };
             // TODO: API has an error. this endpoint should verify the provided fee token is supported
             const { transaction } = await client.transferTransaction(transferRequest);
@@ -280,13 +334,11 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
     });
     describe('End-to-End Flows', () => {
         it('should handle transfer and sign flow', async () => {
-            const config = await client.getConfig();
-            const paymentAddress = config.fee_payers[0];
             const request = {
                 amount: 1000000,
                 token: usdcMint,
                 source: testWalletAddress,
-                destination: paymentAddress,
+                destination: koraAddress,
             };
             // Create and sign the transaction
             const { transaction } = await client.transferTransaction(request);
@@ -299,7 +351,7 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
                 amount: 1000000,
                 token: invalidTokenMint,
                 source: testWalletAddress,
-                destination: destinationAddress,
+                destination: koraAddress,
             };
             await expect(client.transferTransaction(request)).rejects.toThrow();
         });

package/dist/test/unit.test.js

@@ -108,6 +108,9 @@ describe('KoraClient Unit Tests', () => {
                             allow_revoke: true,
                             allow_set_authority: true,
                             allow_mint_to: true,
+                            allow_initialize_mint: true,
+                            allow_initialize_account: true,
+                            allow_initialize_multisig: true,
                             allow_freeze_account: true,
                             allow_thaw_account: true,
                         },
@@ -119,6 +122,9 @@ describe('KoraClient Unit Tests', () => {
                             allow_revoke: true,
                             allow_set_authority: true,
                             allow_mint_to: true,
+                            allow_initialize_mint: true,
+                            allow_initialize_account: true,
+                            allow_initialize_multisig: true,
                             allow_freeze_account: true,
                             allow_thaw_account: true,
                         },
@@ -135,12 +141,17 @@ describe('KoraClient Unit Tests', () => {
                 enabled_methods: {
                     liveness: true,
                     estimate_transaction_fee: true,
+                    estimate_bundle_fee: true,
                     get_supported_tokens: true,
+                    get_payer_signer: true,
                     sign_transaction: true,
                     sign_and_send_transaction: true,
                     transfer_transaction: true,
                     get_blockhash: true,
                     get_config: true,
+                    get_version: true,
+                    sign_and_send_bundle: true,
+                    sign_bundle: true,
                 },
             };
             await testSuccessfulRpcMethod('getConfig', () => client.getConfig(), mockConfig);
@@ -154,6 +165,14 @@ describe('KoraClient Unit Tests', () => {
             await testSuccessfulRpcMethod('getBlockhash', () => client.getBlockhash(), mockResponse);
         });
     });
+    describe('getVersion', () => {
+        it('should return server version', async () => {
+            const mockResponse = {
+                version: '2.1.0-beta.0',
+            };
+            await testSuccessfulRpcMethod('getVersion', () => client.getVersion(), mockResponse);
+        });
+    });
     describe('getSupportedTokens', () => {
         it('should return supported tokens list', async () => {
             const mockResponse = {
@@ -219,48 +238,49 @@ describe('KoraClient Unit Tests', () => {
             await testSuccessfulRpcMethod('signAndSendTransaction', () => client.signAndSendTransaction(request), mockResponse, request);
         });
     });
-    describe('transferTransaction', () => {
-        it('should create transfer transaction', async () => {
+    describe('signBundle', () => {
+        it('should sign bundle of transactions', async () => {
             const request = {
-                amount: 1000000,
-                token: 'SOL',
-                source: 'source_address',
-                destination: 'destination_address',
+                transactions: ['base64_tx_1', 'base64_tx_2'],
             };
             const mockResponse = {
-                transaction: 'base64_encoded_transaction',
-                message: 'Transfer transaction created',
-                blockhash: 'test_blockhash',
+                signed_transactions: ['base64_signed_tx_1', 'base64_signed_tx_2'],
                 signer_pubkey: 'test_signer_pubkey',
-                instructions: [],
             };
-            await testSuccessfulRpcMethod('transferTransaction', () => client.transferTransaction(request), mockResponse, request);
+            await testSuccessfulRpcMethod('signBundle', () => client.signBundle(request), mockResponse, request);
         });
-        it('should parse instructions from transfer transaction message', async () => {
+        it('should handle RPC error', async () => {
             const request = {
-                amount: 1000000,
-                token: 'SOL',
-                source: 'source_address',
-                destination: 'destination_address',
+                transactions: ['base64_tx_1'],
+            };
+            const mockError = { code: -32000, message: 'Bundle validation failed' };
+            mockErrorResponse(mockError);
+            await expect(client.signBundle(request)).rejects.toThrow('RPC Error -32000: Bundle validation failed');
+        });
+    });
+    describe('signAndSendBundle', () => {
+        it('should sign and send bundle of transactions', async () => {
+            const request = {
+                transactions: ['base64_tx_1', 'base64_tx_2'],
             };
-            // This is a real base64 encoded message for testing
-            // In production, this would come from the RPC response
-            const mockMessage = 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAQABAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDAAEMAgAAAAEAAAAAAAAA';
             const mockResponse = {
-                transaction: 'base64_encoded_transaction',
-                message: mockMessage,
-                blockhash: 'test_blockhash',
+                signed_transactions: ['base64_signed_tx_1', 'base64_signed_tx_2'],
                 signer_pubkey: 'test_signer_pubkey',
-                instructions: [],
+                bundle_uuid: 'test-bundle-uuid-123',
             };
-            mockSuccessfulResponse(mockResponse);
-            const result = await client.transferTransaction(request);
-            expect(result.instructions).toBeDefined();
-            expect(Array.isArray(result.instructions)).toBe(true);
-            // The instructions array should be populated from the parsed message
-            expect(result.instructions).not.toBeNull();
-        });
-        it('should handle transfer transaction with empty message gracefully', async () => {
+            await testSuccessfulRpcMethod('signAndSendBundle', () => client.signAndSendBundle(request), mockResponse, request);
+        });
+        it('should handle RPC error', async () => {
+            const request = {
+                transactions: ['base64_tx_1'],
+            };
+            const mockError = { code: -32000, message: 'Jito submission failed' };
+            mockErrorResponse(mockError);
+            await expect(client.signAndSendBundle(request)).rejects.toThrow('RPC Error -32000: Jito submission failed');
+        });
+    });
+    describe('transferTransaction (DEPRECATED)', () => {
+        it('should create transfer transaction', async () => {
             const request = {
                 amount: 1000000,
                 token: 'SOL',
@@ -269,15 +289,12 @@ describe('KoraClient Unit Tests', () => {
             };
             const mockResponse = {
                 transaction: 'base64_encoded_transaction',
-                message: '',
+                message: 'Transfer transaction created',
                 blockhash: 'test_blockhash',
                 signer_pubkey: 'test_signer_pubkey',
                 instructions: [],
             };
-            mockSuccessfulResponse(mockResponse);
-            const result = await client.transferTransaction(request);
-            // Should handle empty message gracefully
-            expect(result.instructions).toEqual([]);
+            await testSuccessfulRpcMethod('transferTransaction', () => client.transferTransaction(request), mockResponse, request);
         });
     });
     describe('getPaymentInstruction', () => {
@@ -312,6 +329,9 @@ describe('KoraClient Unit Tests', () => {
                         allow_revoke: true,
                         allow_set_authority: true,
                         allow_mint_to: true,
+                        allow_initialize_mint: true,
+                        allow_initialize_account: true,
+                        allow_initialize_multisig: true,
                         allow_freeze_account: true,
                         allow_thaw_account: true,
                     },
@@ -323,6 +343,9 @@ describe('KoraClient Unit Tests', () => {
                         allow_revoke: true,
                         allow_set_authority: true,
                         allow_mint_to: true,
+                        allow_initialize_mint: true,
+                        allow_initialize_account: true,
+                        allow_initialize_multisig: true,
                         allow_freeze_account: true,
                         allow_thaw_account: true,
                     },
@@ -339,12 +362,17 @@ describe('KoraClient Unit Tests', () => {
             enabled_methods: {
                 liveness: true,
                 estimate_transaction_fee: true,
+                estimate_bundle_fee: true,
                 get_supported_tokens: true,
+                get_payer_signer: true,
                 sign_transaction: true,
                 sign_and_send_transaction: true,
                 transfer_transaction: true,
                 get_blockhash: true,
                 get_config: true,
+                get_version: true,
+                sign_and_send_bundle: true,
+                sign_bundle: true,
             },
         };
         const mockFeeEstimate = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/kora",
-  "version": "0.2.0-beta.0",
+  "version": "0.2.0-beta.2",
   "description": "TypeScript SDK for Kora RPC",
   "main": "dist/src/index.js",
   "type": "module",