httpcat-cli 0.3.0 → 0.3.1

package/dist/commands/swap.js

@@ -0,0 +1,744 @@
+import chalk from "chalk";
+import { printBox, } from "../utils/formatting.js";
+import { printSuccess } from "../interactive/art.js";
+import { createPublicClient, createWalletClient, parseAbi, formatUnits, parseUnits, decodeEventLog, } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { getUSDCAddress, getNetworkConfig } from "../utils/constants.js";
+import { resolveTokenId } from "../utils/token-resolver.js";
+import { getTokenInfo } from "./info.js";
+import { createRpcTransport } from "../utils/rpc-transport.js";
+/**
+ * Resolve a token identifier (symbol, name, or address) to a contract address
+ */
+async function resolveToAddress(identifier, client, network, silent) {
+    const lower = identifier.toLowerCase().trim();
+    // Handle USDC specially
+    if (lower === "usdc") {
+        return getUSDCAddress(network);
+    }
+    // Check if it's already an address
+    const addressRegex = /^0x[0-9a-f]{40}$/i;
+    if (addressRegex.test(identifier)) {
+        return identifier;
+    }
+    // Resolve via token_info
+    const tokenId = await resolveTokenId(identifier, client, silent);
+    // If resolveTokenId returned an address (external token or CAT), use it
+    if (addressRegex.test(tokenId)) {
+        return tokenId;
+    }
+    // Otherwise it's a UUID - get the token info to find the address
+    const tokenInfo = await getTokenInfo(client, tokenId, undefined, silent);
+    if (!tokenInfo.address) {
+        throw new Error(`Token ${identifier} has no contract address`);
+    }
+    return tokenInfo.address;
+}
+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)",
+    "function symbol() view returns (string)",
+    "function name() view returns (string)",
+]);
+const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+// Routers that use Permit2 for token transfers
+const PERMIT2_ROUTERS = new Set([
+    "0x6ff5693b99212da76ad316178a184ab56d299b43", // Uniswap Universal Router (Base)
+    "0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad", // Uniswap Universal Router (Mainnet)
+    "0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc", // Uniswap Universal Router (Base Sepolia)
+].map((a) => a.toLowerCase()));
+// Routers that require direct ERC20 approve (NOT Permit2)
+const DIRECT_APPROVE_ROUTERS = new Set([
+    "0x6352a56caadc4f1e25cd6c75970fa768a3304e64", // OpenOcean Exchange (Base)
+    "0xdef1c0ded9bec7f1a1670819833240f027b25eff", // 0x Exchange Proxy
+].map((a) => a.toLowerCase()));
+/**
+ * Check if a router uses Permit2 or requires direct ERC20 approval
+ */
+function routerUsesPermit2(routerAddress) {
+    const normalized = routerAddress.toLowerCase();
+    // Explicitly known Permit2 routers
+    if (PERMIT2_ROUTERS.has(normalized)) {
+        return true;
+    }
+    // Explicitly known direct-approve routers
+    if (DIRECT_APPROVE_ROUTERS.has(normalized)) {
+        return false;
+    }
+    // Default: assume direct approval for unknown routers (safer)
+    // Most DEX aggregators use direct approval
+    return false;
+}
+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;
+}
+/**
+ * Ensure direct ERC20 approval to a router (for non-Permit2 routers like OpenOcean)
+ */
+async function ensureDirectApproval(args) {
+    const currentAllowance = await args.publicClient.readContract({
+        address: args.tokenIn,
+        abi: ERC20_ABI,
+        functionName: "allowance",
+        args: [args.userAddress, args.router],
+    });
+    if (currentAllowance >= args.amount) {
+        if (!args.silent) {
+            console.log(chalk.dim(`  ✓ Already approved to router`));
+        }
+        return;
+    }
+    if (!args.silent) {
+        console.log(chalk.cyan(`  Approving token to router...`));
+    }
+    const maxUint256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+    const approveTx = await args.walletClient.writeContract({
+        address: args.tokenIn,
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [args.router, maxUint256],
+    });
+    await args.publicClient.waitForTransactionReceipt({ hash: approveTx });
+}
+async function ensurePermit2Allowance(args) {
+    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, args.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 >= args.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: [args.tokenIn, args.universalRouter, MAX_UINT160, MAX_UINT48],
+    });
+    await args.publicClient.waitForTransactionReceipt({ hash: approveTx });
+}
+async function executeSwap(swapData, tokenIn, tokenOut, amountIn, privateKey, chain, silent, httpcatClient) {
+    const account = privateKeyToAccount(privateKey);
+    const userAddress = account.address;
+    if (process.env.DEBUG) {
+        console.log(`[executeSwap] Starting swap execution`);
+        console.log(`[executeSwap] User: ${userAddress}`);
+        console.log(`[executeSwap] TokenIn: ${tokenIn}`);
+        console.log(`[executeSwap] TokenOut: ${tokenOut}`);
+        console.log(`[executeSwap] AmountIn: ${amountIn.toString()}`);
+        console.log(`[executeSwap] Provider: ${swapData.provider}`);
+        console.log(`[executeSwap] Route: ${swapData.route}`);
+        console.log(`[executeSwap] Expected AmountOut: ${swapData.amountOut}`);
+        console.log(`[executeSwap] Min AmountOut: ${swapData.minAmountOut}`);
+        console.log(`[executeSwap] Swap target: ${swapData.transaction.to}`);
+        console.log(`[executeSwap] Swap value: ${swapData.transaction.value}`);
+        console.log(`[executeSwap] Swap data length: ${swapData.transaction.data.length} chars`);
+    }
+    const publicClient = createPublicClient({
+        chain,
+        transport: createRpcTransport({
+            chainId: chain.id,
+            httpcatClient,
+        }),
+    });
+    const walletClient = createWalletClient({
+        account,
+        chain,
+        transport: createRpcTransport({
+            chainId: chain.id,
+            httpcatClient,
+        }),
+    });
+    const routerAddress = swapData.transaction.to;
+    const usesPermit2 = routerUsesPermit2(routerAddress);
+    if (usesPermit2) {
+        // Permit2 flow: approve token to Permit2, then set Permit2 allowance to router
+        if (!silent) {
+            console.log(chalk.dim(`  Router ${routerAddress.slice(0, 10)}... uses Permit2`));
+        }
+        const currentAllowance = await publicClient.readContract({
+            address: tokenIn,
+            abi: ERC20_ABI,
+            functionName: "allowance",
+            args: [userAddress, PERMIT2_ADDRESS],
+        });
+        if (currentAllowance < amountIn) {
+            if (!silent) {
+                console.log(chalk.cyan(`  Approving ${tokenIn} to Permit2...`));
+            }
+            const maxUint256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+            const approveTx = await walletClient.writeContract({
+                address: tokenIn,
+                abi: ERC20_ABI,
+                functionName: "approve",
+                args: [PERMIT2_ADDRESS, maxUint256],
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+        }
+        else if (!silent) {
+            console.log(chalk.dim(`  ✓ Already approved ${tokenIn} to Permit2`));
+        }
+        // Ensure Permit2 allowance to Universal Router
+        await ensurePermit2Allowance({
+            tokenIn,
+            amount: amountIn,
+            universalRouter: routerAddress,
+            userAddress,
+            publicClient,
+            walletClient,
+            silent,
+        });
+    }
+    else {
+        // Direct approval flow: approve token directly to router (OpenOcean, 0x, etc.)
+        if (!silent) {
+            console.log(chalk.dim(`  Router ${routerAddress.slice(0, 10)}... uses direct approval`));
+        }
+        await ensureDirectApproval({
+            tokenIn,
+            amount: amountIn,
+            router: routerAddress,
+            userAddress,
+            publicClient,
+            walletClient,
+            silent,
+        });
+    }
+    if (!silent) {
+        console.log(chalk.cyan(`  Executing swap via ${swapData.provider}...`));
+    }
+    // Get balances before
+    const tokenInBefore = (await publicClient.readContract({
+        address: tokenIn,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [userAddress],
+    }));
+    const tokenOutBefore = (await publicClient.readContract({
+        address: tokenOut,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [userAddress],
+    }));
+    if (process.env.DEBUG) {
+        console.log(`[executeSwap] TokenIn balance before: ${tokenInBefore.toString()}`);
+        console.log(`[executeSwap] TokenOut balance before: ${tokenOutBefore.toString()}`);
+    }
+    // Execute swap
+    let swapTx;
+    try {
+        if (process.env.DEBUG) {
+            console.log(`[executeSwap] Sending swap transaction...`);
+        }
+        swapTx = await walletClient.sendTransaction({
+            to: swapData.transaction.to,
+            data: swapData.transaction.data,
+            value: BigInt(swapData.transaction.value),
+        });
+        if (process.env.DEBUG) {
+            console.log(`[executeSwap] Swap tx submitted: ${swapTx}`);
+        }
+    }
+    catch (error) {
+        const msg = String(error?.message ?? "");
+        if (process.env.DEBUG) {
+            console.log(`[executeSwap] Transaction estimation error: ${msg}`);
+        }
+        // Don't retry with manual gas for known failure cases
+        const isKnownFailure = msg.toLowerCase().includes("safeerc20") ||
+            msg.toLowerCase().includes("low-level call failed") ||
+            msg.toLowerCase().includes("insufficient liquidity") ||
+            msg.toLowerCase().includes("transfer failed");
+        if (msg.toLowerCase().includes("execution reverted") && !isKnownFailure) {
+            if (!silent) {
+                console.log(chalk.yellow(`  ⚠️  Estimation reverted; force-broadcasting with manual gas limit...`));
+            }
+            if (process.env.DEBUG) {
+                console.log(`[executeSwap] Retrying with manual gas limit (1,500,000)...`);
+            }
+            swapTx = await walletClient.sendTransaction({
+                to: swapData.transaction.to,
+                data: swapData.transaction.data,
+                value: BigInt(swapData.transaction.value),
+                gas: 1500000n,
+            });
+            if (process.env.DEBUG) {
+                console.log(`[executeSwap] Swap tx submitted (manual gas): ${swapTx}`);
+            }
+        }
+        else {
+            if (process.env.DEBUG) {
+                console.log(`[executeSwap] ${isKnownFailure
+                    ? "Known failure - not retrying"
+                    : "Fatal error, throwing"}: ${msg}`);
+            }
+            throw error;
+        }
+    }
+    if (process.env.DEBUG) {
+        console.log(`[executeSwap] Waiting for transaction receipt...`);
+    }
+    const receipt = await publicClient.waitForTransactionReceipt({
+        hash: swapTx,
+    });
+    if (process.env.DEBUG) {
+        console.log(`[executeSwap] Receipt received`);
+        console.log(`[executeSwap] Receipt status: ${receipt.status}`);
+        console.log(`[executeSwap] Gas used: ${receipt.gasUsed?.toString()}`);
+        console.log(`[executeSwap] Block number: ${receipt.blockNumber?.toString()}`);
+        console.log(`[executeSwap] Number of logs: ${receipt.logs?.length || 0}`);
+    }
+    // Check if transaction reverted
+    if (receipt.status === "reverted") {
+        throw new Error(`Swap transaction reverted. This usually means:\n` +
+            `  - Insufficient liquidity for this trade\n` +
+            `  - Slippage tolerance too low\n` +
+            `  - Price moved unfavorably\n` +
+            `  - Token approval issue\n\n` +
+            `Transaction: ${swapTx}\n` +
+            `Try increasing slippage with --slippage (e.g., --slippage 100 for 1%)`);
+    }
+    // Calculate actual deltas
+    if (process.env.DEBUG) {
+        console.log(`[executeSwap] Calculating token deltas from receipt logs...`);
+    }
+    let tokenInDelta = getErc20NetDeltaFromReceipt({
+        receipt,
+        token: tokenIn,
+        user: userAddress,
+    });
+    let tokenOutDelta = getErc20NetDeltaFromReceipt({
+        receipt,
+        token: tokenOut,
+        user: userAddress,
+    });
+    if (process.env.DEBUG) {
+        console.log(`[executeSwap] TokenIn delta (from logs): ${tokenInDelta.toString()}`);
+        console.log(`[executeSwap] TokenOut delta (from logs): ${tokenOutDelta.toString()}`);
+    }
+    // Fallback to balance comparison
+    if (tokenInDelta === 0n || tokenOutDelta === 0n) {
+        if (process.env.DEBUG) {
+            console.log(`[executeSwap] One or both deltas are 0, checking actual balances...`);
+        }
+        const tokenInAfter = (await publicClient.readContract({
+            address: tokenIn,
+            abi: ERC20_ABI,
+            functionName: "balanceOf",
+            args: [userAddress],
+        }));
+        const tokenOutAfter = (await publicClient.readContract({
+            address: tokenOut,
+            abi: ERC20_ABI,
+            functionName: "balanceOf",
+            args: [userAddress],
+        }));
+        if (process.env.DEBUG) {
+            console.log(`[executeSwap] TokenIn balance after: ${tokenInAfter.toString()}`);
+            console.log(`[executeSwap] TokenOut balance after: ${tokenOutAfter.toString()}`);
+        }
+        if (tokenInDelta === 0n)
+            tokenInDelta = tokenInAfter - tokenInBefore;
+        if (tokenOutDelta === 0n)
+            tokenOutDelta = tokenOutAfter - tokenOutBefore;
+        if (process.env.DEBUG) {
+            console.log(`[executeSwap] TokenIn delta (from balance): ${tokenInDelta.toString()}`);
+            console.log(`[executeSwap] TokenOut delta (from balance): ${tokenOutDelta.toString()}`);
+        }
+    }
+    // Final safety check: if both deltas are 0, the swap failed
+    if (tokenInDelta === 0n && tokenOutDelta === 0n) {
+        if (process.env.DEBUG) {
+            console.log(`[executeSwap] ❌ Both deltas are 0 - swap failed!`);
+        }
+        throw new Error(`Swap failed: No tokens were transferred.\n` +
+            `Transaction: ${swapTx}\n` +
+            `The transaction was mined but no swap occurred. This usually means:\n` +
+            `  - Insufficient liquidity\n` +
+            `  - Slippage tolerance too low\n` +
+            `  - Invalid route\n\n` +
+            `Try increasing slippage with --slippage (e.g., --slippage 100 for 1%)`);
+    }
+    if (!silent) {
+        console.log(chalk.green(`  ✅ Swap complete!`));
+        let tokenInDecimals = 18;
+        let tokenOutDecimals = 18;
+        try {
+            tokenInDecimals = Number(await publicClient.readContract({
+                address: tokenIn,
+                abi: ERC20_ABI,
+                functionName: "decimals",
+            }));
+            tokenOutDecimals = Number(await publicClient.readContract({
+                address: tokenOut,
+                abi: ERC20_ABI,
+                functionName: "decimals",
+            }));
+        }
+        catch {
+            /* ignore */
+        }
+        console.log(chalk.dim(`  Token in delta: ${formatUnits(tokenInDelta, tokenInDecimals)} (raw=${tokenInDelta.toString()})`));
+        console.log(chalk.dim(`  Token out delta: ${formatUnits(tokenOutDelta, tokenOutDecimals)} (raw=${tokenOutDelta.toString()})`));
+    }
+    // Return absolute values (tokenInDelta is negative, tokenOutDelta is positive)
+    const result = {
+        txHash: swapTx,
+        actualAmountIn: tokenInDelta < 0n ? -tokenInDelta : tokenInDelta,
+        actualAmountOut: tokenOutDelta < 0n ? -tokenOutDelta : tokenOutDelta,
+    };
+    if (process.env.DEBUG) {
+        console.log(`[executeSwap] ✅ Swap successful!`);
+        console.log(`[executeSwap] Final actualAmountIn: ${result.actualAmountIn.toString()}`);
+        console.log(`[executeSwap] Final actualAmountOut: ${result.actualAmountOut.toString()}`);
+        console.log(`[executeSwap] Tx hash: ${result.txHash}`);
+    }
+    return result;
+}
+export async function swap(client, tokenInIdentifier, tokenOutIdentifier, amount, slippageBps = 50, silent = false, privateKey) {
+    if (!privateKey) {
+        throw new Error("Private key required for swaps");
+    }
+    const account = privateKeyToAccount(privateKey);
+    const userAddress = account.address;
+    const network = client.getNetwork();
+    // Resolve token identifiers to addresses
+    if (!silent) {
+        console.log(chalk.cyan(`Resolving tokens...`));
+    }
+    const tokenIn = await resolveToAddress(tokenInIdentifier, client, network, silent);
+    const tokenOut = await resolveToAddress(tokenOutIdentifier, client, network, silent);
+    // Get network config (chain + USDC address)
+    const { chain } = await getNetworkConfig(network);
+    // Get token metadata
+    const publicClient = createPublicClient({
+        chain,
+        transport: createRpcTransport({
+            chainId: chain.id,
+            httpcatClient: client,
+        }),
+    });
+    let tokenInSymbol = "???";
+    let tokenOutSymbol = "???";
+    let tokenInDecimals = 18;
+    let tokenOutDecimals = 18;
+    try {
+        tokenInSymbol = (await publicClient.readContract({
+            address: tokenIn,
+            abi: ERC20_ABI,
+            functionName: "symbol",
+        }));
+        tokenInDecimals = Number(await publicClient.readContract({
+            address: tokenIn,
+            abi: ERC20_ABI,
+            functionName: "decimals",
+        }));
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        tokenOutSymbol = (await publicClient.readContract({
+            address: tokenOut,
+            abi: ERC20_ABI,
+            functionName: "symbol",
+        }));
+        tokenOutDecimals = Number(await publicClient.readContract({
+            address: tokenOut,
+            abi: ERC20_ABI,
+            functionName: "decimals",
+        }));
+    }
+    catch {
+        /* ignore */
+    }
+    // Convert human-readable amount to smallest units
+    const amountInSmallestUnits = parseUnits(amount, tokenInDecimals);
+    if (!silent) {
+        console.log(chalk.cyan(`Swapping ${amount} ${tokenInSymbol} → ${tokenOutSymbol}...`));
+        console.log(chalk.dim(`  tokenIn: ${tokenIn}`));
+        console.log(chalk.dim(`  tokenOut: ${tokenOut}`));
+        console.log(chalk.dim(`  amount (raw): ${amountInSmallestUnits.toString()}`));
+    }
+    // Call the universal_swap endpoint
+    const input = {
+        tokenIn,
+        tokenOut,
+        amount: amountInSmallestUnits.toString(),
+        slippageBps,
+        recipient: userAddress,
+    };
+    const { data, payment } = await client.invoke("swaps/universal", input);
+    // Execute the swap on-chain
+    const swapResult = await executeSwap(data, tokenIn, tokenOut, amountInSmallestUnits, privateKey, chain, silent, client);
+    return {
+        ...data,
+        tokenInSymbol,
+        tokenOutSymbol,
+        tokenInDecimals,
+        tokenOutDecimals,
+        txHash: swapResult.txHash,
+        paymentTxHash: payment?.txHash,
+        // Use actual on-chain amounts instead of quote estimates
+        amountIn: swapResult.actualAmountIn.toString(),
+        amountOut: swapResult.actualAmountOut.toString(),
+        minAmountOut: swapResult.actualAmountOut.toString(), // Actual = min since it already executed
+    };
+}
+export function displaySwapResult(result) {
+    printSuccess("Swap completed successfully!", "money");
+    console.log();
+    const tokenInDecimals = result.tokenInDecimals ?? 18;
+    const tokenOutDecimals = result.tokenOutDecimals ?? 18;
+    console.log(chalk.magenta.bold("🔄 Swap Summary"));
+    console.log();
+    const amountInStr = result.amountIn
+        ? formatUnits(BigInt(result.amountIn), tokenInDecimals) +
+            ` ${result.tokenInSymbol}`
+        : "N/A";
+    const amountOutStr = formatUnits(BigInt(result.amountOut), tokenOutDecimals) +
+        ` ${result.tokenOutSymbol}`;
+    const minAmountOutStr = formatUnits(BigInt(result.minAmountOut), tokenOutDecimals) +
+        ` ${result.tokenOutSymbol}`;
+    const boxContent = {
+        Swap: chalk.blue(result.tokenInSymbol) +
+            chalk.cyan(" → ") +
+            chalk.yellow.bold(result.tokenOutSymbol),
+        Provider: chalk.cyan(result.provider),
+        Route: chalk.yellow(result.route),
+        "Amount In": result.amountIn ? chalk.cyan(amountInStr) : chalk.dim("N/A"),
+        "Amount Out": chalk.green.bold(amountOutStr),
+        "Min Amount Out": chalk.green(minAmountOutStr),
+    };
+    if (result.txHash) {
+        boxContent["Transaction"] = chalk.cyan(result.txHash);
+    }
+    printBox("Swap Details", boxContent);
+    // Display price impact
+    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)}%`));
+        }
+        else {
+            console.log(chalk.red(`  🚨 VERY HIGH Price Impact: ${result.priceImpact.toFixed(2)}%`));
+        }
+    }
+    // Display gas estimate
+    if (result.gasEstimate) {
+        console.log(chalk.dim(`  Gas Estimate:    ${result.gasEstimate} wei`));
+    }
+    console.log();
+}
+/**
+ * Execute a MEV-protected swap via UniswapX Dutch auction
+ */
+export async function shieldedSwap(client, tokenInIdentifier, tokenOutIdentifier, amount, slippageBps = 50, privateKey, silent = false) {
+    const account = privateKeyToAccount(privateKey);
+    const userAddress = account.address;
+    const network = client.getNetwork();
+    // Resolve token identifiers to addresses
+    if (!silent) {
+        console.log(chalk.cyan(`Resolving tokens...`));
+    }
+    const tokenIn = await resolveToAddress(tokenInIdentifier, client, network, silent);
+    const tokenOut = await resolveToAddress(tokenOutIdentifier, client, network, silent);
+    // Get network config (chain + USDC address)
+    const { chain } = await getNetworkConfig(network);
+    // Get token metadata
+    const publicClient = createPublicClient({
+        chain,
+        transport: createRpcTransport({
+            chainId: chain.id,
+            httpcatClient: client,
+        }),
+    });
+    let tokenInSymbol = "???";
+    let tokenOutSymbol = "???";
+    let tokenInDecimals = 18;
+    let tokenOutDecimals = 18;
+    try {
+        tokenInSymbol = (await publicClient.readContract({
+            address: tokenIn,
+            abi: ERC20_ABI,
+            functionName: "symbol",
+        }));
+        tokenInDecimals = Number(await publicClient.readContract({
+            address: tokenIn,
+            abi: ERC20_ABI,
+            functionName: "decimals",
+        }));
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        tokenOutSymbol = (await publicClient.readContract({
+            address: tokenOut,
+            abi: ERC20_ABI,
+            functionName: "symbol",
+        }));
+        tokenOutDecimals = Number(await publicClient.readContract({
+            address: tokenOut,
+            abi: ERC20_ABI,
+            functionName: "decimals",
+        }));
+    }
+    catch {
+        /* ignore */
+    }
+    // Convert human-readable amount to smallest units
+    const amountInSmallestUnits = parseUnits(amount, tokenInDecimals);
+    if (!silent) {
+        console.log(chalk.cyan(`Swapping ${amount} ${tokenInSymbol} → ${tokenOutSymbol} (MEV-protected)...`));
+        console.log(chalk.dim(`  tokenIn: ${tokenIn}`));
+        console.log(chalk.dim(`  tokenOut: ${tokenOut}`));
+        console.log(chalk.dim(`  amount (raw): ${amountInSmallestUnits.toString()}`));
+    }
+    // Call the shielded swap endpoint
+    const input = {
+        tokenIn,
+        tokenOut,
+        amount: amountInSmallestUnits.toString(),
+        slippageBps,
+        recipient: userAddress,
+    };
+    const { data, payment } = await client.invoke("swaps/shielded", input);
+    // Shielded swaps via UniswapX are handled off-chain, so we may not have a transaction
+    // The orderHash indicates the order was placed
+    return {
+        ...data,
+        tokenInSymbol,
+        tokenOutSymbol,
+        tokenInDecimals,
+        tokenOutDecimals,
+        paymentTxHash: payment?.txHash,
+        amountIn: amountInSmallestUnits.toString(),
+    };
+}
+export function displayShieldedSwapResult(result) {
+    printSuccess("MEV-protected swap order placed!", "money");
+    console.log();
+    const tokenInDecimals = result.tokenInDecimals ?? 18;
+    const tokenOutDecimals = result.tokenOutDecimals ?? 18;
+    console.log(chalk.magenta.bold("🛡️  Shielded Swap Summary"));
+    console.log();
+    const amountInStr = result.amountIn
+        ? formatUnits(BigInt(result.amountIn), tokenInDecimals) +
+            ` ${result.tokenInSymbol}`
+        : "N/A";
+    const amountOutStr = formatUnits(BigInt(result.amountOut), tokenOutDecimals) +
+        ` ${result.tokenOutSymbol}`;
+    const minAmountOutStr = formatUnits(BigInt(result.minAmountOut), tokenOutDecimals) +
+        ` ${result.tokenOutSymbol}`;
+    const boxContent = {
+        Swap: chalk.blue(result.tokenInSymbol) +
+            chalk.cyan(" → ") +
+            chalk.yellow.bold(result.tokenOutSymbol),
+        Provider: chalk.cyan(result.provider),
+        Route: chalk.yellow(result.route),
+        "Amount In": result.amountIn ? chalk.cyan(amountInStr) : chalk.dim("N/A"),
+        "Amount Out": chalk.green.bold(amountOutStr),
+        "Min Amount Out": chalk.green(minAmountOutStr),
+    };
+    if (result.orderHash) {
+        boxContent["Order Hash"] = chalk.cyan(result.orderHash);
+    }
+    if (result.txHash) {
+        boxContent["Transaction"] = chalk.cyan(result.txHash);
+    }
+    printBox("Shielded Swap Details", boxContent);
+    // Display price impact
+    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)}%`));
+        }
+        else {
+            console.log(chalk.red(`  🚨 VERY HIGH Price Impact: ${result.priceImpact.toFixed(2)}%`));
+        }
+    }
+    // Display gas estimate
+    if (result.gasEstimate) {
+        console.log(chalk.dim(`  Gas Estimate:    ${result.gasEstimate} wei`));
+    }
+    console.log();
+    console.log(chalk.cyan("💡 This swap is MEV-protected via UniswapX Dutch auction. The order will be filled by a filler."));
+    console.log();
+}
+//# sourceMappingURL=swap.js.map