@stake-dao/reader 0.1.1 → 0.1.2

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

package/src/lockers/utils/index.ts

@@ -0,0 +1,200 @@
+import { formatUnits, parseUnits } from 'viem'
+
+import { Zero } from '../../index.js'
+
+interface Data {
+  veSDTSupply: bigint
+  userVeSDTBalance: bigint
+  gaugeSupply: bigint
+  userSdTokenGaugeBalance: bigint
+  llVotingPower: bigint
+  gaugeWorkingSupply: bigint
+  delegatedVeSDTBalance: bigint
+  receivedVeSDTBalance: bigint
+}
+
+/**
+ * Get the amount of veSDT to have more to have max boost
+ */
+const getVeSDTAmountMaxBoostCalculator = (toAdd: bigint, data: Data): bigint => {
+  const newSdTokenGaugeToAdd = parseUnits(formatUnits(toAdd, 0), 18)
+
+  const w0 = data.veSDTSupply
+  const wu0 = data.userVeSDTBalance + data.receivedVeSDTBalance - data.delegatedVeSDTBalance
+  const bs = data.gaugeSupply + newSdTokenGaugeToAdd
+  const bu = data.userSdTokenGaugeBalance + newSdTokenGaugeToAdd
+
+  const a = w0 * bu
+  const b = wu0 * bs
+  const c = a - b
+  const d = bs - bu
+
+  if (d === Zero) {
+    return Zero
+  }
+
+  // x1000 to keep 3 decimals
+  const res = (c * BigInt(1000)) / d
+  if (res < 0) {
+    return Zero
+  }
+
+  return res
+}
+
+const getBetaU = (data: Data, toAdd: bigint, additionalVeSDT?: bigint): bigint => {
+  const sdTokenGaugeToAdd = parseUnits(formatUnits(toAdd, 0), 18)
+
+  const dvu = additionalVeSDT === Zero ? additionalVeSDT : getVeSDTAmountMaxBoostCalculator(toAdd, data) / BigInt(1000)
+
+  const newUserSdTokenGaugeBalance = data.userSdTokenGaugeBalance + sdTokenGaugeToAdd
+  const newUserVeSDTBalance = dvu + data.userVeSDTBalance + data.receivedVeSDTBalance - data.delegatedVeSDTBalance
+
+  const newVeSDTSupply = data.veSDTSupply + data.userVeSDTBalance + dvu
+
+  const newGaugeSupply = data.gaugeSupply + sdTokenGaugeToAdd
+
+  const a = (newUserSdTokenGaugeBalance * BigInt(4)) / BigInt(10)
+  const b = (((newGaugeSupply * newUserVeSDTBalance) / newVeSDTSupply) * BigInt(6)) / BigInt(10)
+  const c = a + b
+
+  if (c > newUserSdTokenGaugeBalance) {
+    return newUserSdTokenGaugeBalance
+  }
+
+  return c
+}
+
+const getBetaU0 = (data: Data): bigint => {
+  const a = (data.userSdTokenGaugeBalance * BigInt(4)) / BigInt(10)
+  const b =
+    (((data.gaugeSupply * (data.userVeSDTBalance + data.receivedVeSDTBalance - data.delegatedVeSDTBalance)) /
+      data.veSDTSupply) *
+      BigInt(6)) /
+    BigInt(10)
+  const c = a + b
+
+  if (c > data.userSdTokenGaugeBalance) {
+    return data.userSdTokenGaugeBalance
+  }
+
+  return c
+}
+
+/**
+ * Get the possible max boost for the user
+ */
+const getMaxVotingPower = (toAdd: bigint, data: any, additionalVeSDT?: bigint): bigint => {
+  const sdTokenGaugeToAdd = parseUnits(formatUnits(toAdd, 0), 18)
+  const totalVotingPower = data.llVotingPower + sdTokenGaugeToAdd
+
+  const betaU = getBetaU(data, toAdd, additionalVeSDT)
+  const betaU0 = getBetaU0(data)
+
+  const ws = data.gaugeWorkingSupply + betaU - betaU0
+  if (ws === Zero) {
+    return Zero
+  }
+  const vu = (totalVotingPower * betaU) / ws
+
+  // x1000 to keep 3 decimals
+  const newSdUserTokenGauge = sdTokenGaugeToAdd + data.userSdTokenGaugeBalance
+  if (newSdUserTokenGauge === Zero) {
+    return Zero
+  }
+
+  return (vu * BigInt(1000)) / newSdUserTokenGauge
+}
+
+const getRewardBoost = (toAdd: bigint, data: any, additionalVeSDT?: bigint): number => {
+  const newSdTokenGaugeToAdd = parseUnits(formatUnits(toAdd, 0), 18)
+  const bu = data.userSdTokenGaugeBalance + newSdTokenGaugeToAdd
+  const betaUMax = getBetaU(data, toAdd, additionalVeSDT)
+  const betaUMin = getBetaU(data, toAdd, additionalVeSDT)
+  const betaU0 = getBetaU0(data)
+  const ws = data.gaugeWorkingSupply + betaUMin - betaU0
+  const wsMin = data.gaugeWorkingSupply + (bu * BigInt(4)) / BigInt(10) - betaU0
+
+  const wsMinNumber = Number.parseFloat(wsMin.toString())
+  const betaUMaxNumber = Number.parseFloat(betaUMax.toString())
+  const wsNumber = Number.parseFloat(ws.toString())
+  const ru_min = (Number.parseFloat(bu.toString()) * 0.4) / wsMinNumber
+  const ru = betaUMaxNumber / wsNumber
+
+  const res = ru / ru_min
+  return Number.isNaN(res) ? 0 : res
+}
+
+export const calculateAllData = (lockerId: string, data: Data, toAdd: bigint, additionalVeSDT: bigint = Zero) => {
+  additionalVeSDT = parseUnits(formatUnits(additionalVeSDT, 0), 18)
+
+  const veSDTAmountToMaxBoost = getVeSDTAmountMaxBoostCalculator(toAdd, data)
+  const maxVotingPower = getMaxVotingPower(toAdd, data)
+  const rewardBoost = getRewardBoost(toAdd, data)
+
+  const newMaxVotingPower = getMaxVotingPower(toAdd, data, additionalVeSDT)
+  const newRewardBoost = getRewardBoost(toAdd, data, additionalVeSDT)
+
+  return {
+    veSDTAmountToMaxBoost,
+    max: lockerId === 'fxs' ? maxVotingPower / BigInt(4) : maxVotingPower,
+    rewardBoost,
+    min: lockerId === 'fxs' ? newMaxVotingPower / BigInt(4) : newMaxVotingPower,
+    newRewardBoost,
+  }
+}
+
+export const lockedAmountCall = (lockerId: string, votingEscrow: string, locker: string) => {
+  switch (lockerId) {
+    case 'pendle':
+      return {
+        address: votingEscrow,
+        name: 'positionData',
+        params: [locker],
+      }
+    case 'mav':
+      return {
+        address: votingEscrow,
+        name: 'lockups',
+        params: [locker, 0],
+      }
+    case 'cake':
+      return {
+        address: votingEscrow,
+        name: 'locks',
+        params: [locker],
+      }
+    default:
+      return {
+        address: votingEscrow,
+        name: 'locked',
+        params: [locker],
+      }
+  }
+}
+
+export const lockedAmountCallSideChain = (lockerId: string, votingEscrow: string, locker: string, chainId: number) => {
+  switch (lockerId) {
+    case 'mav':
+      return {
+        address: votingEscrow,
+        name: 'lockups',
+        params: [locker, 0],
+        chainId,
+      }
+    case 'fxs':
+      return {
+        address: votingEscrow,
+        name: 'balanceOfLockedFxs',
+        params: [locker],
+        chainId,
+      }
+    default:
+      return {
+        address: votingEscrow,
+        name: 'locked',
+        params: [locker],
+        chainId,
+      }
+  }
+}

package/src/lockers/utils/substractFees.ts

@@ -0,0 +1,26 @@
+const substractFees = (lockerId: string, maxApr: number, lockerFee: any): number => {
+  switch (lockerId) {
+    case 'yfi':
+    case 'bpt':
+    case 'apw': {
+      const totalFee = lockerFee
+        ? Object.keys(lockerFee).reduce(
+            (total, key) => (key !== 'lockerId' ? total + Number(lockerFee[key]) / 100 : total),
+            0,
+          )
+        : 0
+
+      return (maxApr * (100 - totalFee)) / 100
+    }
+    case 'mav': {
+      // 10% airdrop fees
+      return (maxApr * (100 - 10)) / 100
+    }
+    default: {
+      // Streaming from gauges, fees are already substracted
+      return maxApr
+    }
+  }
+}
+
+export default substractFees