@stake-dao/reader 0.4.97 → 0.4.99

package/src/strategies/v2/parse.ts

@@ -0,0 +1,199 @@
+import { getOnlyboostData } from '@stake-dao/reader'
+import { formatUnits, zeroAddress } from 'viem'
+import { arbitrum, base, fraxtal, mainnet, optimism, sonic } from 'viem/chains'
+import { withTwoDec } from '../../number.js'
+import { equalTlc } from '../../utils.js'
+import getTokenTypes from '../utils/getTokenTypes.js'
+
+const V2_FEES = 17
+
+const parseAsset = (asset) => ({
+  id: asset.id,
+  name: asset.name,
+  symbol: asset.symbol,
+  address: asset.address,
+  decimals: asset.decimals,
+})
+
+const baseTokens = {
+  curve: {
+    [mainnet.id]: '0xD533a949740bb3306d119CC777fa900bA034cd52',
+    [sonic.id]: '0x5Af79133999f7908953E94b7A5CF367740Ebee35',
+    [fraxtal.id]: '0x331B9182088e2A7d6D3Fe4742AbA1fB231aEcc56',
+    [arbitrum.id]: '0x11cDb42B0EB46D95f990BeDD4695A6e3fA034978',
+    [base.id]: '0x8Ee73c484A26e0A5df2Ee2a4960B789967dd0415',
+    [optimism.id]: '0x0994206dfE8De6Ec6920FF4D779B0d950605Fb53',
+  },
+  balancer: {
+    [mainnet.id]: '0xba100000625a3754423978a60c9317c58a424e3D',
+  },
+  yearn: {
+    [mainnet.id]: '0x41252E8691e964f7DE35156B68493bAb6797a275',
+  },
+  pendle: {
+    [mainnet.id]: '0x808507121B80c02388fAd14726482e061B8da827',
+  },
+}
+
+export const parseV2Strats = (global: any, rawStrats: any[], extra: any) => {
+  try {
+    return rawStrats.map((s) => {
+      const isLending = s.asset.name.startsWith('Llamalend')
+
+      const lpToken = parseAsset(s.asset)
+      const coins = s.asset.components.map((c) => parseAsset(c.childAsset))
+
+      let name = coins.map((c) => c.symbol).join('/')
+      if (name.length > 26 || lpToken?.name?.startsWith('CrossCurve')) name = lpToken.symbol
+      if (isLending) name = s.asset.name
+
+      const lpPriceInUsd =
+        Number(s.gauge.totalSupply) > 0
+          ? Number(s.gauge.totalSupplyUSD) / Number(formatUnits(BigInt(s.gauge.totalSupply || '0'), 18))
+          : 0
+
+      const compoundedYieldKey = isLending ? 'LENDING_INTEREST' : 'TRADING_FEES'
+      const tradingApy = (s.gauge.aprDetails.find((el) => el.yieldType === compoundedYieldKey)?.aprUSD || 0) * 100
+      const otherRewards = s.gauge.aprDetails.filter((el) => el.yieldType !== compoundedYieldKey && el.asset)
+      const merklRewards = (extra?.merklApi || [])
+        .filter((r) => equalTlc(r.explorerAddress, lpToken?.address))
+        .map((r) => ({
+          token: parseAsset(r.rewardsRecord.breakdowns[0]?.token),
+          aprInToken: r.apr / r.rewardsRecord.breakdowns[0]?.token.price || 1,
+          apr: r.apr,
+          streaming: true,
+          periodFinish: 2000000000,
+          yieldType: 'OFFCHAIN',
+        }))
+
+      const rewards = otherRewards
+        .map((r) => ({
+          token: parseAsset(r.asset),
+          aprInToken: r.apr,
+          apr: Number(r.aprUSD) * 100,
+          streaming: true,
+          periodFinish: 2000000000,
+          yieldType: r.yieldType,
+        }))
+        .concat(merklRewards)
+        .sort((a, b) => {
+          if (a.token.address === baseTokens.curve[s.chainId]) return -1
+          if (b.token.address === baseTokens.curve[s.chainId]) return 1
+          return 0
+        })
+
+      const metadata: any = {}
+      for (const m of s.gauge.metadata) metadata[m.key] = m.value
+
+      // Current
+      const totalSupply = BigInt(s.totalSupply)
+      const convexSupply = BigInt(s.sidecarBalance)
+      const stakeDaoSupply = totalSupply - convexSupply
+
+      // Optimal
+      const stakeDaoOptSupply =
+        totalSupply > BigInt(metadata.optimalDepositBalance || '0')
+          ? BigInt(metadata.optimalDepositBalance || '0')
+          : totalSupply
+      const convexOptSupply = totalSupply - stakeDaoOptSupply
+
+      const useVeBoost = s.chainId === mainnet.id && s.gauge?.address !== '0xd8b712d29381748dB89c36BCa0138d7c75866ddF' // MIM/3crv
+
+      const onlyboost = getOnlyboostData(
+        {
+          active: s.sidecar !== zeroAddress,
+          convexImpl: s.sidecar,
+          totalSupply,
+          convexSupply,
+          stakeDaoSupply,
+          convexStrategyHoldings: BigInt(metadata.convexTotalSupply || '0'),
+          convexWorkingBalance: BigInt(metadata.workingBalanceConvex || '0'),
+          convexOptSupply,
+          stakeDaoOptSupply,
+          claimableData: [],
+        },
+        global[useVeBoost ? 'stakeDaoVeBoost' : 'stakeDaoVeBalance'],
+        global[useVeBoost ? 'convexVeBoost' : 'convexVeBalance'],
+        global.veCrvTotalSupply,
+        BigInt(s.gauge.totalSupply),
+        stakeDaoSupply,
+        BigInt(metadata.workingBalance || '0'),
+        totalSupply,
+        lpPriceInUsd,
+      )
+
+      const boost = onlyboost.boost
+      const baseReward = rewards[0]
+      const maxApr = baseReward?.apr || 0
+      const baseRewardApr = (maxApr / 2.5) * boost * ((100 - V2_FEES) / 100)
+
+      let baseRewardAdded = false
+      const aprDetails = [{ label: isLending ? 'Lending' : 'Trading Fees (APY)', value: [tradingApy] }]
+
+      for (const r of rewards) {
+        if (baseReward && r.token.symbol === baseReward.token.symbol && !baseRewardAdded) {
+          aprDetails.push({
+            label: `${r.token.symbol} APR (incl. ${withTwoDec(boost)}x boost)`,
+            value: [baseRewardApr || 0],
+          })
+
+          baseRewardAdded = true
+        } else {
+          aprDetails.push({ label: `${r.token.symbol} APR`, value: [r.apr || 0] })
+        }
+      }
+
+      let aprTotal = aprDetails.reduce((total, x) => {
+        for (const v of x.value) total += v
+        return total
+      }, 0)
+      if (aprTotal > 1e18) aprTotal = 2727
+
+      return {
+        key: s.id,
+        tokensFilter: getTokenTypes({ isLending, coins }),
+        isLending,
+        name,
+        type: 'factory-stable-ng',
+        version: 2,
+        protocol: 'curve',
+        chainId: s.chainId,
+        vault: s.address,
+        lpToken,
+        gaugeAddress: s.gauge.address,
+        gauge: {
+          address: s.gauge.address,
+          totalSupply: s.gauge.totalSupply,
+          totalSupplyUsd: s.gauge.totalSupplyUSD,
+          extraRewards: [],
+        },
+        coins,
+        underlyingCoins: [],
+        lpPriceInUsd,
+        streaming: true,
+        tvl: Number(s.totalSupplyUSD),
+        apr: {
+          boost,
+          current: { total: aprTotal, details: aprDetails },
+        },
+        rewards,
+        tradingApy,
+        minApr: maxApr / 2.5,
+        maxApr,
+        totalSupply: s.totalSupply,
+        workingBalance: metadata?.workingBalance || '0',
+        onlyboost,
+        convexPool:
+          metadata.pid && metadata.convexBaseRewardPool
+            ? {
+                id: Number(metadata.pid),
+                crvRewards: metadata.convexBaseRewardPool,
+              }
+            : undefined,
+      }
+    })
+  } catch (e) {
+    console.error(e)
+    return []
+  }
+}

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

@@ -14,6 +14,7 @@ import type { Price } from '../../../prices.js'
 import { getLogsFromEtherscan } from '../../../utils/etherscan.js'
 import type { RewardsData, SdtApr, StrategyData, ValidChainId } from '../../types.js'
 import { getAprBreakdown } from '../../utils/getAprBreakdown.js'
+import getTokenTypes from '../../utils/getTokenTypes.js'
 import { decodeNewFactoryEvent } from '../../utils/index.js'
 import { fetchAllYearnGauges } from './fetchAllYearnGauges.js'
 
@@ -209,6 +210,7 @@ export const fetchYearn = async ({
     return {
       key: s.key,
       type: s.type,
+      tokensFilter: getTokenTypes(s),
       protocol: s.protocol,
       chainId,
       vault: s.vault,

package/src/votemarket/curve/fetchSnapshotUserData.ts

@@ -94,6 +94,8 @@ export const getStakeDaoSnapshotSpace = (protocolId: string): string | undefined
       return 'sdfxn.eth'
     case 'balancer':
       return 'sdbal.eth'
+    case 'pendle':
+      return 'sdpendle.eth'
     default:
       return undefined
   }