@moonwell-fi/moonwell-sdk 0.12.1 → 0.13.0

package/actions/governance/proposals/common.ts

@@ -99,6 +99,24 @@ export const isMultichainProposal = (targets?: string[]): boolean => {
   );
 };
 
+/**
+ * Routes a proposal to the multichain governor when:
+ *   - its targets include the Wormhole bridge (legacy detection), OR
+ *   - its proposalId is past the legacy Artemis governor's `proposalCount`,
+ *     which means it could only have been created on the multichain governor
+ *     (proposals migrated to the multichain governor after the cutoff but
+ *     can have local-only targets, e.g. Moonbeam-internal contract calls).
+ *
+ * `legacyArtemisMaxId === 0` indicates the count read failed; in that case we
+ * fall back to the targets-only heuristic.
+ */
+export const isMultichainAware = (
+  proposal: { targets?: string[]; proposalId: number },
+  legacyArtemisMaxId: number,
+): boolean =>
+  isMultichainProposal(proposal.targets) ||
+  (legacyArtemisMaxId > 0 && proposal.proposalId > legacyArtemisMaxId);
+
 export type ApiProposalFormatted = {
   forVotes: Amount;
   againstVotes: Amount;
@@ -181,6 +199,40 @@ export type ProposalOnChainData = {
   quorum: bigint;
 };
 
+// Cached per chain: highest proposalId held by the legacy Artemis governor.
+// Anything with a higher proposalId belongs to the multichain governor, even
+// if its targets don't include the Wormhole bridge. The legacy governor only
+// receives new proposals during chain migrations, so a 5-minute TTL is plenty.
+const LEGACY_ARTEMIS_MAX_ID_TTL_MS = 5 * 60 * 1000;
+const legacyArtemisMaxIdCache = new Map<
+  number,
+  { value: number; fetchedAt: number }
+>();
+
+const getLegacyArtemisMaxId = async (
+  governanceEnvironment: Environment,
+): Promise<number> => {
+  const governor = governanceEnvironment.contracts.governor;
+  if (!governor) return 0;
+
+  const cached = legacyArtemisMaxIdCache.get(governanceEnvironment.chainId);
+  if (cached && Date.now() - cached.fetchedAt < LEGACY_ARTEMIS_MAX_ID_TTL_MS) {
+    return cached.value;
+  }
+
+  try {
+    const value = Number(await governor.read.proposalCount());
+    legacyArtemisMaxIdCache.set(governanceEnvironment.chainId, {
+      value,
+      fetchedAt: Date.now(),
+    });
+    return value;
+  } catch (error) {
+    console.warn("Failed to fetch legacy governor proposalCount:", error);
+    return cached?.value ?? 0;
+  }
+};
+
 /**
  * Fetches on-chain data for multiple proposals
  */
@@ -201,9 +253,11 @@ export const getProposalsOnChainData = async (
     }
   }
 
+  const legacyArtemisMaxId = await getLegacyArtemisMaxId(governanceEnvironment);
+
   const onChainDataList = await Promise.all(
     apiProposals.map(async (p) => {
-      const isMultichain = isMultichainProposal(p.targets);
+      const isMultichain = isMultichainAware(p, legacyArtemisMaxId);
 
       const governorContract = isMultichain
         ? governanceEnvironment.contracts.multichainGovernor
@@ -242,7 +296,7 @@ export const getProposalsOnChainData = async (
 
   const votesCollectedList = await Promise.all(
     apiProposals.map(async (apiProposal) => {
-      const isMultichain = isMultichainProposal(apiProposal.targets);
+      const isMultichain = isMultichainAware(apiProposal, legacyArtemisMaxId);
 
       if (
         !isMultichain ||

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,90 @@ 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";
+
+/**
+ * Error thrown for any failure communicating with the Merkl API: non-ok HTTP
+ * responses, network rejections (fetch threw), and response-body parse errors.
+ *
+ * - HTTP failures populate `status` and `statusText`.
+ * - Network and parse failures leave `status`/`statusText` undefined and
+ *   carry the original error via `cause`.
+ */
+export class MerklApiError extends Error {
+  readonly status: number | undefined;
+  readonly statusText: string | undefined;
+  readonly url: string;
+  readonly chainId: number;
+
+  constructor(params: {
+    message: string;
+    url: string;
+    chainId: number;
+    status?: number | undefined;
+    statusText?: string | undefined;
+    cause?: unknown;
+  }) {
+    super(
+      params.message,
+      params.cause !== undefined ? { cause: params.cause } : undefined,
+    );
+    this.name = "MerklApiError";
+    this.url = params.url;
+    this.chainId = params.chainId;
+    this.status = params.status;
+    this.statusText = params.statusText;
+  }
+}
 
 export async function getUserMorphoRewardsData(params: {
   environment: Environment;
   account: `0x${string}`;
+  throwOnExternalApiError?: boolean;
 }): 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,
+    { throwOnError: params.throwOnExternalApiError ?? false },
+  );
+
   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 +107,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 +132,7 @@ export async function getUserMorphoRewardsData(params: {
         claimableNowUsd,
         claimableFuture,
         claimableFutureUsd,
-      };
-
-      merklResult.push(merklReward);
+      });
     }
   }
 
@@ -456,94 +288,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;
@@ -586,30 +330,64 @@ type MerklRewardsResponse = {
 async function getMerklRewardsData(
   environment: Environment,
   account: Address,
+  options: { throwOnError: boolean } = { throwOnError: false },
 ): Promise<MerklRewardsResponse[]> {
+  const url = `https://api.merkl.xyz/v4/users/${account}/rewards?chainId=${environment.chainId}&test=false&breakdownPage=0&reloadChainId=${environment.chainId}`;
+
+  let response: Response;
   try {
     // Merkl campaigns always distribute rewards on the same chain as the
     // opportunity, so environment.chainId is the only chain we need to query.
     // The previous two-phase approach (fetch opportunities per vault → extract
     // chain IDs → fetch rewards per chain) made N+1 HTTP calls to discover
     // a chain ID we already know.
-    const response = await fetch(
-      `https://api.merkl.xyz/v4/users/${account}/rewards?chainId=${environment.chainId}&test=false&breakdownPage=0&reloadChainId=${environment.chainId}`,
-      {
-        headers: MOONWELL_FETCH_JSON_HEADERS,
-      },
+    response = await fetch(url, { headers: MOONWELL_FETCH_JSON_HEADERS });
+  } catch (error) {
+    if (options.throwOnError) {
+      throw new MerklApiError({
+        message: `Merkl API network error for chain ${environment.chainId}`,
+        url,
+        chainId: environment.chainId,
+        cause: error,
+      });
+    }
+    console.error(
+      `[getMerklRewardsData:network] chain=${environment.chainId} url=${url}`,
+      error,
     );
+    return [];
+  }
 
-    if (!response.ok) {
-      console.warn(
-        `Merkl API request failed: ${response.status} ${response.statusText}`,
-      );
-      return [];
+  if (!response.ok) {
+    const message = `Merkl API request failed for chain ${environment.chainId}: ${response.status} ${response.statusText}`;
+    if (options.throwOnError) {
+      throw new MerklApiError({
+        message,
+        url,
+        chainId: environment.chainId,
+        status: response.status,
+        statusText: response.statusText,
+      });
     }
+    console.warn(`${message} (url=${url})`);
+    return [];
+  }
 
+  try {
     return (await response.json()) as MerklRewardsResponse[];
   } catch (error) {
-    console.error("Error in getMerklRewardsData:", error);
+    if (options.throwOnError) {
+      throw new MerklApiError({
+        message: `Merkl API response parse error for chain ${environment.chainId}`,
+        url,
+        chainId: environment.chainId,
+        cause: error,
+      });
+    }
+    console.error(
+      `[getMerklRewardsData:parse] chain=${environment.chainId} url=${url}`,
+      error,
+    );
     return [];
   }
 }