@stake-dao/reader 0.1.0

package/src/strategies/curve/fetch/curveApiData/getPoolsFromRegistries.ts.ts

@@ -0,0 +1,36 @@
+import { range } from 'lodash-es'
+import { encodeAbiParameters, parseAbiParameters } from 'viem'
+import { batchJsonRpc } from '../../../../utils.js'
+import { getCurveDataPoolsOutputTypeAbi } from './abi.js'
+import { curveApiDataBytecodes } from './bytecode.js'
+import { CHUNK_SIZE } from './config.js'
+
+export const getPoolsFromRegistries = async (rpc: string, lendingCallsStartIndex: number, poolCounts: any) => {
+  const registriesCalls = poolCounts.flatMap((registry) =>
+    range(0, registry.poolCount, CHUNK_SIZE).map((skip) => {
+      const inputParams = [
+        registry.address,
+        skip,
+        skip + CHUNK_SIZE > registry.poolCount ? registry.poolCount : skip + CHUNK_SIZE,
+      ]
+
+      const inputData = encodeAbiParameters(
+        parseAbiParameters(['address _registry, uint256 skip, uint256 limit']) as any,
+        inputParams,
+      )
+      return curveApiDataBytecodes[registry.bytecodeIndex]?.concat(inputData.slice(2))
+    }),
+  )
+
+  const pools = await batchJsonRpc({
+    rpc,
+    calls: registriesCalls,
+    outputTypeAbi: Array.from({ length: registriesCalls.length }, (_el, index) =>
+      getCurveDataPoolsOutputTypeAbi(index >= lendingCallsStartIndex),
+    ),
+    parse: false,
+    callsKey: 'Fetch Curve Apis Data',
+  })
+
+  return pools
+}

package/src/strategies/curve/fetch/curveApiData/getRegistries.ts

@@ -0,0 +1,25 @@
+import { decodeAbiParameters } from 'viem'
+import { rpcCall } from '../../../../utils.js'
+import { CHUNK_SIZE, lendingStartIndex, registries } from './config.js'
+
+export const getRegistries = async (rpc: string, chainId: number) => {
+  const poolCountsRequest = await rpcCall(
+    rpc,
+    registries[chainId]!.map((registry) => ({
+      to: registry.address,
+      data: registry.isLending ? '0xfd775c78' : '0x956aae3a',
+    })),
+  )
+
+  let totalPoolCount = 0
+  let lendingCallsStartIndex = 0
+
+  const poolCounts = poolCountsRequest.map((res, index) => {
+    const poolCount = Number(decodeAbiParameters([{ type: 'uint256', name: 'poolCount' }], res.result))
+    if (lendingStartIndex[chainId] > index) lendingCallsStartIndex += Math.ceil(poolCount / CHUNK_SIZE)
+    totalPoolCount += poolCount
+    return { ...registries[chainId]![index], poolCount, sumCount: totalPoolCount }
+  })
+
+  return { lendingCallsStartIndex, poolCounts }
+}

package/src/strategies/curve/fetch/getAprBreakdown.ts

@@ -0,0 +1,98 @@
+import { getBreakdownLabel, isProtocolToken } from '../../../utils.js'
+import type { RewardsData } from '../../types.js'
+
+type Breakdown = {
+  label: string
+  value: number[]
+}
+
+export const getAprBreakdown = (strat: any, rewardsData: RewardsData[], boost: number, cvxApr: number, sdtApr: any) => {
+  // Base Rewards
+  // Trading Fees for LP
+  // Supply APY for lending
+  const baseReward: Breakdown = {
+    label: `${strat.isLending ? 'Lending' : 'Trading Fees'} (APY)`,
+    value: [strat?.tradingApy || 0],
+  }
+
+  // Current streaming APRs from the Stake DAO gauge
+  const currentAprBreakdown: Breakdown[] = rewardsData.map((r) => {
+    const value = r.token.symbol === 'SDT' ? [sdtApr.sdtMinApr, sdtApr.sdtMaxApr] : [r.apr * 100]
+
+    return {
+      label: getBreakdownLabel(strat, r, false, boost, sdtApr),
+      value,
+    }
+  })
+
+  // Projected CRV APR
+  const projectedCrvApr = strat ? boost * strat.minApr : 0
+
+  // Projected CVX APR
+  const projectedCvxApr = { label: 'CVX APR', value: [cvxApr] }
+
+  // Format SDT and CRV rewards APR for breakdown
+  const projectedAprBreakdown: Breakdown[] = rewardsData
+    .map((r) => {
+      const value =
+        r.token.symbol === 'SDT'
+          ? [sdtApr.sdtFuturMinApr, sdtApr.sdtFuturMaxApr]
+          : isProtocolToken(strat.protocol, r.token.symbol)
+            ? [projectedCrvApr]
+            : [0]
+
+      return {
+        label: getBreakdownLabel(strat, r, true, boost, sdtApr),
+        value,
+      }
+    })
+    .filter((r) => r.value[0] > 0)
+
+  // Get extra rewards APR from current streaming APR breakdown
+  let extraTokensAprBreakdown: Breakdown[] = currentAprBreakdown.filter(
+    (x) =>
+      ![...projectedAprBreakdown, projectedCvxApr].find((y) => y.label.startsWith(x.label)) &&
+      !x.label.startsWith('SDT'),
+  )
+
+  // Remove extra rewards already present in gaugesProjectedApr
+  if (strat?.gaugesProjectedApr) {
+    extraTokensAprBreakdown = extraTokensAprBreakdown.filter(
+      (x) => !strat.gaugesProjectedApr.find((z: any) => x.label === `${z.symbol} APR`),
+    )
+  }
+
+  // Compute total current APR
+  const currentTotal =
+    baseReward.value[0]! + currentAprBreakdown.reduce((total: number, curr) => total + curr.value[0]!, 0)
+
+  // Compute total projected APR
+  const projectedTotal =
+    baseReward.value[0]! +
+    projectedAprBreakdown.reduce((total: number, curr) => total + curr.value[0]!, 0) +
+    cvxApr +
+    (strat.gaugesProjectedApr ? strat.gaugesProjectedApr.reduce((total: number, y: any) => total + y.apr, 0) : 0) +
+    extraTokensAprBreakdown.reduce((total: number, y: any) => total + y.value[0], 0)
+
+  return {
+    current: {
+      total: currentTotal,
+      details: [baseReward, ...currentAprBreakdown].filter((r) => r.value[0] || -1 > 0),
+    },
+    projected: {
+      total: projectedTotal,
+      details: [
+        baseReward,
+        ...projectedAprBreakdown,
+        ...(strat?.gaugesProjectedApr
+          ? strat.gaugesProjectedApr.map((r: any) => ({
+              label: `${r.symbol} APR`,
+              value: [r.apr],
+            }))
+          : []),
+        ...extraTokensAprBreakdown,
+        projectedCvxApr,
+      ].filter((r) => r.value[0] > 0),
+    },
+  }
+}

package/src/strategies/curve/fetch/getCvxApr.ts

@@ -0,0 +1,49 @@
+import { formatUnits, parseUnits } from 'viem'
+import { Zero } from '../../utils/index.js'
+
+const CVX_CLIFF_SIZE = parseUnits('100000', 18) // new cliff every 100,000 tokens
+const CVX_CLIFF_COUNT = BigInt(1000) // 1,000 cliffs
+const CVX_MAX_SUPPLY = parseUnits('100000000', 18) // 100 mil max supply
+
+export const getCvxMintAmount = (crvEarned: bigint, _cvxTotalSupply: string) => {
+  // First get total supply
+  const cvxTotalSupply = parseUnits(_cvxTotalSupply, 0)
+
+  // Get current cliff
+  const currentCliff = cvxTotalSupply / CVX_CLIFF_SIZE
+
+  // If current cliff is under the max
+  if (currentCliff < CVX_CLIFF_COUNT) {
+    // Get remaining cliffs
+    const remaining = CVX_CLIFF_COUNT - currentCliff
+
+    // Multiply ratio of remaining cliffs to total cliffs against amount CRV received
+    let cvxEarned = (crvEarned * remaining) / CVX_CLIFF_COUNT
+
+    // Double check we have not gone over the max supply
+    const amountTillMax = CVX_MAX_SUPPLY - cvxTotalSupply
+    if (cvxEarned > amountTillMax) {
+      cvxEarned = amountTillMax
+    }
+
+    return cvxEarned
+  }
+
+  return Zero
+}
+
+export const getCvxApr = (
+  convexTvlInUsd: number,
+  tvlInUsd: number,
+  crvApr: number,
+  cvxTotalSupply: string,
+  cvxPrice: number,
+) => {
+  const weeklyCrvEarn = (convexTvlInUsd * (crvApr / 100)) / 52
+  const weeklyCrvEarnBI = parseUnits(weeklyCrvEarn.toString(), 18)
+
+  const weeklyCvxMint = getCvxMintAmount(weeklyCrvEarnBI, cvxTotalSupply)
+  const yearlyCvxMint = Number(formatUnits(weeklyCvxMint, 18)) * 52
+
+  return ((yearlyCvxMint * cvxPrice) / tvlInUsd) * 100
+}

package/src/strategies/curve/fetch/getOnlyboostData.ts

@@ -0,0 +1,100 @@
+import { formatUnits } from 'viem'
+import { projectWorkingBalance } from '../../../utils.js'
+import type { OnlyBoostData } from '../../types.js'
+import { getBoost } from '../../utils/boost.js'
+
+const getOnlyboostData = (
+  data: any,
+  stakeDaoVeBoost: string,
+  convexVeBoost: string,
+  veCrvTotalSupply: string,
+  curveGaugeTotalSupply: bigint,
+  strategyHoldings: bigint,
+  workingBalance: bigint,
+  baseTotalSupply: bigint,
+  lpPriceInUsd: number,
+): OnlyBoostData => {
+  const active = data.active
+  const convexImpl = data.convexImpl
+
+  const totalSupply = formatUnits(active ? data.totalSupply : baseTotalSupply, 0)
+
+  // Current
+  const stakeDaoSupply = formatUnits(data.stakeDaoSupply, 0)
+  const convexSupply = formatUnits(data.convexSupply, 0)
+
+  const stakeDaoTvl = Number(formatUnits(data.stakeDaoSupply, 18)) * lpPriceInUsd
+  const convexTvl = Number(formatUnits(data.convexSupply, 18)) * lpPriceInUsd
+
+  const stakeDaoShare = Number(stakeDaoSupply) / Number(totalSupply)
+  const convexShare = Number(convexSupply) / Number(totalSupply)
+
+  const stakeDaoBoost = getBoost('curve', strategyHoldings, workingBalance)
+  const convexBoost = getBoost('curve', data.convexStrategyHoldings, data.convexWorkingBalance)
+
+  // Optimal
+  const stakeDaoOptSupply = formatUnits(data.stakeDaoOptSupply, 0)
+  const convexOptSupply = formatUnits(data.convexOptSupply, 0)
+
+  const stakeDaoOptShare = Number(stakeDaoOptSupply) / Number(totalSupply)
+  const convexOptShare = Number(convexOptSupply) / Number(totalSupply)
+
+  const stakeDaoOptStrategyHoldings = strategyHoldings - data.stakeDaoSupply + data.stakeDaoOptSupply
+  const convexOptStrategyHoldings = data.convexStrategyHoldings - data.convexSupply + data.convexOptSupply
+
+  const stakeDaoOptWorkingBalance = projectWorkingBalance(
+    BigInt(stakeDaoVeBoost),
+    BigInt(veCrvTotalSupply),
+    stakeDaoOptStrategyHoldings,
+    curveGaugeTotalSupply,
+  )
+  const convexOptWorkingBalance = projectWorkingBalance(
+    BigInt(convexVeBoost),
+    BigInt(veCrvTotalSupply),
+    convexOptStrategyHoldings,
+    curveGaugeTotalSupply,
+  )
+
+  const stakeDaoOptBoost = getBoost('curve', stakeDaoOptStrategyHoldings, stakeDaoOptWorkingBalance)
+  const convexOptBoost = getBoost('curve', convexOptStrategyHoldings, convexOptWorkingBalance)
+
+  const boost = Number(totalSupply) > 0 ? stakeDaoBoost * stakeDaoShare + convexBoost * convexShare : 2.5
+  const optimalBoost =
+    Number(totalSupply) > 0 ? stakeDaoOptBoost * stakeDaoOptShare + convexOptBoost * convexOptShare : 2.5
+
+  return {
+    active,
+    implementations: [{ key: 'convex', address: convexImpl }],
+
+    totalSupply,
+    boost,
+    optimalBoost,
+
+    stakeDao: {
+      tvl: stakeDaoTvl,
+      supply: stakeDaoSupply,
+      boost: stakeDaoBoost,
+      optimal: {
+        supply: stakeDaoOptSupply,
+        boost: stakeDaoOptBoost,
+        share: stakeDaoOptShare,
+      },
+    },
+    convex: {
+      tvl: convexTvl,
+      supply: convexSupply,
+      boost: convexBoost,
+      optimal: {
+        supply: convexOptSupply,
+        boost: convexOptBoost,
+        share: convexOptShare,
+      },
+      claimable: data.claimableData.map((c: any) => ({
+        token: c.token,
+        claimable: formatUnits(c.claimable, 0),
+      })),
+    },
+  }
+}
+
+export default getOnlyboostData

package/src/strategies/curve/fetch/getStratsWithApr.ts

@@ -0,0 +1,118 @@
+import { formatUnits, parseAbi } from 'viem'
+
+import { ONE_YEAR, STRAT_FEES, contract, tokenWithId } from '@stake-dao/constants'
+import { equalTlc, multicall } from '../../../utils.js'
+
+export const getCurveStratsWithApr = (chainId: number, curveStrats: any[], apisData: any) => {
+  const curveStratsDataCalls: any[] = []
+
+  const strats = curveStrats.filter((s) => s.key && s.chainId === chainId && !s.isLending)
+
+  const curveStratsWithApr = strats.map((s) => {
+    const curveApiData = apisData.curveApiData.find((el) => equalTlc(el.lp, s.lpToken.address))
+
+    const subgraphData = apisData.curveSubgraphData.find((el: any) => curveApiData && el.address === curveApiData.pool)
+    const gaugesProjectedApr = curveApiData?.gauge
+      ? curveApiData.gauge.extraRewards.map((extra) => ({
+          symbol: extra.token.symbol,
+          apr: extra.apr,
+        }))
+      : []
+    const convexPool =
+      s.chainId === 1
+        ? apisData.convexPools.find(
+            (pool: any) => pool.lpTokenAddress.toLowerCase() === s.lpToken.address.toLowerCase(),
+          )
+        : undefined
+
+    curveStratsDataCalls.push({
+      vault: s.vault,
+      token: s.lpToken.address,
+      liquidityGauge: s.gaugeAddress,
+      sdtLiquidityGauge: s.sdGauge,
+    })
+
+    return {
+      ...s,
+      name: (s.isMetapool ? s.underlyingCoins : s.coins)
+        .reduce((res: string, current: any) => `${res}/${current.symbol}`, '')
+        .slice(1),
+      tradingApy: subgraphData?.latestWeeklyApy || 0,
+      gaugesProjectedApr,
+      minApr: curveApiData?.crvApr ? curveApiData.crvApr[0] * ((100 - STRAT_FEES) / 100) : 0,
+      maxApr: curveApiData?.crvApr ? curveApiData.crvApr[1] * ((100 - STRAT_FEES) / 100) : 0,
+      lpPriceInUsd: curveApiData.lpPriceInUsd,
+      convexPool: convexPool ? convexPool.convexPoolData : undefined,
+    }
+  })
+
+  return { curveStratsWithApr, curveStratsDataCalls }
+}
+
+export const getCurveLendingWithApr = async (provider: any, chainId: number, curveStrats: any[], apisData: any) => {
+  const curveLendingDataCalls: any[] = []
+
+  const strats = curveStrats.filter((s) => s.key && s.chainId === chainId && s.isLending)
+
+  const gaugesData = await multicall(
+    provider,
+    strats.flatMap((s) => [
+      { address: s.gaugeAddress, name: 'inflation_rate' },
+      { address: s.gaugeAddress, name: 'working_supply' },
+      { address: contract('curveGaugeController', chainId), name: 'gauge_relative_weight', params: [s.gaugeAddress] },
+    ]),
+    parseAbi([
+      'function inflation_rate() external view returns (uint256)',
+      'function working_supply() external view returns (uint256)',
+      'function gauge_relative_weight(address gauge) external view returns (uint256)',
+    ]),
+  )
+
+  const triCrvPool = apisData.curveApiData.find((el) => equalTlc(el.lp, '0x4eBdF703948ddCEA3B11f675B4D1Fba9d2414A14'))
+  const triCrvPoolCrvData = triCrvPool.coins.find((c) => equalTlc(c.coinAddress, tokenWithId('crv')?.address as string))
+  const crvPriceInUsd = triCrvPoolCrvData.usdBalance / Number(triCrvPoolCrvData.balance)
+
+  const curveLendingWithApr = strats.map((s) => {
+    const curveApiData = apisData.curveApiData.find((el) => equalTlc(el.lp, s.lpToken.address))
+
+    const convexPool =
+      s.chainId === 1
+        ? apisData.convexLendingVaults.find(
+            (pool: any) => pool.address.toLowerCase() === s.lpToken.address.toLowerCase(),
+          )
+        : undefined
+    const lpPriceInUsd = curveApiData?.lpPriceInUsd || 0
+
+    curveLendingDataCalls.push({
+      vault: s.vault,
+      token: s.lpToken.address,
+      liquidityGauge: s.gaugeAddress,
+      sdtLiquidityGauge: s.sdGauge,
+    })
+
+    const inflationRate = Number(formatUnits(gaugesData.shift().result as any as bigint, 18))
+    const workingSupply = Number(formatUnits(gaugesData.shift().result as any as bigint, 18))
+    const gaugeRelativeWeight = Number(formatUnits(gaugesData.shift().result as any as bigint, 18))
+
+    const crvBaseApr =
+      ((((inflationRate * gaugeRelativeWeight * ONE_YEAR) / workingSupply) * 0.4 * crvPriceInUsd) / lpPriceInUsd) * 100
+
+    const gaugesProjectedApr = undefined
+    const minApr = crvBaseApr * ((100 - STRAT_FEES) / 100)
+    const maxApr = crvBaseApr * 2.5 * ((100 - STRAT_FEES) / 100)
+
+    return {
+      ...s,
+      name: s.coins[0].symbol,
+      // subname: curveApiData?.assets ? `${curveApiData.assets.collateral.symbol} collateral` : '',
+      // tradingApy: curveApiData?.rates ? curveApiData.rates.lendApyPcent : 0,
+      gaugesProjectedApr,
+      minApr,
+      maxApr,
+      lpPriceInUsd,
+      convexPool: convexPool ? convexPool.convexPoolData : undefined,
+    }
+  })
+
+  return { curveLendingWithApr, curveLendingDataCalls }
+}