@moonwell-fi/moonwell-sdk 0.2.0 → 0.3.2

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

@@ -1,3 +1,4 @@
+import { uniq } from "lodash";
 import type { Address } from "viem";
 import { Amount } from "../../../common/amount.js";
 import type { Environment, TokenConfig } from "../../../environments/index.js";
@@ -12,16 +13,20 @@ export async function getUserMorphoRewardsData(params: {
     params.environment.chainId,
     params.account,
   );
+
   const assets = await getMorphoAssetsData(
     params.environment.chainId,
     rewards.map((r) => r.asset.address),
   );
 
-  const result: MorphoUserReward[] = rewards.map((r) => {
+  const result: (MorphoUserReward | undefined)[] = rewards.map((r) => {
     const asset = assets.find(
       (a) => a.address.toLowerCase() === r.asset.address.toLowerCase(),
-    )!;
-    // TODO: handle undefined
+    );
+
+    if (!asset) {
+      return undefined;
+    }
 
     const rewardToken: TokenConfig = {
       address: asset.address,
@@ -135,7 +140,7 @@ export async function getUserMorphoRewardsData(params: {
     }
   });
 
-  return result;
+  return result.filter((r) => r !== undefined) as MorphoUserReward[];
 }
 
 type MorphoRewardsResponse = {
@@ -199,7 +204,9 @@ async function getMorphoAssetsData(
     };
   }>(`
     query {
-      assets(where: {address_in: [${addresses.map((a: string) => `"${a}"`).join(",")}], chain_id: ${chainId}}) {
+      assets(where: {address_in: [${uniq(addresses)
+        .map((a: string) => `"${a}"`)
+        .join(",")}], chainId_in: ${chainId}}) {
         items {
           address     
           symbol

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

@@ -1,7 +1,7 @@
 import type { Address } from "viem";
 import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
 import { getEnvironmentsFromArgs } from "../../../common/index.js";
-import type { NetworkParameterType } from "../../../common/types.js";
+import type { OptionalNetworkParameterType } from "../../../common/types.js";
 import type { Chain } from "../../../environments/index.js";
 import type { MorphoUserReward } from "../../../types/morphoUserReward.js";
 import { getUserMorphoRewardsData } from "./common.js";
@@ -9,7 +9,7 @@ import { getUserMorphoRewardsData } from "./common.js";
 export type GetMorphoUserRewardsParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   userAddress: Address;
 };
 
@@ -25,12 +25,14 @@ export async function getMorphoUserRewards<
   const environments = getEnvironmentsFromArgs(client, args);
 
   const environmentsUserRewards = await Promise.all(
-    environments.map((environment) => {
-      return getUserMorphoRewardsData({
-        environment,
-        account: args.userAddress,
-      });
-    }),
+    environments
+      .filter((environment) => environment.contracts.morphoViews !== undefined)
+      .map((environment) => {
+        return getUserMorphoRewardsData({
+          environment,
+          account: args.userAddress,
+        });
+      }),
   );
 
   return environmentsUserRewards.flat();

package/actions/morpho/utils/graphql.ts

@@ -8,7 +8,7 @@ export async function getGraphQL<T>(
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ query: query, operationName, variables }),
-      signal: AbortSignal.timeout(5000),
+      signal: AbortSignal.timeout(10000),
     });
 
     const json = await response.json();

package/actions/morpho/vaults/common.ts

@@ -5,7 +5,7 @@ import type { Environment, TokenConfig } from "../../../environments/index.js";
 import type { MorphoReward } from "../../../types/morphoReward.js";
 import type {
   MorphoVault,
-  MorphoVaultMarkets,
+  MorphoVaultMarket,
 } from "../../../types/morphoVault.js";
 import { getGraphQL } from "../utils/graphql.js";
 import { WAD, mulDivDown, wMulDown } from "../utils/math.js";
@@ -97,7 +97,7 @@ export async function getMorphoVaultsData(params: {
             marketLiquidityUsd = totalSuppliedUsd;
           }
 
-          const mapping: MorphoVaultMarkets = {
+          const mapping: MorphoVaultMarket = {
             marketId: vaultMarket.marketId,
             allocation,
             marketApy,
@@ -144,11 +144,13 @@ export async function getMorphoVaultsData(params: {
 
         const mapping: MorphoVault = {
           chainId: environment.chainId,
+          vaultKey: vaultKey!,
           vaultToken,
           underlyingToken,
           underlyingPrice: underlyingPrice.value,
           baseApy,
           totalApy: baseApy,
+          rewardsApy: 0,
           curators: [],
           performanceFee,
           timelock,
@@ -176,6 +178,7 @@ export async function getMorphoVaultsData(params: {
   if (params.includeRewards === true) {
     const vaults = Object.values(result).flat();
     const rewards = await getMorphoVaultsRewards(vaults);
+
     vaults.forEach((vault) => {
       const vaultRewards = rewards.find(
         (reward) =>
@@ -208,8 +211,8 @@ export async function getMorphoVaultsData(params: {
 
         market.rewards = marketRewards;
         market.rewards.forEach((reward) => {
-          const supplyApr = reward.supplyApr * (market.allocation / 100);
-          const supplyAmount = reward.supplyAmount * (market.allocation / 100);
+          const supplyApr = reward.supplyApr * market.allocation;
+          const supplyAmount = reward.supplyAmount * market.allocation;
 
           const vaultReward = vault.rewards.find(
             (r) => r.asset.address === reward.asset.address,
@@ -229,9 +232,12 @@ export async function getMorphoVaultsData(params: {
         });
       });
 
-      vault.totalApy =
-        vault.rewards.reduce((acc, curr) => acc + curr.supplyApr, 0) +
-        vault.baseApy;
+      vault.rewardsApy = vault.rewards.reduce(
+        (acc, curr) => acc + curr.supplyApr,
+        0,
+      );
+
+      vault.totalApy = vault.rewardsApy + vault.baseApy;
     });
   }
 
@@ -375,15 +381,16 @@ export async function getMorphoVaultsRewards(
           const tokenAmountPer1000 =
             (Number.parseFloat(reward.amountPerSuppliedToken) /
               item.market.loanAsset.priceUsd) *
-              1000 || "0";
+            1000;
           const tokenDecimals = 10 ** reward.asset.decimals;
           const amount = Number(tokenAmountPer1000) / tokenDecimals;
+
           return {
             chainId: item.market.morphoBlue.chain.id,
             vaultId: item.user.address,
             marketId: item.market.uniqueKey,
             asset: reward.asset,
-            supplyApr: reward.supplyApr || 0 * 100,
+            supplyApr: (reward.supplyApr || 0) * 100,
             supplyAmount: amount,
             borrowApr: 0,
             borrowAmount: 0,
@@ -397,9 +404,10 @@ export async function getMorphoVaultsRewards(
           const tokenAmountPer1000 =
             (Number.parseFloat(reward.amountPerSuppliedToken) /
               item.asset.priceUsd) *
-              1000 || "0";
+            1000;
           const tokenDecimals = 10 ** reward.asset.decimals;
           const amount = Number(tokenAmountPer1000) / tokenDecimals;
+
           return {
             chainId: item.chain.id,
             vaultId: item.address,

package/actions/morpho/vaults/getMorphoVaults.ts

@@ -1,14 +1,15 @@
 import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
 import { getEnvironmentsFromArgs } from "../../../common/index.js";
-import type { NetworkParameterType } from "../../../common/types.js";
+import type { OptionalNetworkParameterType } from "../../../common/types.js";
 import type { Chain } from "../../../environments/index.js";
+import * as logger from "../../../logger/console.js";
 import type { MorphoVault } from "../../../types/morphoVault.js";
 import { getMorphoVaultsData } from "./common.js";
 
 export type GetMorphoVaultsParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   includeRewards?: boolean | undefined;
 };
 
@@ -19,12 +20,18 @@ export async function getMorphoVaults<
   Network extends Chain | undefined,
 >(
   client: MoonwellClient,
-  args: GetMorphoVaultsParameters<environments, Network>,
+  args?: GetMorphoVaultsParameters<environments, Network>,
 ): GetMorphoVaultsReturnType {
   const environments = getEnvironmentsFromArgs(client, args);
 
-  return getMorphoVaultsData({
+  const logId = logger.start("getMorphoVaults", "Starting to get vaults...");
+
+  const result = await getMorphoVaultsData({
     environments: environments,
-    includeRewards: args.includeRewards ?? false,
+    includeRewards: args?.includeRewards ?? false,
   });
+
+  logger.end(logId);
+
+  return result;
 }

package/client/createActions.ts

@@ -36,6 +36,11 @@ import {
   type GetUserRewardsReturnType,
   getUserRewards,
 } from "../actions/core/user-rewards/getUserRewards.js";
+import {
+  type GetCirculatingSupplySnapshotsParameters,
+  type GetCirculatingSupplySnapshotsReturnType,
+  getCirculatingSupplySnapshots,
+} from "../actions/governance/getCirculatingSupplySnapshots.js";
 import {
   type GetDelegatesReturnType,
   getDelegates,
@@ -94,6 +99,11 @@ import {
   type GetSnapshotProposalsReturnType,
   getSnapshotProposals,
 } from "../actions/governance/snapshot/getSnapshotProposals.js";
+import {
+  type GetMarketSnapshotsParameters,
+  type GetMarketSnapshotsReturnType,
+  getMarketSnapshots,
+} from "../actions/index.js";
 import {
   type GetMorphoUserBalancesParameters,
   type GetMorphoUserBalancesReturnType,
@@ -144,144 +154,183 @@ import {
   type GetMorphoVaultsReturnType,
   getMorphoVaults,
 } from "../actions/morpho/vaults/getMorphoVaults.js";
+import type { Environment, SupportedChains } from "../environments/index.js";
+
+export type Actions<
+  environments extends { [name in SupportedChains]?: Environment },
+> = {
+  getMarket: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetMarketParameters<environments, chain>,
+  ) => GetMarketReturnType;
+
+  getMarkets: <chain extends Chain | undefined = Chain | undefined>(
+    args?: GetMarketsParameters<environments, chain>,
+  ) => GetMarketsReturnType;
+
+  getUserPosition: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetUserPositionParameters<environments, chain>,
+  ) => GetUserPositionReturnType;
+
+  getUserPositions: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetUserPositionsParameters<environments, chain>,
+  ) => GetUserPositionsReturnType;
+
+  getUserReward: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetUserRewardParameters<environments, chain>,
+  ) => GetUserRewardReturnType;
+
+  getUserRewards: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetUserRewardsParameters<environments, chain>,
+  ) => GetUserRewardsReturnType;
+
+  getUserBalances: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetUserBalancesParameters<environments, chain>,
+  ) => GetUserBalancesReturnType;
+
+  getProposal: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetProposalParameters<environments, chain>,
+  ) => GetProposalReturnType;
+
+  getProposals: <chain extends Chain | undefined = Chain | undefined>(
+    args?: GetProposalsParameters<environments, chain>,
+  ) => GetProposalsReturnType;
+
+  getSnapshotProposal: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetSnapshotProposalParameters<environments, chain>,
+  ) => GetSnapshotProposalReturnType;
+
+  getSnapshotProposals: <chain extends Chain | undefined = Chain | undefined>(
+    args?: GetSnapshotProposalsParameters<environments, chain>,
+  ) => GetSnapshotProposalsReturnType;
+
+  getDelegates: () => GetDelegatesReturnType;
+
+  getDiscussions: () => GetDiscussionsReturnType;
+
+  getGovernanceTokenInfo: (
+    args: GetGovernanceTokenInfoParameters,
+  ) => GetGovernanceTokenInfoReturnType;
+
+  getStakingInfo: <chain extends Chain | undefined = Chain | undefined>(
+    args?: GetStakingInfoParameters<environments, chain>,
+  ) => GetStakingInfoReturnType;
+
+  getStakingSnapshots: <chain extends Chain | undefined = Chain | undefined>(
+    args?: GetStakingSnapshotsParameters<environments, chain>,
+  ) => GetStakingSnapshotsReturnType;
+
+  getUserStakingInfo: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetUserStakingInfoParameters<environments, chain>,
+  ) => GetUserStakingInfoReturnType;
+
+  getUserVoteReceipt: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetUserVoteReceiptParameters<environments, chain>,
+  ) => GetUserVoteReceiptReturnType;
+
+  getUserVotingPowers: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetUserVotingPowersParameters<environments, chain>,
+  ) => GetUserVotingPowersReturnType;
+
+  getMorphoMarket: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetMorphoMarketParameters<environments, chain>,
+  ) => GetMorphoMarketReturnType;
+
+  getMorphoMarkets: <chain extends Chain | undefined = Chain | undefined>(
+    args?: GetMorphoMarketsParameters<environments, chain>,
+  ) => GetMorphoMarketsReturnType;
+
+  getMorphoMarketUserPosition: <
+    chain extends Chain | undefined = Chain | undefined,
+  >(
+    args: GetMorphoMarketUserPositionParameters<environments, chain>,
+  ) => GetMorphoMarketUserPositionReturnType;
+
+  getMorphoMarketUserPositions: <
+    chain extends Chain | undefined = Chain | undefined,
+  >(
+    args: GetMorphoMarketUserPositionsParameters<environments, chain>,
+  ) => GetMorphoMarketUserPositionsReturnType;
+
+  getMorphoVaultUserPosition: <
+    chain extends Chain | undefined = Chain | undefined,
+  >(
+    args: GetMorphoVaultUserPositionParameters<environments, chain>,
+  ) => GetMorphoVaultUserPositionReturnType;
+
+  getMorphoVaultUserPositions: <
+    chain extends Chain | undefined = Chain | undefined,
+  >(
+    args: GetMorphoVaultUserPositionsParameters<environments, chain>,
+  ) => GetMorphoVaultUserPositionsReturnType;
+
+  getMorphoUserRewards: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetMorphoUserRewardsParameters<environments, chain>,
+  ) => GetMorphoUserRewardsReturnType;
+
+  getMorphoVault: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetMorphoVaultParameters<environments, chain>,
+  ) => GetMorphoVaultReturnType;
+
+  getMorphoVaults: <chain extends Chain | undefined = Chain | undefined>(
+    args?: GetMorphoVaultsParameters<environments, chain>,
+  ) => GetMorphoVaultsReturnType;
+
+  getMorphoUserBalances: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetMorphoUserBalancesParameters<environments, chain>,
+  ) => GetMorphoUserBalancesReturnType;
+
+  getCirculatingSupplySnapshots: <
+    chain extends Chain | undefined = Chain | undefined,
+  >(
+    args: GetCirculatingSupplySnapshotsParameters<environments, chain>,
+  ) => GetCirculatingSupplySnapshotsReturnType;
+
+  getMarketSnapshots: <chain extends Chain | undefined = Chain | undefined>(
+    args: GetMarketSnapshotsParameters<environments, chain>,
+  ) => GetMarketSnapshotsReturnType;
+};
 
-export const createActions = <environments>(
+export const actions = <
+  environments extends { [name in SupportedChains]?: Environment },
+>(
   client: MoonwellClient<environments>,
-) => {
+): Actions<environments> => {
   return {
-    getMarket: <chain extends Chain | undefined>(
-      args: GetMarketParameters<environments, chain>,
-    ): GetMarketReturnType => getMarket<environments, chain>(client, args),
-
-    getMarkets: <chain extends Chain | undefined>(
-      args?: GetMarketsParameters<environments, chain>,
-    ): GetMarketsReturnType => getMarkets<environments, chain>(client, args),
-
-    getUserPosition: <chain extends Chain | undefined>(
-      args: GetUserPositionParameters<environments, chain>,
-    ): GetUserPositionReturnType =>
-      getUserPosition<environments, chain>(client, args),
-
-    getUserPositions: <chain extends Chain | undefined>(
-      args: GetUserPositionsParameters<environments, chain>,
-    ): GetUserPositionsReturnType =>
-      getUserPositions<environments, chain>(client, args),
-
-    getUserReward: <chain extends Chain | undefined>(
-      args: GetUserRewardParameters<environments, chain>,
-    ): GetUserRewardReturnType =>
-      getUserReward<environments, chain>(client, args),
-
-    getUserRewards: <chain extends Chain | undefined>(
-      args: GetUserRewardsParameters<environments, chain>,
-    ): GetUserRewardsReturnType =>
-      getUserRewards<environments, chain>(client, args),
-
-    getUserBalances: <chain extends Chain | undefined>(
-      args: GetUserBalancesParameters<environments, chain>,
-    ): GetUserBalancesReturnType =>
-      getUserBalances<environments, chain>(client, args),
-
-    getProposal: <chain extends Chain | undefined>(
-      args: GetProposalParameters<environments, chain>,
-    ): GetProposalReturnType => getProposal<environments, chain>(client, args),
-
-    getProposals: <chain extends Chain | undefined>(
-      args?: GetProposalsParameters<environments, chain>,
-    ): GetProposalsReturnType =>
-      getProposals<environments, chain>(client, args),
-
-    getSnapshotProposal: <chain extends Chain | undefined>(
-      args: GetSnapshotProposalParameters<environments, chain>,
-    ): GetSnapshotProposalReturnType =>
-      getSnapshotProposal<environments, chain>(client, args),
-
-    getSnapshotProposals: <chain extends Chain | undefined>(
-      args?: GetSnapshotProposalsParameters<environments, chain>,
-    ): GetSnapshotProposalsReturnType =>
-      getSnapshotProposals<environments, chain>(client, args),
-
-    getDelegates: (): GetDelegatesReturnType => getDelegates(client),
-
-    getDiscussions: (): GetDiscussionsReturnType => getDiscussions(client),
-
-    getGovernanceTokenInfo: (
-      args: GetGovernanceTokenInfoParameters,
-    ): GetGovernanceTokenInfoReturnType => getGovernanceTokenInfo(client, args),
-
-    getStakingInfo: <chain extends Chain | undefined>(
-      args?: GetStakingInfoParameters<environments, chain>,
-    ): GetStakingInfoReturnType =>
-      getStakingInfo<environments, chain>(client, args),
-
-    getStakingSnapshots: <chain extends Chain | undefined>(
-      args?: GetStakingSnapshotsParameters<environments, chain>,
-    ): GetStakingSnapshotsReturnType =>
-      getStakingSnapshots<environments, chain>(client, args),
-
-    getUserStakingInfo: <chain extends Chain | undefined>(
-      args: GetUserStakingInfoParameters<environments, chain>,
-    ): GetUserStakingInfoReturnType =>
-      getUserStakingInfo<environments, chain>(client, args),
-
-    getUserVoteReceipt: <chain extends Chain | undefined>(
-      args: GetUserVoteReceiptParameters<environments, chain>,
-    ): GetUserVoteReceiptReturnType =>
-      getUserVoteReceipt<environments, chain>(client, args),
-
-    getUserVotingPowers: <chain extends Chain | undefined>(
-      args: GetUserVotingPowersParameters<environments, chain>,
-    ): GetUserVotingPowersReturnType =>
-      getUserVotingPowers<environments, chain>(client, args),
-
-    getMorphoMarket: <chain extends Chain | undefined>(
-      args: GetMorphoMarketParameters<environments, chain>,
-    ): GetMorphoMarketReturnType =>
-      getMorphoMarket<environments, chain>(client, args),
-
-    getMorphoMarkets: <chain extends Chain | undefined>(
-      args?: GetMorphoMarketsParameters<environments, chain>,
-    ): GetMorphoMarketsReturnType =>
-      getMorphoMarkets<environments, chain>(client, args),
-
-    getMorphoMarketUserPosition: <chain extends Chain | undefined>(
-      args: GetMorphoMarketUserPositionParameters<environments, chain>,
-    ): GetMorphoMarketUserPositionReturnType =>
-      getMorphoMarketUserPosition<environments, chain>(client, args),
-
-    getMorphoMarketUserPositions: <chain extends Chain | undefined>(
-      args: GetMorphoMarketUserPositionsParameters<environments, chain>,
-    ): GetMorphoMarketUserPositionsReturnType =>
-      getMorphoMarketUserPositions<environments, chain>(client, args),
-
-    getMorphoVaultUserPosition: <chain extends Chain | undefined>(
-      args: GetMorphoVaultUserPositionParameters<environments, chain>,
-    ): GetMorphoVaultUserPositionReturnType =>
-      getMorphoVaultUserPosition<environments, chain>(client, args),
-
-    getMorphoVaultUserPositions: <chain extends Chain | undefined>(
-      args: GetMorphoVaultUserPositionsParameters<environments, chain>,
-    ): GetMorphoVaultUserPositionsReturnType =>
-      getMorphoVaultUserPositions<environments, chain>(client, args),
-
-    getMorphoUserRewards: <chain extends Chain | undefined>(
-      args: GetMorphoUserRewardsParameters<environments, chain>,
-    ): GetMorphoUserRewardsReturnType =>
-      getMorphoUserRewards<environments, chain>(client, args),
-
-    getMorphoVault: <chain extends Chain | undefined>(
-      args: GetMorphoVaultParameters<environments, chain>,
-    ): GetMorphoVaultReturnType =>
-      getMorphoVault<environments, chain>(client, args),
-
-    getMorphoVaults: <chain extends Chain | undefined>(
-      args: GetMorphoVaultsParameters<environments, chain>,
-    ): GetMorphoVaultsReturnType =>
-      getMorphoVaults<environments, chain>(client, args),
-
-    getMorphoUserBalances: <chain extends Chain | undefined>(
-      args: GetMorphoUserBalancesParameters<environments, chain>,
-    ): GetMorphoUserBalancesReturnType =>
-      getMorphoUserBalances<environments, chain>(client, args),
+    getMarket: (args) => getMarket(client, args),
+    getMarkets: (args) => getMarkets(client, args),
+    getUserPosition: (args) => getUserPosition(client, args),
+    getUserPositions: (args) => getUserPositions(client, args),
+    getUserReward: (args) => getUserReward(client, args),
+    getUserRewards: (args) => getUserRewards(client, args),
+    getUserBalances: (args) => getUserBalances(client, args),
+    getProposal: (args) => getProposal(client, args),
+    getProposals: (args) => getProposals(client, args),
+    getSnapshotProposal: (args) => getSnapshotProposal(client, args),
+    getSnapshotProposals: (args) => getSnapshotProposals(client, args),
+    getDelegates: () => getDelegates(client),
+    getDiscussions: () => getDiscussions(client),
+    getGovernanceTokenInfo: (args) => getGovernanceTokenInfo(client, args),
+    getStakingInfo: (args) => getStakingInfo(client, args),
+    getStakingSnapshots: (args) => getStakingSnapshots(client, args),
+    getUserStakingInfo: (args) => getUserStakingInfo(client, args),
+    getUserVoteReceipt: (args) => getUserVoteReceipt(client, args),
+    getUserVotingPowers: (args) => getUserVotingPowers(client, args),
+    getMorphoMarket: (args) => getMorphoMarket(client, args),
+    getMorphoMarkets: (args) => getMorphoMarkets(client, args),
+    getMorphoMarketUserPosition: (args) =>
+      getMorphoMarketUserPosition(client, args),
+    getMorphoMarketUserPositions: (args) =>
+      getMorphoMarketUserPositions(client, args),
+    getMorphoVaultUserPosition: (args) =>
+      getMorphoVaultUserPosition(client, args),
+    getMorphoVaultUserPositions: (args) =>
+      getMorphoVaultUserPositions(client, args),
+    getMorphoUserRewards: (args) => getMorphoUserRewards(client, args),
+    getMorphoVault: (args) => getMorphoVault(client, args),
+    getMorphoVaults: (args) => getMorphoVaults(client, args),
+    getMorphoUserBalances: (args) => getMorphoUserBalances(client, args),
+    getCirculatingSupplySnapshots: (args) =>
+      getCirculatingSupplySnapshots(client, args),
+    getMarketSnapshots: (args) => getMarketSnapshots(client, args),
   };
 };

package/client/createMoonwellClient.ts

@@ -1,18 +1,26 @@
 import type { Narrow, Prettify } from "viem";
 import {
+  type ArbitrumEnvironment,
+  type AvalancheEnvironment,
   type BaseEnvironment,
   type Environment,
+  type EthereumEnvironment,
   type MoonbeamEnvironment,
   type MoonriverEnvironment,
   type OptimismEnvironment,
+  type PolygonEnvironment,
   type SupportedChains,
+  arbitrum,
+  avalanche,
   base,
   createEnvironment,
+  ethereum,
   moonbeam,
   moonriver,
   optimism,
+  polygon,
 } from "../environments/index.js";
-import { createActions } from "./createActions.js";
+import { actions } from "./createActions.js";
 
 export type MoonwellClient<
   environments = { [name in SupportedChains]?: Environment },
@@ -35,6 +43,26 @@ export type MoonwellClient<
         name,
         "moonriver"
       >]: MoonriverEnvironment;
+    } & {
+      [name in keyof environments as Extract<
+        name,
+        "ethereum"
+      >]: EthereumEnvironment;
+    } & {
+      [name in keyof environments as Extract<
+        name,
+        "avalanche"
+      >]: AvalancheEnvironment;
+    } & {
+      [name in keyof environments as Extract<
+        name,
+        "arbitrum"
+      >]: ArbitrumEnvironment;
+    } & {
+      [name in keyof environments as Extract<
+        name,
+        "polygon"
+      >]: PolygonEnvironment;
     }
   >;
 };
@@ -67,7 +95,13 @@ export const createMoonwellClient = <const networks>(config: {
                 ? moonbeam
                 : curr === "moonriver"
                   ? moonriver
-                  : base,
+                  : curr === "ethereum"
+                    ? ethereum
+                    : curr === "avalanche"
+                      ? avalanche
+                      : curr === "arbitrum"
+                        ? arbitrum
+                        : polygon,
         rpcUrls: networkConfig.rpcUrls,
       }),
     };
@@ -89,6 +123,23 @@ export const createMoonwellClient = <const networks>(config: {
         name,
         "moonriver"
       >]: MoonriverEnvironment;
+    } & {
+      [name in keyof networks as Extract<
+        name,
+        "ethereum"
+      >]: EthereumEnvironment;
+    } & {
+      [name in keyof networks as Extract<
+        name,
+        "avalanche"
+      >]: AvalancheEnvironment;
+    } & {
+      [name in keyof networks as Extract<
+        name,
+        "arbitrum"
+      >]: ArbitrumEnvironment;
+    } & {
+      [name in keyof networks as Extract<name, "polygon">]: PolygonEnvironment;
     }
   >;
 
@@ -96,8 +147,5 @@ export const createMoonwellClient = <const networks>(config: {
     environments,
   };
 
-  return Object.assign(
-    client,
-    createActions<typeof environments>(client as any),
-  );
+  return Object.assign(client, actions<typeof environments>(client as any));
 };