@solana/kora 0.2.0-beta.6 → 0.2.1

package/dist/test/setup.js

@@ -1,24 +1,25 @@
-import { assertIsAddress, createKeyPairSignerFromBytes, getBase58Encoder, lamports, } from '@solana/kit';
-import { createClient } from '@solana/kit-client-litesvm';
-import { tokenProgram, associatedTokenProgram } from '@solana-program/token';
+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,
-    // 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',
+    TOKEN_DROP_AMOUNT: 100_000,
     KORA_RPC_URL: 'http://localhost:8080/',
-    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',
+    COMMITMENT: 'processed',
     SOL_DROP_AMOUNT: 1_000_000_000,
-    // HhA5j2rRiPbMrpF2ZD36r69FyZf3zWmEHRNSZbbNdVjf
-    TEST_USDC_MINT_SECRET: '59kKmXphL5UJANqpFFjtH17emEq3oRNmYsx6a3P3vSGJRmhMgVdzH77bkNEi9bArRViT45e8L2TsuPxKNFoc3Qfg',
-    TOKEN_DROP_AMOUNT: 100_000, // Default signer type
+    // 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();
@@ -50,6 +51,9 @@ 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);
@@ -59,15 +63,18 @@ export function loadEnvironmentVariables() {
     assertIsAddress(destinationAddress);
     assertIsAddress(koraAddress);
     return {
-        destinationAddress,
-        koraAddress,
         koraRpcUrl,
+        koraAddress,
         koraSignerType,
-        solDropAmount,
-        testUsdcMintSecret,
-        testWalletSecret,
+        commitment,
         tokenDecimals,
         tokenDropAmount,
+        solDropAmount,
+        solanaRpcUrl,
+        solanaWsUrl,
+        testWalletSecret,
+        testUsdcMintSecret,
+        destinationAddress,
     };
 }
 async function createKeyPairSigners() {
@@ -75,58 +82,151 @@ 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, tokenDecimals, tokenDropAmount, solDropAmount } = loadEnvironmentVariables();
+    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 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),
+    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,
-    })
-        .sendTransaction();
-    // Create ATAs for kora and destination wallets
-    for (const owner of [koraAddress, destinationAddress]) {
-        await client.associatedToken.instructions
-            .createAssociatedTokenIdempotent({
-            owner,
-            mint: usdcMint.address,
-        })
-            .sendTransaction();
-    }
+        otherAtaWallets: [testWallet.address, koraAddress, destinationAddress],
+    });
     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;