@moonwell-fi/moonwell-sdk 0.2.0 → 0.3.2

package/actions/governance/proposals/common.ts

@@ -1,6 +1,6 @@
 import axios from "axios";
 
-import { first, last } from "lodash";
+import { last } from "lodash";
 import { moonriver } from "viem/chains";
 import { Amount } from "../../../common/index.js";
 import {
@@ -11,7 +11,7 @@ import {
   type ExtendedProposalData,
   MultichainProposalStateMapping,
   type Proposal,
-  ProposalState,
+  type ProposalState,
 } from "../../../types/proposal.js";
 
 axios.defaults.timeout = 5_000;
@@ -24,19 +24,19 @@ export const appendProposalExtendedData = (
     const extendedData = extendedDatas.find((item) => item.id === proposal.id);
 
     if (extendedData) {
-      const lastProposalUpdate = first(
-        last(extendedData.stateChanges)?.messages,
-      );
-
-      // If the xChain timestamp is in the future, but less than 24 hours from now, it is queued
-      if (lastProposalUpdate && lastProposalUpdate.timestamp > 0) {
-        const now = Math.floor(Date.now() / 1000);
-        if (lastProposalUpdate.timestamp + 60 * 60 * 24 > now) {
-          proposal.state = ProposalState.MultichainQueued;
-        } else {
-          proposal.state = ProposalState.MultichainExecuted;
-        }
-      }
+      // const lastProposalUpdate = first(
+      //   last(extendedData.stateChanges)?.messages,
+      // );
+
+      // // If the xChain timestamp is in the future, but less than 24 hours from now, it is queued
+      // if (lastProposalUpdate && lastProposalUpdate.timestamp > 0) {
+      //   const now = Math.floor(Date.now() / 1000);
+      //   if (lastProposalUpdate.timestamp + 60 * 60 * 24 > now) {
+      //     proposal.state = ProposalState.MultichainQueued;
+      //   } else {
+      //     proposal.state = ProposalState.MultichainExecuted;
+      //   }
+      // }
 
       proposal.title = extendedData.title;
       proposal.calldatas = extendedData.calldatas;
@@ -407,12 +407,6 @@ export const getExtendedProposalData = async (params: {
                 txnHash: string;
                 blockNumber: number;
                 newState: string;
-                messages: {
-                  items: {
-                    timestamp: number;
-                    sequence: number;
-                  }[];
-                };
               }[];
             };
           }[];
@@ -442,12 +436,6 @@ export const getExtendedProposalData = async (params: {
                     txnHash
                     blockNumber
                     newState
-                    messages {
-                      items {
-                        timestamp
-                        sequence
-                      }
-                    }
                   }
                 }
               }
@@ -468,7 +456,6 @@ export const getExtendedProposalData = async (params: {
           stateChanges: item.stateChanges.items.map((change) => {
             return {
               blockNumber: change.blockNumber,
-              messages: change.messages.items.map((message) => message),
               state: change.newState,
               transactionHash: change.txnHash,
             };

package/actions/governance/proposals/getProposals.ts

@@ -1,7 +1,12 @@
 import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
 import { getEnvironmentsFromArgs } from "../../../common/index.js";
-import type { NetworkParameterType } from "../../../common/types.js";
-import type { Chain } from "../../../environments/index.js";
+import type { OptionalNetworkParameterType } from "../../../common/types.js";
+import {
+  type Chain,
+  moonbeam,
+  moonriver,
+} from "../../../environments/index.js";
+import * as logger from "../../../logger/console.js";
 import type { Proposal } from "../../../types/proposal.js";
 import {
   appendProposalExtendedData,
@@ -13,7 +18,7 @@ import {
 export type GetProposalsParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network>;
+> = OptionalNetworkParameterType<environments, network>;
 
 export type GetProposalsReturnType = Promise<Proposal[]>;
 
@@ -26,17 +31,33 @@ export async function getProposals<
 ): GetProposalsReturnType {
   const environments = getEnvironmentsFromArgs(client, args);
 
+  const governanceEnvironments = environments.filter(
+    (environment) =>
+      environment.chainId === moonriver.id ||
+      environment.chainId === moonbeam.id,
+  );
+
+  const logId = logger.start("getProposals", "Starting to get proposals...");
+
   const environmentProposals = await Promise.all(
-    environments.map((environment) =>
-      Promise.all([
-        getProposalData({ environment }),
-        getCrossChainProposalData({ environment }),
-        getExtendedProposalData({ environment }),
-      ]),
-    ),
+    governanceEnvironments
+      .filter(
+        (environment) =>
+          environment.chainId === moonriver.id ||
+          environment.chainId === moonbeam.id,
+      )
+      .map((environment) =>
+        Promise.all([
+          getProposalData({ environment }),
+          getCrossChainProposalData({ environment }),
+          getExtendedProposalData({ environment }),
+        ]),
+      ),
   );
 
-  const proposals = environments.flatMap((_item, index: number) => {
+  logger.end(logId);
+
+  const proposals = governanceEnvironments.flatMap((_item, index: number) => {
     const [_proposals, _xcProposals, _extendedDatas] =
       environmentProposals[index]!;
 

package/actions/governance/snapshot/getSnapshotProposals.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 { SnapshotProposal } from "../../../types/snapshotProposal.js";
 import { getSnapshotProposalData } from "./common.js";
 
 export type GetSnapshotProposalsParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   pagination?: {
     size?: number;
     page?: number;
@@ -35,9 +36,18 @@ export async function getSnapshotProposals<
 
   const environments = getEnvironmentsFromArgs(client, args);
 
-  return getSnapshotProposalData({
+  const logId = logger.start(
+    "getSnapshotProposals",
+    "Starting to get snapshot proposals...",
+  );
+
+  const proposals = await getSnapshotProposalData({
     environments,
     filters,
     pagination,
   });
+
+  logger.end(logId);
+
+  return proposals;
 }

package/actions/index.ts

@@ -1,148 +1,159 @@
 /* Core */
 export {
+  getUserBalances,
+  type GetUserBalancesParameters,
+  type GetUserBalancesReturnType,
+} from "./core/getUserBalances.js";
+export {
+  getMarket,
   type GetMarketParameters,
   type GetMarketReturnType,
-  getMarket,
 } from "./core/markets/getMarket.js";
 export {
+  getMarkets,
   type GetMarketsParameters,
   type GetMarketsReturnType,
-  getMarkets,
 } from "./core/markets/getMarkets.js";
 export {
+  getUserPosition,
   type GetUserPositionParameters,
   type GetUserPositionReturnType,
-  getUserPosition,
 } from "./core/user-positions/getUserPosition.js";
 export {
+  getUserPositions,
   type GetUserPositionsParameters,
   type GetUserPositionsReturnType,
-  getUserPositions,
 } from "./core/user-positions/getUserPositions.js";
 export {
+  getUserReward,
   type GetUserRewardParameters,
   type GetUserRewardReturnType,
-  getUserReward,
 } from "./core/user-rewards/getUserReward.js";
 export {
+  getUserRewards,
   type GetUserRewardsParameters,
   type GetUserRewardsReturnType,
-  getUserRewards,
 } from "./core/user-rewards/getUserRewards.js";
-export {
-  type GetUserBalancesParameters,
-  type GetUserBalancesReturnType,
-  getUserBalances,
-} from "./core/getUserBalances.js";
 
 /* Governance */
 export {
-  type GetProposalParameters,
-  type GetProposalReturnType,
-  getProposal,
-} from "./governance/proposals/getProposal.js";
+  getCirculatingSupplySnapshots,
+  type GetCirculatingSupplySnapshotsParameters,
+  type GetCirculatingSupplySnapshotsReturnType,
+} from "./governance/getCirculatingSupplySnapshots.js";
 export {
-  type GetProposalsParameters,
-  type GetProposalsReturnType,
-  getProposals,
-} from "./governance/proposals/getProposals.js";
-export {
-  type GetSnapshotProposalParameters,
-  type GetSnapshotProposalReturnType,
-  getSnapshotProposal,
-} from "./governance/snapshot/getSnapshotProposal.js";
-export {
-  type GetSnapshotProposalsParameters,
-  type GetSnapshotProposalsReturnType,
-  getSnapshotProposals,
-} from "./governance/snapshot/getSnapshotProposals.js";
-export {
-  type GetDelegatesReturnType,
   getDelegates,
+  type GetDelegatesReturnType,
 } from "./governance/getDelegates.js";
 export {
-  type GetDiscussionsReturnType,
   getDiscussions,
+  type GetDiscussionsReturnType,
 } from "./governance/getDiscussions.js";
 export {
+  getGovernanceTokenInfo,
   type GetGovernanceTokenInfoParameters,
   type GetGovernanceTokenInfoReturnType,
-  getGovernanceTokenInfo,
 } from "./governance/getGovernanceTokenInfo.js";
 export {
+  getStakingInfo,
   type GetStakingInfoParameters,
   type GetStakingInfoReturnType,
-  getStakingInfo,
 } from "./governance/getStakingInfo.js";
 export {
+  getStakingSnapshots,
   type GetStakingSnapshotsParameters,
   type GetStakingSnapshotsReturnType,
-  getStakingSnapshots,
 } from "./governance/getStakingSnapshots.js";
 export {
+  getUserStakingInfo,
   type GetUserStakingInfoParameters,
   type GetUserStakingInfoReturnType,
-  getUserStakingInfo,
 } from "./governance/getUserStakingInfo.js";
 export {
+  getUserVoteReceipt,
   type GetUserVoteReceiptParameters,
   type GetUserVoteReceiptReturnType,
-  getUserVoteReceipt,
 } from "./governance/getUserVoteReceipt.js";
 export {
+  getUserVotingPowers,
   type GetUserVotingPowersParameters,
   type GetUserVotingPowersReturnType,
-  getUserVotingPowers,
 } from "./governance/getUserVotingPowers.js";
+export {
+  getProposal,
+  type GetProposalParameters,
+  type GetProposalReturnType,
+} from "./governance/proposals/getProposal.js";
+export {
+  getProposals,
+  type GetProposalsParameters,
+  type GetProposalsReturnType,
+} from "./governance/proposals/getProposals.js";
+export {
+  getSnapshotProposal,
+  type GetSnapshotProposalParameters,
+  type GetSnapshotProposalReturnType,
+} from "./governance/snapshot/getSnapshotProposal.js";
+export {
+  getSnapshotProposals,
+  type GetSnapshotProposalsParameters,
+  type GetSnapshotProposalsReturnType,
+} from "./governance/snapshot/getSnapshotProposals.js";
 
 /* Morpho */
 export {
+  getMorphoUserBalances,
+  type GetMorphoUserBalancesParameters,
+  type GetMorphoUserBalancesReturnType,
+} from "./morpho/getMorphoUserBalances.js";
+export {
+  getMorphoMarket,
   type GetMorphoMarketParameters,
   type GetMorphoMarketReturnType,
-  getMorphoMarket,
 } from "./morpho/markets/getMorphoMarket.js";
 export {
+  getMorphoMarkets,
   type GetMorphoMarketsParameters,
   type GetMorphoMarketsReturnType,
-  getMorphoMarkets,
 } from "./morpho/markets/getMorphoMarkets.js";
 export {
-  type GetMorphoMarketUserPositionsParameters,
-  type GetMorphoMarketUserPositionsReturnType,
-  getMorphoMarketUserPositions,
-} from "./morpho/user-positions/getMorphoMarketUserPositions.js";
-export {
+  getMorphoMarketUserPosition,
   type GetMorphoMarketUserPositionParameters,
   type GetMorphoMarketUserPositionReturnType,
-  getMorphoMarketUserPosition,
 } from "./morpho/user-positions/getMorphoMarketUserPosition.js";
 export {
+  getMorphoMarketUserPositions,
+  type GetMorphoMarketUserPositionsParameters,
+  type GetMorphoMarketUserPositionsReturnType,
+} from "./morpho/user-positions/getMorphoMarketUserPositions.js";
+export {
+  getMorphoVaultUserPosition,
   type GetMorphoVaultUserPositionParameters,
   type GetMorphoVaultUserPositionReturnType,
-  getMorphoVaultUserPosition,
 } from "./morpho/user-positions/getMorphoVaultUserPosition.js";
 export {
+  getMorphoVaultUserPositions,
   type GetMorphoVaultUserPositionsParameters,
   type GetMorphoVaultUserPositionsReturnType,
-  getMorphoVaultUserPositions,
 } from "./morpho/user-positions/getMorphoVaultUserPositions.js";
 export {
+  getMorphoUserRewards,
   type GetMorphoUserRewardsParameters,
   type GetMorphoUserRewardsReturnType,
-  getMorphoUserRewards,
 } from "./morpho/user-rewards/getMorphoUserRewards.js";
 export {
+  getMorphoVault,
   type GetMorphoVaultParameters,
   type GetMorphoVaultReturnType,
-  getMorphoVault,
 } from "./morpho/vaults/getMorphoVault.js";
 export {
+  getMorphoVaults,
   type GetMorphoVaultsParameters,
   type GetMorphoVaultsReturnType,
-  getMorphoVaults,
 } from "./morpho/vaults/getMorphoVaults.js";
+
 export {
-  type GetMorphoUserBalancesParameters,
-  type GetMorphoUserBalancesReturnType,
-  getMorphoUserBalances,
-} from "./morpho/getMorphoUserBalances.js";
+  getMarketSnapshots,
+  type GetMarketSnapshotsParameters,
+  type GetMarketSnapshotsReturnType,
+} from "./core/markets/getMarketSnapshots.js";

package/actions/morpho/getMorphoUserBalances.ts

@@ -1,7 +1,7 @@
 import type { Address } from "viem";
 import type { MoonwellClient } from "../../client/createMoonwellClient.js";
 import { Amount, 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 { findTokenByAddress } from "../../environments/utils/index.js";
 import type { UserBalance } from "../../types/userBalance.js";
@@ -9,7 +9,7 @@ import type { UserBalance } from "../../types/userBalance.js";
 export type GetMorphoUserBalancesParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   userAddress: Address;
 };
 

package/actions/morpho/markets/common.ts

@@ -45,6 +45,12 @@ export async function getMorphoMarketsData(params: {
       const environmentMarketsInfo = environmentsMarketsInfo[environmentIndex]!;
 
       const markets = environmentMarketsInfo.map((marketInfo) => {
+        const marketKey = Object.keys(environment.config.morphoMarkets).find(
+          (item) =>
+            environment.config.morphoMarkets[item].id.toLowerCase() ===
+            marketInfo.marketId.toLowerCase(),
+        )!;
+
         const marketConfig = Object.values(
           environment.config.morphoMarkets,
         ).find(
@@ -55,7 +61,7 @@ export async function getMorphoMarketsData(params: {
           environment.config.tokens[marketConfig.collateralToken];
 
         const oraclePrice = new Amount(
-          marketInfo.oraclePrice,
+          BigInt(marketInfo.oraclePrice),
           36 + loanToken.decimals - collateralToken.decimals,
         ).value;
 
@@ -67,12 +73,12 @@ export async function getMorphoMarketsData(params: {
         const loanToValue = new Amount(marketInfo.lltv, 18).value;
 
         const totalSupplyInLoanToken = new Amount(
-          marketInfo.totalSupplyAssets,
+          BigInt(marketInfo.totalSupplyAssets),
           loanToken.decimals,
         );
 
         const totalSupply = new Amount(
-          totalSupplyInLoanToken.value / oraclePrice,
+          Number(totalSupplyInLoanToken.value / oraclePrice),
           collateralToken.decimals,
         );
         const totalBorrows = new Amount(
@@ -87,6 +93,7 @@ export async function getMorphoMarketsData(params: {
         const mapping: MorphoMarket = {
           chainId: environment.chainId,
           marketId: marketInfo.marketId,
+          marketKey,
           deprecated: marketConfig.deprecated === true,
           loanToValue,
           performanceFee,
@@ -103,11 +110,13 @@ export async function getMorphoMarketsData(params: {
           totalBorrowApr: borrowApy,
           baseSupplyApy: 0, //supplyApy,
           totalSupplyApr: 0, //supplyApy,
+          rewardsSupplyApy: 0,
+          rewardsBorrowApy: 0,
           availableLiquidity: new Amount(0, collateralToken.decimals),
           availableLiquidityUsd: 0,
           marketParams: {
-            loanToken: loanToken.address,
-            collateralToken: collateralToken.address,
+            loanToken: marketInfo.loanToken,
+            collateralToken: marketInfo.collateralToken,
             irm: marketInfo.irm,
             lltv: marketInfo.lltv,
             oracle: marketInfo.oracle,
@@ -147,12 +156,19 @@ export async function getMorphoMarketsData(params: {
           market.loanTokenPrice;
       }
 
-      market.totalSupplyApr =
-        market.rewards.reduce((acc, curr) => acc + curr.supplyApr, 0) +
-        market.baseSupplyApy;
-      market.totalBorrowApr =
-        market.rewards.reduce((acc, curr) => acc + curr.borrowApr, 0) +
-        market.baseBorrowApy;
+      market.rewardsSupplyApy = market.rewards.reduce(
+        (acc, curr) => acc + curr.supplyApr,
+        0,
+      );
+
+      market.rewardsBorrowApy = market.rewards.reduce(
+        (acc, curr) => acc + curr.borrowApr,
+        0,
+      );
+
+      market.totalSupplyApr = market.rewardsSupplyApy + market.baseSupplyApy;
+
+      market.totalBorrowApr = market.rewardsBorrowApy + market.baseBorrowApy;
     });
   }
 
@@ -173,6 +189,10 @@ type GetMorphoMarketsRewardsReturnType = {
 async function getMorphoMarketRewards(
   markets: MorphoMarket[],
 ): Promise<GetMorphoMarketsRewardsReturnType[]> {
+  if (markets.length === 0) {
+    return [];
+  }
+
   const query = `
   {
     markets(where: { uniqueKey_in: [${markets.map((market) => `"${market.marketId.toLowerCase()}"`).join(",")}], chainId_in: [${markets.map((market) => market.chainId).join(",")}] }) 
@@ -329,14 +349,15 @@ async function getMorphoMarketRewards(
           const borrowTokenAmountPer1000 =
             (Number.parseFloat(reward.amountPerBorrowedToken) /
               item.loanAsset.priceUsd) *
-              1000 || 0;
+            1000;
+
           const borrowAmount = borrowTokenAmountPer1000 / tokenDecimals;
           return {
             marketId: item.uniqueKey,
             asset: reward.asset,
             supplyApr: 0, //(reward.supplyApr || 0) * 100,
             supplyAmount: 0, //amount,
-            borrowApr: (reward.borrowApr || 0) * 100,
+            borrowApr: (reward.borrowApr || 0) * 100 * -1,
             borrowAmount: borrowAmount,
           };
         }),

package/actions/morpho/markets/getMorphoMarkets.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 { MorphoMarket } from "../../../types/morphoMarket.js";
 import { getMorphoMarketsData } from "./common.js";
 
 export type GetMorphoMarketsParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   includeRewards?: boolean | undefined;
 };
 
@@ -23,8 +24,17 @@ export async function getMorphoMarkets<
 ): GetMorphoMarketsReturnType {
   const environments = getEnvironmentsFromArgs(client, args);
 
-  return getMorphoMarketsData({
+  const logId = logger.start(
+    "getMorphoMarkets",
+    "Starting to get morpho markets...",
+  );
+
+  const result = await getMorphoMarketsData({
     environments: environments,
     includeRewards: args?.includeRewards,
   });
+
+  logger.end(logId);
+
+  return result;
 }

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

@@ -72,6 +72,7 @@ export async function getMorphoMarketUserPositionsData(params: {
     const position = userMarketPositions[index];
 
     const loanToken = params.environment.config.tokens[market.loanToken];
+
     const collateralToken =
       params.environment.config.tokens[market.collateralToken];
 
@@ -79,7 +80,9 @@ export async function getMorphoMarketUserPositionsData(params: {
       position.collateralAssets,
       collateralToken.decimals,
     );
+
     const borrowed = new Amount(position.loanAssets, loanToken.decimals);
+
     const borrowedShares = new Amount(
       position.loanShares,
       loanToken.decimals + 6,

package/actions/morpho/user-positions/getMorphoMarketUserPositions.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 { MorphoMarketUserPosition } from "../../../types/morphoUserPosition.js";
 import { getMorphoMarketUserPositionsData } from "./common.js";
@@ -9,7 +9,7 @@ import { getMorphoMarketUserPositionsData } from "./common.js";
 export type GetMorphoMarketUserPositionsParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   userAddress: Address;
 };
 
@@ -27,12 +27,14 @@ export async function getMorphoMarketUserPositions<
   const environments = getEnvironmentsFromArgs(client, args);
 
   const environmentsUserPositions = await Promise.all(
-    environments.map((environment) => {
-      return getMorphoMarketUserPositionsData({
-        environment,
-        account: args.userAddress,
-      });
-    }),
+    environments
+      .filter((environment) => environment.contracts.morphoViews !== undefined)
+      .map((environment) => {
+        return getMorphoMarketUserPositionsData({
+          environment,
+          account: args.userAddress,
+        });
+      }),
   );
 
   return environmentsUserPositions.flat();

package/actions/morpho/user-positions/getMorphoVaultUserPositions.ts

@@ -1,14 +1,14 @@
 import type { Address, Chain } 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 { MorphoVaultUserPosition } from "../../../types/morphoUserPosition.js";
 import { getMorphoVaultUserPositionsData } from "./common.js";
 
 export type GetMorphoVaultUserPositionsParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   userAddress: Address;
 };
 
@@ -26,12 +26,14 @@ export async function getMorphoVaultUserPositions<
   const environments = getEnvironmentsFromArgs(client, args);
 
   const environmentsUserPositions = await Promise.all(
-    environments.map((environment) => {
-      return getMorphoVaultUserPositionsData({
-        environment,
-        account: args.userAddress,
-      });
-    }),
+    environments
+      .filter((environment) => environment.contracts.morphoViews !== undefined)
+      .map((environment) => {
+        return getMorphoVaultUserPositionsData({
+          environment,
+          account: args.userAddress,
+        });
+      }),
   );
 
   return environmentsUserPositions.flat();