@stake-dao/reader 0.1.0

package/src/strategies/utils/sdt.ts

@@ -0,0 +1,206 @@
+import { ONE_WEEK, ONE_YEAR, contracts, mainnet } from '@stake-dao/constants'
+import { LOCKERS_MASTERCHEF_PID } from '@stake-dao/constants'
+import { STRATEGIES_MASTERCHEF_PID } from '@stake-dao/constants'
+import { ETH_SECONDS_PER_BLOCK } from '@stake-dao/constants'
+import { formatUnits, parseAbi, parseEther, parseUnits } from 'viem'
+import { multicall } from '../../utils.js'
+import type { RewardsData, SdtApr } from '../types.js'
+import { OneEther, Zero } from './index.js'
+
+export type SdtEmissionData = {
+  lockersSdtPerBlock: bigint
+  lockersSdtPerSecond: bigint
+  stratsSdtPerBlock: bigint
+  stratsSdtPerSecond: bigint
+}
+
+const simulateUserWorkingBalance = (
+  adjustedBalanceOf: bigint,
+  veSDTTotalSupply: bigint,
+  userAmountLP: bigint,
+  totalAmountLP: bigint,
+  currentUserWorkingBalance: bigint,
+  currentWorkingSupply: bigint,
+): {
+  newUserWorkingBalance: bigint
+  newWorkingSupply: bigint
+} => {
+  const voting_balance = adjustedBalanceOf
+  const voting_total = veSDTTotalSupply
+
+  let lim = (userAmountLP * BigInt(40)) / BigInt(100)
+  if (voting_total > 0) {
+    lim += (((totalAmountLP * voting_balance) / voting_total) * BigInt(60)) / BigInt(100)
+  }
+
+  if (userAmountLP < lim) {
+    lim = userAmountLP
+  }
+
+  const _working_supply = currentWorkingSupply + lim - currentUserWorkingBalance
+
+  return {
+    newUserWorkingBalance: lim,
+    newWorkingSupply: _working_supply,
+  }
+}
+
+export const calculateSDTRangeApr = (
+  sdtRateInput: bigint,
+  periodFinish: number,
+  workingBalance: string,
+  workingSupply: string,
+  depositBalance: bigint,
+  adjustedBalanceOf: string,
+  votingEscrowTotalSupply: string,
+  gaugeTotalSupply: string,
+  sdtPrice: number,
+  lpPrice: number,
+) => {
+  // Assign rate is needed
+  const sdtRate = periodFinish === 0 || Date.now() / 1000 > periodFinish ? Zero : sdtRateInput
+
+  let workingBalanceToUse = parseUnits(workingBalance, 0)
+  let workingSupplyToUse = parseUnits(workingSupply, 0)
+  let stakedAmountToUse = BigInt(depositBalance)
+  let realStakedAmount = (stakedAmountToUse * BigInt(4)) / BigInt(10)
+  const isSimulated = stakedAmountToUse <= 0
+
+  if (isSimulated) {
+    // Simulation with 1 LP
+    stakedAmountToUse = parseUnits('1', 18)
+    realStakedAmount = (stakedAmountToUse * BigInt(4)) / BigInt(10)
+
+    const simu = simulateUserWorkingBalance(
+      parseUnits(adjustedBalanceOf, 0),
+      parseUnits(votingEscrowTotalSupply, 0),
+      stakedAmountToUse,
+      parseUnits(gaugeTotalSupply, 0) + stakedAmountToUse,
+      workingBalanceToUse,
+      workingSupplyToUse,
+    )
+
+    workingBalanceToUse = simu.newUserWorkingBalance
+    workingSupplyToUse = simu.newWorkingSupply
+  }
+
+  let sdtUserApr =
+    ((Number.parseFloat(formatUnits(sdtRate, 18)) *
+      Number.parseFloat(formatUnits(workingBalanceToUse, 18)) *
+      sdtPrice *
+      ONE_YEAR) /
+      (Number.parseFloat(formatUnits(workingSupplyToUse, 18)) *
+        Number.parseFloat(formatUnits(stakedAmountToUse, 18)) *
+        lpPrice)) *
+    100
+
+  if (Number.isNaN(sdtUserApr)) sdtUserApr = 0
+
+  let sdtBoost =
+    (BigInt(depositBalance) > 0 || isSimulated) && realStakedAmount > Zero
+      ? Number.parseFloat(formatUnits(parseEther(formatUnits(workingBalanceToUse, 0)) / realStakedAmount, 18))
+      : 1
+
+  const sdtMinApr = sdtUserApr / sdtBoost
+  const sdtMaxApr = sdtMinApr * 2.5
+  if (isSimulated) {
+    // Reset user apr + boost to minimum because we used only data to simulate the position and calculate the SDT apr range
+    sdtUserApr = sdtMinApr
+    sdtBoost = 1
+  }
+
+  return {
+    sdtMinApr,
+    sdtMaxApr,
+    sdtBoost,
+    sdtUserApr,
+  }
+}
+
+export const getSdtInflationData = async (provider: any, chainId: number): Promise<SdtEmissionData | undefined> => {
+  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() view returns (uint256)',
+        'function totalAllocPoint() view returns (uint256)',
+        'function poolInfo(uint256 pid) view returns (address,uint256,uint256,uint256)',
+      ]),
+    )
+
+    const sdtPerBlock = rawSdtMasterchefData[0].result
+    const totalAllocPoint = rawSdtMasterchefData[1].result
+    const lockerPoolInfo = rawSdtMasterchefData[2].result
+    const stratPoolInfo = rawSdtMasterchefData[3].result
+
+    const lockersAllocPoint = lockerPoolInfo[1] as bigint
+    const stratsAllocPoint = stratPoolInfo[1] 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 const computeSdtApr = (
+  sdtEmissionData: SdtEmissionData,
+  sdtRewards: RewardsData,
+  userData: any,
+  sdGauge: any,
+  lpPriceInUsd: number,
+): SdtApr => {
+  const futureRate = (sdtEmissionData.stratsSdtPerSecond * BigInt(sdGauge.futureWeight)) / OneEther
+
+  const sdtRangeApr = calculateSDTRangeApr(
+    BigInt(sdtRewards.rate),
+    sdtRewards.periodFinish,
+    userData?.workingBalance || '0',
+    sdGauge.workingSupply,
+    BigInt(userData?.depositBalance || '0'),
+    userData?.sdtAprData.adjustedBalanceOf || '0',
+    userData?.sdtAprData.votingEscrowTotalSupply || '0',
+    sdGauge.totalSupply,
+    sdtRewards.price,
+    lpPriceInUsd,
+  )
+
+  const futurSdtRangeApr = calculateSDTRangeApr(
+    futureRate,
+    Math.floor(Date.now() / 1000) + ONE_WEEK,
+    userData?.workingBalance || '0',
+    sdGauge.workingSupply,
+    BigInt(userData?.depositBalance || '0'),
+    userData?.sdtAprData.adjustedBalanceOf || '0',
+    userData?.sdtAprData.votingEscrowTotalSupply || '0',
+    sdGauge.totalSupply,
+    sdtRewards.price,
+    lpPriceInUsd,
+  )
+
+  return {
+    sdtUserApr: sdtRangeApr?.sdtUserApr || 0,
+    sdtFuturUserApr: futurSdtRangeApr?.sdtUserApr || 0,
+    sdtMinApr: sdtRangeApr?.sdtMinApr || 0,
+    sdtFuturMinApr: futurSdtRangeApr?.sdtMinApr || 0,
+    sdtMaxApr: sdtRangeApr?.sdtMaxApr || 0,
+    sdtFuturMaxApr: futurSdtRangeApr?.sdtMaxApr || 0,
+    sdtBoost: sdtRangeApr?.sdtBoost || 1,
+  }
+}

package/src/utils.ts

@@ -0,0 +1,171 @@
+import { tokens } from '@stake-dao/constants'
+import type { Token } from '@stake-dao/constants'
+import { decodeAbiParameters, parseAbiParameters } from 'viem'
+import { AGNOSTIC_QUERY_URL } from './endpoints.js'
+import { withTwoDec } from './number.js'
+
+export const isProtocolToken = (protocol: string, tokenSymbol: string) =>
+  (protocol === 'curve' && tokenSymbol === 'CRV') ||
+  (protocol === 'balancer' && tokenSymbol === 'BAL') ||
+  (protocol === 'angle' && tokenSymbol === 'ANGLE') ||
+  (protocol === 'pendle' && tokenSymbol === 'PENDLE') ||
+  (protocol === 'yearn' && tokenSymbol === 'dYFI') ||
+  (protocol === 'pancakeswap' && tokenSymbol === 'CAKE')
+
+export const getBreakdownLabel = (strat: any, reward: any, isFuturSDT: boolean, boost: number, sdtApr: any) => {
+  switch (reward.token.symbol) {
+    case 'SDT':
+      return `${reward.token.symbol} APR${
+        sdtApr?.sdtBoost
+          ? ` (${withTwoDec(isFuturSDT ? sdtApr.sdtFuturMinApr : sdtApr.sdtMinApr)}% → ${withTwoDec(
+              isFuturSDT ? sdtApr.sdtFuturMaxApr : sdtApr.sdtMaxApr,
+            )}% | Your boost : ${sdtApr.sdtBoost.toFixed(2)}x)`
+          : ''
+      }`
+    default:
+      return `${reward.token.symbol} APR${
+        isProtocolToken(strat.protocol, reward.token.symbol) ? ` (incl. ${boost.toFixed(2)}x boost)` : ''
+      }`
+  }
+}
+
+export const equalTlc = (addressOne: string, addressTwo: string): boolean =>
+  addressOne.toLowerCase() === addressTwo.toLowerCase()
+
+export const getTokenInfo = (
+  coinData: any,
+  address: string,
+  chainId: number = 1,
+): { name: string; symbol: string; address: string; decimals: number } | Token => {
+  if (coinData) {
+    return {
+      name: coinData.name,
+      symbol: coinData.symbol,
+      address: coinData.tokenAddress,
+      decimals: Number(coinData.decimals),
+    }
+  }
+
+  const tokenObj = tokens.find((t: Token) => t.chainId === chainId && t.address === address)!
+  return {
+    name: tokenObj.name,
+    symbol: tokenObj.symbol,
+    address: tokenObj.address,
+    decimals: tokenObj.decimals,
+  }
+}
+
+export const projectWorkingBalance = (veBalance: bigint, veTotal: bigint, balance: bigint, totalSupply: bigint) => {
+  const TOKENLESS_PRODUCTION = BigInt(40)
+  const DENOMINATOR = BigInt(100)
+
+  const derived = (balance * TOKENLESS_PRODUCTION) / DENOMINATOR
+  const adjusted = (((totalSupply * veBalance) / veTotal) * (DENOMINATOR - TOKENLESS_PRODUCTION)) / DENOMINATOR
+
+  // Math.min for BigInt
+  return [balance, derived + adjusted].reduce((m, e) => (e < m ? e : m))
+}
+
+interface RpcCallArgs {
+  to: string
+  data: string
+}
+
+export const rpcCall = async (rpc: string, params: RpcCallArgs[]) => {
+  const request = (
+    await fetch(rpc, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(
+        params.map((param, index) => ({
+          id: index,
+          jsonrpc: '2.0',
+          method: 'eth_call',
+          params: [{ to: param.to, data: param.data }, 'latest'],
+        })),
+      ),
+    })
+  ).json()
+
+  return request
+}
+
+interface BatchJsonRpcArgs {
+  rpc: string
+  calls: string[]
+  outputTypeAbi: any | any[]
+  parse?: boolean
+  callsKey?: string
+}
+
+export const batchJsonRpc = async (args: BatchJsonRpcArgs) => {
+  const { rpc, calls, outputTypeAbi, parse = true, callsKey = '' } = args
+
+  const rpcRequests = await (
+    await fetch(rpc, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(
+        calls.map((calldata, index) => ({
+          id: index,
+          jsonrpc: '2.0',
+          method: 'eth_call',
+          params: [{ data: calldata }, 'latest'],
+        })),
+      ),
+    })
+  ).json()
+
+  const rpcResults = rpcRequests.map((res: any, index: number) => {
+    const isError = Object.keys(res).includes('error')
+    const abi = Array.isArray(outputTypeAbi[0]) ? outputTypeAbi[index] : outputTypeAbi
+    const status = isError ? 'error' : 'fulfilled'
+    const value = isError
+      ? `${callsKey} call index ${index}: code ${res.error.code}\n${res.error.message}`
+      : decodeAbiParameters(parse ? (parseAbiParameters(abi) as any) : abi, res.result)
+
+    if (isError) {
+      console.error(value)
+    }
+
+    return { status, value }
+  })
+
+  return rpcResults.flatMap((r) => (r.status === 'fulfilled' ? r.value[0] : []))
+}
+
+export interface Call {
+  address: string // Address of the contract
+  name: string // Function name on the contract (example: balanceOf)
+  params?: any[] // Function params
+}
+
+export const multicall = async (provider: any, calls: Call[], abi: readonly any[]) => {
+  const contracts = calls.map((c) => ({
+    address: c.address as `0x${string}`,
+    abi,
+    functionName: c.name,
+    args: c.params ? c.params : [],
+  }))
+
+  const results = await provider.multicall({ contracts, batchSize: 10_240 })
+
+  return results
+}
+
+export const agnostic = async (query: string, apiKey: string, defaultErrorValue?: any): Promise<any> => {
+  try {
+    const response = await fetch(AGNOSTIC_QUERY_URL, {
+      body: query,
+      method: 'POST',
+      headers: {
+        Authorization: apiKey,
+      },
+    })
+    const data = await response.json()
+    return data.rows
+  } catch (e) {
+    console.error(e)
+    return defaultErrorValue
+  }
+}