@moonwell-fi/moonwell-sdk 0.23.0 → 0.25.0

package/actions/core/getUserBalances.ts

@@ -30,49 +30,74 @@ export type GetUserBalancesReturnType = Promise<UserBalance[]>;
  * 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.
+ * is UNKNOWN rather than zero. Failures are routed to `environment.onError`
+ * (source `user-balances-token-read`) once per chain by `getUserBalances`, 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) {
-      const balance = await environment.publicClient.getBalance({
-        address: userAddress,
-      });
-      return { amount: BigInt(balance), token: tokenAddress };
-    }
-
-    const erc20Abi = parseAbi([
-      "function balanceOf(address owner) view returns (uint256)",
-    ]);
-
-    const erc20Contract = getContract({
-      address: tokenAddress,
-      abi: erc20Abi,
-      client: environment.publicClient,
+  if (tokenAddress === zeroAddress) {
+    const balance = await environment.publicClient.getBalance({
+      address: userAddress,
     });
-
-    const balance = await erc20Contract.read.balanceOf([userAddress]);
     return { amount: BigInt(balance), token: tokenAddress };
-  } catch (error) {
-    environment.onError?.(error, {
-      source: "user-balances-token-read",
-      chainId: environment.chainId,
-      token: tokenAddress,
-    });
-    throw error;
   }
+
+  const erc20Abi = parseAbi([
+    "function balanceOf(address owner) view returns (uint256)",
+  ]);
+
+  const erc20Contract = getContract({
+    address: tokenAddress,
+    abi: erc20Abi,
+    client: environment.publicClient,
+  });
+
+  const balance = await erc20Contract.read.balanceOf([userAddress]);
+  return { amount: BigInt(balance), token: tokenAddress };
+};
+
+type TokenBalanceReads = {
+  balances: { amount: bigint; token: `0x${string}` }[];
+  failures: { token: Address; error: unknown }[];
+  total: number;
+};
+
+/**
+ * Reads each token balance, keeping failures instead of reporting them one by
+ * one: viem batches these reads into one multicall, so a single failed request
+ * rejects every token on the chain.
+ */
+const readTokenBalances = async (
+  environment: Environment,
+  userAddress: Address,
+  tokenAddresses: Address[],
+): Promise<TokenBalanceReads> => {
+  const results = await Promise.all(
+    tokenAddresses.map(async (token) => {
+      try {
+        return {
+          balance: await getTokenBalance(environment, userAddress, token),
+        };
+      } catch (error) {
+        return { failure: { token, error } };
+      }
+    }),
+  );
+  return {
+    balances: results.flatMap((r) => (r.balance ? [r.balance] : [])),
+    failures: results.flatMap((r) => (r.failure ? [r.failure] : [])),
+    total: tokenAddresses.length,
+  };
 };
 
 async function getTokenBalancesFromEnvironment(
   environment: Environment,
   userAddress: Address,
-): Promise<{ amount: bigint; token: `0x${string}` }[]> {
+): Promise<TokenBalanceReads> {
   // Try the views multicall first (single RPC for N tokens). Some chains ship a
   // staking-only views contract (Ethereum's at the time of writing) that doesn't
   // implement getTokensBalances and reverts on the call — in that case fall
@@ -87,7 +112,7 @@ async function getTokenBalancesFromEnvironment(
           userAddress,
         ]);
 
-      return [...tokenBalancesFromView];
+      return { balances: [...tokenBalancesFromView], failures: [], total: 0 };
     } catch (error) {
       environment.onError?.(error, {
         source: "user-balances-views-fallback",
@@ -96,14 +121,10 @@ async function getTokenBalancesFromEnvironment(
     }
   }
 
-  const tokenBalancesSettled = await Promise.allSettled(
-    Object.values(environment.config.tokens).map((token) =>
-      getTokenBalance(environment, userAddress, token.address),
-    ),
-  );
-
-  return tokenBalancesSettled.flatMap((s) =>
-    s.status === "fulfilled" ? s.value : [],
+  return readTokenBalances(
+    environment,
+    userAddress,
+    Object.values(environment.config.tokens).map((token) => token.address),
   );
 }
 
@@ -124,32 +145,58 @@ export async function getUserBalances<
     ),
   );
 
-  const environmentsTokensBalances = environmentsTokensBalancesSettled.map(
-    (s) => (s.status === "fulfilled" ? [...s.value] : []),
+  const environmentsTokenReads = environmentsTokensBalancesSettled.map((s) =>
+    s.status === "fulfilled"
+      ? s.value
+      : { balances: [], failures: [], total: 0 },
   );
+  const environmentsTokensBalances = environmentsTokenReads.map((r) => [
+    ...r.balances,
+  ]);
 
   // Fetch morpho staking balances
   await Promise.all(
     environments.map(async (env, index) => {
       if (!env.config.vaults) return;
 
-      const vaultBalancesSettled = await Promise.allSettled(
-        Object.values(env.config.vaults)
-          .filter((vault) => vault.multiReward)
-          .map((vault) =>
-            getTokenBalance(env, userAddress, vault.multiReward!),
-          ),
-      );
-
-      const vaultBalances = vaultBalancesSettled.flatMap((s) =>
-        s.status === "fulfilled" ? s.value : [],
+      const vaultReads = await readTokenBalances(
+        env,
+        userAddress,
+        Object.values(env.config.vaults).flatMap((vault) =>
+          vault.multiReward ? [vault.multiReward] : [],
+        ),
       );
 
       const envBalances = environmentsTokensBalances[index] || [];
-      environmentsTokensBalances[index] = [...envBalances, ...vaultBalances];
+      environmentsTokensBalances[index] = [
+        ...envBalances,
+        ...vaultReads.balances,
+      ];
+
+      const tokenReads = environmentsTokenReads[index];
+      if (tokenReads) {
+        tokenReads.failures.push(...vaultReads.failures);
+        tokenReads.total += vaultReads.total;
+      }
     }),
   );
 
+  // One report per chain for every token read that failed.
+  environments.forEach((env, index) => {
+    const reads = environmentsTokenReads[index];
+    const [firstFailure] = reads?.failures ?? [];
+    if (!reads || !firstFailure) return;
+    env.onError?.(firstFailure.error, {
+      source: "user-balances-token-read",
+      chainId: env.chainId,
+      ...(reads.failures.length === 1 && { token: firstFailure.token }),
+      operation: "token-balance-read",
+      failedCount: reads.failures.length,
+      totalCount: reads.total,
+      items: reads.failures.map((f) => f.token),
+    });
+  });
+
   const result = environments.flatMap((env, index) => {
     const balances = environmentsTokensBalances[index] || [];
 

package/actions/core/markets/common.ts

@@ -17,7 +17,10 @@ import {
   findTokenByAddress,
 } from "../../../environments/utils/index.js";
 import type { Market } from "../../../types/market.js";
-import { getGovernanceTokenPriceFor } from "../../governance/getWellPrice.js";
+import {
+  getGovernanceTokenPriceFor,
+  getGovernanceTokenPriceOrZero,
+} from "../../governance/getWellPrice.js";
 
 export const getMarketsData = async (environment: Environment) => {
   // Moonriver (chainId 1285) should always use on-chain data
@@ -530,13 +533,7 @@ async function fetchMarketsFromLunar(
 
     const [nativeTokenPriceRaw, governanceTokenPriceRaw] = await Promise.all([
       homeEnvironment.contracts.views?.read.getNativeTokenPrice(),
-      getGovernanceTokenPriceFor(environment).catch((err) => {
-        environment.onError?.(err, {
-          source: "governance-token-price",
-          chainId: environment.chainId,
-        });
-        return 0n;
-      }),
+      getGovernanceTokenPriceOrZero(environment),
     ]);
 
     if (nativeTokenPriceRaw === undefined) {
@@ -876,54 +873,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/getStakingInfo.ts

@@ -10,7 +10,7 @@ import type { NetworkParameterType } from "../../common/types.js";
 import type { Chain, Environment } from "../../environments/index.js";
 import type { StakingInfo } from "../../types/staking.js";
 import { getMerklStakingApr } from "./common.js";
-import { getGovernanceTokenPriceFor } from "./getWellPrice.js";
+import { getGovernanceTokenPriceOrZero } from "./getWellPrice.js";
 
 export type GetStakingInfoParameters<
   environments,
@@ -150,7 +150,7 @@ export async function getStakingInfo<
                 blockNumber: BigInt(34149943),
               })
             : Promise.resolve(undefined),
-          getGovernanceTokenPriceFor(environment, baseEnvironment),
+          getGovernanceTokenPriceOrZero(environment, baseEnvironment),
         ]);
 
       const viewsStaking =
@@ -181,13 +181,6 @@ export async function getStakingInfo<
 
       const price = priceResult.status === "fulfilled" ? priceResult.value : 0n;
 
-      if (priceResult.status === "rejected") {
-        environment.onError?.(priceResult.reason, {
-          source: "governance-token-price",
-          chainId: environment.chainId,
-        });
-      }
-
       return { stakingInfo, historicalStaking, price };
     }),
   );