@stake-dao/reader 0.4.111 → 0.5.0

package/src/lockers/fetch/protocols/yieldnest.ts

@@ -0,0 +1,157 @@
+import { One, STAKE_DAO_ASSETS_BASE_URL, Zero, tokenWithId } from '@stake-dao/constants'
+import { formatUnits, parseUnits } from 'viem'
+import lockersMulticallAbi from '../../../abis/lockersMulticall.js'
+import { type Call, getRes, multicall } from '../../../utils.js'
+import { parse, parsePeg } from '../parse.js'
+import type { Locker } from '../types.js'
+
+export const locker: Locker = {
+  id: 'ynd',
+  symbol: 'YND',
+  protocol: 'YieldNest',
+  protocolDescription:
+    'YieldNest is a next-generation DeFi protocol that offers simple, high-yielding, risk-adjusted restaking and DeFi strategies',
+  website: 'https://www.yieldnest.finance/',
+  logoUrl: `${STAKE_DAO_ASSETS_BASE_URL}/assets/1/0x7159cc276d7d17ab4b3beb19959e1f39368a45ba.svg`,
+  chainId: 1,
+  rgb: '181, 154, 107',
+  token: tokenWithId('ynd')!,
+  sdToken: tokenWithId('sdynd')!,
+  rewards: [
+    { ...tokenWithId('sdt')!, distribution: 'streamed', origin: 'native.common' },
+    { ...tokenWithId('ynd')!, distribution: 'merkl', origin: 'native.common' },
+  ],
+  delegation: ['sdynd.eth'],
+  modules: {
+    depositor: '0x8f0e636A19c1677fDF37DA0E3aF602f96DA3352E',
+    locker: '0x8396A782cc966661cd818a4DaC19C3E0aA893012',
+    veToken: '0x23d2923e15f5cce8a131CB37F0c7BCC5caD15639',
+    gauge: '0x26aB50DC99F14405155013ea580Ea2b3dB1801c7',
+    accumulator: '0x0000000000000000000000000000000000000000',
+    escrow: '0xD666B56EE7786Cc918fDdcEade542d013de0E4F1',
+  },
+  secondaryMarket: {
+    label: 'Curve',
+    poolKey: 'factory-stable-ng-464',
+    vaultKey: '1-0x147367Ed8966a46769f331a1210C952BabE87b09',
+    pool: '0xE5c78cbcf6241f1793caF496f6480B45Fa5BDb46',
+    pools: ['0xE5c78cbcf6241f1793caF496f6480B45Fa5BDb46'],
+    pegBase: 500000,
+  },
+  alternativeYields: {
+    sdSpectraSpectraStakeDao: {
+      label: 'sdYND/YND',
+      platform: 'Stake DAO',
+      href: '/yield?search=0x147367Ed8966a46769f331a1210C952BabE87b09',
+    },
+  },
+  autoCompounder: {
+    aSdToken: '0x3610A0f4a36513d27128e110dB999D6e1e6105D5',
+  },
+  fees: [
+    { label: { key: 'liquidity', variable: 'sdYND/YND' }, value: 10, key: 'liquidityFee' },
+    { label: { key: 'treasury' }, value: 5, key: 'daoFee' },
+    { label: { key: 'harvesterOn', variable: 'YND' }, value: 0.1, token: 'ynd', key: 'claimerFee' },
+  ],
+  extensions: {
+    coingeckoBaseSlug: 'yieldnest',
+  },
+}
+
+const yieldnestLocker = async ({ provider, common, prices }: { provider; common; prices }) => {
+  const token = locker.token.address
+  const sdToken = locker.sdToken.address
+
+  const gauge = locker.modules.gauge
+  const depositor = locker.modules.depositor
+  const escrow = locker.modules.escrow!
+
+  const secondaryMarket = locker.secondaryMarket!
+  const rewards = locker.rewards!
+
+  const pegBase = parseUnits(secondaryMarket?.pegBase?.toString() || '1', 18)
+
+  const format = (value: bigint) => formatUnits(value, locker.token.decimals)
+  const formatRes = (value: any) => format(getRes(value))
+
+  const calls: Call[] = [
+    /*********************************************************************************
+     *** Voting Escrow
+     *********************************************************************************/
+
+    // Token locked by the Locker
+    { address: depositor, name: 'getLockedBalance' },
+    // Total token locked
+    { address: token, name: 'balanceOf', params: [escrow] },
+    // Total veToken supply
+    { address: escrow, name: 'totalLocked' },
+
+    /*********************************************************************************
+     *** Gauge
+     *********************************************************************************/
+
+    // Total sdToken staked
+    { address: gauge, name: 'totalSupply' },
+    // Gauge working supply
+    { address: gauge, name: 'working_supply' },
+
+    /*********************************************************************************
+     *** Token & sdToken
+     *********************************************************************************/
+
+    // Token balance not locked
+    { address: token, name: 'balanceOf', params: [depositor] },
+    // sdToken in secondary market pool
+    { address: sdToken, name: 'balanceOf', params: [secondaryMarket.pool] },
+
+    /*********************************************************************************
+     *** Peg
+     *********************************************************************************/
+
+    // Return amount when swapping {pegBase} sdToken to token -> get_dy(int128,int128,uint256)
+    { address: secondaryMarket.pool, name: '0x5e0d443f', params: [One, Zero, pegBase] },
+
+    /*********************************************************************************
+     *** Rewards
+     *********************************************************************************/
+
+    // Streaming status for each reward token
+    ...rewards.map((r) => ({ address: gauge, name: 'reward_data', params: [r.address] })),
+  ]
+
+  const [res, yieldnestMerkl] = await Promise.all([
+    multicall(provider, calls, lockersMulticallAbi(locker.id, locker.chainId)),
+    fetch('https://api.merkl.xyz/v4/opportunities/12447605725077990381').then((res) => res.json()),
+  ])
+
+  const raw = {
+    tokenLocked: formatRes(res.shift()),
+    veBalanceOfLocker: '0',
+    totalTokenLocked: formatRes(res.shift()),
+    veTotalSupply: formatRes(res.shift()),
+    totalSupplyStaked: formatRes(res.shift()),
+    gaugeWorkingSupply: formatRes(res.shift()),
+    amountTokenNotLock: formatRes(res.shift()),
+    sdTokenInPool: formatRes(res.shift()),
+    peg: getRes(res.shift()),
+    rewards: rewards.map(() => getRes(res.shift())),
+    veTokenRate: '4',
+    _workingSupply: '0',
+    _veBalanceOfLocker: '0',
+    replaceApr: [] as any[],
+  }
+
+  raw.veBalanceOfLocker = raw.tokenLocked
+  raw.peg = parsePeg(locker, raw.peg)
+  raw._workingSupply = raw.gaugeWorkingSupply
+  raw._veBalanceOfLocker = raw.veBalanceOfLocker
+
+  raw.replaceApr = rewards.map((r) => {
+    if (r.distribution === 'merkl') return yieldnestMerkl?.apr || 0
+    return undefined
+  })
+
+  return parse({ locker, common, prices, raw })
+}
+
+export default yieldnestLocker

package/src/lockers/fetch/protocols/zerolend.ts

@@ -0,0 +1,144 @@
+import { STAKE_DAO_ASSETS_BASE_URL, tokenWithId } from '@stake-dao/constants'
+import { formatUnits } from 'viem'
+import lockersMulticallAbi from '../../../abis/lockersMulticall.js'
+import { type Call, getRes, multicall } from '../../../utils.js'
+import { parse, parsePeg } from '../parse.js'
+import type { Locker } from '../types.js'
+
+export const locker: Locker = {
+  id: 'zero',
+  symbol: 'ZERO',
+  protocol: 'ZeroLend',
+  protocolDescription: 'ZeroLend is the most efficient and dominant lending market on Linea, zkSync, Blast and Manta.',
+  website: 'https://zerolend.xyz/',
+  logoUrl: `${STAKE_DAO_ASSETS_BASE_URL}/assets/archive/zero.svg`,
+  chainId: 59144,
+  rgb: '0, 0, 0',
+  token: tokenWithId('zero', 59144)!,
+  sdToken: tokenWithId('sdzero', 59144)!,
+  rewards: [{ ...tokenWithId('zero', 59144)!, distribution: 'streamed', origin: 'native.zerolend' }],
+  delegation: ['sdzero.eth'],
+  modules: {
+    depositor: '0xC5CCc20f6A4CD65fda979A2E292DBCF2C450C067',
+    locker: '0xC0295F271c4fD531d436F55b0ceF4Cc316188046',
+    veToken: '0xf374229a18ff691406f99CCBD93e8a3f16B68888',
+    gauge: '0xC6973841dC130597dF3Cb8bE2F57440d856FD7C4',
+    accumulator: '0xb30807324354379233FC6F7716C0510BbBD88487',
+    veNFT: '0x08D5FEA625B1dBf9Bae0b97437303a0374ee02F8',
+  },
+  secondaryMarket: {
+    label: '',
+    poolKey: '',
+    vaultKey: '',
+    pool: '0x0000000000000000000000000000000000000000',
+    pools: ['0x0000000000000000000000000000000000000000'],
+    pegBase: 10000000,
+  },
+  fees: [
+    {
+      label: { key: 'liquidity', variable: 'sdZERO/ZERO' },
+      value: 10,
+      key: 'liquidityFee',
+    },
+    {
+      label: { key: 'treasury' },
+      value: 5,
+      key: 'daoFee',
+    },
+  ],
+  extensions: {
+    coingeckoBaseSlug: 'zerolend',
+  },
+}
+
+const zerolendLocker = async ({ provider, common, prices }: { provider; common; prices }) => {
+  const token = locker.token.address
+  const sdToken = locker.sdToken.address
+
+  const gauge = locker.modules.gauge
+  const depositor = locker.modules.depositor
+  const votingEscrow = locker.modules.veToken
+  const lockerAddress = locker.modules.locker
+  const veNFT = locker.modules.veNFT
+
+  const secondaryMarket = locker.secondaryMarket!
+  const rewards = locker.rewards
+
+  // const pegBase = parseUnits(secondaryMarket?.pegBase?.toString() || '1', 18)
+
+  const format = (value: bigint) => formatUnits(value, locker.token.decimals)
+  const formatRes = (value: any) => format(getRes(value))
+
+  const calls: Call[] = [
+    /*********************************************************************************
+     *** Voting Escrow
+     *********************************************************************************/
+
+    // Token locked by the Locker
+    { address: votingEscrow, name: 'getLockedNftDetails', params: [lockerAddress] },
+    // veToken Balance of the Locker
+    { address: votingEscrow, name: 'balanceOf', params: [lockerAddress] },
+    // Total token locked
+    { address: token, name: 'balanceOf', params: [veNFT] },
+    // Total veToken supply
+    { address: votingEscrow, name: 'totalSupply' },
+
+    /*********************************************************************************
+     *** Gauge
+     *********************************************************************************/
+
+    // Total sdToken staked
+    { address: gauge, name: 'totalSupply' },
+
+    /*********************************************************************************
+     *** Token & sdToken
+     *********************************************************************************/
+
+    // Token balance not locked
+    { address: token, name: 'balanceOf', params: [depositor] },
+    // sdToken in secondary market pool
+    { address: sdToken, name: 'balanceOf', params: [secondaryMarket.pool] },
+
+    /*********************************************************************************
+     *** Peg
+     *********************************************************************************/
+
+    // Return amount when swapping {pegBase} sdToken to token -> get_dy(int128,int128,uint256)
+    // { address: secondaryMarket.pool, name: '0x5e0d443f', params: [One, Zero, pegBase] },
+
+    /*********************************************************************************
+     *** Rewards
+     *********************************************************************************/
+
+    // Streaming status for each reward token
+    ...rewards.map((r) => ({ address: gauge, name: 'reward_data', params: [r.address] })),
+  ]
+
+  const res = await multicall(provider, calls, lockersMulticallAbi(locker.id, locker.chainId))
+  const raw = {
+    tokenLocked: getRes(res.shift()),
+    veBalanceOfLocker: formatRes(res.shift()),
+    totalTokenLocked: formatRes(res.shift()),
+    veTotalSupply: formatRes(res.shift()),
+    totalSupplyStaked: formatRes(res.shift()),
+    gaugeWorkingSupply: '0',
+    amountTokenNotLock: formatRes(res.shift()),
+    sdTokenInPool: formatRes(res.shift()),
+    // peg: getRes(res.shift()),
+    peg: '-',
+    rewards: rewards.map(() => getRes(res.shift())),
+    veTokenRate: '4',
+    _workingSupply: '0',
+    _veBalanceOfLocker: '0',
+  }
+
+  raw.tokenLocked = format(raw.tokenLocked[1][0].amount)
+  raw.gaugeWorkingSupply = raw.totalSupplyStaked
+  raw.peg = parsePeg(locker, raw.peg)
+  raw._workingSupply = raw.gaugeWorkingSupply
+  raw._veBalanceOfLocker = raw.veBalanceOfLocker
+
+  return parse({ locker, common, prices, raw })
+}
+
+export default zerolendLocker

package/src/lockers/fetch/static.ts

@@ -0,0 +1,35 @@
+import type { Locker } from './types.js'
+
+import { locker as staticAngleLocker } from './protocols/angle.js'
+import { locker as staticBalancerLocker } from './protocols/balancer.js'
+import { locker as staticBlackpoolLocker } from './protocols/blackpool.js'
+import { locker as staticCurveLocker } from './protocols/curve.js'
+import { locker as staticFraxFpisLocker } from './protocols/frax-fpis.js'
+import { locker as staticFraxFxsLocker } from './protocols/frax-fxs.js'
+import { locker as staticFxnLocker } from './protocols/fxn.js'
+import { locker as staticMaverickLocker } from './protocols/maverick.js'
+import { locker as staticPancakeswapLocker } from './protocols/pancakeswap.js'
+import { locker as staticPendleLocker } from './protocols/pendle.js'
+import { locker as staticSpectraLocker } from './protocols/spectra.js'
+import { locker as staticYearnLocker } from './protocols/yearn.js'
+import { locker as staticYieldbasisLocker } from './protocols/yieldbasis.js'
+import { locker as staticYieldnestLocker } from './protocols/yieldnest.js'
+import { locker as staticZerolendLocker } from './protocols/zerolend.js'
+
+export const staticLockers: Locker[] = [
+  staticAngleLocker,
+  staticBalancerLocker,
+  staticBlackpoolLocker,
+  staticCurveLocker,
+  staticFraxFpisLocker,
+  staticFraxFxsLocker,
+  staticFxnLocker,
+  staticMaverickLocker,
+  staticPancakeswapLocker,
+  staticPendleLocker,
+  staticSpectraLocker,
+  staticYearnLocker,
+  staticYieldbasisLocker,
+  staticYieldnestLocker,
+  staticZerolendLocker,
+]

package/src/lockers/fetch/types.ts

@@ -0,0 +1,112 @@
+import type { Address } from 'viem'
+
+// TODO: use common Token type
+type Token = {
+  id: string
+  name: string
+  address: string
+  symbol: string
+  decimals: number
+  chainId: number
+  logoURI: string
+  tags: string[]
+  extensions: {
+    underlying?: string
+    wrapper?: string
+    oftVersion?: number
+    coingeckoSlug?: string
+  }
+}
+
+export interface LockerReward extends Token {
+  distribution: 'streamed' | 'distributed' | 'merkl'
+  origin: string
+  noEarn?: boolean
+  isAirdrop?: boolean
+}
+
+type LockerModule = {
+  depositor: Address
+  locker: Address
+  veToken: Address
+  gauge: Address
+  accumulator: Address
+  escrow?: Address
+  redeem?: Address
+  veNFT?: Address
+}
+
+export type LockerSecondaryMarket = {
+  label: string
+  poolKey: string
+  vaultKey: string
+  pool: Address
+  pegBase: number
+  pools?: Address[]
+  router?: Address
+}
+
+type LockerAltYield = {
+  [key: string]: {
+    label: string
+    platform: string
+    href: string
+  }
+}
+
+type LockerFee = {
+  key: 'liquidityFee' | 'claimerFee' | 'daoFee' | 'voteFee' | 'lockerFee' | 'bountyFee' | 'sdtFee'
+  label: {
+    key: 'harvester' | 'harvesterOn' | 'airdrop' | 'liquidity' | 'treasury' | 'treasuryOn' | 'vesdt'
+    variable?: string
+  }
+  value: number
+  token?: string
+  static?: boolean
+}
+
+type LockerSideChain = {
+  chainId: number
+  locker: Address
+  veToken: Address
+  depositor: Address
+  sdToken: Address
+  token: Address
+  gauge?: Address
+  accumulator?: Address
+  rewards?: LockerReward[]
+}
+
+export type Locker = {
+  id: string
+  symbol: string
+  protocol: string
+  protocolDescription: string
+  website: string
+  logoUrl: string
+  chainId: number
+  rgb: string
+  token: Token
+  sdToken: Token
+  rewards: LockerReward[]
+  delegation?: string[]
+  modules: LockerModule
+  secondaryMarket?: LockerSecondaryMarket
+  veBoost?: {
+    address: Address
+    delegator: Address
+  }
+  voteBooster?: {
+    vSdToken: Address
+    booster: Address
+  }
+  autoCompounder?: {
+    aSdToken: Address
+  }
+  alternativeYields?: LockerAltYield
+  fees: LockerFee[]
+  extensions: {
+    coingeckoBaseSlug?: string
+    sideChains?: LockerSideChain[]
+  }
+}

package/src/lockers/utils/callsForLockers/pegCalls.ts

@@ -1,6 +1,7 @@
 import { parseUnits, zeroAddress } from 'viem'
 
-import { type LockerSecondaryMarket, One, Zero, contracts } from '@stake-dao/constants'
+import { One, Zero, contracts } from '@stake-dao/constants'
+import type { LockerSecondaryMarket } from '../../fetch/types.js'
 
 const pegCalls = (secondaryMarket: LockerSecondaryMarket | undefined, sdToken: string, token: string) => {
   const secondaryMarketLabel = secondaryMarket?.label || ''

package/src/lockers/utils/getBribesRewardsData.ts

@@ -1,9 +1,11 @@
+import { One, Zero } from '@stake-dao/constants'
 import { parseUnits } from 'viem'
-
-import { One, Zero, delegationWithId, lockerWithAutovoter } from '@stake-dao/constants'
-
 import { calculateAllData } from './index.js'
 
+export const lockerWithAutovoter = (id: string) => {
+  return ['crv', 'bal', 'fxn', 'pendle'].includes(id)
+}
+
 export type TBribesRewards = {
   bribeMinApr: number
   bribeMaxApr: number
@@ -25,14 +27,13 @@ const getBribesRewardsData = (
   tokenLocked: any,
 ): { bribeMinApr: number; bribeMaxApr: number; bribeRewards: TBribesRewards | undefined } => {
   const bribesAverageApr = [
-    { id: 'crv', value: bribesData?.[delegationWithId('crv')!] / 100 || 0 },
-    { id: 'bal', value: bribesData?.[delegationWithId('bal')!] / 100 || 0 },
-    { id: 'fxs', value: bribesData?.[delegationWithId('fxs')!] / 100 || 0 }, // 1 FXS = 4 veFXS
-    { id: 'angle', value: bribesData?.[delegationWithId('angle')!] / 100 || 0 },
-    { id: 'cake', value: bribesData?.[delegationWithId('cake')!] / 100 || 0 },
-    { id: 'pendle', value: bribesData?.[delegationWithId('pendle')!] / 100 || 0 },
-    { id: 'fxn', value: bribesData?.[delegationWithId('fxn')!] / 100 || 0 },
-    { id: 'spectra', value: bribesData?.[delegationWithId('spectra')!] / 100 || 0 },
+    { id: 'crv', value: bribesData?.['sdcrv.eth'] / 100 || 0 },
+    { id: 'bal', value: bribesData?.['sdbal.eth'] / 100 || 0 },
+    { id: 'fxs', value: bribesData?.['sdfxs.eth'] / 100 || 0 }, // 1 FXS = 4 veFXS
+    { id: 'cake', value: bribesData?.['sdcake.eth'] / 100 || 0 },
+    { id: 'pendle', value: bribesData?.['sdpendle.eth'] / 100 || 0 },
+    { id: 'fxn', value: bribesData?.['sdfxn.eth'] / 100 || 0 },
+    { id: 'spectra', value: bribesData?.['sdspectra.eth'] / 100 || 0 },
   ]
 
   const llVotingPower = lockerWithAutovoter(locker.id)

package/src/lockers/utils/substractFees.ts

@@ -1,7 +1,6 @@
 const substractFees = (lockerId: string, maxApr: number, lockerFee: any): number => {
   switch (lockerId) {
-    case 'ynd':
-    case 'apw': {
+    case 'ynd': {
       const totalFee = lockerFee
         ? Object.keys(lockerFee).reduce(
             (total, key) => (key !== 'lockerId' ? total + Number(lockerFee[key]) : total),

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

@@ -1,4 +1,4 @@
-import { Zero } from '@stake-dao/constants'
+import { ONE_YEAR, Zero } from '@stake-dao/constants'
 import { formatUnits, parseEther } from 'viem'
 import { projectWorkingBalance } from '../../../utils.js'
 import type { OnlyBoostData } from '../../types.js'
@@ -14,6 +14,8 @@ const getOnlyboostData = (
   workingBalance: bigint,
   baseTotalSupply: bigint,
   lpPriceInUsd: number,
+  maxApr: number,
+  baseRewardPrice: number,
 ): OnlyBoostData => {
   const active = data.active
   const convexImpl = data.convexImpl
@@ -33,6 +35,13 @@ const getOnlyboostData = (
   const stakeDaoBoost = getBoost('curve', strategyHoldings, workingBalance)
   const convexBoost = getBoost('curve', data.convexStrategyHoldings, data.convexWorkingBalance)
 
+  let convexApr =
+    ((Number(formatUnits(data.convexRewardRate * BigInt(ONE_YEAR), 18)) * baseRewardPrice) /
+      (convexTvl > 0 ? convexTvl : 1)) *
+    100
+  convexApr = convexApr > maxApr ? maxApr : convexApr
+  const convexRealBoost = (convexApr / maxApr) * 2.5
+
   const stakeDaoWorkingBalanceShare = formatUnits(workingBalance, 0)
   const convexWorkingBalanceShare =
     data.convexStrategyHoldings > Zero && data.convexWorkingBalance > Zero
@@ -69,7 +78,7 @@ const getOnlyboostData = (
   const stakeDaoOptBoost = getBoost('curve', stakeDaoOptStrategyHoldings, stakeDaoOptWorkingBalance)
   const convexOptBoost = getBoost('curve', convexOptStrategyHoldings, convexOptWorkingBalance)
 
-  const boost = Number(totalSupply) > 0 ? stakeDaoBoost * stakeDaoShare + convexBoost * convexShare : 2.5
+  const boost = Number(totalSupply) > 0 ? stakeDaoBoost * stakeDaoShare + convexRealBoost * convexShare : 2.5
   const optimalBoost =
     Number(totalSupply) > 0 ? stakeDaoOptBoost * stakeDaoOptShare + convexOptBoost * convexOptShare : 2.5
 

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

@@ -103,6 +103,8 @@ export const fetchCurve = async ({
           v.workingBalance,
           v.totalSupply,
           strat.lpPriceInUsd,
+          0,
+          0,
         )
         totalSupply = onlyboost.totalSupply
         boost = onlyboost.boost

package/src/strategies/v2/parse.ts

@@ -100,6 +100,13 @@ export const parseV2Strats = (global: any, rawStrats: any[], extra: any) => {
 
       const useVeBoost = s.chainId === mainnet.id && s.gauge?.address !== '0xd8b712d29381748dB89c36BCa0138d7c75866ddF' // MIM/3crv
 
+      const baseReward = rewards.find(
+        (r) => r.yieldType === 'STAKING_REWARDS' && equalTlc(r.token.address, baseTokens.curve[s.chainId]),
+      )
+      const baseRewardPrice =
+        extra.baseRewardsPrices.find((r) => equalTlc(r.address, baseTokens.curve[s.chainId]))?.usdPrice || 0
+      const maxApr = baseReward?.apr || 0
+
       const onlyboost = getOnlyboostData(
         {
           active: s.sidecar !== zeroAddress,
@@ -109,6 +116,7 @@ export const parseV2Strats = (global: any, rawStrats: any[], extra: any) => {
           stakeDaoSupply,
           convexStrategyHoldings: BigInt(metadata.convexTotalSupply || '0'),
           convexWorkingBalance: BigInt(metadata.workingBalanceConvex || '0'),
+          convexRewardRate: BigInt(metadata.convexRewardRate || '0'),
           convexOptSupply,
           stakeDaoOptSupply,
           claimableData: [],
@@ -121,13 +129,11 @@ export const parseV2Strats = (global: any, rawStrats: any[], extra: any) => {
         BigInt(metadata.workingBalance || '0'),
         totalSupply,
         lpPriceInUsd,
+        maxApr,
+        baseRewardPrice,
       )
 
       const boost = onlyboost.boost
-      const baseReward = rewards.find(
-        (r) => r.yieldType === 'STAKING_REWARDS' && equalTlc(r.token.address, baseTokens.curve[s.chainId]),
-      )
-      const maxApr = baseReward?.apr || 0
       const baseRewardApr = (maxApr / 2.5) * boost * ((100 - V2_FEES) / 100)
 
       let baseRewardAdded = false
@@ -179,7 +185,7 @@ export const parseV2Strats = (global: any, rawStrats: any[], extra: any) => {
         underlyingCoins: [],
         lpPriceInUsd,
         streaming: true,
-        tvl: Number(s.totalSupplyUSD),
+        tvl: Number(s.totalSupplyUSD) > 10000000000 ? 0 : Number(s.totalSupplyUSD),
         apr: {
           boost,
           current: { total: aprTotal, details: aprDetails },

package/src/utils.ts

@@ -318,3 +318,8 @@ export const multichainMulticall = async (calls: MultiChainCall[], abi: readonly
 }
 
 export const concatBytecode = (contract: string, args: string): string => contract.concat(args.slice(2))
+
+export const getRes = (raw: any) => {
+  if (raw.status === 'failure') throw Error(raw.error)
+  return raw.result
+}

package/dist/esm/lockers/fetch/parseBoost.js

@@ -1,36 +0,0 @@
-import { ONE_WEEK, ONE_YEAR, Zero } from '@stake-dao/constants';
-import { range } from 'lodash-es';
-import { formatUnits } from 'viem';
-export const parseBoost = (locker, chunkedRawLockersData) => {
-    let boost = '0';
-    if (locker.veBoost && locker.id === 'crv') {
-        boost = formatUnits(chunkedRawLockersData[16].result, locker.token.decimals);
-    }
-    else if (locker.veBoost) {
-        boost = formatUnits(chunkedRawLockersData[12].result, locker.token.decimals);
-    }
-    return boost;
-};
-export const parseVeBoostApr = (lockerId, tokenPriceInUsd, totalDelegatedVeBoost, chunkedRawLockersData) => {
-    const startIndex = lockerId === 'crv' ? 17 : 13;
-    let amountPerYear = 0;
-    try {
-        const rawWeeklyRewards = range(startIndex, startIndex + 5).map((i) => chunkedRawLockersData[i]);
-        const weeklyRewardsWithoutNull = rawWeeklyRewards
-            .filter((el) => el.status === 'success' && el.result && typeof el.result === 'bigint' && el.result > Zero)
-            .map((el) => Number(formatUnits(el.result, 18)));
-        if (weeklyRewardsWithoutNull.length > 0) {
-            amountPerYear =
-                (weeklyRewardsWithoutNull.reduce((total, x) => (total += x)) / (weeklyRewardsWithoutNull.length * ONE_WEEK)) *
-                    ONE_YEAR;
-        }
-    }
-    catch (e) {
-        console.error(e);
-        amountPerYear = 0;
-    }
-    const tvl = totalDelegatedVeBoost * tokenPriceInUsd;
-    const apr = tvl > 0 ? ((amountPerYear * tokenPriceInUsd) / tvl) * 100 : 0;
-    return apr;
-};
-//# sourceMappingURL=parseBoost.js.map

package/dist/esm/lockers/fetch/parseBoost.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseBoost.js","sourceRoot":"","sources":["../../../../src/lockers/fetch/parseBoost.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAC5E,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AACjC,OAAO,EAAE,WAAW,EAAE,MAAM,MAAM,CAAA;AAElC,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAc,EAAE,qBAA0B,EAAE,EAAE;IACvE,IAAI,KAAK,GAAG,GAAG,CAAA;IACf,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,EAAE,KAAK,KAAK,EAAE,CAAC;QAC1C,KAAK,GAAG,WAAW,CAAC,qBAAqB,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;IAC9E,CAAC;SAAM,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QAC1B,KAAK,GAAG,WAAW,CAAC,qBAAqB,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;IAC9E,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,QAAgB,EAChB,eAAuB,EACvB,qBAA6B,EAC7B,qBAA0B,EAC1B,EAAE;IACF,MAAM,UAAU,GAAG,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IAC/C,IAAI,aAAa,GAAG,CAAC,CAAA;IAErB,IAAI,CAAC;QACH,MAAM,gBAAgB,GAAG,KAAK,CAAC,UAAU,EAAE,UAAU,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAA;QAE/F,MAAM,wBAAwB,GAAG,gBAAgB;aAC9C,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,CAAC,MAAM,IAAI,OAAO,EAAE,CAAC,MAAM,KAAK,QAAQ,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC;aACzG,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,MAAgB,EAAE,EAAE,CAAC,CAAC,CAAC,CAAA;QAE5D,IAAI,wBAAwB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxC,aAAa;gBACX,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,wBAAwB,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC;oBAC5G,QAAQ,CAAA;QACZ,CAAC;IACH,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAChB,aAAa,GAAG,CAAC,CAAA;IACnB,CAAC;IAED,MAAM,GAAG,GAAG,qBAAqB,GAAG,eAAe,CAAA;IACnD,MAAM,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,GAAG,eAAe,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;IAEzE,OAAO,GAAG,CAAA;AACZ,CAAC,CAAA"}

package/dist/esm/lockers/fetch/parsePeg.js

@@ -1,18 +0,0 @@
-import {} from '@stake-dao/constants';
-import { formatUnits, parseUnits, zeroAddress } from 'viem';
-export const parsePeg = (locker, chunkedRawLockersData) => {
-    const rawPeg = locker.secondaryMarket?.pool !== zeroAddress
-        ? chunkedRawLockersData[locker.voteBooster ? 15 : 11].result
-        : undefined;
-    let parsedPeg = rawPeg;
-    switch (locker.id) {
-        case 'bal':
-            parsedPeg = rawPeg[1] * BigInt(-1);
-            break;
-    }
-    const peg = rawPeg && parsedPeg
-        ? formatUnits(parsedPeg / parseUnits(locker.secondaryMarket?.pegBase?.toString() || '1', 0), 18)
-        : '-';
-    return peg;
-};
-//# sourceMappingURL=parsePeg.js.map