@moonwell-fi/moonwell-sdk 0.23.0 → 0.24.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/retry.ts

@@ -16,8 +16,8 @@
  *    where the existing `environment.onError(...)` wiring picks it up
  */
 import axios, {
-  type AxiosError,
   type AxiosInstance,
+  type GenericAbortSignal,
   type InternalAxiosRequestConfig,
 } from "axios";
 
@@ -25,14 +25,30 @@ export interface RetryOptions {
   maxAttempts?: number;
   initialDelay?: number;
   maxDelay?: number;
+  signal?: GenericAbortSignal | undefined;
 }
 
 const DEFAULT_MAX_ATTEMPTS = 3;
 const DEFAULT_INITIAL_DELAY_MS = 250;
 const DEFAULT_MAX_DELAY_MS = 5_000;
 
-async function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+async function sleep(ms: number, signal?: GenericAbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new axios.CanceledError());
+      return;
+    }
+    const onAbort = (): void => {
+      clearTimeout(timer);
+      signal?.removeEventListener?.("abort", onAbort);
+      reject(new axios.CanceledError());
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener?.("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener?.("abort", onAbort, { once: true });
+  });
 }
 
 function backoffDelay(
@@ -51,6 +67,7 @@ function backoffDelay(
  * - Non-axios errors (parse errors, code bugs) → do NOT retry
  */
 export function isRetriableError(error: unknown): boolean {
+  if (axios.isCancel(error)) return false;
   if (!axios.isAxiosError(error)) return false;
   if (!error.response) return true;
   return error.response.status >= 500;
@@ -59,33 +76,49 @@ export function isRetriableError(error: unknown): boolean {
 /**
  * Attach a retry-on-failure interceptor to an axios instance. Every request
  * made through this instance is retried up to `maxAttempts` times when the
- * failure is retriable. Per-config state is tracked on a WeakMap so we don't
- * pollute the public axios config shape.
+ * failure is retriable. Axios merges into a new config on every request, so
+ * the attempt counter must travel with that config rather than its identity.
  */
 export function attachRetryInterceptor(
   instance: AxiosInstance,
-  options: RetryOptions = {},
+  options: Omit<RetryOptions, "signal"> = {},
 ): void {
   const {
     maxAttempts = DEFAULT_MAX_ATTEMPTS,
     initialDelay = DEFAULT_INITIAL_DELAY_MS,
     maxDelay = DEFAULT_MAX_DELAY_MS,
   } = options;
-  const attemptsByConfig = new WeakMap<InternalAxiosRequestConfig, number>();
+  interface RetryConfig extends InternalAxiosRequestConfig {
+    moonwellRetryAttempts?: number | undefined;
+  }
 
   instance.interceptors.response.use(
-    (response) => response,
-    async (error: AxiosError) => {
-      const config = error.config;
+    (response) => {
+      const config: RetryConfig = response.config;
+      config.moonwellRetryAttempts = undefined;
+      return response;
+    },
+    async (error: unknown) => {
+      if (!axios.isAxiosError(error)) throw error;
+      const config: RetryConfig | undefined = error.config;
       if (!config) throw error;
-      if (!isRetriableError(error)) throw error;
-
-      const previousAttempts = attemptsByConfig.get(config) ?? 0;
-      if (previousAttempts >= maxAttempts - 1) throw error;
+      const previousAttempts = config.moonwellRetryAttempts ?? 0;
+      if (!isRetriableError(error) || previousAttempts >= maxAttempts - 1) {
+        config.moonwellRetryAttempts = undefined;
+        throw error;
+      }
 
-      attemptsByConfig.set(config, previousAttempts + 1);
-      await sleep(backoffDelay(previousAttempts, initialDelay, maxDelay));
-      return instance.request(config);
+      config.moonwellRetryAttempts = previousAttempts + 1;
+      try {
+        await sleep(
+          backoffDelay(previousAttempts, initialDelay, maxDelay),
+          config.signal,
+        );
+        return await instance.request(config);
+      } catch (retryError) {
+        config.moonwellRetryAttempts = undefined;
+        throw retryError;
+      }
     },
   );
 }
@@ -103,10 +136,12 @@ export async function retry<T>(
     maxAttempts = DEFAULT_MAX_ATTEMPTS,
     initialDelay = DEFAULT_INITIAL_DELAY_MS,
     maxDelay = DEFAULT_MAX_DELAY_MS,
+    signal,
   } = options;
   let attempt = 0;
   let lastError: unknown;
   while (attempt < maxAttempts) {
+    if (signal?.aborted) throw new axios.CanceledError();
     try {
       return await fn();
     } catch (error) {
@@ -114,7 +149,7 @@ export async function retry<T>(
       attempt++;
       if (!isRetriableError(error)) throw error;
       if (attempt >= maxAttempts) break;
-      await sleep(backoffDelay(attempt - 1, initialDelay, maxDelay));
+      await sleep(backoffDelay(attempt - 1, initialDelay, maxDelay), signal);
     }
   }
   throw lastError;

package/client/createActions.ts

@@ -143,6 +143,11 @@ import {
   type GetMorphoMarketsReturnType,
   getMorphoMarkets,
 } from "../actions/morpho/markets/getMorphoMarkets.js";
+import {
+  type GetMorphoMarketsSharedLiquidityParameters,
+  type GetMorphoMarketsSharedLiquidityReturnType,
+  getMorphoMarketsSharedLiquidity,
+} from "../actions/morpho/markets/getMorphoMarketsSharedLiquidity.js";
 import {
   type GetMorphoMarketUserPositionParameters,
   type GetMorphoMarketUserPositionReturnType,
@@ -288,6 +293,12 @@ export type Actions<
     args?: GetMorphoMarketsParameters<environments, chain>,
   ) => GetMorphoMarketsReturnType;
 
+  getMorphoMarketsSharedLiquidity: <
+    chain extends Chain | undefined = Chain | undefined,
+  >(
+    args: GetMorphoMarketsSharedLiquidityParameters<environments, chain>,
+  ) => GetMorphoMarketsSharedLiquidityReturnType;
+
   getMorphoMarketUserPosition: <
     chain extends Chain | undefined = Chain | undefined,
   >(
@@ -399,6 +410,8 @@ export const actions = <
     getUserVotingPowers: (args) => getUserVotingPowers(client, args),
     getMorphoMarket: (args) => getMorphoMarket(client, args),
     getMorphoMarkets: (args) => getMorphoMarkets(client, args),
+    getMorphoMarketsSharedLiquidity: (args) =>
+      getMorphoMarketsSharedLiquidity(client, args),
     getMorphoMarketUserPosition: (args) =>
       getMorphoMarketUserPosition(client, args),
     getMorphoMarketUserPositions: (args) =>

package/common/error.ts

@@ -28,3 +28,48 @@ export class HttpRequestError extends BaseError {
     Object.setPrototypeOf(this, HttpRequestError.prototype);
   }
 }
+
+/** One failed per-chain read inside a multi-chain action. */
+export type ChainReadFailure = {
+  chainId: number;
+  /** The original error from the RPC / contract read, unchanged. */
+  reason: unknown;
+};
+
+/**
+ * Thrown by multi-chain read actions (`getUserPositions`,
+ * `getMorphoMarketUserPositions`, `getMorphoVaultUserPositions`) when the read
+ * fails on one or more of the requested chains.
+ *
+ * `failures` lists every failed chain with its original error and `data`
+ * carries the results from the chains that succeeded, so a consumer can keep
+ * rendering the healthy chains while flagging the broken one. `errors` (from
+ * `AggregateError`) holds the same original errors in `failures` order.
+ *
+ * These failures are surfaced only through this rejection, not additionally
+ * through `onError`: a rejection is the consumer's to report, and reporting it
+ * on both paths doubled telemetry under query-library retries.
+ */
+export class ChainReadError<T = unknown> extends AggregateError {
+  override readonly name = "ChainReadError";
+  readonly source: string;
+  readonly failures: ChainReadFailure[];
+  readonly data: T[];
+
+  constructor(params: {
+    source: string;
+    failures: ChainReadFailure[];
+    data: T[];
+  }) {
+    const chainIds = params.failures
+      .map((failure) => failure.chainId)
+      .join(", ");
+    super(
+      params.failures.map((failure) => failure.reason),
+      `[moonwell-sdk] ${params.source}: read failed on chainIds ${chainIds}`,
+    );
+    this.source = params.source;
+    this.failures = params.failures;
+    this.data = params.data;
+  }
+}

package/common/index.ts

@@ -5,8 +5,8 @@ import type { Environment } from "../environments/index.js";
 
 dayjs.extend(utc);
 export { Amount } from "./amount.js";
-export { BaseError, HttpRequestError } from "./error.js";
-export type { HttpRequestErrorType } from "./error.js";
+export { BaseError, ChainReadError, HttpRequestError } from "./error.js";
+export type { ChainReadFailure, HttpRequestErrorType } from "./error.js";
 export { getBlockNumberAtTimestamp } from "./getBlockNumberAtTimestamp.js";
 export type { MultichainReturnType } from "./types.js";
 

package/common/readAcrossEnvironments.ts

@@ -0,0 +1,45 @@
+import type { Environment } from "../environments/index.js";
+import { ChainReadError } from "./error.js";
+
+/**
+ * Run a per-environment read on every environment and flatten the results.
+ *
+ * Unlike a bare `Promise.allSettled` that keeps only fulfilled entries, a
+ * rejected environment is never dropped silently: if any environment fails,
+ * the call rejects with a `ChainReadError` that lists every failed chain with
+ * its original error and carries the results of the chains that succeeded.
+ * For user positions a silently missing chain is indistinguishable from "no
+ * position", which drives wrong balances and borrow limits downstream; the
+ * partial `data` on the error lets a consumer keep rendering the healthy
+ * chains while flagging the broken one.
+ *
+ * Failures are surfaced only through the rejection, not additionally through
+ * `environment.onError`, so a consumer that retries the call is not told about
+ * the same outage once per attempt per chain.
+ */
+export async function readAcrossEnvironments<T>(params: {
+  environments: Environment[];
+  source: string;
+  read: (environment: Environment) => Promise<T[]>;
+}): Promise<T[]> {
+  const { environments, source, read } = params;
+
+  const settled = await Promise.allSettled(
+    environments.map((environment) => read(environment)),
+  );
+
+  const data = settled.flatMap((result) =>
+    result.status === "fulfilled" ? result.value : [],
+  );
+  const failures = settled.flatMap((result, index) =>
+    result.status === "rejected"
+      ? [{ chainId: environments[index].chainId, reason: result.reason }]
+      : [],
+  );
+
+  if (failures.length > 0) {
+    throw new ChainReadError({ source, failures, data });
+  }
+
+  return data;
+}

package/errors/version.ts

@@ -1 +1 @@
-export const version = '0.23.0'
+export const version = '0.24.0'

package/index.ts

@@ -5,6 +5,8 @@ export {
 
 export { MerklApiError } from "./actions/morpho/user-rewards/common.js";
 export { MorphoUserRewardsAggregateError } from "./actions/morpho/user-rewards/getMorphoUserRewards.js";
+export { ChainReadError } from "./common/error.js";
+export type { ChainReadFailure } from "./common/error.js";
 
 export type {
   MarketConfig,
@@ -18,6 +20,7 @@ export type { Discussion } from "./types/discussion.js";
 export type { Market, MarketReward, MarketSnapshot } from "./types/market.js";
 export type {
   MorphoMarket,
+  MorphoMarketSharedLiquidity,
   MorphoMarketParamsType,
   PublicAllocatorSharedLiquidityType,
 } from "./types/morphoMarket.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@moonwell-fi/moonwell-sdk",
   "description": "TypeScript Interface for Moonwell",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/types/morphoMarket.ts

@@ -41,6 +41,16 @@ export type MorphoMarket = {
   totalBorrowApr: number;
   rewards: Required<MorphoReward>[];
   publicAllocatorSharedLiquidity: PublicAllocatorSharedLiquidityType[];
+  /** Whether allocator liquidity was fetched. An empty list is not proof of zero
+   * reallocatable liquidity when this is "not-requested" or "unavailable". */
+  sharedLiquidityStatus?: "available" | "unavailable" | "not-requested";
+};
+
+export type MorphoMarketSharedLiquidity = {
+  chainId: number;
+  marketId: string;
+  reallocatableLiquidityAssets: Amount;
+  publicAllocatorSharedLiquidity: PublicAllocatorSharedLiquidityType[];
 };
 
 export type MorphoMarketParamsType = {