@stake-dao/reader 0.1.1 → 0.1.2

package/src/strategies/curve/build.ts

@@ -5,6 +5,7 @@ import { contract, tokens } from '@stake-dao/constants'
 import type { FetchedToken, Token } from '@stake-dao/constants'
 import { batchSdtGaugeRewards, batchTokenData } from '../../batches/index.js'
 import { equalTlc, getTokenInfo } from '../../utils.js'
+import type { BuiltStrat } from '../types.js'
 
 interface VaultAndLp {
   vault: string
@@ -16,60 +17,64 @@ export const buildCurveStrategies = async (
   stratsList: VaultAndLp[],
   chainId: number,
   externalApisResult: any[],
-) => {
+): Promise<BuiltStrat[]> => {
   const tokensToFetch: string[] = []
   const gaugesToFetch: string[] = []
 
-  const strats = stratsList.map((data) => {
-    const lpToken = data.lpToken
-    const curveApiData = externalApisResult.find((el) => equalTlc(el.lp, lpToken))
-
-    if (curveApiData) {
-      const isMetapool = curveApiData.isMetapool
-      const isLending = curveApiData.isLending
-
-      const coins: string[] = curveApiData.coins.map((c) => c.coinAddress)
-
-      let underlyingCoins: string[] = []
-      if (isMetapool || isLending) {
-        underlyingCoins = curveApiData.underlyingCoins
+  const strats = stratsList
+    .map((data, index) => {
+      const lpToken = data.lpToken
+      const curveApiData = externalApisResult.find((el) => equalTlc(el.lp, lpToken))
+
+      if (curveApiData) {
+        const isMetapool = curveApiData.isMetapool
+        const isLending = curveApiData.isLending
+
+        const coins: string[] = curveApiData.coins.map((c) => c.coinAddress)
+
+        let underlyingCoins: string[] = []
+        if (isMetapool || isLending) {
+          underlyingCoins = curveApiData.underlyingCoins
+        }
+
+        const gaugeAddress = curveApiData.gauge?.address || undefined
+
+        for (const coin of coins) tokensToFetch.push(coin)
+        for (const uCoin of underlyingCoins) tokensToFetch.push(uCoin)
+        tokensToFetch.push(lpToken)
+
+        if (typeof gaugeAddress === 'undefined') {
+          gaugesToFetch.push(data.vault)
+        }
+
+        return {
+          type: curveApiData.poolType,
+          key: `${curveApiData.poolType}-${curveApiData.id}`,
+          isMetapool,
+          isLending,
+          coins,
+          vault: data.vault,
+          lpToken,
+          gaugeAddress,
+          underlyingCoins,
+        }
       }
 
-      const gaugeAddress = curveApiData.gauge?.address || undefined
-
-      for (const coin of coins) tokensToFetch.push(coin)
-      for (const uCoin of underlyingCoins) tokensToFetch.push(uCoin)
-      tokensToFetch.push(lpToken)
-
-      if (typeof gaugeAddress === 'undefined') {
-        gaugesToFetch.push(data.vault)
-      }
+      console.error(`-- Error building curve strat at index ${index}: Not found in API data`)
+      console.error(`   Vault: ${data.vault}`)
+      console.error(`   LP Token: ${data.lpToken}`)
 
       return {
-        type: curveApiData.poolType,
-        key: `${curveApiData.poolType}-${curveApiData.id}`,
-        isMetapool,
-        isLending,
-        coins,
+        type: 'error',
+        key: 'error',
+        coins: [],
         vault: data.vault,
         lpToken,
-        gaugeAddress,
-        underlyingCoins,
+        gaugeAddress: 'error',
+        underlyingCoins: [],
       }
-    }
-
-    return {
-      type: undefined,
-      key: undefined,
-      isMetapool: undefined,
-      isLending: undefined,
-      coins: [],
-      vault: data.vault,
-      lpToken,
-      gaugeAddress: undefined,
-      underlyingCoins: [],
-    }
-  })
+    })
+    .filter((s) => s.type !== 'error')
 
   // Fetch tokens infos
   const inputArgsChunks = chunk(

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

@@ -1,6 +1,6 @@
 import { STRAT_FEES } from '@stake-dao/constants'
-import { equalTlc } from '../../../utils.js'
 import { mainnet } from 'viem/chains'
+import { equalTlc } from '../../../utils.js'
 
 const getConvexPool = (apisData: any, chainId: number, isLending: boolean, stratLpAddress: string) => {
   if (chainId === mainnet.id) {

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

@@ -2,20 +2,19 @@ import { formatUnits } from 'viem'
 
 import { ONE_YEAR, curveStrats, mainnet, tokenWithId } from '@stake-dao/constants'
 import { equalTlc } from '../../../utils.js'
-import type { OnlyBoostData, RewardsData, SdtApr } from '../../types.js'
+import type { CurveGlobalData, OnlyBoostData, RewardsData, StrategyData } from '../../types.js'
 import { getBoost } from '../../utils/boost.js'
 import decodeEtherscanFactoryEvent, { decodeNewFactoryEvent } from '../../utils/decodeEtherscanFactoryEvent.js'
+import { getAprBreakdown } from '../../utils/getAprBreakdown.js'
 import { OneEther, Zero } from '../../utils/index.js'
-import { type SdtEmissionData, computeSdtApr } from '../../utils/sdt.js'
+import { type SdtEmissionData, getSdtApr } from '../../utils/sdt.js'
 import { buildCurveStrategies } from '../build.js'
 import { getCurveHttpCalls } from '../httpCalls.js'
 import { getOnChainSdCurveData } from '../onChainCalls.js'
 import type { GaugesWeightsData } from './curveApiData/getGaugesWeights.js'
-import { getAprBreakdown } from './getAprBreakdown.js'
 import { getCvxApr } from './getCvxApr.js'
 import getOnlyboostData from './getOnlyboostData.js'
 import { getCurveStratsWithApr } from './getStratsWithApr.js'
-import type { StratGlobalData } from './types.js'
 
 export const fetchCurve = async (
   prices: any, // TODO Type
@@ -27,7 +26,7 @@ export const fetchCurve = async (
   lastBlockNumber: number,
   sdtEmissionData: SdtEmissionData,
   gaugesWeights: GaugesWeightsData,
-) => {
+): Promise<StrategyData> => {
   const apisData = await getCurveHttpCalls(explorerApiKey, explorer, rpc, chainId, lastBlockNumber, gaugesWeights)
 
   const newVaultAndLp =
@@ -39,11 +38,15 @@ export const fetchCurve = async (
 
   const strats: any[] = await buildCurveStrategies(provider, allVaultAndLp, chainId, apisData.curveApiData)
 
-  const { curveStratsWithApr: stratsWithApr, curveStratsDataCalls: stratsDataCalls } = getCurveStratsWithApr(chainId, strats, apisData)
+  const { curveStratsWithApr: stratsWithApr, curveStratsDataCalls: stratsDataCalls } = getCurveStratsWithApr(
+    chainId,
+    strats,
+    apisData,
+  )
 
   const decodedPromise = await getOnChainSdCurveData(chainId, rpc, stratsDataCalls)
 
-  const global: StratGlobalData = {
+  const global: CurveGlobalData = {
     totalGaugeWeights: '0',
     nextEffectiveTimestamp: '0',
     cvxTotalSupply: '0',
@@ -153,19 +156,7 @@ export const fetchCurve = async (
         }
       })
 
-      let sdtApr: SdtApr = {
-        sdtUserApr: 0,
-        sdtFuturUserApr: 0,
-        sdtMinApr: 0,
-        sdtFuturMinApr: 0,
-        sdtMaxApr: 0,
-        sdtFuturMaxApr: 0,
-        sdtBoost: 1,
-      }
-      const sdtRewards = rewardsData.find((r) => r.token.symbol === 'SDT')
-      if (sdtRewards) {
-        sdtApr = computeSdtApr(sdtEmissionData, sdtRewards, undefined, sdGauge, strat.lpPriceInUsd)
-      }
+      const sdtApr = getSdtApr(rewardsData, sdtEmissionData, sdGauge, strat.lpPriceInUsd, undefined)
 
       let convexCrvProjectedApr = 0
       let cvxApr = 0
@@ -184,7 +175,7 @@ export const fetchCurve = async (
             : 0
       }
 
-      const apr = getAprBreakdown(strat, rewardsData, boost, cvxApr, sdtApr)
+      const apr = getAprBreakdown(strat, rewardsData, boost, sdtApr, cvxApr)
 
       return {
         ...strat,
@@ -216,7 +207,6 @@ export const fetchCurve = async (
         totalSupply,
         strategyHoldings: formatUnits(v.strategyHoldings, 0),
         workingBalance: formatUnits(v.workingBalance, 0),
-        workingSupplyStaked: formatUnits(v.workingSupplyStaked, 0),
         sdGauge,
         vaultFees:
           chainId === mainnet.id

package/src/strategies/curve/httpCalls.ts

@@ -78,7 +78,9 @@ export const getCurveHttpCalls = async (
 
       const arbiscanData = arbitrumHttpResponses[0]
       const arbitrumCurveData = arbitrumHttpResponses[1]
-      const arbitrumCurveSubgraph = arbitrumHttpResponses[2].success ? arbitrumHttpResponses[2].data.poolList : undefined
+      const arbitrumCurveSubgraph = arbitrumHttpResponses[2].success
+        ? arbitrumHttpResponses[2].data.poolList
+        : undefined
 
       return {
         explorerData: arbiscanData,

package/src/strategies/types.ts

@@ -65,7 +65,7 @@ export type Fees = {
 
 export type VaultFees = {
   keeper: number
-  accumulated: number
+  accumulated: string
 }
 
 export type SdtApr = {
@@ -94,15 +94,18 @@ export type Strategy = {
   type: string
   protocol: string
   chainId: number
-  isMetapool: boolean
-  isLending: boolean
+  isMetapool?: boolean
+  isLending?: boolean
   vault: string
   lpToken: Coin
   gaugeAddress: string
+  gaugeToken?: Coin & { version: number }
   coins: Coin[]
   underlyingCoins?: Coin[]
   rewards: RewardsData[]
   name: string
+  tradingApy: number
+  underlyingApy?: number
   minApr: number
   maxApr: number
   lpPriceInUsd: number
@@ -120,18 +123,61 @@ export type Strategy = {
     boost: number
     current: AprDetail
     projected: AprDetail
-    onlyboost: {
+    onlyboost?: {
       convex: OnlyBoostAprDetail
       optimal: OnlyBoostAprDetail
     }
   }
-  sdtApr: SdtApr
+  sdtApr?: SdtApr
   vaultHoldings: string
   totalSupply: string
   strategyHoldings: string
   workingBalance: string
-  workingSupplyStaked: string
   sdGauge: SdGauge
   vaultFees: VaultFees
   onlyboost?: OnlyBoostData | { active: boolean }
 }
+
+// GLOBAL DATA TYPE
+
+export type CurveGlobalData = {
+  totalGaugeWeights: string
+  nextEffectiveTimestamp: string
+  cvxTotalSupply: string
+  veCrvTotalSupply: string
+  stakeDaoVeBoost: string
+  convexVeBoost: string
+  fees: Fees
+}
+
+export type YearnGlobalData = {
+  totalGaugeWeights: string
+  fees: Fees
+}
+
+export type Global = CurveGlobalData | YearnGlobalData
+
+export type StrategyData = {
+  global?: Global
+  deployed: Strategy[]
+  notDeployed: any
+  fetched: boolean
+}
+
+export type BuiltStrat = {
+  key: string
+  type: string
+  protocol: string
+  chainId: number
+  isMetapool?: boolean
+  isLending?: boolean
+  vault: string
+  lpToken: Coin
+  gaugeAddress: string
+  gaugeToken?: Coin & { version: number }
+  coins: Coin[]
+  underlyingCoins?: Coin[]
+  sdGauge: string
+  rewards: Coin[]
+  underlyingReward?: Coin
+}

package/src/strategies/{curve/fetch → utils}/getAprBreakdown.ts

@@ -1,12 +1,18 @@
-import { getBreakdownLabel, isProtocolToken } from '../../../utils.js'
-import type { RewardsData } from '../../types.js'
+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) => {
+export const getAprBreakdown = (
+  strat: any,
+  rewardsData: RewardsData[],
+  boost: number,
+  sdtApr: any,
+  cvxApr: number = 0,
+) => {
   // Base Rewards
   // Trading Fees for LP
   // Supply APY for lending
@@ -15,6 +21,13 @@ export const getAprBreakdown = (strat: any, rewardsData: RewardsData[], boost: n
     value: [strat?.tradingApy || 0],
   }
 
+  const underlyingReward = strat.underlyingReward
+    ? {
+        label: `Underlying Yield (${strat.underlyingReward.symbol})`,
+        value: [strat.underlyingReward.apy],
+      }
+    : { label: '', value: [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]
@@ -25,10 +38,10 @@ export const getAprBreakdown = (strat: any, rewardsData: RewardsData[], boost: n
     }
   })
 
-  // Projected CRV APR
+  // Projected Protocol Token (CRV, dYFI, CAKE, ...) APR
   const projectedCrvApr = strat ? boost * strat.minApr : 0
 
-  // Projected CVX APR
+  // Projected CVX APR - for Onlyboost Convex only
   const projectedCvxApr = { label: 'CVX APR', value: [cvxApr] }
 
   // Format SDT and CRV rewards APR for breakdown
@@ -64,11 +77,14 @@ export const getAprBreakdown = (strat: any, rewardsData: RewardsData[], boost: n
 
   // Compute total current APR
   const currentTotal =
-    baseReward.value[0]! + currentAprBreakdown.reduce((total: number, curr) => total + curr.value[0]!, 0)
+    baseReward.value[0]! +
+    underlyingReward.value[0] +
+    currentAprBreakdown.reduce((total: number, curr) => total + curr.value[0]!, 0)
 
   // Compute total projected APR
   const projectedTotal =
     baseReward.value[0]! +
+    underlyingReward.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) +
@@ -77,12 +93,13 @@ export const getAprBreakdown = (strat: any, rewardsData: RewardsData[], boost: n
   return {
     current: {
       total: currentTotal,
-      details: [baseReward, ...currentAprBreakdown].filter((r) => r.value[0] || -1 > 0),
+      details: [baseReward, underlyingReward, ...currentAprBreakdown].filter((r) => r?.value[0] > 0 || false),
     },
     projected: {
       total: projectedTotal,
       details: [
         baseReward,
+        underlyingReward,
         ...projectedAprBreakdown,
         ...(strat?.gaugesProjectedApr
           ? strat.gaugesProjectedApr.map((r: any) => ({
@@ -92,7 +109,7 @@ export const getAprBreakdown = (strat: any, rewardsData: RewardsData[], boost: n
           : []),
         ...extraTokensAprBreakdown,
         projectedCvxApr,
-      ].filter((r) => r.value[0] > 0),
+      ].filter((r) => r?.value[0] > 0 || false),
     },
   }
 }

package/src/strategies/utils/index.ts

@@ -1,6 +1,7 @@
 import { parseEther } from 'viem'
 
 export const Zero = BigInt(0)
+export const One = BigInt(1)
 export const OneEther = parseEther('1')
 
 export * from './boost.js'

package/src/strategies/utils/sdt.ts

@@ -204,3 +204,27 @@ export const computeSdtApr = (
     sdtBoost: sdtRangeApr?.sdtBoost || 1,
   }
 }
+
+export const getSdtApr = (
+  rewardsData: any, // TODO Type
+  sdtEmissionData: SdtEmissionData,
+  sdGauge: any,
+  lpPriceInUsd: number,
+  userData: any,
+): SdtApr => {
+  let sdtApr: SdtApr = {
+    sdtUserApr: 0,
+    sdtFuturUserApr: 0,
+    sdtMinApr: 0,
+    sdtFuturMinApr: 0,
+    sdtMaxApr: 0,
+    sdtFuturMaxApr: 0,
+    sdtBoost: 1,
+  }
+  const sdtRewards = rewardsData.find((r) => r.token.symbol === 'SDT')
+  if (sdtRewards) {
+    sdtApr = computeSdtApr(sdtEmissionData, sdtRewards, userData, sdGauge, lpPriceInUsd)
+  }
+
+  return sdtApr
+}

package/src/strategies/yearn/build.ts

@@ -0,0 +1,156 @@
+import { chunk, remove, uniq } from 'lodash-es'
+import { decodeAbiParameters, encodeAbiParameters, parseAbiParameters } from 'viem'
+
+import { contracts, tokens } from '@stake-dao/constants'
+import type { FetchedToken, Token } from '@stake-dao/constants'
+import { batchSdtGaugeRewards, batchTokenData, buildYearnStrats } from '../../batches/index.js'
+import { equalTlc, getTokenInfo } from '../../utils.js'
+import type { BuiltStrat } from '../types.js'
+
+interface VaultAndLp {
+  vault: string
+  lpToken: string
+}
+
+export const buildYearnStrategies = async (
+  provider: any,
+  stratsList: VaultAndLp[],
+  chainId: number,
+): Promise<BuiltStrat[]> => {
+  const tokensToFetch: string[] = []
+
+  const inputArgsChunks = chunk(stratsList, 30)
+  const stratsPromise = await Promise.allSettled(
+    inputArgsChunks.map(async (inputArgs) => {
+      const inputData = encodeAbiParameters(parseAbiParameters(buildYearnStrats.inputType![chainId]!) as any, [
+        contracts.yearnGaugeFactory![chainId],
+        inputArgs,
+      ])
+      const contractCreationCode = buildYearnStrats.bytecode![chainId]!.concat(inputData.slice(2))
+      const returnedData = await provider.call({
+        data: contractCreationCode,
+      })
+      return decodeAbiParameters(buildYearnStrats.outputType![chainId]! as any, returnedData.data)
+    }),
+  )
+  const fetchedStrats = stratsPromise.flatMap((d) => (d.status === 'fulfilled' ? d.value[0].yearnStrats : [])).flat()
+
+  const strats = stratsList.map((data, index) => {
+    const vault = data.vault
+    const lpToken = data.lpToken
+    const gaugeAddress = fetchedStrats[index].gauge
+    const sdGauge = fetchedStrats[index].sdGauge
+
+    const coins = fetchedStrats[index].coins
+    const rewards = fetchedStrats[index].rewardsTokens
+    const underlyingReward = fetchedStrats[index].underlyingReward
+    const gaugeVersion = Number(fetchedStrats[index].gaugeVersion)
+
+    for (const c of coins) tokensToFetch.push(c)
+    for (const c of rewards) tokensToFetch.push(c)
+    tokensToFetch.push(lpToken)
+    tokensToFetch.push(gaugeAddress)
+    tokensToFetch.push(underlyingReward)
+
+    return {
+      key: vault,
+      vault,
+      gaugeAddress,
+      sdGauge,
+      lpToken,
+      coins,
+      rewards,
+      underlyingReward,
+      gaugeVersion,
+    }
+  })
+
+  // Fetch tokens infos
+  const tokensInputArgsChunks = chunk(
+    remove(uniq(tokensToFetch), (t) => !tokens.find((token: Token) => token.address === t)),
+    40,
+  )
+  const decodedPromise = await Promise.allSettled(
+    tokensInputArgsChunks.map(async (inputArgs) => {
+      const inputData = encodeAbiParameters(parseAbiParameters(batchTokenData.inputType[chainId] || []) as any, [
+        inputArgs,
+      ])
+      const contractCreationCode = batchTokenData.bytecode[chainId]?.concat(inputData.slice(2))
+      const returnedData = await provider.call({
+        data: contractCreationCode,
+      })
+      return decodeAbiParameters(
+        parseAbiParameters(batchTokenData.outputTypeHr[chainId] || []) as any,
+        returnedData.data,
+      )
+    }),
+  )
+
+  const fetchedTokenData = decodedPromise.flatMap((d) => (d.status === 'fulfilled' ? d.value : [])).flat()
+
+  // Fetch Sdt Gauge rewards tokens infos
+  const sdtGaugeInputArgsChunks = chunk(
+    stratsList.map((data) => data.vault),
+    30,
+  )
+  const sdtGaugedecodedPromise = await Promise.allSettled(
+    sdtGaugeInputArgsChunks.map(async (inputArgs) => {
+      const inputData = encodeAbiParameters(parseAbiParameters(batchSdtGaugeRewards.inputType[chainId] || []) as any, [
+        inputArgs,
+      ])
+      const contractCreationCode = batchSdtGaugeRewards.bytecode[chainId]?.concat(inputData.slice(2))
+      const returnedData = await provider.call({
+        data: contractCreationCode,
+      })
+      return decodeAbiParameters(
+        parseAbiParameters(batchSdtGaugeRewards.outputTypeHr[chainId] || []) as any,
+        returnedData.data,
+      )
+    }),
+  )
+  const fetchedSdtGaugeData = sdtGaugedecodedPromise.flatMap((d) => (d.status === 'fulfilled' ? d.value : [])).flat()
+
+  const stratsData = strats.map((s, index) => {
+    const coinsData = s.coins.map((c) =>
+      getTokenInfo(
+        fetchedTokenData.find((t) => equalTlc(t.tokenAddress, c)),
+        c,
+        chainId,
+      ),
+    )
+    const stakeTokenData = getTokenInfo(
+      fetchedTokenData.find((t) => equalTlc(t.tokenAddress, s.lpToken)),
+      s.lpToken,
+      chainId,
+    )
+    const gaugeTokenData = getTokenInfo(
+      fetchedTokenData.find((t) => equalTlc(t.tokenAddress, s.gaugeAddress)),
+      s.gaugeAddress,
+      chainId,
+    )
+    const underlyingRewardData = getTokenInfo(
+      fetchedTokenData.find((t) => equalTlc(t.tokenAddress, s.underlyingReward)),
+      s.underlyingReward,
+      chainId,
+    )
+
+    return {
+      key: s.key,
+      type: 'veyfi-gauge',
+      protocol: 'yearn',
+      chainId: chainId,
+      vault: s.vault,
+      gaugeAddress: s.gaugeAddress,
+      lpToken: stakeTokenData,
+      gaugeToken: { ...gaugeTokenData, version: s.gaugeVersion },
+      coins: coinsData,
+      sdGauge: fetchedSdtGaugeData[index]?.gauge || undefined,
+      rewards: fetchedSdtGaugeData[index]?.rewards.map((tokenInfo: FetchedToken) =>
+        getTokenInfo(tokenInfo, tokenInfo.tokenAddress, chainId),
+      ),
+      underlyingReward: underlyingRewardData,
+    }
+  })
+
+  return stratsData
+}

package/src/strategies/yearn/fetch/computeYearnApr.ts

@@ -0,0 +1,47 @@
+import { formatUnits } from 'viem'
+
+import { ONE_YEAR, STRAT_FEES } from '@stake-dao/constants'
+
+export const computeYearnApr = (args: {
+  rawTotalAssets: bigint
+  rawRewardRate: bigint
+  rawPricePerShare: bigint
+  dYfiPrice: number
+  strat: any
+  yearnApiData: any
+}) => {
+  const { rawTotalAssets, rawRewardRate, rawPricePerShare, dYfiPrice, strat, yearnApiData } = args
+
+  const yearnStratApiData = yearnApiData.find(
+    (element) => element.address.toLowerCase() === strat.lpToken.address.toLowerCase(),
+  )
+
+  const underlyingAprLpPriceInUsd = yearnStratApiData ? yearnStratApiData.tvl.price : 0
+  const lpPriceInUsd = underlyingAprLpPriceInUsd * Number(formatUnits(rawPricePerShare, strat.lpToken.decimals))
+
+  const vaultMonthlyApr = yearnStratApiData ? yearnStratApiData.apr.points.monthAgo : 0
+  const vaultWeeklyApr = yearnStratApiData ? yearnStratApiData.apr.points.weekAgo : 0
+  const underlyingApr = (vaultMonthlyApr === 0 ? vaultWeeklyApr : vaultMonthlyApr) * 100
+
+  const totalAssets = Number(formatUnits(rawTotalAssets, strat.gaugeToken.decimals))
+
+  const rewardScale = (strat.gaugeToken.version === 2 ? 36 : 18) + (18 - strat.lpToken.decimals)
+  const rewardRate = Number(formatUnits(rawRewardRate, rewardScale))
+
+  const maxApr =
+    lpPriceInUsd > 0 && rewardRate > 0 && totalAssets > 0
+      ? (rewardRate * dYfiPrice * ONE_YEAR) / totalAssets / lpPriceInUsd
+      : 0
+  const minApr = maxApr / 10
+
+  const coins = strat.underlyingCoins && strat.underlyingCoins.length > 0 ? strat.underlyingCoins : strat.coins
+
+  return {
+    ...strat,
+    name: coins.reduce((res: string, current) => `${res}/${current.symbol}`, '').slice(1),
+    lpPriceInUsd,
+    underlyingApr,
+    minApr: minApr * (100 - STRAT_FEES),
+    maxApr: maxApr * (100 - STRAT_FEES),
+  }
+}