@sherwoodagent/cli 0.88.1 → 0.89.0

package/dist/{chunk-QFGZQYZA.js → chunk-WDPA2BYK.js}

@@ -1,33 +1,49 @@
+import {
+  LIGHTER_USDG,
+  buildExecuteCalls,
+  buildInitData,
+  buildSettleCalls,
+  parseLighterTemplateFlags,
+  usdgToTicks
+} from "./chunk-G5FOHSQW.js";
+import {
+  buildExecuteCalls as buildExecuteCalls2,
+  buildInitData as buildInitData2,
+  buildLaunchpadInitParams,
+  buildSettleCalls as buildSettleCalls2
+} from "./chunk-QVXKYT2N.js";
 import {
   AERODROME,
   CHAINLINK,
   MOONWELL,
   ROBINHOOD_STOCK_ROUTES,
+  STRATEGY_VENUES,
   SYNTHRA,
   TOKENS,
   UNISWAP,
   VENICE
-} from "./chunk-FWQESFFM.js";
+} from "./chunk-GYGSKMZE.js";
 import {
   getPublicClient
-} from "./chunk-D4BSBW3Q.js";
+} from "./chunk-Z53JZORT.js";
 import {
   getNetwork
-} from "./chunk-G3FUEM5N.js";
+} from "./chunk-LIW6K4OJ.js";
 import {
   BASE_STRATEGY_ABI,
+  CONCENTRATED_LIQUIDITY_STRATEGY_ABI,
   ERC20_ABI,
   UNISWAP_QUOTER_V2_ABI
-} from "./chunk-J2IZWAEW.js";
+} from "./chunk-JCL2DEH3.js";
 
 // src/lib/swap-router.ts
-import { encodeFunctionData as encodeFunctionData9, decodeFunctionResult } from "viem";
+import { encodeFunctionData as encodeFunctionData11, decodeFunctionResult } from "viem";
 
 // src/lib/template-encoder.ts
 import {
-  parseUnits,
-  isAddress,
-  encodeAbiParameters as encodeAbiParameters9,
+  parseUnits as parseUnits2,
+  isAddress as isAddress2,
+  encodeAbiParameters as encodeAbiParameters12,
   concat as concat2,
   numberToHex
 } from "viem";
@@ -35,7 +51,7 @@ import chalk from "chalk";
 
 // src/strategies/moonwell-supply-template.ts
 import { encodeAbiParameters, encodeFunctionData } from "viem";
-function buildInitData(underlying, mToken, supplyAmount, minRedeemAmount, isNativeEthMarket) {
+function buildInitData3(underlying, mToken, supplyAmount, minRedeemAmount, isNativeEthMarket) {
   return encodeAbiParameters(
     [
       { type: "address" },
@@ -47,7 +63,7 @@ function buildInitData(underlying, mToken, supplyAmount, minRedeemAmount, isNati
     [underlying, mToken, supplyAmount, minRedeemAmount, isNativeEthMarket]
   );
 }
-function buildExecuteCalls(clone, underlying, supplyAmount) {
+function buildExecuteCalls3(clone, underlying, supplyAmount) {
   return [
     {
       target: underlying,
@@ -68,7 +84,7 @@ function buildExecuteCalls(clone, underlying, supplyAmount) {
     }
   ];
 }
-function buildSettleCalls(clone) {
+function buildSettleCalls3(clone) {
   return [
     {
       target: clone,
@@ -101,10 +117,10 @@ var INIT_PARAMS_TYPES = [
     ]
   }
 ];
-function buildInitData2(params) {
+function buildInitData4(params) {
   return encodeAbiParameters2(INIT_PARAMS_TYPES, [params]);
 }
-function buildExecuteCalls2(clone, asset, assetAmount) {
+function buildExecuteCalls4(clone, asset, assetAmount) {
   return [
     {
       target: asset,
@@ -125,7 +141,7 @@ function buildExecuteCalls2(clone, asset, assetAmount) {
     }
   ];
 }
-function buildSettleCalls2(clone) {
+function buildSettleCalls4(clone) {
   return [
     {
       target: clone,
@@ -160,10 +176,10 @@ var INIT_PARAMS_TYPES2 = [
     ]
   }
 ];
-function buildInitData3(params) {
+function buildInitData5(params) {
   return encodeAbiParameters3(INIT_PARAMS_TYPES2, [params]);
 }
-function buildExecuteCalls3(clone, tokenA, amountA, tokenB, amountB) {
+function buildExecuteCalls5(clone, tokenA, amountA, tokenB, amountB) {
   return [
     {
       target: tokenA,
@@ -193,7 +209,7 @@ function buildExecuteCalls3(clone, tokenA, amountA, tokenB, amountB) {
     }
   ];
 }
-function buildSettleCalls3(clone) {
+function buildSettleCalls5(clone) {
   return [
     {
       target: clone,
@@ -225,10 +241,10 @@ var INIT_PARAMS_TYPES3 = [
     ]
   }
 ];
-function buildInitData4(params) {
+function buildInitData6(params) {
   return encodeAbiParameters4(INIT_PARAMS_TYPES3, [params]);
 }
-function buildExecuteCalls4(clone, weth, supplyAmount) {
+function buildExecuteCalls6(clone, weth, supplyAmount) {
   const approveAmount = supplyAmount === 0n ? maxUint256 : supplyAmount;
   return [
     {
@@ -259,7 +275,7 @@ function buildExecuteCalls4(clone, weth, supplyAmount) {
     }
   ];
 }
-function buildSettleCalls4(clone) {
+function buildSettleCalls6(clone) {
   return [
     {
       target: clone,
@@ -274,7 +290,7 @@ function buildSettleCalls4(clone) {
 
 // src/strategies/mamo-yield-template.ts
 import { encodeAbiParameters as encodeAbiParameters5, encodeFunctionData as encodeFunctionData5 } from "viem";
-function buildInitData5(underlying, mamoFactory, minRedeemAmount) {
+function buildInitData7(underlying, mamoFactory, minRedeemAmount) {
   return encodeAbiParameters5(
     [
       { type: "address" },
@@ -284,7 +300,7 @@ function buildInitData5(underlying, mamoFactory, minRedeemAmount) {
     [underlying, mamoFactory, minRedeemAmount]
   );
 }
-function buildExecuteCalls5(clone, underlying, amount) {
+function buildExecuteCalls7(clone, underlying, amount) {
   return [
     {
       target: underlying,
@@ -305,7 +321,7 @@ function buildExecuteCalls5(clone, underlying, amount) {
     }
   ];
 }
-function buildSettleCalls5(clone) {
+function buildSettleCalls7(clone) {
   return [
     {
       target: clone,
@@ -355,7 +371,7 @@ function v4PathExtraData(hops) {
     )
   );
 }
-function buildInitData6(asset, swapAdapter, allocations, totalAmount, maxSlippageBps) {
+function buildInitData8(asset, swapAdapter, 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);
@@ -386,7 +402,7 @@ function buildInitData6(asset, swapAdapter, allocations, totalAmount, maxSlippag
     ]
   );
 }
-function buildExecuteCalls6(clone, asset, totalAmount) {
+function buildExecuteCalls8(clone, asset, totalAmount) {
   return [
     {
       target: asset,
@@ -407,7 +423,7 @@ function buildExecuteCalls6(clone, asset, totalAmount) {
     }
   ];
 }
-function buildSettleCalls6(clone) {
+function buildSettleCalls8(clone) {
   return [
     {
       target: clone,
@@ -801,7 +817,7 @@ var HYPERLIQUID_PERP_STRATEGY_ABI = [
 ];
 
 // src/strategies/hyperliquid-perp-template.ts
-function buildInitData7(asset, depositAmount, perpAssetIndex, leverage, maxPositionSize, maxTradesPerDay) {
+function buildInitData9(asset, depositAmount, perpAssetIndex, leverage, maxPositionSize, maxTradesPerDay) {
   return encodeAbiParameters7(
     [
       { type: "address" },
@@ -814,7 +830,7 @@ function buildInitData7(asset, depositAmount, perpAssetIndex, leverage, maxPosit
     [asset, depositAmount, perpAssetIndex, leverage, maxPositionSize, maxTradesPerDay]
   );
 }
-function buildExecuteCalls7(clone, asset, amount) {
+function buildExecuteCalls9(clone, asset, amount) {
   const approveAmount = amount === 0n ? maxUint2562 : amount;
   return [
     {
@@ -845,7 +861,7 @@ function buildExecuteCalls7(clone, asset, amount) {
     }
   ];
 }
-function buildSettleCalls7(clone) {
+function buildSettleCalls9(clone) {
   return [
     {
       target: clone,
@@ -860,7 +876,7 @@ function buildSettleCalls7(clone) {
 
 // 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) {
+function buildInitData10(asset, depositAmount, leverage, maxOrderSize, maxOrdersPerTick, assetIndices) {
   return encodeAbiParameters8(
     [
       { type: "address" },
@@ -873,7 +889,7 @@ function buildInitData8(asset, depositAmount, leverage, maxOrderSize, maxOrdersP
     [asset, depositAmount, leverage, maxOrderSize, maxOrdersPerTick, assetIndices]
   );
 }
-function buildExecuteCalls8(clone, asset, amount) {
+function buildExecuteCalls10(clone, asset, amount) {
   const approveAmount = amount === 0n ? maxUint2563 : amount;
   return [
     {
@@ -904,7 +920,7 @@ function buildExecuteCalls8(clone, asset, amount) {
     }
   ];
 }
-function buildSettleCalls8(clone) {
+function buildSettleCalls10(clone) {
   return [
     {
       target: clone,
@@ -917,6 +933,827 @@ function buildSettleCalls8(clone) {
   ];
 }
 
+// src/strategies/morpho-supply-template.ts
+import { encodeAbiParameters as encodeAbiParameters10, encodeFunctionData as encodeFunctionData9, formatUnits, parseUnits } from "viem";
+
+// src/strategies/morpho-cl-shared.ts
+import { encodeAbiParameters as encodeAbiParameters9, isAddress, keccak256, toFunctionSelector } from "viem";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function viewOutputComponents(abi, fn) {
+  const entry = abi.find(
+    (e) => e.type === "function" && e.name === fn
+  );
+  const components = entry?.outputs?.[0]?.components;
+  if (!components) throw new Error(`generated ABI has no tuple output for ${fn}()`);
+  return components;
+}
+var MARKET_PARAMS_COMPONENTS = viewOutputComponents(
+  CONCENTRATED_LIQUIDITY_STRATEGY_ABI,
+  "marketParams"
+);
+function marketIdOf(mp) {
+  return keccak256(
+    encodeAbiParameters9(
+      [{ type: "address" }, { type: "address" }, { type: "address" }, { type: "address" }, { type: "uint256" }],
+      [mp.loanToken, mp.collateralToken, mp.oracle, mp.irm, mp.lltv]
+    )
+  );
+}
+function MORPHO_CL_VENUES() {
+  const v = STRATEGY_VENUES();
+  return {
+    MORPHO_BLUE: v.MORPHO_BLUE,
+    UNISWAP_V3_FACTORY: v.UNISWAP_V3_FACTORY,
+    UNISWAP_V3_POSITION_MANAGER: v.UNISWAP_V3_POSITION_MANAGER
+  };
+}
+var MORPHO_READ_ABI = [
+  {
+    type: "function",
+    name: "idToMarketParams",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "bytes32" }],
+    outputs: [{ name: "", type: "tuple", components: MARKET_PARAMS_COMPONENTS }]
+  },
+  {
+    type: "function",
+    name: "market",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "bytes32" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "totalSupplyAssets", type: "uint128" },
+          { name: "totalSupplyShares", type: "uint128" },
+          { name: "totalBorrowAssets", type: "uint128" },
+          { name: "totalBorrowShares", type: "uint128" },
+          { name: "lastUpdate", type: "uint128" },
+          { name: "fee", type: "uint128" }
+        ]
+      }
+    ]
+  }
+];
+var TIER_BINDING_ABI = [
+  { type: "function", name: "governor", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "address" }] },
+  { type: "function", name: "tierRegistry", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "address" }] },
+  {
+    type: "function",
+    name: "isCounterpartyAllowed",
+    stateMutability: "view",
+    inputs: [{ name: "counterparty", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var VAULT_ASSET_ABI = [
+  { type: "function", name: "asset", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "address" }] }
+];
+var ERC4626_PREVIEW_ABI = [
+  { type: "function", name: "asset", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "address" }] },
+  {
+    type: "function",
+    name: "previewDeposit",
+    stateMutability: "view",
+    inputs: [{ name: "assets", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "previewRedeem",
+    stateMutability: "view",
+    inputs: [{ name: "shares", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+async function readTierRegistry(client, vault) {
+  try {
+    const governor = await client.readContract({
+      address: vault,
+      abi: TIER_BINDING_ABI,
+      functionName: "governor"
+    });
+    if (!governor || governor === ZERO_ADDRESS) return null;
+    const registry = await client.readContract({
+      address: governor,
+      abi: TIER_BINDING_ABI,
+      functionName: "tierRegistry"
+    });
+    return registry && registry !== ZERO_ADDRESS ? registry : null;
+  } catch {
+    return null;
+  }
+}
+async function readAllowed(client, registry, counterparties) {
+  const out = {};
+  const unique = [...new Set(counterparties.map((c) => c.toLowerCase()))];
+  await Promise.all(
+    unique.map(async (c) => {
+      if (!registry) {
+        out[c] = false;
+        return;
+      }
+      try {
+        out[c] = await client.readContract({
+          address: registry,
+          abi: TIER_BINDING_ABI,
+          functionName: "isCounterpartyAllowed",
+          args: [c]
+        });
+      } catch {
+        out[c] = false;
+      }
+    })
+  );
+  return out;
+}
+function isAllowed(allowed, a) {
+  return allowed[a.toLowerCase()] === true;
+}
+function sameAddress(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function withSelector(signature) {
+  return `${signature} [${toFunctionSelector(signature)}]`;
+}
+function parseAddressFlag(raw, flag) {
+  const s = String(raw ?? "").trim();
+  if (!isAddress(s)) throw new Error(`${flag} must be a 0x-address (got '${s}')`);
+  return s;
+}
+function parseBytes32Flag(raw, flag) {
+  const s = String(raw ?? "").trim();
+  if (!/^0x[0-9a-fA-F]{64}$/.test(s)) throw new Error(`${flag} must be a 0x-prefixed 32-byte hex id (got '${s}')`);
+  return s.toLowerCase();
+}
+function parseIntFlag(raw, flag, fallback, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+  if (raw === void 0 || raw === null || raw === "") return fallback;
+  const s = String(raw).trim();
+  if (!/^-?\d+$/.test(s)) throw new Error(`${flag} must be an integer (got '${s}')`);
+  const n = Number(s);
+  if (n < min || n > max) throw new Error(`${flag} must be within [${min}, ${max}] (got ${n})`);
+  return n;
+}
+function parseUintFlag(raw, flag, fallback) {
+  if (raw === void 0 || raw === null || raw === "") return fallback;
+  const s = String(raw).trim();
+  if (!/^\d+$/.test(s)) throw new Error(`${flag} must be a non-negative integer (got '${s}')`);
+  return BigInt(s);
+}
+
+// src/strategies/morpho-supply-template.ts
+function buildInitData11(morpho, marketParams, supplyAmount) {
+  return encodeAbiParameters10(
+    [
+      { type: "address" },
+      { type: "tuple", components: MARKET_PARAMS_COMPONENTS },
+      { type: "uint256" }
+    ],
+    [morpho, marketParams, supplyAmount]
+  );
+}
+function buildExecuteCalls11(clone, asset, supplyAmount) {
+  return [
+    {
+      target: asset,
+      data: encodeFunctionData9({ abi: ERC20_ABI, functionName: "approve", args: [clone, supplyAmount] }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData9({ abi: BASE_STRATEGY_ABI, functionName: "execute" }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls11(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData9({ abi: BASE_STRATEGY_ABI, functionName: "settle" }),
+      value: 0n
+    }
+  ];
+}
+function planMorphoSupply(inputs, state) {
+  const errors = [];
+  const warnings = [];
+  const { morpho, marketId } = inputs;
+  const mp = state.marketParams;
+  if (sameAddress(morpho, ZERO_ADDRESS)) {
+    errors.push(`${withSelector("ZeroAddress()")}: no Morpho Blue address \u2014 pass --morpho on this network`);
+  }
+  if (!state.tierRegistry) {
+    errors.push(
+      `${withSelector("TierRegistryUnresolved()")}: the vault's governor names no TierRegistry, so the strategy cannot bind Morpho`
+    );
+  } else if (!state.morphoAllowed) {
+    errors.push(
+      `${withSelector("MorphoNotAllowed(address,address)")}: Morpho ${morpho} is not counterparty-allowlisted on the vault's TierRegistry ${state.tierRegistry}`
+    );
+  }
+  let supplyAmount = 0n;
+  try {
+    supplyAmount = parseUnits(inputs.amount, state.assetDecimals);
+  } catch {
+    errors.push(`--amount '${inputs.amount}' is not a decimal amount of ${state.assetSymbol}`);
+  }
+  if (supplyAmount === 0n) errors.push(`${withSelector("InvalidAmount()")}: --amount must be > 0`);
+  const unknownMarket = sameAddress(mp.loanToken, ZERO_ADDRESS) && mp.lltv === 0n;
+  if (unknownMarket) {
+    errors.push(
+      `${withSelector("MarketNotCreated()")}: market ${marketId} does not exist on Morpho ${morpho} (idToMarketParams is empty)`
+    );
+  } else {
+    if (!sameAddress(mp.loanToken, state.vaultAsset)) {
+      errors.push(
+        `${withSelector("LoanAssetMismatch()")}: market ${marketId} lends ${mp.loanToken}, but the vault asset is ${state.vaultAsset} (${state.assetSymbol})`
+      );
+    }
+    const derived = marketIdOf(mp);
+    if (derived.toLowerCase() !== marketId.toLowerCase()) {
+      errors.push(`market params returned for ${marketId} hash to ${derived} \u2014 not the market you named`);
+    }
+    if (state.market.lastUpdate === 0n) {
+      errors.push(`${withSelector("MarketNotCreated()")}: market ${marketId} has never been created on ${morpho}`);
+    }
+  }
+  if (supplyAmount > 0n && state.vaultBalance < supplyAmount) {
+    errors.push(
+      `vault holds ${formatUnits(state.vaultBalance, state.assetDecimals)} ${state.assetSymbol} but execute pulls ${formatUnits(supplyAmount, state.assetDecimals)} (--amount is in human units)`
+    );
+  }
+  if (errors.length > 0) return { plan: null, errors, warnings };
+  return {
+    plan: { morpho, marketId, marketParams: mp, asset: state.vaultAsset, supplyAmount },
+    errors,
+    warnings
+  };
+}
+
+// src/strategies/concentrated-liquidity-template.ts
+import { encodeAbiParameters as encodeAbiParameters11, encodeFunctionData as encodeFunctionData10, formatUnits as formatUnits2 } from "viem";
+var BPS = 10000n;
+var FEE_DENOMINATOR = 1000000n;
+var MIN_TICK = -887272;
+var MAX_TICK = 887272;
+var MAX_POOL_SHARE_BPS = 1000n;
+var MIN_LLTV_BUFFER_BPS = 500n;
+var MAX_SLIPPAGE_BPS = 1e3;
+var MAX_TWAP_DEVIATION_BPS = 1e3;
+var MIN_TWAP_WINDOW = 300;
+var MAX_RERANGE_LIMIT = 20;
+var MAX_HALF_WIDTH_TICKS = MAX_TICK;
+var CL_DEFAULTS = {
+  twapWindow: 1800,
+  maxTwapDeviationBps: 100,
+  mintSlippageBps: 500,
+  settleSlippageBps: 500,
+  settleDeadline: 0n,
+  rerangeTriggerBps: 8e3,
+  rerangeMinInterval: 3600n,
+  maxReranges: 3,
+  rerangeSlippageBps: 500
+};
+function rerangeComponents() {
+  const entry = CONCENTRATED_LIQUIDITY_STRATEGY_ABI.find(
+    (e) => e.type === "function" && e.name === "rerangePolicy"
+  );
+  const c = entry?.outputs?.[0]?.components;
+  if (!c) throw new Error("generated ABI has no tuple output for rerangePolicy()");
+  return c;
+}
+var INIT_PARAMS_COMPONENTS = [
+  { name: "pool", type: "address" },
+  { name: "positionManager", type: "address" },
+  { name: "uniswapFactory", type: "address" },
+  { name: "swapAdapter", type: "address" },
+  { name: "morpho", type: "address" },
+  { name: "marketParams", type: "tuple", components: MARKET_PARAMS_COMPONENTS },
+  { name: "collateralAmount", type: "uint256" },
+  { name: "borrowAmount", type: "uint256" },
+  { name: "tickLower", type: "int24" },
+  { name: "tickUpper", type: "int24" },
+  { name: "expectedLiquidity", type: "uint128" },
+  { name: "swapFractionBps", type: "uint256" },
+  { name: "twapWindow", type: "uint32" },
+  { name: "maxTwapDeviationBps", type: "uint256" },
+  { name: "mintSlippageBps", type: "uint256" },
+  { name: "rerange", type: "tuple", components: rerangeComponents() },
+  { name: "settleSlippageBps", type: "uint256" },
+  { name: "settleDeadline", type: "uint256" },
+  { name: "swapExtraData", type: "bytes" }
+];
+function buildInitData12(p) {
+  return encodeAbiParameters11([{ type: "tuple", components: INIT_PARAMS_COMPONENTS }], [p]);
+}
+function buildExecuteCalls12(clone, asset, collateralAmount) {
+  return [
+    {
+      target: asset,
+      data: encodeFunctionData10({ abi: ERC20_ABI, functionName: "approve", args: [clone, collateralAmount] }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData10({ abi: BASE_STRATEGY_ABI, functionName: "execute" }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls12(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData10({ abi: BASE_STRATEGY_ABI, functionName: "settle" }),
+      value: 0n
+    }
+  ];
+}
+var Q96 = 1n << 96n;
+var MAX_UINT256 = (1n << 256n) - 1n;
+function getSqrtRatioAtTick(tick) {
+  if (!Number.isInteger(tick)) throw new Error(`tick must be an integer (got ${tick})`);
+  const absTick = BigInt(Math.abs(tick));
+  if (absTick > BigInt(MAX_TICK)) throw new Error(`tick ${tick} outside [${MIN_TICK}, ${MAX_TICK}]`);
+  let ratio = (absTick & 0x1n) !== 0n ? 0xfffcb933bd6fad37aa2d162d1a594001n : 0x100000000000000000000000000000000n;
+  const steps = [
+    [0x2n, 0xfff97272373d413259a46990580e213an],
+    [0x4n, 0xfff2e50f5f656932ef12357cf3c7fdccn],
+    [0x8n, 0xffe5caca7e10e4e61c3624eaa0941cd0n],
+    [0x10n, 0xffcb9843d60f6159c9db58835c926644n],
+    [0x20n, 0xff973b41fa98c081472e6896dfb254c0n],
+    [0x40n, 0xff2ea16466c96a3843ec78b326b52861n],
+    [0x80n, 0xfe5dee046a99a2a811c461f1969c3053n],
+    [0x100n, 0xfcbe86c7900a88aedcffc83b479aa3a4n],
+    [0x200n, 0xf987a7253ac413176f2b074cf7815e54n],
+    [0x400n, 0xf3392b0822b70005940c7a398e4b70f3n],
+    [0x800n, 0xe7159475a2c29b7443b29c7fa6e889d9n],
+    [0x1000n, 0xd097f3bdfd2022b8845ad8f792aa5825n],
+    [0x2000n, 0xa9f746462d870fdf8a65dc1f90e061e5n],
+    [0x4000n, 0x70d869a156d2a1b890bb3df62baf32f7n],
+    [0x8000n, 0x31be135f97d08fd981231505542fcfa6n],
+    [0x10000n, 0x9aa508b5b7a84e1c677de54f3e99bc9n],
+    [0x20000n, 0x5d6af8dedb81196699c329225ee604n],
+    [0x40000n, 0x2216e584f5fa1ea926041bedfe98n],
+    [0x80000n, 0x48a170391f7dc42444e8fa2n]
+  ];
+  for (const [bit, mul] of steps) {
+    if ((absTick & bit) !== 0n) ratio = ratio * mul >> 128n;
+  }
+  if (tick > 0) ratio = MAX_UINT256 / ratio;
+  return (ratio >> 32n) + (ratio % (1n << 32n) === 0n ? 0n : 1n);
+}
+function snapDown(tick, spacing) {
+  return Math.floor(tick / spacing) * spacing;
+}
+function snapUp(tick, spacing) {
+  return Math.ceil(tick / spacing) * spacing;
+}
+function rangeFromPct(centerTick, pct, spacing) {
+  if (!(pct > 0 && pct < 100)) throw new Error(`--range-pct must be in (0, 100) (got ${pct})`);
+  const p = pct / 100;
+  const lnBase = Math.log(1.0001);
+  const down = Math.floor(Math.log(1 - p) / lnBase);
+  const up = Math.ceil(Math.log(1 + p) / lnBase);
+  const minAligned = snapUp(MIN_TICK, spacing);
+  const maxAligned = snapDown(MAX_TICK, spacing);
+  const tickLower = Math.max(minAligned, snapDown(centerTick + down, spacing));
+  const tickUpper = Math.min(maxAligned, snapUp(centerTick + up, spacing));
+  return { tickLower, tickUpper };
+}
+function liquidityForAmount0(sqrtA, sqrtB, amount0) {
+  if (sqrtA > sqrtB) [sqrtA, sqrtB] = [sqrtB, sqrtA];
+  const intermediate = sqrtA * sqrtB / Q96;
+  return amount0 * intermediate / (sqrtB - sqrtA);
+}
+function liquidityForAmount1(sqrtA, sqrtB, amount1) {
+  if (sqrtA > sqrtB) [sqrtA, sqrtB] = [sqrtB, sqrtA];
+  return amount1 * Q96 / (sqrtB - sqrtA);
+}
+function liquidityForAmounts(sqrtP, sqrtA, sqrtB, amount0, amount1) {
+  if (sqrtA > sqrtB) [sqrtA, sqrtB] = [sqrtB, sqrtA];
+  if (sqrtP <= sqrtA) return liquidityForAmount0(sqrtA, sqrtB, amount0);
+  if (sqrtP < sqrtB) {
+    const l0 = liquidityForAmount0(sqrtP, sqrtB, amount0);
+    const l1 = liquidityForAmount1(sqrtA, sqrtP, amount1);
+    return l0 < l1 ? l0 : l1;
+  }
+  return liquidityForAmount1(sqrtA, sqrtB, amount1);
+}
+function amountsForLiquidity(sqrtP, sqrtA, sqrtB, liquidity) {
+  if (sqrtA > sqrtB) [sqrtA, sqrtB] = [sqrtB, sqrtA];
+  const a0 = (lo, hi) => (liquidity << 96n) * (hi - lo) / hi / lo;
+  const a1 = (lo, hi) => liquidity * (hi - lo) / Q96;
+  if (sqrtP <= sqrtA) return { amount0: a0(sqrtA, sqrtB), amount1: 0n };
+  if (sqrtP < sqrtB) return { amount0: a0(sqrtP, sqrtB), amount1: a1(sqrtA, sqrtP) };
+  return { amount0: 0n, amount1: a1(sqrtA, sqrtB) };
+}
+function token0ToToken1(amount0, sqrtP) {
+  return amount0 * sqrtP / Q96 * sqrtP / Q96;
+}
+function token1ToToken0(amount1, sqrtP) {
+  return amount1 * Q96 / sqrtP * Q96 / sqrtP;
+}
+function idealSwapFractionBps(sqrtP, tickLower, tickUpper, assetIsToken0) {
+  const sqrtA = getSqrtRatioAtTick(tickLower);
+  const sqrtB = getSqrtRatioAtTick(tickUpper);
+  const { amount0, amount1 } = amountsForLiquidity(sqrtP, sqrtA, sqrtB, 10n ** 24n);
+  const value0 = token0ToToken1(amount0, sqrtP);
+  const total = value0 + amount1;
+  if (total === 0n) return 0;
+  const other = assetIsToken0 ? amount1 : value0;
+  return Number((other * BPS + total / 2n) / total);
+}
+function estimateExpectedLiquidity(args) {
+  const { sqrtPriceX96: sqrtP, assetIsToken0, deployable } = args;
+  const swapped = deployable * BigInt(args.swapFractionBps) / BPS;
+  const kept = deployable - swapped;
+  let otherOut = assetIsToken0 ? token0ToToken1(swapped, sqrtP) : token1ToToken0(swapped, sqrtP);
+  otherOut = otherOut * (FEE_DENOMINATOR - BigInt(args.poolFee)) / FEE_DENOMINATOR;
+  const amount0 = assetIsToken0 ? kept : otherOut;
+  const amount1 = assetIsToken0 ? otherOut : kept;
+  return liquidityForAmounts(
+    sqrtP,
+    getSqrtRatioAtTick(args.tickLower),
+    getSqrtRatioAtTick(args.tickUpper),
+    amount0,
+    amount1
+  );
+}
+function derivedRerangeRange(center, halfWidthTicks, spacing) {
+  const minAligned = snapUp(MIN_TICK, spacing);
+  const maxAligned = snapDown(MAX_TICK, spacing);
+  const lo = center - halfWidthTicks;
+  const hi = center + halfWidthTicks;
+  return {
+    tickLower: lo <= minAligned ? minAligned : snapDown(lo, spacing),
+    tickUpper: hi >= maxAligned ? maxAligned : snapUp(hi, spacing)
+  };
+}
+function estimateSwapImpactBps(args) {
+  const { sqrtPriceX96: sqrtP, liquidity: L } = args;
+  const amt = args.amountIn * (FEE_DENOMINATOR - BigInt(args.poolFee)) / FEE_DENOMINATOR;
+  if (amt === 0n) return 0;
+  if (L === 0n || sqrtP === 0n) return 1e4;
+  let num;
+  let den;
+  if (args.tokenInIsToken0) {
+    const next = L * sqrtP * Q96 / (L * Q96 + amt * sqrtP);
+    num = sqrtP - next;
+    den = sqrtP;
+  } else {
+    const next = sqrtP + amt * Q96 / L;
+    num = next - sqrtP;
+    den = next;
+  }
+  const bps = (num * BPS + den - 1n) / den;
+  return Number(bps > BPS ? BPS : bps);
+}
+var IMPACT_WARN_SHARE_BPS = 7000n;
+var POOL_SHARE_WARN_BPS = 8000n;
+function twapTickFromCumulatives(tickCumulatives, window) {
+  const delta = tickCumulatives[1] - tickCumulatives[0];
+  const w = BigInt(window);
+  let avg = delta / w;
+  if (delta < 0n && delta % w !== 0n) avg -= 1n;
+  return Number(avg);
+}
+var UINT128_MAX = (1n << 128n) - 1n;
+function planConcentratedLiquidity(inputs, state) {
+  const errors = [];
+  const warnings = [];
+  const asset = state.vaultAsset;
+  const mp = state.marketParams;
+  const sym = state.assetSymbol;
+  const fmt = (v) => `${formatUnits2(v, state.assetDecimals)} ${sym}`;
+  const named = [
+    ["pool", inputs.pool],
+    ["positionManager", inputs.positionManager],
+    ["morpho", inputs.morpho],
+    ["swapAdapter", inputs.swapAdapter],
+    ["uniswapFactory", inputs.uniswapFactory]
+  ];
+  for (const [name, a] of named) {
+    if (sameAddress(a, ZERO_ADDRESS)) {
+      errors.push(`${withSelector("ZeroAddress()")}: ${name} is unset \u2014 no default on this network, pass it by flag`);
+    }
+  }
+  if (inputs.collateralAmount === 0n || inputs.borrowAmount === 0n) {
+    errors.push(`${withSelector("InvalidAmount()")}: --collateral-amount and --borrow-amount must both be > 0`);
+  }
+  if (!state.tierRegistry) {
+    errors.push(
+      `${withSelector("TierRegistryUnresolved()")}: the vault's governor names no TierRegistry, so no counterparty can be vouched for`
+    );
+  } else {
+    const bound = [
+      ["swap adapter", inputs.swapAdapter],
+      ["position manager", inputs.positionManager],
+      ["Morpho", inputs.morpho],
+      ["Uniswap V3 factory", inputs.uniswapFactory]
+    ];
+    if (!sameAddress(mp.collateralToken, asset) && !sameAddress(mp.collateralToken, ZERO_ADDRESS)) {
+      bound.push(["market collateral token", mp.collateralToken]);
+    }
+    for (const [label, a] of bound) {
+      if (!sameAddress(a, ZERO_ADDRESS) && !isAllowed(state.allowed, a)) {
+        errors.push(
+          `${withSelector("CounterpartyNotAllowed(address,address)")}: ${label} ${a} is not counterparty-allowlisted on TierRegistry ${state.tierRegistry}`
+        );
+      }
+    }
+  }
+  const pool = state.pool;
+  let otherToken = ZERO_ADDRESS;
+  let assetIsToken0 = false;
+  let poolUsable = false;
+  if (!pool.hasCode) {
+    errors.push(`${withSelector("PoolNotFromFactory()")}: pool ${inputs.pool} holds no code`);
+  } else {
+    if (!sameAddress(pool.factoryPool, inputs.pool)) {
+      errors.push(
+        `${withSelector("PoolNotFromFactory()")}: factory ${inputs.uniswapFactory}.getPool(token0, token1, ${pool.fee}) = ${pool.factoryPool}, not ${inputs.pool}`
+      );
+    }
+    if (sameAddress(pool.token0, asset)) {
+      assetIsToken0 = true;
+      otherToken = pool.token1;
+    } else if (sameAddress(pool.token1, asset)) {
+      otherToken = pool.token0;
+    } else {
+      errors.push(
+        `${withSelector("PoolAssetMismatch()")}: pool ${inputs.pool} trades ${pool.token0}/${pool.token1}; neither is the vault asset ${asset} (${sym})`
+      );
+    }
+    if (!sameAddress(otherToken, ZERO_ADDRESS)) {
+      poolUsable = true;
+      if (state.tierRegistry && !isAllowed(state.allowed, otherToken)) {
+        errors.push(
+          `${withSelector("CounterpartyNotAllowed(address,address)")}: the pool's other token ${otherToken} is not counterparty-allowlisted on TierRegistry ${state.tierRegistry}`
+        );
+      }
+    }
+  }
+  const unknownMarket = sameAddress(mp.loanToken, ZERO_ADDRESS) && mp.lltv === 0n;
+  if (unknownMarket) {
+    errors.push(
+      `${withSelector("MarketNotCreated()")}: market ${inputs.marketId} does not exist on Morpho ${inputs.morpho} (idToMarketParams is empty)`
+    );
+  } else {
+    if (!sameAddress(mp.loanToken, asset)) {
+      errors.push(
+        `${withSelector("LoanAssetMismatch()")}: market ${inputs.marketId} lends ${mp.loanToken}, not the vault asset ${asset} (${sym})`
+      );
+    }
+    const derived = marketIdOf(mp);
+    if (derived.toLowerCase() !== inputs.marketId.toLowerCase()) {
+      errors.push(`market params returned for ${inputs.marketId} hash to ${derived} \u2014 not the market you named`);
+    }
+    if (state.market.lastUpdate === 0n) {
+      errors.push(`${withSelector("MarketNotCreated()")}: market ${inputs.marketId} has never been created`);
+    }
+    if (poolUsable && sameAddress(mp.collateralToken, otherToken)) {
+      errors.push(
+        `${withSelector("CollateralAssetMismatch()")}: the market's collateral ${mp.collateralToken} is the pool's volatile leg \u2014 CL borrows the vault asset against the vault asset or an ERC-4626 wrapper of it (e.g. a USDG-loan market with USDG/sUSDG collateral)`
+      );
+    } else if (!sameAddress(mp.collateralToken, asset)) {
+      const wa = state.collateral.wrapperAsset;
+      if (!wa || !sameAddress(wa, asset)) {
+        errors.push(
+          `${withSelector("CollateralAssetMismatch()")}: the market's collateral ${mp.collateralToken} is neither the vault asset nor an ERC-4626 wrapper of it` + (wa ? ` (its asset() is ${wa})` : " (no ERC-4626 asset())")
+        );
+      }
+    }
+  }
+  const lendable = state.market.totalSupplyAssets > state.market.totalBorrowAssets ? state.market.totalSupplyAssets - state.market.totalBorrowAssets : 0n;
+  if (!unknownMarket && inputs.borrowAmount > lendable) {
+    errors.push(
+      `${withSelector("BorrowExceedsLiquidity()")}: borrow ${fmt(inputs.borrowAmount)} exceeds the market's lendable ${fmt(lendable)}`
+    );
+  }
+  let ltvBps = 0n;
+  const lltvBps = mp.lltv * BPS / 10n ** 18n;
+  if (!unknownMarket && inputs.collateralAmount > 0n) {
+    const value = sameAddress(mp.collateralToken, asset) ? inputs.collateralAmount : state.collateral.value;
+    if (value === null || value === 0n) {
+      if (!sameAddress(mp.collateralToken, asset)) {
+        errors.push(
+          `${withSelector("CollateralValueUnavailable()")}: ${mp.collateralToken}.previewRedeem(previewDeposit(${inputs.collateralAmount})) is unreadable or zero`
+        );
+      }
+    } else {
+      ltvBps = inputs.borrowAmount * BPS / value;
+      if (lltvBps < MIN_LLTV_BUFFER_BPS || ltvBps > lltvBps - MIN_LLTV_BUFFER_BPS) {
+        const maxLtv = lltvBps >= MIN_LLTV_BUFFER_BPS ? lltvBps - MIN_LLTV_BUFFER_BPS : 0n;
+        const maxBorrow = value * maxLtv / BPS;
+        errors.push(
+          `${withSelector("LtvInsideLiquidationBuffer()")}: LTV ${ltvBps} bps vs market LLTV ${lltvBps} bps \u2014 must be \u2264 ${maxLtv} bps (LLTV \u2212 ${MIN_LLTV_BUFFER_BPS} bps buffer); max borrow against ${fmt(inputs.collateralAmount)} collateral \u2248 ${fmt(maxBorrow)}`
+        );
+      }
+    }
+  }
+  const spacing = pool.tickSpacing;
+  let tickLower = 0;
+  let tickUpper = 0;
+  let rangeOk = false;
+  if (poolUsable) {
+    if ("pct" in inputs.range) {
+      try {
+        ({ tickLower, tickUpper } = rangeFromPct(pool.tick, inputs.range.pct, spacing));
+      } catch (e) {
+        errors.push(e.message);
+      }
+    } else {
+      ({ tickLower, tickUpper } = inputs.range);
+    }
+    if (tickLower >= tickUpper || spacing <= 0 || tickLower % spacing !== 0 || tickUpper % spacing !== 0) {
+      errors.push(
+        `${withSelector("InvalidTickRange()")}: [${tickLower}, ${tickUpper}] must be ordered, non-empty and multiples of tickSpacing ${spacing}`
+      );
+    } else if (tickLower < MIN_TICK || tickUpper > MAX_TICK) {
+      errors.push(`tick range [${tickLower}, ${tickUpper}] leaves the V3 domain [${MIN_TICK}, ${MAX_TICK}] \u2014 the mint would revert`);
+    } else {
+      rangeOk = true;
+    }
+  }
+  const swapFractionBps = inputs.swapFractionBps ?? (rangeOk ? idealSwapFractionBps(pool.sqrtPriceX96, tickLower, tickUpper, assetIsToken0) : 0);
+  const poolShareCap = pool.liquidity * MAX_POOL_SHARE_BPS / BPS;
+  let expectedLiquidity = inputs.expectedLiquidity ?? 0n;
+  if (inputs.expectedLiquidity === void 0 && rangeOk && pool.sqrtPriceX96 > 0n) {
+    expectedLiquidity = estimateExpectedLiquidity({
+      sqrtPriceX96: pool.sqrtPriceX96,
+      tickLower,
+      tickUpper,
+      assetIsToken0,
+      deployable: inputs.borrowAmount,
+      swapFractionBps,
+      poolFee: pool.fee
+    });
+  }
+  if (poolUsable && rangeOk) {
+    if (expectedLiquidity === 0n) {
+      errors.push(`${withSelector("InvalidAmount()")}: expectedLiquidity is 0 \u2014 the borrow is too small to mint in this range`);
+    } else if (expectedLiquidity > UINT128_MAX) {
+      errors.push(`expectedLiquidity ${expectedLiquidity} does not fit uint128`);
+    } else if (expectedLiquidity > poolShareCap) {
+      const maxBorrow = inputs.borrowAmount * poolShareCap / expectedLiquidity;
+      errors.push(
+        `${withSelector("PositionExceedsPoolShareCap()")}: expected liquidity ${expectedLiquidity} exceeds ${MAX_POOL_SHARE_BPS} bps of the pool's in-range liquidity (${pool.liquidity} \u2192 cap ${poolShareCap}); at this range the borrow must stay under \u2248 ${fmt(maxBorrow)}`
+      );
+    }
+  }
+  const bounds = [
+    [inputs.twapWindow < MIN_TWAP_WINDOW, `--twap-window ${inputs.twapWindow} < MIN_TWAP_WINDOW ${MIN_TWAP_WINDOW}`],
+    [
+      inputs.maxTwapDeviationBps === 0 || inputs.maxTwapDeviationBps > MAX_TWAP_DEVIATION_BPS,
+      `--max-twap-deviation ${inputs.maxTwapDeviationBps} must be in [1, ${MAX_TWAP_DEVIATION_BPS}]`
+    ],
+    [
+      inputs.mintSlippageBps === 0 || inputs.mintSlippageBps > MAX_SLIPPAGE_BPS,
+      `--mint-slippage-bps ${inputs.mintSlippageBps} must be in [1, ${MAX_SLIPPAGE_BPS}]`
+    ],
+    [
+      inputs.settleSlippageBps === 0 || inputs.settleSlippageBps > MAX_SLIPPAGE_BPS,
+      `--settle-slippage-bps ${inputs.settleSlippageBps} must be in [1, ${MAX_SLIPPAGE_BPS}] (0 is not a legal init value)`
+    ],
+    [swapFractionBps < 0 || swapFractionBps > 1e4, `--swap-fraction-bps ${swapFractionBps} must be in [0, 10000]`]
+  ];
+  for (const [bad, msg] of bounds) if (bad) errors.push(`${withSelector("InvalidBound()")}: ${msg}`);
+  const halfWidthTicks = inputs.rerange.halfWidthTicks ?? Math.max(spacing, Math.ceil((tickUpper - tickLower) / 2));
+  let rerangeSwapFraction = swapFractionBps;
+  if (inputs.rerange.swapFractionBps !== void 0) {
+    rerangeSwapFraction = inputs.rerange.swapFractionBps;
+  } else if (poolUsable && rangeOk && pool.sqrtPriceX96 > 0n && halfWidthTicks >= spacing && halfWidthTicks <= MAX_HALF_WIDTH_TICKS) {
+    const centred = derivedRerangeRange(pool.tick, halfWidthTicks, spacing);
+    rerangeSwapFraction = idealSwapFractionBps(pool.sqrtPriceX96, centred.tickLower, centred.tickUpper, assetIsToken0);
+  }
+  if (poolUsable && rangeOk) {
+    const policy = [
+      [halfWidthTicks < spacing, `--rerange-half-width ${halfWidthTicks} < tickSpacing ${spacing}`],
+      [
+        halfWidthTicks * 2 < tickUpper - tickLower,
+        `--rerange-half-width ${halfWidthTicks} \xD7 2 is narrower than the initial range (${tickUpper - tickLower} ticks)`
+      ],
+      [halfWidthTicks > MAX_HALF_WIDTH_TICKS, `--rerange-half-width ${halfWidthTicks} > ${MAX_HALF_WIDTH_TICKS}`]
+    ];
+    for (const [bad, msg] of policy) if (bad) errors.push(`${withSelector("InvalidRerangePolicy()")}: ${msg}`);
+  }
+  const policyBounds = [
+    [
+      inputs.rerange.triggerBps === 0 || inputs.rerange.triggerBps > 1e4,
+      `--rerange-trigger-bps ${inputs.rerange.triggerBps} must be in [1, 10000]`
+    ],
+    [inputs.rerange.maxReranges > MAX_RERANGE_LIMIT, `--max-reranges ${inputs.rerange.maxReranges} > ${MAX_RERANGE_LIMIT}`],
+    [
+      inputs.rerange.slippageBps === 0 || inputs.rerange.slippageBps > MAX_SLIPPAGE_BPS,
+      `--rerange-slippage-bps ${inputs.rerange.slippageBps} must be in [1, ${MAX_SLIPPAGE_BPS}]`
+    ],
+    [
+      rerangeSwapFraction < 0 || rerangeSwapFraction > 1e4,
+      `--rerange-swap-fraction-bps ${rerangeSwapFraction} must be in [0, 10000]`
+    ]
+  ];
+  for (const [bad, msg] of policyBounds) if (bad) errors.push(`${withSelector("InvalidRerangePolicy()")}: ${msg}`);
+  if (inputs.collateralAmount > 0n && state.vaultBalance < inputs.collateralAmount) {
+    errors.push(
+      `vault holds ${fmt(state.vaultBalance)} but execute pulls ${fmt(inputs.collateralAmount)} as collateral (amounts are human units)`
+    );
+  }
+  if (poolUsable) {
+    if (pool.observationCardinality < 2 || pool.twapTick === null) {
+      warnings.push(
+        `pool ${inputs.pool} cannot serve a ${inputs.twapWindow}s TWAP right now (observation cardinality ${pool.observationCardinality}) \u2014 execute() reverts ${withSelector("TwapUnavailable()")} until it can; raise it with pool.increaseObservationCardinalityNext(n) and wait out the window`
+      );
+    } else {
+      const dev = Math.abs(pool.tick - pool.twapTick);
+      if (dev > inputs.maxTwapDeviationBps) {
+        warnings.push(
+          `spot tick ${pool.tick} is ${dev} ticks from the ${inputs.twapWindow}s TWAP ${pool.twapTick} (bound ${inputs.maxTwapDeviationBps}) \u2014 execute() would revert ${withSelector("SpotOutsideTwapBound()")} if it ran now`
+        );
+      }
+    }
+  }
+  if (poolUsable && rangeOk && pool.sqrtPriceX96 > 0n && expectedLiquidity > 0n && expectedLiquidity <= UINT128_MAX) {
+    const sqrtA = getSqrtRatioAtTick(tickLower);
+    const sqrtB = getSqrtRatioAtTick(tickUpper);
+    const otherIsToken0 = !assetIsToken0;
+    const pick = (a) => otherIsToken0 ? a.amount0 : a.amount1;
+    const legNow = pick(amountsForLiquidity(pool.sqrtPriceX96, sqrtA, sqrtB, expectedLiquidity));
+    const edgeSqrt = otherIsToken0 ? sqrtA : sqrtB;
+    const legEdge = pick(amountsForLiquidity(edgeSqrt, sqrtA, sqrtB, expectedLiquidity));
+    const impact = (sqrt, amountIn, tokenInIsToken0) => estimateSwapImpactBps({ sqrtPriceX96: sqrt, liquidity: pool.liquidity, amountIn, tokenInIsToken0, poolFee: pool.fee });
+    const settleNow = impact(pool.sqrtPriceX96, legNow, otherIsToken0);
+    const settleEdge = impact(edgeSqrt, legEdge, otherIsToken0);
+    const settle = BigInt(inputs.settleSlippageBps);
+    const approx = `(constant in-range liquidity ${pool.liquidity}, no tick crossings, pool route only \u2014 an estimate)`;
+    const suggest = (bps) => Math.min(MAX_SLIPPAGE_BPS, Math.ceil(bps * 1e4 / Number(IMPACT_WARN_SHARE_BPS)));
+    if (BigInt(settleNow) * BPS > settle * IMPACT_WARN_SHARE_BPS) {
+      warnings.push(
+        `settle sells the volatile leg (~${legNow} base units of ${otherToken} at today's price) through this pool with an estimated ${settleNow} bps price impact ${approx} \u2014 more than 70% of --settle-slippage-bps ${inputs.settleSlippageBps}, so settle() can revert on its own slippage floor. Settle slippage can only be tightened after init: consider --settle-slippage-bps ${suggest(settleNow)} or a smaller borrow`
+      );
+    } else if (BigInt(settleEdge) * BPS > settle * BPS) {
+      warnings.push(
+        `if price reaches the range edge on the volatile side, settle sells the whole position (~${legEdge} base units of ${otherToken}) with an estimated ${settleEdge} bps impact ${approx} \u2014 above --settle-slippage-bps ${inputs.settleSlippageBps}, which can only be tightened after init; consider --settle-slippage-bps ${suggest(settleEdge)} or a smaller borrow`
+      );
+    }
+    const swapped = inputs.borrowAmount * BigInt(swapFractionBps) / BPS;
+    const mintImpact = impact(pool.sqrtPriceX96, swapped, assetIsToken0);
+    if (BigInt(mintImpact) * BPS > BigInt(inputs.mintSlippageBps) * IMPACT_WARN_SHARE_BPS) {
+      warnings.push(
+        `execute swaps ${fmt(swapped)} into ${otherToken} through this pool with an estimated ${mintImpact} bps price impact ${approx} \u2014 more than 70% of --mint-slippage-bps ${inputs.mintSlippageBps}; execute() can revert on its slippage floor. Consider --mint-slippage-bps ${suggest(mintImpact)} or a smaller borrow`
+      );
+    }
+    if (poolShareCap > 0n && expectedLiquidity <= poolShareCap && expectedLiquidity * BPS > poolShareCap * POOL_SHARE_WARN_BPS) {
+      const pct = Number(expectedLiquidity * 1000n / poolShareCap) / 10;
+      warnings.push(
+        `expected liquidity ${expectedLiquidity} is ${pct}% of the pool-share cap ${poolShareCap} (${MAX_POOL_SHARE_BPS} bps of in-range liquidity ${pool.liquidity}). execute() re-checks the ACTUAL minted liquidity against the pool as it is then; a small drop in pool liquidity (or a mint above the estimate) reverts ${withSelector("PositionExceedsPoolShareCap()")} \u2014 leave more headroom`
+      );
+    }
+  }
+  if (errors.length > 0) return { plan: null, errors, warnings };
+  const params = {
+    pool: inputs.pool,
+    positionManager: inputs.positionManager,
+    uniswapFactory: inputs.uniswapFactory,
+    swapAdapter: inputs.swapAdapter,
+    morpho: inputs.morpho,
+    marketParams: mp,
+    collateralAmount: inputs.collateralAmount,
+    borrowAmount: inputs.borrowAmount,
+    tickLower,
+    tickUpper,
+    expectedLiquidity,
+    swapFractionBps: BigInt(swapFractionBps),
+    twapWindow: inputs.twapWindow,
+    maxTwapDeviationBps: BigInt(inputs.maxTwapDeviationBps),
+    mintSlippageBps: BigInt(inputs.mintSlippageBps),
+    rerange: {
+      halfWidthTicks,
+      triggerBps: BigInt(inputs.rerange.triggerBps),
+      minInterval: inputs.rerange.minInterval,
+      maxReranges: BigInt(inputs.rerange.maxReranges),
+      slippageBps: BigInt(inputs.rerange.slippageBps),
+      swapFractionBps: BigInt(rerangeSwapFraction)
+    },
+    settleSlippageBps: BigInt(inputs.settleSlippageBps),
+    settleDeadline: inputs.settleDeadline,
+    swapExtraData: inputs.swapExtraData ?? v3SingleHopExtraData(pool.fee)
+  };
+  return {
+    plan: {
+      params,
+      asset,
+      otherToken,
+      assetIsToken0,
+      info: { ltvBps, lltvBps, poolShareCap, spotTick: pool.tick, twapTick: pool.twapTick }
+    },
+    errors,
+    warnings
+  };
+}
+
 // src/lib/template-encoder.ts
 var ZERO = "0x0000000000000000000000000000000000000000";
 function encodeV3Path(tokens, fees) {
@@ -933,13 +1770,13 @@ function encodeV3Path(tokens, fees) {
 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(
+    const encoded2 = encodeAbiParameters12(
       [{ type: "bytes" }, { type: "uint16" }],
       [path, perHopSlippageBps]
     );
     return `0x01${encoded2.slice(2)}`;
   }
-  const encoded = encodeAbiParameters9([{ type: "uint24" }], [feeTier]);
+  const encoded = encodeAbiParameters12([{ type: "uint24" }], [feeTier]);
   return `0x00${encoded.slice(2)}`;
 }
 function parseSwapRouteSpec(spec, token) {
@@ -973,7 +1810,7 @@ function parseSwapRouteSpec(spec, token) {
         let currency;
         if (c === "eth" || c === "native") currency = ZERO;
         else if (c === "self") currency = token;
-        else if (isAddress(currencyRaw.trim())) currency = currencyRaw.trim();
+        else if (isAddress2(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 };
       });
@@ -996,14 +1833,14 @@ function computeProposalAssetChecks(templateKey, opts) {
     const token = opts.token || "USDC";
     const asset = resolveToken(token);
     const decimals = assetDecimalsForSymbol(token);
-    return [{ asset, amount: parseUnits(opts.amount, decimals), label: token.toUpperCase() }];
+    return [{ asset, amount: parseUnits2(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() }];
+    return [{ asset, amount: parseUnits2(opts.amount, decimals), label: assetSymbol.toUpperCase() }];
   }
   if (templateKey === "aerodrome-lp") {
     if (!opts.tokenA || !opts.tokenB || !opts.amountA || !opts.amountB) return [];
@@ -1013,7 +1850,7 @@ function computeProposalAssetChecks(templateKey, opts) {
     if (!opts.amount) return [];
     return [{
       asset: TOKENS().WETH,
-      amount: parseUnits(opts.amount, 18),
+      amount: parseUnits2(opts.amount, 18),
       label: "WETH"
     }];
   }
@@ -1022,14 +1859,25 @@ function computeProposalAssetChecks(templateKey, opts) {
     const assetSymbol = opts.asset || defaultPortfolioAsset();
     const asset = resolveToken(assetSymbol);
     const decimals = assetDecimalsForSymbol(assetSymbol);
-    return [{ asset, amount: parseUnits(opts.amount, decimals), label: assetSymbol.toUpperCase() }];
+    return [{ asset, amount: parseUnits2(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 [{ asset, amount: parseUnits2(opts.amount, decimals), label: token.toUpperCase() }];
+  }
+  if (templateKey === "lighter-perp") {
+    const human = opts.deposit ?? opts.amount;
+    if (!human) return [];
+    let amount;
+    try {
+      amount = usdgToTicks(human);
+    } catch {
+      return [];
+    }
+    return [{ asset: LIGHTER_USDG, amount, label: "USDG" }];
   }
   return [];
 }
@@ -1048,11 +1896,11 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
     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 supplyAmount = parseUnits2(opts.amount, decimals);
+    const minRedeem = parseUnits2(opts.minRedeem || opts.amount, decimals);
     const isNativeEthMarket = token.toUpperCase() !== "USDC";
     return {
-      initData: buildInitData(underlying, mToken, supplyAmount, minRedeem, isNativeEthMarket),
+      initData: buildInitData3(underlying, mToken, supplyAmount, minRedeem, isNativeEthMarket),
       asset: underlying,
       assetAmount: supplyAmount
     };
@@ -1067,7 +1915,7 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
     const vvv = VENICE().VVV;
     const isDirect = asset.toLowerCase() === vvv.toLowerCase();
     const decimals = assetDecimalsForSymbol(assetSymbol);
-    const assetAmount = parseUnits(opts.amount, decimals);
+    const assetAmount = parseUnits2(opts.amount, decimals);
     const agent = opts.agent || resolved?.veniceAgent;
     if (!agent) {
       throw new Error(
@@ -1078,7 +1926,7 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
     let minVVV = 0n;
     if (!isDirect) {
       if (opts.minVvv) {
-        minVVV = parseUnits(opts.minVvv, 18);
+        minVVV = parseUnits2(opts.minVvv, 18);
       } else if (resolved?.veniceMinVVV !== void 0) {
         minVVV = resolved.veniceMinVVV;
       } else {
@@ -1101,7 +1949,7 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
       singleHop: isSingleHop
     };
     return {
-      initData: buildInitData2(params),
+      initData: buildInitData4(params),
       asset,
       assetAmount
     };
@@ -1121,10 +1969,10 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
       );
     }
     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 amountA = parseUnits2(opts.amountA, decimalsA);
+    const amountB = parseUnits2(opts.amountB, decimalsB);
+    const minAOut = parseUnits2(opts.minAOut || "0", decimalsA);
+    const minBOut = parseUnits2(opts.minBOut || "0", decimalsB);
     const params = {
       tokenA,
       tokenB,
@@ -1142,14 +1990,14 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
       minAmountBOut: minBOut
     };
     return {
-      initData: buildInitData3(params),
+      initData: buildInitData5(params),
       asset: tokenA,
       assetAmount: amountA,
       extraApprovals: [{ token: tokenB, amount: amountB }]
     };
   }
   if (templateKey === "wsteth-moonwell") {
-    const supplyAmount = opts.amount ? parseUnits(opts.amount, 18) : 0n;
+    const supplyAmount = opts.amount ? parseUnits2(opts.amount, 18) : 0n;
     const slippageBps = BigInt(opts.slippage || "500");
     const ONE = 10n ** 18n;
     const minWstethOutPerWeth = ONE * (10000n - slippageBps) / 10000n;
@@ -1167,7 +2015,7 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
       deadlineOffset: 300n
     };
     return {
-      initData: buildInitData4(params),
+      initData: buildInitData6(params),
       asset: TOKENS().WETH,
       assetAmount: supplyAmount
     };
@@ -1184,10 +2032,10 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
     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);
+    const amount = parseUnits2(opts.amount, decimals);
+    const minRedeemAmount = parseUnits2(opts.minRedeem || opts.amount, decimals);
     return {
-      initData: buildInitData5(underlying, opts.mamoFactory, minRedeemAmount),
+      initData: buildInitData7(underlying, opts.mamoFactory, minRedeemAmount),
       asset: underlying,
       assetAmount: amount
     };
@@ -1226,12 +2074,12 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
     const assetSymbol = opts.asset || defaultPortfolioAsset();
     const asset = resolveToken(assetSymbol);
     const decimals = assetDecimalsForSymbol(assetSymbol);
-    const totalAmount = parseUnits(opts.amount, decimals);
+    const totalAmount = parseUnits2(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;
+      if (isAddress2(trimmed)) return trimmed;
       const allTokens = tokens;
       const resolvedAddr = allTokens[trimmed.toUpperCase()];
       if (resolvedAddr && resolvedAddr !== ZERO) return resolvedAddr;
@@ -1314,14 +2162,14 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
       console.log(chalk.dim(`    ${token.slice(0, 10)}... \u2192 ${route.routeDesc}`));
       const priceDecimals2 = priceDecimalOverrides[i] ? Number(priceDecimalOverrides[i]) : 8;
       let feed = feedOverrides[i];
-      if (feed && !isAddress(feed)) {
+      if (feed && !isAddress2(feed)) {
         console.error(chalk.red(`Bad --feeds entry for ${tokenSpecs[i]}: '${feed}' is not a 0x-prefixed AggregatorV3 address.`));
         process.exit(1);
       }
       if (!feed) {
         const sym = tokenSpecs[i].toUpperCase();
         const feedKey = sym === "WETH" || sym === "ETH" ? "ETH_USD_FEED" : `${sym}_USD_FEED`;
-        feed = isAddress(tokenSpecs[i]) ? void 0 : chainlink[feedKey];
+        feed = isAddress2(tokenSpecs[i]) ? void 0 : chainlink[feedKey];
       }
       if (!feed || feed === ZERO) {
         console.error(chalk.red(`No Chainlink push feed for ${tokenSpecs[i]} on ${network}. Pass --feeds <feedAddr,...> to supply AggregatorV3 addresses (every slot must be non-zero).`));
@@ -1336,7 +2184,7 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
       });
     }
     return {
-      initData: buildInitData6(asset, swapAdapter, allocations, totalAmount, maxSlippageBps),
+      initData: buildInitData8(asset, swapAdapter, allocations, totalAmount, maxSlippageBps),
       asset,
       assetAmount: totalAmount
     };
@@ -1345,13 +2193,13 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
     const token = opts.token || "USDC";
     const asset = resolveToken(token);
     const decimals = assetDecimalsForSymbol(token);
-    const depositAmount = opts.amount ? parseUnits(opts.amount, decimals) : 0n;
+    const depositAmount = opts.amount ? parseUnits2(opts.amount, decimals) : 0n;
     const leverage = Number(opts.leverage || "10");
     const assetIndex = Number(opts.assetIndex || "0");
-    const maxPosition = parseUnits(opts.maxPosition || "100000", decimals);
+    const maxPosition = parseUnits2(opts.maxPosition || "100000", decimals);
     const maxTradesDay = Number(opts.maxTradesPerDay || "50");
     return {
-      initData: buildInitData7(asset, depositAmount, assetIndex, leverage, maxPosition, maxTradesDay),
+      initData: buildInitData9(asset, depositAmount, assetIndex, leverage, maxPosition, maxTradesDay),
       asset,
       assetAmount: depositAmount
     };
@@ -1360,68 +2208,139 @@ async function buildInitDataForTemplate(templateKey, opts, vault, resolved) {
     const token = opts.token || "USDC";
     const asset = resolveToken(token);
     const decimals = assetDecimalsForSymbol(token);
-    const depositAmount = opts.amount ? parseUnits(opts.amount, decimals) : 0n;
+    const depositAmount = opts.amount ? parseUnits2(opts.amount, decimals) : 0n;
     const leverage = Number(opts.leverage || "5");
-    const maxOrderSize = parseUnits(opts.maxOrderSize || "10000", decimals);
+    const maxOrderSize = parseUnits2(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),
+      initData: buildInitData10(asset, depositAmount, leverage, maxOrderSize, maxOrdersPerTick, assetIndices),
       asset,
       assetAmount: depositAmount
     };
   }
+  if (templateKey === "lighter-perp") {
+    const params = parseLighterTemplateFlags(
+      {
+        pubkey: opts.pubkey,
+        keyIndex: opts.keyIndex,
+        markets: opts.markets,
+        deposit: opts.deposit,
+        amount: opts.amount
+      },
+      resolved?.lighterSavedKey
+    );
+    return {
+      initData: buildInitData(params),
+      asset: LIGHTER_USDG,
+      assetAmount: params.depositAmount
+    };
+  }
+  if (templateKey === "launchpad") {
+    if (!resolved?.launchpad) {
+      throw new Error("launchpad: missing resolved chain inputs \u2014 run resolveChainInputsForTemplate before encoding");
+    }
+    const { params } = buildLaunchpadInitParams(opts, resolved.launchpad);
+    return {
+      initData: buildInitData2(params),
+      asset: resolved.launchpad.asset,
+      assetAmount: params.assetIn,
+      maxDrawdownBps: resolved.launchpad.maxDrawdownBps
+    };
+  }
+  if (templateKey === "morpho-supply") {
+    const plan = resolved?.morphoSupply;
+    if (!plan) throw new Error("morpho-supply: missing resolved market plan \u2014 resolve chain inputs before encoding");
+    return {
+      initData: buildInitData11(plan.morpho, plan.marketParams, plan.supplyAmount),
+      asset: plan.asset,
+      assetAmount: plan.supplyAmount
+    };
+  }
+  if (templateKey === "concentrated-liquidity") {
+    const plan = resolved?.concentratedLiquidity;
+    if (!plan) throw new Error("concentrated-liquidity: missing resolved pool/market plan \u2014 resolve chain inputs before encoding");
+    return {
+      initData: buildInitData12(plan.params),
+      asset: plan.asset,
+      assetAmount: plan.params.collateralAmount
+    };
+  }
   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)
+      executeCalls: buildExecuteCalls3(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls3(clone)
     };
   }
   if (templateKey === "venice-inference") {
     return {
-      executeCalls: buildExecuteCalls2(clone, asset, assetAmount),
-      settleCalls: buildSettleCalls2(clone)
+      executeCalls: buildExecuteCalls4(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls4(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)
+      executeCalls: buildExecuteCalls5(clone, asset, assetAmount, tokenB, amountB),
+      settleCalls: buildSettleCalls5(clone)
     };
   }
   if (templateKey === "wsteth-moonwell") {
     return {
-      executeCalls: buildExecuteCalls4(clone, asset, assetAmount),
-      settleCalls: buildSettleCalls4(clone)
+      executeCalls: buildExecuteCalls6(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls6(clone)
     };
   }
   if (templateKey === "mamo-yield") {
     return {
-      executeCalls: buildExecuteCalls5(clone, asset, assetAmount),
-      settleCalls: buildSettleCalls5(clone)
+      executeCalls: buildExecuteCalls7(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls7(clone)
     };
   }
   if (templateKey === "portfolio") {
     return {
-      executeCalls: buildExecuteCalls6(clone, asset, assetAmount),
-      settleCalls: buildSettleCalls6(clone)
+      executeCalls: buildExecuteCalls8(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls8(clone)
     };
   }
   if (templateKey === "hyperliquid-perp") {
     return {
-      executeCalls: buildExecuteCalls7(clone, asset, assetAmount),
-      settleCalls: buildSettleCalls7(clone)
+      executeCalls: buildExecuteCalls9(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls9(clone)
     };
   }
   if (templateKey === "hyperliquid-grid") {
     return {
-      executeCalls: buildExecuteCalls8(clone, asset, assetAmount),
-      settleCalls: buildSettleCalls8(clone)
+      executeCalls: buildExecuteCalls10(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls10(clone)
+    };
+  }
+  if (templateKey === "lighter-perp") {
+    return {
+      executeCalls: buildExecuteCalls(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls(clone)
+    };
+  }
+  if (templateKey === "launchpad") {
+    return {
+      executeCalls: buildExecuteCalls2(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls2(clone)
+    };
+  }
+  if (templateKey === "morpho-supply") {
+    return {
+      executeCalls: buildExecuteCalls11(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls11(clone)
+    };
+  }
+  if (templateKey === "concentrated-liquidity") {
+    return {
+      executeCalls: buildExecuteCalls12(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls12(clone)
     };
   }
   throw new Error(`No call builder for template: ${templateKey}`);
@@ -1438,7 +2357,7 @@ function resolveSwapAdapter() {
   process.exit(1);
 }
 function resolveToken(symbolOrAddress) {
-  if (isAddress(symbolOrAddress)) return symbolOrAddress;
+  if (isAddress2(symbolOrAddress)) return symbolOrAddress;
   const upper = symbolOrAddress.toUpperCase();
   const tokenMap = {
     ...TOKENS(),
@@ -1545,7 +2464,7 @@ async function selectBestFeeTier(params, deps = {}) {
 }
 async function getQuote(params, deps = {}) {
   const client = deps.client ?? getPublicClient();
-  const calldata = encodeFunctionData9({
+  const calldata = encodeFunctionData11({
     abi: UNISWAP_QUOTER_V2_ABI,
     functionName: "quoteExactInputSingle",
     args: [
@@ -1571,7 +2490,7 @@ async function getQuote(params, deps = {}) {
 }
 async function getMultiHopQuote(params, deps = {}) {
   const client = deps.client ?? getPublicClient();
-  const calldata = encodeFunctionData9({
+  const calldata = encodeFunctionData11({
     abi: UNISWAP_QUOTER_V2_ABI,
     functionName: "quoteExactInput",
     args: [params.path, params.amountIn]
@@ -1599,6 +2518,24 @@ function encodeSwapPath(tokens, fees) {
 
 export {
   HYPERLIQUID_PERP_STRATEGY_ABI,
+  v3SingleHopExtraData,
+  ZERO_ADDRESS,
+  MORPHO_CL_VENUES,
+  MORPHO_READ_ABI,
+  VAULT_ASSET_ABI,
+  ERC4626_PREVIEW_ABI,
+  readTierRegistry,
+  readAllowed,
+  sameAddress,
+  parseAddressFlag,
+  parseBytes32Flag,
+  parseIntFlag,
+  parseUintFlag,
+  planMorphoSupply,
+  CL_DEFAULTS,
+  twapTickFromCumulatives,
+  planConcentratedLiquidity,
+  parseSwapRouteSpec,
   computeProposalAssetChecks,
   parseAlignedOverrides,
   buildInitDataForTemplate,
@@ -1614,4 +2551,4 @@ export {
   applySlippage,
   encodeSwapPath
 };
-//# sourceMappingURL=chunk-QFGZQYZA.js.map
+//# sourceMappingURL=chunk-WDPA2BYK.js.map