@stake-dao/reader 0.1.1 → 0.1.2

package/src/lockers/fetch/index.ts

@@ -0,0 +1,407 @@
+import { formatUnits, parseAbi, parseUnits, zeroAddress } from 'viem'
+import { mainnet } from 'viem/chains'
+
+import { ONE_YEAR, lockers, tokenWithId } from '@stake-dao/constants'
+import { delegationWithId } from '@stake-dao/constants'
+import { OneEther, Zero } from '../../index.js'
+import { type Price } from '../../prices.js'
+import { type Call, multicall } from '../../utils.js'
+import { lockedAmountCallSideChain } from '../utils/index.js'
+
+import { type MultiChainCall, multichainMulticall } from '../../utils.js'
+import lockersMulticallAbi from '../abis/MulticallLockers.json'
+import { getCherriesLeaderBoard } from '../utils/getCherriesLeaderBoard.js'
+
+import { extractFees, feeCalls } from '../utils/callsForLockers/feeCalls.js'
+import callsForLockers from '../utils/callsForLockers/index.js'
+import getBribesRewardsData from '../utils/getBribesRewardsData.js'
+import getFees from '../utils/getFees.js'
+import getHttpCalls from '../utils/getHttpCalls.js'
+import getSdtInflationData from '../utils/getSdtInflationData.js'
+import substractFees from '../utils/substractFees.js'
+
+const callsForRewards = (gauge: string, rewards: any[]) =>
+  rewards.map((r) => ({ address: gauge, name: 'reward_data', params: [r.address] }))
+
+const callsForLockersSideChains = (lockerId: any, sideChains: any[]) => {
+  return sideChains.reduce((acc, value) => {
+    return acc.concat([
+      lockedAmountCallSideChain(lockerId, value.veToken, value.locker, value.chainId),
+      { address: value.veToken, name: 'balanceOf', params: [value.locker], chainId: value.chainId },
+      { address: value.veToken, name: 'totalSupply', chainId: value.chainId },
+    ])
+  }, [])
+}
+
+export const fetchLockers = async (provider: any, chainId: number, prices: Price[]) => {
+  const chainLockers = lockers.filter((l) => l.chainId === chainId)
+
+  const httpCalls = await getHttpCalls(chainId)
+
+  const lockersCalls: Call[] = []
+  const lockersRewardsCalls: Call[] = []
+  const lockersFeeCalls: Call[] = []
+  const lockersSideChainsCalls: MultiChainCall[] = []
+
+  for (const locker of chainLockers) {
+    lockersCalls.push(
+      ...callsForLockers(
+        locker.id,
+        locker.token!.address,
+        locker.sdToken!.address,
+        locker.extensions.veToken,
+        locker.extensions.depositor,
+        locker.extensions.gaugeController,
+        locker.extensions.gauge,
+        locker.extensions.locker,
+        locker.extensions.pool,
+        locker.pegCalculator,
+        locker.extensions.secondaryMarket,
+        locker.extensions.voteBooster,
+      ),
+    )
+    lockersRewardsCalls.push(...callsForRewards(locker.extensions.gauge, locker.rewards))
+    if (locker.extensions.sideChains) {
+      lockersSideChainsCalls.push(...callsForLockersSideChains(locker.id, locker.extensions.sideChains))
+    }
+
+    // Add fee calls into another array
+    // We will concat it with #lockersRewardsCalls to do only one multicall, the concat will push all fee calls at the end
+    lockersFeeCalls.push(...feeCalls(locker.id, locker.extensions.accumulator))
+  }
+
+  const [rawLockersData, rawLockersSideChainData] = (
+    await Promise.allSettled([
+      multicall(provider, lockersCalls.concat(lockersFeeCalls), lockersMulticallAbi),
+      multichainMulticall(lockersSideChainsCalls, lockersMulticallAbi),
+    ])
+  ).map((result) => (result.status === 'fulfilled' ? result.value : result.reason))
+
+  const lockersFees = extractFees(chainLockers, rawLockersData)
+
+  const [sdtInflationData, rawLockersRewardsData]: any = await Promise.all([
+    getSdtInflationData(provider),
+    multicall(
+      provider,
+      lockersRewardsCalls,
+      parseAbi([
+        'function reward_data(address) external view returns (address,address,uint256,uint256,uint256,uint256)',
+      ]),
+    ),
+  ])
+
+  const lockerData = chainLockers.map(async (locker) => {
+    const lockerCallsLength = callsForLockers(
+      locker.id,
+      locker.token!.address,
+      locker.sdToken!.address,
+      locker.extensions.veToken,
+      locker.extensions.depositor,
+      locker.extensions.gaugeController,
+      locker.extensions.gauge,
+      locker.extensions.locker,
+      locker.extensions.pool,
+      locker.pegCalculator,
+      locker.extensions.secondaryMarket,
+      locker.extensions.voteBooster,
+    ).length
+    const chunkedRawLockersData = rawLockersData.splice(0, lockerCallsLength)
+
+    let gaugeRelativeWeight = '0'
+    let gaugeTotalWeight = '0'
+    let gaugeWeight = '0'
+    let nextEffectiveTimestamp = '0'
+
+    let airdropGraph: any = undefined
+    if (locker.id === 'cake') {
+      airdropGraph = await getCherriesLeaderBoard()
+    }
+
+    const lockerFee = lockersFees.find((l) => l.lockerId === locker.id)
+    const fees = getFees(locker, lockerFee)
+
+    const tokenLocked = formatUnits(chunkedRawLockersData[0].result[0], 0)
+    const veBalanceOfLockerBN = chunkedRawLockersData[1].result
+    const veBalanceOfLocker = formatUnits(veBalanceOfLockerBN, locker.token!.decimals)
+    const totalTokenLocked = formatUnits(chunkedRawLockersData[2].result, 0)
+    const veTotalSupplyBN = chunkedRawLockersData[3].result
+    const veTotalSupply = formatUnits(veTotalSupplyBN, locker.token!.decimals)
+    const lockIncentive = formatUnits(chunkedRawLockersData[4].result, 0)
+    const incentiveAmountInToken = formatUnits(chunkedRawLockersData[5].result, 0)
+    if (chainId === mainnet.id) {
+      gaugeRelativeWeight = formatUnits(chunkedRawLockersData[6].result, 0)
+      gaugeTotalWeight = formatUnits(chunkedRawLockersData[7].result, 0)
+      gaugeWeight = formatUnits(chunkedRawLockersData[8].result, 0)
+      nextEffectiveTimestamp = formatUnits(chunkedRawLockersData[9].result, 0)
+    }
+
+    const totalSupplyStakedStr =
+      locker.extensions.gauge !== zeroAddress ? formatUnits(chunkedRawLockersData[10].result, 0) : '0'
+    const totalSupplyStaked =
+      locker.extensions.gauge !== zeroAddress
+        ? formatUnits(chunkedRawLockersData[10].result, locker.token!.decimals)
+        : '0'
+
+    const gaugeWorkingSupplyStr =
+      locker.chainId === mainnet.id && locker.extensions.gauge !== zeroAddress
+        ? formatUnits(chunkedRawLockersData[11].result, 0)
+        : '0'
+    const gaugeWorkingSupply =
+      locker.chainId === mainnet.id && locker.extensions.gauge !== zeroAddress
+        ? formatUnits(chunkedRawLockersData[11].result, locker.token!.decimals)
+        : '0'
+    const amountTokenNotLock = formatUnits(chunkedRawLockersData[12].result, 0)
+    const veSdtTotalSupply = chainId === mainnet.id ? chunkedRawLockersData[13].result : '0'
+
+    const voteBoosterBalance = locker.extensions.voteBooster
+      ? {
+          token: formatUnits(chunkedRawLockersData[14].result, locker.token!.decimals),
+          sdToken: formatUnits(chunkedRawLockersData[15].result, locker.sdToken!.decimals),
+          staked:
+            locker.extensions.gauge !== zeroAddress
+              ? formatUnits(chunkedRawLockersData[16].result, locker.sdToken!.decimals)
+              : '0',
+          working:
+            locker.chainId === mainnet.id && locker.extensions.gauge !== zeroAddress
+              ? formatUnits(chunkedRawLockersData[17].result, locker.sdToken!.decimals)
+              : '0',
+        }
+      : undefined
+
+    const voteBoosterBoost = locker.extensions.voteBooster
+      ? Number(voteBoosterBalance!.working) > 0 && Number(voteBoosterBalance!.staked) > 0
+        ? Number(voteBoosterBalance!.working) / (Number(voteBoosterBalance!.staked) * 0.4)
+        : 1
+      : undefined
+
+    const voteBooster = locker.extensions.voteBooster
+      ? { balance: voteBoosterBalance, boost: voteBoosterBoost }
+      : undefined
+
+    const rawPeg =
+      locker.extensions.pool !== zeroAddress
+        ? chunkedRawLockersData[locker.extensions.voteBooster ? 18 : 14].result
+        : undefined
+    const veTokenRate =
+      locker.id === 'mav' ? formatUnits(chunkedRawLockersData[15].result[0], locker.token!.decimals) : '4'
+
+    const futureWeight =
+      BigInt(gaugeTotalWeight) > Zero ? (BigInt(gaugeWeight) * OneEther * OneEther) / BigInt(gaugeTotalWeight) : Zero
+
+    const sideChains = locker.extensions.sideChains?.map((sideChain) => {
+      const tokenLocked = rawLockersSideChainData[sideChain.chainId].shift().result
+      return {
+        ...sideChain,
+        tokenLocked: formatUnits(locker.id === 'mav' ? tokenLocked[0] : tokenLocked, 0),
+        veBalanceOfLocker: formatUnits(rawLockersSideChainData[sideChain.chainId].shift().result, 0),
+        veTotalSupply: formatUnits(rawLockersSideChainData[sideChain.chainId].shift().result, locker.token!.decimals),
+      }
+    })
+
+    let parsedPeg = rawPeg
+    switch (locker.id) {
+      case 'bal': {
+        parsedPeg = rawPeg[1] * BigInt(-1)
+        break
+      }
+      case 'cake': {
+        parsedPeg = rawPeg[0]
+        break
+      }
+    }
+    const peg =
+      rawPeg && parsedPeg ? formatUnits(parsedPeg / parseUnits(locker.pegCalculator.basedOn.toString(), 0), 18) : '-'
+
+    const tokenPrice = prices.find((p) => p.address === locker.token!.address)
+    const tokenPriceInUsd = tokenPrice ? tokenPrice.usdPrice : 0
+    const sdTokenPriceInUsd = peg !== '-' ? tokenPriceInUsd * Number(peg) : tokenPriceInUsd
+
+    const tvl = totalSupplyStaked ? Number(totalSupplyStaked) * sdTokenPriceInUsd : undefined
+
+    // Rewards APR
+    const rewardsData = locker.rewards.map((r) => {
+      const rawData = rawLockersRewardsData.shift().result
+      const rewardPrice = prices.find((p) => p.address === r.address)?.usdPrice || 0
+
+      const periodFinish = rawData ? rawData[2] : Zero
+      const isFinished = Math.floor(Date.now() / 1000) > Number(periodFinish)
+
+      const rate = rawData ? rawData[3] : Zero
+      const oneYearRate = rate * BigInt(ONE_YEAR)
+      const oneYearRewardInUsd = parseUnits(`${rewardPrice}`, locker.token!.decimals) * oneYearRate
+
+      let maxApr = 0
+      switch (locker.id) {
+        case 'mav': {
+          const MAV_AIRDROP = 10_000_000
+          const veMavBalanceOfLocker =
+            Number(veBalanceOfLocker) + sideChains?.reduce((acc, value) => acc + Number(value.veBalanceOfLocker), 0)
+          const veMavTotalSupply =
+            Number(veTotalSupply) + sideChains?.reduce((acc, value) => acc + Number(value.veTotalSupply), 0)
+
+          const mavAirdropStakeDaoShare = MAV_AIRDROP * (veMavBalanceOfLocker / veMavTotalSupply)
+          const airdropPerSdMav = mavAirdropStakeDaoShare / (veMavBalanceOfLocker / Number(veTokenRate))
+
+          maxApr = airdropPerSdMav
+          break
+        }
+        default: {
+          if (isFinished) {
+            maxApr = 0
+          } else {
+            maxApr =
+              rewardPrice && (tvl || 0) > 0
+                ? ((Number(formatUnits(oneYearRate, r.decimals)) * rewardPrice) / tvl!) * 100
+                : 0
+          }
+          break
+        }
+      }
+
+      // Remove fees from APR
+      maxApr = substractFees(locker.id, maxApr, lockerFee)
+      if (r.id === 'sdt' && locker.id !== 'cake') {
+        maxApr = isFinished ? 0 : maxApr
+      }
+      const minApr = maxApr / (locker.id !== 'cake' && r.address === tokenWithId('sdt')!.address ? 2.5 : 1)
+
+      let futureMinApr = minApr
+      let futureMaxApr = maxApr
+
+      if (r.id === 'sdt' && locker.id !== 'cake') {
+        const futureRate = (sdtInflationData.lockersSdtPerSecond * futureWeight) / OneEther
+        const futureOneYearRate = futureRate * BigInt(ONE_YEAR)
+        const futureOneYearRewardInUsd = rewardPrice * Number(formatUnits(futureOneYearRate, locker.token!.decimals))
+
+        futureMaxApr = rewardPrice && (tvl || 0) > 0 ? (futureOneYearRewardInUsd / tvl!) * 100 : 0
+        futureMinApr = futureMaxApr / 2.5
+      }
+
+      return {
+        token: r.address,
+        distributor: rawData ? rawData[1] : zeroAddress,
+        periodFinish: formatUnits(periodFinish, 0),
+        rate: formatUnits(rate, 0),
+        oneYearRate: formatUnits(oneYearRate, 0),
+        oneYearRewardInUsd: formatUnits(oneYearRewardInUsd, 0),
+        lastUpdate: rawData ? Number(formatUnits(rawData[4], 0)) : 0,
+        integral: rawData ? formatUnits(rawData[5], 0) : '0',
+        minApr: minApr,
+        maxApr: maxApr,
+        futureMinApr,
+        futureMaxApr,
+        rewardPrice,
+        isFinished,
+        isAirdrop: r.isAirdrop,
+      }
+    })
+
+    let bribeMinApr = 0
+    let bribeMaxApr = 0
+    let bribeRewards: any = undefined
+
+    if (chainId === mainnet.id) {
+      const data = getBribesRewardsData(
+        locker,
+        httpCalls?.bribesData,
+        veSdtTotalSupply,
+        totalSupplyStaked,
+        veBalanceOfLocker,
+        gaugeWorkingSupply,
+      )
+
+      bribeMinApr = data.bribeMinApr
+      bribeMaxApr = data.bribeMaxApr
+      bribeRewards = data.bribeRewards
+    } else if (locker.id === 'cake') {
+      const apr =
+        (httpCalls?.bribesData?.[delegationWithId('cake')!] || 0) *
+        (Number.parseFloat(veBalanceOfLocker) / Number.parseFloat(totalSupplyStaked))
+      bribeMinApr = apr
+      bribeMaxApr = apr
+      bribeRewards = {
+        bribeMinApr: apr,
+        bribeMaxApr: apr,
+        bribeAverageApr: apr,
+        average: apr,
+        minBoost: 0,
+        maxBoost: 0,
+        hideBoostTab: true,
+        token: 'sdcake',
+      }
+    }
+
+    // Total APR
+    const minRewardsAprs = rewardsData.reduce((x, y) => x + y.minApr, 0) + bribeMinApr
+    const maxRewardsAprs = rewardsData.reduce((x, y) => x + y.maxApr, 0) + bribeMaxApr
+
+    // Streaming status
+    const streaming = rewardsData.some((r) => !r.isFinished)
+    const alternativeYields = JSON.parse(JSON.stringify(locker.alternativeYields || {})) // parse and stringify to avoid extensible issue
+    if (httpCalls?.cvgAprs?.[locker.extensions.gauge]) {
+      alternativeYields.convergenceSdToken = {
+        label: locker.sdToken!.symbol,
+        platform: 'Convergence',
+        href: 'https://app.cvg.finance/',
+        apr: httpCalls.cvgAprs[locker.extensions.gauge].totalApr,
+      }
+    }
+
+    if (httpCalls?.cvgAprs?.[locker.extensions.strategyGauge!]) {
+      alternativeYields[`convergence${locker.sdToken!.symbol}Pool`] = {
+        label: `${locker.sdToken!.symbol}/${locker.token!.symbol}`,
+        platform: 'Convergence',
+        href: 'https://app.cvg.finance/',
+        apr: httpCalls.cvgAprs[locker.extensions.strategyGauge!].totalApr,
+      }
+    }
+
+    return {
+      ...locker,
+      fees,
+      tokenLocked: tokenLocked,
+      veBalanceOfLocker: formatUnits(veBalanceOfLockerBN, 0),
+      totalTokenLocked: totalTokenLocked,
+      veTotalSupply: formatUnits(veTotalSupplyBN, 0),
+      lockIncentive: lockIncentive,
+      incentiveAmountInToken: incentiveAmountInToken,
+      gaugeRelativeWeight: gaugeRelativeWeight,
+      gaugeTotalWeight: gaugeTotalWeight,
+      gaugeWeight: gaugeWeight,
+      futureWeight: formatUnits(futureWeight, 16),
+      gaugeWorkingSupply: gaugeWorkingSupplyStr,
+      nextEffectiveTimestamp: nextEffectiveTimestamp,
+      totalSupplyStaked: totalSupplyStakedStr,
+      amountTokenNotLock: amountTokenNotLock,
+      rewardsData,
+      bribeRewards,
+      apr: [minRewardsAprs, maxRewardsAprs],
+      streaming,
+      veTokenRate,
+      tvl,
+      peg,
+      tokenPriceInUsd,
+      sdTokenPriceInUsd,
+      voteBooster,
+      alternativeYields,
+      extensions: {
+        ...locker.extensions,
+        sideChains,
+        ...(locker.id === 'cake' ? { airdropGraph } : {}),
+      },
+    }
+  })
+
+  return {
+    parsed: (await Promise.allSettled(lockerData)).map((r) => (r.status === 'fulfilled' ? r.value : r.reason)),
+    sdt:
+      chainId === mainnet.id
+        ? {
+            lockersSdtPerBlock: formatUnits(sdtInflationData.lockersSdtPerBlock, 18),
+            lockersSdtPerSecond: formatUnits(sdtInflationData.lockersSdtPerSecond, 18),
+            stratsSdtPerBlock: formatUnits(sdtInflationData.stratsSdtPerBlock, 18),
+            stratsSdtPerSecond: formatUnits(sdtInflationData.stratsSdtPerSecond, 18),
+          }
+        : undefined,
+  }
+}

package/src/lockers/utils/cakeLockerAirdrop.ts

@@ -0,0 +1,73 @@
+import { Zero } from '../../index.js'
+
+const THREE_M_MULTIPLIER = BigInt(10)
+const TEN_M_MULTIPLIER = BigInt(8)
+const TWENTY_FIVE_M_MULTIPLIER = BigInt(5)
+const FIFTY_M_MULTIPLIER = BigInt(3)
+
+export const computeRatePoints = (
+  rate: bigint,
+  timestampStart: bigint,
+  timestampEnd: bigint,
+  global: {
+    threeMTimestamp: bigint
+    tenMTimestamp: bigint
+    twentyFiveMTimestamp: bigint
+    fiftyMTimestamp: bigint
+  },
+  basePoints: bigint = Zero,
+): bigint => {
+  if (global.fiftyMTimestamp > Zero && timestampStart >= global.fiftyMTimestamp) {
+    return basePoints + rate * (timestampEnd - timestampStart)
+  }
+  if (global.twentyFiveMTimestamp > Zero && timestampStart >= global.twentyFiveMTimestamp) {
+    if (global.fiftyMTimestamp > Zero && timestampEnd >= global.fiftyMTimestamp) {
+      const checkpointPoints = basePoints + FIFTY_M_MULTIPLIER * rate * (global.fiftyMTimestamp - timestampStart)
+      return computeRatePoints(rate, global.fiftyMTimestamp, timestampEnd, global, checkpointPoints)
+    }
+    return basePoints + FIFTY_M_MULTIPLIER * rate * (timestampEnd - timestampStart)
+  }
+  if (global.tenMTimestamp > Zero && timestampStart >= global.tenMTimestamp) {
+    if (global.twentyFiveMTimestamp > Zero && timestampEnd >= global.twentyFiveMTimestamp) {
+      const checkpointPoints =
+        basePoints + TWENTY_FIVE_M_MULTIPLIER * rate * (global.twentyFiveMTimestamp - timestampStart)
+      return computeRatePoints(rate, global.twentyFiveMTimestamp, timestampEnd, global, checkpointPoints)
+    }
+    return basePoints + TWENTY_FIVE_M_MULTIPLIER * rate * (timestampEnd - timestampStart)
+  }
+  if (global.threeMTimestamp > Zero && timestampStart >= global.threeMTimestamp) {
+    if (global.tenMTimestamp > Zero && timestampEnd >= global.tenMTimestamp) {
+      const checkpointPoints = basePoints + TEN_M_MULTIPLIER * rate * (global.tenMTimestamp - timestampStart)
+      return computeRatePoints(rate, global.tenMTimestamp, timestampEnd, global, checkpointPoints)
+    }
+    return basePoints + TEN_M_MULTIPLIER * rate * (timestampEnd - timestampStart)
+  }
+  if (global.threeMTimestamp > Zero && timestampEnd >= global.threeMTimestamp) {
+    const checkpointPoints = basePoints + THREE_M_MULTIPLIER * rate * (global.threeMTimestamp - timestampStart)
+    return computeRatePoints(rate, global.threeMTimestamp, timestampEnd, global, checkpointPoints)
+  }
+  return basePoints + THREE_M_MULTIPLIER * rate * (timestampEnd - timestampStart)
+}
+
+export const getUpdatedPointsAmount = (
+  userRate: bigint,
+  userLastUpdate: number,
+  userLastPoints: bigint,
+  airdropGraph: any,
+  timestamp?: number,
+) => {
+  const now = timestamp ? timestamp : Math.floor(Date.now() / 1000)
+
+  return computeRatePoints(
+    userRate,
+    BigInt(userLastUpdate),
+    BigInt(now),
+    {
+      threeMTimestamp: BigInt(airdropGraph.threeMTimestamp),
+      tenMTimestamp: BigInt(airdropGraph.tenMTimestamp),
+      twentyFiveMTimestamp: BigInt(airdropGraph.twentyFiveMTimestamp),
+      fiftyMTimestamp: BigInt(airdropGraph.fiftyMTimestamp),
+    },
+    userLastPoints,
+  )
+}

package/src/lockers/utils/callsForLockers/depositorCalls.ts

@@ -0,0 +1,25 @@
+import { lockerWithId } from '@stake-dao/constants'
+
+const depositorCalls = (depositor: string, locker: string) => {
+  const calls: any[] = []
+
+  if (
+    [
+      lockerWithId('crv')!.extensions.locker,
+      lockerWithId('mav')!.extensions.locker,
+      lockerWithId('cake', 56)!.extensions.locker,
+      lockerWithId('fxn')!.extensions.locker,
+      lockerWithId('yfi')!.extensions.locker,
+    ].includes(locker)
+  ) {
+    calls.push({ address: depositor, name: 'lockIncentivePercent' })
+  } else {
+    calls.push({ address: depositor, name: 'lockIncentive' })
+  }
+
+  calls.push({ address: depositor, name: 'incentiveToken' })
+
+  return calls
+}
+
+export default depositorCalls

package/src/lockers/utils/callsForLockers/feeCalls.ts

@@ -0,0 +1,118 @@
+import { zeroAddress } from 'viem'
+
+import { Zero } from '../../../index.js'
+
+export const feeCalls = (lockerId: string, accumulatorAddress: string) => {
+  const calls: any[] = []
+
+  if (accumulatorAddress === zeroAddress || lockerId === 'mav') {
+    return calls
+  }
+
+  // Harvester fees
+  calls.push({ address: accumulatorAddress, name: 'claimerFee', params: [] })
+
+  // Treasury
+  if (['crv', 'cake', 'yfi', 'pendle', 'fpis'].includes(lockerId)) {
+    calls.push({ address: accumulatorAddress, name: 'daoFee', params: [] })
+  }
+
+  switch (lockerId) {
+    case 'crv':
+      calls.push({ address: accumulatorAddress, name: 'liquidityFee', params: [] })
+      break
+    case 'cake':
+    case 'yfi':
+      calls.push({ address: accumulatorAddress, name: 'liquidityFee', params: [] })
+      break
+    case 'pendle':
+      calls.push({ address: accumulatorAddress, name: 'bountyFee', params: [] })
+      break
+    case 'fpis':
+      calls.push({ address: accumulatorAddress, name: 'bribeFee', params: [] })
+      break
+    case 'apw':
+    case 'bpt':
+      calls.push({ address: accumulatorAddress, name: 'lockerFee', params: [] })
+      break
+  }
+
+  return calls
+}
+
+export interface ILockerFee {
+  lockerId: string
+  claimerFee: bigint
+  daoFee: bigint
+  bountyFee: bigint
+  liquidityFee: bigint
+  lockerFee: bigint
+}
+
+export const extractFees = (lockers: any, feesData: any): ILockerFee[] => {
+  const results: ILockerFee[] = []
+
+  // We reverse it because all fee calls was pushed in the locker array order
+  // It's easier to get back fees with the pop function
+  // And we slice it because the reverse modify the original array
+  const lockersReverse = lockers.slice().reverse()
+
+  for (const locker of lockersReverse) {
+    if (locker.extensions.accumulator === zeroAddress || locker.id === 'mav') {
+      const claimerFee = locker.fees.find((f) => f.key === 'claimerFee')
+      const daoFee = locker.fees.find((f) => f.key === 'daoFee')
+      const bountyFee = locker.fees.find((f) => f.key === 'bountyFee')
+      const liquidityFee = locker.fees.find((f) => f.key === 'liquidityFee')
+      const lockerFee = locker.fees.find((f) => f.key === 'lockerFee')
+
+      results.push({
+        lockerId: locker.id,
+        claimerFee: claimerFee ? BigInt(claimerFee.value * 100) : Zero,
+        daoFee: daoFee ? BigInt(daoFee.value * 100) : Zero,
+        bountyFee: bountyFee ? BigInt(bountyFee.value * 100) : Zero,
+        liquidityFee: liquidityFee ? BigInt(liquidityFee.value * 100) : Zero,
+        lockerFee: lockerFee ? BigInt(lockerFee.value * 100) : Zero,
+      })
+      continue
+    }
+
+    let daoFee = Zero
+    let bountyFee = Zero
+    let liquidityFee = Zero
+    let lockerFee = Zero
+
+    switch (locker.id) {
+      case 'crv':
+        liquidityFee = BigInt(feesData.pop()?.result)
+        daoFee = BigInt(feesData.pop()?.result)
+        break
+      case 'cake':
+      case 'yfi':
+        liquidityFee = BigInt(feesData.pop()?.result)
+        daoFee = BigInt(feesData.pop()?.result)
+        break
+      case 'pendle':
+      case 'fpis':
+        bountyFee = BigInt(feesData.pop()?.result)
+        daoFee = BigInt(feesData.pop()?.result)
+        break
+      case 'apw':
+      case 'bpt':
+        lockerFee = BigInt(feesData.pop()?.result)
+        break
+    }
+
+    const claimerFee = BigInt(feesData.pop()?.result)
+
+    results.push({
+      lockerId: locker.id,
+      claimerFee,
+      daoFee,
+      bountyFee,
+      liquidityFee,
+      lockerFee,
+    })
+  }
+
+  return results
+}

package/src/lockers/utils/callsForLockers/gaugeCalls.ts

@@ -0,0 +1,6 @@
+const gaugeCalls = (gauge: string) => [
+  { address: gauge, name: 'totalSupply' },
+  { address: gauge, name: 'working_supply' },
+]
+
+export default gaugeCalls

package/src/lockers/utils/callsForLockers/gaugeControllerCalls.ts

@@ -0,0 +1,8 @@
+const gaugeControllerCalls = (gaugeController: string, gauge: string) => [
+  { address: gaugeController, name: 'gauge_relative_weight', params: [gauge] },
+  { address: gaugeController, name: 'get_total_weight' },
+  { address: gaugeController, name: 'get_gauge_weight', params: [gauge] },
+  { address: gaugeController, name: 'time_total' },
+]
+
+export default gaugeControllerCalls

package/src/lockers/utils/callsForLockers/index.ts

@@ -0,0 +1,44 @@
+import { FOUR_YEAR } from '@stake-dao/constants'
+import { OneEther } from '../../../index.js'
+
+import depositorCalls from './depositorCalls.js'
+import gaugeCalls from './gaugeCalls.js'
+import gaugeControllerCalls from './gaugeControllerCalls.js'
+import pegCalls from './pegCalls.js'
+import veCalls from './veCalls.js'
+import veSdtCalls from './veSdtCalls.js'
+
+const callsForLockers = (
+  lockerId: string,
+  token: string,
+  sdToken: string,
+  votingEscrow: string,
+  depositor: string,
+  gaugeController: string,
+  gauge: string,
+  locker: string,
+  pool: string,
+  pegInfo: any,
+  secondaryMarket: string,
+  voteBooster: any,
+) => [
+  ...veCalls(lockerId, votingEscrow, locker, token),
+  ...depositorCalls(depositor, locker),
+  ...gaugeControllerCalls(gaugeController, gauge),
+  ...gaugeCalls(gauge),
+  // Token
+  { address: token, name: 'balanceOf', params: [depositor] },
+  ...veSdtCalls(voteBooster, token, sdToken, gauge),
+  pegCalls(secondaryMarket, pool, pegInfo, sdToken, token),
+  ...(lockerId === 'mav'
+    ? [
+        {
+          address: votingEscrow,
+          name: 'previewPoints',
+          params: [OneEther, FOUR_YEAR],
+        },
+      ]
+    : []),
+]
+
+export default callsForLockers