@sherwoodagent/cli 0.73.4 → 0.74.2

package/dist/{trade-LGFQEK3I.js → trade-WDPMFFYB.js}

@@ -1,37 +1,258 @@
 import {
   getResearchProvider
-} from "./chunk-BKJ7HYX7.js";
-import {
-  UniswapProvider,
-  getQuote
-} from "./chunk-DIZEB2VV.js";
+} from "./chunk-DGLLSZ2D.js";
+import "./chunk-EGJESQXZ.js";
 import {
   chatCompletion
-} from "./chunk-NPWYX6NU.js";
+} from "./chunk-BD4ZV7FQ.js";
+import {
+  getQuote
+} from "./chunk-WBQMGZ5X.js";
 import {
   TOKENS
-} from "./chunk-IFL5SREW.js";
+} from "./chunk-UINMHN6S.js";
 import {
   formatContractError,
   getAccount,
-  getPublicClient
-} from "./chunk-ROKE6ZAW.js";
+  getPublicClient,
+  sendTxWithRetry,
+  waitForReceipt
+} from "./chunk-2OHX3O55.js";
 import {
-  getExplorerUrl
-} from "./chunk-DXJJMRBM.js";
+  getChain,
+  getExplorerUrl,
+  getNetwork
+} from "./chunk-LHVSS27T.js";
 import {
+  getUniswapApiKey,
   loadConfig,
   saveConfig
-} from "./chunk-GSC7PVEO.js";
+} from "./chunk-6MV4ESXM.js";
 import {
   ERC20_ABI
-} from "./chunk-BQMOE4FJ.js";
+} from "./chunk-I2PC6TBZ.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";
+import { isAddress as isAddress2, parseUnits as parseUnits2, formatUnits as formatUnits3 } from "viem";
+
+// src/providers/uniswap.ts
+import { isAddress } from "viem";
+var API_BASE = "https://trade-api.gateway.uniswap.org/v1";
+function getApiKey() {
+  const key = getUniswapApiKey();
+  if (!key) {
+    throw new Error(
+      "Uniswap API key not configured. Run 'sherwood config set --uniswap-api-key <key>' or set UNISWAP_API_KEY env var.\nGet your key at https://developers.uniswap.org/"
+    );
+  }
+  return key;
+}
+function apiHeaders() {
+  return {
+    "Content-Type": "application/json",
+    "x-api-key": getApiKey(),
+    "x-universal-router-version": "2.0"
+  };
+}
+function isUniswapXRouting(routing) {
+  return routing === "DUTCH_V2" || routing === "DUTCH_V3" || routing === "PRIORITY";
+}
+function getOutputAmount(q) {
+  if (isUniswapXRouting(q.routing)) {
+    const ux = q;
+    const firstOutput = ux.quote.orderInfo.outputs[0];
+    if (!firstOutput) throw new Error("UniswapX quote has no outputs");
+    return firstOutput.startAmount;
+  }
+  return q.quote.output.amount;
+}
+async function fetchWithRetry(url, init, maxRetries = 3) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const response = await fetch(url, {
+      ...init,
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (response.status !== 429 && response.status < 500) return response;
+    if (attempt === maxRetries) return response;
+    const delay = Math.min(200 * Math.pow(2, attempt) + Math.random() * 100, 1e4);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+  }
+  throw new Error("Unreachable");
+}
+var UniswapProvider = class {
+  /**
+   * Get a quote from the Uniswap Trading API.
+   * Returns the optimal route (CLASSIC, PRIORITY, or UniswapX).
+   */
+  async quote(params) {
+    const account = getAccount();
+    const chainId = getChain().id;
+    const body = {
+      swapper: account.address,
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+      tokenInChainId: String(chainId),
+      tokenOutChainId: String(chainId),
+      amount: params.amountIn.toString(),
+      type: "EXACT_INPUT",
+      slippageTolerance: 0.5,
+      routingPreference: "BEST_PRICE"
+    };
+    const res = await fetchWithRetry(`${API_BASE}/quote`, {
+      method: "POST",
+      headers: apiHeaders(),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Uniswap quote failed (${res.status}): ${err}`);
+    }
+    const data = await res.json();
+    const amountOut = BigInt(getOutputAmount(data));
+    return {
+      amountOut,
+      priceImpact: 0,
+      route: `${data.routing}: ${params.tokenIn.slice(0, 8)}\u2192${params.tokenOut.slice(0, 8)}`
+    };
+  }
+  /**
+   * Get a full quote response (preserving the raw API response for swap execution).
+   */
+  async fullQuote(params) {
+    const account = getAccount();
+    const chainId = getChain().id;
+    const body = {
+      swapper: account.address,
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+      tokenInChainId: String(chainId),
+      tokenOutChainId: String(chainId),
+      amount: params.amountIn.toString(),
+      type: "EXACT_INPUT",
+      slippageTolerance: params.slippageTolerance ?? 0.5,
+      routingPreference: "BEST_PRICE"
+    };
+    const res = await fetchWithRetry(`${API_BASE}/quote`, {
+      method: "POST",
+      headers: apiHeaders(),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Uniswap quote failed (${res.status}): ${err}`);
+    }
+    const quoteResponse = await res.json();
+    const amountOut = BigInt(getOutputAmount(quoteResponse));
+    return { quoteResponse, amountOut, routing: quoteResponse.routing };
+  }
+  /**
+   * Check and handle token approval for Uniswap.
+   * Uses the Trading API's /check_approval endpoint.
+   */
+  async checkApproval(params) {
+    const account = getAccount();
+    const chainId = getChain().id;
+    const client = getPublicClient();
+    const res = await fetchWithRetry(`${API_BASE}/check_approval`, {
+      method: "POST",
+      headers: apiHeaders(),
+      body: JSON.stringify({
+        walletAddress: account.address,
+        token: params.token,
+        amount: params.amount.toString(),
+        chainId
+      })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Approval check failed (${res.status}): ${err}`);
+    }
+    const data = await res.json();
+    if (data.approval) {
+      const approvalHash = await sendTxWithRetry({
+        to: data.approval.to,
+        data: data.approval.data,
+        value: BigInt(data.approval.value || "0"),
+        account,
+        chain: getChain()
+      });
+      await waitForReceipt(approvalHash);
+    }
+  }
+  /**
+   * Execute a swap via the Uniswap Trading API.
+   *
+   * Full flow: check_approval → quote → swap → sign & broadcast.
+   */
+  async swap(params) {
+    const account = getAccount();
+    const client = getPublicClient();
+    const ETH_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+    if (params.tokenIn !== ETH_ADDRESS2) {
+      await this.checkApproval({
+        token: params.tokenIn,
+        amount: params.amountIn
+      });
+    }
+    const { quoteResponse } = await this.fullQuote({
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+      amountIn: params.amountIn,
+      slippageTolerance: params.slippageTolerance ?? 0.5
+    });
+    const quoteRaw = quoteResponse;
+    const { permitData, ...cleanQuote } = quoteRaw;
+    const swapRequest = { ...cleanQuote };
+    if (permitData && typeof permitData === "object") {
+      const typedData = permitData;
+      const primaryType = Object.keys(typedData.types).find((k) => k !== "EIP712Domain") ?? "PermitSingle";
+      const signature = await account.signTypedData({
+        domain: typedData.domain,
+        types: typedData.types,
+        primaryType,
+        message: typedData.values
+      });
+      swapRequest.signature = signature;
+      if (!isUniswapXRouting(quoteResponse.routing)) {
+        swapRequest.permitData = permitData;
+      }
+    }
+    const swapRes = await fetchWithRetry(`${API_BASE}/swap`, {
+      method: "POST",
+      headers: apiHeaders(),
+      body: JSON.stringify(swapRequest)
+    });
+    if (!swapRes.ok) {
+      const err = await swapRes.text();
+      throw new Error(`Uniswap swap failed (${swapRes.status}): ${err}`);
+    }
+    const swapData = await swapRes.json();
+    if (!swapData.swap?.data || swapData.swap.data === "" || swapData.swap.data === "0x") {
+      throw new Error("Empty swap data \u2014 quote may have expired. Try again.");
+    }
+    if (!isAddress(swapData.swap.to) || !isAddress(swapData.swap.from)) {
+      throw new Error("Invalid address in swap response");
+    }
+    const gasLimit = swapData.swap.gasLimit ? BigInt(swapData.swap.gasLimit) * 150n / 100n : void 0;
+    const hash = await sendTxWithRetry({
+      to: swapData.swap.to,
+      data: swapData.swap.data,
+      value: BigInt(swapData.swap.value || "0"),
+      gas: gasLimit,
+      account,
+      chain: getChain()
+    });
+    const receipt = await waitForReceipt(hash);
+    return {
+      hash,
+      success: receipt.status === "success",
+      gasUsed: receipt.gasUsed
+    };
+  }
+};
 
 // src/lib/signals.ts
 var DEFAULT_CONFIG = {
@@ -278,7 +499,7 @@ function checkExit(entryPrice, currentPrice, highWaterPrice, config, signalResul
 }
 
 // src/lib/positions.ts
-import { formatUnits, parseUnits } from "viem";
+import { formatUnits as formatUnits2, parseUnits } from "viem";
 function getOpenPositions() {
   const config = loadConfig();
   return config.positions ?? [];
@@ -328,13 +549,13 @@ async function getCurrentPrice(tokenAddress, tokenDecimals, feeTier) {
     amountIn: oneToken,
     fee: feeTier
   });
-  return Number(formatUnits(amountOut, 6));
+  return Number(formatUnits2(amountOut, 6));
 }
 
 // src/commands/trade.ts
 var uniswap = new UniswapProvider();
 async function loadXmtp() {
-  return import("./xmtp-6US7GH3Z.js");
+  return import("./xmtp-Q4ZSQV2Q.js");
 }
 var ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
 var KNOWN_MEMECOINS = {
@@ -359,7 +580,7 @@ async function resolveToken(symbolOrAddress) {
   }
   let address;
   let symbol;
-  if (isAddress(symbolOrAddress)) {
+  if (isAddress2(symbolOrAddress)) {
     address = symbolOrAddress;
     const client2 = getPublicClient();
     try {
@@ -431,8 +652,21 @@ function formatSignalValue(v) {
   const s = (v >= 0 ? "+" : "") + v.toFixed(2);
   return v > 0 ? chalk.green(s) : v < 0 ? chalk.red(s) : chalk.dim(s);
 }
+var TRADING_API_NETWORKS = /* @__PURE__ */ new Set(["base", "base-sepolia"]);
 function registerTradeCommands(program) {
   const trade = program.command("trade").description("Memecoin trading \u2014 scan, buy, sell, monitor positions (Uniswap Trading API on Base)");
+  trade.hook("preAction", () => {
+    const network = getNetwork();
+    if (!TRADING_API_NETWORKS.has(network)) {
+      console.error(chalk.red(`trade commands are not supported on ${network}.`));
+      console.error(
+        chalk.dim(
+          "They require the Uniswap Trading API, which covers Base only. Sherwood currently deploys on Robinhood testnet (chain 46630)."
+        )
+      );
+      process.exit(1);
+    }
+  });
   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("--fund <name>", "Post results to fund chat").option("--yes", "Skip cost confirmation", false).action(async (opts) => {
     const targets = [];
     if (opts.token) {
@@ -512,22 +746,22 @@ function registerTradeCommands(program) {
       const ethBalance = await client.getBalance({ address: account.address });
       if (ethBalance < inputAmount) {
         console.error(chalk.red(
-          `Insufficient ETH. Have ${formatUnits2(ethBalance, 18)}, need ${opts.amount}`
+          `Insufficient ETH. Have ${formatUnits3(ethBalance, 18)}, need ${opts.amount}`
         ));
         process.exit(1);
       }
       const wrapSpinner = ora("Wrapping ETH \u2192 WETH...").start();
       try {
-        const { writeContractWithRetry, waitForReceipt: waitForReceiptFn } = await import("./client-NAL3HVLK.js");
+        const { writeContractWithRetry: writeContractWithRetry2, waitForReceipt: waitForReceiptFn } = await import("./client-C3C6IXAH.js");
         const wethAddr = TOKENS().WETH;
-        const wrapHash = await writeContractWithRetry({
+        const wrapHash = await writeContractWithRetry2({
           address: wethAddr,
           abi: WETH_ABI,
           functionName: "deposit",
           args: [],
           value: inputAmount,
           account,
-          chain: (await import("./network-MKMX2NG6.js")).getChain()
+          chain: (await import("./network-WU2QC3L4.js")).getChain()
         });
         await waitForReceiptFn(wrapHash);
         wrapSpinner.succeed(`Wrapped ${opts.amount} ETH \u2192 WETH`);
@@ -545,7 +779,7 @@ function registerTradeCommands(program) {
       });
       if (balance < inputAmount) {
         console.error(chalk.red(
-          `Insufficient ${inputSymbol}. Have ${formatUnits2(balance, inputDecimals)}, need ${opts.amount}`
+          `Insufficient ${inputSymbol}. Have ${formatUnits3(balance, inputDecimals)}, need ${opts.amount}`
         ));
         process.exit(1);
       }
@@ -562,7 +796,7 @@ function registerTradeCommands(program) {
       expectedOut = result.amountOut;
       const routing = result.routing;
       quoteSpinner.succeed(
-        `Quote: ${formatUnits2(result.amountOut, decimals)} ${symbol} (${routing} route)`
+        `Quote: ${formatUnits3(result.amountOut, decimals)} ${symbol} (${routing} route)`
       );
     } catch (err) {
       quoteSpinner.fail("Quote failed");
@@ -600,7 +834,7 @@ function registerTradeCommands(program) {
       args: [account.address]
     });
     const tokensReceived = tokenBalance > 0n ? tokenBalance : expectedOut;
-    const entryPrice = Number(opts.amount) / Number(formatUnits2(tokensReceived, decimals));
+    const entryPrice = Number(opts.amount) / Number(formatUnits3(tokensReceived, decimals));
     const exitConfig = {
       stopLossPct: Number(opts.stopLoss) || DEFAULT_EXIT_CONFIG.stopLossPct,
       trailingStopPct: Number(opts.trailingStop) || DEFAULT_EXIT_CONFIG.trailingStopPct,
@@ -630,7 +864,7 @@ function registerTradeCommands(program) {
     console.log(chalk.dim("\u2500".repeat(40)));
     console.log(`  Token:    ${symbol} (${tokenAddr})`);
     console.log(`  Spent:    ${opts.amount} ${inputSymbol}`);
-    console.log(`  Received: ${formatUnits2(tokensReceived, decimals)} ${symbol}`);
+    console.log(`  Received: ${formatUnits3(tokensReceived, decimals)} ${symbol}`);
     console.log(`  Entry:    ${entryPrice.toFixed(8)} ${inputSymbol}/${symbol}`);
     console.log(`  Stop:     -${exitConfig.stopLossPct}%`);
     if (exitConfig.trailingStopPct > 0) {
@@ -641,15 +875,15 @@ function registerTradeCommands(program) {
     }
     console.log(`  Tx:       ${chalk.dim(getExplorerUrl(txHash))}`);
     try {
-      const { createTradeAttestation, getEasScanUrl } = await import("./eas-QAH7XVLK.js");
-      const { getChainContracts } = await import("./config-FAQO37S7.js");
-      const { getChain: getActiveChain } = await import("./network-MKMX2NG6.js");
+      const { createTradeAttestation, getEasScanUrl } = await import("./eas-G4TPLJ6S.js");
+      const { getChainContracts } = await import("./config-7HU4X7EK.js");
+      const { getChain: getActiveChain } = await import("./network-WU2QC3L4.js");
       const vaultRecipient = getChainContracts(getActiveChain().id).vault;
       const { uid } = await createTradeAttestation(
         inputAddr,
         tokenAddr,
         inputAmount,
-        formatUnits2(tokensReceived, decimals),
+        formatUnits3(tokensReceived, decimals),
         txHash,
         "BUY",
         vaultRecipient
@@ -664,7 +898,7 @@ function registerTradeCommands(program) {
       await postToChat(
         opts.fund,
         "TRADE_EXECUTED",
-        `Bought ${formatUnits2(tokensReceived, decimals)} ${symbol} for ${opts.amount} ${inputSymbol} via Uniswap`,
+        `Bought ${formatUnits3(tokensReceived, decimals)} ${symbol} for ${opts.amount} ${inputSymbol} via Uniswap`,
         { token: symbol, address: tokenAddr, amountIn: opts.amount, inputToken: inputSymbol, txHash }
       );
     }
@@ -710,7 +944,7 @@ function registerTradeCommands(program) {
       expectedOut = result.amountOut;
       const routing = result.routing;
       quoteSpinner.succeed(
-        `Quote: ${formatUnits2(result.amountOut, outputDecimals)} ${outputSymbol} (${routing} route)`
+        `Quote: ${formatUnits3(result.amountOut, outputDecimals)} ${outputSymbol} (${routing} route)`
       );
     } catch (err) {
       quoteSpinner.fail("Quote failed");
@@ -739,12 +973,12 @@ function registerTradeCommands(program) {
       console.error(chalk.red(formatContractError(err)));
       process.exit(1);
     }
-    const outputReceived = Number(formatUnits2(expectedOut, outputDecimals));
+    const outputReceived = Number(formatUnits3(expectedOut, outputDecimals));
     const costBasis = pos ? Number(pos.amountIn) : 0;
     const inputMatchesOutput = pos ? (pos.inputTokenSymbol ?? "USDC").toUpperCase() === outputSymbol.toUpperCase() : outputSymbol.toUpperCase() === "USDC";
     const pnl = costBasis > 0 && inputMatchesOutput ? outputReceived - costBasis : 0;
     const pnlPct = costBasis > 0 && inputMatchesOutput ? pnl / costBasis * 100 : 0;
-    const exitPrice = sellAmount > 0n ? outputReceived / Number(formatUnits2(sellAmount, decimals)) : 0;
+    const exitPrice = sellAmount > 0n ? outputReceived / Number(formatUnits3(sellAmount, decimals)) : 0;
     if (pos) {
       closePosition(tokenAddr, {
         exitPrice,
@@ -760,7 +994,7 @@ function registerTradeCommands(program) {
     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(`  Sold:     ${formatUnits3(sellAmount, decimals)} ${symbol}`);
     console.log(`  Received: ~${outputReceived.toFixed(outputDecimals <= 6 ? 2 : 6)} ${outputSymbol}`);
     if (costBasis > 0 && inputMatchesOutput) {
       const posInputSymbol = pos?.inputTokenSymbol ?? "USDC";
@@ -769,15 +1003,15 @@ function registerTradeCommands(program) {
     }
     console.log(`  Tx:       ${chalk.dim(getExplorerUrl(txHash))}`);
     try {
-      const { createTradeAttestation, getEasScanUrl } = await import("./eas-QAH7XVLK.js");
-      const { getChainContracts } = await import("./config-FAQO37S7.js");
-      const { getChain: getActiveChain } = await import("./network-MKMX2NG6.js");
+      const { createTradeAttestation, getEasScanUrl } = await import("./eas-G4TPLJ6S.js");
+      const { getChainContracts } = await import("./config-7HU4X7EK.js");
+      const { getChain: getActiveChain } = await import("./network-WU2QC3L4.js");
       const vaultRecipient = getChainContracts(getActiveChain().id).vault;
       const { uid } = await createTradeAttestation(
         tokenAddr,
         outputAddr,
         sellAmount,
-        formatUnits2(expectedOut, outputDecimals),
+        formatUnits3(expectedOut, outputDecimals),
         txHash,
         "SELL",
         vaultRecipient
@@ -792,7 +1026,7 @@ function registerTradeCommands(program) {
       await postToChat(
         opts.fund,
         "TRADE_EXECUTED",
-        `Sold ${formatUnits2(sellAmount, decimals)} ${symbol} for ~${outputReceived.toFixed(2)} ${outputSymbol}${inputMatchesOutput && costBasis > 0 ? ` (P&L: ${pnl >= 0 ? "+" : ""}${pnl.toFixed(2)})` : ""}`,
+        `Sold ${formatUnits3(sellAmount, decimals)} ${symbol} for ~${outputReceived.toFixed(2)} ${outputSymbol}${inputMatchesOutput && costBasis > 0 ? ` (P&L: ${pnl >= 0 ? "+" : ""}${pnl.toFixed(2)})` : ""}`,
         { token: symbol, address: tokenAddr, outputReceived, outputToken: outputSymbol, pnl, pnlPct, txHash }
       );
     }
@@ -812,7 +1046,7 @@ function registerTradeCommands(program) {
     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 qty = Number(formatUnits3(BigInt(pos.amountOut), pos.tokenDecimals));
         const cost = Number(pos.amountIn);
         const value = qty * current;
         const pnl = value - cost;
@@ -900,7 +1134,7 @@ function registerTradeCommands(program) {
                 slippageTolerance: 1
                 // 1% for auto-sell
               });
-              const usdcReceived = Number(formatUnits2(sellQuote, 6));
+              const usdcReceived = Number(formatUnits3(sellQuote, 6));
               const costBasis = Number(pos.amountIn);
               const pnlUsdc = usdcReceived - costBasis;
               closePosition(pos.tokenAddress, {
@@ -946,4 +1180,4 @@ function sleep(ms) {
 export {
   registerTradeCommands
 };
-//# sourceMappingURL=trade-LGFQEK3I.js.map
+//# sourceMappingURL=trade-WDPMFFYB.js.map