@stake-dao/reader 0.1.4 → 0.2.1

package/src/strategies/pancakeswap/build.ts

@@ -0,0 +1,57 @@
+import { decodeAbiParameters, encodeAbiParameters, parseAbiParameters, zeroAddress } from 'viem'
+
+import { contracts, tokenWithId } from '@stake-dao/constants'
+import { range } from 'lodash-es'
+import { buildPancakeSwapStrats } from '../../bytecodes/index.js'
+import { batchJsonRpc, rpcCall } from '../../utils.js'
+import { concatBytecode } from '../utils/index.js'
+import { PCS_POOLS_CHUNK_SIZE } from './config.js'
+
+export const buildPancakeSwapStrategies = async (rpc: string, chainId: number) => {
+  const cake = tokenWithId('cake', chainId)!
+  const cakeReward = { name: cake.name, symbol: cake.symbol, address: cake.address, decimals: cake.decimals }
+
+  const nPoolsRequest = await rpcCall(rpc, [{ to: contracts.pancakeMasterchef![chainId]!, data: '0x081e3eda' }]) // poolLength()
+  const nPools = Number(decodeAbiParameters([{ type: 'uint256', name: 'n_gauges' }], nPoolsRequest[0].result))
+
+  const poolsCalls = range(0, nPools, PCS_POOLS_CHUNK_SIZE).map((skip) => {
+    const inputParams = [
+      contracts.pancakeMasterchef![chainId]!,
+      skip,
+      skip + PCS_POOLS_CHUNK_SIZE > nPools ? nPools : skip + PCS_POOLS_CHUNK_SIZE,
+    ]
+
+    const inputData = encodeAbiParameters(
+      parseAbiParameters(buildPancakeSwapStrats.inputType![chainId]!) as any,
+      inputParams,
+    )
+    return concatBytecode(buildPancakeSwapStrats.bytecode[chainId]!, inputData)
+  })
+
+  const pools = await batchJsonRpc({
+    rpc,
+    calls: poolsCalls,
+    outputTypeAbi: buildPancakeSwapStrats.outputTypeHr![chainId]!,
+    callsKey: `strategies/pancakeswap/build.ts: buildPancakeSwapStrategies/pools - chainId ${chainId} - rpc ${rpc}`,
+  })
+
+  return pools
+    .filter((d) => d.pool !== zeroAddress)
+    .map((data) => {
+      return {
+        key: `${chainId}-${data.id}`,
+        poolId: Number(data.id),
+        protocol: 'pancakeswap',
+        chainId,
+        pool: data.pool,
+        fee: data.fee,
+        coins: data.coins.map((c) => ({
+          name: c._name,
+          symbol: c._symbol,
+          address: c._address,
+          decimals: Number(c._decimals),
+        })),
+        rewards: [cakeReward],
+      }
+    })
+}

package/src/strategies/pancakeswap/buildErc20.ts

@@ -0,0 +1,73 @@
+import { chunk } from 'lodash-es'
+import { encodeAbiParameters, parseAbiParameters } from 'viem'
+import { buildPancakeSwapErc20Strats } from '../../bytecodes/index.js'
+import { batchJsonRpc } from '../../utils.js'
+import { bytes32ToString, concatBytecode } from '../utils/index.js'
+import { BROKEN_VAULT, PCS_POOLS_ERC20_CHUNK_SIZE } from './config.js'
+
+interface VaultAndLp {
+  vault: string
+  lpToken: string
+}
+
+export const buildPancakeSwapErc20Strategies = async (stratsList: VaultAndLp[], rpc: string, chainId: number) => {
+  const inputArgsChunks = chunk(stratsList, PCS_POOLS_ERC20_CHUNK_SIZE)
+  const poolsCalls = inputArgsChunks.map((poolsArgs) => {
+    const inputData = encodeAbiParameters(parseAbiParameters(buildPancakeSwapErc20Strats.inputType[chainId]!) as any, [
+      poolsArgs,
+    ])
+    return concatBytecode(buildPancakeSwapErc20Strats.bytecode[chainId]!, inputData)
+  })
+
+  const pools = await batchJsonRpc({
+    rpc,
+    calls: poolsCalls,
+    outputTypeAbi: buildPancakeSwapErc20Strats.outputTypeHr[chainId],
+    callsKey: `strategies/pancakeswap/buildErc20.ts: buildPancakeSwapErc20Strategies/pools - chainId ${chainId} - rpc ${rpc}`,
+  })
+
+  return pools
+    .map((data) => {
+      const coins = data.coins.map((c) => ({
+        name: bytes32ToString(c._name),
+        symbol: bytes32ToString(c._symbol),
+        address: c._address,
+        decimals: Number(c._decimals),
+      }))
+
+      const lpName = bytes32ToString(data.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'}`
+
+      if (!BROKEN_VAULT[chainId].includes(data.vault)) {
+        return {
+          key: `${data.manager.toLowerCase()}-${coins.map((c) => c.symbol.toLowerCase()).join('-')}`,
+          protocol: 'pancakeswap',
+          chainId,
+          isMetapool,
+          isStable,
+          manager: data.manager,
+          pool: data.pool,
+          gaugeAddress: data.gauge,
+          vault: data.vault,
+          lpToken: {
+            name: lpName,
+            symbol: lpSymbol,
+            address: data.lpToken._address,
+            decimals: Number(data.lpToken._decimals),
+          },
+          coins,
+          rewards: data.rewards.map((r) => ({
+            name: r._name,
+            symbol: r._symbol,
+            address: r._address,
+            decimals: Number(r._decimals),
+          })),
+        }
+      }
+
+      return undefined
+    })
+    .filter(Boolean)
+}

package/src/strategies/pancakeswap/config.ts

@@ -0,0 +1,7 @@
+export const PCS_POOLS_CHUNK_SIZE = 30
+export const PCS_POOLS_ERC20_CHUNK_SIZE = 10
+export const PCS_POOLS_NOT_DEPLOYED_CHUNK_SIZE = 10
+
+export const BROKEN_VAULT = {
+  56: ['0xBf94E99cAF355BdEb3Fbb172449EC6E933E7B3Ec'],
+}

package/src/strategies/pancakeswap/endpoints.ts

@@ -0,0 +1,12 @@
+export const CHAINS_DENOMINATOR = {
+  1: 'ethereum',
+  56: 'bsc',
+  42161: 'arbitrum',
+}
+
+export const PANCAKESWAP_FEE_URL = (version: string, chainId: number) => {
+  return `https://explorer-api.pancakeswap.com/cached/pools/apr/${version}/${CHAINS_DENOMINATOR[chainId]}/farms-lp`
+}
+
+export const MANAGER_FEES_ENDPOINT =
+  'https://raw.githubusercontent.com/stake-dao/votemarket-data/main/tvls/pancakeManagersFees.json'

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

@@ -0,0 +1,32 @@
+import { bsc } from 'viem/chains'
+import { MANAGER_FEES_ENDPOINT, PANCAKESWAP_FEE_URL } from '../endpoints.js'
+
+interface PancakeManagerFees {
+  [lp: string]: { token0: string; token1: string }
+}
+
+export const getPancakeSwapManagerFeesAPR = async (chainId: number): Promise<PancakeManagerFees> => {
+  if (chainId !== bsc.id) return {}
+
+  const data = await (await fetch(MANAGER_FEES_ENDPOINT)).json()
+  const res: PancakeManagerFees = {}
+
+  for (const d of data) {
+    res[d.lpAddress.toLowerCase()] = {
+      token0: d.token0,
+      token1: d.token1,
+    }
+  }
+
+  return res
+}
+
+export const getPancakeSwapFeesAPR = async (chainId: number) => {
+  const [v2TradingFees, stableTradingFees, v3TradingFees] = await Promise.all([
+    (await fetch(PANCAKESWAP_FEE_URL('v2', chainId))).json(),
+    (await fetch(PANCAKESWAP_FEE_URL('stable', chainId))).json(),
+    (await fetch(PANCAKESWAP_FEE_URL('v3', chainId))).json(),
+  ])
+
+  return { ...v2TradingFees, ...stableTradingFees, ...v3TradingFees }
+}

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

@@ -0,0 +1,184 @@
+import { encodeAbiParameters, formatUnits, parseAbiParameters } from 'viem'
+
+import { batchPancakeSwapErc20Strats } from '../../../bytecodes/index.js'
+
+import { buildPancakeSwapErc20Strategies } from '../buildErc20.js'
+
+import { ONE_YEAR, STRAT_FEES, contracts, pancakeswapErc20Strats, tokenWithId } from '@stake-dao/constants'
+import { concatBytecode, decodeNewFactoryEvent } from '../../../index.js'
+import { type Price, mergePrices } from '../../../prices.js'
+import { batchJsonRpc, equalTlc } from '../../../utils.js'
+import { getAprBreakdown } from '../../utils/getAprBreakdown.js'
+
+export const getPancakeErc20Vaults = async (
+  rpc: string,
+  chainId: number,
+  basePrices: Price[],
+  feesApr: any,
+  managerFees: any,
+  events: any,
+) => {
+  const oldVaultsAndLp = pancakeswapErc20Strats.strats[chainId]!
+  const newVaultsAndLp = decodeNewFactoryEvent(events).map((e) => ({ vault: e.vault, lpToken: e.lpToken }))
+  const vaultsAndLp = oldVaultsAndLp.concat(newVaultsAndLp)
+
+  const poolsErc20: any[] =
+    vaultsAndLp.length > 0
+      ? await buildPancakeSwapErc20Strategies(oldVaultsAndLp.concat(newVaultsAndLp), rpc, chainId)
+      : []
+
+  if (poolsErc20.length > 0) {
+    const poolsErc20Info = poolsErc20.map((p) => ({ lp: p.lpToken.address, wrapper: p.gaugeAddress, vault: p.vault }))
+
+    const pricesToFetch = poolsErc20
+      .flatMap((p) =>
+        p.coins.map((c) => {
+          const coinPrice = basePrices.find((bp) => equalTlc(bp.address, c.address))?.usdPrice || 0
+          return coinPrice === 0 ? { address: c.address, symbol: c.symbol } : undefined
+        }),
+      )
+      .filter(Boolean)
+    const prices = await mergePrices(basePrices, pricesToFetch, chainId)
+
+    const cake = tokenWithId('cake', chainId)!
+    const cakePriceUsd = prices.find((p) => equalTlc(p.address, cake.address))?.usdPrice || 0
+
+    const poolsErc20InputData = encodeAbiParameters(
+      parseAbiParameters(batchPancakeSwapErc20Strats.inputType[chainId]!) as any,
+      [contracts.cakeLocker![chainId], poolsErc20Info],
+    )
+    const poolsErc20Calls = concatBytecode(batchPancakeSwapErc20Strats.bytecode[chainId]!, poolsErc20InputData)
+    const decodedPromiseErc20 = await batchJsonRpc({
+      rpc,
+      calls: [poolsErc20Calls],
+      outputTypeAbi: batchPancakeSwapErc20Strats.outputTypeHr[chainId],
+      callsKey: `strategies/pancakeswap/fetch/getPancakeErc20Vaults.ts: getPancakeErc20Vaults - chainId ${chainId} - rpc ${rpc}`,
+    })
+
+    const parsedStratsErc20 = poolsErc20.map((strat, index) => {
+      const stratParsedData = decodedPromiseErc20[0].stratsData[index]
+
+      const token0PriceInUsd = prices.find((p) => equalTlc(p.address, strat.coins[0]!.address))?.usdPrice || 0
+      const token1PriceInUsd = prices.find((p) => equalTlc(p.address, strat.coins[1]!.address))?.usdPrice || 0
+
+      const lpPriceInUsd =
+        Number(formatUnits(stratParsedData.token0PerShare, strat.coins[0].decimals)) * token0PriceInUsd +
+        Number(formatUnits(stratParsedData.token1PerShare, strat.coins[1].decimals)) * token1PriceInUsd
+
+      const totalSupply = formatUnits(stratParsedData.sharesDeposited, 18)
+      const tvl = lpPriceInUsd * Number(totalSupply)
+      const tvlTotal = lpPriceInUsd * Number(formatUnits(stratParsedData.sharesTotalSupply, 18))
+
+      let tradingApy = Number(feesApr[strat.lpToken.address.toLowerCase()]?.apr7d || 0)
+      if (!tradingApy && managerFees[strat.pool.toLowerCase()]) {
+        const feesData = managerFees[strat.pool.toLowerCase()]
+        tradingApy = feesData
+          ? ((Number(formatUnits(feesData.token0, strat.coins[0].decimals)) * token0PriceInUsd +
+              Number(formatUnits(feesData.token1, strat.coins[1].decimals)) * token1PriceInUsd) /
+              tvlTotal) *
+            365 *
+            100
+          : 0
+      }
+
+      const boost =
+        Number(formatUnits(stratParsedData.boost, 0)) / Number(formatUnits(stratParsedData.boostPrecision, 0)) ||
+        (strat.manager === 'pancakeswap' ? 2.5 : 3) // Pancake max boost is 2.5, managers farm is 3
+
+      const rewardPerYear = cakePriceUsd * Number(formatUnits(stratParsedData.rewardPerSecond, 18)) * ONE_YEAR
+      const farmApr =
+        tvl > 0
+          ? ((rewardPerYear *
+              (Number(formatUnits(stratParsedData.boostedSharesDeposited, 0)) /
+                Number(formatUnits(stratParsedData.boostedSharesTotalSupply, 0)))) /
+              tvl) *
+            ((100 - STRAT_FEES + 0.5) / 100)
+          : (rewardPerYear / tvlTotal) * boost
+
+      const rewardsData = stratParsedData.sdRewardsData.map((r: any, index: number) => {
+        const rewardToken = strat.rewards[index]
+        const rewardPrice = prices.find((p: any) => equalTlc(p.symbol, rewardToken.symbol))
+
+        const periodFinish = Number(formatUnits(r.period_finish, 0))
+        const streaming = periodFinish > Math.floor(Date.now() / 1000)
+
+        const rewardApr =
+          streaming && rewardPrice && tvl > 0
+            ? (Number(formatUnits(r.rate * BigInt(ONE_YEAR), 18)) * rewardPrice.usdPrice) /
+              tvl /
+              (equalTlc(rewardToken.symbol, 'SDT') ? 2.5 : 1)
+            : 0
+
+        return {
+          token: rewardToken,
+          price: rewardPrice ? rewardPrice.usdPrice : 0,
+          apr: rewardApr * 100,
+          streaming,
+          periodFinish,
+          rate: formatUnits(r.rate, 0),
+          lastUpdate: formatUnits(r.last_update, 0),
+          claimablePendingRewards:
+            rewardToken.symbol === 'CAKE' ? formatUnits(stratParsedData.claimablePendingRewards, 0) : '0',
+        }
+      })
+
+      const apr = getAprBreakdown(
+        { ...strat, minApr: (farmApr / boost) * 100, tradingApy },
+        rewardsData,
+        boost,
+        undefined,
+      )
+
+      const name = strat.coins.reduce((res: string, current) => `${res}/${current.symbol}`, '').slice(1)
+      const subname =
+        strat.manager === 'pancakeswap' ? (strat.lpToken.symbol.includes('Stable LP') ? 'Stable' : 'v2') : strat.manager
+      const version =
+        strat.manager === 'pancakeswap'
+          ? strat.lpToken.symbol.includes('Stable LP')
+            ? 'stable'
+            : '2'
+          : strat.manager.toLowerCase()
+
+      const sdGauge = {
+        address: strat.sdGauge,
+        totalSupply: formatUnits(stratParsedData.sharesDeposited, 0),
+        relativeWeight: '0',
+        weight: '0',
+        futureWeight: '0',
+        workingSupply: '0',
+      }
+
+      return {
+        key: strat.key,
+        name,
+        subname,
+        protocol: strat.protocol,
+        version,
+        chainId: strat.chainId,
+        isMetapool: strat.isMetapool,
+        isStable: strat.isStable,
+        vault: strat.vault,
+        lpToken: strat.lpToken,
+        gaugeAddress: strat.gaugeAddress,
+        pool: strat.pool,
+        manager: strat.manager,
+        coins: strat.coins,
+        sdGauge,
+        lpPriceInUsd,
+        tvl,
+        apr: { ...apr, boost },
+        rewards: rewardsData,
+        // Base APR data
+        tradingApy,
+        minApr: (farmApr / boost) * 100,
+        maxApr: (farmApr / boost) * (strat.manager === 'pancakeswap' ? 2.5 : 3) * 100,
+        // Raw data
+        totalSupply: formatUnits(stratParsedData.sharesDeposited, 0),
+      }
+    })
+
+    return parsedStratsErc20
+  }
+
+  return []
+}

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

@@ -0,0 +1,132 @@
+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
+}

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

@@ -0,0 +1,191 @@
+import { chunk } from 'lodash-es'
+import { encodeAbiParameters, formatUnits, parseAbiParameters } from 'viem'
+
+import { batchPancakeSwapPositions, batchPancakeSwapStrats } from '../../../bytecodes/index.js'
+
+import { getFarmApr } from './pancakeswapMath.js'
+
+import { STRAT_FEES, contracts, tokenWithId } from '@stake-dao/constants'
+import { buildPancakeSwapStrategies, concatBytecode } from '../../../index.js'
+import { type Price, mergePrices } from '../../../prices.js'
+import { batchJsonRpc, equalTlc } from '../../../utils.js'
+import type { PancakeSwapGlobalData } from '../../types.js'
+import { getAprBreakdown } from '../../utils/getAprBreakdown.js'
+import { computePositionData } from './pancakePositions.js'
+
+// NOTE: Need to include mainnet SDT price and sdCAKE in prices args
+export const getPancakeV3Vaults = async (
+  rpc: string,
+  chainId: number,
+  basePrices: Price[],
+  feesApr: any,
+  stakedTVLS: any,
+) => {
+  const pools = await buildPancakeSwapStrategies(rpc, chainId)
+  const poolInfos = pools.map((p) => ({ pid: p.poolId, pool: p.pool }))
+
+  const poolInfosInputArgsChunks = chunk(poolInfos, 20)
+  const poolInfosCalls = poolInfosInputArgsChunks.map((inputArgs) => {
+    const inputData = encodeAbiParameters(parseAbiParameters(batchPancakeSwapStrats.inputType[chainId]!) as any, [
+      contracts.pancakeMasterchef![chainId],
+      inputArgs,
+    ])
+    return concatBytecode(batchPancakeSwapStrats.bytecode[chainId]!, inputData)
+  })
+
+  const decodedPromise = await batchJsonRpc({
+    rpc,
+    calls: poolInfosCalls,
+    outputTypeAbi: batchPancakeSwapStrats.outputTypeHr[chainId]!,
+    callsKey: `strategies/pancakeswap/fetch/getPancakeV3Vaults.ts: getPancakeV3Vaults - chainId ${chainId} - rpc ${rpc}`,
+  })
+
+  const positionsInputData = encodeAbiParameters(
+    parseAbiParameters(batchPancakeSwapPositions.inputType[chainId]!) as any,
+    [contracts.pancakeMasterchef![chainId], contracts.cakeStrategy![chainId], contracts.cakeLocker![chainId]],
+  )
+  const positionsCalls = concatBytecode(batchPancakeSwapPositions.bytecode[chainId]!, positionsInputData)
+
+  const positionsData = await batchJsonRpc({
+    rpc,
+    calls: [positionsCalls],
+    outputTypeAbi: batchPancakeSwapPositions.outputTypeHr[chainId]!,
+    callsKey: `strategies/pancakeswap/fetch/getPancakeV3Vaults.ts: positionsData - chainId ${chainId} - rpc ${rpc}`,
+  })
+
+  const pricesToFetch = pools
+    .flatMap((p) =>
+      p.coins.map((c) => {
+        const coinPrice = basePrices.find((bp) => equalTlc(bp.address, c.address))?.usdPrice || 0
+        return coinPrice === 0 ? { address: c.address, symbol: c.symbol } : undefined
+      }),
+    )
+    .filter(Boolean)
+  const prices = await mergePrices(basePrices, pricesToFetch, chainId)
+
+  const cake = tokenWithId('cake', chainId)!
+  const cakePriceUsd = prices.find((p) => equalTlc(p.address, cake.address))?.usdPrice || 0
+
+  const global: PancakeSwapGlobalData = {
+    totalAllocPoint: '0',
+    inflationRate: '0',
+    fees: {
+      veSdt: 0,
+      perf: 0,
+      accumulator: 0,
+      claimer: 0,
+    },
+  }
+
+  // TODO stratsData type
+  let stratsData: any[] = []
+
+  decodedPromise.forEach((d, index) => {
+    if (index === 0) {
+      global.totalAllocPoint = formatUnits(d.totalAllocPoint, 0)
+      global.inflationRate = formatUnits(d.inflationRate, 30)
+    }
+
+    for (const stratData of d.pancakeSwapStratsData) {
+      const stratParsedData = {
+        poolId: Number(stratData.id),
+        allocPoint: Number(stratData.allocPoint),
+        tick: stratData.tick,
+        sqrtPriceX96: stratData.sqrtPriceX96.toString(),
+        totalLiquidity: stratData.totalLiquidity.toString(),
+        totalBoostLiquidity: stratData.totalBoostLiquidity.toString(),
+        poolLiquidity: stratData.poolLiquidity.toString(),
+      }
+
+      const strat = pools.find((p) => p.poolId === stratParsedData.poolId)
+
+      const token0PriceInUsd = prices.find((p) => equalTlc(p.address, strat.coins[0]!.address))?.usdPrice || 0
+      const token1PriceInUsd = prices.find((p) => equalTlc(p.address, strat.coins[1]!.address))?.usdPrice || 0
+
+      let tvl = 0
+      let boost = 2
+      const poolPositionData = positionsData.filter((p) => Number(p.pid) === strat.poolId)
+      const fees24H = ((feesApr[strat.pool.toLowerCase()]?.volumeUSD24h || 0) * strat.fee) / 10000
+
+      const positions = poolPositionData.map((p) => {
+        const computedPositionData = computePositionData(
+          strat,
+          p,
+          stratParsedData,
+          fees24H,
+          prices,
+          token0PriceInUsd,
+          token1PriceInUsd,
+          global.totalAllocPoint,
+          global.inflationRate,
+        )
+
+        tvl += computedPositionData.tvlToAdd
+        boost = computedPositionData.boost
+
+        return computedPositionData.positionData
+      })
+
+      const protocolTvlData = stakedTVLS[strat.pool]
+      const protocolTvl = protocolTvlData
+        ? Number(protocolTvlData.token0) * token0PriceInUsd + Number(protocolTvlData.token1) * token1PriceInUsd
+        : 0
+
+      const farmApr =
+        getFarmApr({
+          tvlUsd: protocolTvl,
+          cakePriceUsd,
+          cakePerSecond: Number(global.inflationRate),
+          poolWeight: stratParsedData.allocPoint / Number(global.totalAllocPoint),
+        }) *
+        ((100 - STRAT_FEES + 0.5) / 100) // +0.5 because no harvest fee on v3 pools
+
+      const rewards = [
+        {
+          token: strat.rewards[0],
+          apr: farmApr * boost,
+          price: cakePriceUsd,
+          streaming: true,
+          periodFinish: 0,
+          rate: '0',
+          lastUpdate: '0',
+          claimablePendingRewards: '0',
+        },
+      ]
+
+      const tradingApy = Number(feesApr[strat.pool.toLowerCase()]?.apr7d || 0)
+      const apr = getAprBreakdown({ ...strat, tradingApy }, rewards, boost, undefined)
+
+      const parsedData = {
+        key: strat.key,
+        name: strat.coins.reduce((res: string, current) => `${res}/${current.symbol}`, '').slice(1),
+        subname: 'v3',
+        protocol: strat.protocol,
+        version: '3',
+        chainId: strat.chainId,
+        pool: strat.pool,
+        fee: strat.fee,
+        coins: strat.coins,
+        coinsPrice: [token0PriceInUsd, token1PriceInUsd],
+        tvl,
+        apr: { ...apr, boost },
+        rewards,
+        // Positions
+        positions,
+        // Base APR data
+        tradingApy,
+        gaugesProjectedApr: strat.gaugesProjectedApr,
+        minApr: farmApr,
+        maxApr: farmApr * 2,
+        // Raw data
+        tick: Number(stratParsedData.tick),
+        sqrtPriceX96: stratParsedData.sqrtPriceX96.toString(),
+        allocPoint: stratParsedData.allocPoint,
+      }
+
+      stratsData = stratsData.concat(parsedData)
+    }
+  })
+
+  return { global, stratsData }
+}