@stake-dao/reader 0.4.50 → 0.4.52

package/dist/types/votemarket/curve/fetchUserVlCvxClaimable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchUserVlCvxClaimable.d.ts","sourceRoot":"","sources":["../../../../src/votemarket/curve/fetchUserVlCvxClaimable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAyB,MAAM,MAAM,CAAA;AAO1D,KAAK,IAAI,GAAG;IACV,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;CAC1B,CAAA;AAkGD,eAAO,MAAM,uBAAuB,aAAoB,GAAG,OAAO,IAAI,QAAQ,MAAM;;;;;;;mBAT1C,OAAO;;iBA6EhD,CAAA"}
+{"version":3,"file":"fetchUserVlCvxClaimable.d.ts","sourceRoot":"","sources":["../../../../src/votemarket/curve/fetchUserVlCvxClaimable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAyB,MAAM,MAAM,CAAA;AAO1D,KAAK,IAAI,GAAG;IACV,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;CAC1B,CAAA;AAuGD,eAAO,MAAM,uBAAuB,aAAoB,GAAG,OAAO,IAAI,QAAQ,MAAM;;;;;;;mBAT1C,OAAO;;iBA6EhD,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stake-dao/reader",
   "description": "",
-  "version": "0.4.50",
+  "version": "0.4.52",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",
@@ -36,7 +36,7 @@
     "graphql-request": "^6.0.0",
     "lodash-es": "^4.17.21",
     "viem": "^2.9.31",
-    "@stake-dao/constants": "0.4.22"
+    "@stake-dao/constants": "0.4.23"
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.12"

package/src/abis/passiveVaultsMulticall.ts

@@ -0,0 +1,56 @@
+const passiveVaultsMulticall = [
+  {
+    constant: true,
+    inputs: [],
+    name: 'totalSupply',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'getPricePerFullShare',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
+    name: 'balanceOf',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'withdrawalFee',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'performanceFee',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    name: 'working_balances',
+    outputs: [{ type: 'uint256', name: '' }],
+    inputs: [{ type: 'address', name: 'arg0' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+]
+
+export default passiveVaultsMulticall

package/src/index.ts

@@ -48,6 +48,9 @@ export { buildPancakeSwapErc20Strategies } from './strategies/pancakeswap/buildE
 export { computePositionData } from './strategies/pancakeswap/fetch/pancakePositions.js'
 export { getPancakeV3Positions } from './strategies/pancakeswap/fetch/getPancakeV3Positions.js'
 
+// Passive
+export { fetchPassive } from './strategies/passive/fetch.js'
+
 // Pendle
 export { fetchPendle } from './strategies/pendle/fetch.js'
 export { buildPendleStrategies } from './strategies/pendle/build.js'

package/src/lockers/utils/getBribesRewardsData.ts

@@ -30,6 +30,7 @@ const getBribesRewardsData = (
     { id: 'cake', value: bribesData?.[delegationWithId('cake')!] / 100 || 0 },
     { id: 'pendle', value: bribesData?.[delegationWithId('pendle')!] / 100 || 0 },
     { id: 'fxn', value: bribesData?.[delegationWithId('fxn')!] / 100 || 0 },
+    { id: 'apw', value: bribesData?.[delegationWithId('apw')!] / 100 || 0 },
   ]
 
   // Vote incentives APR

package/src/prices.ts

@@ -109,21 +109,21 @@ interface TokenToFetch {
 }
 
 export const getPrices = async (tokens: TokenToFetch[], chainId = 1): Promise<Price[]> => {
-  let pricesFromLlama: Price[] = []
+  let pricesFromGecko: Price[] = []
   if (tokens.length > 0) {
-    pricesFromLlama = pricesFromLlama.concat(await getPricesFromLlama(tokens, chainId))
+    pricesFromGecko = pricesFromGecko.concat(await getPricesFromGeckoTerminal(tokens, chainId))
   }
 
-  const pricesToFetchFromGecko = tokens
+  const pricesToFetchFromLlama = tokens
     .map((t) => {
-      const coinPrice = pricesFromLlama.find((pl) => equalTlc(pl.address, t.address))?.usdPrice || 0
+      const coinPrice = pricesFromGecko.find((pl) => equalTlc(pl.address, t.address))?.usdPrice || 0
       return coinPrice === 0 ? t : undefined
     })
     .filter(Boolean)
 
-  let pricesFromGecko: Price[] = []
-  if (pricesToFetchFromGecko.length > 0) {
-    pricesFromGecko = pricesFromGecko.concat(await getPricesFromGeckoTerminal(pricesToFetchFromGecko, chainId))
+  let pricesFromLlama: Price[] = []
+  if (tokens.length > 0) {
+    pricesFromLlama = pricesFromLlama.concat(await getPricesFromLlama(pricesToFetchFromLlama, chainId))
   }
 
   return [pricesFromLlama, pricesFromGecko].flat().filter((p) => p.usdPrice > 0)

package/src/sdt/fetch.ts

@@ -1,14 +1,15 @@
-import { decodeAbiParameters, formatUnits, parseAbi, parseUnits } from 'viem'
+import { formatUnits, parseAbi, parseUnits } from 'viem'
 
-import { ONE_DAY, type Token, Zero, contracts, explorers, tokenWithId } from '@stake-dao/constants'
+import { ONE_DAY, type Token, contract, tokenWithId } from '@stake-dao/constants'
+import { mainnet } from 'viem/chains'
 import { type Price } from '../prices.js'
-import { multicall } from '../utils.js'
+import { equalTlc, multicall } from '../utils.js'
+import { getLogsFromEtherscan } from '../utils/etherscan.js'
+import getAverageYearlyRewards from '../utils/getAverageYearlyRewards.js'
 import veSdtAlternativeYields from './veSdtAlternativeYields.js'
 
-const CHECKPOINT_EVENTS_ENDPOINT = (fromBlock: number, apiKey: string) =>
-  `https://api.${
-    explorers[1].url
-  }/api?module=logs&action=getLogs&fromBlock=${fromBlock}&address=${contracts.veSdtFeeDistributor![1]!}&topic0=0xce749457b74e10f393f2c6b1ce4261b78791376db5a3f501477a809f03f500d6&apikey=${apiKey}`
+const NB_EVENTS_TO_USE = 5
+const EVENT_TOPIC = '0xce749457b74e10f393f2c6b1ce4261b78791376db5a3f501477a809f03f500d6'
 
 interface TFetchSdt {
   provider: any
@@ -22,26 +23,41 @@ export const fetchSdt = async ({ provider, prices, explorerApiKey }: TFetchSdt)
   const frax3CrvToken = tokenWithId('frax3crv') as Token
 
   const now = Math.ceil(new Date().getTime() / 1000)
-  const lastCheck = now - ONE_DAY * 28
+  const lastCheck = now - ONE_DAY * 60
   const lastCheckBlock = await (await fetch(`https://coins.llama.fi/block/ethereum/${lastCheck}`)).json()
 
-  const checkpoints = await (await fetch(CHECKPOINT_EVENTS_ENDPOINT(lastCheckBlock.height, explorerApiKey))).json()
+  let amountPerYear = 0
+
+  try {
+    const rawEventsData = await getLogsFromEtherscan({
+      chainId: mainnet.id,
+      address: contract('veSdtFeeDistributor'),
+      apikey: explorerApiKey,
+      extraQueryParams: {
+        fromBlock: `${lastCheckBlock.height}`,
+        topic0: EVENT_TOPIC,
+      },
+    })
+    amountPerYear = await getAverageYearlyRewards(rawEventsData, NB_EVENTS_TO_USE)
+  } catch {
+    amountPerYear = 0
+  }
 
   const rawSdtData: any = await multicall(
     provider,
     [
-      { address: contracts.sdFrx3CrvVault![1]!, name: 'getPricePerFullShare' },
-      { address: sdtToken.address, name: 'balanceOf', params: [contracts.veSdt![1]!] },
-      { address: sdtToken.address, name: 'balanceOf', params: [contracts.vestedSdt![1]!] },
+      { address: contract('sdFrx3CrvVault'), name: 'getPricePerFullShare' },
+      { address: sdtToken.address, name: 'balanceOf', params: [contract('veSdt')] },
+      { address: sdtToken.address, name: 'balanceOf', params: [contract('vestedSdt')] },
       { address: sdtToken.address, name: 'totalSupply' },
-      { address: contracts.veSdt![1]!, name: 'totalSupply' },
+      { address: contract('veSdt'), name: 'totalSupply' },
       {
-        address: contracts.veSdtBoostDelegation![1]!,
+        address: contract('veSdtBoostDelegation'),
         name: 'received_balance',
-        params: [contracts.voteBoosterStrategy![1]!],
+        params: [contract('voteBoosterStrategy')],
       },
-      { address: contracts.liquidLockersGaugeController![1]!, name: 'get_total_weight' },
-      { address: contracts.sdGaugeController![1]!, name: 'get_total_weight' },
+      { address: contract('liquidLockersGaugeController'), name: 'get_total_weight' },
+      { address: contract('sdGaugeController'), name: 'get_total_weight' },
     ],
     parseAbi([
       'function getPricePerFullShare() external view returns (uint256)',
@@ -59,55 +75,28 @@ export const fetchSdt = async ({ provider, prices, explorerApiKey }: TFetchSdt)
   const veSdtTotalSupply = rawSdtData[4].result
   const voteBoosterVeSdt = rawSdtData[5].result
 
-  const sdtPrice = prices?.find((p) => p.address.toLowerCase() === sdtToken.address.toLowerCase())?.usdPrice || 0
-  const frax3CrvPrice =
-    prices?.find((p) => p.address.toLowerCase() === frax3CrvToken.address.toLowerCase())?.usdPrice || 0
+  const sdtPrice = prices.find((p) => equalTlc(p.address, sdtToken.address))?.usdPrice || 0
+  const frax3CrvPrice = prices.find((p) => equalTlc(p.address, frax3CrvToken.address))?.usdPrice || 0
 
   const lockedInUsd = parseUnits(`${sdtPrice}`, sdtToken.decimals) * lockedSdtBalance
   const vestedInUsd = parseUnits(`${sdtPrice}`, sdtToken.decimals) * vestedSdtBalance
   const percentLocked = parseUnits(formatUnits(lockedSdtBalance, 0), sdtToken.decimals) / sdtTotalSupply
   const averageLock = (parseUnits(formatUnits(veSdtTotalSupply, 0), sdtToken.decimals) / lockedSdtBalance) * BigInt(4)
 
-  let rewardsAmount = Zero
-  let checkedTimestamp = now - ONE_DAY * 7
-
-  let apr = 0
-  if (checkpoints && checkpoints.message === 'OK') {
-    const checkpointsData = checkpoints.result.map((r) => {
-      const [eventTimestamp, eventAmount] = decodeAbiParameters(
-        [
-          { type: 'uint256', name: 'timestamp' },
-          { type: 'uint256', name: 'amount' },
-        ],
-        r.data,
-      )
-
-      return { ts: Number(eventTimestamp), amount: eventAmount }
-    })
-
-    while (lastCheck <= checkedTimestamp && rewardsAmount === Zero) {
-      const checkedWeek = checkpointsData ? checkpointsData.filter((d: any) => checkedTimestamp < d.ts) : null
-      rewardsAmount = checkedWeek ? checkedWeek.reduce((total, d) => total + d.amount, Zero) : Zero
-      checkedTimestamp = checkedTimestamp - ONE_DAY * 7
-    }
-
-    apr =
-      ((frax3CrvPrice * Number(formatUnits(rewardsAmount, 18)) * 52) / Number(formatUnits(lockedInUsd, 18))) *
-      Number(vaultRatio)
-  }
+  const apr = ((frax3CrvPrice * amountPerYear) / Number(formatUnits(lockedInUsd, 18))) * Number(vaultRatio)
 
   const parsedData = {
     alternativeYields: veSdtAlternativeYields,
-    veSdtTotalSupply: formatUnits(veSdtTotalSupply, 0),
-    locked: formatUnits(lockedSdtBalance, 0),
+    veSdtTotalSupply: Number(formatUnits(veSdtTotalSupply, 18)),
+    locked: Number(formatUnits(lockedSdtBalance, sdtToken.decimals)),
     lockedInUsd: Number(formatUnits(lockedInUsd, sdtToken.decimals * 2)),
     vestedInUsd: Number(formatUnits(vestedInUsd, sdtToken.decimals * 2)),
     percentLocked: Number(formatUnits(percentLocked, 18)) * 100,
     averageLockInYears: Number(formatUnits(averageLock, 18)),
     apr: apr * 100,
     voteBoosterVeSdt: Number(formatUnits(voteBoosterVeSdt, sdtToken.decimals)),
-    lockersTotalWeight: formatUnits(rawSdtData[6].result, 0),
-    stratsTotalWeight: formatUnits(rawSdtData[7].result, 0),
+    lockersTotalWeight: Number(formatUnits(rawSdtData[6].result, sdtToken.decimals * 2)),
+    stratsTotalWeight: Number(formatUnits(rawSdtData[7].result, sdtToken.decimals * 2)),
   }
 
   return parsedData

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

@@ -215,7 +215,6 @@ export function mostSignificantBit(x: bigint): number {
   let msb = 0
   for (const [power, min] of POWERS_OF_2) {
     if (x >= min) {
-      // eslint-disable-next-line operator-assignment
       x = x >> BigInt(power)
       msb += power
     }
@@ -240,9 +239,7 @@ function getTickAtSqrtRatio(sqrtRatioX96: bigint): number {
   for (let i = 0; i < 14; i++) {
     r = (r * r) >> BigInt(127)
     const f = r >> BigInt(128)
-    // eslint-disable-next-line operator-assignment
     log_2 = log_2 | (f << BigInt(63 - i))
-    // eslint-disable-next-line operator-assignment
     r = r >> f
   }
 

package/src/strategies/passive/fetch.ts

@@ -0,0 +1,97 @@
+import { formatUnits } from 'viem'
+
+import multicallPassiveVaultsAbi from '../../abis/passiveVaultsMulticall.js'
+import { contract, passiveStrats } from '@stake-dao/constants'
+import { multicall } from '../../utils.js'
+import { mainnet } from 'viem/chains'
+import { getPassiveHttpCalls } from './httpCalls.js'
+import { getBoost } from '../utils/boost.js'
+
+interface TFetchPassive {
+  provider: any
+  chainId: number
+}
+
+const vaultCalls = (vaultAddress: string, strategyAddress: string, gaugeAddress: string, chainId: number) =>
+  [
+    { address: vaultAddress, name: 'totalSupply' },
+    { address: vaultAddress, name: 'getPricePerFullShare' },
+    { address: strategyAddress, name: 'performanceFee' },
+    { address: strategyAddress, name: 'withdrawalFee' },
+    chainId === mainnet.id && { address: gaugeAddress, name: 'balanceOf', params: [contract('convexCrvLocker')] },
+    chainId === mainnet.id && {
+      address: gaugeAddress,
+      name: 'working_balances',
+      params: [contract('convexCrvLocker')],
+    },
+  ].filter((c) => c && typeof c !== 'undefined')
+
+export const fetchPassive = async ({ provider, chainId }: TFetchPassive) => {
+  const passive = passiveStrats.strats.filter((s) => s.chainId === chainId)
+  const apisData = await getPassiveHttpCalls(chainId)
+
+  const rawData: any = await multicall(
+    provider,
+    passive.flatMap((s) => vaultCalls(s.vault.address, s.vault.strategy, s.gaugeAddress, chainId)),
+    multicallPassiveVaultsAbi,
+  )
+
+  let currentRawIndex = 0
+  const parsedStratsData = passive.map((s) => {
+    const curveApiRaw = apisData.curveApiData.map((apiResult) =>
+      apiResult.value.find((pool) => pool.lpTokenAddress.toLowerCase() === s.lpToken.address.toLowerCase()),
+    )
+    const indexOfData = curveApiRaw.findIndex((e) => e)
+    const curveApiData = curveApiRaw[indexOfData]
+
+    const subgraphData = apisData.curveSubgraphData.find((el) => el.address === curveApiData.address)
+
+    const lpPriceInUsd = curveApiData.usdTotal / Number(formatUnits(BigInt(curveApiData.totalSupply), 18))
+
+    const totalSupply = Number(formatUnits(rawData[currentRawIndex].result, s.lpToken.decimals))
+    const conversionRate = Number(formatUnits(rawData[currentRawIndex + 1].result, s.lpToken.decimals))
+    const totalSupplyInLpToken = totalSupply * conversionRate
+    const tvl = totalSupplyInLpToken * lpPriceInUsd
+    const perfFee = rawData[currentRawIndex + 2].result
+    const withdrawalFee = rawData[currentRawIndex + 3].result
+    const boost =
+      chainId === 1 ? getBoost('curve', rawData[currentRawIndex + 4].result, rawData[currentRawIndex + 5].result) : 1
+    const aprWithBoost = curveApiData.gaugeCrvApy?.[0] && boost ? curveApiData.gaugeCrvApy[0] * boost : 0
+
+    currentRawIndex += vaultCalls('', '', '', chainId).length
+
+    const apy = subgraphData.latestWeeklyApy ? Number(subgraphData.latestWeeklyApy) + aprWithBoost : 0
+
+    return {
+      ...s,
+      tradingApy: subgraphData.latestWeeklyApy,
+      minApy: curveApiData.gaugeCrvApy ? curveApiData.gaugeCrvApy[0] : 0,
+      maxApy: curveApiData.gaugeCrvApy ? curveApiData.gaugeCrvApy[1] : 0,
+      lpPriceInUsd,
+      tvl,
+      apr: {
+        boost,
+        current: {
+          total: apy,
+          details: [{ label: 'Trading Fees + Rewards (APY)', value: [apy] }],
+        },
+      },
+      stratsData: {
+        boost,
+        accumulatedFees: '0',
+        keeperFee: '0',
+        veSDTFee: '0',
+        accumulatorFee: '0',
+        claimerFee: '0',
+        perfFee: formatUnits(perfFee, 0),
+        withdrawalFee: formatUnits(withdrawalFee, 0),
+      },
+    }
+  })
+
+  return {
+    deployed: parsedStratsData,
+    notDeployed: [],
+    fetched: true,
+  }
+}

package/src/strategies/passive/httpCalls.ts

@@ -0,0 +1,42 @@
+import { CURVE_API_URL } from '../curve/endpoints.js'
+
+export const getPassiveHttpCalls = async (chainId: number) => {
+  switch (chainId) {
+    case 1: {
+      const ethHttpCalls = [
+        // Curve Apis
+        (await fetch(`${CURVE_API_URL}/getPools/ethereum/main`)).json(),
+        (await fetch(`${CURVE_API_URL}/getSubgraphData/ethereum`)).json(),
+      ]
+
+      const ethHttpResponses = await Promise.all(ethHttpCalls)
+
+      const ethCurveMain = ethHttpResponses[0].data.poolData
+      const ethCurveSubgraph = ethHttpResponses[1].data.poolList
+
+      return {
+        curveSubgraphData: ethCurveSubgraph,
+        curveApiData: [{ type: 'main', value: ethCurveMain }],
+      }
+    }
+    case 137: {
+      const polygonHttpCalls = [
+        // Curve Apis
+        (await fetch(`${CURVE_API_URL}/getPools/polygon/main`)).json(),
+        (await fetch(`${CURVE_API_URL}/getSubgraphData/polygon`)).json(),
+      ]
+
+      const polygonHttpResponses = await Promise.all(polygonHttpCalls)
+
+      const polygonCurveMain = polygonHttpResponses[0].data.poolData
+      const polygonCurveSubgraph = polygonHttpResponses[1].data.poolList
+
+      return {
+        curveSubgraphData: polygonCurveSubgraph,
+        curveApiData: [{ type: 'main', value: polygonCurveMain }],
+      }
+    }
+  }
+
+  return { curveSubgraphData: undefined, curveApiData: [] }
+}

package/src/utils/etherscan.ts

@@ -0,0 +1,21 @@
+interface GetLogsFromEtherscanArgs {
+  chainId: number
+  address: string
+  apikey: string
+  rawQueryParams?: { [key: string]: string }
+  extraQueryParams?: { [key: string]: string }
+}
+
+export const getLogsFromEtherscan = async ({
+  chainId,
+  address,
+  apikey,
+  rawQueryParams,
+  extraQueryParams = {},
+}: GetLogsFromEtherscanArgs) => {
+  const queryParams = rawQueryParams
+    ? rawQueryParams
+    : { chainid: `${chainId}`, module: 'logs', action: 'getLogs', address, apikey, ...extraQueryParams }
+
+  return fetch(`https://api.etherscan.io/v2/api?${new URLSearchParams(queryParams)}`).then((res) => res.json())
+}

package/src/utils/getAverageYearlyRewards.ts

@@ -0,0 +1,53 @@
+import { ONE_YEAR, Zero } from '@stake-dao/constants'
+import { decodeAbiParameters, formatUnits } from 'viem'
+
+const decodeEvent = (rawEventsData: any) => {
+  return rawEventsData.result?.map((event) => {
+    const [eventTimestamp, eventAmount] = decodeAbiParameters(
+      [
+        { type: 'uint256', name: 'timestamp' },
+        { type: 'uint256', name: 'amount' },
+      ],
+      event.data,
+    )
+
+    return { eventTimestamp: Number(eventTimestamp), eventAmount }
+  })
+}
+
+const decodeEventWithRewardToken = (rawEventsData: any) => {
+  return rawEventsData.result?.map((event) => {
+    const [eventTimestamp, eventRewardToken, eventAmount] = decodeAbiParameters(
+      [
+        { type: 'uint256', name: 'timestamp' },
+        { type: 'address', name: 'rewardToken' },
+        { type: 'uint256', name: 'amount' },
+      ],
+      event.data,
+    )
+
+    return { eventTimestamp: Number(eventTimestamp), eventAmount, eventRewardToken }
+  })
+}
+
+const getAverageYearlyRewards = async (rawEventsData: any, nbEvents: number, withRewardToken?: boolean) => {
+  const eventsData = (withRewardToken ? decodeEventWithRewardToken(rawEventsData) : decodeEvent(rawEventsData))
+    .filter((event) => event.eventAmount > Zero)
+    .sort((a, b) => b.eventTimestamp - a.eventTimestamp)
+
+  const amountPerYear =
+    eventsData
+      .slice(0, nbEvents)
+      .map((_, index) => {
+        const duration = eventsData[index].eventTimestamp - eventsData[index + 1].eventTimestamp
+        const amount = Number(formatUnits(eventsData[index].eventAmount, 18))
+
+        // Annualized Reward
+        return (amount / duration) * ONE_YEAR
+      })
+      .reduce((total, x) => (total += x), 0) / nbEvents
+
+  return amountPerYear
+}
+
+export default getAverageYearlyRewards

package/src/utils.ts

@@ -1,7 +1,7 @@
 import { RPC, tokens } from '@stake-dao/constants'
 import type { Token } from '@stake-dao/constants'
 import { request } from 'graphql-request'
-import { groupBy } from 'lodash-es'
+import { chunk, groupBy } from 'lodash-es'
 import {
   http,
   type Address,
@@ -121,23 +121,27 @@ export const rpcCall = async (rpc: string, params: RpcCallArgs[]) => {
   return request
 }
 
-export const ethGetTxsReceipts = async (rpc: string, txHashes: string[]) => {
-  const request = (
-    await fetch(rpc, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(
-        txHashes.map((txHash, index) => ({
-          id: index,
-          jsonrpc: '2.0',
-          method: 'eth_getTransactionReceipt',
-          params: [txHash],
-        })),
-      ),
-    })
-  ).json()
+export const ethGetTxsReceipts = async (rpc: string, txHashes: string[], maxSize: number = 100) => {
+  const chunkedTxHashes = chunk(txHashes, maxSize)
 
-  return request
+  const receiptsRequests = await Promise.all(
+    chunkedTxHashes.map((txs) =>
+      fetch(rpc, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(
+          txs.map((txHash, index) => ({
+            id: index,
+            jsonrpc: '2.0',
+            method: 'eth_getTransactionReceipt',
+            params: [txHash],
+          })),
+        ),
+      }).then((res) => res.json()),
+    ),
+  )
+
+  return receiptsRequests.flat()
 }
 
 export const ethEstimateGas = async (rpc: string, from: string, to: string, data: string) => {
@@ -289,7 +293,7 @@ export const multichainMulticall = async (calls: MultiChainCall[], abi: readonly
   const callsPerChain = groupBy(calls, (call) => call.chainId)
 
   const chains = Object.keys(callsPerChain)
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
   const parsedCallsPerChain = chains.map((chainId) => callsPerChain[chainId]!.map(({ chainId, ...call }) => call))
 
   const promises = await Promise.allSettled(

package/src/votemarket/curve/config.ts

@@ -40,6 +40,7 @@ export const NOT_LP_GAUGES = {
   427: '0xC91113B4Dd89dd20FDEECDAC82477Bc99A840355',
   428: '0x7ce8aF75A9180B602445bE230860DDcb4cAc3E42',
   473: '0x66EFd8E255B8B7Cf32961E90A5820f289402629e',
+  670: '0x5A537a46D780B1C70138aB98eDce69e7a53177ba',
 }
 
 export const NOT_LP_GAUGES_INDEX = Object.keys(NOT_LP_GAUGES).map((x) => Number(x))

package/src/votemarket/curve/fetchUserVlCvxClaimable.ts

@@ -19,15 +19,20 @@ type UnknownToken = {
 }
 
 const getMerkleData = async (epoch: number) => {
-  const response = await fetch(
-    `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/${epoch}/vlCVX/merkle_data.json`,
-  )
-  if (!response.ok) throw new Error('Failed to fetch merkle data')
-  return response.json()
+  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`,
+    ).then((res) => res.json()),
+  ])
+
+  return { delegators, nonDelegators }
 }
 
 const isRootMatch = (contractRoot: string, fileRoot: string) =>
-  (contractRoot === ZERO_ROOT && fileRoot === ZERO_ROOT) || contractRoot.toLowerCase() === fileRoot.toLowerCase()
+  (contractRoot === ZERO_ROOT && fileRoot === ZERO_ROOT) || equalTlc(contractRoot, fileRoot)
 
 const validateMerkleRoots = (delegatorRoot: string, nonDelegatorRoot: string, merkleData: any) => {
   const delegatorMatches = isRootMatch(delegatorRoot, merkleData.delegators.merkleRoot)
@@ -107,8 +112,8 @@ const getParsedData = (
 const ZERO_ROOT = '0x0000000000000000000000000000000000000000000000000000000000000000'
 
 export const fetchUserVlCvxClaimable = async (provider: any, rpc: Rpcs, user: string) => {
-  const nowEpoch = Math.floor(Date.now() / (1000 * 2 * ONE_WEEK)) * 2 * ONE_WEEK
-  const prevEpoch = nowEpoch - 2 * ONE_WEEK
+  const nowEpoch = Math.floor(Date.now() / 1000 / ONE_WEEK) * ONE_WEEK
+  const prevEpoch = nowEpoch - ONE_WEEK
 
   const { delegatorRoot, nonDelegatorRoot } = await getMerkleRoots(provider)
 
@@ -140,8 +145,8 @@ export const fetchUserVlCvxClaimable = async (provider: any, rpc: Rpcs, user: st
   if (!tokens.length) return []
 
   const [delegatedClaimed, notDelegatedClaimed] = await Promise.all([
-    getClaimedData(provider, tokensDelegated, user, contract('vlCvxDelegatorMerkle', mainnet.id)),
-    getClaimedData(provider, tokensNotDelegated, user, contract('vlCvxNotDelegatorMerkle', mainnet.id)),
+    getClaimedData(provider, tokensDelegated, user, contract('vlCvxDelegatorMerkle')),
+    getClaimedData(provider, tokensNotDelegated, user, contract('vlCvxNotDelegatorMerkle')),
   ])
 
   const unknownTokens = tokens.filter((t) => !tokenWithAddress(t))

package/src/votemarket/fetchPendingRemoteCampaigns.ts

@@ -54,7 +54,7 @@ export const fetchPendingRemoteCampaigns = async ({
           const payload = decodeAbiParameters(
             parseAbiParameters([
               'Payload payload',
-              'struct Payload { uint256 actionType; address sender; bytes parameters }',
+              'struct Payload { uint256 actionType; address sender; address votemarket; bytes parameters }',
             ]),
             decodedEvent.args.message.payload,
           )