@sherwoodagent/cli 0.18.4 → 0.19.0

package/dist/trade-YCBFXOB3.js

@@ -0,0 +1,874 @@
+import {
+  getResearchProvider
+} from "./chunk-ZXV4TBPE.js";
+import {
+  UniswapProvider,
+  chatCompletion,
+  getQuote
+} from "./chunk-DCT3IDBS.js";
+import {
+  ERC20_ABI,
+  TOKENS
+} from "./chunk-W76CHVD3.js";
+import {
+  getAccount,
+  getPublicClient
+} from "./chunk-HRA2KPGW.js";
+import {
+  getExplorerUrl
+} from "./chunk-FEDSWXSD.js";
+import {
+  loadConfig,
+  saveConfig
+} from "./chunk-B4BMCXWK.js";
+
+// src/commands/trade.ts
+import chalk from "chalk";
+import ora from "ora";
+import { confirm } from "@inquirer/prompts";
+import { isAddress, parseUnits as parseUnits2, formatUnits as formatUnits2 } from "viem";
+
+// src/lib/signals.ts
+var DEFAULT_CONFIG = {
+  buyThreshold: 0.3,
+  sellThreshold: -0.2
+};
+async function analyzeToken(tokenAddress, tokenSymbol, config) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  let totalCostUsdc = 0;
+  const [onChain, social, fundamental] = await Promise.allSettled([
+    getOnChainSignal(tokenSymbol),
+    getSocialSignal(tokenAddress, tokenSymbol),
+    getFundamentalSignal(tokenSymbol)
+  ]);
+  const signals = [];
+  if (onChain.status === "fulfilled") {
+    signals.push(onChain.value.signal);
+    totalCostUsdc += onChain.value.costUsdc;
+  }
+  if (social.status === "fulfilled") {
+    signals.push(social.value.signal);
+    totalCostUsdc += social.value.costUsdc;
+  }
+  if (fundamental.status === "fulfilled") {
+    signals.push(fundamental.value.signal);
+    totalCostUsdc += fundamental.value.costUsdc;
+  }
+  let weightedSum = 0;
+  let totalWeight = 0;
+  for (const s of signals) {
+    weightedSum += s.value * s.weight;
+    totalWeight += s.weight;
+  }
+  const compositeScore = totalWeight > 0 ? weightedSum / totalWeight : 0;
+  const confidence = signals.length > 0 ? signals.reduce((sum, s) => sum + Math.abs(s.value), 0) / signals.length : 0;
+  let action = "hold";
+  if (compositeScore >= cfg.buyThreshold && confidence >= 0.5) {
+    action = "buy";
+  } else if (compositeScore <= cfg.sellThreshold) {
+    action = "sell";
+  }
+  return {
+    action,
+    confidence: Math.min(confidence, 1),
+    compositeScore,
+    signals,
+    costUsdc: totalCostUsdc.toFixed(4),
+    timestamp: Math.floor(Date.now() / 1e3)
+  };
+}
+async function getOnChainSignal(tokenSymbol) {
+  const nansen = getResearchProvider("nansen");
+  let result;
+  try {
+    result = await nansen.query({ type: "smart-money", target: tokenSymbol });
+  } catch {
+    return {
+      signal: {
+        source: "onchain",
+        name: "smart_money_net_flow",
+        value: 0,
+        weight: 0.4,
+        raw: { error: "nansen query failed" }
+      },
+      costUsdc: 0
+    };
+  }
+  const data = result.data;
+  const netFlow = extractNetFlow(data);
+  const value = Math.max(-1, Math.min(1, netFlow));
+  return {
+    signal: {
+      source: "onchain",
+      name: "smart_money_net_flow",
+      value,
+      weight: 0.4,
+      raw: data
+    },
+    costUsdc: Number(result.costUsdc) || 0.06
+  };
+}
+async function getSocialSignal(tokenAddress, tokenSymbol) {
+  try {
+    const result = await chatCompletion({
+      model: "llama-3.3-70b",
+      messages: [
+        {
+          role: "system",
+          content: `You are a crypto market sentiment analyst. Analyze current Twitter/X discourse about the given token. Return ONLY valid JSON with no markdown: {"sentiment": <number from -1.0 to 1.0>, "reasoning": "<brief explanation>", "tweetCount": <estimated tweets in last 24h>, "keyTopics": ["topic1", "topic2"]}. Positive sentiment means bullish discussion, influencer endorsements, positive news. Negative means FUD, rug pull warnings, community exodus. If you cannot find data, return {"sentiment": 0, "reasoning": "insufficient data", "tweetCount": 0, "keyTopics": []}.`
+        },
+        {
+          role: "user",
+          content: `Analyze current X/Twitter sentiment for token ${tokenSymbol} (contract: ${tokenAddress} on Base chain). What is the social consensus in the last 24 hours?`
+        }
+      ],
+      temperature: 0.3,
+      maxTokens: 500,
+      enableWebSearch: true
+    });
+    const parsed = parseJsonResponse(result.content);
+    const sentiment = typeof parsed.sentiment === "number" ? Math.max(-1, Math.min(1, parsed.sentiment)) : 0;
+    return {
+      signal: {
+        source: "social",
+        name: "x_sentiment",
+        value: sentiment,
+        weight: 0.3,
+        raw: parsed
+      },
+      costUsdc: 0
+      // Venice inference is prepaid via sVVV, no per-call cost
+    };
+  } catch {
+    return {
+      signal: {
+        source: "social",
+        name: "x_sentiment",
+        value: 0,
+        weight: 0.3,
+        raw: { error: "venice inference failed" }
+      },
+      costUsdc: 0
+    };
+  }
+}
+async function getFundamentalSignal(tokenSymbol) {
+  const messari = getResearchProvider("messari");
+  let result;
+  try {
+    result = await messari.query({ type: "market", target: tokenSymbol });
+  } catch {
+    return {
+      signal: {
+        source: "fundamental",
+        name: "market_fundamentals",
+        value: 0,
+        weight: 0.3,
+        raw: { error: "messari query failed" }
+      },
+      costUsdc: 0
+    };
+  }
+  const data = result.data;
+  const value = scoreFundamentals(data);
+  return {
+    signal: {
+      source: "fundamental",
+      name: "market_fundamentals",
+      value,
+      weight: 0.3,
+      raw: data
+    },
+    costUsdc: Number(result.costUsdc) || 0.2
+  };
+}
+function extractNetFlow(data) {
+  const netFlow = data.netFlow ?? data.net_flow ?? (data.inflow ?? 0) - (data.outflow ?? 0);
+  if (typeof netFlow !== "number" || isNaN(netFlow)) return 0;
+  const normalized = netFlow / 1e6;
+  return Math.max(-1, Math.min(1, normalized));
+}
+function scoreFundamentals(data) {
+  let score = 0;
+  const marketData = data.marketData ?? data.market_data ?? data;
+  const athData = data.allTimeHigh ?? data.ath ?? {};
+  const vol24h = toNumber(marketData.volume_last_24_hours ?? marketData.volume24h);
+  const vol7d = toNumber(marketData.volume_last_7_days ?? marketData.volume7d);
+  if (vol24h > 0 && vol7d > 0) {
+    const dailyAvg7d = vol7d / 7;
+    const ratio = vol24h / dailyAvg7d;
+    if (ratio > 3) score += 0.5;
+    else if (ratio > 2) score += 0.25;
+    else if (ratio < 0.5) score -= 0.25;
+  }
+  const mcap = toNumber(marketData.current_marketcap_usd ?? marketData.marketCap);
+  if (mcap > 0 && mcap < 1e7 && vol24h > 0) {
+    score += 0.3;
+  } else if (mcap > 1e9) {
+    score -= 0.15;
+  }
+  const currentPrice = toNumber(marketData.price_usd ?? marketData.currentPrice);
+  const athPrice = toNumber(athData.price ?? athData.athPrice);
+  if (currentPrice > 0 && athPrice > 0) {
+    const athDistance = (athPrice - currentPrice) / athPrice * 100;
+    if (athDistance > 80) score += 0.2;
+    else if (athDistance < 10) score -= 0.3;
+  }
+  return Math.max(-1, Math.min(1, score));
+}
+function toNumber(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") return Number(v) || 0;
+  return 0;
+}
+function parseJsonResponse(content) {
+  let cleaned = content.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+  }
+  const start = cleaned.indexOf("{");
+  const end = cleaned.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    try {
+      return JSON.parse(cleaned.slice(start, end + 1));
+    } catch {
+    }
+  }
+  return { sentiment: 0, reasoning: "failed to parse response", raw: content };
+}
+
+// src/lib/exit-strategy.ts
+var DEFAULT_EXIT_CONFIG = {
+  stopLossPct: 10,
+  trailingStopPct: 0,
+  takeProfitPct: 0,
+  deadlineUnix: 0,
+  signalExitEnabled: true
+};
+function checkExit(entryPrice, currentPrice, highWaterPrice, config, signalResult) {
+  if (entryPrice <= 0) {
+    return { shouldExit: false, reason: "hold", currentPnlPct: 0, highWaterPnlPct: 0 };
+  }
+  const currentPnlPct = (currentPrice - entryPrice) / entryPrice * 100;
+  const highWaterPnlPct = (highWaterPrice - entryPrice) / entryPrice * 100;
+  if (config.deadlineUnix > 0 && Date.now() / 1e3 > config.deadlineUnix) {
+    return { shouldExit: true, reason: "deadline", currentPnlPct, highWaterPnlPct };
+  }
+  if (currentPnlPct <= -config.stopLossPct) {
+    return { shouldExit: true, reason: "stop_loss", currentPnlPct, highWaterPnlPct };
+  }
+  if (config.trailingStopPct > 0 && highWaterPrice > 0) {
+    const drawdownPct = (highWaterPrice - currentPrice) / highWaterPrice * 100;
+    if (drawdownPct >= config.trailingStopPct) {
+      return { shouldExit: true, reason: "trailing_stop", currentPnlPct, highWaterPnlPct };
+    }
+  }
+  if (config.takeProfitPct > 0 && currentPnlPct >= config.takeProfitPct) {
+    return { shouldExit: true, reason: "take_profit", currentPnlPct, highWaterPnlPct };
+  }
+  if (config.signalExitEnabled && signalResult && signalResult.action === "sell" && signalResult.confidence > 0.4) {
+    return { shouldExit: true, reason: "signal_bearish", currentPnlPct, highWaterPnlPct };
+  }
+  return { shouldExit: false, reason: "hold", currentPnlPct, highWaterPnlPct };
+}
+
+// src/lib/positions.ts
+import { formatUnits, parseUnits } from "viem";
+function getOpenPositions() {
+  const config = loadConfig();
+  return config.positions ?? [];
+}
+function addPosition(pos) {
+  const config = loadConfig();
+  const positions = config.positions ?? [];
+  positions.push(pos);
+  config.positions = positions;
+  saveConfig(config);
+}
+function closePosition(tokenAddress, exitData) {
+  const config = loadConfig();
+  const positions = config.positions ?? [];
+  const idx = positions.findIndex(
+    (p) => p.tokenAddress.toLowerCase() === tokenAddress.toLowerCase()
+  );
+  if (idx === -1) {
+    throw new Error(`No open position for ${tokenAddress}`);
+  }
+  const [pos] = positions.splice(idx, 1);
+  const closed = { ...pos, ...exitData };
+  const closedPositions = config.closedPositions ?? [];
+  closedPositions.push(closed);
+  config.positions = positions;
+  config.closedPositions = closedPositions;
+  saveConfig(config);
+}
+function updateHighWater(tokenAddress, price) {
+  const config = loadConfig();
+  const positions = config.positions ?? [];
+  const pos = positions.find(
+    (p) => p.tokenAddress.toLowerCase() === tokenAddress.toLowerCase()
+  );
+  if (pos && price > pos.highWaterPrice) {
+    pos.highWaterPrice = price;
+    config.positions = positions;
+    saveConfig(config);
+  }
+}
+async function getCurrentPrice(tokenAddress, tokenDecimals, feeTier) {
+  const oneToken = parseUnits("1", tokenDecimals);
+  const usdc = TOKENS().USDC;
+  const { amountOut } = await getQuote({
+    tokenIn: tokenAddress,
+    tokenOut: usdc,
+    amountIn: oneToken,
+    fee: feeTier
+  });
+  return Number(formatUnits(amountOut, 6));
+}
+
+// src/commands/trade.ts
+var uniswap = new UniswapProvider();
+async function loadXmtp() {
+  return import("./xmtp-IH57GYSR.js");
+}
+var KNOWN_MEMECOINS = {
+  DEGEN: "0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed",
+  TOSHI: "0xAC1Bd2486aAf3B5C0fc3Fd868558b082a531B2B4",
+  BRETT: "0x532f27101965dd16442E59d40670FaF5eBB142E4",
+  HIGHER: "0x0578d8A44db98B23BF096A382e016e29a5Ce0ffe"
+};
+async function resolveToken(symbolOrAddress) {
+  let address;
+  let symbol;
+  if (isAddress(symbolOrAddress)) {
+    address = symbolOrAddress;
+    const client2 = getPublicClient();
+    try {
+      symbol = await client2.readContract({
+        address,
+        abi: ERC20_ABI,
+        functionName: "symbol"
+      });
+    } catch {
+      symbol = address.slice(0, 8);
+    }
+  } else {
+    const upper = symbolOrAddress.toUpperCase();
+    const tokens = TOKENS();
+    const tokenMap = {
+      USDC: tokens.USDC,
+      WETH: tokens.WETH,
+      ...KNOWN_MEMECOINS
+    };
+    address = tokenMap[upper];
+    if (!address) {
+      throw new Error(
+        `Unknown token: ${symbolOrAddress}. Use a contract address or known symbol (${Object.keys(tokenMap).join(", ")}).`
+      );
+    }
+    symbol = upper;
+  }
+  const client = getPublicClient();
+  const decimals = await client.readContract({
+    address,
+    abi: ERC20_ABI,
+    functionName: "decimals"
+  });
+  return { address, symbol, decimals };
+}
+async function postToChat(syndicate, type, text, data) {
+  try {
+    const xmtp = await loadXmtp();
+    const group = await xmtp.getGroup("", syndicate);
+    await xmtp.sendEnvelope(group, {
+      type,
+      from: getAccount().address,
+      text,
+      data,
+      timestamp: Math.floor(Date.now() / 1e3)
+    });
+  } catch {
+  }
+}
+function formatSignalTable(results) {
+  console.log();
+  console.log(chalk.bold("  Token          Score   Action   Conf.  On-chain  Social  Fundmtl"));
+  console.log(chalk.dim("  " + "\u2500".repeat(72)));
+  for (const { symbol, address, result } of results) {
+    const scoreColor = result.compositeScore > 0 ? chalk.green : result.compositeScore < 0 ? chalk.red : chalk.dim;
+    const actionColor = result.action === "buy" ? chalk.green.bold : result.action === "sell" ? chalk.red.bold : chalk.dim;
+    const onChain = result.signals.find((s) => s.source === "onchain");
+    const social = result.signals.find((s) => s.source === "social");
+    const fundamental = result.signals.find((s) => s.source === "fundamental");
+    const shortAddr = `${address.slice(0, 6)}..`;
+    const label = `${symbol.padEnd(6)} (${shortAddr})`;
+    console.log(
+      `  ${label.padEnd(16)} ${scoreColor(result.compositeScore.toFixed(2).padStart(6))}  ${actionColor(result.action.toUpperCase().padEnd(6))}  ${(result.confidence * 100).toFixed(0).padStart(4)}%  ${formatSignalValue(onChain?.value).padStart(8)}  ${formatSignalValue(social?.value).padStart(6)}  ${formatSignalValue(fundamental?.value).padStart(7)}`
+    );
+  }
+  console.log();
+}
+function formatSignalValue(v) {
+  if (v === void 0) return chalk.dim("n/a");
+  const s = (v >= 0 ? "+" : "") + v.toFixed(2);
+  return v > 0 ? chalk.green(s) : v < 0 ? chalk.red(s) : chalk.dim(s);
+}
+function registerTradeCommands(program) {
+  const trade = program.command("trade").description("Memecoin trading \u2014 scan, buy, sell, monitor positions (Uniswap Trading API on Base)");
+  trade.command("scan").description("Analyze token(s) using on-chain, social, and fundamental signals").option("--token <addr|symbol>", "Specific token to analyze (otherwise scans known memecoins)").option("--syndicate <name>", "Post results to syndicate chat").option("--yes", "Skip cost confirmation", false).action(async (opts) => {
+    const targets = [];
+    if (opts.token) {
+      const resolved = await resolveToken(opts.token);
+      targets.push({ symbol: resolved.symbol, address: resolved.address });
+    } else {
+      for (const [symbol, address] of Object.entries(KNOWN_MEMECOINS)) {
+        targets.push({ symbol, address });
+      }
+    }
+    const estCost = targets.length * 0.26;
+    console.log();
+    console.log(chalk.bold("Memecoin Alpha Scan"));
+    console.log(chalk.dim("\u2500".repeat(40)));
+    console.log(`  Tokens:    ${targets.map((t) => t.symbol).join(", ")}`);
+    console.log(`  Est. cost: ${chalk.yellow(`~$${estCost.toFixed(2)} USDC`)} (x402 research) + Venice inference`);
+    console.log();
+    if (!opts.yes) {
+      const ok = await confirm({
+        message: `Proceed with signal analysis?`,
+        default: true
+      });
+      if (!ok) {
+        console.log(chalk.dim("Cancelled."));
+        return;
+      }
+    }
+    const spinner = ora("Analyzing signals...").start();
+    const results = [];
+    for (const target of targets) {
+      try {
+        spinner.text = `Analyzing ${target.symbol}...`;
+        const result = await analyzeToken(target.address, target.symbol);
+        results.push({ ...target, result });
+      } catch {
+        results.push({
+          ...target,
+          result: {
+            action: "hold",
+            confidence: 0,
+            compositeScore: 0,
+            signals: [],
+            costUsdc: "0",
+            timestamp: Math.floor(Date.now() / 1e3)
+          }
+        });
+      }
+    }
+    spinner.succeed("Scan complete");
+    formatSignalTable(results);
+    const totalCost = results.reduce((sum, r) => sum + Number(r.result.costUsdc), 0);
+    console.log(chalk.dim(`  Total research cost: $${totalCost.toFixed(4)} USDC`));
+    console.log();
+    if (opts.syndicate) {
+      await postToChat(
+        opts.syndicate,
+        "TRADE_SIGNAL",
+        `Scanned ${results.length} tokens: ${results.filter((r) => r.result.action === "buy").map((r) => r.symbol).join(", ") || "no buys"}`,
+        { results: results.map((r) => ({ symbol: r.symbol, action: r.result.action, score: r.result.compositeScore })) }
+      );
+    }
+  });
+  trade.command("buy").description("Buy a token with USDC via Uniswap Trading API").requiredOption("--token <addr|symbol>", "Token to buy").requiredOption("--amount <usdc>", "USDC amount to spend").option("--slippage <pct>", "Slippage tolerance % (default: 0.5)", "0.5").option("--stop-loss <pct>", "Stop loss percentage (default: 10)", "10").option("--trailing-stop <pct>", "Trailing stop percentage (0 = disabled)", "0").option("--deadline <hours>", "Force exit after N hours (0 = none)", "0").option("--syndicate <name>", "Post trade to syndicate chat").action(async (opts) => {
+    const { address: tokenAddr, symbol, decimals } = await resolveToken(opts.token);
+    const usdc = TOKENS().USDC;
+    const usdcAmount = parseUnits2(opts.amount, 6);
+    const slippage = Number(opts.slippage);
+    const client = getPublicClient();
+    const account = getAccount();
+    const balance = await client.readContract({
+      address: usdc,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [account.address]
+    });
+    if (balance < usdcAmount) {
+      console.error(chalk.red(
+        `Insufficient USDC. Have ${formatUnits2(balance, 6)}, need ${opts.amount}`
+      ));
+      process.exit(1);
+    }
+    const quoteSpinner = ora("Getting quote from Uniswap API...").start();
+    let expectedOut;
+    try {
+      const result = await uniswap.fullQuote({
+        tokenIn: usdc,
+        tokenOut: tokenAddr,
+        amountIn: usdcAmount,
+        slippageTolerance: slippage
+      });
+      expectedOut = result.amountOut;
+      const routing = result.routing;
+      quoteSpinner.succeed(
+        `Quote: ${formatUnits2(result.amountOut, decimals)} ${symbol} (${routing} route)`
+      );
+    } catch (err) {
+      quoteSpinner.fail("Quote failed");
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const swapSpinner = ora("Executing swap via Uniswap API...").start();
+    let txHash;
+    try {
+      const result = await uniswap.swap({
+        tokenIn: usdc,
+        tokenOut: tokenAddr,
+        amountIn: usdcAmount,
+        amountOutMinimum: 0n,
+        // slippage handled by API
+        fee: 3e3
+        // unused in API mode
+      });
+      txHash = result.hash;
+      if (!result.success) {
+        swapSpinner.fail("Swap reverted");
+        process.exit(1);
+      }
+      swapSpinner.succeed("Swap executed");
+    } catch (err) {
+      swapSpinner.fail("Swap failed");
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const tokenBalance = await client.readContract({
+      address: tokenAddr,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [account.address]
+    });
+    const tokensReceived = tokenBalance > 0n ? tokenBalance : expectedOut;
+    const entryPrice = Number(opts.amount) / Number(formatUnits2(tokensReceived, decimals));
+    const exitConfig = {
+      stopLossPct: Number(opts.stopLoss) || DEFAULT_EXIT_CONFIG.stopLossPct,
+      trailingStopPct: Number(opts.trailingStop) || DEFAULT_EXIT_CONFIG.trailingStopPct,
+      takeProfitPct: DEFAULT_EXIT_CONFIG.takeProfitPct,
+      deadlineUnix: Number(opts.deadline) > 0 ? Math.floor(Date.now() / 1e3) + Number(opts.deadline) * 3600 : 0,
+      signalExitEnabled: true
+    };
+    addPosition({
+      tokenAddress: tokenAddr,
+      tokenSymbol: symbol,
+      tokenDecimals: decimals,
+      amountIn: opts.amount,
+      amountOut: tokensReceived.toString(),
+      entryPrice,
+      highWaterPrice: entryPrice,
+      feeTier: 3e3,
+      // stored for price lookups via QuoterV2
+      openedAt: Math.floor(Date.now() / 1e3),
+      txHash,
+      exitConfig
+    });
+    console.log();
+    console.log(chalk.bold("Trade Executed"));
+    console.log(chalk.dim("\u2500".repeat(40)));
+    console.log(`  Token:    ${symbol} (${tokenAddr})`);
+    console.log(`  Spent:    ${opts.amount} USDC`);
+    console.log(`  Received: ${formatUnits2(tokensReceived, decimals)} ${symbol}`);
+    console.log(`  Entry:    $${entryPrice.toFixed(8)} per ${symbol}`);
+    console.log(`  Stop:     -${exitConfig.stopLossPct}%`);
+    if (exitConfig.trailingStopPct > 0) {
+      console.log(`  Trailing: ${exitConfig.trailingStopPct}%`);
+    }
+    if (exitConfig.deadlineUnix > 0) {
+      console.log(`  Deadline: ${new Date(exitConfig.deadlineUnix * 1e3).toISOString()}`);
+    }
+    console.log(`  Tx:       ${chalk.dim(getExplorerUrl(txHash))}`);
+    try {
+      const { createTradeAttestation, getEasScanUrl } = await import("./eas-YZF6MN65.js");
+      const { uid } = await createTradeAttestation(
+        usdc,
+        tokenAddr,
+        usdcAmount,
+        formatUnits2(tokensReceived, decimals),
+        txHash,
+        "BUY"
+      );
+      if (uid !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        console.log(`  Attested: ${chalk.dim(getEasScanUrl(uid))}`);
+      }
+    } catch {
+    }
+    console.log();
+    if (opts.syndicate) {
+      await postToChat(
+        opts.syndicate,
+        "TRADE_EXECUTED",
+        `Bought ${formatUnits2(tokensReceived, decimals)} ${symbol} for ${opts.amount} USDC via Uniswap`,
+        { token: symbol, address: tokenAddr, amountUsdc: opts.amount, txHash }
+      );
+    }
+  });
+  trade.command("sell").description("Sell a token position back to USDC via Uniswap Trading API").requiredOption("--token <addr|symbol>", "Token to sell").option("--amount <n>", "Token amount to sell (default: entire position)").option("--slippage <pct>", "Slippage tolerance % (default: 0.5)", "0.5").option("--syndicate <name>", "Post trade to syndicate chat").action(async (opts) => {
+    const { address: tokenAddr, symbol, decimals } = await resolveToken(opts.token);
+    const usdc = TOKENS().USDC;
+    const slippage = Number(opts.slippage);
+    const positions = getOpenPositions();
+    const pos = positions.find(
+      (p) => p.tokenAddress.toLowerCase() === tokenAddr.toLowerCase()
+    );
+    const client = getPublicClient();
+    const account = getAccount();
+    let sellAmount;
+    if (opts.amount) {
+      sellAmount = parseUnits2(opts.amount, decimals);
+    } else {
+      sellAmount = await client.readContract({
+        address: tokenAddr,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [account.address]
+      });
+    }
+    if (sellAmount === 0n) {
+      console.error(chalk.red("No tokens to sell."));
+      process.exit(1);
+    }
+    const quoteSpinner = ora("Getting quote from Uniswap API...").start();
+    let expectedUsdc;
+    try {
+      const result = await uniswap.fullQuote({
+        tokenIn: tokenAddr,
+        tokenOut: usdc,
+        amountIn: sellAmount,
+        slippageTolerance: slippage
+      });
+      expectedUsdc = result.amountOut;
+      const routing = result.routing;
+      quoteSpinner.succeed(
+        `Quote: ${formatUnits2(result.amountOut, 6)} USDC (${routing} route)`
+      );
+    } catch (err) {
+      quoteSpinner.fail("Quote failed");
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const swapSpinner = ora("Executing sell via Uniswap API...").start();
+    let txHash;
+    try {
+      const result = await uniswap.swap({
+        tokenIn: tokenAddr,
+        tokenOut: usdc,
+        amountIn: sellAmount,
+        amountOutMinimum: 0n,
+        fee: 3e3
+      });
+      txHash = result.hash;
+      if (!result.success) {
+        swapSpinner.fail("Sell reverted");
+        process.exit(1);
+      }
+      swapSpinner.succeed("Sell executed");
+    } catch (err) {
+      swapSpinner.fail("Sell failed");
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const usdcReceived = Number(formatUnits2(expectedUsdc, 6));
+    const costBasis = pos ? Number(pos.amountIn) : 0;
+    const pnlUsdc = costBasis > 0 ? usdcReceived - costBasis : 0;
+    const pnlPct = costBasis > 0 ? pnlUsdc / costBasis * 100 : 0;
+    const exitPrice = sellAmount > 0n ? usdcReceived / Number(formatUnits2(sellAmount, decimals)) : 0;
+    if (pos) {
+      closePosition(tokenAddr, {
+        exitPrice,
+        closedAt: Math.floor(Date.now() / 1e3),
+        exitTxHash: txHash,
+        exitReason: "manual",
+        pnlUsdc,
+        pnlPct
+      });
+    }
+    const pnlColor = pnlUsdc >= 0 ? chalk.green : chalk.red;
+    console.log();
+    console.log(chalk.bold("Position Closed"));
+    console.log(chalk.dim("\u2500".repeat(40)));
+    console.log(`  Token:    ${symbol}`);
+    console.log(`  Sold:     ${formatUnits2(sellAmount, decimals)} ${symbol}`);
+    console.log(`  Received: ~${usdcReceived.toFixed(2)} USDC`);
+    if (costBasis > 0) {
+      console.log(`  Cost:     ${costBasis.toFixed(2)} USDC`);
+      console.log(`  P&L:      ${pnlColor(`${pnlUsdc >= 0 ? "+" : ""}${pnlUsdc.toFixed(2)} USDC (${pnlPct >= 0 ? "+" : ""}${pnlPct.toFixed(1)}%)`)}`);
+    }
+    console.log(`  Tx:       ${chalk.dim(getExplorerUrl(txHash))}`);
+    try {
+      const { createTradeAttestation, getEasScanUrl } = await import("./eas-YZF6MN65.js");
+      const { uid } = await createTradeAttestation(
+        tokenAddr,
+        usdc,
+        sellAmount,
+        usdcReceived.toFixed(6),
+        txHash,
+        "SELL"
+      );
+      if (uid !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        console.log(`  Attested: ${chalk.dim(getEasScanUrl(uid))}`);
+      }
+    } catch {
+    }
+    console.log();
+    if (opts.syndicate) {
+      await postToChat(
+        opts.syndicate,
+        "TRADE_EXECUTED",
+        `Sold ${formatUnits2(sellAmount, decimals)} ${symbol} for ~${usdcReceived.toFixed(2)} USDC (P&L: ${pnlUsdc >= 0 ? "+" : ""}${pnlUsdc.toFixed(2)})`,
+        { token: symbol, address: tokenAddr, usdcReceived, pnlUsdc, pnlPct, txHash }
+      );
+    }
+  });
+  trade.command("positions").description("Show open positions with current prices and unrealized P&L").action(async () => {
+    const positions = getOpenPositions();
+    if (positions.length === 0) {
+      console.log(chalk.dim("\n  No open positions.\n"));
+      return;
+    }
+    console.log();
+    console.log(chalk.bold("Open Positions"));
+    console.log(chalk.dim("\u2500".repeat(80)));
+    console.log(chalk.dim(
+      "  Token          Entry        Current      Qty                Cost      Value     P&L"
+    ));
+    for (const pos of positions) {
+      try {
+        const current = await getCurrentPrice(pos.tokenAddress, pos.tokenDecimals, pos.feeTier);
+        const qty = Number(formatUnits2(BigInt(pos.amountOut), pos.tokenDecimals));
+        const cost = Number(pos.amountIn);
+        const value = qty * current;
+        const pnl = value - cost;
+        const pnlPct = cost > 0 ? pnl / cost * 100 : 0;
+        const pnlColor = pnl >= 0 ? chalk.green : chalk.red;
+        console.log(
+          `  ${pos.tokenSymbol.padEnd(14)} $${pos.entryPrice.toFixed(6).padStart(10)}  $${current.toFixed(6).padStart(10)}  ${qty.toFixed(2).padStart(15)}  $${cost.toFixed(2).padStart(8)}  $${value.toFixed(2).padStart(8)}  ` + pnlColor(`${pnl >= 0 ? "+" : ""}${pnl.toFixed(2)} (${pnlPct >= 0 ? "+" : ""}${pnlPct.toFixed(1)}%)`)
+        );
+        if (current > pos.highWaterPrice) {
+          updateHighWater(pos.tokenAddress, current);
+        }
+      } catch {
+        console.log(
+          `  ${pos.tokenSymbol.padEnd(14)} $${pos.entryPrice.toFixed(6).padStart(10)}  ${chalk.dim("price unavailable")}`
+        );
+      }
+    }
+    console.log();
+  });
+  trade.command("monitor").description("Monitor positions and auto-exit on signal triggers").option("--interval <seconds>", "Check interval in seconds (default: 300)", "300").option("--syndicate <name>", "Post updates to syndicate chat").action(async (opts) => {
+    const interval = Number(opts.interval) * 1e3;
+    console.log();
+    console.log(chalk.bold("Position Monitor"));
+    console.log(chalk.dim(`Checking every ${opts.interval}s. Press Ctrl-C to stop.`));
+    console.log();
+    const running = { value: true };
+    process.on("SIGINT", () => {
+      running.value = false;
+      console.log(chalk.dim("\nStopping monitor..."));
+    });
+    while (running.value) {
+      const positions = getOpenPositions();
+      if (positions.length === 0) {
+        console.log(chalk.dim("  No open positions. Waiting..."));
+        await sleep(interval);
+        continue;
+      }
+      for (const pos of positions) {
+        if (!running.value) break;
+        try {
+          const current = await getCurrentPrice(pos.tokenAddress, pos.tokenDecimals, pos.feeTier);
+          const hwPrice = Math.max(current, pos.highWaterPrice);
+          if (current > pos.highWaterPrice) {
+            updateHighWater(pos.tokenAddress, current);
+          }
+          let signalResult;
+          if (pos.exitConfig.signalExitEnabled) {
+            try {
+              signalResult = await analyzeToken(pos.tokenAddress, pos.tokenSymbol);
+            } catch {
+            }
+          }
+          const exit = checkExit(pos.entryPrice, current, hwPrice, pos.exitConfig, signalResult);
+          const pnlPct = exit.currentPnlPct;
+          const pnlColor = pnlPct >= 0 ? chalk.green : chalk.red;
+          const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+          console.log(
+            `  [${ts}] ${pos.tokenSymbol}: $${current.toFixed(6)} ` + pnlColor(`(${pnlPct >= 0 ? "+" : ""}${pnlPct.toFixed(1)}%)`) + (exit.shouldExit ? chalk.red.bold(` \u2192 EXIT (${exit.reason})`) : "")
+          );
+          if (exit.shouldExit) {
+            console.log(chalk.yellow(`  Executing exit for ${pos.tokenSymbol}: ${exit.reason}`));
+            if (opts.syndicate) {
+              await postToChat(
+                opts.syndicate,
+                "RISK_ALERT",
+                `Exit triggered for ${pos.tokenSymbol}: ${exit.reason} (${pnlPct >= 0 ? "+" : ""}${pnlPct.toFixed(1)}%)`,
+                { token: pos.tokenSymbol, reason: exit.reason, pnlPct }
+              );
+            }
+            try {
+              const sellAmount = BigInt(pos.amountOut);
+              const usdc = TOKENS().USDC;
+              const { amountOut: sellQuote } = await uniswap.fullQuote({
+                tokenIn: pos.tokenAddress,
+                tokenOut: usdc,
+                amountIn: sellAmount,
+                slippageTolerance: 0.5
+              });
+              const result = await uniswap.swap({
+                tokenIn: pos.tokenAddress,
+                tokenOut: usdc,
+                amountIn: sellAmount,
+                amountOutMinimum: 0n,
+                fee: 3e3
+              });
+              const usdcReceived = Number(formatUnits2(sellQuote, 6));
+              const costBasis = Number(pos.amountIn);
+              const pnlUsdc = usdcReceived - costBasis;
+              closePosition(pos.tokenAddress, {
+                exitPrice: current,
+                closedAt: Math.floor(Date.now() / 1e3),
+                exitTxHash: result.hash,
+                exitReason: exit.reason,
+                pnlUsdc,
+                pnlPct
+              });
+              const pnlStr = `${pnlUsdc >= 0 ? "+" : ""}${pnlUsdc.toFixed(2)} USDC`;
+              console.log(chalk.green(`  Sold ${pos.tokenSymbol}: ${pnlStr}`));
+              if (opts.syndicate) {
+                await postToChat(
+                  opts.syndicate,
+                  "TRADE_EXECUTED",
+                  `Auto-sold ${pos.tokenSymbol}: ${pnlStr} (${exit.reason})`,
+                  { token: pos.tokenSymbol, reason: exit.reason, pnlUsdc, pnlPct, txHash: result.hash }
+                );
+              }
+            } catch (err) {
+              console.error(chalk.red(
+                `  Failed to sell ${pos.tokenSymbol}: ${err instanceof Error ? err.message : String(err)}`
+              ));
+            }
+          }
+        } catch {
+          console.error(chalk.dim(
+            `  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] ${pos.tokenSymbol}: price check failed`
+          ));
+        }
+      }
+      if (running.value) {
+        await sleep(interval);
+      }
+    }
+    console.log(chalk.dim("Monitor stopped."));
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  registerTradeCommands
+};
+//# sourceMappingURL=trade-YCBFXOB3.js.map