@moonwell-fi/moonwell-sdk 0.2.1 → 0.3.2

package/actions/core/markets/getMarketSnapshots.ts

@@ -0,0 +1,293 @@
+import axios from "axios";
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
+import {
+  Amount,
+  getEnvironmentFromArgs,
+  isStartOfDay,
+} from "../../../common/index.js";
+import type { NetworkParameterType } from "../../../common/types.js";
+import type { Chain, Environment } from "../../../environments/index.js";
+import type { MarketSnapshot } from "../../../types/market.js";
+
+dayjs.extend(utc);
+
+export type GetMarketSnapshotsParameters<
+  environments,
+  network extends Chain | undefined,
+> = NetworkParameterType<environments, network> & {
+  type: "core" | "isolated";
+  marketId: `0x${string}`;
+};
+
+export type GetMarketSnapshotsReturnType = Promise<MarketSnapshot[]>;
+
+export async function getMarketSnapshots<
+  environments,
+  Network extends Chain | undefined,
+>(
+  client: MoonwellClient,
+  args: GetMarketSnapshotsParameters<environments, Network>,
+): GetMarketSnapshotsReturnType {
+  const environment = getEnvironmentFromArgs(client, args);
+
+  if (!environment) {
+    return [];
+  }
+
+  if (args?.type === "core") {
+    return fetchCoreMarketSnapshots(args.marketId, environment);
+  } else {
+    return fetchIsolatedMarketSnapshots(args.marketId, environment);
+  }
+}
+
+async function fetchCoreMarketSnapshots(
+  marketAddress: string,
+  environment: Environment,
+): Promise<MarketSnapshot[]> {
+  const dailyData: MarketDailyData[] = [];
+  let hasNextPage = true;
+  let endCursor: string | undefined;
+
+  interface MarketDailyData {
+    totalBorrows: number;
+    totalBorrowsUSD: number;
+    totalSupplies: number;
+    totalSuppliesUSD: number;
+    timestamp: number;
+  }
+
+  while (hasNextPage) {
+    const result = await axios.post<{
+      data: {
+        marketDailySnapshots: {
+          items: MarketDailyData[];
+          pageInfo: {
+            hasNextPage: boolean;
+            endCursor: string;
+          };
+        };
+      };
+    }>(environment.indexerUrl, {
+      query: `
+          query {
+            marketDailySnapshots (        
+              limit: 1000,
+              orderBy: "timestamp"
+              orderDirection: "desc"
+              where: {marketAddress: "${marketAddress.toLowerCase()}", chainId: ${environment.chainId}}
+              ${endCursor ? `after: "${endCursor}"` : ""}
+            ) {
+              items {
+                totalBorrows
+                totalBorrowsUSD
+                totalSupplies
+                totalSuppliesUSD
+                timestamp
+              }
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+            }
+          }
+        `,
+    });
+
+    dailyData.push(
+      ...result.data.data.marketDailySnapshots.items.filter(
+        (f: { timestamp: number }) => isStartOfDay(f.timestamp),
+      ),
+    );
+    hasNextPage = result.data.data.marketDailySnapshots.pageInfo.hasNextPage;
+    endCursor = result.data.data.marketDailySnapshots.pageInfo.endCursor;
+  }
+
+  if (dailyData.length > 0) {
+    return dailyData.map((point: any) => {
+      const supplied = Number(point.totalSupplies);
+      const borrow = Number(point.totalBorrows);
+
+      const borrowUsd = Number(point.totalBorrowsUSD);
+      const suppliedUsd = Number(point.totalSuppliesUSD);
+
+      let liquidity = supplied - borrow > 0 ? supplied - borrow : 0;
+      let liquidityUsd = supplied - borrow > 0 ? suppliedUsd - borrowUsd : 0;
+      liquidity = Math.max(liquidity, 0);
+      liquidityUsd = Math.max(liquidityUsd, 0);
+
+      const result: MarketSnapshot = {
+        marketId: marketAddress.toLowerCase(),
+        chainId: environment.chainId,
+        timestamp: point.timestamp * 1000,
+        totalSupply: supplied,
+        totalSupplyUsd: suppliedUsd,
+        totalBorrows: borrow,
+        totalBorrowsUsd: borrowUsd,
+        totalLiquidity: liquidity,
+        totalLiquidityUsd: liquidityUsd,
+      };
+
+      return result;
+    });
+  } else {
+    return [];
+  }
+}
+
+async function fetchMorphoGraphQL(
+  query: string,
+  operationName?: string,
+  variables?: any,
+) {
+  try {
+    const response = await axios.post(
+      "https://blue-api.morpho.org/graphql",
+      { query: query, operationName, variables },
+      { timeout: 5000 },
+    );
+
+    if (response.status !== 200 || response.data.errors) {
+      console.log(
+        `Non-200 (${response.statusText}
+        }) or other error from Morpho GraphQL! - ${JSON.stringify(response.data)}`,
+      );
+      return undefined;
+    }
+
+    return response.data.data;
+  } catch (error) {
+    return undefined;
+  }
+}
+
+async function fetchIsolatedMarketSnapshots(
+  marketAddress: string,
+  environment: Environment,
+): Promise<MarketSnapshot[]> {
+  const operationName = "getMarketTotalTimeseries";
+
+  const variables = {
+    options: {
+      startTimestamp: dayjs.utc().subtract(1, "year").unix(),
+      interval: "DAY",
+    },
+  };
+
+  const query = `    
+    query getMarketTotalTimeseries($options: TimeseriesOptions) {
+      marketTotalTimeseries: marketByUniqueKey(
+        chainId: ${environment.chainId}
+        uniqueKey: "${marketAddress.toLowerCase()}"
+      ) {
+        uniqueKey
+        loanAsset {
+          priceUsd
+          decimals
+        }
+        collateralAsset {
+          priceUsd
+          decimals
+        }
+        historicalState {
+          borrowAssets(options: $options) {
+            x
+            y
+          }
+          borrowAssetsUsd(options: $options) {
+            x
+            y
+          }
+          supplyAssets(options: $options) {
+            x
+            y
+          }
+          supplyAssetsUsd(options: $options) {
+            x
+            y
+          }
+          liquidityAssets(options: $options) {
+            x
+            y
+          }
+          liquidityAssetsUsd(options: $options) {
+            x
+            y
+          }
+        }
+      }
+    }`;
+
+  const result = await fetchMorphoGraphQL(query, operationName, variables);
+
+  if (result) {
+    try {
+      const markets: MarketSnapshot[] =
+        result.marketTotalTimeseries.historicalState.borrowAssets.map(
+          (
+            borrowAssets: {
+              x: number;
+              y: number;
+            },
+            index: number,
+          ): MarketSnapshot => {
+            const loanDecimals =
+              result.marketTotalTimeseries.loanAsset.decimals;
+            const collateralPrice =
+              result.marketTotalTimeseries.collateralAsset.priceUsd;
+            const loanPrice = result.marketTotalTimeseries.loanAsset.priceUsd;
+
+            const borrowAssetsUsd =
+              result.marketTotalTimeseries.historicalState.borrowAssetsUsd[
+                index
+              ];
+            const supplyAssets =
+              result.marketTotalTimeseries.historicalState.supplyAssets[index];
+            const supplyAssetsUsd =
+              result.marketTotalTimeseries.historicalState.supplyAssetsUsd[
+                index
+              ];
+            const liquidityAssets =
+              result.marketTotalTimeseries.historicalState.liquidityAssets[
+                index
+              ];
+            const liquidityAssetsUsd =
+              result.marketTotalTimeseries.historicalState.liquidityAssetsUsd[
+                index
+              ];
+
+            return {
+              chainId: environment.chainId,
+              timestamp: borrowAssets.x * 1000,
+              marketId: marketAddress.toLowerCase(),
+              totalBorrows: new Amount(
+                BigInt(borrowAssets.y),
+                Number(loanDecimals),
+              ).value,
+              totalBorrowsUsd: Number(borrowAssetsUsd.y),
+              totalSupply:
+                (new Amount(BigInt(supplyAssets.y), Number(loanDecimals))
+                  .value *
+                  loanPrice) /
+                collateralPrice,
+              totalSupplyUsd: Number(supplyAssetsUsd.y),
+              totalLiquidity:
+                (new Amount(BigInt(liquidityAssets.y), Number(loanDecimals))
+                  .value *
+                  loanPrice) /
+                collateralPrice,
+              totalLiquidityUsd: Number(liquidityAssetsUsd.y),
+            };
+          },
+        );
+
+      return markets;
+    } catch (ex) {
+      return [];
+    }
+  } else {
+    return [];
+  }
+}

package/actions/core/markets/getMarkets.ts

@@ -2,6 +2,7 @@ import type { Chain } from "viem";
 import type { MoonwellClient } from "../../../client/createMoonwellClient.js";
 import { getEnvironmentsFromArgs } from "../../../common/index.js";
 import type { NetworkParameterType } from "../../../common/types.js";
+import * as logger from "../../../logger/console.js";
 import type { Market } from "../../../types/market.js";
 import { getMarketsData } from "./common.js";
 
@@ -21,9 +22,13 @@ export async function getMarkets<
 ): GetMarketsReturnType {
   const environments = getEnvironmentsFromArgs(client, args);
 
+  const logId = logger.start("getMarkets", "Starting to get markets...");
+
   const result = await Promise.all(
     environments.map((environment) => getMarketsData(environment)),
   );
 
+  logger.end(logId);
+
   return result.flat();
 }

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

@@ -67,6 +67,7 @@ export const getUserPositionData = async (params: {
               underlyingToken.decimals,
             )
           : new Amount(0n, underlyingToken.decimals);
+
         const collateralUsd = collateral.value * underlyingPrice;
 
         const result: UserPosition = {

package/actions/core/user-positions/getUserPositions.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 { UserPosition } from "../../../types/userPosition.js";
 import { getUserPositionData } from "./common.js";
 
 export type GetUserPositionsParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   /** User address*/
   userAddress: Address;
 };

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

@@ -128,6 +128,7 @@ export const getUserRewardsData = async (params: {
             reward.supplyRewardsAmount,
             token.decimals,
           );
+
           const borrowRewards = new Amount(
             reward.borrowRewardsAmount,
             token.decimals,

package/actions/core/user-rewards/getUserRewards.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 { UserReward } from "../../../types/userReward.js";
 import { getUserRewardsData } from "./common.js";
@@ -9,7 +9,7 @@ import { getUserRewardsData } from "./common.js";
 export type GetUserRewardsParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   /** User address*/
   userAddress: Address;
 };

package/actions/governance/getCirculatingSupplySnapshots.ts

@@ -0,0 +1,84 @@
+import axios from "axios";
+import type { MoonwellClient } from "../../client/createMoonwellClient.js";
+import { getEnvironmentFromArgs } from "../../common/index.js";
+import type { OptionalNetworkParameterType } from "../../common/types.js";
+import type { Chain } from "../../environments/index.js";
+import type { CirculatingSupplySnapshot } from "../../types/circulatingSupply.js";
+
+export type GetCirculatingSupplySnapshotsParameters<
+  environments,
+  network extends Chain | undefined,
+> = OptionalNetworkParameterType<environments, network>;
+
+export type GetCirculatingSupplySnapshotsReturnType = Promise<
+  CirculatingSupplySnapshot[]
+>;
+
+export async function getCirculatingSupplySnapshots<
+  environments,
+  Network extends Chain | undefined,
+>(
+  client: MoonwellClient,
+  args?: GetCirculatingSupplySnapshotsParameters<environments, Network>,
+): GetCirculatingSupplySnapshotsReturnType {
+  const environment = getEnvironmentFromArgs(client, args);
+
+  if (!environment) {
+    return [];
+  }
+
+  try {
+    const response = await axios.post<{
+      data: {
+        circulatingSupplyDailySnapshots: {
+          items: {
+            chainId: number;
+            tokenAddress: string;
+            circulatingSupply: number;
+            timestamp: number;
+          }[];
+        };
+      };
+    }>(environment.indexerUrl, {
+      query: `
+          {
+            circulatingSupplyDailySnapshots(
+              where: { chainId: ${environment.chainId} }
+              orderBy: "timestamp"
+              orderDirection: "desc"
+              limit: 1000
+            ) {
+              items {
+                chainId
+                tokenAddress
+                circulatingSupply
+                timestamp
+              }
+            }
+          }
+        `,
+    });
+
+    if (
+      response.status === 200 &&
+      response.data?.data?.circulatingSupplyDailySnapshots
+    ) {
+      return response.data?.data?.circulatingSupplyDailySnapshots.items.map(
+        (item) => ({
+          chainId: item.chainId,
+          token: Object.values(environment.config.tokens).find(
+            (token) =>
+              token.address.toLowerCase() === item.tokenAddress.toLowerCase(),
+          )!,
+          circulatingSupply: item.circulatingSupply,
+          timestamp: item.timestamp,
+        }),
+      );
+    } else {
+      return [];
+    }
+  } catch (ex) {
+    console.error("An error occured while fetching getStakingSnapshots...", ex);
+    return [];
+  }
+}

package/actions/governance/getDelegates.ts

@@ -2,7 +2,11 @@ import axios from "axios";
 import { isAddress } from "viem";
 import type { MoonwellClient } from "../../client/createMoonwellClient.js";
 import { HttpRequestError } from "../../common/index.js";
-import { publicEnvironments } from "../../environments/index.js";
+import {
+  type Environment,
+  publicEnvironments,
+} from "../../environments/index.js";
+import * as logger from "../../logger/console.js";
 import type { Delegate } from "../../types/delegate.js";
 
 export type GetDelegatesErrorType = HttpRequestError;
@@ -19,6 +23,8 @@ export async function getDelegates(
 ): GetDelegatesReturnType {
   let users: Delegate[] = [];
 
+  const logId = logger.start("getDelegates", "Starting to get delegates...");
+
   const getUsersPaginated = async (page = 0) => {
     const response = await axios.get<{
       directory_items: {
@@ -91,7 +97,9 @@ export async function getDelegates(
     users: users.map((r) => r.wallet),
   });
   //Get delegate voting powers
-  const envs = Object.values(client.environments);
+  const envs = Object.values(client.environments as Environment[]).filter(
+    (env) => env.contracts.views !== undefined,
+  );
 
   const votingPowers = await Promise.all(
     users.map(async (user) =>
@@ -105,6 +113,8 @@ export async function getDelegates(
     ),
   );
 
+  logger.end(logId);
+
   users = users.map((user, index) => {
     let votingPower: {
       [chainId: string]: number;

package/actions/governance/getDiscussions.ts

@@ -2,6 +2,7 @@ import axios from "axios";
 import { isEqual, uniqWith } from "lodash";
 import type { MoonwellClient } from "../../client/createMoonwellClient.js";
 import { HttpRequestError } from "../../common/index.js";
+import * as logger from "../../logger/console.js";
 import type { Discussion } from "../../types/discussion.js";
 
 export type GetDiscussionsReturnType = Promise<Discussion[]>;
@@ -35,6 +36,11 @@ export async function getDiscussions(
     };
   };
 
+  const logId = logger.start(
+    "getDiscussions",
+    "Starting to get discussions...",
+  );
+
   const moonwellProposalsResult = await axios.get<ForumTopicRequestResponse>(
     "https://forum.moonwell.fi/c/proposals/moonwell-improvement-proposals/9/l/latest.json",
   );
@@ -54,6 +60,8 @@ export async function getDiscussions(
     throw new HttpRequestError(communityProposalsResult.statusText);
   }
 
+  logger.end(logId);
+
   const toType = (item: ForumTopicRequestResponse) => {
     return item.topic_list.topics.map((topic) => {
       const result: Discussion = {

package/actions/governance/getGovernanceTokenInfo.ts

@@ -4,6 +4,7 @@ import {
   type GovernanceToken,
   publicEnvironments,
 } from "../../environments/index.js";
+import * as logger from "../../logger/console.js";
 
 export type GetGovernanceTokenInfoParameters = {
   governanceToken: GovernanceToken;
@@ -20,10 +21,17 @@ export async function getGovernanceTokenInfo(
   _client: MoonwellClient,
   args: GetGovernanceTokenInfoParameters,
 ): GetGovernanceTokenInfoReturnType {
+  const logId = logger.start(
+    "getGovernanceTokenInfo",
+    "Starting to get governance token info...",
+  );
+
   if (args.governanceToken === "WELL") {
     const totalSupply =
       await publicEnvironments.moonbeam.contracts.governanceToken.read.totalSupply();
 
+    logger.end(logId);
+
     return {
       totalSupply: new Amount(totalSupply || 0n, 18),
     };
@@ -31,6 +39,7 @@ export async function getGovernanceTokenInfo(
     const totalSupply =
       await publicEnvironments.moonriver.contracts.governanceToken.read.totalSupply();
 
+    logger.end(logId);
     return {
       totalSupply: new Amount(totalSupply || 0n, 18),
     };

package/actions/governance/getUserStakingInfo.ts

@@ -1,7 +1,7 @@
 import type { Address, Chain } 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 Environment,
   type TokensType,
@@ -12,7 +12,7 @@ import type { UserStakingInfo } from "../../types/staking.js";
 export type GetUserStakingInfoParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   /** User address*/
   userAddress: Address;
 };

package/actions/governance/getUserVoteReceipt.ts

@@ -28,7 +28,7 @@ export async function getUserVoteReceipt<
   client: MoonwellClient,
   args: GetUserVoteReceiptParameters<environments, Network>,
 ): GetUserVoteReceiptReturnType {
-  let { proposalId, userAddress } = args;
+  const { proposalId, userAddress } = args;
 
   const environment = getEnvironmentFromArgs(client, args);
 
@@ -37,12 +37,13 @@ export async function getUserVoteReceipt<
   }
 
   let isMultichain = false;
+  let getReceiptProposalId = proposalId;
 
   if (environment.contracts.multichainGovernor) {
     if (environment.custom?.governance?.proposalIdOffset) {
       if (proposalId > environment.custom?.governance?.proposalIdOffset) {
         isMultichain = true;
-        proposalId =
+        getReceiptProposalId =
           proposalId - environment.custom?.governance?.proposalIdOffset;
       }
     }
@@ -55,7 +56,7 @@ export async function getUserVoteReceipt<
 
     const receipt =
       await environment.contracts.multichainGovernor?.read.getReceipt([
-        BigInt(proposalId),
+        BigInt(getReceiptProposalId),
         userAddress,
       ]);
 
@@ -77,14 +78,14 @@ export async function getUserVoteReceipt<
       if (multichainEnvironment) {
         const receipt =
           await multichainEnvironment.contracts.voteCollector?.read.getReceipt([
-            BigInt(proposalId),
+            BigInt(getReceiptProposalId),
             userAddress,
           ]);
 
         const [hasVoted, voteValue, votes] = receipt || [false, 0, 0];
 
         result.push({
-          chainId: environment.chainId,
+          chainId: multichainEnvironment.chainId,
           proposalId,
           account: userAddress,
           option: voteValue,
@@ -95,7 +96,7 @@ export async function getUserVoteReceipt<
     }
   } else {
     const receipt = await environment.contracts.governor?.read.getReceipt([
-      BigInt(proposalId),
+      BigInt(getReceiptProposalId),
       userAddress,
     ]);
 

package/actions/governance/getUserVotingPowers.ts

@@ -1,14 +1,14 @@
 import { type Address, zeroAddress } 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, GovernanceToken } from "../../environments/index.js";
 import type { UserVotingPowers } from "../../types/userVotingPowers.js";
 
 export type GetUserVotingPowersParameters<
   environments,
   network extends Chain | undefined,
-> = NetworkParameterType<environments, network> & {
+> = OptionalNetworkParameterType<environments, network> & {
   /** Governance token */
   governanceToken: GovernanceToken;