@solana/kora 0.2.1 → 0.3.0-beta.2

package/dist/test/kit-client.test.js

@@ -1,5 +1,6 @@
-import { createKitKoraClient } from '../src/kit/index.js';
-import { address, createNoopSigner } from '@solana/kit';
+import { createKitKoraClient, kora } from '../src/kit/index.js';
+import { address, createClient, createNoopSigner } from '@solana/kit';
+import { identity, signer } from '@solana/kit-plugin-signer';
 // Mock fetch globally
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
@@ -80,7 +81,7 @@ describe('createKitKoraClient', () => {
                 rpcUrl: MOCK_RPC_URL,
                 feeToken: MOCK_FEE_TOKEN,
                 feePayerWallet: MOCK_WALLET,
-            })).rejects.toThrow('RPC Error -32000: Server error');
+            })).rejects.toThrow('Kora Error -32000: Server error');
         });
         it('should expose kora namespace for raw RPC access', async () => {
             mockRpcResponse({
@@ -324,6 +325,24 @@ describe('createKitKoraClient', () => {
             const headers = mockFetch.mock.calls[0][1].headers;
             expect(headers['x-api-key']).toBe('test-api-key');
         });
+        it('should pass getRecaptchaToken to underlying KoraClient', async () => {
+            const mockGetToken = jest.fn().mockResolvedValue('test-recaptcha-token');
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+                getRecaptchaToken: mockGetToken,
+            });
+            // The init call should include the reCAPTCHA token header
+            expect(mockGetToken).toHaveBeenCalledTimes(1);
+            const headers = mockFetch.mock.calls[0][1].headers;
+            expect(headers['x-recaptcha-token']).toBe('test-recaptcha-token');
+        });
     });
     describe('Token-2022 support', () => {
         it('should accept tokenProgramId in config', async () => {
@@ -471,3 +490,47 @@ describe('createKitKoraClient', () => {
         });
     });
 });
+describe('kora() bundle plugin', () => {
+    beforeEach(() => {
+        mockFetch.mockClear();
+    });
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    it('composes with identity() and exposes the same surface as the wrapper', async () => {
+        mockRpcResponse({
+            signer_address: MOCK_PAYER_ADDRESS,
+            payment_address: MOCK_PAYMENT_ADDRESS,
+        });
+        const client = await createClient()
+            .use(identity(MOCK_WALLET))
+            .use(kora({
+            endpoint: MOCK_ENDPOINT,
+            rpcUrl: MOCK_RPC_URL,
+            feeToken: MOCK_FEE_TOKEN,
+        }));
+        expect(client.identity.address).toBe(MOCK_WALLET_ADDRESS);
+        expect(client.payer.address).toBe(MOCK_PAYER_ADDRESS);
+        expect(client.paymentAddress).toBe(MOCK_PAYMENT_ADDRESS);
+        expect(typeof client.sendTransaction).toBe('function');
+        expect(typeof client.planTransaction).toBe('function');
+        expect(client.kora).toBeDefined();
+    });
+    // TODO: re-enable once @solana/kit supports overriding an already-set field on an
+    // extended client.
+    it.skip('overrides client.payer when the caller used signer() (sets identity + payer)', async () => {
+        mockRpcResponse({
+            signer_address: MOCK_PAYER_ADDRESS,
+            payment_address: MOCK_PAYMENT_ADDRESS,
+        });
+        const client = await createClient()
+            .use(signer(MOCK_WALLET))
+            .use(kora({
+            endpoint: MOCK_ENDPOINT,
+            rpcUrl: MOCK_RPC_URL,
+            feeToken: MOCK_FEE_TOKEN,
+        }));
+        expect(client.identity.address).toBe(MOCK_WALLET_ADDRESS);
+        expect(client.payer.address).toBe(MOCK_PAYER_ADDRESS);
+    });
+});

package/dist/test/plugin.test.js

@@ -1,5 +1,5 @@
-import { createEmptyClient } from '@solana/kit';
-import { koraPlugin } from '../src/kit/plugin.js';
+import { createClient } from '@solana/kit';
+import { koraPlugin } from '../src/plugin.js';
 // Mock fetch globally
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
@@ -12,8 +12,8 @@ describe('Kora Kit Plugin', () => {
     const mockSuccessfulResponse = (result) => {
         mockFetch.mockResolvedValueOnce({
             json: jest.fn().mockResolvedValueOnce({
-                jsonrpc: '2.0',
                 id: 1,
+                jsonrpc: '2.0',
                 result,
             }),
         });
@@ -22,9 +22,9 @@ describe('Kora Kit Plugin', () => {
     const mockErrorResponse = (error) => {
         mockFetch.mockResolvedValueOnce({
             json: jest.fn().mockResolvedValueOnce({
-                jsonrpc: '2.0',
-                id: 1,
                 error,
+                id: 1,
+                jsonrpc: '2.0',
             }),
         });
     };
@@ -41,11 +41,14 @@ describe('Kora Kit Plugin', () => {
             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.getVersion).toBe('function');
             expect(typeof enhanced.kora.getSupportedTokens).toBe('function');
             expect(typeof enhanced.kora.estimateTransactionFee).toBe('function');
+            expect(typeof enhanced.kora.estimateBundleFee).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.signBundle).toBe('function');
+            expect(typeof enhanced.kora.signAndSendBundle).toBe('function');
             expect(typeof enhanced.kora.getPaymentInstruction).toBe('function');
         });
         it('should work with empty client object', () => {
@@ -55,8 +58,8 @@ describe('Kora Kit Plugin', () => {
         });
         it('should support authentication options', () => {
             const authConfig = {
-                endpoint: mockEndpoint,
                 apiKey: 'test-api-key',
+                endpoint: mockEndpoint,
                 hmacSecret: 'test-hmac-secret',
             };
             const plugin = koraPlugin(authConfig);
@@ -74,67 +77,67 @@ describe('Kora Kit Plugin', () => {
         describe('getConfig', () => {
             it('should return Kit-typed Address arrays', async () => {
                 const rawResponse = {
+                    enabled_methods: {
+                        estimate_transaction_fee: true,
+                        get_blockhash: true,
+                        get_config: true,
+                        get_supported_tokens: true,
+                        liveness: true,
+                        sign_and_send_transaction: true,
+                        sign_transaction: true,
+                        transfer_transaction: true,
+                    },
                     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'],
+                        allowed_tokens: ['EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'],
                         disallowed_accounts: [],
                         fee_payer_policy: {
-                            system: {
+                            spl_token: {
+                                allow_approve: true,
+                                allow_burn: true,
+                                allow_close_account: true,
+                                allow_freeze_account: true,
+                                allow_mint_to: true,
+                                allow_revoke: true,
+                                allow_set_authority: true,
+                                allow_thaw_account: true,
                                 allow_transfer: true,
+                            },
+                            system: {
+                                allow_allocate: true,
                                 allow_assign: true,
                                 allow_create_account: true,
-                                allow_allocate: true,
+                                allow_transfer: true,
                                 nonce: {
-                                    allow_initialize: true,
                                     allow_advance: true,
                                     allow_authorize: true,
+                                    allow_initialize: 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_approve: true,
                                 allow_burn: true,
                                 allow_close_account: true,
-                                allow_approve: true,
+                                allow_freeze_account: true,
+                                allow_mint_to: true,
                                 allow_revoke: true,
                                 allow_set_authority: true,
-                                allow_mint_to: true,
-                                allow_freeze_account: true,
                                 allow_thaw_account: true,
+                                allow_transfer: true,
                             },
                         },
-                        price: { type: 'margin', margin: 0.1 },
+                        max_allowed_lamports: 1000000,
+                        max_signatures: 10,
+                        price: { margin: 0.1, type: 'margin' },
+                        price_source: 'Jupiter',
                         token2022: {
-                            blocked_mint_extensions: [],
                             blocked_account_extensions: [],
+                            blocked_mint_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();
@@ -146,12 +149,47 @@ describe('Kora Kit Plugin', () => {
                 expect(result.validation_config.allowed_tokens).toHaveLength(1);
                 expect(result.validation_config.allowed_tokens[0]).toBe('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
             });
+            it('should pass through the "All" wildcard for allowed_programs without crashing', async () => {
+                // Regression: ProgramsConfig::All serializes as the string "All" on the wire,
+                // which would crash the kit wrapper if it called .map() unconditionally.
+                const rawResponse = {
+                    enabled_methods: {
+                        estimate_transaction_fee: true,
+                        get_blockhash: true,
+                        get_config: true,
+                        get_supported_tokens: true,
+                        liveness: true,
+                        sign_and_send_transaction: true,
+                        sign_transaction: true,
+                        transfer_transaction: true,
+                    },
+                    fee_payers: ['DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7'],
+                    validation_config: {
+                        allowed_programs: 'All',
+                        allowed_spl_paid_tokens: [],
+                        allowed_tokens: [],
+                        disallowed_accounts: [],
+                        fee_payer_policy: {},
+                        max_allowed_lamports: 1000000,
+                        max_signatures: 10,
+                        price: { margin: 0.1, type: 'margin' },
+                        price_source: 'Jupiter',
+                        token2022: {
+                            blocked_account_extensions: [],
+                            blocked_mint_extensions: [],
+                        },
+                    },
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.getConfig();
+                expect(result.validation_config.allowed_programs).toBe('All');
+            });
         });
         describe('getPayerSigner', () => {
             it('should return Kit-typed Address fields', async () => {
                 const rawResponse = {
-                    signer_address: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
                     payment_address: 'PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                    signer_address: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
                 };
                 mockSuccessfulResponse(rawResponse);
                 const result = await kora.getPayerSigner();
@@ -174,6 +212,16 @@ describe('Kora Kit Plugin', () => {
                 expect(hash).toBe('4NxM2D4kQcipkzMWBWQME5YSVnj5kT8QKA7rvb3rKLvE');
             });
         });
+        describe('getVersion', () => {
+            it('should return version string', async () => {
+                const rawResponse = {
+                    version: '2.0.0',
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.getVersion();
+                expect(result.version).toBe('2.0.0');
+            });
+        });
         describe('getSupportedTokens', () => {
             it('should return Kit-typed Address array', async () => {
                 const rawResponse = {
@@ -197,13 +245,13 @@ describe('Kora Kit Plugin', () => {
                 const rawResponse = {
                     fee_in_lamports: 5000,
                     fee_in_token: 50,
-                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
                     payment_address: 'PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
                 };
                 mockSuccessfulResponse(rawResponse);
                 const result = await kora.estimateTransactionFee({
-                    transaction: 'base64EncodedTransaction',
                     fee_token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+                    transaction: 'base64EncodedTransaction',
                 });
                 // Type assertions
                 const signerPubkey = result.signer_pubkey;
@@ -214,6 +262,28 @@ describe('Kora Kit Plugin', () => {
                 expect(paymentAddr).toBe('PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
             });
         });
+        describe('estimateBundleFee', () => {
+            it('should return Kit-typed Address fields for bundle', async () => {
+                const rawResponse = {
+                    fee_in_lamports: 15000,
+                    fee_in_token: 150,
+                    payment_address: 'PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.estimateBundleFee({
+                    fee_token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+                    transactions: ['base64Tx1', 'base64Tx2', 'base64Tx3'],
+                });
+                // Type assertions
+                const signerPubkey = result.signer_pubkey;
+                const paymentAddr = result.payment_address;
+                expect(result.fee_in_lamports).toBe(15000);
+                expect(result.fee_in_token).toBe(150);
+                expect(signerPubkey).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+                expect(paymentAddr).toBe('PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+            });
+        });
         describe('signTransaction', () => {
             it('should return Kit-typed response with Base64EncodedWireTransaction', async () => {
                 const rawResponse = {
@@ -232,9 +302,11 @@ describe('Kora Kit Plugin', () => {
             });
         });
         describe('signAndSendTransaction', () => {
-            it('should return Kit-typed response with Base64EncodedWireTransaction', async () => {
+            it('should return Kit-typed response with Signature and Base64EncodedWireTransaction', async () => {
+                // Use a valid base58 signature (88 characters, valid base58 alphabet)
+                const mockSignature = '5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW';
                 const rawResponse = {
-                    signature: '5wBzExmp8yR5M6m4KjV8WT9T6B1NMQkaMbsFWqBoDPBMYWxDx6EuSGxNqKfXnBhDhAkEqMiGRjEwKnGhSN3pi3n',
+                    signature: mockSignature,
                     signed_transaction: 'base64SignedTransaction',
                     signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
                 };
@@ -243,37 +315,52 @@ describe('Kora Kit Plugin', () => {
                     transaction: 'base64EncodedTransaction',
                 });
                 // Type assertions - verify Kit types
+                const sig = result.signature;
                 const signedTx = result.signed_transaction;
                 const signerPubkey = result.signer_pubkey;
+                expect(sig).toBe(mockSignature);
                 expect(signedTx).toBe('base64SignedTransaction');
                 expect(signerPubkey).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
             });
         });
-        describe('transferTransaction', () => {
-            it('should return Kit-typed response with Base64EncodedWireTransaction and Blockhash', async () => {
+        describe('signBundle', () => {
+            it('should return Kit-typed response with Base64EncodedWireTransaction array', async () => {
                 const rawResponse = {
-                    transaction: 'base64Transaction',
-                    message: 'base64Message',
-                    blockhash: '4NxM2D4kQcipkzMWBWQME5YSVnj5kT8QKA7rvb3rKLvE',
+                    signed_transactions: ['base64SignedTx1', 'base64SignedTx2'],
                     signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
-                    instructions: [],
                 };
                 mockSuccessfulResponse(rawResponse);
-                const result = await kora.transferTransaction({
-                    amount: 1000000,
-                    token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-                    source: 'sourceWallet',
-                    destination: 'destWallet',
+                const result = await kora.signBundle({
+                    transactions: ['base64Tx1', 'base64Tx2'],
                 });
                 // Type assertions - verify Kit types
-                const tx = result.transaction;
-                const hash = result.blockhash;
+                const signedTxs = result.signed_transactions;
                 const signerPubkey = result.signer_pubkey;
-                expect(tx).toBe('base64Transaction');
-                expect(result.message).toBe('base64Message');
-                expect(hash).toBe('4NxM2D4kQcipkzMWBWQME5YSVnj5kT8QKA7rvb3rKLvE');
+                expect(signedTxs).toHaveLength(2);
+                expect(signedTxs[0]).toBe('base64SignedTx1');
+                expect(signedTxs[1]).toBe('base64SignedTx2');
                 expect(signerPubkey).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
-                expect(result.instructions).toEqual([]);
+            });
+        });
+        describe('signAndSendBundle', () => {
+            it('should return Kit-typed response with Base64EncodedWireTransaction array and bundle UUID', async () => {
+                const rawResponse = {
+                    bundle_uuid: 'jito-bundle-uuid-12345',
+                    signed_transactions: ['base64SignedTx1', 'base64SignedTx2'],
+                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                };
+                mockSuccessfulResponse(rawResponse);
+                const result = await kora.signAndSendBundle({
+                    transactions: ['base64Tx1', 'base64Tx2'],
+                });
+                // Type assertions - verify Kit types
+                const signedTxs = result.signed_transactions;
+                const signerPubkey = result.signer_pubkey;
+                expect(signedTxs).toHaveLength(2);
+                expect(signedTxs[0]).toBe('base64SignedTx1');
+                expect(signedTxs[1]).toBe('base64SignedTx2');
+                expect(signerPubkey).toBe('DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7');
+                expect(result.bundle_uuid).toBe('jito-bundle-uuid-12345');
             });
         });
         describe('getPaymentInstruction', () => {
@@ -281,16 +368,16 @@ describe('Kora Kit Plugin', () => {
                 const mockFeeEstimate = {
                     fee_in_lamports: 5000,
                     fee_in_token: 50000,
-                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
                     payment_address: 'PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                    signer_pubkey: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
                 };
                 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',
+                    transaction: testTx,
                 });
                 // Type assertions - verify Kit types
                 const originalTx = result.original_transaction;
@@ -314,48 +401,51 @@ describe('Kora Kit Plugin', () => {
         });
         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');
+            await expect(kora.getConfig()).rejects.toThrow('Kora 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('KoraPlugin Type Export', () => {
-        it('should export KoraPlugin type correctly', () => {
-            // This test verifies the KoraPlugin type is correctly exported
+    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 KoraPlugin type
+            // Type check - assign to KoraApi type
             const api = client.kora;
             expect(api).toBeDefined();
         });
     });
-    describe('createEmptyClient Integration', () => {
+    describe('createClient Integration', () => {
         it('should initialize kora property on Kit client', () => {
-            const client = createEmptyClient().use(koraPlugin(mockConfig));
+            const client = createClient().use(koraPlugin(mockConfig));
             expect(client).toHaveProperty('kora');
             expect(client.kora).toBeDefined();
         });
         it('should expose all Kora RPC methods', () => {
-            const client = createEmptyClient().use(koraPlugin(mockConfig));
+            const client = createClient().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.getVersion).toBe('function');
             expect(typeof client.kora.getSupportedTokens).toBe('function');
             expect(typeof client.kora.estimateTransactionFee).toBe('function');
+            expect(typeof client.kora.estimateBundleFee).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.signBundle).toBe('function');
+            expect(typeof client.kora.signAndSendBundle).toBe('function');
             expect(typeof client.kora.getPaymentInstruction).toBe('function');
         });
         it('should work with authentication config', () => {
             const authConfig = {
-                endpoint: mockEndpoint,
                 apiKey: 'test-api-key',
+                endpoint: mockEndpoint,
                 hmacSecret: 'test-hmac-secret',
             };
-            const client = createEmptyClient().use(koraPlugin(authConfig));
+            const client = createClient().use(koraPlugin(authConfig));
             expect(client.kora).toBeDefined();
             expect(typeof client.kora.getConfig).toBe('function');
         });
@@ -365,7 +455,7 @@ describe('Kora Kit Plugin', () => {
                 ...c,
                 other: { foo: () => 'bar' },
             });
-            const client = createEmptyClient().use(koraPlugin(mockConfig)).use(otherPlugin);
+            const client = createClient().use(koraPlugin(mockConfig)).use(otherPlugin);
             // Both plugins should be available
             expect(client.kora).toBeDefined();
             expect(client.other).toBeDefined();
@@ -374,11 +464,11 @@ describe('Kora Kit Plugin', () => {
         });
         it('should call RPC methods correctly', async () => {
             const mockResponse = {
-                signer_address: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
                 payment_address: 'PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
+                signer_address: 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7',
             };
             mockSuccessfulResponse(mockResponse);
-            const client = createEmptyClient().use(koraPlugin(mockConfig));
+            const client = createClient().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.d.ts

@@ -1,30 +1,23 @@
-import { Commitment, KeyPairSigner, Address } from '@solana/kit';
+import { Address, KeyPairSigner } from '@solana/kit';
 import { KoraClient } from '../src/index.js';
 interface TestSuite {
+    destinationAddress: Address<string>;
+    koraAddress: Address<string>;
     koraClient: KoraClient;
     koraRpcUrl: string;
     testWallet: KeyPairSigner<string>;
     usdcMint: Address<string>;
-    destinationAddress: Address<string>;
-    koraAddress: Address<string>;
-    authConfig?: {
-        apiKey: string;
-        hmacSecret: string;
-    };
 }
 export declare function loadEnvironmentVariables(): {
-    koraRpcUrl: string;
+    destinationAddress: Address<string>;
     koraAddress: Address<string>;
+    koraRpcUrl: string;
     koraSignerType: string;
-    commitment: Commitment;
-    tokenDecimals: number;
-    tokenDropAmount: number;
     solDropAmount: bigint;
-    solanaRpcUrl: string;
-    solanaWsUrl: string;
-    testWalletSecret: string;
     testUsdcMintSecret: string;
-    destinationAddress: Address<string>;
+    testWalletSecret: string;
+    tokenDecimals: number;
+    tokenDropAmount: number;
 };
 declare function setupTestSuite(): Promise<TestSuite>;
 export default setupTestSuite;