@moonwell-fi/moonwell-sdk 0.23.0 → 0.25.0

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

@@ -1,4 +1,3 @@
-import axios from "axios";
 import { mainnet } from "viem/chains";
 import { Amount } from "../../../common/index.js";
 import type { Environment } from "../../../environments/index.js";
@@ -23,8 +22,6 @@ const MULTICHAIN_WORMHOLE_BRIDGES: ReadonlySet<string> = new Set([
   "0x98f3c9e6e3face36baad05fe09d375ef1464288b", // Ethereum
 ]);
 
-axios.defaults.timeout = 5_000;
-
 /**
  * Extract proposal subtitle from description
  */
@@ -450,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;
@@ -504,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);
         }
       }
 
@@ -612,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/index.ts

@@ -116,6 +116,11 @@ export {
   type GetMorphoMarketsParameters,
   type GetMorphoMarketsReturnType,
 } from "./morpho/markets/getMorphoMarkets.js";
+export {
+  getMorphoMarketsSharedLiquidity,
+  type GetMorphoMarketsSharedLiquidityParameters,
+  type GetMorphoMarketsSharedLiquidityReturnType,
+} from "./morpho/markets/getMorphoMarketsSharedLiquidity.js";
 export {
   getMarketSnapshots as getMorphoMarketSnapshots,
   type GetMarketSnapshotsParameters as GetMorphoMarketSnapshotsParameters,