@moonwell-fi/moonwell-sdk 0.9.26 → 0.9.28

package/actions/core/markets/getMarketSnapshots.ts

@@ -10,6 +10,13 @@ import {
 import type { NetworkParameterType } from "../../../common/types.js";
 import type { Chain, Environment } from "../../../environments/index.js";
 import type { MarketSnapshot } from "../../../types/market.js";
+import { buildMarketId } from "../../../utils/lunar-indexer-helpers.js";
+import {
+  DEFAULT_LUNAR_TIMEOUT_MS,
+  createLunarIndexerClient,
+  shouldFallback,
+} from "../../lunar-indexer-client.js";
+import { transformMarketSnapshots } from "../../lunar-indexer-transformers.js";
 import { getSubgraph } from "../../morpho/utils/graphql.js";
 
 dayjs.extend(utc);
@@ -20,8 +27,50 @@ export type GetMarketSnapshotsParameters<
 > = NetworkParameterType<environments, network> & {
   type: "core" | "isolated";
   marketId: `0x${string}`;
+  /** Predefined time period for snapshots */
+  period?: "1M" | "3M" | "1Y" | "ALL";
+  startTime?: number;
+  endTime?: number;
 };
 
+/**
+ * Calculate start and end times based on period or custom timestamps.
+ * Priority: custom timestamps > period > default (365 days)
+ */
+function calculateTimeRange(
+  period?: "1M" | "3M" | "1Y" | "ALL",
+  startTime?: number,
+  endTime?: number,
+): { startTime: number; endTime: number } {
+  const now = dayjs.utc();
+  const end = endTime ?? now.unix();
+
+  if (startTime !== undefined && endTime !== undefined) {
+    return { startTime, endTime: end };
+  }
+
+  let start: number;
+  switch (period) {
+    case "1M":
+      start = now.subtract(31, "days").unix();
+      break;
+    case "3M":
+      start = now.subtract(91, "days").unix();
+      break;
+    case "1Y":
+      start = now.subtract(366, "days").unix();
+      break;
+    case "ALL":
+      start = now.subtract(10, "years").unix();
+      break;
+    default:
+      start = now.subtract(365, "days").unix();
+      break;
+  }
+
+  return { startTime: start, endTime: end };
+}
+
 export type GetMarketSnapshotsReturnType = Promise<MarketSnapshot[]>;
 
 export async function getMarketSnapshots<
@@ -38,7 +87,13 @@ export async function getMarketSnapshots<
   }
 
   if (args?.type === "core") {
-    return fetchCoreMarketSnapshots(args.marketId, environment);
+    return fetchCoreMarketSnapshots(
+      args.marketId,
+      environment,
+      args.period,
+      args.startTime,
+      args.endTime,
+    );
   } else {
     if (environment.custom.morpho?.minimalDeployment === false) {
       return fetchIsolatedMarketSnapshots(args.marketId, environment);
@@ -51,6 +106,102 @@ export async function getMarketSnapshots<
 async function fetchCoreMarketSnapshots(
   marketAddress: string,
   environment: Environment,
+  period?: "1M" | "3M" | "1Y" | "ALL",
+  startTime?: number,
+  endTime?: number,
+): Promise<MarketSnapshot[]> {
+  if (environment.lunarIndexerUrl) {
+    try {
+      const result = await fetchCoreMarketSnapshotsFromLunar(
+        marketAddress,
+        environment,
+        period,
+        startTime,
+        endTime,
+      );
+      return result;
+    } catch (error) {
+      if (!shouldFallback(error)) {
+        throw error;
+      }
+      console.debug(
+        "[Lunar fallback] Falling back to Ponder for snapshots:",
+        error,
+      );
+    }
+  }
+
+  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 } = calculateTimeRange(
+    period,
+    customStartTime,
+    customEndTime,
+  );
+
+  const allSnapshots: MarketSnapshot[] = [];
+  let cursor: string | null = null;
+
+  do {
+    const response = await client.getMarketSnapshots(marketId, {
+      limit: 1000,
+      ...(cursor && { cursor }),
+      granularity: "1d",
+      startTime,
+    });
+
+    const transformed = transformMarketSnapshots(
+      response.results,
+      environment.chainId,
+    );
+
+    const filteredSnapshots = transformed.filter((snapshot: MarketSnapshot) =>
+      isStartOfDay(Math.floor(snapshot.timestamp / 1000)),
+    );
+
+    allSnapshots.push(...filteredSnapshots);
+
+    cursor = response.nextCursor;
+  } while (cursor !== null);
+
+  return allSnapshots.map((snapshot) => {
+    const supplied = snapshot.totalSupply;
+    const suppliedUsd = snapshot.totalSupplyUsd;
+    const price = supplied > 0 ? suppliedUsd / supplied : 0;
+
+    return {
+      ...snapshot,
+      collateralTokenPrice: price,
+      loanTokenPrice: price,
+    };
+  });
+}
+
+async function fetchCoreMarketSnapshotsFromPonder(
+  marketAddress: string,
+  environment: Environment,
 ): Promise<MarketSnapshot[]> {
   const dailyData: MarketDailyData[] = [];
   let hasNextPage = true;
@@ -82,7 +233,7 @@ async function fetchCoreMarketSnapshots(
     }>(environment.indexerUrl, {
       query: `
           query {
-            marketDailySnapshots (        
+            marketDailySnapshots (
               limit: 1000,
               orderBy: "timestamp"
               orderDirection: "desc"

package/actions/core/user-positions/common.ts

@@ -16,12 +16,35 @@ export const getUserPositionData = async (params: {
   }
 
   try {
-    const [allMarkets, balances, borrows, memberships] = await Promise.all([
-      viewsContract.read.getAllMarketsInfo(),
-      viewsContract.read.getUserBalances([params.account]),
-      viewsContract.read.getUserBorrowsBalances([params.account]),
-      viewsContract.read.getUserMarketsMemberships([params.account]),
-    ]);
+    const [allMarketsResult, balancesResult, borrowsResult, membershipsResult] =
+      await Promise.allSettled([
+        viewsContract.read.getAllMarketsInfo(),
+        viewsContract.read.getUserBalances([params.account]),
+        viewsContract.read.getUserBorrowsBalances([params.account]),
+        viewsContract.read.getUserMarketsMemberships([params.account]),
+      ]);
+
+    const balances =
+      balancesResult.status === "fulfilled" ? balancesResult.value : [];
+    const borrows =
+      borrowsResult.status === "fulfilled" ? borrowsResult.value : [];
+    const memberships =
+      membershipsResult.status === "fulfilled" ? membershipsResult.value : [];
+
+    // If getAllMarketsInfo failed (e.g. broken on-chain oracle), fall back to
+    // per-mToken exchange rate calls. The user balance/borrow/membership calls
+    // don't touch the oracle so they can still succeed.
+    if (allMarketsResult.status === "rejected") {
+      return getUserPositionsFromMTokenFallback(
+        params,
+        balances as { amount: bigint; token: `0x${string}` }[],
+        borrows as { amount: bigint; token: `0x${string}` }[],
+        memberships as { membership: boolean; token: `0x${string}` }[],
+      );
+    }
+
+    const allMarkets = allMarketsResult.value;
+
     const markets = allMarkets
       ?.map((marketInfo) => {
         const market = findMarketByAddress(
@@ -104,3 +127,113 @@ export const getUserPositionData = async (params: {
     return [];
   }
 };
+
+/**
+ * Fallback for chains whose on-chain price oracle is non-functional (e.g.
+ * deprecated Moonriver). getUserBalances/getUserBorrowsBalances/getUserMarketsMemberships
+ * don't require the oracle, so we use those results directly. We fetch each
+ * mToken's exchangeRate individually to convert mToken balances to underlying.
+ * All USD values are set to 0 since oracle prices are unavailable.
+ */
+async function getUserPositionsFromMTokenFallback(
+  params: {
+    environment: Environment;
+    account: Address;
+    markets?: string[] | undefined;
+  },
+  balances: { amount: bigint; token: `0x${string}` }[],
+  borrows: { amount: bigint; token: `0x${string}` }[],
+  memberships: { membership: boolean; token: `0x${string}` }[],
+): Promise<UserPosition[]> {
+  const positions: UserPosition[] = [];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const envAny = params.environment as any;
+
+  for (const marketKey of Object.keys(params.environment.config.markets)) {
+    const marketConfig = envAny.config.markets[marketKey] as
+      | { underlyingToken: string; marketToken: string }
+      | undefined;
+    if (!marketConfig) continue;
+
+    const underlyingToken = envAny.config.tokens[
+      marketConfig.underlyingToken
+    ] as
+      | {
+          address: `0x${string}`;
+          decimals: number;
+          symbol: string;
+          name: string;
+        }
+      | undefined;
+    const marketToken = envAny.config.tokens[marketConfig.marketToken] as
+      | {
+          address: `0x${string}`;
+          decimals: number;
+          symbol: string;
+          name: string;
+        }
+      | undefined;
+    if (!underlyingToken || !marketToken) continue;
+
+    const mTokenAddress = marketToken.address.toLowerCase() as `0x${string}`;
+
+    const marketSuppliedRaw =
+      balances.find((r) => r.token.toLowerCase() === mTokenAddress)?.amount ??
+      0n;
+    const marketBorrowedRaw =
+      borrows.find((r) => r.token.toLowerCase() === mTokenAddress)?.amount ??
+      0n;
+
+    // Skip markets where the user has no position
+    if (marketSuppliedRaw === 0n && marketBorrowedRaw === 0n) continue;
+
+    const marketCollateralEnabled =
+      memberships.find((r) => r.token.toLowerCase() === mTokenAddress)
+        ?.membership === true;
+
+    // Fetch exchange rate individually (not oracle-dependent)
+    const mTokenContract = envAny.markets[marketKey] as
+      | { read: Record<string, (...args: unknown[]) => Promise<bigint>> }
+      | undefined;
+    const defaultExchangeRate = 10n ** BigInt(10 + underlyingToken.decimals);
+    let exchangeRateRaw: bigint;
+    try {
+      exchangeRateRaw =
+        (await mTokenContract?.read.exchangeRateStored()) ??
+        defaultExchangeRate;
+    } catch {
+      exchangeRateRaw = defaultExchangeRate;
+    }
+
+    const exchangeRate = new Amount(
+      exchangeRateRaw,
+      10 + underlyingToken.decimals,
+    ).value;
+
+    const borrowed = new Amount(marketBorrowedRaw, underlyingToken.decimals);
+    const marketSupplied = new Amount(marketSuppliedRaw, marketToken.decimals);
+    const supplied = new Amount(
+      marketSupplied.value * exchangeRate,
+      underlyingToken.decimals,
+    );
+
+    if (params.markets && !params.markets.includes(marketToken.address)) {
+      continue;
+    }
+
+    positions.push({
+      chainId: params.environment.chainId,
+      account: params.account,
+      market: marketToken,
+      collateralEnabled: marketCollateralEnabled,
+      borrowed,
+      borrowedUsd: 0,
+      collateral: new Amount(0n, underlyingToken.decimals),
+      collateralUsd: 0,
+      supplied,
+      suppliedUsd: 0,
+    });
+  }
+
+  return positions;
+}

package/actions/core/user-positions/getUserPositionSnapshots.ts

@@ -7,6 +7,12 @@ import { getEnvironmentFromArgs, isStartOfDay } from "../../../common/index.js";
 import type { NetworkParameterType } from "../../../common/types.js";
 import type { Chain, Environment } from "../../../environments/index.js";
 import type { UserPositionSnapshot } from "../../../types/userPosition.js";
+import {
+  DEFAULT_LUNAR_TIMEOUT_MS,
+  createLunarIndexerClient,
+  shouldFallback,
+} from "../../lunar-indexer-client.js";
+import { transformPortfolioToSnapshots } from "../../lunar-indexer-transformers.js";
 
 dayjs.extend(utc);
 
@@ -16,12 +22,82 @@ export type GetUserPositionSnapshotsParameters<
 > = NetworkParameterType<environments, network> & {
   /** User address*/
   userAddress: Address;
+  /** Predefined time period for snapshots */
+  period?: "1M" | "3M" | "1Y" | "ALL";
+  /** Custom start time (unix timestamp in seconds). Overrides period if both startTime and endTime are provided. */
+  startTime?: number;
+  /** Custom end time (unix timestamp in seconds). Overrides period if both startTime and endTime are provided. */
+  endTime?: number;
+  /** Data granularity. Defaults to "1d" */
+  granularity?: "1h" | "6h" | "1d";
 };
 
 export type GetUserPositionSnapshotsReturnType = Promise<
   UserPositionSnapshot[]
 >;
 
+/**
+ * Calculate start and end times based on period or custom timestamps
+ * Priority: custom timestamps > period > default (365 days)
+ */
+function calculateTimeRange(
+  period?: "1M" | "3M" | "1Y" | "ALL",
+  startTime?: number,
+  endTime?: number,
+): { startTime: number; endTime: number } {
+  const now = dayjs.utc();
+  const end = endTime ?? now.unix();
+
+  // If both startTime and endTime are provided, use them (custom range)
+  if (startTime !== undefined && endTime !== undefined) {
+    return { startTime, endTime: end };
+  }
+
+  // Calculate based on period
+  let start: number;
+  switch (period) {
+    case "1M":
+      start = now.subtract(31, "days").unix();
+      break;
+    case "3M":
+      start = now.subtract(91, "days").unix();
+      break;
+    case "1Y":
+      start = now.subtract(366, "days").unix();
+      break;
+    case "ALL":
+      // Use a date far in the past to get all available data
+      start = now.subtract(10, "years").unix();
+      break;
+    default:
+      // Default to 365 days for backward compatibility
+      start = now.subtract(365, "days").unix();
+      break;
+  }
+
+  return { startTime: start, endTime: end };
+}
+
+/**
+ * Get historical snapshots of a user's positions across all markets
+ *
+ * @param client - Moonwell client instance
+ * @param args - Parameters including user address and optional time range
+ * @param args.userAddress - The user's wallet address
+ * @param args.period - Predefined time period: "1M" (31 days), "3M" (91 days), "1Y" (366 days), or "ALL" (all available history)
+ * @param args.startTime - Custom start time (unix timestamp in seconds). Overrides period if both startTime and endTime are provided.
+ * @param args.endTime - Custom end time (unix timestamp in seconds). Overrides period if both startTime and endTime are provided.
+ * @param args.granularity - Data granularity: "1h", "6h", or "1d" (default). Determines snapshot frequency.
+ *
+ * @returns Array of user position snapshots with USD values for supply, borrow, and collateral
+ *
+ * @remarks
+ * - Default behavior (no time parameters): Returns 365 days of history
+ * - Parameter priority: Custom timestamps > period > default (365 days)
+ * - When using Lunar Indexer, custom time ranges are supported
+ * - When falling back to Ponder, all available data is returned (client-side filtering may be needed)
+ * - Snapshots are filtered to start-of-day for "1d" granularity
+ */
 export async function getUserPositionSnapshots<
   environments,
   Network extends Chain | undefined,
@@ -35,12 +111,110 @@ export async function getUserPositionSnapshots<
     return [];
   }
 
-  return fetchUserPositionSnapshots(args.userAddress, environment);
+  return fetchUserPositionSnapshots(
+    args.userAddress,
+    environment,
+    args.period,
+    args.startTime,
+    args.endTime,
+    args.granularity,
+  );
 }
 
 async function fetchUserPositionSnapshots(
   userAddress: Address,
   environment: Environment,
+  period?: "1M" | "3M" | "1Y" | "ALL",
+  startTime?: number,
+  endTime?: number,
+  granularity?: "1h" | "6h" | "1d",
+): Promise<UserPositionSnapshot[]> {
+  if (environment.lunarIndexerUrl) {
+    try {
+      const result = await fetchUserPositionSnapshotsFromLunar(
+        userAddress,
+        environment,
+        period,
+        startTime,
+        endTime,
+        granularity,
+      );
+      return result;
+    } catch (error) {
+      if (!shouldFallback(error)) {
+        throw error;
+      }
+      console.debug(
+        "[Lunar fallback] Falling back to Ponder for user snapshots:",
+        error,
+      );
+    }
+  }
+
+  // Ponder fallback returns all available data (doesn't support time filtering)
+  const result = await fetchUserPositionSnapshotsFromPonder(
+    userAddress,
+    environment,
+  );
+  return result;
+}
+
+async function fetchUserPositionSnapshotsFromLunar(
+  userAddress: Address,
+  environment: Environment,
+  period?: "1M" | "3M" | "1Y" | "ALL",
+  customStartTime?: number,
+  customEndTime?: number,
+  granularity: "1h" | "6h" | "1d" = "1d",
+): Promise<UserPositionSnapshot[]> {
+  if (!environment.lunarIndexerUrl) {
+    throw new Error("Lunar Indexer URL not configured");
+  }
+
+  const client = createLunarIndexerClient({
+    baseUrl: environment.lunarIndexerUrl,
+    timeout: DEFAULT_LUNAR_TIMEOUT_MS,
+  });
+
+  const { startTime, endTime } = calculateTimeRange(
+    period,
+    customStartTime,
+    customEndTime,
+  );
+
+  const portfolio = await client.getAccountPortfolio(
+    userAddress.toLowerCase(),
+    {
+      startTime,
+      endTime,
+      granularity,
+      chainId: environment.chainId,
+    },
+  );
+
+  const snapshots = transformPortfolioToSnapshots(
+    portfolio,
+    environment.chainId,
+  );
+
+  // Find the first snapshot where user has any position
+  const firstNonZeroIndex = snapshots.findIndex(
+    (snapshot) =>
+      snapshot.totalSupplyUsd > 0 ||
+      snapshot.totalBorrowsUsd > 0 ||
+      snapshot.totalCollateralUsd > 0,
+  );
+
+  if (firstNonZeroIndex === -1) {
+    return [];
+  }
+
+  return snapshots.slice(firstNonZeroIndex);
+}
+
+async function fetchUserPositionSnapshotsFromPonder(
+  userAddress: Address,
+  environment: Environment,
 ): Promise<UserPositionSnapshot[]> {
   const dailyData: UserDailyData[] = [];
   let hasNextPage = true;