imm-cli 0.1.0

package/dist/commands/slop.js

@@ -0,0 +1,1053 @@
+import { Command } from "commander";
+import { randomBytes } from "node:crypto";
+import { isAddress, getAddress, parseUnits, formatUnits, decodeEventLog, } 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";
+import { SLOP_FACTORY_ABI } from "../slop/abi/factory.js";
+import { SLOP_TOKEN_ABI } from "../slop/abi/token.js";
+import { SLOP_REGISTRY_ABI } from "../slop/abi/registry.js";
+import { SLOP_FEE_COLLECTOR_ABI } from "../slop/abi/feeCollector.js";
+import { calculateOgOut, calculatePartialFill, applySlippage, calculateGraduationProgress, } from "../slop/quote.js";
+// ============ HELPERS ============
+function parseIntSafe(value, name) {
+    const n = parseInt(value, 10);
+    if (!Number.isFinite(n)) {
+        throw new ImmError(ErrorCodes.INVALID_AMOUNT, `Invalid ${name}: ${value}`);
+    }
+    return n;
+}
+function parseUnitsSafe(value, decimals, name) {
+    try {
+        const result = parseUnits(value, decimals);
+        if (result < 0n) {
+            throw new ImmError(ErrorCodes.INVALID_AMOUNT, `${name} must be >= 0`);
+        }
+        return result;
+    }
+    catch (err) {
+        if (err instanceof ImmError)
+            throw err;
+        throw new ImmError(ErrorCodes.INVALID_AMOUNT, `Invalid ${name}: ${value}`, "Must be a valid decimal number (e.g., 0.01, 100)");
+    }
+}
+function validateUserSalt(salt) {
+    // Check format: 0x + 64 hex chars
+    if (!/^0x[0-9a-fA-F]{64}$/.test(salt)) {
+        throw new ImmError(ErrorCodes.INVALID_AMOUNT, "Invalid userSalt format", "Must be 32 bytes hex (0x + 64 hex characters)");
+    }
+    // Check non-zero (contract requires non-zero salt)
+    if (BigInt(salt) === 0n) {
+        throw new ImmError(ErrorCodes.INVALID_AMOUNT, "userSalt cannot be zero", "Provide a non-zero 32-byte hex value");
+    }
+    return salt;
+}
+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 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 createSlopWalletClient(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,
+        }),
+    });
+}
+async function validateOfficialToken(tokenAddr) {
+    const cfg = loadConfig();
+    const client = getPublicClient();
+    const isValid = await client.readContract({
+        address: cfg.slop.tokenRegistry,
+        abi: SLOP_REGISTRY_ABI,
+        functionName: "isValidToken",
+        args: [tokenAddr],
+    });
+    if (!isValid) {
+        throw new ImmError(ErrorCodes.SLOP_TOKEN_NOT_OFFICIAL, "Not an official slop.money token", `Token ${tokenAddr} is not registered in TokenRegistry`);
+    }
+}
+async function checkNotGraduated(tokenAddr) {
+    const client = getPublicClient();
+    const isGraduated = await client.readContract({
+        address: tokenAddr,
+        abi: SLOP_TOKEN_ABI,
+        functionName: "isGraduated",
+    });
+    if (isGraduated) {
+        throw new ImmError(ErrorCodes.SLOP_TOKEN_GRADUATED, "Token has graduated - bonding curve trading disabled", "Use: imm jaine swap to trade on the DEX");
+    }
+}
+async function checkTradingEnabled(tokenAddr) {
+    const client = getPublicClient();
+    const isTradingEnabled = await client.readContract({
+        address: tokenAddr,
+        abi: SLOP_TOKEN_ABI,
+        functionName: "isTradingEnabled",
+    });
+    if (!isTradingEnabled) {
+        throw new ImmError(ErrorCodes.SLOP_TRADE_DISABLED, "Trading is disabled for this token");
+    }
+}
+async function getTokenState(tokenAddr) {
+    const client = getPublicClient();
+    const [ogReserves, tokenReserves, virtualOgReserves, virtualTokenReserves, k, curveSupply, buyFeeBps, sellFeeBps, isGraduated,] = await Promise.all([
+        client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "ogReserves" }),
+        client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "tokenReserves" }),
+        client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "virtualOgReserves" }),
+        client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "virtualTokenReserves" }),
+        client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "k" }),
+        client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "CURVE_SUPPLY" }),
+        client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "buyFeeBps" }),
+        client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "sellFeeBps" }),
+        client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "isGraduated" }),
+    ]);
+    return {
+        ogReserves,
+        tokenReserves,
+        virtualOgReserves,
+        virtualTokenReserves,
+        k,
+        curveSupply,
+        buyFeeBps: BigInt(buyFeeBps),
+        sellFeeBps: BigInt(sellFeeBps),
+        isGraduated,
+    };
+}
+// ============ COMMAND FACTORY ============
+export function createSlopCommand() {
+    const slop = new Command("slop")
+        .description("Slop.money bonding curve operations")
+        .exitOverride();
+    // ============ TOKEN SUBCOMMAND ============
+    const token = new Command("token")
+        .description("Token management")
+        .exitOverride();
+    token
+        .command("create")
+        .description("Create a new bonding curve token")
+        .requiredOption("--name <name>", "Token name")
+        .requiredOption("--symbol <symbol>", "Token symbol")
+        .option("--description <text>", "Token description", "")
+        .option("--image-url <url>", "Token image URL", "")
+        .option("--twitter <handle>", "Twitter handle", "")
+        .option("--telegram <handle>", "Telegram handle", "")
+        .option("--website <url>", "Website URL", "")
+        .option("--user-salt <hex>", "User-provided salt (32 bytes hex, default: random)")
+        .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();
+        // Generate or validate userSalt
+        let userSalt;
+        if (options.userSalt) {
+            userSalt = validateUserSalt(options.userSalt);
+        }
+        else {
+            userSalt = `0x${randomBytes(32).toString("hex")}`;
+        }
+        const spin = spinner("Creating token...");
+        spin.start();
+        const walletClient = createSlopWalletClient(privateKey);
+        const publicClient = getPublicClient();
+        try {
+            const txHash = await walletClient.writeContract({
+                address: cfg.slop.factory,
+                abi: SLOP_FACTORY_ABI,
+                functionName: "createToken",
+                args: [
+                    options.name,
+                    options.symbol,
+                    options.description,
+                    options.imageUrl,
+                    options.twitter,
+                    options.telegram,
+                    options.website,
+                    userSalt,
+                ],
+            });
+            spin.text = "Waiting for confirmation...";
+            const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+            // Decode TokenCreated event (filter by factory address for safety)
+            let tokenAddress;
+            let tokenId;
+            for (const log of receipt.logs) {
+                // Only process logs from the factory contract
+                if (log.address.toLowerCase() !== cfg.slop.factory.toLowerCase()) {
+                    continue;
+                }
+                try {
+                    const decoded = decodeEventLog({
+                        abi: SLOP_FACTORY_ABI,
+                        data: log.data,
+                        topics: log.topics,
+                    });
+                    if (decoded.eventName === "TokenCreated") {
+                        tokenAddress = decoded.args.tokenAddress;
+                        tokenId = decoded.args.tokenId;
+                        break;
+                    }
+                }
+                catch {
+                    // Not a TokenCreated event
+                }
+            }
+            if (!tokenAddress) {
+                throw new ImmError(ErrorCodes.SLOP_CREATE_FAILED, "Failed to decode TokenCreated event from receipt");
+            }
+            spin.succeed("Token created");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    txHash,
+                    explorerUrl,
+                    tokenAddress,
+                    tokenId: tokenId?.toString(),
+                    creator: walletClient.account.address,
+                    name: options.name,
+                    symbol: options.symbol,
+                });
+            }
+            else {
+                successBox("Token Created", `Name: ${colors.info(options.name)}\n` +
+                    `Symbol: ${colors.info(options.symbol)}\n` +
+                    `Address: ${colors.address(tokenAddress)}\n` +
+                    `Token ID: ${tokenId?.toString()}\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Token creation failed");
+            if (err instanceof ImmError)
+                throw err;
+            throw new ImmError(ErrorCodes.SLOP_CREATE_FAILED, `Token creation failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    token
+        .command("info <token>")
+        .description("Show token information")
+        .action(async (tokenArg) => {
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        const client = getPublicClient();
+        const cfg = loadConfig();
+        const spin = spinner("Fetching token info...");
+        spin.start();
+        const [name, symbol, metadata, creator, creationTime, state, tradeInfo, [price, priceSource],] = await Promise.all([
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "name" }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "symbol" }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "metadata" }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "creator" }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "creationTime" }),
+            getTokenState(tokenAddr),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "tradeInfo" }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "getCurrentPrice" }),
+        ]);
+        const graduationProgress = calculateGraduationProgress(state.tokenReserves, state.virtualTokenReserves, state.curveSupply);
+        spin.succeed("Token info loaded");
+        const priceSourceStr = priceSource === 0 ? "bonding" : "pool";
+        if (isHeadless()) {
+            writeJsonSuccess({
+                token: tokenAddr,
+                name,
+                symbol,
+                creator,
+                creationTime: creationTime.toString(),
+                isGraduated: state.isGraduated,
+                price: price.toString(),
+                priceSource: priceSourceStr,
+                priceFormatted: formatUnits(price, 18),
+                graduationProgressBps: graduationProgress.toString(),
+                graduationProgressPct: (Number(graduationProgress) / 100).toFixed(2),
+                reserves: {
+                    og: state.ogReserves.toString(),
+                    token: state.tokenReserves.toString(),
+                    virtualOg: state.virtualOgReserves.toString(),
+                    virtualToken: state.virtualTokenReserves.toString(),
+                },
+                fees: {
+                    buyBps: Number(state.buyFeeBps),
+                    sellBps: Number(state.sellFeeBps),
+                },
+                tradeInfo: {
+                    totalVolume: tradeInfo[0].toString(),
+                    totalTransactions: tradeInfo[1].toString(),
+                    buyCount: tradeInfo[2].toString(),
+                    sellCount: tradeInfo[3].toString(),
+                    uniqueTraders: tradeInfo[4].toString(),
+                },
+                metadata: {
+                    description: metadata[0],
+                    imageUrl: metadata[1],
+                    twitter: metadata[2],
+                    telegram: metadata[3],
+                    website: metadata[4],
+                },
+            });
+        }
+        else {
+            const statusStr = state.isGraduated
+                ? colors.success("Graduated")
+                : `${colors.info("Active")} (${(Number(graduationProgress) / 100).toFixed(2)}% to graduation)`;
+            infoBox(`${name} (${symbol})`, `Address: ${colors.address(tokenAddr)}\n` +
+                `Creator: ${colors.address(creator)}\n` +
+                `Status: ${statusStr}\n` +
+                `Price: ${colors.value(formatUnits(price, 18))} 0G (${priceSourceStr})\n` +
+                `Buy Fee: ${(Number(state.buyFeeBps) / 100).toFixed(2)}%\n` +
+                `Sell Fee: ${(Number(state.sellFeeBps) / 100).toFixed(2)}%\n` +
+                `Trades: ${tradeInfo[1].toString()} (${tradeInfo[4].toString()} unique traders)\n` +
+                `Volume: ${colors.value(formatBalance(tradeInfo[0], 18))} 0G`);
+        }
+    });
+    slop.addCommand(token);
+    // ============ TOKENS SUBCOMMAND ============
+    const tokens = new Command("tokens")
+        .description("List tokens")
+        .exitOverride();
+    tokens
+        .command("mine")
+        .description("List tokens created by a specific address")
+        .option("--creator <address>", "Creator address (default: wallet from config)")
+        .action(async (options) => {
+        const cfg = loadConfig();
+        const client = getPublicClient();
+        let creatorAddr;
+        if (options.creator) {
+            if (!isAddress(options.creator)) {
+                throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${options.creator}`);
+            }
+            creatorAddr = getAddress(options.creator);
+        }
+        else if (cfg.wallet.address) {
+            creatorAddr = cfg.wallet.address;
+        }
+        else {
+            throw new ImmError(ErrorCodes.WALLET_NOT_CONFIGURED, "No creator specified and no wallet configured", "Use --creator <address> or configure a wallet");
+        }
+        const spin = spinner("Fetching tokens...");
+        spin.start();
+        const tokenAddresses = await client.readContract({
+            address: cfg.slop.tokenRegistry,
+            abi: SLOP_REGISTRY_ABI,
+            functionName: "getCreatorTokens",
+            args: [creatorAddr],
+        });
+        if (tokenAddresses.length === 0) {
+            spin.succeed("No tokens found");
+            if (isHeadless()) {
+                writeJsonSuccess({ creator: creatorAddr, tokens: [], count: 0, truncated: false });
+            }
+            else {
+                infoBox("Creator Tokens", `No tokens found for ${colors.address(creatorAddr)}`);
+            }
+            return;
+        }
+        // Fetch token info
+        const tokenInfos = await client.readContract({
+            address: cfg.slop.tokenRegistry,
+            abi: SLOP_REGISTRY_ABI,
+            functionName: "getTokensInfo",
+            args: [tokenAddresses],
+        });
+        spin.succeed(`Found ${tokenAddresses.length} tokens`);
+        const tokensData = tokenAddresses.map((addr, i) => ({
+            address: addr,
+            name: tokenInfos[i].name,
+            symbol: tokenInfos[i].symbol,
+            createdAt: tokenInfos[i].createdAt.toString(),
+            isGraduated: tokenInfos[i].isGraduated,
+        }));
+        const count = await client.readContract({
+            address: cfg.slop.tokenRegistry,
+            abi: SLOP_REGISTRY_ABI,
+            functionName: "creatorTokenCount",
+            args: [creatorAddr],
+        });
+        const truncated = Number(count) > 100;
+        if (isHeadless()) {
+            writeJsonSuccess({
+                creator: creatorAddr,
+                tokens: tokensData,
+                count: tokensData.length,
+                truncated,
+            });
+        }
+        else {
+            const table = createTable([
+                { header: "Symbol", width: 12 },
+                { header: "Name", width: 20 },
+                { header: "Address", width: 45 },
+                { header: "Status", width: 12 },
+            ]);
+            for (const t of tokensData) {
+                table.push([
+                    t.symbol,
+                    t.name.slice(0, 18),
+                    t.address,
+                    t.isGraduated ? colors.success("Graduated") : colors.info("Active"),
+                ]);
+            }
+            writeStderr(table.toString());
+            if (truncated) {
+                writeStderr(colors.muted(`\nShowing first 100 of ${count} tokens`));
+            }
+        }
+    });
+    slop.addCommand(tokens);
+    // ============ TRADE SUBCOMMAND ============
+    const trade = new Command("trade")
+        .description("Trade on bonding curve (pre-graduation)")
+        .exitOverride();
+    trade
+        .command("buy <token>")
+        .description("Buy tokens with 0G")
+        .requiredOption("--amount-og <amount>", "Amount of 0G to spend")
+        .option("--slippage-bps <bps>", "Slippage tolerance in basis points", "50")
+        .option("--dry-run", "Show quote without executing")
+        .option("--yes", "Confirm the transaction")
+        .action(async (tokenArg, options) => {
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        await checkNotGraduated(tokenAddr);
+        await checkTradingEnabled(tokenAddr);
+        const slippageBps = validateSlippage(parseIntSafe(options.slippageBps, "slippageBps"));
+        const ogAmountWei = parseUnitsSafe(options.amountOg, 18, "amount-og");
+        if (ogAmountWei <= 0n) {
+            throw new ImmError(ErrorCodes.INVALID_AMOUNT, "Amount must be > 0");
+        }
+        const client = getPublicClient();
+        const state = await getTokenState(tokenAddr);
+        // Calculate quote with partial fill logic
+        let quote;
+        try {
+            quote = calculatePartialFill(state.ogReserves, state.tokenReserves, state.virtualTokenReserves, state.curveSupply, ogAmountWei, state.buyFeeBps);
+        }
+        catch (err) {
+            throw new ImmError(ErrorCodes.SLOP_QUOTE_FAILED, `Quote failed: ${err instanceof Error ? err.message : err}`);
+        }
+        const minTokensOut = applySlippage(quote.tokensOut, BigInt(slippageBps));
+        // Fetch token symbol for display
+        const symbol = await client.readContract({
+            address: tokenAddr,
+            abi: SLOP_TOKEN_ABI,
+            functionName: "symbol",
+        });
+        // Dry run output
+        if (options.dryRun) {
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    dryRun: true,
+                    token: tokenAddr,
+                    symbol,
+                    amountOgWei: ogAmountWei.toString(),
+                    tokensOut: quote.tokensOut.toString(),
+                    minTokensOut: minTokensOut.toString(),
+                    ogUsed: quote.ogUsed.toString(),
+                    feeUsed: quote.feeUsed.toString(),
+                    refund: quote.refund.toString(),
+                    hitCap: quote.hitCap,
+                    slippageBps,
+                    formatted: {
+                        amountOg: options.amountOg,
+                        tokensOut: formatUnits(quote.tokensOut, 18),
+                        minTokensOut: formatUnits(minTokensOut, 18),
+                        refund: formatUnits(quote.refund, 18),
+                    },
+                });
+            }
+            else {
+                infoBox("Buy Quote (Dry Run)", `Spend: ${colors.value(options.amountOg)} 0G\n` +
+                    `Receive: ~${colors.value(formatUnits(quote.tokensOut, 18))} ${symbol}\n` +
+                    `Min receive: ${colors.value(formatUnits(minTokensOut, 18))} ${symbol}\n` +
+                    `Fee: ${colors.muted(formatUnits(quote.feeUsed, 18))} 0G\n` +
+                    (quote.hitCap ? `${colors.warn("Partial fill")} - refund: ${formatUnits(quote.refund, 18)} 0G\n` : "") +
+                    `Slippage: ${(slippageBps / 100).toFixed(2)}%`);
+            }
+            return;
+        }
+        // Require --yes for execution
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm (or --dry-run to preview)");
+        }
+        const { privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const spin = spinner("Executing buy...");
+        spin.start();
+        const walletClient = createSlopWalletClient(privateKey);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: tokenAddr,
+                abi: SLOP_TOKEN_ABI,
+                functionName: "buyWithSlippage",
+                args: [minTokensOut],
+                value: ogAmountWei,
+            });
+            spin.succeed("Buy executed");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    txHash,
+                    explorerUrl,
+                    token: tokenAddr,
+                    symbol,
+                    quote: {
+                        tokensOut: quote.tokensOut.toString(),
+                        minTokensOut: minTokensOut.toString(),
+                        ogUsed: quote.ogUsed.toString(),
+                        feeUsed: quote.feeUsed.toString(),
+                        refund: quote.refund.toString(),
+                        hitCap: quote.hitCap,
+                    },
+                });
+            }
+            else {
+                successBox("Buy Executed", `Spent: ${colors.value(options.amountOg)} 0G\n` +
+                    `Expected: ~${colors.value(formatUnits(quote.tokensOut, 18))} ${symbol}\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Buy failed");
+            throw new ImmError(ErrorCodes.SLOP_TX_FAILED, `Buy failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    trade
+        .command("sell <token>")
+        .description("Sell tokens for 0G")
+        .requiredOption("--amount-tokens <amount>", "Amount of tokens to sell")
+        .option("--slippage-bps <bps>", "Slippage tolerance in basis points", "50")
+        .option("--dry-run", "Show quote without executing")
+        .option("--yes", "Confirm the transaction")
+        .action(async (tokenArg, options) => {
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        await checkNotGraduated(tokenAddr);
+        await checkTradingEnabled(tokenAddr);
+        const slippageBps = validateSlippage(parseIntSafe(options.slippageBps, "slippageBps"));
+        const tokenAmountWei = parseUnitsSafe(options.amountTokens, 18, "amount-tokens");
+        if (tokenAmountWei <= 0n) {
+            throw new ImmError(ErrorCodes.INVALID_AMOUNT, "Amount must be > 0");
+        }
+        const client = getPublicClient();
+        const cfg = loadConfig();
+        const state = await getTokenState(tokenAddr);
+        // Calculate quote
+        let ogOutGross;
+        try {
+            ogOutGross = calculateOgOut(state.k, state.ogReserves, state.tokenReserves, tokenAmountWei);
+        }
+        catch (err) {
+            throw new ImmError(ErrorCodes.SLOP_QUOTE_FAILED, `Quote failed: ${err instanceof Error ? err.message : err}`);
+        }
+        const fee = (ogOutGross * state.sellFeeBps) / 10000n;
+        const ogOutNet = ogOutGross - fee;
+        const minOgOut = applySlippage(ogOutNet, BigInt(slippageBps));
+        // Fetch token symbol for display
+        const symbol = await client.readContract({
+            address: tokenAddr,
+            abi: SLOP_TOKEN_ABI,
+            functionName: "symbol",
+        });
+        // Dry run output
+        if (options.dryRun) {
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    dryRun: true,
+                    token: tokenAddr,
+                    symbol,
+                    tokenAmountWei: tokenAmountWei.toString(),
+                    ogOutGross: ogOutGross.toString(),
+                    ogOutNet: ogOutNet.toString(),
+                    minOgOut: minOgOut.toString(),
+                    fee: fee.toString(),
+                    slippageBps,
+                    formatted: {
+                        amountTokens: options.amountTokens,
+                        ogOutNet: formatUnits(ogOutNet, 18),
+                        minOgOut: formatUnits(minOgOut, 18),
+                        fee: formatUnits(fee, 18),
+                    },
+                });
+            }
+            else {
+                infoBox("Sell Quote (Dry Run)", `Sell: ${colors.value(options.amountTokens)} ${symbol}\n` +
+                    `Receive: ~${colors.value(formatUnits(ogOutNet, 18))} 0G\n` +
+                    `Min receive: ${colors.value(formatUnits(minOgOut, 18))} 0G\n` +
+                    `Fee: ${colors.muted(formatUnits(fee, 18))} 0G\n` +
+                    `Slippage: ${(slippageBps / 100).toFixed(2)}%`);
+            }
+            return;
+        }
+        // Require --yes for execution
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm (or --dry-run to preview)");
+        }
+        // Check balance
+        const { address, privateKey } = requireWalletAndKeystore();
+        const balance = await client.readContract({
+            address: tokenAddr,
+            abi: SLOP_TOKEN_ABI,
+            functionName: "balanceOf",
+            args: [address],
+        });
+        if (balance < tokenAmountWei) {
+            throw new ImmError(ErrorCodes.SLOP_INSUFFICIENT_BALANCE, `Insufficient balance: ${formatUnits(balance, 18)} ${symbol}`, `You need ${options.amountTokens} ${symbol}`);
+        }
+        const spin = spinner("Executing sell...");
+        spin.start();
+        const walletClient = createSlopWalletClient(privateKey);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: tokenAddr,
+                abi: SLOP_TOKEN_ABI,
+                functionName: "sellWithSlippage",
+                args: [tokenAmountWei, minOgOut],
+            });
+            spin.succeed("Sell executed");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    txHash,
+                    explorerUrl,
+                    token: tokenAddr,
+                    symbol,
+                    quote: {
+                        tokensSold: tokenAmountWei.toString(),
+                        ogOutNet: ogOutNet.toString(),
+                        minOgOut: minOgOut.toString(),
+                        fee: fee.toString(),
+                    },
+                });
+            }
+            else {
+                successBox("Sell Executed", `Sold: ${colors.value(options.amountTokens)} ${symbol}\n` +
+                    `Expected: ~${colors.value(formatUnits(ogOutNet, 18))} 0G\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Sell failed");
+            throw new ImmError(ErrorCodes.SLOP_TX_FAILED, `Sell failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    slop.addCommand(trade);
+    // ============ PRICE COMMAND ============
+    slop
+        .command("price <token>")
+        .description("Get current token price")
+        .action(async (tokenArg) => {
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        const client = getPublicClient();
+        const [[price, priceSource], symbol] = await Promise.all([
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "getCurrentPrice" }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "symbol" }),
+        ]);
+        const sourceStr = priceSource === 0 ? "bonding" : "pool";
+        if (isHeadless()) {
+            writeJsonSuccess({
+                token: tokenAddr,
+                symbol,
+                price: price.toString(),
+                priceFormatted: formatUnits(price, 18),
+                source: sourceStr,
+            });
+        }
+        else {
+            infoBox(`${symbol} Price`, `${colors.value(formatUnits(price, 18))} 0G per token\n` +
+                `Source: ${sourceStr}`);
+        }
+    });
+    // ============ CURVE COMMAND ============
+    slop
+        .command("curve <token>")
+        .description("Show bonding curve state and graduation progress")
+        .action(async (tokenArg) => {
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        const client = getPublicClient();
+        const state = await getTokenState(tokenAddr);
+        const symbol = await client.readContract({
+            address: tokenAddr,
+            abi: SLOP_TOKEN_ABI,
+            functionName: "symbol",
+        });
+        const graduationProgress = calculateGraduationProgress(state.tokenReserves, state.virtualTokenReserves, state.curveSupply);
+        // Clamp to >= 0 for defensive safety (matches on-chain getRealOgReserves behavior)
+        const realOg = state.ogReserves > state.virtualOgReserves
+            ? state.ogReserves - state.virtualOgReserves
+            : 0n;
+        const tokensSold = state.virtualTokenReserves > state.tokenReserves
+            ? state.virtualTokenReserves - state.tokenReserves
+            : 0n;
+        if (isHeadless()) {
+            writeJsonSuccess({
+                token: tokenAddr,
+                symbol,
+                isGraduated: state.isGraduated,
+                reserves: {
+                    og: state.ogReserves.toString(),
+                    token: state.tokenReserves.toString(),
+                    virtualOg: state.virtualOgReserves.toString(),
+                    virtualToken: state.virtualTokenReserves.toString(),
+                    realOg: realOg.toString(),
+                    k: state.k.toString(),
+                },
+                curveSupply: state.curveSupply.toString(),
+                tokensSold: tokensSold.toString(),
+                graduationProgressBps: graduationProgress.toString(),
+                graduationProgressPct: (Number(graduationProgress) / 100).toFixed(2),
+                graduationThresholdBps: "8000",
+            });
+        }
+        else {
+            const progressBar = (pct) => {
+                const filled = Math.round(pct / 5);
+                const empty = 20 - filled;
+                return `[${"=".repeat(filled)}${" ".repeat(empty)}] ${pct.toFixed(2)}%`;
+            };
+            const progressPct = Number(graduationProgress) / 100;
+            infoBox(`${symbol} Bonding Curve`, `Status: ${state.isGraduated ? colors.success("Graduated") : colors.info("Active")}\n` +
+                `\nReserves:\n` +
+                `  0G: ${colors.value(formatUnits(state.ogReserves, 18))} (real: ${formatUnits(realOg, 18)})\n` +
+                `  Token: ${colors.value(formatUnits(state.tokenReserves, 18))}\n` +
+                `  K: ${state.k.toString()}\n` +
+                `\nProgress to Graduation (80%):\n` +
+                `  ${progressBar(progressPct)}\n` +
+                `  Tokens sold: ${colors.value(formatUnits(tokensSold, 18))} / ${formatUnits(state.curveSupply, 18)}`);
+        }
+    });
+    // ============ FEES SUBCOMMAND ============
+    const fees = new Command("fees")
+        .description("Fee management")
+        .exitOverride();
+    fees
+        .command("stats <token>")
+        .description("Show fee statistics for a token")
+        .action(async (tokenArg) => {
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        const cfg = loadConfig();
+        const client = getPublicClient();
+        const [feeStats, symbol] = await Promise.all([
+            client.readContract({
+                address: cfg.slop.feeCollector,
+                abi: SLOP_FEE_COLLECTOR_ABI,
+                functionName: "getTokenFeeStats",
+                args: [tokenAddr],
+            }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "symbol" }),
+        ]);
+        const [totalCreator, totalPlatform, pendingCreator, pendingPlatform, volume] = feeStats;
+        if (isHeadless()) {
+            writeJsonSuccess({
+                token: tokenAddr,
+                symbol,
+                totalCreatorFees: totalCreator.toString(),
+                totalPlatformFees: totalPlatform.toString(),
+                pendingCreatorFees: pendingCreator.toString(),
+                pendingPlatformFees: pendingPlatform.toString(),
+                totalVolume: volume.toString(),
+                formatted: {
+                    totalCreatorFees: formatUnits(totalCreator, 18),
+                    totalPlatformFees: formatUnits(totalPlatform, 18),
+                    pendingCreatorFees: formatUnits(pendingCreator, 18),
+                    pendingPlatformFees: formatUnits(pendingPlatform, 18),
+                    totalVolume: formatUnits(volume, 18),
+                },
+            });
+        }
+        else {
+            infoBox(`${symbol} Fee Stats`, `Total Volume: ${colors.value(formatUnits(volume, 18))} 0G\n` +
+                `\nCreator Fees:\n` +
+                `  Total: ${colors.value(formatUnits(totalCreator, 18))} 0G\n` +
+                `  Pending: ${colors.value(formatUnits(pendingCreator, 18))} 0G\n` +
+                `\nPlatform Fees:\n` +
+                `  Total: ${colors.value(formatUnits(totalPlatform, 18))} 0G`);
+        }
+    });
+    fees
+        .command("claim-creator <token>")
+        .description("Withdraw pending creator fees")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (tokenArg, options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        const { privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const spin = spinner("Withdrawing creator fees...");
+        spin.start();
+        const walletClient = createSlopWalletClient(privateKey);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: cfg.slop.feeCollector,
+                abi: SLOP_FEE_COLLECTOR_ABI,
+                functionName: "withdrawCreatorFees",
+                args: [tokenAddr],
+            });
+            spin.succeed("Creator fees withdrawn");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({ txHash, explorerUrl, token: tokenAddr });
+            }
+            else {
+                successBox("Creator Fees Withdrawn", `Token: ${colors.address(tokenAddr)}\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Withdrawal failed");
+            throw new ImmError(ErrorCodes.SLOP_TX_FAILED, `Withdrawal failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    const lpFees = new Command("lp")
+        .description("LP fees (post-graduation)")
+        .exitOverride();
+    lpFees
+        .command("pending <token>")
+        .description("Show pending LP fees")
+        .action(async (tokenArg) => {
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        const client = getPublicClient();
+        const [isGraduated, symbol] = await Promise.all([
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "isGraduated" }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "symbol" }),
+        ]);
+        if (!isGraduated) {
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    token: tokenAddr,
+                    symbol,
+                    isGraduated: false,
+                    pendingW0G: "0",
+                    pendingToken: "0",
+                    note: "Token not graduated - no LP fees yet",
+                });
+            }
+            else {
+                infoBox(`${symbol} LP Fees`, "Token not graduated - no LP fees yet");
+            }
+            return;
+        }
+        const [pendingW0G, pendingToken] = await client.readContract({
+            address: tokenAddr,
+            abi: SLOP_TOKEN_ABI,
+            functionName: "getPendingLPFees",
+        });
+        if (isHeadless()) {
+            writeJsonSuccess({
+                token: tokenAddr,
+                symbol,
+                isGraduated: true,
+                pendingW0G: pendingW0G.toString(),
+                pendingToken: pendingToken.toString(),
+                formatted: {
+                    pendingW0G: formatUnits(pendingW0G, 18),
+                    pendingToken: formatUnits(pendingToken, 18),
+                },
+            });
+        }
+        else {
+            infoBox(`${symbol} LP Fees`, `Pending W0G: ${colors.value(formatUnits(pendingW0G, 18))}\n` +
+                `Pending ${symbol}: ${colors.value(formatUnits(pendingToken, 18))}`);
+        }
+    });
+    lpFees
+        .command("collect <token>")
+        .description("Collect LP fees (creator only)")
+        .option("--recipient <address>", "Recipient address (default: wallet)")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (tokenArg, options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        const { address, privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const recipient = options.recipient ? getAddress(options.recipient) : address;
+        const spin = spinner("Collecting LP fees...");
+        spin.start();
+        const walletClient = createSlopWalletClient(privateKey);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: tokenAddr,
+                abi: SLOP_TOKEN_ABI,
+                functionName: "collectLPFees",
+                args: [recipient],
+            });
+            spin.succeed("LP fees collected");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({ txHash, explorerUrl, token: tokenAddr, recipient });
+            }
+            else {
+                successBox("LP Fees Collected", `Token: ${colors.address(tokenAddr)}\n` +
+                    `Recipient: ${colors.address(recipient)}\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Collection failed");
+            throw new ImmError(ErrorCodes.SLOP_TX_FAILED, `LP fee collection failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    fees.addCommand(lpFees);
+    slop.addCommand(fees);
+    // ============ REWARD SUBCOMMAND ============
+    const reward = new Command("reward")
+        .description("Creator graduation reward")
+        .exitOverride();
+    reward
+        .command("pending <token>")
+        .description("Show pending creator graduation reward")
+        .action(async (tokenArg) => {
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        const client = getPublicClient();
+        const [pendingReward, totalReward, symbol, isGraduated] = await Promise.all([
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "pendingCreatorReward" }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "CREATOR_GRADUATION_REWARD" }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "symbol" }),
+            client.readContract({ address: tokenAddr, abi: SLOP_TOKEN_ABI, functionName: "isGraduated" }),
+        ]);
+        if (isHeadless()) {
+            writeJsonSuccess({
+                token: tokenAddr,
+                symbol,
+                isGraduated,
+                pendingReward: pendingReward.toString(),
+                totalReward: totalReward.toString(),
+                formatted: {
+                    pendingReward: formatUnits(pendingReward, 18),
+                    totalReward: formatUnits(totalReward, 18),
+                },
+            });
+        }
+        else {
+            const statusNote = isGraduated
+                ? pendingReward > 0n
+                    ? colors.success("Claimable")
+                    : colors.muted("Already claimed")
+                : colors.muted("Not graduated yet");
+            infoBox(`${symbol} Creator Reward`, `Status: ${statusNote}\n` +
+                `Pending: ${colors.value(formatUnits(pendingReward, 18))} 0G\n` +
+                `Total Reward: ${formatUnits(totalReward, 18)} 0G`);
+        }
+    });
+    reward
+        .command("claim <token>")
+        .description("Claim creator graduation reward")
+        .requiredOption("--yes", "Confirm the transaction")
+        .action(async (tokenArg, options) => {
+        if (!options.yes) {
+            throw new ImmError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        if (!isAddress(tokenArg)) {
+            throw new ImmError(ErrorCodes.INVALID_ADDRESS, `Invalid address: ${tokenArg}`);
+        }
+        const tokenAddr = getAddress(tokenArg);
+        await validateOfficialToken(tokenAddr);
+        const { privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const spin = spinner("Claiming creator reward...");
+        spin.start();
+        const walletClient = createSlopWalletClient(privateKey);
+        try {
+            const txHash = await walletClient.writeContract({
+                address: tokenAddr,
+                abi: SLOP_TOKEN_ABI,
+                functionName: "claimCreatorReward",
+            });
+            spin.succeed("Creator reward claimed");
+            const explorerUrl = `${cfg.chain.explorerUrl}/tx/${txHash}`;
+            if (isHeadless()) {
+                writeJsonSuccess({ txHash, explorerUrl, token: tokenAddr });
+            }
+            else {
+                successBox("Creator Reward Claimed", `Token: ${colors.address(tokenAddr)}\n` +
+                    `Tx: ${colors.info(txHash)}\n` +
+                    `Explorer: ${colors.muted(explorerUrl)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Claim failed");
+            throw new ImmError(ErrorCodes.SLOP_TX_FAILED, `Reward claim failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    slop.addCommand(reward);
+    return slop;
+}
+//# sourceMappingURL=slop.js.map