@moonwell-fi/moonwell-sdk 0.24.0 → 0.25.0

package/actions/governance/proposals/common.ts

@@ -447,6 +447,29 @@ export const getProposalsOnChainData = async (
       ? governanceEnvironment
       : getEnvironmentByChainId(chainId);
 
+  // viem batches these reads into one multicall, so a single failed request
+  // rejects every read in it. Collect failures per chain and report them once
+  // after the batch instead of once per read (Sentry MOONWELL-FRONTEND-1AX).
+  const readFailures = new Map<
+    number,
+    { error: unknown; failed: number; total: number; proposalIds: Set<string> }
+  >();
+  const recordRead = (chainId: number, proposalId: number, error?: unknown) => {
+    const entry = readFailures.get(chainId) ?? {
+      error: undefined,
+      failed: 0,
+      total: 0,
+      proposalIds: new Set<string>(),
+    };
+    entry.total++;
+    if (error !== undefined) {
+      entry.error ??= error;
+      entry.failed++;
+      entry.proposalIds.add(String(proposalId));
+    }
+    readFailures.set(chainId, entry);
+  };
+
   const onChainDataList = await Promise.all(
     apiProposals.map(async (p) => {
       const isLocal = p.chainId === governanceEnvironment.chainId;
@@ -501,29 +524,17 @@ export const getProposalsOnChainData = async (
         ]);
         if (stateResult.status === "fulfilled") {
           state = Number(stateResult.value);
+          recordRead(p.chainId, p.proposalId);
         } else {
           stateReadFailed = true;
-          console.warn(
-            `Failed to fetch state for proposal ${p.proposalId} (chainId=${p.chainId}):`,
-            stateResult.reason,
-          );
-          governanceEnvironment.onError?.(stateResult.reason, {
-            source: "governance-proposals",
-            chainId: p.chainId,
-          });
+          recordRead(p.chainId, p.proposalId, stateResult.reason);
         }
         if (proposalsResult.status === "fulfilled") {
           proposalData = proposalsResult.value ?? null;
+          recordRead(p.chainId, p.proposalId);
         } else {
           proposalsReadFailed = true;
-          console.warn(
-            `Failed to fetch proposalData for proposal ${p.proposalId} (chainId=${p.chainId}):`,
-            proposalsResult.reason,
-          );
-          governanceEnvironment.onError?.(proposalsResult.reason, {
-            source: "governance-proposals",
-            chainId: p.chainId,
-          });
+          recordRead(p.chainId, p.proposalId, proposalsResult.reason);
         }
       }
 
@@ -609,6 +620,23 @@ export const getProposalsOnChainData = async (
     }),
   );
 
+  for (const [chainId, entry] of readFailures) {
+    if (entry.failed === 0) continue;
+    const proposalIds = [...entry.proposalIds];
+    console.warn(
+      `Failed ${entry.failed}/${entry.total} governor reads (chainId=${chainId}, proposals ${proposalIds.join(", ")}):`,
+      entry.error,
+    );
+    governanceEnvironment.onError?.(entry.error, {
+      source: "governance-proposals",
+      chainId,
+      operation: "proposal-onchain-read",
+      failedCount: entry.failed,
+      totalCount: entry.total,
+      items: proposalIds,
+    });
+  }
+
   return onChainDataList;
 };
 

package/actions/governance/proposals/getProposals.ts

@@ -20,7 +20,16 @@ import {
 export type GetProposalsParameters<
   environments,
   network extends Chain | undefined,
-> = OptionalNetworkParameterType<environments, network>;
+> = OptionalNetworkParameterType<environments, network> & {
+  /**
+   * Governance chains to fetch proposals from: 1 (Ethereum, active),
+   * 1284 (Moonbeam archive) and/or 1285 (Moonriver archive). Defaults to all
+   * of them. The archives hold almost all of the payload (~6.6MB of ~7MB), so
+   * views that only show recent proposals can pass `[1]` and load the archives
+   * separately when needed. Unsupported chainIds are ignored.
+   */
+  proposalChainIds?: readonly number[];
+};
 
 export type GetProposalsReturnType = Promise<Proposal[]>;
 
@@ -42,7 +51,10 @@ export async function getProposals<
     return [];
   }
 
-  const proposals = await fetchGovernorProposals(governanceEnvironment);
+  const proposals = await fetchGovernorProposals(
+    governanceEnvironment,
+    args?.proposalChainIds,
+  );
   // Newer multigov-ethereum proposals (chainId=1) and historical Moonbeam
   // proposals (chainId=1284) restart their proposalId counters from 1, so IDs
   // may collide across chains. Sort by proposalId desc with chainId as a
@@ -58,7 +70,8 @@ export async function getProposals<
 }
 
 /**
- * Fetch every proposal the Governor API serves, across all governance chains.
+ * Fetch every proposal the Governor API serves, across all governance chains
+ * (or only `proposalChainIds`, when given).
  *
  * One indexer DO serves them all:
  *   - chainId=1    (Ethereum)  — the active multigov contract
@@ -76,16 +89,20 @@ export async function getProposals<
  */
 async function fetchGovernorProposals(
   governanceEnvironment: Environment,
+  proposalChainIds?: readonly number[],
 ): Promise<Proposal[]> {
+  const chainIds = SUPPORTED_GOVERNOR_CHAIN_IDS.filter(
+    (chainId) => !proposalChainIds || proposalChainIds.includes(chainId),
+  );
   const results = await Promise.allSettled(
-    SUPPORTED_GOVERNOR_CHAIN_IDS.map((chainId) =>
+    chainIds.map((chainId) =>
       fetchAllProposals(governanceEnvironment, { chainId }),
     ),
   );
 
   const apiProposals: ApiProposal[] = [];
   results.forEach((result, index) => {
-    const chainId = SUPPORTED_GOVERNOR_CHAIN_IDS[index];
+    const chainId = chainIds[index];
     if (result.status === "fulfilled") {
       apiProposals.push(...result.value);
     } else if (chainId !== undefined) {

package/actions/morpho/markets/common.ts

@@ -76,6 +76,21 @@ function validateLoanDecimals(value: unknown): number {
   return value;
 }
 
+/** Summarizes an unexpected top-level body so the error says what arrived. */
+function describeSharedLiquidityBody(data: unknown): string {
+  if (data === null || data === undefined) return `received ${data}`;
+  if (typeof data === "string") {
+    return `received string of ${data.length} chars: ${JSON.stringify(data.slice(0, 100))}`;
+  }
+  if (typeof data !== "object") return `received ${typeof data}`;
+  if (Array.isArray(data)) return `received array of ${data.length}`;
+  const body = data as Record<string, unknown>;
+  const kind = (value: unknown): string =>
+    Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
+  const keys = Object.keys(body).slice(0, 10).join(", ");
+  return `received object with keys [${keys}]; vaults: ${kind(body.vaults)}, markets: ${kind(body.markets)}`;
+}
+
 function validatedMarketLiquidity(
   data: LunarSharedLiquidityResponse,
 ): Map<string, number> {
@@ -86,7 +101,9 @@ function validatedMarketLiquidity(
     typeof data.markets !== "object" ||
     Array.isArray(data.markets)
   ) {
-    throw new TypeError("Invalid shared-liquidity response");
+    throw new TypeError(
+      `Invalid shared-liquidity response (${describeSharedLiquidityBody(data)})`,
+    );
   }
   for (const vault of data.vaults) {
     parseLiquidityQuantity(vault.fee, "vault.fee", true);
@@ -158,13 +175,31 @@ export async function fetchSharedLiquidityFromLunar(
   const abort = (): void => controller.abort();
   if (options.signal?.aborted) abort();
   options.signal?.addEventListener("abort", abort, { once: true });
-  const timer = setTimeout(abort, timeoutMs);
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    abort();
+  }, timeoutMs);
   try {
     const response = await getWithRetry<LunarSharedLiquidityResponse>(
       `${lunarIndexerUrl}/api/v1/isolated/shared-liquidity/${chainId}`,
       { timeout: timeoutMs, signal: controller.signal },
     );
     return response.data;
+  } catch (error) {
+    // Our own deadline aborts the request, which axios reports as a bare
+    // `CanceledError: canceled` (Sentry MOONWELL-FRONTEND-1C7 & co). That is a
+    // timeout, not a cancellation: surface it as one. A caller's own abort
+    // still propagates as the CanceledError it is.
+    if (timedOut && !options.signal?.aborted) {
+      const timeoutError = new Error(
+        `Shared-liquidity request timed out after ${timeoutMs}ms (chainId=${chainId})`,
+        { cause: error },
+      );
+      timeoutError.name = "TimeoutError";
+      throw timeoutError;
+    }
+    throw error;
   } finally {
     clearTimeout(timer);
     options.signal?.removeEventListener("abort", abort);

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;

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/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.24.0'
+export const version = '0.25.0'

package/package.json

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