httpcat-cli 0.0.27 → 0.1.1-rc.1

package/dist/commands/buy.js

@@ -1,52 +1,760 @@
-import chalk from 'chalk';
-import { validateAmount } from '../utils/validation.js';
-import { printBox, formatTokenAmount, formatCurrency } from '../utils/formatting.js';
-import { printSuccess, printGraduationProgress } from '../interactive/art.js';
-import { resolveTokenId } from '../utils/token-resolver.js';
-export const TEST_AMOUNTS = ['0.05', '0.10', '0.20'];
-export const PROD_AMOUNTS = ['50', '100', '200'];
-export async function buyToken(client, identifier, // Can be token ID (UUID), address (0x...), name, or symbol
-amount, isTestMode = true, silent = false // Suppress resolver output for quiet/JSON mode
+import chalk from "chalk";
+import { validateTokenId, validateAmount } 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";
+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";
+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.)`));
+            }
+        }
+    }
+}
+export const TEST_AMOUNTS = ["0.05", "0.10", "0.20"];
+export const PROD_AMOUNTS = ["50", "100", "200"];
+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)",
+    "function decimals() view returns (uint8)",
+]);
+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
+        }
+    }
+    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;
+    let tokenIn = null;
+    let amount = null;
+    // Find V4_SWAP command and decode first action params (ExactInputSingle)
+    const commands = decoded.commands;
+    const cmdLen = (commands.length - 2) / 2;
+    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 ? decoded.inputs[v4Index] : undefined;
+    if (v4Input) {
+        try {
+            const [_, params] = decodeAbiParameters([
+                { name: 'actions', type: 'bytes' },
+                { name: 'params', type: 'bytes[]' },
+            ], v4Input);
+            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 calldata 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 toBigInt = (v) => (typeof v === 'bigint' ? v : BigInt(v));
+    const normalizeAllowance = (raw) => {
+        if (Array.isArray(raw)) {
+            const [a, e, n] = raw;
+            return {
+                amount: toBigInt(a),
+                expiration: toBigInt(e),
+                nonce: toBigInt(n),
+            };
+        }
+        return {
+            amount: toBigInt(raw.amount),
+            expiration: toBigInt(raw.expiration),
+            nonce: toBigInt(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}`));
+    }
+    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 executeUniswapBuy(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
+    if (!silent) {
+        console.log(chalk.cyan(`  Executing swap via ${swapData.route}...`));
+    }
+    const usdcBefore = (await publicClient.readContract({
+        address: USDC_ADDRESS,
+        abi: ERC20_ABI,
+        functionName: 'balanceOf',
+        args: [userAddress],
+    }));
+    const tokenBefore = (await publicClient.readContract({
+        address: swapData.tokenAddress,
+        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) {
+                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 (!silent) {
+        console.log(chalk.green(`  ✅ Swap complete!`));
+    }
+    if (!silent) {
+        try {
+            const usdcDeltaFromLogs = getErc20NetDeltaFromReceipt({
+                receipt,
+                token: USDC_ADDRESS,
+                user: userAddress,
+            });
+            const tokenDeltaFromLogs = getErc20NetDeltaFromReceipt({
+                receipt,
+                token: swapData.tokenAddress,
+                user: userAddress,
+            });
+            // For buys:
+            // - USDC delta is typically negative (spent)
+            // - token delta is typically positive (received)
+            let usdcDelta = usdcDeltaFromLogs;
+            let tokenDelta = tokenDeltaFromLogs;
+            // Fallback to balance snapshots if logs don't include transfers
+            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: swapData.tokenAddress,
+                        abi: ERC20_ABI,
+                        functionName: 'balanceOf',
+                        args: [userAddress],
+                    }));
+                    if (usdcDelta === 0n)
+                        usdcDelta = usdcAfter - usdcBefore;
+                    if (tokenDelta === 0n)
+                        tokenDelta = tokenAfter - tokenBefore;
+                }
+                catch {
+                    // ignore
+                }
+            }
+            let tokenDecimals = 18;
+            try {
+                tokenDecimals = Number(await publicClient.readContract({
+                    address: swapData.tokenAddress,
+                    abi: ERC20_ABI,
+                    functionName: 'decimals',
+                }));
+            }
+            catch {
+                // ignore
+            }
+            console.log(chalk.dim(`  Actual USDC delta: ${formatUnits(usdcDelta, 6)} (raw=${usdcDelta.toString()})`));
+            console.log(chalk.dim(`  Actual token delta: ${formatUnits(tokenDelta, tokenDecimals)} (raw=${tokenDelta.toString()})`));
+        }
+        catch {
+            // ignore
+        }
+    }
+    return swapTx;
+}
+export async function buyToken(client, identifier, // Can be token ID, name, or symbol
+amount, isTestMode = true, 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 amount
+    // Resolve identifier to token ID (or contract address for external tokens)
+    const tokenId = await resolveTokenId(identifier, client, silent);
+    // Validate input
+    validateTokenId(tokenId);
+    // Check if it's a contract address
+    const addressRegex = /^0x[0-9a-f]{40}$/i;
+    const isContractAddress = addressRegex.test(tokenId);
+    // If it's a contract address, try to look it up in the database first
+    // It might be one of our tokens (bonding curve or graduated)
+    if (isContractAddress) {
+        try {
+            // Try to get token info - if it exists in our DB, use normal flow
+            const tokenInfo = await getTokenInfo(client, tokenId, undefined, silent);
+            // It's one of our tokens! Continue with normal flow based on status
+            if (tokenInfo.status === "graduating") {
+                throw new Error("Token is currently graduating. Please wait for graduation to complete.");
+            }
+            if (tokenInfo.status === "graduated") {
+                // Graduated token - use universal swap
+                const amountNum = parseFloat(amount);
+                if (isNaN(amountNum) || amountNum <= 0) {
+                    throw new Error("Amount must be a positive number");
+                }
+                if (!privateKey) {
+                    throw new Error("Private key required for Uniswap V2 swaps");
+                }
+                // Get user address from private key
+                const account = privateKeyToAccount(privateKey);
+                const userAddress = account.address;
+                // Get transaction data from backend using universal swap
+                const input = { tokenIdentifier: tokenId, amount, slippage: 0.5, recipient: userAddress };
+                const { data } = await client.invoke("token_buy_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 executeUniswapBuy(data, privateKey, silent);
+                return {
+                    tokenId: data.tokenId,
+                    tokenAddress: data.tokenAddress,
+                    tokenName: data.tokenName,
+                    tokenSymbol: data.tokenSymbol,
+                    tokensReceived: data.expectedTokens,
+                    amountSpent: data.usdcAmount,
+                    newPrice: data.pricePerToken,
+                    source: "uniswap_v2",
+                    txHash,
+                    slippage: data.slippage,
+                    priceImpact: data.priceImpact,
+                    route: data.route,
+                    routeFee: data.fee,
+                };
+            }
+            // Active token - fall through to bonding curve logic below
+        }
+        catch (error) {
+            // Token not in our database - treat as external token
+            if (error.message?.includes('not found') || error.message?.includes('Invalid UUID')) {
+                // External token - use universal swap
+                const amountNum = parseFloat(amount);
+                if (isNaN(amountNum) || amountNum <= 0) {
+                    throw new Error("Amount must be a positive number");
+                }
+                if (!privateKey) {
+                    throw new Error("Private key required for swaps");
+                }
+                // Get user address from private key
+                const account = privateKeyToAccount(privateKey);
+                const userAddress = account.address;
+                // Get transaction data from backend using universal swap
+                const input = { tokenIdentifier: tokenId, amount, slippage: 0.5, recipient: userAddress };
+                const { data } = await client.invoke("token_buy_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 executeUniswapBuy(data, privateKey, silent);
+                return {
+                    tokenId: data.tokenId,
+                    tokenAddress: data.tokenAddress,
+                    tokenName: data.tokenName,
+                    tokenSymbol: data.tokenSymbol,
+                    tokensReceived: data.expectedTokens,
+                    amountSpent: data.usdcAmount,
+                    newPrice: data.pricePerToken,
+                    source: "uniswap_v2",
+                    txHash,
+                    slippage: data.slippage,
+                    priceImpact: data.priceImpact,
+                    route: data.route,
+                    routeFee: data.fee,
+                };
+            }
+            else {
+                // Some other error - rethrow
+                throw error;
+            }
+        }
+    }
+    // For UUID tokens or contract addresses that are in our DB, get token info
+    const tokenInfo = isContractAddress
+        ? await getTokenInfo(client, tokenId, undefined, silent)
+        : 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 - any amount allowed
+        const amountNum = parseFloat(amount);
+        if (isNaN(amountNum) || amountNum <= 0) {
+            throw new Error("Amount must be a positive number");
+        }
+        if (!privateKey) {
+            throw new Error("Private key required for Uniswap V2 swaps");
+        }
+        // Get transaction data from backend using universal swap
+        const input = { tokenIdentifier: tokenId, amount, slippage: 0.5 };
+        const { data } = await client.invoke("token_buy_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 executeUniswapBuy(data, privateKey, silent);
+        return {
+            tokenId: data.tokenId,
+            tokenAddress: data.tokenAddress,
+            tokenName: data.tokenName,
+            tokenSymbol: data.tokenSymbol,
+            tokensReceived: data.expectedTokens,
+            amountSpent: data.usdcAmount,
+            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 validAmounts = isTestMode ? TEST_AMOUNTS : PROD_AMOUNTS;
     const normalizedAmount = validateAmount(amount, validAmounts, isTestMode);
-    const input = { tokenIdentifier, amount: normalizedAmount };
+    const input = {
+        tokenIdentifier: tokenId,
+        amount: normalizedAmount,
+    };
     // Route to correct entrypoint based on test mode and amount
     // Test mode: token_buy_0_05, token_buy_0_10, token_buy_0_20
     // Production mode: token_buy (single entrypoint)
-    const entrypoint = isTestMode ? `token_buy_${normalizedAmount.replace('.', '_')}` : 'token_buy';
+    const entrypoint = isTestMode
+        ? `token_buy_${normalizedAmount.replace(".", "_")}`
+        : "token_buy";
     // Make request
     const { data } = await client.invoke(entrypoint, 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 displayBuyResult(result) {
-    printSuccess('Tokens purchased successfully!', 'money');
-    const graduationStatus = result.graduationReached
-        ? '✅ GRADUATED!'
-        : `${result.graduationProgress.toFixed(2)}%`;
-    printBox('💰 Purchase Summary', {
-        'Tokens Received': formatTokenAmount(result.tokensReceived),
-        'Amount Spent': formatCurrency(result.amountSpent),
-        'Fee (1%)': formatCurrency(result.fee),
-        'New Price': formatCurrency(result.newPrice),
-        'New Market Cap': formatCurrency(result.newMcap),
-        'Graduation': graduationStatus,
-    });
-    console.log();
-    printGraduationProgress(result.graduationProgress);
+    printSuccess("Tokens purchased successfully!", "money");
+    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 Received": formatTokenAmount(result.tokensReceived),
+            "Amount Spent": formatCurrency(result.amountSpent, 6),
+            Price: formatCurrency(result.newPrice),
+        };
+        if (result.slippage !== undefined) {
+            boxContent["Slippage"] = `${result.slippage}%`;
+        }
+        if (result.txHash) {
+            boxContent["Transaction"] = result.txHash;
+        }
+        printBox("💰 Purchase 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 graduationStatus = result.graduationReached
+            ? "✅ GRADUATED!"
+            : `${(result.graduationProgress || 0).toFixed(2)}%`;
+        const boxContent = {
+            Token: `${result.tokenName} (${result.tokenSymbol})`,
+            Contract: formatAddress(result.tokenAddress || ""),
+            Source: "Bonding Curve",
+            "Tokens Received": formatTokenAmount(result.tokensReceived),
+            "Amount Spent": formatCurrency(result.amountSpent, 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);
+        }
+        boxContent["Graduation"] = graduationStatus;
+        printBox("💰 Purchase Summary", boxContent);
+        console.log();
+        if (result.graduationProgress !== undefined) {
+            printGraduationProgress(result.graduationProgress);
+        }
+    }
 }
 export function displayBuyResultCompact(result, buyNumber, totalBuys) {
     const graduationStatus = result.graduationReached
-        ? '✅ GRADUATED!'
-        : `${result.graduationProgress.toFixed(2)}%`;
-    const prefix = buyNumber && totalBuys
-        ? chalk.dim(`[${buyNumber}/${totalBuys}] `)
-        : '';
+        ? "✅ GRADUATED!"
+        : `${(result.graduationProgress || 0).toFixed(2)}%`;
+    const prefix = buyNumber && totalBuys ? chalk.dim(`[${buyNumber}/${totalBuys}] `) : "";
     console.log(prefix +
-        chalk.green('✅ Buy successful! ') +
+        chalk.green("✅ Buy successful! ") +
         `Received ${chalk.cyan(formatTokenAmount(result.tokensReceived))} tokens, ` +
         `spent ${chalk.yellow(formatCurrency(result.amountSpent))}, ` +
         `new price ${chalk.cyan(formatCurrency(result.newPrice))}, ` +