@solana/kora 0.2.0 → 0.3.0-beta.0

package/dist/test/setup.js

@@ -1,25 +1,24 @@
-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 { 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 = {
     DECIMALS: 6,
-    TOKEN_DROP_AMOUNT: 100_000,
+    // Make sure this matches the USDC mint in kora.toml (9BgeTKqmFsPVnfYscfM6NvsgmZxei7XfdciShQ6D3bxJ)
+    DESTINATION_ADDRESS: 'AVmDft8deQEo78bRKcGN5ZMf3hyjeLBK4Rd4xGB46yQM',
+    // DO NOT USE THESE KEYPAIRS IN PRODUCTION, TESTING KEYPAIRS ONLY
+    KORA_ADDRESS: '7AqpcUvgJ7Kh1VmJZ44rWp2XDow33vswo9VK9VqpPU2d',
     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',
+    KORA_SIGNER_TYPE: 'memory',
+    // Make sure this matches the kora-rpc signer address on launch (root .env)
+    SENDER_SECRET: 'tzgfgSWTE3KUA6qfRoFYLaSfJm59uUeZRDy4ybMrLn1JV2drA1mftiaEcVFvq1Lok6h6EX2C4Y9kSKLvQWyMpS5',
     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
+    // HhA5j2rRiPbMrpF2ZD36r69FyZf3zWmEHRNSZbbNdVjf
+    TEST_USDC_MINT_SECRET: '59kKmXphL5UJANqpFFjtH17emEq3oRNmYsx6a3P3vSGJRmhMgVdzH77bkNEi9bArRViT45e8L2TsuPxKNFoc3Qfg',
+    TOKEN_DROP_AMOUNT: 100_000, // Default signer type
 };
 const createKeyPairSignerFromB58Secret = async (b58Secret) => {
     const base58Encoder = getBase58Encoder();
@@ -51,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);
@@ -63,18 +59,15 @@ export function loadEnvironmentVariables() {
     assertIsAddress(destinationAddress);
     assertIsAddress(koraAddress);
     return {
-        koraRpcUrl,
+        destinationAddress,
         koraAddress,
+        koraRpcUrl,
         koraSignerType,
-        commitment,
-        tokenDecimals,
-        tokenDropAmount,
         solDropAmount,
-        solanaRpcUrl,
-        solanaWsUrl,
-        testWalletSecret,
         testUsdcMintSecret,
-        destinationAddress,
+        testWalletSecret,
+        tokenDecimals,
+        tokenDropAmount,
     };
 }
 async function createKeyPairSigners() {
@@ -82,151 +75,58 @@ async function createKeyPairSigners() {
     const testWallet = await createKeyPairSignerFromB58Secret(testWalletSecret);
     const usdcMint = await createKeyPairSignerFromB58Secret(testUsdcMintSecret);
     return {
+        destinationAddress,
         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 { 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,
-        mintAuthority,
-        payer: mintAuthority,
-        owner: testWallet,
-        mint: usdcMint,
-        dropAmount: tokenDropAmount,
+    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,
-        otherAtaWallets: [testWallet.address, koraAddress, destinationAddress],
-    });
+    })
+        .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,
         koraClient: new KoraClient({ rpcUrl: koraRpcUrl, ...authConfig }),
         koraRpcUrl,
         testWallet,
         usdcMint: usdcMint.address,
-        destinationAddress,
-        koraAddress,
-        authConfig,
     };
 }
-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;