@moonwell-fi/moonwell-sdk 0.12.0 → 0.12.2

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

@@ -1,5 +1,3 @@
-import lodash from "lodash";
-const { uniq } = lodash;
 import { type Address, getContract, parseAbi, zeroAddress } from "viem";
 import { Amount } from "../../../common/amount.js";
 import { MOONWELL_FETCH_JSON_HEADERS } from "../../../common/fetch-headers.js";
@@ -14,258 +12,54 @@ import {
 } from "../../../environments/utils/index.js";
 import type { MorphoUserReward } from "../../../types/morphoUserReward.js";
 import type { MorphoUserStakingReward } from "../../../types/morphoUserStakingReward.js";
-import { getGraphQL } from "../utils/graphql.js";
 
 export async function getUserMorphoRewardsData(params: {
   environment: Environment;
   account: `0x${string}`;
 }): Promise<MorphoUserReward[]> {
+  // The Morpho URD distributions endpoint (rewards.morpho.org) was
+  // deprecated and now 301-redirects to a SPA, so JSON parsing fails.
+  // Surface only Merkl rewards.
+  const merklRewards = await getMerklRewardsData(
+    params.environment,
+    params.account,
+  );
+
   const isFullDeployment =
     params.environment.custom.morpho?.minimalDeployment === false;
 
-  const emptyMorphoRewards: MorphoRewardsResponse[] = [];
-  const [merklRewards, morphoRewards] = await Promise.all([
-    getMerklRewardsData(params.environment, params.account),
-    isFullDeployment
-      ? getMorphoRewardsData(params.environment, params.account)
-      : Promise.resolve(emptyMorphoRewards),
-  ]);
-
-  if (isFullDeployment) {
-    // Process Morpho rewards (GraphQL query depends on morphoRewards result)
-    const morphoAssets = await getMorphoAssetsData(
-      params.environment,
-      morphoRewards.map((r) => r.asset.address),
-    );
-
-    const morphoResult: (MorphoUserReward | undefined)[] = morphoRewards.map(
-      (r) => {
-        const asset = morphoAssets.find(
-          (a) => a.address.toLowerCase() === r.asset.address.toLowerCase(),
-        );
-
-        if (!asset) {
-          return undefined;
-        }
-
-        const rewardToken: TokenConfig = {
-          address: asset.address,
-          decimals: asset.decimals,
-          symbol: asset.symbol,
-          name: asset.name,
-        };
-
-        switch (r.type) {
-          case "uniform-reward": {
-            const claimableNow = new Amount(
-              BigInt(r.amount?.claimable_now || 0),
-              rewardToken.decimals,
-            );
-            const claimableNowUsd = claimableNow.value * (asset.priceUsd || 0);
-            const claimableFuture = new Amount(
-              BigInt(r.amount?.claimable_next || 0),
-              rewardToken.decimals,
-            );
-            const claimableFutureUsd =
-              claimableFuture.value * (asset.priceUsd || 0);
-
-            const uniformReward: MorphoUserReward = {
-              type: "uniform-reward",
-              chainId: r.asset.chain_id,
-              account: r.user,
-              rewardToken,
-              claimableNow,
-              claimableNowUsd,
-              claimableFuture,
-              claimableFutureUsd,
-            };
-            return uniformReward;
-          }
-
-          case "market-reward": {
-            const claimableNow = new Amount(
-              BigInt(r.for_supply?.claimable_now || 0),
-              rewardToken.decimals,
-            );
-            const claimableNowUsd = claimableNow.value * (asset.priceUsd || 0);
-
-            const claimableFuture = new Amount(
-              BigInt(r.for_supply?.claimable_next || 0),
-              rewardToken.decimals,
-            );
-            const claimableFutureUsd =
-              claimableFuture.value * (asset.priceUsd || 0);
-
-            const collateralClaimableNow = new Amount(
-              BigInt(r.for_collateral?.claimable_now || 0),
-              rewardToken.decimals,
-            );
-            const collateralClaimableNowUsd =
-              collateralClaimableNow.value * (asset.priceUsd || 0);
-            const collateralClaimableFuture = new Amount(
-              BigInt(r.for_collateral?.claimable_next || 0),
-              rewardToken.decimals,
-            );
-            const collateralClaimableFutureUsd =
-              collateralClaimableFuture.value * (asset.priceUsd || 0);
-
-            const borrowClaimableNow = new Amount(
-              BigInt(r.for_borrow?.claimable_now || 0),
-              rewardToken.decimals,
-            );
-            const borrowClaimableNowUsd =
-              borrowClaimableNow.value * (asset.priceUsd || 0);
-            const borrowClaimableFuture = new Amount(
-              BigInt(r.for_borrow?.claimable_next || 0),
-              rewardToken.decimals,
-            );
-            const borrowClaimableFutureUsd =
-              borrowClaimableFuture.value * (asset.priceUsd || 0);
-
-            //Rewards reallocated to vaults are reported as vault rewards
-            if (r.reallocated_from) {
-              const vaultReward: MorphoUserReward = {
-                type: "vault-reward",
-                chainId: r.program.chain_id,
-                account: r.user,
-                vaultId: r.reallocated_from,
-                rewardToken,
-                claimableNow,
-                claimableNowUsd,
-                claimableFuture,
-                claimableFutureUsd,
-              };
-              return vaultReward;
-            } else {
-              const marketReward: MorphoUserReward = {
-                type: "market-reward",
-                chainId: r.program.chain_id,
-                account: r.user,
-                marketId: r.program.market_id || "",
-                rewardToken,
-                collateralRewards: {
-                  claimableNow: collateralClaimableNow,
-                  claimableNowUsd: collateralClaimableNowUsd,
-                  claimableFuture: collateralClaimableFuture,
-                  claimableFutureUsd: collateralClaimableFutureUsd,
-                },
-                borrowRewards: {
-                  claimableNow: borrowClaimableNow,
-                  claimableNowUsd: borrowClaimableNowUsd,
-                  claimableFuture: borrowClaimableFuture,
-                  claimableFutureUsd: borrowClaimableFutureUsd,
-                },
-              };
-              return marketReward;
-            }
-          }
-          case "vault-reward": {
-            const claimableNow = new Amount(
-              BigInt(r.for_supply?.claimable_now || 0),
-              rewardToken.decimals,
-            );
-            const claimableNowUsd = claimableNow.value * (asset.priceUsd || 0);
-            const claimableFuture = new Amount(
-              BigInt(r.for_supply?.claimable_next || 0),
-              rewardToken.decimals,
-            );
-            const claimableFutureUsd =
-              claimableFuture.value * (asset.priceUsd || 0);
-
-            const vaultReward: MorphoUserReward = {
-              type: "vault-reward",
-              chainId: r.program.chain_id,
-              account: r.user,
-              vaultId: r.program.vault,
-              rewardToken,
-              claimableNow,
-              claimableNowUsd,
-              claimableFuture,
-              claimableFutureUsd,
-            };
-
-            return vaultReward;
-          }
-        }
-      },
-    );
-
-    // Process Merkl rewards
-    const vaultCampaignIds = new Set<string>(
-      (Object.values(publicEnvironments) as Environment[]).flatMap(
-        (environment) =>
-          Object.values(environment.config.vaults ?? {})
-            .map((vault) => vault.campaignId)
-            .filter((id): id is string => id !== undefined),
-      ),
+  // For full deployments (Base), restrict to Moonwell vault campaigns so the
+  // result excludes staking and other Moonwell campaigns; those are returned
+  // by their own actions (e.g. getUserStakingInfo). On other chains, surface
+  // every Merkl reward we get back.
+  const vaultCampaignIds = isFullDeployment
+    ? new Set<string>(
+        (Object.values(publicEnvironments) as Environment[]).flatMap(
+          (environment) =>
+            Object.values(environment.config.vaults ?? {})
+              .map((vault) => vault.campaignId)
+              .filter((id): id is string => id !== undefined),
+        ),
+      )
+    : null;
+
+  const sumBreakdowns = (
+    breakdowns: {
+      campaignId: string;
+      amount: string;
+      claimed: string;
+      pending: string;
+    }[],
+    field: "amount" | "claimed" | "pending",
+  ): bigint =>
+    breakdowns.reduce(
+      (acc, curr) =>
+        vaultCampaignIds === null || vaultCampaignIds.has(curr.campaignId)
+          ? acc + BigInt(curr[field])
+          : acc,
+      0n,
     );
 
-    const getVaultRewardAmount = (
-      breakdowns: any[],
-      field: "amount" | "claimed" | "pending",
-    ) => {
-      return breakdowns.reduce(
-        (acc, curr) =>
-          vaultCampaignIds.has(curr.campaignId)
-            ? acc + BigInt(curr[field])
-            : acc,
-        0n,
-      );
-    };
-
-    const merklResult: MorphoUserReward[] = [];
-
-    for (const chainData of merklRewards) {
-      for (const reward of chainData.rewards) {
-        // Try to find token info in morphoAssets first
-        const morphoAsset = morphoAssets.find(
-          (a) => a.address.toLowerCase() === reward.token.address.toLowerCase(),
-        );
-
-        const rewardToken: TokenConfig = {
-          address: reward.token.address as Address,
-          decimals: morphoAsset?.decimals ?? reward.token.decimals,
-          symbol: morphoAsset?.symbol ?? reward.token.symbol,
-          name: morphoAsset?.name ?? reward.token.symbol,
-        };
-
-        const amount = getVaultRewardAmount(reward.breakdowns, "amount");
-        const claimed = getVaultRewardAmount(reward.breakdowns, "claimed");
-        const pending = getVaultRewardAmount(reward.breakdowns, "pending");
-
-        const claimableNow = new Amount(amount - claimed, rewardToken.decimals);
-        const claimableNowUsd =
-          claimableNow.value *
-          (morphoAsset?.priceUsd ?? reward.token.price ?? 0);
-        const claimableFuture = new Amount(pending, rewardToken.decimals);
-        const claimableFutureUsd =
-          claimableFuture.value *
-          (morphoAsset?.priceUsd ?? reward.token.price ?? 0);
-
-        const merklReward: MorphoUserReward = {
-          type: "merkl-reward",
-          chainId: chainData.chain.id,
-          account: params.account,
-          rewardToken,
-          claimableNow,
-          claimableNowUsd,
-          claimableFuture,
-          claimableFutureUsd,
-        };
-
-        merklResult.push(merklReward);
-      }
-    }
-
-    // Combine both results
-    const allResults = [
-      ...(morphoResult.filter((r) => r !== undefined) as MorphoUserReward[]),
-      ...merklResult,
-    ];
-
-    return allResults;
-  }
-
   const merklResult: MorphoUserReward[] = [];
 
   for (const chainData of merklRewards) {
@@ -277,19 +71,23 @@ export async function getUserMorphoRewardsData(params: {
         name: reward.token.symbol,
       };
 
-      const claimableNow = new Amount(
-        BigInt(reward.amount) - BigInt(reward.claimed),
-        rewardToken.decimals,
-      );
+      const amount = vaultCampaignIds
+        ? sumBreakdowns(reward.breakdowns, "amount")
+        : BigInt(reward.amount);
+      const claimed = vaultCampaignIds
+        ? sumBreakdowns(reward.breakdowns, "claimed")
+        : BigInt(reward.claimed);
+      const pending = vaultCampaignIds
+        ? sumBreakdowns(reward.breakdowns, "pending")
+        : BigInt(reward.pending);
+
+      const claimableNow = new Amount(amount - claimed, rewardToken.decimals);
       const claimableNowUsd = claimableNow.value * (reward.token.price ?? 0);
-      const claimableFuture = new Amount(
-        BigInt(reward.pending),
-        rewardToken.decimals,
-      );
+      const claimableFuture = new Amount(pending, rewardToken.decimals);
       const claimableFutureUsd =
         claimableFuture.value * (reward.token.price ?? 0);
 
-      const merklReward: MorphoUserReward = {
+      merklResult.push({
         type: "merkl-reward",
         chainId: chainData.chain.id,
         account: params.account,
@@ -298,9 +96,7 @@ export async function getUserMorphoRewardsData(params: {
         claimableNowUsd,
         claimableFuture,
         claimableFutureUsd,
-      };
-
-      merklResult.push(merklReward);
+      });
     }
   }
 
@@ -456,94 +252,6 @@ const getRewardsEarnedData = async (
   return rewards.filter(Boolean);
 };
 
-type MorphoRewardsResponse = {
-  user: Address;
-  for_borrow: {
-    claimable_next: string;
-    claimable_now: string;
-    claimed: string;
-    total: string;
-  };
-  for_collateral: {
-    claimable_next: string;
-    claimable_now: string;
-    claimed: string;
-    total: string;
-  };
-  for_supply: {
-    claimable_next: string;
-    claimable_now: string;
-    claimed: string;
-    total: string;
-  };
-  program: {
-    asset: { address: Address };
-    market_id?: string;
-    chain_id: number;
-    vault: Address;
-  };
-  asset: { address: Address; chain_id: number };
-  amount?: { claimable_next: string; claimable_now: string };
-  type: "vault-reward" | "market-reward" | "uniform-reward";
-  reallocated_from: Address;
-};
-
-type MorphoAssetResponse = {
-  address: Address;
-  symbol: string;
-  priceUsd: number | undefined;
-  name: string;
-  decimals: number;
-};
-
-async function getMorphoRewardsData(
-  environment: Environment,
-  account: Address,
-): Promise<MorphoRewardsResponse[]> {
-  const baseUrl =
-    environment.custom.morpho?.rewardsApiUrl || "https://rewards.morpho.org";
-  const rewardsRequest = await fetch(
-    `${baseUrl}/v1/users/${account}/rewards?chain_id=${environment.chainId}&trusted=true&exclude_merkl_programs=true`,
-    {
-      headers: MOONWELL_FETCH_JSON_HEADERS,
-    },
-  );
-  const rewards = await rewardsRequest.json();
-  return (rewards.data || []) as MorphoRewardsResponse[];
-}
-
-async function getMorphoAssetsData(
-  environment: Environment,
-  addresses: Address[],
-): Promise<MorphoAssetResponse[]> {
-  const rewardsRequest = await getGraphQL<{
-    assets: {
-      items: MorphoAssetResponse[];
-    };
-  }>(
-    environment,
-    `
-    query {
-      assets(where: { address_in:[${uniq(addresses)
-        .map((a: string) => `"${a.toLowerCase()}"`)
-        .join(",")}]}) {
-        items {
-          address     
-          symbol
-          priceUsd
-          name
-          decimals
-        }
-      }
-    }
-  `,
-  );
-  if (rewardsRequest) {
-    return rewardsRequest.assets.items;
-  }
-  return [];
-}
-
 type MerklRewardsResponse = {
   chain: {
     id: number;

package/actions/retry.ts

@@ -0,0 +1,121 @@
+/**
+ * Retry helpers for SDK API calls.
+ *
+ * Two consumers:
+ *  1. `attachRetryInterceptor` — axios response interceptor used inside
+ *     LunarIndexerClient. One install per axios instance covers every method.
+ *  2. `retry` — generic wrapper for ad-hoc `axios.post(...)` callsites in
+ *     actions that don't go through a shared axios instance.
+ *
+ * Policy:
+ *  - 3 attempts (initial + 2 retries) by default
+ *  - Exponential backoff: 250ms → 500ms (capped at 5s)
+ *  - Retry only network errors / timeouts / 5xx; never retry 4xx (incl. 404 —
+ *    retrying a deterministic "not found" wastes time and amplifies log noise)
+ *  - After retries exhaust, the last error propagates to the caller's try/catch
+ *    where the existing `environment.onError(...)` wiring picks it up
+ */
+import axios, {
+  type AxiosError,
+  type AxiosInstance,
+  type InternalAxiosRequestConfig,
+} from "axios";
+
+export interface RetryOptions {
+  maxAttempts?: number;
+  initialDelay?: number;
+  maxDelay?: number;
+}
+
+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));
+}
+
+function backoffDelay(
+  attemptIndex: number,
+  initialDelay: number,
+  maxDelay: number,
+): number {
+  return Math.min(initialDelay * 2 ** attemptIndex, maxDelay);
+}
+
+/**
+ * Decide whether an error represents a transient failure worth retrying.
+ * - Axios network errors (no `response`) → retry (server unreachable, timeout)
+ * - 5xx responses → retry (server hiccup)
+ * - 4xx responses (incl. 404) → do NOT retry (deterministic, won't change)
+ * - Non-axios errors (parse errors, code bugs) → do NOT retry
+ */
+export function isRetriableError(error: unknown): boolean {
+  if (!axios.isAxiosError(error)) return false;
+  if (!error.response) return true;
+  return error.response.status >= 500;
+}
+
+/**
+ * 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.
+ */
+export function attachRetryInterceptor(
+  instance: AxiosInstance,
+  options: RetryOptions = {},
+): void {
+  const {
+    maxAttempts = DEFAULT_MAX_ATTEMPTS,
+    initialDelay = DEFAULT_INITIAL_DELAY_MS,
+    maxDelay = DEFAULT_MAX_DELAY_MS,
+  } = options;
+  const attemptsByConfig = new WeakMap<InternalAxiosRequestConfig, number>();
+
+  instance.interceptors.response.use(
+    (response) => response,
+    async (error: AxiosError) => {
+      const config = error.config;
+      if (!config) throw error;
+      if (!isRetriableError(error)) throw error;
+
+      const previousAttempts = attemptsByConfig.get(config) ?? 0;
+      if (previousAttempts >= maxAttempts - 1) throw error;
+
+      attemptsByConfig.set(config, previousAttempts + 1);
+      await sleep(backoffDelay(previousAttempts, initialDelay, maxDelay));
+      return instance.request(config);
+    },
+  );
+}
+
+/**
+ * Generic wrapper for individual axios calls (e.g. raw `axios.post(...)` in
+ * action files that don't share a configured instance). Mirrors the
+ * interceptor's policy: retry transient failures, fail fast on 4xx.
+ */
+export async function retry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {},
+): Promise<T> {
+  const {
+    maxAttempts = DEFAULT_MAX_ATTEMPTS,
+    initialDelay = DEFAULT_INITIAL_DELAY_MS,
+    maxDelay = DEFAULT_MAX_DELAY_MS,
+  } = options;
+  let attempt = 0;
+  let lastError: unknown;
+  while (attempt < maxAttempts) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      attempt++;
+      if (!isRetriableError(error)) throw error;
+      if (attempt >= maxAttempts) break;
+      await sleep(backoffDelay(attempt - 1, initialDelay, maxDelay));
+    }
+  }
+  throw lastError;
+}

package/common/getBlockNumberAtTimestamp.ts

@@ -0,0 +1,59 @@
+import type { PublicClient } from "viem";
+
+/**
+ * Safety cap on interpolation iterations. With near-linear `ts(block)` the search
+ * converges in ~3–5 reads; 8 leaves headroom for chains with variable block times
+ * (e.g. Moonbeam) without unbounded RPC fan-out on pathological inputs.
+ */
+const MAX_ITERATIONS = 8;
+
+/**
+ * Find the block number on a chain whose timestamp is the latest one ≤ the target unix timestamp.
+ *
+ * Uses interpolation search anchored on the latest block and block 1: each iteration
+ * narrows the range by reading one block and projecting the target via the slope of the
+ * remaining range. Converges in ~3–5 RPC calls even on chains with variable block times.
+ *
+ * Assumes block 1 exists on the chain — true for every EVM chain Moonwell supports.
+ *
+ * Returns the latest block if `targetTimestamp` is at or after the head, and block 1
+ * if it is before block 1's timestamp. On a chain with only block 0, returns block 0.
+ */
+export async function getBlockNumberAtTimestamp(
+  publicClient: PublicClient,
+  targetTimestamp: bigint,
+): Promise<bigint> {
+  const latest = await publicClient.getBlock({ blockTag: "latest" });
+  if (targetTimestamp >= latest.timestamp) return latest.number;
+  if (latest.number === 0n) return latest.number;
+
+  const first = await publicClient.getBlock({ blockNumber: 1n });
+  if (targetTimestamp <= first.timestamp) return first.number;
+
+  let lo = first.number;
+  let loTs = first.timestamp;
+  let hi = latest.number;
+  let hiTs = latest.timestamp;
+
+  for (let i = 0; i < MAX_ITERATIONS; i += 1) {
+    if (hi - lo <= 1n) break;
+    const tsRange = hiTs - loTs;
+    if (tsRange <= 0n) break;
+
+    const offset = ((targetTimestamp - loTs) * (hi - lo)) / tsRange;
+    let mid = lo + offset;
+    if (mid <= lo) mid = lo + 1n;
+    if (mid >= hi) mid = hi - 1n;
+
+    const block = await publicClient.getBlock({ blockNumber: mid });
+    if (block.timestamp <= targetTimestamp) {
+      lo = mid;
+      loTs = block.timestamp;
+    } else {
+      hi = mid;
+      hiTs = block.timestamp;
+    }
+  }
+
+  return lo;
+}

package/common/index.ts

@@ -7,6 +7,7 @@ dayjs.extend(utc);
 export { Amount } from "./amount.js";
 export { BaseError, HttpRequestError } from "./error.js";
 export type { HttpRequestErrorType } from "./error.js";
+export { getBlockNumberAtTimestamp } from "./getBlockNumberAtTimestamp.js";
 export type { MultichainReturnType } from "./types.js";
 
 export const SECONDS_PER_DAY = 86400;