@stake-dao/reader 0.4.31 → 0.4.33

package/src/lockers/fetch/index.ts

@@ -14,6 +14,7 @@ import getFees from '../utils/getFees.js'
 import getHttpCalls from '../utils/getHttpCalls.js'
 import { lockedAmountCallSideChain } from '../utils/index.js'
 import substractFees from '../utils/substractFees.js'
+import { parseBoost } from './parseBoost.js'
 import { parsePeg } from './parsePeg.js'
 import { parseVoteBoosterData } from './parseVoteBoosterData.js'
 
@@ -59,6 +60,7 @@ export const fetchLockers = async ({ provider, chainId, prices, withAirdropGraph
         locker.modules.locker,
         locker.secondaryMarket,
         locker.voteBooster,
+        locker.veBoost,
       ),
     )
     lockersRewardsCalls.push(...callsForRewards(locker.modules.gauge, locker.rewards))
@@ -101,6 +103,7 @@ export const fetchLockers = async ({ provider, chainId, prices, withAirdropGraph
       locker.modules.locker,
       locker.secondaryMarket,
       locker.voteBooster,
+      locker.veBoost,
     ).length
     const chunkedRawLockersData = rawLockersData.splice(0, lockerCallsLength)
 
@@ -140,6 +143,8 @@ export const fetchLockers = async ({ provider, chainId, prices, withAirdropGraph
     const veTokenRate =
       locker.id === 'mav' ? formatUnits(chunkedRawLockersData[11].result[0], locker.token.decimals) : '4'
 
+    const veBoostTotalSupply = parseBoost(locker, chunkedRawLockersData)
+
     const sideChains = locker.extensions.sideChains?.map((sideChain) => {
       const rewards =
         sideChain.rewards?.map((reward) => {
@@ -322,6 +327,7 @@ export const fetchLockers = async ({ provider, chainId, prices, withAirdropGraph
         sideChains,
         ...(locker.id === 'cake' ? { airdropGraph } : {}),
       },
+      veBoostTotalSupply,
     }
   })
 

package/src/lockers/fetch/parseBoost.ts

@@ -0,0 +1,13 @@
+import { type Locker } from '@stake-dao/constants'
+import { formatUnits } from 'viem'
+
+export const parseBoost = (locker: Locker, chunkedRawLockersData: any) => {
+  let boost = '0'
+  if (locker.veBoost && locker.id === 'crv') {
+    boost = formatUnits(chunkedRawLockersData[15].result, locker.token.decimals)
+  } else if (locker.veBoost) {
+    boost = formatUnits(chunkedRawLockersData[11].result, locker.token.decimals)
+  }
+
+  return boost
+}

package/src/lockers/utils/callsForLockers/index.ts

@@ -4,6 +4,7 @@ import type { Address } from 'viem'
 import depositorCalls from './depositorCalls.js'
 import gaugeCalls from './gaugeCalls.js'
 import pegCalls from './pegCalls.js'
+import veBoosts from './veBoosts.js'
 import veCalls from './veCalls.js'
 import veSdtCalls from './veSdtCalls.js'
 
@@ -17,6 +18,10 @@ const callsForLockers = (
   locker: string,
   secondaryMarket: LockerSecondaryMarket | undefined,
   voteBooster: any,
+  veBoost?: {
+    address: Address
+    delegator: Address
+  },
 ) => [
   ...veCalls(lockerId, votingEscrow, locker as Address, token),
   ...depositorCalls(depositor, locker as Address),
@@ -34,6 +39,7 @@ const callsForLockers = (
         },
       ]
     : []),
+  ...veBoosts(veBoost),
 ]
 
 export default callsForLockers

package/src/lockers/utils/callsForLockers/veBoosts.ts

@@ -0,0 +1,15 @@
+import type { Address } from 'viem'
+
+const veBoosts = (veBoost?: {
+  address: Address
+  delegator: Address
+}) => {
+  const calls: any[] = []
+  if (veBoost) {
+    calls.push({ address: veBoost.delegator, name: 'totalSupply', params: [] })
+  }
+
+  return calls
+}
+
+export default veBoosts

package/src/strategies/pancakeswap/fetch/getPancakeV3Vaults.ts

@@ -150,7 +150,7 @@ export const getPancakeV3Vaults = async (
         },
       ]
 
-      const tradingApy = Number(feesApr[strat.pool.toLowerCase()]?.apr7d || 0)
+      const tradingApy = Number(feesApr[strat.pool.toLowerCase()]?.apr7d || 0) * 100
       const apr = getAprBreakdown({ ...strat, tradingApy }, rewards, boost, undefined)
 
       const parsedData = {

package/src/strategies/pancakeswap/fetch/pancakePositions.ts

@@ -44,8 +44,8 @@ export const computePositionData = (
   const token1AmountUsd = Number(token1Amount) * token1PriceInUsd
   const tvlToAdd = token0AmountUsd + token1AmountUsd
 
-  const priceLower = tickToPrice(p.tickLower)
-  const priceUpper = tickToPrice(p.tickUpper)
+  const priceLower = tickToPrice(p.tickLower) * 10 ** (s.coins[0].decimals - s.coins[1].decimals)
+  const priceUpper = tickToPrice(p.tickUpper) * 10 ** (s.coins[0].decimals - s.coins[1].decimals)
 
   const boost = Number(formatUnits(p.boostMultiplier.toString(), 12))
 

package/src/strategies/pancakeswap/fetch/pancakeswapMath.ts

@@ -295,7 +295,7 @@ export function getPositionTradingFee({
   return (positionUSD + fees24HPosition * 365) / positionUSD - 1
 }
 
-export function tickToPrice(tick: number, precision = 6): number {
+export function tickToPrice(tick: number, precision = 18): number {
   const sqrtRatioX96 = getSqrtRatioAtTick(tick)
 
   const ratioX192 = sqrtRatioX96 * sqrtRatioX96

package/src/votemarket/curve/fetchCurveGauges.ts

@@ -111,7 +111,7 @@ export const fetchCurveGauges = async (rpc: Rpcs): Promise<GaugesData> => {
     const gaugeMetadata = gaugesMetadata.find((gm) => equalTlc(gm.gauge, g.childGauge))
     const filteredCoins = gaugeMetadata.coins.filter((c) => c._address !== zeroAddress)
 
-    const name = gaugeMetadata.lp.name
+    let name = gaugeMetadata.lp.name
       .replace('Curve.fi Factory Crypto Pool:', '')
       .replace('Curve.fi Factory Pool:', '')
       .replace('Curve.fi Factory USD Metapool:', '')
@@ -119,6 +119,10 @@ export const fetchCurveGauges = async (rpc: Rpcs): Promise<GaugesData> => {
       .replace('Curve.fi', '')
       .trim()
 
+    if (name.startsWith('Curve Vault for')) {
+      name = `Lending ${gaugeMetadata.coins[0].symbol} (${gaugeMetadata.coins[1].symbol})`
+    }
+
     if (filteredCoins.length === 0 && !g.isKilled && g.weight !== '0')
       gaugesLpWithMissingCoins.push(gaugeMetadata.lp._address)
 

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
+}