@stake-dao/reader 0.4.51 → 0.4.53

package/src/strategies/passive/httpCalls.ts

@@ -0,0 +1,42 @@
+import { CURVE_API_URL } from '../curve/endpoints.js'
+
+export const getPassiveHttpCalls = async (chainId: number) => {
+  switch (chainId) {
+    case 1: {
+      const ethHttpCalls = [
+        // Curve Apis
+        (await fetch(`${CURVE_API_URL}/getPools/ethereum/main`)).json(),
+        (await fetch(`${CURVE_API_URL}/getSubgraphData/ethereum`)).json(),
+      ]
+
+      const ethHttpResponses = await Promise.all(ethHttpCalls)
+
+      const ethCurveMain = ethHttpResponses[0].data.poolData
+      const ethCurveSubgraph = ethHttpResponses[1].data.poolList
+
+      return {
+        curveSubgraphData: ethCurveSubgraph,
+        curveApiData: [{ type: 'main', value: ethCurveMain }],
+      }
+    }
+    case 137: {
+      const polygonHttpCalls = [
+        // Curve Apis
+        (await fetch(`${CURVE_API_URL}/getPools/polygon/main`)).json(),
+        (await fetch(`${CURVE_API_URL}/getSubgraphData/polygon`)).json(),
+      ]
+
+      const polygonHttpResponses = await Promise.all(polygonHttpCalls)
+
+      const polygonCurveMain = polygonHttpResponses[0].data.poolData
+      const polygonCurveSubgraph = polygonHttpResponses[1].data.poolList
+
+      return {
+        curveSubgraphData: polygonCurveSubgraph,
+        curveApiData: [{ type: 'main', value: polygonCurveMain }],
+      }
+    }
+  }
+
+  return { curveSubgraphData: undefined, curveApiData: [] }
+}

package/src/strategies/stakeDao/fetch.ts

@@ -0,0 +1,128 @@
+import { contract, stakeDaoStrats } from '@stake-dao/constants'
+import { formatUnits, parseAbi, zeroAddress } from 'viem'
+import type { Price } from '../../prices.js'
+import { multicall } from '../../utils.js'
+import getAverageYearlyRewards from '../../utils/getAverageYearlyRewards.js'
+
+const baseQueryParams = {
+  module: 'logs',
+  action: 'getLogs',
+  fromBlock: `${20061000}`,
+  address: '0xCe00aD8DF94D8C365dc415B84963aA37A06bE923',
+  topic0: '0x4882c2b96bd65ac9234537053e19a51399df7ee5f67f5f20256bfff49f7389a5',
+}
+
+interface TFetchStakeDao {
+  provider: any
+  chainId: number
+  lockers: any[]
+  prices: Price[]
+  explorerApiKey: string
+}
+
+export const fetchStakeDao = async ({ provider, chainId, lockers, prices, explorerApiKey }: TFetchStakeDao) => {
+  let amountPerYear = 0
+
+  try {
+    const queryParams = { ...baseQueryParams, chainid: `${chainId}`, apikey: explorerApiKey }
+    const url = `https://api.etherscan.io/v2/api?${new URLSearchParams(queryParams)}`
+
+    const rawEventsData = await (await fetch(url)).json()
+    amountPerYear = await getAverageYearlyRewards(rawEventsData, 5)
+  } catch {
+    amountPerYear = 0
+  }
+
+  const rawData: any = await multicall(
+    provider,
+    [
+      {
+        address: contract('veSdtBoostDelegation'),
+        name: 'received_balance',
+        params: [contract('voteBoosterStrategy')],
+      },
+    ],
+    parseAbi(['function received_balance(address user) external view returns (uint256)']),
+  )
+
+  const parsedData = stakeDaoStrats.strats.map((s, index) => {
+    const locker = lockers.find((l) => l.id === s.lockerId)
+    const boost = locker.voteBooster?.boost || 0
+    const lpPriceInUsd = prices.find((p) => p.symbol === 'SDT')?.usdPrice || 0
+
+    const totalSupply = rawData[index].result
+    const tvl = lpPriceInUsd * Number(formatUnits(totalSupply, 18))
+
+    const currentApr = ((amountPerYear * lpPriceInUsd) / tvl) * 100
+    const projectedApr = locker?.rewards ? locker.rewards.reduce((total, r) => (total += r.apr), 0) : 0
+
+    return {
+      key: s.key,
+      name: s.name,
+      subname: s.subname,
+      type: s.type,
+      protocol: s.protocol,
+      chainId: s.chainId,
+      vault: s.vault,
+      lpToken: s.lpToken,
+      coins: s.coins,
+      underlyingCoins: s.underlyingCoins,
+      vSdToken: s.vSdToken,
+      lpPriceInUsd,
+      streaming: amountPerYear > 0,
+      tvl,
+      apr: {
+        boost,
+        current: {
+          total: currentApr,
+          details: [
+            {
+              label: 'SDT',
+              value: [currentApr],
+            },
+          ],
+        },
+        projected: {
+          total: projectedApr,
+          details: [
+            {
+              label: 'SDT',
+              value: [projectedApr],
+            },
+          ],
+        },
+      },
+      rewards: s.rewards.map((r) => {
+        return {
+          token: {
+            name: r!.name,
+            decimals: r!.decimals,
+            symbol: r!.symbol,
+            address: r!.address,
+          },
+          distributor: zeroAddress,
+          periodFinish: '0',
+          rate: '0',
+          lastUpdate: '0',
+          integral: '0',
+          claimablePendingRewards: '0',
+        }
+      }),
+      // Base APR data
+      tradingApy: 0,
+      minApr: projectedApr,
+      maxApr: projectedApr,
+      // Raw data
+      totalSupply: formatUnits(totalSupply, 0),
+    }
+  })
+
+  return {
+    global: {
+      fees: { accumulator: 0, perf: 0, veSdt: 0, claimer: 0 },
+    },
+    deployed: parsedData,
+    notDeployed: [],
+    fetched: true,
+  }
+}

package/src/votemarket/curve/fetchUserVlCvxClaimable.ts

@@ -19,15 +19,20 @@ type UnknownToken = {
 }
 
 const getMerkleData = async (epoch: number) => {
-  const response = await fetch(
-    `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/${epoch}/vlCVX/merkle_data.json`,
-  )
-  if (!response.ok) throw new Error('Failed to fetch merkle data')
-  return response.json()
+  const [delegators, nonDelegators] = await Promise.all([
+    fetch(
+      `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/${epoch}/vlCVX/merkle_data_delegators.json`,
+    ).then((res) => res.json()),
+    fetch(
+      `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/${epoch}/vlCVX/merkle_data_non_delegators.json`,
+    ).then((res) => res.json()),
+  ])
+
+  return { delegators, nonDelegators }
 }
 
 const isRootMatch = (contractRoot: string, fileRoot: string) =>
-  (contractRoot === ZERO_ROOT && fileRoot === ZERO_ROOT) || contractRoot.toLowerCase() === fileRoot.toLowerCase()
+  (contractRoot === ZERO_ROOT && fileRoot === ZERO_ROOT) || equalTlc(contractRoot, fileRoot)
 
 const validateMerkleRoots = (delegatorRoot: string, nonDelegatorRoot: string, merkleData: any) => {
   const delegatorMatches = isRootMatch(delegatorRoot, merkleData.delegators.merkleRoot)
@@ -107,8 +112,8 @@ const getParsedData = (
 const ZERO_ROOT = '0x0000000000000000000000000000000000000000000000000000000000000000'
 
 export const fetchUserVlCvxClaimable = async (provider: any, rpc: Rpcs, user: string) => {
-  const nowEpoch = Math.floor(Date.now() / (1000 * 2 * ONE_WEEK)) * 2 * ONE_WEEK
-  const prevEpoch = nowEpoch - 2 * ONE_WEEK
+  const nowEpoch = Math.floor(Date.now() / 1000 / ONE_WEEK) * ONE_WEEK
+  const prevEpoch = nowEpoch - ONE_WEEK
 
   const { delegatorRoot, nonDelegatorRoot } = await getMerkleRoots(provider)
 
@@ -140,8 +145,8 @@ export const fetchUserVlCvxClaimable = async (provider: any, rpc: Rpcs, user: st
   if (!tokens.length) return []
 
   const [delegatedClaimed, notDelegatedClaimed] = await Promise.all([
-    getClaimedData(provider, tokensDelegated, user, contract('vlCvxDelegatorMerkle', mainnet.id)),
-    getClaimedData(provider, tokensNotDelegated, user, contract('vlCvxNotDelegatorMerkle', mainnet.id)),
+    getClaimedData(provider, tokensDelegated, user, contract('vlCvxDelegatorMerkle')),
+    getClaimedData(provider, tokensNotDelegated, user, contract('vlCvxNotDelegatorMerkle')),
   ])
 
   const unknownTokens = tokens.filter((t) => !tokenWithAddress(t))