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

package/dist/test/integration.test.js

@@ -1,5 +1,7 @@
-import { appendTransactionMessageInstruction, compileTransaction, createTransactionMessage, getBase64Decoder, getBase64EncodedWireTransaction, getBase64Encoder, getTransactionDecoder, getTransactionEncoder, partiallySignTransaction, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, } from '@solana/kit';
+import { address, appendTransactionMessageInstruction, compileTransaction, createTransactionMessage, getBase64Decoder, getBase64EncodedWireTransaction, getBase64Encoder, getTransactionDecoder, getTransactionEncoder, partiallySignTransaction, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, } from '@solana/kit';
+import { getTransferSolInstruction } from '@solana-program/system';
 import { findAssociatedTokenPda, getTransferInstruction, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+import { createKitKoraClient } from '../src/index.js';
 import { runAuthenticationTests } from './auth-setup.js';
 import setupTestSuite from './setup.js';
 function transactionFromBase64(base64) {
@@ -54,6 +56,7 @@ async function buildTokenTransferTransaction(params) {
     return { blockhash: blockhash, transaction: base64Transaction };
 }
 const AUTH_ENABLED = process.env.ENABLE_AUTH === 'true';
+const FREE_PRICING = process.env.FREE_PRICING === 'true';
 const KORA_SIGNER_TYPE = process.env.KORA_SIGNER_TYPE || 'memory';
 describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without auth'} | signer type: ${KORA_SIGNER_TYPE})`, () => {
     let client;
@@ -172,9 +175,12 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
             const fee = await client.estimateTransactionFee({ fee_token: usdcMint, transaction });
             expect(fee).toBeDefined();
             expect(typeof fee.fee_in_lamports).toBe('number');
-            expect(fee.fee_in_lamports).toBeGreaterThan(0);
+            expect(fee.fee_in_lamports).toBeGreaterThanOrEqual(0);
             expect(typeof fee.fee_in_token).toBe('number');
-            expect(fee.fee_in_token).toBeGreaterThan(0);
+            if (!FREE_PRICING) {
+                expect(fee.fee_in_lamports).toBeGreaterThan(0);
+                expect(fee.fee_in_token).toBeGreaterThan(0);
+            }
         });
         it('should sign transaction', async () => {
             const { transaction } = await buildTokenTransferTransaction({
@@ -246,7 +252,8 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
             expect(original_transaction).toBe(transaction);
         });
     });
-    describe('Bundle Operations', () => {
+    // Bundle tests require bundle.enabled = true in the Kora config
+    (FREE_PRICING ? describe.skip : describe)('Bundle Operations', () => {
         it('should sign bundle of transactions', async () => {
             // Create two transfer transactions for the bundle
             const { transaction: tx1String } = await buildTokenTransferTransaction({
@@ -324,17 +331,37 @@ describe(`KoraClient Integration Tests (${AUTH_ENABLED ? 'with auth' : 'without
             await expect(client.estimateTransactionFee({ fee_token: usdcMint, transaction: 'invalid_transaction' })).rejects.toThrow();
         });
     });
-    describe('End-to-End Flows', () => {
-        it('should handle transfer and sign flow', async () => {
-            const { transaction } = await buildTokenTransferTransaction({
-                amount: 1000000n,
-                client,
-                destinationWallet: koraAddress,
-                mint: usdcMint,
-                sourceWallet: testWallet,
-            });
-            const signResult = await client.signTransaction({ transaction });
-            expect(signResult.signed_transaction).toBeDefined();
+    if (FREE_PRICING) {
+        describe('Kit Client (free pricing)', () => {
+            let freeClient;
+            beforeAll(async () => {
+                const koraRpcUrl = process.env.KORA_RPC_URL || 'http://127.0.0.1:8080';
+                freeClient = await createKitKoraClient({
+                    endpoint: koraRpcUrl,
+                    rpcUrl: process.env.SOLANA_RPC_URL || 'http://127.0.0.1:8899',
+                    feeToken: usdcMint,
+                    feePayerWallet: testWallet,
+                });
+            }, 30000);
+            it('should send transaction without payment instruction when fee is 0', async () => {
+                const ix = getTransferSolInstruction({
+                    source: testWallet,
+                    destination: address(koraAddress),
+                    amount: 1000,
+                });
+                const result = await freeClient.sendTransaction([ix]);
+                expect(result.status).toBe('successful');
+                expect(result.context.signature).toBeDefined();
+            }, 30000);
+            it('should strip placeholder from planned message when fee is 0', async () => {
+                const ix = getTransferSolInstruction({
+                    source: testWallet,
+                    destination: address(koraAddress),
+                    amount: 1000,
+                });
+                const result = await freeClient.sendTransaction([ix]);
+                expect(result.status).toBe('successful');
+            }, 30000);
         });
-    });
+    }
 });

package/dist/test/kit-client.test.d.ts

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

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

@@ -0,0 +1,491 @@
+import { createKitKoraClient } from '../src/kit/index.js';
+import { address, createNoopSigner } from '@solana/kit';
+// Mock fetch globally
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+const MOCK_ENDPOINT = 'http://localhost:8080';
+const MOCK_RPC_URL = 'http://127.0.0.1:8899';
+const MOCK_PAYER_ADDRESS = 'DemoKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7';
+const MOCK_PAYMENT_ADDRESS = 'PayKMZWkk483QoFPLRPQ2XVKB7bWnuXwSjvDE1JsWk7';
+const MOCK_FEE_TOKEN = '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU';
+const MOCK_WALLET_ADDRESS = 'BrEe1Xjy2Ky72doGBAhyUPCxMm5b4bRTm3AD6MNMfKmq';
+const MOCK_WALLET = createNoopSigner(MOCK_WALLET_ADDRESS);
+const MOCK_SIGNATURE = '5wBzExmp8yR5M6m4KjV8WT9T6B1NMQkaMbsFWqBoDPBMYWxDx6EuSGxNqKfXnBhDhAkEqMiGRjEwKnGhSN3pi3n';
+function mockRpcResponse(result) {
+    mockFetch.mockResolvedValueOnce({
+        json: jest.fn().mockResolvedValueOnce({
+            jsonrpc: '2.0',
+            id: 1,
+            result,
+        }),
+    });
+}
+function mockSimulateResponse(unitsConsumed = 50000) {
+    const body = JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        result: {
+            context: { slot: 1 },
+            value: { err: null, logs: [], unitsConsumed },
+        },
+    });
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: new Headers({ 'content-type': 'application/json' }),
+        text: jest.fn().mockResolvedValueOnce(body),
+        json: jest.fn().mockResolvedValueOnce(JSON.parse(body)),
+    });
+}
+function mockRpcError(code, message) {
+    mockFetch.mockResolvedValueOnce({
+        json: jest.fn().mockResolvedValueOnce({
+            jsonrpc: '2.0',
+            id: 1,
+            error: { code, message },
+        }),
+    });
+}
+describe('createKitKoraClient', () => {
+    beforeEach(() => {
+        mockFetch.mockClear();
+    });
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    describe('initialization', () => {
+        it('should fetch payer info on creation', async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+            });
+            expect(client.paymentAddress).toBe(MOCK_PAYMENT_ADDRESS);
+            // ClientWithPayer: payer is a NoopSigner for the Kora fee payer
+            expect(client.payer.address).toBe(MOCK_PAYER_ADDRESS);
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+            expect(body.method).toBe('getPayerSigner');
+        });
+        it('should throw if getPayerSigner fails', async () => {
+            mockRpcError(-32000, 'Server error');
+            await expect(createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+            })).rejects.toThrow('RPC Error -32000: Server error');
+        });
+        it('should expose kora namespace for raw RPC access', async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+            });
+            expect(client.kora).toBeDefined();
+            expect(typeof client.kora.getConfig).toBe('function');
+            expect(typeof client.kora.getBlockhash).toBe('function');
+            expect(typeof client.kora.estimateTransactionFee).toBe('function');
+        });
+        it('should implement Kit plugin interfaces', async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+            });
+            // ClientWithPayer
+            expect(client.payer).toBeDefined();
+            expect(client.payer.address).toBe(MOCK_PAYER_ADDRESS);
+            // ClientWithTransactionPlanning
+            expect(typeof client.planTransaction).toBe('function');
+            expect(typeof client.planTransactions).toBe('function');
+            // ClientWithTransactionSending
+            expect(typeof client.sendTransaction).toBe('function');
+            expect(typeof client.sendTransactions).toBe('function');
+        });
+    });
+    describe('sendTransaction', () => {
+        let client;
+        beforeEach(async () => {
+            // Mock getPayerSigner for init
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+            });
+            mockFetch.mockClear();
+        });
+        it('should call getBlockhash, simulateTransaction, estimateTransactionFee, and signAndSendTransaction', async () => {
+            // Mock getBlockhash
+            mockRpcResponse({ blockhash: '4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi' });
+            // Mock simulateTransaction (CU estimation)
+            mockSimulateResponse();
+            // Mock estimateTransactionFee
+            mockRpcResponse({
+                fee_in_lamports: 5000,
+                fee_in_token: 50000,
+                signer_pubkey: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            // Mock signAndSendTransaction
+            mockRpcResponse({
+                signature: MOCK_SIGNATURE,
+                signed_transaction: 'base64signedtx',
+                signer_pubkey: MOCK_PAYER_ADDRESS,
+            });
+            const dummyIx = {
+                programAddress: address('11111111111111111111111111111111'),
+                accounts: [],
+                data: new Uint8Array(4),
+            };
+            const result = await client.sendTransaction([dummyIx]);
+            expect(result.status).toBe('successful');
+            expect(result.context.signature).toBe(MOCK_SIGNATURE);
+            expect(mockFetch).toHaveBeenCalledTimes(4);
+            const calls = mockFetch.mock.calls.map(c => JSON.parse(c[1].body).method);
+            expect(calls).toEqual([
+                'getBlockhash',
+                'simulateTransaction',
+                'estimateTransactionFee',
+                'signAndSendTransaction',
+            ]);
+        });
+        it('should skip payment instruction when fee is 0', async () => {
+            mockRpcResponse({ blockhash: '4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi' });
+            mockSimulateResponse();
+            mockRpcResponse({
+                fee_in_lamports: 0,
+                fee_in_token: 0,
+                signer_pubkey: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            // Mock signAndSendTransaction
+            mockRpcResponse({
+                signature: MOCK_SIGNATURE,
+                signed_transaction: 'base64signedtx',
+                signer_pubkey: MOCK_PAYER_ADDRESS,
+            });
+            const dummyIx = {
+                programAddress: address('11111111111111111111111111111111'),
+                accounts: [],
+                data: new Uint8Array(4),
+            };
+            const result = await client.sendTransaction([dummyIx]);
+            expect(result.status).toBe('successful');
+            expect(result.context.signature).toBe(MOCK_SIGNATURE);
+        });
+        it('should propagate fee estimation errors', async () => {
+            mockRpcResponse({ blockhash: '4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi' });
+            mockSimulateResponse();
+            mockRpcError(-32602, 'Invalid transaction');
+            const dummyIx = {
+                programAddress: address('11111111111111111111111111111111'),
+                accounts: [],
+                data: new Uint8Array(4),
+            };
+            // Kit's executor wraps errors — the original RPC error is in the cause chain
+            await expect(client.sendTransaction([dummyIx])).rejects.toThrow();
+            const calls = mockFetch.mock.calls.map(c => JSON.parse(c[1].body).method);
+            expect(calls).toContain('estimateTransactionFee');
+        });
+        it('should propagate signAndSendTransaction errors', async () => {
+            mockRpcResponse({ blockhash: '4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi' });
+            mockSimulateResponse();
+            mockRpcResponse({
+                fee_in_lamports: 5000,
+                fee_in_token: 50000,
+                signer_pubkey: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            mockRpcError(-32003, 'Transaction failed');
+            const dummyIx = {
+                programAddress: address('11111111111111111111111111111111'),
+                accounts: [],
+                data: new Uint8Array(4),
+            };
+            // Kit's executor wraps errors — the original RPC error is the cause
+            await expect(client.sendTransaction([dummyIx])).rejects.toThrow();
+            // Verify signAndSendTransaction was attempted
+            const calls = mockFetch.mock.calls.map(c => JSON.parse(c[1].body).method);
+            expect(calls).toContain('signAndSendTransaction');
+        });
+    });
+    describe('planTransaction', () => {
+        let client;
+        beforeEach(async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+            });
+            mockFetch.mockClear();
+        });
+        it('should return a transaction message without sending', async () => {
+            const dummyIx = {
+                programAddress: address('11111111111111111111111111111111'),
+                accounts: [],
+                data: new Uint8Array(4),
+            };
+            const result = await client.planTransaction([dummyIx]);
+            // Returns a transaction message (has version, instructions, feePayer)
+            expect(result).toBeDefined();
+            expect('version' in result).toBe(true);
+            expect('instructions' in result).toBe(true);
+            // Should NOT call any RPC methods (planner is local)
+            expect(mockFetch).toHaveBeenCalledTimes(0);
+        });
+    });
+    describe('plugin composition', () => {
+        it('should support .use() for extending the client with a Kit plugin', async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+            });
+            // Kit plugins must spread the client to preserve existing properties
+            const extended = client.use((c) => ({
+                ...c,
+                custom: {
+                    hello: () => 'world',
+                },
+            }));
+            expect(extended.custom.hello()).toBe('world');
+            // Original methods preserved via spread
+            expect(extended.kora).toBeDefined();
+            expect(typeof extended.sendTransaction).toBe('function');
+            expect(typeof extended.planTransaction).toBe('function');
+        });
+        it('should preserve existing properties when extending via plugin spread', async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+            });
+            // Plugin that adds extra property (with spread)
+            const extended = client.use((c) => ({
+                ...c,
+                extra: 42,
+            }));
+            expect(extended.extra).toBe(42);
+            expect(extended.payer.address).toBe(MOCK_PAYER_ADDRESS);
+            expect(extended.paymentAddress).toBe(MOCK_PAYMENT_ADDRESS);
+        });
+    });
+    describe('auth passthrough', () => {
+        it('should pass apiKey to underlying KoraClient', async () => {
+            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,
+                apiKey: 'test-api-key',
+            });
+            // The init call should include the API key header
+            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 () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const TOKEN_2022_PROGRAM_ADDRESS = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+                tokenProgramId: TOKEN_2022_PROGRAM_ADDRESS,
+            });
+            expect(client).toBeDefined();
+            expect(typeof client.sendTransaction).toBe('function');
+        });
+    });
+    describe('compute budget instructions', () => {
+        const COMPUTE_BUDGET_PROGRAM = 'ComputeBudget111111111111111111111111111111';
+        // SetComputeUnitLimit discriminator = 0x02, SetComputeUnitPrice discriminator = 0x03
+        const CU_LIMIT_DISCRIMINATOR = 2;
+        const CU_PRICE_DISCRIMINATOR = 3;
+        const DUMMY_IX = {
+            programAddress: address('11111111111111111111111111111111'),
+            accounts: [],
+            data: new Uint8Array(4),
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function getComputeBudgetIxs(planned) {
+            return planned.instructions.filter((ix) => ix.programAddress === COMPUTE_BUDGET_PROGRAM);
+        }
+        it('should include provisory CU limit by default (simulation-based estimation)', async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+            });
+            const planned = await client.planTransaction([DUMMY_IX]);
+            const cbIxs = getComputeBudgetIxs(planned);
+            expect(cbIxs).toHaveLength(1);
+            expect(cbIxs[0].data[0]).toBe(CU_LIMIT_DISCRIMINATOR);
+            const units = new DataView(cbIxs[0].data.buffer, cbIxs[0].data.byteOffset).getUint32(1, true);
+            expect(units).toBe(0); // Provisory — resolved via simulation in executor
+        });
+        it('should include SetComputeUnitLimit with correct units when computeUnitLimit is set', async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+                computeUnitLimit: 200_000,
+            });
+            const planned = await client.planTransaction([DUMMY_IX]);
+            const cbIxs = getComputeBudgetIxs(planned);
+            expect(cbIxs).toHaveLength(1);
+            const ix = cbIxs[0];
+            // discriminator 0x02 = SetComputeUnitLimit
+            expect(ix.data[0]).toBe(CU_LIMIT_DISCRIMINATOR);
+            // 200_000 in u32 LE = [0x40, 0x0D, 0x03, 0x00]
+            const units = new DataView(ix.data.buffer, ix.data.byteOffset).getUint32(1, true);
+            expect(units).toBe(200_000);
+        });
+        it('should include SetComputeUnitPrice and provisory CU limit when computeUnitPrice is set', async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+                computeUnitPrice: 1000n,
+            });
+            const planned = await client.planTransaction([DUMMY_IX]);
+            const cbIxs = getComputeBudgetIxs(planned);
+            // Price instruction + provisory CU limit (simulation-based estimation always on)
+            expect(cbIxs).toHaveLength(2);
+            const priceIx = cbIxs.find(ix => ix.data[0] === CU_PRICE_DISCRIMINATOR);
+            expect(priceIx).toBeDefined();
+            const ix = priceIx;
+            // discriminator 0x03 = SetComputeUnitPrice
+            expect(ix.data[0]).toBe(CU_PRICE_DISCRIMINATOR);
+            // 1000 in u64 LE
+            const view = new DataView(ix.data.buffer, ix.data.byteOffset);
+            const microLamports = view.getBigUint64(1, true);
+            expect(microLamports).toBe(1000n);
+        });
+        it('should include both CU limit and price instructions when both are set', async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+                computeUnitLimit: 150_000,
+                computeUnitPrice: 500n,
+            });
+            const planned = await client.planTransaction([DUMMY_IX]);
+            const cbIxs = getComputeBudgetIxs(planned);
+            expect(cbIxs).toHaveLength(2);
+            // First should be SetComputeUnitLimit
+            expect(cbIxs[0].data[0]).toBe(CU_LIMIT_DISCRIMINATOR);
+            const units = new DataView(cbIxs[0].data.buffer, cbIxs[0].data.byteOffset).getUint32(1, true);
+            expect(units).toBe(150_000);
+            // Second should be SetComputeUnitPrice
+            expect(cbIxs[1].data[0]).toBe(CU_PRICE_DISCRIMINATOR);
+            const microLamports = new DataView(cbIxs[1].data.buffer, cbIxs[1].data.byteOffset).getBigUint64(1, true);
+            expect(microLamports).toBe(500n);
+        });
+        it('should use explicit computeUnitLimit over simulation when computeUnitLimit is set', async () => {
+            mockRpcResponse({
+                signer_address: MOCK_PAYER_ADDRESS,
+                payment_address: MOCK_PAYMENT_ADDRESS,
+            });
+            const client = await createKitKoraClient({
+                endpoint: MOCK_ENDPOINT,
+                rpcUrl: MOCK_RPC_URL,
+                feeToken: MOCK_FEE_TOKEN,
+                feePayerWallet: MOCK_WALLET,
+                computeUnitLimit: 200_000,
+            });
+            const planned = await client.planTransaction([DUMMY_IX]);
+            const cbIxs = getComputeBudgetIxs(planned);
+            expect(cbIxs).toHaveLength(1);
+            const ix = cbIxs[0];
+            expect(ix.data[0]).toBe(CU_LIMIT_DISCRIMINATOR);
+            // Should be the explicit 200_000, not 0 (provisory)
+            const units = new DataView(ix.data.buffer, ix.data.byteOffset).getUint32(1, true);
+            expect(units).toBe(200_000);
+        });
+    });
+});

package/dist/test/setup.d.ts

@@ -1,4 +1,4 @@
-import { Address, Commitment, KeyPairSigner } from '@solana/kit';
+import { Address, KeyPairSigner } from '@solana/kit';
 import { KoraClient } from '../src/index.js';
 interface TestSuite {
     destinationAddress: Address<string>;
@@ -9,14 +9,11 @@ interface TestSuite {
     usdcMint: Address<string>;
 }
 export declare function loadEnvironmentVariables(): {
-    commitment: Commitment;
     destinationAddress: Address<string>;
     koraAddress: Address<string>;
     koraRpcUrl: string;
     koraSignerType: string;
     solDropAmount: bigint;
-    solanaRpcUrl: string;
-    solanaWsUrl: string;
     testUsdcMintSecret: string;
     testWalletSecret: string;
     tokenDecimals: number;