@moonwell-fi/moonwell-sdk 0.23.0 → 0.25.0

package/actions/morpho/vaults/lunarIndexerTransform.ts

@@ -248,13 +248,14 @@ export function transformVaultFromIndexer(
   // where totalLiquidity briefly exceeds totalAssets.
   const vaultSupplyValue = Math.max(0, totalAssetsValue - totalLiquidityValue);
 
-  // Transform markets
-  const markets = indexerVault.markets.map((market) =>
+  // Transform markets. The indexer has served vaults without `markets` /
+  // `rewards` (Sentry MOONWELL-FRONTEND-GX); keep the vault with empty lists.
+  const markets = (indexerVault.markets ?? []).map((market) =>
     transformMarket(market, underlyingDecimals, totalAssetsValue, tokenMap),
   );
 
   // Transform rewards
-  const rewards = transformRewards(indexerVault.rewards, tokenMap);
+  const rewards = transformRewards(indexerVault.rewards ?? [], tokenMap);
 
   // Build vault object
   const vault: MorphoVault = {
@@ -313,9 +314,43 @@ export function transformVaultsFromIndexer(
   environment: Environment,
   tokenMap: Map<string, LunarIndexerToken>,
 ): MorphoVault[] {
-  return indexerVaults.map((vault) =>
-    transformVaultFromIndexer(vault, environment, tokenMap),
-  );
+  // A malformed record costs only that record, never the chain's whole list.
+  // Missing `markets` / `rewards` keep the vault (as empty lists); a vault
+  // that cannot be built at all is dropped. Both are reported once per call.
+  const malformed: string[] = [];
+  let firstError: unknown;
+  const vaults = indexerVaults.flatMap((vault) => {
+    if (!Array.isArray(vault.markets) || !Array.isArray(vault.rewards)) {
+      malformed.push(vault.address);
+      firstError ??= new Error(
+        `Lunar Indexer vault ${vault.address} is missing ${!Array.isArray(vault.markets) ? "markets" : "rewards"}`,
+      );
+    }
+    try {
+      return [transformVaultFromIndexer(vault, environment, tokenMap)];
+    } catch (error) {
+      if (!malformed.includes(vault.address)) malformed.push(vault.address);
+      firstError ??= error;
+      return [];
+    }
+  });
+
+  if (malformed.length > 0) {
+    console.warn(
+      `Malformed Lunar Indexer vault record(s) on chain ${environment.chainId}: ${malformed.join(", ")}`,
+      firstError,
+    );
+    environment.onError?.(firstError, {
+      source: "vaults",
+      chainId: environment.chainId,
+      operation: "malformed-vault-records",
+      failedCount: malformed.length,
+      totalCount: indexerVaults.length,
+      items: malformed,
+    });
+  }
+
+  return vaults;
 }
 
 /**

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/environments/types/config.ts

@@ -228,11 +228,21 @@ export type ContractsConfig<contracts, tokens> = {} extends contracts
   ? {}
   : { [name in keyof ContractConfig<tokens>]?: ContractConfig<tokens>[name] };
 
-/** Context passed to `onError` callbacks. `token` is set for per-token read failures. */
+/**
+ * Context passed to `onError` callbacks. `token` is set for per-token read failures.
+ *
+ * Batched reads report once per operation rather than once per item: `error`
+ * is the first failure, `failedCount`/`totalCount` size the batch and `items`
+ * identifies what failed (proposalIds, token/vault addresses, chainIds...).
+ */
 export type OnErrorContext = {
   source: string;
   chainId: number;
   token?: Address;
+  operation?: string;
+  failedCount?: number;
+  totalCount?: number;
+  items?: string[];
 };
 
 export type CustomConfig<custom> = {} extends custom

package/errors/version.ts

@@ -1 +1 @@
-export const version = '0.23.0'
+export const version = '0.25.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.25.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 = {