@moonwell-fi/moonwell-sdk 0.24.0 → 0.25.1

package/actions/morpho/vaults/common.ts

@@ -19,7 +19,7 @@ import type {
   MorphoVault,
   MorphoVaultMarket,
 } from "../../../types/morphoVault.js";
-import { getGovernanceTokenPriceFor } from "../../governance/getWellPrice.js";
+import { getGovernanceTokenPriceOrZero } from "../../governance/getWellPrice.js";
 import { getGraphQL, getVaultV2Apy } from "../utils/graphql.js";
 import {
   SECONDS_PER_YEAR,
@@ -300,144 +300,184 @@ async function getMorphoVaultsDataFromIndexer(params: {
 
   // Add staking rewards if includeRewards is true
   if (params.includeRewards) {
+    const vaultsByEnvironment = new Map<
+      Environment,
+      { vault: MorphoVault; multiReward: Address }[]
+    >();
     for (const vault of allVaults) {
       const environment = environments.find(
         (env) => env.chainId === vault.chainId,
       );
       if (!environment) continue;
 
-      const vaultConfig = environment.config.vaults[vault.vaultKey];
-      if (!vaultConfig?.multiReward) continue;
+      const multiReward =
+        environment.config.vaults[vault.vaultKey]?.multiReward;
+      if (!multiReward) continue;
 
-      try {
-        // Fetch market prices from the views contract to calculate rewards
-        const homeEnvironment =
-          (Object.values(publicEnvironments) as Environment[]).find((e) =>
-            e.custom?.governance?.chainIds?.includes(environment.chainId),
-          ) || environment;
-
-        const viewsContract = environment.contracts.views;
-        const homeViewsContract = homeEnvironment.contracts.views;
-
-        const data = await Promise.all([
-          viewsContract?.read.getAllMarketsInfo(),
-          homeViewsContract?.read.getNativeTokenPrice(),
-          getGovernanceTokenPriceFor(environment).catch((err) => {
-            environment.onError?.(err, {
-              source: "governance-token-price",
-              chainId: environment.chainId,
-            });
-            return 0n;
-          }),
-        ]);
+      const group = vaultsByEnvironment.get(environment) ?? [];
+      group.push({ vault, multiReward });
+      vaultsByEnvironment.set(environment, group);
+    }
 
-        const [allMarkets, nativeTokenPriceRaw, governanceTokenPriceRaw] = data;
+    // Price reads are per environment, not per vault: read them once per
+    // environment (in parallel across environments) and report failures once.
+    await Promise.all(
+      [...vaultsByEnvironment].map(([environment, group]) =>
+        addStakingRewardsForEnvironment(environment, group),
+      ),
+    );
+  }
 
-        const governanceTokenPrice = new Amount(governanceTokenPriceRaw, 18);
-        const nativeTokenPrice = new Amount(nativeTokenPriceRaw ?? 0n, 18);
+  return [...allVaults, ...fallbackVaults];
+}
 
-        let tokenPrices =
-          allMarkets
-            ?.map((marketInfo) => {
-              const marketFound = findMarketByAddress(
-                environment,
-                marketInfo.market,
-              );
-              if (marketFound) {
-                return {
-                  token: marketFound.underlyingToken,
-                  tokenPrice: new Amount(
-                    marketInfo.underlyingPrice,
-                    36 - marketFound.underlyingToken.decimals,
-                  ),
-                };
-              } else {
-                return;
-              }
-            })
-            .filter((token) => !!token) || [];
-
-        // Add governance token to token prices
-        if (environment.custom?.governance?.token) {
-          tokenPrices = [
-            ...tokenPrices,
-            {
-              token:
-                environment.config.tokens[environment.custom.governance.token]!,
-              tokenPrice: governanceTokenPrice,
-            },
-          ];
-        }
+async function getStakingRewardTokenPrices(
+  environment: Environment,
+): Promise<{ token: TokenConfig; tokenPrice: Amount }[]> {
+  // Fetch market prices from the views contract to calculate rewards
+  const homeEnvironment =
+    (Object.values(publicEnvironments) as Environment[]).find((e) =>
+      e.custom?.governance?.chainIds?.includes(environment.chainId),
+    ) || environment;
+
+  const [allMarkets, nativeTokenPriceRaw, governanceTokenPriceRaw] =
+    await Promise.all([
+      environment.contracts.views?.read.getAllMarketsInfo(),
+      homeEnvironment.contracts.views?.read.getNativeTokenPrice(),
+      getGovernanceTokenPriceOrZero(environment),
+    ]);
+
+  const tokenPrices: { token: TokenConfig; tokenPrice: Amount }[] = [];
+  for (const marketInfo of allMarkets ?? []) {
+    const marketFound = findMarketByAddress(environment, marketInfo.market);
+    if (marketFound) {
+      tokenPrices.push({
+        token: marketFound.underlyingToken,
+        tokenPrice: new Amount(
+          marketInfo.underlyingPrice,
+          36 - marketFound.underlyingToken.decimals,
+        ),
+      });
+    }
+  }
 
-        // Add native token to token prices
-        tokenPrices = [
-          ...tokenPrices,
-          {
-            token: findTokenByAddress(environment, zeroAddress)!,
-            tokenPrice: nativeTokenPrice,
-          },
-        ];
+  // Add governance token to token prices
+  const governanceToken = environment.custom?.governance?.token
+    ? environment.config.tokens[environment.custom.governance.token]
+    : undefined;
+  if (governanceToken) {
+    tokenPrices.push({
+      token: governanceToken,
+      tokenPrice: new Amount(governanceTokenPriceRaw, 18),
+    });
+  }
 
-        const rewards = await getRewardsData(
-          environment,
-          vaultConfig.multiReward,
-        );
+  // Add native token to token prices
+  const nativeToken = findTokenByAddress(environment, zeroAddress);
+  if (nativeToken) {
+    tokenPrices.push({
+      token: nativeToken,
+      tokenPrice: new Amount(nativeTokenPriceRaw ?? 0n, 18),
+    });
+  }
 
-        const distributorTotalSupply = await getTotalSupplyData(
-          environment,
-          vaultConfig.multiReward,
-        );
+  return tokenPrices;
+}
 
-        rewards
-          .filter(
-            (reward) =>
-              reward?.periodFinish &&
-              dayjs.utc().isBefore(dayjs.unix(Number(reward.periodFinish))),
-          )
-          .forEach((reward) => {
-            const token = Object.values(environment.config.tokens).find(
-              (token) => token.address === reward?.token,
-            );
-            if (!token || !reward?.rewardRate) return;
+async function addStakingRewardsForEnvironment(
+  environment: Environment,
+  group: { vault: MorphoVault; multiReward: Address }[],
+): Promise<void> {
+  const vaultKeys = group.map(({ vault }) => vault.vaultKey);
 
-            const market = tokenPrices.find(
-              (m) => m?.token.address === reward.token,
-            );
+  let tokenPrices: { token: TokenConfig; tokenPrice: Amount }[];
+  try {
+    tokenPrices = await getStakingRewardTokenPrices(environment);
+  } catch (error) {
+    console.warn(
+      `Failed to fetch staking reward prices for chain ${environment.chainId}:`,
+      error,
+    );
+    environment.onError?.(error, {
+      source: "morpho-vault-staking-rewards",
+      chainId: environment.chainId,
+      operation: "staking-reward-prices",
+      failedCount: group.length,
+      totalCount: group.length,
+      items: vaultKeys,
+    });
+    return;
+  }
 
-            const rewardPriceUsd = market?.tokenPrice.value ?? 0;
-
-            const rewardsPerYear =
-              new Amount(reward.rewardRate, market?.token.decimals ?? 18)
-                .value *
-              SECONDS_PER_YEAR *
-              rewardPriceUsd;
-
-            vault.stakingRewards.push({
-              apr:
-                (rewardsPerYear /
-                  (new Amount(distributorTotalSupply, vault.vaultToken.decimals)
-                    .value *
-                    vault.underlyingPrice)) *
-                100,
-              token: token,
-            });
+  const settlements = await Promise.allSettled(
+    group.map(async ({ vault, multiReward }) => {
+      const [rewards, distributorTotalSupply] = await Promise.all([
+        getRewardsData(environment, multiReward),
+        getTotalSupplyData(environment, multiReward),
+      ]);
+
+      rewards
+        .filter(
+          (reward) =>
+            reward?.periodFinish &&
+            dayjs.utc().isBefore(dayjs.unix(Number(reward.periodFinish))),
+        )
+        .forEach((reward) => {
+          const token = Object.values(environment.config.tokens).find(
+            (token) => token.address === reward?.token,
+          );
+          if (!token || !reward?.rewardRate) return;
+
+          const market = tokenPrices.find(
+            (m) => m?.token.address === reward.token,
+          );
+
+          const rewardPriceUsd = market?.tokenPrice.value ?? 0;
+
+          const rewardsPerYear =
+            new Amount(reward.rewardRate, market?.token.decimals ?? 18).value *
+            SECONDS_PER_YEAR *
+            rewardPriceUsd;
+
+          vault.stakingRewards.push({
+            apr:
+              (rewardsPerYear /
+                (new Amount(distributorTotalSupply, vault.vaultToken.decimals)
+                  .value *
+                  vault.underlyingPrice)) *
+              100,
+            token: token,
           });
+        });
 
-        vault.stakingRewardsApr = vault.stakingRewards.reduce(
-          (acc, curr) => acc + curr.apr,
-          0,
-        );
-        vault.totalStakingApr = vault.stakingRewardsApr + vault.baseApy;
-      } catch (error) {
-        console.warn(
-          `Failed to fetch staking rewards for vault ${vault.vaultKey}:`,
-          error,
-        );
-      }
-    }
-  }
+      vault.stakingRewardsApr = vault.stakingRewards.reduce(
+        (acc, curr) => acc + curr.apr,
+        0,
+      );
+      vault.totalStakingApr = vault.stakingRewardsApr + vault.baseApy;
+    }),
+  );
 
-  return [...allVaults, ...fallbackVaults];
+  const failedVaultKeys = vaultKeys.filter(
+    (_, i) => settlements[i]?.status === "rejected",
+  );
+  const firstFailure = settlements.find(
+    (s): s is PromiseRejectedResult => s.status === "rejected",
+  );
+  if (firstFailure) {
+    console.warn(
+      `Failed to fetch staking rewards for vault(s) ${failedVaultKeys.join(", ")} (chain ${environment.chainId}):`,
+      firstFailure.reason,
+    );
+    environment.onError?.(firstFailure.reason, {
+      source: "morpho-vault-staking-rewards",
+      chainId: environment.chainId,
+      operation: "staking-rewards",
+      failedCount: failedVaultKeys.length,
+      totalCount: group.length,
+      items: failedVaultKeys,
+    });
+  }
 }
 
 export async function getMorphoVaultsData(params: {
@@ -1060,13 +1100,7 @@ async function getMorphoVaultsDataFromOnChain(params: {
       const data = await Promise.all([
         viewsContract?.read.getAllMarketsInfo(),
         homeViewsContract?.read.getNativeTokenPrice(),
-        getGovernanceTokenPriceFor(environment).catch((err) => {
-          environment.onError?.(err, {
-            source: "governance-token-price",
-            chainId: environment.chainId,
-          });
-          return 0n;
-        }),
+        getGovernanceTokenPriceOrZero(environment),
       ]);
 
       const [allMarkets, nativeTokenPriceRaw, governanceTokenPriceRaw] = data;

package/actions/morpho/vaults/lunarIndexerTransform.ts

@@ -15,6 +15,7 @@ import type {
   MorphoVaultMarket,
   MorphoVaultSnapshot,
 } from "../../../types/morphoVault.js";
+import { LunarIndexerError } from "../../lunar-indexer-client.js";
 
 /**
  * Lunar Indexer API Response Types
@@ -248,13 +249,14 @@ export function transformVaultFromIndexer(
   // where totalLiquidity briefly exceeds totalAssets.
   const vaultSupplyValue = Math.max(0, totalAssetsValue - totalLiquidityValue);
 
-  // Transform markets
-  const markets = indexerVault.markets.map((market) =>
+  // Transform markets. The indexer has served vaults without `markets` /
+  // `rewards` (Sentry MOONWELL-FRONTEND-GX); keep the vault with empty lists.
+  const markets = (indexerVault.markets ?? []).map((market) =>
     transformMarket(market, underlyingDecimals, totalAssetsValue, tokenMap),
   );
 
   // Transform rewards
-  const rewards = transformRewards(indexerVault.rewards, tokenMap);
+  const rewards = transformRewards(indexerVault.rewards ?? [], tokenMap);
 
   // Build vault object
   const vault: MorphoVault = {
@@ -313,9 +315,99 @@ export function transformVaultsFromIndexer(
   environment: Environment,
   tokenMap: Map<string, LunarIndexerToken>,
 ): MorphoVault[] {
-  return indexerVaults.map((vault) =>
-    transformVaultFromIndexer(vault, environment, tokenMap),
-  );
+  // A malformed record costs only that record, never the chain's whole list.
+  // Missing `markets` / `rewards` keep the vault (as empty lists); a vault
+  // that cannot be built at all is dropped. Both are reported once per call,
+  // with `droppedCount` telling them apart: only the first error is reported,
+  // so a consumer demoting the kept case (the frontend logs it at warning,
+  // since the list still renders in full) would otherwise misread a batch
+  // where a kept record precedes a dropped one.
+  const malformed: string[] = [];
+  let droppedCount = 0;
+  let firstError: unknown;
+  const vaults = indexerVaults.flatMap((vault) => {
+    // A `null` entry would throw on `vault.markets` below, before the try
+    // (PR #339 review). Drop it and count it with the other malformed records.
+    if (vault === null || typeof vault !== "object") {
+      malformed.push(String(vault));
+      droppedCount += 1;
+      firstError ??= new Error(
+        `Lunar Indexer vault record is ${String(vault)}, not an object`,
+      );
+      return [];
+    }
+    if (!Array.isArray(vault.markets) || !Array.isArray(vault.rewards)) {
+      malformed.push(vault.address);
+      firstError ??= new Error(
+        `Lunar Indexer vault ${vault.address} is missing ${!Array.isArray(vault.markets) ? "markets" : "rewards"}`,
+      );
+    }
+    try {
+      return [transformVaultFromIndexer(vault, environment, tokenMap)];
+    } catch (error) {
+      if (!malformed.includes(vault.address)) malformed.push(vault.address);
+      droppedCount += 1;
+      firstError ??= error;
+      return [];
+    }
+  });
+
+  if (malformed.length > 0) {
+    console.warn(
+      `Malformed Lunar Indexer vault record(s) on chain ${environment.chainId}: ${malformed.join(", ")}`,
+      firstError,
+    );
+    environment.onError?.(firstError, {
+      source: "vaults",
+      chainId: environment.chainId,
+      operation: "malformed-vault-records",
+      failedCount: malformed.length,
+      totalCount: indexerVaults.length,
+      items: malformed,
+      droppedCount,
+    });
+  }
+
+  return vaults;
+}
+
+/**
+ * Fetch JSON from the Lunar Indexer and reject on a non-OK or missing response.
+ *
+ * `response` can arrive `undefined` when a wallet extension monkeypatches
+ * `window.fetch` (Sentry MOONWELL-FRONTEND-H0 / -133, MOO-535); reading `.ok`
+ * on it used to throw a bare TypeError instead of a diagnosable error.
+ *
+ * The rejection is a `LunarIndexerError` whose message must not start with
+ * "Failed to fetch": the frontend's Sentry noise filter substring-matches that
+ * browser transport text and dropped every failure raised here (PR #339
+ * review). Consumers should match on `error.name`, not on the message.
+ *
+ * `AbortSignal.timeout` is missing in Safari < 16 and older WebViews, where it
+ * throws a bare TypeError before `fetch` runs; use AbortController instead and
+ * keep the timer alive until the body has been read.
+ */
+async function fetchJsonFromIndexer<T>(url: string, what: string): Promise<T> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 10_000);
+  try {
+    const response: Response | undefined = await fetch(url, {
+      signal: controller.signal,
+    });
+    if (!response?.ok) {
+      const status = response
+        ? `${response.status} ${response.statusText}`
+        : "no response";
+      throw new LunarIndexerError(
+        `Lunar Indexer ${what} request failed: ${status}`,
+        response?.status,
+        url,
+      );
+    }
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
 }
 
 /**
@@ -331,16 +423,16 @@ export async function fetchTokenMap(
 ): Promise<Map<string, LunarIndexerToken>> {
   const url = `${lunarIndexerUrl}/api/v1/vaults/tokens/${chainId}`;
 
-  const response = await fetch(url, { signal: AbortSignal.timeout(10_000) });
-
-  if (!response.ok) {
+  const data = await fetchJsonFromIndexer<LunarIndexerTokensResponse>(
+    url,
+    "tokens",
+  );
+  if (!Array.isArray(data?.results)) {
     throw new Error(
-      `Failed to fetch tokens from Lunar Indexer: ${response.status} ${response.statusText}`,
+      `Lunar Indexer tokens response for chain ${chainId} is missing the results array`,
     );
   }
 
-  const data: LunarIndexerTokensResponse = await response.json();
-
   const tokenMap = new Map<string, LunarIndexerToken>();
   for (const token of data.results) {
     tokenMap.set(token.address.toLowerCase(), token);
@@ -373,15 +465,17 @@ export async function fetchVaultsFromIndexer(
 
   const url = `${lunarIndexerUrl}/api/v1/vaults/vaults/${chainId}${params.toString() ? `?${params.toString()}` : ""}`;
 
-  const response = await fetch(url, { signal: AbortSignal.timeout(10_000) });
-
-  if (!response.ok) {
+  const data = await fetchJsonFromIndexer<LunarIndexerVaultsResponse>(
+    url,
+    "vaults",
+  );
+  // transformVaultsFromIndexer calls `.flatMap` on this array (PR #339 review).
+  if (!Array.isArray(data?.results)) {
     throw new Error(
-      `Failed to fetch vaults from Lunar Indexer: ${response.status} ${response.statusText}`,
+      `Lunar Indexer vaults response for chain ${chainId} is missing the results array`,
     );
   }
-
-  return response.json();
+  return data;
 }
 
 /**
@@ -397,15 +491,7 @@ export async function fetchVaultFromIndexer(
 ): Promise<LunarIndexerVault> {
   const url = `${lunarIndexerUrl}/api/v1/vaults/vault/${vaultId}`;
 
-  const response = await fetch(url, { signal: AbortSignal.timeout(10_000) });
-
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch vault from Lunar Indexer: ${response.status} ${response.statusText}`,
-    );
-  }
-
-  return response.json();
+  return fetchJsonFromIndexer<LunarIndexerVault>(url, "vault");
 }
 
 /**
@@ -464,15 +550,10 @@ export async function fetchVaultSnapshotsFromIndexer(
   const queryString = params.toString();
   const url = `${lunarIndexerUrl}/api/v1/vaults/vault/${vaultId}/snapshots${queryString ? `?${queryString}` : ""}`;
 
-  const response = await fetch(url, { signal: AbortSignal.timeout(10_000) });
-
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch vault snapshots from Lunar Indexer: ${response.status} ${response.statusText}`,
-    );
-  }
-
-  return response.json();
+  return fetchJsonFromIndexer<LunarIndexerVaultSnapshotsResponse>(
+    url,
+    "vault snapshots",
+  );
 }
 
 /**

package/environments/types/config.ts

@@ -228,11 +228,27 @@ export type ContractsConfig<contracts, tokens> = {} extends contracts
   ? {}
   : { [name in keyof ContractConfig<tokens>]?: ContractConfig<tokens>[name] };
 
-/** Context passed to `onError` callbacks. `token` is set for per-token read failures. */
+/**
+ * Context passed to `onError` callbacks. `token` is set for per-token read failures.
+ *
+ * Batched reads report once per operation rather than once per item: `error`
+ * is the first failure, `failedCount`/`totalCount` size the batch and `items`
+ * identifies what failed (proposalIds, token/vault addresses, chainIds...).
+ *
+ * `droppedCount` is how many of the failed items were left out of the result
+ * rather than kept in a degraded form. Only `error` (the first failure) is
+ * reported, so without it a consumer cannot tell a batch whose failed records
+ * were all kept from one where a later record was dropped.
+ */
 export type OnErrorContext = {
   source: string;
   chainId: number;
   token?: Address;
+  operation?: string;
+  failedCount?: number;
+  totalCount?: number;
+  items?: string[];
+  droppedCount?: number;
 };
 
 export type CustomConfig<custom> = {} extends custom

package/errors/version.ts

@@ -1 +1 @@
-export const version = '0.24.0'
+export const version = '0.25.1'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@moonwell-fi/moonwell-sdk",
   "description": "TypeScript Interface for Moonwell",
-  "version": "0.24.0",
+  "version": "0.25.1",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -76,7 +76,7 @@
     "@rhinestone/module-sdk": "0.2.7",
     "@types/lodash": "^4.17.9",
     "@types/node": "^22.13.10",
-    "axios": "^1.18.1",
+    "axios": "^1.20.0",
     "dayjs": "^1.11.20",
     "lodash": "^4.17.21",
     "viem": "^2.26.2"