@1delta/margin-fetcher 5.0.101 → 5.0.102

package/dist/index.js

@@ -10729,11 +10729,11 @@ async function resolveListaBrokers(chainId, marketKeys, getClient = getEvmClient
   const moolah = morphoPools()?.LISTA_DAO?.[chainId];
   const out = {};
   if (!moolah || marketKeys.length === 0) return out;
-  const cache6 = BROKER_CACHE[chainId] ??= {};
+  const cache7 = BROKER_CACHE[chainId] ??= {};
   const missing = [];
   for (const key3 of marketKeys) {
     const id = toBytes32MarketId(key3);
-    if (cache6[id] === void 0) missing.push(id);
+    if (cache7[id] === void 0) missing.push(id);
   }
   if (missing.length > 0) {
     try {
@@ -10749,7 +10749,7 @@ async function resolveListaBrokers(chainId, marketKeys, getClient = getEvmClient
       );
       results.forEach((addr4, i) => {
         if (addr4 === void 0) return;
-        cache6[missing[i]] = addr4.toLowerCase();
+        cache7[missing[i]] = addr4.toLowerCase();
       });
     } catch (e) {
       console.warn(
@@ -10760,7 +10760,7 @@ async function resolveListaBrokers(chainId, marketKeys, getClient = getEvmClient
   }
   for (const key3 of marketKeys) {
     const id = toBytes32MarketId(key3);
-    const broker = cache6[id];
+    const broker = cache7[id];
     if (broker && broker !== zeroAddress) out[id] = broker;
   }
   return out;
@@ -10788,7 +10788,7 @@ async function fetchListaFixedTerms(chainId, marketKeys, multicallRetry) {
         })),
         multicallRetry
       );
-      const cache6 = FIXED_TERMS_CACHE[chainId] ??= {};
+      const cache7 = FIXED_TERMS_CACHE[chainId] ??= {};
       results.forEach((raw, i) => {
         if (!raw) return;
         const id = ids[i];
@@ -10802,7 +10802,7 @@ async function fetchListaFixedTerms(chainId, marketKeys, multicallRetry) {
           };
         });
         out[id] = terms;
-        cache6[id] = terms;
+        cache7[id] = terms;
       });
     } catch (e) {
       console.warn(
@@ -12307,6 +12307,39 @@ function formatNr(n, d) {
   return Number(formatUnits(BigInt(n ?? 0), d));
 }
 
+// src/lending/public-data/morpho/unlisted.ts
+var MORPHO_UNLISTED_CHAINS = /* @__PURE__ */ new Set([
+  // Robinhood Chain. 189 of its 194 markets are unlisted and essentially all of
+  // them are Longbow — a curated Morpho Blue deployment (tokenized equities and
+  // RWAs against USDG) that Morpho's own frontend does not carry, so `listed`
+  // here says nothing about the market's quality. Enabled 2026-09-08 together
+  // with the three things a chain needs before it can be:
+  //   1. its collateral tokens in `token-lists` (wsNET was the last gap — the
+  //      collateral of the chain's LARGEST market), or the rows price at $0,
+  //   2. `lender-metadata`'s `SERVES_UNLISTED_CHAINS` carrying the same chain
+  //      id, so the markets get a NAME and an oracle roster (5 -> 188 rows),
+  //   3. a look at what the unlisted book actually holds — here 56 real
+  //      markets, $524k supplied / $351k borrowed, no runaway rates (the
+  //      highest borrow APR on the chain is 21.9 %).
+  // See LONGBOW.md.
+  "4663",
+  // World Chain. blue-api indexes it, but 0 of its 30 markets are listed —
+  // Morpho's frontend simply does not carry the chain, so `listed` says
+  // nothing about the book (the Longbow shape again). Looked at 2026-09-16:
+  // $59.5M supplied / $45.0M borrowed, of which the real two-sided markets are
+  // USDC/WBTC $3.9M, USDC/WETH $3.6M, WETH/WBTC $2.1M, USDC/WLD $1.6M and
+  // WETH/ezETH $1.1M at 0.1–4.6 % borrow APY; the $35.8M USDC/sdeUSD market is
+  // pinned at 100 % utilization (297,994 % APY, $0 liquid) and is exactly what
+  // `earn/rateSanity.ts` exists to drop. Token-list gaps on 480 at enablement:
+  // sdeUSD and ezETH (collateral of two markets) — those rows price at $0 with
+  // a blank LTV until token-lists carries them. `lender-metadata`'s
+  // `SERVES_UNLISTED_CHAINS` was updated in the same change.
+  "480"
+]);
+function morphoIncludesUnlisted(chainId) {
+  return MORPHO_UNLISTED_CHAINS.has(chainId);
+}
+
 // src/lending/public-data/morpho/convertPublic.ts
 function convertMarketsToMorphoResponse(response, chainId, additionalYields = {
   intrinsicYields: {},
@@ -12316,6 +12349,7 @@ function convertMarketsToMorphoResponse(response, chainId, additionalYields = {
   const data = {};
   const items = response?.markets?.items;
   if (!items) return data;
+  const listedFlagMeaningful = !morphoIncludesUnlisted(chainId);
   items.forEach((market) => {
     const {
       uniqueKey,
@@ -12480,7 +12514,7 @@ function convertMarketsToMorphoResponse(response, chainId, additionalYields = {
           irm: irmAddress,
           collateralAddress: collateralAssetAddress,
           loanAddress: loanAssetAddress,
-          isListed: whitelisted,
+          isListed: whitelisted || listedFlagMeaningful ? whitelisted : void 0,
           fee: state.fee,
           rateAtTarget: state?.rateAtTarget?.toString()
         }
@@ -12490,18 +12524,220 @@ function convertMarketsToMorphoResponse(response, chainId, additionalYields = {
   });
   return data;
 }
-var query = (first, skip, chainId, includeUnlisted = false) => `
+
+// src/lending/public-data/morpho/vaultFunded.ts
+var MORPHO_VAULT_FUNDED_MIN_USD = 1e4;
+var MORPHO_VAULT_FUNDED_MIN_VAULT_USD = 1e3;
+var BASE_URL = "https://blue-api.morpho.org/graphql";
+var V1_PAGE = 100;
+var V2_PAGE = 50;
+var MAX_PAGES = 20;
+var CACHE_TTL_MS = 15 * 6e4;
+var FAIL_TTL_MS = 6e4;
+var V1_VAULT_ALLOCATIONS_QUERY = (first, skip, chainId) => `
+query VaultFundedV1 {
+  vaults(first: ${first}, skip: ${skip}, where: {
+    chainId_in: [${chainId}],
+    totalAssetsUsd_gte: ${MORPHO_VAULT_FUNDED_MIN_VAULT_USD}
+  }) {
+    items {
+      address
+      state {
+        allocation {
+          supplyAssetsUsd
+          market { marketId listed collateralAsset { address } }
+        }
+      }
+    }
+  }
+}
+`;
+var V2_VAULT_CAPS_QUERY = (first, skip, chainId) => `
+query VaultFundedV2 {
+  vaultV2s(first: ${first}, skip: ${skip}, where: {
+    chainId_in: [${chainId}],
+    totalAssetsUsd_gte: ${MORPHO_VAULT_FUNDED_MIN_VAULT_USD}
+  }) {
+    items {
+      address
+      totalAssets
+      totalAssetsUsd
+      asset { decimals price { usd } }
+      caps {
+        items {
+          type
+          allocation
+          data {
+            __typename
+            ... on MarketV1CapData {
+              market { marketId listed collateralAsset { address } }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`;
+var ZERO = "0x0000000000000000000000000000000000000000";
+var isUnlistedLendable = (m) => {
+  if (m?.listed !== false) return false;
+  const coll = m.collateralAsset?.address?.toLowerCase();
+  return !!coll && coll !== ZERO;
+};
+function sumVaultFundedUnlisted(v1Vaults, v2Vaults, minUsd = MORPHO_VAULT_FUNDED_MIN_USD) {
+  const byMarket = /* @__PURE__ */ new Map();
+  const add = (marketId, usd) => {
+    if (!marketId || usd == null || !Number.isFinite(usd) || usd <= 0) return;
+    const k = marketId.toLowerCase();
+    byMarket.set(k, (byMarket.get(k) ?? 0) + usd);
+  };
+  for (const v of v1Vaults) {
+    for (const a of v?.state?.allocation ?? []) {
+      if (!isUnlistedLendable(a?.market)) continue;
+      add(a.market.marketId, typeof a.supplyAssetsUsd === "number" ? a.supplyAssetsUsd : null);
+    }
+  }
+  for (const v of v2Vaults) {
+    const decimals = typeof v?.asset?.decimals === "number" ? v.asset.decimals : null;
+    let price2 = typeof v?.asset?.price?.usd === "number" ? v.asset.price.usd : null;
+    const total = Number(v?.totalAssets ?? 0);
+    if (price2 == null && decimals != null && total > 0 && typeof v?.totalAssetsUsd === "number")
+      price2 = v.totalAssetsUsd / (total / 10 ** decimals);
+    for (const c of v?.caps?.items ?? []) {
+      if (c?.type !== "MarketV1") continue;
+      const m = c.data?.market;
+      if (!isUnlistedLendable(m)) continue;
+      const raw = Number(c.allocation ?? 0);
+      add(m.marketId, price2 != null && decimals != null ? raw / 10 ** decimals * price2 : null);
+    }
+  }
+  return [...byMarket].filter(([, usd]) => usd >= minUsd).map(([marketId, vaultUsd]) => ({ marketId, vaultUsd })).sort((a, b) => b.vaultUsd - a.vaultUsd || a.marketId.localeCompare(b.marketId));
+}
+async function post(query3) {
+  const res = await fetch(BASE_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ query: query3 })
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const json = await res.json();
+  if (json?.errors?.length)
+    throw new Error(json.errors.map((e) => e?.message).join("; "));
+  return json.data;
+}
+async function pageAll(build6, field13, pageSize) {
+  const out = [];
+  for (let page = 0; page < MAX_PAGES; page++) {
+    const items = (await post(build6(pageSize, page * pageSize)))?.[field13]?.items;
+    if (!Array.isArray(items)) throw new Error(`unexpected ${field13} shape`);
+    out.push(...items);
+    if (items.length < pageSize) return out;
+  }
+  console.warn(`[morpho-vault-funded] ${field13}: hit MAX_PAGES, result truncated`);
+  return out;
+}
+async function discover(chainId) {
+  const [v1, v2] = await Promise.all([
+    pageAll((f, s) => V1_VAULT_ALLOCATIONS_QUERY(f, s, chainId), "vaults", V1_PAGE),
+    pageAll((f, s) => V2_VAULT_CAPS_QUERY(f, s, chainId), "vaultV2s", V2_PAGE)
+  ]);
+  return sumVaultFundedUnlisted(v1, v2);
+}
+var cache = /* @__PURE__ */ new Map();
+function morphoVaultFundedUnlistedMarkets(chainId) {
+  if (morphoIncludesUnlisted(chainId)) return Promise.resolve([]);
+  const now = Date.now();
+  const hit = cache.get(chainId);
+  if (hit && now - hit.at < hit.ttl) return hit.promise;
+  const entry = { at: now, ttl: CACHE_TTL_MS, promise: Promise.resolve([]) };
+  entry.promise = discover(chainId).catch((e) => {
+    entry.ttl = FAIL_TTL_MS;
+    console.warn(
+      `[morpho-vault-funded] chain ${chainId}: discovery failed, serving listed markets only:`,
+      e?.message ?? e
+    );
+    return [];
+  });
+  cache.set(chainId, entry);
+  return entry.promise;
+}
+async function morphoVaultFundedUnlistedMarketIds(chainId) {
+  return (await morphoVaultFundedUnlistedMarkets(chainId)).map((m) => m.marketId);
+}
+var uniqueKeyInFilter = (keys) => `uniqueKey_in: [${keys.map((k) => JSON.stringify(k.toLowerCase())).join(", ")}]`;
+function mergeMarketItemsByKey(base, extra) {
+  const have = new Set(base.map((m) => m?.uniqueKey?.toLowerCase()));
+  const out = [...base];
+  for (const m of extra) {
+    const k = m?.uniqueKey?.toLowerCase();
+    if (!k || have.has(k)) continue;
+    have.add(k);
+    out.push(m);
+  }
+  return out;
+}
+var BY_KEY_CHUNK = 100;
+async function appendVaultFundedMarkets(chainId, base, buildByKeys) {
+  const ids = await morphoVaultFundedUnlistedMarketIds(chainId);
+  if (ids.length === 0) return base;
+  const have = new Set(base.map((m) => m?.uniqueKey?.toLowerCase()));
+  const missing = ids.filter((id) => !have.has(id));
+  if (missing.length === 0) return base;
+  try {
+    const extra = [];
+    for (let i = 0; i < missing.length; i += BY_KEY_CHUNK) {
+      const items = (await post(buildByKeys(missing.slice(i, i + BY_KEY_CHUNK))))?.markets?.items;
+      if (!Array.isArray(items)) throw new Error("unexpected markets shape");
+      extra.push(...items);
+    }
+    return mergeMarketItemsByKey(base, extra);
+  } catch (e) {
+    console.warn(
+      `[morpho-vault-funded] chain ${chainId}: by-key fetch of ${missing.length} markets failed:`,
+      e?.message ?? e
+    );
+    return base;
+  }
+}
+
+// src/lending/public-data/morpho/apiFields.ts
+function normalizeMorphoApiMarket(item) {
+  if (!item || typeof item !== "object") return item;
+  const out = { ...item };
+  if ("oracle" in out) {
+    out.oracleAddress = out.oracle?.address ?? void 0;
+    delete out.oracle;
+  }
+  for (const side of ["loanAsset", "collateralAsset"]) {
+    const a = out[side];
+    if (a && typeof a === "object" && "price" in a) {
+      const { price: price2, ...rest } = a;
+      out[side] = { ...rest, priceUsd: price2?.usd ?? null };
+    }
+  }
+  return out;
+}
+function normalizeMorphoApiMarkets(items) {
+  return items.map(normalizeMorphoApiMarket);
+}
+
+// src/lending/public-data/morpho/fetchPublic.ts
+var query = (first, skip, chainId, includeUnlisted = false, uniqueKeys) => `
 query GetMarkets {
   markets(first: ${first}, skip: ${skip}, where:  {
-     chainId_in: [${chainId}]${includeUnlisted ? "" : ",\n     listed: true"}
+     chainId_in: [${chainId}]${uniqueKeys ? `,
+     ${uniqueKeyInFilter(uniqueKeys)}` : includeUnlisted ? "" : ",\n     listed: true"}
   },
-  orderBy: SupplyAssetsUsd,
+  orderBy: ${uniqueKeys ? "UniqueKey" : "SupplyAssetsUsd"},
   orderDirection: Desc
   ) {
     items {
       uniqueKey: marketId
       irmAddress
-      oracleAddress
+      oracle {
+        address
+      }
       lltv
       whitelisted: listed
       loanAsset {
@@ -12509,14 +12745,18 @@ query GetMarkets {
         name
         symbol
         decimals
-        priceUsd
+        price {
+          usd
+        }
       }
       collateralAsset {
         address
         name
         symbol
         decimals
-        priceUsd
+        price {
+          usd
+        }
       }
       state {
         borrowApy
@@ -12544,7 +12784,7 @@ query GetMarkets {
   }
 }
 `;
-var BASE_URL = "https://blue-api.morpho.org/graphql";
+var BASE_URL2 = "https://blue-api.morpho.org/graphql";
 function assertNoGraphQLErrors(json) {
   if (json?.errors?.length) {
     throw new Error(
@@ -12553,12 +12793,25 @@ function assertNoGraphQLErrors(json) {
   }
 }
 async function fetchMorphoMarkets(chainId, includeUnlisted = false) {
+  const data = await fetchMorphoMarketsBase(chainId, includeUnlisted);
+  if (!Array.isArray(data?.markets?.items)) return data;
+  const items = includeUnlisted ? data.markets.items : await appendVaultFundedMarkets(
+    chainId,
+    data.markets.items,
+    (keys) => query(keys.length, 0, chainId, false, keys)
+  );
+  return {
+    ...data,
+    markets: { ...data.markets, items: normalizeMorphoApiMarkets(items) }
+  };
+}
+async function fetchMorphoMarketsBase(chainId, includeUnlisted) {
   if (chainId !== Chain.ETHEREUM_MAINNET) {
     const requestBody = {
       query: query(200, 0, chainId, includeUnlisted),
       variables: {}
     };
-    const response = await fetch(BASE_URL, {
+    const response = await fetch(BASE_URL2, {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
@@ -12583,14 +12836,14 @@ async function fetchMorphoMarkets(chainId, includeUnlisted = false) {
     variables: {}
   };
   const [data0, data1] = await Promise.all([
-    fetch(BASE_URL, {
+    fetch(BASE_URL2, {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
       },
       body: JSON.stringify(requestBody0)
     }).then((x) => x.json()),
-    fetch(BASE_URL, {
+    fetch(BASE_URL2, {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
@@ -20181,7 +20434,7 @@ var FLUID_API_BASE = "https://api.fluid.instadapp.io/v2";
 var SUPPORTED_CHAINS = /* @__PURE__ */ new Set(["1", "56", "137", "8453", "9745", "42161"]);
 var TTL_MS2 = 6e4;
 var ZERO_ADDRESS4 = "0x0000000000000000000000000000000000000000";
-var cache = {};
+var cache2 = {};
 var inflight = /* @__PURE__ */ new Map();
 var isRealDex = (d) => !!d && String(d.id ?? "0") !== "0" && String(d.address ?? ZERO_ADDRESS4).toLowerCase() !== ZERO_ADDRESS4;
 var toBigInt7 = (v) => {
@@ -20226,7 +20479,7 @@ var parseChainPayload = (raw) => {
 };
 var fetchFluidApiData = async (chainId) => {
   if (!SUPPORTED_CHAINS.has(chainId)) return void 0;
-  const hit = cache[chainId];
+  const hit = cache2[chainId];
   if (hit && Date.now() - hit.at < TTL_MS2) return hit.data;
   const pending = inflight.get(chainId);
   if (pending) return pending;
@@ -20237,11 +20490,11 @@ var fetchFluidApiData = async (chainId) => {
       const json = await res.json();
       if (!Array.isArray(json)) throw new Error("unexpected payload");
       const data = parseChainPayload(json);
-      cache[chainId] = { at: Date.now(), data };
+      cache2[chainId] = { at: Date.now(), data };
       return data;
     } catch {
-      const prev = cache[chainId]?.data;
-      cache[chainId] = { at: Date.now(), data: prev };
+      const prev = cache2[chainId]?.data;
+      cache2[chainId] = { at: Date.now(), data: prev };
       return prev;
     } finally {
       inflight.delete(chainId);
@@ -20250,7 +20503,7 @@ var fetchFluidApiData = async (chainId) => {
   inflight.set(chainId, run);
   return run;
 };
-var getCachedFluidApiData = (chainId) => cache[chainId]?.data;
+var getCachedFluidApiData = (chainId) => cache2[chainId]?.data;
 var DEX_RESOLVER_FALLBACK = {
   "1": "0x11D80CfF056Cef4F9E6d23da8672fE9873e5cC07",
   "137": "0x11D80CfF056Cef4F9E6d23da8672fE9873e5cC07",
@@ -20262,12 +20515,12 @@ var DEX_RESOLVER_FALLBACK = {
 var dexResolverFor = (chainId) => fluidResolvers()?.[chainId]?.dexResolver ?? DEX_RESOLVER_FALLBACK[chainId];
 var ZERO_ADDRESS5 = "0x0000000000000000000000000000000000000000";
 var TTL_MS3 = 6e4;
-var cache2 = {};
+var cache3 = {};
 var inflight2 = /* @__PURE__ */ new Map();
 var fetchFluidDexState = async (chainId, multicallRetry, extraDexAddresses = []) => {
   const resolver = dexResolverFor(chainId);
   if (!resolver) return void 0;
-  const hit = cache2[chainId];
+  const hit = cache3[chainId];
   if (hit && Date.now() - hit.at < TTL_MS3) return hit.data;
   const pending = inflight2.get(chainId);
   if (pending) return pending;
@@ -20307,11 +20560,11 @@ var fetchFluidDexState = async (chainId, multicallRetry, extraDexAddresses = [])
           totalBorrowShares: BigInt(s.totalBorrowShares ?? 0)
         };
       }
-      cache2[chainId] = { at: Date.now(), data };
+      cache3[chainId] = { at: Date.now(), data };
       return data;
     } catch {
-      const prev = cache2[chainId]?.data;
-      cache2[chainId] = { at: Date.now(), data: prev };
+      const prev = cache3[chainId]?.data;
+      cache3[chainId] = { at: Date.now(), data: prev };
       return prev;
     } finally {
       inflight2.delete(chainId);
@@ -20320,7 +20573,7 @@ var fetchFluidDexState = async (chainId, multicallRetry, extraDexAddresses = [])
   inflight2.set(chainId, run);
   return run;
 };
-var getCachedFluidDexState = (chainId) => cache2[chainId]?.data;
+var getCachedFluidDexState = (chainId) => cache3[chainId]?.data;
 
 // src/lending/public-data/fluid/publicCallParse.ts
 var FLUID_EEE_LOWER = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
@@ -25517,7 +25770,7 @@ var LLAMALEND_READ_ABI = [
   ...LlamaLendAmmAbi,
   ...Erc20Abi
 ];
-var ZERO = "0x0000000000000000000000000000000000000000";
+var ZERO2 = "0x0000000000000000000000000000000000000000";
 var WAD8 = 10n ** 18n;
 var CALLS_PER_MARKET = 6;
 var fetchJson2 = async (url, timeoutMs = 8e3) => {
@@ -25566,7 +25819,7 @@ async function fetchChainExtras(chainId, markets) {
       { address: m.amm, name: "price_oracle", params: [] },
       { address: m.amm, name: "active_band", params: [] },
       { address: m.controller, name: "n_loans", params: [] },
-      { address: m.vault, name: "maxDeposit", params: [ZERO] },
+      { address: m.vault, name: "maxDeposit", params: [ZERO2] },
       // v1 controllers have no `borrow_cap`; allowFailure turns that into a
       // null rather than sinking the whole batch.
       { address: m.controller, name: "borrow_cap", params: [] },
@@ -29339,7 +29592,7 @@ function convertFrankencoinMarketsToResponse(raw, chainId, prices = {}, _additio
 }
 
 // src/lending/public-data/silo-v2/fetchPublic.ts
-var BASE_URL2 = "https://api-v3.silo.finance";
+var BASE_URL3 = "https://api-v3.silo.finance";
 var SILO_API_SUPPORTED_CHAIN_IDS = /* @__PURE__ */ new Set([
   "1",
   // Ethereum
@@ -29482,7 +29735,7 @@ query GetSilosLite {
 async function fetchSiloMarketsLite(chainId, options) {
   if (!SILO_API_SUPPORTED_CHAIN_IDS.has(chainId)) return [];
   const limit = options?.limit ?? 500;
-  const response = await fetch(BASE_URL2, {
+  const response = await fetch(BASE_URL3, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ query: liteQuery(chainId, limit) })
@@ -29507,7 +29760,7 @@ async function fetchSiloMarketsLite(chainId, options) {
 async function fetchSiloMarkets(chainId, options) {
   if (!SILO_API_SUPPORTED_CHAIN_IDS.has(chainId)) return [];
   const limit = options?.limit ?? 500;
-  const response = await fetch(BASE_URL2, {
+  const response = await fetch(BASE_URL3, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ query: query2(chainId, limit) })
@@ -30288,39 +30541,6 @@ var getLenderPublicDataViaApi = async (chainId, lenders, prices, additionalYield
   }
   return lenderData;
 };
-
-// src/lending/public-data/morpho/unlisted.ts
-var MORPHO_UNLISTED_CHAINS = /* @__PURE__ */ new Set([
-  // Robinhood Chain. 189 of its 194 markets are unlisted and essentially all of
-  // them are Longbow — a curated Morpho Blue deployment (tokenized equities and
-  // RWAs against USDG) that Morpho's own frontend does not carry, so `listed`
-  // here says nothing about the market's quality. Enabled 2026-09-08 together
-  // with the three things a chain needs before it can be:
-  //   1. its collateral tokens in `token-lists` (wsNET was the last gap — the
-  //      collateral of the chain's LARGEST market), or the rows price at $0,
-  //   2. `lender-metadata`'s `SERVES_UNLISTED_CHAINS` carrying the same chain
-  //      id, so the markets get a NAME and an oracle roster (5 -> 188 rows),
-  //   3. a look at what the unlisted book actually holds — here 56 real
-  //      markets, $524k supplied / $351k borrowed, no runaway rates (the
-  //      highest borrow APR on the chain is 21.9 %).
-  // See LONGBOW.md.
-  "4663",
-  // World Chain. blue-api indexes it, but 0 of its 30 markets are listed —
-  // Morpho's frontend simply does not carry the chain, so `listed` says
-  // nothing about the book (the Longbow shape again). Looked at 2026-09-16:
-  // $59.5M supplied / $45.0M borrowed, of which the real two-sided markets are
-  // USDC/WBTC $3.9M, USDC/WETH $3.6M, WETH/WBTC $2.1M, USDC/WLD $1.6M and
-  // WETH/ezETH $1.1M at 0.1–4.6 % borrow APY; the $35.8M USDC/sdeUSD market is
-  // pinned at 100 % utilization (297,994 % APY, $0 liquid) and is exactly what
-  // `earn/rateSanity.ts` exists to drop. Token-list gaps on 480 at enablement:
-  // sdeUSD and ezETH (collateral of two markets) — those rows price at $0 with
-  // a blank LTV until token-lists carries them. `lender-metadata`'s
-  // `SERVES_UNLISTED_CHAINS` was updated in the same change.
-  "480"
-]);
-function morphoIncludesUnlisted(chainId) {
-  return MORPHO_UNLISTED_CHAINS.has(chainId);
-}
 var ERC20_BALANCE_OF_ABI2 = [
   {
     inputs: [{ name: "account", type: "address" }],
@@ -30943,7 +31163,7 @@ function decodeVariableLensRows(blob, fixedWords, headerBytes = 0) {
 }
 
 // src/lending/user-data/aave-v3-type/lens.ts
-var ZERO2 = "0x0000000000000000000000000000000000000000";
+var ZERO3 = "0x0000000000000000000000000000000000000000";
 var AAVE_LENS_HEADER_BYTES = 3;
 var HEADER_EMODE_OK = 1;
 var HEADER_CONFIG_OK = 2;
@@ -30951,7 +31171,7 @@ var AAVE_LENS_WORDS = 7;
 var reserveTuple = (tokens, asset) => {
   const t = tokens?.[asset.toLowerCase()];
   if (!t?.aToken || !t?.vToken) return void 0;
-  return [asset, t.aToken, t.vToken, t.sToken ?? ZERO2];
+  return [asset, t.aToken, t.vToken, t.sToken ?? ZERO3];
 };
 var usesAaveLens = (chainId, lender) => {
   if (getPositionLensFor(chainId, LENS_FAMILY.AAVE) === void 0) return false;
@@ -30981,7 +31201,7 @@ var buildAaveLensCall = (chainId, lender, account, assetsToQuery, withEMode) =>
       getAaveTypePoolDataProviderAddress(chainId, lender),
       // A zero pool disables the e-mode read, which is exactly what YLDR wants:
       // it has no `getUserEMode` and the walk omits that call for it too.
-      withEMode ? getAaveTypePoolAddress(chainId, lender) : ZERO2
+      withEMode ? getAaveTypePoolAddress(chainId, lender) : ZERO3
     ]
   );
   return [
@@ -32061,7 +32281,7 @@ var buildExactlyUserCall = (chainId, _lender, account) => {
   return [{ address: cfg.previewer, name: "exactly", params: [account] }];
 };
 var OWNER_INDEX_PROBE_COUNT = 8;
-var CACHE_TTL_MS = 5 * 6e4;
+var CACHE_TTL_MS2 = 5 * 6e4;
 var discoveryCache = /* @__PURE__ */ new Map();
 async function discoverViaLens(chainId, branches, zappers, account, opts) {
   const lens = getPositionLensFor(chainId, LENS_FAMILY.LIQUITY);
@@ -32130,7 +32350,7 @@ var getCachedLiquityTroves = (chainId, lender, account, opts) => {
   const hit = discoveryCache.get(
     cacheKey(chainId, lender, account, blockKey(opts))
   );
-  if (!hit || Date.now() - hit.at > CACHE_TTL_MS) return void 0;
+  if (!hit || Date.now() - hit.at > CACHE_TTL_MS2) return void 0;
   return hit;
 };
 var ADDRESS_ADDRESS_UINT = [
@@ -32350,7 +32570,7 @@ var buildRiverUserCall = (chainId, lender, account) => {
   });
   return calls;
 };
-var ZERO3 = "0x0000000000000000000000000000000000000000";
+var ZERO4 = "0x0000000000000000000000000000000000000000";
 var LLAMALEND_LENS_WORDS = 12;
 var LLAMALEND_CALLS_PER_MARKET = 8;
 var usesLlamaLendLens = (chainId) => getPositionLensFor(chainId, LENS_FAMILY.LLAMALEND) !== void 0;
@@ -32364,7 +32584,7 @@ var buildLlamaLendLensCall = (chainId, markets, account, delegate) => {
         m.controller,
         m.amm,
         m.vault,
-        m.gauge ?? ZERO3
+        m.gauge ?? ZERO4
       ]),
       delegate
     ]
@@ -32913,7 +33133,7 @@ function getCachedTwyneDiscovery(chainId, lender, account, opts) {
 }
 var lower2 = (a) => String(a).toLowerCase();
 var isAddress4 = (v) => typeof v === "string" && /^0x[0-9a-fA-F]{40}$/.test(v);
-async function discover(chainId, lender, account, opts) {
+async function discover2(chainId, lender, account, opts) {
   const key3 = discoveryKey3(chainId, lender, account, blockKey(opts));
   const cached = discoveryCache4.get(key3);
   if (cached && Date.now() - cached.at < DISCOVERY_TTL_MS3) return cached;
@@ -33015,7 +33235,7 @@ async function discover(chainId, lender, account, opts) {
   return result;
 }
 async function buildTwyneUserCall(chainId, lender, account, opts) {
-  const { vaults } = await discover(chainId, lender, account, opts);
+  const { vaults } = await discover2(chainId, lender, account, opts);
   if (vaults.length === 0) return [];
   return vaults.flatMap(({ vault }) => [
     { address: vault, name: "totalAssetsDepositedOrReserved", args: [] },
@@ -33029,14 +33249,14 @@ async function buildTwyneUserCall(chainId, lender, account, opts) {
 }
 var DSS_CALLS_PER_CDP = 1;
 var MAX_CDP_WALK = 64;
-var CACHE_TTL_MS2 = 5 * 6e4;
+var CACHE_TTL_MS3 = 5 * 6e4;
 var discoveryCache5 = /* @__PURE__ */ new Map();
 var cacheKey2 = (lender, chainId, account, block = "head") => `${lender}:${chainId}:${account.toLowerCase()}:${block}`;
 var getCachedDssCdps = (lender, chainId, account, opts) => {
   const hit = discoveryCache5.get(
     cacheKey2(lender, chainId, account, blockKey(opts))
   );
-  if (!hit || Date.now() - hit.at > CACHE_TTL_MS2) return void 0;
+  if (!hit || Date.now() - hit.at > CACHE_TTL_MS3) return void 0;
   return hit;
 };
 var big7 = (v) => {
@@ -33279,12 +33499,12 @@ async function discoverTellerBidsViaLens(chainId, tellerV2, account, opts) {
 
 // src/lending/user-data/teller/userCallBuild.ts
 var TELLER_CALLS_PER_BID = 4;
-var CACHE_TTL_MS3 = 5 * 6e4;
+var CACHE_TTL_MS4 = 5 * 6e4;
 var discoveryCache7 = /* @__PURE__ */ new Map();
 var cacheKey4 = (chainId, account, block = "head") => `${chainId}:${account.toLowerCase()}:${block}`;
 var getCachedTellerBids = (chainId, account, opts) => {
   const hit = discoveryCache7.get(cacheKey4(chainId, account, blockKey(opts)));
-  if (!hit || Date.now() - hit.at > CACHE_TTL_MS3) return void 0;
+  if (!hit || Date.now() - hit.at > CACHE_TTL_MS4) return void 0;
   return hit;
 };
 var nowSec5 = () => Math.floor(Date.now() / 1e3);
@@ -33421,12 +33641,12 @@ var buildFlyingTulipUserCall = (chainId, lender, account) => {
   ];
 };
 var TERMMAX_MARKETS_PER_CALL = 180;
-var CACHE_TTL_MS4 = 5 * 6e4;
+var CACHE_TTL_MS5 = 5 * 6e4;
 var discoveryCache8 = /* @__PURE__ */ new Map();
 var cacheKey5 = (chainId, account) => `${chainId}:${account.toLowerCase()}`;
 var getCachedTermMaxDiscovery = (chainId, account) => {
   const hit = discoveryCache8.get(cacheKey5(chainId, account));
-  if (!hit || Date.now() - hit.at > CACHE_TTL_MS4) return void 0;
+  if (!hit || Date.now() - hit.at > CACHE_TTL_MS5) return void 0;
   return hit;
 };
 var buildTermMaxUserCall = async (chainId, _lender, account) => {
@@ -43706,7 +43926,7 @@ var MORPHO_API_CHAIN_IDS = {
   [Chain.UNICHAIN]: 130
 };
 var FETCH_TIMEOUT_MS = 3e3;
-var CACHE_TTL_MS5 = 2e3;
+var CACHE_TTL_MS6 = 2e3;
 var buildSubgraphQuery = (account) => `
 {
   account(id: "${account.toLowerCase()}") {
@@ -43774,7 +43994,7 @@ async function dedupedFetch(chainId, account, loader) {
   const existing = inflight3.get(key3);
   if (existing) return existing;
   const promise = loader().then((value) => {
-    resolved.set(key3, { value, expiresAt: Date.now() + CACHE_TTL_MS5 });
+    resolved.set(key3, { value, expiresAt: Date.now() + CACHE_TTL_MS6 });
     return value;
   }).finally(() => {
     inflight3.delete(key3);
@@ -56751,7 +56971,7 @@ var dtrinityRebateRewardFetcher = {
 };
 var SECONDS_PER_YEAR15 = 31536e3;
 var WAD16 = 10n ** 18n;
-var ZERO4 = "0x0000000000000000000000000000000000000000";
+var ZERO5 = "0x0000000000000000000000000000000000000000";
 var UNBOOSTED_FACTOR = 0.4;
 var MAX_BOOST = 2.5;
 var GAUGE_CONTROLLER = "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB";
@@ -56947,7 +57167,7 @@ async function fetchPrices(keys) {
 var priceOf = (prices, chainId, address) => prices[`${LLAMA_CHAIN_SLUG[chainId]}:${address.toLowerCase()}`] ?? 0;
 function rosterFor(chainId) {
   const markets = llamaLendChainData(Lender.LLAMALEND, chainId)?.markets ?? [];
-  return markets.filter((m) => m.gauge && m.gauge !== ZERO4).map((m) => ({
+  return markets.filter((m) => m.gauge && m.gauge !== ZERO5).map((m) => ({
     controller: m.controller,
     vault: m.vault,
     gauge: m.gauge,
@@ -57024,7 +57244,7 @@ async function fetchForChain(chainId, nowSeconds) {
   }) : [];
   let cursor = 0;
   const withTokens = state.map((s) => {
-    const tokens = r2.slice(cursor, cursor + s.rewardCount).filter((t) => typeof t === "string" && t !== ZERO4);
+    const tokens = r2.slice(cursor, cursor + s.rewardCount).filter((t) => typeof t === "string" && t !== ZERO5);
     cursor += s.rewardCount;
     return { ...s, tokens };
   });
@@ -57619,26 +57839,32 @@ function getMorphoAbi() {
 var MORPHO_GRAPHQL_URL = "https://blue-api.morpho.org/graphql";
 var MAX_UNLISTED_PRICE_PAGES = 10;
 var PRICE_PAGE_SIZE = 200;
-var PRICE_QUERY = (first, skip, chainId, includeUnlisted) => `
+var PRICE_QUERY = (first, skip, chainId, includeUnlisted, uniqueKeys) => `
 query GetMarketPrices {
   markets(first: ${first}, skip: ${skip}, where: {
-    chainId_in: [${chainId}]${!includeUnlisted && chainId != Chain.ETHEREUM_MAINNET ? `,listed: true` : ""}
+    chainId_in: [${chainId}]${uniqueKeys ? `,${uniqueKeyInFilter(uniqueKeys)}` : !includeUnlisted && chainId != Chain.ETHEREUM_MAINNET ? `,listed: true` : ""}
   },
-  orderBy: SupplyAssetsUsd,
+  orderBy: ${uniqueKeys ? "UniqueKey" : "SupplyAssetsUsd"},
   orderDirection: Desc
   ) {
     items {
       uniqueKey: marketId
-      oracleAddress
+      oracle {
+        address
+      }
       loanAsset {
         address
         decimals
-        priceUsd
+        price {
+          usd
+        }
       }
       collateralAsset {
         address
         decimals
-        priceUsd
+        price {
+          usd
+        }
       }
       state {
         price
@@ -57649,7 +57875,7 @@ query GetMarketPrices {
 `;
 async function fetchMorphoGraphQLPrices(chainId, includeUnlisted = false) {
   if (!morphoApiAvailable(chainId)) return null;
-  const post = (skip) => fetch(MORPHO_GRAPHQL_URL, {
+  const post2 = (skip) => fetch(MORPHO_GRAPHQL_URL, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
@@ -57670,7 +57896,7 @@ async function fetchMorphoGraphQLPrices(chainId, includeUnlisted = false) {
     const allMarkets = [];
     if (includeUnlisted) {
       for (let page = 0; page < MAX_UNLISTED_PRICE_PAGES; page++) {
-        const items = readItems(await post(page * PRICE_PAGE_SIZE));
+        const items = readItems(await post2(page * PRICE_PAGE_SIZE));
         if (!items) return null;
         allMarkets.push(...items);
         if (items.length < PRICE_PAGE_SIZE) break;
@@ -57682,14 +57908,23 @@ async function fetchMorphoGraphQLPrices(chainId, includeUnlisted = false) {
       }
     } else {
       const skips = chainId === Chain.ETHEREUM_MAINNET ? [0, PRICE_PAGE_SIZE] : [0];
-      const results = await Promise.all(skips.map(post));
+      const results = await Promise.all(skips.map(post2));
       for (const result of results) {
         const items = readItems(result);
         if (!items) return null;
         allMarkets.push(...items);
       }
     }
-    return processMarketsToEntries(chainId, allMarkets, "morpho-gql");
+    const priced = includeUnlisted ? allMarkets : await appendVaultFundedMarkets(
+      chainId,
+      allMarkets,
+      (keys) => PRICE_QUERY(keys.length, 0, chainId, false, keys)
+    );
+    return processMarketsToEntries(
+      chainId,
+      normalizeMorphoApiMarkets(priced),
+      "morpho-gql"
+    );
   } catch (err) {
     console.warn(
       `[morpho-gql] chain ${chainId}: API error, falling back to on-chain`,
@@ -64294,7 +64529,7 @@ var fetchSiloVaults = async (chainId, prices = {}, tokenList = {}, options) => {
 // src/vaults/euler-earn/entityLabels.ts
 var LABELS_BASE = "https://raw.githubusercontent.com/euler-xyz/euler-labels/master";
 var TTL_MS4 = 30 * 60 * 1e3;
-var cache3 = /* @__PURE__ */ new Map();
+var cache4 = /* @__PURE__ */ new Map();
 var inflight4 = /* @__PURE__ */ new Map();
 async function fetchChainEntities(chainId) {
   const res = await fetch(`${LABELS_BASE}/${chainId}/entities.json`);
@@ -64318,12 +64553,12 @@ async function fetchChainEntities(chainId) {
   return map;
 }
 async function fetchEulerEntityNames(chainId) {
-  const hit = cache3.get(chainId);
+  const hit = cache4.get(chainId);
   if (hit && Date.now() - hit.at <= TTL_MS4) return hit.map;
   const running = inflight4.get(chainId);
   if (running) return running;
   const p = fetchChainEntities(chainId).then((map) => {
-    cache3.set(chainId, { at: Date.now(), map });
+    cache4.set(chainId, { at: Date.now(), map });
     return map;
   }).catch(() => {
     return hit?.map ?? /* @__PURE__ */ new Map();
@@ -64420,7 +64655,7 @@ query EvkByAssets($assets: [Bytes!]!) {
   }
 }
 `;
-var ZERO5 = 0n;
+var ZERO6 = 0n;
 var RAY_TO_PERCENT3 = 1e25;
 function readAddress2(field13) {
   if (!field13) return void 0;
@@ -64435,28 +64670,28 @@ function parseVaultFee(v) {
   return n;
 }
 function safeBigInt(v) {
-  if (v == null || v === "") return ZERO5;
+  if (v == null || v === "") return ZERO6;
   try {
     return BigInt(v);
   } catch {
-    return ZERO5;
+    return ZERO6;
   }
 }
 function computeWeightedSupplyApy(strategies, totalAssetsRaw, feePercent2, evkIndex) {
   if (!strategies?.length) return 0;
   const totalAssets = safeBigInt(totalAssetsRaw);
-  if (totalAssets === ZERO5) return 0;
-  let weightedRay = ZERO5;
+  if (totalAssets === ZERO6) return 0;
+  let weightedRay = ZERO6;
   for (const s of strategies) {
     const evk = s.strategy?.toLowerCase();
     if (!evk) continue;
     const apyRay = evkIndex.bySupplyApyRay.get(evk);
     if (apyRay == null) continue;
     const allocated = safeBigInt(s.allocatedAssets);
-    if (allocated === ZERO5) continue;
+    if (allocated === ZERO6) continue;
     weightedRay += allocated * apyRay;
   }
-  if (weightedRay === ZERO5) return 0;
+  if (weightedRay === ZERO6) return 0;
   const apyRayPerAsset = weightedRay / totalAssets;
   const grossPercent = apyToAprPercent(Number(apyRayPerAsset) / RAY_TO_PERCENT3);
   const netPercent = grossPercent * (1 - feePercent2 / 100);
@@ -64464,24 +64699,24 @@ function computeWeightedSupplyApy(strategies, totalAssetsRaw, feePercent2, evkIn
 }
 function computeRealLiquidity(strategies, totalAssetsRaw, evkIndex) {
   const totalAssets = safeBigInt(totalAssetsRaw);
-  if (totalAssets === ZERO5) return ZERO5;
+  if (totalAssets === ZERO6) return ZERO6;
   if (evkIndex.byCash.size === 0 && evkIndex.bySupplyApyRay.size === 0) {
     return totalAssets;
   }
   if (!strategies?.length) {
     return totalAssets;
   }
-  let allocSum = ZERO5;
-  let withdrawable = ZERO5;
+  let allocSum = ZERO6;
+  let withdrawable = ZERO6;
   for (const s of strategies) {
     const alloc = safeBigInt(s.allocatedAssets);
-    if (alloc === ZERO5) continue;
+    if (alloc === ZERO6) continue;
     allocSum += alloc;
     const evk = s.strategy?.toLowerCase();
     const cash = evk ? evkIndex.byCash.get(evk) : void 0;
     withdrawable += cash == null ? alloc : alloc < cash ? alloc : cash;
   }
-  const idle = totalAssets > allocSum ? totalAssets - allocSum : ZERO5;
+  const idle = totalAssets > allocSum ? totalAssets - allocSum : ZERO6;
   const result = idle + withdrawable;
   return result > totalAssets ? totalAssets : result;
 }
@@ -75058,7 +75293,7 @@ function isLiveMarket(market, nowSecs = Math.floor(Date.now() / 1e3)) {
   if (expiry === void 0) return false;
   return expiry > nowSecs;
 }
-var CACHE_TTL_MS6 = 6e4;
+var CACHE_TTL_MS7 = 6e4;
 var marketsCache;
 var assetsCache;
 function clearPendleMarketsCache() {
@@ -75074,9 +75309,9 @@ async function getJson4(url, label) {
   }
   return response.json();
 }
-function cache4(slot, build6, store) {
+function cache5(slot, build6, store) {
   const now = Date.now();
-  if (slot && now - slot.at < CACHE_TTL_MS6) return slot.promise;
+  if (slot && now - slot.at < CACHE_TTL_MS7) return slot.promise;
   const promise = build6();
   const entry = { at: now, promise };
   store(entry);
@@ -75084,7 +75319,7 @@ function cache4(slot, build6, store) {
   return promise;
 }
 function fetchPendleApiMarkets() {
-  return cache4(
+  return cache5(
     marketsCache,
     async () => (await getJson4(PENDLE_MARKETS_URL, "markets"))?.markets ?? [],
     (c) => {
@@ -75094,7 +75329,7 @@ function fetchPendleApiMarkets() {
 }
 var assetKey = (chainId, address) => `${chainId}-${address.toLowerCase()}`;
 function fetchPendleApiAssets() {
-  return cache4(
+  return cache5(
     assetsCache,
     async () => {
       const json = await getJson4(PENDLE_ASSETS_URL, "assets");
@@ -75345,17 +75580,17 @@ function parsePtRate(raw) {
   if (!Number.isFinite(n) || n < 0 || n > 1.000001) return void 0;
   return n;
 }
-var CACHE_TTL_MS7 = 6e4;
-var cache5 = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS8 = 6e4;
+var cache6 = /* @__PURE__ */ new Map();
 function clearSpectraMarketsCache() {
-  cache5.clear();
+  cache6.clear();
 }
 function fetchSpectraApiMarkets(chainId) {
   const network = spectraNetwork(chainId);
   if (!network) return Promise.resolve([]);
   const now = Date.now();
-  const hit = cache5.get(network);
-  if (hit && now - hit.at < CACHE_TTL_MS7) return hit.promise;
+  const hit = cache6.get(network);
+  if (hit && now - hit.at < CACHE_TTL_MS8) return hit.promise;
   const promise = (async () => {
     const response = await fetch(spectraPoolsUrl(network), {
       headers: { Accept: "application/json" }
@@ -75368,9 +75603,9 @@ function fetchSpectraApiMarkets(chainId) {
     const json = await response.json();
     return Array.isArray(json) ? json : [];
   })();
-  cache5.set(network, { at: now, promise });
+  cache6.set(network, { at: now, promise });
   promise.catch(() => {
-    if (cache5.get(network)?.promise === promise) cache5.delete(network);
+    if (cache6.get(network)?.promise === promise) cache6.delete(network);
   });
   return promise;
 }