@moonwell-fi/moonwell-sdk 0.11.0 → 0.12.0

package/actions/core/markets/getMarketSnapshots.ts

@@ -1,7 +1,6 @@
 import axios from "axios";
 import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
 import {
-  Amount,
   type SnapshotPeriod,
   applyGranularity,
   calculateTimeRange,
@@ -16,7 +15,6 @@ import type { MarketSnapshot } from "../../../types/market.js";
 import {
   DEFAULT_LUNAR_TIMEOUT_MS,
   createLunarIndexerClient,
-  shouldFallback,
 } from "../../lunar-indexer-client.js";
 import { transformMarketSnapshots } from "../../lunar-indexer-transformers.js";
 import {
@@ -93,9 +91,7 @@ export async function getMarketSnapshots<
     args.endTime,
   );
 
-  // Isolated markets can receive snapshots from multiple code paths (lunar indexer,
-  // Morpho Blue API, subgraph, or a mix). Apply a final sanity check to ensure
-  // totalSupply is always in loan token units.
+  // Apply a final sanity check to ensure totalSupply is always in loan token units.
   //
   // Some markets (e.g. USDC/ETH where collateral=USDC, loan=WETH) normalize
   // totalSupply to collateral units — skip the check for those because
@@ -144,103 +140,51 @@ async function fetchCoreMarketSnapshots(
   startTime?: number,
   endTime?: number,
 ): Promise<MarketSnapshot[]> {
-  if (environment.lunarIndexerUrl) {
+  if (!environment.lunarIndexerUrl) {
+    if (!environment.indexerUrl) return [];
     try {
-      const result = await fetchCoreMarketSnapshotsFromLunar(
+      return await fetchCoreMarketSnapshotsFromPonder(
         marketAddress,
         environment,
-        period,
-        startTime,
-        endTime,
       );
-      return result;
     } catch (error) {
-      if (!shouldFallback(error)) {
-        throw error;
-      }
-      console.debug(
-        "[Lunar fallback] Falling back to Ponder for snapshots:",
+      console.warn(
+        `[getMarketSnapshots] Ponder failed for chain ${environment.chainId}:`,
         error,
       );
+      environment.onError?.(error, {
+        source: "market-snapshots-ponder",
+        chainId: environment.chainId,
+      });
+      return [];
     }
   }
-
-  const result = await fetchCoreMarketSnapshotsFromPonder(
-    marketAddress,
-    environment,
-  );
-  return result;
-}
-
-async function fetchCoreMarketSnapshotsFromLunar(
-  marketAddress: string,
-  environment: Environment,
-  period?: "1M" | "3M" | "1Y" | "ALL",
-  customStartTime?: number,
-  customEndTime?: number,
-): Promise<MarketSnapshot[]> {
-  if (!environment.lunarIndexerUrl) {
-    throw new Error("Lunar Indexer URL not configured");
-  }
-
-  const client = createLunarIndexerClient({
-    baseUrl: environment.lunarIndexerUrl,
-    timeout: DEFAULT_LUNAR_TIMEOUT_MS,
-  });
-
-  const marketId = buildMarketId(environment.chainId, marketAddress);
-  const { startTime, endTime, granularity } = calculateTimeRange(
-    period,
-    customStartTime,
-    customEndTime,
-  );
-
-  const allSnapshots: MarketSnapshot[] = [];
-  let cursor: string | null = null;
-  const MAX_PAGES = 100;
-  let page = 0;
-
-  do {
-    const response = await client.getMarketSnapshots(marketId, {
-      limit: 1000,
-      ...(cursor && { cursor }),
-      granularity: toApiGranularity(granularity),
+  try {
+    return await fetchCoreMarketSnapshotsFromLunar(
+      marketAddress,
+      environment,
+      period,
       startTime,
       endTime,
-    });
-
-    const transformed = transformMarketSnapshots(
-      response.results,
-      environment.chainId,
     );
-
-    allSnapshots.push(...transformed);
-
-    cursor = response.nextCursor;
-    page++;
-  } while (cursor !== null && page < MAX_PAGES);
-
-  allSnapshots.sort((a, b) => a.timestamp - b.timestamp);
-  return applyGranularity(allSnapshots, granularity).map((snapshot) => {
-    const supplied = snapshot.totalSupply;
-    const suppliedUsd = snapshot.totalSupplyUsd;
-    const price = supplied > 0 ? suppliedUsd / supplied : 0;
-
-    return {
-      ...snapshot,
-      collateralTokenPrice: price,
-      loanTokenPrice: price,
-    };
-  });
+  } catch (error) {
+    console.warn(
+      `[getMarketSnapshots] Lunar Indexer failed for chain ${environment.chainId}:`,
+      error,
+    );
+    environment.onError?.(error, {
+      source: "market-snapshots",
+      chainId: environment.chainId,
+    });
+    return [];
+  }
 }
 
 async function fetchCoreMarketSnapshotsFromPonder(
   marketAddress: string,
   environment: Environment,
 ): Promise<MarketSnapshot[]> {
-  const dailyData: MarketDailyData[] = [];
-  let hasNextPage = true;
-  let endCursor: string | undefined;
+  if (!environment.indexerUrl) return [];
 
   interface MarketDailyData {
     totalBorrows: number;
@@ -254,15 +198,16 @@ async function fetchCoreMarketSnapshotsFromPonder(
     timestamp: number;
   }
 
+  const dailyData: MarketDailyData[] = [];
+  let hasNextPage = true;
+  let endCursor: string | undefined;
+
   while (hasNextPage) {
     const result = await axios.post<{
       data: {
         marketDailySnapshots: {
           items: MarketDailyData[];
-          pageInfo: {
-            hasNextPage: boolean;
-            endCursor: string;
-          };
+          pageInfo: { hasNextPage: boolean; endCursor: string };
         };
       };
     }>(environment.indexerUrl, {
@@ -304,78 +249,97 @@ async function fetchCoreMarketSnapshotsFromPonder(
     endCursor = result.data.data.marketDailySnapshots.pageInfo.endCursor;
   }
 
-  if (dailyData.length > 0) {
-    return dailyData.map((point: any) => {
-      const supplied = Number(point.totalSupplies);
-      const borrow = Number(point.totalBorrows);
+  if (dailyData.length === 0) return [];
 
-      const borrowUsd = Number(point.totalBorrowsUSD);
-      const suppliedUsd = Number(point.totalSuppliesUSD);
-      const liquidity = Math.max(point.totalLiquidity, 0);
-      const liquidityUsd = Math.max(point.totalLiquidityUSD, 0);
+  return dailyData.map((point) => {
+    const supplied = Number(point.totalSupplies);
+    const borrow = Number(point.totalBorrows);
+    const borrowUsd = Number(point.totalBorrowsUSD);
+    const suppliedUsd = Number(point.totalSuppliesUSD);
+    const liquidity = Math.max(point.totalLiquidity, 0);
+    const liquidityUsd = Math.max(point.totalLiquidityUSD, 0);
+    const price = suppliedUsd / supplied;
 
-      const price = suppliedUsd / supplied;
+    return {
+      marketId: marketAddress.toLowerCase(),
+      chainId: environment.chainId,
+      timestamp: point.timestamp * 1000,
+      totalSupply: supplied,
+      totalSupplyUsd: suppliedUsd,
+      totalBorrows: borrow,
+      totalBorrowsUsd: borrowUsd,
+      totalLiquidity: liquidity,
+      totalLiquidityUsd: liquidityUsd,
+      totalReallocatableLiquidity: 0,
+      totalReallocatableLiquidityUsd: 0,
+      baseSupplyApy: point.baseSupplyApy,
+      baseBorrowApy: point.baseBorrowApy,
+      collateralTokenPrice: price,
+      loanTokenPrice: price,
+    };
+  });
+}
 
-      const result: MarketSnapshot = {
-        marketId: marketAddress.toLowerCase(),
-        chainId: environment.chainId,
-        timestamp: point.timestamp * 1000,
-        totalSupply: supplied,
-        totalSupplyUsd: suppliedUsd,
-        totalBorrows: borrow,
-        totalBorrowsUsd: borrowUsd,
-        totalLiquidity: liquidity,
-        totalLiquidityUsd: liquidityUsd,
-        totalReallocatableLiquidity: 0,
-        totalReallocatableLiquidityUsd: 0,
-        baseSupplyApy: point.baseSupplyApy,
-        baseBorrowApy: point.baseBorrowApy,
-        collateralTokenPrice: price,
-        loanTokenPrice: price,
-      };
+async function fetchCoreMarketSnapshotsFromLunar(
+  marketAddress: string,
+  environment: Environment,
+  period?: "1M" | "3M" | "1Y" | "ALL",
+  customStartTime?: number,
+  customEndTime?: number,
+): Promise<MarketSnapshot[]> {
+  if (!environment.lunarIndexerUrl) {
+    throw new Error("Lunar Indexer URL not configured");
+  }
 
-      return result;
+  const client = createLunarIndexerClient({
+    baseUrl: environment.lunarIndexerUrl,
+    timeout: DEFAULT_LUNAR_TIMEOUT_MS,
+  });
+
+  const marketId = buildMarketId(environment.chainId, marketAddress);
+  const { startTime, endTime, granularity } = calculateTimeRange(
+    period,
+    customStartTime,
+    customEndTime,
+  );
+
+  const allSnapshots: MarketSnapshot[] = [];
+  let cursor: string | null = null;
+  const MAX_PAGES = 100;
+  let page = 0;
+
+  do {
+    const response = await client.getMarketSnapshots(marketId, {
+      limit: 1000,
+      ...(cursor && { cursor }),
+      granularity: toApiGranularity(granularity),
+      startTime,
+      endTime,
     });
-  } else {
-    return [];
-  }
-}
 
-async function fetchMorphoGraphQL(
-  environment: Environment,
-  query: string,
-  operationName?: string,
-  variables?: any,
-) {
-  try {
-    const url =
-      environment.custom.morpho?.apiUrl || "https://api.morpho.org/graphql";
-    const response = await axios.post(
-      url,
-      { query: query, operationName, variables },
-      { timeout: 5000 },
+    const transformed = transformMarketSnapshots(
+      response.results,
+      environment.chainId,
     );
 
-    if (response.status !== 200 || response.data.errors) {
-      if (typeof window !== "undefined") {
-        console.debug(
-          `[Morpho GraphQL Market Snapshots] Non-200 (${response.statusText}) or errors:`,
-          response.data.errors,
-        );
-      }
-      return undefined;
-    }
+    allSnapshots.push(...transformed);
 
-    return response.data.data;
-  } catch (error) {
-    if (typeof window !== "undefined") {
-      console.debug(
-        "[Morpho GraphQL Market Snapshots] Error fetching data:",
-        error,
-      );
-    }
-    return undefined;
-  }
+    cursor = response.nextCursor;
+    page++;
+  } while (cursor !== null && page < MAX_PAGES);
+
+  allSnapshots.sort((a, b) => a.timestamp - b.timestamp);
+  return applyGranularity(allSnapshots, granularity).map((snapshot) => {
+    const supplied = snapshot.totalSupply;
+    const suppliedUsd = snapshot.totalSupplyUsd;
+    const price = supplied > 0 ? suppliedUsd / supplied : 0;
+
+    return {
+      ...snapshot,
+      collateralTokenPrice: price,
+      loanTokenPrice: price,
+    };
+  });
 }
 
 // Fetches a timestamp-ms → WELL price map from the WELL market in the indexer.
@@ -432,386 +396,172 @@ export async function fetchIsolatedMarketSnapshots(
 ): Promise<MarketSnapshot[]> {
   const lunarIndexerUrl = environment.lunarIndexerUrl;
 
-  if (lunarIndexerUrl) {
-    try {
-      const { startTime } = calculateTimeRange(
-        period,
-        customStartTime,
-        customEndTime,
-      );
-
-      // The USDC/ETH market (collateral = USDC, loan = WETH) needs normalization:
-      // the indexer returns totalSupplyAssets in WETH units but the chart needs
-      // USDC-equivalent units (totalSupplyAssetsUsd / collateralTokenPrice).
-      const marketConfig = Object.values(environment.config.morphoMarkets).find(
-        (m) => m.id.toLowerCase() === marketAddress.toLowerCase(),
-      );
-      const loanSymbol = marketConfig
-        ? environment.config.tokens[marketConfig.loanToken]?.symbol
-        : undefined;
-      const collateralSymbol = marketConfig
-        ? environment.config.tokens[marketConfig.collateralToken]?.symbol
-        : undefined;
-      const normalizeToCollateral =
-        loanSymbol === "ETH" && collateralSymbol === "USDC";
-
-      // stkWELL is not priced by the indexer (same oracle as WELL but unrecognized).
-      // Fetch the WELL market snapshots concurrently and use their prices to correct
-      // any stkWELL snapshots where collateralTokenPrice is 0.
-      const isStkWellMarket = collateralSymbol === "stkWELL";
-      const wellMarketConfig = isStkWellMarket
-        ? Object.values(environment.config.morphoMarkets).find(
-            (m) => m.collateralToken === "WELL" || m.loanToken === "WELL",
-          )
-        : undefined;
-
-      const wellPricesPromise = wellMarketConfig
-        ? fetchWellPricesByTimestamp(
-            lunarIndexerUrl,
-            environment.chainId,
-            wellMarketConfig,
-            startTime,
-          )
-        : Promise.resolve(new Map<number, number>());
-
-      const allSnapshots: MarketSnapshot[] = [];
-      let cursor: string | undefined;
-      const MAX_PAGES = 100;
-      let page = 0;
-
-      do {
-        const response = await fetchMarketSnapshotsFromIndexer(
-          lunarIndexerUrl,
-          environment.chainId,
-          marketAddress,
-          {
-            startTime,
-            granularity: "1d",
-            limit: 1000,
-            ...(cursor && { cursor }),
-          },
-        );
-
-        allSnapshots.push(
-          ...response.results
-            .filter((s) => isStartOfDay(s.timestamp))
-            .map((s) =>
-              transformIsolatedMarketSnapshotFromIndexer(s, {
-                normalizeToCollateral,
-              }),
-            ),
-        );
-
-        cursor = response.nextCursor ?? undefined;
-        page++;
-      } while (cursor !== undefined && page < MAX_PAGES);
-
-      // Sanity check for non-normalized markets: detect when totalSupplyAssets was
-      // stored in collateral units instead of loan token units (an indexer bug seen on
-      // the stkWELL/USDC market). When this happens, totalSupplyUsd / totalSupply is
-      // close to collateralTokenPrice rather than loanTokenPrice. Recover the correct
-      // loan-token amount from the USD value instead of discarding the data point.
-      // We skip normalized markets (e.g. USDC/ETH where totalSupply is already in
-      // collateral units after normalization) to avoid false corrections.
-      const sanitizedSnapshots = normalizeToCollateral
-        ? allSnapshots
-        : allSnapshots.map((snapshot) => {
-            if (snapshot.totalSupply === 0 || snapshot.loanTokenPrice === 0)
-              return snapshot;
-            const impliedLoanPrice =
-              snapshot.totalSupplyUsd / snapshot.totalSupply;
-            if (impliedLoanPrice < snapshot.loanTokenPrice * 0.1) {
-              return {
-                ...snapshot,
-                totalSupply: snapshot.totalSupplyUsd / snapshot.loanTokenPrice,
-                totalLiquidity:
-                  snapshot.totalLiquidityUsd / snapshot.loanTokenPrice,
-              };
-            }
-            return snapshot;
-          });
-
-      if (isStkWellMarket) {
-        const wellPriceByTimestampMs = await wellPricesPromise;
-        return sanitizedSnapshots.map((snapshot) => {
-          // Resolve the collateral (stkWELL) price: use indexed price when available,
-          // fall back to the WELL market price fetched concurrently.
-          let collateralTokenPrice = snapshot.collateralTokenPrice;
-          if (collateralTokenPrice === 0) {
-            const wellPrice = wellPriceByTimestampMs.get(snapshot.timestamp);
-            if (wellPrice) collateralTokenPrice = wellPrice;
-          }
-
-          // The lunar indexer stores totalSupplyAssets in loan-token (USDC) units.
-          // All fallback paths (BlueAPI, subgraph) convert to collateral (stkWELL) units:
-          //   totalSupply = totalSupplyUsd / collateralTokenPrice
-          // Apply the same conversion here so the chart axis is consistent.
-          const totalSupply =
-            collateralTokenPrice > 0
-              ? snapshot.totalSupplyUsd / collateralTokenPrice
-              : snapshot.totalSupply;
-          const totalLiquidity =
-            collateralTokenPrice > 0
-              ? snapshot.totalLiquidityUsd / collateralTokenPrice
-              : snapshot.totalLiquidity;
-          const totalReallocatableLiquidity =
-            collateralTokenPrice > 0
-              ? snapshot.totalReallocatableLiquidityUsd / collateralTokenPrice
-              : snapshot.totalReallocatableLiquidity;
-
-          return {
-            ...snapshot,
-            collateralTokenPrice,
-            totalSupply,
-            totalLiquidity,
-            totalReallocatableLiquidity,
-          };
-        });
-      }
-
-      return sanitizedSnapshots;
-    } catch (error) {
-      if (!shouldFallback(error)) {
-        throw error;
-      }
-      console.debug(
-        "[Lunar fallback] Falling back for isolated market snapshots:",
-        error,
-      );
-    }
+  if (!lunarIndexerUrl) {
+    return [];
   }
 
-  return fetchIsolatedMarketSnapshotsFromBlueApi(
-    marketAddress,
-    environment,
-    period,
-    customStartTime,
-    customEndTime,
-  );
+  try {
+    return await fetchIsolatedMarketSnapshotsFromLunar(
+      marketAddress,
+      environment,
+      lunarIndexerUrl,
+      period,
+      customStartTime,
+      customEndTime,
+    );
+  } catch (error) {
+    console.warn(
+      `[getMarketSnapshots] Lunar Indexer failed for chain ${environment.chainId}:`,
+      error,
+    );
+    environment.onError?.(error, {
+      source: "market-snapshots",
+      chainId: environment.chainId,
+    });
+    return [];
+  }
 }
 
-async function fetchIsolatedMarketSnapshotsFromBlueApi(
+async function fetchIsolatedMarketSnapshotsFromLunar(
   marketAddress: string,
   environment: Environment,
+  lunarIndexerUrl: string,
   period?: "1M" | "3M" | "1Y" | "ALL",
   customStartTime?: number,
   customEndTime?: number,
 ): Promise<MarketSnapshot[]> {
+  const { startTime } = calculateTimeRange(
+    period,
+    customStartTime,
+    customEndTime,
+  );
+
+  // The USDC/ETH market (collateral = USDC, loan = WETH) needs normalization:
+  // the indexer returns totalSupplyAssets in WETH units but the chart needs
+  // USDC-equivalent units (totalSupplyAssetsUsd / collateralTokenPrice).
   const marketConfig = Object.values(environment.config.morphoMarkets).find(
-    (market) => market.id.toLowerCase() === marketAddress.toLowerCase(),
+    (m) => m.id.toLowerCase() === marketAddress.toLowerCase(),
   );
+  const loanSymbol = marketConfig
+    ? environment.config.tokens[marketConfig.loanToken]?.symbol
+    : undefined;
+  const collateralSymbol = marketConfig
+    ? environment.config.tokens[marketConfig.collateralToken]?.symbol
+    : undefined;
+  const normalizeToCollateral =
+    loanSymbol === "ETH" && collateralSymbol === "USDC";
+
+  // stkWELL is not priced by the indexer (same oracle as WELL but unrecognized).
+  // Fetch the WELL market snapshots concurrently and use their prices to correct
+  // any stkWELL snapshots where collateralTokenPrice is 0.
+  const isStkWellMarket = collateralSymbol === "stkWELL";
+  const wellMarketConfig = isStkWellMarket
+    ? Object.values(environment.config.morphoMarkets).find(
+        (m) => m.collateralToken === "WELL" || m.loanToken === "WELL",
+      )
+    : undefined;
 
-  const isStkWellMarket =
-    marketConfig &&
-    environment.config.tokens[marketConfig.collateralToken]?.symbol ===
-      "stkWELL";
+  const wellPricesPromise = wellMarketConfig
+    ? fetchWellPricesByTimestamp(
+        lunarIndexerUrl,
+        environment.chainId,
+        wellMarketConfig,
+        startTime,
+      )
+    : Promise.resolve(new Map<number, number>());
 
-  // If stkWELL market, fetch WELL price from subgraph. stkWELL and WELL have the same price
-  let wellPrice: number | null = null;
-  if (isStkWellMarket) {
-    const wellMarketConfig = Object.values(
-      environment.config.morphoMarkets,
-    ).find(
-      (market) =>
-        market.collateralToken === "WELL" || market.loanToken === "WELL",
-    );
+  const allSnapshots: MarketSnapshot[] = [];
+  let cursor: string | undefined;
+  const MAX_PAGES = 100;
+  let page = 0;
 
-    if (wellMarketConfig) {
-      const wellQuery = `    
-        query getWellPrice {
-          wellMarket: marketByUniqueKey(
-            chainId: ${environment.chainId}
-            uniqueKey: "${wellMarketConfig.id.toLowerCase()}"
-          ) {
-            loanAsset {
-              priceUsd
-            }
-            collateralAsset {
-              priceUsd
-            }
-          }
-        }`;
+  do {
+    const response = await fetchMarketSnapshotsFromIndexer(
+      lunarIndexerUrl,
+      environment.chainId,
+      marketAddress,
+      {
+        startTime,
+        granularity: "1d",
+        limit: 1000,
+        ...(cursor && { cursor }),
+      },
+    );
 
-      const wellResult = await fetchMorphoGraphQL(
-        environment,
-        wellQuery,
-        "getWellPrice",
-      );
-      if (wellResult?.wellMarket) {
-        wellPrice =
-          wellMarketConfig.collateralToken === "WELL"
-            ? wellResult.wellMarket.collateralAsset.priceUsd
-            : wellResult.wellMarket.loanAsset.priceUsd;
-      }
-    }
-  }
+    allSnapshots.push(
+      ...response.results
+        .filter((s) => isStartOfDay(s.timestamp))
+        .map((s) =>
+          transformIsolatedMarketSnapshotFromIndexer(s, {
+            normalizeToCollateral,
+          }),
+        ),
+    );
 
-  const operationName = "getMarketTotalTimeseries";
+    cursor = response.nextCursor ?? undefined;
+    page++;
+  } while (cursor !== undefined && page < MAX_PAGES);
 
-  const { startTime } = calculateTimeRange(
-    period,
-    customStartTime,
-    customEndTime,
-  );
-  const variables = {
-    options: {
-      startTimestamp: startTime,
-      interval: "DAY",
-    },
-  };
-
-  const query = `    
-    query getMarketTotalTimeseries($options: TimeseriesOptions) {
-      marketTotalTimeseries: marketByUniqueKey(
-        chainId: ${environment.chainId}
-        uniqueKey: "${marketAddress.toLowerCase()}"
-      ) {
-        uniqueKey
-        loanAsset {
-          priceUsd
-          decimals
-        }
-        collateralAsset {
-          priceUsd
-          decimals
-        }
-        historicalState {
-         supplyApy(options: $options) {
-            x
-            y
-          }
-          borrowApy(options: $options) {
-            x
-            y
-          }
-          borrowAssets(options: $options) {
-            x
-            y
-          }
-          borrowAssetsUsd(options: $options) {
-            x
-            y
-          }
-          supplyAssets(options: $options) {
-            x
-            y
-          }
-          supplyAssetsUsd(options: $options) {
-            x
-            y
-          }
-          liquidityAssets(options: $options) {
-            x
-            y
-          }
-          liquidityAssetsUsd(options: $options) {
-            x
-            y
-          }
+  // Sanity check for non-normalized markets: detect when totalSupplyAssets was
+  // stored in collateral units instead of loan token units (an indexer bug seen on
+  // the stkWELL/USDC market). When this happens, totalSupplyUsd / totalSupply is
+  // close to collateralTokenPrice rather than loanTokenPrice. Recover the correct
+  // loan-token amount from the USD value instead of discarding the data point.
+  // We skip normalized markets (e.g. USDC/ETH where totalSupply is already in
+  // collateral units after normalization) to avoid false corrections.
+  const sanitizedSnapshots = normalizeToCollateral
+    ? allSnapshots
+    : allSnapshots.map((snapshot) => {
+        if (snapshot.totalSupply === 0 || snapshot.loanTokenPrice === 0)
+          return snapshot;
+        const impliedLoanPrice = snapshot.totalSupplyUsd / snapshot.totalSupply;
+        if (impliedLoanPrice < snapshot.loanTokenPrice * 0.1) {
+          return {
+            ...snapshot,
+            totalSupply: snapshot.totalSupplyUsd / snapshot.loanTokenPrice,
+            totalLiquidity:
+              snapshot.totalLiquidityUsd / snapshot.loanTokenPrice,
+          };
         }
-      }
-    }`;
-
-  const result = await fetchMorphoGraphQL(
-    environment,
-    query,
-    operationName,
-    variables,
-  );
+        return snapshot;
+      });
 
-  if (result) {
-    try {
-      const markets: MarketSnapshot[] =
-        result.marketTotalTimeseries.historicalState.borrowAssets.map(
-          (
-            borrowAssets: {
-              x: number;
-              y: number;
-            },
-            index: number,
-          ): MarketSnapshot => {
-            const loanDecimals =
-              result.marketTotalTimeseries.loanAsset.decimals;
-
-            const borrowAssetsUsd =
-              result.marketTotalTimeseries.historicalState.borrowAssetsUsd[
-                index
-              ];
-
-            const supplyAssets =
-              result.marketTotalTimeseries.historicalState.supplyAssets[index];
-
-            const supplyAssetsUsd =
-              result.marketTotalTimeseries.historicalState.supplyAssetsUsd[
-                index
-              ];
-
-            const liquidityAssets =
-              result.marketTotalTimeseries.historicalState.liquidityAssets[
-                index
-              ];
-
-            const liquidityAssetsUsd =
-              result.marketTotalTimeseries.historicalState.liquidityAssetsUsd[
-                index
-              ];
-
-            const supplyApy =
-              result.marketTotalTimeseries.historicalState.supplyApy[index];
-
-            const borrowApy =
-              result.marketTotalTimeseries.historicalState.borrowApy[index];
-
-            let collateralTokenPrice =
-              result.marketTotalTimeseries.collateralAsset.priceUsd;
-            const loanTokenPrice =
-              result.marketTotalTimeseries.loanAsset.priceUsd;
-
-            if (isStkWellMarket && wellPrice !== null) {
-              collateralTokenPrice = wellPrice;
-            }
+  if (isStkWellMarket) {
+    const wellPriceByTimestampMs = await wellPricesPromise;
+    return sanitizedSnapshots.map((snapshot) => {
+      // Resolve the collateral (stkWELL) price: use indexed price when available,
+      // fall back to the WELL market price fetched concurrently.
+      let collateralTokenPrice = snapshot.collateralTokenPrice;
+      if (collateralTokenPrice === 0) {
+        const wellPrice = wellPriceByTimestampMs.get(snapshot.timestamp);
+        if (wellPrice) collateralTokenPrice = wellPrice;
+      }
 
-            const totalSupply =
-              (new Amount(BigInt(supplyAssets.y), Number(loanDecimals)).value *
-                loanTokenPrice) /
-              collateralTokenPrice;
-
-            const totalBorrows = new Amount(
-              BigInt(borrowAssets.y),
-              Number(loanDecimals),
-            ).value;
-
-            const totalLiquidity =
-              (new Amount(BigInt(liquidityAssets.y), Number(loanDecimals))
-                .value *
-                loanTokenPrice) /
-              collateralTokenPrice;
-
-            return {
-              chainId: environment.chainId,
-              timestamp: borrowAssets.x * 1000,
-              marketId: marketAddress.toLowerCase(),
-              totalBorrows,
-              totalBorrowsUsd: Number(borrowAssetsUsd.y),
-              totalSupply,
-              totalSupplyUsd: Number(supplyAssetsUsd.y),
-              totalLiquidity,
-              totalLiquidityUsd: Number(liquidityAssetsUsd.y),
-              totalReallocatableLiquidity: 0,
-              totalReallocatableLiquidityUsd: 0,
-              baseSupplyApy: supplyApy.y,
-              baseBorrowApy: borrowApy.y,
-              loanTokenPrice,
-              collateralTokenPrice,
-            };
-          },
-        );
-
-      return markets;
-    } catch (ex) {
-      return [];
-    }
-  } else {
-    return [];
+      // The lunar indexer stores totalSupplyAssets in loan-token (USDC) units.
+      // Convert to collateral (stkWELL) units for a consistent chart axis:
+      //   totalSupply = totalSupplyUsd / collateralTokenPrice
+      const totalSupply =
+        collateralTokenPrice > 0
+          ? snapshot.totalSupplyUsd / collateralTokenPrice
+          : snapshot.totalSupply;
+      const totalLiquidity =
+        collateralTokenPrice > 0
+          ? snapshot.totalLiquidityUsd / collateralTokenPrice
+          : snapshot.totalLiquidity;
+      const totalReallocatableLiquidity =
+        collateralTokenPrice > 0
+          ? snapshot.totalReallocatableLiquidityUsd / collateralTokenPrice
+          : snapshot.totalReallocatableLiquidity;
+
+      return {
+        ...snapshot,
+        collateralTokenPrice,
+        totalSupply,
+        totalLiquidity,
+        totalReallocatableLiquidity,
+      };
+    });
   }
+
+  return sanitizedSnapshots;
 }