@stake-dao/reader 0.1.0 → 0.1.2

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

@@ -1,12 +1,30 @@
-import { formatUnits, parseAbi } from 'viem'
+import { STRAT_FEES } from '@stake-dao/constants'
+import { mainnet } from 'viem/chains'
+import { equalTlc } from '../../../utils.js'
+
+const getConvexPool = (apisData: any, chainId: number, isLending: boolean, stratLpAddress: string) => {
+  if (chainId === mainnet.id) {
+    if (isLending) {
+      return apisData.convexLendingVaults.find((pool: any) => equalTlc(pool.address, stratLpAddress))
+    }
+    return apisData.convexPools.find((pool: any) => equalTlc(pool.lpTokenAddress, stratLpAddress))
+  }
+  return undefined
+}
 
-import { ONE_YEAR, STRAT_FEES, contract, tokenWithId } from '@stake-dao/constants'
-import { equalTlc, multicall } from '../../../utils.js'
+const getName = (s: any) => {
+  if (s.isLending) {
+    return s.coins[0].symbol
+  }
+  return (s.isMetapool ? s.underlyingCoins : s.coins)
+    .reduce((res: string, current: any) => `${res}/${current.symbol}`, '')
+    .slice(1)
+}
 
 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 strats = curveStrats.filter((s) => s.key && s.chainId === chainId)
 
   const curveStratsWithApr = strats.map((s) => {
     const curveApiData = apisData.curveApiData.find((el) => equalTlc(el.lp, s.lpToken.address))
@@ -18,12 +36,7 @@ export const getCurveStratsWithApr = (chainId: number, curveStrats: any[], apisD
           apr: extra.apr,
         }))
       : []
-    const convexPool =
-      s.chainId === 1
-        ? apisData.convexPools.find(
-            (pool: any) => pool.lpTokenAddress.toLowerCase() === s.lpToken.address.toLowerCase(),
-          )
-        : undefined
+    const convexPool = getConvexPool(apisData, s.chainId, s.isLending, s.lpToken.address)
 
     curveStratsDataCalls.push({
       vault: s.vault,
@@ -34,9 +47,10 @@ export const getCurveStratsWithApr = (chainId: number, curveStrats: any[], apisD
 
     return {
       ...s,
-      name: (s.isMetapool ? s.underlyingCoins : s.coins)
-        .reduce((res: string, current: any) => `${res}/${current.symbol}`, '')
-        .slice(1),
+      name: getName(s),
+      // TODO LENDING
+      // subname: curveApiData?.assets ? `${curveApiData.assets.collateral.symbol} collateral` : '',
+      // tradingApy: curveApiData?.rates ? curveApiData.rates.lendApyPcent : 0,
       tradingApy: subgraphData?.latestWeeklyApy || 0,
       gaugesProjectedApr,
       minApr: curveApiData?.crvApr ? curveApiData.crvApr[0] * ((100 - STRAT_FEES) / 100) : 0,
@@ -48,71 +62,3 @@ export const getCurveStratsWithApr = (chainId: number, curveStrats: any[], apisD
 
   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 }
-}

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 { getCurveLendingWithApr, getCurveStratsWithApr } from './getStratsWithApr.js'
-import type { StratGlobalData } from './types.js'
+import { getCurveStratsWithApr } from './getStratsWithApr.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,20 +38,15 @@ export const fetchCurve = async (
 
   const strats: any[] = await buildCurveStrategies(provider, allVaultAndLp, chainId, apisData.curveApiData)
 
-  const { curveStratsWithApr, curveStratsDataCalls } = getCurveStratsWithApr(chainId, strats, apisData)
-  const { curveLendingWithApr, curveLendingDataCalls } = await getCurveLendingWithApr(
-    provider,
+  const { curveStratsWithApr: stratsWithApr, curveStratsDataCalls: stratsDataCalls } = getCurveStratsWithApr(
     chainId,
     strats,
     apisData,
   )
 
-  const stratsWithApr = [...curveStratsWithApr, ...curveLendingWithApr]
-  const stratsDataCalls = [...curveStratsDataCalls, ...curveLendingDataCalls]
-
   const decodedPromise = await getOnChainSdCurveData(chainId, rpc, stratsDataCalls)
 
-  const global: StratGlobalData = {
+  const global: CurveGlobalData = {
     totalGaugeWeights: '0',
     nextEffectiveTimestamp: '0',
     cvxTotalSupply: '0',
@@ -148,7 +142,7 @@ export const fetchCurve = async (
         return {
           token: rewardToken,
           price: rewardPrice ? rewardPrice.usdPrice : 0,
-          apr: rewardApr,
+          apr: rewardApr * 100,
           streaming,
           periodFinish,
           rate: formatUnits(r.rate, 0),
@@ -162,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
@@ -193,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,
@@ -225,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

@@ -66,12 +66,9 @@ export const getCurveHttpCalls = async (
             FACTORY_EXPLORER_EVENTS(explorerApiKey, explorer, contract('curveVaultFactory', chainId), lastBlockNumber),
           )
         ).json(),
-        // Curve Apis
-        (await fetch(`${CURVE_API_URL}/getPools/arbitrum/factory`)).json(),
-        (await fetch(`${CURVE_API_URL}/getPools/arbitrum/main`)).json(),
-        (await fetch(`${CURVE_API_URL}/getPools/arbitrum/crypto`)).json(),
-        (await fetch(`${CURVE_API_URL}/getPools/arbitrum/factory-stable-ng`)).json(),
-        (await fetch(`${CURVE_API_URL}/getPools/arbitrum/factory-tricrypto`)).json(),
+        // Curve Data (replace APIs calls)
+        fetchCurveBase(rpc, chainId, gaugesWeights.gauges),
+        // Curve Trading Apy API
         (await fetch(`${CURVE_API_URL}/getSubgraphData/arbitrum`)).json(),
       ]
 
@@ -80,30 +77,17 @@ export const getCurveHttpCalls = async (
       )
 
       const arbiscanData = arbitrumHttpResponses[0]
-      const arbitrumCurveFactory = arbitrumHttpResponses[1].success ? arbitrumHttpResponses[1].data.poolData : undefined
-      const arbitrumCurveMain = arbitrumHttpResponses[2].success ? arbitrumHttpResponses[2].data.poolData : undefined
-      const arbitrumCurveCrypto = arbitrumHttpResponses[3].success ? arbitrumHttpResponses[3].data.poolData : undefined
-      const arbitrumCurveFactoryStableNg = arbitrumHttpResponses[4].success
-        ? arbitrumHttpResponses[4].data.poolData
-        : undefined
-      const arbitrumCurveFactoryTriCrypto = arbitrumHttpResponses[5].success
-        ? arbitrumHttpResponses[5].data.poolData
-        : undefined
-      const arbitrumCurveSubgraph = arbitrumHttpResponses[6].success
-        ? arbitrumHttpResponses[6].data.poolList
+      const arbitrumCurveData = arbitrumHttpResponses[1]
+      const arbitrumCurveSubgraph = arbitrumHttpResponses[2].success
+        ? arbitrumHttpResponses[2].data.poolList
         : undefined
 
       return {
         explorerData: arbiscanData,
         curveSubgraphData: arbitrumCurveSubgraph,
         convexPools: [],
-        curveApiData: [
-          { type: 'factory-tricrypto', value: arbitrumCurveFactoryTriCrypto },
-          { type: 'factory', value: arbitrumCurveFactory },
-          { type: 'main', value: arbitrumCurveMain },
-          { type: 'crypto', value: arbitrumCurveCrypto },
-          { type: 'factory-stable-ng', value: arbitrumCurveFactoryStableNg },
-        ],
+        convexLendingVaults: [],
+        curveApiData: arbitrumCurveData,
       }
     }
   }

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,9 +21,16 @@ 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 * 100]
+    const value = r.token.symbol === 'SDT' ? [sdtApr.sdtMinApr, sdtApr.sdtMaxApr] : [r.apr]
 
     return {
       label: getBreakdownLabel(strat, r, false, boost, sdtApr),
@@ -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
+}