@moonwell-fi/moonwell-sdk 0.23.0 → 0.25.0

package/actions/morpho/markets/getMorphoMarketsSharedLiquidity.ts

@@ -0,0 +1,93 @@
+import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
+import { getEnvironmentFromArgs } from "../../../common/index.js";
+import type { NetworkParameterType } from "../../../common/types.js";
+import type { Chain } from "../../../environments/index.js";
+import type {
+  MorphoMarket,
+  MorphoMarketSharedLiquidity,
+} from "../../../types/morphoMarket.js";
+import {
+  computeSharedLiquidityFromLunar,
+  fetchSharedLiquidityFromLunar,
+} from "./common.js";
+
+export type GetMorphoMarketsSharedLiquidityParameters<
+  environments,
+  network extends Chain | undefined,
+> = NetworkParameterType<environments, network> & {
+  /** Pass the full chain's base market result to retain allocation parameters. */
+  markets: readonly MorphoMarket[];
+  signal?: AbortSignal;
+  /** Overall deadline, including retries and backoff. Defaults to 15 seconds. */
+  timeoutMs?: number;
+};
+
+export type GetMorphoMarketsSharedLiquidityReturnType = Promise<
+  MorphoMarketSharedLiquidity[]
+>;
+
+/** Fetch allocator liquidity independently, without refetching base market data.
+ * Rejects on failure so callers can retain the previous successful snapshot and
+ * distinguish unavailable liquidity from a successful empty allocation list. */
+export async function getMorphoMarketsSharedLiquidity<
+  environments,
+  Network extends Chain | undefined,
+>(
+  client: MoonwellClient,
+  args: GetMorphoMarketsSharedLiquidityParameters<environments, Network>,
+): GetMorphoMarketsSharedLiquidityReturnType {
+  const environment = getEnvironmentFromArgs(client, args);
+  if (!environment?.lunarIndexerUrl) {
+    throw new Error(
+      "Independent shared liquidity requires a configured Lunar Indexer environment",
+    );
+  }
+  if (args.markets.some((market) => market.chainId !== environment.chainId)) {
+    throw new Error(
+      "Shared-liquidity markets must belong to the requested chain",
+    );
+  }
+  if (args.markets.length === 0) return [];
+
+  const marketParamsMap = new Map(
+    args.markets.map((market) => [
+      market.marketId.toLowerCase(),
+      {
+        oracle: market.marketParams.oracle,
+        irm: market.marketParams.irm,
+        lltv: market.marketParams.lltv.toString(),
+        // Display token metadata can use the native-token zero address for ETH.
+        // Allocator transactions need the actual ERC20 addresses from Morpho.
+        loanToken: {
+          address: market.marketParams.loanToken,
+          decimals: market.loanToken.decimals,
+        },
+        collateralToken: {
+          address: market.marketParams.collateralToken,
+          decimals: market.collateralToken.decimals,
+        },
+      },
+    ]),
+  );
+  try {
+    const data = await fetchSharedLiquidityFromLunar(
+      environment.lunarIndexerUrl,
+      environment.chainId,
+      args,
+    );
+    return computeSharedLiquidityFromLunar(
+      data,
+      args.markets.map((market) => market.marketId),
+      marketParamsMap,
+      environment.chainId,
+    );
+  } catch (error) {
+    if (!args.signal?.aborted) {
+      environment.onError?.(error, {
+        source: "morpho-shared-liquidity",
+        chainId: environment.chainId,
+      });
+    }
+    throw error;
+  }
+}

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

@@ -59,50 +59,56 @@ export async function getMorphoMarketUserPositionsData(params: {
   account: Address;
   markets?: string[] | undefined;
 }): Promise<MorphoMarketUserPosition[]> {
+  // A chain without a Morpho deployment has no positions to read. Both the
+  // plural action and the singular getMorphoMarketUserPosition come through
+  // here, so the guard lives at the source rather than in each caller.
+  const morphoViews = params.environment.contracts.morphoViews;
+  if (!morphoViews) {
+    return [];
+  }
+
   const markets = Object.values(params.environment.config.morphoMarkets).filter(
     (market) => (params.markets ? params.markets.includes(market.id) : true),
   );
 
-  try {
-    const userMarketPositions =
-      await params.environment.contracts.morphoViews!.read.getMorphoBlueUserBalances(
-        [markets.map((market) => market.id), params.account],
-      );
-
-    return markets.map((market, index) => {
-      const position = userMarketPositions[index];
-
-      const loanToken = params.environment.config.tokens[market.loanToken];
-
-      const collateralToken =
-        params.environment.config.tokens[market.collateralToken];
-
-      const supplied = new Amount(
-        position.collateralAssets,
-        collateralToken.decimals,
-      );
-
-      const borrowed = new Amount(position.loanAssets, loanToken.decimals);
-
-      const borrowedShares = new Amount(
-        position.loanShares,
-        loanToken.decimals + 6,
-      );
-
-      const result: MorphoMarketUserPosition = {
-        chainId: params.environment.chainId,
-        account: params.account,
-        marketId: market.id,
-        loanToken,
-        collateralToken,
-        supplied,
-        borrowed,
-        borrowedShares,
-      };
-
-      return result;
-    });
-  } catch (error) {
-    return [];
-  }
+  // A failed read must propagate: swallowing it here made a Base RPC outage
+  // look like "user has no isolated positions" (MOO-884).
+  const userMarketPositions = await morphoViews.read.getMorphoBlueUserBalances([
+    markets.map((market) => market.id),
+    params.account,
+  ]);
+
+  return markets.map((market, index) => {
+    const position = userMarketPositions[index];
+
+    const loanToken = params.environment.config.tokens[market.loanToken];
+
+    const collateralToken =
+      params.environment.config.tokens[market.collateralToken];
+
+    const supplied = new Amount(
+      position.collateralAssets,
+      collateralToken.decimals,
+    );
+
+    const borrowed = new Amount(position.loanAssets, loanToken.decimals);
+
+    const borrowedShares = new Amount(
+      position.loanShares,
+      loanToken.decimals + 6,
+    );
+
+    const result: MorphoMarketUserPosition = {
+      chainId: params.environment.chainId,
+      account: params.account,
+      marketId: market.id,
+      loanToken,
+      collateralToken,
+      supplied,
+      borrowed,
+      borrowedShares,
+    };
+
+    return result;
+  });
 }

package/actions/morpho/user-positions/getMorphoMarketUserPositions.ts

@@ -1,6 +1,7 @@
 import type { Address } 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 { Chain } from "../../../environments/index.js";
 import type { MorphoMarketUserPosition } from "../../../types/morphoUserPosition.js";
@@ -17,6 +18,11 @@ export type GetMorphoMarketUserPositionsReturnType = Promise<
   MorphoMarketUserPosition[]
 >;
 
+/**
+ * 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 getMorphoMarketUserPositions<
   environments,
   Network extends Chain | undefined,
@@ -26,20 +32,13 @@ export async function getMorphoMarketUserPositions<
 ): GetMorphoMarketUserPositionsReturnType {
   const environments = getEnvironmentsFromArgs(client, args);
 
-  const settled = await Promise.allSettled(
-    environments
-      .filter((environment) => environment.contracts.morphoViews !== undefined)
-      .map((environment) => {
-        return getMorphoMarketUserPositionsData({
-          environment,
-          account: args.userAddress,
-        });
+  return readAcrossEnvironments({
+    environments,
+    source: "getMorphoMarketUserPositions",
+    read: (environment) =>
+      getMorphoMarketUserPositionsData({
+        environment,
+        account: args.userAddress,
       }),
-  );
-
-  const result = settled.flatMap((s) =>
-    s.status === "fulfilled" ? s.value : [],
-  );
-
-  return result;
+  });
 }

package/actions/morpho/user-positions/getMorphoVaultUserPositions.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 { MorphoVaultUserPosition } from "../../../types/morphoUserPosition.js";
 import { getMorphoVaultUserPositionsData } from "./common.js";
@@ -16,6 +17,11 @@ export type GetMorphoVaultUserPositionsReturnType = Promise<
   MorphoVaultUserPosition[]
 >;
 
+/**
+ * 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 getMorphoVaultUserPositions<
   environments,
   Network extends Chain | undefined,
@@ -25,20 +31,13 @@ export async function getMorphoVaultUserPositions<
 ): GetMorphoVaultUserPositionsReturnType {
   const environments = getEnvironmentsFromArgs(client, args);
 
-  const settled = await Promise.allSettled(
-    environments
-      .filter((environment) => environment.contracts.morphoViews !== undefined)
-      .map((environment) => {
-        return getMorphoVaultUserPositionsData({
-          environment,
-          account: args.userAddress,
-        });
+  return readAcrossEnvironments({
+    environments,
+    source: "getMorphoVaultUserPositions",
+    read: (environment) =>
+      getMorphoVaultUserPositionsData({
+        environment,
+        account: args.userAddress,
       }),
-  );
-
-  const result = settled.flatMap((s) =>
-    s.status === "fulfilled" ? s.value : [],
-  );
-
-  return result;
+  });
 }

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);

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;