@stake-dao/reader 0.1.4 → 0.2.1

package/src/strategies/pendle/fetch.ts

@@ -0,0 +1,349 @@
+import dayjs from 'dayjs'
+import { chunk } from 'lodash-es'
+import { encodeAbiParameters, formatUnits, parseAbiParameters } from 'viem'
+
+import { ONE_YEAR, STRAT_FEES, contract, contracts, mainnet, pendleStrats, tokenWithId } from '@stake-dao/constants'
+import { batchPendleStrats } from '../../bytecodes/index.js'
+import type { Price } from '../../prices.js'
+import { type Call, batchJsonRpc, equalTlc, multicall } from '../../utils.js'
+import { FACTORY_EXPLORER_EVENTS } from '../curve/endpoints.js'
+import type { RewardsData, SdtApr, ValidChainId, ValidExplorer } from '../types.js'
+import { getBoost } from '../utils/boost.js'
+import decodeEtherscanFactoryEvent from '../utils/decodeEtherscanFactoryEvent.js'
+import { getAprBreakdown } from '../utils/getAprBreakdown.js'
+import { OneEther, Zero, concatBytecode } from '../utils/index.js'
+import multicallPendleStratsAbi from './abis/MulticallPendleStratsAbi.json'
+import { buildPendleStrategies } from './build.js'
+import getPendleApiData from './getPendleApiData.js'
+import pendlePoints from './pendlePoints.js'
+
+const pendleApiForMarket = async (market: string) =>
+  (await fetch(`https://api-v2.pendle.finance/core/v1/1/markets/${market}`)).json()
+
+const calls = (tokenAddresses: string[]): Call[] => [
+  { address: contracts.sdGaugeController![1]!, name: 'get_total_weight' },
+  ...tokenAddresses.map((tokenAddress) => ({
+    address: tokenAddress,
+    name: 'redeemRewards',
+    params: [contracts.pendleLocker![1]],
+  })),
+]
+
+interface TFetchPendle {
+  prices: Price[]
+  provider: any
+  rpc: string
+  explorerApiKey: string
+  explorer: ValidExplorer
+  chainId: ValidChainId
+}
+
+export const fetchPendle = async ({ prices, provider, rpc, explorerApiKey, explorer, chainId }: TFetchPendle) => {
+  const sdt = tokenWithId('sdt', chainId)!
+  const sdtToken = {
+    name: sdt.name,
+    symbol: sdt.symbol,
+    decimals: sdt.decimals,
+    address: sdt.address,
+  }
+
+  const lastBlockNumber = pendleStrats.meta.lastSyncBlock[chainId]! + 1
+
+  const httpCalls = [
+    // Etherscan Events
+    await (
+      await fetch(
+        FACTORY_EXPLORER_EVENTS(explorerApiKey, explorer, contracts.pendleVaultFactory![chainId]!, lastBlockNumber),
+      )
+    ).json(),
+    // Pende Api
+    getPendleApiData(),
+  ]
+
+  const httpResp = await Promise.all(httpCalls)
+  const etherscanData = httpResp[0]
+  const pendleApiData = httpResp[1]
+
+  const vaultsAndLps = pendleStrats.strats[chainId]!.concat(decodeEtherscanFactoryEvent(etherscanData))
+  const strats: any[] = await buildPendleStrategies(rpc, vaultsAndLps, pendleApiData, chainId)
+
+  const pendleMarketAddresses = strats.map((s) => s.lpToken.address.toLowerCase())
+
+  const stratsWithExtraUnderlyingReward = pendleApiData.filter(
+    (s) => pendleMarketAddresses.includes(s.address.toLowerCase()) && s.underlyingRewardApy > 0,
+  )
+  const extraDataHttpCalls = stratsWithExtraUnderlyingReward.map((s) => pendleApiForMarket(s.address))
+  const pendleApiExtraData = await Promise.all(extraDataHttpCalls)
+
+  const inputArgsChunks = chunk(
+    strats.map((data) => [data.vault, data.lpToken.address]),
+    12,
+  )
+
+  const allContractCreationCodes: string[] = inputArgsChunks.map((inputArgs) => {
+    const inputParams = [contract('sdGaugeController', chainId), inputArgs]
+
+    const inputData = encodeAbiParameters(
+      parseAbiParameters(batchPendleStrats.inputType[chainId] || []) as any,
+      inputParams,
+    )
+    return concatBytecode(batchPendleStrats.bytecode[chainId]!, inputData)
+  })
+
+  const decodedPromise = await batchJsonRpc({
+    rpc,
+    calls: allContractCreationCodes,
+    outputTypeAbi: batchPendleStrats.outputType![chainId],
+    parse: false,
+    callsKey: `strategies/pendle/fetch.ts: fetchPendle - chainId ${chainId} - rpc ${rpc}`,
+  })
+
+  const multicallRawData = await multicall(
+    provider,
+    calls(strats.map((s) => s.lpToken.address)),
+    multicallPendleStratsAbi,
+  )
+
+  const totalGaugeWeight = multicallRawData.shift().result
+
+  const parsedData = strats.map((s) => {
+    const pendleStratApiData = pendleApiData.find((element) => equalTlc(element.address, s.lpToken.address))
+    const rawData = decodedPromise.find((element) => equalTlc(element.lpt, s.lpToken.address))
+
+    const expiry = Number(rawData.expiry)
+    const totalSupply = rawData.totalSupply
+    const strategyHoldings = rawData.strategyHoldings
+    const workingBalance = rawData.workingBalance
+
+    const lpPriceInUsd = pendleStratApiData.lp.price.usd
+    const tvl = Number(formatUnits(totalSupply, 18)) * lpPriceInUsd
+
+    const pendingRewards = multicallRawData.shift().result
+    const rewards = rawData.rewards.map((r, index) => ({
+      name: r.name,
+      symbol: r.symbol,
+      decimals: Number(r.decimals),
+      address: r._address,
+      pending: formatUnits(pendingRewards[index], 0),
+    }))
+
+    const rewardsData: RewardsData[] = rawData.sdRewards.map((r, index) => {
+      const rewardTokenAddress = rawData.sdRewardsTokens[index]
+      const rewardToken = rewards.find((rt) => equalTlc(rewardTokenAddress, rt.address))
+      const rewardTokenData = equalTlc(rewardTokenAddress, sdt.address)
+        ? sdtToken
+        : {
+            name: rewardToken.name,
+            symbol: rewardToken.symbol,
+            decimals: rewardToken.decimals,
+            address: rewardToken.address,
+          }
+
+      const rewardPrice = prices.find((p: any) => equalTlc(p.address, rewardTokenData.address))
+
+      const periodFinish = Number(formatUnits(r.period_finish, 0))
+      const streaming = periodFinish > Math.floor(Date.now() / 1000)
+
+      const rewardApr =
+        streaming && rewardPrice && tvl > 0
+          ? (Number(formatUnits(r.rate * BigInt(ONE_YEAR), 18)) * rewardPrice.usdPrice) /
+            tvl /
+            (equalTlc(rewardTokenData.symbol, 'SDT') ? 2.5 : 1)
+          : 0
+
+      return {
+        token: rewardTokenData,
+        price: rewardPrice ? rewardPrice.usdPrice : 0,
+        apr: rewardApr * 100,
+        streaming,
+        periodFinish,
+        rate: formatUnits(r.rate, 0),
+        lastUpdate: formatUnits(r.last_update, 0),
+        claimablePendingRewards: equalTlc(rewardTokenAddress, sdt.address) ? '0' : rewardToken.pending,
+      }
+    })
+
+    const boost = getBoost('pendle', strategyHoldings, workingBalance)
+
+    let extraRewards = []
+    if (pendleStratApiData.underlyingRewardApy > 0) {
+      const extraApiData = pendleApiExtraData.find((el) => equalTlc(el.address, s.lpToken.address))
+      extraRewards = extraApiData.underlyingRewardApyBreakdown.map((r) => {
+        const nonBoostedApr = (r.absoluteApy * (100 - STRAT_FEES)) / 2.5
+        return {
+          address: r.address,
+          name: r.name,
+          symbol: r.symbol,
+          decimals: r.decimals,
+          apy: nonBoostedApr * boost,
+        }
+      })
+    }
+
+    const totalPt = pendleStratApiData.totalPt
+    const totalSy = pendleStratApiData.totalSy
+
+    const syYield = (totalSy / (totalPt + totalSy)) * pendleStratApiData.underlyingApy * 100
+    const ptYield = (totalPt / (totalPt + totalSy)) * pendleStratApiData.impliedApy * 100
+
+    const subname = `${dayjs(expiry * 1000).format('DD/MM/YYYY')}`
+
+    const gaugeWeight = rawData.sdGaugeWeight
+
+    const sdGauge = {
+      address: rawData.sdGauge,
+      totalSupply: formatUnits(rawData.sdGaugeTotalSupply, 0),
+      ...(chainId === mainnet.id
+        ? {
+            relativeWeight: formatUnits(rawData.sdGaugeRelativeWeight, 0),
+            weight: formatUnits(gaugeWeight, 0),
+            futureWeight:
+              totalGaugeWeight > Zero
+                ? formatUnits(((gaugeWeight as bigint) * OneEther * OneEther) / totalGaugeWeight, 0)
+                : '0',
+            workingSupply: formatUnits(rawData.sdGaugeWorkingSupply, 0),
+          }
+        : { relativeWeight: '0', weight: '0', futureWeight: '0', workingSupply: '0' }),
+    }
+
+    const tradingApy = pendleStratApiData.swapFeeApy * 100
+    const minApr = pendleStratApiData.pendleApy * (100 - STRAT_FEES)
+    const maxApr = pendleStratApiData.pendleApy * (100 - STRAT_FEES) * 2.5
+
+    const underlyingReward = [
+      {
+        ...s.underlyingReward,
+        apy: syYield,
+      },
+      {
+        ...s.underlyingReward,
+        symbol: `PT ${s.underlyingReward.symbol}`,
+        apy: ptYield,
+      },
+      ...extraRewards,
+    ]
+
+    const sdtApr: SdtApr = {
+      sdtUserApr: 0,
+      sdtFuturUserApr: 0,
+      sdtMinApr: 0,
+      sdtFuturMinApr: 0,
+      sdtMaxApr: 0,
+      sdtFuturMaxApr: 0,
+      sdtBoost: 1,
+    }
+
+    const apr = getAprBreakdown(
+      {
+        ...s,
+        tradingApy,
+        minApr,
+        maxApr,
+        underlyingReward,
+      },
+      rewardsData,
+      boost,
+      sdtApr,
+    )
+
+    return {
+      key: s.key,
+      name: s.coins.reduce((res: string, current) => `${res}/${current.symbol}`, '').slice(1),
+      subname,
+      protocol: s.protocol,
+      chainId: s.chainId,
+      vault: s.vault,
+      lpToken: s.lpToken,
+      coins: s.coins,
+      sdGauge,
+      lpPriceInUsd,
+      tvl,
+      apr: {
+        boost,
+        ...apr,
+      },
+      // sdtApr,
+      rewards: rewardsData,
+      underlyingReward,
+      // Base APR data
+      tradingApy,
+      minApr,
+      maxApr,
+      // Raw data
+      vaultHoldings: formatUnits(rawData.vaultHoldings, 0),
+      totalSupply: formatUnits(totalSupply, 0),
+      strategyHoldings: formatUnits(strategyHoldings, 0),
+      workingBalance: formatUnits(workingBalance, 0),
+      // Gas optimised
+      vaultFees: {
+        keeper: 0,
+        accumulated: '0',
+      },
+    }
+  })
+
+  const rawNotDeployed = pendleApiData.filter((s) => {
+    if (!pendleMarketAddresses.includes(s.address.toLowerCase())) {
+      const expiry = new Date(s.expiry)
+      const expiryTimestamp = Math.floor(expiry.getTime() / 1000)
+      const nowTimestamp = Math.floor(Date.now() / 1000)
+
+      return expiryTimestamp > nowTimestamp
+    }
+
+    return false
+  })
+
+  const notDeployed = rawNotDeployed.map((s) => ({
+    name: s.proName,
+    lpTokenAddress: s.address,
+    gaugeAddress: s.address,
+    protocol: 'pendle',
+    chainId,
+    coins: [
+      {
+        address: s.underlyingAsset.address,
+        name: s.underlyingAsset.name,
+        symbol: s.underlyingAsset.symbol,
+        decimals: s.underlyingAsset.decimals,
+      },
+    ],
+    maxApy: s.maxBoostedApy * 100,
+    accentColor: s.accentColor,
+    points: pendlePoints[s.address.toLowerCase()],
+  }))
+
+  return {
+    deployed: parsedData,
+    notDeployed: notDeployed.filter(
+      (s) =>
+        ![
+          // Exclude
+          '0xd1434df1e2ad0cb7b3701a751d01981c7cf2dd62', // Stafi RETH
+
+          // With old factory
+          '0xfcbae4635ca89866f83add208ecceec742678746', // 2024-06-27 wstETH-WETH
+          '0xabc8ae339e3f560bf700a3f6ee85ee719979762b', // 2024-09-26 ankrETH-WETH
+          '0x2ec8c498ec997ad963969a2c93bf7150a1f5b213', // 2024-12-26 rETH-WETH
+          '0x8225dd26ddfaaa321e5388e0f4c090ba16217c21', // 2024-09-26 swETH-bbaWETH
+          '0xd547d9c74314f787affc587d101146e1663d046e', // 2024-06-27 ankrETH-wstETH
+          '0xc112b12addc11f988abc1aafb47e4c2f62fb6070', // 2024-09-26 ETHx-bbaWETH
+          '0xcf756c00a755172bdc073787ea83817603da42ef', // 2024-09-26 swETH-bbaWETH
+          '0x23aefced9255ad3560cdaa4a10cbfe9ec230dc5a', // 2024-12-26 eUSD
+          '0xff262396f2a35cd7aa24b7255e7d3f45f057cdba', // 2024-12-26 ETHx
+          '0xa5fd0e8991be631917d2d2b2d5dacfd7bfef7876', // 2024-06-27 swETH
+          '0x0eb3f11ed8ca69813744868d02d83d4fbf72841e', // 2024-09-26 ePENDLE
+          '0x93a82f3873e5b4ff81902663c43286d662f6721c', // 2024-09-26 sDAI
+
+          // With new factory (not deployed yet)
+          '0x90c98ab215498b72abfec04c651e2e496ba364c0', // 2024-06-27 USDe (Zircuit)
+          '0x445d25a1c31445fb29e65d12da8e0eea38174176', // 2024-06-27 rsETH (Zircuit)
+          '0xd7e0809998693fd87e81d51de1619fd0ee658031', // 2024-06-27 ezETH (Zircuit)
+          '0xe26d7f9409581f606242300fbfe63f56789f2169', // 2024-06-27 (Zircuit) eETH
+          '0xe6d4986cd935529fc4505d48e926bcd36a58a0f0', // 2025-03-27 apxETH
+          '0x2084b373979415bc93190071af3390f92dcdd189', // 2024-06-27 stTAO
+        ].includes(s.lpTokenAddress.toLowerCase()),
+    ),
+    fetched: true,
+  }
+}

package/src/strategies/pendle/getPendleApiData.ts

@@ -0,0 +1,20 @@
+const LIMIT = 100
+const URL = (skip: number = 0) =>
+  `https://api-v2.pendle.finance/core/v1/1/markets?limit=${LIMIT}&select=all&skip=${skip}`
+
+const getPendleApiData = async () => {
+  let totalFetched = 0
+  let pendleApiData: any
+  let pendleStrats: any[] = []
+
+  do {
+    pendleApiData = await (await fetch(URL(totalFetched))).json()
+    totalFetched += LIMIT
+
+    pendleStrats = pendleStrats.concat(pendleApiData.results)
+  } while (pendleApiData.total > totalFetched)
+
+  return pendleStrats
+}
+
+export default getPendleApiData

package/src/strategies/pendle/pendlePoints.ts

@@ -0,0 +1,71 @@
+const pendlePoints = {
+  '0x9c73879f795cefa1d5239de08d1b6aba2d2d1434': [{ multiplier: 30, label: 'Sats Multiplier' }],
+  '0x19588f29f9402bb508007feadd415c875ee3f19f': [{ multiplier: 20, label: 'Sats Multiplier' }],
+  '0x90c98ab215498b72abfec04c651e2e496ba364c0': [
+    { multiplier: 20, label: 'Sats Multiplier' },
+    { multiplier: 2, label: 'Zircuit Multiplier' },
+  ],
+  '0x107a2e3cd2bb9a32b9ee2e4d51143149f8367eba': [{ multiplier: 20, label: 'Sats Multiplier' }],
+  '0x7d372819240d14fb477f17b964f95f33beb4c704': [
+    { multiplier: 3, label: 'Ether.fi Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0xf32e58f92e60f4b0a37a69b95d642a471365eae8': [
+    { multiplier: 2, label: 'Ether.fi Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0xe26d7f9409581f606242300fbfe63f56789f2169': [
+    { multiplier: 3, label: 'Ether.fi Multiplier' },
+    { multiplier: 2, label: 'Zircuit Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0xd8f12bcde578c653014f27379a6114f67f0e445f': [
+    { multiplier: 4, label: 'Renzo Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0xd7e0809998693fd87e81d51de1619fd0ee658031': [
+    { multiplier: 1, label: 'Renzo Multiplier' },
+    { multiplier: 2, label: 'Zircuit Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0x4f43c77872db6ba177c270986cd30c3381af37ee': [
+    { multiplier: 2, label: 'Kelp Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0x445d25a1c31445fb29e65d12da8e0eea38174176': [
+    { multiplier: 2, label: 'Kelp Multiplier' },
+    { multiplier: 2, label: 'Zircuit Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0xa9355a5d306c67027c54de0e5a72df76befa5694': [
+    { multiplier: 4.5, label: 'Swell Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0x38100a480dbed278b0fe57ba80a75498a7dc5bb1': [
+    { multiplier: 5, label: 'Bedrock Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0x17be998a578fd97687b24e83954fec86dc20c979': [
+    { multiplier: 1.25, label: 'Puffer Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0xd1d7d99764f8a52aff007b7831cc02748b2013b5': [{ multiplier: 20, label: 'Sats Multiplier' }],
+  '0xa54fc268101c8b97de19ef3141d34751a11996b2': [
+    { multiplier: 2, label: 'Puffer Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0xbae2df4dfcd0c613018d6056a40077f2d1eff28a': [
+    { multiplier: 5, label: 'Bedrock Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0xc8edd52d0502aa8b4d5c77361d4b3d300e8fc81c': [
+    { multiplier: 2, label: 'Ether.fi Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+  '0xcdbd5ff3e03b6828db9c32e2131a60aba5137901': [
+    { multiplier: 4, label: 'Renzo Multiplier' },
+    { multiplier: 1, label: 'EigenLayer Multiplier' },
+  ],
+}
+
+export default pendlePoints

package/src/strategies/types.ts

@@ -1,3 +1,6 @@
+export type ValidExplorer = 'etherscan.io' | 'bscscan.com' | 'arbiscan.io'
+export type ValidChainId = 1 | 56 | 42161
+
 export type Coin = {
   name: string
   symbol: string
@@ -91,7 +94,7 @@ export type RewardsData = {
 
 export type Strategy = {
   key: string
-  type: string
+  type?: string
   protocol: string
   chainId: number
   isMetapool?: boolean
@@ -105,6 +108,7 @@ export type Strategy = {
   rewards: RewardsData[]
   name: string
   tradingApy: number
+  gaugesProjectedApr?: any
   underlyingApy?: number
   minApr: number
   maxApr: number
@@ -155,7 +159,20 @@ export type YearnGlobalData = {
   fees: Fees
 }
 
-export type Global = CurveGlobalData | YearnGlobalData
+export type BalancerGlobalData = {
+  totalGaugeWeights: string
+  inflationRate: string
+  balPerWeek: string
+  fees: Fees
+}
+
+export type PancakeSwapGlobalData = {
+  totalAllocPoint: string
+  inflationRate: string
+  fees: Fees
+}
+
+export type Global = CurveGlobalData | YearnGlobalData | BalancerGlobalData | PancakeSwapGlobalData
 
 export type StrategyData = {
   global?: Global
@@ -166,7 +183,7 @@ export type StrategyData = {
 
 export type BuiltStrat = {
   key: string
-  type: string
+  type?: string
   protocol: string
   chainId: number
   isMetapool?: boolean

package/src/strategies/utils/getAprBreakdown.ts

@@ -22,11 +22,11 @@ export const getAprBreakdown = (
   }
 
   const underlyingReward = strat.underlyingReward
-    ? {
-        label: `Underlying Yield (${strat.underlyingReward.symbol})`,
-        value: [strat.underlyingReward.apy],
-      }
-    : { label: '', value: [0] }
+    ? strat.underlyingReward.map((sur) => ({
+        label: `Underlying Yield (${sur.symbol})`,
+        value: [sur.apy],
+      }))
+    : [{ label: '', value: [0] }]
 
   // Current streaming APRs from the Stake DAO gauge
   const currentAprBreakdown: Breakdown[] = rewardsData.map((r) => {
@@ -78,13 +78,13 @@ export const getAprBreakdown = (
   // Compute total current APR
   const currentTotal =
     baseReward.value[0]! +
-    underlyingReward.value[0] +
+    underlyingReward.reduce((total: number, curr) => total + curr.value[0]!, 0) +
     currentAprBreakdown.reduce((total: number, curr) => total + curr.value[0]!, 0)
 
   // Compute total projected APR
   const projectedTotal =
     baseReward.value[0]! +
-    underlyingReward.value[0] +
+    underlyingReward.reduce((total: number, curr) => total + curr.value[0]!, 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) +
@@ -93,13 +93,13 @@ export const getAprBreakdown = (
   return {
     current: {
       total: currentTotal,
-      details: [baseReward, underlyingReward, ...currentAprBreakdown].filter((r) => r?.value[0] > 0 || false),
+      details: [baseReward, ...underlyingReward, ...currentAprBreakdown].filter((r) => r?.value[0] > 0 || false),
     },
     projected: {
       total: projectedTotal,
       details: [
         baseReward,
-        underlyingReward,
+        ...underlyingReward,
         ...projectedAprBreakdown,
         ...(strat?.gaugesProjectedApr
           ? strat.gaugesProjectedApr.map((r: any) => ({

package/src/strategies/utils/index.ts

@@ -1,9 +1,22 @@
-import { parseEther } from 'viem'
+import { decodeAbiParameters, fromBytes, hexToBytes, parseAbiParameters, parseEther } from 'viem'
 
 export const Zero = BigInt(0)
 export const One = BigInt(1)
 export const OneEther = parseEther('1')
 
+export const bytes32ToString = (bytes32: `0x${string}`) => {
+  try {
+    return decodeAbiParameters(parseAbiParameters('string'), bytes32)[0]
+  } catch {
+    return fromBytes(
+      hexToBytes(bytes32).filter((v) => v > 0),
+      'string',
+    )
+  }
+}
+
+export const concatBytecode = (contract: string, args: string): string => contract.concat(args.slice(2))
+
 export * from './boost.js'
 export * from './decodeEtherscanFactoryEvent.js'
 export * from './sdt.js'

package/src/strategies/yearn/build.ts

@@ -3,9 +3,10 @@ import { decodeAbiParameters, encodeAbiParameters, parseAbiParameters } from 'vi
 
 import { contracts, tokens } from '@stake-dao/constants'
 import type { FetchedToken, Token } from '@stake-dao/constants'
-import { batchSdtGaugeRewards, batchTokenData, buildYearnStrats } from '../../batches/index.js'
+import { batchSdtGaugeRewards, batchTokenData, buildYearnStrats } from '../../bytecodes/index.js'
 import { equalTlc, getTokenInfo } from '../../utils.js'
 import type { BuiltStrat } from '../types.js'
+import { concatBytecode } from '../utils/index.js'
 
 interface VaultAndLp {
   vault: string
@@ -26,7 +27,7 @@ export const buildYearnStrategies = async (
         contracts.yearnGaugeFactory![chainId],
         inputArgs,
       ])
-      const contractCreationCode = buildYearnStrats.bytecode![chainId]!.concat(inputData.slice(2))
+      const contractCreationCode = concatBytecode(buildYearnStrats.bytecode![chainId]!, inputData)
       const returnedData = await provider.call({
         data: contractCreationCode,
       })
@@ -75,7 +76,7 @@ export const buildYearnStrategies = async (
       const inputData = encodeAbiParameters(parseAbiParameters(batchTokenData.inputType[chainId] || []) as any, [
         inputArgs,
       ])
-      const contractCreationCode = batchTokenData.bytecode[chainId]?.concat(inputData.slice(2))
+      const contractCreationCode = concatBytecode(batchTokenData.bytecode[chainId]!, inputData)
       const returnedData = await provider.call({
         data: contractCreationCode,
       })
@@ -98,7 +99,7 @@ export const buildYearnStrategies = async (
       const inputData = encodeAbiParameters(parseAbiParameters(batchSdtGaugeRewards.inputType[chainId] || []) as any, [
         inputArgs,
       ])
-      const contractCreationCode = batchSdtGaugeRewards.bytecode[chainId]?.concat(inputData.slice(2))
+      const contractCreationCode = concatBytecode(batchSdtGaugeRewards.bytecode[chainId]!, inputData)
       const returnedData = await provider.call({
         data: contractCreationCode,
       })

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

@@ -2,9 +2,10 @@ import { chunk } from 'lodash-es'
 import { encodeAbiParameters, parseAbiParameters } from 'viem'
 
 import { contracts } from '@stake-dao/constants'
-import { fetchYearnGauges } from '../../../batches/index.js'
+import { fetchYearnGauges } from '../../../bytecodes/index.js'
 import { batchJsonRpc, multicall } from '../../../utils.js'
 import multicallYearnStratsAbi from '../../utils/abis/MulticallYearnStratsAbi.json'
+import { concatBytecode } from '../../utils/index.js'
 import { computeYearnApr } from './computeYearnApr.js'
 
 const SKIP = '8'
@@ -36,11 +37,11 @@ export const fetchAllYearnGauges = async (
   ])
 
   const decodedPromises = await batchJsonRpc({
-    calls: [fetchYearnGauges.bytecode[chainId]!.concat(inputData.slice(2))],
+    calls: [concatBytecode(fetchYearnGauges.bytecode[chainId]!, inputData)],
     outputTypeAbi: fetchYearnGauges.outputType![chainId]!,
     rpc,
     parse: false,
-    callsKey: `Fetch all Yearn gauges chainId : ${chainId}`,
+    callsKey: `strategies/yearn/fetch/fetchAllYearnGauges.ts: fetchAllYearnGauges - chainId ${chainId} - rpc ${rpc}`,
   })
   const decodedResult = decodedPromises[0]?.yearnStrats || []
 

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

@@ -11,7 +11,7 @@ import { computeYearnApr } from './computeYearnApr.js'
 
 import { contracts } from '@stake-dao/constants'
 import type { Price } from '../../../prices.js'
-import type { RewardsData, StrategyData } from '../../types.js'
+import type { RewardsData, StrategyData, ValidChainId, ValidExplorer } from '../../types.js'
 import { getAprBreakdown } from '../../utils/getAprBreakdown.js'
 import { type SdtEmissionData, decodeNewFactoryEvent, getSdtApr } from '../../utils/index.js'
 import { fetchAllYearnGauges } from './fetchAllYearnGauges.js'
@@ -46,16 +46,27 @@ const calls = (
 const callsForRewards = (gauge: string, rewards: any[]) =>
   rewards.map((r) => ({ address: gauge, name: 'reward_data', params: [r.address] }))
 
-export const fetchYearn = async (
-  prices: Price[],
-  provider: any,
-  rpc: string,
-  explorerApiKey: string,
-  explorer: string,
-  chainId: number,
-  lastBlockNumber: number,
-  sdtEmissionData: SdtEmissionData,
-): Promise<StrategyData> => {
+interface TFetchYearn {
+  prices: Price[]
+  provider: any
+  rpc: string
+  explorerApiKey: string
+  explorer: ValidExplorer
+  chainId: ValidChainId
+  lastBlockNumber: number
+  sdtEmissionData: SdtEmissionData
+}
+
+export const fetchYearn = async ({
+  prices,
+  provider,
+  rpc,
+  explorerApiKey,
+  explorer,
+  chainId,
+  lastBlockNumber,
+  sdtEmissionData,
+}: TFetchYearn): Promise<StrategyData> => {
   const dYfiPrice = prices.find((p) => p.symbol === 'dYFI')?.usdPrice || 0
   const stratsCalls: any[] = []
   const rewardsCalls: any[] = []