@continuumdao/ctm-mpc-defi 0.2.9 → 0.2.11

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

@@ -0,0 +1,1971 @@
+'use strict';
+
+var viem = require('viem');
+var continuumNodeSdk = require('@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);
+  }
+}
+async function postJsonViaOptionalProxy(args) {
+  const r = await fetch(args.directUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(args.body)
+  });
+  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();
+}
+
+// src/protocols/evm/morpho/api.ts
+var MORPHO_GRAPHQL_URL = "https://api.morpho.org/graphql";
+async function morphoGql(query, variables) {
+  const body = { query, variables: variables ?? {} };
+  const j = await postJsonViaOptionalProxy({
+    directUrl: MORPHO_GRAPHQL_URL,
+    body});
+  if (j.errors?.length) {
+    const msg = j.errors.map((e) => e.message ?? "Unknown").join("; ");
+    throw new Error(msg);
+  }
+  if (j.data == null) throw new Error("Morpho API: empty response");
+  return j.data;
+}
+async function fetchMorphoChains() {
+  const d = await morphoGql(`
+    query { chains { id network } }
+  `);
+  return d.chains ?? [];
+}
+async function loadMorphoSupportedChainIds() {
+  const rows = await fetchMorphoChains();
+  const s = /* @__PURE__ */ new Set();
+  for (const c of rows) {
+    if (typeof c.id === "number" && Number.isFinite(c.id)) s.add(c.id);
+  }
+  return s;
+}
+function morphoKeyForAssetRow(args) {
+  const raw = (args.contractAddress ?? "").trim();
+  if (!raw) return null;
+  const lower = raw.toLowerCase();
+  if (lower === "0x0000000000000000000000000000000000000000" || lower === "native") {
+    const w = (args.nativeWrapped ?? "").trim();
+    if (!w || !viem.isAddress(w)) return null;
+    return viem.getAddress(w).toLowerCase();
+  }
+  if (!viem.isAddress(raw)) return null;
+  return viem.getAddress(raw).toLowerCase();
+}
+function formatMorphoApyPct(apy) {
+  if (apy == null || !Number.isFinite(apy)) return "\u2014";
+  return `${(apy * 100).toFixed(2)}%`;
+}
+function formatMorphoFeePct(fee) {
+  if (fee == null || !Number.isFinite(fee)) return "\u2014";
+  return `${(fee * 100).toFixed(2)}%`;
+}
+function formatMorphoUsd(n) {
+  if (n == null || !Number.isFinite(n)) return "\u2014";
+  if (n >= 1e6) return `$${(n / 1e6).toFixed(2)}M`;
+  if (n >= 1e3) return `$${(n / 1e3).toFixed(2)}K`;
+  return `$${n.toFixed(2)}`;
+}
+function marketParamsFromApiRow(row) {
+  const loanToken = viem.getAddress(row.loanAsset.address ?? "");
+  const collateralToken = viem.getAddress(row.collateralAsset.address ?? "");
+  const oracle = viem.getAddress(row.oracle.address);
+  const irm = viem.getAddress(row.irmAddress);
+  const lltv = BigInt(row.lltv);
+  return { loanToken, collateralToken, oracle, irm, lltv };
+}
+async function fetchMorphoMarketById(args) {
+  const marketId = args.marketId.trim();
+  if (!marketId) return null;
+  const d = await morphoGql(
+    `
+    query MorphoMarketById($marketId: String!, $chainId: Int!) {
+      marketById(marketId: $marketId, chainId: $chainId) {
+        marketId
+        loanAsset { address symbol decimals price { usd } }
+        collateralAsset { address symbol decimals price { usd } }
+        lltv
+        oracle { address }
+        irmAddress
+        morphoBlue { address }
+        state {
+          supplyApy borrowApy netSupplyApy netBorrowApy
+          supplyAssetsUsd borrowAssetsUsd collateralAssetsUsd utilization
+          rewards { supplyApr borrowApr asset { address symbol } }
+        }
+      }
+    }
+  `,
+    { marketId, chainId: args.chainId }
+  );
+  const row = d.marketById;
+  if (!row?.marketId || !row.morphoBlue?.address) return null;
+  return {
+    ...row,
+    morphoBlueAddress: viem.getAddress(row.morphoBlue.address),
+    marketParams: marketParamsFromApiRow(row)
+  };
+}
+var LIGHT_BATCH_SIZE = 8;
+var V2_EXPOSURE_POSITION_LIMIT = 20;
+var EXPOSURE_FETCH_CONCURRENCY = 4;
+function formatAllocationPercent(partUsd, totalUsd) {
+  if (!Number.isFinite(partUsd) || !Number.isFinite(totalUsd) || totalUsd <= 0) return "\u2014";
+  return `${(partUsd / totalUsd * 100).toFixed(1)}%`;
+}
+function marketExposureLabel(loan, collateral) {
+  const loanSym = (loan ?? "").trim() || "LOAN";
+  const colSym = (collateral ?? "").trim();
+  return colSym ? `${loanSym}/${colSym}` : loanSym;
+}
+function latestHistoryApy(points) {
+  const y = points?.[0]?.y;
+  return y != null && Number.isFinite(y) ? y : null;
+}
+function parseV1Exposure(allocation, totalUsd) {
+  const out = [];
+  for (const a of allocation) {
+    const usd = a.supplyAssetsUsd;
+    if (usd == null || !Number.isFinite(usd) || usd <= 0) continue;
+    out.push({
+      label: marketExposureLabel(a.market?.loanAsset?.symbol, a.market?.collateralAsset?.symbol),
+      allocatedUsdLabel: formatMorphoUsd(usd),
+      allocationPercentLabel: formatAllocationPercent(usd, totalUsd)
+    });
+  }
+  return out.sort((a, b) => parseFloat(b.allocatedUsdLabel.replace(/[^0-9.]/g, "")) - parseFloat(a.allocatedUsdLabel.replace(/[^0-9.]/g, "")));
+}
+function parseV2Exposure(adapters, totalUsd) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const adapter of adapters) {
+    if (adapter.__typename === "MorphoVaultV2Adapter") {
+      const usd = adapter.assetsUsd;
+      if (usd == null || !Number.isFinite(usd) || usd <= 0) continue;
+      const label = (adapter.innerVault?.name ?? adapter.innerVault?.asset?.symbol ?? "Vault V2 adapter").trim() || "Vault V2 adapter";
+      byKey.set(label, (byKey.get(label) ?? 0) + usd);
+      continue;
+    }
+    if (adapter.__typename === "MorphoMarketV1Adapter") {
+      for (const p of adapter.positions?.items ?? []) {
+        const usd = p.state?.supplyAssetsUsd;
+        if (usd == null || !Number.isFinite(usd) || usd <= 0) continue;
+        const label = marketExposureLabel(p.market?.loanAsset?.symbol, p.market?.collateralAsset?.symbol);
+        byKey.set(label, (byKey.get(label) ?? 0) + usd);
+      }
+      const adapterUsd = adapter.assetsUsd;
+      if (!adapter.positions?.items?.length && adapterUsd != null && Number.isFinite(adapterUsd) && adapterUsd > 0) {
+        byKey.set("Morpho markets", (byKey.get("Morpho markets") ?? 0) + adapterUsd);
+      }
+    }
+  }
+  return [...byKey.entries()].map(([label, usd]) => ({
+    label,
+    allocatedUsdLabel: formatMorphoUsd(usd),
+    allocationPercentLabel: formatAllocationPercent(usd, totalUsd)
+  })).sort((a, b) => parseFloat(b.allocatedUsdLabel.replace(/[^0-9.]/g, "")) - parseFloat(a.allocatedUsdLabel.replace(/[^0-9.]/g, "")));
+}
+function emptyMorphoEarnVaultDetailFields() {
+  return {
+    liquidityUsdLabel: "\u2014",
+    netApy7dLabel: "\u2014",
+    netApy30dLabel: "\u2014",
+    netApy90dLabel: "\u2014",
+    exposure: []
+  };
+}
+async function fetchV1EarnVaultLightBatch(args) {
+  const out = /* @__PURE__ */ new Map();
+  if (!args.addresses.length) return out;
+  const d = await morphoGql(
+    `
+    query MorphoV1EarnVaultLight($chainId: Int!, $addresses: [String!]!) {
+      vaults(where: { chainId_in: [$chainId], address_in: $addresses, listed: true }) {
+        items {
+          address
+          liquidity { usd }
+        }
+      }
+    }
+  `,
+    { chainId: args.chainId, addresses: args.addresses.map((a) => viem.getAddress(a)) }
+  );
+  for (const v of d.vaults?.items ?? []) {
+    const addr = (v.address ?? "").trim();
+    if (!viem.isAddress(addr)) continue;
+    out.set(viem.getAddress(addr).toLowerCase(), {
+      ...emptyMorphoEarnVaultDetailFields(),
+      liquidityUsdLabel: formatMorphoUsd(v.liquidity?.usd)
+    });
+  }
+  return out;
+}
+async function fetchV1EarnVaultPeriodApys(args) {
+  const d = await morphoGql(
+    `
+    query MorphoV1EarnVaultPeriodApys($chainId: Int!, $address: String!) {
+      vaultByAddress(chainId: $chainId, address: $address) {
+        historicalState {
+          weeklyNetApy { y }
+          monthlyNetApy { y }
+          quarterlyNetApy { y }
+        }
+      }
+    }
+  `,
+    { chainId: args.chainId, address: viem.getAddress(args.address) }
+  );
+  const hs = d.vaultByAddress?.historicalState;
+  return {
+    netApy7dLabel: formatMorphoApyPct(latestHistoryApy(hs?.weeklyNetApy)),
+    netApy30dLabel: formatMorphoApyPct(latestHistoryApy(hs?.monthlyNetApy)),
+    netApy90dLabel: formatMorphoApyPct(latestHistoryApy(hs?.quarterlyNetApy))
+  };
+}
+async function fetchV2EarnVaultLightBatch(args) {
+  const out = /* @__PURE__ */ new Map();
+  if (!args.addresses.length) return out;
+  const d = await morphoGql(
+    `
+    query MorphoV2EarnVaultLight($chainId: Int!, $addresses: [String!]!) {
+      vaultV2s(where: { chainId_in: [$chainId], address_in: $addresses, listed: true }) {
+        items {
+          address
+          liquidityUsd
+          avgNetApy7d: avgNetApy(lookback: SEVEN_DAYS)
+          avgNetApy30d: avgNetApy(lookback: THIRTY_DAYS)
+          avgNetApy90d: avgNetApy(lookback: NINETY_DAYS)
+        }
+      }
+    }
+  `,
+    {
+      chainId: args.chainId,
+      addresses: args.addresses.map((a) => viem.getAddress(a))
+    }
+  );
+  for (const v of d.vaultV2s?.items ?? []) {
+    const addr = (v.address ?? "").trim();
+    if (!viem.isAddress(addr)) continue;
+    out.set(viem.getAddress(addr).toLowerCase(), {
+      liquidityUsdLabel: formatMorphoUsd(v.liquidityUsd),
+      netApy7dLabel: formatMorphoApyPct(v.avgNetApy7d),
+      netApy30dLabel: formatMorphoApyPct(v.avgNetApy30d),
+      netApy90dLabel: formatMorphoApyPct(v.avgNetApy90d),
+      exposure: []
+    });
+  }
+  return out;
+}
+async function fetchV1EarnVaultExposure(args) {
+  const d = await morphoGql(
+    `
+    query MorphoV1EarnVaultExposure($chainId: Int!, $address: String!) {
+      vaultByAddress(chainId: $chainId, address: $address) {
+        address
+        state {
+          totalAssetsUsd
+          allocation {
+            supplyAssetsUsd
+            market { loanAsset { symbol } collateralAsset { symbol } }
+          }
+        }
+      }
+    }
+  `,
+    { chainId: args.chainId, address: viem.getAddress(args.address) }
+  );
+  const v = d.vaultByAddress;
+  if (!v?.address) return [];
+  return parseV1Exposure(v.state?.allocation ?? [], v.state?.totalAssetsUsd ?? 0);
+}
+async function fetchV2EarnVaultExposure(args) {
+  const d = await morphoGql(
+    `
+    query MorphoV2EarnVaultExposure($chainId: Int!, $address: String!, $posLimit: Int!) {
+      vaultV2ByAddress(chainId: $chainId, address: $address) {
+        address
+        totalAssetsUsd
+        adapters {
+          items {
+            __typename
+            assetsUsd
+            ... on MorphoVaultV2Adapter {
+              innerVault { name asset { symbol } }
+            }
+            ... on MorphoMarketV1Adapter {
+              positions(first: $posLimit) {
+                items {
+                  market { loanAsset { symbol } collateralAsset { symbol } }
+                  state { supplyAssetsUsd }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  `,
+    { chainId: args.chainId, address: viem.getAddress(args.address), posLimit: V2_EXPOSURE_POSITION_LIMIT }
+  );
+  const v = d.vaultV2ByAddress;
+  if (!v?.address) return [];
+  return parseV2Exposure(v.adapters?.items ?? [], v.totalAssetsUsd ?? 0);
+}
+async function fetchMorphoEarnVaultDetails(args) {
+  const addr = args.vaultAddress.trim();
+  if (!viem.isAddress(addr)) return emptyMorphoEarnVaultDetailFields();
+  if (args.vaultGeneration === "v1") {
+    const [light2, periodApys, exposure2] = await Promise.all([
+      fetchV1EarnVaultLightBatch({ chainId: args.chainId, addresses: [addr] }),
+      fetchV1EarnVaultPeriodApys({ chainId: args.chainId, address: addr }),
+      fetchV1EarnVaultExposure({ chainId: args.chainId, address: addr })
+    ]);
+    const detail2 = light2.get(viem.getAddress(addr).toLowerCase()) ?? emptyMorphoEarnVaultDetailFields();
+    return { ...detail2, ...periodApys, exposure: exposure2 };
+  }
+  const [light, exposure] = await Promise.all([
+    fetchV2EarnVaultLightBatch({ chainId: args.chainId, addresses: [addr] }),
+    fetchV2EarnVaultExposure({ chainId: args.chainId, address: addr })
+  ]);
+  const detail = light.get(viem.getAddress(addr).toLowerCase()) ?? emptyMorphoEarnVaultDetailFields();
+  return { ...detail, exposure };
+}
+async function enrichMorphoEarnOfferingRowsLight(chainId, rows) {
+  if (!rows.length) return rows;
+  const v1Addrs = [];
+  const v2Addrs = [];
+  for (const r of rows) {
+    if (r.vaultGeneration === "v1") v1Addrs.push(r.vaultAddress);
+    else v2Addrs.push(r.vaultAddress);
+  }
+  const detailByAddr = /* @__PURE__ */ new Map();
+  for (let i = 0; i < v1Addrs.length; i += LIGHT_BATCH_SIZE) {
+    const batch = await fetchV1EarnVaultLightBatch({ chainId, addresses: v1Addrs.slice(i, i + LIGHT_BATCH_SIZE) });
+    for (const [k, v] of batch) detailByAddr.set(k, v);
+  }
+  for (let i = 0; i < v2Addrs.length; i += LIGHT_BATCH_SIZE) {
+    const batch = await fetchV2EarnVaultLightBatch({ chainId, addresses: v2Addrs.slice(i, i + LIGHT_BATCH_SIZE) });
+    for (const [k, v] of batch) detailByAddr.set(k, v);
+  }
+  return rows.map((row) => {
+    const detail = detailByAddr.get(row.vaultAddress.toLowerCase());
+    if (!detail) return row;
+    return {
+      ...row,
+      liquidityUsdLabel: detail.liquidityUsdLabel !== "\u2014" ? detail.liquidityUsdLabel : row.liquidityUsdLabel,
+      netApy7dLabel: detail.netApy7dLabel,
+      netApy30dLabel: detail.netApy30dLabel,
+      netApy90dLabel: detail.netApy90dLabel
+    };
+  });
+}
+async function attachAgentVaultDetails(chainId, rows) {
+  if (!rows.length) return rows;
+  const out = [...rows];
+  for (let i = 0; i < out.length; i += EXPOSURE_FETCH_CONCURRENCY) {
+    const chunk = out.slice(i, i + EXPOSURE_FETCH_CONCURRENCY);
+    const details = await Promise.all(
+      chunk.map(async (row) => {
+        const exposure = row.vaultGeneration === "v1" ? await fetchV1EarnVaultExposure({ chainId, address: row.vaultAddress }) : await fetchV2EarnVaultExposure({ chainId, address: row.vaultAddress });
+        const periodApys = row.vaultGeneration === "v1" ? await fetchV1EarnVaultPeriodApys({ chainId, address: row.vaultAddress }) : {
+          netApy7dLabel: row.netApy7dLabel,
+          netApy30dLabel: row.netApy30dLabel,
+          netApy90dLabel: row.netApy90dLabel
+        };
+        return { exposure, periodApys };
+      })
+    );
+    for (let j = 0; j < chunk.length; j++) {
+      out[i + j] = { ...out[i + j], ...details[j].periodApys, exposure: details[j].exposure };
+    }
+  }
+  return out;
+}
+async function enrichMorphoEarnOfferingRows(chainId, rows) {
+  return enrichMorphoEarnOfferingRowsLight(chainId, rows);
+}
+async function enrichMorphoEarnOfferingRowsForAgent(chainId, rows) {
+  const light = await enrichMorphoEarnOfferingRowsLight(chainId, rows);
+  return attachAgentVaultDetails(chainId, light);
+}
+
+// src/protocols/evm/morpho/vaultMarkets.ts
+var EMPTY_EARN_DETAIL = emptyMorphoEarnVaultDetailFields();
+var VAULT_PAGE_SIZE = 100;
+var VAULT_ASSET_QUERY_LIMIT = 200;
+var DISCOVERY_DEFAULT_LIMIT = 50;
+var DISCOVERY_CHAIN_FETCH_LIMIT = 300;
+function parseUsdLabel(s) {
+  const n = parseFloat(s.replace(/[^0-9.]/g, ""));
+  return Number.isFinite(n) ? n : 0;
+}
+function sortEarnRowsByTvl(rows) {
+  return [...rows].sort((a, b) => parseUsdLabel(b.totalAssetsUsdLabel) - parseUsdLabel(a.totalAssetsUsdLabel));
+}
+function morphoEarnOfferingToDiscoveryRow(row) {
+  const mgmt = row.managementFeeLabel;
+  return {
+    vaultAddress: row.vaultAddress,
+    vaultName: row.vaultName,
+    vaultSymbol: row.vaultSymbol,
+    underlyingAddress: row.underlyingAddress,
+    underlyingSymbol: row.underlyingSymbol,
+    apy: row.apyLabel,
+    netApy: row.netApyLabel,
+    netApy7d: row.netApy7dLabel,
+    netApy30d: row.netApy30dLabel,
+    netApy90d: row.netApy90dLabel,
+    performanceFee: row.performanceFeeLabel,
+    managementFee: mgmt === "\u2014" || mgmt === "0.00%" ? null : mgmt,
+    totalDepositsUsd: row.totalAssetsUsdLabel,
+    liquidityUsd: row.liquidityUsdLabel,
+    exposure: row.exposure
+  };
+}
+function matchesMorphoVaultSearch(row, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  const haystack = [row.vaultName, row.vaultSymbol, row.vaultAddress, row.underlyingSymbol].join(" ").toLowerCase();
+  return haystack.includes(q);
+}
+function matchesMorphoUnderlyingFilter(row, underlying) {
+  const u = underlying.trim();
+  if (!u) return true;
+  if (viem.isAddress(u)) {
+    try {
+      return row.underlyingAddress.toLowerCase() === viem.getAddress(u).toLowerCase();
+    } catch {
+      return false;
+    }
+  }
+  return row.underlyingSymbol.toLowerCase().includes(u.toLowerCase());
+}
+async function fetchAllListedEarnVaultsForChain(chainId) {
+  const [v1Vaults, v2Vaults] = await Promise.all([
+    fetchMorphoVaultsForChain(chainId, DISCOVERY_CHAIN_FETCH_LIMIT),
+    fetchMorphoVaultV2sForChain(chainId, DISCOVERY_CHAIN_FETCH_LIMIT, 0)
+  ]);
+  const byAddr = /* @__PURE__ */ new Map();
+  const defaultDecimals = 18;
+  for (const v of v1Vaults) {
+    if (v.listed === false) continue;
+    const row = earnRowFromVault({
+      chainId,
+      address: v.address,
+      symbol: v.symbol,
+      name: v.name,
+      asset: v.asset,
+      apy: v.state?.apy,
+      netApy: v.state?.netApy,
+      performanceFee: v.state?.fee,
+      managementFee: null,
+      totalAssetsUsd: v.state?.totalAssetsUsd,
+      underlyingDecimals: v.asset?.decimals ?? defaultDecimals,
+      vaultGeneration: "v1"
+    });
+    if (row) byAddr.set(row.vaultAddress.toLowerCase(), row);
+  }
+  for (const v of v2Vaults) {
+    if (v.listed === false) continue;
+    const row = earnRowFromVault({
+      chainId,
+      address: v.address,
+      symbol: v.symbol,
+      name: v.name,
+      asset: v.asset,
+      apy: v.apy,
+      netApy: v.netApy,
+      performanceFee: v.performanceFee,
+      managementFee: v.managementFee,
+      totalAssetsUsd: v.totalAssetsUsd,
+      underlyingDecimals: v.asset?.decimals ?? defaultDecimals,
+      vaultGeneration: "v2"
+    });
+    if (row) byAddr.set(row.vaultAddress.toLowerCase(), row);
+  }
+  return sortEarnRowsByTvl([...byAddr.values()]);
+}
+async function searchMorphoListedEarnVaults(args) {
+  const limit = args.limit ?? DISCOVERY_DEFAULT_LIMIT;
+  const underlying = args.underlying?.trim() ?? "";
+  const query = args.query?.trim() ?? "";
+  let rows;
+  const enrichedFromAsset = Boolean(underlying && viem.isAddress(underlying));
+  if (enrichedFromAsset) {
+    rows = await fetchMorphoEarnOfferingsForAsset({
+      chainId: args.chainId,
+      contractAddress: underlying,
+      underlyingDecimals: 18,
+      suppliedAssetSymbol: void 0
+    });
+  } else {
+    rows = await fetchAllListedEarnVaultsForChain(args.chainId);
+  }
+  if (underlying) {
+    rows = rows.filter((r) => matchesMorphoUnderlyingFilter(morphoEarnOfferingToDiscoveryRow(r), underlying));
+  }
+  if (query) {
+    rows = rows.filter((r) => matchesMorphoVaultSearch(morphoEarnOfferingToDiscoveryRow(r), query));
+  }
+  rows = rows.slice(0, Math.max(1, Math.min(limit, 200)));
+  rows = await enrichMorphoEarnOfferingRowsForAgent(args.chainId, rows);
+  return rows.map(morphoEarnOfferingToDiscoveryRow);
+}
+async function isMorphoVaultListed(args) {
+  const row = await fetchMorphoVaultByAddress(args);
+  return row?.listed === true;
+}
+function earnRowFromVault(args) {
+  const assetAddr = (args.asset?.address ?? "").trim();
+  if (!viem.isAddress(assetAddr)) return null;
+  const vaultAddress = viem.getAddress(args.address);
+  const sym = (args.symbol ?? args.name ?? "Vault").trim() || "Vault";
+  const vaultName = (args.name ?? sym).trim() || sym;
+  const underlyingSymbol = (args.asset?.symbol ?? args.suppliedAssetSymbol ?? "ASSET").trim();
+  const dec = args.asset?.decimals ?? args.underlyingDecimals;
+  return {
+    vaultAddress,
+    vaultSymbol: sym,
+    vaultName,
+    underlyingAddress: viem.getAddress(assetAddr),
+    underlyingSymbol,
+    underlyingDecimals: dec,
+    apyLabel: formatMorphoApyPct(args.apy),
+    netApyLabel: formatMorphoApyPct(args.netApy),
+    performanceFeeLabel: formatMorphoFeePct(args.performanceFee),
+    managementFeeLabel: formatMorphoFeePct(args.managementFee),
+    totalAssetsUsdLabel: formatMorphoUsd(args.totalAssetsUsd),
+    liquidityUsdLabel: formatMorphoUsd(args.liquidityUsd),
+    netApy7dLabel: EMPTY_EARN_DETAIL.netApy7dLabel,
+    netApy30dLabel: EMPTY_EARN_DETAIL.netApy30dLabel,
+    netApy90dLabel: EMPTY_EARN_DETAIL.netApy90dLabel,
+    exposure: EMPTY_EARN_DETAIL.exposure,
+    vaultId: `${args.chainId}:${vaultAddress.toLowerCase()}`,
+    vaultGeneration: args.vaultGeneration
+  };
+}
+async function fetchMorphoVaultsForChain(chainId, first = 100) {
+  const d = await morphoGql(
+    `
+    query MorphoVaults($chainId: Int!, $first: Int!) {
+      vaults(first: $first, where: { chainId_in: [$chainId], listed: true }, orderBy: TotalAssetsUsd, orderDirection: Desc) {
+        items {
+          address symbol name listed
+          asset { address symbol decimals price { usd } }
+          chain { id }
+          state { apy netApy fee totalAssetsUsd allRewards { supplyApr asset { address symbol } } }
+        }
+      }
+    }
+  `,
+    { chainId, first }
+  );
+  return d.vaults?.items ?? [];
+}
+async function fetchMorphoVaultV2sForChain(chainId, first = 100, skip = 0) {
+  const d = await morphoGql(
+    `
+    query MorphoVaultV2s($chainId: Int!, $first: Int!, $skip: Int!) {
+      vaultV2s(
+        first: $first
+        skip: $skip
+        where: { chainId_in: [$chainId], listed: true }
+        orderBy: TotalAssetsUsd
+        orderDirection: Desc
+      ) {
+        items {
+          address symbol name listed
+          asset { address symbol decimals price { usd } }
+          chain { id }
+          apy netApy performanceFee managementFee totalAssetsUsd
+          rewards { supplyApr asset { address symbol } }
+        }
+      }
+    }
+  `,
+    { chainId, first, skip }
+  );
+  return d.vaultV2s?.items ?? [];
+}
+async function fetchMorphoVaultsForAssetAddress(args) {
+  const asset = viem.getAddress(args.assetAddress);
+  const d = await morphoGql(
+    `
+    query MorphoVaultsForAsset($chainId: Int!, $asset: String!, $first: Int!) {
+      vaults(
+        first: $first
+        where: { chainId_in: [$chainId], assetAddress_in: [$asset], listed: true }
+        orderBy: TotalAssetsUsd
+        orderDirection: Desc
+      ) {
+        items {
+          address symbol name listed
+          asset { address symbol decimals }
+          liquidity { usd }
+          state { apy netApy fee totalAssetsUsd }
+        }
+      }
+    }
+  `,
+    { chainId: args.chainId, asset, first: VAULT_ASSET_QUERY_LIMIT }
+  );
+  return d.vaults?.items ?? [];
+}
+async function fetchMorphoVaultV2sForAssetAddress(args) {
+  const asset = viem.getAddress(args.assetAddress);
+  const d = await morphoGql(
+    `
+    query MorphoVaultV2sForAsset($chainId: Int!, $asset: Address!, $first: Int!) {
+      vaultV2s(
+        first: $first
+        where: { chainId_in: [$chainId], assetAddress_in: [$asset], listed: true }
+        orderBy: TotalAssetsUsd
+        orderDirection: Desc
+      ) {
+        items {
+          address symbol name listed
+          asset { address symbol decimals }
+          apy netApy performanceFee managementFee totalAssetsUsd liquidityUsd
+        }
+      }
+    }
+  `,
+    { chainId: args.chainId, asset, first: VAULT_ASSET_QUERY_LIMIT }
+  );
+  return d.vaultV2s?.items ?? [];
+}
+async function fetchAllMorphoVaultV2AssetAddresses(chainId) {
+  const out = /* @__PURE__ */ new Set();
+  let skip = 0;
+  for (let page = 0; page < 20; page++) {
+    const batch = await fetchMorphoVaultV2sForChain(chainId, VAULT_PAGE_SIZE, skip);
+    if (!batch.length) break;
+    for (const v of batch) {
+      const a = (v.asset?.address ?? "").trim();
+      if (viem.isAddress(a)) out.add(viem.getAddress(a).toLowerCase());
+    }
+    if (batch.length < VAULT_PAGE_SIZE) break;
+    skip += VAULT_PAGE_SIZE;
+  }
+  return out;
+}
+async function fetchMorphoVaultByAddress(args) {
+  const addr = args.vaultAddress.trim();
+  if (!viem.isAddress(addr)) return null;
+  const checksummed = viem.getAddress(addr);
+  const v2 = await morphoGql(
+    `
+    query MorphoVaultV2ByAddress($address: String!, $chainId: Int!) {
+      vaultV2ByAddress(address: $address, chainId: $chainId) {
+        address symbol name listed
+        asset { address symbol decimals price { usd } }
+        chain { id }
+        apy netApy totalAssetsUsd
+        rewards { supplyApr asset { address symbol } }
+      }
+    }
+  `,
+    { address: checksummed, chainId: args.chainId }
+  ).catch(() => ({ vaultV2ByAddress: null }));
+  if (v2.vaultV2ByAddress?.address) return v2.vaultV2ByAddress;
+  const d = await morphoGql(
+    `
+    query MorphoVaultByAddress($address: String!, $chainId: Int!) {
+      vaultByAddress(address: $address, chainId: $chainId) {
+        address symbol name listed
+        asset { address symbol decimals price { usd } }
+        chain { id }
+        state { apy netApy fee totalAssetsUsd allRewards { supplyApr asset { address symbol } } }
+      }
+    }
+  `,
+    { address: checksummed, chainId: args.chainId }
+  ).catch(() => ({ vaultByAddress: null }));
+  return d.vaultByAddress;
+}
+async function fetchMorphoEarnOfferingsForAsset(args) {
+  const key = morphoKeyForAssetRow({ contractAddress: args.contractAddress });
+  if (!key) return [];
+  const assetAddress = viem.getAddress(key);
+  const [v1Vaults, v2Vaults] = await Promise.all([
+    fetchMorphoVaultsForAssetAddress({ chainId: args.chainId, assetAddress }),
+    fetchMorphoVaultV2sForAssetAddress({ chainId: args.chainId, assetAddress })
+  ]);
+  const byAddr = /* @__PURE__ */ new Map();
+  for (const v of v1Vaults) {
+    const row = earnRowFromVault({
+      chainId: args.chainId,
+      address: v.address,
+      symbol: v.symbol,
+      name: v.name,
+      asset: v.asset,
+      apy: v.state?.apy,
+      netApy: v.state?.netApy,
+      performanceFee: v.state?.fee,
+      managementFee: null,
+      totalAssetsUsd: v.state?.totalAssetsUsd,
+      liquidityUsd: v.liquidity?.usd,
+      underlyingDecimals: args.underlyingDecimals,
+      suppliedAssetSymbol: args.suppliedAssetSymbol,
+      vaultGeneration: "v1"
+    });
+    if (row) byAddr.set(row.vaultAddress.toLowerCase(), row);
+  }
+  for (const v of v2Vaults) {
+    const row = earnRowFromVault({
+      chainId: args.chainId,
+      address: v.address,
+      symbol: v.symbol,
+      name: v.name,
+      asset: v.asset,
+      apy: v.apy,
+      netApy: v.netApy,
+      performanceFee: v.performanceFee,
+      managementFee: v.managementFee,
+      totalAssetsUsd: v.totalAssetsUsd,
+      liquidityUsd: v.liquidityUsd,
+      underlyingDecimals: args.underlyingDecimals,
+      suppliedAssetSymbol: args.suppliedAssetSymbol,
+      vaultGeneration: "v2"
+    });
+    if (row) byAddr.set(row.vaultAddress.toLowerCase(), row);
+  }
+  return sortEarnRowsByTvl([...byAddr.values()]);
+}
+var chainAssetCache = /* @__PURE__ */ new Map();
+async function ensureMorphoChainAssetCache(chainId) {
+  const hit = chainAssetCache.get(chainId);
+  if (hit) return hit;
+  const modes = /* @__PURE__ */ new Map();
+  const [v1Vaults, v2Assets] = await Promise.all([
+    fetchMorphoVaultsForChain(chainId, 300),
+    fetchAllMorphoVaultV2AssetAddresses(chainId)
+  ]);
+  for (const v of v1Vaults) {
+    const a = (v.asset?.address ?? "").trim();
+    if (!viem.isAddress(a)) continue;
+    const k = viem.getAddress(a).toLowerCase();
+    const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+    prev.earn = true;
+    modes.set(k, prev);
+  }
+  for (const k of v2Assets) {
+    const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+    prev.earn = true;
+    modes.set(k, prev);
+  }
+  const marketsD = await morphoGql(
+    `
+    query MorphoMarketsAssets($chainId: Int!) {
+      markets(first: 500, where: { chainId_in: [$chainId] }) {
+        items {
+          loanAsset { address }
+          collateralAsset { address }
+        }
+      }
+    }
+  `,
+    { chainId }
+  );
+  for (const m of marketsD.markets?.items ?? []) {
+    const loanAddr = (m.loanAsset?.address ?? "").trim();
+    const colAddr = (m.collateralAsset?.address ?? "").trim();
+    if (viem.isAddress(loanAddr)) {
+      const k = viem.getAddress(loanAddr).toLowerCase();
+      const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+      prev.borrow = true;
+      modes.set(k, prev);
+    }
+    if (viem.isAddress(colAddr)) {
+      const k = viem.getAddress(colAddr).toLowerCase();
+      const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+      prev.collateral = true;
+      modes.set(k, prev);
+    }
+  }
+  const cache = { modesByUnderlying: modes, nativeWrapped: null };
+  chainAssetCache.set(chainId, cache);
+  return cache;
+}
+async function morphoFetchEarnVaultsSummary(args) {
+  const vaults = await searchMorphoListedEarnVaults({
+    chainId: args.chainId,
+    underlying: args.underlying?.trim() || void 0,
+    query: args.query?.trim() || void 0,
+    limit: args.limit
+  });
+  return { vaults };
+}
+async function morphoResolveListedEarnVaultByAddress(args) {
+  const addr = args.vaultAddress.trim();
+  if (!viem.isAddress(addr)) return null;
+  const rows = await searchMorphoListedEarnVaults({
+    chainId: args.chainId,
+    query: viem.getAddress(addr),
+    limit: 5
+  });
+  const hit = rows.find((r) => r.vaultAddress.toLowerCase() === viem.getAddress(addr).toLowerCase());
+  return hit ?? null;
+}
+function lltvToPctLabel(lltv) {
+  try {
+    const wad = BigInt(lltv);
+    const pct = Number(wad) / 1e16;
+    if (!Number.isFinite(pct)) return "\u2014";
+    return `${pct.toFixed(1)}%`;
+  } catch {
+    return "\u2014";
+  }
+}
+async function fetchMorphoMarketsForChain(chainId, first = 200) {
+  const d = await morphoGql(
+    `
+    query MorphoMarkets($chainId: Int!, $first: Int!) {
+      markets(first: $first, where: { chainId_in: [$chainId] }, orderBy: BorrowAssetsUsd, orderDirection: Desc) {
+        items {
+          marketId
+          loanAsset { address symbol decimals price { usd } }
+          collateralAsset { address symbol decimals price { usd } }
+          lltv
+          oracle { address }
+          irmAddress
+          morphoBlue { address }
+          state {
+            supplyApy borrowApy netSupplyApy netBorrowApy
+            supplyAssetsUsd borrowAssetsUsd collateralAssetsUsd utilization
+            rewards { supplyApr borrowApr asset { address symbol } }
+          }
+        }
+      }
+    }
+  `,
+    { chainId, first }
+  );
+  return d.markets?.items ?? [];
+}
+function morphoMarketToBorrowRow(m) {
+  if (!m.marketId || !m.morphoBlue?.address) return null;
+  const loan = m.loanAsset;
+  const col = m.collateralAsset;
+  if (!viem.isAddress(loan?.address ?? "") || !viem.isAddress(col?.address ?? "")) return null;
+  const loanSym = (loan.symbol ?? "LOAN").trim();
+  const colSym = (col.symbol ?? "COL").trim();
+  return {
+    marketId: m.marketId,
+    morphoBlueAddress: viem.getAddress(m.morphoBlue.address),
+    loanAssetAddress: viem.getAddress(loan.address),
+    loanAssetSymbol: loanSym,
+    loanAssetDecimals: loan.decimals ?? 18,
+    collateralAssetAddress: viem.getAddress(col.address),
+    collateralAssetSymbol: colSym,
+    collateralAssetDecimals: col.decimals ?? 18,
+    borrowApyLabel: formatMorphoApyPct(m.state?.borrowApy),
+    supplyApyLabel: formatMorphoApyPct(m.state?.supplyApy),
+    borrowAssetsUsdLabel: formatMorphoUsd(m.state?.borrowAssetsUsd),
+    lltvLabel: lltvToPctLabel(m.lltv),
+    marketLabel: `${colSym}/${loanSym}`
+  };
+}
+async function fetchMorphoBorrowMarketsForCollateral(args) {
+  const key = morphoKeyForAssetRow({ contractAddress: args.collateralAddress });
+  if (!key) return [];
+  const markets = await fetchMorphoMarketsForChain(args.chainId, 300);
+  const out = [];
+  for (const m of markets) {
+    const col = (m.collateralAsset?.address ?? "").trim().toLowerCase();
+    if (!col || col !== key) continue;
+    const row = morphoMarketToBorrowRow(m);
+    if (row) out.push(row);
+  }
+  return out;
+}
+async function fetchMorphoBorrowMarketsForLoan(args) {
+  const key = morphoKeyForAssetRow({ contractAddress: args.loanAddress });
+  if (!key) return [];
+  const markets = await fetchMorphoMarketsForChain(args.chainId, 300);
+  const out = [];
+  for (const m of markets) {
+    const loan = (m.loanAsset?.address ?? "").trim().toLowerCase();
+    if (!loan || loan !== key) continue;
+    const row = morphoMarketToBorrowRow(m);
+    if (row) out.push(row);
+  }
+  return out;
+}
+function formatMorphoPositionAssets(raw, decimals) {
+  if (raw == null) return "0";
+  const s = String(raw).trim();
+  if (!s || s === "0") return "0";
+  try {
+    return viem.formatUnits(BigInt(s), decimals);
+  } catch {
+    return s;
+  }
+}
+function isZeroPositionAmount(raw) {
+  if (raw == null) return true;
+  const s = String(raw).trim();
+  return !s || s === "0" || s === "0.0";
+}
+async function fetchMorphoUserVaultPositions(args) {
+  const user = args.user.trim();
+  if (!viem.isAddress(user)) return [];
+  const d = await morphoGql(
+    `
+    query MorphoUserVaultPositions($address: String!, $chainId: Int!) {
+      userByAddress(address: $address, chainId: $chainId) {
+        vaultPositions {
+          vault { address symbol asset { symbol decimals } }
+          state { assets assetsUsd shares }
+        }
+        vaultV2Positions {
+          vault { address symbol asset { symbol decimals } }
+          assets assetsUsd shares
+        }
+      }
+    }
+  `,
+    { address: viem.getAddress(user), chainId: args.chainId }
+  );
+  const byVault = /* @__PURE__ */ new Map();
+  for (const p of d.userByAddress?.vaultPositions ?? []) {
+    const vaultAddr = (p.vault?.address ?? "").trim();
+    if (!viem.isAddress(vaultAddr)) continue;
+    const rawAssets = p.state?.assets;
+    if (isZeroPositionAmount(rawAssets)) continue;
+    const decimals = p.vault?.asset?.decimals ?? 18;
+    const vaultAddress = viem.getAddress(vaultAddr);
+    byVault.set(vaultAddress.toLowerCase(), {
+      vaultAddress,
+      vaultSymbol: (p.vault?.symbol ?? "Vault").trim(),
+      underlyingSymbol: (p.vault?.asset?.symbol ?? "").trim() || "\u2014",
+      assetsHuman: formatMorphoPositionAssets(rawAssets, decimals),
+      assetsUsdLabel: formatMorphoUsd(p.state?.assetsUsd),
+      shares: String(p.state?.shares ?? "0").trim()
+    });
+  }
+  for (const p of d.userByAddress?.vaultV2Positions ?? []) {
+    const vaultAddr = (p.vault?.address ?? "").trim();
+    if (!viem.isAddress(vaultAddr)) continue;
+    const rawAssets = p.assets;
+    if (isZeroPositionAmount(rawAssets)) continue;
+    const decimals = p.vault?.asset?.decimals ?? 18;
+    const vaultAddress = viem.getAddress(vaultAddr);
+    byVault.set(vaultAddress.toLowerCase(), {
+      vaultAddress,
+      vaultSymbol: (p.vault?.symbol ?? p.vault?.asset?.symbol ?? "Vault").trim() || "Vault",
+      underlyingSymbol: (p.vault?.asset?.symbol ?? "").trim() || "\u2014",
+      assetsHuman: formatMorphoPositionAssets(rawAssets, decimals),
+      assetsUsdLabel: formatMorphoUsd(p.assetsUsd),
+      shares: String(p.shares ?? "0").trim()
+    });
+  }
+  return [...byVault.values()];
+}
+async function fetchMorphoUserBluePositions(args) {
+  const user = args.user.trim();
+  if (!viem.isAddress(user)) return [];
+  const d = await morphoGql(
+    `
+    query MorphoUserBluePositions($address: String!, $chainId: Int!) {
+      userByAddress(address: $address, chainId: $chainId) {
+        marketPositions {
+          healthFactor
+          market {
+            marketId
+            loanAsset { address symbol decimals }
+            collateralAsset { address symbol decimals }
+            lltv
+            oracle { address }
+            irmAddress
+            morphoBlue { address }
+            state { borrowApy supplyApy borrowAssetsUsd }
+          }
+          state { collateral borrowAssets }
+        }
+      }
+    }
+  `,
+    { address: viem.getAddress(user), chainId: args.chainId }
+  );
+  const out = [];
+  for (const p of d.userByAddress?.marketPositions ?? []) {
+    const borrow = (p.state?.borrowAssets ?? "0").trim();
+    const collateral = (p.state?.collateral ?? "0").trim();
+    if ((borrow === "0" || borrow === "0.0") && (collateral === "0" || collateral === "0.0")) continue;
+    const borrowMarket = morphoMarketToBorrowRow(p.market);
+    if (!borrowMarket) continue;
+    const hf = p.healthFactor;
+    out.push({
+      marketId: p.market.marketId,
+      marketLabel: borrowMarket.marketLabel,
+      loanAssetSymbol: borrowMarket.loanAssetSymbol,
+      collateralAssetSymbol: borrowMarket.collateralAssetSymbol,
+      collateralHuman: collateral || "0",
+      borrowHuman: borrow || "0",
+      healthFactorLabel: hf != null && Number.isFinite(hf) ? hf.toFixed(2) : "\u2014",
+      borrowMarket
+    });
+  }
+  return out;
+}
+async function fetchMorphoUserPortfolioUsd(args) {
+  const user = args.user.trim();
+  if (!viem.isAddress(user)) return { vaultUsd: 0, borrowCollateralUsd: 0, totalUsd: 0 };
+  const d = await morphoGql(
+    `
+    query MorphoUserPortfolio($address: String!, $chainId: Int!) {
+      userByAddress(address: $address, chainId: $chainId) {
+        vaultPositions { state { assetsUsd } }
+        vaultV2Positions { assetsUsd }
+        marketPositions { state { collateralUsd borrowAssetsUsd } }
+      }
+    }
+  `,
+    { address: viem.getAddress(user), chainId: args.chainId }
+  );
+  let vaultUsd = 0;
+  let borrowCollateralUsd = 0;
+  for (const v of d.userByAddress?.vaultPositions ?? []) {
+    const n = v.state?.assetsUsd;
+    if (n != null && Number.isFinite(n)) vaultUsd += n;
+  }
+  for (const v of d.userByAddress?.vaultV2Positions ?? []) {
+    const n = v.assetsUsd;
+    if (n != null && Number.isFinite(n)) vaultUsd += n;
+  }
+  for (const m of d.userByAddress?.marketPositions ?? []) {
+    const n = m.state?.collateralUsd;
+    if (n != null && Number.isFinite(n)) borrowCollateralUsd += n;
+  }
+  return { vaultUsd, borrowCollateralUsd, totalUsd: vaultUsd + borrowCollateralUsd };
+}
+function formatMorphoMarketApySummary(apy) {
+  return formatMorphoApyPct(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.";
+async function fetchMorphoMidnightIntents(_args) {
+  return [];
+}
+var erc4626Abi = viem.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 = viem.defineChain({
+    id: args.chainId,
+    name: "MorphoVault",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const vault = viem.getAddress(args.vault);
+  const assetAddr = await publicClient.readContract({
+    address: vault,
+    abi: erc4626Abi,
+    functionName: "asset"
+  });
+  const d = await publicClient.readContract({
+    address: viem.getAddress(assetAddr),
+    abi: viem.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 = viem.defineChain({
+    id: args.chainId,
+    name: "MorphoVault",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  return publicClient.readContract({
+    address: viem.getAddress(args.vault),
+    abi: erc4626Abi,
+    functionName: "maxWithdraw",
+    args: [viem.getAddress(args.owner)]
+  });
+}
+var morphoBlueAbi = viem.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 = viem.parseAbi(["function price() view returns (uint256)"]);
+var WAD = 10n ** 18n;
+var ORACLE_PRICE_SCALE = 10n ** 36n;
+async function previewMorphoBlueHealthAfterCollateralWithdraw(args) {
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "MorphoBlue",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const morpho = viem.getAddress(args.morphoBlue);
+  const user = viem.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 = viem.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 };
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = purposeText.trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = continuumNodeSdk.getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return continuumNodeSdk.gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = viem.defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
+  const feeParams = await continuumNodeSdk.fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
+  const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
+  const executor = viem.getAddress(executorAddress);
+  const baseNonce = await publicClient.getTransactionCount({ address: executor, blockTag: "pending" });
+  const legs = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    if (args.estimateGasForStep) {
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient, executor });
+    } else {
+      try {
+        estimatedGas = await publicClient.estimateGas({
+          to: step.to,
+          data: step.data,
+          value: step.value,
+          account: executor
+        });
+      } catch {
+        estimatedGas = step.fallbackGas ?? 100000n;
+      }
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? continuumNodeSdk.gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = viem.parseGwei(continuumNodeSdk.gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = viem.serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = continuumNodeSdk.proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? viem.parseGwei(continuumNodeSdk.gweiToDecimalString(effectivePriorityFeeGwei)) : viem.parseGwei("1");
+      let maxFeePerGas = viem.parseGwei(continuumNodeSdk.gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = continuumNodeSdk.alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = viem.serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? continuumNodeSdk.proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = viem.keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  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;
+var wethDepositAbi = viem.parseAbi(["function deposit() payable"]);
+var erc20AllowanceAbi = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)"
+]);
+var erc20ApproveAbi = viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var vaultDepositAbi = viem.parseAbi([
+  "function deposit(uint256 assets, address onBehalf) returns (uint256 shares)"
+]);
+async function buildEvmMultisignBodyMorphoVaultDepositBatch(args) {
+  const asset = viem.getAddress(args.underlying);
+  const vault = viem.getAddress(args.vault);
+  const weth = viem.getAddress(args.nativeWrapped);
+  const executor = viem.getAddress(args.executorAddress);
+  const onBehalf = viem.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 = viem.defineChain({
+    id: args.chainId,
+    name: "MorphoVaultDeposit",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const dec = await fetchMorphoVaultAssetDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, vault });
+  const amountWei = viem.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 = viem.encodeFunctionData({ abi: wethDepositAbi, functionName: "deposit" });
+    steps.push({ kind: "weth_deposit", to: weth, data: wethData, value: amountWei });
+  }
+  const spendToken = args.isNativeIn ? weth : asset;
+  const currentAllowance = await publicClient.readContract({
+    address: spendToken,
+    abi: erc20AllowanceAbi,
+    functionName: "allowance",
+    args: [executor, vault]
+  });
+  if (currentAllowance < amountWei) {
+    if (currentAllowance > 0n) {
+      steps.push({
+        kind: "approve",
+        to: spendToken,
+        data: viem.encodeFunctionData({ abi: erc20ApproveAbi, functionName: "approve", args: [vault, 0n] }),
+        value: 0n
+      });
+    }
+    steps.push({
+      kind: "approve",
+      to: spendToken,
+      data: viem.encodeFunctionData({ abi: erc20ApproveAbi, functionName: "approve", args: [vault, amountWei] }),
+      value: 0n
+    });
+  }
+  const depositData = viem.encodeFunctionData({
+    abi: vaultDepositAbi,
+    functionName: "deposit",
+    args: [amountWei, onBehalf]
+  });
+  steps.push({ kind: "vault_deposit", to: vault, data: depositData, value: 0n });
+  const vaultLabel = (args.vaultMarketLabel ?? "").trim() || "Morpho vault";
+  const purposeSuffix = `Morpho: ${steps.length}-tx \u2014 VaultV2.deposit (${args.amountHuman} underlying) into "${vaultLabel}".`;
+  const evmSteps = steps.map((s) => ({
+    to: s.to,
+    data: s.data,
+    value: s.value,
+    fallbackGas: s.kind === "weth_deposit" ? MORPHO_WETH_DEPOSIT_FALLBACK : s.kind === "approve" ? MORPHO_ERC20_APPROVE_FALLBACK : MORPHO_VAULT_DEPOSIT_FALLBACK_GAS
+  }));
+  const firstDataNo0x = steps[0].data.startsWith("0x") ? steps[0].data.slice(2) : steps[0].data;
+  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,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: vault,
+    buildBatchMeta: ({ gasLimit }) => ({
+      signatureText: JSON.stringify({
+        kind: "Morpho",
+        name: "VaultV2.deposit",
+        vault,
+        onBehalf,
+        vaultMarket: vaultLabel,
+        amountHuman: args.amountHuman
+      }),
+      evm: { type: "morpho_vault_deposit", version: 1, chainId: String(args.chainId) },
+      morpho: {
+        vaultMarket: vaultLabel,
+        amountHuman: args.amountHuman,
+        vault,
+        onBehalf,
+        gasBuildDeposit: { baseGasUnits: gasLimit.toString() }
+      }
+    })
+  });
+}
+var MORPHO_VAULT_WITHDRAW_FALLBACK_GAS = 900000n;
+var vaultWithdrawAbi = viem.parseAbi([
+  "function withdraw(uint256 assets, address receiver, address onBehalf) returns (uint256 shares)"
+]);
+async function buildEvmMultisignBodyMorphoVaultWithdraw(args) {
+  const vault = viem.getAddress(args.vault);
+  const receiver = viem.getAddress(args.receiver);
+  const shareOwner = viem.getAddress(args.vaultShareOwner ?? args.receiver);
+  const executor = viem.getAddress(args.executorAddress);
+  const dec = await fetchMorphoVaultAssetDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, vault });
+  const amountWei = viem.parseUnits(args.amountHuman, dec);
+  if (amountWei === 0n) throw new Error("Withdraw amount is zero after converting with token decimals.");
+  const maxW = await fetchMorphoVaultMaxWithdrawWei({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    vault,
+    owner: shareOwner
+  });
+  if (amountWei > maxW) {
+    throw new Error("Withdraw amount exceeds maxWithdraw for this vault. Try a smaller amount.");
+  }
+  const withdrawData = viem.encodeFunctionData({
+    abi: vaultWithdrawAbi,
+    functionName: "withdraw",
+    args: [amountWei, receiver, shareOwner]
+  });
+  const vaultLabel = (args.vaultMarketLabel ?? "").trim() || "Morpho vault";
+  const purposeSuffix = `Morpho: 1-tx \u2014 VaultV2.withdraw (${args.amountHuman} underlying) from "${vaultLabel}".`;
+  const evmSteps = [
+    { to: vault, data: withdrawData, value: 0n, fallbackGas: MORPHO_VAULT_WITHDRAW_FALLBACK_GAS }
+  ];
+  const firstDataNo0x = withdrawData.startsWith("0x") ? withdrawData.slice(2) : withdrawData;
+  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,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: vault,
+    buildBatchMeta: ({ gasLimit }) => ({
+      signatureText: JSON.stringify({
+        kind: "Morpho",
+        name: "VaultV2.withdraw",
+        vault,
+        receiver,
+        owner: shareOwner,
+        vaultMarket: vaultLabel,
+        amountHuman: args.amountHuman
+      }),
+      evm: { type: "morpho_vault_withdraw", version: 1, chainId: String(args.chainId) },
+      morpho: {
+        vaultMarket: vaultLabel,
+        amountHuman: args.amountHuman,
+        vault,
+        owner: shareOwner,
+        gasBuildWithdraw: { baseGasUnits: gasLimit.toString() }
+      }
+    })
+  });
+}
+var MORPHO_BLUE_COLLATERAL_DEPOSIT_FALLBACK_GAS = 1200000n;
+var MORPHO_BLUE_BORROW_FALLBACK_GAS = 1100000n;
+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 = viem.parseAbi(["function deposit() payable"]);
+var erc20AllowanceAbi2 = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+]);
+var erc20ApproveAbi2 = viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var morphoBlueAbi2 = viem.parseAbi([
+  "function supplyCollateral((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv), uint256 assets, address onBehalf, bytes data)",
+  "function borrow((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv), uint256 assets, uint256 shares, address onBehalf, address receiver)",
+  "function repay((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv), uint256 assets, uint256 shares, address onBehalf, bytes data)",
+  "function withdrawCollateral((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv), uint256 assets, address onBehalf, address receiver)"
+]);
+function marketParamsTuple(p) {
+  return {
+    loanToken: p.loanToken,
+    collateralToken: p.collateralToken,
+    oracle: p.oracle,
+    irm: p.irm,
+    lltv: p.lltv
+  };
+}
+async function readTokenDecimals(args) {
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "MorphoToken",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const d = await publicClient.readContract({
+    address: args.token,
+    abi: erc20AllowanceAbi2,
+    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 = viem.getAddress(args.nativeWrapped);
+    if (spendToken.toLowerCase() !== weth.toLowerCase()) {
+      throw new Error("Native collateral path: token must match wrapped native.");
+    }
+    const wethData = viem.encodeFunctionData({ abi: wethDepositAbi2, functionName: "deposit" });
+    steps.push({ kind: "weth_deposit", to: weth, data: wethData, value: args.amountWei });
+    spendToken = weth;
+  }
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "MorphoApprove",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const currentAllowance = await publicClient.readContract({
+    address: spendToken,
+    abi: erc20AllowanceAbi2,
+    functionName: "allowance",
+    args: [args.executor, args.spender]
+  });
+  if (currentAllowance < args.amountWei) {
+    if (currentAllowance > 0n) {
+      steps.push({
+        kind: "approve",
+        to: spendToken,
+        data: viem.encodeFunctionData({ abi: erc20ApproveAbi2, functionName: "approve", args: [args.spender, 0n] }),
+        value: 0n
+      });
+    }
+    steps.push({
+      kind: "approve",
+      to: spendToken,
+      data: viem.encodeFunctionData({ abi: erc20ApproveAbi2, functionName: "approve", args: [args.spender, args.amountWei] }),
+      value: 0n
+    });
+  }
+  return steps;
+}
+function stepsToEvm(steps, final) {
+  return [
+    ...steps.map((s) => ({
+      to: s.to,
+      data: s.data,
+      value: s.value,
+      fallbackGas: s.kind === "weth_deposit" ? MORPHO_WETH_DEPOSIT_FALLBACK2 : MORPHO_ERC20_APPROVE_FALLBACK2
+    })),
+    final
+  ];
+}
+async function buildEvmMultisignBodyMorphoBlueSupplyCollateralBatch(args) {
+  const morphoBlue = viem.getAddress(args.morphoBlue);
+  const onBehalf = viem.getAddress(args.onBehalf);
+  const executor = viem.getAddress(args.executorAddress);
+  const collateral = viem.getAddress(args.collateralToken);
+  const dec = await readTokenDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: collateral });
+  const amountWei = viem.parseUnits(args.amountHuman, dec);
+  if (amountWei === 0n) throw new Error("Collateral amount is zero.");
+  const approveSteps = await buildApproveSteps({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    token: collateral,
+    spender: morphoBlue,
+    amountWei,
+    executor,
+    isNativeIn: args.isNativeIn,
+    nativeWrapped: args.nativeWrapped
+  });
+  const supplyData = viem.encodeFunctionData({
+    abi: morphoBlueAbi2,
+    functionName: "supplyCollateral",
+    args: [marketParamsTuple(args.marketParams), amountWei, onBehalf, "0x"]
+  });
+  const marketLabel = (args.marketLabel ?? "").trim() || "Morpho Blue market";
+  const evmSteps = stepsToEvm(approveSteps, {
+    to: morphoBlue,
+    data: supplyData,
+    value: 0n,
+    fallbackGas: MORPHO_BLUE_COLLATERAL_DEPOSIT_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 Blue: supplyCollateral (${args.amountHuman}) for "${marketLabel}".`,
+    firstMsgRawNo0x: evmSteps[0].data.slice(2),
+    destinationAddress: morphoBlue,
+    buildBatchMeta: ({ gasLimit }) => ({
+      signatureText: JSON.stringify({ kind: "MorphoBlue", name: "supplyCollateral", marketLabel, amountHuman: args.amountHuman }),
+      evm: { type: "morpho_blue_supply_collateral", version: 1, chainId: String(args.chainId) },
+      morpho: { marketLabel, amountHuman: args.amountHuman, gasBuild: { baseGasUnits: gasLimit.toString() } }
+    })
+  });
+}
+async function buildEvmMultisignBodyMorphoBlueBorrowBatch(args) {
+  const morphoBlue = viem.getAddress(args.morphoBlue);
+  const onBehalf = viem.getAddress(args.onBehalf);
+  const receiver = viem.getAddress(args.receiver);
+  const executor = viem.getAddress(args.executorAddress);
+  const loan = viem.getAddress(args.loanToken);
+  const dec = await readTokenDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: loan });
+  const amountWei = viem.parseUnits(args.amountHuman, dec);
+  if (amountWei === 0n) throw new Error("Borrow amount is zero.");
+  const borrowData = viem.encodeFunctionData({
+    abi: morphoBlueAbi2,
+    functionName: "borrow",
+    args: [marketParamsTuple(args.marketParams), amountWei, 0n, onBehalf, receiver]
+  });
+  const marketLabel = (args.marketLabel ?? "").trim() || "Morpho Blue market";
+  const evmSteps = [
+    { to: morphoBlue, data: borrowData, value: 0n, fallbackGas: MORPHO_BLUE_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 Blue: borrow (${args.amountHuman}) from "${marketLabel}".`,
+    firstMsgRawNo0x: borrowData.slice(2),
+    destinationAddress: morphoBlue,
+    buildBatchMeta: ({ gasLimit }) => ({
+      signatureText: JSON.stringify({ kind: "MorphoBlue", name: "borrow", marketLabel, amountHuman: args.amountHuman }),
+      evm: { type: "morpho_blue_borrow", version: 1, chainId: String(args.chainId) },
+      morpho: { marketLabel, amountHuman: args.amountHuman, gasBuild: { baseGasUnits: gasLimit.toString() } }
+    })
+  });
+}
+async function buildEvmMultisignBodyMorphoBlueRepayBatch(args) {
+  const morphoBlue = viem.getAddress(args.morphoBlue);
+  const onBehalf = viem.getAddress(args.onBehalf);
+  const executor = viem.getAddress(args.executorAddress);
+  const loan = viem.getAddress(args.loanToken);
+  const dec = await readTokenDecimals({ rpcUrl: args.rpcUrl, chainId: args.chainId, token: loan });
+  const amountWei = viem.parseUnits(args.amountHuman, dec);
+  if (amountWei === 0n) throw new Error("Repay amount is zero.");
+  const approveSteps = await buildApproveSteps({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    token: loan,
+    spender: morphoBlue,
+    amountWei,
+    executor
+  });
+  const repayData = viem.encodeFunctionData({
+    abi: morphoBlueAbi2,
+    functionName: "repay",
+    args: [marketParamsTuple(args.marketParams), amountWei, 0n, onBehalf, "0x"]
+  });
+  const marketLabel = (args.marketLabel ?? "").trim() || "Morpho Blue market";
+  const evmSteps = stepsToEvm(approveSteps, {
+    to: morphoBlue,
+    data: repayData,
+    value: 0n,
+    fallbackGas: MORPHO_BLUE_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 Blue: repay (${args.amountHuman}) for "${marketLabel}".`,
+    firstMsgRawNo0x: evmSteps[0].data.slice(2),
+    destinationAddress: morphoBlue,
+    buildBatchMeta: ({ gasLimit }) => ({
+      signatureText: JSON.stringify({ kind: "MorphoBlue", name: "repay", marketLabel, amountHuman: args.amountHuman }),
+      evm: { type: "morpho_blue_repay", version: 1, chainId: String(args.chainId) },
+      morpho: { marketLabel, amountHuman: args.amountHuman, gasBuild: { baseGasUnits: gasLimit.toString() } }
+    })
+  });
+}
+async function buildEvmMultisignBodyMorphoBlueWithdrawCollateralBatch(args) {
+  const morphoBlue = viem.getAddress(args.morphoBlue);
+  const onBehalf = viem.getAddress(args.onBehalf);
+  const receiver = viem.getAddress(args.receiver);
+  const executor = viem.getAddress(args.executorAddress);
+  const amountWei = viem.parseUnits(args.amountHuman, args.collateralDecimals);
+  if (amountWei === 0n) throw new Error("Collateral withdraw amount is zero.");
+  const withdrawData = viem.encodeFunctionData({
+    abi: morphoBlueAbi2,
+    functionName: "withdrawCollateral",
+    args: [marketParamsTuple(args.marketParams), amountWei, onBehalf, receiver]
+  });
+  const marketLabel = (args.marketLabel ?? "").trim() || "Morpho Blue market";
+  const evmSteps = [
+    { to: morphoBlue, data: withdrawData, value: 0n, fallbackGas: MORPHO_BLUE_COLLATERAL_WITHDRAW_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 Blue: withdrawCollateral (${args.amountHuman}) from "${marketLabel}".`,
+    firstMsgRawNo0x: withdrawData.slice(2),
+    destinationAddress: morphoBlue,
+    buildBatchMeta: ({ gasLimit }) => ({
+      signatureText: JSON.stringify({ kind: "MorphoBlue", name: "withdrawCollateral", marketLabel, amountHuman: args.amountHuman }),
+      evm: { type: "morpho_blue_withdraw_collateral", version: 1, chainId: String(args.chainId) },
+      morpho: { marketLabel, amountHuman: args.amountHuman, gasBuild: { baseGasUnits: gasLimit.toString() } }
+    })
+  });
+}
+var MORPHO_MERKL_CLAIM_FALLBACK_GAS = 500000n;
+async function buildEvmMultisignBodyMorphoMerklDistributorClaim(args) {
+  const to = viem.getAddress(args.to);
+  const executor = viem.getAddress(args.executorAddress);
+  const firstDataNo0x = args.data.startsWith("0x") ? args.data.slice(2) : args.data;
+  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: [{ to, data: args.data, value: args.valueWei, fallbackGas: MORPHO_MERKL_CLAIM_FALLBACK_GAS }],
+    purposeSuffix: `Morpho: 1-tx \u2014 Merkl distributor claim (${args.claimLeafCount} reward(s)).`,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: to,
+    buildBatchMeta: ({ gasLimit }) => ({
+      signatureText: JSON.stringify({
+        kind: "Morpho",
+        name: "Merkl Distributor claim",
+        claimLeafCount: args.claimLeafCount,
+        chainId: args.chainId
+      }),
+      evm: { type: "morpho_merkl_distributor_claim", version: 1, chainId: String(args.chainId) },
+      morpho: { step: "merkl_distributor_claim", claimLeafCount: args.claimLeafCount, gasBuildClaim: { baseGasUnits: gasLimit.toString() } }
+    })
+  });
+}
+
+// src/protocols/evm/morpho/index.ts
+var MORPHO_PROTOCOL_ID = "morpho";
+var morphoProtocolModule = {
+  id: MORPHO_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    return ctx.chainCategory === "evm";
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    { id: "morpho.fetch-earn-vaults", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Search Morpho-listed earn vaults by asset or name", commonParams: [], params: {} },
+    { id: "morpho.vault-deposit", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Deposit into Morpho-listed earn vault (V1 or V2)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.vault-withdraw", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw from Morpho earn vault (V1 or V2)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.blue-collateral-deposit", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Supply collateral to Morpho Blue market", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.blue-borrow", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Borrow from Morpho Blue market", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { 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: {} }
+  ]
+};
+registerProtocolModule(morphoProtocolModule);
+
+exports.MORPHO_BLUE_BORROW_FALLBACK_GAS = MORPHO_BLUE_BORROW_FALLBACK_GAS;
+exports.MORPHO_BLUE_COLLATERAL_DEPOSIT_FALLBACK_GAS = MORPHO_BLUE_COLLATERAL_DEPOSIT_FALLBACK_GAS;
+exports.MORPHO_BLUE_COLLATERAL_WITHDRAW_FALLBACK_GAS = MORPHO_BLUE_COLLATERAL_WITHDRAW_FALLBACK_GAS;
+exports.MORPHO_BLUE_REPAY_FALLBACK_GAS = MORPHO_BLUE_REPAY_FALLBACK_GAS;
+exports.MORPHO_GRAPHQL_URL = MORPHO_GRAPHQL_URL;
+exports.MORPHO_MIDNIGHT_UNAVAILABLE_MESSAGE = MORPHO_MIDNIGHT_UNAVAILABLE_MESSAGE;
+exports.MORPHO_PROTOCOL_ID = MORPHO_PROTOCOL_ID;
+exports.MORPHO_VAULT_DEPOSIT_FALLBACK_GAS = MORPHO_VAULT_DEPOSIT_FALLBACK_GAS;
+exports.MORPHO_VAULT_WITHDRAW_FALLBACK_GAS = MORPHO_VAULT_WITHDRAW_FALLBACK_GAS;
+exports.buildEvmMultisignBodyMorphoBlueBorrowBatch = buildEvmMultisignBodyMorphoBlueBorrowBatch;
+exports.buildEvmMultisignBodyMorphoBlueRepayBatch = buildEvmMultisignBodyMorphoBlueRepayBatch;
+exports.buildEvmMultisignBodyMorphoBlueSupplyCollateralBatch = buildEvmMultisignBodyMorphoBlueSupplyCollateralBatch;
+exports.buildEvmMultisignBodyMorphoBlueWithdrawCollateralBatch = buildEvmMultisignBodyMorphoBlueWithdrawCollateralBatch;
+exports.buildEvmMultisignBodyMorphoMerklDistributorClaim = buildEvmMultisignBodyMorphoMerklDistributorClaim;
+exports.buildEvmMultisignBodyMorphoVaultDepositBatch = buildEvmMultisignBodyMorphoVaultDepositBatch;
+exports.buildEvmMultisignBodyMorphoVaultWithdraw = buildEvmMultisignBodyMorphoVaultWithdraw;
+exports.emptyMorphoEarnVaultDetailFields = emptyMorphoEarnVaultDetailFields;
+exports.enrichMorphoEarnOfferingRows = enrichMorphoEarnOfferingRows;
+exports.enrichMorphoEarnOfferingRowsForAgent = enrichMorphoEarnOfferingRowsForAgent;
+exports.ensureMorphoChainAssetCache = ensureMorphoChainAssetCache;
+exports.fetchMorphoBorrowMarketsForCollateral = fetchMorphoBorrowMarketsForCollateral;
+exports.fetchMorphoBorrowMarketsForLoan = fetchMorphoBorrowMarketsForLoan;
+exports.fetchMorphoChains = fetchMorphoChains;
+exports.fetchMorphoEarnOfferingsForAsset = fetchMorphoEarnOfferingsForAsset;
+exports.fetchMorphoEarnVaultDetails = fetchMorphoEarnVaultDetails;
+exports.fetchMorphoMarketById = fetchMorphoMarketById;
+exports.fetchMorphoMarketsForChain = fetchMorphoMarketsForChain;
+exports.fetchMorphoMidnightIntents = fetchMorphoMidnightIntents;
+exports.fetchMorphoUserBluePositions = fetchMorphoUserBluePositions;
+exports.fetchMorphoUserPortfolioUsd = fetchMorphoUserPortfolioUsd;
+exports.fetchMorphoUserVaultPositions = fetchMorphoUserVaultPositions;
+exports.fetchMorphoVaultAssetDecimals = fetchMorphoVaultAssetDecimals;
+exports.fetchMorphoVaultByAddress = fetchMorphoVaultByAddress;
+exports.fetchMorphoVaultMaxWithdrawWei = fetchMorphoVaultMaxWithdrawWei;
+exports.fetchMorphoVaultV2sForChain = fetchMorphoVaultV2sForChain;
+exports.fetchMorphoVaultsForChain = fetchMorphoVaultsForChain;
+exports.formatMorphoApyPct = formatMorphoApyPct;
+exports.formatMorphoFeePct = formatMorphoFeePct;
+exports.formatMorphoMarketApySummary = formatMorphoMarketApySummary;
+exports.formatMorphoUsd = formatMorphoUsd;
+exports.isMorphoVaultListed = isMorphoVaultListed;
+exports.loadMorphoSupportedChainIds = loadMorphoSupportedChainIds;
+exports.marketParamsFromApiRow = marketParamsFromApiRow;
+exports.morphoEarnOfferingToDiscoveryRow = morphoEarnOfferingToDiscoveryRow;
+exports.morphoFetchEarnVaultsSummary = morphoFetchEarnVaultsSummary;
+exports.morphoGql = morphoGql;
+exports.morphoKeyForAssetRow = morphoKeyForAssetRow;
+exports.morphoMarketToBorrowRow = morphoMarketToBorrowRow;
+exports.morphoProtocolModule = morphoProtocolModule;
+exports.morphoResolveListedEarnVaultByAddress = morphoResolveListedEarnVaultByAddress;
+exports.previewMorphoBlueHealthAfterCollateralWithdraw = previewMorphoBlueHealthAfterCollateralWithdraw;
+exports.searchMorphoListedEarnVaults = searchMorphoListedEarnVaults;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map