@stake-dao/reader 0.4.95 → 0.4.96

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

@@ -259,29 +259,10 @@ export const fetchCurve = async ({
     stratsData = stratsData.concat(parsedData)
   })
 
-  const deployedStratsGauges = stratsData.map((s) => s.gaugeAddress)
-  const notDeployedStrats = apisData.curveApiData
-    .filter(
-      (curvePool) =>
-        curvePool.gauge &&
-        !deployedStratsGauges.includes(curvePool.gauge.address) &&
-        ((curvePool.crvApr && curvePool.crvApr.length > 1 && curvePool.crvApr[1] !== null && curvePool.crvApr[1] > 0) ||
-          (curvePool.gauge.extraRewards && curvePool.gauge.extraRewards.length > 0)),
-    )
-    .map((s) => ({
-      ...s,
-      protocol: 'curve',
-      chainId,
-      convexPool:
-        chainId === 1
-          ? apisData.convexPools.find((pool: any) => equalTlc(pool.lpTokenAddress, s.lp))?.convexPoolData || undefined
-          : undefined,
-    }))
-
   return {
     global,
     deployed: stratsData,
-    notDeployed: notDeployedStrats,
+    notDeployed: [],
     fetched: true,
   }
 }

package/src/utils/snapshot.ts

@@ -71,6 +71,11 @@ export const getSnapshotProposalVp = async (space: string, proposalId: string, u
       ) {
         vp
       }
+      votes(where: { voter: "${userAddress}", space: "${space}", proposal: "${proposalId}" }) {
+        vp
+        vp_by_strategy
+        vp_state
+      }
     }
   `,
   )

package/src/votemarket/curve/fetchSnapshotUserData.ts

@@ -134,8 +134,7 @@ export const fetchSnapshotUserData = async (
     const userVotes = {}
     if (isAddress(userAddress)) {
       const proposalVp = await getSnapshotProposalVp(space, proposal.id, userAddress)
-
-      vp = proposalVp.vp.vp
+      vp = proposalVp.votes.length ? proposalVp.votes[0].vp : proposalVp.vp.vp
 
       const rawUserVotes = await graphql(SNAPSHOT_HUB, SNAPSHOT_USER_VOTE_QUERY(space, proposal.id, userAddress))
 

package/src/votemarket/fetchClaimableData.ts

@@ -1,11 +1,51 @@
-import { chunk } from 'lodash-es'
 import { encodeAbiParameters, formatUnits, parseAbiParameters } from 'viem'
 import { arbitrum } from 'viem/chains'
 import batchClaimableData from '../bytecodes/votemarket/batchClaimableData.js'
 import { concatBytecode } from '../index.js'
 import { batchJsonRpc } from '../utils.js'
 
-const CLAIMABLE_CHUNK_SIZE = 5
+const MAX_VOTES_PER_CHUNK = 50
+const MAX_CAMPAIGNS_PER_CHUNKS = 5
+
+const chunkCampaignsWithVoteLimit = (campaigns: number[], userVotes: any[]) => {
+  const campaignChunks: number[][] = []
+  const voteChunks: any[][][] = []
+
+  let currentCampaignChunk: number[] = []
+  let currentVoteChunk: any[][] = []
+  let currentVoteCount = 0
+
+  for (let i = 0; i < campaigns.length; i++) {
+    const votes = userVotes[i]
+    const voteCount = votes.length
+
+    if (
+      (currentVoteCount + voteCount > MAX_VOTES_PER_CHUNK && currentCampaignChunk.length > 0) ||
+      currentCampaignChunk.length >= MAX_CAMPAIGNS_PER_CHUNKS
+    ) {
+      // Push current chunks and resets
+      campaignChunks.push(currentCampaignChunk)
+      voteChunks.push(currentVoteChunk)
+
+      currentCampaignChunk = []
+      currentVoteChunk = []
+      currentVoteCount = 0
+    }
+
+    //Add to chunk
+    currentCampaignChunk.push(campaigns[i] as number)
+    currentVoteChunk.push(votes)
+    currentVoteCount += voteCount
+  }
+
+  // Push remaining
+  if (currentCampaignChunk.length > 0) {
+    campaignChunks.push(currentCampaignChunk)
+    voteChunks.push(currentVoteChunk)
+  }
+
+  return { campaignChunks, voteChunks }
+}
 
 export const fetchClaimableData = async (
   chainId: number,
@@ -15,8 +55,10 @@ export const fetchClaimableData = async (
   campaigns: number[],
   userVotes: any[][],
 ) => {
-  const inputCampaignsChunks = chunk(campaigns, CLAIMABLE_CHUNK_SIZE)
-  const inputVotesChunks = chunk(userVotes, CLAIMABLE_CHUNK_SIZE)
+  const { campaignChunks: inputCampaignsChunks, voteChunks: inputVotesChunks } = chunkCampaignsWithVoteLimit(
+    campaigns,
+    userVotes,
+  )
 
   const claimableCalls = inputCampaignsChunks.map((campaignsArgs, index) => {
     const inputData = encodeAbiParameters(

package/src/votemarket/fetchEpochVotes.ts

@@ -1,10 +1,12 @@
+import { contracts } from '@stake-dao/constants'
 import { chunk } from 'lodash-es'
 import { encodeAbiParameters, parseAbiParameters } from 'viem'
 import { mainnet } from 'viem/chains'
+import batchPendleVotes from '../bytecodes/votemarket/batchPendleVotes.js'
 import batchVotes from '../bytecodes/votemarket/batchVotes.js'
 import { STAKE_DAO_API } from '../endpoints.js'
 import { concatBytecode } from '../index.js'
-import { batchJsonRpcWithBlocks } from '../utils.js'
+import { batchJsonRpcWithBlocks, equalTlc } from '../utils.js'
 
 type Rpcs = {
   [chainId: number]: string
@@ -35,20 +37,26 @@ export const fetchEpochsVotes = async (rpc: Rpcs, gaugeController: string, user:
   // Merge blocks
   const blocksForEpoch = [...cachedBlocks, ...missingBlocks]
 
-  const inputData = encodeAbiParameters(parseAbiParameters(batchVotes.inputType[mainnet.id]!) as any, [
+  const batchVotesProtocol = equalTlc(gaugeController, contracts.pendleGaugeController?.[1] || '')
+    ? batchPendleVotes
+    : batchVotes
+
+  const inputData = encodeAbiParameters(parseAbiParameters(batchVotesProtocol.inputType[mainnet.id]!) as any, [
     gaugeController,
     user,
   ])
-  const call = concatBytecode(batchVotes.bytecode[mainnet.id]!, inputData)
+
+  const call = concatBytecode(batchVotesProtocol.bytecode[mainnet.id]!, inputData)
 
   const blocksChunks = chunk(blocksForEpoch, 10)
+
   const votes = (
     await Promise.all(
       blocksChunks.map((b) =>
         batchJsonRpcWithBlocks({
           rpc: rpc[1]!,
           call,
-          outputTypeAbi: batchVotes.outputTypeHr[mainnet.id],
+          outputTypeAbi: batchVotesProtocol.outputTypeHr[mainnet.id],
           callsKey: `Batch block votes data - chainId ${mainnet.id} - rpc ${rpc[mainnet.id]}`,
           blocks: b,
         }),

package/src/votemarket/pendle/fetchPendleUserVotes.ts

@@ -0,0 +1,46 @@
+import { encodeAbiParameters, formatUnits, parseAbiParameters, zeroAddress } from 'viem'
+import { mainnet } from 'viem/chains'
+import batchPendleUserVotes from '../../bytecodes/votemarket/batchPendleUserVotes.js'
+import { concatBytecode } from '../../index.js'
+import { batchJsonRpc, equalTlc } from '../../utils.js'
+import type { GaugesUserData } from '../curve/fetchCurveUserVotes.js'
+
+export const fetchPendleUserVotes = async (rpc: string, user: string): Promise<GaugesUserData> => {
+  const calls = [
+    concatBytecode(
+      batchPendleUserVotes.bytecode[mainnet.id]!,
+      encodeAbiParameters(parseAbiParameters(batchPendleUserVotes.inputType[mainnet.id]!) as any, [user]),
+    ),
+  ]
+
+  const rawVotes = await batchJsonRpc({
+    rpc,
+    calls,
+    outputTypeAbi: batchPendleUserVotes.outputType![mainnet.id],
+    parse: false,
+    callsKey: `votemarket/pendle/fetchPendleUserVotes.ts: rawGauges - chainId ${mainnet.id} - rpc ${rpc}`,
+  })
+
+  const veBalance = rawVotes[0].veBalance
+
+  const votes = rawVotes[0].votes
+    .filter((rv) => !equalTlc(rv.gauge, zeroAddress))
+    .map((v) => ({
+      gauge: v.gauge,
+      slope: formatUnits(v.slope, 0),
+      relativeWeight: Number.parseFloat(formatUnits(v.power, 16)),
+      weight: formatUnits((veBalance * BigInt(v.power)) / BigInt(10 ** 16) / BigInt(100), 18),
+      start: Number(v.start),
+      end: Number(v.end),
+    }))
+
+  const unusedRelativeWeight = 10 ** 18 - votes.reduce((total, x) => total + x.relativeWeight * 100, 0)
+  const unusedVeBalance = (veBalance * BigInt(unusedRelativeWeight)) / BigInt(10 ** 18)
+
+  return {
+    veBalance: formatUnits(veBalance, 18),
+    unusedVeBalance: formatUnits(unusedVeBalance, 18),
+    unusedRelativeWeight: unusedRelativeWeight / 100,
+    votes,
+  }
+}