@zoidz123/raydium-cli 0.1.0

package/dist/commands/pools/index.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPoolCommands = registerPoolCommands;
+const raydium_sdk_v2_1 = require("@raydium-io/raydium-sdk-v2");
+const raydium_client_1 = require("../../lib/raydium-client");
+const output_1 = require("../../lib/output");
+function mapPoolType(type) {
+    switch (type) {
+        case "standard":
+            return raydium_sdk_v2_1.PoolFetchType.Standard;
+        case "concentrated":
+            return raydium_sdk_v2_1.PoolFetchType.Concentrated;
+        case "all":
+        default:
+            return raydium_sdk_v2_1.PoolFetchType.All;
+    }
+}
+function registerPoolCommands(program) {
+    const pools = program.command("pools").description("Pool utilities");
+    pools
+        .command("list")
+        .description("List pools")
+        .option("--type <type>", "all|standard|concentrated", "all")
+        .option("--mint-a <mint>", "Filter by mint A")
+        .option("--mint-b <mint>", "Filter by mint B")
+        .option("--limit <number>", "Limit results", "100")
+        .option("--page <number>", "Page number", "1")
+        .action(async (options) => {
+        const limit = Number(options.limit);
+        const page = Number(options.page);
+        const raydium = await (0, output_1.withSpinner)("Fetching pools", () => (0, raydium_client_1.loadRaydium)({ disableLoadToken: true }));
+        const poolType = mapPoolType(options.type);
+        let data;
+        let outputPage = Number.isFinite(page) ? page : undefined;
+        if (options.mintA || options.mintB) {
+            const mintA = options.mintA ?? options.mintB;
+            const mintB = options.mintA ? options.mintB : undefined;
+            const mintPage = Number.isFinite(page) && page > 0 ? page : 1;
+            outputPage = mintPage;
+            data = await raydium.api.fetchPoolByMints({
+                mint1: mintA,
+                mint2: mintB,
+                type: poolType,
+                page: mintPage
+            });
+        }
+        else {
+            const listPage = Number.isFinite(page) && page > 0 ? page : 1;
+            outputPage = listPage;
+            data = await raydium.api.getPoolList({
+                type: poolType,
+                page: listPage,
+                pageSize: Number.isFinite(limit) ? limit : 100
+            });
+        }
+        const poolsList = data.data ?? [];
+        const results = Number.isFinite(limit) ? poolsList.slice(0, limit) : poolsList;
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({
+                pools: results,
+                page: outputPage,
+                count: data.count,
+                hasNextPage: data.hasNextPage
+            });
+            return;
+        }
+        if (results.length === 0) {
+            (0, output_1.logInfo)("No pools found");
+            return;
+        }
+        (0, output_1.logInfo)(`Showing ${results.length} pools (page ${outputPage}, total: ${data.count})\n`);
+        results.forEach((pool) => {
+            (0, output_1.logInfo)(`${pool.id} (${pool.type})`);
+            (0, output_1.logInfo)(`  mintA: ${pool.mintA.address}`);
+            (0, output_1.logInfo)(`  mintB: ${pool.mintB.address}`);
+            if ("lpMint" in pool && pool.lpMint) {
+                (0, output_1.logInfo)(`  lpMint: ${pool.lpMint.address}`);
+            }
+        });
+    });
+}

package/dist/commands/swap/index.js

@@ -0,0 +1,490 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSwapCommands = registerSwapCommands;
+const node_util_1 = require("node:util");
+const web3_js_1 = require("@solana/web3.js");
+const raydium_sdk_v2_1 = require("@raydium-io/raydium-sdk-v2");
+const spl_token_1 = require("@solana/spl-token");
+const config_manager_1 = require("../../lib/config-manager");
+const wallet_manager_1 = require("../../lib/wallet-manager");
+const prompt_1 = require("../../lib/prompt");
+const output_1 = require("../../lib/output");
+const raydium_client_1 = require("../../lib/raydium-client");
+const connection_1 = require("../../lib/connection");
+const WRAPPED_SOL_MINT = "So11111111111111111111111111111111111111112";
+const VALID_AMM_PROGRAM_IDS = new Set([
+    raydium_sdk_v2_1.AMM_V4.toBase58(),
+    raydium_sdk_v2_1.AMM_STABLE.toBase58(),
+    raydium_sdk_v2_1.DEVNET_PROGRAM_ID.AMM_V4.toBase58(),
+    raydium_sdk_v2_1.DEVNET_PROGRAM_ID.AMM_STABLE.toBase58()
+]);
+function buildTokenFromInfo(info) {
+    const isToken2022 = info.programId === spl_token_1.TOKEN_2022_PROGRAM_ID.toBase58();
+    return new raydium_sdk_v2_1.Token({
+        mint: info.address,
+        decimals: info.decimals,
+        symbol: info.symbol,
+        name: info.name,
+        isToken2022
+    });
+}
+// Trade API functions
+const TRADE_API_HOST = "https://transaction-v1.raydium.io";
+async function fetchTradeQuote(params) {
+    const url = `${TRADE_API_HOST}/compute/swap-base-in?inputMint=${params.inputMint}&outputMint=${params.outputMint}&amount=${params.amount}&slippageBps=${params.slippageBps}&txVersion=V0`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Trade API error: HTTP ${res.status} - ${text}`);
+    }
+    const json = await res.json();
+    if (!json.success) {
+        const errDetail = json.msg || json.message || json.error || JSON.stringify(json);
+        throw new Error(`Trade API quote failed: ${errDetail}`);
+    }
+    return json;
+}
+async function serializeSwapTx(params) {
+    const res = await fetch(`${TRADE_API_HOST}/transaction/swap-base-in`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            swapResponse: params.swapResponse,
+            wallet: params.wallet,
+            txVersion: "V0",
+            wrapSol: params.wrapSol,
+            unwrapSol: params.unwrapSol,
+            inputAccount: params.inputAccount,
+            outputAccount: params.outputAccount,
+            computeUnitPriceMicroLamports: String(params.computeUnitPriceMicroLamports)
+        })
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Trade API serialize error: HTTP ${res.status} - ${text}`);
+    }
+    const json = await res.json();
+    if (!json.success) {
+        const errDetail = json.msg || json.message || json.error || JSON.stringify(json);
+        throw new Error(`Trade API serialize failed: ${errDetail}`);
+    }
+    return json;
+}
+async function getTokenDecimals(mint) {
+    if (mint === WRAPPED_SOL_MINT)
+        return 9;
+    const connection = await (0, connection_1.getConnection)();
+    const info = await connection.getParsedAccountInfo(new web3_js_1.PublicKey(mint));
+    if (!info.value || !("parsed" in info.value.data)) {
+        throw new Error(`Could not fetch mint info for ${mint}`);
+    }
+    return info.value.data.parsed.info.decimals;
+}
+function registerSwapCommands(program) {
+    // Trade API swap (auto-routing)
+    const tradeApiSwap = async (options) => {
+        const inputMintStr = options.inputMint;
+        const outputMintStr = options.outputMint;
+        // Get input token decimals and convert amount to lamports
+        const inputDecimals = await (0, output_1.withSpinner)("Fetching token info", () => getTokenDecimals(inputMintStr));
+        const amountLamports = BigInt(Math.floor(Number(options.amount) * 10 ** inputDecimals));
+        // Fetch quote from Trade API
+        const slippageBps = Math.round(options.slippage * 10000);
+        let quote;
+        try {
+            quote = await (0, output_1.withSpinner)("Fetching swap quote", () => fetchTradeQuote({
+                inputMint: inputMintStr,
+                outputMint: outputMintStr,
+                amount: amountLamports.toString(),
+                slippageBps
+            }));
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            (0, output_1.logError)("Failed to fetch quote", msg);
+            process.exitCode = 1;
+            return;
+        }
+        // Get output token decimals for display
+        const outputDecimals = await getTokenDecimals(outputMintStr);
+        const estimatedOutput = Number(quote.data.outputAmount) / 10 ** outputDecimals;
+        const minimumOutput = Number(quote.data.otherAmountThreshold) / 10 ** outputDecimals;
+        // Format route display
+        const routeDisplay = quote.data.routePlan.length > 1
+            ? `${quote.data.routePlan.length}-hop via ${quote.data.routePlan.map(r => r.poolId.slice(0, 4) + "..." + r.poolId.slice(-3)).join(" -> ")}`
+            : `Direct via ${quote.data.routePlan[0]?.poolId.slice(0, 4)}...${quote.data.routePlan[0]?.poolId.slice(-3)}`;
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({
+                route: quote.data.routePlan.map(r => r.poolId),
+                input: { amount: options.amount, mint: inputMintStr },
+                output: {
+                    estimated: estimatedOutput.toString(),
+                    minimum: minimumOutput.toString(),
+                    mint: outputMintStr
+                },
+                priceImpactPct: quote.data.priceImpactPct,
+                slippage: options.slippage
+            });
+        }
+        else {
+            (0, output_1.logInfo)(`Route: ${routeDisplay}`);
+            (0, output_1.logInfo)(`Input: ${options.amount} (${inputMintStr.slice(0, 6)}...)`);
+            (0, output_1.logInfo)(`Estimated output: ${estimatedOutput.toFixed(6)} (${outputMintStr.slice(0, 6)}...)`);
+            (0, output_1.logInfo)(`Minimum output: ${minimumOutput.toFixed(6)}`);
+            (0, output_1.logInfo)(`Price impact: ${quote.data.priceImpactPct.toFixed(2)}%`);
+            (0, output_1.logInfo)(`Slippage: ${options.slippagePercent}%`);
+        }
+        const ok = await (0, prompt_1.promptConfirm)("Proceed with swap?", false);
+        if (!ok) {
+            (0, output_1.logInfo)("Cancelled");
+            return;
+        }
+        // Serialize transaction
+        const inputIsSol = inputMintStr === WRAPPED_SOL_MINT;
+        const outputIsSol = outputMintStr === WRAPPED_SOL_MINT;
+        // Get token accounts (ATAs) for non-SOL tokens
+        const inputAccount = inputIsSol
+            ? undefined
+            : (0, spl_token_1.getAssociatedTokenAddressSync)(new web3_js_1.PublicKey(inputMintStr), options.owner.publicKey).toBase58();
+        const outputAccount = outputIsSol
+            ? undefined
+            : (0, spl_token_1.getAssociatedTokenAddressSync)(new web3_js_1.PublicKey(outputMintStr), options.owner.publicKey).toBase58();
+        let txResponse;
+        try {
+            txResponse = await (0, output_1.withSpinner)("Building swap transaction", () => serializeSwapTx({
+                swapResponse: quote,
+                wallet: options.owner.publicKey.toBase58(),
+                wrapSol: inputIsSol,
+                unwrapSol: outputIsSol,
+                inputAccount,
+                outputAccount,
+                computeUnitPriceMicroLamports: options.priorityFeeMicroLamports
+            }));
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            (0, output_1.logError)("Failed to build transaction", msg);
+            process.exitCode = 1;
+            return;
+        }
+        // Sign and send transactions
+        const connection = await (0, connection_1.getConnection)();
+        const txIds = [];
+        try {
+            for (const txData of txResponse.data) {
+                const txBuf = Buffer.from(txData.transaction, "base64");
+                const tx = web3_js_1.VersionedTransaction.deserialize(txBuf);
+                tx.sign([options.owner]);
+                const txId = await (0, output_1.withSpinner)("Sending transaction", async () => {
+                    const sig = await connection.sendRawTransaction(tx.serialize(), {
+                        skipPreflight: false,
+                        preflightCommitment: "confirmed"
+                    });
+                    await connection.confirmTransaction(sig, "confirmed");
+                    return sig;
+                });
+                txIds.push(txId);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error ?? "Swap failed");
+            if (options.debug) {
+                const detail = error instanceof Error ? error.stack ?? message : (0, node_util_1.inspect)(error, { depth: 6 });
+                (0, output_1.logError)("Swap failed", detail);
+                const logs = error?.logs;
+                if (logs?.length) {
+                    console.error(logs.join("\n"));
+                }
+            }
+            else {
+                (0, output_1.logError)("Swap failed", message);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({ txIds });
+        }
+        else {
+            for (const txId of txIds) {
+                (0, output_1.logSuccess)(`Swap submitted: ${txId}`);
+            }
+        }
+    };
+    // Direct AMM swap (existing logic)
+    const directAmmSwap = async (options) => {
+        let poolId;
+        let inputMint;
+        let outputMint;
+        try {
+            poolId = new web3_js_1.PublicKey(options.poolId).toBase58();
+            inputMint = new web3_js_1.PublicKey(options.inputMint);
+            outputMint = options.outputMint ? new web3_js_1.PublicKey(options.outputMint) : undefined;
+        }
+        catch {
+            (0, output_1.logError)("Invalid pool or mint address");
+            process.exitCode = 1;
+            return;
+        }
+        const raydium = await (0, output_1.withSpinner)("Loading Raydium", () => (0, raydium_client_1.loadRaydium)({ owner: options.owner, disableLoadToken: true }));
+        let poolInfo;
+        let poolKeys;
+        let rpcData;
+        if (raydium.cluster === "mainnet") {
+            try {
+                const data = await (0, output_1.withSpinner)("Fetching pool info", async () => {
+                    const apiData = await raydium.api.fetchPoolById({ ids: poolId });
+                    const info = apiData[0];
+                    if (!info)
+                        throw new Error("Pool not found");
+                    if (!VALID_AMM_PROGRAM_IDS.has(info.programId))
+                        throw new Error("Pool is not a standard AMM pool");
+                    const keys = await raydium.liquidity.getAmmPoolKeys(poolId);
+                    const rpc = await raydium.liquidity.getRpcPoolInfo(poolId);
+                    return { info, keys, rpc };
+                });
+                poolInfo = data.info;
+                poolKeys = data.keys;
+                rpcData = data.rpc;
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                (0, output_1.logError)("Failed to fetch pool info", msg);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        else {
+            const data = await (0, output_1.withSpinner)("Fetching pool info", () => raydium.liquidity.getPoolInfoFromRpc({ poolId }));
+            if (!data.poolInfo) {
+                (0, output_1.logError)("Pool not found");
+                process.exitCode = 1;
+                return;
+            }
+            if (!VALID_AMM_PROGRAM_IDS.has(data.poolInfo.programId)) {
+                (0, output_1.logError)("Pool is not a standard AMM pool");
+                process.exitCode = 1;
+                return;
+            }
+            poolInfo = data.poolInfo;
+            poolKeys = data.poolKeys;
+            rpcData = data.poolRpcData;
+        }
+        const mintA = poolInfo.mintA;
+        const mintB = poolInfo.mintB;
+        const mintAAddress = mintA.address;
+        const mintBAddress = mintB.address;
+        const inputMintStr = inputMint.toBase58();
+        if (inputMintStr !== mintAAddress && inputMintStr !== mintBAddress) {
+            (0, output_1.logError)("Input mint does not match pool mints");
+            process.exitCode = 1;
+            return;
+        }
+        const derivedOutputMint = inputMintStr === mintAAddress ? mintBAddress : mintAAddress;
+        const outputMintStr = outputMint ? outputMint.toBase58() : derivedOutputMint;
+        if (outputMintStr !== derivedOutputMint) {
+            (0, output_1.logError)("Output mint does not match pool mints");
+            process.exitCode = 1;
+            return;
+        }
+        const inputTokenInfo = inputMintStr === mintAAddress ? mintA : mintB;
+        const outputTokenInfo = inputMintStr === mintAAddress ? mintB : mintA;
+        const inputToken = buildTokenFromInfo(inputTokenInfo);
+        const inputTokenAmount = new raydium_sdk_v2_1.TokenAmount(inputToken, options.amount, false);
+        const computeOut = raydium.liquidity.computeAmountOut({
+            poolInfo: {
+                ...poolInfo,
+                baseReserve: rpcData.baseReserve,
+                quoteReserve: rpcData.quoteReserve,
+                status: rpcData.status.toNumber(),
+                version: 4
+            },
+            amountIn: inputTokenAmount.raw,
+            mintIn: inputMintStr,
+            mintOut: outputMintStr,
+            slippage: options.slippage
+        });
+        const outputToken = buildTokenFromInfo(outputTokenInfo);
+        const estimatedOut = new raydium_sdk_v2_1.TokenAmount(outputToken, computeOut.amountOut, true);
+        const minOut = new raydium_sdk_v2_1.TokenAmount(outputToken, computeOut.minAmountOut, true);
+        const outSymbol = outputTokenInfo.symbol || outputTokenInfo.name || outputTokenInfo.address.slice(0, 6);
+        const inSymbol = inputTokenInfo.symbol || inputTokenInfo.name || inputTokenInfo.address.slice(0, 6);
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({
+                poolId,
+                input: { amount: options.amount, symbol: inSymbol, mint: inputTokenInfo.address },
+                output: {
+                    estimated: estimatedOut.toExact(),
+                    minimum: minOut.toExact(),
+                    symbol: outSymbol,
+                    mint: outputTokenInfo.address
+                },
+                slippage: options.slippage
+            });
+        }
+        else {
+            (0, output_1.logInfo)(`Pool: ${poolId}`);
+            (0, output_1.logInfo)(`Input: ${options.amount} ${inSymbol}`);
+            (0, output_1.logInfo)(`Estimated output: ${estimatedOut.toExact()} ${outSymbol}`);
+            (0, output_1.logInfo)(`Minimum output: ${minOut.toExact()} ${outSymbol}`);
+            (0, output_1.logInfo)(`Slippage: ${options.slippagePercent}%`);
+        }
+        const ok = await (0, prompt_1.promptConfirm)("Proceed with swap?", false);
+        if (!ok) {
+            (0, output_1.logInfo)("Cancelled");
+            return;
+        }
+        const DEFAULT_COMPUTE_UNITS = 600000;
+        const computeBudgetConfig = options.priorityFeeMicroLamports > 0 ? { units: DEFAULT_COMPUTE_UNITS, microLamports: options.priorityFeeMicroLamports } : undefined;
+        const inputIsSol = inputMintStr === WRAPPED_SOL_MINT;
+        const outputIsSol = outputMintStr === WRAPPED_SOL_MINT;
+        const txData = await (0, output_1.withSpinner)("Building swap transaction", () => raydium.liquidity.swap({
+            txVersion: raydium_sdk_v2_1.TxVersion.V0,
+            poolInfo,
+            poolKeys,
+            amountIn: inputTokenAmount.raw,
+            amountOut: computeOut.minAmountOut,
+            inputMint: inputMintStr,
+            fixedSide: "in",
+            config: {
+                associatedOnly: true,
+                inputUseSolBalance: inputIsSol,
+                outputUseSolBalance: outputIsSol
+            },
+            computeBudgetConfig
+        }));
+        let result;
+        try {
+            result = await (0, output_1.withSpinner)("Sending transaction", () => txData.execute({ sendAndConfirm: true }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error ?? "Swap failed");
+            if (options.debug) {
+                const detail = error instanceof Error ? error.stack ?? message : (0, node_util_1.inspect)(error, { depth: 6 });
+                (0, output_1.logError)("Swap failed", detail);
+                const logs = error?.logs;
+                if (logs?.length) {
+                    console.error(logs.join("\n"));
+                }
+                else if (detail) {
+                    console.error(detail);
+                }
+            }
+            else {
+                (0, output_1.logError)("Swap failed", message);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({ txId: result.txId });
+        }
+        else {
+            (0, output_1.logSuccess)(`Swap submitted: ${result.txId}`);
+        }
+    };
+    const swapAction = async (options) => {
+        // Validate required options based on mode
+        if (!options.inputMint || !options.amount) {
+            (0, output_1.logError)("Missing required options: --input-mint, --amount");
+            process.exitCode = 1;
+            return;
+        }
+        // If no pool-id, require output-mint for Trade API routing
+        if (!options.poolId && !options.outputMint) {
+            (0, output_1.logError)("--output-mint is required when --pool-id is not provided");
+            process.exitCode = 1;
+            return;
+        }
+        const config = await (0, config_manager_1.loadConfig)({ createIfMissing: true });
+        const slippagePercent = options.slippage ? Number(options.slippage) : config["default-slippage"];
+        if (!Number.isFinite(slippagePercent) || slippagePercent < 0) {
+            (0, output_1.logError)("Invalid slippage percent");
+            process.exitCode = 1;
+            return;
+        }
+        const slippage = slippagePercent / 100;
+        const priorityFeeSol = options.priorityFee ? Number(options.priorityFee) : config["priority-fee"];
+        if (!Number.isFinite(priorityFeeSol) || priorityFeeSol < 0) {
+            (0, output_1.logError)("Invalid priority fee");
+            process.exitCode = 1;
+            return;
+        }
+        const DEFAULT_COMPUTE_UNITS = 600000;
+        const priorityFeeLamports = priorityFeeSol * 1e9;
+        const priorityFeeMicroLamports = Math.round((priorityFeeLamports * 1e6) / DEFAULT_COMPUTE_UNITS);
+        const walletName = config.activeWallet;
+        if (!walletName) {
+            (0, output_1.logError)("No active wallet set");
+            process.exitCode = 1;
+            return;
+        }
+        // Validate mint addresses
+        try {
+            new web3_js_1.PublicKey(options.inputMint);
+            if (options.outputMint)
+                new web3_js_1.PublicKey(options.outputMint);
+            if (options.poolId)
+                new web3_js_1.PublicKey(options.poolId);
+        }
+        catch {
+            (0, output_1.logError)("Invalid mint or pool address");
+            process.exitCode = 1;
+            return;
+        }
+        if (Number(options.amount) <= 0) {
+            (0, output_1.logError)("Amount must be greater than zero");
+            process.exitCode = 1;
+            return;
+        }
+        const password = await (0, prompt_1.promptPassword)("Enter wallet password");
+        let owner;
+        try {
+            owner = await (0, wallet_manager_1.decryptWallet)(walletName, password);
+        }
+        catch (error) {
+            (0, output_1.logError)("Failed to decrypt wallet", error.message);
+            process.exitCode = 1;
+            return;
+        }
+        // Route to appropriate swap method
+        if (options.poolId) {
+            // Direct AMM swap
+            await directAmmSwap({
+                poolId: options.poolId,
+                inputMint: options.inputMint,
+                outputMint: options.outputMint,
+                amount: options.amount,
+                slippage,
+                slippagePercent,
+                priorityFeeMicroLamports,
+                owner,
+                debug: options.debug
+            });
+        }
+        else {
+            // Trade API swap (auto-routing)
+            await tradeApiSwap({
+                inputMint: options.inputMint,
+                outputMint: options.outputMint,
+                amount: options.amount,
+                slippage,
+                slippagePercent,
+                priorityFeeMicroLamports,
+                owner,
+                debug: options.debug
+            });
+        }
+    };
+    program
+        .command("swap")
+        .description("Swap tokens (omit --pool-id for auto-routing via Trade API)")
+        .option("--pool-id <pool>", "AMM pool address (omit for auto-routing)")
+        .requiredOption("--input-mint <mint>", "Input token mint")
+        .requiredOption("--amount <number>", "Amount to swap")
+        .option("--output-mint <mint>", "Output token mint (required if --pool-id not provided)")
+        .option("--slippage <percent>", "Slippage tolerance")
+        .option("--priority-fee <sol>", "Priority fee in SOL")
+        .option("--debug", "Print full error object on failure")
+        .action(swapAction);
+}

package/dist/commands/tokens/index.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTokenCommands = registerTokenCommands;
+const codex_sdk_1 = require("../../lib/codex-sdk");
+const output_1 = require("../../lib/output");
+function registerTokenCommands(program) {
+    const tokens = program.command("tokens").description("Token utilities");
+    tokens
+        .command("list")
+        .description("List tokens")
+        .option("--search <text>", "Search by symbol, name, or mint")
+        .option("--limit <number>", "Max results (default 10, max 50)", "10")
+        .option("--offset <number>", "Offset for pagination", "0")
+        .action(async (options) => {
+        const limitInput = Number(options.limit);
+        const offsetInput = Number(options.offset);
+        const limit = Number.isFinite(limitInput) ? Math.min(Math.max(limitInput, 1), 50) : 10;
+        const offset = Number.isFinite(offsetInput) && offsetInput >= 0 ? offsetInput : 0;
+        const filters = {
+            liquidity: { gte: 25000 },
+            txnCount24: { gte: 50 },
+            network: [codex_sdk_1.SOLANA_CODEX_NETWORK_ID],
+            creatorAddress: null,
+            potentialScam: false
+        };
+        const filterQuery = `
+        query FilterTokens(
+          $filters: TokenFilters
+          $statsType: TokenPairStatisticsType
+          $excludeTokens: [String]
+          $phrase: String
+          $tokens: [String]
+          $rankings: [TokenRanking]
+          $limit: Int
+          $offset: Int
+        ) {
+          filterTokens(
+            filters: $filters
+            statsType: $statsType
+            excludeTokens: $excludeTokens
+            phrase: $phrase
+            tokens: $tokens
+            rankings: $rankings
+            limit: $limit
+            offset: $offset
+          ) {
+            results {
+              priceUSD
+              volume24
+              token {
+                address
+                decimals
+                name
+                symbol
+              }
+            }
+            count
+            page
+          }
+        }
+      `;
+        const sdk = (0, codex_sdk_1.getCodexClient)();
+        const response = await (0, output_1.withSpinner)("Loading token list", () => sdk.send(filterQuery, {
+            filters,
+            statsType: "FILTERED",
+            phrase: options.search ?? null,
+            rankings: [{ attribute: "volume24", direction: "DESC" }],
+            limit,
+            offset
+        }));
+        const results = response.filterTokens?.results ?? [];
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({
+                tokens: results,
+                count: response.filterTokens?.count ?? results.length,
+                page: response.filterTokens?.page ?? 0
+            });
+            return;
+        }
+        if (results.length === 0) {
+            (0, output_1.logInfo)("No tokens found");
+            return;
+        }
+        results.forEach((item) => {
+            const token = item.token;
+            (0, output_1.logInfo)(`${token.symbol} ${token.name}`.trim());
+            (0, output_1.logInfo)(`  mint: ${token.address}`);
+            (0, output_1.logInfo)(`  decimals: ${token.decimals}`);
+            (0, output_1.logInfo)(`  priceUSD: ${item.priceUSD}`);
+            (0, output_1.logInfo)(`  volume24: ${item.volume24}`);
+        });
+    });
+}