@1delta/margin-fetcher 0.0.196 → 0.0.197

package/dist/index.js

@@ -4,7 +4,7 @@ import './chunk-PR4QN5HX.js';
 import { Lender, isAaveType, isCompoundV3, isMultiMarket, isInit, isMorphoType, isCompoundV2Type, isVenusType, isSumerType, AAVE_V3_LENDERS, AAVE_V2_LENDERS, isAaveV2Type, isAaveV32Type, isAaveV3Type, isEulerType, isYLDR, isCompoundV3Type, isTectonicType, isBenqiType, isLista } from '@1delta/lender-registry';
 export { isAaveType, isAaveV2Type, isAaveV32Type, isAaveV3Type, isCompoundV3, isCompoundV3Type, isInit, isMorphoType, isMultiMarket, isYLDR } from '@1delta/lender-registry';
 import lodash from 'lodash';
-import { getEvmChain, multicallRetry, getEvmClient, getEvmClientUniversal } from '@1delta/providers';
+import { getEvmChain, multicallRetryUniversal, getEvmClient, getEvmClientUniversal } from '@1delta/providers';
 import { MorphoLensAbi, MorphoBlueAbi } from '@1delta/abis';
 export { MorphoLensAbi } from '@1delta/abis';
 import { prepareDebitDataMulticall, prepareLenderDebitMulticall, parseDebitDataResult, parseLenderDebitResult, getPermit2ContractAddress, InitMarginAddresses } from '@1delta/calldata-sdk';
@@ -17998,7 +17998,7 @@ var getAbi = (lender) => {
   if (isCompoundV2Type(lender)) return VenusLensAbi;
   return [];
 };
-var getLenderPublicData = async (chainId, lenders, prices, additionalYields, multicallRetry3, tokenList = async () => {
+var getLenderPublicData = async (chainId, lenders, prices, additionalYields, multicallRetry, tokenList = async () => {
   return {};
 }) => {
   let calls = [];
@@ -18009,16 +18009,12 @@ var getLenderPublicData = async (chainId, lenders, prices, additionalYields, mul
     calls = [...calls, ...mappedCalls];
   }
   const [rawResults, list] = await Promise.all([
-    multicallRetry3(
-      chainId,
-      calls.map((call) => call.call),
-      calls.map((call) => call.abi),
-      chainId === Chain.ETHEREUM_MAINNET ? 500 : void 0
-      // default size
-      // retries = 3
-      // provider = 0
-      // allowFailure = false
-    ),
+    multicallRetry({
+      chain: chainId,
+      calls: calls.map((call) => call.call),
+      abi: calls.map((call) => call.abi),
+      batchSize: chainId === Chain.ETHEREUM_MAINNET ? 500 : void 0
+    }),
     await tokenList()
   ]);
   const invalidLenders = [];
@@ -18126,7 +18122,7 @@ function lenderCanUseApi(lender, chainId) {
   }
   return false;
 }
-var getLenderPublicDataAll = async (chainId, lenders, prices, additionalYields, multicallRetry3, tokenList, includeUnlistedMorphoMarkets = false) => {
+var getLenderPublicDataAll = async (chainId, lenders, prices, additionalYields, multicallRetry, tokenList, includeUnlistedMorphoMarkets = false) => {
   const lendersApi = lenders.filter((l) => lenderCanUseApi(l, chainId));
   const lendersOnChain = lenders.filter((l) => !lenderCanUseApi(l, chainId));
   const onChain = getLenderPublicData(
@@ -18134,7 +18130,7 @@ var getLenderPublicDataAll = async (chainId, lenders, prices, additionalYields,
     lendersOnChain,
     prices,
     additionalYields,
-    multicallRetry3,
+    multicallRetry,
     tokenList
   );
   const api = getLenderPublicDataViaApi(
@@ -24732,20 +24728,20 @@ function parseMergedResult(chainId, rawResults, prepared, lenderState) {
 }
 
 // src/lending/user-data/with-permissions/e2e.ts
-async function getMergedUserData(chainId, balanceQueries, permissionParams, lenderState, multicallRetry3, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, maxRetries2 = 3, tokenApprovalParams) {
+async function getMergedUserData(chainId, balanceQueries, permissionParams, lenderState, multicallRetry, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, maxRetries2 = 3, tokenApprovalParams) {
   const prepared = await prepareMergedMulticallParams(
     chainId,
     balanceQueries,
     permissionParams,
     tokenApprovalParams
   );
-  const rawResults = await multicallRetry3(
-    chainId,
-    prepared.calls,
-    prepared.abis,
+  const rawResults = await multicallRetry({
+    chain: chainId,
+    calls: prepared.calls,
+    abi: prepared.abis,
     batchSize,
-    maxRetries2
-  );
+    maxRetries: maxRetries2
+  });
   return parseMergedResult(chainId, rawResults, prepared, lenderState);
 }
 function toCompoundV2Shares(entry, amount) {
@@ -29057,16 +29053,16 @@ var fetchMainPrices = async (chainIds, rpcOverrides, lists = {}, retries = 3, ba
       ...CometAbi,
       ...VenusLensAbi
     ];
-    const result = await multicallRetry(
-      chainId,
-      allCalls,
-      abis,
+    const result = await multicallRetryUniversal({
+      chain: chainId,
+      calls: allCalls,
+      abi: abis,
       batchSize,
-      retries,
-      0,
+      maxRetries: retries,
+      providerId: 0,
       allowFailure,
-      rpcOverrides
-    );
+      overrdies: rpcOverrides
+    });
     return {
       chainId,
       result,
@@ -30365,6 +30361,13 @@ var aaveFetcher = {
   parse: parseAaveResults2,
   getAbi: getAaveAbi
 };
+function morphoApiAvailable(chainId) {
+  if (chainId === Chain.SONEIUM) return false;
+  if (chainId === Chain.HEMI_NETWORK) return false;
+  if (chainId === Chain.BERACHAIN) return false;
+  if (chainId === Chain.SEI_NETWORK) return false;
+  return true;
+}
 function generateMarketId(oracle, loanAsset, collateralAsset) {
   return `${oracle}${loanAsset}${collateralAsset}`.replace(/0x/gi, "").toUpperCase();
 }
@@ -30456,6 +30459,111 @@ function parseMorphoResults2(data, meta, context) {
 function getMorphoAbi() {
   return ProxyOracleAbi;
 }
+var MORPHO_GRAPHQL_URL = "https://blue-api.morpho.org/graphql";
+var PRICE_QUERY = (first, skip, chainId) => `
+query GetMarketPrices {
+  markets(first: ${first}, skip: ${skip}, where: {
+    chainId_in: [${chainId}],
+    whitelisted: true
+  },
+  orderBy: SupplyAssetsUsd,
+  orderDirection: Desc
+  ) {
+    items {
+      uniqueKey
+      oracleAddress
+      loanAsset {
+        address
+        decimals
+        priceUsd
+      }
+      collateralAsset {
+        address
+        decimals
+        priceUsd
+      }
+      state {
+        price
+      }
+    }
+  }
+}
+`;
+async function fetchMorphoGraphQLPrices(chainId) {
+  if (!morphoApiAvailable(chainId)) return null;
+  try {
+    const pages = chainId === "1" ? [
+      fetch(MORPHO_GRAPHQL_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          query: PRICE_QUERY(200, 0, chainId)
+        })
+      }).then((r) => r.json()),
+      fetch(MORPHO_GRAPHQL_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          query: PRICE_QUERY(200, 200, chainId)
+        })
+      }).then((r) => r.json())
+    ] : [
+      fetch(MORPHO_GRAPHQL_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          query: PRICE_QUERY(200, 0, chainId)
+        })
+      }).then((r) => r.json())
+    ];
+    const results = await Promise.all(pages);
+    const allMarkets = [];
+    for (const result of results) {
+      const items = result?.data?.markets?.items;
+      if (!Array.isArray(items)) return null;
+      allMarkets.push(...items);
+    }
+    if (allMarkets.length === 0) return null;
+    const entries = [];
+    for (const market of allMarkets) {
+      if (!market.collateralAsset) continue;
+      const oracle = market.oracleAddress;
+      const loanAsset = market.loanAsset.address.toLowerCase();
+      const collateralAsset = market.collateralAsset.address.toLowerCase();
+      const marketId = market.uniqueKey?.replace(/^0x/i, "").toUpperCase() ?? generateMarketId(oracle, loanAsset, collateralAsset);
+      const lenderKey = generateMorphoLenderKey(marketId);
+      const loanPriceUSD = market.loanAsset.priceUsd;
+      const collateralPriceUSD = market.collateralAsset.priceUsd;
+      const statePrice = market.state?.price;
+      const oracleRatio = statePrice != null ? formatMorphoPrice(
+        statePrice,
+        market.loanAsset.decimals,
+        market.collateralAsset.decimals
+      ) : 0;
+      if (collateralPriceUSD != null && collateralPriceUSD > 0) {
+        entries.push({
+          asset: collateralAsset,
+          price: oracleRatio || collateralPriceUSD,
+          priceUSD: collateralPriceUSD,
+          marketUid: createMarketUid(chainId, lenderKey, collateralAsset),
+          targetLender: lenderKey
+        });
+      }
+      if (loanPriceUSD != null && loanPriceUSD > 0) {
+        entries.push({
+          asset: loanAsset,
+          price: oracleRatio > 0 ? 1 / oracleRatio : loanPriceUSD,
+          priceUSD: loanPriceUSD,
+          marketUid: createMarketUid(chainId, lenderKey, loanAsset),
+          targetLender: lenderKey
+        });
+      }
+    }
+    return entries.length > 0 ? entries : null;
+  } catch {
+    return null;
+  }
+}
 var morphoFetcher = {
   getCalls: getMorphoCalls2,
   parse: parseMorphoResults2,
@@ -30806,162 +30914,447 @@ var eulerV2Fetcher = {
 };
 
 // src/prices/oracle-prices/fetchOraclePrices.ts
-async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3, batchSize = void 0, allowFailure = true, basePrices = {}, morphoMarketOverrides, listaMarketOverrides) {
+function countFailures(data, offset, count) {
+  let failures = 0;
+  for (let i = offset; i < offset + count; i++) {
+    if (data[i] === "0x" || data[i] === void 0) failures++;
+  }
+  return failures;
+}
+function safeGetCalls(fetcherName, fn, errors) {
+  try {
+    return fn();
+  } catch (e) {
+    errors[fetcherName] = e instanceof Error ? e.message : String(e);
+    return [];
+  }
+}
+function buildGroup(fetcherName, results, parse, abi) {
+  const group = {
+    fetcherName,
+    calls: [],
+    abi,
+    trackers: []
+  };
+  for (const fr of results) {
+    group.trackers.push({
+      lender: fr.lender,
+      meta: fr.meta,
+      offset: group.calls.length,
+      count: fr.calls.length,
+      parse
+    });
+    group.calls.push(...fr.calls);
+  }
+  return group;
+}
+function isFailed(r) {
+  return r === "0x" || r === void 0;
+}
+async function executeGroup(group, chainId, chainBatchSize, retries, allowFailure, rpcOverrides, failRetries = 2) {
+  if (group.calls.length === 0) {
+    return { results: [] };
+  }
+  try {
+    const results = await multicallRetryUniversal({
+      chain: chainId,
+      calls: group.calls,
+      abi: group.abi,
+      batchSize: chainBatchSize,
+      maxRetries: retries,
+      providerId: void 0,
+      allowFailure,
+      overrdies: rpcOverrides,
+      logErrors: true
+    });
+    let failedIndices = results.map((r, i) => isFailed(r) ? i : -1).filter((i) => i >= 0);
+    for (let round = 0; round < failRetries && failedIndices.length > 0; round++) {
+      const retryCalls = failedIndices.map((i) => group.calls[i]);
+      try {
+        const retryResults = await multicallRetryUniversal({
+          chain: chainId,
+          calls: retryCalls,
+          abi: group.abi,
+          batchSize: chainBatchSize,
+          maxRetries: retries,
+          providerId: round + 1,
+          // rotate to next RPC provider
+          allowFailure,
+          overrdies: rpcOverrides,
+          logErrors: true
+        });
+        const stillFailed = [];
+        for (let j = 0; j < failedIndices.length; j++) {
+          if (!isFailed(retryResults[j])) {
+            results[failedIndices[j]] = retryResults[j];
+          } else {
+            stillFailed.push(failedIndices[j]);
+          }
+        }
+        failedIndices = stillFailed;
+      } catch {
+        break;
+      }
+    }
+    const failCount = results.filter((r) => isFailed(r)).length;
+    const allFailed = failCount === results.length && results.length > 0;
+    return {
+      results,
+      error: allFailed ? `All ${group.calls.length} calls returned 0x (${group.fetcherName})` : void 0
+    };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return {
+      results: Array(group.calls.length).fill("0x"),
+      error: `multicall threw: ${msg.slice(0, 200)}`
+    };
+  }
+}
+async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3, batchSize = void 0, allowFailure = true, basePrices = {}, morphoMarketOverrides, listaMarketOverrides, stalenessThresholdSeconds = 3600, onlyFetchers) {
+  const totalStart = Date.now();
   const result = {};
-  const combinedAbi = [
-    ...AaveOracleAbi,
-    ...ProxyOracleAbi,
-    ...CompoundV2OracleAbi,
-    ...ChainlinkAggregatorAbi,
-    ...vaultLensAbi
-  ];
   const chainPromises = chainIds.map(async (chainId) => {
+    const chainStart = Date.now();
     const chainResult = {};
     const tokenList = lists[chainId] ?? {};
-    const aaveResults = aaveFetcher.getCalls(chainId);
-    const compoundV2Results = compoundV2Fetcher.getCalls(chainId);
-    const compoundV3Results = compoundV3Fetcher.getCalls(chainId);
-    const listaResults = listaFetcher.getCalls(chainId, {
-      marketOverrides: listaMarketOverrides
-    });
-    const eulerResults = eulerV2Fetcher.getCalls(chainId);
-    const morphoResults = morphoFetcher.getCalls(chainId, {
-      marketOverrides: morphoMarketOverrides
-    });
-    const allCalls = [];
-    const fetcherTracker = [];
-    for (const fr of aaveResults) {
-      fetcherTracker.push({
-        lender: fr.lender,
-        meta: fr.meta,
-        offset: allCalls.length,
-        count: fr.calls.length,
-        parse: aaveFetcher.parse
-      });
-      allCalls.push(...fr.calls);
-    }
-    for (const fr of compoundV2Results) {
-      fetcherTracker.push({
-        lender: fr.lender,
-        meta: fr.meta,
-        offset: allCalls.length,
-        count: fr.calls.length,
-        parse: compoundV2Fetcher.parse
-      });
-      allCalls.push(...fr.calls);
-    }
-    for (const fr of compoundV3Results) {
-      fetcherTracker.push({
-        lender: fr.lender,
-        meta: fr.meta,
-        offset: allCalls.length,
-        count: fr.calls.length,
-        parse: compoundV3Fetcher.parse
-      });
-      allCalls.push(...fr.calls);
-    }
-    for (const fr of listaResults) {
-      fetcherTracker.push({
-        lender: fr.lender,
-        meta: fr.meta,
-        offset: allCalls.length,
-        count: fr.calls.length,
-        parse: listaFetcher.parse
-      });
-      allCalls.push(...fr.calls);
-    }
-    for (const fr of eulerResults) {
-      fetcherTracker.push({
-        lender: fr.lender,
-        meta: fr.meta,
-        offset: allCalls.length,
-        count: fr.calls.length,
-        parse: eulerV2Fetcher.parse
-      });
-      allCalls.push(...fr.calls);
-    }
-    for (const fr of morphoResults) {
-      fetcherTracker.push({
-        lender: fr.lender,
-        meta: fr.meta,
-        offset: allCalls.length,
-        count: fr.calls.length,
-        parse: morphoFetcher.parse
-      });
-      allCalls.push(...fr.calls);
-    }
-    if (allCalls.length === 0) {
-      return { chainId, data: chainResult };
+    const getCallsErrors = {};
+    const trackerDiags = [];
+    const unresolvedMorphoMarkets = [];
+    const staleFeeds = [];
+    const multicallErrors = [];
+    const active = onlyFetchers ? new Set(onlyFetchers.map((f) => f.toLowerCase())) : null;
+    const isActive = (name) => !active || active.has(name);
+    const aaveResults = isActive("aave") ? safeGetCalls(
+      "aave",
+      () => aaveFetcher.getCalls(chainId),
+      getCallsErrors
+    ) : [];
+    const compoundV2Results = isActive("compoundv2") ? safeGetCalls(
+      "compoundV2",
+      () => compoundV2Fetcher.getCalls(chainId),
+      getCallsErrors
+    ) : [];
+    const compoundV3Results = isActive("compoundv3") ? safeGetCalls(
+      "compoundV3",
+      () => compoundV3Fetcher.getCalls(chainId),
+      getCallsErrors
+    ) : [];
+    const listaResults = isActive("lista") ? safeGetCalls(
+      "lista",
+      () => listaFetcher.getCalls(chainId, {
+        marketOverrides: listaMarketOverrides
+      }),
+      getCallsErrors
+    ) : [];
+    const eulerResults = isActive("eulerv2") ? safeGetCalls(
+      "eulerV2",
+      () => eulerV2Fetcher.getCalls(chainId),
+      getCallsErrors
+    ) : [];
+    const morphoResults = isActive("morpho") ? safeGetCalls(
+      "morpho",
+      () => morphoFetcher.getCalls(chainId, {
+        marketOverrides: morphoMarketOverrides
+      }),
+      getCallsErrors
+    ) : [];
+    const aaveGroup = buildGroup(
+      "aave",
+      aaveResults,
+      aaveFetcher.parse,
+      AaveOracleAbi
+    );
+    const compoundV2Group = buildGroup(
+      "compoundV2",
+      compoundV2Results,
+      compoundV2Fetcher.parse,
+      CompoundV2OracleAbi
+    );
+    const compoundV3Group = buildGroup(
+      "compoundV3",
+      compoundV3Results,
+      compoundV3Fetcher.parse,
+      ChainlinkAggregatorAbi
+    );
+    const listaGroup = buildGroup(
+      "lista",
+      listaResults,
+      listaFetcher.parse,
+      ProxyOracleAbi
+    );
+    const eulerGroup = buildGroup(
+      "eulerV2",
+      eulerResults,
+      eulerV2Fetcher.parse,
+      vaultLensAbi
+    );
+    const morphoGroup = buildGroup(
+      "morpho",
+      morphoResults,
+      morphoFetcher.parse,
+      ProxyOracleAbi
+    );
+    const allGroups = [
+      aaveGroup,
+      compoundV2Group,
+      compoundV3Group,
+      listaGroup,
+      eulerGroup,
+      morphoGroup
+    ];
+    const totalCalls = allGroups.reduce((s, g) => s + g.calls.length, 0);
+    if (totalCalls === 0) {
+      const diag2 = {
+        chainId,
+        totalCalls: 0,
+        totalFailedCalls: 0,
+        totalParsedEntries: 0,
+        durationMs: Date.now() - chainStart,
+        trackers: [],
+        getCallsErrors,
+        unresolvedMorphoMarkets: [],
+        staleFeeds: []
+      };
+      return { chainId, data: chainResult, diagnostic: diag2 };
     }
-    const multicallResult = await multicallRetry(
+    const chainBatchSize = batchSize?.[chainId];
+    const morphoGqlPromise = isActive("morpho") ? fetchMorphoGraphQLPrices(chainId) : Promise.resolve(null);
+    const [
+      aaveData,
+      compoundV2Data,
+      compoundV3Data,
+      listaData,
+      eulerData,
+      morphoGqlEntries
+    ] = await Promise.all([
+      executeGroup(
+        aaveGroup,
+        chainId,
+        chainBatchSize,
+        retries,
+        allowFailure,
+        rpcOverrides
+      ),
+      executeGroup(
+        compoundV2Group,
+        chainId,
+        chainBatchSize,
+        retries,
+        allowFailure,
+        rpcOverrides
+      ),
+      executeGroup(
+        compoundV3Group,
+        chainId,
+        chainBatchSize,
+        retries,
+        allowFailure,
+        rpcOverrides
+      ),
+      executeGroup(
+        listaGroup,
+        chainId,
+        chainBatchSize,
+        retries,
+        allowFailure,
+        rpcOverrides
+      ),
+      executeGroup(
+        eulerGroup,
+        chainId,
+        chainBatchSize,
+        retries,
+        allowFailure,
+        rpcOverrides
+      ),
+      morphoGqlPromise
+    ]);
+    const morphoData = morphoGqlEntries != null ? { results: [], error: void 0 } : await executeGroup(
+      morphoGroup,
       chainId,
-      allCalls,
-      combinedAbi,
-      batchSize?.[chainId],
+      chainBatchSize,
       retries,
-      void 0,
       allowFailure,
       rpcOverrides
     );
+    const useMorphoGql = morphoGqlEntries != null;
+    const groupResults = [
+      { group: aaveGroup, data: aaveData },
+      { group: compoundV2Group, data: compoundV2Data },
+      { group: compoundV3Group, data: compoundV3Data },
+      { group: listaGroup, data: listaData },
+      { group: eulerGroup, data: eulerData },
+      ...useMorphoGql ? [] : [{ group: morphoGroup, data: morphoData }]
+    ];
+    for (const { group, data } of groupResults) {
+      if (data.error) {
+        multicallErrors.push(`[${group.fetcherName}] ${data.error}`);
+      }
+    }
     const usdPrices = { ...basePrices };
-    const parseTracker = (tracker, updatePrices = true) => {
-      const dataSlice = multicallResult.slice(
-        tracker.offset,
-        tracker.offset + tracker.count
-      );
-      const context = {
-        chainId,
-        usdPrices,
-        tokenList
-      };
-      const entries = tracker.parse(dataSlice, tracker.meta, context);
-      for (const entry of entries) {
-        const lender = entry.targetLender ?? tracker.lender;
-        if (!chainResult[lender]) {
-          chainResult[lender] = [];
-        }
-        chainResult[lender].push(entry);
-        if (updatePrices) {
-          const oracleKey = tokenList[entry.asset]?.assetGroup ?? `${chainId}-${entry.asset}`;
-          usdPrices[oracleKey] = entry.priceUSD;
-          usdPrices[entry.asset] = entry.priceUSD;
+    const parseTrackers = (group, data, updatePrices = true, filter) => {
+      const trackers = filter ? group.trackers.filter(filter) : group.trackers;
+      for (const tracker of trackers) {
+        const failedCalls = countFailures(data, tracker.offset, tracker.count);
+        const diag2 = {
+          lender: tracker.lender,
+          callCount: tracker.count,
+          failedCalls,
+          parsedEntries: 0
+        };
+        try {
+          const dataSlice = data.slice(
+            tracker.offset,
+            tracker.offset + tracker.count
+          );
+          const context = { chainId, usdPrices, tokenList };
+          const entries = tracker.parse(dataSlice, tracker.meta, context);
+          diag2.parsedEntries = entries.length;
+          for (const entry of entries) {
+            const lender = entry.targetLender ?? tracker.lender;
+            if (!chainResult[lender]) {
+              chainResult[lender] = [];
+            }
+            chainResult[lender].push(entry);
+            if (updatePrices) {
+              const oracleKey = tokenList[entry.asset]?.assetGroup ?? `${chainId}-${entry.asset}`;
+              usdPrices[oracleKey] = entry.priceUSD;
+              usdPrices[entry.asset] = entry.priceUSD;
+            }
+          }
+        } catch (e) {
+          diag2.parseError = e instanceof Error ? e.message : String(e);
         }
+        trackerDiags.push(diag2);
       }
     };
-    const nonMorphoTrackers = fetcherTracker.filter(
-      (t) => t.parse !== morphoFetcher.parse
-    );
-    const aaveSourceTrackers = nonMorphoTrackers.filter(
-      (t) => t.parse === aaveFetcher.parse && !t.meta.baseAssetSource
+    parseTrackers(
+      aaveGroup,
+      aaveData.results,
+      true,
+      (t) => !t.meta.baseAssetSource
     );
-    const aaveDependentTrackers = nonMorphoTrackers.filter(
-      (t) => t.parse === aaveFetcher.parse && t.meta.baseAssetSource
-    );
-    const otherTrackers = nonMorphoTrackers.filter(
-      (t) => t.parse !== aaveFetcher.parse
-    );
-    for (const tracker of aaveSourceTrackers) {
-      parseTracker(tracker);
-    }
-    for (const tracker of otherTrackers) {
-      parseTracker(tracker);
-    }
-    for (const tracker of aaveDependentTrackers) {
-      parseTracker(tracker);
+    parseTrackers(compoundV2Group, compoundV2Data.results);
+    parseTrackers(compoundV3Group, compoundV3Data.results);
+    parseTrackers(listaGroup, listaData.results);
+    parseTrackers(eulerGroup, eulerData.results);
+    if (stalenessThresholdSeconds > 0) {
+      const nowSeconds = Math.floor(Date.now() / 1e3);
+      for (const tracker of compoundV3Group.trackers) {
+        const meta = tracker.meta;
+        for (let i = 0; i < tracker.count; i++) {
+          const raw = compoundV3Data.results[tracker.offset + i];
+          if (!raw || raw === "0x" || !Array.isArray(raw)) continue;
+          const updatedAt = Number(raw[3]);
+          if (updatedAt > 0) {
+            const staleSeconds = nowSeconds - updatedAt;
+            if (staleSeconds > stalenessThresholdSeconds) {
+              const queryMeta = meta[i];
+              staleFeeds.push({
+                asset: queryMeta?.asset?.toLowerCase() ?? "unknown",
+                lender: queryMeta?.lender ?? tracker.lender,
+                oracle: queryMeta?.oracle ?? "unknown",
+                staleSeconds
+              });
+            }
+          }
+        }
+      }
     }
-    const morphoTrackers = fetcherTracker.filter(
-      (t) => t.parse === morphoFetcher.parse
+    parseTrackers(
+      aaveGroup,
+      aaveData.results,
+      true,
+      (t) => !!t.meta.baseAssetSource
     );
-    for (const tracker of morphoTrackers) {
-      parseTracker(tracker, false);
+    if (useMorphoGql) {
+      const morphoGqlDiag = {
+        lender: "MORPHO_BLUE (GraphQL)",
+        callCount: 0,
+        failedCalls: 0,
+        parsedEntries: morphoGqlEntries.length
+      };
+      for (const entry of morphoGqlEntries) {
+        const lender = entry.targetLender ?? "MORPHO_BLUE";
+        if (!chainResult[lender]) chainResult[lender] = [];
+        chainResult[lender].push(entry);
+      }
+      trackerDiags.push(morphoGqlDiag);
+    } else {
+      for (const tracker of morphoGroup.trackers) {
+        const meta = tracker.meta;
+        if (meta.markets) {
+          for (const market of meta.markets) {
+            const loanAsset = market.loanAsset?.toLowerCase();
+            const collateralAsset = market.collateralAsset?.toLowerCase();
+            const loanOracleKey = tokenList[loanAsset]?.assetGroup ?? `${chainId}-${loanAsset}`;
+            const collateralOracleKey = tokenList[collateralAsset]?.assetGroup ?? `${chainId}-${collateralAsset}`;
+            const hasLoanPrice = usdPrices[loanOracleKey] !== void 0 || usdPrices[loanAsset] !== void 0;
+            const hasCollateralPrice = usdPrices[collateralOracleKey] !== void 0 || usdPrices[collateralAsset] !== void 0;
+            if (!hasLoanPrice && !hasCollateralPrice) {
+              unresolvedMorphoMarkets.push(
+                `${market.oracle}:${loanAsset}/${collateralAsset}`
+              );
+            }
+          }
+        }
+      }
+      parseTrackers(morphoGroup, morphoData.results, false);
     }
-    return { chainId, data: chainResult };
+    const totalFailedCalls = trackerDiags.reduce(
+      (sum, d) => sum + d.failedCalls,
+      0
+    );
+    const totalParsedEntries = trackerDiags.reduce(
+      (sum, d) => sum + d.parsedEntries,
+      0
+    );
+    const diag = {
+      chainId,
+      totalCalls,
+      totalFailedCalls,
+      totalParsedEntries,
+      durationMs: Date.now() - chainStart,
+      trackers: trackerDiags,
+      getCallsErrors,
+      chainError: multicallErrors.length > 0 ? multicallErrors.join("; ") : void 0,
+      unresolvedMorphoMarkets,
+      staleFeeds
+    };
+    return { chainId, data: chainResult, diagnostic: diag };
   });
-  const chainResults = await Promise.all(chainPromises);
-  for (const { chainId, data } of chainResults) {
-    result[chainId] = data;
+  const settled = await Promise.allSettled(chainPromises);
+  const chainDiagnostics = [];
+  const failedChains = [];
+  for (let i = 0; i < settled.length; i++) {
+    const settlement = settled[i];
+    const chainId = chainIds[i];
+    if (settlement.status === "fulfilled") {
+      const { data, diagnostic } = settlement.value;
+      result[chainId] = data;
+      chainDiagnostics.push(diagnostic);
+    } else {
+      failedChains.push(chainId);
+      chainDiagnostics.push({
+        chainId,
+        totalCalls: 0,
+        totalFailedCalls: 0,
+        totalParsedEntries: 0,
+        durationMs: 0,
+        trackers: [],
+        getCallsErrors: {},
+        chainError: settlement.reason instanceof Error ? settlement.reason.message : String(settlement.reason),
+        unresolvedMorphoMarkets: [],
+        staleFeeds: []
+      });
+    }
   }
-  return result;
+  const diagnostics = {
+    chains: chainDiagnostics,
+    totalDurationMs: Date.now() - totalStart,
+    failedChains
+  };
+  return { prices: result, diagnostics };
 }
 var DEFAULT_PRIORITY = {
   chainPriority: [
@@ -31175,7 +31568,7 @@ var FLASHLOAN_ENABLED_MASK = BigInt(
 function getFlashLoanEnabled(data) {
   return (data & ~FLASHLOAN_ENABLED_MASK) !== BigInt(0);
 }
-async function fetchFlashLiquidityForChain(chain, multicallRetry3, list = {}) {
+async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
   let callLengths = {};
   let aaveAssets = {};
   let aaveCalls = [];
@@ -31290,15 +31683,15 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry3, list = {}) {
     ...balancerV3Calls,
     ...uniswapV4Calls
   ];
-  const rawResults = await multicallRetry3(
+  const rawResults = await multicallRetry({
     chain,
     calls,
-    FlashAbi,
-    DEFAULT_BATCH_SIZE,
-    3,
-    0,
-    false
-  );
+    abi: FlashAbi,
+    batchSize: DEFAULT_BATCH_SIZE,
+    maxRetries: 3,
+    providerId: 0,
+    allowFailure: false
+  });
   let liquidity = {};
   let currentOffset = 0;
   aaveProtocols.forEach((aave) => {