@1delta/margin-fetcher 0.0.34 → 0.0.36

package/src/lending/morpho/utils/mathLib.ts

@@ -0,0 +1,434 @@
+import { rateToApy, SECONDS_PER_YEAR } from './parsers'
+
+export type RoundingDirection = 'Up' | 'Down'
+
+/**
+ * Library to manage fixed-point arithmetic.
+ * https://github.com/morpho-org/morpho-blue/blob/main/src/libraries/MathLib.sol
+ */
+export namespace MathLib {
+  export const WAD = 1_000000000000000000n
+  export const RAY = 1_000000000000000000000000000n
+
+  export const MAX_UINT_256 = maxUint(256)
+  export const MAX_UINT_160 = maxUint(160)
+  export const MAX_UINT_128 = maxUint(128)
+  export const MAX_UINT_48 = maxUint(48)
+
+  export function maxUint(nBits: number) {
+    if (nBits % 4 !== 0) throw new Error(`Invalid number of bits: ${nBits}`)
+
+    return BigInt(`0x${'f'.repeat(nBits / 4)}`)
+  }
+
+  /**
+   * Returns the absolute value of a number
+   * @param a The number
+   */
+  export function abs(a: bigint) {
+    a = BigInt(a)
+
+    return a >= 0 ? a : -a
+  }
+
+  /**
+   * Returns the smallest number given as param
+   * @param x The first number
+   * @param y The second number
+   */
+  export function min(...xs: bigint[]) {
+    return xs.map(BigInt).reduce((x, y) => (x <= y ? x : y))
+  }
+
+  /**
+   * Returns the greatest number given as param
+   * @param x The first number
+   * @param y The second number
+   */
+  export function max(...xs: bigint[]) {
+    return xs.map(BigInt).reduce((x, y) => (x <= y ? y : x))
+  }
+
+  /**
+   * Returns the subtraction of b from a, floored to zero if negative
+   * @param x The first number
+   * @param y The second number
+   */
+  export function zeroFloorSub(x: bigint, y: bigint) {
+    x = BigInt(x)
+    y = BigInt(y)
+
+    return x <= y ? 0n : x - y
+  }
+
+  /**
+   * Perform the WAD-based multiplication of 2 numbers, rounded down
+   * @param x The first number
+   * @param y The second number
+   */
+  export function wMulDown(x: bigint, y: bigint) {
+    return MathLib.wMul(x, y, 'Down')
+  }
+
+  /**
+   * Perform the WAD-based multiplication of 2 numbers, rounded up
+   * @param x The first number
+   * @param y The second number
+   */
+  export function wMulUp(x: bigint, y: bigint) {
+    return MathLib.wMul(x, y, 'Up')
+  }
+
+  /**
+   * Perform the WAD-based multiplication of 2 numbers with a provided rounding direction
+   * @param x The first number
+   * @param y The second number
+   */
+  export function wMul(x: bigint, y: bigint, rounding: RoundingDirection) {
+    return MathLib.mulDiv(x, y, MathLib.WAD, rounding)
+  }
+
+  /**
+   * Perform the WAD-based division of 2 numbers, rounded down
+   * @param x The first number
+   * @param y The second number
+   */
+  export function wDivDown(x: bigint, y: bigint) {
+    return MathLib.wDiv(x, y, 'Down')
+  }
+
+  /**
+   * Perform the WAD-based multiplication of 2 numbers, rounded up
+   * @param x The first number
+   * @param y The second number
+   */
+  export function wDivUp(x: bigint, y: bigint) {
+    return MathLib.wDiv(x, y, 'Up')
+  }
+
+  /**
+   * Perform the WAD-based multiplication of 2 numbers with a provided rounding direction
+   * @param x The first number
+   * @param y The second number
+   */
+  export function wDiv(x: bigint, y: bigint, rounding: RoundingDirection) {
+    return MathLib.mulDiv(x, MathLib.WAD, y, rounding)
+  }
+
+  /**
+   * Multiply two numbers and divide by a denominator, rounding down the result
+   * @param x The first number
+   * @param y The second number
+   * @param denominator The denominator
+   */
+  export function mulDivDown(x: bigint, y: bigint, denominator: bigint) {
+    x = BigInt(x)
+    y = BigInt(y)
+    denominator = BigInt(denominator)
+    if (denominator === 0n) throw Error('MathLib: DIVISION_BY_ZERO')
+
+    return (x * y) / denominator
+  }
+
+  /**
+   * Multiply two numbers and divide by a denominator, rounding up the result
+   * @param x The first number
+   * @param y The second number
+   * @param denominator The denominator
+   */
+  export function mulDivUp(x: bigint, y: bigint, denominator: bigint) {
+    x = BigInt(x)
+    y = BigInt(y)
+    denominator = BigInt(denominator)
+    if (denominator === 0n) throw Error('MathLib: DIVISION_BY_ZERO')
+
+    const roundup = (x * y) % denominator > 0 ? 1n : 0n
+
+    return (x * y) / denominator + roundup
+  }
+
+  export function mulDiv(
+    x: bigint,
+    y: bigint,
+    denominator: bigint,
+    rounding: RoundingDirection,
+  ) {
+    return MathLib[`mulDiv${rounding}`](x, y, denominator)
+  }
+
+  /**
+   * The sum of the first three non-zero terms of a Taylor expansion of e^(nx) - 1,
+   * to approximate a continuously compounded interest rate.
+   *
+   * @param x The base of the exponent
+   * @param n The exponent
+   */
+  export function wTaylorCompounded(x: bigint, n: bigint) {
+    const firstTerm = BigInt(x) * BigInt(n)
+    const secondTerm = MathLib.mulDivDown(
+      firstTerm,
+      firstTerm,
+      2n * MathLib.WAD,
+    )
+    const thirdTerm = MathLib.mulDivDown(
+      secondTerm,
+      firstTerm,
+      3n * MathLib.WAD,
+    )
+
+    return firstTerm + secondTerm + thirdTerm
+  }
+
+  /**
+   * Converts a WAD-based quantity to a RAY-based quantity.
+   * @param x The WAD-based quantity.
+   */
+  export function wToRay(x: bigint) {
+    return BigInt(x) * 1_000000000n
+  }
+
+  /**
+   * Returns the market's utilization rate (scaled by WAD).
+   * @param market The market state.
+   */
+  export function getUtilization({
+    totalSupplyAssets,
+    totalBorrowAssets,
+  }: {
+    totalSupplyAssets: bigint
+    totalBorrowAssets: bigint
+  }) {
+    if (totalSupplyAssets === 0n) {
+      if (totalBorrowAssets > 0n) return MathLib.MAX_UINT_256
+
+      return 0n
+    }
+
+    return MathLib.wDivDown(totalBorrowAssets, totalSupplyAssets)
+  }
+
+  /**
+   * The market's instantaneous supply-side Annual Percentage Yield (APY) at the given timestamp,
+   * if the state remains unchanged (not accrued) (scaled by WAD).
+   * @param timestamp The timestamp at which to calculate the supply APY.
+   * Must be greater than or equal to `lastUpdate`.
+   * Defaults to `Time.timestamp()` (returns the current supply APY).
+   */
+  export function getSupplyApy(
+    borrowApy: bigint,
+    utilization: bigint,
+    fee: bigint,
+  ) {
+    if (!utilization) return 0n
+    return MathLib.wMulUp(
+      MathLib.wMulDown(borrowApy, utilization),
+      MathLib.WAD - fee,
+    )
+  }
+
+  /**
+   * Returns the rates that _would_ apply to interest accrual for borrowers of this market,
+   * if `accrueInterest` was called at the given timestamp (scaled by WAD).
+   * @param timestamp The timestamp at which to calculate the accrual borrow rate.
+   * Must be greater than or equal to `lastUpdate`.
+   * Defaults to `Time.timestamp()` (returns the current accrual borrow rate).
+   */
+  function getAccrualBorrowRates(
+    rateAtTarget: bigint | null,
+    utilization: bigint,
+    _timestamp: number = Math.floor(Date.now() / 1000),
+    _lastUpdate: number,
+  ):
+    | {
+        elapsed: bigint
+        avgBorrowRate: bigint
+        endBorrowRate: bigint
+        endRateAtTarget?: bigint
+      }
+    | undefined {
+    const timestamp = BigInt(_timestamp)
+
+    const elapsed = timestamp - BigInt(_lastUpdate)
+    if (elapsed < 0n) return undefined
+
+    if (rateAtTarget == null)
+      return {
+        elapsed,
+        avgBorrowRate: 0n,
+        endBorrowRate: 0n,
+      }
+
+    return {
+      elapsed,
+      ..._getBorrowRate(utilization, rateAtTarget, elapsed),
+    }
+  }
+
+  /**
+   */
+  function getEndBorrowRate(
+    rateAtTarget: bigint | null,
+    utilization: bigint,
+    _timestamp: number = Math.floor(Date.now() / 1000),
+    _lastUpdate: number,
+  ) {
+    return getAccrualBorrowRates(
+      rateAtTarget,
+      utilization,
+      _timestamp,
+      _lastUpdate,
+    )?.endBorrowRate
+  }
+
+  export function getBorrowApy(
+    rateAtTarget: bigint | null,
+    utilization: bigint,
+    _timestamp: number = Math.floor(Date.now() / 1000),
+    _lastUpdate: number,
+  ) {
+    const borrowRate = getEndBorrowRate(
+      rateAtTarget,
+      utilization,
+      _timestamp,
+      _lastUpdate,
+    )
+
+    return borrowRate ? rateToApy(borrowRate) : 0n
+  }
+
+  const CURVE_STEEPNESS = 4_000000000000000000n
+  const TARGET_UTILIZATION = 90_0000000000000000n
+  const INITIAL_RATE_AT_TARGET = 4_0000000000000000n / SECONDS_PER_YEAR
+  const ADJUSTMENT_SPEED = 50_000000000000000000n / SECONDS_PER_YEAR
+  const MIN_RATE_AT_TARGET = 10_00000000000000n / SECONDS_PER_YEAR
+  const MAX_RATE_AT_TARGET = 2_000000000000000000n / SECONDS_PER_YEAR
+
+  /**
+   * ln(2), scaled by WAD.
+   */
+  const LN_2_INT = 693147180559945309n
+
+  /**
+   * ln(1e-18), scaled by WAD.
+   */
+  const LN_WEI_INT = -41_446531673892822312n
+
+  /**
+   * Above this bound, `wExp` is clipped to avoid overflowing when multiplied with 1 ether.
+   * This upper bound corresponds to: ln(type(int256).max / 1e36) (scaled by WAD, floored).
+   */
+  const WEXP_UPPER_BOUND = 93_859467695000404319n
+
+  /**
+   * The value of wExp(`WEXP_UPPER_BOUND`).
+   */
+  const WEXP_UPPER_VALUE =
+    57716089161558943949701069502944508345128_422502756744429568n
+
+  export function wExp(x: bigint) {
+    x = BigInt(x)
+
+    // If x < ln(1e-18) then exp(x) < 1e-18 so it is rounded to zero.
+    if (x < LN_WEI_INT) return 0n
+    // `wExp` is clipped to avoid overflowing when multiplied with 1 ether.
+    if (x >= WEXP_UPPER_BOUND) return WEXP_UPPER_VALUE
+
+    // Decompose x as x = q * ln(2) + r with q an integer and -ln(2)/2 <= r <= ln(2)/2.
+    // q = x / ln(2) rounded half toward zero.
+    const roundingAdjustment = x < 0n ? -(LN_2_INT / 2n) : LN_2_INT / 2n
+    const q = (x + roundingAdjustment) / LN_2_INT
+    const r = x - q * LN_2_INT
+
+    // Compute e^r with a 2nd-order Taylor polynomial.
+    const expR = MathLib.WAD + r + (r * r) / MathLib.WAD / 2n
+
+    // Return e^x = 2^q * e^r.
+    if (q >= 0n) return expR << q
+    return expR >> -q
+  }
+
+  export function _getBorrowRate(
+    startUtilization: bigint,
+    startRateAtTarget: bigint,
+    elapsed: bigint,
+  ) {
+    startUtilization = BigInt(startUtilization)
+    startRateAtTarget = BigInt(startRateAtTarget)
+    elapsed = BigInt(elapsed)
+
+    const errNormFactor =
+      startUtilization > TARGET_UTILIZATION
+        ? MathLib.WAD - TARGET_UTILIZATION
+        : TARGET_UTILIZATION
+    const err = MathLib.wDivDown(
+      startUtilization - TARGET_UTILIZATION,
+      errNormFactor,
+    )
+
+    let avgRateAtTarget: bigint
+    let endRateAtTarget: bigint
+
+    if (startRateAtTarget === 0n) {
+      // First interaction.
+      avgRateAtTarget = INITIAL_RATE_AT_TARGET
+      endRateAtTarget = INITIAL_RATE_AT_TARGET
+    } else {
+      // The speed is assumed constant between two updates, but it is in fact not constant because of interest.
+      // So the rate is always underestimated.
+      const speed = MathLib.wMulDown(ADJUSTMENT_SPEED, err)
+      const linearAdaptation = speed * elapsed
+
+      if (linearAdaptation === 0n) {
+        // If linearAdaptation == 0, avgRateAtTarget = endRateAtTarget = startRateAtTarget;
+        avgRateAtTarget = startRateAtTarget
+        endRateAtTarget = startRateAtTarget
+      } else {
+        // Non negative because MIN_RATE_AT_TARGET > 0.
+        const _newRateAtTarget = (linearAdaptation: bigint) =>
+          MathLib.min(
+            MathLib.max(
+              MathLib.wMulDown(startRateAtTarget, wExp(linearAdaptation)),
+              MIN_RATE_AT_TARGET,
+            ),
+            MAX_RATE_AT_TARGET,
+          )
+
+        // Formula of the average rate that should be returned to Morpho Blue:
+        // avg = 1/T * ∫_0^T curve(startRateAtTarget*exp(speed*x), err) dx
+        // The integral is approximated with the trapezoidal rule:
+        // avg ~= 1/T * Σ_i=1^N [curve(f((i-1) * T/N), err) + curve(f(i * T/N), err)] / 2 * T/N
+        // Where f(x) = startRateAtTarget*exp(speed*x)
+        // avg ~= Σ_i=1^N [curve(f((i-1) * T/N), err) + curve(f(i * T/N), err)] / (2 * N)
+        // As curve is linear in its first argument:
+        // avg ~= curve([Σ_i=1^N [f((i-1) * T/N) + f(i * T/N)] / (2 * N), err)
+        // avg ~= curve([(f(0) + f(T))/2 + Σ_i=1^(N-1) f(i * T/N)] / N, err)
+        // avg ~= curve([(startRateAtTarget + endRateAtTarget)/2 + Σ_i=1^(N-1) f(i * T/N)] / N, err)
+        // With N = 2:
+        // avg ~= curve([(startRateAtTarget + endRateAtTarget)/2 + startRateAtTarget*exp(speed*T/2)] / 2, err)
+        // avg ~= curve([startRateAtTarget + endRateAtTarget + 2*startRateAtTarget*exp(speed*T/2)] / 4, err)
+        endRateAtTarget = _newRateAtTarget(linearAdaptation)
+        avgRateAtTarget =
+          (startRateAtTarget +
+            endRateAtTarget +
+            2n * _newRateAtTarget(linearAdaptation / 2n)) /
+          4n
+      }
+    }
+
+    // Non negative because 1 - 1/C >= 0, C - 1 >= 0.
+    const coeff =
+      err < 0
+        ? MathLib.WAD - MathLib.wDivDown(MathLib.WAD, CURVE_STEEPNESS)
+        : CURVE_STEEPNESS - MathLib.WAD
+
+    const _curve = (rateAtTarget: bigint) =>
+      MathLib.wMulDown(MathLib.wMulDown(coeff, err) + MathLib.WAD, rateAtTarget)
+
+    // Non negative if avgRateAtTarget >= 0 because if err < 0, coeff <= 1.
+    return {
+      avgBorrowRate: _curve(avgRateAtTarget),
+      endBorrowRate: _curve(endRateAtTarget),
+      endRateAtTarget,
+    }
+  }
+}

package/src/lending/morpho/utils/parsers.ts

@@ -0,0 +1,53 @@
+import { formatEther, formatUnits, parseUnits } from 'viem'
+
+export const SECONDS_PER_YEAR = 31_556_952n
+
+// Alternative to Number.toFixed that doesn't use scientific notation for excessively small or large numbers.
+const toFixed = (x: number, decimals: number) =>
+  new Intl.NumberFormat('en-US', {
+    style: 'decimal',
+    useGrouping: false,
+    maximumFractionDigits: decimals,
+    minimumFractionDigits: decimals,
+  }).format(x)
+
+const safeParseNumber = (value: number, decimals = 18) =>
+  safeParseUnits(toFixed(value, decimals), decimals)
+
+const safeParseUnits = (strValue: string, decimals = 18) => {
+  if (!/[-+]?[0-9]*\.?[0-9]+/.test(strValue))
+    throw Error(`invalid number: ${strValue}`)
+
+  let [whole, dec = ''] = strValue.split('.')
+
+  dec = dec.slice(0, decimals)
+
+  return parseUnits(
+    [whole || '0', dec].filter((v) => v.length > 0).join('.'),
+    decimals,
+  )
+}
+
+/**
+ * Returns the per-second rate continuously compounded over a year (scaled by WAD),
+ * as calculated in Morpho Blue assuming the market is frequently accrued onchain.
+ * @param rate The per-second rate to compound annually (scaled by WAD).
+ */
+// TODO: return a Number for APYs.
+export function rateToApy(rate: bigint) {
+  return safeParseNumber(
+    Math.expm1(+formatEther(BigInt(rate) * SECONDS_PER_YEAR)),
+  )
+}
+
+export function parseLtv(ltv: bigint | number | string) {
+  let str = 0
+  try {
+    str = Number(formatUnits(BigInt(ltv), 18))
+  } catch (e) {}
+  return str
+}
+
+export function formatNr(n: string | bigint, d: number) {
+  return Number(formatUnits(BigInt(n ?? 0), d))
+}

package/src/lending/user-data/aave-v2-type/userCallParse.ts

@@ -375,8 +375,8 @@ function createAaveV2Entry(
   const priceHist = pricesHist?.[key] ?? price
 
   const dataForAsset = {
-    poolId: asset,
-    underlying: asset,
+    poolId: asset.address,
+    underlying: asset.address,
     deposits: currentATokenBalance,
     depositsRaw: currentATokenBalanceRaw,
     debtStable: currentStableDebt,

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

@@ -114,8 +114,8 @@ function createAaveV3Entry(
   const priceHist = pricesHist?.[key] ?? price
 
   const dataForAsset = {
-    poolId: asset,
-    underlying: asset,
+    poolId: asset.address,
+    underlying: asset.address,
     deposits: currentATokenBalance,
     depositsRaw: currentATokenBalanceRaw,
     debtStable: currentStableDebt,

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

@@ -103,8 +103,8 @@ function createAaveV3Entry(
   const priceHist = pricesHist?.[key] ?? price
 
   const dataForAsset = {
-    poolId: asset,
-    underlying: asset,
+    poolId: asset.address,
+    underlying: asset.address,
     deposits: currentATokenBalance,
     depositsRaw: currentATokenBalanceRaw,
     debtStable: '0',

package/src/lending/user-data/morpho/userCallBuild.ts

@@ -4,14 +4,15 @@ import { Call } from '../../../utils/multicall'
 import { chunk } from 'lodash'
 import { morphoPools } from '@1delta/data-sdk'
 
-const MORPHO_LENS: { [c: string]: string } = {
-  [Chain.BASE]: '0x98542B95B44a4732EffB1F4F01A696F1546236d3',
-  [Chain.POLYGON_MAINNET]: '0x105eb87D2b3127f43B1b4C0F125dbEb0EDF3d6C6',
-  [Chain.OP_MAINNET]: '0xd184c5315B728c1C990f59dDD275c8155f8e255c',
-  [Chain.ARBITRUM_ONE]: '0xF64F862Fb7D687411585e06C08711B612e156530',
-  [Chain.KATANA]: '0xcB6Eb8df68153cebF60E1872273Ef52075a5C297',
-  [Chain.HYPEREVM]: '0xCe434378adacC51d54312c872113D687Ac19B516',
-  [Chain.ETHEREUM_MAINNET]: '0x0bd7473CbBf81d9dD936c61117eD230d95006CA2',
+export const MORPHO_LENS: { [c: string]: string } = {
+  [Chain.BASE]: '0x05f3f58716a88A52493Be45aA0871c55b3748f18',
+  [Chain.POLYGON_MAINNET]: '0x04102873b1A80647879Aa8B8a119F07aE08f457a',
+  [Chain.OP_MAINNET]: '0x61895aEB0a42679E2Df8EE64334C405a8d47D244',
+  [Chain.ARBITRUM_ONE]: '0xeaC918F73Ba5b11D21D31a72BD00ca4A22865C3f',
+  [Chain.KATANA]: '0xCe434378adacC51d54312c872113D687Ac19B516',
+  [Chain.HYPEREVM]: '0x6Bc6aCB905c1216B0119C87Bf9E178ce298310FA',
+  [Chain.SONEIUM]: '0x4b5458BB47dCBC1a41B31b41e1a8773dE312BE9d',
+  [Chain.ETHEREUM_MAINNET]: '0x4b5458BB47dCBC1a41B31b41e1a8773dE312BE9d'
 }
 
 const getBaseMorphoCalls = (

package/src/lending-pairs/computeLendingPairs.ts

@@ -6,7 +6,7 @@ import {
 } from '../assets/liquidityThresholds'
 import { GenericCurrency } from '../lending/types'
 import { ConfigEntry, LenderData, PoolData } from '../types'
-import { isAaveV3Type, isInit } from '../utils'
+import { isAaveV3Type, isInit, isMorphoType } from '../utils'
 
 interface SimpleAssetInfo {
   asset: GenericCurrency
@@ -252,7 +252,8 @@ function getPriceKey(asset: GenericCurrency): [string, string] {
   const assetGroup = asset?.assetGroup
   return [
     assetGroup,
-    toOracleKey(assetGroup) ?? toGenericPriceKey(asset.address, asset.chainId),
+    toOracleKey(assetGroup) ??
+      toGenericPriceKey(asset?.address, asset?.chainId),
   ]
 }
 
@@ -301,14 +302,18 @@ function filterPairsByCategory(
         p.assetGroupShort,
       )
 
-      const longMeetsThresholds = meetsLiquidityThresholdsLong(
-        {
-          totalDepositsUSD: p.longTotalDepositsUSD,
-          totalDebtUSD: p.longTotalDebtUSD,
-          totalLiquidityUSD: p.longTotalLiquidityUSD,
-        },
-        longThresholds,
-      )
+      // note: morpho does not allow to borrow collateral
+      // therefore, the collateral is always withdrawable if debt is repaid
+      const longMeetsThresholds =
+        isMorphoType(p.lender) ||
+        meetsLiquidityThresholdsLong(
+          {
+            totalDepositsUSD: p.longTotalDepositsUSD,
+            totalDebtUSD: p.longTotalDebtUSD,
+            totalLiquidityUSD: p.longTotalLiquidityUSD,
+          },
+          longThresholds,
+        )
 
       const shortMeetsThresholds = meetsLiquidityThresholdsShort(
         {

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

@@ -7,7 +7,7 @@ import { RWADynamicOracleAbi } from '../../abis/oracle/RWADynamicOracle'
 import { api3OracleAddresses } from './addresses/api3'
 import { AAVE_V2_LENDERS } from '@1delta/lender-registry'
 import { Chain } from '@1delta/chain-registry'
-import { formatEther, formatUnits } from 'viem'
+import { formatUnits } from 'viem'
 import { getAaveAssets } from '../../assets'
 import {
   chainlinkOracles,
@@ -17,45 +17,13 @@ import {
 import { fetchDefillamaData } from '../defillama'
 import { fetchPendlePrices } from '../pendle'
 import { getAavesForChain } from '../../utils'
-import { parseRawAmount } from '../../utils/parsing'
+import { formatAavePrice, formatMorphoPrice, parseRawAmount } from '../../utils/parsing'
 import { ProxyOracleAbi } from '../../abis/oracle/ProxyOracle'
 import { multicallRetry } from '@1delta/providers'
 import { TokenList } from '../../types'
 import { UniswapV3Abi } from '../../abis/oracle/UniV3'
 import { aaveOracles, morphoOracles } from '@1delta/data-sdk'
 
-export const formatAavePrice = (price: string, isV2 = false): number => {
-  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)
-        36 + collateralDec - debtDec,
-      ),
-    )
-  } catch {
-    return NaN
-  }
-}
-
 const LENDLE_PAIR_MANTLE = '0x4c57BE599d0e0414785943569E9B6A66dA79Aa6b'
 const AU_PAIR_MANTLE = '0x709503fbb50b10f921e812c48fbd5c5522a0b20c'
 const WMNT_USDT_PAIR = '0x3e5922cd0cec71dc2d60ec8b36aa4c05b7c1672f'

package/src/utils/index.ts

@@ -63,10 +63,9 @@ export const getLendersForChain = (c: string) => {
   })
 
   // compound V3s
-  Object.entries(compoundV3Pools() ?? {}).forEach(([l, data]) => {
-    const chains = Object.keys(data)
-    if (chains.includes(c)) lenders.push(l)
-  })
+
+  if (compoundV3Pools()?.[c])
+    lenders = [...lenders, ...Object.keys(compoundV3Pools()?.[c])]
 
   // init
   Object.entries(initConfig() ?? {}).forEach(([l, data]) => {

package/src/utils/parsing.ts

@@ -80,3 +80,35 @@ export const convertRateToApr = (ratePerSecond: number | string) => {
   if (isNaN(rps)) return 0
   return rps * 3600 * 24 * 365 * 100
 }
+
+export const formatAavePrice = (price: string, isV2 = false): number => {
+  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)
+        36 + collateralDec - debtDec,
+      ),
+    )
+  } catch {
+    return NaN
+  }
+}