@moonwell-fi/moonwell-sdk 0.10.1 → 0.10.3

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

@@ -20,17 +20,19 @@ export async function getUserMorphoRewardsData(params: {
   environment: Environment;
   account: `0x${string}`;
 }): Promise<MorphoUserReward[]> {
-  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 (params.environment.custom.morpho?.minimalDeployment === false) {
-    const morphoRewards = await getMorphoRewardsData(
-      params.environment,
-      params.account,
-    );
-    // Process Morpho rewards
+  if (isFullDeployment) {
+    // Process Morpho rewards (GraphQL query depends on morphoRewards result)
     const morphoAssets = await getMorphoAssetsData(
       params.environment,
       morphoRewards.map((r) => r.asset.address),
@@ -189,6 +191,28 @@ export async function getUserMorphoRewardsData(params: {
     );
 
     // 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),
+      ),
+    );
+
+    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) {
@@ -205,30 +229,6 @@ export async function getUserMorphoRewardsData(params: {
           name: morphoAsset?.name ?? reward.token.symbol,
         };
 
-        const getVaultRewardAmount = (
-          breakdowns: any[],
-          field: "amount" | "claimed" | "pending",
-        ) => {
-          return breakdowns.reduce((acc, curr) => {
-            // Check if campaign exists in vaults across all chains
-            const isVaultCampaign = Object.values(publicEnvironments).some(
-              (environment) => {
-                // Check if environment has vaults
-                if (
-                  environment.config.vaults &&
-                  Object.keys(environment.config.vaults).length > 0
-                ) {
-                  return Object.values(environment.config.vaults).some(
-                    (vault) => vault.campaignId === curr.campaignId,
-                  );
-                }
-                return false;
-              },
-            );
-            return isVaultCampaign ? acc + BigInt(curr[field]) : acc;
-          }, 0n);
-        };
-
         const amount = getVaultRewardAmount(reward.breakdowns, "amount");
         const claimed = getVaultRewardAmount(reward.breakdowns, "claimed");
         const pending = getVaultRewardAmount(reward.breakdowns, "pending");
@@ -319,6 +319,69 @@ export async function getUserMorphoStakingRewardsData(params: {
     return [];
   }
 
+  // Hoist shared contract reads outside the per-vault loop
+  const homeEnvironment =
+    (Object.values(publicEnvironments) as Environment[]).find((e) =>
+      e.custom?.governance?.chainIds?.includes(params.environment.chainId),
+    ) || params.environment;
+
+  const viewsContract = params.environment.contracts.views;
+  const homeViewsContract = homeEnvironment.contracts.views;
+
+  const [allMarkets, nativeTokenPriceRaw, governanceTokenPriceRaw] =
+    await Promise.all([
+      viewsContract?.read.getAllMarketsInfo(),
+      homeViewsContract?.read.getNativeTokenPrice(),
+      homeViewsContract?.read.getGovernanceTokenPrice(),
+    ]);
+
+  const governanceTokenPrice = new Amount(governanceTokenPriceRaw || 0n, 18);
+  const nativeTokenPrice = new Amount(nativeTokenPriceRaw || 0n, 18);
+
+  let tokenPrices =
+    allMarkets
+      ?.map((marketInfo) => {
+        const marketFound = findMarketByAddress(
+          params.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 (params.environment.custom?.governance?.token) {
+    tokenPrices = [
+      ...tokenPrices,
+      {
+        token:
+          params.environment.config.tokens[
+            params.environment.custom.governance.token
+          ]!,
+        tokenPrice: governanceTokenPrice,
+      },
+    ];
+  }
+
+  // Add native token to token prices
+  tokenPrices = [
+    ...tokenPrices,
+    {
+      token: findTokenByAddress(params.environment, zeroAddress)!,
+      tokenPrice: nativeTokenPrice,
+    },
+  ];
+
   const rewards = await Promise.all(
     vaultsWithStaking.map(async (vault) => {
       if (!vault.multiReward) return [];
@@ -329,73 +392,6 @@ export async function getUserMorphoStakingRewardsData(params: {
         vault.multiReward,
       );
 
-      const homeEnvironment =
-        (Object.values(publicEnvironments) as Environment[]).find((e) =>
-          e.custom?.governance?.chainIds?.includes(params.environment.chainId),
-        ) || params.environment;
-
-      const viewsContract = params.environment.contracts.views;
-      const homeViewsContract = homeEnvironment.contracts.views;
-
-      const userData = await Promise.all([
-        viewsContract?.read.getAllMarketsInfo(),
-        homeViewsContract?.read.getNativeTokenPrice(),
-        homeViewsContract?.read.getGovernanceTokenPrice(),
-      ]);
-
-      const [allMarkets, nativeTokenPriceRaw, governanceTokenPriceRaw] =
-        userData;
-
-      const governanceTokenPrice = new Amount(
-        governanceTokenPriceRaw || 0n,
-        18,
-      );
-      const nativeTokenPrice = new Amount(nativeTokenPriceRaw || 0n, 18);
-
-      let tokenPrices =
-        allMarkets
-          ?.map((marketInfo) => {
-            const marketFound = findMarketByAddress(
-              params.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 (params.environment.custom?.governance?.token) {
-        tokenPrices = [
-          ...tokenPrices,
-          {
-            token:
-              params.environment.config.tokens[
-                params.environment.custom.governance.token
-              ]!,
-            tokenPrice: governanceTokenPrice,
-          },
-        ];
-      }
-
-      // Add native token to token prices
-      tokenPrices = [
-        ...tokenPrices,
-        {
-          token: findTokenByAddress(params.environment, zeroAddress)!,
-          tokenPrice: nativeTokenPrice,
-        },
-      ];
-
       return vaultRewards
         .filter((reward): reward is { amount: Amount; token: TokenConfig } => {
           return reward !== undefined && reward.amount.value > 0;
@@ -587,140 +583,31 @@ type MerklRewardsResponse = {
   }>;
 };
 
-// Types for Merkl Opportunities API
-type MerklToken = {
-  id: string;
-  name: string;
-  chainId: number;
-  address: string;
-  decimals: number;
-  symbol: string;
-  displaySymbol: string;
-  icon: string;
-  verified: boolean;
-  isTest: boolean;
-  type: string;
-  isNative: boolean;
-  price: number;
-};
-
-type MerklRewardBreakdown = {
-  token: MerklToken;
-  amount: string;
-  value: number;
-  distributionType: string;
-  id: string;
-  timestamp: string;
-  campaignId: string;
-  dailyRewardsRecordId: string;
-};
-
-type MerklOpportunity = {
-  chainId: number;
-  type: string;
-  identifier: string;
-  name: string;
-  description: string;
-  howToSteps: string[];
-  status: string;
-  action: string;
-  tvl: number;
-  apr: number;
-  dailyRewards: number;
-  tags: any[];
-  id: string;
-  depositUrl: string;
-  explorerAddress: string;
-  lastCampaignCreatedAt: number;
-  aprRecord: {
-    cumulated: number;
-    timestamp: string;
-    breakdowns: {
-      distributionType: string;
-      identifier: string;
-      type: string;
-      value: number;
-      timestamp: string;
-    }[];
-  };
-  rewardsRecord: {
-    id: string;
-    total: number;
-    timestamp: string;
-    breakdowns: MerklRewardBreakdown[];
-  };
-};
-
 async function getMerklRewardsData(
   environment: Environment,
   account: Address,
 ): Promise<MerklRewardsResponse[]> {
   try {
-    // Get unique chain IDs from vault opportunities
-    const chainIdsPromises = Object.values(environment.config.vaults).map(
-      async (vault) => {
-        try {
-          const response = await fetch(
-            `https://api.merkl.xyz/v4/opportunities?identifier=${environment.config.tokens[vault.vaultToken]?.address}&chainId=${environment.chainId}&status=LIVE`,
-            {
-              headers: MOONWELL_FETCH_JSON_HEADERS,
-            },
-          );
-
-          if (!response.ok) {
-            console.warn(
-              `Failed to fetch opportunities: ${response.status} ${response.statusText}`,
-            );
-            return [];
-          }
-
-          const data: MerklOpportunity[] = await response.json();
-          return data.flatMap((opportunity) =>
-            opportunity.rewardsRecord.breakdowns.map(
-              (breakdown) => breakdown.token.chainId,
-            ),
-          );
-        } catch (error) {
-          console.warn(
-            `Error fetching opportunities for vault ${vault.vaultToken}:`,
-            error,
-          );
-          return [];
-        }
+    // 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,
       },
     );
 
-    const chainIds = [...new Set((await Promise.all(chainIdsPromises)).flat())];
-
-    // Fetch rewards for each unique chain ID
-    const rewardsPromises = chainIds.map(async (chainId) => {
-      try {
-        const response = await fetch(
-          `https://api.merkl.xyz/v4/users/${account}/rewards?chainId=${chainId}&test=false&breakdownPage=0&reloadChainId=${chainId}`,
-          {
-            headers: MOONWELL_FETCH_JSON_HEADERS,
-          },
-        );
-
-        if (!response.ok) {
-          console.warn(
-            `Merkl API request failed: ${response.status} ${response.statusText}`,
-          );
-          return [];
-        }
-
-        return (await response.json()) as MerklRewardsResponse[];
-      } catch (error) {
-        console.warn(
-          `Error fetching Merkl rewards for chain ${chainId}:`,
-          error,
-        );
-        return [];
-      }
-    });
+    if (!response.ok) {
+      console.warn(
+        `Merkl API request failed: ${response.status} ${response.statusText}`,
+      );
+      return [];
+    }
 
-    const allRewards = await Promise.all(rewardsPromises);
-    return allRewards.flat();
+    return (await response.json()) as MerklRewardsResponse[];
   } catch (error) {
     console.error("Error in getMerklRewardsData:", error);
     return [];

package/actions/morpho/vaults/common.ts

@@ -847,6 +847,21 @@ async function getMorphoVaultsDataFromOnChain(params: {
               },
             );
 
+            // For V2 vaults, normalize allocations to reflect deployed asset distribution
+            // V2 vaults may have idle capital not deployed to adapters, which causes
+            // raw allocations to sum to less than 100% of total vault assets
+            if (vaultConfig.version === 2) {
+              const totalAllocation = markets.reduce(
+                (sum, m) => sum + m.allocation,
+                0,
+              );
+              if (totalAllocation > 0) {
+                for (const market of markets) {
+                  market.allocation = market.allocation / totalAllocation;
+                }
+              }
+            }
+
             // Only calculate baseApy from markets for v1 vaults
             // v2 vaults already have baseApy from Morpho API
             if (vaultConfig.version !== 2) {

package/environments/definitions/base/morpho-vaults.ts

@@ -9,24 +9,52 @@ export const vaults = createVaultConfig({
       vaultToken: "mwETH",
       campaignId:
         "0x1df9a935f6b928b4809c4fda483f16839140864b2b412cc5fea85fd5d9d00e57",
+      version: 2,
+    },
+    mwETHv1: {
+      underlyingToken: "ETH",
+      vaultToken: "mwETHv1",
+      campaignId:
+        "0x1df9a935f6b928b4809c4fda483f16839140864b2b412cc5fea85fd5d9d00e57",
     },
     mwUSDC: {
       underlyingToken: "USDC",
       vaultToken: "mwUSDC",
       campaignId:
         "0xec43a3d75ae25c5255eb06b3aac6b79ccb2cdb6b99740ea13553661b0f06b756",
+      version: 2,
+    },
+    mwUSDCv1: {
+      underlyingToken: "USDC",
+      vaultToken: "mwUSDCv1",
+      campaignId:
+        "0xec43a3d75ae25c5255eb06b3aac6b79ccb2cdb6b99740ea13553661b0f06b756",
     },
     mwEURC: {
       underlyingToken: "EURC",
       vaultToken: "mwEURC",
       campaignId:
         "0x03430078e052d58b6e80fa8e373c38a75736f1d24768b9c92a2e44bc4ce62b1d",
+      version: 2,
+    },
+    mwEURCv1: {
+      underlyingToken: "EURC",
+      vaultToken: "mwEURCv1",
+      campaignId:
+        "0x03430078e052d58b6e80fa8e373c38a75736f1d24768b9c92a2e44bc4ce62b1d",
     },
     mwcbBTC: {
       underlyingToken: "cbBTC",
       vaultToken: "mwcbBTC",
       campaignId:
         "0xb230a09331c22280ae3e02a65caad21a553274912352d8f93c7a92c0f9bb3da4",
+      version: 2,
+    },
+    mwcbBTCv1: {
+      underlyingToken: "cbBTC",
+      vaultToken: "mwcbBTCv1",
+      campaignId:
+        "0xb230a09331c22280ae3e02a65caad21a553274912352d8f93c7a92c0f9bb3da4",
     },
     meUSDC: {
       underlyingToken: "USDC",

package/environments/definitions/base/tokens.ts

@@ -141,29 +141,53 @@ export const tokens = createTokenConfig({
     symbol: "mEURC",
   },
   mwETH: {
-    address: "0xa0E430870c4604CcfC7B38Ca7845B1FF653D0ff1",
+    address: "0x89BeDBB1C4837444Da215A377275Ff96A84D6f53",
     decimals: 18,
     name: "Moonwell Flagship ETH",
     symbol: "mwETH",
   },
+  mwETHv1: {
+    address: "0xa0E430870c4604CcfC7B38Ca7845B1FF653D0ff1",
+    decimals: 18,
+    name: "Moonwell Flagship ETH V1",
+    symbol: "mwETHv1",
+  },
   mwUSDC: {
-    address: "0xc1256Ae5FF1cf2719D4937adb3bbCCab2E00A2Ca",
+    address: "0x48a90E85be5C56b0A669985A12ee7C449fC79965",
     decimals: 18,
     name: "Moonwell Flagship USDC",
     symbol: "mwUSDC",
   },
+  mwUSDCv1: {
+    address: "0xc1256Ae5FF1cf2719D4937adb3bbCCab2E00A2Ca",
+    decimals: 18,
+    name: "Moonwell Flagship USDC V1",
+    symbol: "mwUSDCv1",
+  },
   mwEURC: {
-    address: "0xf24608E0CCb972b0b0f4A6446a0BBf58c701a026",
+    address: "0x5083b1387Ec3d4Ee6467B83890D98f1AF93F7c48",
     decimals: 18,
     name: "Moonwell Flagship EURC",
     symbol: "mwEURC",
   },
+  mwEURCv1: {
+    address: "0xf24608E0CCb972b0b0f4A6446a0BBf58c701a026",
+    decimals: 18,
+    name: "Moonwell Flagship EURC V1",
+    symbol: "mwEURCv1",
+  },
   mwcbBTC: {
-    address: "0x543257eF2161176D7C8cD90BA65C2d4CaEF5a796",
+    address: "0xdbA76Bc542bb07538e046B40F2e8a215B409F7A8",
     decimals: 18,
     name: "Moonwell Frontier cbBTC",
     symbol: "mwcbBTC",
   },
+  mwcbBTCv1: {
+    address: "0x543257eF2161176D7C8cD90BA65C2d4CaEF5a796",
+    decimals: 18,
+    name: "Moonwell Frontier cbBTC V1",
+    symbol: "mwcbBTCv1",
+  },
   WELL: {
     address: "0xA88594D404727625A9437C3f886C7643872296AE",
     decimals: 18,

package/errors/version.ts

@@ -1 +1 @@
-export const version = '0.10.1'
+export const version = '0.10.3'

package/package.json

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