@moonwell-fi/moonwell-sdk 0.10.7 → 0.12.0

package/actions/lunar-indexer-client.ts

@@ -74,6 +74,30 @@ export interface LunarPortfolioOptions {
   market?: string;
 }
 
+export interface LunarVaultPortfolioOptions {
+  startTime: number;
+  endTime: number;
+  granularity?: "1h" | "6h" | "1d";
+  chainId?: number;
+  vault?: string;
+}
+
+export interface LunarVaultPosition {
+  chainId: number;
+  vaultAddress: string;
+  shareBalance: string;
+  shareBalanceUsd: number;
+  assetsValue: number;
+}
+
+export interface LunarVaultPortfolio {
+  account: string;
+  positions: Array<{
+    timestamp: number;
+    vaults: LunarVaultPosition[];
+  }>;
+}
+
 export interface LunarComptroller {
   id: string;
   chainId: number;
@@ -251,6 +275,7 @@ export const DEFAULT_LUNAR_TIMEOUT_MS = 10_000;
 export class LunarIndexerClient {
   private client: AxiosInstance;
   private stakingClient: AxiosInstance;
+  private vaultsClient: AxiosInstance;
 
   constructor(config: LunarIndexerConfig) {
     this.client = axios.create({
@@ -268,6 +293,14 @@ export class LunarIndexerClient {
         "Content-Type": "application/json",
       },
     });
+
+    this.vaultsClient = axios.create({
+      baseURL: `${config.baseUrl}/api/v1/vaults`,
+      timeout: config.timeout || DEFAULT_LUNAR_TIMEOUT_MS,
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
   }
 
   /**
@@ -469,6 +502,37 @@ export class LunarIndexerClient {
     }
   }
 
+  /**
+   * Get vault account portfolio with historical positions
+   */
+  async getVaultAccountPortfolio(
+    accountAddress: string,
+    options: LunarVaultPortfolioOptions,
+  ): Promise<LunarVaultPortfolio> {
+    try {
+      const params: Record<string, string> = {
+        startTime: options.startTime.toString(),
+        endTime: options.endTime.toString(),
+      };
+      if (options.granularity) params.granularity = options.granularity;
+      if (options.chainId) params.chainId = options.chainId.toString();
+      if (options.vault) params.vault = options.vault;
+
+      const response = await this.vaultsClient.get<LunarVaultPortfolio>(
+        `/account/${accountAddress.toLowerCase()}/portfolio`,
+        { params },
+      );
+      return response.data;
+    } catch (error) {
+      throw new LunarIndexerError(
+        `Failed to fetch vault portfolio for account ${accountAddress}`,
+        axios.isAxiosError(error) ? error.response?.status : undefined,
+        `/account/${accountAddress}/portfolio`,
+        error as Error,
+      );
+    }
+  }
+
   /**
    * Get vault staking snapshots for a specific chain (MetaMorpho vault staking)
    */

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,23 +1,32 @@
-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 {
-  MorphoVaultParameterType,
-  NetworkParameterType,
-} from "../../../common/types.js";
-import type { Chain, Environment } from "../../../environments/index.js";
+  Chain,
+  Environment,
+  GetEnvironment,
+  VaultsType,
+} from "../../../environments/index.js";
 import type { MorphoVaultUserPositionSnapshot } from "../../../types/morphoUserPosition.js";
-
-dayjs.extend(utc);
+import {
+  DEFAULT_LUNAR_TIMEOUT_MS,
+  createLunarIndexerClient,
+} from "../../lunar-indexer-client.js";
 
 export type GetMorphoVaultUserPositionSnapshotsParameters<
   environments,
   network extends Chain | undefined,
 > = NetworkParameterType<environments, network> &
-  MorphoVaultParameterType<network> & {
+  (undefined extends network
+    ? {
+        /** Address of the vault token (omit to get all vaults for the account) */
+        vaultAddress?: Address;
+      }
+    : {
+        /** Vault key */
+        vault: keyof VaultsType<GetEnvironment<network>>;
+      }) & {
     userAddress: Address;
   };
 
@@ -38,95 +47,75 @@ export async function getMorphoVaultUserPositionSnapshots<
     return [];
   }
 
-  let { vaultAddress, vault } = args as unknown as {
-    vaultAddress: Address;
-    vault: string;
+  const { vaultAddress: rawVaultAddress, vault } = args as unknown as {
+    vaultAddress: Address | undefined;
+    vault: string | undefined;
   };
 
-  if (!vaultAddress) {
-    vaultAddress = environment.vaults[vault].address;
+  const vaultAddress: Address | undefined =
+    rawVaultAddress ?? (vault ? environment.vaults[vault].address : undefined);
+
+  const lunarIndexerUrl = environment.lunarIndexerUrl;
+
+  if (!lunarIndexerUrl) {
+    return [];
   }
 
-  return fetchUserPositionSnapshots(
-    args.userAddress,
-    vaultAddress,
-    environment,
-  );
+  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 [];
+  }
 }
 
-async function fetchUserPositionSnapshots(
+async function fetchUserPositionSnapshotsFromLunar(
   userAddress: Address,
-  vaultAddress: Address,
+  vaultAddress: Address | undefined,
+  lunarIndexerUrl: string,
   environment: Environment,
 ): Promise<MorphoVaultUserPositionSnapshot[]> {
-  const dailyData: MorphoVaultUserDailyData[] = [];
-  let hasNextPage = true;
-  let endCursor: string | undefined;
+  const lunarClient = createLunarIndexerClient({
+    baseUrl: lunarIndexerUrl,
+    timeout: DEFAULT_LUNAR_TIMEOUT_MS,
+  });
 
-  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
-              }
-            }
-          }
-        `,
-    });
+  const endTime = Math.floor(Date.now() / 1000);
+  const startTime = endTime - 3 * 365 * 24 * 60 * 60;
 
-    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;
-  }
+  const portfolio = await lunarClient.getVaultAccountPortfolio(userAddress, {
+    startTime,
+    endTime,
+    granularity: "1d",
+    chainId: environment.chainId,
+    ...(vaultAddress ? { vault: vaultAddress } : {}),
+  });
 
-  if (dailyData.length > 0) {
-    return dailyData.map((point: MorphoVaultUserDailyData) => {
-      const suppliedUsd = Number(point.totalSuppliesUSD);
+  const snapshots: MorphoVaultUserPositionSnapshot[] = [];
 
-      const result: MorphoVaultUserPositionSnapshot = {
-        chainId: environment.chainId,
-        timestamp: point.timestamp * 1000,
-        suppliedUsd: suppliedUsd,
+  for (const position of portfolio.positions) {
+    for (const v of position.vaults) {
+      snapshots.push({
+        chainId: v.chainId,
         account: userAddress,
-        vaultAddress: vaultAddress,
-      };
-
-      return result;
-    });
-  } else {
-    return [];
+        vaultAddress: v.vaultAddress as Address,
+        suppliedUsd: v.shareBalanceUsd,
+        timestamp: position.timestamp * 1000,
+      });
+    }
   }
+
+  return snapshots;
 }

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 [];
-  }
-}