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

package/dist/test/setup.js

@@ -1,13 +1,11 @@
-import { airdropFactory, appendTransactionMessageInstructions, assertIsAddress, assertIsSendableTransaction, assertIsTransactionWithBlockhashLifetime, createKeyPairSignerFromBytes, createSolanaRpc, createSolanaRpcSubscriptions, createTransactionMessage, getBase58Encoder, getSignatureFromTransaction, lamports, pipe, sendAndConfirmTransactionFactory, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from '@solana/kit';
-import { MAX_COMPUTE_UNIT_LIMIT, updateOrAppendSetComputeUnitLimitInstruction, updateOrAppendSetComputeUnitPriceInstruction, } from '@solana-program/compute-budget';
-import { getCreateAccountInstruction } from '@solana-program/system';
-import { findAssociatedTokenPda, getCreateAssociatedTokenIdempotentInstructionAsync, getInitializeMintInstruction, getMintSize, getMintToInstruction, TOKEN_PROGRAM_ADDRESS, } from '@solana-program/token';
+import { assertIsAddress, createKeyPairSignerFromBytes, getBase58Encoder, lamports, } from '@solana/kit';
+import { createClient } from '@solana/kit-client-litesvm';
+import { tokenProgram, associatedTokenProgram } from '@solana-program/token';
 import { config } from 'dotenv';
 import path from 'path';
 import { KoraClient } from '../src/index.js';
 config({ path: path.resolve(process.cwd(), '.env') });
 const DEFAULTS = {
-    COMMITMENT: 'processed',
     DECIMALS: 6,
     // Make sure this matches the USDC mint in kora.toml (9BgeTKqmFsPVnfYscfM6NvsgmZxei7XfdciShQ6D3bxJ)
     DESTINATION_ADDRESS: 'AVmDft8deQEo78bRKcGN5ZMf3hyjeLBK4Rd4xGB46yQM',
@@ -17,8 +15,6 @@ const DEFAULTS = {
     KORA_SIGNER_TYPE: 'memory',
     // Make sure this matches the kora-rpc signer address on launch (root .env)
     SENDER_SECRET: 'tzgfgSWTE3KUA6qfRoFYLaSfJm59uUeZRDy4ybMrLn1JV2drA1mftiaEcVFvq1Lok6h6EX2C4Y9kSKLvQWyMpS5',
-    SOLANA_RPC_URL: 'http://127.0.0.1:8899',
-    SOLANA_WS_URL: 'ws://127.0.0.1:8900',
     SOL_DROP_AMOUNT: 1_000_000_000,
     // HhA5j2rRiPbMrpF2ZD36r69FyZf3zWmEHRNSZbbNdVjf
     TEST_USDC_MINT_SECRET: '59kKmXphL5UJANqpFFjtH17emEq3oRNmYsx6a3P3vSGJRmhMgVdzH77bkNEi9bArRViT45e8L2TsuPxKNFoc3Qfg',
@@ -54,9 +50,6 @@ export function loadEnvironmentVariables() {
         }
     }
     const koraRpcUrl = process.env.KORA_RPC_URL || DEFAULTS.KORA_RPC_URL;
-    const solanaRpcUrl = process.env.SOLANA_RPC_URL || DEFAULTS.SOLANA_RPC_URL;
-    const solanaWsUrl = process.env.SOLANA_WS_URL || DEFAULTS.SOLANA_WS_URL;
-    const commitment = (process.env.COMMITMENT || DEFAULTS.COMMITMENT);
     const tokenDecimals = Number(process.env.TOKEN_DECIMALS || DEFAULTS.DECIMALS);
     const tokenDropAmount = Number(process.env.TOKEN_DROP_AMOUNT || DEFAULTS.TOKEN_DROP_AMOUNT);
     const solDropAmount = BigInt(process.env.SOL_DROP_AMOUNT || DEFAULTS.SOL_DROP_AMOUNT);
@@ -66,14 +59,11 @@ export function loadEnvironmentVariables() {
     assertIsAddress(destinationAddress);
     assertIsAddress(koraAddress);
     return {
-        commitment,
         destinationAddress,
         koraAddress,
         koraRpcUrl,
         koraSignerType,
         solDropAmount,
-        solanaRpcUrl,
-        solanaWsUrl,
         testUsdcMintSecret,
         testWalletSecret,
         tokenDecimals,
@@ -90,129 +80,46 @@ async function createKeyPairSigners() {
         usdcMint,
     };
 }
-const createDefaultTransaction = async (client, feePayer, computeLimit = MAX_COMPUTE_UNIT_LIMIT, feeMicroLamports = 1n) => {
-    const { value: latestBlockhash } = await client.rpc.getLatestBlockhash().send();
-    return pipe(createTransactionMessage({ version: 0 }), tx => setTransactionMessageFeePayerSigner(feePayer, tx), tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), tx => updateOrAppendSetComputeUnitPriceInstruction(feeMicroLamports, tx), tx => updateOrAppendSetComputeUnitLimitInstruction(computeLimit, tx));
-};
-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;
-};
-function safeStringify(obj) {
-    return JSON.stringify(obj, (key, value) => {
-        if (typeof value === 'bigint') {
-            return value.toString();
-        }
-        return value;
-    }, 2);
-}
-async function sendAndConfirmInstructions(client, payer, instructions, description, commitment = loadEnvironmentVariables().commitment) {
-    try {
-        const signature = await pipe(await createDefaultTransaction(client, payer, 200_000), tx => appendTransactionMessageInstructions(instructions, tx), tx => signAndSendTransaction(client, tx, commitment));
-        return signature;
-    }
-    catch (error) {
-        console.error(safeStringify(error));
-        throw new Error(`Failed to ${description.toLowerCase()}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-async function initializeToken({ client, mintAuthority, payer, owner, mint, dropAmount, decimals, otherAtaWallets, }) {
-    // Get Owner ATA
-    const [ata] = await findAssociatedTokenPda({
-        mint: mint.address,
-        owner: owner.address,
-        tokenProgram: TOKEN_PROGRAM_ADDRESS,
-    });
-    // Get Mint size & rent
-    const mintSpace = BigInt(getMintSize());
-    const mintRent = await client.rpc.getMinimumBalanceForRentExemption(mintSpace).send();
-    // Create instructions for new token mint
-    const baseInstructions = [
-        // Create the Mint Account
-        getCreateAccountInstruction({
-            lamports: mintRent,
-            newAccount: mint,
-            payer,
-            programAddress: TOKEN_PROGRAM_ADDRESS,
-            space: mintSpace,
-        }),
-        // Initialize the Mint
-        getInitializeMintInstruction({
-            decimals,
-            mint: mint.address,
-            mintAuthority: mintAuthority.address,
-        }),
-        // Create Associated Token Account
-        await getCreateAssociatedTokenIdempotentInstructionAsync({
-            mint: mint.address,
-            owner: owner.address,
-            payer,
-        }),
-        // Mint To the Destination Associated Token Account
-        getMintToInstruction({
-            amount: BigInt(dropAmount * 10 ** decimals),
-            mint: mint.address,
-            mintAuthority,
-            token: ata,
-        }),
-    ];
-    // Generate Create ATA instructions for other token accounts we wish to add
-    const otherAtaInstructions = otherAtaWallets
-        ? await Promise.all(otherAtaWallets.map(async (wallet) => await getCreateAssociatedTokenIdempotentInstructionAsync({
-            mint: mint.address,
-            owner: wallet,
-            payer,
-        })))
-        : [];
-    const alreadyExists = await mintExists(client, mint.address);
-    const instructions = alreadyExists ? [...otherAtaInstructions] : [...baseInstructions, ...otherAtaInstructions];
-    await sendAndConfirmInstructions(client, payer, instructions, 'Initialize token and ATAs', 'finalized');
-}
 async function setupTestSuite() {
-    const { koraAddress, koraRpcUrl, tokenDecimals, tokenDropAmount, solDropAmount, solanaRpcUrl, solanaWsUrl } = loadEnvironmentVariables();
-    // Load auth config from environment if not provided
+    const { koraAddress, koraRpcUrl, tokenDecimals, tokenDropAmount, solDropAmount } = loadEnvironmentVariables();
     const authConfig = process.env.ENABLE_AUTH === 'true'
         ? {
             apiKey: process.env.KORA_API_KEY || 'test-api-key-123',
             hmacSecret: process.env.KORA_HMAC_SECRET || 'test-hmac-secret-456',
         }
         : undefined;
-    // Create Solana client
-    const rpc = createSolanaRpc(solanaRpcUrl);
-    const rpcSubscriptions = createSolanaRpcSubscriptions(solanaWsUrl);
-    const airdrop = airdropFactory({ rpc, rpcSubscriptions });
-    const client = { rpc, rpcSubscriptions };
-    // Get or create keypairs
     const { testWallet, usdcMint, destinationAddress } = await createKeyPairSigners();
-    const mintAuthority = testWallet; // test wallet can be used as mint authority for the test
-    // Airdrop SOL to test sender and kora wallets
-    await Promise.all([
-        airdrop({
-            commitment: 'finalized',
-            lamports: lamports(solDropAmount),
-            recipientAddress: koraAddress,
-        }),
-        airdrop({
-            commitment: 'finalized',
-            lamports: lamports(solDropAmount),
-            recipientAddress: testWallet.address,
-        }),
-    ]);
-    // Initialize token and ATAs
-    await initializeToken({
-        client,
+    const client = await createClient({ payer: testWallet }).use(tokenProgram()).use(associatedTokenProgram());
+    // Airdrop SOL via LiteSVM
+    await client.airdrop(koraAddress, lamports(solDropAmount));
+    await client.airdrop(testWallet.address, lamports(solDropAmount));
+    // Create mint
+    await client.token.instructions
+        .createMint({
+        newMint: usdcMint,
+        decimals: tokenDecimals,
+        mintAuthority: testWallet.address,
+    })
+        .sendTransaction();
+    // Mint tokens to testWallet's ATA (auto-creates ATA)
+    await client.token.instructions
+        .mintToATA({
+        mint: usdcMint.address,
+        owner: testWallet.address,
+        mintAuthority: testWallet,
+        amount: BigInt(tokenDropAmount * 10 ** tokenDecimals),
         decimals: tokenDecimals,
-        dropAmount: tokenDropAmount,
-        mint: usdcMint,
-        mintAuthority,
-        otherAtaWallets: [testWallet.address, koraAddress, destinationAddress],
-        owner: testWallet,
-        payer: mintAuthority,
-    });
+    })
+        .sendTransaction();
+    // Create ATAs for kora and destination wallets
+    for (const owner of [koraAddress, destinationAddress]) {
+        await client.associatedToken.instructions
+            .createAssociatedTokenIdempotent({
+            owner,
+            mint: usdcMint.address,
+        })
+            .sendTransaction();
+    }
     return {
         destinationAddress,
         koraAddress,
@@ -222,13 +129,4 @@ async function setupTestSuite() {
         usdcMint: usdcMint.address,
     };
 }
-const mintExists = async (client, mint) => {
-    try {
-        const mintAccount = await client.rpc.getAccountInfo(mint).send();
-        return mintAccount.value !== null;
-    }
-    catch {
-        return false;
-    }
-};
 export default setupTestSuite;

package/dist/test/unit.test.js

@@ -509,28 +509,112 @@ describe('KoraClient Unit Tests', () => {
             await expect(client.getConfig()).rejects.toThrow('RPC Error undefined: undefined');
         });
     });
-    // TODO: Add Authentication Tests (separate PR)
-    //
-    // describe('Authentication', () => {
-    //     describe('API Key Authentication', () => {
-    //         - Test that x-api-key header is included when apiKey is provided
-    //         - Test requests work without apiKey when not provided
-    //         - Test all RPC methods include the header
-    //     });
-    //
-    //     describe('HMAC Authentication', () => {
-    //         - Test x-timestamp and x-hmac-signature headers are included when hmacSecret is provided
-    //         - Test HMAC signature calculation is correct (SHA256 of timestamp + body)
-    //         - Test timestamp is current (within reasonable bounds)
-    //         - Test requests work without HMAC when not provided
-    //         - Test all RPC methods include the headers
-    //     });
-    //
-    //     describe('Combined Authentication', () => {
-    //         - Test both API key and HMAC headers are included when both are provided
-    //         - Test headers are correctly combined
-    //     });
-    // });
+    describe('reCAPTCHA Authentication', () => {
+        it('should include x-recaptcha-token header when getRecaptchaToken callback is provided (sync)', async () => {
+            const recaptchaClient = new KoraClient({
+                getRecaptchaToken: () => 'test-recaptcha-token',
+                rpcUrl: mockRpcUrl,
+            });
+            mockSuccessfulResponse({ version: '1.0.0' });
+            await recaptchaClient.getVersion();
+            expect(mockFetch).toHaveBeenCalledWith(mockRpcUrl, {
+                body: JSON.stringify({
+                    id: 1,
+                    jsonrpc: '2.0',
+                    method: 'getVersion',
+                    params: undefined,
+                }),
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-recaptcha-token': 'test-recaptcha-token',
+                },
+                method: 'POST',
+            });
+        });
+        it('should include x-recaptcha-token header when getRecaptchaToken callback returns Promise', async () => {
+            const recaptchaClient = new KoraClient({
+                getRecaptchaToken: () => Promise.resolve('async-recaptcha-token'),
+                rpcUrl: mockRpcUrl,
+            });
+            mockSuccessfulResponse({ version: '1.0.0' });
+            await recaptchaClient.getVersion();
+            expect(mockFetch).toHaveBeenCalledWith(mockRpcUrl, {
+                body: JSON.stringify({
+                    id: 1,
+                    jsonrpc: '2.0',
+                    method: 'getVersion',
+                    params: undefined,
+                }),
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-recaptcha-token': 'async-recaptcha-token',
+                },
+                method: 'POST',
+            });
+        });
+        it('should NOT include x-recaptcha-token header when getRecaptchaToken is not provided', async () => {
+            mockSuccessfulResponse({ version: '1.0.0' });
+            await client.getVersion();
+            expect(mockFetch).toHaveBeenCalledWith(mockRpcUrl, {
+                body: JSON.stringify({
+                    id: 1,
+                    jsonrpc: '2.0',
+                    method: 'getVersion',
+                    params: undefined,
+                }),
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                method: 'POST',
+            });
+        });
+        it('should include x-recaptcha-token along with other auth headers', async () => {
+            const combinedAuthClient = new KoraClient({
+                apiKey: 'test-api-key',
+                getRecaptchaToken: () => 'test-recaptcha-token',
+                rpcUrl: mockRpcUrl,
+            });
+            mockSuccessfulResponse({ version: '1.0.0' });
+            await combinedAuthClient.getVersion();
+            const callArgs = mockFetch.mock.calls[0][1];
+            expect(callArgs.headers).toMatchObject({
+                'Content-Type': 'application/json',
+                'x-api-key': 'test-api-key',
+                'x-recaptcha-token': 'test-recaptcha-token',
+            });
+        });
+        it('should call getRecaptchaToken callback for each request', async () => {
+            let callCount = 0;
+            const recaptchaClient = new KoraClient({
+                getRecaptchaToken: () => `token-${++callCount}`,
+                rpcUrl: mockRpcUrl,
+            });
+            mockSuccessfulResponse({ version: '1.0.0' });
+            await recaptchaClient.getVersion();
+            mockSuccessfulResponse({ blockhash: 'test-blockhash' });
+            await recaptchaClient.getBlockhash();
+            expect(callCount).toBe(2);
+            const calls = mockFetch.mock.calls;
+            expect(calls[0][1].headers['x-recaptcha-token']).toBe('token-1');
+            expect(calls[1][1].headers['x-recaptcha-token']).toBe('token-2');
+        });
+        it('should propagate errors when getRecaptchaToken callback throws', async () => {
+            const recaptchaClient = new KoraClient({
+                getRecaptchaToken: () => {
+                    throw new Error('reCAPTCHA failed to load');
+                },
+                rpcUrl: mockRpcUrl,
+            });
+            await expect(recaptchaClient.getVersion()).rejects.toThrow('reCAPTCHA failed to load');
+        });
+        it('should propagate errors when getRecaptchaToken returns rejected Promise', async () => {
+            const recaptchaClient = new KoraClient({
+                getRecaptchaToken: () => Promise.reject(new Error('Token generation failed')),
+                rpcUrl: mockRpcUrl,
+            });
+            await expect(recaptchaClient.getVersion()).rejects.toThrow('Token generation failed');
+        });
+    });
 });
 describe('Transaction Utils', () => {
     describe('getInstructionsFromBase64Message', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/kora",
-  "version": "0.2.0-beta.3",
+  "version": "0.2.0-beta.6",
   "description": "TypeScript SDK for Kora RPC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -16,31 +16,42 @@
   ],
   "author": "",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/solana-foundation/kora",
+    "directory": "sdks/ts"
+  },
   "peerDependencies": {
-    "@solana-program/token": "^0.9.0",
-    "@solana/kit": "^5.0.0"
+    "@solana-program/compute-budget": "^0.15.0",
+    "@solana-program/token": "^0.12.0",
+    "@solana/kit": "^6.3.0",
+    "@solana/kit-plugin-instruction-plan": "^0.7.0",
+    "@solana/kit-plugin-payer": "^0.6.0",
+    "@solana/kit-plugin-rpc": "^0.7.0"
   },
   "devDependencies": {
-    "@solana-program/compute-budget": "^0.11.0",
-    "@solana-program/system": "^0.10.0",
-    "@solana-program/token": "^0.9.0",
-    "@solana/eslint-config-solana": "^6.0.0",
-    "@solana/kit": "^5.4.0",
+    "@eslint/js": "^9.39.3",
+    "@solana-program/system": "^0.12.0",
+    "@solana/eslint-config-solana": "6.0.0",
+    "@solana/kit-client-litesvm": "^0.7.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",
-    "@typescript-eslint/parser": "^8.38.0",
     "dotenv": "^16.4.5",
-    "eslint": "^9.31.0",
+    "eslint": "^9.39.3",
+    "eslint-plugin-jest": "^29.15.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-sort-keys-fix": "^1.1.2",
+    "eslint-plugin-typescript-sort-keys": "^3.3.0",
+    "globals": "^16.5.0",
     "jest": "^29.7.0",
     "prettier": "^3.2.5",
     "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.9",
     "typedoc-plugin-markdown": "^4.8.0",
-    "typescript": "^5.3.3",
-    "ws": "^8.18.3"
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1"
   },
   "scripts": {
     "build": "tsc",
@@ -50,13 +61,12 @@
     "test:coverage": "jest --coverage",
     "test:integration": "pnpm test integration.test.ts",
     "test:integration:auth": "ENABLE_AUTH=true pnpm test integration.test.ts",
+    "test:integration:free": "FREE_PRICING=true pnpm test integration.test.ts",
     "test:integration:privy": "KORA_SIGNER_TYPE=privy pnpm test integration.test.ts",
     "test:integration:turnkey": "KORA_SIGNER_TYPE=turnkey pnpm test integration.test.ts",
     "test:unit": "pnpm test unit.test.ts",
-    "test:ci:integration": "node scripts/test-with-validator.js",
-    "test:ci:integration:auth": "ENABLE_AUTH=true node scripts/test-with-validator.js",
     "test:ci:unit": "jest test/unit.test.ts",
-    "lint": "eslint src test",
+    "lint": "eslint src/",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
     "type-check": "tsc --noEmit",