@stake-dao/reader 0.4.52 → 0.4.54

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

@@ -3,7 +3,7 @@ import { formatUnits } from 'viem'
 import { ONE_YEAR, OneEther, Zero, curveStrats, mainnet, tokenWithId } from '@stake-dao/constants'
 import type { Price } from '../../../prices.js'
 import { type SdtEmissionData, getSdtApr } from '../../../sdt.js'
-import { equalTlc } from '../../../utils.js'
+import { equalTlc, lc } from '../../../utils.js'
 import type {
   CurveGlobalData,
   OnlyBoostData,
@@ -18,6 +18,7 @@ import { getAprBreakdown } from '../../utils/getAprBreakdown.js'
 import { buildCurveStrategies } from '../build.js'
 import { getCurveHttpCalls } from '../httpCalls.js'
 import { getOnChainSdCurveData } from '../onChainCalls.js'
+import curvePoints from '../points.js'
 import { BROKEN_VAULTS } from './curveApiData/config.js'
 import type { GaugesWeightsData } from './curveApiData/getGaugesWeights.js'
 import { getCvxApr } from './getCvxApr.js'
@@ -218,6 +219,7 @@ export const fetchCurve = async ({
         underlyingCoins: strat.underlyingCoins,
         sdGauge,
         lpPriceInUsd: strat.lpPriceInUsd,
+        points: curvePoints[lc(strat.lpToken.address)],
         streaming: rewardsData.some((r) => Number(r.periodFinish) > Math.floor(Date.now() / 1000)),
         tvl,
         apr: {

package/src/strategies/curve/points.ts

@@ -0,0 +1,8 @@
+const curvePoints = {
+  '0x38de22a3175708d45e7c7c64cd78479c8b56f76e': [{ multiplier: 30, label: 'Resolv Points' }],
+  '0x4628f13651ead6793f8d838b34b8f8522fb0cc52': [{ multiplier: 30, label: 'Resolv Points' }],
+  '0xc907ba505c2e1cbc4658c395d4a2c7e6d2c32656': [{ multiplier: 30, label: 'Resolv Points' }],
+  '0x3ee841f47947fefbe510366e4bbb49e145484195': [{ multiplier: 30, label: 'Resolv Points' }],
+}
+
+export default curvePoints

package/src/strategies/passive/fetch.ts

@@ -1,11 +1,11 @@
 import { formatUnits } from 'viem'
 
-import multicallPassiveVaultsAbi from '../../abis/passiveVaultsMulticall.js'
 import { contract, passiveStrats } from '@stake-dao/constants'
-import { multicall } from '../../utils.js'
 import { mainnet } from 'viem/chains'
-import { getPassiveHttpCalls } from './httpCalls.js'
+import multicallPassiveVaultsAbi from '../../abis/passiveVaultsMulticall.js'
+import { multicall } from '../../utils.js'
 import { getBoost } from '../utils/boost.js'
+import { getPassiveHttpCalls } from './httpCalls.js'
 
 interface TFetchPassive {
   provider: any

package/src/strategies/pendle/fetch.ts

@@ -16,7 +16,7 @@ import {
 import multicallPendleStratsAbi from '../../abis/pendleVaultsMulticall.js'
 import { batchPendleStrats } from '../../bytecodes/index.js'
 import type { Price } from '../../prices.js'
-import { type Call, batchJsonRpc, equalTlc, multicall } from '../../utils.js'
+import { type Call, batchJsonRpc, equalTlc, lc, 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'
@@ -281,6 +281,7 @@ export const fetchPendle = async ({ prices, provider, rpc, explorerApiKey, explo
       lpToken: s.lpToken,
       coins: s.coins,
       syToken: s.syToken,
+      points: pendlePoints[lc(s.lpToken.address)],
       streaming: rewardsData.some((r) => Number(r.periodFinish) > Math.floor(Date.now() / 1000)),
       sdGauge,
       lpPriceInUsd,

package/src/strategies/pendle/pendlePoints.ts

@@ -1,71 +1,24 @@
 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' },
-  ],
+  '0x353d0b2efb5b3a7987fb06d30ad6160522d08426': [{ multiplier: 15, label: 'Resolv Points' }],
 }
 
 export default pendlePoints

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/utils/snapshot.ts

@@ -0,0 +1,116 @@
+import { isAddress, zeroAddress } from 'viem'
+
+interface Strategy {
+  name: string
+  network?: string
+  params: any
+}
+
+const DEFAULT_SCORE_API_URL = 'https://score.snapshot.org'
+
+const NETWORKS = {
+  1: { key: '1', name: 'Ethereum', start: 7929876 },
+  10: { key: '10', name: 'Optimism', start: 657806 },
+  56: { key: '56', name: 'BNB Smart Chain', start: 461230 },
+  100: { key: '100', name: 'Gnosis Chain', start: 4108192 },
+  137: { key: '137', name: 'Polygon PoS', start: 9834491 },
+  146: { key: '146', name: 'Sonic', start: 60 },
+  250: { key: '250', name: 'Fantom Opera', start: 2497732 },
+  252: { key: '252', name: 'Fraxtal', start: 1 },
+  324: { key: '324', name: 'zkSync Era', start: 3908235 },
+  8453: { key: '8453', name: 'Base', start: 5022 },
+  42161: { key: '42161', name: 'Arbitrum One', start: 256508 },
+  42220: { key: '42220', name: 'Celo', start: 6599803 },
+  43114: { key: '43114', name: 'Avalanche', start: 536483 },
+  59144: { key: '59144', name: 'Linea', start: 42 },
+  81457: { key: '81457', name: 'Blast', start: 88189 },
+}
+
+const inputError = (message: string) => Promise.reject(new Error(message))
+
+function isValidNetwork(network: string) {
+  return !!NETWORKS[network]
+}
+
+function isValidAddress(address: string) {
+  return isAddress(address) && address !== zeroAddress
+}
+
+function isValidSnapshot(snapshot: number | string, network: string) {
+  return snapshot === 'latest' || (typeof snapshot === 'number' && snapshot >= NETWORKS[network].start)
+}
+
+const parseScoreAPIResponse = async (res: any) => {
+  let data: any = await res.text()
+
+  try {
+    data = JSON.parse(data)
+  } catch (_e: any) {
+    return Promise.reject({
+      code: res.status || 500,
+      message: 'Failed to parse response from score API',
+      data,
+    })
+  }
+
+  if (data.error) return Promise.reject(data.error)
+  return data
+}
+
+export const getSnapshotScores = async (
+  space: string,
+  strategies: Strategy[],
+  network: string,
+  addresses: string[],
+  snapshot: number | string = 'latest',
+  options: any = {},
+) => {
+  if (!Array.isArray(addresses)) {
+    return inputError('addresses should be an array of addresses')
+  }
+  if (addresses.length === 0) {
+    return inputError('addresses can not be empty')
+  }
+  const invalidAddress = addresses.find((address) => !isValidAddress(address))
+  if (invalidAddress) {
+    return inputError(`Invalid address: ${invalidAddress}`)
+  }
+  if (!isValidNetwork(network)) {
+    return inputError(`Invalid network: ${network}`)
+  }
+  const invalidStrategy = strategies.find((strategy) => strategy.network && !isValidNetwork(strategy.network))
+  if (invalidStrategy) {
+    return inputError(`Invalid network (${invalidStrategy.network}) in strategy ${invalidStrategy.name}`)
+  }
+  if (!isValidSnapshot(snapshot, network)) {
+    return inputError(
+      `Snapshot (${snapshot}) must be 'latest' or greater than network start block (${NETWORKS[network].start})`,
+    )
+  }
+
+  const url = `${DEFAULT_SCORE_API_URL}/api/scores`
+  const headers = { Accept: 'application/json', 'Content-Type': 'application/json' }
+
+  try {
+    const params = {
+      space,
+      network,
+      snapshot,
+      strategies,
+      addresses,
+    }
+    const res = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ params }),
+    })
+    const response = await parseScoreAPIResponse(res)
+
+    return options.returnValue === 'all' ? response.result : response.result[options.returnValue || 'scores']
+  } catch (e: any) {
+    if (e.errno) {
+      return Promise.reject({ code: e.errno, message: e.toString(), data: '' })
+    }
+    return Promise.reject(e)
+  }
+}

package/src/votemarket/curve/config.ts

@@ -6,6 +6,7 @@ export const GAUGES_METADATA_CHUNK_SIZE = {
   10: 10,
   100: 10,
   137: 10,
+  146: 10,
   250: 10,
   252: 10,
   8453: 10,

package/src/votemarket/curve/fetchSnapshotUserData.ts

@@ -1,8 +1,8 @@
-import snapshot from '@snapshot-labs/snapshot.js'
 import { gql } from 'graphql-request'
 import { isAddress } from 'viem'
 import { SNAPSHOT_HUB } from '../../endpoints.js'
 import { graphql } from '../../utils.js'
+import { getSnapshotScores } from '../../utils/snapshot.js'
 
 interface SnapshotProposal {
   id: string
@@ -114,8 +114,8 @@ export const fetchSnapshotUserData = async (
     let vp = 0
     const userVotes = {}
     if (isAddress(userAddress)) {
-      const fetchedVp = await (snapshot as any).utils.getScores(
-        spaces[i],
+      const fetchedVp = await getSnapshotScores(
+        spaces[i]!,
         proposal.space.strategies,
         '1',
         [userAddress],

package/src/votemarket/curve/fetchUserVlCvxClaimable.ts

@@ -1,4 +1,4 @@
-import { ONE_WEEK, Zero, contract, tokenWithAddress } from '@stake-dao/constants'
+import { Zero, contract, tokenWithAddress } from '@stake-dao/constants'
 import { type Address, formatUnits, parseAbi } from 'viem'
 import { mainnet } from 'viem/chains'
 import { GH_STAKE_DAO_BOUNTIES_REPORT } from '../../endpoints.js'
@@ -18,14 +18,14 @@ type UnknownToken = {
   chainId: number
 }
 
-const getMerkleData = async (epoch: number) => {
+const getMerkleData = async () => {
   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`,
+      `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/latest/vlCVX/vlcvx_merkle_delegators.json`,
     ).then((res) => res.json()),
+    fetch(`${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/latest/vlCVX/vlcvx_merkle.json`).then(
+      (res) => res.json(),
+    ),
   ])
 
   return { delegators, nonDelegators }
@@ -112,23 +112,16 @@ const getParsedData = (
 const ZERO_ROOT = '0x0000000000000000000000000000000000000000000000000000000000000000'
 
 export const fetchUserVlCvxClaimable = async (provider: any, rpc: Rpcs, user: string) => {
-  const nowEpoch = Math.floor(Date.now() / 1000 / ONE_WEEK) * ONE_WEEK
-  const prevEpoch = nowEpoch - ONE_WEEK
-
   const { delegatorRoot, nonDelegatorRoot } = await getMerkleRoots(provider)
 
   let vlCvxClaimable: any
 
-  // Try current week, then previous week if needed
-  for (const epoch of [nowEpoch, prevEpoch]) {
-    try {
-      const merkleData = await getMerkleData(epoch)
-      if (validateMerkleRoots(delegatorRoot, nonDelegatorRoot, merkleData)) {
-        vlCvxClaimable = merkleData
-        break
-      }
-    } catch {}
-  }
+  try {
+    const merkleData = await getMerkleData()
+    if (validateMerkleRoots(delegatorRoot, nonDelegatorRoot, merkleData)) {
+      vlCvxClaimable = merkleData
+    }
+  } catch {}
 
   if (!vlCvxClaimable) {
     throw new Error('Could not find valid merkle data')