@solana/kora 0.1.0 → 0.1.2

package/README.md

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

package/dist/src/client.js

@@ -1,4 +1,3 @@
-// TODO Make sure to change necessary deps from devdeps to deps
 import { assertIsAddress, createNoopSigner } from '@solana/kit';
 import crypto from 'crypto';
 import { getInstructionsFromBase64Message } from './utils/transaction.js';

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,73 @@
+import type { KoraPluginConfig, KitPayerSignerResponse, KitBlockhashResponse, KitSupportedTokensResponse, KitEstimateFeeResponse, KitSignTransactionResponse, KitSignAndSendTransactionResponse, KitTransferTransactionResponse, KitPaymentInstructionResponse, KitConfigResponse, EstimateTransactionFeeRequest, SignTransactionRequest, SignAndSendTransactionRequest, TransferTransactionRequest, GetPaymentInstructionRequest } 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: {
+        /**
+         * 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>;
+        /**
+         * Gets the latest blockhash with Kit Blockhash type.
+         */
+        getBlockhash(): Promise<KitBlockhashResponse>;
+        /**
+         * Retrieves the list of tokens supported for fee payment with Kit-typed addresses.
+         */
+        getSupportedTokens(): Promise<KitSupportedTokensResponse>;
+        /**
+         * Estimates the transaction fee with Kit-typed addresses.
+         */
+        estimateTransactionFee(request: EstimateTransactionFeeRequest): Promise<KitEstimateFeeResponse>;
+        /**
+         * Signs a transaction with Kit-typed response.
+         */
+        signTransaction(request: SignTransactionRequest): Promise<KitSignTransactionResponse>;
+        /**
+         * Signs and sends a transaction with Kit-typed response.
+         */
+        signAndSendTransaction(request: SignAndSendTransactionRequest): Promise<KitSignAndSendTransactionResponse>;
+        /**
+         * Creates a token transfer transaction with Kit-typed response.
+         */
+        transferTransaction(request: TransferTransactionRequest): Promise<KitTransferTransactionResponse>;
+        /**
+         * Creates a payment instruction with Kit-typed response.
+         */
+        getPaymentInstruction(request: GetPaymentInstructionRequest): Promise<KitPaymentInstructionResponse>;
+    };
+};
+/** 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,148 @@
+import { address, blockhash } 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({
+        rpcUrl: config.endpoint,
+        apiKey: config.apiKey,
+        hmacSecret: config.hmacSecret,
+    });
+    return (c) => ({
+        ...c,
+        kora: {
+            /**
+             * Retrieves the current Kora server configuration with Kit-typed addresses.
+             */
+            async getConfig() {
+                const result = await client.getConfig();
+                return {
+                    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_tokens: result.validation_config.allowed_tokens.map(addr => address(addr)),
+                        allowed_spl_paid_tokens: result.validation_config.allowed_spl_paid_tokens.map(addr => address(addr)),
+                        disallowed_accounts: result.validation_config.disallowed_accounts.map(addr => address(addr)),
+                    },
+                    enabled_methods: result.enabled_methods,
+                };
+            },
+            /**
+             * Retrieves the payer signer and payment destination with Kit-typed addresses.
+             */
+            async getPayerSigner() {
+                const result = await client.getPayerSigner();
+                return {
+                    signer_address: address(result.signer_address),
+                    payment_address: address(result.payment_address),
+                };
+            },
+            /**
+             * Gets the latest blockhash with Kit Blockhash type.
+             */
+            async getBlockhash() {
+                const result = await client.getBlockhash();
+                return {
+                    blockhash: blockhash(result.blockhash),
+                };
+            },
+            /**
+             * 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)),
+                };
+            },
+            /**
+             * 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,
+                    signer_pubkey: address(result.signer_pubkey),
+                    payment_address: address(result.payment_address),
+                };
+            },
+            /**
+             * 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),
+                };
+            },
+            /**
+             * Signs and sends a transaction with Kit-typed response.
+             */
+            async signAndSendTransaction(request) {
+                const result = await client.signAndSendTransaction(request);
+                return {
+                    signed_transaction: result.signed_transaction,
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Creates a token transfer transaction with Kit-typed response.
+             */
+            async transferTransaction(request) {
+                const result = await client.transferTransaction(request);
+                return {
+                    transaction: result.transaction,
+                    message: result.message,
+                    blockhash: blockhash(result.blockhash),
+                    signer_pubkey: address(result.signer_pubkey),
+                    instructions: result.instructions,
+                };
+            },
+            /**
+             * Creates a payment instruction with Kit-typed response.
+             */
+            async getPaymentInstruction(request) {
+                const result = await client.getPaymentInstruction(request);
+                return {
+                    original_transaction: result.original_transaction,
+                    payment_instruction: result.payment_instruction,
+                    payment_amount: result.payment_amount,
+                    payment_token: address(result.payment_token),
+                    payment_address: address(result.payment_address),
+                    signer_address: address(result.signer_address),
+                };
+            },
+        },
+    });
+}

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

@@ -381,3 +381,118 @@ export interface KoraClientOptions {
     /** Optional HMAC secret for signature-based authentication */
     hmacSecret?: string;
 }
+/**
+ * Plugin Types - Kit-typed responses for the Kora plugin
+ */
+import type { Address, Blockhash, Instruction as KitInstruction, Base64EncodedWireTransaction } from '@solana/kit';
+/** Configuration options for the Kora Kit plugin */
+export interface KoraPluginConfig {
+    /** Kora RPC endpoint URL */
+    endpoint: string;
+    /** Optional API key for authentication */
+    apiKey?: string;
+    /** Optional HMAC secret for signature-based authentication */
+    hmacSecret?: string;
+}
+/** Plugin response for getPayerSigner with Kit Address types */
+export interface KitPayerSignerResponse {
+    /** Public key of the payer signer */
+    signer_address: Address;
+    /** Public key of the payment destination */
+    payment_address: Address;
+}
+/** Plugin response for getBlockhash with Kit Blockhash type */
+export interface KitBlockhashResponse {
+    /** Base58-encoded blockhash */
+    blockhash: Blockhash;
+}
+/** Plugin response for getSupportedTokens with Kit Address types */
+export interface KitSupportedTokensResponse {
+    /** Array of supported token mint addresses */
+    tokens: Address[];
+}
+/** Plugin response for estimateTransactionFee with Kit Address types */
+export interface KitEstimateFeeResponse {
+    /** Transaction fee in lamports */
+    fee_in_lamports: number;
+    /** Transaction fee in the requested token */
+    fee_in_token: number;
+    /** Public key of the signer used to estimate the fee */
+    signer_pubkey: Address;
+    /** Public key of the payment destination */
+    payment_address: Address;
+}
+/** Plugin response for signTransaction with Kit types */
+export interface KitSignTransactionResponse {
+    /** Base64-encoded signed transaction */
+    signed_transaction: Base64EncodedWireTransaction;
+    /** Public key of the signer used to sign the transaction */
+    signer_pubkey: Address;
+}
+/** Plugin response for signAndSendTransaction with Kit types */
+export interface KitSignAndSendTransactionResponse {
+    /** Base64-encoded signed transaction */
+    signed_transaction: Base64EncodedWireTransaction;
+    /** Public key of the signer used to send the transaction */
+    signer_pubkey: Address;
+}
+/** Plugin response for transferTransaction with Kit types */
+export interface KitTransferTransactionResponse {
+    /** Base64-encoded signed transaction */
+    transaction: Base64EncodedWireTransaction;
+    /** Base64-encoded message */
+    message: string;
+    /** Recent blockhash used in the transaction */
+    blockhash: Blockhash;
+    /** Public key of the signer used to send the transaction */
+    signer_pubkey: Address;
+    /** Parsed instructions from the transaction message */
+    instructions: KitInstruction[];
+}
+/** Plugin response for getPaymentInstruction with Kit types */
+export interface KitPaymentInstructionResponse {
+    /** Base64-encoded original transaction */
+    original_transaction: Base64EncodedWireTransaction;
+    /** Payment instruction */
+    payment_instruction: KitInstruction;
+    /** Payment amount in the requested token */
+    payment_amount: number;
+    /** Mint address of the token used for payment */
+    payment_token: Address;
+    /** Public key of the payment destination */
+    payment_address: Address;
+    /** Public key of the payer signer */
+    signer_address: Address;
+}
+/** Plugin response for getConfig with Kit Address types */
+export interface KitConfigResponse {
+    /** Array of public keys of the fee payer accounts (signer pool) */
+    fee_payers: Address[];
+    /** Validation rules and constraints */
+    validation_config: KitValidationConfig;
+    /** Enabled methods */
+    enabled_methods: EnabledMethods;
+}
+/** Plugin validation config with Kit Address types */
+export interface KitValidationConfig {
+    /** Maximum allowed transaction value in lamports */
+    max_allowed_lamports: number;
+    /** Maximum number of signatures allowed per transaction */
+    max_signatures: number;
+    /** Price oracle source for token conversions */
+    price_source: PriceSource;
+    /** List of allowed Solana program IDs */
+    allowed_programs: Address[];
+    /** List of allowed token mint addresses for fee payment */
+    allowed_tokens: Address[];
+    /** List of SPL tokens accepted for paid transactions */
+    allowed_spl_paid_tokens: Address[];
+    /** List of blocked account addresses */
+    disallowed_accounts: Address[];
+    /** Policy controlling fee payer permissions */
+    fee_payer_policy: FeePayerPolicy;
+    /** Pricing model configuration */
+    price: PriceConfig;
+    /** Token2022 configuration */
+    token2022: Token2022Config;
+}

package/dist/test/plugin.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/plugin.test.js

@@ -0,0 +1,386 @@
+import { createEmptyClient } from '@solana/kit';
+import { koraPlugin } from '../src/plugin.js';
+// Mock fetch globally
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+describe('Kora Kit Plugin', () => {
+    const mockEndpoint = 'http://localhost:8080';
+    const mockConfig = {
+        endpoint: mockEndpoint,
+    };
+    // Helper to mock successful RPC response
+    const mockSuccessfulResponse = (result) => {
+        mockFetch.mockResolvedValueOnce({
+            json: jest.fn().mockResolvedValueOnce({
+                jsonrpc: '2.0',
+                id: 1,
+                result,
+            }),
+        });
+    };
+    // Helper to mock error response
+    const mockErrorResponse = (error) => {
+        mockFetch.mockResolvedValueOnce({
+            json: jest.fn().mockResolvedValueOnce({
+                jsonrpc: '2.0',
+                id: 1,
+                error,
+            }),
+        });
+    };
+    beforeEach(() => {
+        mockFetch.mockClear();
+    });
+    describe('Plugin Composition', () => {
+        it('should add kora property to client', () => {
+            const baseClient = { existing: 'property' };
+            const plugin = koraPlugin(mockConfig);
+            const enhanced = plugin(baseClient);
+            expect(enhanced.existing).toBe('property');
+            expect(enhanced.kora).toBeDefined();
+            expect(typeof enhanced.kora.getConfig).toBe('function');
+            expect(typeof enhanced.kora.getPayerSigner).toBe('function');
+            expect(typeof enhanced.kora.getBlockhash).toBe('function');
+            expect(typeof enhanced.kora.getSupportedTokens).toBe('function');
+            expect(typeof enhanced.kora.estimateTransactionFee).toBe('function');
+            expect(typeof enhanced.kora.signTransaction).toBe('function');
+            expect(typeof enhanced.kora.signAndSendTransaction).toBe('function');
+            expect(typeof enhanced.kora.transferTransaction).toBe('function');
+            expect(typeof enhanced.kora.getPaymentInstruction).toBe('function');
+        });
+        it('should work with empty client object', () => {
+            const plugin = koraPlugin(mockConfig);
+            const enhanced = plugin({});
+            expect(enhanced.kora).toBeDefined();
+        });
+        it('should support authentication options', () => {
+            const authConfig = {
+                endpoint: mockEndpoint,
+                apiKey: 'test-api-key',
+                hmacSecret: 'test-hmac-secret',
+            };
+            const plugin = koraPlugin(authConfig);
+            const enhanced = plugin({});
+            expect(enhanced.kora).toBeDefined();
+        });
+    });
+    describe('Type Casting', () => {
+        let kora;
+        beforeEach(() => {
+            const plugin = koraPlugin(mockConfig);
+            const client = plugin({});
+            kora = client.kora;
+        });
+        describe('getConfig', () => {
+            it('should return Kit-typed Address arrays', async () => {
+                const rawResponse = {
+                    fee_payers: ['DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7'],
+                    validation_config: {
+                        max_allowed_lamports: 1000000,
+                        max_signatures: 10,
+                        price_source: 'Jupiter',
+                        allowed_programs: ['11111111111111111111111111111111'],
+                        allowed_tokens: ['EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'],
+                        allowed_spl_paid_tokens: ['EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'],
+                        disallowed_accounts: [],
+                        fee_payer_policy: {
+                            system: {
+                                allow_transfer: true,
+                                allow_assign: true,
+                                allow_create_account: true,
+                                allow_allocate: true,
+                                nonce: {
+                                    allow_initialize: true,
+                                    allow_advance: true,
+                                    allow_authorize: true,
+                                    allow_withdraw: true,
+                                },
+                            },
+                            spl_token: {
+                                allow_transfer: true,
+                                allow_burn: true,
+                                allow_close_account: true,
+                                allow_approve: true,
+                                allow_revoke: true,
+                                allow_set_authority: true,
+                                allow_mint_to: true,
+                                allow_freeze_account: true,
+                                allow_thaw_account: true,
+                            },
+                            token_2022: {
+                                allow_transfer: true,
+                                allow_burn: true,
+                                allow_close_account: true,
+                                allow_approve: true,
+                                allow_revoke: true,
+                                allow_set_authority: true,
+                                allow_mint_to: true,
+                                allow_freeze_account: true,
+                                allow_thaw_account: true,
+                            },
+                        },
+                        price: { type: 'margin', margin: 0.1 },
+                        token2022: {
+                            blocked_mint_extensions: [],
+                            blocked_account_extensions: [],
+                        },
+                    },
+                    enabled_methods: {
+                        liveness: true,
+                        estimate_transaction_fee: true,
+                        get_supported_tokens: true,
+                        sign_transaction: true,
+                        sign_and_send_transaction: true,
+                        transfer_transaction: true,
+                        get_blockhash: true,
+                        get_config: true,
+                    },
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.getConfig();
+                // Verify type casting - these should be Address types
+                expect(result.fee_payers).toHaveLength(1);
+                expect(result.fee_payers[0]).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+                expect(result.validation_config.allowed_programs).toHaveLength(1);
+                expect(result.validation_config.allowed_programs[0]).toBe('11111111111111111111111111111111');
+                expect(result.validation_config.allowed_tokens).toHaveLength(1);
+                expect(result.validation_config.allowed_tokens[0]).toBe('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+            });
+        });
+        describe('getPayerSigner', () => {
+            it('should return Kit-typed Address fields', async () => {
+                const rawResponse = {
+                    signer_address: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                    payment_address: 'PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.getPayerSigner();
+                // Type assertion - these should be Address types
+                const signerAddr = result.signer_address;
+                const paymentAddr = result.payment_address;
+                expect(signerAddr).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+                expect(paymentAddr).toBe('PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+            });
+        });
+        describe('getBlockhash', () => {
+            it('should return Kit-typed Blockhash field', async () => {
+                const rawResponse = {
+                    blockhash: '4NxM2D4kQcipkzMWBWQME5YSVnj5kT8QKA7rvb3rKLvE',
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.getBlockhash();
+                // Type assertion - should be Blockhash type
+                const hash = result.blockhash;
+                expect(hash).toBe('4NxM2D4kQcipkzMWBWQME5YSVnj5kT8QKA7rvb3rKLvE');
+            });
+        });
+        describe('getSupportedTokens', () => {
+            it('should return Kit-typed Address array', async () => {
+                const rawResponse = {
+                    tokens: [
+                        'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+                        'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
+                    ],
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.getSupportedTokens();
+                // Type assertion - these should be Address types
+                expect(result.tokens).toHaveLength(2);
+                const token0 = result.tokens[0];
+                const token1 = result.tokens[1];
+                expect(token0).toBe('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+                expect(token1).toBe('Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB');
+            });
+        });
+        describe('estimateTransactionFee', () => {
+            it('should return Kit-typed Address fields', async () => {
+                const rawResponse = {
+                    fee_in_lamports: 5000,
+                    fee_in_token: 50,
+                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                    payment_address: 'PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.estimateTransactionFee({
+                    transaction: 'base64EncodedTransaction',
+                    fee_token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+                });
+                // Type assertions
+                const signerPubkey = result.signer_pubkey;
+                const paymentAddr = result.payment_address;
+                expect(result.fee_in_lamports).toBe(5000);
+                expect(result.fee_in_token).toBe(50);
+                expect(signerPubkey).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+                expect(paymentAddr).toBe('PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+            });
+        });
+        describe('signTransaction', () => {
+            it('should return Kit-typed response with Base64EncodedWireTransaction', async () => {
+                const rawResponse = {
+                    signed_transaction: 'base64SignedTransaction',
+                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.signTransaction({
+                    transaction: 'base64EncodedTransaction',
+                });
+                // Type assertions - verify Kit types
+                const signedTx = result.signed_transaction;
+                const signerPubkey = result.signer_pubkey;
+                expect(signedTx).toBe('base64SignedTransaction');
+                expect(signerPubkey).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+            });
+        });
+        describe('signAndSendTransaction', () => {
+            it('should return Kit-typed response with Base64EncodedWireTransaction', async () => {
+                const rawResponse = {
+                    signed_transaction: 'base64SignedTransaction',
+                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.signAndSendTransaction({
+                    transaction: 'base64EncodedTransaction',
+                });
+                // Type assertions - verify Kit types
+                const signedTx = result.signed_transaction;
+                const signerPubkey = result.signer_pubkey;
+                expect(signedTx).toBe('base64SignedTransaction');
+                expect(signerPubkey).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+            });
+        });
+        describe('transferTransaction', () => {
+            it('should return Kit-typed response with Base64EncodedWireTransaction and Blockhash', async () => {
+                const rawResponse = {
+                    transaction: 'base64Transaction',
+                    message: 'base64Message',
+                    blockhash: '4NxM2D4kQcipkzMWBWQME5YSVnj5kT8QKA7rvb3rKLvE',
+                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                    instructions: [],
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.transferTransaction({
+                    amount: 1000000,
+                    token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+                    source: 'sourceWallet',
+                    destination: 'destWallet',
+                });
+                // Type assertions - verify Kit types
+                const tx = result.transaction;
+                const hash = result.blockhash;
+                const signerPubkey = result.signer_pubkey;
+                expect(tx).toBe('base64Transaction');
+                expect(result.message).toBe('base64Message');
+                expect(hash).toBe('4NxM2D4kQcipkzMWBWQME5YSVnj5kT8QKA7rvb3rKLvE');
+                expect(signerPubkey).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+                expect(result.instructions).toEqual([]);
+            });
+        });
+        describe('getPaymentInstruction', () => {
+            it('should return Kit-typed response with Base64EncodedWireTransaction and Address fields', async () => {
+                const mockFeeEstimate = {
+                    fee_in_lamports: 5000,
+                    fee_in_token: 50000,
+                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                    payment_address: 'PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                };
+                const testTx = 'Aoq7ymA5OGP+gmDXiY5m3cYXlY2Rz/a/gFjOgt9ZuoCS7UzuiGGaEnW2OOtvHvMQHkkD7Z4LRF5B63ftu+1oZwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgECB1urjQEjgFgzqYhJ8IXJeSg4cJP1j1g2CJstOQTDchOKUzqH3PxgGW3c4V3vZV05A5Y30/MggOBs0Kd00s1JEwg5TaEeaV4+KL2y7fXIAuf6cN0ZQitbhY+G9ExtBSChspOXPgNcy9pYpETe4bmB+fg4bfZx1tnicA/kIyyubczAmbcIKIuniNOOQYG2ggKCz8NjEsHVezrWMatndu1wk6J5miGP26J6Vwp31AljiAajAFuP0D9mWJwSeFuA7J5rPwbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCpd/O36SW02zRtNtqk6GFeip2+yBQsVTeSbLL4rWJRkd4CBgQCBQQBCgxAQg8AAAAAAAYGBAIFAwEKDBAnAAAAAAAABg==';
+                mockSuccessfulResponse(mockFeeEstimate);
+                const result = await kora.getPaymentInstruction({
+                    transaction: testTx,
+                    fee_token: '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU',
+                    source_wallet: '11111111111111111111111111111111',
+                    token_program_id: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                });
+                // Type assertions - verify Kit types
+                const originalTx = result.original_transaction;
+                const paymentToken = result.payment_token;
+                const paymentAddr = result.payment_address;
+                const signerAddr = result.signer_address;
+                expect(originalTx).toBe(testTx);
+                expect(paymentToken).toBe('4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU');
+                expect(paymentAddr).toBe('PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+                expect(signerAddr).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+                expect(result.payment_amount).toBe(50000);
+            });
+        });
+    });
+    describe('Error Handling', () => {
+        let kora;
+        beforeEach(() => {
+            const plugin = koraPlugin(mockConfig);
+            const client = plugin({});
+            kora = client.kora;
+        });
+        it('should propagate RPC errors', async () => {
+            mockErrorResponse({ code: -32601, message: 'Method not found' });
+            await expect(kora.getConfig()).rejects.toThrow('RPC Error -32601: Method not found');
+        });
+        it('should propagate network errors', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('Network error'));
+            await expect(kora.getConfig()).rejects.toThrow('Network error');
+        });
+    });
+    describe('KoraApi Type Export', () => {
+        it('should export KoraApi type correctly', () => {
+            // This test verifies the KoraApi type is correctly exported
+            const plugin = koraPlugin(mockConfig);
+            const client = plugin({});
+            // Type check - assign to KoraApi type
+            const api = client.kora;
+            expect(api).toBeDefined();
+        });
+    });
+    describe('createEmptyClient Integration', () => {
+        it('should initialize kora property on Kit client', () => {
+            const client = createEmptyClient().use(koraPlugin(mockConfig));
+            expect(client).toHaveProperty('kora');
+            expect(client.kora).toBeDefined();
+        });
+        it('should expose all Kora RPC methods', () => {
+            const client = createEmptyClient().use(koraPlugin(mockConfig));
+            expect(typeof client.kora.getConfig).toBe('function');
+            expect(typeof client.kora.getPayerSigner).toBe('function');
+            expect(typeof client.kora.getBlockhash).toBe('function');
+            expect(typeof client.kora.getSupportedTokens).toBe('function');
+            expect(typeof client.kora.estimateTransactionFee).toBe('function');
+            expect(typeof client.kora.signTransaction).toBe('function');
+            expect(typeof client.kora.signAndSendTransaction).toBe('function');
+            expect(typeof client.kora.transferTransaction).toBe('function');
+            expect(typeof client.kora.getPaymentInstruction).toBe('function');
+        });
+        it('should work with authentication config', () => {
+            const authConfig = {
+                endpoint: mockEndpoint,
+                apiKey: 'test-api-key',
+                hmacSecret: 'test-hmac-secret',
+            };
+            const client = createEmptyClient().use(koraPlugin(authConfig));
+            expect(client.kora).toBeDefined();
+            expect(typeof client.kora.getConfig).toBe('function');
+        });
+        it('should compose with other plugins', () => {
+            // Simulate another plugin that adds a different property
+            const otherPlugin = (c) => ({
+                ...c,
+                other: { foo: () => 'bar' },
+            });
+            const client = createEmptyClient().use(koraPlugin(mockConfig)).use(otherPlugin);
+            // Both plugins should be available
+            expect(client.kora).toBeDefined();
+            expect(client.other).toBeDefined();
+            expect(typeof client.kora.getConfig).toBe('function');
+            expect(client.other.foo()).toBe('bar');
+        });
+        it('should call RPC methods correctly', async () => {
+            const mockResponse = {
+                signer_address: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                payment_address: 'PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+            };
+            mockSuccessfulResponse(mockResponse);
+            const client = createEmptyClient().use(koraPlugin(mockConfig));
+            const result = await client.kora.getPayerSigner();
+            expect(result.signer_address).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+            expect(result.payment_address).toBe('PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+        });
+    });
+});

package/dist/test/setup.js

@@ -1,6 +1,6 @@
 import { getCreateAccountInstruction } from '@solana-program/system';
 import { findAssociatedTokenPda, getCreateAssociatedTokenIdempotentInstructionAsync, getInitializeMintInstruction, getMintSize, getMintToInstruction, TOKEN_PROGRAM_ADDRESS, } from '@solana-program/token';
-import { airdropFactory, createSolanaRpc, createSolanaRpcSubscriptions, lamports, sendAndConfirmTransactionFactory, pipe, createTransactionMessage, setTransactionMessageLifetimeUsingBlockhash, setTransactionMessageFeePayerSigner, appendTransactionMessageInstructions, signTransactionMessageWithSigners, getSignatureFromTransaction, assertIsAddress, createKeyPairSignerFromBytes, getBase58Encoder, } from '@solana/kit';
+import { airdropFactory, createSolanaRpc, createSolanaRpcSubscriptions, lamports, sendAndConfirmTransactionFactory, pipe, createTransactionMessage, setTransactionMessageLifetimeUsingBlockhash, setTransactionMessageFeePayerSigner, appendTransactionMessageInstructions, signTransactionMessageWithSigners, getSignatureFromTransaction, assertIsAddress, createKeyPairSignerFromBytes, getBase58Encoder, assertIsSendableTransaction, assertIsTransactionWithBlockhashLifetime, } from '@solana/kit';
 import { updateOrAppendSetComputeUnitLimitInstruction, updateOrAppendSetComputeUnitPriceInstruction, MAX_COMPUTE_UNIT_LIMIT, } from '@solana-program/compute-budget';
 import { config } from 'dotenv';
 import path from 'path';
@@ -94,6 +94,8 @@ const createDefaultTransaction = async (client, feePayer, computeLimit = MAX_COM
 const signAndSendTransaction = async (client, transactionMessage, commitment) => {
     const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
     const signature = getSignatureFromTransaction(signedTransaction);
+    assertIsSendableTransaction(signedTransaction);
+    assertIsTransactionWithBlockhashLifetime(signedTransaction);
     await sendAndConfirmTransactionFactory(client)(signedTransaction, { commitment, skipPreflight: true });
     return signature;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/kora",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "TypeScript SDK for Kora RPC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -16,12 +16,16 @@
   ],
   "author": "",
   "license": "MIT",
+  "peerDependencies": {
+    "@solana-program/token": "^0.9.0",
+    "@solana/kit": "^5.0.0"
+  },
   "devDependencies": {
-    "@solana-program/compute-budget": "^0.8.0",
-    "@solana-program/system": "^0.7.0",
-    "@solana-program/token": "^0.5.1",
-    "@solana/kit": "^2.3.0",
-    "@solana/prettier-config-solana": "^0.0.5",
+    "@solana-program/compute-budget": "^0.11.0",
+    "@solana-program/system": "^0.10.0",
+    "@solana-program/token": "^0.9.0",
+    "@solana/kit": "^5.4.0",
+    "@solana/prettier-config-solana": "^0.0.6",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.17.27",
     "@typescript-eslint/eslint-plugin": "^8.38.0",
@@ -34,7 +38,8 @@
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.9",
     "typedoc-plugin-markdown": "^4.8.0",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "ws": "^8.18.3"
   },
   "scripts": {
     "build": "tsc",