@continuumdao/ctm-mpc-defi 0.2.26 → 0.2.28

package/dist/protocols/evm/morpho/index.js

@@ -1,15 +1,19 @@
-import { parseAbi, isAddress, getAddress, defineChain, createPublicClient, http, parseUnits, encodeFunctionData, formatUnits, parseGwei, serializeTransaction, keccak256 } from 'viem';
+import { parseAbi, isAddress, getAddress, parseUnits, encodeFunctionData, zeroAddress, maxUint256, defineChain, createPublicClient, http, formatUnits, parseGwei, serializeTransaction, keccak256 } from 'viem';
+import { MidnightApi } from '@morpho-org/midnight-sdk/api';
+import { midnightBundlesAbi, midnightAbi } from '@morpho-org/midnight-sdk';
 import { fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
 
-// src/core/registry.ts
-var modules = [];
-function registerProtocolModule(mod) {
-  const existing = modules.findIndex((m) => m.id === mod.id);
-  if (existing >= 0) {
-    modules[existing] = mod;
-  } else {
-    modules.push(mod);
-  }
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function getMorphoMidnightRestProxyUrl() {
+  return morphoMidnightRestProxyUrl;
 }
 async function postJsonViaOptionalProxy(args) {
   const r = await fetch(args.directUrl, {
@@ -23,8 +27,254 @@ async function postJsonViaOptionalProxy(args) {
   }
   return await r.json();
 }
+async function getJsonViaOptionalProxy(args) {
+  const url = args.directUrl;
+  const r = await fetch(url, { method: "GET", headers: { accept: "application/json" } });
+  if (!r.ok) {
+    const t = await r.text().catch(() => "");
+    throw new Error(t ? `HTTP ${r.status}: ${t.slice(0, 200)}` : `HTTP ${r.status}`);
+  }
+  return await r.json();
+}
+var morphoMidnightRestProxyUrl;
+var init_defiProxy = __esm({
+  "src/core/defiProxy.ts"() {
+  }
+});
+
+// src/protocols/evm/morpho/midnightConstants.ts
+var midnightConstants_exports = {};
+__export(midnightConstants_exports, {
+  MORPHO_MIDNIGHT_ADDRESSES: () => MORPHO_MIDNIGHT_ADDRESSES,
+  MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS: () => MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_BASE_CHAIN_ID: () => MORPHO_MIDNIGHT_BASE_CHAIN_ID,
+  MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT: () => MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT,
+  MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS: () => MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS: () => MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS,
+  MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT: () => MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT,
+  MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK: () => MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK,
+  MORPHO_MIDNIGHT_LEND_FALLBACK_GAS: () => MORPHO_MIDNIGHT_LEND_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS: () => MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_REST_BASE: () => MORPHO_MIDNIGHT_REST_BASE,
+  MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK: () => MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK,
+  TOKEN_PERMIT_NONE: () => TOKEN_PERMIT_NONE,
+  morphoMidnightAddressesForChain: () => morphoMidnightAddressesForChain
+});
+function morphoMidnightAddressesForChain(chainId) {
+  return MORPHO_MIDNIGHT_ADDRESSES[chainId] ?? null;
+}
+var MORPHO_MIDNIGHT_REST_BASE, MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT, MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT, MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS, MORPHO_MIDNIGHT_BASE_CHAIN_ID, MORPHO_MIDNIGHT_ADDRESSES, TOKEN_PERMIT_NONE, MORPHO_MIDNIGHT_LEND_FALLBACK_GAS, MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS, MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS, MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS, MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK, MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK;
+var init_midnightConstants = __esm({
+  "src/protocols/evm/morpho/midnightConstants.ts"() {
+    MORPHO_MIDNIGHT_REST_BASE = "https://api.morpho.org/v0/midnight";
+    MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT = 20;
+    MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT = "0.5";
+    MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS = 3600;
+    MORPHO_MIDNIGHT_BASE_CHAIN_ID = 8453;
+    MORPHO_MIDNIGHT_ADDRESSES = {
+      [MORPHO_MIDNIGHT_BASE_CHAIN_ID]: {
+        midnight: "0xadedd8ab6de832766fedf0fac4992e5c4d3ea18a",
+        bundles: "0x6688dEc8878f43905e11B3C6Bc025E098133144f"
+      }
+    };
+    TOKEN_PERMIT_NONE = { kind: 0, data: "0x" };
+    MORPHO_MIDNIGHT_LEND_FALLBACK_GAS = 2500000n;
+    MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS = 3000000n;
+    MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS = 2200000n;
+    MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS = 80000n;
+    MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK = 100000n;
+    MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK = 120000n;
+  }
+});
+
+// src/protocols/evm/morpho/midnightApi.ts
+var midnightApi_exports = {};
+__export(midnightApi_exports, {
+  fetchMorphoMidnightBook: () => fetchMorphoMidnightBook,
+  fetchMorphoMidnightBookQuote: () => fetchMorphoMidnightBookQuote,
+  fetchMorphoMidnightBooks: () => fetchMorphoMidnightBooks,
+  fetchMorphoMidnightMarketById: () => fetchMorphoMidnightMarketById,
+  fetchMorphoMidnightUserMarketPosition: () => fetchMorphoMidnightUserMarketPosition,
+  fetchMorphoMidnightUserPositions: () => fetchMorphoMidnightUserPositions,
+  morphoMidnightApiBaseUrl: () => morphoMidnightApiBaseUrl,
+  morphoMidnightBookToMarketParams: () => morphoMidnightBookToMarketParams,
+  morphoMidnightMarketToParams: () => morphoMidnightMarketToParams
+});
+function morphoMidnightApiBaseUrl() {
+  const proxy = getMorphoMidnightRestProxyUrl()?.replace(/\/$/, "");
+  return proxy || MORPHO_MIDNIGHT_REST_BASE;
+}
+function midnightApiConfig() {
+  return { baseUrl: morphoMidnightApiBaseUrl() };
+}
+async function midnightGetJson(pathAndQuery) {
+  const path = pathAndQuery.startsWith("/") ? pathAndQuery : `/${pathAndQuery}`;
+  const directUrl = `${MORPHO_MIDNIGHT_REST_BASE}${path}`;
+  return getJsonViaOptionalProxy({ directUrl});
+}
+async function fetchMorphoMidnightBooks(args) {
+  const limit = args.limit == null ? void 0 : Math.min(Math.max(Math.floor(args.limit), 1), MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT);
+  const result = await MidnightApi.fetchBooks({
+    ...midnightApiConfig(),
+    chainIds: [args.chainId],
+    loanTokens: args.loanTokens?.filter((a) => isAddress(a)).map((a) => getAddress(a)),
+    collateralTokens: args.collateralTokens?.filter((a) => isAddress(a)).map((a) => getAddress(a)),
+    sort: args.sort ? [args.sort] : ["maturity"],
+    limit,
+    cursor: args.cursor
+  });
+  return { data: [...result.data], cursor: result.cursor ?? null };
+}
+async function fetchMorphoMidnightBook(marketId) {
+  const id = marketId.trim();
+  if (!id) return null;
+  try {
+    const result = await MidnightApi.fetchBook({
+      ...midnightApiConfig(),
+      marketId: id
+    });
+    return result.data;
+  } catch {
+    return null;
+  }
+}
+async function fetchMorphoMidnightBookQuote(args) {
+  const quote = await MidnightApi.fetchBookQuote({
+    ...midnightApiConfig(),
+    marketId: args.marketId.trim(),
+    side: args.side,
+    assets: args.assets,
+    slippage: args.slippage?.trim() || "0.5"
+  });
+  return quote.data;
+}
+async function fetchMorphoMidnightMarketById(marketId) {
+  const id = marketId.trim();
+  if (!id) return null;
+  const j = await midnightGetJson(`/markets/${encodeURIComponent(id)}`);
+  const d = j.data;
+  if (!d?.market_id || !d.loan_token || !isAddress(d.loan_token)) return null;
+  const midnight = d.midnight && isAddress(d.midnight) ? getAddress(d.midnight) : "0x0000000000000000000000000000000000000000";
+  const collaterals = (d.collaterals ?? []).filter((c) => c.token && isAddress(c.token) && c.oracle && isAddress(c.oracle)).map((c) => ({
+    token: getAddress(c.token),
+    lltv: String(c.lltv ?? "0"),
+    liquidationCursor: String(c.liquidation_cursor ?? "0"),
+    oracle: getAddress(c.oracle)
+  }));
+  return {
+    chainId: Number(d.chain_id ?? 0),
+    marketId: d.market_id,
+    midnight,
+    loanToken: getAddress(d.loan_token),
+    maturity: Number(d.maturity ?? 0),
+    rcfThreshold: String(d.rcf_threshold ?? "0"),
+    enterGate: d.enter_gate && isAddress(d.enter_gate) ? getAddress(d.enter_gate) : getAddress("0x0000000000000000000000000000000000000000"),
+    liquidatorGate: d.liquidator_gate && isAddress(d.liquidator_gate) ? getAddress(d.liquidator_gate) : getAddress("0x0000000000000000000000000000000000000000"),
+    collaterals
+  };
+}
+function morphoMidnightMarketToParams(row) {
+  return {
+    chainId: BigInt(row.chainId),
+    midnight: row.midnight,
+    loanToken: row.loanToken,
+    collateralParams: row.collaterals.map((c) => ({
+      token: c.token,
+      lltv: BigInt(c.lltv),
+      liquidationCursor: BigInt(c.liquidationCursor),
+      oracle: c.oracle
+    })),
+    maturity: BigInt(row.maturity),
+    rcfThreshold: BigInt(row.rcfThreshold),
+    enterGate: row.enterGate,
+    liquidatorGate: row.liquidatorGate
+  };
+}
+function morphoMidnightBookToMarketParams(book) {
+  return {
+    chainId: BigInt(book.chainId),
+    midnight: getAddress(book.midnight),
+    loanToken: getAddress(book.loanToken),
+    collateralParams: book.collaterals.map((c) => ({
+      token: getAddress(c.token),
+      lltv: BigInt(c.lltv),
+      liquidationCursor: BigInt(c.liquidationCursor),
+      oracle: getAddress(c.oracle)
+    })),
+    maturity: BigInt(book.maturity),
+    rcfThreshold: BigInt(book.rcfThreshold),
+    enterGate: getAddress(book.enterGate),
+    liquidatorGate: getAddress(book.liquidatorGate)
+  };
+}
+async function fetchMorphoMidnightUserPositions(args) {
+  const user = args.user.trim();
+  if (!isAddress(user)) return [];
+  const qs = new URLSearchParams();
+  if (args.types) qs.set("types", args.types);
+  if (args.activeOnly) qs.set("active_only", "true");
+  const q = qs.toString();
+  const path = `/users/${encodeURIComponent(getAddress(user))}/positions${q ? `?${q}` : ""}`;
+  const j = await midnightGetJson(path);
+  const rows = [];
+  for (const p of j.data ?? []) {
+    if (!p.market_id) continue;
+    rows.push({
+      marketId: p.market_id,
+      type: p.type ?? "lend",
+      credit: String(p.credit ?? "0"),
+      debt: String(p.debt ?? "0"),
+      pendingFee: String(p.pending_fee ?? "0"),
+      lossFactor: String(p.loss_factor ?? "0"),
+      costBasis: p.cost_basis ?? null,
+      effectiveRateWad: p.effective_rate_wad ?? null,
+      maturity: p.maturity != null ? Number(p.maturity) : null,
+      loanToken: p.loan_token && isAddress(p.loan_token) ? getAddress(p.loan_token) : null,
+      collaterals: (p.collaterals ?? []).filter((c) => c.token && isAddress(c.token)).map((c) => ({ token: getAddress(c.token), amount: String(c.amount ?? "0") }))
+    });
+  }
+  return rows;
+}
+async function fetchMorphoMidnightUserMarketPosition(args) {
+  const marketId = args.marketId.trim();
+  const user = args.user.trim();
+  if (!marketId || !isAddress(user)) return null;
+  const path = `/markets/${encodeURIComponent(marketId)}/users/${encodeURIComponent(getAddress(user))}/position`;
+  const j = await midnightGetJson(path);
+  const p = j.data;
+  if (!p) return null;
+  return {
+    marketId,
+    type: p.type ?? "borrow",
+    credit: String(p.credit ?? "0"),
+    debt: String(p.debt ?? "0"),
+    pendingFee: String(p.pending_fee ?? "0"),
+    lossFactor: String(p.loss_factor ?? "0"),
+    maturity: p.maturity != null ? Number(p.maturity) : null,
+    loanToken: p.loan_token && isAddress(p.loan_token) ? getAddress(p.loan_token) : null,
+    collaterals: (p.collaterals ?? []).filter((c) => c.token && isAddress(c.token)).map((c) => ({ token: getAddress(c.token), amount: String(c.amount ?? "0") }))
+  };
+}
+var init_midnightApi = __esm({
+  "src/protocols/evm/morpho/midnightApi.ts"() {
+    init_defiProxy();
+    init_midnightConstants();
+  }
+});
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
 
 // src/protocols/evm/morpho/api.ts
+init_defiProxy();
 var MORPHO_GRAPHQL_URL = "https://api.morpho.org/graphql";
 async function morphoGql(query, variables) {
   const body = { query, variables: variables ?? {} };
@@ -795,6 +1045,32 @@ async function ensureMorphoChainAssetCache(chainId) {
       modes.set(k, prev);
     }
   }
+  try {
+    const { fetchMorphoMidnightBooks: fetchMorphoMidnightBooks2 } = await Promise.resolve().then(() => (init_midnightApi(), midnightApi_exports));
+    const { MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT: MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT2 } = await Promise.resolve().then(() => (init_midnightConstants(), midnightConstants_exports));
+    const { data: books } = await fetchMorphoMidnightBooks2({
+      chainId,
+      limit: MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT2
+    });
+    for (const book of books) {
+      const loanAddr = (book.loanToken ?? "").toString().trim();
+      if (isAddress(loanAddr)) {
+        const k = getAddress(loanAddr).toLowerCase();
+        const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+        prev.borrow = true;
+        modes.set(k, prev);
+      }
+      for (const c of book.collaterals ?? []) {
+        const colAddr = (c.token ?? "").toString().trim();
+        if (!isAddress(colAddr)) continue;
+        const k = getAddress(colAddr).toLowerCase();
+        const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+        prev.collateral = true;
+        modes.set(k, prev);
+      }
+    }
+  } catch {
+  }
   const cache = { modesByUnderlying: modes, nativeWrapped: null };
   chainAssetCache.set(chainId, cache);
   return cache;
@@ -1177,111 +1453,254 @@ function formatMorphoMarketApySummary(apy) {
 }
 
 // src/protocols/evm/morpho/midnightTypes.ts
-var MORPHO_MIDNIGHT_UNAVAILABLE_MESSAGE = "Morpho Midnight fixed-rate lending is not yet available on mainnet. This tab will activate after the progressive mainnet rollout.";
+var MORPHO_MIDNIGHT_UNAVAILABLE_MESSAGE = "Morpho Midnight fixed-rate markets are available on supported chains (starting with Base). Open the Midnight tab to browse books.";
 async function fetchMorphoMidnightIntents(_args) {
   return [];
 }
-var erc4626Abi = parseAbi([
-  "function asset() view returns (address)",
-  "function decimals() view returns (uint8)",
-  "function balanceOf(address account) view returns (uint256)",
-  "function convertToAssets(uint256 shares) view returns (uint256)",
-  "function maxWithdraw(address owner) view returns (uint256)"
-]);
-async function fetchMorphoVaultAssetDecimals(args) {
-  const ch = defineChain({
-    id: args.chainId,
-    name: "MorphoVault",
-    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
-    rpcUrls: { default: { http: [args.rpcUrl] } }
-  });
-  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
-  const vault = getAddress(args.vault);
-  const assetAddr = await publicClient.readContract({
-    address: vault,
-    abi: erc4626Abi,
-    functionName: "asset"
-  });
-  const d = await publicClient.readContract({
-    address: getAddress(assetAddr),
-    abi: parseAbi(["function decimals() view returns (uint8)"]),
-    functionName: "decimals"
-  });
-  const n = typeof d === "bigint" ? Number(d) : Number(d);
-  return !Number.isFinite(n) || n < 0 || n > 36 ? 18 : n;
+
+// src/protocols/evm/morpho/index.ts
+init_midnightConstants();
+init_midnightApi();
+
+// src/protocols/evm/morpho/midnightMath.ts
+function morphoMidnightAprFromPriceWad(priceWad, ttmSeconds) {
+  const raw = typeof priceWad === "bigint" ? priceWad : BigInt(priceWad.split(".")[0] || "0");
+  if (raw <= 0n || !Number.isFinite(ttmSeconds) || ttmSeconds <= 0) return null;
+  const p = Number(raw) / 1e18;
+  if (!Number.isFinite(p) || p <= 0) return null;
+  const apr = (1 / p - 1) * (365 * 86400 / ttmSeconds);
+  return Number.isFinite(apr) ? apr : null;
+}
+function formatMorphoMidnightAprPct(apr, digits = 2) {
+  if (apr == null || !Number.isFinite(apr)) return "\u2014";
+  return `${(apr * 100).toFixed(digits)}%`;
+}
+function morphoMidnightTtmSeconds(maturityUnix, nowMs = Date.now()) {
+  return Math.max(0, maturityUnix - nowMs / 1e3);
+}
+function morphoMidnightUnitsFromAssets(targetAssets, priceWad) {
+  if (priceWad <= 0n || targetAssets <= 0n) return 0n;
+  return (targetAssets * 10n ** 18n + priceWad - 1n) / priceWad;
 }
-async function fetchMorphoVaultMaxWithdrawWei(args) {
-  const ch = defineChain({
-    id: args.chainId,
-    name: "MorphoVault",
-    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
-    rpcUrls: { default: { http: [args.rpcUrl] } }
-  });
-  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
-  return publicClient.readContract({
-    address: getAddress(args.vault),
-    abi: erc4626Abi,
-    functionName: "maxWithdraw",
-    args: [getAddress(args.owner)]
-  });
+
+// src/protocols/evm/morpho/midnightDiscovery.ts
+init_midnightApi();
+init_midnightConstants();
+function shortAddr(a) {
+  return a.length > 10 ? `${a.slice(0, 6)}\u2026${a.slice(-4)}` : a;
+}
+function maturityIso(maturity) {
+  if (!maturity || maturity <= 0) return "\u2014";
+  try {
+    return new Date(maturity * 1e3).toISOString().slice(0, 10);
+  } catch {
+    return "\u2014";
+  }
 }
-var morphoBlueAbi = parseAbi([
-  "function position(bytes32 id, address user) view returns (uint256 supplyShares, uint128 borrowShares, uint128 collateral)",
-  "function market(bytes32 id) view returns (uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee)",
-  "function idToMarketParams(bytes32 id) view returns (address loanToken, address collateralToken, address oracle, address irm, uint256 lltv)"
-]);
-var oracleAbi = parseAbi(["function price() view returns (uint256)"]);
-var WAD = 10n ** 18n;
-var ORACLE_PRICE_SCALE = 10n ** 36n;
-async function previewMorphoBlueHealthAfterCollateralWithdraw(args) {
-  const ch = defineChain({
-    id: args.chainId,
-    name: "MorphoBlue",
-    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
-    rpcUrls: { default: { http: [args.rpcUrl] } }
+function morphoMidnightBookToDiscoveryRow(book) {
+  const ttm = morphoMidnightTtmSeconds(book.maturity);
+  const bestAsk = book.asks[0];
+  const bestBid = book.bids[0];
+  const lendAprN = bestAsk ? morphoMidnightAprFromPriceWad(bestAsk.price, ttm) : null;
+  const borrowAprN = bestBid ? morphoMidnightAprFromPriceWad(bestBid.price, ttm) : null;
+  const loan = getAddress(book.loanToken);
+  const collaterals = book.collaterals.map((c) => getAddress(c.token));
+  const primary = book.collaterals[0];
+  const primaryAddr = primary ? getAddress(primary.token) : null;
+  const marketLabel = `${shortAddr(primaryAddr ?? "\u2014")}/${shortAddr(loan)} \xB7 ${maturityIso(book.maturity)}`;
+  return {
+    marketId: book.marketId,
+    chainId: book.chainId,
+    midnightAddress: getAddress(book.midnight),
+    loanTokenAddress: loan,
+    maturity: book.maturity,
+    maturityIso: maturityIso(book.maturity),
+    collateralTokenAddresses: collaterals,
+    primaryCollateralTokenAddress: primaryAddr,
+    primaryCollateralLltv: primary?.lltv ?? null,
+    bestAskPriceWad: bestAsk?.price ?? null,
+    bestBidPriceWad: bestBid?.price ?? null,
+    bestAskAssets: bestAsk?.assets ?? null,
+    bestBidAssets: bestBid?.assets ?? null,
+    lendApr: formatMorphoMidnightAprPct(lendAprN),
+    borrowApr: formatMorphoMidnightAprPct(borrowAprN),
+    lendAprNumeric: lendAprN,
+    borrowAprNumeric: borrowAprN,
+    marketLabel
+  };
+}
+async function morphoFetchMidnightBooksSummary(args) {
+  const limit = Math.min(Math.max(args.limit ?? MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT, 1), MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT);
+  const loan = args.loan?.trim();
+  const collateral = args.collateral?.trim();
+  const loanTokens = loan && isAddress(loan) ? [getAddress(loan)] : void 0;
+  const collateralTokens = collateral && isAddress(collateral) ? [getAddress(collateral)] : void 0;
+  const { data } = await fetchMorphoMidnightBooks({
+    chainId: args.chainId,
+    loanTokens,
+    collateralTokens,
+    sort: "maturity",
+    limit
   });
-  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
-  const morpho = getAddress(args.morphoBlue);
-  const user = getAddress(args.user);
-  const id = args.marketId;
-  const [pos, mkt, params] = await Promise.all([
-    publicClient.readContract({
-      address: morpho,
-      abi: morphoBlueAbi,
-      functionName: "position",
-      args: [id, user]
-    }),
-    publicClient.readContract({
-      address: morpho,
-      abi: morphoBlueAbi,
-      functionName: "market",
-      args: [id]
+  let rows = data.map(morphoMidnightBookToDiscoveryRow);
+  if (collateral && isAddress(collateral)) {
+    const col = getAddress(collateral).toLowerCase();
+    rows = rows.filter((r) => r.collateralTokenAddresses.some((a) => a.toLowerCase() === col));
+  }
+  const side = args.side ?? "either";
+  if (side === "bids") {
+    rows = rows.filter((r) => r.bestBidPriceWad != null);
+  } else if (side === "asks") {
+    rows = rows.filter((r) => r.bestAskPriceWad != null);
+  }
+  const q = (args.query ?? "").trim().toLowerCase();
+  if (q) {
+    rows = rows.filter((r) => {
+      const hay = [
+        r.marketId,
+        r.marketLabel,
+        r.loanTokenAddress,
+        r.primaryCollateralTokenAddress ?? "",
+        ...r.collateralTokenAddresses
+      ].join(" ").toLowerCase();
+      return hay.includes(q);
+    });
+  }
+  return { books: rows.slice(0, limit) };
+}
+async function fetchMorphoMidnightBooksForAsset(args) {
+  const asset = args.assetAddress.trim();
+  if (!isAddress(asset)) return [];
+  const mode = args.mode ?? "any";
+  if (mode === "lend") {
+    const { books } = await morphoFetchMidnightBooksSummary({
+      chainId: args.chainId,
+      loan: asset,
+      side: "asks",
+      limit: MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT
+    });
+    return books;
+  }
+  if (mode === "borrow") {
+    const asCollateral = await morphoFetchMidnightBooksSummary({
+      chainId: args.chainId,
+      collateral: asset,
+      side: "bids",
+      limit: MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT
+    });
+    const asLoan2 = await morphoFetchMidnightBooksSummary({
+      chainId: args.chainId,
+      loan: asset,
+      side: "bids",
+      limit: MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT
+    });
+    const byId2 = /* @__PURE__ */ new Map();
+    for (const b of [...asCollateral.books, ...asLoan2.books]) byId2.set(b.marketId.toLowerCase(), b);
+    return [...byId2.values()];
+  }
+  const [asLoan, asCol] = await Promise.all([
+    morphoFetchMidnightBooksSummary({
+      chainId: args.chainId,
+      loan: asset,
+      limit: MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT
     }),
-    publicClient.readContract({
-      address: morpho,
-      abi: morphoBlueAbi,
-      functionName: "idToMarketParams",
-      args: [id]
+    morphoFetchMidnightBooksSummary({
+      chainId: args.chainId,
+      collateral: asset,
+      limit: MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT
     })
   ]);
-  const borrowShares = BigInt(pos[1]);
-  if (borrowShares === 0n) return { healthy: true, healthFactor: null };
-  const collateral = BigInt(pos[2]) - args.withdrawCollateralWei;
-  const oracle = getAddress(params[2]);
-  const lltv = BigInt(params[4]);
-  const price = await publicClient.readContract({
-    address: oracle,
-    abi: oracleAbi,
-    functionName: "price"
+  const byId = /* @__PURE__ */ new Map();
+  for (const b of [...asLoan.books, ...asCol.books]) byId.set(b.marketId.toLowerCase(), b);
+  return [...byId.values()];
+}
+
+// src/protocols/evm/morpho/midnightQuote.ts
+init_midnightApi();
+init_midnightConstants();
+async function morphoFetchMidnightQuote(args) {
+  const assets = typeof args.assets === "bigint" ? args.assets : BigInt(String(args.assets).split(".")[0] || "0");
+  if (assets <= 0n) throw new Error("Quote assets must be > 0.");
+  const slippage = (args.slippagePct ?? MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT).trim() || MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT;
+  const [quote, book] = await Promise.all([
+    fetchMorphoMidnightBookQuote({
+      marketId: args.marketId,
+      side: args.side,
+      assets,
+      slippage
+    }),
+    fetchMorphoMidnightBook(args.marketId)
+  ]);
+  const maturity = book?.maturity ?? null;
+  const ttm = maturity != null ? morphoMidnightTtmSeconds(maturity) : 0;
+  const aprN = morphoMidnightAprFromPriceWad(quote.averageBestPrice, ttm);
+  return {
+    marketId: args.marketId.trim(),
+    side: args.side,
+    averageBestPriceWad: quote.averageBestPrice,
+    averageWorstPriceWad: quote.averageWorstPrice,
+    availableAssets: quote.availableAssets,
+    availableUnits: quote.availableUnits,
+    impliedApr: formatMorphoMidnightAprPct(aprN),
+    impliedAprNumeric: aprN,
+    maturity,
+    takeableOfferCount: quote.takeableOffers.length,
+    takeableOffers: quote.takeableOffers
+  };
+}
+async function morphoFetchMidnightQuoteSummary(args) {
+  const { takeableOffers: _takes, ...rest } = await morphoFetchMidnightQuote(args);
+  return rest;
+}
+
+// src/protocols/evm/morpho/midnightPositions.ts
+init_midnightApi();
+function maturityIso2(maturity) {
+  if (maturity == null || maturity <= 0) return "\u2014";
+  try {
+    return new Date(maturity * 1e3).toISOString().slice(0, 10);
+  } catch {
+    return "\u2014";
+  }
+}
+function effectiveRateLabel(wad) {
+  if (!wad) return "\u2014";
+  try {
+    const n = Number(BigInt(wad.split(".")[0] || "0")) / 1e18;
+    return formatMorphoMidnightAprPct(Number.isFinite(n) ? n : null);
+  } catch {
+    return "\u2014";
+  }
+}
+function morphoMidnightPositionToDiscoveryRow(p) {
+  const debt = BigInt(p.debt || "0");
+  const fee = BigInt(p.pendingFee || "0");
+  return {
+    marketId: p.marketId,
+    type: p.type,
+    credit: p.credit,
+    debt: p.debt,
+    pendingFee: p.pendingFee,
+    repayAssets: (debt + fee).toString(),
+    maturity: p.maturity ?? null,
+    maturityIso: maturityIso2(p.maturity ?? null),
+    loanTokenAddress: p.loanToken ?? null,
+    collateralTokenAddresses: p.collaterals.map((c) => c.token),
+    collateralAmounts: p.collaterals.map((c) => ({ token: c.token, amount: c.amount })),
+    effectiveRate: effectiveRateLabel(p.effectiveRateWad),
+    costBasis: p.costBasis ?? null
+  };
+}
+async function morphoFetchMidnightPositionsSummary(args) {
+  if (!isAddress(args.user)) {
+    throw new Error("user must be a valid EVM address.");
+  }
+  const rows = await fetchMorphoMidnightUserPositions({
+    user: getAddress(args.user),
+    types: args.types,
+    activeOnly: args.activeOnly
   });
-  const totalBorrowAssets = BigInt(mkt[2]);
-  const totalBorrowShares = BigInt(mkt[3]);
-  if (totalBorrowShares === 0n) return { healthy: true, healthFactor: null };
-  const borrowed = (borrowShares * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares;
-  const maxBorrow = collateral * price / ORACLE_PRICE_SCALE * lltv / WAD;
-  const healthy = maxBorrow >= borrowed;
-  const hf = borrowed === 0n ? null : Number(maxBorrow * WAD / borrowed) / Number(WAD);
-  return { healthy, healthFactor: hf != null && Number.isFinite(hf) ? hf : null };
+  return { positions: rows.map(morphoMidnightPositionToDiscoveryRow) };
 }
 
 // src/core/purpose.ts
@@ -1518,40 +1937,603 @@ async function buildEvmMultisignBatch(args) {
   return result;
 }
 
-// src/protocols/evm/morpho/vaultDepositMultisign.ts
-var MORPHO_VAULT_DEPOSIT_FALLBACK_GAS = 950000n;
-var MORPHO_ERC20_APPROVE_FALLBACK = 100000n;
-var MORPHO_WETH_DEPOSIT_FALLBACK = 120000n;
+// src/protocols/evm/morpho/midnightMultisign.ts
+init_midnightConstants();
+init_midnightApi();
 var wethDepositAbi = parseAbi(["function deposit() payable"]);
-var erc20AllowanceAbi = parseAbi([
-  "function allowance(address owner, address spender) view returns (uint256)"
-]);
-var erc20ApproveAbi = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
-var vaultDepositAbi = parseAbi([
-  "function deposit(uint256 assets, address onBehalf) returns (uint256 shares)"
+var erc20Abi = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function approve(address spender, uint256 amount) returns (bool)"
 ]);
-async function buildEvmMultisignBodyMorphoVaultDepositBatch(args) {
-  const asset = getAddress(args.underlying);
-  const vault = getAddress(args.vault);
-  const weth = getAddress(args.nativeWrapped);
-  const executor = getAddress(args.executorAddress);
-  const onBehalf = getAddress(args.onBehalf);
-  if (args.isNativeIn && asset.toLowerCase() !== weth.toLowerCase()) {
-    throw new Error("Native deposit path: underlying asset must match the chain wrapped native token.");
-  }
+function publicClientFor(rpcUrl, chainId) {
   const ch = defineChain({
-    id: args.chainId,
-    name: "MorphoVaultDeposit",
+    id: chainId,
+    name: "MorphoMidnight",
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
-    rpcUrls: { default: { http: [args.rpcUrl] } }
+    rpcUrls: { default: { http: [rpcUrl] } }
   });
-  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
-  const dec = await fetchMorphoVaultAssetDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, vault });
-  const amountWei = parseUnits(args.amountHuman, dec);
-  if (amountWei === 0n) throw new Error("Deposit amount is zero after converting with token decimals.");
-  const steps = [];
+  return createPublicClient({ chain: ch, transport: http(rpcUrl) });
+}
+async function readTokenDecimals(args) {
+  const publicClient = publicClientFor(args.rpcUrl, args.chainId);
+  const d = await publicClient.readContract({
+    address: args.token,
+    abi: erc20Abi,
+    functionName: "decimals"
+  });
+  const n = typeof d === "bigint" ? Number(d) : Number(d);
+  return !Number.isFinite(n) || n < 0 || n > 36 ? 18 : n;
+}
+async function buildApproveSteps(args) {
+  const steps = [];
+  let spendToken = args.token;
+  if (args.isNativeIn && args.nativeWrapped) {
+    const weth = getAddress(args.nativeWrapped);
+    if (spendToken.toLowerCase() !== weth.toLowerCase()) {
+      throw new Error("Native path: token must match wrapped native.");
+    }
+    steps.push({
+      kind: "weth_deposit",
+      to: weth,
+      data: encodeFunctionData({ abi: wethDepositAbi, functionName: "deposit" }),
+      value: args.amountWei
+    });
+    spendToken = weth;
+  }
+  const publicClient = publicClientFor(args.rpcUrl, args.chainId);
+  const currentAllowance = await publicClient.readContract({
+    address: spendToken,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [args.executor, args.spender]
+  });
+  if (currentAllowance < args.amountWei) {
+    if (currentAllowance > 0n) {
+      steps.push({
+        kind: "approve",
+        to: spendToken,
+        data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [args.spender, 0n] }),
+        value: 0n
+      });
+    }
+    steps.push({
+      kind: "approve",
+      to: spendToken,
+      data: encodeFunctionData({
+        abi: erc20Abi,
+        functionName: "approve",
+        args: [args.spender, args.amountWei]
+      }),
+      value: 0n
+    });
+  }
+  return steps;
+}
+async function ensureBundlesAuthorizedSteps(args) {
+  const publicClient = publicClientFor(args.rpcUrl, args.chainId);
+  const authorized = await publicClient.readContract({
+    address: args.midnight,
+    abi: midnightAbi,
+    functionName: "isAuthorized",
+    args: [args.onBehalf, args.bundles]
+  });
+  if (authorized) return [];
+  return [
+    {
+      to: args.midnight,
+      data: encodeFunctionData({
+        abi: midnightAbi,
+        functionName: "setIsAuthorized",
+        args: [args.bundles, true, args.onBehalf]
+      }),
+      value: 0n,
+      fallbackGas: MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS
+    }
+  ];
+}
+function approveStepsToEvm(steps) {
+  return steps.map((s) => ({
+    to: s.to,
+    data: s.data,
+    value: s.value,
+    fallbackGas: s.kind === "weth_deposit" ? MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK : MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK
+  }));
+}
+function offerFillsFromTakes(takes) {
+  return takes.map((t) => ({
+    offer: t.offer,
+    ratifierData: t.ratifierData,
+    units: t.units
+  }));
+}
+function resolveAddresses(args) {
+  const known = morphoMidnightAddressesForChain(args.chainId);
+  const midnight = args.midnight ? getAddress(args.midnight) : args.marketMidnight ? getAddress(args.marketMidnight) : known?.midnight;
+  const bundles = args.bundles ? getAddress(args.bundles) : known?.bundles;
+  if (!midnight || !bundles) {
+    throw new Error(
+      `Morpho Midnight addresses unknown for chain ${args.chainId}. Pass midnight/bundles or use a supported chain.`
+    );
+  }
+  return { midnight, bundles };
+}
+function deadlineFromNow(seconds) {
+  const s = seconds && seconds > 0 ? seconds : MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS;
+  return BigInt(Math.floor(Date.now() / 1e3) + s);
+}
+function collateralIndex(market, collateralToken) {
+  const idx = market.collateralParams.findIndex(
+    (c) => c.token.toLowerCase() === collateralToken.toLowerCase()
+  );
+  if (idx < 0) {
+    throw new Error(`Collateral ${collateralToken} is not in market collateralParams.`);
+  }
+  return BigInt(idx);
+}
+async function buildEvmMultisignBodyMorphoMidnightLendBatch(args) {
+  const taker = getAddress(args.taker);
+  const executor = getAddress(args.executorAddress);
+  const book = await fetchMorphoMidnightBook(args.marketId);
+  if (!book) throw new Error(`Midnight book not found: ${args.marketId}`);
+  const market = morphoMidnightBookToMarketParams(book);
+  const { midnight, bundles } = resolveAddresses({
+    chainId: args.chainId,
+    midnight: args.midnight,
+    bundles: args.bundles,
+    marketMidnight: market.midnight
+  });
+  const loanToken = args.loanToken ? getAddress(args.loanToken) : getAddress(market.loanToken);
+  if (loanToken.toLowerCase() !== market.loanToken.toLowerCase()) {
+    throw new Error("loanToken does not match Midnight market loan token.");
+  }
+  const dec = await readTokenDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: loanToken });
+  const targetBuyerAssets = parseUnits(args.amountHuman, dec);
+  if (targetBuyerAssets === 0n) throw new Error("Lend amount is zero.");
+  const slippage = (args.slippagePct ?? MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT).trim();
+  const quote = await fetchMorphoMidnightBookQuote({
+    marketId: args.marketId,
+    side: "asks",
+    assets: targetBuyerAssets,
+    slippage
+  });
+  if (!quote.takeableOffers.length) {
+    throw new Error("No takeable Midnight asks for this size. Try a smaller amount or another maturity.");
+  }
+  const worst = BigInt(quote.averageWorstPrice.split(".")[0] || "0");
+  const minUnits = morphoMidnightUnitsFromAssets(targetBuyerAssets, worst);
+  const deadline = deadlineFromNow(args.deadlineSeconds);
+  const offerFills = offerFillsFromTakes(quote.takeableOffers);
+  const approveSteps = await buildApproveSteps({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    token: loanToken,
+    spender: bundles,
+    amountWei: targetBuyerAssets,
+    executor,
+    isNativeIn: args.isNativeIn,
+    nativeWrapped: args.nativeWrapped
+  });
+  const authSteps = await ensureBundlesAuthorizedSteps({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    midnight,
+    bundles,
+    onBehalf: taker
+  });
+  const lendData = encodeFunctionData({
+    abi: midnightBundlesAbi,
+    functionName: "midnightBundlesV1BuyWithAssetsTargetAndWithdrawCollateral",
+    args: [
+      targetBuyerAssets,
+      minUnits,
+      taker,
+      false,
+      TOKEN_PERMIT_NONE,
+      offerFills,
+      [],
+      taker,
+      0n,
+      zeroAddress,
+      maxUint256,
+      deadline
+    ]
+  });
+  const marketLabel = (args.marketLabel ?? "").trim() || `Midnight ${args.marketId.slice(0, 10)}\u2026`;
+  const evmSteps = [
+    ...approveStepsToEvm(approveSteps),
+    ...authSteps,
+    { to: bundles, data: lendData, value: 0n, fallbackGas: MORPHO_MIDNIGHT_LEND_FALLBACK_GAS }
+  ];
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps: evmSteps,
+    purposeSuffix: `Morpho Midnight: lend (${args.amountHuman}) on "${marketLabel}".`,
+    firstMsgRawNo0x: evmSteps[0].data.slice(2),
+    destinationAddress: bundles,
+    buildBatchMeta: ({ gasLimit }) => ({
+      signatureText: JSON.stringify({
+        kind: "MorphoMidnight",
+        name: "lend",
+        marketLabel,
+        amountHuman: args.amountHuman
+      }),
+      evm: { type: "morpho_midnight_lend", version: 1, chainId: String(args.chainId) },
+      morpho: {
+        marketId: args.marketId,
+        marketLabel,
+        amountHuman: args.amountHuman,
+        gasBuild: { baseGasUnits: gasLimit.toString() }
+      }
+    })
+  });
+}
+async function buildEvmMultisignBodyMorphoMidnightBorrowBatch(args) {
+  const taker = getAddress(args.taker);
+  const receiver = getAddress(args.receiver ?? args.taker);
+  const executor = getAddress(args.executorAddress);
+  const collateralToken = getAddress(args.collateralToken);
+  const book = await fetchMorphoMidnightBook(args.marketId);
+  if (!book) throw new Error(`Midnight book not found: ${args.marketId}`);
+  const market = morphoMidnightBookToMarketParams(book);
+  const { midnight, bundles } = resolveAddresses({
+    chainId: args.chainId,
+    midnight: args.midnight,
+    bundles: args.bundles,
+    marketMidnight: market.midnight
+  });
+  const loanToken = args.loanToken ? getAddress(args.loanToken) : getAddress(market.loanToken);
+  const loanDec = await readTokenDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: loanToken });
+  const colDec = await readTokenDecimals({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    token: collateralToken
+  });
+  const targetSellerAssets = parseUnits(args.borrowAmountHuman, loanDec);
+  const collateralAmount = parseUnits(args.collateralAmountHuman, colDec);
+  if (targetSellerAssets === 0n) throw new Error("Borrow amount is zero.");
+  if (collateralAmount === 0n) throw new Error("Collateral amount is zero.");
+  const colIdx = args.collateralIndex != null && args.collateralIndex >= 0 ? BigInt(args.collateralIndex) : collateralIndex(market, collateralToken);
+  const slippage = (args.slippagePct ?? MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT).trim();
+  const quote = await fetchMorphoMidnightBookQuote({
+    marketId: args.marketId,
+    side: "bids",
+    assets: targetSellerAssets,
+    slippage
+  });
+  if (!quote.takeableOffers.length) {
+    throw new Error("No takeable Midnight bids for this size. Try a smaller amount or another maturity.");
+  }
+  const worst = BigInt(quote.averageWorstPrice.split(".")[0] || "0");
+  const maxUnits = morphoMidnightUnitsFromAssets(targetSellerAssets, worst);
+  const deadline = deadlineFromNow(args.deadlineSeconds);
+  const offerFills = offerFillsFromTakes(quote.takeableOffers);
+  const approveSteps = await buildApproveSteps({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    token: collateralToken,
+    spender: bundles,
+    amountWei: collateralAmount,
+    executor,
+    isNativeIn: args.isNativeIn,
+    nativeWrapped: args.nativeWrapped
+  });
+  const authSteps = await ensureBundlesAuthorizedSteps({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    midnight,
+    bundles,
+    onBehalf: taker
+  });
+  const borrowData = encodeFunctionData({
+    abi: midnightBundlesAbi,
+    functionName: "midnightBundlesV1SupplyCollateralAndSellWithAssetsTarget",
+    args: [
+      targetSellerAssets,
+      maxUnits,
+      taker,
+      false,
+      receiver,
+      [{ collateralIndex: colIdx, assets: collateralAmount, permit: TOKEN_PERMIT_NONE }],
+      offerFills,
+      0n,
+      zeroAddress,
+      maxUint256,
+      deadline
+    ]
+  });
+  const marketLabel = (args.marketLabel ?? "").trim() || `Midnight ${args.marketId.slice(0, 10)}\u2026`;
+  const evmSteps = [
+    ...approveStepsToEvm(approveSteps),
+    ...authSteps,
+    { to: bundles, data: borrowData, value: 0n, fallbackGas: MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS }
+  ];
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps: evmSteps,
+    purposeSuffix: `Morpho Midnight: borrow (${args.borrowAmountHuman}) on "${marketLabel}".`,
+    firstMsgRawNo0x: evmSteps[0].data.slice(2),
+    destinationAddress: bundles,
+    buildBatchMeta: ({ gasLimit }) => ({
+      signatureText: JSON.stringify({
+        kind: "MorphoMidnight",
+        name: "borrow",
+        marketLabel,
+        borrowAmountHuman: args.borrowAmountHuman,
+        collateralAmountHuman: args.collateralAmountHuman
+      }),
+      evm: { type: "morpho_midnight_borrow", version: 1, chainId: String(args.chainId) },
+      morpho: {
+        marketId: args.marketId,
+        marketLabel,
+        amountHuman: args.borrowAmountHuman,
+        gasBuild: { baseGasUnits: gasLimit.toString() }
+      }
+    })
+  });
+}
+async function buildEvmMultisignBodyMorphoMidnightRepayBatch(args) {
+  const onBehalf = getAddress(args.onBehalf);
+  const collateralReceiver = getAddress(args.collateralReceiver ?? args.onBehalf);
+  const executor = getAddress(args.executorAddress);
+  const [marketRow, position] = await Promise.all([
+    fetchMorphoMidnightMarketById(args.marketId),
+    fetchMorphoMidnightUserMarketPosition({ marketId: args.marketId, user: onBehalf })
+  ]);
+  if (!marketRow) throw new Error(`Midnight market not found: ${args.marketId}`);
+  if (!position) throw new Error(`No Midnight position for ${onBehalf} in ${args.marketId}`);
+  const baseMarket = morphoMidnightMarketToParams(marketRow);
+  let midnightAddr = baseMarket.midnight;
+  if (midnightAddr === zeroAddress) {
+    const book = await fetchMorphoMidnightBook(args.marketId);
+    if (book) midnightAddr = getAddress(book.midnight);
+  }
+  const { midnight, bundles } = resolveAddresses({
+    chainId: args.chainId,
+    midnight: args.midnight ?? (midnightAddr !== zeroAddress ? midnightAddr : void 0),
+    bundles: args.bundles,
+    marketMidnight: midnightAddr !== zeroAddress ? midnightAddr : void 0
+  });
+  const market = { ...baseMarket, midnight };
+  const loanToken = args.loanToken ? getAddress(args.loanToken) : getAddress(market.loanToken);
+  const dec = await readTokenDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: loanToken });
+  const debt = BigInt(position.debt || "0");
+  const fee = BigInt(position.pendingFee || "0");
+  const buffer = parseUnits("1", Math.min(dec, 6));
+  let repayAssets;
+  if (args.repayAmountHuman?.trim()) {
+    repayAssets = parseUnits(args.repayAmountHuman.trim(), dec);
+  } else {
+    repayAssets = debt + fee + buffer;
+  }
+  if (repayAssets === 0n) throw new Error("Repay amount is zero.");
+  const withdrawAll = args.withdrawAllCollateral !== false;
+  const collateralWithdrawals = withdrawAll ? position.collaterals.map((c) => {
+    const idx = market.collateralParams.findIndex(
+      (cp) => cp.token.toLowerCase() === c.token.toLowerCase()
+    );
+    if (idx < 0) throw new Error(`Collateral ${c.token} missing from market params.`);
+    return { collateralIndex: BigInt(idx), assets: BigInt(c.amount || "0") };
+  }) : [];
+  const deadline = deadlineFromNow(args.deadlineSeconds);
+  const approveSteps = await buildApproveSteps({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    token: loanToken,
+    spender: bundles,
+    amountWei: repayAssets,
+    executor
+  });
+  const authSteps = await ensureBundlesAuthorizedSteps({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    midnight,
+    bundles,
+    onBehalf
+  });
+  const repayData = encodeFunctionData({
+    abi: midnightBundlesAbi,
+    functionName: "midnightBundlesV1RepayAndWithdrawCollateral",
+    args: [
+      market,
+      repayAssets,
+      onBehalf,
+      TOKEN_PERMIT_NONE,
+      collateralWithdrawals,
+      collateralReceiver,
+      0n,
+      zeroAddress,
+      deadline
+    ]
+  });
+  const marketLabel = (args.marketLabel ?? "").trim() || `Midnight ${args.marketId.slice(0, 10)}\u2026`;
+  const evmSteps = [
+    ...approveStepsToEvm(approveSteps),
+    ...authSteps,
+    { to: bundles, data: repayData, value: 0n, fallbackGas: MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS }
+  ];
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps: evmSteps,
+    purposeSuffix: `Morpho Midnight: repay + withdraw on "${marketLabel}".`,
+    firstMsgRawNo0x: evmSteps[0].data.slice(2),
+    destinationAddress: bundles,
+    buildBatchMeta: ({ gasLimit }) => ({
+      signatureText: JSON.stringify({ kind: "MorphoMidnight", name: "repay", marketLabel }),
+      evm: { type: "morpho_midnight_repay", version: 1, chainId: String(args.chainId) },
+      morpho: {
+        marketId: args.marketId,
+        marketLabel,
+        gasBuild: { baseGasUnits: gasLimit.toString() }
+      }
+    })
+  });
+}
+var erc4626Abi = parseAbi([
+  "function asset() view returns (address)",
+  "function decimals() view returns (uint8)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function convertToAssets(uint256 shares) view returns (uint256)",
+  "function maxWithdraw(address owner) view returns (uint256)"
+]);
+async function fetchMorphoVaultAssetDecimals(args) {
+  const ch = defineChain({
+    id: args.chainId,
+    name: "MorphoVault",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  const vault = getAddress(args.vault);
+  const assetAddr = await publicClient.readContract({
+    address: vault,
+    abi: erc4626Abi,
+    functionName: "asset"
+  });
+  const d = await publicClient.readContract({
+    address: getAddress(assetAddr),
+    abi: parseAbi(["function decimals() view returns (uint8)"]),
+    functionName: "decimals"
+  });
+  const n = typeof d === "bigint" ? Number(d) : Number(d);
+  return !Number.isFinite(n) || n < 0 || n > 36 ? 18 : n;
+}
+async function fetchMorphoVaultMaxWithdrawWei(args) {
+  const ch = defineChain({
+    id: args.chainId,
+    name: "MorphoVault",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  return publicClient.readContract({
+    address: getAddress(args.vault),
+    abi: erc4626Abi,
+    functionName: "maxWithdraw",
+    args: [getAddress(args.owner)]
+  });
+}
+var morphoBlueAbi = parseAbi([
+  "function position(bytes32 id, address user) view returns (uint256 supplyShares, uint128 borrowShares, uint128 collateral)",
+  "function market(bytes32 id) view returns (uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee)",
+  "function idToMarketParams(bytes32 id) view returns (address loanToken, address collateralToken, address oracle, address irm, uint256 lltv)"
+]);
+var oracleAbi = parseAbi(["function price() view returns (uint256)"]);
+var WAD = 10n ** 18n;
+var ORACLE_PRICE_SCALE = 10n ** 36n;
+async function previewMorphoBlueHealthAfterCollateralWithdraw(args) {
+  const ch = defineChain({
+    id: args.chainId,
+    name: "MorphoBlue",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  const morpho = getAddress(args.morphoBlue);
+  const user = getAddress(args.user);
+  const id = args.marketId;
+  const [pos, mkt, params] = await Promise.all([
+    publicClient.readContract({
+      address: morpho,
+      abi: morphoBlueAbi,
+      functionName: "position",
+      args: [id, user]
+    }),
+    publicClient.readContract({
+      address: morpho,
+      abi: morphoBlueAbi,
+      functionName: "market",
+      args: [id]
+    }),
+    publicClient.readContract({
+      address: morpho,
+      abi: morphoBlueAbi,
+      functionName: "idToMarketParams",
+      args: [id]
+    })
+  ]);
+  const borrowShares = BigInt(pos[1]);
+  if (borrowShares === 0n) return { healthy: true, healthFactor: null };
+  const collateral = BigInt(pos[2]) - args.withdrawCollateralWei;
+  const oracle = getAddress(params[2]);
+  const lltv = BigInt(params[4]);
+  const price = await publicClient.readContract({
+    address: oracle,
+    abi: oracleAbi,
+    functionName: "price"
+  });
+  const totalBorrowAssets = BigInt(mkt[2]);
+  const totalBorrowShares = BigInt(mkt[3]);
+  if (totalBorrowShares === 0n) return { healthy: true, healthFactor: null };
+  const borrowed = (borrowShares * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares;
+  const maxBorrow = collateral * price / ORACLE_PRICE_SCALE * lltv / WAD;
+  const healthy = maxBorrow >= borrowed;
+  const hf = borrowed === 0n ? null : Number(maxBorrow * WAD / borrowed) / Number(WAD);
+  return { healthy, healthFactor: hf != null && Number.isFinite(hf) ? hf : null };
+}
+var MORPHO_VAULT_DEPOSIT_FALLBACK_GAS = 950000n;
+var MORPHO_ERC20_APPROVE_FALLBACK = 100000n;
+var MORPHO_WETH_DEPOSIT_FALLBACK = 120000n;
+var wethDepositAbi2 = parseAbi(["function deposit() payable"]);
+var erc20AllowanceAbi = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)"
+]);
+var erc20ApproveAbi = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var vaultDepositAbi = parseAbi([
+  "function deposit(uint256 assets, address onBehalf) returns (uint256 shares)"
+]);
+async function buildEvmMultisignBodyMorphoVaultDepositBatch(args) {
+  const asset = getAddress(args.underlying);
+  const vault = getAddress(args.vault);
+  const weth = getAddress(args.nativeWrapped);
+  const executor = getAddress(args.executorAddress);
+  const onBehalf = getAddress(args.onBehalf);
+  if (args.isNativeIn && asset.toLowerCase() !== weth.toLowerCase()) {
+    throw new Error("Native deposit path: underlying asset must match the chain wrapped native token.");
+  }
+  const ch = defineChain({
+    id: args.chainId,
+    name: "MorphoVaultDeposit",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  const dec = await fetchMorphoVaultAssetDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, vault });
+  const amountWei = parseUnits(args.amountHuman, dec);
+  if (amountWei === 0n) throw new Error("Deposit amount is zero after converting with token decimals.");
+  const steps = [];
   if (args.isNativeIn) {
-    const wethData = encodeFunctionData({ abi: wethDepositAbi, functionName: "deposit" });
+    const wethData = encodeFunctionData({ abi: wethDepositAbi2, functionName: "deposit" });
     steps.push({ kind: "weth_deposit", to: weth, data: wethData, value: amountWei });
   }
   const spendToken = args.isNativeIn ? weth : asset;
@@ -1703,7 +2685,7 @@ var MORPHO_BLUE_REPAY_FALLBACK_GAS = 1000000n;
 var MORPHO_BLUE_COLLATERAL_WITHDRAW_FALLBACK_GAS = 900000n;
 var MORPHO_ERC20_APPROVE_FALLBACK2 = 100000n;
 var MORPHO_WETH_DEPOSIT_FALLBACK2 = 120000n;
-var wethDepositAbi2 = parseAbi(["function deposit() payable"]);
+var wethDepositAbi3 = parseAbi(["function deposit() payable"]);
 var erc20AllowanceAbi2 = parseAbi([
   "function allowance(address owner, address spender) view returns (uint256)",
   "function decimals() view returns (uint8)"
@@ -1724,7 +2706,7 @@ function marketParamsTuple(p) {
     lltv: p.lltv
   };
 }
-async function readTokenDecimals(args) {
+async function readTokenDecimals2(args) {
   const ch = defineChain({
     id: args.chainId,
     name: "MorphoToken",
@@ -1740,7 +2722,7 @@ async function readTokenDecimals(args) {
   const n = typeof d === "bigint" ? Number(d) : Number(d);
   return !Number.isFinite(n) || n < 0 || n > 36 ? 18 : n;
 }
-async function buildApproveSteps(args) {
+async function buildApproveSteps2(args) {
   const steps = [];
   let spendToken = args.token;
   if (args.isNativeIn && args.nativeWrapped) {
@@ -1748,7 +2730,7 @@ async function buildApproveSteps(args) {
     if (spendToken.toLowerCase() !== weth.toLowerCase()) {
       throw new Error("Native collateral path: token must match wrapped native.");
     }
-    const wethData = encodeFunctionData({ abi: wethDepositAbi2, functionName: "deposit" });
+    const wethData = encodeFunctionData({ abi: wethDepositAbi3, functionName: "deposit" });
     steps.push({ kind: "weth_deposit", to: weth, data: wethData, value: args.amountWei });
     spendToken = weth;
   }
@@ -1799,10 +2781,10 @@ async function buildEvmMultisignBodyMorphoBlueSupplyCollateralBatch(args) {
   const onBehalf = getAddress(args.onBehalf);
   const executor = getAddress(args.executorAddress);
   const collateral = getAddress(args.collateralToken);
-  const dec = await readTokenDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: collateral });
+  const dec = await readTokenDecimals2({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: collateral });
   const amountWei = parseUnits(args.amountHuman, dec);
   if (amountWei === 0n) throw new Error("Collateral amount is zero.");
-  const approveSteps = await buildApproveSteps({
+  const approveSteps = await buildApproveSteps2({
     rpcUrl: args.rpcUrl,
     chainId: args.chainId,
     token: collateral,
@@ -1853,7 +2835,7 @@ async function buildEvmMultisignBodyMorphoBlueBorrowBatch(args) {
   const receiver = getAddress(args.receiver);
   const executor = getAddress(args.executorAddress);
   const loan = getAddress(args.loanToken);
-  const dec = await readTokenDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: loan });
+  const dec = await readTokenDecimals2({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: loan });
   const amountWei = parseUnits(args.amountHuman, dec);
   if (amountWei === 0n) throw new Error("Borrow amount is zero.");
   const borrowData = encodeFunctionData({
@@ -1893,10 +2875,10 @@ async function buildEvmMultisignBodyMorphoBlueRepayBatch(args) {
   const onBehalf = getAddress(args.onBehalf);
   const executor = getAddress(args.executorAddress);
   const loan = getAddress(args.loanToken);
-  const dec = await readTokenDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: loan });
+  const dec = await readTokenDecimals2({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: loan });
   const amountWei = parseUnits(args.amountHuman, dec);
   if (amountWei === 0n) throw new Error("Repay amount is zero.");
-  const approveSteps = await buildApproveSteps({
+  const approveSteps = await buildApproveSteps2({
     rpcUrl: args.rpcUrl,
     chainId: args.chainId,
     token: loan,
@@ -2032,11 +3014,16 @@ var morphoProtocolModule = {
     { id: "morpho.blue-repay", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Repay Morpho Blue borrow", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
     { id: "morpho.blue-collateral-withdraw", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw Morpho Blue collateral", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
     { id: "morpho.merkl-claim", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Claim Morpho Merkl rewards", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
-    { id: "morpho.midnight-borrow", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate borrow (coming soon)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+    { id: "morpho.fetch-midnight-books", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "List Morpho Midnight fixed-rate books", commonParams: [], params: {} },
+    { id: "morpho.fetch-midnight-quote", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Quote Morpho Midnight lend/borrow fill", commonParams: [], params: {} },
+    { id: "morpho.fetch-midnight-positions", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "List Morpho Midnight user positions", commonParams: [], params: {} },
+    { id: "morpho.midnight-lend", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate lend (take asks)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.midnight-borrow", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate borrow (supply collateral + take bids)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.midnight-repay", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight repay debt and withdraw collateral", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
   ]
 };
 registerProtocolModule(morphoProtocolModule);
 
-export { MORPHO_BLUE_BORROW_FALLBACK_GAS, MORPHO_BLUE_COLLATERAL_DEPOSIT_FALLBACK_GAS, MORPHO_BLUE_COLLATERAL_WITHDRAW_FALLBACK_GAS, MORPHO_BLUE_REPAY_FALLBACK_GAS, MORPHO_GRAPHQL_URL, MORPHO_MIDNIGHT_UNAVAILABLE_MESSAGE, MORPHO_PROTOCOL_ID, MORPHO_VAULT_DEPOSIT_FALLBACK_GAS, MORPHO_VAULT_WITHDRAW_FALLBACK_GAS, ROBINHOOD_CHAIN_ID, ROBINHOOD_EARN_USDG_ADDRESS, ROBINHOOD_EARN_VAULT_ADDRESS, ROBINHOOD_EARN_VAULT_NAME, ROBINHOOD_EARN_VAULT_SYMBOL, applyRobinhoodEarnMultisignDefaults, buildEvmMultisignBodyMorphoBlueBorrowBatch, buildEvmMultisignBodyMorphoBlueRepayBatch, buildEvmMultisignBodyMorphoBlueSupplyCollateralBatch, buildEvmMultisignBodyMorphoBlueWithdrawCollateralBatch, buildEvmMultisignBodyMorphoMerklDistributorClaim, buildEvmMultisignBodyMorphoVaultDepositBatch, buildEvmMultisignBodyMorphoVaultWithdraw, emptyMorphoEarnVaultDetailFields, enrichMorphoEarnOfferingRows, enrichMorphoEarnOfferingRowsForAgent, ensureMorphoChainAssetCache, fetchMorphoBorrowMarketsForCollateral, fetchMorphoBorrowMarketsForLoan, fetchMorphoChains, fetchMorphoEarnOfferingsForAsset, fetchMorphoEarnVaultDetails, fetchMorphoMarketById, fetchMorphoMarketsForChain, fetchMorphoMidnightIntents, fetchMorphoUserBluePositions, fetchMorphoUserPortfolioUsd, fetchMorphoUserVaultPositions, fetchMorphoVaultAssetDecimals, fetchMorphoVaultByAddress, fetchMorphoVaultMaxWithdrawWei, fetchMorphoVaultV2sForChain, fetchMorphoVaultsForChain, formatMorphoApyPct, formatMorphoFeePct, formatMorphoMarketApySummary, formatMorphoUsd, isMorphoVaultListed, isRobinhoodEarnProductFlag, isRobinhoodEarnQuery, loadMorphoSupportedChainIds, marketParamsFromApiRow, morphoEarnOfferingToDiscoveryRow, morphoFetchBlueMarketsSummary, morphoFetchEarnVaultsSummary, morphoGql, morphoKeyForAssetRow, morphoMarketToBorrowRow, morphoProtocolModule, morphoResolveListedEarnVaultByAddress, previewMorphoBlueHealthAfterCollateralWithdraw, resolveRobinhoodEarnFetchQuery, searchMorphoListedEarnVaults };
+export { MORPHO_BLUE_BORROW_FALLBACK_GAS, MORPHO_BLUE_COLLATERAL_DEPOSIT_FALLBACK_GAS, MORPHO_BLUE_COLLATERAL_WITHDRAW_FALLBACK_GAS, MORPHO_BLUE_REPAY_FALLBACK_GAS, MORPHO_GRAPHQL_URL, MORPHO_MIDNIGHT_ADDRESSES, MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS, MORPHO_MIDNIGHT_BASE_CHAIN_ID, MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT, MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS, MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS, MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT, MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK, MORPHO_MIDNIGHT_LEND_FALLBACK_GAS, MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS, MORPHO_MIDNIGHT_REST_BASE, MORPHO_MIDNIGHT_UNAVAILABLE_MESSAGE, MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK, MORPHO_PROTOCOL_ID, MORPHO_VAULT_DEPOSIT_FALLBACK_GAS, MORPHO_VAULT_WITHDRAW_FALLBACK_GAS, ROBINHOOD_CHAIN_ID, ROBINHOOD_EARN_USDG_ADDRESS, ROBINHOOD_EARN_VAULT_ADDRESS, ROBINHOOD_EARN_VAULT_NAME, ROBINHOOD_EARN_VAULT_SYMBOL, TOKEN_PERMIT_NONE, applyRobinhoodEarnMultisignDefaults, buildEvmMultisignBodyMorphoBlueBorrowBatch, buildEvmMultisignBodyMorphoBlueRepayBatch, buildEvmMultisignBodyMorphoBlueSupplyCollateralBatch, buildEvmMultisignBodyMorphoBlueWithdrawCollateralBatch, buildEvmMultisignBodyMorphoMerklDistributorClaim, buildEvmMultisignBodyMorphoMidnightBorrowBatch, buildEvmMultisignBodyMorphoMidnightLendBatch, buildEvmMultisignBodyMorphoMidnightRepayBatch, buildEvmMultisignBodyMorphoVaultDepositBatch, buildEvmMultisignBodyMorphoVaultWithdraw, emptyMorphoEarnVaultDetailFields, enrichMorphoEarnOfferingRows, enrichMorphoEarnOfferingRowsForAgent, ensureMorphoChainAssetCache, fetchMorphoBorrowMarketsForCollateral, fetchMorphoBorrowMarketsForLoan, fetchMorphoChains, fetchMorphoEarnOfferingsForAsset, fetchMorphoEarnVaultDetails, fetchMorphoMarketById, fetchMorphoMarketsForChain, fetchMorphoMidnightBook, fetchMorphoMidnightBookQuote, fetchMorphoMidnightBooks, fetchMorphoMidnightBooksForAsset, fetchMorphoMidnightIntents, fetchMorphoMidnightMarketById, fetchMorphoMidnightUserMarketPosition, fetchMorphoMidnightUserPositions, fetchMorphoUserBluePositions, fetchMorphoUserPortfolioUsd, fetchMorphoUserVaultPositions, fetchMorphoVaultAssetDecimals, fetchMorphoVaultByAddress, fetchMorphoVaultMaxWithdrawWei, fetchMorphoVaultV2sForChain, fetchMorphoVaultsForChain, formatMorphoApyPct, formatMorphoFeePct, formatMorphoMarketApySummary, formatMorphoMidnightAprPct, formatMorphoUsd, isMorphoVaultListed, isRobinhoodEarnProductFlag, isRobinhoodEarnQuery, loadMorphoSupportedChainIds, marketParamsFromApiRow, morphoEarnOfferingToDiscoveryRow, morphoFetchBlueMarketsSummary, morphoFetchEarnVaultsSummary, morphoFetchMidnightBooksSummary, morphoFetchMidnightPositionsSummary, morphoFetchMidnightQuote, morphoFetchMidnightQuoteSummary, morphoGql, morphoKeyForAssetRow, morphoMarketToBorrowRow, morphoMidnightAddressesForChain, morphoMidnightApiBaseUrl, morphoMidnightAprFromPriceWad, morphoMidnightBookToDiscoveryRow, morphoMidnightBookToMarketParams, morphoMidnightMarketToParams, morphoMidnightPositionToDiscoveryRow, morphoMidnightTtmSeconds, morphoMidnightUnitsFromAssets, morphoProtocolModule, morphoResolveListedEarnVaultByAddress, previewMorphoBlueHealthAfterCollateralWithdraw, resolveRobinhoodEarnFetchQuery, searchMorphoListedEarnVaults };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map