imm-cli 0.1.0

package/dist/commands/jaine.js

@@ -0,0 +1,1397 @@
+import { Command } from "commander";
+import { isAddress, getAddress, parseUnits, formatUnits, maxUint256, encodeFunctionData, } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { createWalletClient, http } from "viem";
+import { loadConfig } from "../config/store.js";
+import { getPublicClient } from "../wallet/client.js";
+import { loadKeystore, decryptPrivateKey } from "../wallet/keystore.js";
+import { requireKeystorePassword } from "../utils/env.js";
+import { ImmError, ErrorCodes } from "../errors.js";
+import { isHeadless, writeJsonSuccess, writeStderr } from "../utils/output.js";
+import { spinner, successBox, infoBox, colors, formatBalance, createTable } from "../utils/ui.js";
+// Jaine module imports
+import { resolveToken, getTokenSymbol } from "../jaine/coreTokens.js";
+import { loadUserTokens, addUserAlias, removeUserAlias, getMergedTokens } from "../jaine/userTokens.js";
+import { loadPoolsCache, savePoolsCache, scanCorePools, findPoolsForToken, findPoolsBetweenTokens, } from "../jaine/poolCache.js";
+import { POOLS_CACHE_FILE } from "../jaine/paths.js";
+import { FEE_TIERS } from "../jaine/abi/factory.js";
+import { ERC20_EXTENDED_ABI } from "../jaine/abi/erc20.js";
+import { W0G_ABI } from "../jaine/abi/w0g.js";
+import { ROUTER_ABI } from "../jaine/abi/router.js";
+import { NFT_MANAGER_ABI } from "../jaine/abi/nftManager.js";
+import { POOL_ABI } from "../jaine/abi/pool.js";
+import { getAllAllowances, ensureAllowance, revokeApproval, getSpenderAddress, } from "../jaine/allowance.js";
+import { findBestRouteExactInput, findBestRouteExactOutput, formatRoute, } from "../jaine/routing.js";
+// Validation helpers
+function validateFeeTier(fee) {
+    if (!FEE_TIERS.includes(fee)) {
+        throw new ImmError(ErrorCodes.INVALID_FEE_TIER, `Invalid fee tier: ${fee}`, `Valid fee tiers: ${FEE_TIERS.join(", ")}`);
+    }
+    return fee;
+}
+function validateSlippage(bps) {
+    if (bps < 0 || bps > 5000) {
+        throw new ImmError(ErrorCodes.INVALID_SLIPPAGE, `Invalid slippage: ${bps} bps`, "Slippage must be between 0 and 5000 bps (0-50%)");
+    }
+    return bps;
+}
+function parseIntSafe(value, name) {
+    const n = parseInt(value, 10);
+    if (!Number.isFinite(n)) {
+        throw new ImmError(ErrorCodes.INVALID_AMOUNT, `Invalid ${name}: ${value}`);
+    }
+    return n;
+}
+async function getTokenDecimals(token) {
+    const client = getPublicClient();
+    const decimals = await client.readContract({
+        address: token,
+        abi: ERC20_EXTENDED_ABI,
+        functionName: "decimals",
+    });
+    const n = Number(decimals);
+    // Guard: NaN or out of range → fallback 18
+    if (!Number.isFinite(n) || n < 0 || n > 255) {
+        return 18;
+    }
+    return n;
+}
+async function getTokenSymbolOnChain(token) {
+    const client = getPublicClient();
+    try {
+        return await client.readContract({
+            address: token,
+            abi: ERC20_EXTENDED_ABI,
+            functionName: "symbol",
+        });
+    }
+    catch {
+        return getTokenSymbol(token);
+    }
+}
+function requireWalletAndKeystore() {
+    const cfg = loadConfig();
+    if (!cfg.wallet.address) {
+        throw new ImmError(ErrorCodes.WALLET_NOT_CONFIGURED, "No wallet configured.", "Run: imm wallet create --json");
+    }
+    const password = requireKeystorePassword();
+    const keystore = loadKeystore();
+    if (!keystore) {
+        throw new ImmError(ErrorCodes.KEYSTORE_NOT_FOUND, "Keystore not found.", "Run: imm wallet create --json");
+    }
+    const privateKey = decryptPrivateKey(keystore, password);
+    return { address: cfg.wallet.address, privateKey };
+}
+function createJaineWalletClient(privateKey) {
+    const cfg = loadConfig();
+    const account = privateKeyToAccount(privateKey);
+    return createWalletClient({
+        account,
+        chain: {
+            id: cfg.chain.chainId,
+            name: "0G",
+            nativeCurrency: { name: "0G", symbol: "0G", decimals: 18 },
+            rpcUrls: { default: { http: [cfg.chain.rpcUrl] } },
+        },
+        transport: http(cfg.chain.rpcUrl, {
+            timeout: 30_000,
+            retryCount: 2,
+        }),
+    });
+}
+export function createJaineCommand() {
+    const jaine = new Command("jaine")
+        .description("Jaine DEX operations (swap, LP, pools)")
+        .exitOverride();
+    // ============ TOKENS SUBCOMMAND ============
+    const tokens = new Command("tokens")
+        .description("Manage token aliases")
+        .exitOverride();
+    tokens
+        .command("list")
+        .description("List all known tokens (core + user aliases)")
+        .action(async () => {
+        const merged = getMergedTokens();
+        const userConfig = loadUserTokens();
+        if (isHeadless()) {
+            writeJsonSuccess({
+                tokens: Object.entries(merged).map(([symbol, address]) => ({
+                    symbol,
+                    address,
+                    isUserAlias: !!userConfig.aliases[symbol],
+                })),
+            });
+        }
+        else {
+            const table = createTable([
+                { header: "Symbol", width: 15 },
+                { header: "Address", width: 45 },
+                { header: "Source", width: 10 },
+            ]);
+            for (const [symbol, address] of Object.entries(merged).sort((a, b) => a[0].localeCompare(b[0]))) {
+                const source = userConfig.aliases[symbol] ? colors.info("user") : colors.muted("core");
+                table.push([symbol, address, source]);
+            }
+            writeStderr(table.toString());
+        }
+    });
+    tokens
+        .command("add-alias <symbol> <address>")
+        .description("Add a user token alias")
+        .action(async (symbol, address) => {
+        if (!isAddress(address)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${address}`);
+        }
+        addUserAlias(symbol, getAddress(address));
+        if (isHeadless()) {
+            writeJsonSuccess({ symbol, address: getAddress(address) });
+        }
+        else {
+            successBox("Token Alias Added", `${colors.info(symbol)} → ${colors.address(address)}`);
+        }
+    });
+    tokens
+        .command("remove-alias <symbol>")
+        .description("Remove a user token alias")
+        .action(async (symbol) => {
+        const removed = removeUserAlias(symbol);
+        if (!removed) {
+            throw new ImmError(ErrorCodes.TOKEN_NOT_FOUND, `Alias not found: ${symbol}`);
+        }
+        if (isHeadless()) {
+            writeJsonSuccess({ symbol, removed: true });
+        }
+        else {
+            successBox("Token Alias Removed", `Removed alias: ${colors.info(symbol)}`);
+        }
+    });
+    jaine.addCommand(tokens);
+    // ============ POOLS SUBCOMMAND ============
+    const pools = new Command("pools")
+        .description("Pool discovery and cache management")
+        .exitOverride();
+    pools
+        .command("scan-core")
+        .description("Scan factory for pools between core tokens")
+        .option("--fee-tiers <tiers>", "Comma-separated fee tiers", FEE_TIERS.join(","))
+        .action(async (options) => {
+        const feeTiers = options.feeTiers.split(",").map((t) => validateFeeTier(parseIntSafe(t.trim(), "feeTier")));
+        const spin = spinner("Scanning pools...");
+        spin.start();
+        const cfg = loadConfig();
+        const foundPools = await scanCorePools(feeTiers, (found, scanned) => {
+            if (!isHeadless()) {
+                spin.text = `Scanning pools... (${found} found, ${scanned} pairs scanned)`;
+            }
+        });
+        const cache = {
+            version: 1,
+            chainId: cfg.chain.chainId,
+            generatedAt: new Date().toISOString(),
+            pools: foundPools,
+        };
+        savePoolsCache(cache);
+        spin.succeed(`Found ${foundPools.length} pools`);
+        if (isHeadless()) {
+            writeJsonSuccess({
+                poolsFound: foundPools.length,
+                generatedAt: cache.generatedAt,
+                pools: foundPools,
+            });
+        }
+        else {
+            infoBox("Pool Cache Updated", `Found: ${colors.value(foundPools.length.toString())} pools\n` +
+                `Saved to: ${colors.muted(POOLS_CACHE_FILE)}`);
+        }
+    });
+    pools
+        .command("for-token <token>")
+        .description("Find pools containing a specific token")
+        .action(async (token) => {
+        const userTokens = loadUserTokens();
+        const tokenAddr = resolveToken(token, userTokens.aliases);
+        const cache = loadPoolsCache();
+        if (!cache) {
+            throw new ImmError(ErrorCodes.NO_ROUTE_FOUND, "Pool cache is empty", "Run: imm jaine pools scan-core");
+        }
+        const matchingPools = findPoolsForToken(tokenAddr, cache);
+        if (isHeadless()) {
+            writeJsonSuccess({
+                token: tokenAddr,
+                pools: matchingPools,
+            });
+        }
+        else {
+            if (matchingPools.length === 0) {
+                infoBox("No Pools Found", `No pools found for ${getTokenSymbol(tokenAddr, userTokens.aliases)}`);
+            }
+            else {
+                const table = createTable([
+                    { header: "Pool", width: 45 },
+                    { header: "Token0", width: 12 },
+                    { header: "Token1", width: 12 },
+                    { header: "Fee", width: 8 },
+                ]);
+                for (const pool of matchingPools) {
+                    table.push([
+                        pool.address,
+                        getTokenSymbol(pool.token0, userTokens.aliases),
+                        getTokenSymbol(pool.token1, userTokens.aliases),
+                        `${(pool.fee / 10000).toFixed(2)}%`,
+                    ]);
+                }
+                writeStderr(table.toString());
+            }
+        }
+    });
+    pools
+        .command("find <tokenIn> <tokenOut>")
+        .description("Find pools between two tokens")
+        .option("--amount-in <amount>", "Amount in for quote")
+        .action(async (tokenIn, tokenOut, options) => {
+        const userTokens = loadUserTokens();
+        const tokenInAddr = resolveToken(tokenIn, userTokens.aliases);
+        const tokenOutAddr = resolveToken(tokenOut, userTokens.aliases);
+        const directPools = findPoolsBetweenTokens(tokenInAddr, tokenOutAddr);
+        if (options.amountIn) {
+            const decimals = await getTokenDecimals(tokenInAddr);
+            const amountIn = parseUnits(options.amountIn, decimals);
+            const spin = spinner("Finding best route...");
+            spin.start();
+            const bestRoute = await findBestRouteExactInput(tokenInAddr, tokenOutAddr, amountIn);
+            spin.succeed("Route found");
+            if (!bestRoute) {
+                throw new ImmError(ErrorCodes.NO_ROUTE_FOUND, "No route found for this swap");
+            }
+            const decimalsOut = await getTokenDecimals(tokenOutAddr);
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    tokenIn: tokenInAddr,
+                    tokenOut: tokenOutAddr,
+                    amountIn: amountIn.toString(),
+                    amountOut: bestRoute.amountOut.toString(),
+                    route: formatRoute(bestRoute, userTokens.aliases),
+                    hops: bestRoute.tokens.length - 1,
+                    directPools,
+                });
+            }
+            else {
+                infoBox("Best Route", `${colors.value(options.amountIn)} ${getTokenSymbol(tokenInAddr, userTokens.aliases)} → ` +
+                    `${colors.value(formatUnits(bestRoute.amountOut, decimalsOut))} ${getTokenSymbol(tokenOutAddr, userTokens.aliases)}\n\n` +
+                    `Route: ${formatRoute(bestRoute, userTokens.aliases)}\n` +
+                    `Hops: ${bestRoute.tokens.length - 1}`);
+            }
+        }
+        else {
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    tokenIn: tokenInAddr,
+                    tokenOut: tokenOutAddr,
+                    directPools,
+                });
+            }
+            else {
+                if (directPools.length === 0) {
+                    infoBox("No Direct Pools", "No direct pools found. Multi-hop routing may still work.");
+                }
+                else {
+                    const table = createTable([
+                        { header: "Pool", width: 45 },
+                        { header: "Fee", width: 10 },
+                    ]);
+                    for (const pool of directPools) {
+                        table.push([pool.address, `${(pool.fee / 10000).toFixed(2)}%`]);
+                    }
+                    writeStderr(table.toString());
+                }
+            }
+        }
+    });
+    jaine.addCommand(pools);
+    // ============ W0G SUBCOMMAND ============
+    const w0g = new Command("w0g")
+        .description("Wrap/unwrap native 0G to w0G")
+        .exitOverride();
+    w0g
+        .command("balance")
+        .description("Show native 0G and w0G balances")
+        .action(async () => {
+        const cfg = loadConfig();
+        if (!cfg.wallet.address) {
+            throw new ImmError(ErrorCodes.WALLET_NOT_CONFIGURED, "No wallet configured.");
+        }
+        const client = getPublicClient();
+        const w0gAddr = cfg.protocol.w0g;
+        const [nativeBalance, w0gBalance] = await Promise.all([
+            client.getBalance({ address: cfg.wallet.address }),
+            client.readContract({
+                address: w0gAddr,
+                abi: W0G_ABI,
+                functionName: "balanceOf",
+                args: [cfg.wallet.address],
+            }),
+        ]);
+        if (isHeadless()) {
+            writeJsonSuccess({
+                native0G: nativeBalance.toString(),
+                w0G: w0gBalance.toString(),
+                formatted: {
+                    native0G: formatUnits(nativeBalance, 18),
+                    w0G: formatUnits(w0gBalance, 18),
+                },
+            });
+        }
+        else {
+            infoBox("0G Balances", `Native 0G: ${colors.value(formatBalance(nativeBalance, 18))} 0G\n` +
+                `Wrapped w0G: ${colors.value(formatBalance(w0gBalance, 18))} w0G`);
+        }
+    });
+    w0g
+        .command("wrap")
+        .description("Wrap native 0G to w0G")
+        .requiredOption("--amount <0G>", "Amount of native 0G to wrap")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        const { privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const amount = parseUnits(options.amount, 18);
+        if (amount <= 0n) {
+            throw new ImmError(ErrorCodes.INVALID_AMOUNT, "Amount must be greater than 0");
+        }
+        const spin = spinner("Wrapping 0G...");
+        spin.start();
+        const walletClient = createJaineWalletClient(privateKey);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: cfg.protocol.w0g,
+                abi: W0G_ABI,
+                functionName: "deposit",
+                value: amount,
+            });
+            spin.succeed("0G wrapped successfully");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    txHash,
+                    explorerUrl,
+                    amount: amount.toString(),
+                    formatted: options.amount,
+                });
+            }
+            else {
+                successBox("0G Wrapped", `Amount: ${colors.value(options.amount)} 0G → w0G\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Wrap failed");
+            throw new ImmError(ErrorCodes.RPC_ERROR, `Wrap failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    w0g
+        .command("unwrap")
+        .description("Unwrap w0G to native 0G")
+        .requiredOption("--amount <w0G>", "Amount of w0G to unwrap")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        const { privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const amount = parseUnits(options.amount, 18);
+        if (amount <= 0n) {
+            throw new ImmError(ErrorCodes.INVALID_AMOUNT, "Amount must be greater than 0");
+        }
+        const spin = spinner("Unwrapping w0G...");
+        spin.start();
+        const walletClient = createJaineWalletClient(privateKey);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: cfg.protocol.w0g,
+                abi: W0G_ABI,
+                functionName: "withdraw",
+                args: [amount],
+            });
+            spin.succeed("w0G unwrapped successfully");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    txHash,
+                    explorerUrl,
+                    amount: amount.toString(),
+                    formatted: options.amount,
+                });
+            }
+            else {
+                successBox("w0G Unwrapped", `Amount: ${colors.value(options.amount)} w0G → 0G\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Unwrap failed");
+            throw new ImmError(ErrorCodes.RPC_ERROR, `Unwrap failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    jaine.addCommand(w0g);
+    // ============ ALLOWANCE SUBCOMMAND ============
+    const allowance = new Command("allowance")
+        .description("Manage token approvals for Jaine contracts")
+        .exitOverride();
+    allowance
+        .command("show <token>")
+        .description("Show current allowances for a token")
+        .option("--spender <type>", "Spender type (router|nft)", "router")
+        .action(async (token, options) => {
+        const cfg = loadConfig();
+        if (!cfg.wallet.address) {
+            throw new ImmError(ErrorCodes.WALLET_NOT_CONFIGURED, "No wallet configured.");
+        }
+        const userTokens = loadUserTokens();
+        const tokenAddr = resolveToken(token, userTokens.aliases);
+        const allowances = await getAllAllowances(tokenAddr, cfg.wallet.address);
+        const decimals = await getTokenDecimals(tokenAddr);
+        const symbol = await getTokenSymbolOnChain(tokenAddr);
+        if (isHeadless()) {
+            writeJsonSuccess({
+                token: tokenAddr,
+                symbol,
+                allowances: {
+                    router: allowances.router.toString(),
+                    nft: allowances.nft.toString(),
+                },
+                formatted: {
+                    router: allowances.router === maxUint256 ? "unlimited" : formatUnits(allowances.router, decimals),
+                    nft: allowances.nft === maxUint256 ? "unlimited" : formatUnits(allowances.nft, decimals),
+                },
+            });
+        }
+        else {
+            const formatAllowance = (val) => val === maxUint256 ? colors.success("unlimited") : colors.value(formatUnits(val, decimals));
+            infoBox(`Allowances for ${symbol}`, `Router: ${formatAllowance(allowances.router)}\n` + `NFT Manager: ${formatAllowance(allowances.nft)}`);
+        }
+    });
+    allowance
+        .command("revoke <token>")
+        .description("Revoke approval for a token")
+        .option("--spender <type>", "Spender type (router|nft)", "router")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (token, options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        const { privateKey } = requireWalletAndKeystore();
+        const userTokens = loadUserTokens();
+        const tokenAddr = resolveToken(token, userTokens.aliases);
+        const spenderAddr = getSpenderAddress(options.spender);
+        const spin = spinner("Revoking approval...");
+        spin.start();
+        const txHash = await revokeApproval(tokenAddr, spenderAddr, privateKey);
+        spin.succeed("Approval revoked");
+        const cfg = loadConfig();
+        const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+        if (isHeadless()) {
+            writeJsonSuccess({ txHash, explorerUrl, token: tokenAddr, spender: spenderAddr });
+        }
+        else {
+            successBox("Approval Revoked", `Token: ${colors.address(tokenAddr)}\n` +
+                `Spender: ${options.spender}\n` +
+                `Tx: ${colors.info(txHash)}`);
+        }
+    });
+    jaine.addCommand(allowance);
+    // ============ SWAP SUBCOMMAND ============
+    const swap = new Command("swap")
+        .description("Swap tokens on Jaine DEX")
+        .exitOverride();
+    swap
+        .command("sell <tokenIn> <tokenOut>")
+        .description("Sell exact amount of tokenIn for tokenOut")
+        .requiredOption("--amount-in <amount>", "Amount of tokenIn to sell")
+        .option("--slippage-bps <bps>", "Slippage tolerance in basis points", "50")
+        .option("--deadline-sec <sec>", "Transaction deadline in seconds", "90")
+        .option("--recipient <address>", "Recipient address (defaults to wallet)")
+        .option("--max-hops <n>", "Maximum routing hops", "3")
+        .option("--approve-exact", "Approve exact amount instead of unlimited")
+        .option("--dry-run", "Show quote without executing")
+        .option("--yes", "Confirm the transaction")
+        .action(async (tokenIn, tokenOut, options) => {
+        const userTokens = loadUserTokens();
+        const tokenInAddr = resolveToken(tokenIn, userTokens.aliases);
+        const tokenOutAddr = resolveToken(tokenOut, userTokens.aliases);
+        const slippageBps = validateSlippage(parseIntSafe(options.slippageBps, "slippageBps"));
+        const maxHops = Math.min(Math.max(parseIntSafe(options.maxHops, "maxHops"), 1), 4);
+        const deadlineSec = parseIntSafe(options.deadlineSec, "deadlineSec");
+        const decimalsIn = await getTokenDecimals(tokenInAddr);
+        const decimalsOut = await getTokenDecimals(tokenOutAddr);
+        const amountIn = parseUnits(options.amountIn, decimalsIn);
+        // Find best route
+        const spin = spinner("Finding best route...");
+        spin.start();
+        const route = await findBestRouteExactInput(tokenInAddr, tokenOutAddr, amountIn, {
+            maxHops,
+        });
+        if (!route) {
+            spin.fail("No route found");
+            throw new ImmError(ErrorCodes.NO_ROUTE_FOUND, "No route found for this swap");
+        }
+        spin.succeed("Route found");
+        // Calculate minimum output with slippage
+        const amountOutMinimum = (route.amountOut * BigInt(10000 - slippageBps)) / 10000n;
+        const routeStr = formatRoute(route, userTokens.aliases);
+        // Dry run output
+        if (options.dryRun) {
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    dryRun: true,
+                    tokenIn: tokenInAddr,
+                    tokenOut: tokenOutAddr,
+                    amountIn: amountIn.toString(),
+                    amountOut: route.amountOut.toString(),
+                    amountOutMinimum: amountOutMinimum.toString(),
+                    route: routeStr,
+                    hops: route.tokens.length - 1,
+                    slippageBps,
+                    formatted: {
+                        amountIn: options.amountIn,
+                        amountOut: formatUnits(route.amountOut, decimalsOut),
+                        amountOutMinimum: formatUnits(amountOutMinimum, decimalsOut),
+                    },
+                });
+            }
+            else {
+                infoBox("Swap Quote (Dry Run)", `Sell: ${colors.value(options.amountIn)} ${getTokenSymbol(tokenInAddr, userTokens.aliases)}\n` +
+                    `Receive: ~${colors.value(formatUnits(route.amountOut, decimalsOut))} ${getTokenSymbol(tokenOutAddr, userTokens.aliases)}\n` +
+                    `Min receive: ${colors.value(formatUnits(amountOutMinimum, decimalsOut))}\n` +
+                    `Route: ${routeStr}\n` +
+                    `Slippage: ${(slippageBps / 100).toFixed(2)}%`);
+            }
+            return;
+        }
+        // Require --yes for actual execution
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm (or --dry-run to preview)");
+        }
+        const { address, privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        let recipient = address;
+        if (options.recipient) {
+            if (!isAddress(options.recipient)) {
+                throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid recipient: ${options.recipient}`);
+            }
+            recipient = getAddress(options.recipient);
+        }
+        // Check and approve if needed
+        const spinApprove = spinner("Checking allowance...");
+        spinApprove.start();
+        const approvalResult = await ensureAllowance(tokenInAddr, cfg.protocol.jaineRouter, amountIn, privateKey, options.approveExact);
+        if (approvalResult && approvalResult.txHash !== "0x0") {
+            spinApprove.succeed("Token approved");
+        }
+        else {
+            spinApprove.succeed("Allowance sufficient");
+        }
+        // Execute swap
+        const spinSwap = spinner("Executing swap...");
+        spinSwap.start();
+        const walletClient = createJaineWalletClient(privateKey);
+        const deadline = BigInt(Math.floor(Date.now() / 1000) + deadlineSec);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: cfg.protocol.jaineRouter,
+                abi: ROUTER_ABI,
+                functionName: "exactInput",
+                args: [
+                    {
+                        path: route.encodedPath,
+                        recipient,
+                        deadline,
+                        amountIn,
+                        amountOutMinimum,
+                    },
+                ],
+            });
+            spinSwap.succeed("Swap executed");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    txHash,
+                    explorerUrl,
+                    tokenIn: tokenInAddr,
+                    tokenOut: tokenOutAddr,
+                    amountIn: amountIn.toString(),
+                    amountOutExpected: route.amountOut.toString(),
+                    amountOutMinimum: amountOutMinimum.toString(),
+                    route: routeStr,
+                    recipient,
+                });
+            }
+            else {
+                successBox("Swap Executed", `Sold: ${colors.value(options.amountIn)} ${getTokenSymbol(tokenInAddr, userTokens.aliases)}\n` +
+                    `Expected: ~${colors.value(formatUnits(route.amountOut, decimalsOut))} ${getTokenSymbol(tokenOutAddr, userTokens.aliases)}\n` +
+                    `Route: ${routeStr}\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spinSwap.fail("Swap failed");
+            throw new ImmError(ErrorCodes.SWAP_FAILED, `Swap failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    swap
+        .command("buy <tokenIn> <tokenOut>")
+        .description("Buy exact amount of tokenOut using tokenIn")
+        .requiredOption("--amount-out <amount>", "Amount of tokenOut to buy")
+        .option("--slippage-bps <bps>", "Slippage tolerance in basis points", "50")
+        .option("--deadline-sec <sec>", "Transaction deadline in seconds", "90")
+        .option("--recipient <address>", "Recipient address (defaults to wallet)")
+        .option("--max-hops <n>", "Maximum routing hops", "3")
+        .option("--approve-exact", "Approve exact amount instead of unlimited")
+        .option("--dry-run", "Show quote without executing")
+        .option("--yes", "Confirm the transaction")
+        .action(async (tokenIn, tokenOut, options) => {
+        const userTokens = loadUserTokens();
+        const tokenInAddr = resolveToken(tokenIn, userTokens.aliases);
+        const tokenOutAddr = resolveToken(tokenOut, userTokens.aliases);
+        const slippageBps = validateSlippage(parseIntSafe(options.slippageBps, "slippageBps"));
+        const maxHops = Math.min(Math.max(parseIntSafe(options.maxHops, "maxHops"), 1), 4);
+        const deadlineSec = parseIntSafe(options.deadlineSec, "deadlineSec");
+        const decimalsIn = await getTokenDecimals(tokenInAddr);
+        const decimalsOut = await getTokenDecimals(tokenOutAddr);
+        const amountOut = parseUnits(options.amountOut, decimalsOut);
+        // Find best route
+        const spin = spinner("Finding best route...");
+        spin.start();
+        const route = await findBestRouteExactOutput(tokenInAddr, tokenOutAddr, amountOut, {
+            maxHops,
+        });
+        if (!route) {
+            spin.fail("No route found");
+            throw new ImmError(ErrorCodes.NO_ROUTE_FOUND, "No route found for this swap");
+        }
+        spin.succeed("Route found");
+        // Calculate maximum input with slippage
+        const amountInMaximum = (route.amountIn * BigInt(10000 + slippageBps)) / 10000n;
+        const routeStr = formatRoute(route, userTokens.aliases);
+        // Dry run output
+        if (options.dryRun) {
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    dryRun: true,
+                    tokenIn: tokenInAddr,
+                    tokenOut: tokenOutAddr,
+                    amountOut: amountOut.toString(),
+                    amountIn: route.amountIn.toString(),
+                    amountInMaximum: amountInMaximum.toString(),
+                    route: routeStr,
+                    hops: route.tokens.length - 1,
+                    slippageBps,
+                    formatted: {
+                        amountOut: options.amountOut,
+                        amountIn: formatUnits(route.amountIn, decimalsIn),
+                        amountInMaximum: formatUnits(amountInMaximum, decimalsIn),
+                    },
+                });
+            }
+            else {
+                infoBox("Swap Quote (Dry Run)", `Buy: ${colors.value(options.amountOut)} ${getTokenSymbol(tokenOutAddr, userTokens.aliases)}\n` +
+                    `Cost: ~${colors.value(formatUnits(route.amountIn, decimalsIn))} ${getTokenSymbol(tokenInAddr, userTokens.aliases)}\n` +
+                    `Max cost: ${colors.value(formatUnits(amountInMaximum, decimalsIn))}\n` +
+                    `Route: ${routeStr}\n` +
+                    `Slippage: ${(slippageBps / 100).toFixed(2)}%`);
+            }
+            return;
+        }
+        // Require --yes for actual execution
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm (or --dry-run to preview)");
+        }
+        const { address, privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        let recipient = address;
+        if (options.recipient) {
+            if (!isAddress(options.recipient)) {
+                throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid recipient: ${options.recipient}`);
+            }
+            recipient = getAddress(options.recipient);
+        }
+        // Check and approve if needed
+        const spinApprove = spinner("Checking allowance...");
+        spinApprove.start();
+        const approvalResult = await ensureAllowance(tokenInAddr, cfg.protocol.jaineRouter, amountInMaximum, privateKey, options.approveExact);
+        if (approvalResult && approvalResult.txHash !== "0x0") {
+            spinApprove.succeed("Token approved");
+        }
+        else {
+            spinApprove.succeed("Allowance sufficient");
+        }
+        // Execute swap
+        const spinSwap = spinner("Executing swap...");
+        spinSwap.start();
+        const walletClient = createJaineWalletClient(privateKey);
+        const deadline = BigInt(Math.floor(Date.now() / 1000) + deadlineSec);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: cfg.protocol.jaineRouter,
+                abi: ROUTER_ABI,
+                functionName: "exactOutput",
+                args: [
+                    {
+                        path: route.encodedPath,
+                        recipient,
+                        deadline,
+                        amountOut,
+                        amountInMaximum,
+                    },
+                ],
+            });
+            spinSwap.succeed("Swap executed");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    txHash,
+                    explorerUrl,
+                    tokenIn: tokenInAddr,
+                    tokenOut: tokenOutAddr,
+                    amountOut: amountOut.toString(),
+                    amountInExpected: route.amountIn.toString(),
+                    amountInMaximum: amountInMaximum.toString(),
+                    route: routeStr,
+                    recipient,
+                });
+            }
+            else {
+                successBox("Swap Executed", `Bought: ${colors.value(options.amountOut)} ${getTokenSymbol(tokenOutAddr, userTokens.aliases)}\n` +
+                    `Expected cost: ~${colors.value(formatUnits(route.amountIn, decimalsIn))} ${getTokenSymbol(tokenInAddr, userTokens.aliases)}\n` +
+                    `Route: ${routeStr}\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spinSwap.fail("Swap failed");
+            throw new ImmError(ErrorCodes.SWAP_FAILED, `Swap failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    jaine.addCommand(swap);
+    // ============ LP SUBCOMMAND ============
+    const lp = new Command("lp")
+        .description("Liquidity position management")
+        .exitOverride();
+    lp.command("list")
+        .description("List your LP positions")
+        .action(async () => {
+        const cfg = loadConfig();
+        if (!cfg.wallet.address) {
+            throw new ImmError(ErrorCodes.WALLET_NOT_CONFIGURED, "No wallet configured.");
+        }
+        const client = getPublicClient();
+        const nftManager = cfg.protocol.nftPositionManager;
+        const spin = spinner("Fetching positions...");
+        spin.start();
+        const balance = await client.readContract({
+            address: nftManager,
+            abi: NFT_MANAGER_ABI,
+            functionName: "balanceOf",
+            args: [cfg.wallet.address],
+        });
+        if (balance === 0n) {
+            spin.succeed("No positions found");
+            if (isHeadless()) {
+                writeJsonSuccess({ positions: [] });
+            }
+            else {
+                infoBox("LP Positions", "You have no LP positions.");
+            }
+            return;
+        }
+        // Fetch all token IDs
+        const tokenIds = [];
+        for (let i = 0n; i < balance; i++) {
+            const tokenId = await client.readContract({
+                address: nftManager,
+                abi: NFT_MANAGER_ABI,
+                functionName: "tokenOfOwnerByIndex",
+                args: [cfg.wallet.address, i],
+            });
+            tokenIds.push(tokenId);
+        }
+        // Fetch position details
+        const userTokens = loadUserTokens();
+        const positions = [];
+        for (const tokenId of tokenIds) {
+            const position = await client.readContract({
+                address: nftManager,
+                abi: NFT_MANAGER_ABI,
+                functionName: "positions",
+                args: [tokenId],
+            });
+            const [, , token0, token1, fee, tickLower, tickUpper, liquidity, , , tokensOwed0, tokensOwed1,] = position;
+            positions.push({
+                tokenId: tokenId.toString(),
+                token0,
+                token1,
+                fee,
+                tickLower,
+                tickUpper,
+                liquidity: liquidity.toString(),
+                tokensOwed0: tokensOwed0.toString(),
+                tokensOwed1: tokensOwed1.toString(),
+            });
+        }
+        spin.succeed(`Found ${positions.length} positions`);
+        if (isHeadless()) {
+            writeJsonSuccess({ positions });
+        }
+        else {
+            const table = createTable([
+                { header: "ID", width: 8 },
+                { header: "Pair", width: 20 },
+                { header: "Fee", width: 8 },
+                { header: "Liquidity", width: 20 },
+            ]);
+            for (const pos of positions) {
+                const symbol0 = getTokenSymbol(pos.token0, userTokens.aliases);
+                const symbol1 = getTokenSymbol(pos.token1, userTokens.aliases);
+                table.push([
+                    pos.tokenId,
+                    `${symbol0}/${symbol1}`,
+                    `${(pos.fee / 10000).toFixed(2)}%`,
+                    pos.liquidity === "0" ? colors.muted("0") : pos.liquidity,
+                ]);
+            }
+            writeStderr(table.toString());
+        }
+    });
+    lp.command("show <tokenId>")
+        .description("Show details of a specific LP position")
+        .action(async (tokenId) => {
+        const cfg = loadConfig();
+        const client = getPublicClient();
+        const nftManager = cfg.protocol.nftPositionManager;
+        const spin = spinner("Fetching position...");
+        spin.start();
+        try {
+            const position = await client.readContract({
+                address: nftManager,
+                abi: NFT_MANAGER_ABI,
+                functionName: "positions",
+                args: [BigInt(tokenId)],
+            });
+            const [nonce, operator, token0, token1, fee, tickLower, tickUpper, liquidity, feeGrowthInside0LastX128, feeGrowthInside1LastX128, tokensOwed0, tokensOwed1,] = position;
+            spin.succeed("Position loaded");
+            const userTokens = loadUserTokens();
+            const [decimals0, decimals1] = await Promise.all([
+                getTokenDecimals(token0),
+                getTokenDecimals(token1),
+            ]);
+            const symbol0 = getTokenSymbol(token0, userTokens.aliases);
+            const symbol1 = getTokenSymbol(token1, userTokens.aliases);
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    tokenId,
+                    token0,
+                    token1,
+                    fee,
+                    tickLower,
+                    tickUpper,
+                    liquidity: liquidity.toString(),
+                    tokensOwed0: tokensOwed0.toString(),
+                    tokensOwed1: tokensOwed1.toString(),
+                    formatted: {
+                        pair: `${symbol0}/${symbol1}`,
+                        fee: `${(fee / 10000).toFixed(2)}%`,
+                        tokensOwed0: formatUnits(tokensOwed0, decimals0),
+                        tokensOwed1: formatUnits(tokensOwed1, decimals1),
+                    },
+                });
+            }
+            else {
+                infoBox(`Position #${tokenId}`, `Pair: ${colors.info(`${symbol0}/${symbol1}`)}\n` +
+                    `Fee: ${(fee / 10000).toFixed(2)}%\n` +
+                    `Tick Range: ${tickLower} → ${tickUpper}\n` +
+                    `Liquidity: ${liquidity.toString()}\n` +
+                    `\nUncollected Fees:\n` +
+                    `  ${symbol0}: ${colors.value(formatUnits(tokensOwed0, decimals0))}\n` +
+                    `  ${symbol1}: ${colors.value(formatUnits(tokensOwed1, decimals1))}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch position");
+            throw new ImmError(ErrorCodes.POSITION_NOT_FOUND, `Position not found: ${tokenId}`);
+        }
+    });
+    lp.command("collect <tokenId>")
+        .description("Collect fees from LP position")
+        .option("--recipient <address>", "Recipient address")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (tokenId, options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        const { address, privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const recipient = options.recipient ? getAddress(options.recipient) : address;
+        const spin = spinner("Collecting fees...");
+        spin.start();
+        const walletClient = createJaineWalletClient(privateKey);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: cfg.protocol.nftPositionManager,
+                abi: NFT_MANAGER_ABI,
+                functionName: "collect",
+                args: [
+                    {
+                        tokenId: BigInt(tokenId),
+                        recipient,
+                        amount0Max: BigInt("0xffffffffffffffffffffffffffffffff"), // uint128 max
+                        amount1Max: BigInt("0xffffffffffffffffffffffffffffffff"),
+                    },
+                ],
+            });
+            spin.succeed("Fees collected");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({ txHash, explorerUrl, tokenId, recipient });
+            }
+            else {
+                successBox("Fees Collected", `Position: #${tokenId}\n` +
+                    `Recipient: ${colors.address(recipient)}\n` +
+                    `Tx: ${colors.info(txHash)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Collection failed");
+            throw new ImmError(ErrorCodes.LP_OPERATION_FAILED, `Failed to collect: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    lp.command("remove <tokenId>")
+        .description("Remove liquidity from position")
+        .requiredOption("--percent <n>", "Percentage of liquidity to remove (1-100)")
+        .option("--burn", "Burn the NFT after removing all liquidity")
+        .option("--slippage-bps <bps>", "Slippage tolerance", "50")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (tokenId, options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        const percent = parseIntSafe(options.percent, "percent");
+        if (percent < 1 || percent > 100) {
+            throw new ImmError(ErrorCodes.INVALID_AMOUNT, "Percent must be between 1 and 100");
+        }
+        const slippageBps = validateSlippage(parseIntSafe(options.slippageBps, "slippageBps"));
+        const { address, privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const client = getPublicClient();
+        // Fetch position to get liquidity
+        const spin = spinner("Fetching position...");
+        spin.start();
+        const position = await client.readContract({
+            address: cfg.protocol.nftPositionManager,
+            abi: NFT_MANAGER_ABI,
+            functionName: "positions",
+            args: [BigInt(tokenId)],
+        });
+        const [, , token0, token1, , , , liquidity] = position;
+        // Allow operation even with 0 liquidity - user may want to collect fees and/or burn
+        if (liquidity === 0n && !options.burn) {
+            spin.fail("Position has no liquidity");
+            throw new ImmError(ErrorCodes.LP_OPERATION_FAILED, "Position has no liquidity to remove", "Use --burn to collect any remaining fees and burn the NFT");
+        }
+        const liquidityToRemove = (liquidity * BigInt(percent)) / 100n;
+        spin.text = "Removing liquidity...";
+        const walletClient = createJaineWalletClient(privateKey);
+        const deadline = BigInt(Math.floor(Date.now() / 1000) + 90);
+        // Calculate minimum amounts with slippage (simplified - 0 for now)
+        const amount0Min = 0n;
+        const amount1Min = 0n;
+        try {
+            const MAX_UINT128 = (2n ** 128n) - 1n;
+            const calls = [];
+            // 1) decreaseLiquidity (only if there's liquidity to remove)
+            if (liquidityToRemove > 0n) {
+                calls.push(encodeFunctionData({
+                    abi: NFT_MANAGER_ABI,
+                    functionName: "decreaseLiquidity",
+                    args: [{
+                            tokenId: BigInt(tokenId),
+                            liquidity: liquidityToRemove,
+                            amount0Min,
+                            amount1Min,
+                            deadline,
+                        }],
+                }));
+            }
+            // 2) collect (always - clears tokensOwed)
+            calls.push(encodeFunctionData({
+                abi: NFT_MANAGER_ABI,
+                functionName: "collect",
+                args: [{
+                        tokenId: BigInt(tokenId),
+                        recipient: address,
+                        amount0Max: MAX_UINT128,
+                        amount1Max: MAX_UINT128,
+                    }],
+            }));
+            // 3) burn (only with --burn and percent=100)
+            const shouldBurn = options.burn && percent === 100;
+            if (shouldBurn) {
+                calls.push(encodeFunctionData({
+                    abi: NFT_MANAGER_ABI,
+                    functionName: "burn",
+                    args: [BigInt(tokenId)],
+                }));
+            }
+            // Single atomic transaction via multicall
+            const txHash = await walletClient.writeContract({
+                address: cfg.protocol.nftPositionManager,
+                abi: NFT_MANAGER_ABI,
+                functionName: "multicall",
+                args: [calls],
+            });
+            spin.succeed(shouldBurn ? "Liquidity removed and NFT burned" : "Liquidity removed");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    txHash,
+                    explorerUrl,
+                    tokenId,
+                    percent,
+                    liquidityRemoved: liquidityToRemove.toString(),
+                    burned: shouldBurn,
+                });
+            }
+            else {
+                successBox(shouldBurn ? "Liquidity Removed & NFT Burned" : "Liquidity Removed", `Position: #${tokenId}\n` +
+                    `Removed: ${percent}%\n` +
+                    `Tx: ${colors.info(txHash)}` +
+                    (shouldBurn ? `\n${colors.muted("NFT burned")}` : ""));
+            }
+        }
+        catch (err) {
+            spin.fail("Operation failed");
+            throw new ImmError(ErrorCodes.LP_OPERATION_FAILED, `Failed to remove liquidity: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    lp.command("add")
+        .description("Add liquidity to create a new position")
+        .requiredOption("--token0 <token>", "First token")
+        .requiredOption("--token1 <token>", "Second token")
+        .requiredOption("--fee <fee>", "Fee tier (100, 500, 3000, 10000)")
+        .requiredOption("--amount0 <amount>", "Amount of token0")
+        .requiredOption("--amount1 <amount>", "Amount of token1")
+        .option("--range-pct <percent>", "Price range percentage around current price", "10")
+        .option("--tick-lower <tick>", "Lower tick (overrides --range-pct)")
+        .option("--tick-upper <tick>", "Upper tick (overrides --range-pct)")
+        .option("--create-pool", "Create pool if it doesn't exist")
+        .option("--sqrt-price-x96 <uint160>", "Initial sqrtPriceX96 for new pool (as decimal string)")
+        .option("--approve-exact", "Approve exact amounts")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        const userTokens = loadUserTokens();
+        let token0Addr = resolveToken(options.token0, userTokens.aliases);
+        let token1Addr = resolveToken(options.token1, userTokens.aliases);
+        const fee = validateFeeTier(parseIntSafe(options.fee, "fee"));
+        // Sort tokens (token0 < token1)
+        if (token0Addr.toLowerCase() > token1Addr.toLowerCase()) {
+            [token0Addr, token1Addr] = [token1Addr, token0Addr];
+            [options.amount0, options.amount1] = [options.amount1, options.amount0];
+        }
+        const { address, privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const client = getPublicClient();
+        // Fetch decimals
+        const [decimals0, decimals1] = await Promise.all([
+            getTokenDecimals(token0Addr),
+            getTokenDecimals(token1Addr),
+        ]);
+        const amount0Desired = parseUnits(options.amount0, decimals0);
+        const amount1Desired = parseUnits(options.amount1, decimals1);
+        // Check if pool exists
+        const spin = spinner("Checking pool...");
+        spin.start();
+        const poolAddress = await client.readContract({
+            address: cfg.protocol.jaineFactory,
+            abi: [
+                {
+                    type: "function",
+                    name: "getPool",
+                    stateMutability: "view",
+                    inputs: [
+                        { name: "tokenA", type: "address" },
+                        { name: "tokenB", type: "address" },
+                        { name: "fee", type: "uint24" },
+                    ],
+                    outputs: [{ name: "pool", type: "address" }],
+                },
+            ],
+            functionName: "getPool",
+            args: [token0Addr, token1Addr, fee],
+        });
+        const walletClient = createJaineWalletClient(privateKey);
+        if (poolAddress === "0x0000000000000000000000000000000000000000") {
+            if (!options.createPool || !options.sqrtPriceX96) {
+                spin.fail("Pool does not exist");
+                throw new ImmError(ErrorCodes.POOL_NOT_FOUND, "Pool does not exist for this token pair and fee tier", "Use --create-pool --sqrt-price-x96 <uint160> to create it");
+            }
+            // Create pool
+            spin.text = "Creating pool...";
+            // Parse sqrtPriceX96 as BigInt directly (precise, no float conversion)
+            let sqrtPriceX96;
+            try {
+                sqrtPriceX96 = BigInt(options.sqrtPriceX96);
+            }
+            catch {
+                throw new ImmError(ErrorCodes.INVALID_AMOUNT, `Invalid sqrtPriceX96: ${options.sqrtPriceX96}`, "Must be a valid uint160 decimal string");
+            }
+            try {
+                const createTxHash = await walletClient.writeContract({
+                    address: cfg.protocol.nftPositionManager,
+                    abi: NFT_MANAGER_ABI,
+                    functionName: "createAndInitializePoolIfNecessary",
+                    args: [token0Addr, token1Addr, fee, sqrtPriceX96],
+                });
+                // Wait for pool creation to confirm
+                await client.waitForTransactionReceipt({ hash: createTxHash });
+                spin.succeed("Pool created");
+            }
+            catch (err) {
+                spin.fail("Failed to create pool");
+                throw new ImmError(ErrorCodes.LP_OPERATION_FAILED, `Failed to create pool: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+        else {
+            spin.succeed("Pool exists");
+        }
+        // Get current tick for range calculation
+        const spinTick = spinner("Fetching pool state...");
+        spinTick.start();
+        let tickLower;
+        let tickUpper;
+        let tickSpacing;
+        const poolAddr = poolAddress !== "0x0000000000000000000000000000000000000000"
+            ? poolAddress
+            : await client.readContract({
+                address: cfg.protocol.jaineFactory,
+                abi: [
+                    {
+                        type: "function",
+                        name: "getPool",
+                        stateMutability: "view",
+                        inputs: [
+                            { name: "tokenA", type: "address" },
+                            { name: "tokenB", type: "address" },
+                            { name: "fee", type: "uint24" },
+                        ],
+                        outputs: [{ name: "pool", type: "address" }],
+                    },
+                ],
+                functionName: "getPool",
+                args: [token0Addr, token1Addr, fee],
+            });
+        const [slot0, spacing] = await Promise.all([
+            client.readContract({
+                address: poolAddr,
+                abi: POOL_ABI,
+                functionName: "slot0",
+            }),
+            client.readContract({
+                address: poolAddr,
+                abi: POOL_ABI,
+                functionName: "tickSpacing",
+            }),
+        ]);
+        const currentTick = slot0[1];
+        tickSpacing = spacing;
+        if (options.tickLower && options.tickUpper) {
+            tickLower = parseIntSafe(options.tickLower, "tickLower");
+            tickUpper = parseIntSafe(options.tickUpper, "tickUpper");
+        }
+        else {
+            // Calculate range based on percentage
+            const rangePct = parseIntSafe(options.rangePct, "rangePct");
+            // Approximate tick range: 1% price change ≈ 100 ticks
+            const tickRange = Math.floor(rangePct * 100);
+            tickLower = currentTick - tickRange;
+            tickUpper = currentTick + tickRange;
+        }
+        // Round to tick spacing
+        tickLower = Math.floor(tickLower / tickSpacing) * tickSpacing;
+        tickUpper = Math.ceil(tickUpper / tickSpacing) * tickSpacing;
+        spinTick.succeed("Pool state fetched");
+        // Approve tokens
+        const spinApprove = spinner("Approving tokens...");
+        spinApprove.start();
+        await ensureAllowance(token0Addr, cfg.protocol.nftPositionManager, amount0Desired, privateKey, options.approveExact);
+        await ensureAllowance(token1Addr, cfg.protocol.nftPositionManager, amount1Desired, privateKey, options.approveExact);
+        spinApprove.succeed("Tokens approved");
+        // Mint position
+        const spinMint = spinner("Minting position...");
+        spinMint.start();
+        const deadline = BigInt(Math.floor(Date.now() / 1000) + 90);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: cfg.protocol.nftPositionManager,
+                abi: NFT_MANAGER_ABI,
+                functionName: "mint",
+                args: [
+                    {
+                        token0: token0Addr,
+                        token1: token1Addr,
+                        fee,
+                        tickLower,
+                        tickUpper,
+                        amount0Desired,
+                        amount1Desired,
+                        amount0Min: 0n,
+                        amount1Min: 0n,
+                        recipient: address,
+                        deadline,
+                    },
+                ],
+            });
+            spinMint.succeed("Position minted");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            const symbol0 = getTokenSymbol(token0Addr, userTokens.aliases);
+            const symbol1 = getTokenSymbol(token1Addr, userTokens.aliases);
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    txHash,
+                    explorerUrl,
+                    token0: token0Addr,
+                    token1: token1Addr,
+                    fee,
+                    tickLower,
+                    tickUpper,
+                    amount0Desired: amount0Desired.toString(),
+                    amount1Desired: amount1Desired.toString(),
+                });
+            }
+            else {
+                successBox("Position Created", `Pair: ${colors.info(`${symbol0}/${symbol1}`)}\n` +
+                    `Fee: ${(fee / 10000).toFixed(2)}%\n` +
+                    `Range: ${tickLower} → ${tickUpper}\n` +
+                    `Amounts: ${options.amount0} ${symbol0} + ${options.amount1} ${symbol1}\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spinMint.fail("Minting failed");
+            throw new ImmError(ErrorCodes.LP_OPERATION_FAILED, `Failed to mint position: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    lp.command("increase <tokenId>")
+        .description("Add more liquidity to existing position")
+        .requiredOption("--amount0 <amount>", "Amount of token0 to add")
+        .requiredOption("--amount1 <amount>", "Amount of token1 to add")
+        .option("--approve-exact", "Approve exact amounts")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (tokenId, options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        const { address, privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const client = getPublicClient();
+        // Fetch position to get tokens
+        const spin = spinner("Fetching position...");
+        spin.start();
+        const position = await client.readContract({
+            address: cfg.protocol.nftPositionManager,
+            abi: NFT_MANAGER_ABI,
+            functionName: "positions",
+            args: [BigInt(tokenId)],
+        });
+        const [, , token0, token1] = position;
+        const [decimals0, decimals1] = await Promise.all([
+            getTokenDecimals(token0),
+            getTokenDecimals(token1),
+        ]);
+        const amount0Desired = parseUnits(options.amount0, decimals0);
+        const amount1Desired = parseUnits(options.amount1, decimals1);
+        spin.text = "Approving tokens...";
+        await ensureAllowance(token0, cfg.protocol.nftPositionManager, amount0Desired, privateKey, options.approveExact);
+        await ensureAllowance(token1, cfg.protocol.nftPositionManager, amount1Desired, privateKey, options.approveExact);
+        spin.text = "Increasing liquidity...";
+        const walletClient = createJaineWalletClient(privateKey);
+        const deadline = BigInt(Math.floor(Date.now() / 1000) + 90);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: cfg.protocol.nftPositionManager,
+                abi: NFT_MANAGER_ABI,
+                functionName: "increaseLiquidity",
+                args: [
+                    {
+                        tokenId: BigInt(tokenId),
+                        amount0Desired,
+                        amount1Desired,
+                        amount0Min: 0n,
+                        amount1Min: 0n,
+                        deadline,
+                    },
+                ],
+            });
+            spin.succeed("Liquidity increased");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    txHash,
+                    explorerUrl,
+                    tokenId,
+                    amount0Added: amount0Desired.toString(),
+                    amount1Added: amount1Desired.toString(),
+                });
+            }
+            else {
+                successBox("Liquidity Increased", `Position: #${tokenId}\n` +
+                    `Added: ${options.amount0} + ${options.amount1}\n` +
+                    `Tx: ${colors.info(txHash)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Operation failed");
+            throw new ImmError(ErrorCodes.LP_OPERATION_FAILED, `Failed to increase liquidity: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    lp.command("rebalance <tokenId>")
+        .description("Close position and open new one with different range")
+        .requiredOption("--range-pct <percent>", "New price range percentage")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (tokenId, options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        const instructions = [
+            `imm jaine lp remove ${tokenId} --percent 100 --yes`,
+            `imm jaine lp add --token0 <t0> --token1 <t1> --fee <fee> --amount0 <a0> --amount1 <a1> --range-pct ${options.rangePct} --yes`,
+        ];
+        // This is a compound operation: remove 100% + collect + mint new
+        // For simplicity, we guide the user to do it in steps
+        if (isHeadless()) {
+            writeJsonSuccess({
+                tokenId,
+                rangePct: options.rangePct,
+                instructions,
+                note: "Rebalancing requires multiple transactions. Execute the instructions in order.",
+            });
+        }
+        else {
+            infoBox("Rebalance Instructions", "Rebalancing requires multiple transactions:\n\n" +
+                `1. Remove liquidity: ${instructions[0]}\n` +
+                `2. Add new position: ${instructions[1]}`);
+        }
+    });
+    jaine.addCommand(lp);
+    return jaine;
+}
+//# sourceMappingURL=jaine.js.map