@stake-dao/reader 0.2.21 → 0.3.1

package/src/lockers/fetch/index.ts

@@ -1,23 +1,21 @@
-import { formatUnits, parseAbi, parseUnits, zeroAddress } from 'viem'
+import { type Locker, ONE_YEAR, delegationWithId, lockers } from '@stake-dao/constants'
+import { formatUnits, parseAbi, 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, getSdtInflationData } from '../../index.js'
-import { type Price } from '../../prices.js'
-import { type Call, multicall } from '../../utils.js'
-import { lockedAmountCallSideChain } from '../utils/index.js'
-
 import lockersMulticallAbi from '../../abis/lockersMulticall.js'
-import { type MultiChainCall, multichainMulticall } from '../../utils.js'
-import { getCherriesLeaderBoard } from '../utils/getCherriesLeaderBoard.js'
-
+import { Zero, getSdtInflationData } from '../../index.js'
+import type { Price } from '../../prices.js'
+import { handlePromise } from '../../strategies/utils/promise.js'
+import { type Call, type MultiChainCall, multicall, multichainMulticall } from '../../utils.js'
 import { extractFees, feeCalls } from '../utils/callsForLockers/feeCalls.js'
 import callsForLockers from '../utils/callsForLockers/index.js'
-import getBribesRewardsData from '../utils/getBribesRewardsData.js'
+import getBribesRewardsData, { type TBribesRewards } from '../utils/getBribesRewardsData.js'
+import { getCherriesLeaderBoard } from '../utils/getCherries.js'
 import getFees from '../utils/getFees.js'
 import getHttpCalls from '../utils/getHttpCalls.js'
+import { lockedAmountCallSideChain } from '../utils/index.js'
 import substractFees from '../utils/substractFees.js'
+import { parsePeg } from './parsePeg.js'
+import { parseVoteBoosterData } from './parseVoteBoosterData.js'
 
 const callsForRewards = (gauge: string, rewards: any[]) =>
   rewards.map((r) => ({ address: gauge, name: 'reward_data', params: [r.address] }))
@@ -32,8 +30,15 @@ const callsForLockersSideChains = (lockerId: any, sideChains: any[]) => {
   }, [])
 }
 
-export const fetchLockers = async (provider: any, chainId: number, prices: Price[]) => {
-  const chainLockers = lockers.filter((l) => l.chainId === chainId)
+interface TFetchLockers {
+  provider: any
+  chainId: number
+  prices: Price[]
+  withAirdropGraph?: boolean
+}
+
+export const fetchLockers = async ({ provider, chainId, prices, withAirdropGraph }: TFetchLockers) => {
+  const chainLockers: Locker[] = lockers.filter((l) => l.chainId === chainId)
 
   const httpCalls = await getHttpCalls(chainId)
 
@@ -46,263 +51,148 @@ export const fetchLockers = async (provider: any, chainId: number, prices: Price
     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,
+        locker.token.address,
+        locker.sdToken.address,
+        locker.modules.veToken,
+        locker.modules.depositor,
+        locker.modules.gauge,
+        locker.modules.locker,
+        locker.secondaryMarket,
+        locker.voteBooster,
       ),
     )
-    lockersRewardsCalls.push(...callsForRewards(locker.extensions.gauge, locker.rewards))
+    lockersRewardsCalls.push(...callsForRewards(locker.modules.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))
+    lockersFeeCalls.push(...feeCalls(locker.id, locker.modules.accumulator))
   }
 
-  const [rawLockersData, rawLockersSideChainData] = (
-    await Promise.allSettled([
+  const [rawLockersData, rawLockersSideChainData, rawLockersRewardsData] = await handlePromise(
+    [
       multicall(provider, lockersCalls.concat(lockersFeeCalls), lockersMulticallAbi),
       multichainMulticall(lockersSideChainsCalls, lockersMulticallAbi),
-    ])
-  ).map((result) => (result.status === 'fulfilled' ? result.value : result.reason))
+      multicall(
+        provider,
+        lockersRewardsCalls,
+        parseAbi([
+          'function reward_data(address) external view returns (address,address,uint256,uint256,uint256,uint256)',
+        ]),
+      ),
+    ],
+    'lockerMulticalls',
+  )
 
   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 sdtInflationData = chainId === mainnet.id ? await getSdtInflationData(provider) : undefined
 
   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,
+      locker.token.address,
+      locker.sdToken.address,
+      locker.modules.veToken,
+      locker.modules.depositor,
+      locker.modules.gauge,
+      locker.modules.locker,
+      locker.secondaryMarket,
+      locker.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') {
+    let airdropGraph: any
+    if (locker.id === 'cake' && withAirdropGraph) {
       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 tokenLocked = formatUnits(chunkedRawLockersData[0].result[0], locker.token.decimals)
+    const veBalanceOfLocker = formatUnits(chunkedRawLockersData[1].result, locker.token.decimals)
+    const totalTokenLocked = formatUnits(chunkedRawLockersData[2].result, locker.token.decimals)
+    const veTotalSupply = formatUnits(chunkedRawLockersData[3].result, 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 incentiveAmountInToken = formatUnits(chunkedRawLockersData[5].result, locker.token.decimals)
 
-    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'
+      locker.modules.gauge !== zeroAddress ? formatUnits(chunkedRawLockersData[6].result, locker.token.decimals) : '0'
     const gaugeWorkingSupply =
-      locker.chainId === mainnet.id && locker.extensions.gauge !== zeroAddress
-        ? formatUnits(chunkedRawLockersData[11].result, locker.token!.decimals)
+      locker.chainId === mainnet.id && locker.modules.gauge !== zeroAddress
+        ? formatUnits(chunkedRawLockersData[7].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 amountTokenNotLock = formatUnits(chunkedRawLockersData[8].result, locker.token.decimals)
+    const veSdtTotalSupply = chainId === mainnet.id ? chunkedRawLockersData[9].result : '0'
+
+    const voteBooster = parseVoteBoosterData(locker, chunkedRawLockersData)
+    const peg = parsePeg(locker, chunkedRawLockersData)
 
-    const futureWeight =
-      BigInt(gaugeTotalWeight) > Zero ? (BigInt(gaugeWeight) * OneEther * OneEther) / BigInt(gaugeTotalWeight) : Zero
+    const veTokenRate =
+      locker.id === 'mav' ? formatUnits(chunkedRawLockersData[11].result[0], locker.token.decimals) : '4'
 
     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),
+        tokenLocked: formatUnits(locker.id === 'mav' ? tokenLocked[0] : tokenLocked, locker.token.decimals),
+        veBalanceOfLocker: formatUnits(
+          rawLockersSideChainData[sideChain.chainId].shift().result,
+          locker.token.decimals,
+        ),
+        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 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
+    const tvl = totalSupplyStaked ? Number(totalSupplyStaked) * sdTokenPriceInUsd : 0
 
     // 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 periodFinish = Number(formatUnits(rawData ? rawData[2] : Zero, 0))
+      const streaming = periodFinish > Math.floor(Date.now() / 1000)
 
       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
+      let apr = streaming
+        ? rewardPrice && tvl > 0
+          ? ((Number(formatUnits(oneYearRate, r.decimals)) * rewardPrice) / tvl) * 100
+          : 0
+        : 0
 
-      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
-      }
+      // Remove fees from APR
+      apr = substractFees(locker.id, apr, lockerFee)
 
       return {
-        token: r.address,
-        distributor: rawData ? rawData[1] : zeroAddress,
-        periodFinish: formatUnits(periodFinish, 0),
+        token: r,
+        price: rewardPrice,
+        apr,
+        streaming,
+        periodFinish,
         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,
+        lastUpdate: rawData ? formatUnits(rawData[4], 0) : '0',
         isAirdrop: r.isAirdrop,
       }
     })
 
     let bribeMinApr = 0
     let bribeMaxApr = 0
-    let bribeRewards: any = undefined
+    let bribeRewards: TBribesRewards | undefined = undefined
 
     if (chainId === mainnet.id) {
       const data = getBribesRewardsData(
         locker,
-        httpCalls?.bribesData,
+        httpCalls.bribesData,
         veSdtTotalSupply,
         totalSupplyStaked,
         veBalanceOfLocker,
@@ -314,7 +204,7 @@ export const fetchLockers = async (provider: any, chainId: number, prices: Price
       bribeRewards = data.bribeRewards
     } else if (locker.id === 'cake') {
       const apr =
-        (httpCalls?.bribesData?.[delegationWithId('cake')!] || 0) *
+        (httpCalls.bribesData?.[delegationWithId('cake')!] || 0) *
         (Number.parseFloat(veBalanceOfLocker) / Number.parseFloat(totalSupplyStaked))
       bribeMinApr = apr
       bribeMaxApr = apr
@@ -322,57 +212,51 @@ export const fetchLockers = async (provider: any, chainId: number, prices: Price
         bribeMinApr: apr,
         bribeMaxApr: apr,
         bribeAverageApr: apr,
-        average: apr,
-        minBoost: 0,
-        maxBoost: 0,
+        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
+    const minRewardsAprs = rewardsData.reduce((x, y) => x + y.apr, 0) + bribeMinApr
+    const maxRewardsAprs = rewardsData.reduce((x, y) => x + y.apr, 0) + bribeMaxApr
 
     // Streaming status
-    const streaming = rewardsData.some((r) => !r.isFinished)
+    const streaming = rewardsData.some((r) => r.streaming)
     const alternativeYields = JSON.parse(JSON.stringify(locker.alternativeYields || {})) // parse and stringify to avoid extensible issue
-    if (httpCalls?.cvgAprs?.[locker.extensions.gauge]) {
+    if (httpCalls.cvgAprs?.[locker.modules.gauge]) {
       alternativeYields.convergenceSdToken = {
-        label: locker.sdToken!.symbol,
+        label: locker.sdToken.symbol,
         platform: 'Convergence',
         href: 'https://app.cvg.finance/',
-        apr: httpCalls.cvgAprs[locker.extensions.gauge].totalApr,
+        apr: httpCalls.cvgAprs[locker.modules.gauge].totalApr,
       }
     }
 
-    if (httpCalls?.cvgAprs?.[locker.extensions.strategyGauge!]) {
-      alternativeYields[`convergence${locker.sdToken!.symbol}Pool`] = {
-        label: `${locker.sdToken!.symbol}/${locker.token!.symbol}`,
+    if (locker.extensions.strategyGauge && 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,
+        apr: locker.extensions.strategyGauge ? httpCalls.cvgAprs[locker.extensions.strategyGauge].totalApr : 0,
       }
     }
 
     return {
       ...locker,
+      rewards: rewardsData,
       fees,
       tokenLocked: tokenLocked,
-      veBalanceOfLocker: formatUnits(veBalanceOfLockerBN, 0),
+      veBalanceOfLocker: veBalanceOfLocker,
       totalTokenLocked: totalTokenLocked,
-      veTotalSupply: formatUnits(veTotalSupplyBN, 0),
+      veTotalSupply: veTotalSupply,
       lockIncentive: lockIncentive,
       incentiveAmountInToken: incentiveAmountInToken,
-      gaugeRelativeWeight: gaugeRelativeWeight,
-      gaugeTotalWeight: gaugeTotalWeight,
-      gaugeWeight: gaugeWeight,
-      futureWeight: formatUnits(futureWeight, 16),
-      gaugeWorkingSupply: gaugeWorkingSupplyStr,
-      nextEffectiveTimestamp: nextEffectiveTimestamp,
-      totalSupplyStaked: totalSupplyStakedStr,
+      gaugeWorkingSupply: gaugeWorkingSupply,
+      totalSupplyStaked: totalSupplyStaked,
       amountTokenNotLock: amountTokenNotLock,
-      rewardsData,
       bribeRewards,
       apr: [minRewardsAprs, maxRewardsAprs],
       streaming,
@@ -392,9 +276,9 @@ export const fetchLockers = async (provider: any, chainId: number, prices: Price
   })
 
   return {
-    parsed: (await Promise.allSettled(lockerData)).map((r) => (r.status === 'fulfilled' ? r.value : r.reason)),
+    parsed: await Promise.all(lockerData),
     sdt:
-      chainId === mainnet.id
+      chainId === mainnet.id && sdtInflationData
         ? {
             lockersSdtPerBlock: formatUnits(sdtInflationData.lockersSdtPerBlock, 18),
             lockersSdtPerSecond: formatUnits(sdtInflationData.lockersSdtPerSecond, 18),

package/src/lockers/fetch/parsePeg.ts

@@ -0,0 +1,25 @@
+import { type Locker } from '@stake-dao/constants'
+import { formatUnits, parseUnits, zeroAddress } from 'viem'
+
+export const parsePeg = (locker: Locker, chunkedRawLockersData: any) => {
+  const rawPeg =
+    locker.secondaryMarket?.pool !== zeroAddress
+      ? chunkedRawLockersData[locker.voteBooster ? 14 : 10].result
+      : undefined
+
+  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.secondaryMarket?.pegBase?.toString() || '1', 0), 18)
+      : '-'
+
+  return peg
+}

package/src/lockers/fetch/parseVoteBoosterData.ts

@@ -0,0 +1,34 @@
+import { type Locker } from '@stake-dao/constants'
+import { formatUnits, zeroAddress } from 'viem'
+import { mainnet } from 'viem/chains'
+
+export const parseVoteBoosterData = (locker: Locker, chunkedRawLockersData: any) => {
+  if (locker.voteBooster) {
+    const voteBoosterBalance = {
+      token: formatUnits(chunkedRawLockersData[10].result, locker.token.decimals),
+      sdToken: formatUnits(chunkedRawLockersData[11].result, locker.sdToken.decimals),
+      staked:
+        locker.modules.gauge !== zeroAddress
+          ? formatUnits(chunkedRawLockersData[12].result, locker.sdToken.decimals)
+          : '0',
+      working:
+        locker.chainId === mainnet.id && locker.modules.gauge !== zeroAddress
+          ? formatUnits(chunkedRawLockersData[13].result, locker.sdToken.decimals)
+          : '0',
+    }
+
+    const voteBoosterBoost =
+      voteBoosterBalance && Number(voteBoosterBalance.working) > 0 && Number(voteBoosterBalance.staked) > 0
+        ? Number(voteBoosterBalance.working) / (Number(voteBoosterBalance.staked) * 0.4)
+        : 1
+
+    return {
+      booster: locker.voteBooster.booster,
+      vSdToken: locker.voteBooster.vSdToken,
+      balance: voteBoosterBalance,
+      boost: voteBoosterBoost,
+    }
+  }
+
+  return undefined
+}

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

@@ -1,15 +1,16 @@
 import { lockerWithId } from '@stake-dao/constants'
+import type { Address } from 'viem'
 
-const depositorCalls = (depositor: string, locker: string) => {
+const depositorCalls = (depositor: string, locker: Address) => {
   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,
+      lockerWithId('crv')!.modules.locker,
+      lockerWithId('mav')!.modules.locker,
+      lockerWithId('cake', 56)!.modules.locker,
+      lockerWithId('fxn')!.modules.locker,
+      lockerWithId('yfi')!.modules.locker,
     ].includes(locker)
   ) {
     calls.push({ address: depositor, name: 'lockIncentivePercent' })

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

@@ -1,39 +1,39 @@
-import { zeroAddress } from 'viem'
-
+import { type Address, zeroAddress } from 'viem'
 import { Zero } from '../../../index.js'
+import type { Call } from '../../../utils.js'
 
-export const feeCalls = (lockerId: string, accumulatorAddress: string) => {
-  const calls: any[] = []
+export const feeCalls = (lockerId: string, accumulatorAddress: Address) => {
+  const calls: Call[] = []
 
   if (accumulatorAddress === zeroAddress || lockerId === 'mav') {
     return calls
   }
 
   // Harvester fees
-  calls.push({ address: accumulatorAddress, name: 'claimerFee', params: [] })
+  calls.push({ address: accumulatorAddress, name: 'claimerFee' })
 
   // Treasury
-  if (['crv', 'cake', 'yfi', 'pendle', 'fpis'].includes(lockerId)) {
-    calls.push({ address: accumulatorAddress, name: 'daoFee', params: [] })
+  if (['cake', 'yfi', 'pendle', 'fpis'].includes(lockerId)) {
+    calls.push({ address: accumulatorAddress, name: 'daoFee' })
   }
 
   switch (lockerId) {
     case 'crv':
-      calls.push({ address: accumulatorAddress, name: 'liquidityFee', params: [] })
+      calls.push({ address: accumulatorAddress, name: 'getFeeSplit' })
       break
     case 'cake':
     case 'yfi':
-      calls.push({ address: accumulatorAddress, name: 'liquidityFee', params: [] })
+      calls.push({ address: accumulatorAddress, name: 'liquidityFee' })
       break
     case 'pendle':
-      calls.push({ address: accumulatorAddress, name: 'bountyFee', params: [] })
+      calls.push({ address: accumulatorAddress, name: 'bountyFee' })
       break
     case 'fpis':
-      calls.push({ address: accumulatorAddress, name: 'bribeFee', params: [] })
+      calls.push({ address: accumulatorAddress, name: 'bribeFee' })
       break
     case 'apw':
     case 'bpt':
-      calls.push({ address: accumulatorAddress, name: 'lockerFee', params: [] })
+      calls.push({ address: accumulatorAddress, name: 'lockerFee' })
       break
   }
 
@@ -82,10 +82,12 @@ export const extractFees = (lockers: any, feesData: any): ILockerFee[] => {
     let lockerFee = Zero
 
     switch (locker.id) {
-      case 'crv':
-        liquidityFee = BigInt(feesData.pop()?.result)
-        daoFee = BigInt(feesData.pop()?.result)
+      case 'crv': {
+        const crvFees = feesData.pop()?.result
+        daoFee = BigInt(crvFees.fees[0])
+        liquidityFee = BigInt(crvFees.fees[1])
         break
+      }
       case 'cake':
       case 'yfi':
         liquidityFee = BigInt(feesData.pop()?.result)