@1delta/margin-fetcher 0.0.13 → 0.0.15-0.1

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

@@ -1,496 +0,0 @@
-import { AaveOracleAbi } from '../../abis/oracle/AaveOracle'
-import { UniswapV2PairAbi } from '../../abis/oracle/UniswapV2Pair'
-import { ChainLinkAggregatorAbi } from '../../abis/oracle/ChainLinkAggregator'
-import { Api3OracleAbi } from '../../abis/oracle/Api3Oracle'
-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 { getAaveAssets } from '../../assets'
-import {
-  chainlinkOracles,
-  getChainLinkKeys,
-  ChainlinkAggregatorIndexes,
-} from './addresses/chainlink'
-import { fetchDefillamaData } from '../defillama'
-import { multicallViemAbiArray } from '../../utils/multicall'
-import { AAVE_STYLE_ORACLES } from './addresses/aaveOracles'
-import { AAVES_PER_CHAIN } from '../../utils'
-import { GetEvmClientFunction } from '../../types'
-import { parseRawAmount } from '../../utils/parsing'
-
-export const formatAavePrice = (price: string, isV2 = false): number => {
-  return Number(
-    formatEther(
-      BigInt(price ?? '0') *
-        // 10^(18 - decimals)
-        10n ** (isV2 ? 0n : 10n),
-    ),
-  )
-}
-
-const LENDLE_PAIR_MANTLE = '0x4c57BE599d0e0414785943569E9B6A66dA79Aa6b'
-const AU_PAIR_MANTLE = '0x709503fbb50b10f921e812c48fbd5c5522a0b20c'
-const WMNT_USDT_PAIR = '0x3e5922cd0cec71dc2d60ec8b36aa4c05b7c1672f'
-const RWA_DYNAMIC_ORACLE = '0xA96abbe61AfEdEB0D14a20440Ae7100D9aB4882f'
-
-interface OracleData {
-  [key: string]: number
-}
-
-type QueryAave = { oracle: string; assets: string[]; fork: string }
-
-/**
- * Fetches Aave and uniswap V2 oracle data
- */
-export const fetchMainPrices = async (
-  chainIds: string[],
-  getEvmClient: GetEvmClientFunction,
-): Promise<OracleData> => {
-  let promises = chainIds.map((chainId) => {
-    const aaveForks = AAVES_PER_CHAIN[chainId]
-    let reservesToQuery: { fork: string; assets: string[] }[] = aaveForks.map(
-      (a) => ({ fork: a, assets: getAaveAssets(chainId, a) }),
-    )
-    let handled: string[] = []
-    let queries: QueryAave[] = []
-    reservesToQuery.forEach((e) => {
-      const newOnes = e.assets.filter((a) => !handled.includes(a))
-      if (newOnes.length > 0) {
-        queries.push({
-          assets: newOnes,
-          // @ts-ignore
-          oracle: AAVE_STYLE_ORACLES[e.fork][chainId],
-          fork: e.fork,
-        })
-        handled = [...handled, ...newOnes]
-      }
-    })
-    const callAave = getAaveCalls(queries)
-
-    const [callsChainLink, chainLinkNames] = getChainLinkCalls(chainId)
-
-    const uniswapV2Calls = getUniswapV2Calls(chainId)
-
-    const [api3Calls, api3Names] = getApi3Calls(chainId)
-
-    const [rwaCalls, rwaNames] = getRWADynamicOracleCalls(chainId)
-
-    return multicallViemAbiArray(
-      chainId,
-      [
-        ...ChainLinkAggregatorAbi,
-        ...UniswapV2PairAbi,
-        ...AaveOracleAbi,
-        ...Api3OracleAbi,
-        ...RWADynamicOracleAbi,
-      ],
-      [
-        ...callsChainLink,
-        ...callAave,
-        ...uniswapV2Calls,
-        ...api3Calls,
-        ...rwaCalls,
-      ],
-      getEvmClient,
-    ).then((multicallResult) => {
-      const chainLinkResults = multicallResult.slice(0, callsChainLink.length)
-
-      const aaveResult = multicallResult.slice(
-        callsChainLink.length,
-        callsChainLink.length + callAave.length,
-      )
-
-      const chainLinkData = parseChainLinkResults(
-        chainId,
-        chainLinkResults,
-        chainLinkNames,
-      )
-      // @ts-ignore
-      const aaveData = parseAaveResults(chainId, aaveResult, queries)
-
-      const uniswapResult = multicallResult.slice(
-        callsChainLink.length + callAave.length,
-        callsChainLink.length + callAave.length + uniswapV2Calls.length,
-      )
-
-      const api3Result = multicallResult.slice(
-        callsChainLink.length + callAave.length + uniswapV2Calls.length,
-        callsChainLink.length +
-          callAave.length +
-          uniswapV2Calls.length +
-          api3Calls.length,
-      )
-
-      const uniswapData = parseUniswapV2results(uniswapResult, chainId)
-
-      const api3Data = parseApi3Results(chainId, api3Result, api3Names)
-
-      const rwaResult = multicallResult.slice(
-        callsChainLink.length +
-          callAave.length +
-          uniswapV2Calls.length +
-          api3Calls.length,
-        callsChainLink.length +
-          callAave.length +
-          uniswapV2Calls.length +
-          api3Calls.length +
-          rwaCalls.length,
-      )
-
-      const rwaData = parseRWADynamicOracleResults(chainId, rwaResult, rwaNames)
-      return {
-        ...uniswapData,
-        ...aaveData,
-        ...chainLinkData,
-        ...api3Data,
-        ...rwaData,
-      }
-    })
-  })
-  promises.push(fetchDefillamaData())
-  const result = await Promise.all(promises)
-  let data: any = {}
-  result.forEach((r) => {
-    data = { ...data, ...r }
-  })
-
-  return data
-}
-
-/**
- * Gets the calls foir the uniswap pools
- * @param chainId network id
- * @returns array of calls
- */
-const getUniswapV2Calls = (chainId: string) => {
-  switch (chainId) {
-    case Chain.MANTLE:
-      return [
-        {
-          address: WMNT_USDT_PAIR,
-          name: 'getReserves',
-          params: [],
-        },
-        {
-          address: LENDLE_PAIR_MANTLE,
-          name: 'getReserves',
-          params: [],
-        },
-        {
-          address: AU_PAIR_MANTLE,
-          name: 'getReserves',
-          params: [],
-        },
-      ]
-    default:
-      return []
-  }
-}
-
-/**
- * Create calldata for aave oracles
- * @param chainId network
- * @param addressesAaveUnderlyings address array
- * @returns call data
- */
-const getAaveCalls = (query: QueryAave[]) => {
-  if (query.length === 0) return []
-  return query
-    .map(({ oracle, assets }) => ({
-      address: oracle,
-      name: 'getAssetsPrices',
-      params: [assets],
-    }))
-    .flat()
-}
-
-/**
- * Create calldata for chainLink oracles
- * @param chainId network
- * @param addressesAaveUnderlyings address array
- * @returns call data
- */
-const getChainLinkCalls = (
-  chainId: string,
-): [
-  {
-    address: string
-    name: string
-    params: any[]
-  }[],
-  string[],
-] => {
-  switch (chainId) {
-    case Chain.MANTLE:
-      return [[], []]
-    default: {
-      const keys = getChainLinkKeys(chainId).filter(
-        (k) => k.split('-')[1] === 'USD',
-      )
-      // @ts-ignore
-      const addresses = keys.map((k) => chainlinkOracles[k][chainId])
-      return [
-        addresses.map((tk) => {
-          return {
-            address: tk,
-            name: 'latestRoundData',
-            params: [],
-          }
-        }),
-        keys.map((k) => k.split('-')[0]),
-      ]
-    }
-  }
-}
-
-/**
- * Processes data creeated from fetch through 'getUniswapV2Calls
- * @param data the result data array slice from the multicall
- * @param chainId network id
- * @returns price dictionary asset->number
- */
-const parseUniswapV2results = (data: any[], chainId: string) => {
-  switch (chainId) {
-    case Chain.MANTLE: {
-      let uniswapData: any = {}
-      if (data.length > 0) {
-        const reserves = data[1]
-        // lendle and wmnt are respective token0s
-        const lendleReserve = Number(parseRawAmount(reserves[0].toString(), 18))
-        const wmntReserve = Number(parseRawAmount(reserves[1].toString(), 18))
-
-        const auReserves = data[2]
-        const auReserve = Number(parseRawAmount(auReserves[1].toString(), 18))
-        const wmntReserve_au = Number(
-          parseRawAmount(auReserves[0].toString(), 18),
-        )
-
-        const reservesWmntUsdt = data[0]
-        const usdtReserve = Number(
-          parseRawAmount(reservesWmntUsdt[0].toString(), 6),
-        )
-        const wmnt2Reserve = Number(
-          parseRawAmount(reservesWmntUsdt[1].toString(), 18),
-        )
-        const lendPrice =
-          (wmntReserve / lendleReserve / wmnt2Reserve) * usdtReserve
-        const auPrice =
-          (wmntReserve_au / auReserve / wmnt2Reserve) * usdtReserve
-        uniswapData['LEND'] = lendPrice
-        uniswapData['AU'] = auPrice
-      }
-      return uniswapData
-    }
-    default:
-      return {}
-  }
-}
-
-function lowDecimalOracle(chainId: string, fork: string) {
-  // some chains only have high decimal oracles
-  if (chainId === Chain.AVALANCHE_C_CHAIN || chainId === Chain.MODE) {
-    return false
-  }
-  // otherwise, it depends on whether it is aave V3
-  return AAVE_V2_LENDERS.includes(fork as any)
-}
-
-/**
- * Parser for aave results in ulticall slice
- * @param chainId network
- * @param data result array slice
- * @param assetName asset names (aligned with the originall addresses called)
- * @returns price mapping asset->number
- */
-const parseAaveResults = (
-  chainId: string,
-  data: any[],
-  queries: QueryAave[],
-) => {
-  let prices: any = {}
-
-  data.forEach((d, i) => {
-    const details = queries[i]
-    details.assets.forEach((a, j) => {
-      const oracleId =
-        ASSET_META[chainId][a]?.assetGroup ??
-        ASSET_META[chainId]?.[a]?.symbol ??
-        chainId + '-' + a
-      prices[oracleId] = formatAavePrice(
-        d[j].toString(),
-        lowDecimalOracle(chainId, details.fork as any),
-      )
-    })
-  })
-
-  return prices
-}
-
-/**
- * Parser for aave results in ulticall slice
- * @param chainId network
- * @param data result array slice
- * @param assetName asset names (aligned with the originall addresses called)
- * @returns price mapping asset->number
- */
-const parseChainLinkResults = (
-  chainId: string,
-  data: any[],
-  assetName: string[],
-) => {
-  switch (chainId) {
-    default: {
-      return Object.assign(
-        {},
-        ...data.map((entry, index) => {
-          return {
-            [assetName[index]]: Number(
-              parseRawAmount(
-                entry?.[ChainlinkAggregatorIndexes.answer]?.toString() ?? '0',
-                8,
-              ),
-            ),
-          }
-        }),
-      )
-    }
-  }
-}
-
-/**
- * Create calldata for api3 oracles
- * @param chainId network
- * @returns call data
- */
-const getApi3Calls = (
-  chainId: string,
-): [
-  {
-    address: string
-    name: string
-    params: any[]
-  }[],
-  string[],
-] => {
-  switch (chainId) {
-    case Chain.MANTLE: {
-      const keys = ['WETH', 'METH', 'FBTC', 'CMETH']
-      const addresses = keys.map((k) => api3OracleAddresses[chainId][k])
-      return [
-        addresses.map((tk) => {
-          return {
-            address: tk,
-            name: 'read',
-            params: [],
-          }
-        }),
-        keys,
-      ]
-    }
-    default:
-      return [[], []]
-  }
-}
-
-/**
- * Parser for api3 results in multicall slice
- * @param chainId network
- * @param data result array slice
- * @param assetName asset names (aligned with the originall addresses called)
- * @returns price mapping asset->number
- */
-const parseApi3Results = (
-  chainId: string,
-  data: any[],
-  assetName: string[],
-) => {
-  switch (chainId) {
-    case Chain.MANTLE: {
-      let prices = Object.assign(
-        {},
-        ...data.map((entry, index) => {
-          return {
-            [assetName[index]]: Number(
-              parseRawAmount(entry?.[0]?.toString() ?? '0', 18),
-            ),
-          }
-        }),
-      )
-      // METH is given in mETH/WETH
-      prices['METH'] = prices['METH'] * prices['WETH']
-      prices['CMETH'] = prices['CMETH'] * prices['METH']
-      return prices
-    }
-    default: {
-      return {}
-    }
-  }
-}
-
-/**
- * Create calldata for RWADynamicOracle (wrap rate for musd/usdy)
- * @param chainId network
- * @returns call data
- */
-const getRWADynamicOracleCalls = (
-  chainId: string,
-): [
-  {
-    address: string
-    name: string
-    params: any[]
-  }[],
-  string[],
-] => {
-  switch (chainId) {
-    case Chain.MANTLE: {
-      const keys = ['USDY_MUSD']
-      return [
-        [
-          {
-            address: RWA_DYNAMIC_ORACLE,
-            name: 'getPrice',
-            params: [],
-          },
-        ],
-        keys,
-      ]
-    }
-    default:
-      return [[], []]
-  }
-}
-
-/**
- * Parser for RWADynamicOracle (wrap rate for musd/usdy) results in multicall slice
- * @param chainId network
- * @param data result array slice
- * @param assetName asset names (aligned with the originall addresses called)
- * @returns price mapping asset->number
- */
-const parseRWADynamicOracleResults = (
-  chainId: string,
-  data: any[],
-  assetName: string[],
-) => {
-  switch (chainId) {
-    case Chain.MANTLE: {
-      let prices = Object.assign(
-        {},
-        ...data.map((entry, index) => {
-          return {
-            [assetName[index]]: Number(
-              parseRawAmount(entry?.toString() ?? '0', 18),
-            ),
-          }
-        }),
-      )
-      return prices
-    }
-    default: {
-      return {}
-    }
-  }
-}

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

@@ -1 +0,0 @@
-export * from "./fetchOracleData"

package/src/types/apiReturnType.ts

@@ -1,80 +0,0 @@
-export interface BaseYields {
-  // borrow interest rates
-  variableBorrowRate: number
-  stableBorrowRate: number
-  // deposit interest rate
-  depositRate: number
-}
-
-export type RewardsMap = { [rewardId: string]: BaseYields }
-
-export interface LenderYields extends BaseYields {
-  // staking
-  stakingYield: number
-
-  // rewards
-  rewards?: RewardsMap
-}
-
-export interface ConfigEntry {
-  category: number;
-  borrowCollateralFactor: number;
-  collateralFactor: number;
-  borrowFactor: number;
-}
-
-interface PoolConfig {
-  [category: number]: ConfigEntry;
-}
-
-interface EMode {
-  category: number;
-  label: string;
-  borrowCollateralFactor: number;
-  collateralFactor: number;
-  borrowFactor: number;
-}
-
-export interface PoolData {
-  poolId: string;
-  underlying: string;
-  totalDeposits: string;
-  totalDebtStable: string;
-  totalDebt: string;
-  totalLiquidity: number;
-  totalDepositsUSD: number;
-  totalDebtStableUSD: number;
-  totalDebtUSD: number;
-  totalLiquidityUSD: number;
-  depositRate: number;
-  variableBorrowRate: number;
-  stableBorrowRate: number;
-  stakingYield: number;
-  rewards: RewardsMap;
-  decimals: number;
-  config: PoolConfig;
-  collateralActive: boolean;
-  borrowingEnabled: boolean;
-  hasStable: boolean;
-  isActive: boolean;
-  isFrozen: boolean;
-  eMode: EMode;
-  borrowCap: number;
-  supplyCap: number;
-  debtCeiling: string;
-}
-
-export type LenderData = {
-  [chainId: string]: {
-    data: {
-      [lender: string]: {
-        data: {
-          [poolId: string]: PoolData
-        },
-        eModes: { [modeId: number]: EMode }
-        chainId: string
-      }
-    },
-    lastFetched: number
-  }
-}

package/src/types/index.ts

@@ -1,38 +0,0 @@
-export * from "./apiReturnType"
-
-export interface ParsedResponse {
-  price: number
-  time: number
-}
-export interface ChainLinkResponse extends ParsedResponse {
-  roundId: number
-}
-
-export enum ChainlinkAggregatorIndexes {
-  roundId = 0,
-  answer,
-  startedAt,
-  updatedAt,
-  answeredInRound
-}
-
-interface LenderRewardsEntry {
-  deposit: number
-  borrow: number
-}
-
-export type LenderRewardsMap = { [key: string]: LenderRewardsEntry }
-export type NumberMap = { [key: string]: number }
-export type FullLenderRewardsMap = { [chainId: string]: { [lender: string]: LenderRewardsMap } }
-export type AdditionalYields = {
-  intrinsicYields: NumberMap
-  lenderRewards: FullLenderRewardsMap
-  loaded: boolean
-}
-export declare interface GeneralCall {
-  address: string // Address of the contract
-  name: string // Function name on the contract (example: balanceOf)
-  params?: any[] // Function params
-}
-
-export * from "./providers"

package/src/types/providers.ts

@@ -1,26 +0,0 @@
-import { PublicClient } from 'viem'
-
-export type MulticallRetryFunction = (
-  chain: string,
-  calls: any[],
-  abi: any,
-  batchSize?: number,
-  maxRetries?: number,
-  providerId?: number,
-  allowFailure?: boolean
-) => Promise<any[]>
-
-export type GetEvmClientFunction = (
-  chain: string,
-  rpcId?: number
-) => PublicClient
-
-export interface ProviderDependencies {
-  multicallRetry: MulticallRetryFunction
-  getEvmClient: GetEvmClientFunction
-}
-
-export interface OptionalProviderDependencies {
-  multicallRetry?: MulticallRetryFunction
-  getEvmClient?: GetEvmClientFunction
-}