@moonwell-fi/moonwell-sdk 0.22.0 → 0.24.0

package/actions/core/getUserBalances.ts

@@ -22,27 +22,29 @@ export type GetUserBalancesParameters<
 
 export type GetUserBalancesReturnType = Promise<UserBalance[]>;
 
+/**
+ * Reads one token balance. Rejects when the read fails — it must never resolve
+ * to a zero, which is what it did before MOO-832: an RPC failure surfaced to
+ * consumers as a "successful" empty wallet. The Moonwell frontend gates repay-all
+ * on this figure, so a transient RPC hiccup on a 5s refetch read as "wallet is
+ * empty" and disabled the confirm button for 59 users (Sentry
+ * MOONWELL-FRONTEND-195). Callers settle these with `Promise.allSettled` and
+ * omit the rejected tokens, so a consumer that finds no entry knows the balance
+ * is UNKNOWN rather than zero. The failure is routed to `environment.onError`
+ * (source `user-balances-token-read`) so Sentry-wired consumers can see the
+ * degraded read.
+ */
 const getTokenBalance = async (
   environment: Environment,
   userAddress: Address,
   tokenAddress: Address,
-) => {
+): Promise<{ amount: bigint; token: `0x${string}` }> => {
   try {
     if (tokenAddress === zeroAddress) {
-      return new Promise<{ amount: bigint; token: `0x${string}` }>(
-        (resolve) => {
-          environment.publicClient
-            .getBalance({
-              address: userAddress,
-            })
-            .then((balance) => {
-              resolve({ amount: BigInt(balance), token: tokenAddress });
-            })
-            .catch(() => {
-              resolve({ amount: 0n, token: tokenAddress });
-            });
-        },
-      );
+      const balance = await environment.publicClient.getBalance({
+        address: userAddress,
+      });
+      return { amount: BigInt(balance), token: tokenAddress };
     }
 
     const erc20Abi = parseAbi([
@@ -55,23 +57,15 @@ const getTokenBalance = async (
       client: environment.publicClient,
     });
 
-    const result = new Promise<{ amount: bigint; token: `0x${string}` }>(
-      (resolve) => {
-        erc20Contract.read
-          .balanceOf([userAddress])
-          .then((balance) => {
-            resolve({ amount: BigInt(balance), token: tokenAddress });
-          })
-          .catch(() => {
-            resolve({ amount: 0n, token: tokenAddress });
-          });
-      },
-    );
-
-    return result;
+    const balance = await erc20Contract.read.balanceOf([userAddress]);
+    return { amount: BigInt(balance), token: tokenAddress };
   } catch (error) {
-    console.error("getTokenBalance error", error);
-    return { amount: 0n, token: tokenAddress };
+    environment.onError?.(error, {
+      source: "user-balances-token-read",
+      chainId: environment.chainId,
+      token: tokenAddress,
+    });
+    throw error;
   }
 };
 

package/actions/core/markets/common.ts

@@ -876,54 +876,55 @@ async function fetchMarketsFromLunar(
 }
 
 const fetchFromGenericCacheApi = async <T>(uri: string): Promise<T> => {
-  const response = await fetch(
-    "https://generic-api-cache.moonwell.workers.dev/",
-    {
-      method: "POST",
-      body: `{"uri":"${uri}","cacheDuration":"300"}`,
-      headers: {
-        ...MOONWELL_FETCH_JSON_HEADERS,
-        "Content-Type": "text/plain",
+  // AbortSignal.timeout is not available in every browser supported by SDK
+  // consumers. Keep the timeout local and release it after reading the body.
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 5_000);
+  try {
+    const response = await fetch(
+      "https://generic-api-cache.moonwell.workers.dev/",
+      {
+        method: "POST",
+        body: `{"uri":"${uri}","cacheDuration":"300"}`,
+        signal: controller.signal,
+        headers: {
+          ...MOONWELL_FETCH_JSON_HEADERS,
+          "Content-Type": "text/plain",
+        },
       },
-    },
-  );
+    );
 
-  return response.json() as T;
+    if (!response.ok)
+      throw new Error(`Staking APR request failed: ${response.status}`);
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
 };
 
-export const fetchLiquidStakingRewards = async () => {
-  const result = {
-    cbETH: 0,
-    rETH: 0,
-    wstETH: 0,
-  };
-
-  try {
-    const cbETH = await fetchFromGenericCacheApi<{ apy: string }>(
+export const fetchLiquidStakingRewards = async (): Promise<{
+  cbETH: number;
+  rETH: number;
+  wstETH: number;
+}> => {
+  // Each provider can succeed independently, and each has a bounded request.
+  // Preserve the existing zero fallback for callers of this optional enrichment.
+  const [cbETH, rETH, wstETH] = await Promise.all([
+    fetchFromGenericCacheApi<{ apy: string }>(
       "https://api.exchange.coinbase.com/wrapped-assets/CBETH",
-    );
-    result.cbETH = Number(cbETH.apy) * 100;
-  } catch (error) {
-    result.cbETH = 0;
-  }
-
-  try {
-    const rETH = await fetchFromGenericCacheApi<{ rethAPR: string }>(
+    )
+      .then((result) => Number(result.apy) * 100)
+      .catch(() => 0),
+    fetchFromGenericCacheApi<{ rethAPR: string }>(
       "https://rocketpool.net/api/mainnet/payload",
-    );
-    result.rETH = Number(rETH.rethAPR);
-  } catch (error) {
-    result.rETH = 0;
-  }
-
-  try {
-    const stETH = await fetchFromGenericCacheApi<{ data: { apr: number } }>(
+    )
+      .then((result) => Number(result.rethAPR))
+      .catch(() => 0),
+    fetchFromGenericCacheApi<{ data: { apr: number } }>(
       "https://eth-api.lido.fi/v1/protocol/steth/apr/last",
-    );
-    result.wstETH = stETH.data.apr;
-  } catch (error) {
-    result.wstETH = 0;
-  }
-
-  return result;
+    )
+      .then((result) => result.data.apr)
+      .catch(() => 0),
+  ]);
+  return { cbETH, rETH, wstETH };
 };

package/actions/core/markets/getMarkets.ts

@@ -25,9 +25,14 @@ export async function getMarkets<
   const environments = getEnvironmentsFromArgs(client, args);
   const logId = logger.start("getMarkets", "Starting to get markets...");
 
-  const settlements = await Promise.allSettled(
-    environments.map((environment) => getMarketsData(environment)),
-  );
+  const [settlements, liquidStakingRewards] = await Promise.all([
+    Promise.allSettled(
+      environments.map((environment) => getMarketsData(environment)),
+    ),
+    args?.includeLiquidStakingRewards === true
+      ? fetchLiquidStakingRewards()
+      : undefined,
+  ]);
 
   const result = settlements
     .filter(
@@ -35,8 +40,7 @@ export async function getMarkets<
     )
     .map((s) => s.value);
 
-  if (args?.includeLiquidStakingRewards === true) {
-    const liquidStakingRewards = await fetchLiquidStakingRewards();
+  if (liquidStakingRewards) {
     for (const item of result.flat()) {
       if (item.underlyingToken.symbol.toLowerCase() === "cbeth") {
         item.rewards.push({

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

@@ -15,117 +15,113 @@ export const getUserPositionData = async (params: {
     return [];
   }
 
-  try {
-    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}` }[],
-      );
-    }
+  // Only getAllMarketsInfo is settled, because it has the mToken fallback
+  // below. The three user reads have no fallback: Promise.all lets their first
+  // rejection propagate instead of being treated as an empty list, which would
+  // misreport the user as having no position (MOO-885).
+  const [[allMarketsResult], balances, borrows, memberships] =
+    await Promise.all([
+      Promise.allSettled([viewsContract.read.getAllMarketsInfo()]),
+      viewsContract.read.getUserBalances([params.account]),
+      viewsContract.read.getUserBorrowsBalances([params.account]),
+      viewsContract.read.getUserMarketsMemberships([params.account]),
+    ]);
+
+  // 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. The fallback reports
+  // every USD value as 0, so the degraded read is surfaced through onError
+  // instead of passing as a healthy result.
+  if (allMarketsResult.status === "rejected") {
+    params.environment.onError?.(allMarketsResult.reason, {
+      source: "user-positions-oracle-fallback",
+      chainId: params.environment.chainId,
+    });
+    return getUserPositionsFromMTokenFallback(
+      params,
+      balances,
+      borrows,
+      memberships,
+    );
+  }
 
-    const allMarkets = allMarketsResult.value;
+  const allMarkets = allMarketsResult.value;
+
+  const markets = allMarkets
+    ?.map((marketInfo) => {
+      const market = findMarketByAddress(params.environment, marketInfo.market);
+      if (market) {
+        const { marketToken, underlyingToken } = market;
+
+        const underlyingPrice = new Amount(
+          marketInfo.underlyingPrice,
+          36 - underlyingToken.decimals,
+        ).value;
+        const collateralFactor = new Amount(marketInfo.collateralFactor, 18)
+          .value;
+        const exchangeRate = new Amount(
+          marketInfo.exchangeRate,
+          10 + underlyingToken.decimals,
+        ).value;
+
+        const marketCollateralEnabled =
+          memberships?.find((r) => r.token === marketInfo.market)
+            ?.membership === true;
+        const marketBorrowedRaw =
+          borrows?.find((r) => r.token === marketInfo.market)?.amount || 0n;
+        const marketSuppliedRaw =
+          balances?.find((r) => r.token === marketInfo.market)?.amount || 0n;
+
+        const borrowed = new Amount(
+          marketBorrowedRaw,
+          market.underlyingToken.decimals,
+        );
+        const borrowedUsd = borrowed.value * underlyingPrice;
 
-    const markets = allMarkets
-      ?.map((marketInfo) => {
-        const market = findMarketByAddress(
-          params.environment,
-          marketInfo.market,
+        const marketSupplied = new Amount(
+          marketSuppliedRaw,
+          marketToken.decimals,
         );
-        if (market) {
-          const { marketToken, underlyingToken } = market;
-
-          const underlyingPrice = new Amount(
-            marketInfo.underlyingPrice,
-            36 - underlyingToken.decimals,
-          ).value;
-          const collateralFactor = new Amount(marketInfo.collateralFactor, 18)
-            .value;
-          const exchangeRate = new Amount(
-            marketInfo.exchangeRate,
-            10 + underlyingToken.decimals,
-          ).value;
-
-          const marketCollateralEnabled =
-            memberships?.find((r) => r.token === marketInfo.market)
-              ?.membership === true;
-          const marketBorrowedRaw =
-            borrows?.find((r) => r.token === marketInfo.market)?.amount || 0n;
-          const marketSuppliedRaw =
-            balances?.find((r) => r.token === marketInfo.market)?.amount || 0n;
-
-          const borrowed = new Amount(
-            marketBorrowedRaw,
-            market.underlyingToken.decimals,
-          );
-          const borrowedUsd = borrowed.value * underlyingPrice;
-
-          const marketSupplied = new Amount(
-            marketSuppliedRaw,
-            marketToken.decimals,
-          );
-
-          const supplied = new Amount(
-            marketSupplied.value * exchangeRate,
-            underlyingToken.decimals,
-          );
-          const suppliedUsd = supplied.value * underlyingPrice;
-
-          const collateral = marketCollateralEnabled
-            ? new Amount(
-                supplied.value * collateralFactor,
-                underlyingToken.decimals,
-              )
-            : new Amount(0n, underlyingToken.decimals);
-
-          const collateralUsd = collateral.value * underlyingPrice;
-
-          const result: UserPosition = {
-            chainId: params.environment.chainId,
-            account: params.account,
-            market: market.marketToken,
-            collateralEnabled: marketCollateralEnabled,
-            borrowed,
-            borrowedUsd,
-            collateral,
-            collateralUsd,
-            supplied,
-            suppliedUsd,
-          };
-
-          return result;
-        } else {
-          return;
-        }
-      })
-      .filter((r) => r !== undefined)
-      .filter((r) =>
-        params.markets ? params.markets.includes(r!.market.address) : true,
-      ) as UserPosition[];
-
-    return markets;
-  } catch {
-    return [];
-  }
+
+        const supplied = new Amount(
+          marketSupplied.value * exchangeRate,
+          underlyingToken.decimals,
+        );
+        const suppliedUsd = supplied.value * underlyingPrice;
+
+        const collateral = marketCollateralEnabled
+          ? new Amount(
+              supplied.value * collateralFactor,
+              underlyingToken.decimals,
+            )
+          : new Amount(0n, underlyingToken.decimals);
+
+        const collateralUsd = collateral.value * underlyingPrice;
+
+        const result: UserPosition = {
+          chainId: params.environment.chainId,
+          account: params.account,
+          market: market.marketToken,
+          collateralEnabled: marketCollateralEnabled,
+          borrowed,
+          borrowedUsd,
+          collateral,
+          collateralUsd,
+          supplied,
+          suppliedUsd,
+        };
+
+        return result;
+      } else {
+        return;
+      }
+    })
+    .filter((r) => r !== undefined)
+    .filter((r) =>
+      params.markets ? params.markets.includes(r!.market.address) : true,
+    ) as UserPosition[];
+
+  return markets;
 };
 
 /**
@@ -141,9 +137,9 @@ async function getUserPositionsFromMTokenFallback(
     account: Address;
     markets?: string[] | undefined;
   },
-  balances: { amount: bigint; token: `0x${string}` }[],
-  borrows: { amount: bigint; token: `0x${string}` }[],
-  memberships: { membership: boolean; token: `0x${string}` }[],
+  balances: readonly { amount: bigint; token: `0x${string}` }[],
+  borrows: readonly { amount: bigint; token: `0x${string}` }[],
+  memberships: readonly { membership: boolean; token: `0x${string}` }[],
 ): Promise<UserPosition[]> {
   const positions: UserPosition[] = [];
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

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

@@ -1,6 +1,7 @@
 import type { Address, Chain } from "viem";
 import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
 import { getEnvironmentsFromArgs } from "../../../common/index.js";
+import { readAcrossEnvironments } from "../../../common/readAcrossEnvironments.js";
 import type { OptionalNetworkParameterType } from "../../../common/types.js";
 import type { UserPosition } from "../../../types/userPosition.js";
 import { getUserPositionData } from "./common.js";
@@ -15,6 +16,11 @@ export type GetUserPositionsParameters<
 
 export type GetUserPositionsReturnType = Promise<UserPosition[]>;
 
+/**
+ * Rejects with a `ChainReadError` when the read fails on any requested chain,
+ * so a failed RPC never looks like an empty position list. The error lists the
+ * failed chains and carries the positions from the chains that succeeded.
+ */
 export async function getUserPositions<
   environments,
   Network extends Chain | undefined,
@@ -26,18 +32,13 @@ export async function getUserPositions<
 
   const environments = getEnvironmentsFromArgs(client, args);
 
-  const settled = await Promise.allSettled(
-    environments.map((environment) =>
+  return readAcrossEnvironments({
+    environments,
+    source: "getUserPositions",
+    read: (environment) =>
       getUserPositionData({
         environment,
         account: userAddress,
       }),
-    ),
-  );
-
-  const result = settled.flatMap((s) =>
-    s.status === "fulfilled" ? s.value : [],
-  );
-
-  return result;
+  });
 }

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
  */

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,