@stake-dao/reader 0.1.0 → 0.1.2

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

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

@@ -0,0 +1,40 @@
+import { parseUnits, zeroAddress } from 'viem'
+
+import { contracts } from '@stake-dao/constants'
+import { One, Zero } from '../../../index.js'
+
+const pegCalls = (secondaryMarket: string, pool: string, pegInfo: any, sdToken: string, token: string) => {
+  switch (secondaryMarket) {
+    case 'Balancer':
+      return {
+        address: contracts.balancerVault![1],
+        name: 'queryBatchSwap',
+        params: [
+          Zero,
+          [[pool, Zero, One, parseUnits(pegInfo?.basedOn ? pegInfo.basedOn.toString() : '1', 18), '0x']],
+          [sdToken, token],
+          [zeroAddress, false, zeroAddress, false],
+        ],
+      }
+    case 'Maverick':
+      return {
+        address: contracts.mavPoolInfos![1],
+        name: 'calculateSwap',
+        params: [pool, parseUnits(pegInfo?.basedOn ? pegInfo.basedOn.toString() : '1', 18), true, false, Zero],
+      }
+    case 'PancakeSwap':
+      return {
+        address: contracts.pancakeQuoter![56],
+        name: 'quoteExactInputSingle',
+        params: [[sdToken, token, parseUnits(pegInfo?.basedOn ? pegInfo.basedOn.toString() : '1', 18), '2500', '0']],
+      }
+    default:
+      return {
+        address: pool,
+        name: 'get_dy',
+        params: [One, Zero, parseUnits(pegInfo?.basedOn ? pegInfo.basedOn.toString() : '1', 18)],
+      }
+  }
+}
+
+export default pegCalls

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

@@ -0,0 +1,31 @@
+import { lockerWithId } from '@stake-dao/constants'
+
+import { lockedAmountCall } from '../index.js'
+
+const veCalls = (lockerId: string, votingEscrow: string, locker: string, token: string) => {
+  const calls: any[] = []
+  calls.push(lockedAmountCall(lockerId, votingEscrow, locker))
+  calls.push({ address: votingEscrow, name: 'balanceOf', params: [locker] })
+
+  if (
+    [
+      lockerWithId('pendle')!.extensions.locker,
+      lockerWithId('mav')!.extensions.locker,
+      lockerWithId('cake', 56)!.extensions.locker,
+    ].includes(locker)
+  ) {
+    calls.push({ address: token, name: 'balanceOf', params: [votingEscrow] })
+  } else {
+    calls.push({ address: votingEscrow, name: 'supply' })
+  }
+
+  if (locker === lockerWithId('pendle')!.extensions.locker) {
+    calls.push({ address: votingEscrow, name: 'totalSupplyStored' })
+  } else {
+    calls.push({ address: votingEscrow, name: 'totalSupply' })
+  }
+
+  return calls
+}
+
+export default veCalls

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

@@ -0,0 +1,15 @@
+import { contracts, tokenWithId } from '@stake-dao/constants'
+
+const veSdtCalls = (voteBooster: any, token: string, sdToken: string, sdTokenGauge: string) => [
+  { address: tokenWithId('vesdt')!.address, name: 'totalSupply' },
+  ...(voteBooster
+    ? [
+        { address: token, name: 'balanceOf', params: [contracts.voteBoosterStrategy![1]] },
+        { address: sdToken, name: 'balanceOf', params: [contracts.voteBoosterStrategy![1]] },
+        { address: sdTokenGauge, name: 'balanceOf', params: [contracts.voteBoosterStrategy![1]] },
+        { address: sdTokenGauge, name: 'working_balances', params: [contracts.voteBoosterStrategy![1]] },
+      ]
+    : []),
+]
+
+export default veSdtCalls

package/src/lockers/utils/endpoints.ts

@@ -0,0 +1,24 @@
+import { gql } from 'graphql-request'
+
+export const SDCAKE_AIRDROP_GRAPH_URL = 'https://api.thegraph.com/subgraphs/name/lucasramadour/sdcake-airdrop'
+
+export const SDCAKE_AIRDROP_GLOBAL_QUERY = gql`
+  query Global {
+    globals(first: 1) {
+      timestamp
+      points
+      rate
+      threeMTimestamp
+      tenMTimestamp
+      twentyFiveMTimestamp
+      fiftyMTimestamp
+      currentMultiplier
+    }
+    users(first: 1000) {
+      address
+      timestamp
+      points
+      rate
+    }
+  }
+`

package/src/lockers/utils/getBribesRewardsData.ts

@@ -0,0 +1,64 @@
+import { parseUnits } from 'viem'
+
+import { delegationWithId } from '@stake-dao/constants'
+import { One, Zero } from '../../index.js'
+
+import { calculateAllData } from './index.js'
+
+const getBribesRewardsData = (
+  locker: any,
+  bribesData: any,
+  veSdtTotalSupply: any,
+  totalSupplyStaked: any,
+  veBalanceOfLocker: any,
+  gaugeWorkingSupply: any,
+) => {
+  const bribesAverageApr = [
+    { id: 'crv', value: bribesData?.[delegationWithId('crv')!] / 100 || 0 },
+    { id: 'bal', value: bribesData?.[delegationWithId('bal')!] / 100 || 0 },
+    { id: 'fxs', value: bribesData?.[delegationWithId('fxs')!] / 100 || 0 }, // 1 FXS = 4 veFXS
+    { id: 'angle', value: bribesData?.[delegationWithId('angle')!] / 100 || 0 },
+    { id: 'pendle', value: bribesData?.[delegationWithId('pendle')!] / 100 || 0 },
+    { id: 'fxn', value: bribesData?.[delegationWithId('fxn')!] / 100 || 0 },
+  ]
+
+  // Vote incentives APR
+  const votingPower = calculateAllData(
+    locker.id,
+    {
+      veSDTSupply: veSdtTotalSupply,
+      userVeSDTBalance: Zero,
+      gaugeSupply: parseUnits(totalSupplyStaked, locker.token.decimals),
+      userSdTokenGaugeBalance: Zero,
+      llVotingPower: parseUnits(veBalanceOfLocker, locker.token.decimals),
+      gaugeWorkingSupply: parseUnits(gaugeWorkingSupply, locker.token.decimals),
+      delegatedVeSDTBalance: Zero,
+      receivedVeSDTBalance: Zero,
+    },
+    One,
+    Zero,
+  )
+
+  const bribesAverage = bribesAverageApr.find((b) => b.id === locker.id)
+  const bribeMinApr = (bribesAverage ? bribesAverage.value * (Number(votingPower.min) / 1000) : 0) * 100
+  const bribeMaxApr = (bribesAverage ? bribesAverage.value * (Number(votingPower.max) / 1000) : 0) * 100
+  const bribeRewards = bribesAverage
+    ? {
+        bribeMinApr,
+        bribeMaxApr,
+        bribeAverageApr: bribesAverage.value * 100,
+        average: bribesAverageApr,
+        minBoost: (Number(votingPower.min) / 1000).toFixed(2),
+        maxBoost: (Number(votingPower.max) / 1000).toFixed(2),
+        token: `sd${bribesAverage.id}`,
+      }
+    : undefined
+
+  return {
+    bribeMinApr,
+    bribeMaxApr,
+    bribeRewards,
+  }
+}
+
+export default getBribesRewardsData

package/src/lockers/utils/getCherriesLeaderBoard.ts

@@ -0,0 +1,34 @@
+import { formatEther } from 'viem'
+
+import { graphql } from '../../utils.js'
+import { SDCAKE_AIRDROP_GLOBAL_QUERY, SDCAKE_AIRDROP_GRAPH_URL } from './endpoints.js'
+
+import { computeRatePoints } from './cakeLockerAirdrop.js'
+
+export const getCherriesLeaderBoard = async () => {
+  const subgraphData = await graphql(SDCAKE_AIRDROP_GRAPH_URL, SDCAKE_AIRDROP_GLOBAL_QUERY, {})
+  const airdropGraph = subgraphData?.globals ? subgraphData.globals[0] : undefined
+
+  const now = Math.floor(Date.now() / 1000)
+
+  const leaderBoard =
+    subgraphData?.globals &&
+    subgraphData.users.map((user) => {
+      const currentPoints = computeRatePoints(
+        BigInt(user.rate),
+        BigInt(user.timestamp),
+        BigInt(now),
+        airdropGraph,
+        BigInt(user.points),
+      )
+      return {
+        ...user,
+        currentPoints: Number(formatEther(currentPoints)),
+      }
+    })
+
+  return {
+    ...airdropGraph,
+    leaderBoard: leaderBoard?.sort((a, b) => b.currentPoints - a.currentPoints),
+  }
+}

package/src/lockers/utils/getFees.ts

@@ -0,0 +1,34 @@
+import { type ILockerFee } from './callsForLockers/feeCalls.js'
+
+const getFees = (locker: any, lockerFee: ILockerFee | null | undefined) => {
+  const fees: any[] = []
+
+  for (const fee of locker.fees) {
+    let value: number = fee.value
+    if (!fee.static) {
+      switch (fee.key) {
+        case 'voteFee':
+          value = Number(lockerFee?.bountyFee || 0) / 100
+          break
+        case 'claimerFee':
+        case 'liquidityFee':
+        case 'daoFee':
+        case 'lockerFee':
+          value = Number(lockerFee?.[fee.key] || 0) / 100
+          break
+      }
+    }
+
+    if (value > 0) {
+      fees.push({
+        label: fee.label,
+        value,
+        key: fee.key,
+      })
+    }
+  }
+
+  return fees
+}
+
+export default getFees

package/src/lockers/utils/getHttpCalls.ts

@@ -0,0 +1,55 @@
+import { bsc, mainnet } from 'viem/chains'
+
+const getHttpCalls = async (chainId: number) => {
+  switch (chainId) {
+    case mainnet.id: {
+      const httpCalls = [
+        (await fetch('https://raw.githubusercontent.com/stake-dao/bounties-report/main/delegationsAPRs.json')).json(),
+        fetch('https://api.frax.finance/v1/vefpisdata/1-day')
+          .then((result) => result.json())
+          .catch((error) => {
+            console.error(error)
+            return undefined
+          }),
+        fetch('https://api.cvg.finance//stake-dao/aprs')
+          .then((result) => result.json())
+          .catch((error) => {
+            console.error(error)
+            return undefined
+          }),
+      ]
+
+      const httpResponses = (await Promise.allSettled(httpCalls)).map((result) =>
+        result.status === 'fulfilled' ? result.value : undefined,
+      )
+
+      const bribesData = httpResponses[0]
+      const fpisBribesData = httpResponses[1]
+      const cvgAprs = httpResponses[2]?.aprProjecteds
+
+      return {
+        bribesData,
+        fpisBribesData,
+        cvgAprs,
+      }
+    }
+    case bsc.id: {
+      const delegationsAPRsCall = [
+        (await fetch('https://raw.githubusercontent.com/stake-dao/bounties-report/main/delegationsAPRs.json')).json(),
+      ]
+
+      const delegationsAPRsResponse = (await Promise.allSettled(delegationsAPRsCall)).map((result) =>
+        result.status === 'fulfilled' ? result.value : undefined,
+      )
+
+      const delegationsAPRsData = delegationsAPRsResponse[0]
+
+      return {
+        bribesData: delegationsAPRsData,
+      }
+    }
+  }
+  return undefined
+}
+
+export default getHttpCalls

package/src/lockers/utils/getSdtInflationData.ts

@@ -0,0 +1,54 @@
+import { mainnet } from 'viem/chains'
+
+import {
+  ETH_SECONDS_PER_BLOCK,
+  LOCKERS_MASTERCHEF_PID,
+  STRATEGIES_MASTERCHEF_PID,
+  contracts,
+} from '@stake-dao/constants'
+import { parseAbi } from 'viem'
+import { multicall } from '../../utils.js'
+
+const getSdtInflationData = async (provider: any) => {
+  const chainId = await provider.getChainId()
+  if (chainId === mainnet.id) {
+    const rawSdtMasterchefData = await multicall(
+      provider,
+      [
+        { address: contracts.sdtMasterchef![1]!, name: 'sdtPerBlock' },
+        { address: contracts.sdtMasterchef![1]!, name: 'totalAllocPoint' },
+        { address: contracts.sdtMasterchef![1]!, name: 'poolInfo', params: [LOCKERS_MASTERCHEF_PID] },
+        { address: contracts.sdtMasterchef![1]!, name: 'poolInfo', params: [STRATEGIES_MASTERCHEF_PID] },
+      ],
+      parseAbi([
+        'function sdtPerBlock() external view returns (uint256)',
+        'function totalAllocPoint() external view returns (uint256)',
+        'function poolInfo(uint256) external view returns (address,uint256,uint256)',
+      ]),
+    )
+
+    const sdtPerBlock = rawSdtMasterchefData[0].result as unknown as bigint
+    const totalAllocPoint = rawSdtMasterchefData[1].result as unknown as bigint
+    const lockerPoolInfo = rawSdtMasterchefData[2].result as unknown as bigint
+    const stratPoolInfo = rawSdtMasterchefData[3].result as unknown as bigint
+
+    const lockersAllocPoint = lockerPoolInfo[1] as unknown as bigint
+    const stratsAllocPoint = stratPoolInfo[1] as unknown as bigint
+
+    const lockersSdtPerBlock = (lockersAllocPoint * sdtPerBlock) / totalAllocPoint
+    const lockersSdtPerSecond = BigInt(lockersSdtPerBlock) / BigInt(ETH_SECONDS_PER_BLOCK)
+
+    const stratsSdtPerBlock = (stratsAllocPoint * sdtPerBlock) / totalAllocPoint
+    const stratsSdtPerSecond = BigInt(stratsSdtPerBlock) / BigInt(ETH_SECONDS_PER_BLOCK)
+
+    return {
+      lockersSdtPerBlock,
+      lockersSdtPerSecond,
+      stratsSdtPerBlock,
+      stratsSdtPerSecond,
+    }
+  }
+  return undefined
+}
+
+export default getSdtInflationData