httpcat-cli 0.0.27 → 0.1.1-rc.1

package/dist/commands/sell.js

@@ -1,44 +1,736 @@
-import { printBox, formatTokenAmount, formatCurrency } from '../utils/formatting.js';
+import { validateTokenId } from '../utils/validation.js';
+import { printBox, formatTokenAmount, formatCurrency, formatAddress } from '../utils/formatting.js';
 import { printSuccess, printGraduationProgress } from '../interactive/art.js';
 import { resolveTokenId } from '../utils/token-resolver.js';
-export async function sellToken(client, identifier, // Can be token ID (UUID), address (0x...), name, or symbol
-tokenAmount, silent = false // Suppress resolver output for quiet/JSON mode
+import { getTokenInfo } from './info.js';
+import { createPublicClient, createWalletClient, http, parseAbi, formatUnits, decodeAbiParameters, decodeFunctionData, decodeEventLog } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { baseSepolia } from 'viem/chains';
+import chalk from 'chalk';
+async function simulateAndExplainUniversalRouterRevert(args) {
+    try {
+        await args.publicClient.call({
+            to: args.txTo,
+            data: args.txData,
+            value: args.txValue,
+            account: args.userAddress,
+            gas: 3000000n,
+        });
+    }
+    catch (error) {
+        const revertData = error?.data ??
+            error?.cause?.data ??
+            error?.walk?.data ??
+            error?.cause?.walk?.data;
+        if (!args.silent) {
+            if (typeof revertData === 'string' && revertData.startsWith('0x') && revertData.length >= 10) {
+                const selector = revertData.slice(0, 10);
+                console.log(chalk.yellow(`  Universal Router simulation revert selector: ${selector}`));
+                console.log(chalk.yellow(`  Universal Router simulation revert data: ${revertData}`));
+                console.log(chalk.yellow(`  (Proceeding to broadcast anyway; some RPCs are flaky for eth_call on Universal Router.)`));
+            }
+            else {
+                console.log(chalk.yellow(`  Universal Router simulation reverted (no data).`));
+                console.log(chalk.yellow(`  (Proceeding to broadcast anyway; some RPCs are flaky for eth_call on Universal Router.)`));
+            }
+        }
+    }
+}
+const ERC20_ABI = parseAbi([
+    'function approve(address spender, uint256 amount) returns (bool)',
+    'function allowance(address owner, address spender) view returns (uint256)',
+    'function balanceOf(address owner) view returns (uint256)',
+]);
+const USDC_ADDRESS = '0x036CbD53842c5426634e7929541eC2318f3dCF7e';
+const PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3';
+const PERMIT2_ABI = parseAbi([
+    'function allowance(address owner, address token, address spender) view returns (uint160 amount, uint48 expiration, uint48 nonce)',
+    'function approve(address token, address spender, uint160 amount, uint48 expiration)',
+]);
+const ERC20_TRANSFER_EVENT_ABI = parseAbi([
+    'event Transfer(address indexed from, address indexed to, uint256 value)',
+]);
+function getErc20NetDeltaFromReceipt(args) {
+    const tokenLc = args.token.toLowerCase();
+    const userLc = args.user.toLowerCase();
+    let delta = 0n;
+    const logs = Array.isArray(args.receipt?.logs) ? args.receipt.logs : [];
+    for (const log of logs) {
+        try {
+            const addr = String(log?.address ?? '').toLowerCase();
+            if (addr !== tokenLc)
+                continue;
+            const decoded = decodeEventLog({
+                abi: ERC20_TRANSFER_EVENT_ABI,
+                data: log.data,
+                topics: log.topics,
+            });
+            if (decoded.eventName !== 'Transfer')
+                continue;
+            const fromLc = decoded.args.from.toLowerCase();
+            const toLc = decoded.args.to.toLowerCase();
+            const value = BigInt(decoded.args.value);
+            if (fromLc === userLc)
+                delta -= value;
+            if (toLc === userLc)
+                delta += value;
+        }
+        catch {
+            // ignore non-matching logs
+        }
+    }
+    return delta;
+}
+function decodeUniversalRouterExecute(data) {
+    const UNIVERSAL_ROUTER_ABI = parseAbi([
+        'function execute(bytes commands, bytes[] inputs, uint256 deadline) external payable',
+    ]);
+    try {
+        const decoded = decodeFunctionData({
+            abi: UNIVERSAL_ROUTER_ABI,
+            data,
+        });
+        const [commands, inputs, deadline] = decoded.args;
+        return { commands, inputs, deadline };
+    }
+    catch {
+        return null;
+    }
+}
+async function ensurePermit2AllowanceIfNeeded(args) {
+    const decoded = decodeUniversalRouterExecute(args.txData);
+    if (!decoded)
+        return;
+    const cmdLen = (decoded.commands.length - 2) / 2;
+    if (cmdLen <= 0)
+        return;
+    const cmdBytes = [];
+    for (let i = 0; i < cmdLen; i++) {
+        cmdBytes.push(decoded.commands.slice(2 + i * 2, 4 + i * 2).toLowerCase());
+    }
+    // Prefer decoding tokenIn from V4_SWAP input (standard pattern).
+    const v4Index = cmdBytes.findIndex((c) => c === '10');
+    let tokenIn = null;
+    let amount = null;
+    if (v4Index >= 0 && decoded.inputs[v4Index]) {
+        try {
+            const [actions, params] = decodeAbiParameters([
+                { name: 'actions', type: 'bytes' },
+                { name: 'params', type: 'bytes[]' },
+            ], decoded.inputs[v4Index]);
+            if (params[0]) {
+                const [swap] = decodeAbiParameters([
+                    {
+                        name: 'swap',
+                        type: 'tuple',
+                        components: [
+                            {
+                                name: 'poolKey',
+                                type: 'tuple',
+                                components: [
+                                    { name: 'currency0', type: 'address' },
+                                    { name: 'currency1', type: 'address' },
+                                    { name: 'fee', type: 'uint24' },
+                                    { name: 'tickSpacing', type: 'int24' },
+                                    { name: 'hooks', type: 'address' },
+                                ],
+                            },
+                            { name: 'zeroForOne', type: 'bool' },
+                            { name: 'amountIn', type: 'uint128' },
+                            { name: 'amountOutMinimum', type: 'uint128' },
+                            { name: 'hookData', type: 'bytes' },
+                        ],
+                    },
+                ], params[0]);
+                const currency0 = (swap.poolKey?.currency0 ?? swap.poolKey?.[0]);
+                const currency1 = (swap.poolKey?.currency1 ?? swap.poolKey?.[1]);
+                const zeroForOne = (swap.zeroForOne ?? swap[1]);
+                tokenIn = (zeroForOne ? currency0 : currency1);
+                amount = (swap.amountIn ?? swap[2]);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    // Backwards compatibility: if our calldata still starts with PERMIT2_TRANSFER_FROM, decode token/amount from that.
+    const firstCommand = decoded.commands.length >= 4 ? decoded.commands.slice(2, 4).toLowerCase() : '';
+    if ((!tokenIn || !amount) && (firstCommand === '02' || firstCommand === '0a') && decoded.inputs.length >= 1) {
+        try {
+            const decodedPermit2 = decodeAbiParameters([
+                { name: 'token', type: 'address' },
+                { name: 'recipient', type: 'address' },
+                { name: 'amount', type: 'uint160' },
+            ], decoded.inputs[0]);
+            tokenIn = decodedPermit2[0];
+            amount = decodedPermit2[2];
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!tokenIn || !amount)
+        return;
+    const normalizeAllowance = (raw) => {
+        const toBigInt = (value) => {
+            if (typeof value === 'bigint')
+                return value;
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                return BigInt(value);
+            }
+            throw new Error('Invalid bigint value');
+        };
+        // viem may return either a tuple array or an object with named fields.
+        if (Array.isArray(raw)) {
+            const [a, e, n] = raw;
+            return {
+                amount: toBigInt(a),
+                expiration: toBigInt(e),
+                nonce: toBigInt(n),
+            };
+        }
+        return {
+            amount: typeof raw.amount === 'bigint' ? raw.amount : BigInt(raw.amount),
+            expiration: typeof raw.expiration === 'bigint' ? raw.expiration : BigInt(raw.expiration),
+            nonce: typeof raw.nonce === 'bigint' ? raw.nonce : BigInt(raw.nonce),
+        };
+    };
+    const allowance = normalizeAllowance(await args.publicClient.readContract({
+        address: PERMIT2_ADDRESS,
+        abi: PERMIT2_ABI,
+        functionName: 'allowance',
+        args: [args.userAddress, tokenIn, args.universalRouter],
+    }));
+    const currentAmount = allowance.amount;
+    const expiration = allowance.expiration;
+    const now = BigInt(Math.floor(Date.now() / 1000));
+    const isExpired = expiration === 0n || expiration <= now;
+    if (currentAmount >= amount && !isExpired) {
+        return;
+    }
+    if (!args.silent) {
+        console.log(chalk.cyan(`  Setting Permit2 allowance for Universal Router...`));
+    }
+    const MAX_UINT160 = (1n << 160n) - 1n;
+    const MAX_UINT48 = 281474976710655n;
+    const approveTx = await args.walletClient.writeContract({
+        address: PERMIT2_ADDRESS,
+        abi: PERMIT2_ABI,
+        functionName: 'approve',
+        args: [tokenIn, args.universalRouter, MAX_UINT160, MAX_UINT48],
+    });
+    await args.publicClient.waitForTransactionReceipt({ hash: approveTx });
+    if (!args.silent) {
+        try {
+            const updated = normalizeAllowance(await args.publicClient.readContract({
+                address: PERMIT2_ADDRESS,
+                abi: PERMIT2_ABI,
+                functionName: 'allowance',
+                args: [args.userAddress, tokenIn, args.universalRouter],
+            }));
+            console.log(chalk.dim(`  Permit2 allowance now: amount=${updated.amount.toString()} expiration=${updated.expiration.toString()}`));
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+function debugUniversalRouterCalldata(data) {
+    const UNIVERSAL_ROUTER_ABI = parseAbi([
+        'function execute(bytes commands, bytes[] inputs, uint256 deadline) external payable',
+    ]);
+    let decoded;
+    try {
+        decoded = decodeFunctionData({
+            abi: UNIVERSAL_ROUTER_ABI,
+            data,
+        });
+    }
+    catch {
+        return;
+    }
+    const [commands, inputs] = decoded.args;
+    const cmdLen = (commands.length - 2) / 2;
+    console.log(chalk.dim(`  UniversalRouter.execute preflight: commands=${commands} (len=${cmdLen}), inputs=${inputs.length}`));
+    if (cmdLen === 0) {
+        throw new Error('Refusing to send Universal Router tx with empty commands (no-op)');
+    }
+    const cmdBytes = [];
+    for (let i = 0; i < cmdLen; i++) {
+        cmdBytes.push(commands.slice(2 + i * 2, 4 + i * 2).toLowerCase());
+    }
+    const v4Index = cmdBytes.findIndex((c) => c === '10');
+    const v4Input = v4Index >= 0 ? inputs[v4Index] : undefined;
+    if (!v4Input)
+        return;
+    try {
+        const [actions, params] = decodeAbiParameters([
+            { name: 'actions', type: 'bytes' },
+            { name: 'params', type: 'bytes[]' },
+        ], v4Input);
+        const actionsLen = (actions.length - 2) / 2;
+        console.log(chalk.dim(`  V4 actions payload: actions=${actions} (len=${actionsLen}), params=${params.length}`));
+        // Attempt to decode known params for our swapExactInSingle + settle + takeAll pattern.
+        if (params[0]) {
+            try {
+                const [swap] = decodeAbiParameters([
+                    {
+                        name: 'swap',
+                        type: 'tuple',
+                        components: [
+                            {
+                                name: 'poolKey',
+                                type: 'tuple',
+                                components: [
+                                    { name: 'currency0', type: 'address' },
+                                    { name: 'currency1', type: 'address' },
+                                    { name: 'fee', type: 'uint24' },
+                                    { name: 'tickSpacing', type: 'int24' },
+                                    { name: 'hooks', type: 'address' },
+                                ],
+                            },
+                            { name: 'zeroForOne', type: 'bool' },
+                            { name: 'amountIn', type: 'uint128' },
+                            { name: 'amountOutMinimum', type: 'uint128' },
+                            { name: 'hookData', type: 'bytes' },
+                        ],
+                    },
+                ], params[0]);
+                console.log(chalk.dim(`  V4 swap decode: amountIn=${swap.amountIn?.toString?.() ?? String(swap.amountIn)} amountOutMinimum=${swap.amountOutMinimum?.toString?.() ?? String(swap.amountOutMinimum)}`));
+            }
+            catch {
+                // ignore
+            }
+        }
+        if (params[2]) {
+            try {
+                const [currency, minAmount] = decodeAbiParameters([
+                    { name: 'currency', type: 'address' },
+                    { name: 'minAmount', type: 'uint256' },
+                ], params[2]);
+                console.log(chalk.dim(`  V4 takeAll decode: currency=${currency} minAmount=${minAmount.toString()}`));
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    catch {
+        // ignore decode errors
+    }
+}
+/**
+ * Check price impact and log warning if too high
+ * TODO: Add confirmation prompt (needs refactor to work with spinner)
+ */
+async function checkPriceImpact(priceImpact, silent) {
+    // Just log for now - confirmation prompt conflicts with spinner
+    // Will add proper confirmation in future refactor
+    return;
+}
+async function executeUniswapSell(swapData, privateKey, silent) {
+    const account = privateKeyToAccount(privateKey);
+    const userAddress = account.address;
+    // Create clients
+    const publicClient = createPublicClient({
+        chain: baseSepolia,
+        transport: http(),
+    });
+    const walletClient = createWalletClient({
+        account,
+        chain: baseSepolia,
+        transport: http(),
+    });
+    // Approve tokens if needed
+    for (const approval of swapData.approvals) {
+        // Check current allowance first
+        const currentAllowance = await publicClient.readContract({
+            address: approval.token,
+            abi: ERC20_ABI,
+            functionName: 'allowance',
+            args: [userAddress, approval.spender],
+        });
+        const requiredAmount = BigInt(approval.amount);
+        // Only approve if current allowance is insufficient
+        if (currentAllowance < requiredAmount) {
+            if (!silent) {
+                console.log(chalk.cyan(`  Approving ${approval.token}...`));
+            }
+            // Approve max uint256 for better UX (avoid repeated approvals)
+            const maxUint256 = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
+            const approveTx = await walletClient.writeContract({
+                address: approval.token,
+                abi: ERC20_ABI,
+                functionName: 'approve',
+                args: [approval.spender, maxUint256],
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+        }
+        else if (!silent) {
+            console.log(chalk.dim(`  ✓ Already approved ${approval.token}`));
+        }
+    }
+    // Execute swap using raw transaction data with retry logic
+    if (!silent) {
+        console.log(chalk.cyan(`  Executing swap via ${swapData.route}...`));
+    }
+    const tokenInAddress = swapData.tokenAddress;
+    const usdcBefore = (await publicClient.readContract({
+        address: USDC_ADDRESS,
+        abi: ERC20_ABI,
+        functionName: 'balanceOf',
+        args: [userAddress],
+    }));
+    const tokenBefore = (await publicClient.readContract({
+        address: tokenInAddress,
+        abi: ERC20_ABI,
+        functionName: 'balanceOf',
+        args: [userAddress],
+    }));
+    let txData;
+    // Check if we have args (old V2 format) or encoded data
+    if (swapData.swap.args && swapData.swap.functionName) {
+        // Old format - encode the transaction ourselves
+        const { encodeFunctionData } = await import('viem');
+        const V2_ROUTER_ABI = [
+            {
+                inputs: [
+                    { name: "amountIn", type: "uint256" },
+                    { name: "amountOutMin", type: "uint256" },
+                    { name: "path", type: "address[]" },
+                    { name: "to", type: "address" },
+                    { name: "deadline", type: "uint256" },
+                ],
+                name: "swapExactTokensForTokens",
+                outputs: [{ name: "amounts", type: "uint256[]" }],
+                stateMutability: "nonpayable",
+                type: "function",
+            },
+        ];
+        // Replace {{USER_ADDRESS}} in args
+        const args = swapData.swap.args.map((arg) => arg === "{{USER_ADDRESS}}" ? userAddress : arg);
+        txData = encodeFunctionData({
+            abi: V2_ROUTER_ABI,
+            functionName: "swapExactTokensForTokens",
+            args: [
+                BigInt(args[0]),
+                BigInt(args[1]),
+                args[2],
+                args[3],
+                BigInt(args[4]),
+            ],
+        });
+    }
+    else {
+        // New format - use encoded data
+        txData = swapData.swap.data;
+    }
+    if (!silent) {
+        debugUniversalRouterCalldata(txData);
+    }
+    await ensurePermit2AllowanceIfNeeded({
+        txData,
+        universalRouter: swapData.swap.to,
+        userAddress,
+        publicClient,
+        walletClient,
+        silent,
+    });
+    await simulateAndExplainUniversalRouterRevert({
+        txTo: swapData.swap.to,
+        txData,
+        txValue: BigInt(swapData.swap.value),
+        userAddress,
+        publicClient,
+        silent,
+    });
+    // Retry logic for swap execution
+    let swapTx;
+    let lastError = null;
+    const maxRetries = 3;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const send = async (gas) => walletClient.sendTransaction({
+                to: swapData.swap.to,
+                data: txData,
+                value: BigInt(swapData.swap.value),
+                ...(gas ? { gas } : {}),
+            });
+            try {
+                swapTx = await send();
+            }
+            catch (inner) {
+                // Some RPCs surface swap failures as "execution reverted" during gas estimation.
+                // Force-broadcast with an explicit gas limit so we can inspect the on-chain revert.
+                const msg = String(inner?.message ?? '');
+                if (msg.toLowerCase().includes('execution reverted')) {
+                    if (!silent) {
+                        console.log(chalk.yellow(`  ⚠️  Estimation reverted; force-broadcasting with manual gas limit for debugging...`));
+                    }
+                    swapTx = await send(1500000n);
+                }
+                else {
+                    throw inner;
+                }
+            }
+            break; // Success, exit retry loop
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < maxRetries && error.message?.includes('transferFrom failed')) {
+                if (!silent) {
+                    console.log(chalk.yellow(`  ⚠️  Swap failed (attempt ${attempt}/${maxRetries}), retrying...`));
+                }
+                // Wait a bit before retrying
+                await new Promise(resolve => setTimeout(resolve, 1000 * attempt)); // Exponential backoff
+            }
+            else {
+                throw error; // Max retries reached or different error
+            }
+        }
+    }
+    if (!swapTx) {
+        throw lastError || new Error('Swap failed after retries');
+    }
+    const receipt = await publicClient.waitForTransactionReceipt({
+        hash: swapTx,
+    });
+    if (receipt.status !== 'success') {
+        throw new Error(`Swap reverted on-chain. tx=${swapTx}`);
+    }
+    const usdcDeltaFromLogs = getErc20NetDeltaFromReceipt({
+        receipt,
+        token: USDC_ADDRESS,
+        user: userAddress,
+    });
+    const tokenDeltaFromLogs = getErc20NetDeltaFromReceipt({
+        receipt,
+        token: tokenInAddress,
+        user: userAddress,
+    });
+    // Fallback to balance snapshots if logs don't include the token (some RPCs may omit logs).
+    let usdcDelta = usdcDeltaFromLogs;
+    let tokenDelta = -tokenDeltaFromLogs;
+    if (usdcDelta === 0n || tokenDelta === 0n) {
+        try {
+            const usdcAfter = (await publicClient.readContract({
+                address: USDC_ADDRESS,
+                abi: ERC20_ABI,
+                functionName: 'balanceOf',
+                args: [userAddress],
+            }));
+            const tokenAfter = (await publicClient.readContract({
+                address: tokenInAddress,
+                abi: ERC20_ABI,
+                functionName: 'balanceOf',
+                args: [userAddress],
+            }));
+            if (usdcDelta === 0n)
+                usdcDelta = usdcAfter - usdcBefore;
+            if (tokenDelta === 0n)
+                tokenDelta = tokenBefore - tokenAfter;
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!silent) {
+        console.log(chalk.dim(`  Actual USDC delta: ${formatUnits(usdcDelta, 6)} (raw=${usdcDelta.toString()})`));
+        const tokenDecimals = swapData?.tokenDecimals ?? 18;
+        console.log(chalk.dim(`  Actual token delta: ${formatUnits(tokenDelta, tokenDecimals)} (raw=${tokenDelta.toString()})`));
+        if (usdcDelta <= 0n) {
+            console.log(chalk.yellow(`  ⚠️  No USDC balance increase detected. Funds may have been sent to a different recipient.`));
+        }
+    }
+    if (!silent) {
+        console.log(chalk.green(`  ✅ Swap complete!`));
+    }
+    return swapTx;
+}
+export async function sellToken(client, identifier, // Can be token ID, name, or symbol
+tokenAmount, silent = false, // Suppress resolver output for quiet/JSON mode
+privateKey // Private key for executing Uniswap swaps
 ) {
-    // Resolve/validate identifier (returns identifier as-is, backend will resolve)
-    const tokenIdentifier = await resolveTokenId(identifier, client, silent);
-    // Validate that we got a tokenIdentifier
-    if (!tokenIdentifier || typeof tokenIdentifier !== 'string') {
+    // Resolve identifier to token ID (or contract address for external tokens)
+    const tokenId = await resolveTokenId(identifier, client, silent);
+    // Validate that we got a tokenId
+    if (!tokenId || typeof tokenId !== 'string') {
         throw new Error(`Failed to resolve token identifier: ${identifier}`);
     }
-    // Ensure tokenIdentifier is set in input
-    const input = {
-        tokenIdentifier,
-        tokenAmount
-    };
-    // Double-check tokenIdentifier is set
-    if (!input.tokenIdentifier) {
-        throw new Error(`Token identifier is missing in input object. Resolved identifier was: ${tokenIdentifier}`);
+    // Validate input
+    validateTokenId(tokenId);
+    // Check if it's a contract address (external token)
+    const addressRegex = /^0x[0-9a-f]{40}$/i;
+    const isExternalToken = addressRegex.test(tokenId);
+    // For external tokens, skip token info lookup and go straight to universal swap
+    if (isExternalToken) {
+        // External token - use universal swap
+        if (!privateKey) {
+            throw new Error('Private key required for swaps');
+        }
+        // For external tokens, we need to check on-chain balance to handle percentages
+        // The tokenAmount parameter might be a percentage like "50%" or "all"
+        // We need the actual balance to convert that to a token amount
+        // For now, just pass the tokenAmount as-is to the backend
+        // The backend will need to handle this or we need to check balance here
+        // TODO: Handle percentage amounts for external tokens
+        // Get transaction data from backend using universal swap
+        const input = { tokenIdentifier: tokenId, tokenAmount, slippage: 0.5 };
+        const { data } = await client.invoke('token_sell_universal', input);
+        // Check price impact (confirmation disabled for now)
+        if (data.priceImpact) {
+            await checkPriceImpact(data.priceImpact, silent);
+        }
+        // Execute the swap on-chain
+        const txHash = await executeUniswapSell(data, privateKey, silent);
+        return {
+            tokenId: data.tokenId,
+            tokenAddress: data.tokenAddress,
+            tokenName: data.tokenName,
+            tokenSymbol: data.tokenSymbol,
+            tokensSold: data.tokenAmount,
+            usdcReceived: data.expectedUsdc,
+            newPrice: data.pricePerToken,
+            source: 'uniswap_v2',
+            txHash,
+            slippage: data.slippage,
+            priceImpact: data.priceImpact,
+            route: data.route,
+            routeFee: data.fee,
+        };
     }
+    // Internal token - get token info to check status
+    const tokenInfo = await getTokenInfo(client, tokenId, undefined, silent);
+    // Check token status and route accordingly
+    if (tokenInfo.status === 'graduating') {
+        throw new Error('Token is currently graduating. Please wait for graduation to complete.');
+    }
+    if (tokenInfo.status === 'graduated') {
+        // Use Uniswap V2 for graduated tokens
+        if (!privateKey) {
+            throw new Error('Private key required for Uniswap V2 swaps');
+        }
+        // Get transaction data from backend using universal swap
+        const input = { tokenIdentifier: tokenId, tokenAmount, slippage: 0.5 };
+        const { data } = await client.invoke('token_sell_universal', input);
+        // Check price impact (confirmation disabled for now)
+        if (data.priceImpact) {
+            await checkPriceImpact(data.priceImpact, silent);
+        }
+        // Sanity check: token amount should be reasonable (< 10^30)
+        const tokenAmountBigInt = BigInt(data.tokenAmount);
+        const maxReasonableAmount = BigInt('1000000000000000000000000000000'); // 10^30
+        if (tokenAmountBigInt > maxReasonableAmount) {
+            throw new Error(`Backend returned invalid token amount: ${data.tokenAmount}. ` +
+                `This is likely a backend bug. Expected amount around ${tokenAmount} tokens (18 decimals).`);
+        }
+        if (!silent) {
+            console.log(`Selling ${formatUnits(tokenAmountBigInt, 18)} tokens`);
+            console.log(`Expected USDC: ${formatUnits(BigInt(data.expectedUsdc), 6)}`);
+        }
+        // Execute the swap on-chain
+        const txHash = await executeUniswapSell(data, privateKey, silent);
+        return {
+            tokenId: data.tokenId,
+            tokenAddress: data.tokenAddress,
+            tokenName: data.tokenName,
+            tokenSymbol: data.tokenSymbol,
+            tokensSold: data.tokenAmount,
+            usdcReceived: data.expectedUsdc,
+            newPrice: data.pricePerToken,
+            source: 'uniswap_v2',
+            txHash,
+            slippage: data.slippage,
+            priceImpact: data.priceImpact,
+            route: data.route,
+            routeFee: data.fee,
+        };
+    }
+    // Active token - use bonding curve (existing logic)
+    const input = { tokenIdentifier: tokenId, tokenAmount };
     // Make request
     const { data } = await client.invoke('token_sell', input);
-    return data;
+    // Add token info and source to result
+    return {
+        ...data,
+        tokenAddress: tokenInfo.address,
+        tokenName: tokenInfo.name,
+        tokenSymbol: tokenInfo.symbol,
+        source: 'bonding_curve',
+    };
 }
 export function displaySellResult(result) {
     printSuccess('Tokens sold successfully!', 'money');
-    printBox('💸 Sale Summary', {
-        'Tokens Sold': formatTokenAmount(result.tokensSold),
-        'USDC Received': formatCurrency(result.usdcReceived),
-        'Fee (1%)': formatCurrency(result.fee),
-        'New Price': formatCurrency(result.newPrice),
-        'New Market Cap': formatCurrency(result.newMcap),
-        'Graduation': `${result.graduationProgress.toFixed(2)}%`,
-    });
-    if (result.usdcTransferTx) {
+    if (result.source === 'uniswap_v2') {
+        // Graduated token - Uniswap V2 display
+        const boxContent = {
+            'Token': `${result.tokenName} (${result.tokenSymbol})`,
+            'Contract': formatAddress(result.tokenAddress || ''),
+            'Source': result.route ?? 'Uniswap',
+            'Tokens Sold': formatTokenAmount(result.tokensSold),
+            'USDC Received': formatCurrency(result.usdcReceived, 6),
+            'Price': formatCurrency(result.newPrice),
+        };
+        if (result.slippage !== undefined) {
+            boxContent['Slippage'] = `${result.slippage}%`;
+        }
+        if (result.txHash) {
+            boxContent['Transaction'] = result.txHash;
+        }
+        printBox('💸 Sale Summary', boxContent);
+        // Display price impact warning
+        if (result.priceImpact !== undefined) {
+            console.log();
+            if (result.priceImpact < 0.5) {
+                console.log(chalk.green(`  Price Impact:    ${result.priceImpact.toFixed(2)}%`));
+            }
+            else if (result.priceImpact < 1) {
+                console.log(chalk.yellow(`  Price Impact:    ${result.priceImpact.toFixed(2)}%`));
+            }
+            else if (result.priceImpact < 3) {
+                console.log(chalk.red(`  ⚠️  HIGH Price Impact: ${result.priceImpact.toFixed(2)}%`));
+                console.log(chalk.yellow(`     Your trade will move the market significantly.`));
+            }
+            else {
+                console.log(chalk.red(`  🚨 VERY HIGH Price Impact: ${result.priceImpact.toFixed(2)}%`));
+                console.log(chalk.yellow(`     Consider splitting into smaller trades.`));
+            }
+        }
+        // Display route info
+        if (result.route) {
+            const feePercent = result.routeFee ? (result.routeFee / 10000).toFixed(2) : 'N/A';
+            console.log(chalk.cyan(`  Route:           ${result.route} (${feePercent}% fee)`));
+        }
+    }
+    else {
+        // Active token - Bonding curve display
+        const boxContent = {
+            'Token': `${result.tokenName} (${result.tokenSymbol})`,
+            'Contract': formatAddress(result.tokenAddress || ''),
+            'Source': 'Bonding Curve',
+            'Tokens Sold': formatTokenAmount(result.tokensSold),
+            'USDC Received': formatCurrency(result.usdcReceived, 6),
+        };
+        if (result.fee) {
+            boxContent['Fee (1%)'] = formatCurrency(result.fee, 6);
+        }
+        boxContent['New Price'] = formatCurrency(result.newPrice);
+        if (result.newMcap) {
+            boxContent['New Market Cap'] = formatCurrency(result.newMcap);
+        }
+        if (result.graduationProgress !== undefined) {
+            boxContent['Graduation'] = `${result.graduationProgress.toFixed(2)}%`;
+        }
+        printBox('💸 Sale Summary', boxContent);
+        if (result.usdcTransferTx) {
+            console.log();
+            console.log('Transaction:', result.usdcTransferTx);
+        }
         console.log();
-        console.log('Transaction:', result.usdcTransferTx);
+        if (result.graduationProgress !== undefined) {
+            printGraduationProgress(result.graduationProgress);
+        }
     }
-    console.log();
-    printGraduationProgress(result.graduationProgress);
 }
 /**
  * Parse token amount from various formats: