@stake-dao/reader 0.4.53 → 0.4.54

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')