@moonwell-fi/moonwell-sdk 0.24.0 → 0.25.1

package/actions/governance/getUserStakingInfo.ts

@@ -6,7 +6,7 @@ import type { OptionalNetworkParameterType } from "../../common/types.js";
 import type { Environment } from "../../environments/index.js";
 import type { UserStakingInfo } from "../../types/staking.js";
 import { getMerklCampaignIds, getMerklRewardsData } from "./common.js";
-import { getGovernanceTokenPriceFor } from "./getWellPrice.js";
+import { getGovernanceTokenPriceOrZero } from "./getWellPrice.js";
 
 export type GetUserStakingInfoParameters<
   environments,
@@ -150,7 +150,7 @@ export async function getUserStakingInfo<
         environment.contracts.views?.read.getUserStakingInfo([userAddress]),
         environment.contracts.governanceToken?.read.balanceOf([userAddress]),
         environment.contracts.views?.read.getStakingInfo(),
-        getGovernanceTokenPriceFor(environment, baseEnvironment),
+        getGovernanceTokenPriceOrZero(environment, baseEnvironment),
       ]);
 
       const [userStakingR, balanceR, stakingScheduleR, priceR] = settled;
@@ -175,12 +175,6 @@ export async function getUserStakingInfo<
           : 0n;
 
       const price = priceR.status === "fulfilled" ? priceR.value : 0n;
-      if (priceR.status === "rejected") {
-        environment.onError?.(priceR.reason, {
-          source: "governance-token-price",
-          chainId: environment.chainId,
-        });
-      }
 
       return { userStaking, schedule, tokenBalance, price };
     }),

package/actions/governance/getWellPrice.ts

@@ -41,6 +41,71 @@ export async function getWellPriceFromBaseOracle(
   return await oracle.read.getUnderlyingPrice([mWELL]);
 }
 
+async function readGovernanceTokenPrice(
+  environment: Environment,
+  baseEnvironment?: Environment,
+): Promise<bigint> {
+  if (environment.custom?.governance?.token === "WELL") {
+    return getWellPriceFromBaseOracle(baseEnvironment);
+  }
+  // Non-WELL (e.g. Moonriver / MFAM): the env itself is the governance "home".
+  const views = environment.contracts.views;
+  if (!views) return 0n;
+  return (await views.read.getGovernanceTokenPrice()) ?? 0n;
+}
+
+const GOVERNANCE_TOKEN_PRICE_TTL_MS = 10_000;
+
+type OnErrorCallback = NonNullable<Environment["onError"]>;
+
+type GovernanceTokenPriceEntry = {
+  promise: Promise<bigint>;
+  expiresAt: number;
+  requestingChainIds: Set<number>;
+  /** Callbacks already told about this read's failure. */
+  reportedTo: Set<OnErrorCallback>;
+};
+
+// Keyed by the environment the price is read through (the Base env for every
+// WELL chain), so markets, vaults, rewards and staking reads issued together
+// share one request, while clients with their own RPCs never share results.
+const governanceTokenPriceCache = new WeakMap<
+  Environment,
+  GovernanceTokenPriceEntry
+>();
+
+function getSharedGovernanceTokenPrice(
+  environment: Environment,
+  baseEnvironment?: Environment,
+): { sourceChainId: number; entry: GovernanceTokenPriceEntry } {
+  const sourceEnvironment: Environment =
+    environment.custom?.governance?.token === "WELL"
+      ? (baseEnvironment ?? publicEnvironments.base)
+      : environment;
+  const sourceChainId = sourceEnvironment.chainId;
+
+  const cached = governanceTokenPriceCache.get(sourceEnvironment);
+  if (cached && Date.now() < cached.expiresAt) {
+    cached.requestingChainIds.add(environment.chainId);
+    return { sourceChainId, entry: cached };
+  }
+
+  const entry: GovernanceTokenPriceEntry = {
+    promise: readGovernanceTokenPrice(environment, baseEnvironment),
+    expiresAt: Date.now() + GOVERNANCE_TOKEN_PRICE_TTL_MS,
+    requestingChainIds: new Set([environment.chainId]),
+    reportedTo: new Set(),
+  };
+  governanceTokenPriceCache.set(sourceEnvironment, entry);
+  // Failures are never cached: evict so the next call reads again.
+  entry.promise.catch(() => {
+    if (governanceTokenPriceCache.get(sourceEnvironment) === entry) {
+      governanceTokenPriceCache.delete(sourceEnvironment);
+    }
+  });
+  return { sourceChainId, entry };
+}
+
 /**
  * Returns the governance-token-in-USD price for an environment.
  *
@@ -50,17 +115,44 @@ export async function getWellPriceFromBaseOracle(
  *   env's own views.getGovernanceTokenPrice() — Moonriver has its own MFAM
  *   oracle and isn't priced from Base.
  *
- * Returns 0n if the lookup fails.
+ * Concurrent calls for the same price source share one in-flight read, and a
+ * successful price is reused for a few seconds. Rejects if the read fails.
  */
 export async function getGovernanceTokenPriceFor(
   environment: Environment,
   baseEnvironment?: Environment,
 ): Promise<bigint> {
-  if (environment.custom?.governance?.token === "WELL") {
-    return getWellPriceFromBaseOracle(baseEnvironment);
+  return getSharedGovernanceTokenPrice(environment, baseEnvironment).entry
+    .promise;
+}
+
+/**
+ * Same shared read as `getGovernanceTokenPriceFor`, but resolves to 0n on
+ * failure. A failed shared read is reported once per `onError` callback,
+ * however many callers using that callback were waiting on it; `items` lists
+ * the requesting chainIds.
+ */
+export async function getGovernanceTokenPriceOrZero(
+  environment: Environment,
+  baseEnvironment?: Environment,
+): Promise<bigint> {
+  const { sourceChainId, entry } = getSharedGovernanceTokenPrice(
+    environment,
+    baseEnvironment,
+  );
+  try {
+    return await entry.promise;
+  } catch (error) {
+    const onError = environment.onError;
+    if (onError && !entry.reportedTo.has(onError)) {
+      entry.reportedTo.add(onError);
+      environment.onError?.(error, {
+        source: "governance-token-price",
+        chainId: sourceChainId,
+        operation: "governance-token-price-read",
+        items: [...entry.requestingChainIds].map(String),
+      });
+    }
+    return 0n;
   }
-  // Non-WELL (e.g. Moonriver / MFAM): the env itself is the governance "home".
-  const views = environment.contracts.views;
-  if (!views) return 0n;
-  return (await views.read.getGovernanceTokenPrice()) ?? 0n;
 }

package/actions/governance/proposals/common.ts

@@ -447,6 +447,29 @@ export const getProposalsOnChainData = async (
       ? governanceEnvironment
       : getEnvironmentByChainId(chainId);
 
+  // viem batches these reads into one multicall, so a single failed request
+  // rejects every read in it. Collect failures per chain and report them once
+  // after the batch instead of once per read (Sentry MOONWELL-FRONTEND-1AX).
+  const readFailures = new Map<
+    number,
+    { error: unknown; failed: number; total: number; proposalIds: Set<string> }
+  >();
+  const recordRead = (chainId: number, proposalId: number, error?: unknown) => {
+    const entry = readFailures.get(chainId) ?? {
+      error: undefined,
+      failed: 0,
+      total: 0,
+      proposalIds: new Set<string>(),
+    };
+    entry.total++;
+    if (error !== undefined) {
+      entry.error ??= error;
+      entry.failed++;
+      entry.proposalIds.add(String(proposalId));
+    }
+    readFailures.set(chainId, entry);
+  };
+
   const onChainDataList = await Promise.all(
     apiProposals.map(async (p) => {
       const isLocal = p.chainId === governanceEnvironment.chainId;
@@ -501,29 +524,17 @@ export const getProposalsOnChainData = async (
         ]);
         if (stateResult.status === "fulfilled") {
           state = Number(stateResult.value);
+          recordRead(p.chainId, p.proposalId);
         } else {
           stateReadFailed = true;
-          console.warn(
-            `Failed to fetch state for proposal ${p.proposalId} (chainId=${p.chainId}):`,
-            stateResult.reason,
-          );
-          governanceEnvironment.onError?.(stateResult.reason, {
-            source: "governance-proposals",
-            chainId: p.chainId,
-          });
+          recordRead(p.chainId, p.proposalId, stateResult.reason);
         }
         if (proposalsResult.status === "fulfilled") {
           proposalData = proposalsResult.value ?? null;
+          recordRead(p.chainId, p.proposalId);
         } else {
           proposalsReadFailed = true;
-          console.warn(
-            `Failed to fetch proposalData for proposal ${p.proposalId} (chainId=${p.chainId}):`,
-            proposalsResult.reason,
-          );
-          governanceEnvironment.onError?.(proposalsResult.reason, {
-            source: "governance-proposals",
-            chainId: p.chainId,
-          });
+          recordRead(p.chainId, p.proposalId, proposalsResult.reason);
         }
       }
 
@@ -609,6 +620,23 @@ export const getProposalsOnChainData = async (
     }),
   );
 
+  for (const [chainId, entry] of readFailures) {
+    if (entry.failed === 0) continue;
+    const proposalIds = [...entry.proposalIds];
+    console.warn(
+      `Failed ${entry.failed}/${entry.total} governor reads (chainId=${chainId}, proposals ${proposalIds.join(", ")}):`,
+      entry.error,
+    );
+    governanceEnvironment.onError?.(entry.error, {
+      source: "governance-proposals",
+      chainId,
+      operation: "proposal-onchain-read",
+      failedCount: entry.failed,
+      totalCount: entry.total,
+      items: proposalIds,
+    });
+  }
+
   return onChainDataList;
 };
 

package/actions/governance/proposals/getProposals.ts

@@ -20,7 +20,16 @@ import {
 export type GetProposalsParameters<
   environments,
   network extends Chain | undefined,
-> = OptionalNetworkParameterType<environments, network>;
+> = OptionalNetworkParameterType<environments, network> & {
+  /**
+   * Governance chains to fetch proposals from: 1 (Ethereum, active),
+   * 1284 (Moonbeam archive) and/or 1285 (Moonriver archive). Defaults to all
+   * of them. The archives hold almost all of the payload (~6.6MB of ~7MB), so
+   * views that only show recent proposals can pass `[1]` and load the archives
+   * separately when needed. Unsupported chainIds are ignored.
+   */
+  proposalChainIds?: readonly number[];
+};
 
 export type GetProposalsReturnType = Promise<Proposal[]>;
 
@@ -42,7 +51,10 @@ export async function getProposals<
     return [];
   }
 
-  const proposals = await fetchGovernorProposals(governanceEnvironment);
+  const proposals = await fetchGovernorProposals(
+    governanceEnvironment,
+    args?.proposalChainIds,
+  );
   // Newer multigov-ethereum proposals (chainId=1) and historical Moonbeam
   // proposals (chainId=1284) restart their proposalId counters from 1, so IDs
   // may collide across chains. Sort by proposalId desc with chainId as a
@@ -58,7 +70,8 @@ export async function getProposals<
 }
 
 /**
- * Fetch every proposal the Governor API serves, across all governance chains.
+ * Fetch every proposal the Governor API serves, across all governance chains
+ * (or only `proposalChainIds`, when given).
  *
  * One indexer DO serves them all:
  *   - chainId=1    (Ethereum)  — the active multigov contract
@@ -76,16 +89,20 @@ export async function getProposals<
  */
 async function fetchGovernorProposals(
   governanceEnvironment: Environment,
+  proposalChainIds?: readonly number[],
 ): Promise<Proposal[]> {
+  const chainIds = SUPPORTED_GOVERNOR_CHAIN_IDS.filter(
+    (chainId) => !proposalChainIds || proposalChainIds.includes(chainId),
+  );
   const results = await Promise.allSettled(
-    SUPPORTED_GOVERNOR_CHAIN_IDS.map((chainId) =>
+    chainIds.map((chainId) =>
       fetchAllProposals(governanceEnvironment, { chainId }),
     ),
   );
 
   const apiProposals: ApiProposal[] = [];
   results.forEach((result, index) => {
-    const chainId = SUPPORTED_GOVERNOR_CHAIN_IDS[index];
+    const chainId = chainIds[index];
     if (result.status === "fulfilled") {
       apiProposals.push(...result.value);
     } else if (chainId !== undefined) {

package/actions/morpho/markets/common.ts

@@ -76,6 +76,21 @@ function validateLoanDecimals(value: unknown): number {
   return value;
 }
 
+/** Summarizes an unexpected top-level body so the error says what arrived. */
+function describeSharedLiquidityBody(data: unknown): string {
+  if (data === null || data === undefined) return `received ${data}`;
+  if (typeof data === "string") {
+    return `received string of ${data.length} chars: ${JSON.stringify(data.slice(0, 100))}`;
+  }
+  if (typeof data !== "object") return `received ${typeof data}`;
+  if (Array.isArray(data)) return `received array of ${data.length}`;
+  const body = data as Record<string, unknown>;
+  const kind = (value: unknown): string =>
+    Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
+  const keys = Object.keys(body).slice(0, 10).join(", ");
+  return `received object with keys [${keys}]; vaults: ${kind(body.vaults)}, markets: ${kind(body.markets)}`;
+}
+
 function validatedMarketLiquidity(
   data: LunarSharedLiquidityResponse,
 ): Map<string, number> {
@@ -86,9 +101,19 @@ function validatedMarketLiquidity(
     typeof data.markets !== "object" ||
     Array.isArray(data.markets)
   ) {
-    throw new TypeError("Invalid shared-liquidity response");
+    throw new TypeError(
+      `Invalid shared-liquidity response (${describeSharedLiquidityBody(data)})`,
+    );
   }
   for (const vault of data.vaults) {
+    // A null entry or a vault record without `markets` (Sentry
+    // MOONWELL-FRONTEND-116, MOO-535) must fail validation here, not as a
+    // TypeError from `vault.fee` or the loop below.
+    if (!vault || !Array.isArray(vault.markets)) {
+      throw new TypeError(
+        `Invalid shared-liquidity response (vault ${vault?.address ?? "<null>"} has no markets array)`,
+      );
+    }
     parseLiquidityQuantity(vault.fee, "vault.fee", true);
     for (const market of vault.markets) {
       for (const field of [
@@ -158,13 +183,31 @@ export async function fetchSharedLiquidityFromLunar(
   const abort = (): void => controller.abort();
   if (options.signal?.aborted) abort();
   options.signal?.addEventListener("abort", abort, { once: true });
-  const timer = setTimeout(abort, timeoutMs);
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    abort();
+  }, timeoutMs);
   try {
     const response = await getWithRetry<LunarSharedLiquidityResponse>(
       `${lunarIndexerUrl}/api/v1/isolated/shared-liquidity/${chainId}`,
       { timeout: timeoutMs, signal: controller.signal },
     );
     return response.data;
+  } catch (error) {
+    // Our own deadline aborts the request, which axios reports as a bare
+    // `CanceledError: canceled` (Sentry MOONWELL-FRONTEND-1C7 & co). That is a
+    // timeout, not a cancellation: surface it as one. A caller's own abort
+    // still propagates as the CanceledError it is.
+    if (timedOut && !options.signal?.aborted) {
+      const timeoutError = new Error(
+        `Shared-liquidity request timed out after ${timeoutMs}ms (chainId=${chainId})`,
+        { cause: error },
+      );
+      timeoutError.name = "TimeoutError";
+      throw timeoutError;
+    }
+    throw error;
   } finally {
     clearTimeout(timer);
     options.signal?.removeEventListener("abort", abort);

package/actions/morpho/markets/lunarIndexerTransform.ts

@@ -186,6 +186,13 @@ export async function fetchMarketsFromIndexer(
   const queryString = params.toString();
   const url = `${lunarIndexerUrl}/api/v1/isolated/markets/${chainId}${queryString ? `?${queryString}` : ""}`;
   const response = await getWithRetry<LunarIndexerMarketsResponse>(url);
+  // A 2xx body without `results` otherwise reaches `.filter` / iteration in
+  // getMorphoMarketsDataFromIndexer as a TypeError (PR #339 review).
+  if (!Array.isArray(response.data?.results)) {
+    throw new Error(
+      `Lunar Indexer morpho markets response for chain ${chainId} is missing the results array`,
+    );
+  }
   return response.data;
 }
 

package/actions/morpho/user-rewards/common.ts

@@ -13,7 +13,7 @@ import {
 } from "../../../environments/utils/index.js";
 import type { MorphoUserReward } from "../../../types/morphoUserReward.js";
 import type { MorphoUserStakingReward } from "../../../types/morphoUserStakingReward.js";
-import { getGovernanceTokenPriceFor } from "../../governance/getWellPrice.js";
+import { getGovernanceTokenPriceOrZero } from "../../governance/getWellPrice.js";
 
 /**
  * Error thrown for any failure communicating with the Merkl API: non-ok HTTP
@@ -166,13 +166,7 @@ export async function getUserMorphoStakingRewardsData(params: {
     await Promise.all([
       viewsContract?.read.getAllMarketsInfo(),
       homeViewsContract?.read.getNativeTokenPrice(),
-      getGovernanceTokenPriceFor(params.environment).catch((err) => {
-        params.environment.onError?.(err, {
-          source: "governance-token-price",
-          chainId: params.environment.chainId,
-        });
-        return 0n;
-      }),
+      getGovernanceTokenPriceOrZero(params.environment),
     ]);
 
   const governanceTokenPrice = new Amount(governanceTokenPriceRaw, 18);