@stake-dao/reader 0.5.3 → 0.5.5

package/src/prices.ts

@@ -35,6 +35,8 @@ export const getLlamaTokenPrefix = (chainId = 1): string => {
       return 'avax'
     case 59144:
       return 'linea'
+    case 42793:
+      return 'etherlink'
     default:
       return 'ethereum'
   }
@@ -105,6 +107,8 @@ export const getGeckoTerminalTokenPrefix = (chainId = 1): string => {
       return 'avax'
     case 59144:
       return 'linea'
+    case 42793:
+      return 'etherlink'
     default:
       return 'eth'
   }

package/src/strategies/v2/parse.ts

@@ -1,3 +1,4 @@
+import { ONE_YEAR } from '@stake-dao/constants'
 import { getOnlyboostData } from '@stake-dao/reader'
 import { formatUnits, zeroAddress } from 'viem'
 import { arbitrum, base, etherlink, fraxtal, gnosis, mainnet, optimism, sonic } from 'viem/chains'
@@ -68,6 +69,61 @@ export const parseV2Strats = (global: any, rawStrats: any[], extra: any) => {
           yieldType: 'OFFCHAIN',
         }))
 
+      // Compute rewards from the hook incentive (Votemarket)
+      const hookIncentivesPrices = extra?.hookIncentivesPrices || []
+      const gaugeUsd = Number(s.gauge.totalSupplyUSD)
+
+      const incentivesByToken = (extra?.hookIncentives || [])
+        .filter((r) => equalTlc(r.vault, s.address))
+        .reduce((acc, r) => {
+          const rewardAddress = r.reward
+          const price = hookIncentivesPrices.find((p) => equalTlc(rewardAddress, p.address))?.usdPrice || 0
+
+          const amountToken = Number.parseFloat(formatUnits(r.amount, r.rewardDecimals))
+          const duration = Number.parseInt(r.end) - Number.parseInt(r.start)
+
+          if (duration <= 0) return acc
+
+          const tokensPerSecond = amountToken / duration
+          const yearlyTokens = tokensPerSecond * ONE_YEAR
+          const yearlyRewardsUsd = yearlyTokens * price
+
+          if (!acc[rewardAddress]) {
+            acc[rewardAddress] = {
+              meta: r,
+              price: price,
+              totalYearlyUsd: 0,
+              maxPeriodFinish: Number.parseInt(r.end),
+            }
+          }
+
+          acc[rewardAddress].totalYearlyUsd += yearlyRewardsUsd
+          acc[rewardAddress].maxPeriodFinish = Math.max(acc[rewardAddress].maxPeriodFinish, Number.parseInt(r.end))
+
+          return acc
+        }, {})
+
+      const hookIncentives = Object.values(incentivesByToken).map((group: any) => {
+        const { meta, price, totalYearlyUsd, maxPeriodFinish } = group
+
+        const apr = gaugeUsd > 0 ? (totalYearlyUsd / gaugeUsd) * 100 : 0
+
+        return {
+          token: parseAsset({
+            id: meta.id.toString(),
+            name: meta.rewardSymbol,
+            symbol: meta.rewardSymbol,
+            address: meta.reward,
+            decimals: meta.rewardDecimals,
+          }),
+          aprInToken: price > 0 ? apr / price : 0,
+          apr,
+          streaming: true,
+          periodFinish: maxPeriodFinish,
+          yieldType: 'VOTEMARKET',
+        }
+      })
+
       const rewards = otherRewards
         .map((r) => ({
           token: parseAsset(r.asset),
@@ -78,6 +134,7 @@ export const parseV2Strats = (global: any, rawStrats: any[], extra: any) => {
           yieldType: r.yieldType,
         }))
         .concat(merklRewards)
+        .concat(hookIncentives)
         .sort((a, b) => {
           if (a.token.address === baseTokens.curve[s.chainId]) return -1
           if (b.token.address === baseTokens.curve[s.chainId]) return 1
@@ -154,7 +211,11 @@ export const parseV2Strats = (global: any, rawStrats: any[], extra: any) => {
 
           baseRewardAdded = true
         } else {
-          aprDetails.push({ label: `${r.token.symbol} APR`, value: [r.apr || 0] })
+          const label =
+            r.yieldType === 'VOTEMARKET'
+              ? `${r.token.symbol} APR (Extra Rewards from Votemarket)`
+              : `${r.token.symbol} APR`
+          aprDetails.push({ label, value: [r.apr || 0] })
         }
       }
 

package/src/votemarket/fetchClaimableData.ts

@@ -4,7 +4,7 @@ import batchClaimableData from '../bytecodes/votemarket/batchClaimableData.js'
 import { concatBytecode } from '../index.js'
 import { batchJsonRpc } from '../utils.js'
 
-const MAX_VOTES_PER_CHUNK = 50
+const MAX_VOTES_PER_CHUNK = 25
 const MAX_CAMPAIGNS_PER_CHUNKS = 5
 
 const chunkCampaignsWithVoteLimit = (campaigns: number[], userVotes: any[]) => {

package/src/votemarket/fetchEpochVotes.ts

@@ -2,11 +2,13 @@ import { contracts } from '@stake-dao/constants'
 import { chunk } from 'lodash-es'
 import { encodeAbiParameters, parseAbiParameters } from 'viem'
 import { mainnet } from 'viem/chains'
+import type { BatchMetaData } from '../bytecodes/types.js'
 import batchPendleVotes from '../bytecodes/votemarket/batchPendleVotes.js'
 import batchVotes from '../bytecodes/votemarket/batchVotes.js'
+import batchYbVotes from '../bytecodes/votemarket/batchYbVotes.js'
 import { STAKE_DAO_API } from '../endpoints.js'
 import { concatBytecode } from '../index.js'
-import { batchJsonRpcWithBlocks, equalTlc } from '../utils.js'
+import { batchJsonRpcWithBlocks } from '../utils.js'
 
 type Rpcs = {
   [chainId: number]: string
@@ -37,9 +39,17 @@ export const fetchEpochsVotes = async (rpc: Rpcs, gaugeController: string, user:
   // Merge blocks
   const blocksForEpoch = [...cachedBlocks, ...missingBlocks]
 
-  const batchVotesProtocol = equalTlc(gaugeController, contracts.pendleGaugeController?.[1] || '')
-    ? batchPendleVotes
-    : batchVotes
+  let batchVotesProtocol: BatchMetaData = batchVotes
+  switch (gaugeController.toLowerCase()) {
+    case (contracts.pendleGaugeController?.[1] || '').toLowerCase():
+      batchVotesProtocol = batchPendleVotes
+      break
+    case (contracts.ybGaugeController?.[1] || '').toLowerCase():
+      batchVotesProtocol = batchYbVotes
+      break
+    default:
+      batchVotesProtocol = batchVotes
+  }
 
   const inputData = encodeAbiParameters(parseAbiParameters(batchVotesProtocol.inputType[mainnet.id]!) as any, [
     gaugeController,

package/src/votemarket/generateProofs/config.ts

@@ -20,12 +20,18 @@ export const GaugeControllerConstants = {
       lastUserVote: 1000000010,
       voteUserSlope: 1000000008,
     },
+    yb: {
+      pointWeights: 1000000006,
+      lastUserVote: 1000000005,
+      voteUserSlope: 1000000003,
+    },
   },
   GAUGE_CONTROLLER: {
     curve: '0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB',
     balancer: '0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD',
     frax: '0x3669C421b77340B2979d1A00a792CC2ee0FcE737',
     fxn: '0xe60eB8098B34eD775ac44B1ddE864e098C6d7f37',
+    yb: '0x1Be14811A3a06F6aF4fA64310a636e1Df04c1c21',
   },
 }
 

package/src/votemarket/generateProofs/getGaugeProof.ts

@@ -20,6 +20,13 @@ function getGaugeTimeStorageSlot(gauge: `0x${string}`, time: bigint, baseSlot: n
   return BigInt(finalSlot)
 }
 
+function getGaugeTimeStorageSlotYb(gauge: `0x${string}`, _: bigint, baseSlot: number): bigint {
+  const gaugeEncoded = keccak256(
+    encodeAbiParameters([{ type: 'uint256' }, { type: 'address' }], [BigInt(baseSlot), gauge]),
+  )
+  return BigInt(gaugeEncoded)
+}
+
 // Function to get storage slot for Curve protocol (pre-Vyper 0.3)
 function getGaugeTimeStorageSlotPreVyper03(gauge: `0x${string}`, time: bigint, baseSlot: number): bigint {
   const intermediateHash = _encodeGaugeTime(gauge, time, baseSlot)
@@ -44,6 +51,7 @@ export async function generateGaugeProof(
 
   const positionFunctions: Record<string, any> = {
     curve: getGaugeTimeStorageSlotPreVyper03,
+    yb: getGaugeTimeStorageSlotYb,
     default: getGaugeTimeStorageSlot,
   }
 

package/src/votemarket/generateProofs/getUserProof.ts

@@ -53,10 +53,23 @@ export async function generateUserProof(
   const getPosition = positionFunctions[protocol] || positionFunctions.default
   const voteUserSlopeSlot = getPosition(user, gaugeAddress, voteUserSlopeBaseSlot)
 
+  let index_additionnal_slots = [2n]
+  switch (protocol.toLowerCase()) {
+    case 'yb':
+      index_additionnal_slots = [1n, 3n]
+      break
+    default:
+      index_additionnal_slots = [2n]
+      break
+  }
+
   const voteUserSlopeSlope = voteUserSlopeSlot
-  const voteUserSlopeEnd = voteUserSlopeSlot + 2n
 
-  const slots = [toHex(lastUserVoteSlot), toHex(voteUserSlopeSlope), toHex(voteUserSlopeEnd)]
+  const slots = [toHex(lastUserVoteSlot), toHex(voteUserSlopeSlope)]
+
+  for (const index_additionnal_slot of index_additionnal_slots) {
+    slots.push(toHex(voteUserSlopeSlot + index_additionnal_slot))
+  }
 
   const proof = await publicClient.getProof({
     address: GaugeControllerConstants.GAUGE_CONTROLLER[protocol] as `0x${string}`,

package/src/votemarket/yb/fetchYbUserVotes.ts

@@ -0,0 +1,61 @@
+import { contracts } from '@stake-dao/constants'
+import { encodeAbiParameters, formatUnits, parseAbiParameters, zeroAddress } from 'viem'
+import { mainnet } from 'viem/chains'
+import batchYbUserVotes from '../../bytecodes/votemarket/batchYbUserVotes.js'
+import { concatBytecode } from '../../index.js'
+import { batchJsonRpc, equalTlc } from '../../utils.js'
+
+export type Vote = {
+  gauge: string
+  slope: string
+  relativeWeight: number
+  weight: number
+  start: number
+  end: number
+}
+
+export type GaugesUserData = { veBalance: string; unusedVeBalance: string; unusedRelativeWeight: number; votes: Vote[] }
+
+export const fetchYbUserVotes = async (rpc: string, user: string): Promise<GaugesUserData> => {
+  const calls = [
+    concatBytecode(
+      batchYbUserVotes.bytecode[mainnet.id]!,
+      encodeAbiParameters(parseAbiParameters(batchYbUserVotes.inputType[mainnet.id]!) as any, [
+        user,
+        contracts.ybGaugeController![1]!,
+        contracts.veYB![1]!,
+      ]),
+    ),
+  ]
+
+  const rawVotes = await batchJsonRpc({
+    rpc,
+    calls,
+    outputTypeAbi: batchYbUserVotes.outputType![mainnet.id],
+    parse: false,
+    callsKey: `votemarket/yb/fetchYbUserVotes.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(v.power) / 100,
+      weight: formatUnits((veBalance * BigInt(v.power)) / BigInt(10000), 18),
+      start: Number(v.start),
+      end: Number(v.end),
+    }))
+
+  const unusedRelativeWeight = 10000 - votes.reduce((total, x) => total + x.relativeWeight * 100, 0)
+  const unusedVeBalance = (veBalance * BigInt(unusedRelativeWeight)) / BigInt(10000)
+
+  return {
+    veBalance: formatUnits(veBalance, 18),
+    unusedVeBalance: formatUnits(unusedVeBalance, 18),
+    unusedRelativeWeight: unusedRelativeWeight / 100,
+    votes,
+  }
+}