@stake-dao/reader 0.4.111 → 0.5.0

package/src/abis/lockersMulticall.ts

@@ -1,4 +1,4 @@
-const lockersMulticallAbi = (chainId = 1) => [
+const lockersMulticallAbi = (lockerId = '', chainId = 1) => [
   {
     inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
     name: 'balanceOf',
@@ -6,6 +6,13 @@ const lockersMulticallAbi = (chainId = 1) => [
     stateMutability: 'view',
     type: 'function',
   },
+  {
+    inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
+    name: 'getVotes',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
   {
     inputs: [],
     name: 'totalSupply',
@@ -13,6 +20,13 @@ const lockersMulticallAbi = (chainId = 1) => [
     stateMutability: 'view',
     type: 'function',
   },
+  {
+    inputs: [],
+    name: 'totalVotes',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
   {
     name: 'locked',
     outputs: [
@@ -37,6 +51,20 @@ const lockersMulticallAbi = (chainId = 1) => [
     stateMutability: 'view',
     type: 'function',
   },
+  {
+    stateMutability: 'view',
+    type: 'function',
+    name: 'reward_data',
+    inputs: [{ name: 'arg0', type: 'address' }],
+    outputs: [
+      { name: 'token', type: 'address' },
+      { name: 'distributor', type: 'address' },
+      { name: 'period_finish', type: 'uint256' },
+      { name: 'rate', type: 'uint256' },
+      { name: 'last_update', type: 'uint256' },
+      { name: 'integral', type: 'uint256' },
+    ],
+  },
   {
     name: 'getLockedNftDetails',
     outputs: [
@@ -335,7 +363,7 @@ const lockersMulticallAbi = (chainId = 1) => [
     stateMutability: 'view',
     type: 'function',
   },
-  [8453, 59144].includes(chainId)
+  ['crv'].includes(lockerId) || [8453, 59144].includes(chainId)
     ? {
         inputs: [],
         name: 'getFeeSplit',

package/src/index.ts

@@ -18,9 +18,10 @@ export { fetchSdt } from './sdt/fetch.js'
 /// --- LOCKERS
 ////////////////////////////////////////////////////////////////
 export { fetchLockers } from './lockers/fetch/index.js'
+export { staticLockers } from './lockers/fetch/static.js'
 export { getVeNFTUser } from './lockers/utils/getVeNFTUser.js'
 export { default as pegCalls } from './lockers/utils/callsForLockers/pegCalls.js'
-export { parsePeg } from './lockers/fetch/parsePeg.js'
+export { lockerWithAutovoter } from './lockers/utils/getBribesRewardsData.js'
 
 ////////////////////////////////////////////////////////////////
 /// --- STATEGIES

package/src/lockers/fetch/index.ts

@@ -1,339 +1,75 @@
-import { type Locker, ONE_YEAR, RPC, Zero, contract, lockers } from '@stake-dao/constants'
-import { formatUnits, parseAbi, zeroAddress } from 'viem'
-import { mainnet } from 'viem/chains'
-import lockersMulticallAbi from '../../abis/lockersMulticall.js'
-import { getSdtInflationData } from '../../index.js'
+import { RPC, contract } from '@stake-dao/constants'
+import { formatUnits } from 'viem'
+import { base, bsc, fraxtal, linea, mainnet } from 'viem/chains'
+import { GH_STAKE_DAO_BOUNTIES_REPORT } from '../../endpoints.js'
+import { getSdtInflationData, rpcCall } from '../../index.js'
 import type { Price } from '../../prices.js'
-import { handlePromise } from '../../strategies/utils/promise.js'
-import { type Call, type MultiChainCall, equalTlc, multicall, multichainMulticall, rpcCall } from '../../utils.js'
-import { extractFees, feeCalls } from '../utils/callsForLockers/feeCalls.js'
-import callsForLockers from '../utils/callsForLockers/index.js'
-import getBribesRewardsData, { type TBribesRewards } from '../utils/getBribesRewardsData.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 { parseBoost, parseVeBoostApr } from './parseBoost.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] }))
-
-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 },
-    ])
-  }, [])
-}
+import angleLocker from './protocols/angle.js'
+import balancerLocker from './protocols/balancer.js'
+import blackpoolLocker from './protocols/blackpool.js'
+import curveLocker from './protocols/curve.js'
+import fraxFpisLocker from './protocols/frax-fpis.js'
+import fraxFxsLocker from './protocols/frax-fxs.js'
+import fxnLocker from './protocols/fxn.js'
+import maverickLocker from './protocols/maverick.js'
+import pancakeswapLocker from './protocols/pancakeswap.js'
+import pendleLocker from './protocols/pendle.js'
+import spectraLocker from './protocols/spectra.js'
+import yearnLocker from './protocols/yearn.js'
+import yieldbasisLocker from './protocols/yieldbasis.js'
+import yieldnestLocker from './protocols/yieldnest.js'
+import zerolendLocker from './protocols/zerolend.js'
 
 interface TFetchLockers {
-  provider: any
-  chainId: number
+  provider: { [chainId: number]: any }
   prices: Price[]
 }
 
-export const fetchLockers = async ({ provider, chainId, prices }: TFetchLockers) => {
-  const chainLockers: Locker[] = 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.modules.veToken,
-        locker.modules.depositor,
-        locker.modules.gauge,
-        locker.modules.locker,
-        locker.secondaryMarket,
-        locker.voteBooster,
-        locker.veBoost,
-        locker.modules.veNFT,
-      ),
-    )
-    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.modules.accumulator))
-  }
-
-  const [rawLockersData, rawLockersSideChainData, rawLockersRewardsData, rawVeSdtTotalSupply] = await handlePromise(
-    [
-      multicall(provider, lockersCalls.concat(lockersFeeCalls), lockersMulticallAbi(chainId)),
-      multichainMulticall(lockersSideChainsCalls, lockersMulticallAbi()),
-      multicall(
-        provider,
-        lockersRewardsCalls,
-        parseAbi([
-          'function reward_data(address) external view returns (address,address,uint256,uint256,uint256,uint256)',
-        ]),
-      ),
-      rpcCall(RPC[mainnet.id], [{ to: contract('veSdt', mainnet.id), data: '0x18160ddd' }]),
-    ],
-    'lockerMulticalls',
-  )
-
-  const lockersFees = extractFees(chainLockers, rawLockersData)
-
-  const sdtInflationData = chainId === mainnet.id ? await getSdtInflationData(provider) : undefined
-  const veSdtTotalSupply = BigInt(rawVeSdtTotalSupply[0].result)
-
-  const lockerData = chainLockers.map(async (locker) => {
-    const lockerCallsLength = callsForLockers(
-      locker.id,
-      locker.token.address,
-      locker.sdToken.address,
-      locker.modules.veToken,
-      locker.modules.depositor,
-      locker.modules.gauge,
-      locker.modules.locker,
-      locker.secondaryMarket,
-      locker.voteBooster,
-      locker.veBoost,
-      locker.modules.veNFT,
-    ).length
-    const chunkedRawLockersData = rawLockersData.splice(0, lockerCallsLength)
-
-    const lockerFee = lockersFees.find((l) => l.lockerId === locker.id)
-    const fees = getFees(locker, lockerFee)
-
-    const tokenLocked = formatUnits(
-      chunkedRawLockersData[0].result[1]?.[0]
-        ? chunkedRawLockersData[0].result[1][0].amount
-        : chunkedRawLockersData[0].result[0]
-          ? chunkedRawLockersData[0].result[0]
-          : chunkedRawLockersData[0].result,
-      locker.token.decimals,
-    )
-    const veBalanceOfLocker =
-      locker.id === 'spectra' || locker.id === 'ynd'
-        ? tokenLocked // Spectra has permanent lock mecanism, which means veBalance = token locked
-        : 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 ? chunkedRawLockersData[4].result : Zero, 0)
-    const incentiveAmountInToken = formatUnits(
-      chunkedRawLockersData[5].result ? chunkedRawLockersData[5].result : Zero,
-      locker.token.decimals,
-    )
-
-    const totalSupplyStaked =
-      locker.modules.gauge !== zeroAddress ? formatUnits(chunkedRawLockersData[6].result, locker.token.decimals) : '0'
-    const gaugeWorkingSupply =
-      locker.chainId === mainnet.id && locker.modules.gauge !== zeroAddress
-        ? formatUnits(chunkedRawLockersData[7].result, locker.token.decimals)
-        : '0'
-    const amountTokenNotLock = formatUnits(chunkedRawLockersData[8].result, locker.token.decimals)
-    const sdTokenInPool = formatUnits(chunkedRawLockersData[9].result, locker.token.decimals)
-    const voteBooster = parseVoteBoosterData(locker, chunkedRawLockersData)
-    const peg = parsePeg(locker, chunkedRawLockersData)
-
-    const veTokenRate =
-      locker.id === 'mav' ? formatUnits(chunkedRawLockersData[12].result[0], locker.token.decimals) : '4'
-
-    const sideChains = locker.extensions.sideChains?.map((sideChain) => {
-      const rewards =
-        sideChain.rewards?.map((reward) => {
-          const price = prices.find((p) => equalTlc(p.address, reward.address))?.usdPrice || 0
-          return {
-            token: reward,
-            price,
-          }
-        }) || []
-
-      const tokenLocked = rawLockersSideChainData[sideChain.chainId].shift().result
-      return {
-        ...sideChain,
-        tokenLocked: formatUnits(
-          ['mav', 'fxs'].includes(locker.id) ? 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),
-        rewards,
-      }
-    })
-
-    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 : 0
-
-    const veBoostTotalSupply = parseBoost(locker, chunkedRawLockersData)
-    const veBoostApr = locker.veBoost
-      ? parseVeBoostApr(locker.id, tokenPriceInUsd, Number(veBoostTotalSupply), chunkedRawLockersData)
-      : 0
-
-    // Rewards APR
-    const rewardsData = locker.rewards.map((r) => {
-      const rawData = rawLockersRewardsData.shift().result
-      const rewardPrice = equalTlc(r.address, locker.sdToken.address)
-        ? sdTokenPriceInUsd
-        : prices.find((p) => p.address === r.address)?.usdPrice || 0
-
-      const periodFinish = Number(formatUnits(rawData ? rawData[2] : Zero, 0))
-      let streaming = r.distribution === 'streamed' && periodFinish > Math.floor(Date.now() / 1000)
-
-      const rate = rawData ? rawData[3] : Zero
-      const oneYearRate = rate * BigInt(ONE_YEAR)
-
-      let apr = streaming
-        ? rewardPrice && tvl > 0
-          ? ((Number(formatUnits(oneYearRate, r.decimals)) * rewardPrice) / tvl) * 100
-          : 0
-        : 0
-
-      if (r.distribution === 'merkl') {
-        if (locker.id === 'ynd') {
-          apr = httpCalls.yieldnestMerkl?.apr || 0
-          streaming = apr > 0
-        }
-      }
-
-      // Remove fees from APR
-      apr = substractFees(locker.id, apr, lockerFee)
-
-      return {
-        token: r,
-        price: rewardPrice,
-        apr,
-        streaming,
-        periodFinish,
-        rate: formatUnits(rate, 0),
-        lastUpdate: rawData ? formatUnits(rawData[4], 0) : '0',
-        isAirdrop: r.isAirdrop,
-      }
-    })
-
-    let _workingSupply = chainId === mainnet.id ? gaugeWorkingSupply : totalSupplyStaked
-    let _veSdtTotalSupply = veSdtTotalSupply
-    let _veBalanceOfLocker = veBalanceOfLocker
-
-    if (locker.id === 'fxs') {
-      _workingSupply = httpCalls.sdfxsWorkingData.working_supply.toString()
-      _veSdtTotalSupply = BigInt(httpCalls.sdfxsWorkingData.veSDT_total_supply)
-      _veBalanceOfLocker = (httpCalls.sdfxsWorkingData.veBalance * 4).toString()
-    } else if (locker.id === 'cake') {
-      _workingSupply = httpCalls.sdcakeData.working_supply.toString()
-      _veBalanceOfLocker = httpCalls.sdcakeData.total_user_votes.toString()
-    } else if (locker.id === 'spectra') {
-      _workingSupply = httpCalls.sdspectraData.working_supply.toString()
-    }
-
-    const data = getBribesRewardsData(
-      locker,
-      httpCalls.bribesData,
-      _veSdtTotalSupply,
-      totalSupplyStaked,
-      _veBalanceOfLocker,
-      _workingSupply,
-      sdTokenInPool,
-      tokenLocked,
-    )
-
-    const bribeMinApr: number = data.bribeMinApr
-    const bribeMaxApr: number = data.bribeMaxApr
-    const bribeRewards: TBribesRewards | undefined = data.bribeRewards
-
-    // Total APR
-    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.streaming)
-    const alternativeYields = JSON.parse(JSON.stringify(locker.alternativeYields || {})) // parse and stringify to avoid extensible issue
-    if (httpCalls.cvgAprs?.[locker.modules.gauge]) {
-      alternativeYields.convergenceSdToken = {
-        label: locker.sdToken.symbol,
-        platform: 'Convergence',
-        href: 'https://app.cvg.finance/',
-        apr: httpCalls.cvgAprs[locker.modules.gauge].totalApr,
-      }
-    }
-
-    if (locker.id === 'crv') {
-      alternativeYields.aSdCrvSpectra = {
-        label: 'asdCRV',
-        platform: 'Spectra',
-        href: 'https://app.spectra.finance/pools#mainnet/0xc63dff67fe1b63004ab6c773022ba06847c11335',
-        apr: Math.max(
-          ...(httpCalls.spectraAprs
-            ?.find((r) => r.underlying.address.toLowerCase() === locker.sdToken.address.toLowerCase())
-            ?.pools.map((p) => p.lpApy?.boostedTotal || 0) || [0]),
-        ),
-      }
-    }
-
-    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: locker.extensions.strategyGauge ? httpCalls.cvgAprs[locker.extensions.strategyGauge].totalApr : 0,
-      }
-    }
-
-    return {
-      ...locker,
-      rewards: rewardsData,
-      fees,
-      tokenLocked: tokenLocked,
-      veBalanceOfLocker: veBalanceOfLocker,
-      totalTokenLocked: totalTokenLocked,
-      veTotalSupply: veTotalSupply,
-      lockIncentive: lockIncentive,
-      incentiveAmountInToken: incentiveAmountInToken,
-      gaugeWorkingSupply: gaugeWorkingSupply,
-      totalSupplyStaked: totalSupplyStaked,
-      amountTokenNotLock: amountTokenNotLock,
-      bribeRewards,
-      apr: [minRewardsAprs, maxRewardsAprs],
-      streaming,
-      veTokenRate,
-      tvl,
-      peg,
-      tokenPriceInUsd,
-      sdTokenPriceInUsd,
-      voteBooster,
-      alternativeYields,
-      extensions: {
-        ...locker.extensions,
-        sideChains,
-      },
-      veBoostTotalSupply,
-      veBoostApr,
-    }
-  })
+export const fetchLockers = async ({ provider, prices }: TFetchLockers) => {
+  const [sdtInflationData, bribesData, veSdtTotalSupply, cvgAprs, spectraAprs] = await Promise.all([
+    // SDT Inflation Data
+    getSdtInflationData(provider[mainnet.id]),
+    // Bounties APR
+    fetch(`${GH_STAKE_DAO_BOUNTIES_REPORT}/main/delegationsAPRs.json`).then((res) => res.json()),
+    // veSDT total supply
+    rpcCall(RPC[mainnet.id], [{ to: contract('veSdt', mainnet.id), data: '0x18160ddd' }]).then((res) =>
+      BigInt(res[0].result),
+    ),
+    // Alternatives Yields
+    fetch('https://api.cvg.finance//stake-dao/aprs').then((res) => res.json()),
+    fetch('https://app.spectra.finance/api/v1/mainnet/pools').then((res) => res.json()),
+  ])
+
+  const common = { bribesData, veSdtTotalSupply, cvgAprs, spectraAprs }
+
+  // Order is set here
+  const parsed = await Promise.all([
+    curveLocker({ provider: provider[mainnet.id], common, prices }),
+    yieldbasisLocker({ provider: provider[mainnet.id], common, prices }),
+    pendleLocker({ provider: provider[mainnet.id], common, prices }),
+    fxnLocker({ provider: provider[mainnet.id], common, prices }),
+    yearnLocker({ provider: provider[mainnet.id], common, prices }),
+    yieldnestLocker({ provider: provider[mainnet.id], common, prices }),
+    balancerLocker({ provider: provider[mainnet.id], common, prices }),
+    spectraLocker({ provider: provider[base.id], common, prices }),
+    fraxFxsLocker({ provider: provider[fraxtal.id], common, prices }),
+    zerolendLocker({ provider: provider[linea.id], common, prices }),
+    maverickLocker({ provider: provider[mainnet.id], common, prices }),
+    blackpoolLocker({ provider: provider[mainnet.id], common, prices }),
+    fraxFpisLocker({ provider: provider[mainnet.id], common, prices }),
+    angleLocker({ provider: provider[mainnet.id], common, prices }),
+    pancakeswapLocker({ provider: provider[bsc.id], common, prices }),
+  ])
 
   return {
-    parsed: await Promise.all(lockerData),
-    sdt:
-      chainId === mainnet.id && sdtInflationData
-        ? {
-            lockersSdtPerBlock: formatUnits(sdtInflationData.lockersSdtPerBlock, 18),
-            lockersSdtPerSecond: formatUnits(sdtInflationData.lockersSdtPerSecond, 18),
-            stratsSdtPerBlock: formatUnits(sdtInflationData.stratsSdtPerBlock, 18),
-            stratsSdtPerSecond: formatUnits(sdtInflationData.stratsSdtPerSecond, 18),
-          }
-        : undefined,
+    parsed,
+    sdt: sdtInflationData
+      ? {
+          lockersSdtPerBlock: formatUnits(sdtInflationData.lockersSdtPerBlock, 18),
+          lockersSdtPerSecond: formatUnits(sdtInflationData.lockersSdtPerSecond, 18),
+          stratsSdtPerBlock: formatUnits(sdtInflationData.stratsSdtPerBlock, 18),
+          stratsSdtPerSecond: formatUnits(sdtInflationData.stratsSdtPerSecond, 18),
+        }
+      : undefined,
   }
 }