@stake-dao/reader 0.4.88 → 0.4.90

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

@@ -1,132 +0,0 @@
-import { ONE_YEAR, STRAT_FEES, contracts, tokenWithId } from '@stake-dao/constants'
-import { decodeAbiParameters, encodeAbiParameters, formatUnits, parseAbiParameters, zeroAddress } from 'viem'
-
-import { range } from 'lodash-es'
-import { buildPancakeswapNotDeployedErc20Strats } from '../../../bytecodes/index.js'
-import { bytes32ToString, concatBytecode } from '../../../index.js'
-import { type Price, mergePrices } from '../../../prices.js'
-import { batchJsonRpc, equalTlc, rpcCall } from '../../../utils.js'
-import { PCS_POOLS_NOT_DEPLOYED_CHUNK_SIZE } from '../config.js'
-
-export const getPancakeNotDeployed = async (
-  rpc: string,
-  chainId: number,
-  basePrices: Price[],
-  feesApr: any,
-  managerFees: any,
-  deployedLp: string[],
-) => {
-  const poolLengthRequest = await rpcCall(rpc, [{ to: contracts.pancakeFarmBooster![chainId]!, data: '0x081e3eda' }]) // poolLength()
-  const poolLength =
-    Number(decodeAbiParameters([{ type: 'uint256', name: 'n_gauges' }], poolLengthRequest[0].result)) + 1
-
-  const notDeployedCalls = range(1, poolLength, PCS_POOLS_NOT_DEPLOYED_CHUNK_SIZE).map((skip) => {
-    const inputParams = [
-      contracts.pancakeFarmBooster![chainId],
-      skip,
-      skip + PCS_POOLS_NOT_DEPLOYED_CHUNK_SIZE > poolLength ? poolLength : skip + PCS_POOLS_NOT_DEPLOYED_CHUNK_SIZE,
-    ]
-
-    const inputData = encodeAbiParameters(
-      parseAbiParameters(buildPancakeswapNotDeployedErc20Strats.inputType[chainId]!) as any,
-      inputParams,
-    )
-    return concatBytecode(buildPancakeswapNotDeployedErc20Strats.bytecode[chainId]!, inputData)
-  })
-
-  const notDeployedData = await batchJsonRpc({
-    rpc,
-    calls: notDeployedCalls,
-    outputTypeAbi: buildPancakeswapNotDeployedErc20Strats.outputTypeHr[chainId],
-    callsKey: `strategies/pancakeswap/fetch/getPancakeNotDeployed.ts: notDeployedData - chainId ${chainId} - rpc ${rpc}`,
-  })
-
-  const pricesToFetch = notDeployedData
-    .flatMap((d) => {
-      if (d.lpToken._address === zeroAddress || deployedLp.includes(d.lpToken._address)) return undefined
-
-      return d.coins.map((c) => {
-        const coinPrice = basePrices.find((bp) => equalTlc(bp.address, c._address))?.usdPrice || 0
-        return coinPrice === 0 ? { address: c._address, symbol: bytes32ToString(c._symbol) } : undefined
-      })
-    })
-    .filter(Boolean)
-  const prices = await mergePrices(basePrices, pricesToFetch, chainId)
-
-  const cake = tokenWithId('cake', chainId)!
-  const cakeReward = { name: cake.name, symbol: cake.symbol, address: cake.address, decimals: cake.decimals }
-  const cakePriceUsd = prices.find((p) => equalTlc(p.address, cake.address))?.usdPrice || 0
-
-  // TODO type
-  const notDeployed: any[] = notDeployedData
-    .map((d) => {
-      if (d.lpToken._address === zeroAddress || deployedLp.includes(d.lpToken._address)) return undefined
-
-      const coins = d.coins.map((c) => ({
-        name: bytes32ToString(c._name),
-        symbol: bytes32ToString(c._symbol),
-        address: c._address,
-        decimals: Number(c._decimals),
-      }))
-
-      const lpName = bytes32ToString(d.lpToken._name)
-      const isStable = lpName.includes('StableSwap')
-      const isMetapool = coins.some((c) => c.name.includes(' LPs'))
-      const lpSymbol = `${coins.map((c) => c.symbol).join('-')} ${isStable ? 'Stable LP' : 'LP'}`
-
-      const lpToken = {
-        name: lpName,
-        symbol: lpSymbol,
-        address: d.lpToken._address,
-        decimals: Number(d.lpToken._decimals),
-      }
-
-      const token0PriceInUsd = prices.find((p) => equalTlc(p.address, coins[0]!.address))?.usdPrice || 0
-      const token1PriceInUsd = prices.find((p) => equalTlc(p.address, coins[1]!.address))?.usdPrice || 0
-
-      const lpPriceInUsd =
-        Number(formatUnits(d.token0PerShare, coins[0].decimals)) * token0PriceInUsd +
-        Number(formatUnits(d.token1PerShare, coins[1].decimals)) * token1PriceInUsd
-
-      const tvl = lpPriceInUsd * Number(formatUnits(d.sharesTotalSupply, 18))
-
-      let tradingApy = Number(feesApr[lpToken.address.toLowerCase()]?.apr7d || 0)
-      if (!tradingApy && managerFees[d.pool.toLowerCase()]) {
-        const feesData = managerFees[d.pool.toLowerCase()]
-        tradingApy = feesData
-          ? ((Number(formatUnits(feesData.token0, coins[0].decimals)) * token0PriceInUsd +
-              Number(formatUnits(feesData.token1, coins[1].decimals)) * token1PriceInUsd) /
-              tvl) *
-            365 *
-            100
-          : 0
-      }
-
-      const boost = d.manager === 'pancakeswap' ? 2.5 : 3 // Pancake max boost is 2.5, managers farm is 3
-
-      const rewardPerYear = cakePriceUsd * Number(formatUnits(d.rewardPerSecond, 18)) * ONE_YEAR
-      const stakedTvl = lpPriceInUsd * Number(formatUnits(d.stakedInGauge, 18))
-
-      const minApr = (rewardPerYear / (stakedTvl > 0 ? stakedTvl : tvl)) * ((100 - STRAT_FEES + 0.5) / 100)
-      const maxApr = minApr * boost
-
-      return {
-        key: `${d.manager.toLowerCase()}-${coins.map((c) => c.symbol.toLowerCase()).join('-')}`,
-        protocol: 'pancakeswap',
-        chainId,
-        isMetapool,
-        isStable,
-        manager: d.manager,
-        pool: d.pool,
-        gaugeAddress: d.gagaugeAddressuge,
-        lpToken,
-        coins,
-        minApr,
-        maxApr,
-        rewards: [cakeReward],
-      }
-    })
-    .filter(Boolean)
-
-  return notDeployed
-}