@solana/kora 0.0.0 → 0.1.1

package/dist/test/integration.test.js

@@ -0,0 +1,307 @@
+import setupTestSuite from './setup.js';
+import { runAuthenticationTests } from './auth-setup.js';
+import { generateKeyPairSigner, getBase64EncodedWireTransaction, getBase64Encoder, getTransactionDecoder, signTransaction, } from '@solana/kit';
+import { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+function transactionFromBase64(base64) {
+    const encoder = getBase64Encoder();
+    const decoder = getTransactionDecoder();
+    const messageBytes = encoder.encode(base64);
+    return decoder.decode(messageBytes);
+}
+const AUTH_ENABLED = process.env.ENABLE_AUTH === '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;
+    let testWallet;
+    let testWalletAddress;
+    let destinationAddress;
+    let usdcMint;
+    let koraAddress;
+    let koraRpcUrl;
+    beforeAll(async () => {
+        const testSuite = await setupTestSuite();
+        client = testSuite.koraClient;
+        testWallet = testSuite.testWallet;
+        testWalletAddress = testWallet.address;
+        destinationAddress = testSuite.destinationAddress;
+        usdcMint = testSuite.usdcMint;
+        koraAddress = testSuite.koraAddress;
+        koraRpcUrl = testSuite.koraRpcUrl;
+    }, 90000); // allow adequate time for airdrops and token initialization
+    // Run authentication tests only when auth is enabled
+    if (AUTH_ENABLED) {
+        runAuthenticationTests();
+    }
+    describe('Configuration and Setup', () => {
+        it('should get config', async () => {
+            const config = await client.getConfig();
+            expect(config).toBeDefined();
+            expect(config.fee_payers).toBeDefined();
+            expect(Array.isArray(config.fee_payers)).toBe(true);
+            expect(config.fee_payers.length).toBeGreaterThan(0);
+            expect(config.validation_config).toBeDefined();
+            expect(config.validation_config.allowed_programs).toBeDefined();
+            expect(config.validation_config.allowed_tokens).toBeDefined();
+            expect(config.validation_config.max_allowed_lamports).toBeDefined();
+            expect(config.validation_config.max_signatures).toBeDefined();
+            expect(config.validation_config.price_source).toBeDefined();
+            expect(config.validation_config.price).toBeDefined();
+            expect(config.validation_config.price.type).toBeDefined();
+            expect(config.validation_config.fee_payer_policy).toBeDefined();
+            // System policy
+            expect(config.validation_config.fee_payer_policy.system).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.system.allow_transfer).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.system.allow_assign).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.system.allow_create_account).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.system.allow_allocate).toBeDefined();
+            // System nonce policy
+            expect(config.validation_config.fee_payer_policy.system.nonce).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.system.nonce.allow_initialize).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.system.nonce.allow_advance).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.system.nonce.allow_authorize).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.system.nonce.allow_withdraw).toBeDefined();
+            // SPL token policy
+            expect(config.validation_config.fee_payer_policy.spl_token).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.spl_token.allow_transfer).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.spl_token.allow_burn).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.spl_token.allow_close_account).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.spl_token.allow_approve).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.spl_token.allow_revoke).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.spl_token.allow_set_authority).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.spl_token.allow_mint_to).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.spl_token.allow_freeze_account).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.spl_token.allow_thaw_account).toBeDefined();
+            // Token2022 policy
+            expect(config.validation_config.fee_payer_policy.token_2022).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.token_2022.allow_transfer).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.token_2022.allow_burn).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.token_2022.allow_close_account).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.token_2022.allow_approve).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.token_2022.allow_revoke).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.token_2022.allow_set_authority).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.token_2022.allow_mint_to).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.token_2022.allow_freeze_account).toBeDefined();
+            expect(config.validation_config.fee_payer_policy.token_2022.allow_thaw_account).toBeDefined();
+            expect(config.enabled_methods).toBeDefined();
+            expect(config.enabled_methods.liveness).toBeDefined();
+            expect(config.enabled_methods.estimate_transaction_fee).toBeDefined();
+            expect(config.enabled_methods.get_supported_tokens).toBeDefined();
+            expect(config.enabled_methods.sign_transaction).toBeDefined();
+            expect(config.enabled_methods.sign_and_send_transaction).toBeDefined();
+            expect(config.enabled_methods.transfer_transaction).toBeDefined();
+            expect(config.enabled_methods.get_blockhash).toBeDefined();
+            expect(config.enabled_methods.get_config).toBeDefined();
+        });
+        it('should get payer signer', async () => {
+            const { signer_address, payment_address } = await client.getPayerSigner();
+            expect(signer_address).toBeDefined();
+            expect(payment_address).toBeDefined();
+        });
+        it('should get supported tokens', async () => {
+            const { tokens } = await client.getSupportedTokens();
+            expect(Array.isArray(tokens)).toBe(true);
+            expect(tokens.length).toBeGreaterThan(0);
+            expect(tokens).toContain(usdcMint); // USDC should be supported
+        });
+        it('should get blockhash', async () => {
+            const { blockhash } = await client.getBlockhash();
+            expect(blockhash).toBeDefined();
+            expect(typeof blockhash).toBe('string');
+            expect(blockhash.length).toBeGreaterThanOrEqual(43);
+            expect(blockhash.length).toBeLessThanOrEqual(44); // Base58 encoded hash length
+        });
+    });
+    describe('Transaction Operations', () => {
+        it('should create transfer transaction', async () => {
+            const request = {
+                amount: 1000000, // 1 USDC
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: destinationAddress,
+            };
+            const response = await client.transferTransaction(request);
+            expect(response).toBeDefined();
+            expect(response.transaction).toBeDefined();
+            expect(response.blockhash).toBeDefined();
+            expect(response.message).toBeDefined();
+            expect(response.instructions).toBeDefined();
+            // since setup created ATA for destination, we should not expect ata instruction, only transfer instruction
+            expect(response.instructions?.length).toBe(1);
+            expect(response.instructions?.[0].programAddress).toBe(TOKEN_PROGRAM_ADDRESS);
+        });
+        it('should create transfer transaction to address with no ATA', async () => {
+            const randomDestination = await generateKeyPairSigner();
+            const request = {
+                amount: 1000000, // 1 USDC
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: randomDestination.address,
+            };
+            const response = await client.transferTransaction(request);
+            expect(response).toBeDefined();
+            expect(response.transaction).toBeDefined();
+            expect(response.blockhash).toBeDefined();
+            expect(response.message).toBeDefined();
+            expect(response.instructions).toBeDefined();
+            // since setup created ATA for destination, we should not expect ata instruction, only transfer instruction
+            expect(response.instructions?.length).toBe(2);
+            expect(response.instructions?.[0].programAddress).toBe(ASSOCIATED_TOKEN_PROGRAM_ADDRESS);
+            expect(response.instructions?.[1].programAddress).toBe(TOKEN_PROGRAM_ADDRESS);
+        });
+        it('should estimate transaction fee', async () => {
+            // First create a transaction
+            const transferRequest = {
+                amount: 1000000,
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: testWalletAddress,
+            };
+            const { transaction } = await client.transferTransaction(transferRequest);
+            const fee = await client.estimateTransactionFee({ transaction, fee_token: usdcMint });
+            expect(fee).toBeDefined();
+            expect(typeof fee.fee_in_lamports).toBe('number');
+            expect(fee.fee_in_lamports).toBeGreaterThan(0);
+            expect(typeof fee.fee_in_token).toBe('number');
+            expect(fee.fee_in_token).toBeGreaterThan(0);
+        });
+        it('should sign transaction', async () => {
+            const config = await client.getConfig();
+            const paymentAddress = config.fee_payers[0];
+            const transferRequest = {
+                amount: 1000000,
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: paymentAddress,
+            };
+            const { transaction } = await client.transferTransaction(transferRequest);
+            const signResult = await client.signTransaction({
+                transaction,
+            });
+            expect(signResult).toBeDefined();
+            expect(signResult.signed_transaction).toBeDefined();
+        });
+        it('should sign and send transaction', async () => {
+            const config = await client.getConfig();
+            const paymentAddress = config.fee_payers[0];
+            const transferRequest = {
+                amount: 1000000,
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: paymentAddress,
+            };
+            const { transaction: transactionString } = await client.transferTransaction(transferRequest);
+            const transaction = transactionFromBase64(transactionString);
+            // Sign transaction with test wallet before sending
+            const signedTransaction = await signTransaction([testWallet.keyPair], transaction);
+            const base64SignedTransaction = getBase64EncodedWireTransaction(signedTransaction);
+            const signResult = await client.signAndSendTransaction({
+                transaction: base64SignedTransaction,
+            });
+            expect(signResult).toBeDefined();
+            expect(signResult.signed_transaction).toBeDefined();
+        });
+        it('should get payment instruction', async () => {
+            const transferRequest = {
+                amount: 1000000,
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: destinationAddress,
+            };
+            const [expectedSenderAta] = await findAssociatedTokenPda({
+                owner: testWalletAddress,
+                tokenProgram: TOKEN_PROGRAM_ADDRESS,
+                mint: usdcMint,
+            });
+            const [koraAta] = await findAssociatedTokenPda({
+                owner: koraAddress,
+                tokenProgram: TOKEN_PROGRAM_ADDRESS,
+                mint: usdcMint,
+            });
+            const { transaction } = await client.transferTransaction(transferRequest);
+            const { payment_instruction, payment_amount, payment_token, payment_address, signer_address, original_transaction, } = await client.getPaymentInstruction({
+                transaction,
+                fee_token: usdcMint,
+                source_wallet: testWalletAddress,
+            });
+            expect(payment_instruction).toBeDefined();
+            expect(payment_instruction.programAddress).toBe(TOKEN_PROGRAM_ADDRESS);
+            expect(payment_instruction.accounts?.[0].address).toBe(expectedSenderAta);
+            expect(payment_instruction.accounts?.[1].address).toBe(koraAta);
+            expect(payment_instruction.accounts?.[2].address).toBe(testWalletAddress);
+            // todo math to verify payment amount
+            // expect(payment_amount).toBe(1000000);
+            expect(payment_token).toBe(usdcMint);
+            expect(payment_address).toBe(koraAddress);
+            expect(signer_address).toBe(koraAddress);
+            expect(original_transaction).toBe(transaction);
+        });
+    });
+    describe('Error Handling', () => {
+        it('should handle invalid token address', async () => {
+            const request = {
+                amount: 1000000,
+                token: 'InvalidTokenAddress',
+                source: testWalletAddress,
+                destination: destinationAddress,
+            };
+            await expect(client.transferTransaction(request)).rejects.toThrow();
+        });
+        it('should handle invalid amount', async () => {
+            const request = {
+                amount: -1, // Invalid amount
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: destinationAddress,
+            };
+            await expect(client.transferTransaction(request)).rejects.toThrow();
+        });
+        it('should handle invalid transaction for signing', async () => {
+            await expect(client.signTransaction({
+                transaction: 'invalid_transaction',
+            })).rejects.toThrow();
+        });
+        it('should handle invalid transaction for fee estimation', async () => {
+            await expect(client.estimateTransactionFee({ transaction: 'invalid_transaction', fee_token: usdcMint })).rejects.toThrow();
+        });
+        it('should handle non-allowed token for fee payment', async () => {
+            const transferRequest = {
+                amount: 1000000,
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: destinationAddress,
+            };
+            // TODO: API has an error. this endpoint should verify the provided fee token is supported
+            const { transaction } = await client.transferTransaction(transferRequest);
+            const fee = await client.estimateTransactionFee({ transaction, fee_token: usdcMint });
+            expect(fee).toBeDefined();
+            expect(typeof fee.fee_in_lamports).toBe('number');
+            expect(fee.fee_in_lamports).toBeGreaterThan(0);
+        });
+    });
+    describe('End-to-End Flows', () => {
+        it('should handle transfer and sign flow', async () => {
+            const config = await client.getConfig();
+            const paymentAddress = config.fee_payers[0];
+            const request = {
+                amount: 1000000,
+                token: usdcMint,
+                source: testWalletAddress,
+                destination: paymentAddress,
+            };
+            // Create and sign the transaction
+            const { transaction } = await client.transferTransaction(request);
+            const signResult = await client.signTransaction({ transaction });
+            expect(signResult.signed_transaction).toBeDefined();
+        });
+        it('should reject transaction with non-allowed token', async () => {
+            const invalidTokenMint = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'; // Mainnet USDC mint
+            const request = {
+                amount: 1000000,
+                token: invalidTokenMint,
+                source: testWalletAddress,
+                destination: destinationAddress,
+            };
+            await expect(client.transferTransaction(request)).rejects.toThrow();
+        });
+    });
+});

package/dist/test/setup.d.ts

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

package/dist/test/setup.js

@@ -0,0 +1,231 @@
+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, 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';
+import { KoraClient } from '../src/index.js';
+config({ path: path.resolve(process.cwd(), '.env') });
+const DEFAULTS = {
+    DECIMALS: 6,
+    TOKEN_DROP_AMOUNT: 100_000,
+    KORA_RPC_URL: 'http://localhost:8080/',
+    SOLANA_RPC_URL: 'http://127.0.0.1:8899',
+    SOLANA_WS_URL: 'ws://127.0.0.1:8900',
+    COMMITMENT: 'processed',
+    SOL_DROP_AMOUNT: 1_000_000_000,
+    // DO NOT USE THESE KEYPAIRS IN PRODUCTION, TESTING KEYPAIRS ONLY
+    KORA_ADDRESS: '7AqpcUvgJ7Kh1VmJZ44rWp2XDow33vswo9VK9VqpPU2d', // Make sure this matches the kora-rpc signer address on launch (root .env)
+    SENDER_SECRET: 'tzgfgSWTE3KUA6qfRoFYLaSfJm59uUeZRDy4ybMrLn1JV2drA1mftiaEcVFvq1Lok6h6EX2C4Y9kSKLvQWyMpS5', // HhA5j2rRiPbMrpF2ZD36r69FyZf3zWmEHRNSZbbNdVjf
+    TEST_USDC_MINT_SECRET: '59kKmXphL5UJANqpFFjtH17emEq3oRNmYsx6a3P3vSGJRmhMgVdzH77bkNEi9bArRViT45e8L2TsuPxKNFoc3Qfg', // Make sure this matches the USDC mint in kora.toml (9BgeTKqmFsPVnfYscfM6NvsgmZxei7XfdciShQ6D3bxJ)
+    DESTINATION_ADDRESS: 'AVmDft8deQEo78bRKcGN5ZMf3hyjeLBK4Rd4xGB46yQM',
+    KORA_SIGNER_TYPE: 'memory', // Default signer type
+};
+const createKeyPairSignerFromB58Secret = async (b58Secret) => {
+    const base58Encoder = getBase58Encoder();
+    const b58SecretEncoded = base58Encoder.encode(b58Secret);
+    return await createKeyPairSignerFromBytes(b58SecretEncoded);
+};
+// TODO Add KORA_PRIVATE_KEY_2= support for multi-signer configs
+export function loadEnvironmentVariables() {
+    const koraSignerType = process.env.KORA_SIGNER_TYPE || DEFAULTS.KORA_SIGNER_TYPE;
+    let koraAddress = process.env.KORA_ADDRESS;
+    if (!koraAddress) {
+        switch (koraSignerType) {
+            case 'turnkey':
+                koraAddress = process.env.TURNKEY_PUBLIC_KEY;
+                if (!koraAddress) {
+                    throw new Error('TURNKEY_PUBLIC_KEY must be set when using Turnkey signer');
+                }
+                break;
+            case 'privy':
+                koraAddress = process.env.PRIVY_PUBLIC_KEY;
+                if (!koraAddress) {
+                    throw new Error('PRIVY_PUBLIC_KEY must be set when using Privy signer');
+                }
+                break;
+            case 'memory':
+            default:
+                koraAddress = DEFAULTS.KORA_ADDRESS;
+                break;
+        }
+    }
+    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);
+    const testWalletSecret = process.env.SENDER_SECRET || DEFAULTS.SENDER_SECRET;
+    const testUsdcMintSecret = process.env.TEST_USDC_MINT_SECRET || DEFAULTS.TEST_USDC_MINT_SECRET;
+    const destinationAddress = process.env.DESTINATION_ADDRESS || DEFAULTS.DESTINATION_ADDRESS;
+    assertIsAddress(destinationAddress);
+    assertIsAddress(koraAddress);
+    return {
+        koraRpcUrl,
+        koraAddress,
+        koraSignerType,
+        commitment,
+        tokenDecimals,
+        tokenDropAmount,
+        solDropAmount,
+        solanaRpcUrl,
+        solanaWsUrl,
+        testWalletSecret,
+        testUsdcMintSecret,
+        destinationAddress,
+    };
+}
+async function createKeyPairSigners() {
+    const { testWalletSecret, testUsdcMintSecret, destinationAddress } = loadEnvironmentVariables();
+    const testWallet = await createKeyPairSignerFromB58Secret(testWalletSecret);
+    const usdcMint = await createKeyPairSignerFromB58Secret(testUsdcMintSecret);
+    return {
+        testWallet,
+        usdcMint,
+        destinationAddress,
+    };
+}
+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({
+            payer,
+            newAccount: mint,
+            lamports: mintRent,
+            space: mintSpace,
+            programAddress: TOKEN_PROGRAM_ADDRESS,
+        }),
+        // Initialize the Mint
+        getInitializeMintInstruction({
+            mint: mint.address,
+            decimals,
+            mintAuthority: mintAuthority.address,
+        }),
+        // Create Associated Token Account
+        await getCreateAssociatedTokenIdempotentInstructionAsync({
+            mint: mint.address,
+            payer,
+            owner: owner.address,
+        }),
+        // Mint To the Destination Associated Token Account
+        getMintToInstruction({
+            mint: mint.address,
+            token: ata,
+            amount: BigInt(dropAmount * 10 ** decimals),
+            mintAuthority,
+        }),
+    ];
+    // 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,
+            payer,
+            owner: wallet,
+        })))
+        : [];
+    const alreadyExists = await mintExists(client, mint.address);
+    let instructions = alreadyExists ? [...otherAtaInstructions] : [...baseInstructions, ...otherAtaInstructions];
+    await sendAndConfirmInstructions(client, payer, instructions, 'Initialize token and ATAs', 'finalized');
+}
+async function setupTestSuite() {
+    const { koraAddress, koraRpcUrl, commitment, tokenDecimals, tokenDropAmount, solDropAmount, solanaRpcUrl, solanaWsUrl, } = await loadEnvironmentVariables();
+    // Load auth config from environment if not provided
+    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,
+        mintAuthority,
+        payer: mintAuthority,
+        owner: testWallet,
+        mint: usdcMint,
+        dropAmount: tokenDropAmount,
+        decimals: tokenDecimals,
+        otherAtaWallets: [testWallet.address, koraAddress, destinationAddress],
+    });
+    return {
+        koraClient: new KoraClient({ rpcUrl: koraRpcUrl, ...authConfig }),
+        koraRpcUrl,
+        testWallet,
+        usdcMint: usdcMint.address,
+        destinationAddress,
+        koraAddress,
+    };
+}
+const mintExists = async (client, mint) => {
+    try {
+        const mintAccount = await client.rpc.getAccountInfo(mint).send();
+        return mintAccount.value !== null;
+    }
+    catch (error) {
+        return false;
+    }
+};
+export default setupTestSuite;

package/dist/test/unit.test.d.ts

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