@stake-dao/reader 0.1.3 → 0.2.0

package/src/strategies/pancakeswap/fetch/pancakePositions.ts

@@ -0,0 +1,147 @@
+import { formatUnits } from 'viem'
+
+import pancakeMasterchefAbi from '../abis/PancakeSwapMasterchef.json'
+
+import { contracts, tokenWithId } from '@stake-dao/constants'
+import {
+  getPositionFarmApr,
+  getPositionTradingFee,
+  getToken0Amount,
+  getToken1Amount,
+  tickToPrice,
+} from './pancakeswapMath.js'
+
+export const computePositionData = (
+  s: any,
+  p: any,
+  stratParsedData: any,
+  fees24H: number,
+  prices: any[],
+  token0PriceInUsd: number,
+  token1PriceInUsd: number,
+  totalAllocPoint: string,
+  inflationRate: string,
+) => {
+  const bnSqrtPriceX96 = BigInt(stratParsedData.sqrtPriceX96)
+
+  const token0Amount = formatUnits(
+    getToken0Amount(Number(stratParsedData.tick), p.tickLower, p.tickUpper, bnSqrtPriceX96, p.liquidity),
+    s.coins[0].decimals,
+  )
+  const token1Amount = formatUnits(
+    getToken1Amount(Number(stratParsedData.tick), p.tickLower, p.tickUpper, bnSqrtPriceX96, p.liquidity),
+    s.coins[1].decimals,
+  )
+
+  const token0AmountUsd = Number(token0Amount) * token0PriceInUsd
+  const token1AmountUsd = Number(token1Amount) * token1PriceInUsd
+  const tvlToAdd = token0AmountUsd + token1AmountUsd
+
+  const priceLower = tickToPrice(p.tickLower)
+  const priceUpper = tickToPrice(p.tickUpper)
+
+  const boost = Number(formatUnits(p.boostMultiplier.toString(), 12))
+
+  const apr =
+    getPositionFarmApr({
+      poolWeight: stratParsedData.allocPoint / Number(totalAllocPoint),
+      cakePriceUsd:
+        prices.find((p) => p.address.toLowerCase() === tokenWithId('cake', 56)!.address.toLowerCase())?.usdPrice || 0,
+      cakePerSecond: Number(inflationRate),
+      positionTvlUsd: token0AmountUsd + token1AmountUsd,
+      liquidity: p.boostLiquidity,
+      totalStakedLiquidity: BigInt(stratParsedData.totalBoostLiquidity),
+      tickCurrent: stratParsedData.tick,
+      tickLower: p.tickLower,
+      tickUpper: p.tickUpper,
+    }) * 0.85
+
+  const tradingApr = getPositionTradingFee({
+    fees24H,
+    sqrtRatioX96: bnSqrtPriceX96,
+    tickLower: p.tickLower,
+    tickUpper: p.tickUpper,
+    mostActiveLiquidity: BigInt(stratParsedData.poolLiquidity),
+    liquidity: p.liquidity,
+    positionUSD: token0AmountUsd + token1AmountUsd,
+  })
+
+  return {
+    positionData: {
+      ...p,
+      boostLiquidity: p.boostLiquidity.toString(),
+      boostMultiplier: p.boostMultiplier.toString(),
+      liquidity: p.liquidity.toString(),
+      pid: Number(p.pid),
+      reward: p.reward.toString(),
+      rewardGrowthInside: p.rewardGrowthInside.toString(),
+      tokenId: Number(p.tokenId),
+      token0: {
+        amount: token0Amount,
+        amountUsd: token0AmountUsd,
+      },
+      token1: {
+        amount: token1Amount,
+        amountUsd: token1AmountUsd,
+      },
+      apr: {
+        trading: tradingApr,
+        min: apr,
+        max: apr,
+      },
+      priceLower,
+      priceUpper,
+    },
+    boost,
+    tvlToAdd,
+  }
+}
+
+export const getPositionData = async (
+  chainId: number,
+  tokenId: number,
+  tickLower: number,
+  tickUpper: number,
+  user: string,
+  strat: any,
+  prices: any[],
+  provider: any,
+) => {
+  const positionData = await provider.readContract({
+    address: contracts.pancakeMasterchef![chainId],
+    abi: pancakeMasterchefAbi,
+    functionName: 'userPositionInfos',
+    args: [tokenId],
+  })
+
+  const p = {
+    tokenId,
+    liquidity: positionData[0],
+    boostLiquidity: positionData[1],
+    tickLower,
+    tickUpper,
+    rewardGrowthInside: positionData[4],
+    reward: positionData[5],
+    owner: user,
+    pid: positionData[7],
+    boostMultiplier: positionData[8],
+  }
+
+  const {
+    positionData: tokenIdPositionData,
+    tvlToAdd,
+    boost,
+  } = computePositionData(
+    strat,
+    p,
+    strat.stratsData,
+    strat.stratsData.fees24H,
+    prices,
+    strat.token0PriceInUsd,
+    strat.token1PriceInUsd,
+    strat.stratsData.totalAllocPoint || strat.stratsData.allocPoints,
+    strat.stratsData.inflationRate,
+  )
+
+  return { tokenIdPositionData, tvlToAdd, boost }
+}

package/src/strategies/pancakeswap/fetch/pancakeswapMath.ts

@@ -0,0 +1,305 @@
+import { ONE_YEAR } from '@stake-dao/constants'
+import { formatUnits, parseUnits } from 'viem'
+import { Zero } from '../../../index.js'
+
+const Q32 = BigInt(2 ** 32)
+const Q96 = BigInt(2 ** 96)
+const Q192 = Q96 * Q96
+const MaxUint256 = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
+export const MAX_TICK = 887250
+
+function mulShift(val: bigint, mulBy: string): bigint {
+  return (val * BigInt(mulBy)) >> BigInt(128)
+}
+
+interface FarmAprParams {
+  poolWeight: number
+  // Total tvl staked in farm in usd
+  tvlUsd: number
+  cakePriceUsd: number
+  cakePerSecond: number
+}
+
+interface PositionFarmAprParams extends Omit<FarmAprParams, 'tvlUsd'> {
+  // Position liquidity
+  liquidity: bigint
+
+  // Total staked liquidity in farm
+  totalStakedLiquidity: bigint
+
+  // Position tvl in usd
+  positionTvlUsd: number
+
+  // Tick
+  tickCurrent: number
+  tickLower: number
+  tickUpper: number
+}
+
+interface EstimateFeeOptions {
+  tickLower: number
+  tickUpper: number
+  // Average 24h historical fees generated minus pancake fees in USD
+  fees24H: number
+
+  // The reason of using price sqrt X96 instead of tick current is that
+  // tick current may have rounding error since it's a floor rounding
+  sqrtRatioX96: bigint
+  // Most active liquidity of the pool
+  mostActiveLiquidity: bigint
+
+  liquidity: bigint
+}
+
+function getSqrtRatioAtTick(tick: number): bigint {
+  const absTick: number = tick < 0 ? tick * -1 : tick
+
+  let ratio: bigint =
+    (absTick & 0x1) !== 0 ? BigInt('0xfffcb933bd6fad37aa2d162d1a594001') : BigInt('0x100000000000000000000000000000000')
+  if ((absTick & 0x2) !== 0) ratio = mulShift(ratio, '0xfff97272373d413259a46990580e213a')
+  if ((absTick & 0x4) !== 0) ratio = mulShift(ratio, '0xfff2e50f5f656932ef12357cf3c7fdcc')
+  if ((absTick & 0x8) !== 0) ratio = mulShift(ratio, '0xffe5caca7e10e4e61c3624eaa0941cd0')
+  if ((absTick & 0x10) !== 0) ratio = mulShift(ratio, '0xffcb9843d60f6159c9db58835c926644')
+  if ((absTick & 0x20) !== 0) ratio = mulShift(ratio, '0xff973b41fa98c081472e6896dfb254c0')
+  if ((absTick & 0x40) !== 0) ratio = mulShift(ratio, '0xff2ea16466c96a3843ec78b326b52861')
+  if ((absTick & 0x80) !== 0) ratio = mulShift(ratio, '0xfe5dee046a99a2a811c461f1969c3053')
+  if ((absTick & 0x100) !== 0) ratio = mulShift(ratio, '0xfcbe86c7900a88aedcffc83b479aa3a4')
+  if ((absTick & 0x200) !== 0) ratio = mulShift(ratio, '0xf987a7253ac413176f2b074cf7815e54')
+  if ((absTick & 0x400) !== 0) ratio = mulShift(ratio, '0xf3392b0822b70005940c7a398e4b70f3')
+  if ((absTick & 0x800) !== 0) ratio = mulShift(ratio, '0xe7159475a2c29b7443b29c7fa6e889d9')
+  if ((absTick & 0x1000) !== 0) ratio = mulShift(ratio, '0xd097f3bdfd2022b8845ad8f792aa5825')
+  if ((absTick & 0x2000) !== 0) ratio = mulShift(ratio, '0xa9f746462d870fdf8a65dc1f90e061e5')
+  if ((absTick & 0x4000) !== 0) ratio = mulShift(ratio, '0x70d869a156d2a1b890bb3df62baf32f7')
+  if ((absTick & 0x8000) !== 0) ratio = mulShift(ratio, '0x31be135f97d08fd981231505542fcfa6')
+  if ((absTick & 0x10000) !== 0) ratio = mulShift(ratio, '0x9aa508b5b7a84e1c677de54f3e99bc9')
+  if ((absTick & 0x20000) !== 0) ratio = mulShift(ratio, '0x5d6af8dedb81196699c329225ee604')
+  if ((absTick & 0x40000) !== 0) ratio = mulShift(ratio, '0x2216e584f5fa1ea926041bedfe98')
+  if ((absTick & 0x80000) !== 0) ratio = mulShift(ratio, '0x48a170391f7dc42444e8fa2')
+
+  if (tick > 0) ratio = MaxUint256 / ratio
+
+  // back to Q96
+  return ratio % Q32 > Zero ? ratio / Q32 + BigInt(1) : ratio / Q32
+}
+
+function getAmount0Delta(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): bigint {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
+    sqrtRatioAX96 = sqrtRatioBX96
+    sqrtRatioBX96 = sqrtRatioAX96
+  }
+
+  const numerator1 = liquidity << BigInt(96)
+  const numerator2 = sqrtRatioBX96 - sqrtRatioAX96
+
+  return (numerator1 * numerator2) / sqrtRatioBX96 / sqrtRatioAX96
+}
+
+function getAmount1Delta(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): bigint {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
+    sqrtRatioAX96 = sqrtRatioBX96
+    sqrtRatioBX96 = sqrtRatioAX96
+  }
+
+  return (liquidity * (sqrtRatioBX96 - sqrtRatioAX96)) / Q96
+}
+
+export function getToken0Amount(
+  tickCurrent: number,
+  tickLower: number,
+  tickUpper: number,
+  sqrtRatioX96: bigint,
+  liquidity: bigint,
+): bigint {
+  if (Number.isNaN(tickCurrent) || Number.isNaN(tickLower) || Number.isNaN(tickUpper) || !sqrtRatioX96 || !liquidity) {
+    return Zero
+  }
+  if (tickCurrent < tickLower) {
+    return getAmount0Delta(getSqrtRatioAtTick(tickLower), getSqrtRatioAtTick(tickUpper), liquidity)
+  }
+  if (tickCurrent < tickUpper) {
+    return getAmount0Delta(sqrtRatioX96, getSqrtRatioAtTick(tickUpper), liquidity)
+  }
+  return Zero
+}
+
+export function getToken1Amount(
+  tickCurrent: number,
+  tickLower: number,
+  tickUpper: number,
+  sqrtRatioX96: bigint,
+  liquidity: bigint,
+): bigint {
+  if (Number.isNaN(tickCurrent) || Number.isNaN(tickLower) || Number.isNaN(tickUpper) || !sqrtRatioX96 || !liquidity) {
+    return Zero
+  }
+  if (tickCurrent < tickLower) {
+    return Zero
+  }
+  if (tickCurrent < tickUpper) {
+    return getAmount1Delta(getSqrtRatioAtTick(tickLower), sqrtRatioX96, liquidity)
+  }
+  return getAmount1Delta(getSqrtRatioAtTick(tickLower), getSqrtRatioAtTick(tickUpper), liquidity)
+}
+
+export function getFarmApr({ poolWeight, tvlUsd, cakePriceUsd, cakePerSecond }: FarmAprParams) {
+  if (!poolWeight || !tvlUsd || !cakePriceUsd || !cakePerSecond) {
+    return 0
+  }
+
+  const cakeRewardPerYear = cakePerSecond * ONE_YEAR
+  const farmApr = ((poolWeight * cakeRewardPerYear * cakePriceUsd) / tvlUsd) * 100
+
+  return farmApr
+}
+
+export function getPositionFarmAprFactor({
+  poolWeight,
+  cakePriceUsd,
+  cakePerSecond,
+  liquidity,
+  totalStakedLiquidity,
+}: Omit<PositionFarmAprParams, 'positionTvlUsd' | 'precision' | 'tickCurrent' | 'tickLower' | 'tickUpper'>) {
+  if (
+    !poolWeight ||
+    !cakePriceUsd ||
+    !cakePerSecond ||
+    BigInt(liquidity) === Zero ||
+    BigInt(totalStakedLiquidity) === Zero
+  ) {
+    return 0
+  }
+
+  const cakeRewardPerYear = cakePerSecond * ONE_YEAR
+  const aprFactor =
+    ((poolWeight * cakeRewardPerYear * cakePriceUsd) /
+      Number(formatUnits(BigInt(liquidity) + BigInt(totalStakedLiquidity), 18))) *
+    100
+
+  return aprFactor
+}
+
+export function getPositionFarmApr({
+  poolWeight,
+  positionTvlUsd,
+  cakePriceUsd,
+  cakePerSecond,
+  liquidity,
+  totalStakedLiquidity,
+  tickCurrent,
+  tickLower,
+  tickUpper,
+}: PositionFarmAprParams) {
+  if (tickCurrent < tickLower || tickCurrent >= tickUpper) {
+    return 0
+  }
+
+  const aprFactor = getPositionFarmAprFactor({
+    poolWeight,
+    cakePriceUsd,
+    cakePerSecond,
+    liquidity,
+    totalStakedLiquidity,
+  })
+
+  if (!aprFactor || !positionTvlUsd) {
+    return 0
+  }
+
+  const positionApr = (aprFactor * Number(formatUnits(liquidity, 18))) / positionTvlUsd
+
+  return positionApr
+}
+
+const POWERS_OF_2 = [128, 64, 32, 16, 8, 4, 2, 1].map((pow: number): [number, bigint] => [pow, BigInt(2 ** pow)])
+
+export function mostSignificantBit(x: bigint): number {
+  let msb = 0
+  for (const [power, min] of POWERS_OF_2) {
+    if (x >= min) {
+      // eslint-disable-next-line operator-assignment
+      x = x >> BigInt(power)
+      msb += power
+    }
+  }
+  return msb
+}
+
+function getTickAtSqrtRatio(sqrtRatioX96: bigint): number {
+  const sqrtRatioX128 = sqrtRatioX96 << BigInt(32)
+
+  const msb = mostSignificantBit(sqrtRatioX128)
+
+  let r: bigint
+  if (BigInt(msb) >= BigInt(128)) {
+    r = sqrtRatioX128 >> BigInt(msb - 127)
+  } else {
+    r = sqrtRatioX128 << BigInt(127 - msb)
+  }
+
+  let log_2: bigint = (BigInt(msb) - BigInt(128)) << BigInt(64)
+
+  for (let i = 0; i < 14; i++) {
+    r = (r * r) >> BigInt(127)
+    const f = r >> BigInt(128)
+    // eslint-disable-next-line operator-assignment
+    log_2 = log_2 | (f << BigInt(63 - i))
+    // eslint-disable-next-line operator-assignment
+    r = r >> f
+  }
+
+  const log_sqrt10001 = log_2 * parseUnits('255738958999603826347141', 0)
+
+  const tickLow = Number((log_sqrt10001 - parseUnits('3402992956809132418596140100660247210', 0)) >> BigInt(128))
+  const tickHigh = Number((log_sqrt10001 + parseUnits('291339464771989622907027621153398088495', 0)) >> BigInt(128))
+
+  return tickLow === tickHigh ? tickLow : getSqrtRatioAtTick(tickHigh) <= sqrtRatioX96 ? tickHigh : tickLow
+}
+
+function getEstimatedLPFeeByAmount({
+  fees24H,
+  sqrtRatioX96,
+  tickLower,
+  tickUpper,
+  mostActiveLiquidity,
+  liquidity,
+}: EstimateFeeOptions): number {
+  const tickCurrent = getTickAtSqrtRatio(sqrtRatioX96)
+  if (tickCurrent < tickLower || tickCurrent >= tickUpper) {
+    return 0
+  }
+
+  if (!liquidity) {
+    return 0
+  }
+
+  return (100 * fees24H * Number(formatUnits(liquidity, 18))) / Number(formatUnits(liquidity + mostActiveLiquidity, 18))
+}
+
+export function getPositionTradingFee({
+  fees24H,
+  sqrtRatioX96,
+  tickLower,
+  tickUpper,
+  mostActiveLiquidity,
+  liquidity,
+  positionUSD,
+}): number {
+  const fees24HPosition = getEstimatedLPFeeByAmount({
+    fees24H,
+    sqrtRatioX96,
+    tickLower,
+    tickUpper,
+    mostActiveLiquidity,
+    liquidity,
+  })
+
+  return (positionUSD + fees24HPosition * 365) / positionUSD - 1
+}
+
+export function tickToPrice(tick: number, precision = 6): number {
+  const sqrtRatioX96 = getSqrtRatioAtTick(tick)
+
+  const ratioX192 = sqrtRatioX96 * sqrtRatioX96
+
+  return Number((ratioX192 * BigInt(10 ** precision)) / Q192) / 10 ** precision
+}

package/src/strategies/pendle/build.ts

@@ -0,0 +1,93 @@
+import dayjs from 'dayjs'
+import utc from 'dayjs/plugin/utc.js'
+import { chunk } from 'lodash-es'
+import { encodeAbiParameters, parseAbiParameters } from 'viem'
+import { buildPendleStrats } from '../../bytecodes/index.js'
+import { batchJsonRpc, equalTlc } from '../../utils.js'
+import { concatBytecode } from '../utils/index.js'
+
+dayjs.extend(utc)
+
+interface VaultAndLp {
+  vault: string
+  lpToken: string
+}
+
+const formatCoin = (data: any) => ({
+  address: data.address,
+  name: data.name,
+  symbol: data.symbol,
+  decimals: data.decimals,
+})
+
+export const buildPendleStrategies = async (
+  rpc: string,
+  vaultsAndLps: VaultAndLp[],
+  pendleApiData: any[],
+  chainId: number,
+) => {
+  const strats = vaultsAndLps.map((vlp) => {
+    const pendleMarketApiData = pendleApiData.find((d) => equalTlc(d.address, vlp.lpToken))
+    const sy = pendleMarketApiData.sy
+
+    const coin = formatCoin(pendleMarketApiData.underlyingAsset)
+    const underlyingCoin = formatCoin(pendleMarketApiData.accountingAsset)
+    const underlyingReward = formatCoin(pendleMarketApiData.basePricingAsset)
+
+    const expiryDayJs = dayjs(pendleMarketApiData.expiry).utc()
+
+    return {
+      key: `pendle_${sy.proSymbol.toLowerCase()}_${expiryDayJs.format('DD_MM_YYYY')}`,
+      name: sy.proSymbol,
+      subname: expiryDayJs.format('DD/MM/YYYY'),
+      protocol: 'pendle',
+      expiry: expiryDayJs.unix(),
+      chainId,
+      vault: vlp.vault,
+      lpToken: {
+        name: `${sy.proName} Pendle Market`,
+        symbol: `${sy.proSymbol} PENDLE LP`,
+        address: vlp.lpToken,
+        decimals: pendleMarketApiData.lp.decimals,
+      },
+      coins: [coin],
+      underlyingCoins: [underlyingCoin],
+      underlyingReward,
+      syToken: sy.address,
+    }
+  })
+
+  const inputsChunks = chunk(
+    strats.map((data) => [data.vault, data.lpToken.address]),
+    30,
+  )
+
+  const pendleCalls = inputsChunks.map((inputParams) => {
+    const inputData = encodeAbiParameters(parseAbiParameters(buildPendleStrats.inputType[chainId]!) as any, [
+      inputParams,
+    ])
+    return concatBytecode(buildPendleStrats.bytecode[chainId]!, inputData)
+  })
+
+  const pendleData = await batchJsonRpc({
+    rpc,
+    calls: pendleCalls,
+    outputTypeAbi: buildPendleStrats.outputTypeHr[chainId],
+    callsKey: 'Build Pendle Strategies',
+  })
+
+  return strats.map((s) => {
+    const stratData = pendleData.find((d) => equalTlc(d.lpt, s.lpToken.address))
+
+    return {
+      ...s,
+      sdGauge: stratData.sdGauge,
+      rewards: stratData.rewards.map((r) => ({
+        name: r._name,
+        symbol: r._symbol,
+        address: r._address,
+        decimals: Number(r._decimals),
+      })),
+    }
+  })
+}