@sherwoodagent/cli 0.73.4 → 0.74.3

package/dist/chunk-4LKU7ASB.js

@@ -0,0 +1,1253 @@
+import {
+  AERODROME,
+  CHAINLINK,
+  MOONWELL,
+  ROBINHOOD_STOCK_ROUTES,
+  SYNTHRA,
+  TOKENS,
+  UNISWAP,
+  VENICE,
+  robinhoodEquityMaxAge
+} from "./chunk-UINMHN6S.js";
+import {
+  getPublicClient
+} from "./chunk-2OHX3O55.js";
+import {
+  getNetwork
+} from "./chunk-LHVSS27T.js";
+import {
+  BASE_STRATEGY_ABI,
+  ERC20_ABI,
+  UNISWAP_QUOTER_V2_ABI
+} from "./chunk-TU655ZTV.js";
+
+// src/lib/swap-router.ts
+import { encodeFunctionData as encodeFunctionData9, decodeFunctionResult } from "viem";
+
+// src/lib/template-encoder.ts
+import {
+  parseUnits,
+  isAddress,
+  encodeAbiParameters as encodeAbiParameters9,
+  concat as concat2,
+  numberToHex as numberToHex2
+} from "viem";
+import chalk from "chalk";
+
+// src/strategies/moonwell-supply-template.ts
+import { encodeAbiParameters, encodeFunctionData } from "viem";
+function buildInitData(underlying, mToken, supplyAmount, minRedeemAmount, isNativeEthMarket) {
+  return encodeAbiParameters(
+    [
+      { type: "address" },
+      { type: "address" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "bool" }
+    ],
+    [underlying, mToken, supplyAmount, minRedeemAmount, isNativeEthMarket]
+  );
+}
+function buildExecuteCalls(clone, underlying, supplyAmount) {
+  return [
+    {
+      target: underlying,
+      data: encodeFunctionData({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, supplyAmount]
+      }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
+      }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
+      }),
+      value: 0n
+    }
+  ];
+}
+
+// src/strategies/venice-inference-template.ts
+import { encodeAbiParameters as encodeAbiParameters2, encodeFunctionData as encodeFunctionData2 } from "viem";
+var INIT_PARAMS_TYPES = [
+  {
+    type: "tuple",
+    components: [
+      { name: "asset", type: "address" },
+      { name: "weth", type: "address" },
+      { name: "vvv", type: "address" },
+      { name: "sVVV", type: "address" },
+      { name: "aeroRouter", type: "address" },
+      { name: "aeroFactory", type: "address" },
+      { name: "agent", type: "address" },
+      { name: "assetAmount", type: "uint256" },
+      { name: "minVVV", type: "uint256" },
+      { name: "deadlineOffset", type: "uint256" },
+      { name: "singleHop", type: "bool" }
+    ]
+  }
+];
+function buildInitData2(params) {
+  return encodeAbiParameters2(INIT_PARAMS_TYPES, [params]);
+}
+function buildExecuteCalls2(clone, asset, assetAmount) {
+  return [
+    {
+      target: asset,
+      data: encodeFunctionData2({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, assetAmount]
+      }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData2({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
+      }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls2(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData2({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
+      }),
+      value: 0n
+    }
+  ];
+}
+
+// src/strategies/aerodrome-lp-template.ts
+import { encodeAbiParameters as encodeAbiParameters3, encodeFunctionData as encodeFunctionData3 } from "viem";
+var INIT_PARAMS_TYPES2 = [
+  {
+    type: "tuple",
+    components: [
+      { name: "tokenA", type: "address" },
+      { name: "tokenB", type: "address" },
+      { name: "stable", type: "bool" },
+      { name: "factory", type: "address" },
+      { name: "router", type: "address" },
+      { name: "gauge", type: "address" },
+      { name: "lpToken", type: "address" },
+      { name: "amountADesired", type: "uint256" },
+      { name: "amountBDesired", type: "uint256" },
+      { name: "amountAMin", type: "uint256" },
+      { name: "amountBMin", type: "uint256" },
+      { name: "minAmountAOut", type: "uint256" },
+      { name: "minAmountBOut", type: "uint256" }
+    ]
+  }
+];
+function buildInitData3(params) {
+  return encodeAbiParameters3(INIT_PARAMS_TYPES2, [params]);
+}
+function buildExecuteCalls3(clone, tokenA, amountA, tokenB, amountB) {
+  return [
+    {
+      target: tokenA,
+      data: encodeFunctionData3({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, amountA]
+      }),
+      value: 0n
+    },
+    {
+      target: tokenB,
+      data: encodeFunctionData3({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, amountB]
+      }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData3({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
+      }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls3(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData3({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
+      }),
+      value: 0n
+    }
+  ];
+}
+
+// src/strategies/wsteth-moonwell-template.ts
+import { encodeAbiParameters as encodeAbiParameters4, encodeFunctionData as encodeFunctionData4, maxUint256 } from "viem";
+var INIT_PARAMS_TYPES3 = [
+  {
+    type: "tuple",
+    components: [
+      { name: "weth", type: "address" },
+      { name: "wsteth", type: "address" },
+      { name: "mwsteth", type: "address" },
+      { name: "aeroRouter", type: "address" },
+      { name: "aeroFactory", type: "address" },
+      { name: "chainlinkWstethEthFeed", type: "address" },
+      { name: "supplyAmount", type: "uint256" },
+      { name: "minWstethOutPerWeth", type: "uint256" },
+      { name: "minWethOutPerWsteth", type: "uint256" },
+      { name: "deadlineOffset", type: "uint256" }
+    ]
+  }
+];
+function buildInitData4(params) {
+  return encodeAbiParameters4(INIT_PARAMS_TYPES3, [params]);
+}
+function buildExecuteCalls4(clone, weth, supplyAmount) {
+  const approveAmount = supplyAmount === 0n ? maxUint256 : supplyAmount;
+  return [
+    {
+      target: weth,
+      data: encodeFunctionData4({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, approveAmount]
+      }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData4({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
+      }),
+      value: 0n
+    },
+    {
+      target: weth,
+      data: encodeFunctionData4({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, 0n]
+      }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls4(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData4({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
+      }),
+      value: 0n
+    }
+  ];
+}
+
+// src/strategies/mamo-yield-template.ts
+import { encodeAbiParameters as encodeAbiParameters5, encodeFunctionData as encodeFunctionData5 } from "viem";
+function buildInitData5(underlying, mamoFactory, minRedeemAmount) {
+  return encodeAbiParameters5(
+    [
+      { type: "address" },
+      { type: "address" },
+      { type: "uint256" }
+    ],
+    [underlying, mamoFactory, minRedeemAmount]
+  );
+}
+function buildExecuteCalls5(clone, underlying, amount) {
+  return [
+    {
+      target: underlying,
+      data: encodeFunctionData5({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, amount]
+      }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData5({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
+      }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls5(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData5({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
+      }),
+      value: 0n
+    }
+  ];
+}
+
+// src/strategies/portfolio-template.ts
+import { concat, encodeAbiParameters as encodeAbiParameters6, encodeFunctionData as encodeFunctionData6, numberToHex, pad } from "viem";
+function withMode(mode, routeData) {
+  const modeByte = `0x${mode.toString(16).padStart(2, "0")}`;
+  return concat([modeByte, routeData]);
+}
+function v3SingleHopExtraData(fee) {
+  return withMode(0, encodeAbiParameters6([{ type: "uint24" }], [fee]));
+}
+function v4SingleHopExtraData(fee, tickSpacing) {
+  return withMode(
+    2,
+    encodeAbiParameters6(
+      [{ type: "uint24" }, { type: "int24" }],
+      [fee, tickSpacing]
+    )
+  );
+}
+function v4PathExtraData(hops) {
+  if (hops.length < 2) throw new Error("v4PathExtraData: mode 3 needs >= 2 hops (use v4SingleHopExtraData for one)");
+  return withMode(
+    3,
+    encodeAbiParameters6(
+      [
+        {
+          type: "tuple[]",
+          components: [
+            { type: "address", name: "currency" },
+            { type: "uint24", name: "fee" },
+            { type: "int24", name: "tickSpacing" }
+          ]
+        }
+      ],
+      [hops.map((h) => ({ currency: h.currency, fee: h.fee, tickSpacing: h.tickSpacing }))]
+    )
+  );
+}
+var EQUITY_MAX_PRICE_AGE_SECONDS = 96 * 60 * 60;
+var MIN_MAX_PRICE_AGE = 3600;
+var MAX_MAX_PRICE_AGE = 2592e3;
+function pushFeedId(feed, maxAgeSeconds) {
+  if (maxAgeSeconds === void 0 || maxAgeSeconds === 0) {
+    return pad(feed, { size: 32 });
+  }
+  if (!Number.isInteger(maxAgeSeconds) || maxAgeSeconds < MIN_MAX_PRICE_AGE || maxAgeSeconds > MAX_MAX_PRICE_AGE) {
+    throw new Error(
+      `pushFeedId: maxAgeSeconds must be an integer in [${MIN_MAX_PRICE_AGE}, ${MAX_MAX_PRICE_AGE}] (or 0 for the contract default), got ${maxAgeSeconds}`
+    );
+  }
+  const packed = BigInt(maxAgeSeconds) << 160n | BigInt(feed);
+  return numberToHex(packed, { size: 32 });
+}
+function buildInitData6(asset, swapAdapter, chainlinkVerifier, allocations, totalAmount, maxSlippageBps) {
+  const tokens = allocations.map((a) => a.token);
+  const weightsBps = allocations.map((a) => BigInt(a.weightBps));
+  const swapExtraData = allocations.map((a) => a.swapExtraData);
+  const priceDecimals = allocations.map((a) => a.priceDecimals);
+  const feedIds = allocations.map((a) => a.feedId);
+  return encodeAbiParameters6(
+    [
+      { type: "address" },
+      { type: "address" },
+      { type: "address" },
+      { type: "address[]" },
+      { type: "uint256[]" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "bytes[]" },
+      { type: "uint8[]" },
+      { type: "bytes32[]" }
+    ],
+    [
+      asset,
+      swapAdapter,
+      chainlinkVerifier,
+      tokens,
+      weightsBps,
+      totalAmount,
+      BigInt(maxSlippageBps),
+      swapExtraData,
+      priceDecimals,
+      feedIds
+    ]
+  );
+}
+function buildExecuteCalls6(clone, asset, totalAmount) {
+  return [
+    {
+      target: asset,
+      data: encodeFunctionData6({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, totalAmount]
+      }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData6({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
+      }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls6(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData6({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
+      }),
+      value: 0n
+    }
+  ];
+}
+
+// src/strategies/hyperliquid-perp-template.ts
+import { encodeAbiParameters as encodeAbiParameters7, encodeFunctionData as encodeFunctionData7, maxUint256 as maxUint2562 } from "viem";
+function buildInitData7(asset, depositAmount, perpAssetIndex, leverage, maxPositionSize, maxTradesPerDay) {
+  return encodeAbiParameters7(
+    [
+      { type: "address" },
+      { type: "uint256" },
+      { type: "uint32" },
+      { type: "uint32" },
+      { type: "uint256" },
+      { type: "uint32" }
+    ],
+    [asset, depositAmount, perpAssetIndex, leverage, maxPositionSize, maxTradesPerDay]
+  );
+}
+function buildExecuteCalls7(clone, asset, amount) {
+  const approveAmount = amount === 0n ? maxUint2562 : amount;
+  return [
+    {
+      target: asset,
+      data: encodeFunctionData7({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, approveAmount]
+      }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData7({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
+      }),
+      value: 0n
+    },
+    {
+      target: asset,
+      data: encodeFunctionData7({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, 0n]
+      }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls7(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData7({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
+      }),
+      value: 0n
+    }
+  ];
+}
+
+// src/strategies/hyperliquid-grid-template.ts
+import { encodeAbiParameters as encodeAbiParameters8, encodeFunctionData as encodeFunctionData8, maxUint256 as maxUint2563 } from "viem";
+function buildInitData8(asset, depositAmount, leverage, maxOrderSize, maxOrdersPerTick, assetIndices) {
+  return encodeAbiParameters8(
+    [
+      { type: "address" },
+      { type: "uint256" },
+      { type: "uint32" },
+      { type: "uint256" },
+      { type: "uint32" },
+      { type: "uint32[]" }
+    ],
+    [asset, depositAmount, leverage, maxOrderSize, maxOrdersPerTick, assetIndices]
+  );
+}
+function buildExecuteCalls8(clone, asset, amount) {
+  const approveAmount = amount === 0n ? maxUint2563 : amount;
+  return [
+    {
+      target: asset,
+      data: encodeFunctionData8({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, approveAmount]
+      }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData8({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
+      }),
+      value: 0n
+    },
+    {
+      target: asset,
+      data: encodeFunctionData8({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, 0n]
+      }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls8(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData8({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
+      }),
+      value: 0n
+    }
+  ];
+}
+
+// src/lib/template-encoder.ts
+var ZERO = "0x0000000000000000000000000000000000000000";
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function encodeV3Path(tokens, fees) {
+  if (tokens.length !== fees.length + 1) throw new Error("tokens.length must be fees.length + 1");
+  const parts = [];
+  for (let i = 0; i < tokens.length; i++) {
+    parts.push(tokens[i].toLowerCase());
+    if (i < fees.length) {
+      parts.push(numberToHex2(fees[i], { size: 3 }));
+    }
+  }
+  return concat2(parts);
+}
+function buildSwapExtraData(network, tokenIn, tokenOut, feeTier, hop, perHopSlippageBps = 100) {
+  if (hop) {
+    const path = encodeV3Path([tokenIn, hop.via, tokenOut], [hop.feeIn, hop.feeOut]);
+    const encoded2 = encodeAbiParameters9(
+      [{ type: "bytes" }, { type: "uint16" }],
+      [path, perHopSlippageBps]
+    );
+    return `0x01${encoded2.slice(2)}`;
+  }
+  const encoded = encodeAbiParameters9([{ type: "uint24" }], [feeTier]);
+  return `0x00${encoded.slice(2)}`;
+}
+function parseSwapRouteSpec(spec, token) {
+  const s = spec.trim();
+  const [kind, ...restParts] = s.split(":");
+  const rest = restParts.join(":");
+  switch (kind) {
+    case "v3": {
+      const fee = Number(rest);
+      if (!Number.isInteger(fee) || fee <= 0) throw new Error(`bad v3 fee in '${spec}'`);
+      return v3SingleHopExtraData(fee);
+    }
+    case "v4": {
+      const [feeStr, tsStr] = rest.split(":");
+      const fee = Number(feeStr);
+      const tickSpacing = Number(tsStr);
+      if (!Number.isInteger(fee) || fee <= 0) throw new Error(`bad v4 fee in '${spec}'`);
+      if (!Number.isInteger(tickSpacing) || tickSpacing <= 0) throw new Error(`bad v4 tickSpacing in '${spec}'`);
+      return v4SingleHopExtraData(fee, tickSpacing);
+    }
+    case "v4path": {
+      const hops = rest.split("+").map((hopStr) => {
+        const [currencyRaw, feeTs] = hopStr.split("@");
+        if (!feeTs) throw new Error(`bad v4path hop '${hopStr}' in '${spec}' (expected currency@fee:tickSpacing)`);
+        const [feeStr, tsStr] = feeTs.split(":");
+        const fee = Number(feeStr);
+        const tickSpacing = Number(tsStr);
+        if (!Number.isInteger(fee) || fee <= 0) throw new Error(`bad v4path fee in '${spec}'`);
+        if (!Number.isInteger(tickSpacing) || tickSpacing <= 0) throw new Error(`bad v4path tickSpacing in '${spec}'`);
+        const c = currencyRaw.trim().toLowerCase();
+        let currency;
+        if (c === "eth" || c === "native") currency = ZERO;
+        else if (c === "self") currency = token;
+        else if (isAddress(currencyRaw.trim())) currency = currencyRaw.trim();
+        else throw new Error(`bad v4path currency '${currencyRaw}' in '${spec}' (use eth/native/self/0x-address)`);
+        return { currency, fee, tickSpacing };
+      });
+      return v4PathExtraData(hops);
+    }
+    default:
+      throw new Error(`unknown swap-route kind '${kind}' in '${spec}' (use v3/v4/v4path)`);
+  }
+}
+async function detectSwapRoute(asset, token, preferredFeeTier) {
+  const network = getNetwork();
+  return {
+    extraData: buildSwapExtraData(network, asset, token, preferredFeeTier),
+    routeDesc: `direct (fee ${preferredFeeTier})`
+  };
+}
+function computeProposalAssetChecks(templateKey, opts) {
+  if (templateKey === "moonwell-supply" || templateKey === "mamo-yield") {
+    if (!opts.amount) return [];
+    const token = opts.token || "USDC";
+    const asset = resolveToken(token);
+    const decimals = assetDecimalsForSymbol(token);
+    return [{ asset, amount: parseUnits(opts.amount, decimals), label: token.toUpperCase() }];
+  }
+  if (templateKey === "venice-inference") {
+    if (!opts.amount) return [];
+    const assetSymbol = opts.asset || "USDC";
+    const asset = resolveToken(assetSymbol);
+    const decimals = assetDecimalsForSymbol(assetSymbol);
+    return [{ asset, amount: parseUnits(opts.amount, decimals), label: assetSymbol.toUpperCase() }];
+  }
+  if (templateKey === "aerodrome-lp") {
+    if (!opts.tokenA || !opts.tokenB || !opts.amountA || !opts.amountB) return [];
+    return [];
+  }
+  if (templateKey === "wsteth-moonwell") {
+    if (!opts.amount) return [];
+    return [{
+      asset: TOKENS().WETH,
+      amount: parseUnits(opts.amount, 18),
+      label: "WETH"
+    }];
+  }
+  if (templateKey === "portfolio") {
+    if (!opts.amount) return [];
+    const assetSymbol = opts.asset || defaultPortfolioAsset();
+    const asset = resolveToken(assetSymbol);
+    const decimals = assetDecimalsForSymbol(assetSymbol);
+    return [{ asset, amount: parseUnits(opts.amount, decimals), label: assetSymbol.toUpperCase() }];
+  }
+  if (templateKey === "hyperliquid-perp" || templateKey === "hyperliquid-grid") {
+    if (!opts.amount) return [];
+    const token = opts.token || "USDC";
+    const asset = resolveToken(token);
+    const decimals = assetDecimalsForSymbol(token);
+    return [{ asset, amount: parseUnits(opts.amount, decimals), label: token.toUpperCase() }];
+  }
+  return [];
+}
+function parseAlignedOverrides(raw, expectedLen) {
+  if (raw === void 0) return { values: [], mismatch: false };
+  const values = raw.split(",").map((s) => s.trim());
+  return { values, mismatch: values.length !== expectedLen };
+}
+async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
+  if (templateKey === "moonwell-supply") {
+    if (!opts.amount) {
+      console.error(chalk.red("--amount is required for moonwell-supply template"));
+      process.exit(1);
+    }
+    const token = opts.token || "USDC";
+    const underlying = resolveToken(token);
+    const mToken = resolveMToken(token);
+    const decimals = assetDecimalsForSymbol(token);
+    const supplyAmount = parseUnits(opts.amount, decimals);
+    const minRedeem = parseUnits(opts.minRedeem || opts.amount, decimals);
+    const isNativeEthMarket = token.toUpperCase() !== "USDC";
+    return {
+      initData: buildInitData(underlying, mToken, supplyAmount, minRedeem, isNativeEthMarket),
+      asset: underlying,
+      assetAmount: supplyAmount
+    };
+  }
+  if (templateKey === "venice-inference") {
+    if (!opts.amount) {
+      console.error(chalk.red("--amount is required for venice-inference template"));
+      process.exit(1);
+    }
+    const assetSymbol = opts.asset || "USDC";
+    const asset = resolveToken(assetSymbol);
+    const vvv = VENICE().VVV;
+    const isDirect = asset.toLowerCase() === vvv.toLowerCase();
+    const decimals = assetDecimalsForSymbol(assetSymbol);
+    const assetAmount = parseUnits(opts.amount, decimals);
+    const agent = opts.agent || resolved?.veniceAgent;
+    if (!agent) {
+      throw new Error(
+        "venice-inference: missing agent \u2014 pass --agent or resolve chain inputs (signer default) before encoding"
+      );
+    }
+    const isSingleHop = !!opts.singleHop;
+    let minVVV = 0n;
+    if (!isDirect) {
+      if (opts.minVvv) {
+        minVVV = parseUnits(opts.minVvv, 18);
+      } else if (resolved?.veniceMinVVV !== void 0) {
+        minVVV = resolved.veniceMinVVV;
+      } else {
+        throw new Error(
+          "venice-inference: missing resolved minVVV quote \u2014 pass --min-vvv or resolve chain inputs before encoding"
+        );
+      }
+    }
+    const params = {
+      asset,
+      weth: isDirect ? ZERO : TOKENS().WETH,
+      vvv,
+      sVVV: VENICE().STAKING,
+      aeroRouter: isDirect ? ZERO : AERODROME().ROUTER,
+      aeroFactory: isDirect ? ZERO : AERODROME().FACTORY,
+      agent,
+      assetAmount,
+      minVVV,
+      deadlineOffset: 300n,
+      singleHop: isSingleHop
+    };
+    return {
+      initData: buildInitData2(params),
+      asset,
+      assetAmount
+    };
+  }
+  if (templateKey === "aerodrome-lp") {
+    for (const flag of ["tokenA", "tokenB", "amountA", "amountB", "lpToken"]) {
+      if (!opts[flag]) {
+        console.error(chalk.red(`--${flag.replace(/([A-Z])/g, "-$1").toLowerCase()} is required for aerodrome-lp template`));
+        process.exit(1);
+      }
+    }
+    const tokenA = opts.tokenA;
+    const tokenB = opts.tokenB;
+    if (!resolved?.aerodromeDecimals) {
+      throw new Error(
+        "aerodrome-lp: missing resolved tokenA/tokenB decimals \u2014 resolve chain inputs before encoding"
+      );
+    }
+    const { decimalsA, decimalsB } = resolved.aerodromeDecimals;
+    const amountA = parseUnits(opts.amountA, decimalsA);
+    const amountB = parseUnits(opts.amountB, decimalsB);
+    const minAOut = parseUnits(opts.minAOut || "0", decimalsA);
+    const minBOut = parseUnits(opts.minBOut || "0", decimalsB);
+    const params = {
+      tokenA,
+      tokenB,
+      stable: !!opts.stable,
+      factory: AERODROME().FACTORY,
+      router: AERODROME().ROUTER,
+      gauge: opts.gauge || ZERO,
+      lpToken: opts.lpToken,
+      amountADesired: amountA,
+      amountBDesired: amountB,
+      amountAMin: amountA,
+      // use desired as min for now
+      amountBMin: amountB,
+      minAmountAOut: minAOut,
+      minAmountBOut: minBOut
+    };
+    return {
+      initData: buildInitData3(params),
+      asset: tokenA,
+      assetAmount: amountA,
+      extraApprovals: [{ token: tokenB, amount: amountB }]
+    };
+  }
+  if (templateKey === "wsteth-moonwell") {
+    const supplyAmount = opts.amount ? parseUnits(opts.amount, 18) : 0n;
+    const slippageBps = BigInt(opts.slippage || "500");
+    const ONE = 10n ** 18n;
+    const minWstethOutPerWeth = ONE * (10000n - slippageBps) / 10000n;
+    const minWethOutPerWsteth = ONE * (10000n - slippageBps) / 10000n;
+    const params = {
+      weth: TOKENS().WETH,
+      wsteth: TOKENS().wstETH,
+      mwsteth: MOONWELL().mWstETH,
+      aeroRouter: AERODROME().ROUTER,
+      aeroFactory: AERODROME().FACTORY,
+      chainlinkWstethEthFeed: CHAINLINK().WSTETH_ETH_FEED,
+      supplyAmount,
+      minWstethOutPerWeth,
+      minWethOutPerWsteth,
+      deadlineOffset: 300n
+    };
+    return {
+      initData: buildInitData4(params),
+      asset: TOKENS().WETH,
+      assetAmount: supplyAmount
+    };
+  }
+  if (templateKey === "mamo-yield") {
+    if (!opts.amount) {
+      console.error(chalk.red("--amount is required for mamo-yield template"));
+      process.exit(1);
+    }
+    if (!opts.mamoFactory) {
+      console.error(chalk.red("--mamo-factory is required for mamo-yield template"));
+      process.exit(1);
+    }
+    const token = opts.token || "USDC";
+    const underlying = resolveToken(token);
+    const decimals = assetDecimalsForSymbol(token);
+    const amount = parseUnits(opts.amount, decimals);
+    const minRedeemAmount = parseUnits(opts.minRedeem || opts.amount, decimals);
+    return {
+      initData: buildInitData5(underlying, opts.mamoFactory, minRedeemAmount),
+      asset: underlying,
+      assetAmount: amount
+    };
+  }
+  if (templateKey === "portfolio") {
+    let robinhoodDefaultRoute2 = function(token, symbol) {
+      if (network !== "robinhood") return null;
+      if (wethAddr !== ZERO && token.toLowerCase() === wethAddr.toLowerCase()) {
+        return { extraData: v3SingleHopExtraData(500), routeDesc: "v3 direct (fee 500)" };
+      }
+      const r = ROBINHOOD_STOCK_ROUTES[symbol.toUpperCase()];
+      if (r) {
+        return {
+          extraData: v4PathExtraData([
+            { currency: ZERO, fee: r.nativeFee, tickSpacing: r.nativeTickSpacing },
+            { currency: token, fee: r.stockFee, tickSpacing: r.stockTickSpacing }
+          ]),
+          routeDesc: `v4 multi-hop (USDG\u2192ETH fee ${r.nativeFee} / ts ${r.nativeTickSpacing} \u2192 ${symbol.toUpperCase()} fee ${r.stockFee} / ts ${r.stockTickSpacing})`
+        };
+      }
+      return null;
+    };
+    var robinhoodDefaultRoute = robinhoodDefaultRoute2;
+    if (!opts.amount) {
+      console.error(chalk.red("--amount is required for portfolio template"));
+      process.exit(1);
+    }
+    if (!opts.tokens || !opts.weights) {
+      console.error(chalk.red("--tokens and --weights are required for portfolio template"));
+      console.error(chalk.dim("  --tokens: comma-separated token addresses or symbols"));
+      console.error(chalk.dim("  --weights: comma-separated bps (must sum to 10000)"));
+      process.exit(1);
+    }
+    const network = getNetwork();
+    const tokens = TOKENS();
+    const assetSymbol = opts.asset || defaultPortfolioAsset();
+    const asset = resolveToken(assetSymbol);
+    const decimals = assetDecimalsForSymbol(assetSymbol);
+    const totalAmount = parseUnits(opts.amount, decimals);
+    const maxSlippageBps = Number(opts.maxSlippage || "500");
+    const feeTier = opts.feeTier || "3000";
+    const tokenSpecs = opts.tokens.split(",").map((t) => t.trim());
+    const tokenAddrs = tokenSpecs.map((trimmed) => {
+      if (isAddress(trimmed)) return trimmed;
+      const allTokens = tokens;
+      const resolvedAddr = allTokens[trimmed.toUpperCase()];
+      if (resolvedAddr && resolvedAddr !== ZERO) return resolvedAddr;
+      console.error(chalk.red(`Unknown token: ${trimmed}`));
+      process.exit(1);
+    });
+    const weightsBps = opts.weights.split(",").map((w) => Number(w.trim()));
+    if (tokenAddrs.length !== weightsBps.length) {
+      console.error(chalk.red("--tokens and --weights must have same length"));
+      process.exit(1);
+    }
+    if (weightsBps.reduce((a, b) => a + b, 0) !== 1e4) {
+      console.error(chalk.red(`Weights must sum to 10000`));
+      process.exit(1);
+    }
+    const swapAdapter = opts.swapAdapter || resolveSwapAdapter();
+    const chainlinkVerifier = CHAINLINK().VERIFIER_PROXY;
+    const pushMode = chainlinkVerifier === ZERO;
+    const chainlink = CHAINLINK();
+    const feedIds = parseAlignedOverrides(opts.feedIds, tokenAddrs.length);
+    const feedIdOverrides = feedIds.values;
+    if (feedIds.mismatch) {
+      console.error(chalk.red("--feed-ids must have the same length as --tokens"));
+      process.exit(1);
+    }
+    const priceDecimals = parseAlignedOverrides(opts.priceDecimals, tokenAddrs.length);
+    const priceDecimalOverrides = priceDecimals.values;
+    if (priceDecimals.mismatch) {
+      console.error(chalk.red("--price-decimals must have the same length as --tokens"));
+      process.exit(1);
+    }
+    const swapRoutes = parseAlignedOverrides(opts.swapRoutes, tokenAddrs.length);
+    const swapRouteOverrides = swapRoutes.values;
+    if (swapRoutes.mismatch) {
+      console.error(chalk.red("--swap-routes must have the same length as --tokens"));
+      process.exit(1);
+    }
+    const maxPriceAges = parseAlignedOverrides(opts.maxPriceAges, tokenAddrs.length);
+    const maxPriceAgeOverrides = maxPriceAges.values;
+    if (maxPriceAges.mismatch) {
+      console.error(chalk.red("--max-price-ages must have the same length as --tokens"));
+      process.exit(1);
+    }
+    const wethAddr = TOKENS().WETH;
+    console.log(chalk.dim("  Detecting swap routes..."));
+    const allocations = [];
+    for (let i = 0; i < tokenAddrs.length; i++) {
+      const token = tokenAddrs[i];
+      let route = null;
+      const override = swapRouteOverrides[i];
+      if (override) {
+        try {
+          route = { extraData: parseSwapRouteSpec(override, token), routeDesc: `explicit '${override}'` };
+        } catch (e) {
+          console.error(chalk.red(`Bad --swap-routes entry for ${tokenSpecs[i]}: ${e.message}`));
+          process.exit(1);
+        }
+      }
+      if (!route) route = robinhoodDefaultRoute2(token, tokenSpecs[i]);
+      if (!route && network === "robinhood") {
+        console.error(
+          chalk.red(
+            `No verified default swap route for ${tokenSpecs[i]} on robinhood mainnet.`
+          )
+        );
+        console.error(
+          chalk.yellow(
+            `  Pass --swap-routes to set it explicitly for this token, e.g.
+    --swap-routes 'v4path:eth@500:10+self@50000:1000'  (USDG\u2192ETH\u2192${tokenSpecs[i].toUpperCase()})`
+          )
+        );
+        process.exit(1);
+      }
+      if (!route) route = await detectSwapRoute(asset, token, Number(feeTier));
+      if (!route) {
+        console.error(chalk.red(`No swap route found for ${token}. No Uniswap V3 pool (direct or via WETH). Pass --swap-routes to set it explicitly.`));
+        process.exit(1);
+      }
+      console.log(chalk.dim(`    ${token.slice(0, 10)}... \u2192 ${route.routeDesc}`));
+      let feedId = feedIdOverrides[i];
+      let priceDecimals2 = priceDecimalOverrides[i] ? Number(priceDecimalOverrides[i]) : pushMode ? 8 : 18;
+      const sym = tokenSpecs[i].toUpperCase();
+      let maxPriceAge = 0;
+      if (maxPriceAgeOverrides[i]) {
+        maxPriceAge = Number(maxPriceAgeOverrides[i]);
+        if (!Number.isInteger(maxPriceAge) || maxPriceAge < 0) {
+          console.error(chalk.red(`Bad --max-price-ages entry for ${tokenSpecs[i]}: '${maxPriceAgeOverrides[i]}' (expected a non-negative integer count of seconds)`));
+          process.exit(1);
+        }
+      } else if (pushMode && network === "robinhood") {
+        const { maxPriceAge: age, unknownAddress } = robinhoodEquityMaxAge(
+          tokenSpecs[i],
+          tokens,
+          EQUITY_MAX_PRICE_AGE_SECONDS
+        );
+        maxPriceAge = age;
+        if (unknownAddress && feedIdOverrides[i]) {
+          console.warn(
+            chalk.yellow(
+              `  Warning: token ${tokenSpecs[i]} is not in the ${network} registry, so its push feed uses the contract's 26h default max-price-age.
+  If this is a tokenized-equity feed, pass --max-price-ages (e.g. ${EQUITY_MAX_PRICE_AGE_SECONDS}) for this slot or it will trip StalePrice over long weekends.`
+            )
+          );
+        }
+      }
+      if (pushMode && !feedId) {
+        const feedKey = sym === "WETH" || sym === "ETH" ? "ETH_USD_FEED" : `${sym}_USD_FEED`;
+        const feed = isAddress(tokenSpecs[i]) ? void 0 : chainlink[feedKey];
+        if (!feed || feed === ZERO) {
+          console.error(chalk.red(`No Chainlink push feed for ${tokenSpecs[i]} on ${network}. Pass --feed-ids <feedAddr,...> to supply AggregatorV3 addresses.`));
+          process.exit(1);
+        }
+        feedId = pushFeedId(feed, maxPriceAge);
+      } else if (pushMode && feedId && isAddress(feedId)) {
+        feedId = pushFeedId(feedId, maxPriceAge);
+      }
+      if (!feedId || feedId === ZERO_BYTES32) {
+        console.error(chalk.red(`Missing Chainlink feedId for allocation ${i} (${tokenSpecs[i]}). The strategy requires a non-zero feedId per token \u2014 pass --feed-ids as a comma-separated list.`));
+        process.exit(1);
+      }
+      allocations.push({
+        token,
+        weightBps: weightsBps[i],
+        swapExtraData: route.extraData,
+        priceDecimals: priceDecimals2,
+        feedId
+      });
+    }
+    return {
+      initData: buildInitData6(asset, swapAdapter, chainlinkVerifier, allocations, totalAmount, maxSlippageBps),
+      asset,
+      assetAmount: totalAmount
+    };
+  }
+  if (templateKey === "hyperliquid-perp") {
+    const token = opts.token || "USDC";
+    const asset = resolveToken(token);
+    const decimals = assetDecimalsForSymbol(token);
+    const depositAmount = opts.amount ? parseUnits(opts.amount, decimals) : 0n;
+    const leverage = Number(opts.leverage || "10");
+    const assetIndex = Number(opts.assetIndex || "0");
+    const maxPosition = parseUnits(opts.maxPosition || "100000", decimals);
+    const maxTradesDay = Number(opts.maxTradesPerDay || "50");
+    return {
+      initData: buildInitData7(asset, depositAmount, assetIndex, leverage, maxPosition, maxTradesDay),
+      asset,
+      assetAmount: depositAmount
+    };
+  }
+  if (templateKey === "hyperliquid-grid") {
+    const token = opts.token || "USDC";
+    const asset = resolveToken(token);
+    const decimals = assetDecimalsForSymbol(token);
+    const depositAmount = opts.amount ? parseUnits(opts.amount, decimals) : 0n;
+    const leverage = Number(opts.leverage || "5");
+    const maxOrderSize = parseUnits(opts.maxOrderSize || "10000", decimals);
+    const maxOrdersPerTick = Number(opts.maxOrdersPerTick || "20");
+    const assetIndices = (opts.assetIndices || "0").split(",").map((s) => Number(s.trim())).filter((n) => !Number.isNaN(n));
+    return {
+      initData: buildInitData8(asset, depositAmount, leverage, maxOrderSize, maxOrdersPerTick, assetIndices),
+      asset,
+      assetAmount: depositAmount
+    };
+  }
+  throw new Error(`No init builder for template: ${templateKey}`);
+}
+function buildCallsForTemplate(templateKey, clone, asset, assetAmount, extraApprovals) {
+  if (templateKey === "moonwell-supply") {
+    return {
+      executeCalls: buildExecuteCalls(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls(clone)
+    };
+  }
+  if (templateKey === "venice-inference") {
+    return {
+      executeCalls: buildExecuteCalls2(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls2(clone)
+    };
+  }
+  if (templateKey === "aerodrome-lp") {
+    const tokenB = extraApprovals?.[0]?.token ?? ZERO;
+    const amountB = extraApprovals?.[0]?.amount ?? 0n;
+    return {
+      executeCalls: buildExecuteCalls3(clone, asset, assetAmount, tokenB, amountB),
+      settleCalls: buildSettleCalls3(clone)
+    };
+  }
+  if (templateKey === "wsteth-moonwell") {
+    return {
+      executeCalls: buildExecuteCalls4(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls4(clone)
+    };
+  }
+  if (templateKey === "mamo-yield") {
+    return {
+      executeCalls: buildExecuteCalls5(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls5(clone)
+    };
+  }
+  if (templateKey === "portfolio") {
+    return {
+      executeCalls: buildExecuteCalls6(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls6(clone)
+    };
+  }
+  if (templateKey === "hyperliquid-perp") {
+    return {
+      executeCalls: buildExecuteCalls7(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls7(clone)
+    };
+  }
+  if (templateKey === "hyperliquid-grid") {
+    return {
+      executeCalls: buildExecuteCalls8(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls8(clone)
+    };
+  }
+  throw new Error(`No call builder for template: ${templateKey}`);
+}
+function resolveSwapAdapter() {
+  const network = getNetwork();
+  if (network === "robinhood-testnet" && SYNTHRA().ROUTER === ZERO) {
+    console.error(chalk.red("Synthra DEX not available"));
+    process.exit(1);
+  }
+  const adapterAddr = UNISWAP().SWAP_ADAPTER;
+  if (adapterAddr !== ZERO) return adapterAddr;
+  console.error(chalk.red("UniswapSwapAdapter not deployed yet. Use --swap-adapter to specify manually."));
+  process.exit(1);
+}
+function resolveToken(symbolOrAddress) {
+  if (isAddress(symbolOrAddress)) return symbolOrAddress;
+  const upper = symbolOrAddress.toUpperCase();
+  const tokenMap = {
+    ...TOKENS(),
+    VVV: VENICE().VVV
+  };
+  const addr = tokenMap[upper];
+  if (!addr || addr === ZERO) {
+    console.error(chalk.red(`Unknown token: ${symbolOrAddress}`));
+    process.exit(1);
+  }
+  return addr;
+}
+function defaultPortfolioAsset() {
+  const network = getNetwork();
+  if (network === "robinhood-testnet") return "WETH";
+  return "USDC";
+}
+function assetDecimalsForSymbol(symbol) {
+  const upper = symbol.toUpperCase();
+  return upper === "USDC" || upper === "USDG" ? 6 : 18;
+}
+function resolveMToken(tokenSymbol) {
+  const upper = tokenSymbol.toUpperCase();
+  const moonwell = MOONWELL();
+  const mTokenMap = {
+    USDC: moonwell.mUSDC,
+    WETH: moonwell.mWETH
+  };
+  const addr = mTokenMap[upper];
+  if (!addr || addr === ZERO) {
+    console.error(chalk.red(`No Moonwell market for: ${tokenSymbol}`));
+    process.exit(1);
+  }
+  return addr;
+}
+
+// src/lib/swap-router.ts
+var DEFAULT_FEE_TIER = 3e3;
+var ZERO2 = "0x0000000000000000000000000000000000000000";
+async function detectRoute(tokenIn, tokenOut, preferredFeeTier = DEFAULT_FEE_TIER) {
+  const detected = await detectSwapRoute(tokenIn, tokenOut, preferredFeeTier);
+  if (!detected) {
+    throw new Error(`No swap route found for ${tokenIn}\u2192${tokenOut} (fee ${preferredFeeTier})`);
+  }
+  return {
+    kind: "v3-direct",
+    tokenIn,
+    tokenOut,
+    feeTier: preferredFeeTier,
+    routeDesc: detected.routeDesc
+  };
+}
+function quoterAddress() {
+  const quoter = UNISWAP().QUOTER_V2;
+  if (quoter === ZERO2) {
+    throw new Error("QuoterV2 not deployed on this network");
+  }
+  return quoter;
+}
+async function quote(params, deps = {}) {
+  const route = await detectRoute(params.tokenIn, params.tokenOut, params.feeTier);
+  if (route.kind === "v3-hop") {
+    const path = encodeSwapPath(
+      [route.tokenIn, route.via, route.tokenOut],
+      [route.feeIn, route.feeOut]
+    );
+    const result2 = await getMultiHopQuote({ path, amountIn: params.amountIn }, deps);
+    return { route, ...result2 };
+  }
+  const result = await getQuote(
+    {
+      tokenIn: route.tokenIn,
+      tokenOut: route.tokenOut,
+      amountIn: params.amountIn,
+      fee: route.feeTier
+    },
+    deps
+  );
+  return { route, ...result };
+}
+async function getQuote(params, deps = {}) {
+  const client = deps.client ?? getPublicClient();
+  const calldata = encodeFunctionData9({
+    abi: UNISWAP_QUOTER_V2_ABI,
+    functionName: "quoteExactInputSingle",
+    args: [
+      {
+        tokenIn: params.tokenIn,
+        tokenOut: params.tokenOut,
+        amountIn: params.amountIn,
+        fee: params.fee,
+        sqrtPriceLimitX96: 0n
+      }
+    ]
+  });
+  const { data } = await client.call({ to: quoterAddress(), data: calldata });
+  if (!data) {
+    throw new Error("Quoter returned no data \u2014 pool may not exist for this pair/fee");
+  }
+  const [amountOut, sqrtPriceX96After, , gasEstimate] = decodeFunctionResult({
+    abi: UNISWAP_QUOTER_V2_ABI,
+    functionName: "quoteExactInputSingle",
+    data
+  });
+  return { amountOut, sqrtPriceX96After, gasEstimate };
+}
+async function getMultiHopQuote(params, deps = {}) {
+  const client = deps.client ?? getPublicClient();
+  const calldata = encodeFunctionData9({
+    abi: UNISWAP_QUOTER_V2_ABI,
+    functionName: "quoteExactInput",
+    args: [params.path, params.amountIn]
+  });
+  const { data } = await client.call({ to: quoterAddress(), data: calldata });
+  if (!data) {
+    throw new Error("Quoter returned no data \u2014 pool may not exist for this path");
+  }
+  const [amountOut, , , gasEstimate] = decodeFunctionResult({
+    abi: UNISWAP_QUOTER_V2_ABI,
+    functionName: "quoteExactInput",
+    data
+  });
+  return { amountOut, sqrtPriceX96After: 0n, gasEstimate };
+}
+function applySlippage(amountOut, slippageBps) {
+  return amountOut * BigInt(1e4 - slippageBps) / 10000n;
+}
+function encodeSwapPath(tokens, fees) {
+  if (tokens.length < 2 || fees.length !== tokens.length - 1) {
+    throw new Error("Invalid path: need at least 2 tokens and (tokens-1) fees");
+  }
+  return encodeV3Path(tokens, fees);
+}
+
+export {
+  computeProposalAssetChecks,
+  buildInitDataForTemplate,
+  buildCallsForTemplate,
+  resolveToken,
+  assetDecimalsForSymbol,
+  quote,
+  getQuote,
+  getMultiHopQuote,
+  applySlippage,
+  encodeSwapPath
+};
+//# sourceMappingURL=chunk-4LKU7ASB.js.map