@moonwell-fi/moonwell-sdk 0.11.0 → 0.12.1

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

package/actions/retry.ts

@@ -0,0 +1,121 @@
+/**
+ * Retry helpers for SDK API calls.
+ *
+ * Two consumers:
+ *  1. `attachRetryInterceptor` — axios response interceptor used inside
+ *     LunarIndexerClient. One install per axios instance covers every method.
+ *  2. `retry` — generic wrapper for ad-hoc `axios.post(...)` callsites in
+ *     actions that don't go through a shared axios instance.
+ *
+ * Policy:
+ *  - 3 attempts (initial + 2 retries) by default
+ *  - Exponential backoff: 250ms → 500ms (capped at 5s)
+ *  - Retry only network errors / timeouts / 5xx; never retry 4xx (incl. 404 —
+ *    retrying a deterministic "not found" wastes time and amplifies log noise)
+ *  - After retries exhaust, the last error propagates to the caller's try/catch
+ *    where the existing `environment.onError(...)` wiring picks it up
+ */
+import axios, {
+  type AxiosError,
+  type AxiosInstance,
+  type InternalAxiosRequestConfig,
+} from "axios";
+
+export interface RetryOptions {
+  maxAttempts?: number;
+  initialDelay?: number;
+  maxDelay?: number;
+}
+
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_INITIAL_DELAY_MS = 250;
+const DEFAULT_MAX_DELAY_MS = 5_000;
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function backoffDelay(
+  attemptIndex: number,
+  initialDelay: number,
+  maxDelay: number,
+): number {
+  return Math.min(initialDelay * 2 ** attemptIndex, maxDelay);
+}
+
+/**
+ * Decide whether an error represents a transient failure worth retrying.
+ * - Axios network errors (no `response`) → retry (server unreachable, timeout)
+ * - 5xx responses → retry (server hiccup)
+ * - 4xx responses (incl. 404) → do NOT retry (deterministic, won't change)
+ * - Non-axios errors (parse errors, code bugs) → do NOT retry
+ */
+export function isRetriableError(error: unknown): boolean {
+  if (!axios.isAxiosError(error)) return false;
+  if (!error.response) return true;
+  return error.response.status >= 500;
+}
+
+/**
+ * Attach a retry-on-failure interceptor to an axios instance. Every request
+ * made through this instance is retried up to `maxAttempts` times when the
+ * failure is retriable. Per-config state is tracked on a WeakMap so we don't
+ * pollute the public axios config shape.
+ */
+export function attachRetryInterceptor(
+  instance: AxiosInstance,
+  options: RetryOptions = {},
+): void {
+  const {
+    maxAttempts = DEFAULT_MAX_ATTEMPTS,
+    initialDelay = DEFAULT_INITIAL_DELAY_MS,
+    maxDelay = DEFAULT_MAX_DELAY_MS,
+  } = options;
+  const attemptsByConfig = new WeakMap<InternalAxiosRequestConfig, number>();
+
+  instance.interceptors.response.use(
+    (response) => response,
+    async (error: AxiosError) => {
+      const config = error.config;
+      if (!config) throw error;
+      if (!isRetriableError(error)) throw error;
+
+      const previousAttempts = attemptsByConfig.get(config) ?? 0;
+      if (previousAttempts >= maxAttempts - 1) throw error;
+
+      attemptsByConfig.set(config, previousAttempts + 1);
+      await sleep(backoffDelay(previousAttempts, initialDelay, maxDelay));
+      return instance.request(config);
+    },
+  );
+}
+
+/**
+ * Generic wrapper for individual axios calls (e.g. raw `axios.post(...)` in
+ * action files that don't share a configured instance). Mirrors the
+ * interceptor's policy: retry transient failures, fail fast on 4xx.
+ */
+export async function retry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {},
+): Promise<T> {
+  const {
+    maxAttempts = DEFAULT_MAX_ATTEMPTS,
+    initialDelay = DEFAULT_INITIAL_DELAY_MS,
+    maxDelay = DEFAULT_MAX_DELAY_MS,
+  } = options;
+  let attempt = 0;
+  let lastError: unknown;
+  while (attempt < maxAttempts) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      attempt++;
+      if (!isRetriableError(error)) throw error;
+      if (attempt >= maxAttempts) break;
+      await sleep(backoffDelay(attempt - 1, initialDelay, maxDelay));
+    }
+  }
+  throw lastError;
+}

package/client/createMoonwellClient.ts

@@ -77,12 +77,15 @@ export type NetworksConfig<networks> = {} extends networks
 
 export const createMoonwellClient = <const networks>(config: {
   networks: NetworksConfig<Narrow<networks>>;
+  onError?: (
+    error: unknown,
+    context: { source: string; chainId: number },
+  ) => void;
 }) => {
-  const environments = Object.keys(config.networks).reduce((prev, curr) => {
-    const key = curr as SupportedChains;
-    const networkConfig = (config.networks as NetworksConfig<SupportedChains>)[
-      key
-    ]!;
+  const environments = Object.entries(
+    config.networks as NetworksConfig<SupportedChains>,
+  ).reduce((prev, [curr, networkConfig]) => {
+    if (!networkConfig) return prev;
     return {
       ...prev,
       [curr]: createEnvironment({
@@ -143,6 +146,15 @@ export const createMoonwellClient = <const networks>(config: {
     }
   >;
 
+  if (config.onError) {
+    const onError = config.onError;
+    for (const env of Object.values(
+      environments as Record<string, Environment>,
+    )) {
+      env.onError = onError;
+    }
+  }
+
   const client = {
     environments,
   };

package/common/getBlockNumberAtTimestamp.ts

@@ -0,0 +1,59 @@
+import type { PublicClient } from "viem";
+
+/**
+ * Safety cap on interpolation iterations. With near-linear `ts(block)` the search
+ * converges in ~3–5 reads; 8 leaves headroom for chains with variable block times
+ * (e.g. Moonbeam) without unbounded RPC fan-out on pathological inputs.
+ */
+const MAX_ITERATIONS = 8;
+
+/**
+ * Find the block number on a chain whose timestamp is the latest one ≤ the target unix timestamp.
+ *
+ * Uses interpolation search anchored on the latest block and block 1: each iteration
+ * narrows the range by reading one block and projecting the target via the slope of the
+ * remaining range. Converges in ~3–5 RPC calls even on chains with variable block times.
+ *
+ * Assumes block 1 exists on the chain — true for every EVM chain Moonwell supports.
+ *
+ * Returns the latest block if `targetTimestamp` is at or after the head, and block 1
+ * if it is before block 1's timestamp. On a chain with only block 0, returns block 0.
+ */
+export async function getBlockNumberAtTimestamp(
+  publicClient: PublicClient,
+  targetTimestamp: bigint,
+): Promise<bigint> {
+  const latest = await publicClient.getBlock({ blockTag: "latest" });
+  if (targetTimestamp >= latest.timestamp) return latest.number;
+  if (latest.number === 0n) return latest.number;
+
+  const first = await publicClient.getBlock({ blockNumber: 1n });
+  if (targetTimestamp <= first.timestamp) return first.number;
+
+  let lo = first.number;
+  let loTs = first.timestamp;
+  let hi = latest.number;
+  let hiTs = latest.timestamp;
+
+  for (let i = 0; i < MAX_ITERATIONS; i += 1) {
+    if (hi - lo <= 1n) break;
+    const tsRange = hiTs - loTs;
+    if (tsRange <= 0n) break;
+
+    const offset = ((targetTimestamp - loTs) * (hi - lo)) / tsRange;
+    let mid = lo + offset;
+    if (mid <= lo) mid = lo + 1n;
+    if (mid >= hi) mid = hi - 1n;
+
+    const block = await publicClient.getBlock({ blockNumber: mid });
+    if (block.timestamp <= targetTimestamp) {
+      lo = mid;
+      loTs = block.timestamp;
+    } else {
+      hi = mid;
+      hiTs = block.timestamp;
+    }
+  }
+
+  return lo;
+}

package/common/index.ts

@@ -7,6 +7,7 @@ dayjs.extend(utc);
 export { Amount } from "./amount.js";
 export { BaseError, HttpRequestError } from "./error.js";
 export type { HttpRequestErrorType } from "./error.js";
+export { getBlockNumberAtTimestamp } from "./getBlockNumberAtTimestamp.js";
 export type { MultichainReturnType } from "./types.js";
 
 export const SECONDS_PER_DAY = 86400;

package/environments/definitions/arbitrum/environment.ts

@@ -8,7 +8,6 @@ import { tokens } from "./tokens.js";
 
 const createEnvironment = (
   rpcUrls?: string[],
-  indexerUrl?: string,
   governanceIndexerUrl?: string,
 ): Environment<typeof tokens, {}, {}, {}, {}> =>
   createEnvironmentConfig({
@@ -25,7 +24,6 @@ const createEnvironment = (
     transport: rpcUrls
       ? fallback(rpcUrls.map((url) => http(url)))
       : http("https://rpc.moonwell.fi/main/evm/42161"),
-    indexerUrl: indexerUrl || "https://ponder.moonwell.fi",
     governanceIndexerUrl:
       governanceIndexerUrl ||
       "https://lunar-services-worker.moonwell.workers.dev",

package/environments/definitions/avalanche/environment.ts

@@ -8,7 +8,6 @@ import { tokens } from "./tokens.js";
 
 const createEnvironment = (
   rpcUrls?: string[],
-  indexerUrl?: string,
   governanceIndexerUrl?: string,
 ): Environment<typeof tokens, {}, {}, {}, {}> =>
   createEnvironmentConfig({
@@ -25,7 +24,6 @@ const createEnvironment = (
     transport: rpcUrls
       ? fallback(rpcUrls.map((url) => http(url)))
       : http("https://rpc.moonwell.fi/main/evm/43114"),
-    indexerUrl: indexerUrl || "https://ponder.moonwell.fi",
     governanceIndexerUrl:
       governanceIndexerUrl ||
       "https://lunar-services-worker.moonwell.workers.dev",

package/environments/definitions/base/custom.ts

@@ -5,7 +5,6 @@ export const custom = createCustomConfig({
     minimalDeployment: false,
     apiUrl: "https://api.morpho.org/graphql",
     rewardsApiUrl: "https://rewards.morpho.org",
-    lunarIndexerUrl: "https://lunar-services-worker.moonwell.workers.dev",
   },
   governance: {
     token: "WELL",

package/environments/definitions/base/environment.ts

@@ -15,7 +15,6 @@ const base = defineChain({ ...baseChain, testnet: false });
 
 const createEnvironment = (
   rpcUrls?: string[],
-  indexerUrl?: string,
   governanceIndexerUrl?: string,
   lunarIndexerUrl?: string,
 ): Environment<
@@ -37,7 +36,6 @@ const createEnvironment = (
     transport: rpcUrls
       ? fallback(rpcUrls.map((url) => http(url)))
       : http("https://rpc.moonwell.fi/main/evm/8453"),
-    indexerUrl: indexerUrl || "https://ponder.moonwell.fi",
     governanceIndexerUrl:
       governanceIndexerUrl ||
       "https://lunar-services-worker.moonwell.workers.dev",

package/environments/definitions/ethereum/environment.ts

@@ -8,7 +8,6 @@ import { tokens } from "./tokens.js";
 
 const createEnvironment = (
   rpcUrls?: string[],
-  indexerUrl?: string,
   governanceIndexerUrl?: string,
 ): Environment<typeof tokens, {}, {}, {}, {}> =>
   createEnvironmentConfig({
@@ -23,7 +22,6 @@ const createEnvironment = (
     transport: rpcUrls
       ? fallback(rpcUrls.map((url) => http(url)))
       : http("https://rpc.moonwell.fi/main/evm/1"),
-    indexerUrl: indexerUrl || "https://ponder.moonwell.fi",
     governanceIndexerUrl:
       governanceIndexerUrl ||
       "https://lunar-services-worker.moonwell.workers.dev",

package/environments/definitions/moonbeam/environment.ts

@@ -8,7 +8,6 @@ import { tokens } from "./tokens.js";
 
 const createEnvironment = (
   rpcUrls?: string[],
-  indexerUrl?: string,
   governanceIndexerUrl?: string,
   lunarIndexerUrl?: string,
 ) =>
@@ -24,7 +23,6 @@ const createEnvironment = (
     transport: rpcUrls
       ? fallback(rpcUrls.map((url) => http(url)))
       : http("https://rpc.moonwell.fi/main/evm/1284"),
-    indexerUrl: indexerUrl || "https://ponder.moonwell.fi",
     lunarIndexerUrl:
       lunarIndexerUrl || "https://lunar-services-worker.moonwell.workers.dev",
     governanceIndexerUrl:

package/environments/definitions/optimism/custom.ts

@@ -5,7 +5,6 @@ export const custom = createCustomConfig({
     minimalDeployment: true,
     apiUrl: "https://api.morpho.org/graphql",
     rewardsApiUrl: "https://rewards.morpho.org",
-    lunarIndexerUrl: "https://lunar-services-worker.moonwell.workers.dev",
   },
   governance: {
     token: "WELL",

package/environments/definitions/optimism/environment.ts

@@ -11,7 +11,6 @@ const optimism = defineChain({ ...optimismChain, testnet: false });
 
 const createEnvironment = (
   rpcUrls?: string[],
-  indexerUrl?: string,
   governanceIndexerUrl?: string,
   lunarIndexerUrl?: string,
 ) =>
@@ -27,7 +26,6 @@ const createEnvironment = (
     transport: rpcUrls
       ? fallback(rpcUrls.map((url) => http(url)))
       : http("https://rpc.moonwell.fi/main/evm/10"),
-    indexerUrl: indexerUrl || "https://ponder.moonwell.fi",
     lunarIndexerUrl:
       lunarIndexerUrl || "https://lunar-services-worker.moonwell.workers.dev",
     governanceIndexerUrl:

package/environments/definitions/polygon/environment.ts

@@ -8,7 +8,6 @@ import { tokens } from "./tokens.js";
 
 const createEnvironment = (
   rpcUrls?: string[],
-  indexerUrl?: string,
   governanceIndexerUrl?: string,
 ): Environment<typeof tokens, {}, {}, {}, {}> =>
   createEnvironmentConfig({
@@ -23,7 +22,6 @@ const createEnvironment = (
     transport: rpcUrls
       ? fallback(rpcUrls.map((url) => http(url)))
       : http("https://rpc.moonwell.fi/main/evm/137"),
-    indexerUrl: indexerUrl || "https://ponder.moonwell.fi",
     governanceIndexerUrl:
       governanceIndexerUrl ||
       "https://lunar-services-worker.moonwell.workers.dev",

package/environments/index.ts

@@ -147,49 +147,28 @@ export type GetEnvironment<chain> = chain extends typeof base
 export const createEnvironment = <const chain extends Chain>(config: {
   chain: chain;
   rpcUrls?: string[] | undefined;
-  indexerUrl?: string;
 }): GetEnvironment<chain> => {
   switch (config.chain.id) {
     case base.id:
-      return createBaseEnvironment(
-        config.rpcUrls,
-        config.indexerUrl,
-      ) as GetEnvironment<chain>;
+      return createBaseEnvironment(config.rpcUrls) as GetEnvironment<chain>;
     case moonbeam.id:
-      return createMoonbeamEnvironment(
-        config.rpcUrls,
-        config.indexerUrl,
-      ) as GetEnvironment<chain>;
+      return createMoonbeamEnvironment(config.rpcUrls) as GetEnvironment<chain>;
     case moonriver.id:
       return createMoonriverEnvironment(
         config.rpcUrls,
-        config.indexerUrl,
       ) as GetEnvironment<chain>;
     case optimism.id:
-      return createOptimismEnvironment(
-        config.rpcUrls,
-        config.indexerUrl,
-      ) as GetEnvironment<chain>;
+      return createOptimismEnvironment(config.rpcUrls) as GetEnvironment<chain>;
     case ethereum.id:
-      return createEthereumEnvironment(
-        config.rpcUrls,
-        config.indexerUrl,
-      ) as GetEnvironment<chain>;
+      return createEthereumEnvironment(config.rpcUrls) as GetEnvironment<chain>;
     case avalanche.id:
       return createAvalancheEnvironment(
         config.rpcUrls,
-        config.indexerUrl,
       ) as GetEnvironment<chain>;
     case arbitrum.id:
-      return createArbitrumEnvironment(
-        config.rpcUrls,
-        config.indexerUrl,
-      ) as GetEnvironment<chain>;
+      return createArbitrumEnvironment(config.rpcUrls) as GetEnvironment<chain>;
     case polygon.id:
-      return createPolygonEnvironment(
-        config.rpcUrls,
-        config.indexerUrl,
-      ) as GetEnvironment<chain>;
+      return createPolygonEnvironment(config.rpcUrls) as GetEnvironment<chain>;
     default:
       throw new Error("Unsupported chainId");
   }