@1delta/margin-fetcher 0.0.11 → 0.0.13

package/src/lending/morpho/convertPublic.ts

@@ -0,0 +1,153 @@
+import { formatUnits } from 'viem'
+import {
+  MorphoGeneralPublicResponse,
+  RewardsMap,
+  GetMarketsResponse,
+} from './types'
+import { apyToApr } from '../user-data/utils'
+import { AdditionalYields } from '../../types'
+import { GenericTokenList } from '../types'
+
+function parseLtv(ltv: number | string) {
+  let str = 0
+  try {
+    str = Number(formatUnits(BigInt(ltv), 18))
+  } catch (e) {}
+  return str
+}
+
+function formatNr(n: string, d: number) {
+  return Number(formatUnits(BigInt(n ?? 0), d))
+}
+
+export function convertMarketsToMorphoResponse(
+  response: GetMarketsResponse,
+  chainId: string,
+  additionalYields: AdditionalYields = {
+    intrinsicYields: {},
+    lenderRewards: {},
+    loaded: true,
+  },
+  tokens: GenericTokenList = {},
+):  { [m: string]: MorphoGeneralPublicResponse }  {
+  const data: { [m: string]: MorphoGeneralPublicResponse } = {}
+
+  response.markets.items.forEach((market) => {
+    const {
+      uniqueKey,
+      lltv,
+      irmAddress,
+      oracleAddress,
+      loanAsset,
+      collateralAsset,
+      state,
+    } = market
+    if (collateralAsset && loanAsset && oracleAddress) {
+      const m = 'MORPHO_BLUE_' + uniqueKey.slice(2).toUpperCase()
+      // @ts-ignore
+      if (!data[m]) data[m] = { data: {} }
+      // 1. LOAN asset entry
+      const loanRewards: RewardsMap = {}
+
+      // state.rewards?.forEach((reward) => {
+      //     loanRewards[reward.asset.address] = {
+      //         depositRate: formatNr(reward.amountPerSuppliedToken, reward.asset.decimals),
+      //         variableBorrowRate: formatNr(reward.amountPerBorrowedToken, reward.asset.decimals),
+      //         stableBorrowRate: 0,
+      //     }
+      // })
+
+      const loanAssetAddress = loanAsset.address.toLowerCase()
+
+      const meta = tokens[loanAssetAddress] ?? loanAsset
+
+      data[m].data[loanAssetAddress] = {
+        poolId: loanAssetAddress,
+        underlying: loanAssetAddress,
+        asset: meta,
+        totalDeposits: formatNr(state.supplyAssets, loanAsset.decimals),
+        totalDebtStable: 0,
+        totalDebt: formatNr(state.borrowAssets, loanAsset.decimals),
+        totalDepositsUSD: Number(state.supplyAssetsUsd),
+        totalDebtStableUSD: 0,
+        totalDebtUSD: Number(state.borrowAssetsUsd),
+        depositRate: apyToApr(Number(state.supplyApy)) * 100,
+        variableBorrowRate: apyToApr(Number(state.borrowApy)) * 100,
+        stableBorrowRate: 0,
+        stakingYield: additionalYields.intrinsicYields[meta?.assetGroup] ?? 0,
+        rewards: Object.keys(loanRewards).length > 0 ? loanRewards : undefined,
+        decimals: loanAsset.decimals,
+        config: {
+          0: {
+            category: 0,
+            borrowCollateralFactor: 0,
+            collateralFactor: 0,
+            borrowFactor: 1,
+          },
+        },
+        collateralActive: false,
+        borrowingEnabled: true,
+        hasStable: false,
+        isActive: true,
+        isFrozen: false,
+      }
+
+      const ltv = parseLtv(lltv)
+
+      const collateralAssetAddress = collateralAsset.address.toLowerCase()
+      const metaCollateral = tokens[collateralAssetAddress] ?? collateralAsset
+      // 2. COLLATERAL asset entry
+      data[m].data[collateralAssetAddress] = {
+        poolId: collateralAssetAddress,
+        underlying: collateralAssetAddress,
+        asset: metaCollateral,
+        totalDeposits: formatNr(
+          state.collateralAssets,
+          collateralAsset.decimals,
+        ),
+        totalDebtStable: 0,
+        totalDebt: 0,
+        totalDepositsUSD: Number(state.collateralAssetsUsd),
+        totalDebtStableUSD: 0,
+        totalDebtUSD: 0,
+        depositRate: 0,
+        variableBorrowRate: 0,
+        stableBorrowRate: 0,
+        stakingYield:
+          additionalYields.intrinsicYields[metaCollateral?.assetGroup] ?? 0,
+        rewards: undefined,
+        decimals: collateralAsset.decimals,
+        config: {
+          0: {
+            category: 0,
+            borrowCollateralFactor: ltv,
+            collateralFactor: ltv,
+            borrowFactor: 1,
+          },
+        },
+        collateralActive: true,
+        borrowingEnabled: false,
+        hasStable: false,
+        isActive: true,
+        isFrozen: false,
+      }
+
+      data[m].params = {
+        market: {
+          lender: m,
+          collateralDecimals: collateralAsset.decimals,
+          loanDecimals: loanAsset.decimals,
+          id: uniqueKey,
+          lltv,
+          oracle: oracleAddress,
+          irm: irmAddress,
+          collateralAddress: collateralAsset.address,
+          loanAddress: loanAsset.address,
+        },
+      }
+      data[m].chainId = chainId
+    }
+  })
+
+  return data
+}

package/src/lending/morpho/fetchPublic.ts

@@ -0,0 +1,80 @@
+
+export const query = (first: number, skip: number, chainId: string) => `
+query GetMarkets {
+  markets(first: ${first}, skip: ${skip}, where:  {
+     chainId_in: [${chainId}],
+     whitelisted: true
+  },
+  orderBy: SupplyAssetsUsd,   
+  orderDirection: Desc
+  ) {
+    items {
+      uniqueKey
+      irmAddress
+      oracleAddress
+      lltv
+      loanAsset {
+        address
+        name
+        symbol
+        decimals
+        priceUsd
+      }
+      collateralAsset {
+        address
+        name
+        symbol
+        decimals
+        priceUsd
+      }
+      state {
+        borrowApy
+        supplyApy
+        price
+        rewards {
+           asset {
+            address
+            name
+            symbol
+            decimals
+          }
+          amountPerBorrowedToken
+          amountPerSuppliedToken
+        }
+        borrowAssets
+        borrowAssetsUsd
+        supplyAssets
+        supplyAssetsUsd
+        collateralAssets
+        collateralAssetsUsd
+      }
+    }
+  }
+}
+`
+
+const BASE_URL = "https://blue-api.morpho.org/graphql"
+
+
+export async function fetchMorphoMarkets(chainId: string) {
+    const requestBody = {
+        query: query(200, 0, chainId),
+        variables: {},
+    };
+    const response = await fetch(BASE_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+        throw new Error(`Network error: ${response.status} - ${response.statusText}`);
+    }
+
+    const data: any = await response.json();
+
+    return data.data
+
+}

package/src/lending/morpho/publicCallBuild.ts

@@ -0,0 +1,11 @@
+import { AdditionalYields } from "../../types"
+import { convertMarketsToMorphoResponse } from "./convertPublic"
+import { fetchMorphoMarkets } from "./fetchPublic"
+
+export async function fetchMorphoPublicData(
+    chainId: string,
+    yields: AdditionalYields = { intrinsicYields: {}, lenderRewards: {}, loaded: true }
+) {
+    const mbData = await fetchMorphoMarkets(chainId)
+    return convertMarketsToMorphoResponse(mbData, chainId, yields)
+}

package/src/lending/morpho/types.ts

@@ -0,0 +1,129 @@
+import { GenericCurrency } from "../types";
+
+
+export type GetMarketsResponse = {
+  markets: {
+    items: {
+      uniqueKey: string;
+      irmAddress: string;
+      oracleAddress: string;
+      lltv: string;
+      loanAsset: {
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        priceUsd: string;
+      };
+      collateralAsset: {
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        priceUsd: string;
+      };
+      state: {
+        borrowApy: string;
+        supplyApy: string;
+        price: string;
+        rewards: {
+          asset: {
+            address: string
+            name: string
+            symbol: string
+            decimals: number
+          }
+          amountPerBorrowedToken: string;
+          amountPerSuppliedToken: string;
+        }[];
+        borrowAssets: string;
+        borrowAssetsUsd: string;
+        supplyAssets: string
+        supplyAssetsUsd: string
+        collateralAssets: string;
+        collateralAssetsUsd: string;
+      };
+    }[];
+  };
+};
+
+export interface BaseYields {
+  // borrow interest rates
+  variableBorrowRate: number
+  stableBorrowRate: number
+  // deposit interest rate
+  depositRate: number
+}
+
+export type RewardsMap = { [rewardId: string]: BaseYields }
+
+
+
+export interface MorphoMarket {
+  /** the 1delta lender enum */
+  lender: string
+  collateralDecimals?: number
+  loanDecimals?: number
+
+
+  /** the market hash */
+  id: string,
+  /** market params */
+  lltv: string;
+  oracle: string;
+  irm: string;
+  collateralAddress: string;
+  loanAddress: string;
+}
+
+
+export interface MorphoGeneralPublicResponse {
+  data: {
+    [tokenSymbol: string]: {
+      poolId: string
+      underlying: string
+      asset: GenericCurrency
+      // token amounts
+      totalDeposits: number;
+      totalDebtStable: 0;
+      totalDebt: number;
+      // USD amounts
+      totalDepositsUSD: number;
+      totalDebtStableUSD: 0;
+      totalDebtUSD: number;
+      // rates
+      depositRate: number;
+      variableBorrowRate: number;
+      stakingYield: number;
+      stableBorrowRate: 0;
+
+      // rewards
+      rewards?: RewardsMap
+
+      // config part
+      decimals: number;
+
+      config: {
+        [0]: {
+          category: number
+          // collateral factors
+          borrowCollateralFactor: number
+          collateralFactor: number
+          borrowFactor: 1
+        }
+      }
+
+      // flags
+      collateralActive: boolean;
+      borrowingEnabled: boolean;
+      hasStable: false;
+      isActive: true;
+      isFrozen: false;
+    }
+  }
+  /** morpho market info */
+  params: {
+    market: MorphoMarket;
+  }
+  chainId: string
+}

package/src/lending/user-data/aave-v3-type/userCallBuild.ts

@@ -1,18 +1,14 @@
 import { Lender } from "@1delta/asset-registry"
 import { Call } from "../../../utils/multicall"
-import { getAaveAssets, getAaveStyleProtocolTokenMap, getAaveTypePoolDataProviderAddress, getAaveTypePoolAddress } from "../../../assets"
-import { getComposerAddress, isYLDR } from "../../../utils"
-
-const fallbackDebtToken = '0x52A1CeB68Ee6b7B5D13E0376A1E0E4423A8cE26e'
+import { getAaveAssets, getAaveTypePoolDataProviderAddress, getAaveTypePoolAddress } from "../../../assets"
+import { isYLDR } from "../../../utils"
 
 const getBaseAaveV3Calls = (
   chainId: string,
   account: string,
   lender: Lender,
   assetsToQuery: string[],
-  aaveTokenMap: any
 ) => {
-  const broker = getComposerAddress(chainId)
   return assetsToQuery.flatMap((tk) => [
     {
       address: getAaveTypePoolDataProviderAddress(chainId, lender),
@@ -24,7 +20,6 @@ const getBaseAaveV3Calls = (
 
 export const buildAaveV3UserCall = (chainId: string, lender: Lender, account: string): Call[] => {
   const assetsToQuery = getAaveAssets(chainId, lender)
-  const aaveTokenMap = getAaveStyleProtocolTokenMap(chainId, lender)
 
   const calls = [
     ...getBaseAaveV3Calls(
@@ -32,7 +27,6 @@ export const buildAaveV3UserCall = (chainId: string, lender: Lender, account: st
       account,
       lender,
       assetsToQuery,
-      aaveTokenMap
     ),
   ]
   if (!isYLDR(lender)) {

package/src/lending/user-data/abis.ts

@@ -1,5 +1,5 @@
 import { Lender } from "@1delta/asset-registry"
-import { isAaveV2Type, isAaveV3Type, isCompoundV3, isInit, isAaveV32Type, isYLDR } from "../../utils"
+import { isAaveV2Type, isAaveV3Type, isCompoundV3, isInit, isAaveV32Type, isYLDR, isMorphoType } from "../../utils"
 import { IncentivesControllerAbi } from "../../abis/lendle/IncentivesController"
 import { RewarderAbi } from "../../abis/aurelius/Rewarder"
 import { AavePoolV3UpgradedAbi } from "../../abis/aave/AavePoolV3Upgraded"
@@ -15,6 +15,8 @@ import { MultiFeeDistributionAbi } from "../../abis/lendle/MultiFeeDistribution"
 import { PullRewardsIncentivesController } from "../../abis/meridian/PullRewardsIncentivesController"
 import { CometRewardsAbi } from "../../abis/compound-v3/CometRewards"
 import { YLDRAbi } from "../../abis/aave-v3/YLDR"
+import { MorphoBlueAbi } from "../../abis/morpho/blue"
+import { MorphoLensAbi } from "../../abis/morpho/lens"
 
 export const getAbi = (lender: Lender) => {
   if (isAaveV2Type(lender as any)) return [
@@ -45,6 +47,7 @@ export const getAbi = (lender: Lender) => {
     ...CometExtAbi,
     ...CometRewardsAbi,
   ]
+  if(isMorphoType(lender)) return [...MorphoBlueAbi, ...MorphoLensAbi]
   if (isInit(lender as any)) return InitLensAbi
   return []
 }

package/src/lending/user-data/compound-v3/userCallParse.ts

@@ -53,6 +53,7 @@ export const getCompoundV3UserDataConverter = (
           depositsUSD: Number(deposits) * price,
           debtStableUSD: 0,
           debt: "0",
+          debtStable: "0",
           debtUSD: 0,
           collateralActive: true,
           // user depos raw

package/src/lending/user-data/fetchUserData.ts

@@ -1,27 +1,39 @@
-import { Call, multicallViemAbiArray } from "../../utils/multicall"
-import { Lender } from "@1delta/asset-registry"
-import { isAaveV2Type, isAaveV3Type, isInit, isYLDR } from "../../utils"
-import { LenderUserQuery } from "./types"
-import { GetEvmClientFunction } from "../../types"
-import { buildAaveV2UserCall } from "./aave-v2-type/userCallBuild"
-import { buildAaveV3UserCall } from "./aave-v3-type/userCallBuild"
-import { buildInitUserCall } from "./init/userCallBuild"
-import { buildCompoundV3UserCall } from "./compound-v3/userCallBuild"
-import { getAbi } from "./abis"
-import { getAaveV2UserDataConverter } from "./aave-v2-type/userCallParse"
-import { getAaveV3UserDataConverter } from "./aave-v3-type/userCallParse"
-import { getInitUserDataConverter } from "./init/userCallParse"
-import { getCompoundV3UserDataConverter } from "./compound-v3/userCallParse"
-import { getYldrUserDataConverter } from "./aave-v3-type/userCallParseYldr"
+import { Call, multicallViemAbiArray } from '../../utils/multicall'
+import { Lender } from '@1delta/asset-registry'
+import {
+  isAaveV2Type,
+  isAaveV3Type,
+  isInit,
+  isMorphoType,
+  isMultiMarket,
+  isYLDR,
+} from '../../utils'
+import { LenderUserQuery, organizeUserQueries } from './types'
+import { GetEvmClientFunction } from '../../types'
+import { buildAaveV2UserCall } from './aave-v2-type/userCallBuild'
+import { buildAaveV3UserCall } from './aave-v3-type/userCallBuild'
+import { buildInitUserCall } from './init/userCallBuild'
+import { buildCompoundV3UserCall } from './compound-v3/userCallBuild'
+import { getAbi } from './abis'
+import { getAaveV2UserDataConverter } from './aave-v2-type/userCallParse'
+import { getAaveV3UserDataConverter } from './aave-v3-type/userCallParse'
+import { getInitUserDataConverter } from './init/userCallParse'
+import { getCompoundV3UserDataConverter } from './compound-v3/userCallParse'
+import { getYldrUserDataConverter } from './aave-v3-type/userCallParseYldr'
+import { buildMorphoUserCallWithLens } from './morpho/userCallBuild'
+import { getMorphoUserDataConverterWithlens } from './morpho/userCallParse'
 
 function buildUserCall(
   chainId: string,
   lender: Lender,
-  account: string
+  account: string,
+  params?: any,
 ) {
   if (isAaveV2Type(lender)) return buildAaveV2UserCall(chainId, lender, account)
   if (isAaveV3Type(lender)) return buildAaveV3UserCall(chainId, lender, account)
   if (isInit(lender)) return buildInitUserCall(chainId, lender, account)
+  if (isMorphoType(lender))
+    return buildMorphoUserCallWithLens(chainId, account, lender, params)
   return buildCompoundV3UserCall(chainId, lender, account)
 }
 
@@ -31,13 +43,63 @@ function getUserDataConverter(
   account: string,
   prices: { [a: string]: number },
   pricesHist: { [a: string]: number },
-  lenderPublicState: any
+  lenderPublicState: any,
+  params?: any,
 ) {
-  if (isYLDR(lender)) return getYldrUserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
-  if (isAaveV2Type(lender)) return getAaveV2UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
-  if (isAaveV3Type(lender)) return getAaveV3UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
-  if (isInit(lender)) return getInitUserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
-  return getCompoundV3UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
+  if (isYLDR(lender))
+    return getYldrUserDataConverter(
+      lender,
+      chainId,
+      account,
+      prices,
+      pricesHist,
+      lenderPublicState?.data?.[lender]?.data,
+    )
+  if (isAaveV2Type(lender))
+    return getAaveV2UserDataConverter(
+      lender,
+      chainId,
+      account,
+      prices,
+      pricesHist,
+      lenderPublicState?.data?.[lender]?.data,
+    )
+  if (isAaveV3Type(lender))
+    return getAaveV3UserDataConverter(
+      lender,
+      chainId,
+      account,
+      prices,
+      pricesHist,
+      lenderPublicState?.data?.[lender]?.data,
+    )
+  if (isInit(lender))
+    return getInitUserDataConverter(
+      lender,
+      chainId,
+      account,
+      prices,
+      pricesHist,
+      lenderPublicState?.data?.[lender]?.data,
+    )
+  if (isMorphoType(lender))
+    return getMorphoUserDataConverterWithlens(
+      lender,
+      chainId,
+      account,
+      params,
+      prices,
+      pricesHist,
+      lenderPublicState?.data,
+    )
+  return getCompoundV3UserDataConverter(
+    lender,
+    chainId,
+    account,
+    prices,
+    pricesHist,
+    lenderPublicState,
+  )
 }
 
 /**
@@ -49,17 +111,23 @@ function getUserDataConverter(
  */
 export const getLenderUserDataResult = async (
   chainId: string,
-  queries: LenderUserQuery[],
-  getEvmClient: GetEvmClientFunction
+  queriesRaw: LenderUserQuery[],
+  getEvmClient: GetEvmClientFunction,
 ): Promise<any[]> => {
   let calls: {
     call: Call
     abi: any
   }[] = []
 
+  const queries = organizeUserQueries(queriesRaw)
   for (const query of queries) {
     const abi = getAbi(query.lender)
-    const callData = buildUserCall(chainId, query.lender, query.account)
+    const callData = buildUserCall(
+      chainId,
+      query.lender,
+      query.account,
+      query.params,
+    )
     const mappedCalls = callData.map((call) => ({ call, abi }))
     calls = [...calls, ...mappedCalls]
   }
@@ -71,7 +139,7 @@ export const getLenderUserDataResult = async (
     getEvmClient,
     true,
     0,
-    3
+    3,
   )
 }
 
@@ -87,12 +155,13 @@ export const getLenderUserDataResult = async (
  */
 export const convertLenderUserDataResult = (
   chainId: string,
-  queries: LenderUserQuery[],
+  queriesRaw: LenderUserQuery[],
   rawResults: any[],
   prices: any,
   pricesHist: any,
-  lenderState: any
+  lenderState: any,
 ): { [lender: string]: any } => {
+  const queries = organizeUserQueries(queriesRaw)
 
   const lenderData: { [lender: string]: any } = {}
   let currentSlice = 0
@@ -103,7 +172,8 @@ export const convertLenderUserDataResult = (
       query.account,
       prices,
       pricesHist,
-      lenderState[chainId]?.data?.[query.lender]?.data
+      lenderState[chainId],
+      query.params,
     )
 
     try {
@@ -111,14 +181,25 @@ export const convertLenderUserDataResult = (
       const convertedData = converter(data)
 
       if (convertedData) {
-        // map it to the user address
-        lenderData[query.lender] = { [query.account.toLowerCase()]: convertedData }
+        if (isMultiMarket(query.lender)) {
+          Object.keys(convertedData).forEach((market) => {
+            lenderData[market] = {
+              // @ts-ignore
+              [query.account.toLowerCase()]: convertedData[market],
+            }
+          })
+        } else {
+          // map it to the user address
+          lenderData[query.lender] = {
+            [query.account.toLowerCase()]: convertedData,
+          }
+        }
       }
     } catch (e) {
-      console.log("Error parsing for", query.lender, "on", chainId, e)
+      console.log('Error parsing for', query.lender, 'on', chainId, e)
     }
     currentSlice += sliceLength
   }
 
   return lenderData
-} 
+}