outsmart 2.0.0-alpha.0

package/dist/cli.js

@@ -0,0 +1,1251 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// Suppress bigint-buffer native binding warning (pure JS fallback works fine)
+// bigint-buffer@1.1.5 doesn't have Node 22+ bindings and prints to stderr on load
+const _origWarn = process.stderr.write.bind(process.stderr);
+process.stderr.write = (chunk, ...args) => {
+    if (typeof chunk === "string" && chunk.includes("bigint: Failed to load bindings"))
+        return true;
+    return _origWarn(chunk, ...args);
+};
+/**
+ * outsmart CLI — The Solana trading command-line interface.
+ *
+ * 18 DEX adapters, 12 TX landing providers, one unified interface.
+ *
+ * Usage:
+ *   # On-chain DEX — pool address required, token auto-detected from pool
+ *   outsmart buy  --dex meteora-dlmm --pool <POOL> --amount 0.1
+ *   outsmart sell --dex meteora-dlmm --pool <POOL> --pct 100
+ *
+ *   # Stablecoin pool — auto-swaps SOL→USD1 then buys, no extra steps needed
+ *   outsmart buy  --dex raydium-launchlab --pool <POOL> --amount 0.1
+ *
+ *   # Swap aggregator — requires token mint only (finds best route automatically)
+ *   outsmart buy  --dex jupiter-ultra --token <MINT> --amount 0.1
+ *   outsmart sell --dex jupiter-ultra --token <MINT> --pct 100
+ *
+ *   outsmart quote --dex meteora-dlmm --pool <POOL>
+ *   outsmart list-dex
+ *   outsmart list-dex --cap canSell
+ *   outsmart config show
+ *   outsmart init
+ */
+require("dotenv/config");
+const commander_1 = require("commander");
+// ---------------------------------------------------------------------------
+// Side-effect imports — trigger adapter self-registration
+// ---------------------------------------------------------------------------
+require("./dex/raydium-amm-v4");
+require("./dex/raydium-cpmm");
+require("./dex/raydium-clmm");
+require("./dex/raydium-launchlab");
+require("./dex/meteora-damm-v1");
+require("./dex/meteora-damm-v2");
+require("./dex/meteora-dlmm");
+require("./dex/meteora-dbc");
+require("./dex/orca");
+require("./dex/byreal-clmm");
+require("./dex/pancakeswap-clmm");
+require("./dex/fusion-amm");
+require("./dex/futarchy-amm");
+require("./dex/futarchy-launchpad");
+require("./dex/pumpfun");
+require("./dex/pumpfun-amm");
+require("./dex/jupiter-ultra");
+require("./dex/dflow");
+// ---------------------------------------------------------------------------
+// Internal imports
+// ---------------------------------------------------------------------------
+const dex_1 = require("./dex");
+const types_1 = require("./dex/types");
+// ---------------------------------------------------------------------------
+// Version from package.json
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require("../package.json");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function die(msg) {
+    console.error(`\n  error: ${msg}\n`);
+    process.exit(1);
+}
+/** Base58 character set (no 0, O, I, l) */
+const BASE58_CHARS = /^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/;
+/**
+ * Validate that a string is a valid Solana base58 address.
+ * Checks length (32-44 chars), character set, and PublicKey construction.
+ */
+function validateBase58(value, flag) {
+    if (value.length < 32 || value.length > 44) {
+        die(`Invalid ${flag}: "${value}" is not a valid Solana address (must be 32-44 characters, got ${value.length})`);
+    }
+    if (!BASE58_CHARS.test(value)) {
+        die(`Invalid ${flag}: "${value}" is not a valid Solana address (contains invalid base58 characters)`);
+    }
+    try {
+        // Dynamic import would be async; use require for synchronous validation
+        // PublicKey is already used elsewhere in this file via dynamic import,
+        // but for a sync helper we use require.
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { PublicKey } = require("@solana/web3.js");
+        new PublicKey(value);
+    }
+    catch {
+        die(`Invalid ${flag}: "${value}" is not a valid Solana address`);
+    }
+}
+/**
+ * Validate that a DEX name is registered in the adapter registry.
+ * Shows available adapters if the name is not found.
+ */
+function validateDex(dexName) {
+    const registry = (0, dex_1.getRegistry)();
+    if (!registry.has(dexName)) {
+        const available = registry.getNames();
+        die(`Unknown --dex "${dexName}". Available adapters:\n` +
+            available.map((n) => `    ${n}`).join("\n"));
+    }
+}
+function printResult(result) {
+    console.log();
+    console.log(`  dex:       ${result.dex}`);
+    console.log(`  tx:        ${result.txSignature}`);
+    console.log(`  confirmed: ${result.confirmed}`);
+    console.log(`  in:        ${result.amountIn} ${result.amountInToken}`);
+    if (result.amountOut != null) {
+        console.log(`  out:       ${result.amountOut} ${result.amountOutToken ?? ""}`);
+    }
+    if (result.poolAddress) {
+        console.log(`  pool:      ${result.poolAddress}`);
+    }
+    if (result.priceImpactPct != null) {
+        console.log(`  impact:    ${result.priceImpactPct.toFixed(2)}%`);
+    }
+    console.log();
+}
+/** Friendly label for a stablecoin mint */
+function stablecoinLabel(mint) {
+    if (mint === types_1.USDC_MINT)
+        return "USDC";
+    if (mint === types_1.USDT_MINT)
+        return "USDT";
+    if (mint === types_1.USD1_MINT)
+        return "USD1";
+    return mint.slice(0, 8) + "...";
+}
+/**
+ * Resolve the token mint and quote mint from pool state.
+ *
+ * Calls adapter.getPrice(pool) which decodes the pool account and returns
+ * baseMint + quoteMint. We determine which is the "token" (what the user
+ * wants to buy/sell) and which is the "quote" (SOL or stablecoin).
+ *
+ * Priority: SOL > USDC/USDT/USD1 > error (ambiguous).
+ */
+async function resolvePool(adapter, poolAddress) {
+    if (!adapter.capabilities.canGetPrice || !adapter.getPrice) {
+        die(`${adapter.name} cannot auto-detect token from pool — please provide --token <mint>`);
+    }
+    const price = await adapter.getPrice(poolAddress);
+    const { baseMint, quoteMint } = price;
+    // SOL as quote — most common
+    if (quoteMint === dex_1.WSOL_MINT)
+        return { tokenMint: baseMint, quoteMint, price };
+    if (baseMint === dex_1.WSOL_MINT)
+        return { tokenMint: quoteMint, quoteMint: baseMint, price };
+    // Stablecoin as quote
+    if (types_1.STABLECOIN_MINTS.has(quoteMint))
+        return { tokenMint: baseMint, quoteMint, price };
+    if (types_1.STABLECOIN_MINTS.has(baseMint))
+        return { tokenMint: quoteMint, quoteMint: baseMint, price };
+    // Neither side is SOL or stablecoin — ambiguous
+    die(`Pool ${poolAddress} has no SOL or stablecoin side (${baseMint} / ${quoteMint}).\n`
+        + `  Please specify --token <mint> to indicate which token to trade.`);
+}
+/**
+ * Get the SPL token balance for a mint in the user's wallet.
+ */
+async function getTokenBalance(mint) {
+    const { getConnection, getWallet } = await Promise.resolve().then(() => __importStar(require("./helpers/config")));
+    const { PublicKey } = await Promise.resolve().then(() => __importStar(require("@solana/web3.js")));
+    const { getAssociatedTokenAddress } = await Promise.resolve().then(() => __importStar(require("@solana/spl-token")));
+    const connection = getConnection();
+    const wallet = getWallet();
+    const mintPk = new PublicKey(mint);
+    try {
+        const ata = await getAssociatedTokenAddress(mintPk, wallet.publicKey);
+        const res = await connection.getTokenAccountBalance(ata);
+        return {
+            amount: Number(res.value.uiAmount ?? 0),
+            raw: BigInt(res.value.amount),
+            decimals: res.value.decimals,
+        };
+    }
+    catch {
+        return { amount: 0, raw: 0n, decimals: 0 };
+    }
+}
+/**
+ * Check if Jupiter Ultra API is available (JUPITER_API_KEY is set).
+ */
+function hasJupiterApiKey() {
+    return !!process.env.JUPITER_API_KEY;
+}
+/**
+ * Auto-swap SOL → stablecoin. Uses jupiter-ultra if JUPITER_API_KEY is set,
+ * otherwise falls back to on-chain DEX adapters from SOL_STABLECOIN_POOLS.
+ * Returns the stablecoin amount received.
+ */
+async function autoSwapSolToStablecoin(stablecoinMint, amountSol) {
+    const label = stablecoinLabel(stablecoinMint);
+    // Snapshot balance BEFORE swap so we return only the delta
+    const balanceBefore = await getTokenBalance(stablecoinMint);
+    if (hasJupiterApiKey()) {
+        // --- Jupiter Ultra path ---
+        console.log(`\n  step 1: swapping ${amountSol} SOL → ${label} via jupiter-ultra...`);
+        const jupAdapter = (0, dex_1.getDexAdapter)("jupiter-ultra");
+        const result = await jupAdapter.buy({
+            tokenMint: stablecoinMint,
+            amountSol,
+        });
+        if (!result.txSignature) {
+            die(`Failed to swap SOL → ${label}: no transaction signature returned`);
+        }
+        console.log(`  ✓ tx: ${result.txSignature}`);
+        if (result.confirmed)
+            console.log(`  ✓ confirmed`);
+    }
+    else {
+        // --- On-chain fallback path ---
+        const pools = types_1.SOL_STABLECOIN_POOLS[stablecoinMint];
+        if (!pools || pools.length === 0) {
+            die(`No on-chain SOL/${label} pools configured and JUPITER_API_KEY is not set.`);
+        }
+        let swapped = false;
+        for (const entry of pools) {
+            try {
+                const adapter = (0, dex_1.getDexAdapter)(entry.dex);
+                console.log(`\n  step 1: swapping ${amountSol} SOL → ${label} via ${entry.dex} (pool ${entry.pool.slice(0, 8)}...)...`);
+                const result = await adapter.buy({
+                    tokenMint: stablecoinMint,
+                    amountSol,
+                    poolAddress: entry.pool,
+                    quoteMint: dex_1.WSOL_MINT,
+                });
+                if (!result.txSignature) {
+                    console.log(`  ✗ no tx signature, trying next pool...`);
+                    continue;
+                }
+                console.log(`  ✓ tx: ${result.txSignature}`);
+                if (result.confirmed)
+                    console.log(`  ✓ confirmed`);
+                swapped = true;
+                break;
+            }
+            catch (err) {
+                console.log(`  ✗ ${entry.dex} failed: ${err.message ?? err}. Trying next pool...`);
+            }
+        }
+        if (!swapped) {
+            die(`All on-chain SOL/${label} pools failed. Set JUPITER_API_KEY for jupiter-ultra fallback,\n`
+                + `  or check your SOL balance and RPC connection.`);
+        }
+    }
+    // Wait for balance to settle, then compute delta (only the swapped amount)
+    await new Promise((r) => setTimeout(r, 2000));
+    const balanceAfter = await getTokenBalance(stablecoinMint);
+    const received = balanceAfter.amount - balanceBefore.amount;
+    console.log(`  ✓ received: ${received.toFixed(6)} ${label} (wallet total: ${balanceAfter.amount} ${label})`);
+    if (received <= 0) {
+        die(`SOL → ${label} swap TX landed but received 0 ${label}. TX may have failed on-chain.`);
+    }
+    return received;
+}
+/**
+ * Auto-swap stablecoin → SOL after a sell. Uses jupiter-ultra if JUPITER_API_KEY
+ * is set, otherwise falls back to on-chain DEX adapters.
+ */
+async function autoSwapStablecoinToSol(stablecoinMint) {
+    const balance = await getTokenBalance(stablecoinMint);
+    if (balance.amount === 0)
+        return;
+    const label = stablecoinLabel(stablecoinMint);
+    if (hasJupiterApiKey()) {
+        // --- Jupiter Ultra path ---
+        console.log(`\n  step 2: swapping ${balance.amount} ${label} → SOL via jupiter-ultra...`);
+        const jupAdapter = (0, dex_1.getDexAdapter)("jupiter-ultra");
+        const result = await jupAdapter.sell({
+            tokenMint: stablecoinMint,
+            percentage: 100,
+        });
+        if (result.txSignature) {
+            console.log(`  ✓ tx: ${result.txSignature}`);
+            if (result.confirmed)
+                console.log(`  ✓ confirmed`);
+        }
+    }
+    else {
+        // --- On-chain fallback path ---
+        const pools = types_1.SOL_STABLECOIN_POOLS[stablecoinMint];
+        if (!pools || pools.length === 0) {
+            console.log(`\n  ⚠ No on-chain ${label}/SOL pools configured and JUPITER_API_KEY is not set. ${label} remains in wallet.`);
+            return;
+        }
+        for (const entry of pools) {
+            try {
+                const adapter = (0, dex_1.getDexAdapter)(entry.dex);
+                console.log(`\n  step 2: swapping ${balance.amount} ${label} → SOL via ${entry.dex} (pool ${entry.pool.slice(0, 8)}...)...`);
+                const result = await adapter.sell({
+                    tokenMint: stablecoinMint,
+                    percentage: 100,
+                    poolAddress: entry.pool,
+                    quoteMint: dex_1.WSOL_MINT,
+                });
+                if (result.txSignature) {
+                    console.log(`  ✓ tx: ${result.txSignature}`);
+                    if (result.confirmed)
+                        console.log(`  ✓ confirmed`);
+                    return;
+                }
+                console.log(`  ✗ no tx signature, trying next pool...`);
+            }
+            catch (err) {
+                console.log(`  ✗ ${entry.dex} failed: ${err.message ?? err}. Trying next pool...`);
+            }
+        }
+        console.log(`\n  ⚠ All on-chain ${label}/SOL pools failed. ${label} remains in wallet.`);
+    }
+}
+function buildSwapOpts(cmd) {
+    const opts = {};
+    if (cmd.slippage != null)
+        opts.slippageBps = Number(cmd.slippage);
+    if (cmd.priority != null)
+        opts.priorityFeeMicroLamports = Number(cmd.priority);
+    if (cmd.tip != null)
+        opts.tipSol = Number(cmd.tip);
+    if (cmd.cu != null)
+        opts.computeUnitLimit = Number(cmd.cu);
+    if (cmd.jito)
+        opts.useJito = true;
+    if (cmd.strategy != null) {
+        opts.landingStrategy = cmd.strategy;
+    }
+    return opts;
+}
+/**
+ * Shared option definitions for swap commands.
+ * @param includeTip - whether to add --tip (false for snipe, which has it as required)
+ */
+function addSwapOptions(cmd, includeTip = true) {
+    cmd
+        .option("--slippage <bps>", `slippage tolerance in basis points (default: ${dex_1.DEFAULT_SLIPPAGE_BPS})`)
+        .option("--priority <microLamports>", "priority fee in microLamports per CU")
+        .option("--cu <units>", "compute unit limit")
+        .option("--jito", "use Jito bundle submission")
+        .option("--strategy <mode>", "TX landing strategy: concurrent|race|random|sequential")
+        .option("--quote <mint>", "quote token mint (default: WSOL)");
+    if (includeTip) {
+        cmd.option("--tip <sol>", "MEV tip in SOL");
+    }
+    return cmd;
+}
+// ---------------------------------------------------------------------------
+// Program
+// ---------------------------------------------------------------------------
+const program = new commander_1.Command()
+    .name("outsmart")
+    .description("The Solana trading CLI — 18 DEX adapters, 12 TX landing providers.")
+    .version(pkg.version);
+// ---------------------------------------------------------------------------
+// outsmart buy
+// ---------------------------------------------------------------------------
+const buyCmd = new commander_1.Command("buy")
+    .description("Buy tokens with SOL (or quote token)")
+    .requiredOption("-d, --dex <name>", "DEX adapter name (e.g. raydium-cpmm, jupiter-ultra)")
+    .requiredOption("-a, --amount <sol>", "amount of SOL to spend")
+    .option("-p, --pool <address>", "pool address (required for on-chain DEXes)")
+    .option("-t, --token <mint>", "token mint address to buy")
+    .action(async (cmdOpts) => {
+    // --- Input sanitization ---
+    validateDex(cmdOpts.dex);
+    if (cmdOpts.pool)
+        validateBase58(cmdOpts.pool, "--pool");
+    if (cmdOpts.token)
+        validateBase58(cmdOpts.token, "--token");
+    if (cmdOpts.quote)
+        validateBase58(cmdOpts.quote, "--quote");
+    const adapter = (0, dex_1.getDexAdapter)(cmdOpts.dex);
+    if (!adapter.capabilities.canBuy) {
+        die(`${adapter.name} does not support buy`);
+    }
+    // Validate inputs based on adapter type
+    if (adapter.capabilities.isAggregator) {
+        // Aggregators (jupiter-ultra, dflow): need --token, no --pool needed
+        if (!cmdOpts.token) {
+            die(`${adapter.name} is a swap aggregator — --token <mint> is required.\n  Example: outsmart buy --dex ${adapter.name} --token <MINT> --amount 0.1`);
+        }
+    }
+    else {
+        // On-chain DEXes: need --pool (--token is optional, auto-resolved from pool)
+        if (!cmdOpts.pool) {
+            die(`${adapter.name} is an on-chain DEX — --pool <address> is required.\n  Example: outsmart buy --dex ${adapter.name} --pool <POOL> --amount 0.1`);
+        }
+    }
+    // Auto-resolve token + quote from pool state
+    let tokenMint = cmdOpts.token;
+    let quoteMint = cmdOpts.quote;
+    let amountToSpend = Number(cmdOpts.amount);
+    if (isNaN(amountToSpend) || amountToSpend <= 0) {
+        die(`Invalid --amount: ${cmdOpts.amount}. Must be a positive number.`);
+    }
+    if (!tokenMint && cmdOpts.pool) {
+        const resolved = await resolvePool(adapter, cmdOpts.pool);
+        tokenMint = resolved.tokenMint;
+        quoteMint = quoteMint ?? resolved.quoteMint;
+        console.log(`  auto-detected token: ${tokenMint}`);
+        // If the quote is a stablecoin (not SOL), auto-swap SOL → stablecoin first
+        if (resolved.quoteMint !== dex_1.WSOL_MINT && types_1.STABLECOIN_MINTS.has(resolved.quoteMint)) {
+            const label = stablecoinLabel(resolved.quoteMint);
+            console.log(`  pool quote: ${label} (not SOL)`);
+            quoteMint = resolved.quoteMint;
+            // Check existing balance
+            const existingBalance = await getTokenBalance(resolved.quoteMint);
+            if (existingBalance.amount > 0) {
+                console.log(`  wallet has ${existingBalance.amount} ${label}`);
+            }
+            // Swap SOL → stablecoin, then use full stablecoin balance for the buy
+            amountToSpend = await autoSwapSolToStablecoin(resolved.quoteMint, amountToSpend);
+        }
+    }
+    const params = {
+        tokenMint,
+        amountSol: amountToSpend,
+        poolAddress: cmdOpts.pool,
+        quoteMint,
+        opts: buildSwapOpts(cmdOpts),
+    };
+    const isStablecoinQuote = quoteMint && types_1.STABLECOIN_MINTS.has(quoteMint);
+    const stepLabel = isStablecoinQuote ? "step 2: " : "";
+    console.log(`\n  ${stepLabel}buying on ${adapter.name}...`);
+    const result = await adapter.buy(params);
+    printResult(result);
+});
+addSwapOptions(buyCmd);
+program.addCommand(buyCmd);
+// ---------------------------------------------------------------------------
+// outsmart sell
+// ---------------------------------------------------------------------------
+const sellCmd = new commander_1.Command("sell")
+    .description("Sell tokens for SOL (or quote token)")
+    .requiredOption("-d, --dex <name>", "DEX adapter name")
+    .requiredOption("--pct <percentage>", "percentage of held balance to sell (0-100)")
+    .option("-p, --pool <address>", "pool address (required for on-chain DEXes)")
+    .option("-t, --token <mint>", "token mint address to sell")
+    .action(async (cmdOpts) => {
+    // --- Input sanitization ---
+    validateDex(cmdOpts.dex);
+    if (cmdOpts.pool)
+        validateBase58(cmdOpts.pool, "--pool");
+    if (cmdOpts.token)
+        validateBase58(cmdOpts.token, "--token");
+    if (cmdOpts.quote)
+        validateBase58(cmdOpts.quote, "--quote");
+    const adapter = (0, dex_1.getDexAdapter)(cmdOpts.dex);
+    if (!adapter.capabilities.canSell) {
+        die(`${adapter.name} does not support sell`);
+    }
+    // Validate inputs based on adapter type
+    if (adapter.capabilities.isAggregator) {
+        // Aggregators (jupiter-ultra, dflow): need --token, no --pool needed
+        if (!cmdOpts.token) {
+            die(`${adapter.name} is a swap aggregator — --token <mint> is required.\n  Example: outsmart sell --dex ${adapter.name} --token <MINT> --pct 100`);
+        }
+    }
+    else {
+        // On-chain DEXes: need --pool (--token is optional, auto-resolved from pool)
+        if (!cmdOpts.pool) {
+            die(`${adapter.name} is an on-chain DEX — --pool <address> is required.\n  Example: outsmart sell --dex ${adapter.name} --pool <POOL> --pct 100`);
+        }
+    }
+    const pct = Number(cmdOpts.pct);
+    if (isNaN(pct) || pct <= 0 || pct > 100) {
+        die(`Invalid --pct: ${cmdOpts.pct}. Must be between 1 and 100.`);
+    }
+    // Auto-resolve token + quote from pool state
+    let tokenMint = cmdOpts.token;
+    let quoteMint = cmdOpts.quote;
+    let isStablecoinQuote = false;
+    if (!tokenMint && cmdOpts.pool) {
+        const resolved = await resolvePool(adapter, cmdOpts.pool);
+        tokenMint = resolved.tokenMint;
+        quoteMint = quoteMint ?? resolved.quoteMint;
+        console.log(`  auto-detected token: ${tokenMint}`);
+        if (resolved.quoteMint !== dex_1.WSOL_MINT && types_1.STABLECOIN_MINTS.has(resolved.quoteMint)) {
+            isStablecoinQuote = true;
+            const label = stablecoinLabel(resolved.quoteMint);
+            console.log(`  pool quote: ${label} (will auto-convert to SOL after sell)`);
+        }
+    }
+    const params = {
+        tokenMint,
+        percentage: pct,
+        poolAddress: cmdOpts.pool,
+        quoteMint,
+        opts: buildSwapOpts(cmdOpts),
+    };
+    const stepLabel = isStablecoinQuote ? "step 1: " : "";
+    console.log(`\n  ${stepLabel}selling ${params.percentage}% on ${adapter.name}...`);
+    const result = await adapter.sell(params);
+    printResult(result);
+    // Auto-swap stablecoin proceeds → SOL
+    if (isStablecoinQuote && quoteMint && result.txSignature) {
+        await autoSwapStablecoinToSol(quoteMint);
+    }
+});
+addSwapOptions(sellCmd);
+program.addCommand(sellCmd);
+// ---------------------------------------------------------------------------
+// outsmart snipe — NOT YET IMPLEMENTED
+//
+// Real sniping requires a gRPC (Geyser/Yellowstone) listener that monitors
+// pool creation events in real time. When a new pool is created where the
+// base or quote token matches the target, it fires an instant buy through
+// concurrent multi-provider TX landing.
+//
+// This needs the user's own Geyser gRPC key and runs as a background
+// process (cronjob/tmux). Will be added when gRPC integration is built.
+//
+// For now, use `outsmart buy --pool <POOL> --tip <SOL>` to execute a
+// competitive buy on a known pool.
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// outsmart quote
+// ---------------------------------------------------------------------------
+program
+    .command("quote")
+    .description("Get the current on-chain price from a pool")
+    .requiredOption("-d, --dex <name>", "DEX adapter name")
+    .requiredOption("-p, --pool <address>", "pool address")
+    .action(async (cmdOpts) => {
+    const adapter = (0, dex_1.getDexAdapter)(cmdOpts.dex);
+    if (!adapter.capabilities.canGetPrice) {
+        die(`${adapter.name} does not support getPrice`);
+    }
+    if (!adapter.getPrice) {
+        die(`${adapter.name} declares canGetPrice but has no getPrice() implementation`);
+    }
+    const price = await adapter.getPrice(cmdOpts.pool);
+    console.log();
+    console.log(`  dex:       ${adapter.name}`);
+    console.log(`  pool:      ${price.poolAddress}`);
+    console.log(`  price:     ${price.price}`);
+    console.log(`  base:      ${price.baseMint}`);
+    console.log(`  quote:     ${price.quoteMint}`);
+    console.log(`  source:    ${price.source}`);
+    console.log(`  time:      ${new Date(price.timestamp).toISOString()}`);
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// outsmart find-pool
+// ---------------------------------------------------------------------------
+program
+    .command("find-pool")
+    .description("Discover a pool for a token pair on a specific DEX")
+    .requiredOption("-d, --dex <name>", "DEX adapter name")
+    .requiredOption("-t, --token <mint>", "base token mint address")
+    .option("--quote <mint>", "quote token mint (default: WSOL)")
+    .action(async (cmdOpts) => {
+    const adapter = (0, dex_1.getDexAdapter)(cmdOpts.dex);
+    if (!adapter.capabilities.canFindPool) {
+        die(`${adapter.name} does not support findPool`);
+    }
+    if (!adapter.findPool) {
+        die(`${adapter.name} declares canFindPool but has no findPool() implementation`);
+    }
+    const pool = await adapter.findPool(cmdOpts.token, cmdOpts.quote);
+    if (!pool) {
+        console.log(`\n  No pool found for ${cmdOpts.token} on ${adapter.name}\n`);
+        process.exit(1);
+    }
+    console.log();
+    console.log(`  dex:            ${pool.dex}`);
+    console.log(`  protocol:       ${pool.protocol}`);
+    console.log(`  pool:           ${pool.address}`);
+    console.log(`  base:           ${pool.baseMint} (${pool.baseDecimals} decimals)`);
+    console.log(`  quote:          ${pool.quoteMint} (${pool.quoteDecimals} decimals)`);
+    if (pool.liquidity != null) {
+        console.log(`  liquidity:      $${pool.liquidity.toLocaleString()}`);
+    }
+    if (pool.price != null) {
+        console.log(`  price:          ${pool.price}`);
+    }
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// outsmart add-liq
+// ---------------------------------------------------------------------------
+program
+    .command("add-liq")
+    .description("Add liquidity to a pool")
+    .requiredOption("-d, --dex <name>", "DEX adapter name (e.g. meteora-dlmm)")
+    .requiredOption("-p, --pool <address>", "pool address")
+    .option("--amount-sol <amount>", "amount of SOL to deposit")
+    .option("--amount-token <amount>", "amount of non-SOL token to deposit")
+    .option("-t, --token <mint>", "token mint (for single-sided token deposits)")
+    .option("--strategy <type>", "distribution strategy: spot|curve|bid-ask (default: spot)")
+    .option("--bins <count>", "number of bins to spread across (default: 50, max: 70)")
+    .option("--amount-a <amount>", "amount of token A (legacy, use --amount-sol instead)")
+    .option("--amount-b <amount>", "amount of token B (legacy, use --amount-token instead)")
+    .option("--slippage <bps>", "slippage tolerance in basis points")
+    .option("--priority <microLamports>", "priority fee in microLamports per CU")
+    .option("--tip <sol>", "MEV tip in SOL")
+    .action(async (cmdOpts) => {
+    const adapter = (0, dex_1.getDexAdapter)(cmdOpts.dex);
+    if (!adapter.capabilities.canAddLiquidity) {
+        die(`${adapter.name} does not support addLiquidity`);
+    }
+    if (!adapter.addLiquidity) {
+        die(`${adapter.name} declares canAddLiquidity but has no addLiquidity() implementation`);
+    }
+    // Validate: at least one amount must be provided
+    const hasAmountSol = cmdOpts.amountSol != null;
+    const hasAmountToken = cmdOpts.amountToken != null;
+    const hasLegacyA = cmdOpts.amountA != null;
+    const hasLegacyB = cmdOpts.amountB != null;
+    if (!hasAmountSol && !hasAmountToken && !hasLegacyA && !hasLegacyB) {
+        die("At least one of --amount-sol or --amount-token must be provided.\n"
+            + "  Examples:\n"
+            + `    outsmart add-liq --dex ${adapter.name} --pool <POOL> --amount-sol 0.5\n`
+            + `    outsmart add-liq --dex ${adapter.name} --pool <POOL> --amount-token 1000 --token <MINT>\n`
+            + `    outsmart add-liq --dex ${adapter.name} --pool <POOL> --amount-sol 0.5 --amount-token 1000`);
+    }
+    // Validate strategy
+    const validStrategies = ["spot", "curve", "bid-ask"];
+    if (cmdOpts.strategy && !validStrategies.includes(cmdOpts.strategy)) {
+        die(`Invalid strategy "${cmdOpts.strategy}". Must be one of: ${validStrategies.join(", ")}`);
+    }
+    const params = {
+        poolAddress: cmdOpts.pool,
+        amountSol: hasAmountSol ? Number(cmdOpts.amountSol) : undefined,
+        amountToken: hasAmountToken ? Number(cmdOpts.amountToken) : undefined,
+        tokenMint: cmdOpts.token,
+        strategy: cmdOpts.strategy,
+        bins: cmdOpts.bins != null ? Number(cmdOpts.bins) : undefined,
+        amountA: hasLegacyA ? Number(cmdOpts.amountA) : undefined,
+        amountB: hasLegacyB ? Number(cmdOpts.amountB) : undefined,
+        opts: buildSwapOpts(cmdOpts),
+    };
+    const mode = params.amountSol && params.amountToken
+        ? "balanced" : params.amountSol ? "one-sided SOL" : "one-sided token";
+    console.log(`\n  adding ${mode} liquidity on ${adapter.name} (pool: ${params.poolAddress})...`);
+    if (cmdOpts.strategy)
+        console.log(`  strategy:  ${cmdOpts.strategy}`);
+    if (cmdOpts.bins)
+        console.log(`  bins:      ${cmdOpts.bins}`);
+    const result = await adapter.addLiquidity(params);
+    console.log();
+    console.log(`  tx:        ${result.txSignature}`);
+    console.log(`  confirmed: ${result.confirmed}`);
+    if (result.positionAddress) {
+        console.log(`  position:  ${result.positionAddress}`);
+    }
+    if (result.error) {
+        console.log(`  error:     ${result.error}`);
+    }
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// outsmart remove-liq
+// ---------------------------------------------------------------------------
+program
+    .command("remove-liq")
+    .description("Remove liquidity from a pool")
+    .requiredOption("-d, --dex <name>", "DEX adapter name (e.g. meteora-dlmm)")
+    .requiredOption("-p, --pool <address>", "pool address")
+    .requiredOption("--pct <percentage>", "percentage of LP position to remove (0-100)")
+    .option("--position <address>", "specific position address to remove from (default: first found)")
+    .option("--slippage <bps>", "slippage tolerance in basis points")
+    .option("--priority <microLamports>", "priority fee in microLamports per CU")
+    .option("--tip <sol>", "MEV tip in SOL")
+    .action(async (cmdOpts) => {
+    const adapter = (0, dex_1.getDexAdapter)(cmdOpts.dex);
+    if (!adapter.capabilities.canRemoveLiquidity) {
+        die(`${adapter.name} does not support removeLiquidity`);
+    }
+    if (!adapter.removeLiquidity) {
+        die(`${adapter.name} declares canRemoveLiquidity but has no removeLiquidity() implementation`);
+    }
+    const params = {
+        poolAddress: cmdOpts.pool,
+        percentage: Number(cmdOpts.pct),
+        positionAddress: cmdOpts.position,
+        opts: buildSwapOpts(cmdOpts),
+    };
+    console.log(`\n  removing ${params.percentage}% liquidity on ${adapter.name} (pool: ${params.poolAddress})...`);
+    if (params.positionAddress) {
+        console.log(`  position:  ${params.positionAddress}`);
+    }
+    const result = await adapter.removeLiquidity(params);
+    console.log();
+    console.log(`  tx:        ${result.txSignature}`);
+    console.log(`  confirmed: ${result.confirmed}`);
+    if (result.positionAddress) {
+        console.log(`  position:  ${result.positionAddress}`);
+    }
+    if (result.error) {
+        console.log(`  error:     ${result.error}`);
+    }
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// outsmart claim-fees
+// ---------------------------------------------------------------------------
+program
+    .command("claim-fees")
+    .description("Claim accumulated swap fees from LP positions")
+    .requiredOption("-d, --dex <name>", "DEX adapter name (e.g. meteora-dlmm)")
+    .requiredOption("-p, --pool <address>", "pool address")
+    .option("--position <address>", "specific position address to claim from (default: first found)")
+    .action(async (cmdOpts) => {
+    const adapter = (0, dex_1.getDexAdapter)(cmdOpts.dex);
+    if (!adapter.capabilities.canClaimFees) {
+        die(`${adapter.name} does not support claimFees`);
+    }
+    if (!adapter.claimFees) {
+        die(`${adapter.name} declares canClaimFees but has no claimFees() implementation`);
+    }
+    console.log(`\n  claiming fees on ${adapter.name} (pool: ${cmdOpts.pool})...`);
+    const result = await adapter.claimFees(cmdOpts.pool, cmdOpts.position);
+    console.log();
+    console.log(`  tx:        ${result.txSignature}`);
+    console.log(`  confirmed: ${result.confirmed}`);
+    if (result.positionAddress) {
+        console.log(`  position:  ${result.positionAddress}`);
+    }
+    if (result.error) {
+        console.log(`  error:     ${result.error}`);
+    }
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// outsmart positions
+// ---------------------------------------------------------------------------
+program
+    .command("positions")
+    .description("List LP positions in a pool")
+    .requiredOption("-d, --dex <name>", "DEX adapter name (e.g. meteora-dlmm)")
+    .requiredOption("-p, --pool <address>", "pool address")
+    .option("--json", "output as JSON")
+    .action(async (cmdOpts) => {
+    const adapter = (0, dex_1.getDexAdapter)(cmdOpts.dex);
+    if (!adapter.capabilities.canListPositions) {
+        die(`${adapter.name} does not support listPositions`);
+    }
+    if (!adapter.listPositions) {
+        die(`${adapter.name} declares canListPositions but has no listPositions() implementation`);
+    }
+    const positions = await adapter.listPositions(cmdOpts.pool);
+    if (cmdOpts.json) {
+        console.log(JSON.stringify(positions, null, 2));
+        return;
+    }
+    if (positions.length === 0) {
+        console.log(`\n  No positions found in pool ${cmdOpts.pool}\n`);
+        return;
+    }
+    console.log(`\n  ${positions.length} position(s) in pool ${cmdOpts.pool}:\n`);
+    for (const pos of positions) {
+        console.log(`  position:  ${pos.positionAddress}`);
+        console.log(`  bins:      ${pos.lowerBinId} → ${pos.upperBinId}`);
+        console.log(`  in-range:  ${pos.inRange}`);
+        console.log(`  tokenX:    ${pos.amountX} (${pos.tokenXMint})`);
+        console.log(`  tokenY:    ${pos.amountY} (${pos.tokenYMint})`);
+        console.log(`  feeX:      ${pos.feeX}`);
+        console.log(`  feeY:      ${pos.feeY}`);
+        console.log();
+    }
+});
+// ---------------------------------------------------------------------------
+// outsmart create-pump-coin (PumpFun bonding curve)
+// ---------------------------------------------------------------------------
+program
+    .command("create-pump-coin")
+    .description("Create a new PumpFun token with a bonding curve")
+    .requiredOption("--name <name>", "token name")
+    .requiredOption("--symbol <symbol>", "token symbol")
+    .requiredOption("--uri <uri>", "metadata URI (IPFS link to JSON metadata)")
+    .action(async (cmdOpts) => {
+    const adapter = (0, dex_1.getDexAdapter)("pumpfun");
+    console.log(`\n  creating token "${cmdOpts.name}" (${cmdOpts.symbol}) on pump.fun...`);
+    const result = await adapter.create(cmdOpts.name, cmdOpts.symbol, cmdOpts.uri);
+    console.log();
+    console.log(`  tx:        ${result.txSignature}`);
+    console.log(`  confirmed: ${result.confirmed}`);
+    if (result.positionAddress) {
+        console.log(`  mint:      ${result.positionAddress}`);
+    }
+    if (result.poolAddress) {
+        console.log(`  curve:     ${result.poolAddress}`);
+    }
+    if (result.error) {
+        console.log(`  error:     ${result.error}`);
+    }
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// outsmart create-pool (PumpSwap AMM)
+// ---------------------------------------------------------------------------
+program
+    .command("create-pool")
+    .description("Create a new PumpSwap AMM pool with initial liquidity")
+    .requiredOption("--base <mint>", "base token mint address")
+    .requiredOption("--quote <mint>", "quote token mint address (usually WSOL)")
+    .requiredOption("--base-amount <amount>", "initial base token deposit (human-readable)")
+    .requiredOption("--quote-amount <amount>", "initial quote token deposit (human-readable)")
+    .option("--index <number>", "pool index (default: 1; 0 is reserved for canonical pump pools)", "1")
+    .action(async (cmdOpts) => {
+    const adapter = (0, dex_1.getDexAdapter)("pumpfun-amm");
+    console.log(`\n  creating pool on PumpSwap AMM...`);
+    console.log(`  base:      ${cmdOpts.base}`);
+    console.log(`  quote:     ${cmdOpts.quote}`);
+    console.log(`  amounts:   ${cmdOpts.baseAmount} base + ${cmdOpts.quoteAmount} quote`);
+    console.log(`  index:     ${cmdOpts.index}`);
+    const result = await adapter.createPool(cmdOpts.base, cmdOpts.quote, Number(cmdOpts.baseAmount), Number(cmdOpts.quoteAmount), Number(cmdOpts.index));
+    console.log();
+    console.log(`  tx:        ${result.txSignature}`);
+    console.log(`  confirmed: ${result.confirmed}`);
+    if (result.poolAddress) {
+        console.log(`  pool:      ${result.poolAddress}`);
+    }
+    if (result.error) {
+        console.log(`  error:     ${result.error}`);
+    }
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// outsmart create-damm-pool (DAMM v2 custom pool — full fee config)
+// ---------------------------------------------------------------------------
+program
+    .command("create-damm-pool")
+    .description("Create a Meteora DAMM v2 custom pool with full fee configuration")
+    .requiredOption("--base <mint>", "base token mint address")
+    .requiredOption("--base-amount <amount>", "initial base token deposit (human-readable)")
+    .requiredOption("--quote-amount <amount>", "initial quote token deposit (human-readable)")
+    .option("--quote <mint>", "quote token mint (default: WSOL)")
+    .option("--price <number>", "initial price in quote/base units (default: quoteAmount / baseAmount)")
+    .option("--max-fee <bps>", "max base fee in bps, charged at activation (default: 9900)", "9900")
+    .option("--min-fee <bps>", "min base fee in bps, reached after decay (default: 200)", "200")
+    .option("--periods <n>", "number of fee decay periods (default: 1440)", "1440")
+    .option("--duration <secs>", "total fee decay duration in seconds (default: 86400)", "86400")
+    .option("--fee-mode <0|1>", "fee scheduler: 0=linear, 1=exponential (default: 0)", "0")
+    .option("--dynamic-fee", "enable dynamic fee on top of base fee")
+    .option("--collect-mode <0|1>", "fee collection: 0=both tokens, 1=quote only (default: 1)", "1")
+    .option("--activation <timestamp>", "activation unix timestamp (default: immediate)")
+    .option("--alpha-vault", "create alpha vault after pool")
+    .option("--priority <microLamports>", "priority fee in microLamports per CU")
+    .option("--cu <units>", "compute unit limit")
+    .action(async (cmdOpts) => {
+    const adapter = (0, dex_1.getDexAdapter)("meteora-damm-v2");
+    const params = {
+        baseMint: cmdOpts.base,
+        quoteMint: cmdOpts.quote,
+        baseAmount: Number(cmdOpts.baseAmount),
+        quoteAmount: Number(cmdOpts.quoteAmount),
+        initPrice: cmdOpts.price ? Number(cmdOpts.price) : undefined,
+        poolFees: {
+            maxBaseFeeBps: Number(cmdOpts.maxFee),
+            minBaseFeeBps: Number(cmdOpts.minFee),
+            numberOfPeriod: Number(cmdOpts.periods),
+            totalDuration: Number(cmdOpts.duration),
+            feeSchedulerMode: Number(cmdOpts.feeMode),
+            useDynamicFee: !!cmdOpts.dynamicFee,
+            dynamicFeeConfig: null,
+        },
+        collectFeeMode: Number(cmdOpts.collectMode),
+        activationType: 1, // timestamp
+        activationPoint: cmdOpts.activation ? Number(cmdOpts.activation) : null,
+        hasAlphaVault: !!cmdOpts.alphaVault,
+        opts: buildSwapOpts(cmdOpts),
+    };
+    console.log(`\n  creating DAMM v2 custom pool...`);
+    console.log(`  base:      ${cmdOpts.base}`);
+    console.log(`  quote:     ${cmdOpts.quote ?? "WSOL"}`);
+    console.log(`  amounts:   ${cmdOpts.baseAmount} base + ${cmdOpts.quoteAmount} quote`);
+    console.log(`  fees:      ${cmdOpts.maxFee} → ${cmdOpts.minFee} bps (${cmdOpts.feeMode === "1" ? "exponential" : "linear"})`);
+    const result = await adapter.createCustomPool(params);
+    console.log();
+    console.log(`  tx:        ${result.txSignature}`);
+    console.log(`  confirmed: ${result.confirmed}`);
+    if (result.poolAddress)
+        console.log(`  pool:      ${result.poolAddress}`);
+    if (result.positionAddress)
+        console.log(`  position:  ${result.positionAddress}`);
+    if (result.error)
+        console.log(`  error:     ${result.error}`);
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// outsmart create-damm-config-pool (DAMM v2 config-based pool)
+// ---------------------------------------------------------------------------
+program
+    .command("create-damm-config-pool")
+    .description("Create a Meteora DAMM v2 pool using an existing config")
+    .requiredOption("--base <mint>", "base token mint address")
+    .requiredOption("--base-amount <amount>", "initial base token deposit (human-readable)")
+    .requiredOption("--quote-amount <amount>", "initial quote token deposit (human-readable)")
+    .requiredOption("--config <address>", "on-chain config address")
+    .option("--quote <mint>", "quote token mint (default: WSOL)")
+    .option("--price <number>", "initial price in quote/base units (default: quoteAmount / baseAmount)")
+    .option("--activation <timestamp>", "activation unix timestamp (default: immediate)")
+    .option("--lock", "permanently lock the initial liquidity")
+    .option("--priority <microLamports>", "priority fee in microLamports per CU")
+    .option("--cu <units>", "compute unit limit")
+    .action(async (cmdOpts) => {
+    const adapter = (0, dex_1.getDexAdapter)("meteora-damm-v2");
+    const params = {
+        baseMint: cmdOpts.base,
+        quoteMint: cmdOpts.quote,
+        baseAmount: Number(cmdOpts.baseAmount),
+        quoteAmount: Number(cmdOpts.quoteAmount),
+        initPrice: cmdOpts.price ? Number(cmdOpts.price) : undefined,
+        configAddress: cmdOpts.config,
+        activationPoint: cmdOpts.activation ? Number(cmdOpts.activation) : null,
+        lockLiquidity: !!cmdOpts.lock,
+        opts: buildSwapOpts(cmdOpts),
+    };
+    console.log(`\n  creating DAMM v2 config-based pool...`);
+    console.log(`  base:      ${cmdOpts.base}`);
+    console.log(`  quote:     ${cmdOpts.quote ?? "WSOL"}`);
+    console.log(`  config:    ${cmdOpts.config}`);
+    console.log(`  amounts:   ${cmdOpts.baseAmount} base + ${cmdOpts.quoteAmount} quote`);
+    const result = await adapter.createConfigPool(params);
+    console.log();
+    console.log(`  tx:        ${result.txSignature}`);
+    console.log(`  confirmed: ${result.confirmed}`);
+    if (result.poolAddress)
+        console.log(`  pool:      ${result.poolAddress}`);
+    if (result.positionAddress)
+        console.log(`  position:  ${result.positionAddress}`);
+    if (result.error)
+        console.log(`  error:     ${result.error}`);
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// outsmart list-dex
+// ---------------------------------------------------------------------------
+program
+    .command("list-dex")
+    .description("List all registered DEX adapters")
+    .option("--cap <capability>", "filter by capability (e.g. canBuy, canSell, canSnipe)")
+    .option("--json", "output as JSON")
+    .action((cmdOpts) => {
+    let adapters = (0, dex_1.listDexAdapters)();
+    if (cmdOpts.cap) {
+        const cap = cmdOpts.cap;
+        adapters = adapters.filter((a) => a.capabilities[cap]);
+    }
+    if (cmdOpts.json) {
+        console.log(JSON.stringify(adapters, null, 2));
+        return;
+    }
+    console.log();
+    console.log(`  ${adapters.length} DEX adapter(s) registered:\n`);
+    // Table header
+    const nameWidth = 22;
+    const protoWidth = 14;
+    console.log(`  ${"NAME".padEnd(nameWidth)}${"PROTOCOL".padEnd(protoWidth)}CAPABILITIES`);
+    console.log(`  ${"─".repeat(nameWidth)}${"─".repeat(protoWidth)}${"─".repeat(40)}`);
+    for (const a of adapters) {
+        const caps = Object.entries(a.capabilities)
+            .filter(([, v]) => v)
+            .map(([k]) => k.replace("can", "").toLowerCase())
+            .join(", ");
+        console.log(`  ${a.name.padEnd(nameWidth)}${a.protocol.padEnd(protoWidth)}${caps}`);
+    }
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// outsmart config
+// ---------------------------------------------------------------------------
+const configCmd = new commander_1.Command("config")
+    .description("View or update outsmart configuration");
+configCmd
+    .command("show")
+    .description("Show current configuration from environment")
+    .action(() => {
+    const envVars = [
+        "SOLANA_RPC_URL",
+        "RPC_URL",
+        "HELIUS_API_KEY",
+        "JITO_API_KEY",
+        "BLOXROUTE_AUTH_HEADER",
+        "NOZOMI_API_KEY",
+        "BLOCKRAZOR_API_KEY",
+        "NEXTBLOCK_API_KEY",
+        "ZERO_SLOT_API_KEY",
+        "SOYAS_API_KEY",
+        "ASTRALANE_API_KEY",
+        "STELLIUM_API_KEY",
+        "FLASHBLOCK_API_KEY",
+        "NODE1_API_KEY",
+        "TX_LANDING_MODE",
+        "TX_LANDING_PROVIDERS",
+        "DEFAULT_TIP_SOL",
+        "DEFAULT_SLIPPAGE_BPS",
+        "DEFAULT_PRIORITY_FEE",
+    ];
+    console.log();
+    console.log("  outsmart configuration (from environment):\n");
+    for (const key of envVars) {
+        const val = process.env[key];
+        if (val) {
+            // Mask sensitive values
+            const isSensitive = key.includes("KEY") || key.includes("AUTH") || key.includes("PRIVATE");
+            const display = isSensitive ? val.slice(0, 6) + "..." + val.slice(-4) : val;
+            console.log(`  ${key.padEnd(28)} ${display}`);
+        }
+        else {
+            console.log(`  ${key.padEnd(28)} (not set)`);
+        }
+    }
+    console.log();
+});
+configCmd
+    .command("env")
+    .description("Print a .env template with all supported variables")
+    .action(() => {
+    console.log(`# outsmart .env configuration
+# Copy this to .env in your project root
+
+# ─── Solana RPC ───
+SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
+# RPC_URL=              # fallback alias
+
+# ─── Wallet ───
+# WALLET_PRIVATE_KEY=   # base58 private key (or set WALLET_PATH)
+# WALLET_PATH=          # path to keypair JSON file
+
+# ─── TX Landing Providers (API keys) ───
+# HELIUS_API_KEY=
+# JITO_API_KEY=
+# BLOXROUTE_AUTH_HEADER=
+# NOZOMI_API_KEY=
+# BLOCKRAZOR_API_KEY=
+# NEXTBLOCK_API_KEY=
+# ZERO_SLOT_API_KEY=
+# SOYAS_API_KEY=
+# ASTRALANE_API_KEY=
+# STELLIUM_API_KEY=
+# FLASHBLOCK_API_KEY=
+# NODE1_API_KEY=
+
+# ─── TX Landing Strategy ───
+# TX_LANDING_MODE=race          # concurrent|race|random|sequential
+# TX_LANDING_PROVIDERS=         # comma-separated provider names (empty = all enabled)
+# DEFAULT_TIP_SOL=0.001
+
+# ─── Defaults ───
+# DEFAULT_SLIPPAGE_BPS=300      # 3%
+# DEFAULT_PRIORITY_FEE=4000     # microLamports per CU
+`);
+});
+program.addCommand(configCmd);
+// ---------------------------------------------------------------------------
+// outsmart init
+// ---------------------------------------------------------------------------
+program
+    .command("init")
+    .description("Set up outsmart — prompts for wallet key and RPC endpoint")
+    .action(async () => {
+    const readline = await Promise.resolve().then(() => __importStar(require("readline")));
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    const path = await Promise.resolve().then(() => __importStar(require("path")));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ask = (question) => new Promise((resolve) => rl.question(question, (answer) => resolve(answer.trim())));
+    console.log();
+    console.log("  outsmart init");
+    console.log("  ─────────────");
+    console.log();
+    // Determine config location
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "~";
+    const globalDir = path.join(homeDir, ".outsmart");
+    const globalConfig = path.join(globalDir, "config.env");
+    const localConfig = path.join(process.cwd(), ".env");
+    // Check if local .env already exists
+    const hasLocalEnv = fs.existsSync(localConfig);
+    const hasGlobalConfig = fs.existsSync(globalConfig);
+    if (hasLocalEnv) {
+        console.log(`  Found existing .env at ${localConfig}`);
+    }
+    if (hasGlobalConfig) {
+        console.log(`  Found existing config at ${globalConfig}`);
+    }
+    // Ask for required values
+    const privateKey = await ask("  Wallet private key (base58): ");
+    if (!privateKey) {
+        console.log("\n  Aborted — no private key provided.\n");
+        rl.close();
+        return;
+    }
+    // Validate the key
+    try {
+        const bs58Module = await Promise.resolve().then(() => __importStar(require("bs58")));
+        const { Keypair } = await Promise.resolve().then(() => __importStar(require("@solana/web3.js")));
+        const decoded = bs58Module.default.decode(privateKey);
+        const kp = Keypair.fromSecretKey(decoded);
+        console.log(`  Wallet: ${kp.publicKey.toBase58()}`);
+    }
+    catch {
+        console.log("\n  Error: invalid private key. Must be base58-encoded.\n");
+        rl.close();
+        return;
+    }
+    const rpcUrl = await ask("  RPC endpoint (e.g. https://mainnet.helius-rpc.com/?api-key=...): ");
+    if (!rpcUrl) {
+        console.log("\n  Aborted — no RPC endpoint provided.\n");
+        rl.close();
+        return;
+    }
+    // Build config content
+    const configContent = [
+        "# outsmart configuration",
+        `# Generated by outsmart init on ${new Date().toISOString()}`,
+        "",
+        "# ─── Required ───",
+        `PRIVATE_KEY=${privateKey}`,
+        `MAINNET_ENDPOINT=${rpcUrl}`,
+        "",
+        "# ─── TX Landing Providers (optional) ───",
+        "# HELIUS_API_KEY=",
+        "# JITO_API_KEY=",
+        "# BLOXROUTE_AUTH_HEADER=",
+        "# NOZOMI_API_KEY=",
+        "# BLOCKRAZOR_API_KEY=",
+        "# NEXTBLOCK_API_KEY=",
+        "# ZERO_SLOT_API_KEY=",
+        "# SOYAS_API_KEY=",
+        "# ASTRALANE_API_KEY=",
+        "# STELLIUM_API_KEY=",
+        "# FLASHBLOCK_API_KEY=",
+        "# NODE1_API_KEY=",
+        "",
+        "# ─── Trading Defaults (optional) ───",
+        "# TX_LANDING_MODE=concurrent",
+        "# DEFAULT_TIP_SOL=0.001",
+        "# DEFAULT_SLIPPAGE_BPS=300",
+        "# DEFAULT_PRIORITY_FEE=4000",
+        "",
+    ].join("\n");
+    // Write to global config (~/.outsmart/config.env)
+    if (!fs.existsSync(globalDir)) {
+        fs.mkdirSync(globalDir, { recursive: true });
+    }
+    fs.writeFileSync(globalConfig, configContent, { mode: 0o600 });
+    console.log(`\n  Config written to ${globalConfig}`);
+    console.log("  (file permissions set to owner-only read/write)");
+    // Also write local .env if we're in a project directory
+    const hasPkgJson = fs.existsSync(path.join(process.cwd(), "package.json"));
+    if (hasPkgJson && !hasLocalEnv) {
+        fs.writeFileSync(localConfig, configContent, { mode: 0o600 });
+        console.log(`  Also written to ${localConfig}`);
+    }
+    console.log();
+    console.log("  You're ready to trade:");
+    console.log("    outsmart buy --dex raydium-cpmm --pool <POOL> --amount 0.1");
+    console.log("    outsmart buy --dex jupiter-ultra --token <MINT> --amount 0.1");
+    console.log("    outsmart list-dex");
+    console.log();
+    rl.close();
+});
+// ---------------------------------------------------------------------------
+// outsmart info
+// ---------------------------------------------------------------------------
+program
+    .command("info")
+    .description("Show token info from DexScreener")
+    .requiredOption("-t, --token <mint>", "token mint address")
+    .action(async (cmdOpts) => {
+    const { getInfoFromDexscreener } = await Promise.resolve().then(() => __importStar(require("./dexscreener/info")));
+    const info = await getInfoFromDexscreener(cmdOpts.token);
+    console.log();
+    console.log(`  name:       ${info.name}`);
+    console.log(`  address:    ${info.address}`);
+    console.log(`  price:      $${info.priceInUSD}`);
+    console.log(`  mcap:       $${Number(info.marketCap).toLocaleString()}`);
+    console.log(`  age:        ${info.pairAge}`);
+    console.log(`  liq (SOL):  ${info.liquidityInSOL}`);
+    console.log(`  pool:       ${info.poolId}`);
+    console.log();
+    console.log(`  vol 5m/1h/6h/24h:    ${info.volume5m} / ${info.volume1h} / ${info.volume6h} / ${info.volume24h}`);
+    console.log(`  buyers 5m/1h/6h/24h: ${info.buyers5m} / ${info.buyers1h} / ${info.buyers6h} / ${info.buyers24h}`);
+    console.log();
+    if (info.dexscreenerURL)
+        console.log(`  dexscreener: ${info.dexscreenerURL}`);
+    if (info.twitterURL)
+        console.log(`  twitter:     ${info.twitterURL}`);
+    if (info.telegramURL)
+        console.log(`  telegram:    ${info.telegramURL}`);
+    if (info.websiteURL)
+        console.log(`  website:     ${info.websiteURL}`);
+    console.log();
+});
+// ---------------------------------------------------------------------------
+// Graceful shutdown — prevents hanging on Ctrl+C during long RPC calls
+// ---------------------------------------------------------------------------
+for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+        console.log("\nShutting down...");
+        process.exit(0);
+    });
+}
+// ---------------------------------------------------------------------------
+// Parse & run
+// ---------------------------------------------------------------------------
+program.parseAsync(process.argv).catch((err) => {
+    console.error(`\n  fatal: ${err.message}\n`);
+    if (process.env.DEBUG) {
+        console.error(err.stack);
+    }
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map