@stake-dao/reader 0.4.32 → 0.4.33

package/src/votemarket/curve/fetchSnapshotUserData.ts

@@ -1,6 +1,7 @@
 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'
 
 interface SnapshotProposal {
@@ -21,6 +22,7 @@ interface ISnapshotUserData {
   proposal: SnapshotProposal
   vp: number
   space: string
+  userVotes: { [gaugeId: string]: { weight: number; relativeWeight: number } }
 }
 
 interface SnapshotStrategy {
@@ -66,6 +68,24 @@ query Proposals {
 }
 `
 
+const SNAPSHOT_USER_VOTE_QUERY = (space: string, proposal: string, user: string) => gql`
+query UserVote {
+    votes (
+        first: 1
+        where: {
+            space: "${space}"
+            proposal: "${proposal}"
+            voter: "${user}"
+        }
+    ) {
+        id
+        created
+        choice
+        vp
+    }
+}
+`
+
 export const fetchSnapshotUserData = async (
   userAddress: string,
   spaces: string[],
@@ -74,9 +94,7 @@ export const fetchSnapshotUserData = async (
     return undefined
   }
 
-  const responses = await Promise.all(
-    spaces.map((space) => graphql('https://hub.snapshot.org/graphql', SNAPSHOT_PROPOSAL_QUERY(space))),
-  )
+  const responses = await Promise.all(spaces.map((space) => graphql(SNAPSHOT_HUB, SNAPSHOT_PROPOSAL_QUERY(space))))
 
   const results: ISnapshotUserData[] = []
   for (let i = 0; i < responses.length; i++) {
@@ -94,6 +112,7 @@ export const fetchSnapshotUserData = async (
 
     // Fetch user voting power
     let vp = 0
+    const userVotes = {}
     if (isAddress(userAddress)) {
       const fetchedVp = await (snapshot as any).utils.getScores(
         spaces[i],
@@ -108,12 +127,33 @@ export const fetchSnapshotUserData = async (
           vp += v?.[userAddress] || 0
         }
       }
+
+      const rawUserVotes = await graphql(SNAPSHOT_HUB, SNAPSHOT_USER_VOTE_QUERY(spaces[i]!, proposal.id, userAddress))
+
+      if (rawUserVotes?.votes && rawUserVotes.votes.length > 0) {
+        const rawUserVote = rawUserVotes.votes[0]
+        const totalSnapshotVote = Object.keys(rawUserVote.choice).reduce(
+          (total, i) => (total += rawUserVote.choice[i]),
+          0,
+        )
+
+        for (const i of Object.keys(rawUserVote.choice)) {
+          const relativeWeight = rawUserVote.choice[i] / totalSnapshotVote
+          const proposalChoiceIndex = Number(i) - 1
+
+          userVotes[proposal.choices[proposalChoiceIndex]!] = {
+            weight: rawUserVote.vp * relativeWeight,
+            relativeWeight: relativeWeight * 100,
+          }
+        }
+      }
     }
 
     results.push({
       proposal,
       space: spaces[i] as string,
       vp,
+      userVotes,
     })
   }
 

package/src/votemarket/curve/fetchUserVlCvxClaimable.ts

@@ -19,9 +19,39 @@ type UnknownToken = {
 }
 
 const getMerkleData = async (epoch: number) => {
-  return await fetch(
+  const response = await fetch(
     `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/${epoch}/vlCVX/merkle_data.json`,
-  ).then((res) => res.json())
+  )
+  if (!response.ok) throw new Error('Failed to fetch merkle data')
+  return response.json()
+}
+
+const isRootMatch = (contractRoot: string, fileRoot: string) =>
+  (contractRoot === ZERO_ROOT && fileRoot === ZERO_ROOT) || contractRoot.toLowerCase() === fileRoot.toLowerCase()
+
+const validateMerkleRoots = (delegatorRoot: string, nonDelegatorRoot: string, merkleData: any) => {
+  const delegatorMatches = isRootMatch(delegatorRoot, merkleData.delegators.merkleRoot)
+  const nonDelegatorMatches = isRootMatch(nonDelegatorRoot, merkleData.nonDelegators.merkleRoot)
+  return delegatorMatches || nonDelegatorMatches
+}
+
+const getMerkleRoots = async (provider: any) => {
+  const contracts = [contract('vlCvxDelegatorMerkle', mainnet.id), contract('vlCvxNotDelegatorMerkle', mainnet.id)]
+
+  const result = await multicall(
+    provider,
+    contracts.map((address) => ({
+      address,
+      name: 'root',
+      params: [],
+    })),
+    parseAbi(['function root() external view returns (bytes32)']),
+  )
+
+  return {
+    delegatorRoot: result[0].result,
+    nonDelegatorRoot: result[1].result,
+  }
 }
 
 const getClaimedData = async (provider: any, tokens: string[], user: string, contract: string) => {
@@ -74,14 +104,29 @@ const getParsedData = (
     : undefined
 }
 
+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 {
-    vlCvxClaimable = await getMerkleData(nowEpoch)
-  } catch {
-    vlCvxClaimable = await getMerkleData(nowEpoch - ONE_WEEK)
+
+  // 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 {}
+  }
+
+  if (!vlCvxClaimable) {
+    throw new Error('Could not find valid merkle data')
   }
 
   const vlCvxUserDelegated = vlCvxClaimable?.delegators.claims[user]

package/src/votemarket/fetchCampaigns.ts

@@ -161,10 +161,10 @@ export const fetchCampaigns = async ({ platform, chainId, rpcs }: FetchCampaigns
   const prices = [
     ...(fetchedTokens.length > 0 ? await getPrices(fetchedTokens as any, chainId) : []),
     ...(nativeFetchedTokens.length > 0 ? await getPrices(nativeFetchedTokens as any, mainnet.id) : []),
-    { address: '0x9E49A0314AE61e9C9E34e4Af62a73FBFfB6DE95A', symbol: 'ARR', usdPrice: 10 }, // For test purpose
-    { address: '0x0Cc20784f790805537D4eE33B41f1aC4eC55446B', symbol: 'USDC', usdPrice: 1 }, // For test purpose
-    { address: '0x59c9a01163e685719FAbE5De34779F563f49D4a3', symbol: 'CRV', usdPrice: 30 }, // For test purpose
-    { address: '0x3c7b193aa39a85FDE911465d35CE3A74499F0A7B', symbol: 'ARR', usdPrice: 10 }, // For test purpose
+    // { address: '0x9E49A0314AE61e9C9E34e4Af62a73FBFfB6DE95A', symbol: 'ARR', usdPrice: 10 }, // For test purpose
+    // { address: '0x0Cc20784f790805537D4eE33B41f1aC4eC55446B', symbol: 'USDC', usdPrice: 1 }, // For test purpose
+    // { address: '0x59c9a01163e685719FAbE5De34779F563f49D4a3', symbol: 'CRV', usdPrice: 30 }, // For test purpose
+    // { address: '0x3c7b193aa39a85FDE911465d35CE3A74499F0A7B', symbol: 'ARR', usdPrice: 10 }, // For test purpose
   ]
 
   const allFetchedTokens = [...fetchedTokens, ...nativeFetchedTokens]

package/src/votemarket/fetchNeededCampaignUpdate.ts

@@ -0,0 +1,28 @@
+import { encodeAbiParameters, parseAbiParameters } from 'viem'
+import { mainnet } from 'viem/chains'
+import { getNeededCampaignUpdate } from '../bytecodes/index.js'
+import { concatBytecode } from '../index.js'
+import { batchJsonRpc } from '../utils.js'
+
+export const fetchNeededCampaignUpdate = async (rpc: string, platform: string, campaign: any) => {
+  const inputData = encodeAbiParameters(
+    parseAbiParameters(
+      getNeededCampaignUpdate.inputType[campaign.chainId] || getNeededCampaignUpdate.inputType[mainnet.id]!,
+    ) as any,
+    [platform, campaign.id],
+  )
+  const call = concatBytecode(
+    getNeededCampaignUpdate.bytecode[campaign.chainId] || getNeededCampaignUpdate.bytecode[mainnet.id]!,
+    inputData,
+  )
+
+  const neededForUpdate = await batchJsonRpc({
+    rpc,
+    calls: [call],
+    outputTypeAbi:
+      getNeededCampaignUpdate.outputTypeHr[campaign.chainId] || getNeededCampaignUpdate.outputTypeHr[mainnet.id]!,
+    callsKey: `Get needed update - chainId ${campaign.chainId} - rpc ${rpc}`,
+  })
+
+  return neededForUpdate
+}