@1delta/margin-fetcher 0.0.15 → 0.0.17

package/src/prices/main-prices/fetchOracleData.ts

@@ -6,7 +6,7 @@ import { RWADynamicOracleAbi } from '../../abis/oracle/RWADynamicOracle'
 
 import { api3OracleAddresses } from './addresses/api3'
 import { AAVE_V2_LENDERS, ASSET_META, Chain } from '@1delta/asset-registry'
-import { formatEther } from 'viem'
+import { formatEther, formatUnits } from 'viem'
 import { getAaveAssets } from '../../assets'
 import {
   chainlinkOracles,
@@ -19,15 +19,39 @@ import { AAVE_STYLE_ORACLES } from './addresses/aaveOracles'
 import { AAVES_PER_CHAIN } from '../../utils'
 import { GetEvmClientFunction } from '../../types'
 import { parseRawAmount } from '../../utils/parsing'
+import { ProxyOracleAbi } from '../../abis/oracle/ProxyOracle'
+import { MrophoOracleInfo, MrophoOracles } from './addresses/morpho'
 
 export const formatAavePrice = (price: string, isV2 = false): number => {
-  return Number(
-    formatEther(
-      BigInt(price ?? '0') *
+  try {
+    return Number(
+      formatEther(
+        BigInt(price ?? '0') *
+          // 10^(18 - decimals)
+          10n ** (isV2 ? 0n : 10n),
+      ),
+    )
+  } catch {
+    return NaN
+  }
+}
+
+export const formatMorphoPrice = (
+  price: string,
+  collateralDec: number,
+  debtDec: number,
+): number => {
+  try {
+    return Number(
+      formatUnits(
+        BigInt(price ?? '0'),
         // 10^(18 - decimals)
-        10n ** (isV2 ? 0n : 10n),
-    ),
-  )
+        36 + collateralDec - debtDec,
+      ),
+    )
+  } catch {
+    return NaN
+  }
 }
 
 const LENDLE_PAIR_MANTLE = '0x4c57BE599d0e0414785943569E9B6A66dA79Aa6b'
@@ -40,6 +64,10 @@ interface OracleData {
 }
 
 type QueryAave = { oracle: string; assets: string[]; fork: string }
+type QueryMorpho = {
+  oracle: string
+  assets: [string, string, number, number][]
+}
 
 /**
  * Fetches Aave and uniswap V2 oracle data
@@ -67,6 +95,14 @@ export const fetchMainPrices = async (
         handled = [...handled, ...newOnes]
       }
     })
+
+    const morphoQueries = (MrophoOracles[chainId] ?? []).filter(
+      (a) =>
+        !handled.includes(a.collateralAsset) || !handled.includes(a.loanAsset),
+    )
+
+    const morphoCalls = getMorphoCalls(morphoQueries)
+
     const callAave = getAaveCalls(queries)
 
     const [callsChainLink, chainLinkNames] = getChainLinkCalls(chainId)
@@ -85,6 +121,7 @@ export const fetchMainPrices = async (
         ...AaveOracleAbi,
         ...Api3OracleAbi,
         ...RWADynamicOracleAbi,
+        ...ProxyOracleAbi,
       ],
       [
         ...callsChainLink,
@@ -92,6 +129,7 @@ export const fetchMainPrices = async (
         ...uniswapV2Calls,
         ...api3Calls,
         ...rwaCalls,
+        ...morphoCalls,
       ],
       getEvmClient,
     ).then((multicallResult) => {
@@ -140,13 +178,37 @@ export const fetchMainPrices = async (
       )
 
       const rwaData = parseRWADynamicOracleResults(chainId, rwaResult, rwaNames)
-      return {
+
+      const morphoResult = multicallResult.slice(
+        callsChainLink.length +
+          callAave.length +
+          uniswapV2Calls.length +
+          api3Calls.length +
+          rwaCalls.length,
+        callsChainLink.length +
+          callAave.length +
+          uniswapV2Calls.length +
+          api3Calls.length +
+          morphoCalls.length,
+      )
+      const prices = {
         ...uniswapData,
         ...aaveData,
         ...chainLinkData,
         ...api3Data,
         ...rwaData,
       }
+      const morphoData = parseMorphoResults(
+        chainId,
+        morphoResult,
+        morphoQueries,
+        prices,
+      )
+
+      return {
+        ...prices,
+        ...morphoData,
+      }
     })
   })
   promises.push(fetchDefillamaData())
@@ -206,6 +268,21 @@ const getAaveCalls = (query: QueryAave[]) => {
     .flat()
 }
 
+/**
+ * Create calldata for aave oracles
+ * @param chainId network
+ * @param addressesAaveUnderlyings address array
+ * @returns call data
+ */
+const getMorphoCalls = (query: MrophoOracleInfo[] = []) => {
+  if (query.length === 0) return []
+  return query.map(({ oracle }) => ({
+    address: oracle,
+    name: 'price',
+    params: [],
+  }))
+}
+
 /**
  * Create calldata for chainLink oracles
  * @param chainId network
@@ -328,6 +405,41 @@ const parseAaveResults = (
   return prices
 }
 
+const parseMorphoResults = (
+  chainId: string,
+  data: any[],
+  queries: MrophoOracleInfo[],
+  donePrices: any = {},
+) => {
+  let prices: any = {}
+
+  data.forEach((d, i) => {
+    const details = queries[i]
+    const {
+      loanAsset,
+      collateralAsset,
+      loanAssetDecimals,
+      collateralAssetDecimals,
+    } = details
+    const oracleId =
+      ASSET_META[chainId][loanAsset]?.assetGroup ?? chainId + '-' + loanAsset
+    const debtPrice = donePrices[oracleId]
+    const oracleIdCollateral =
+      ASSET_META[chainId][collateralAsset]?.assetGroup ??
+      chainId + '-' + collateralAsset
+    if (debtPrice) {
+      const priceCollateral = formatMorphoPrice(
+        d.toString(),
+        loanAssetDecimals,
+        collateralAssetDecimals,
+      )
+      prices[oracleIdCollateral] = priceCollateral * debtPrice
+    }
+  })
+
+  return prices
+}
+
 /**
  * Parser for aave results in ulticall slice
  * @param chainId network

package/src/types/providers.ts

@@ -7,12 +7,13 @@ export type MulticallRetryFunction = (
   batchSize?: number,
   maxRetries?: number,
   providerId?: number,
-  allowFailure?: boolean
+  allowFailure?: boolean,
+  orverrides?: any,
 ) => Promise<any[]>
 
 export type GetEvmClientFunction = (
   chain: string,
-  rpcId?: number
+  rpcId?: number,
 ) => PublicClient
 
 export interface ProviderDependencies {
@@ -23,4 +24,4 @@ export interface ProviderDependencies {
 export interface OptionalProviderDependencies {
   multicallRetry?: MulticallRetryFunction
   getEvmClient?: GetEvmClientFunction
-} 
+}

package/test/mainPriceMB.test.ts

@@ -0,0 +1,32 @@
+import { describe, it } from 'vitest'
+import { Chain } from '@1delta/asset-registry'
+import { fetchMainPrices } from '../src'
+import { getEvmClient } from '@1delta/providers'
+
+const chainId = Chain.POLYGON_MAINNET
+describe(
+  'find prices',
+  () => {
+    it('should return prices for valid tokens', async () => {
+      const prices = await fetchMainPrices([chainId], getEvmClient)
+
+      prettyPrint(prices)
+    })
+  },
+  { timeout: 10000 },
+)
+
+function prettyPrint(obj: any) {
+  for (const key in obj) {
+    const value = obj[key]
+    const keyStr = `\x1b[1m\x1b[36m${key}:\x1b[0m` // bold cyan
+    if (typeof value === 'object' && value !== null) {
+      if (!Number.isNaN(Number(keyStr))) console.log(`${keyStr}`)
+      console.dir(value, { depth: null, colors: true })
+      console.log(',')
+    } else {
+      console.log(`${keyStr} ${value}`)
+      console.log(',')
+    }
+  }
+}

package/test/morpho.ts

@@ -0,0 +1,66 @@
+import { zeroAddress } from "viem"
+
+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 {
+      oracleAddress
+      loanAsset {
+        address
+        decimals
+      }
+      collateralAsset {
+        address
+        decimals
+      }
+    }
+  }
+}
+`
+
+const BASE_URL = 'https://blue-api.morpho.org/graphql'
+
+export async function fetchMorphoPriceMeta(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 getOracleMeta(data.data)
+}
+
+function getOracleMeta(response: any) {
+  const res: any[] = []
+
+  response.markets.items.forEach((data) => {
+    const oracle = data.oracleAddress
+    const loanAsset = data.loanAsset.address.toLowerCase()
+    const collateralAsset = data.collateralAsset?.address.toLowerCase()
+    const loanAssetDecimals = data.loanAsset.decimals
+    const collateralAssetDecimals = data.collateralAsset?.decimals
+    if (collateralAsset && loanAsset && oracle !== zeroAddress)
+      res.push({ oracle, loanAsset, collateralAsset, loanAssetDecimals, collateralAssetDecimals })
+  })
+  return res
+}

package/test/morphoPrice.test.ts

@@ -0,0 +1,31 @@
+import { describe, it } from 'vitest'
+import { fetchMorphoPriceMeta } from './morpho'
+import { Chain } from '@1delta/asset-registry'
+
+const chainId = Chain.BASE
+describe(
+  'find prices',
+  () => {
+    it('should return prices for valid tokens', async () => {
+      const price = await fetchMorphoPriceMeta(chainId)
+
+      prettyPrint(price)
+    })
+  },
+  { timeout: 10000 },
+)
+
+function prettyPrint(obj: any) {
+  for (const key in obj) {
+    const value = obj[key]
+    const keyStr = `\x1b[1m\x1b[36m${key}:\x1b[0m` // bold cyan
+    if (typeof value === 'object' && value !== null) {
+      if (!Number.isNaN(Number(keyStr))) console.log(`${keyStr}`)
+      console.dir(value, { depth: null, colors: true })
+      console.log(',')
+    } else {
+      console.log(`${keyStr} ${value}`)
+      console.log(',')
+    }
+  }
+}

package/test/userDataAll.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import {
+  getLenderUserDataResult,
+  convertLenderUserDataResult,
+} from '../src/lending/user-data/fetchUserData'
+import { fetchGeneralYields, fetchMainPrices } from '../src'
+import { getEvmClient } from '@1delta/providers'
+import { Chain, Lender } from '@1delta/asset-registry'
+import { LenderUserQuery } from '../src/lending/user-data/types'
+import { fetchMorphoPublicData } from '../src/lending/morpho/publicCallBuild'
+import { prettyPrint } from './utils'
+
+// random user with ETH
+const TEST_ADDRESS = '0xbadA9c382165b31419F4CC0eDf0Fa84f80A3C8E5'
+let prices, yields
+
+async function getUserData(chainId: Chain, lenders: string[]) {
+  const publicData = {
+    data: await fetchMorphoPublicData(chainId),
+  }
+  // Define user queries
+  const queries: LenderUserQuery[] = lenders.map((lender) => ({
+    lender: lender,
+    account: TEST_ADDRESS.toLowerCase(),
+    // params: lenders,
+  }))
+
+  // Fetch raw user data
+  const rawUserData = await getLenderUserDataResult(
+    chainId,
+    queries,
+    getEvmClient,
+  )
+
+  // Convert raw data to structured format
+  const userData = convertLenderUserDataResult(
+    chainId,
+    queries,
+    rawUserData,
+    prices as any,
+    prices as any,
+    { [chainId]: publicData },
+  )
+
+  return { userData, rawUserData, publicData, queries }
+}
+
+describe(
+  'user data fetching',
+  () => {
+    beforeAll(async () => {
+      ;[prices, yields] = await Promise.all([
+        fetchMainPrices([Chain.BASE], getEvmClient),
+        fetchGeneralYields(),
+      ])
+    }, 30000)
+
+    it(
+      'should fetch user data for Morpho on Base',
+      async () => {
+        try {
+          const { userData } = await getUserData(Chain.BASE, [
+            'MORPHO_BLUE_6600AAE6C56D242FA6BA68BD527AFF1A146E77813074413186828FD3F1CDCA91',
+            'MORPHO_BLUE_3A4048C64BA1B375330D376B1CE40E4047D03B47AB4D48AF484EDEC9FEC801BA',
+            Lender.AAVE_V3,
+            Lender.ZEROLEND,
+          ])
+
+          prettyPrint(userData)
+
+          // Basic validation
+          expect(userData).toBeDefined()
+          expect(typeof userData).toBe('object')
+        } catch (error) {
+          console.log('Error fetching Morpho Base data:', error)
+        }
+      },
+      { timeout: 30000 },
+    )
+  },
+  { timeout: 90000 },
+)