@moonwell-fi/moonwell-sdk 0.11.0 → 0.12.0

package/actions/morpho/markets/common.ts

@@ -8,7 +8,6 @@ import type {
   PublicAllocatorSharedLiquidityType,
 } from "../../../types/morphoMarket.js";
 import type { MorphoReward } from "../../../types/morphoReward.js";
-import { shouldFallback } from "../../lunar-indexer-client.js";
 import { getGraphQL } from "../utils/graphql.js";
 import {
   type GetMorphoMarketsRewardsReturnType as LunarIndexerRewardsType,
@@ -829,7 +828,10 @@ async function getMorphoMarketsDataFromIndexer(params: {
           `Failed to fetch markets from Lunar Indexer for chain ${environment.chainId}, falling back to on-chain:`,
           error,
         );
-        // Return rejection so we can fall back to on-chain for this environment
+        environment.onError?.(error, {
+          source: "morpho-markets",
+          chainId: environment.chainId,
+        });
         return Promise.reject({ environment, error });
       }
     }),
@@ -841,9 +843,9 @@ async function getMorphoMarketsDataFromIndexer(params: {
 
   // Collect environments that failed to fetch from indexer for fallback
   const failedEnvironments = marketsSettlements
-    .filter((s) => s.status === "rejected")
-    .map((s: any) => s.reason?.environment)
-    .filter((env) => env !== undefined);
+    .filter((s): s is PromiseRejectedResult => s.status === "rejected")
+    .map((s) => (s.reason as { environment?: Environment }).environment)
+    .filter((env): env is Environment => env !== undefined);
 
   // Fall back to on-chain for environments where indexer failed
   let fallbackMarkets: MorphoMarket[] = [];
@@ -851,16 +853,27 @@ async function getMorphoMarketsDataFromIndexer(params: {
     console.warn(
       `Falling back to on-chain for ${failedEnvironments.length} environment(s)`,
     );
-    fallbackMarkets = await getMorphoMarketsDataFromOnChain({
-      environments: failedEnvironments,
-      markets: params.markets,
-      includeRewards: params.includeRewards,
-    });
+    try {
+      fallbackMarkets = await getMorphoMarketsDataFromOnChain({
+        environments: failedEnvironments,
+        markets: params.markets,
+        includeRewards: params.includeRewards,
+      });
+    } catch (rpcError) {
+      console.warn(
+        `RPC fallback also failed for ${failedEnvironments.length} environment(s):`,
+        rpcError,
+      );
+      for (const env of failedEnvironments) {
+        env.onError?.(rpcError, {
+          source: "morpho-markets-rpc-fallback",
+          chainId: env.chainId,
+        });
+      }
+    }
   }
 
-  // Fetch shared liquidity from lunar-indexer, tracking which environments
-  // fell back so we can fill them from api.morpho.org after.
-  const fallbackChainIds = new Set<number>();
+  // Fetch shared liquidity from lunar-indexer.
   const sharedLiquiditySettlements = await Promise.allSettled(
     fulfilledMarkets.map(async ({ environment, markets }) => {
       const lunarIndexerUrl = environment.lunarIndexerUrl;
@@ -903,12 +916,14 @@ async function getMorphoMarketsDataFromIndexer(params: {
         );
         return { environment, data };
       } catch (error) {
-        if (!shouldFallback(error)) throw error;
-        console.debug(
-          "[Lunar fallback] Falling back to Morpho API for shared liquidity:",
+        console.warn(
+          `[getMorphoMarketsData] Lunar shared liquidity failed for chain ${environment.chainId}:`,
           error,
         );
-        fallbackChainIds.add(environment.chainId);
+        environment.onError?.(error, {
+          source: "morpho-shared-liquidity",
+          chainId: environment.chainId,
+        });
         return {
           environment,
           data: [] as GetMorphoMarketsPublicAllocatorSharedLiquidityReturnType[],
@@ -963,32 +978,6 @@ async function getMorphoMarketsDataFromIndexer(params: {
     });
   });
 
-  // Fallback: if the lunar shared-liquidity endpoint failed for some environments,
-  // fetch publicAllocatorSharedLiquidity from the Morpho API for those environments only.
-  if (fallbackChainIds.size > 0) {
-    const fallbackMarketIds = fulfilledMarkets
-      .filter(({ environment }) => fallbackChainIds.has(environment.chainId))
-      .flatMap(({ environment, markets }) =>
-        markets.map((m) => ({
-          marketId: m.marketId,
-          chainId: environment.chainId,
-        })),
-      );
-    const rewardEnvironment =
-      params.environments.find((env) => env.custom?.morpho?.apiUrl) ??
-      params.environments[0];
-    const morphoApiData = await getMorphoMarketRewards(
-      rewardEnvironment,
-      fallbackMarketIds,
-    );
-    morphoApiData.forEach((item) => {
-      const key = `${item.chainId}-${item.marketId.toLowerCase()}`;
-      if (!sharedLiquidityMap.has(key)) {
-        sharedLiquidityMap.set(key, item.publicAllocatorSharedLiquidity);
-      }
-    });
-  }
-
   // Overlay rewards from the indexer when requested
   if (params.includeRewards) {
     fulfilledMarkets.forEach(({ environment, markets }) => {

package/actions/morpho/user-positions/getMorphoVaultUserPositionSnapshots.ts

@@ -1,9 +1,6 @@
-import axios from "axios";
-import dayjs from "dayjs";
-import utc from "dayjs/plugin/utc.js";
 import type { Address } from "viem";
 import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
-import { getEnvironmentFromArgs, isStartOfDay } from "../../../common/index.js";
+import { getEnvironmentFromArgs } from "../../../common/index.js";
 import type { NetworkParameterType } from "../../../common/types.js";
 import type {
   Chain,
@@ -15,11 +12,8 @@ import type { MorphoVaultUserPositionSnapshot } from "../../../types/morphoUserP
 import {
   DEFAULT_LUNAR_TIMEOUT_MS,
   createLunarIndexerClient,
-  shouldFallback,
 } from "../../lunar-indexer-client.js";
 
-dayjs.extend(utc);
-
 export type GetMorphoVaultUserPositionSnapshotsParameters<
   environments,
   network extends Chain | undefined,
@@ -61,36 +55,30 @@ export async function getMorphoVaultUserPositionSnapshots<
   const vaultAddress: Address | undefined =
     rawVaultAddress ?? (vault ? environment.vaults[vault].address : undefined);
 
-  const lunarIndexerUrl = environment.custom?.morpho?.lunarIndexerUrl;
+  const lunarIndexerUrl = environment.lunarIndexerUrl;
 
-  if (lunarIndexerUrl) {
-    try {
-      return await fetchUserPositionSnapshotsFromLunar(
-        args.userAddress,
-        vaultAddress,
-        lunarIndexerUrl,
-        environment,
-      );
-    } catch (error) {
-      if (!shouldFallback(error)) {
-        throw error;
-      }
-      console.debug(
-        "[Lunar fallback] Falling back to Ponder for vault user position snapshots:",
-        error,
-      );
-    }
+  if (!lunarIndexerUrl) {
+    return [];
   }
 
-  if (!vaultAddress) {
+  try {
+    return await fetchUserPositionSnapshotsFromLunar(
+      args.userAddress,
+      vaultAddress,
+      lunarIndexerUrl,
+      environment,
+    );
+  } catch (error) {
+    console.warn(
+      `[getMorphoVaultUserPositionSnapshots] Lunar Indexer failed for chain ${environment.chainId}:`,
+      error,
+    );
+    environment.onError?.(error, {
+      source: "morpho-vault-user-position-snapshots",
+      chainId: environment.chainId,
+    });
     return [];
   }
-
-  return fetchUserPositionSnapshots(
-    args.userAddress,
-    vaultAddress,
-    environment,
-  );
 }
 
 async function fetchUserPositionSnapshotsFromLunar(
@@ -131,80 +119,3 @@ async function fetchUserPositionSnapshotsFromLunar(
 
   return snapshots;
 }
-
-async function fetchUserPositionSnapshots(
-  userAddress: Address,
-  vaultAddress: Address,
-  environment: Environment,
-): Promise<MorphoVaultUserPositionSnapshot[]> {
-  const dailyData: MorphoVaultUserDailyData[] = [];
-  let hasNextPage = true;
-  let endCursor: string | undefined;
-
-  interface MorphoVaultUserDailyData {
-    totalSuppliesUSD: string;
-    timestamp: number;
-  }
-
-  while (hasNextPage) {
-    const result = await axios.post<{
-      data: {
-        accountVaultDailySnapshots: {
-          items: MorphoVaultUserDailyData[];
-          pageInfo: {
-            hasNextPage: boolean;
-            endCursor: string;
-          };
-        };
-      };
-    }>(environment.indexerUrl, {
-      query: `
-          query {
-            accountVaultDailySnapshots(
-              limit: 365,
-              orderDirection: "desc",
-              orderBy: "timestamp",
-              where: { vaultAddress: "${vaultAddress.toLowerCase()}", accountAddress: "${userAddress.toLowerCase()}", chainId: ${environment.chainId} }
-              ${endCursor ? `after: "${endCursor}"` : ""}
-            ) {
-              items {
-                totalSuppliesUSD
-                timestamp
-              }
-              pageInfo {
-                hasNextPage
-                endCursor
-              }
-            }
-          }
-        `,
-    });
-
-    dailyData.push(
-      ...result.data.data.accountVaultDailySnapshots.items.filter(
-        (f: { timestamp: number }) => isStartOfDay(f.timestamp),
-      ),
-    );
-    hasNextPage =
-      result.data.data.accountVaultDailySnapshots.pageInfo.hasNextPage;
-    endCursor = result.data.data.accountVaultDailySnapshots.pageInfo.endCursor;
-  }
-
-  if (dailyData.length > 0) {
-    return dailyData.map((point: MorphoVaultUserDailyData) => {
-      const suppliedUsd = Number(point.totalSuppliesUSD);
-
-      const result: MorphoVaultUserPositionSnapshot = {
-        chainId: environment.chainId,
-        timestamp: point.timestamp * 1000,
-        suppliedUsd: suppliedUsd,
-        account: userAddress,
-        vaultAddress: vaultAddress,
-      };
-
-      return result;
-    });
-  } else {
-    return [];
-  }
-}

package/actions/morpho/vaults/common.ts

@@ -153,14 +153,13 @@ async function getMorphoVaultsDataFromIndexer(params: {
   // Filter environments that have vaults and Lunar Indexer URL configured
   const environmentsWithVaults = environments.filter(
     (environment) =>
-      Object.keys(environment.vaults).length > 0 &&
-      environment.custom?.morpho?.lunarIndexerUrl,
+      Object.keys(environment.vaults).length > 0 && environment.lunarIndexerUrl,
   );
 
   // Fetch vaults from Lunar Indexer for each environment
   const environmentsVaultsSettlements = await Promise.allSettled(
     environmentsWithVaults.map(async (environment) => {
-      const lunarIndexerUrl = environment.custom.morpho!.lunarIndexerUrl!;
+      const lunarIndexerUrl = environment.lunarIndexerUrl!;
 
       try {
         // Fetch tokens and vaults in parallel
@@ -228,6 +227,10 @@ async function getMorphoVaultsDataFromIndexer(params: {
           `Failed to fetch vaults from Lunar Indexer for chain ${environment.chainId}, falling back to on-chain:`,
           error,
         );
+        environment.onError?.(error, {
+          source: "vaults",
+          chainId: environment.chainId,
+        });
         throw { environment, error };
       }
     }),
@@ -442,9 +445,7 @@ export async function getMorphoVaultsData(params: {
   const { environments } = params;
 
   // Check if any environment has Lunar Indexer URL configured
-  const hasLunarIndexer = environments.some(
-    (env) => env.custom?.morpho?.lunarIndexerUrl,
-  );
+  const hasLunarIndexer = environments.some((env) => env.lunarIndexerUrl);
 
   // Use Lunar Indexer implementation if available
   if (hasLunarIndexer) {

package/actions/morpho/vaults/getMorphoVaultSnapshots.ts

@@ -1,17 +1,15 @@
-import axios from "axios";
 import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
 import {
   applyGranularity,
   calculateTimeRange,
   getEnvironmentFromArgs,
-  isStartOfDay,
   toApiGranularity,
 } from "../../../common/index.js";
 import type {
   MorphoVaultParameterType,
   NetworkParameterType,
 } from "../../../common/types.js";
-import type { Chain, Environment } from "../../../environments/index.js";
+import type { Chain } from "../../../environments/index.js";
 import type { MorphoVaultSnapshot } from "../../../types/morphoVault.js";
 import {
   fetchVaultSnapshotsFromIndexer,
@@ -76,29 +74,43 @@ export async function getMorphoVaultSnapshots<
     }
   }
 
-  const lunarIndexerUrl = environment.custom?.morpho?.lunarIndexerUrl;
-
-  const snapshots = lunarIndexerUrl
-    ? await fetchVaultSnapshotsFromLunarIndexer(
-        fetchAddress,
-        environment.chainId,
-        lunarIndexerUrl,
-        period,
-        customStartTime,
-        customEndTime,
-      )
-    : await fetchVaultSnapshotsFromPonder(fetchAddress, environment);
-
-  // Restore the originally-requested vault address on every snapshot so
-  // callers keying by address see the V2 address they asked for.
-  if (fetchAddress.toLowerCase() !== requestedVaultAddress.toLowerCase()) {
-    return snapshots.map((s) => ({
-      ...s,
-      vaultAddress: requestedVaultAddress.toLowerCase(),
-    }));
+  const lunarIndexerUrl = environment.lunarIndexerUrl;
+
+  if (!lunarIndexerUrl) {
+    return [];
   }
 
-  return snapshots;
+  try {
+    const snapshots = await fetchVaultSnapshotsFromLunarIndexer(
+      fetchAddress,
+      environment.chainId,
+      lunarIndexerUrl,
+      period,
+      customStartTime,
+      customEndTime,
+    );
+
+    // Restore the originally-requested vault address on every snapshot so
+    // callers keying by address see the V2 address they asked for.
+    if (fetchAddress.toLowerCase() !== requestedVaultAddress.toLowerCase()) {
+      return snapshots.map((s) => ({
+        ...s,
+        vaultAddress: requestedVaultAddress.toLowerCase(),
+      }));
+    }
+
+    return snapshots;
+  } catch (error) {
+    console.warn(
+      `[getMorphoVaultSnapshots] Lunar Indexer failed for chain ${environment.chainId}:`,
+      error,
+    );
+    environment.onError?.(error, {
+      source: "morpho-vault-snapshots",
+      chainId: environment.chainId,
+    });
+    return [];
+  }
 }
 
 async function fetchVaultSnapshotsFromLunarIndexer(
@@ -147,99 +159,3 @@ async function fetchVaultSnapshotsFromLunarIndexer(
   allSnapshots.sort((a, b) => a.timestamp - b.timestamp);
   return applyGranularity(allSnapshots, granularity);
 }
-
-async function fetchVaultSnapshotsFromPonder(
-  vaultAddress: string,
-  environment: Environment,
-): Promise<MorphoVaultSnapshot[]> {
-  const dailyData: VaultDailyData[] = [];
-  let hasNextPage = true;
-  let endCursor: string | undefined;
-
-  interface VaultDailyData {
-    totalBorrows: number;
-    totalBorrowsUSD: number;
-    totalSupplies: number;
-    totalSuppliesUSD: number;
-    totalLiquidity: number;
-    totalLiquidityUSD: number;
-    timestamp: number;
-  }
-
-  while (hasNextPage) {
-    const result = await axios.post<{
-      data: {
-        vaultDailySnapshots: {
-          items: VaultDailyData[];
-          pageInfo: {
-            hasNextPage: boolean;
-            endCursor: string;
-          };
-        };
-      };
-    }>(environment.indexerUrl, {
-      query: `
-          query {
-            vaultDailySnapshots (
-              limit: 365,
-              orderBy: "timestamp"
-              orderDirection: "desc"
-              where: {vaultAddress: "${vaultAddress.toLowerCase()}", chainId: ${environment.chainId}}
-              ${endCursor ? `after: "${endCursor}"` : ""}
-            ) {
-              items {
-                  totalBorrows
-                  totalBorrowsUSD
-                  totalSupplies
-                  totalSuppliesUSD
-                  totalLiquidity
-                  totalLiquidityUSD
-                  timestamp
-              }
-              pageInfo {
-                hasNextPage
-                endCursor
-              }
-            }
-          }
-        `,
-    });
-
-    if (result.data.data.vaultDailySnapshots) {
-      dailyData.push(
-        ...result.data.data.vaultDailySnapshots.items.filter(
-          (f: { timestamp: number }) => isStartOfDay(f.timestamp),
-        ),
-      );
-      hasNextPage = result.data.data.vaultDailySnapshots.pageInfo.hasNextPage;
-      endCursor = result.data.data.vaultDailySnapshots.pageInfo.endCursor;
-    }
-  }
-
-  if (dailyData.length > 0) {
-    return dailyData.map((point: VaultDailyData) => {
-      const supplied = Number(point.totalSupplies);
-      const borrow = Number(point.totalBorrows);
-      const borrowUsd = Number(point.totalBorrowsUSD);
-      const suppliedUsd = Number(point.totalSuppliesUSD);
-      const liquidity = Number(point.totalLiquidity);
-      const liquidityUsd = Number(point.totalLiquidityUSD);
-
-      const result: MorphoVaultSnapshot = {
-        vaultAddress: vaultAddress.toLowerCase(),
-        chainId: environment.chainId,
-        timestamp: point.timestamp * 1000,
-        totalSupply: supplied,
-        totalSupplyUsd: suppliedUsd,
-        totalBorrows: borrow,
-        totalBorrowsUsd: borrowUsd,
-        totalLiquidity: liquidity,
-        totalLiquidityUsd: liquidityUsd,
-      };
-
-      return result;
-    });
-  } else {
-    return [];
-  }
-}

package/actions/morpho/vaults/getMorphoVaultStakingSnapshots.ts

@@ -1,23 +1,20 @@
-import axios from "axios";
 import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
 import {
   type SnapshotPeriod,
   applyGranularity,
   calculateTimeRange,
   getEnvironmentFromArgs,
-  isStartOfDay,
   toApiGranularity,
 } from "../../../common/index.js";
 import type {
   MorphoVaultParameterType,
   NetworkParameterType,
 } from "../../../common/types.js";
-import type { Chain, Environment } from "../../../environments/index.js";
+import type { Chain } from "../../../environments/index.js";
 import type { MorphoVaultStakingSnapshot } from "../../../types/morphoVault.js";
 import {
   DEFAULT_LUNAR_TIMEOUT_MS,
   createLunarIndexerClient,
-  shouldFallback,
 } from "../../lunar-indexer-client.js";
 import { transformVaultStakingSnapshots } from "../../lunar-indexer-transformers.js";
 
@@ -56,37 +53,31 @@ export async function getMorphoVaultStakingSnapshots<
   } = args as GetMorphoVaultStakingSnapshotsParameters<environments, undefined>;
 
   const { lunarIndexerUrl } = environment;
-  if (lunarIndexerUrl) {
-    try {
-      return await fetchVaultStakingSnapshotsFromLunar(
-        vaultAddress,
-        lunarIndexerUrl,
-        environment.chainId,
-        period,
-        customStartTime,
-        customEndTime,
-      );
-    } catch (error) {
-      if (!shouldFallback(error)) {
-        throw error;
-      }
-      console.debug(
-        "[Lunar fallback] Falling back to Ponder for vault staking snapshots:",
-        error,
-      );
-    }
+
+  if (!lunarIndexerUrl) {
+    return [];
   }
 
-  const { startTime } = calculateTimeRange(
-    period,
-    customStartTime,
-    customEndTime,
-  );
-  return fetchVaultStakingSnapshotsFromPonder(
-    vaultAddress,
-    environment,
-    startTime,
-  );
+  try {
+    return await fetchVaultStakingSnapshotsFromLunar(
+      vaultAddress,
+      lunarIndexerUrl,
+      environment.chainId,
+      period,
+      customStartTime,
+      customEndTime,
+    );
+  } catch (error) {
+    console.warn(
+      `[getMorphoVaultStakingSnapshots] Lunar Indexer failed for chain ${environment.chainId}:`,
+      error,
+    );
+    environment.onError?.(error, {
+      source: "morpho-vault-staking-snapshots",
+      chainId: environment.chainId,
+    });
+    return [];
+  }
 }
 
 async function fetchVaultStakingSnapshotsFromLunar(
@@ -131,81 +122,3 @@ async function fetchVaultStakingSnapshotsFromLunar(
   allSnapshots.sort((a, b) => a.timestamp - b.timestamp);
   return applyGranularity(allSnapshots, granularity);
 }
-
-interface VaultStakingData {
-  totalStaked: number;
-  totalStakedUSD: number;
-  timestamp: number;
-}
-
-async function fetchVaultStakingSnapshotsFromPonder(
-  vaultAddress: string,
-  environment: Environment,
-  startTime?: number,
-): Promise<MorphoVaultStakingSnapshot[]> {
-  const dailyData: VaultStakingData[] = [];
-  let hasNextPage = true;
-  let endCursor: string | undefined;
-
-  while (hasNextPage) {
-    const result = await axios.post<{
-      data: {
-        vaultStakingDailySnapshots: {
-          items: VaultStakingData[];
-          pageInfo: {
-            hasNextPage: boolean;
-            endCursor: string;
-          };
-        };
-      };
-    }>(environment.indexerUrl, {
-      query: `
-          query {
-            vaultStakingDailySnapshots (
-              limit: 365,
-              orderBy: "timestamp"
-              orderDirection: "desc"
-              where: {vaultAddress: "${vaultAddress.toLowerCase()}", chainId: ${environment.chainId}}
-              ${endCursor ? `after: "${endCursor}"` : ""}
-            ) {
-              items {
-                  totalStaked
-                  totalStakedUSD
-                  timestamp
-              }
-              pageInfo {
-                hasNextPage
-                endCursor
-              }
-            }
-          }
-        `,
-    });
-
-    if (result.data.data.vaultStakingDailySnapshots) {
-      dailyData.push(
-        ...result.data.data.vaultStakingDailySnapshots.items.filter(
-          (f: { timestamp: number }) =>
-            isStartOfDay(f.timestamp) &&
-            (startTime === undefined || f.timestamp >= startTime),
-        ),
-      );
-      hasNextPage =
-        result.data.data.vaultStakingDailySnapshots.pageInfo.hasNextPage;
-      endCursor =
-        result.data.data.vaultStakingDailySnapshots.pageInfo.endCursor;
-    }
-  }
-
-  if (dailyData.length > 0) {
-    return dailyData.map((point: VaultStakingData) => ({
-      vaultAddress: vaultAddress.toLowerCase(),
-      chainId: environment.chainId,
-      timestamp: point.timestamp * 1000,
-      totalStaked: Number(point.totalStaked),
-      totalStakedUsd: Number(point.totalStakedUSD),
-    }));
-  } else {
-    return [];
-  }
-}