@solana/kora 0.2.0-beta.1 → 0.2.0-beta.3

package/dist/src/client.d.ts

@@ -1,4 +1,4 @@
-import { Config, EstimateTransactionFeeRequest, EstimateTransactionFeeResponse, GetBlockhashResponse, GetSupportedTokensResponse, GetVersionResponse, SignAndSendTransactionRequest, SignAndSendTransactionResponse, SignTransactionRequest, SignTransactionResponse, SignBundleRequest, SignBundleResponse, SignAndSendBundleRequest, SignAndSendBundleResponse, TransferTransactionRequest, TransferTransactionResponse, KoraClientOptions, GetPayerSignerResponse, GetPaymentInstructionRequest, GetPaymentInstructionResponse } from './types/index.js';
+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';
 /**
  * Kora RPC client for interacting with the Kora paymaster service.
  *
@@ -111,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
@@ -150,6 +169,7 @@ export declare class KoraClient {
      * @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
      *
@@ -169,6 +189,7 @@ export declare class KoraClient {
      * @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
      *
@@ -182,32 +203,6 @@ export declare class KoraClient {
      * ```
      */
     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
-     * @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
-     * ```typescript
-     * const transfer = await client.transferTransaction({
-     *   amount: 1000000, // 1 USDC (6 decimals)
-     *   token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-     *   source: 'sourceWalletPublicKey',
-     *   destination: 'destinationWalletPublicKey',
-     * });
-     * console.log('Signer:', transfer.signer_pubkey);
-     * ```
-     */
-    transferTransaction(request: TransferTransactionRequest): Promise<TransferTransactionResponse>;
     /**
      * Creates a payment instruction to append to a transaction for fee payment to the Kora paymaster.
      *

package/dist/src/client.js

@@ -1,7 +1,6 @@
 import { assertIsAddress, createNoopSigner } from '@solana/kit';
+import { findAssociatedTokenPda, getTransferInstruction, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
 import crypto from 'crypto';
-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.
  *
@@ -52,7 +51,7 @@ export class KoraClient {
         }
         if (this.hmacSecret) {
             const timestamp = Math.floor(Date.now() / 1000).toString();
-            const signature = this.getHmacSignature({ timestamp, body });
+            const signature = this.getHmacSignature({ body, timestamp });
             headers['x-timestamp'] = timestamp;
             headers['x-hmac-signature'] = signature;
         }
@@ -60,16 +59,16 @@ export class KoraClient {
     }
     async rpcRequest(method, params) {
         const body = JSON.stringify({
-            jsonrpc: '2.0',
             id: 1,
+            jsonrpc: '2.0',
             method,
             params,
         });
         const headers = this.getHeaders({ body });
         const response = await fetch(this.rpcUrl, {
-            method: 'POST',
-            headers: { ...headers, 'Content-Type': 'application/json' },
             body,
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            method: 'POST',
         });
         const json = (await response.json());
         if (json.error) {
@@ -91,7 +90,7 @@ export class KoraClient {
      * ```
      */
     async getConfig() {
-        return this.rpcRequest('getConfig', undefined);
+        return await this.rpcRequest('getConfig', undefined);
     }
     /**
      * Retrieves the payer signer and payment destination from the Kora server.
@@ -101,7 +100,7 @@ export class KoraClient {
      * @example
      */
     async getPayerSigner() {
-        return this.rpcRequest('getPayerSigner', undefined);
+        return await this.rpcRequest('getPayerSigner', undefined);
     }
     /**
      * Gets the latest blockhash from the Solana RPC that the Kora server is connected to.
@@ -115,7 +114,7 @@ export class KoraClient {
      * ```
      */
     async getBlockhash() {
-        return this.rpcRequest('getBlockhash', undefined);
+        return await this.rpcRequest('getBlockhash', undefined);
     }
     /**
      * Gets the version of the Kora server.
@@ -129,7 +128,7 @@ export class KoraClient {
      * ```
      */
     async getVersion() {
-        return this.rpcRequest('getVersion', undefined);
+        return await this.rpcRequest('getVersion', undefined);
     }
     /**
      * Retrieves the list of tokens supported for fee payment.
@@ -144,7 +143,7 @@ export class KoraClient {
      * ```
      */
     async getSupportedTokens() {
-        return this.rpcRequest('getSupportedTokens', undefined);
+        return await this.rpcRequest('getSupportedTokens', undefined);
     }
     /**
      * Estimates the transaction fee in both lamports and the specified token.
@@ -165,7 +164,28 @@ export class KoraClient {
      * ```
      */
     async estimateTransactionFee(request) {
-        return this.rpcRequest('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.
@@ -184,7 +204,7 @@ export class KoraClient {
      * ```
      */
     async signTransaction(request) {
-        return this.rpcRequest('signTransaction', request);
+        return await this.rpcRequest('signTransaction', request);
     }
     /**
      * Signs a transaction and immediately broadcasts it to the Solana network.
@@ -202,7 +222,7 @@ export class KoraClient {
      * ```
      */
     async signAndSendTransaction(request) {
-        return this.rpcRequest('signAndSendTransaction', request);
+        return await this.rpcRequest('signAndSendTransaction', request);
     }
     /**
      * Signs a bundle of transactions with the Kora fee payer without broadcasting.
@@ -210,6 +230,7 @@ export class KoraClient {
      * @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
      *
@@ -223,7 +244,7 @@ export class KoraClient {
      * ```
      */
     async signBundle(request) {
-        return this.rpcRequest('signBundle', request);
+        return await this.rpcRequest('signBundle', request);
     }
     /**
      * Signs a bundle of transactions and sends them to Jito block engine.
@@ -231,6 +252,7 @@ export class KoraClient {
      * @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
      *
@@ -244,39 +266,7 @@ export class KoraClient {
      * ```
      */
     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
-     * @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
-     * ```typescript
-     * const transfer = await client.transferTransaction({
-     *   amount: 1000000, // 1 USDC (6 decimals)
-     *   token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-     *   source: 'sourceWalletPublicKey',
-     *   destination: 'destinationWalletPublicKey',
-     * });
-     * console.log('Signer:', transfer.signer_pubkey);
-     * ```
-     */
-    async transferTransaction(request) {
-        const response = await this.rpcRequest('transferTransaction', request);
-        // Parse instructions from the message to enhance developer experience
-        // Always set instructions, even for empty messages (for consistency)
-        response.instructions = getInstructionsFromBase64Message(response.message || '');
-        return response;
+        return await this.rpcRequest('signAndSendBundle', request);
     }
     /**
      * Creates a payment instruction to append to a transaction for fee payment to the Kora paymaster.
@@ -310,34 +300,37 @@ export class KoraClient {
         assertIsAddress(fee_token);
         assertIsAddress(token_program_id);
         const { fee_in_token, payment_address, signer_pubkey } = await this.estimateTransactionFee({
-            transaction,
             fee_token,
             sig_verify,
             signer_key,
+            transaction,
         });
         assertIsAddress(payment_address);
         const [sourceTokenAccount] = await findAssociatedTokenPda({
+            mint: fee_token,
             owner: source_wallet,
             tokenProgram: token_program_id,
-            mint: fee_token,
         });
         const [destinationTokenAccount] = await findAssociatedTokenPda({
+            mint: fee_token,
             owner: payment_address,
             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,
-            authority: createNoopSigner(source_wallet),
             amount: fee_in_token,
+            authority: createNoopSigner(source_wallet),
+            destination: destinationTokenAccount,
+            source: sourceTokenAccount,
         });
         return {
             original_transaction: transaction,
-            payment_instruction: paymentInstruction,
+            payment_address,
             payment_amount: fee_in_token,
+            payment_instruction: paymentInstruction,
             payment_token: fee_token,
-            payment_address,
             signer_address: signer_pubkey,
         };
     }

package/dist/src/index.d.ts

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

package/dist/src/index.js

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

package/dist/src/plugin.d.ts

@@ -0,0 +1,85 @@
+import type { EstimateBundleFeeRequest, EstimateTransactionFeeRequest, GetPaymentInstructionRequest, GetVersionResponse, KitBlockhashResponse, KitConfigResponse, KitEstimateBundleFeeResponse, KitEstimateFeeResponse, KitPayerSignerResponse, KitPaymentInstructionResponse, KitSignAndSendBundleResponse, KitSignAndSendTransactionResponse, KitSignBundleResponse, KitSignTransactionResponse, KitSupportedTokensResponse, KoraPluginConfig, SignAndSendBundleRequest, SignAndSendTransactionRequest, SignBundleRequest, SignTransactionRequest } from './types/index.js';
+/**
+ * Creates a Kora Kit plugin that adds Kora paymaster functionality to a Kit client.
+ *
+ * The plugin exposes all Kora RPC methods with Kit-typed responses (Address, Blockhash).
+ *
+ * **Note:** The plugin pattern with `createEmptyClient().use()` requires `@solana/kit` v5.4.0+.
+ * For older kit versions, use `KoraClient` directly instead.
+ *
+ * @param config - Plugin configuration
+ * @param config.endpoint - Kora RPC endpoint URL
+ * @param config.apiKey - Optional API key for authentication
+ * @param config.hmacSecret - Optional HMAC secret for signature-based authentication
+ * @returns A Kit plugin function that adds `.kora` to the client
+ *
+ * @example
+ * ```typescript
+ * import { createEmptyClient } from '@solana/kit';
+ * import { koraPlugin } from '@solana/kora';
+ *
+ * const client = createEmptyClient()
+ *   .use(koraPlugin({ endpoint: 'https://kora.example.com' }));
+ *
+ * // All responses have Kit-typed fields
+ * const config = await client.kora.getConfig();
+ * // config.fee_payers is Address[] not string[]
+ *
+ * const { signer_pubkey } = await client.kora.signTransaction({ transaction: tx });
+ * // signer_pubkey is Address not string
+ * ```
+ */
+export declare function koraPlugin(config: KoraPluginConfig): <T extends object>(c: T) => T & {
+    kora: {
+        /**
+         * Estimates the bundle fee with Kit-typed addresses.
+         */
+        estimateBundleFee(request: EstimateBundleFeeRequest): Promise<KitEstimateBundleFeeResponse>;
+        /**
+         * Estimates the transaction fee with Kit-typed addresses.
+         */
+        estimateTransactionFee(request: EstimateTransactionFeeRequest): Promise<KitEstimateFeeResponse>;
+        /**
+         * Gets the latest blockhash with Kit Blockhash type.
+         */
+        getBlockhash(): Promise<KitBlockhashResponse>;
+        /**
+         * Retrieves the current Kora server configuration with Kit-typed addresses.
+         */
+        getConfig(): Promise<KitConfigResponse>;
+        /**
+         * Retrieves the payer signer and payment destination with Kit-typed addresses.
+         */
+        getPayerSigner(): Promise<KitPayerSignerResponse>;
+        /**
+         * Creates a payment instruction with Kit-typed response.
+         */
+        getPaymentInstruction(request: GetPaymentInstructionRequest): Promise<KitPaymentInstructionResponse>;
+        /**
+         * Retrieves the list of tokens supported for fee payment with Kit-typed addresses.
+         */
+        getSupportedTokens(): Promise<KitSupportedTokensResponse>;
+        /**
+         * Gets the version of the Kora server.
+         */
+        getVersion(): Promise<GetVersionResponse>;
+        /**
+         * Signs and sends a bundle of transactions via Jito with Kit-typed response.
+         */
+        signAndSendBundle(request: SignAndSendBundleRequest): Promise<KitSignAndSendBundleResponse>;
+        /**
+         * Signs and sends a transaction with Kit-typed response.
+         */
+        signAndSendTransaction(request: SignAndSendTransactionRequest): Promise<KitSignAndSendTransactionResponse>;
+        /**
+         * Signs a bundle of transactions with Kit-typed response.
+         */
+        signBundle(request: SignBundleRequest): Promise<KitSignBundleResponse>;
+        /**
+         * Signs a transaction with Kit-typed response.
+         */
+        signTransaction(request: SignTransactionRequest): Promise<KitSignTransactionResponse>;
+    };
+};
+/** Type representing the Kora API exposed by the plugin */
+export type KoraApi = ReturnType<ReturnType<typeof koraPlugin>>['kora'];

package/dist/src/plugin.js

@@ -0,0 +1,175 @@
+import { address, blockhash, signature } from '@solana/kit';
+import { KoraClient } from './client.js';
+/**
+ * Creates a Kora Kit plugin that adds Kora paymaster functionality to a Kit client.
+ *
+ * The plugin exposes all Kora RPC methods with Kit-typed responses (Address, Blockhash).
+ *
+ * **Note:** The plugin pattern with `createEmptyClient().use()` requires `@solana/kit` v5.4.0+.
+ * For older kit versions, use `KoraClient` directly instead.
+ *
+ * @param config - Plugin configuration
+ * @param config.endpoint - Kora RPC endpoint URL
+ * @param config.apiKey - Optional API key for authentication
+ * @param config.hmacSecret - Optional HMAC secret for signature-based authentication
+ * @returns A Kit plugin function that adds `.kora` to the client
+ *
+ * @example
+ * ```typescript
+ * import { createEmptyClient } from '@solana/kit';
+ * import { koraPlugin } from '@solana/kora';
+ *
+ * const client = createEmptyClient()
+ *   .use(koraPlugin({ endpoint: 'https://kora.example.com' }));
+ *
+ * // All responses have Kit-typed fields
+ * const config = await client.kora.getConfig();
+ * // config.fee_payers is Address[] not string[]
+ *
+ * const { signer_pubkey } = await client.kora.signTransaction({ transaction: tx });
+ * // signer_pubkey is Address not string
+ * ```
+ */
+export function koraPlugin(config) {
+    const client = new KoraClient({
+        apiKey: config.apiKey,
+        hmacSecret: config.hmacSecret,
+        rpcUrl: config.endpoint,
+    });
+    return (c) => ({
+        ...c,
+        kora: {
+            /**
+             * Estimates the bundle fee with Kit-typed addresses.
+             */
+            async estimateBundleFee(request) {
+                const result = await client.estimateBundleFee(request);
+                return {
+                    fee_in_lamports: result.fee_in_lamports,
+                    fee_in_token: result.fee_in_token,
+                    payment_address: address(result.payment_address),
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Estimates the transaction fee with Kit-typed addresses.
+             */
+            async estimateTransactionFee(request) {
+                const result = await client.estimateTransactionFee(request);
+                return {
+                    fee_in_lamports: result.fee_in_lamports,
+                    fee_in_token: result.fee_in_token,
+                    payment_address: address(result.payment_address),
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Gets the latest blockhash with Kit Blockhash type.
+             */
+            async getBlockhash() {
+                const result = await client.getBlockhash();
+                return {
+                    blockhash: blockhash(result.blockhash),
+                };
+            },
+            /**
+             * Retrieves the current Kora server configuration with Kit-typed addresses.
+             */
+            async getConfig() {
+                const result = await client.getConfig();
+                return {
+                    enabled_methods: result.enabled_methods,
+                    fee_payers: result.fee_payers.map(addr => address(addr)),
+                    validation_config: {
+                        ...result.validation_config,
+                        allowed_programs: result.validation_config.allowed_programs.map(addr => address(addr)),
+                        allowed_spl_paid_tokens: result.validation_config.allowed_spl_paid_tokens.map(addr => address(addr)),
+                        allowed_tokens: result.validation_config.allowed_tokens.map(addr => address(addr)),
+                        disallowed_accounts: result.validation_config.disallowed_accounts.map(addr => address(addr)),
+                    },
+                };
+            },
+            /**
+             * Retrieves the payer signer and payment destination with Kit-typed addresses.
+             */
+            async getPayerSigner() {
+                const result = await client.getPayerSigner();
+                return {
+                    payment_address: address(result.payment_address),
+                    signer_address: address(result.signer_address),
+                };
+            },
+            /**
+             * Creates a payment instruction with Kit-typed response.
+             */
+            async getPaymentInstruction(request) {
+                const result = await client.getPaymentInstruction(request);
+                return {
+                    original_transaction: result.original_transaction,
+                    payment_address: address(result.payment_address),
+                    payment_amount: result.payment_amount,
+                    payment_instruction: result.payment_instruction,
+                    payment_token: address(result.payment_token),
+                    signer_address: address(result.signer_address),
+                };
+            },
+            /**
+             * Retrieves the list of tokens supported for fee payment with Kit-typed addresses.
+             */
+            async getSupportedTokens() {
+                const result = await client.getSupportedTokens();
+                return {
+                    tokens: result.tokens.map(addr => address(addr)),
+                };
+            },
+            /**
+             * Gets the version of the Kora server.
+             */
+            async getVersion() {
+                return await client.getVersion();
+            },
+            /**
+             * Signs and sends a bundle of transactions via Jito with Kit-typed response.
+             */
+            async signAndSendBundle(request) {
+                const result = await client.signAndSendBundle(request);
+                return {
+                    bundle_uuid: result.bundle_uuid,
+                    signed_transactions: result.signed_transactions,
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Signs and sends a transaction with Kit-typed response.
+             */
+            async signAndSendTransaction(request) {
+                const result = await client.signAndSendTransaction(request);
+                return {
+                    signature: signature(result.signature),
+                    signed_transaction: result.signed_transaction,
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Signs a bundle of transactions with Kit-typed response.
+             */
+            async signBundle(request) {
+                const result = await client.signBundle(request);
+                return {
+                    signed_transactions: result.signed_transactions,
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Signs a transaction with Kit-typed response.
+             */
+            async signTransaction(request) {
+                const result = await client.signTransaction(request);
+                return {
+                    signed_transaction: result.signed_transaction,
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+        },
+    });
+}