@stake-dao/reader 0.5.36 → 0.5.38

package/src/strategies/angle/fetch.ts

@@ -1,253 +0,0 @@
-import { STRAT_FEES, Zero, angleStrats, contracts } from '@stake-dao/constants'
-import { chunk, uniq } from 'lodash-es'
-import { encodeAbiParameters, formatUnits, parseAbiParameters } from 'viem'
-import { mainnet } from 'viem/chains'
-import multicallAngleVaultsAbi from '../../abis/angleVaultsMulticall.js'
-import { batchAngleStrats } from '../../bytecodes/index.js'
-import { type Price, getPricesFromLlama } from '../../prices.js'
-import { batchJsonRpc, equalTlc, multicall } from '../../utils.js'
-import type { RewardsData, SdtApr } from '../types.js'
-import { getAprBreakdown } from '../utils/getAprBreakdown.js'
-import getTokenTypes from '../utils/getTokenTypes.js'
-import { ANGLE_APR_URL, ANGLE_PRICE_URL } from './endpoints.js'
-
-interface TFetchAngle {
-  prices: Price[]
-  provider: any
-  rpc: string
-  chainId: number
-}
-
-export const fetchAngle = async ({ prices, provider, rpc, chainId }: TFetchAngle) => {
-  const stratsDataCalls: { vault: string; token: string; sdtLiquidityGauge: string }[] = []
-  const balancesCalls: { address: string; name: string }[] = []
-  const dataCalls: { address: string; name: string }[] = []
-
-  const strats = angleStrats.strats[chainId].filter((s) => s.chainId === chainId)
-
-  const tokensToFetch: any = []
-
-  for (const s of strats) {
-    tokensToFetch.push(...s.underlyingCoins)
-    if (s.lpToken.symbol !== 'SLP') {
-      balancesCalls.push(
-        ...[
-          {
-            address: s.lpToken.address,
-            name: s.key.includes('gamma') ? 'getTotalAmounts' : 'getUnderlyingBalances',
-          },
-          {
-            address: s.lpToken.address,
-            name: 'totalSupply',
-          },
-        ],
-      )
-    }
-    dataCalls.push(
-      ...[
-        { address: s.vault, name: 'totalSupply' },
-        { address: s.rewards[0].gauge, name: 'totalSupply' },
-        { address: s.rewards[0].gauge, name: 'working_supply' },
-      ],
-    )
-  }
-
-  const httpCalls = [
-    // Angle APR
-    (await fetch(ANGLE_APR_URL)).json(),
-    // Angle Prices
-    (await fetch(ANGLE_PRICE_URL)).json(),
-    // Defillama prices
-    await getPricesFromLlama(uniq(tokensToFetch), chainId),
-  ]
-
-  const httpResponses = await Promise.all(httpCalls)
-
-  const rawBalances: any = await multicall(provider, balancesCalls, multicallAngleVaultsAbi)
-  const rawData: any = await multicall(provider, dataCalls, multicallAngleVaultsAbi)
-
-  const angleAprData = httpResponses[0]
-  const anglePriceData = httpResponses[1]
-  const defillamaPrices = httpResponses[2]
-
-  let rawPriceIndex = 0
-  const stratsWithApy = strats.map((s) => {
-    const aprData = angleAprData[s.aprApiKey]
-    let priceData = anglePriceData.find((d) => d.token === s.aprApiKey)
-
-    if (!priceData) {
-      const token0 = s.underlyingCoins[0]
-      const token1 = s.underlyingCoins[1]
-      const token0Price = defillamaPrices.find((p) => p.symbol === token0.symbol)
-      const token1Price = defillamaPrices.find((p) => p.symbol === token1.symbol)
-      const token0AmountUsd =
-        Number(formatUnits(rawBalances[rawPriceIndex].result[0], token0.decimals)) * token0Price.usdPrice
-      const token1AmountUsd =
-        Number(formatUnits(rawBalances[rawPriceIndex].result[1], token1.decimals)) * token1Price.usdPrice
-      const totalLp = Number(formatUnits(rawBalances[rawPriceIndex + 1].result, 18))
-      const lpPriceInUsd = (token0AmountUsd + token1AmountUsd) / totalLp
-
-      priceData = { rate: lpPriceInUsd }
-
-      rawPriceIndex += 2
-    }
-
-    let maxApr = 0
-    let tradingApy = 0
-
-    if (aprData?.details && aprData.value && aprData.address) {
-      tradingApy = aprData.details.fees ? aprData.details.fees : 0
-      const aprDetailsKeys = Object.keys(aprData.details)
-      const indexOfApy = aprDetailsKeys.map((k) => k.includes(s.lpToken.address.toLowerCase())).indexOf(true)
-      maxApr =
-        indexOfApy > 0
-          ? aprData.details[aprDetailsKeys[indexOfApy]!]
-          : aprData.details.max
-            ? aprData.details.max
-            : aprData.value - tradingApy
-    }
-
-    if (s.key === 'angle-sushi-eura-angle') {
-      stratsDataCalls.push({
-        vault: s.vault,
-        token: s.lpToken.address,
-        sdtLiquidityGauge: s.gaugeAddress,
-      })
-    }
-
-    return {
-      ...s,
-      tradingApy,
-      minApr: (maxApr * ((100 - STRAT_FEES) / 100)) / 2.5,
-      maxApr: maxApr * ((100 - STRAT_FEES) / 100),
-      lpPriceInUsd: priceData ? priceData.rate : 1,
-    }
-  })
-
-  const inputArgsChunks = chunk(stratsDataCalls, 20)
-  const angleCalls = inputArgsChunks.map((inputArgs) => {
-    const inputData = encodeAbiParameters(parseAbiParameters(batchAngleStrats.inputType[chainId]!) as any, [
-      contracts.sdGaugeController![chainId],
-      inputArgs,
-    ])
-    return batchAngleStrats.bytecode[chainId]!.concat(inputData.slice(2))
-  })
-
-  const rawAngleData = await batchJsonRpc({
-    rpc,
-    calls: angleCalls,
-    outputTypeAbi: batchAngleStrats.outputTypeHr[chainId],
-    callsKey: `strategies/angle/fetch.ts: rawAngleData - chainId ${chainId} - rpc ${rpc}`,
-  })
-
-  let offchainDataIndex = 0
-  const parsedStrats = stratsWithApy.map((s) => {
-    let fetchedData: any
-
-    if (s.offchain) {
-      fetchedData = {
-        totalSupply: rawData[offchainDataIndex].result,
-        sdGaugeTotalSupply: rawData[offchainDataIndex + 1].result,
-        sdWorkingSupply: chainId === mainnet.id ? rawData[offchainDataIndex + 2].result : Zero,
-        accumulatedFees: Zero,
-        keeperFee: Zero,
-      }
-    } else {
-      fetchedData = rawAngleData.shift()
-    }
-
-    offchainDataIndex += 3
-
-    const rewardsData: RewardsData[] = s.rewards.map((r: any) => {
-      const rewardToken = {
-        symbol: r.symbol,
-        name: r.name,
-        decimals: r.decimals,
-        address: r.address,
-      }
-      const rewardPrice = prices.find((p: any) => equalTlc(p.address, rewardToken.address))
-
-      return {
-        token: rewardToken,
-        price: rewardPrice ? rewardPrice.usdPrice : 0,
-        apr: 0,
-        streaming: false,
-        periodFinish: 0,
-        rate: '0',
-        lastUpdate: '0',
-        claimablePendingRewards: '0',
-      }
-    })
-
-    const boost = 2.5
-    const sdtApr: SdtApr = {
-      sdtUserApr: 0,
-      sdtFuturUserApr: 0,
-      sdtMinApr: 0,
-      sdtFuturMinApr: 0,
-      sdtMaxApr: 0,
-      sdtFuturMaxApr: 0,
-      sdtBoost: 1,
-    }
-    const apr = getAprBreakdown(s, rewardsData, boost, sdtApr)
-
-    const totalSupply = formatUnits(fetchedData.totalSupply, 0)
-    const lpPriceInUsd = s.lpPriceInUsd
-    const tvl = lpPriceInUsd * Number(formatUnits(BigInt(fetchedData.totalSupply), 18))
-
-    const sdGauge = {
-      address: s.gaugeAddress,
-      totalSupply: formatUnits(fetchedData.sdGaugeTotalSupply, 0),
-      relativeWeight: '0',
-      weight: '0',
-      futureWeight: '0',
-      workingSupply: '0',
-    }
-
-    return {
-      key: s.key,
-      name: s.name,
-      tokensFilter: getTokenTypes(s),
-      protocol: s.protocol,
-      chainId: s.chainId,
-      vault: s.vault,
-      lpToken: s.lpToken,
-      gaugeAddress: s.gaugeAddress,
-      coins: s.coins,
-      sdGauge,
-      lpPriceInUsd,
-      streaming: rewardsData.some((r) => Number(r.periodFinish) > Math.floor(Date.now() / 1000)),
-      tvl,
-      apr: {
-        boost,
-        ...apr,
-      },
-      rewards: rewardsData,
-      // Base APR data
-      tradingApy: s.tradingApy,
-      minApr: s.minApr,
-      maxApr: s.maxApr,
-      // Raw data
-      totalSupply,
-      // Gas optimised
-      vaultFees: {
-        keeper: Number(fetchedData.keeperFee) / 100,
-        accumulated: formatUnits(fetchedData.accumulatedFees, 0),
-      },
-    }
-  })
-
-  return {
-    global: {
-      fees: {
-        veSdt: 5,
-        perf: 2,
-        accumulator: 8,
-        claimer: 0.5,
-      },
-    },
-    deployed: parsedStrats,
-    notDeployed: [],
-    fetched: true,
-  }
-}