@zoidz123/raydium-cli 0.1.0

package/dist/commands/wallet/index.js

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWalletCommands = registerWalletCommands;
+const inquirer_1 = __importDefault(require("inquirer"));
+const bs58_1 = __importDefault(require("bs58"));
+const bn_js_1 = __importDefault(require("bn.js"));
+const web3_js_1 = require("@solana/web3.js");
+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 connection_1 = require("../../lib/connection");
+function formatAmount(raw, decimals) {
+    if (decimals <= 0)
+        return raw.toString();
+    const rawStr = raw.toString().padStart(decimals + 1, "0");
+    const whole = rawStr.slice(0, -decimals);
+    const frac = rawStr.slice(-decimals).replace(/0+$/, "");
+    return frac ? `${whole}.${frac}` : whole;
+}
+async function fetchRpcBalances(owner) {
+    const connection = await (0, connection_1.getConnection)();
+    const [solBalance, splAccounts, token2022Accounts] = await Promise.all([
+        connection.getBalance(owner),
+        connection.getTokenAccountsByOwner(owner, { programId: spl_token_1.TOKEN_PROGRAM_ID }),
+        connection.getTokenAccountsByOwner(owner, { programId: spl_token_1.TOKEN_2022_PROGRAM_ID })
+    ]);
+    const tokenAccounts = [...splAccounts.value, ...token2022Accounts.value].map(({ account }) => spl_token_1.AccountLayout.decode(account.data));
+    const mintSet = new Set();
+    tokenAccounts.forEach((account) => mintSet.add(account.mint.toBase58()));
+    const mintList = Array.from(mintSet);
+    const mintInfos = new Map();
+    const batchSize = 100;
+    for (let i = 0; i < mintList.length; i += batchSize) {
+        const batch = mintList.slice(i, i + batchSize);
+        const accounts = await connection.getMultipleAccountsInfo(batch.map((mint) => new web3_js_1.PublicKey(mint)));
+        accounts.forEach((info, idx) => {
+            if (!info)
+                return;
+            const decoded = spl_token_1.MintLayout.decode(info.data);
+            mintInfos.set(batch[idx], decoded.decimals);
+        });
+    }
+    const balances = [];
+    balances.push({
+        mint: "SOL",
+        symbol: "SOL",
+        name: "solana",
+        amount: formatAmount(new bn_js_1.default(solBalance.toString()), 9),
+        raw: solBalance.toString(),
+        decimals: 9
+    });
+    tokenAccounts.forEach((account) => {
+        const mint = account.mint.toBase58();
+        const decimals = mintInfos.get(mint) ?? 0;
+        const raw = new bn_js_1.default(account.amount.toString());
+        if (raw.isZero())
+            return;
+        const symbol = mint.slice(0, 6);
+        balances.push({
+            mint,
+            symbol,
+            name: symbol,
+            amount: formatAmount(raw, decimals),
+            raw: raw.toString(),
+            decimals
+        });
+    });
+    return balances;
+}
+function registerWalletCommands(program) {
+    const wallet = program.command("wallet").description("Manage wallets");
+    wallet
+        .command("create")
+        .description("Create a new wallet")
+        .argument("[name]")
+        .action(async (name) => {
+        const walletName = name ?? (await (0, prompt_1.promptInput)("Wallet name"));
+        const password = await (0, prompt_1.promptPassword)("Set wallet password", true);
+        const { mnemonic, wallet: walletFile } = await (0, wallet_manager_1.createWallet)(walletName, password);
+        const config = await (0, config_manager_1.loadConfig)({ createIfMissing: true });
+        if (!config.activeWallet) {
+            await (0, config_manager_1.saveConfig)({ ...config, activeWallet: walletName });
+        }
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({ name: walletFile.name, publicKey: walletFile.publicKey, mnemonic });
+        }
+        else {
+            (0, output_1.logSuccess)(`Wallet created: ${walletFile.name}`);
+            (0, output_1.logInfo)(`Public key: ${walletFile.publicKey}`);
+            (0, output_1.logInfo)(`Seed phrase (write down, shown once): ${mnemonic}`);
+        }
+    });
+    wallet
+        .command("import")
+        .description("Import an existing wallet")
+        .argument("<name>")
+        .option("--private-key <base58>", "Base58-encoded private key")
+        .option("--seed-phrase <phrase>", "Seed phrase")
+        .action(async (name, options) => {
+        let { privateKey, seedPhrase } = options;
+        if (!privateKey && !seedPhrase) {
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: "list",
+                    name: "method",
+                    message: "Import method",
+                    choices: [
+                        { name: "Private key (base58)", value: "private-key" },
+                        { name: "Seed phrase", value: "seed-phrase" }
+                    ]
+                }
+            ]);
+            if (answer.method === "private-key") {
+                privateKey = await (0, prompt_1.promptInput)("Private key (base58)");
+            }
+            else {
+                seedPhrase = await (0, prompt_1.promptInput)("Seed phrase");
+            }
+        }
+        const password = await (0, prompt_1.promptPassword)("Set wallet password", true);
+        if (privateKey) {
+            const walletFile = await (0, wallet_manager_1.importWalletFromPrivateKey)(name, privateKey, password);
+            const config = await (0, config_manager_1.loadConfig)({ createIfMissing: true });
+            if (!config.activeWallet) {
+                await (0, config_manager_1.saveConfig)({ ...config, activeWallet: walletFile.name });
+            }
+            if ((0, output_1.isJsonOutput)()) {
+                (0, output_1.logJson)({ name: walletFile.name, publicKey: walletFile.publicKey });
+            }
+            else {
+                (0, output_1.logSuccess)(`Wallet imported: ${walletFile.name}`);
+                (0, output_1.logInfo)(`Public key: ${walletFile.publicKey}`);
+            }
+            return;
+        }
+        if (!seedPhrase) {
+            (0, output_1.logError)("Missing seed phrase");
+            process.exitCode = 1;
+            return;
+        }
+        const normalizedSeed = seedPhrase.trim().split(/\s+/).join(" ");
+        const walletFile = await (0, wallet_manager_1.importWalletFromMnemonic)(name, normalizedSeed, password);
+        const config = await (0, config_manager_1.loadConfig)({ createIfMissing: true });
+        if (!config.activeWallet) {
+            await (0, config_manager_1.saveConfig)({ ...config, activeWallet: walletFile.name });
+        }
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({ name: walletFile.name, publicKey: walletFile.publicKey });
+        }
+        else {
+            (0, output_1.logSuccess)(`Wallet imported: ${walletFile.name}`);
+            (0, output_1.logInfo)(`Public key: ${walletFile.publicKey}`);
+        }
+    });
+    wallet
+        .command("list")
+        .description("List wallets")
+        .action(async () => {
+        const wallets = await (0, wallet_manager_1.listWallets)();
+        const config = await (0, config_manager_1.loadConfig)({ createIfMissing: true });
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({ wallets, activeWallet: config.activeWallet });
+            return;
+        }
+        if (wallets.length === 0) {
+            (0, output_1.logInfo)("No wallets found");
+            return;
+        }
+        wallets.forEach((item) => {
+            const activeMark = item.name === config.activeWallet ? " (active)" : "";
+            (0, output_1.logInfo)(`${item.name}${activeMark} - ${item.publicKey}`);
+        });
+    });
+    wallet
+        .command("use")
+        .description("Set active wallet")
+        .argument("<name>")
+        .action(async (name) => {
+        (0, wallet_manager_1.assertValidWalletName)(name);
+        if (!(await (0, wallet_manager_1.walletExists)(name))) {
+            (0, output_1.logError)(`Wallet not found: ${name}`);
+            process.exitCode = 1;
+            return;
+        }
+        const config = await (0, config_manager_1.loadConfig)({ createIfMissing: true });
+        await (0, config_manager_1.saveConfig)({ ...config, activeWallet: name });
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({ activeWallet: name });
+        }
+        else {
+            (0, output_1.logSuccess)(`Active wallet set to ${name}`);
+        }
+    });
+    wallet
+        .command("balance")
+        .description("Show wallet balances")
+        .argument("[name]")
+        .action(async (name) => {
+        const config = await (0, config_manager_1.loadConfig)({ createIfMissing: true });
+        const walletName = name ?? config.activeWallet;
+        if (!walletName) {
+            (0, output_1.logError)("No active wallet set");
+            process.exitCode = 1;
+            return;
+        }
+        (0, wallet_manager_1.assertValidWalletName)(walletName);
+        const owner = await (0, wallet_manager_1.getWalletPublicKey)(walletName);
+        const walletAddress = owner.toBase58();
+        const balances = await (0, output_1.withSpinner)("Fetching balances", () => fetchRpcBalances(owner));
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({ wallet: walletName, publicKey: walletAddress, tokens: balances });
+            return;
+        }
+        (0, output_1.logInfo)(`Wallet: ${walletName}`);
+        (0, output_1.logInfo)(`Public key: ${walletAddress}`);
+        if (balances.length === 0) {
+            (0, output_1.logInfo)("No balances found");
+            return;
+        }
+        balances.forEach((item) => {
+            // For SOL, just show symbol. For tokens, show full mint address
+            if (item.mint === "SOL") {
+                (0, output_1.logInfo)(`SOL: ${item.amount}`);
+            }
+            else {
+                const label = item.name && item.name !== item.symbol
+                    ? `${item.symbol} (${item.name})`
+                    : item.symbol;
+                (0, output_1.logInfo)(`${label}: ${item.amount}`);
+                (0, output_1.logInfo)(`  Mint: ${item.mint}`);
+            }
+        });
+    });
+    wallet
+        .command("export")
+        .description("Export a private key")
+        .argument("<name>")
+        .action(async (name) => {
+        (0, wallet_manager_1.assertValidWalletName)(name);
+        if (!(await (0, wallet_manager_1.walletExists)(name))) {
+            (0, output_1.logError)(`Wallet not found: ${name}`);
+            process.exitCode = 1;
+            return;
+        }
+        const ok = await (0, prompt_1.promptConfirm)("This will reveal your private key. Continue?", false);
+        if (!ok) {
+            (0, output_1.logInfo)("Cancelled");
+            return;
+        }
+        const password = await (0, prompt_1.promptPassword)("Enter wallet password");
+        const keypair = await (0, wallet_manager_1.decryptWallet)(name, password);
+        const privateKey = bs58_1.default.encode(keypair.secretKey);
+        if ((0, output_1.isJsonOutput)()) {
+            (0, output_1.logJson)({ name, publicKey: keypair.publicKey.toBase58(), privateKey });
+        }
+        else {
+            (0, output_1.logSuccess)("Private key exported");
+            (0, output_1.logInfo)(`Public key: ${keypair.publicKey.toBase58()}`);
+            (0, output_1.logInfo)(`Private key (base58): ${privateKey}`);
+        }
+    });
+}

package/dist/index.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const dotenv_1 = __importDefault(require("dotenv"));
+const config_1 = require("./commands/config");
+const wallet_1 = require("./commands/wallet");
+const pools_1 = require("./commands/pools");
+const swap_1 = require("./commands/swap");
+const launchpad_1 = require("./commands/launchpad");
+const clmm_1 = require("./commands/clmm");
+const cpmm_1 = require("./commands/cpmm");
+const output_1 = require("./lib/output");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { version } = require("../package.json");
+dotenv_1.default.config();
+const program = new commander_1.Command();
+program
+    .name("raydium")
+    .description("Raydium CLI")
+    .version(version)
+    .option("--json", "output json");
+program.hook("preAction", (_thisCommand, actionCommand) => {
+    const opts = typeof actionCommand.optsWithGlobals === "function"
+        ? actionCommand.optsWithGlobals()
+        : actionCommand.opts();
+    (0, output_1.setJsonOutput)(Boolean(opts.json));
+});
+(0, config_1.registerConfigCommands)(program);
+(0, wallet_1.registerWalletCommands)(program);
+(0, pools_1.registerPoolCommands)(program);
+(0, swap_1.registerSwapCommands)(program);
+(0, launchpad_1.registerLaunchpadCommands)(program);
+(0, clmm_1.registerClmmCommands)(program);
+(0, cpmm_1.registerCpmmCommands)(program);
+program.parseAsync(process.argv).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
+    (0, output_1.logError)(message);
+    process.exitCode = 1;
+});

package/dist/lib/clmm-utils.js

@@ -0,0 +1,296 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqrtPriceX64ToPrice = sqrtPriceX64ToPrice;
+exports.tickToPrice = tickToPrice;
+exports.tickToSqrtPriceX64 = tickToSqrtPriceX64;
+exports.getAmountsFromLiquidity = getAmountsFromLiquidity;
+exports.getAmountsForTickRange = getAmountsForTickRange;
+exports.formatTokenAmount = formatTokenAmount;
+exports.formatUsd = formatUsd;
+exports.calculateUsdValue = calculateUsdValue;
+exports.formatPrice = formatPrice;
+exports.formatFeeRate = formatFeeRate;
+exports.isPositionInRange = isPositionInRange;
+exports.priceToTick = priceToTick;
+exports.priceToAlignedTick = priceToAlignedTick;
+exports.isTickAligned = isTickAligned;
+exports.getTickSpacingFromFeeTier = getTickSpacingFromFeeTier;
+exports.applySlippage = applySlippage;
+exports.findPositionByNftMint = findPositionByNftMint;
+exports.hasUnclaimedFees = hasUnclaimedFees;
+exports.calculateWithdrawAmounts = calculateWithdrawAmounts;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const bn_js_1 = __importDefault(require("bn.js"));
+// Q64.64 fixed point constant
+const Q64 = new decimal_js_1.default(2).pow(64);
+/**
+ * Convert sqrtPriceX64 (Q64.64 fixed point) to decimal price
+ * sqrtPriceX64 = sqrt(price) * 2^64
+ * price = (sqrtPriceX64 / 2^64)^2 = sqrtPriceX64^2 / 2^128
+ */
+function sqrtPriceX64ToPrice(sqrtPriceX64, decimalsA, decimalsB) {
+    const sqrtPrice = new decimal_js_1.default(sqrtPriceX64.toString()).div(Q64);
+    const price = sqrtPrice.pow(2);
+    // Adjust for decimal differences: price is token1/token0, so we need to adjust
+    const decimalAdjustment = new decimal_js_1.default(10).pow(decimalsA - decimalsB);
+    return price.mul(decimalAdjustment);
+}
+/**
+ * Convert a tick index to price
+ * price = 1.0001^tick
+ */
+function tickToPrice(tick, decimalsA, decimalsB) {
+    const price = new decimal_js_1.default(1.0001).pow(tick);
+    const decimalAdjustment = new decimal_js_1.default(10).pow(decimalsA - decimalsB);
+    return price.mul(decimalAdjustment);
+}
+/**
+ * Convert tick to sqrtPriceX64
+ * sqrtPriceX64 = 1.0001^(tick/2) * 2^64
+ */
+function tickToSqrtPriceX64(tick) {
+    return new decimal_js_1.default(1.0001).pow(tick / 2).mul(Q64);
+}
+/**
+ * Calculate token amounts from liquidity for a position
+ * Based on Uniswap V3 math:
+ * - amount0 = L * (1/sqrt(P_lower) - 1/sqrt(P_upper)) when price <= lower
+ * - amount1 = L * (sqrt(P_upper) - sqrt(P_lower)) when price >= upper
+ * - Both when price is in range
+ */
+function getAmountsFromLiquidity(liquidity, currentSqrtPriceX64, tickLower, tickUpper, decimalsA, decimalsB) {
+    const L = new decimal_js_1.default(liquidity.toString());
+    const sqrtPriceCurrent = new decimal_js_1.default(currentSqrtPriceX64.toString());
+    const sqrtPriceLower = tickToSqrtPriceX64(tickLower);
+    const sqrtPriceUpper = tickToSqrtPriceX64(tickUpper);
+    let amount0 = new decimal_js_1.default(0);
+    let amount1 = new decimal_js_1.default(0);
+    if (sqrtPriceCurrent.lte(sqrtPriceLower)) {
+        // Current price is below the range - all liquidity is in token0
+        // amount0 = L * (sqrt(P_upper) - sqrt(P_lower)) / (sqrt(P_lower) * sqrt(P_upper))
+        amount0 = L.mul(sqrtPriceUpper.sub(sqrtPriceLower))
+            .div(sqrtPriceLower.mul(sqrtPriceUpper))
+            .mul(Q64); // Multiply by Q64 because sqrtPrices are scaled
+    }
+    else if (sqrtPriceCurrent.gte(sqrtPriceUpper)) {
+        // Current price is above the range - all liquidity is in token1
+        // amount1 = L * (sqrt(P_upper) - sqrt(P_lower)) / Q64
+        amount1 = L.mul(sqrtPriceUpper.sub(sqrtPriceLower)).div(Q64);
+    }
+    else {
+        // Price is in range - split between both tokens
+        // amount0 = L * (sqrt(P_upper) - sqrt(P_current)) / (sqrt(P_current) * sqrt(P_upper))
+        amount0 = L.mul(sqrtPriceUpper.sub(sqrtPriceCurrent))
+            .div(sqrtPriceCurrent.mul(sqrtPriceUpper))
+            .mul(Q64);
+        // amount1 = L * (sqrt(P_current) - sqrt(P_lower)) / Q64
+        amount1 = L.mul(sqrtPriceCurrent.sub(sqrtPriceLower)).div(Q64);
+    }
+    // Convert to human-readable amounts by dividing by decimals
+    const amount0Human = amount0.div(new decimal_js_1.default(10).pow(decimalsA));
+    const amount1Human = amount1.div(new decimal_js_1.default(10).pow(decimalsB));
+    return { amount0: amount0Human, amount1: amount1Human };
+}
+/**
+ * Calculate token amounts from liquidity for a tick range (for tick listing)
+ * This shows how much liquidity is available in a given tick range
+ */
+function getAmountsForTickRange(liquidityNet, tickIndex, tickSpacing, currentTick, currentSqrtPriceX64, decimalsA, decimalsB) {
+    // For a tick, liquidityNet represents the change in liquidity when crossing
+    // We calculate the amounts assuming the liquidity covers the next tick spacing
+    const tickLower = tickIndex;
+    const tickUpper = tickIndex + tickSpacing;
+    const L = new decimal_js_1.default(liquidityNet.toString()).abs();
+    if (L.isZero()) {
+        return { amount0: new decimal_js_1.default(0), amount1: new decimal_js_1.default(0) };
+    }
+    const sqrtPriceCurrent = new decimal_js_1.default(currentSqrtPriceX64.toString());
+    const sqrtPriceLower = tickToSqrtPriceX64(tickLower);
+    const sqrtPriceUpper = tickToSqrtPriceX64(tickUpper);
+    let amount0 = new decimal_js_1.default(0);
+    let amount1 = new decimal_js_1.default(0);
+    if (currentTick < tickLower) {
+        // Range is above current price - all in token0
+        amount0 = L.mul(sqrtPriceUpper.sub(sqrtPriceLower))
+            .div(sqrtPriceLower.mul(sqrtPriceUpper))
+            .mul(Q64);
+    }
+    else if (currentTick >= tickUpper) {
+        // Range is below current price - all in token1
+        amount1 = L.mul(sqrtPriceUpper.sub(sqrtPriceLower)).div(Q64);
+    }
+    else {
+        // Current price is in this range
+        amount0 = L.mul(sqrtPriceUpper.sub(sqrtPriceCurrent))
+            .div(sqrtPriceCurrent.mul(sqrtPriceUpper))
+            .mul(Q64);
+        amount1 = L.mul(sqrtPriceCurrent.sub(sqrtPriceLower)).div(Q64);
+    }
+    const amount0Human = amount0.div(new decimal_js_1.default(10).pow(decimalsA));
+    const amount1Human = amount1.div(new decimal_js_1.default(10).pow(decimalsB));
+    return { amount0: amount0Human, amount1: amount1Human };
+}
+/**
+ * Format a token amount for display
+ */
+function formatTokenAmount(amount, decimals = 6) {
+    if (amount.isZero())
+        return "0";
+    const fixed = amount.toFixed(decimals);
+    // Remove trailing zeros after decimal
+    return fixed.replace(/\.?0+$/, "");
+}
+/**
+ * Format a USD value for display
+ */
+function formatUsd(value) {
+    if (value === null)
+        return "";
+    const num = typeof value === "number" ? value : value.toNumber();
+    if (!Number.isFinite(num))
+        return "";
+    if (num < 0.01)
+        return "<$0.01";
+    if (num < 1)
+        return `$${num.toFixed(4)}`;
+    if (num < 1000)
+        return `$${num.toFixed(2)}`;
+    return `$${num.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+/**
+ * Calculate total USD value from two token amounts and their prices
+ * Returns null if neither price is available
+ */
+function calculateUsdValue(amount0, amount1, price0, price1) {
+    if (price0 === null && price1 === null)
+        return null;
+    let total = new decimal_js_1.default(0);
+    if (price0 !== null)
+        total = total.add(amount0.mul(price0));
+    if (price1 !== null)
+        total = total.add(amount1.mul(price1));
+    return total;
+}
+/**
+ * Format a price with appropriate precision
+ */
+function formatPrice(price) {
+    const num = price.toNumber();
+    if (num === 0)
+        return "0";
+    if (num < 0.000001)
+        return price.toExponential(4);
+    if (num < 0.0001)
+        return price.toFixed(8);
+    if (num < 0.01)
+        return price.toFixed(6);
+    if (num < 1)
+        return price.toFixed(4);
+    if (num < 100)
+        return price.toFixed(4);
+    if (num < 10000)
+        return price.toFixed(2);
+    return price.toFixed(0);
+}
+/**
+ * Format fee rate (e.g., 0.25% = 2500 basis points in 1e6)
+ */
+function formatFeeRate(feeRate) {
+    const percent = (feeRate / 1000000) * 100;
+    return `${percent}%`;
+}
+/**
+ * Check if a position is in range
+ */
+function isPositionInRange(tickLower, tickUpper, currentTick) {
+    return currentTick >= tickLower && currentTick < tickUpper;
+}
+/**
+ * Convert price to tick, aligned to the given tick spacing
+ * price = 1.0001^tick, so tick = log(price) / log(1.0001)
+ */
+function priceToTick(price, decimalsA, decimalsB) {
+    // Adjust price for decimals (reverse of tickToPrice)
+    const decimalAdjustment = new decimal_js_1.default(10).pow(decimalsA - decimalsB);
+    const adjustedPrice = price.div(decimalAdjustment);
+    // tick = log(adjustedPrice) / log(1.0001)
+    return Math.floor(adjustedPrice.ln().div(new decimal_js_1.default(1.0001).ln()).toNumber());
+}
+/**
+ * Convert price to tick aligned to the given tick spacing
+ * Rounds down to nearest valid tick
+ */
+function priceToAlignedTick(price, tickSpacing, decimalsA, decimalsB) {
+    const tick = priceToTick(price, decimalsA, decimalsB);
+    return Math.floor(tick / tickSpacing) * tickSpacing;
+}
+/**
+ * Check if a tick is aligned to the given tick spacing
+ */
+function isTickAligned(tick, tickSpacing) {
+    return tick % tickSpacing === 0;
+}
+/**
+ * Fee tier (in basis points) to tick spacing mapping
+ * Common Raydium CLMM fee tiers:
+ * - 100 bps (1%) -> tick spacing 100
+ * - 500 bps (0.5%) -> tick spacing 10
+ * - 2500 bps (0.25%) -> tick spacing 60
+ * - 10000 bps (1%) -> tick spacing 200
+ *
+ * Note: The actual mapping depends on the AMM config.
+ * This provides common defaults.
+ */
+function getTickSpacingFromFeeTier(feeTierBps) {
+    switch (feeTierBps) {
+        case 100:
+            return 1;
+        case 500:
+            return 10;
+        case 2500:
+            return 60;
+        case 3000:
+            return 60;
+        case 10000:
+            return 200;
+        default:
+            throw new Error(`Unknown fee tier: ${feeTierBps} bps`);
+    }
+}
+/**
+ * Apply slippage to an amount
+ * @param amount The amount to apply slippage to
+ * @param slippagePercent Slippage as a percentage (e.g., 1 for 1%)
+ * @param isMin If true, calculates minimum (amount - slippage), else maximum (amount + slippage)
+ */
+function applySlippage(amount, slippagePercent, isMin) {
+    const slippageBps = Math.floor(slippagePercent * 100); // Convert percent to basis points
+    const factor = isMin ? 10000 - slippageBps : 10000 + slippageBps;
+    return amount.mul(new bn_js_1.default(factor)).div(new bn_js_1.default(10000));
+}
+/**
+ * Find a position by its NFT mint address from an array of positions
+ */
+function findPositionByNftMint(positions, nftMint) {
+    const nftMintStr = nftMint.toBase58();
+    return positions.find((p) => p.nftMint?.toBase58() === nftMintStr);
+}
+/**
+ * Check if a position has unclaimed fees
+ */
+function hasUnclaimedFees(position) {
+    const feesA = position.tokenFeesOwedA;
+    const feesB = position.tokenFeesOwedB;
+    const hasFeesA = feesA && !feesA.isZero?.();
+    const hasFeesB = feesB && !feesB.isZero?.();
+    return hasFeesA || hasFeesB || false;
+}
+/**
+ * Calculate amounts to receive when removing liquidity
+ */
+function calculateWithdrawAmounts(liquidity, totalLiquidity, currentSqrtPriceX64, tickLower, tickUpper, decimalsA, decimalsB) {
+    return getAmountsFromLiquidity(liquidity.toString(), currentSqrtPriceX64.toString(), tickLower, tickUpper, decimalsA, decimalsB);
+}

package/dist/lib/codex-sdk.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOLANA_CODEX_NETWORK_ID = void 0;
+exports.getCodexClient = getCodexClient;
+const sdk_1 = require("@codex-data/sdk");
+let cachedClient = null;
+function getCodexClient() {
+    if (cachedClient)
+        return cachedClient;
+    const apiKey = process.env.CODEX_API_KEY;
+    if (!apiKey) {
+        throw new Error("Missing CODEX_API_KEY in environment");
+    }
+    cachedClient = new sdk_1.Codex(apiKey);
+    return cachedClient;
+}
+exports.SOLANA_CODEX_NETWORK_ID = 1399811149;

package/dist/lib/config-manager.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureConfigDir = ensureConfigDir;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.isValidConfigKey = isValidConfigKey;
+exports.parseConfigValue = parseConfigValue;
+const promises_1 = __importDefault(require("fs/promises"));
+const paths_1 = require("./paths");
+const config_1 = require("../types/config");
+const NUMBER_KEYS = ["default-slippage", "priority-fee"];
+const EXPLORER_VALUES = ["solscan", "solanaFm", "solanaExplorer"];
+async function ensureConfigDir() {
+    await promises_1.default.mkdir(paths_1.CONFIG_DIR, { recursive: true });
+}
+async function loadConfig(options) {
+    try {
+        const raw = await promises_1.default.readFile(paths_1.CONFIG_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        return { ...config_1.DEFAULT_CONFIG, ...parsed };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            const config = { ...config_1.DEFAULT_CONFIG };
+            if (options?.createIfMissing) {
+                await saveConfig(config);
+            }
+            return config;
+        }
+        throw error;
+    }
+}
+async function saveConfig(config) {
+    await ensureConfigDir();
+    await promises_1.default.writeFile(paths_1.CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+function isValidConfigKey(key) {
+    return Object.prototype.hasOwnProperty.call(config_1.DEFAULT_CONFIG, key);
+}
+function parseConfigValue(key, value) {
+    if (NUMBER_KEYS.includes(key)) {
+        const num = Number(value);
+        if (!Number.isFinite(num))
+            throw new Error(`Invalid number for ${key}: ${value}`);
+        return num;
+    }
+    if (key === "explorer") {
+        if (!EXPLORER_VALUES.includes(value)) {
+            throw new Error(`Invalid explorer value. Use one of: ${EXPLORER_VALUES.join(", ")}`);
+        }
+        return value;
+    }
+    if (key === "activeWallet") {
+        if (value === "null")
+            return null;
+        return value;
+    }
+    if (key === "pinata-jwt") {
+        if (value === "null" || value === "")
+            return null;
+        return value;
+    }
+    return value;
+}