@stake-dao/reader 0.4.30 → 0.4.32

package/src/strategies/yearn/build.ts

@@ -1,9 +1,10 @@
-import { chunk, remove, uniq } from 'lodash-es'
+import { chunk } from 'lodash-es'
 import { decodeAbiParameters, encodeAbiParameters, parseAbiParameters } from 'viem'
 
-import { contracts, tokens } from '@stake-dao/constants'
-import type { FetchedToken, Token } from '@stake-dao/constants'
-import { batchSdtGaugeRewards, batchTokenData, buildYearnStrats } from '../../bytecodes/index.js'
+import { contracts } from '@stake-dao/constants'
+import type { FetchedToken } from '@stake-dao/constants'
+import { batchSdtGaugeRewards, buildYearnStrats } from '../../bytecodes/index.js'
+import { fetchTokensData } from '../../tokens.js'
 import { equalTlc, getTokenInfo } from '../../utils.js'
 import type { BuiltStrat } from '../types.js'
 import { concatBytecode } from '../utils/index.js'
@@ -67,22 +68,7 @@ export const buildYearnStrategies = async (
   })
 
   // Fetch tokens infos
-  const tokensInputArgsChunks = chunk(
-    remove(uniq(tokensToFetch), (t) => !tokens.find((token: Token) => token.address === t)),
-    40,
-  )
-  const decodedPromise = await Promise.allSettled(
-    tokensInputArgsChunks.map(async (inputArgs) => {
-      const inputData = encodeAbiParameters(parseAbiParameters(batchTokenData.inputType || []) as any, [inputArgs])
-      const contractCreationCode = concatBytecode(batchTokenData.bytecode, inputData)
-      const returnedData = await provider.call({
-        data: contractCreationCode,
-      })
-      return decodeAbiParameters(parseAbiParameters(batchTokenData.outputTypeHr || []) as any, returnedData.data)
-    }),
-  )
-
-  const fetchedTokenData = decodedPromise.flatMap((d) => (d.status === 'fulfilled' ? d.value : [])).flat()
+  const fetchedTokenData = await fetchTokensData(provider, tokensToFetch)
 
   // Fetch Sdt Gauge rewards tokens infos
   const sdtGaugeInputArgsChunks = chunk(

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

@@ -1,7 +1,7 @@
 import { chunk } from 'lodash-es'
 import { formatUnits } from 'viem'
 
-import { ONE_YEAR, yearnStrats } from '@stake-dao/constants'
+import { ONE_YEAR, OneEther, Zero, yearnStrats } from '@stake-dao/constants'
 import multicallYearnStratsAbi from '../../../abis/yearnVaultsMulticall.js'
 import { equalTlc, multicall } from '../../../utils.js'
 import { NEW_FACTORY_EXPLORER_EVENTS } from '../../curve/endpoints.js'
@@ -14,7 +14,7 @@ import type { Price } from '../../../prices.js'
 import { type SdtEmissionData, getSdtApr } from '../../../sdt.js'
 import type { RewardsData, StrategyData, ValidChainId, ValidExplorer } from '../../types.js'
 import { getAprBreakdown } from '../../utils/getAprBreakdown.js'
-import { OneEther, Zero, decodeNewFactoryEvent } from '../../utils/index.js'
+import { decodeNewFactoryEvent } from '../../utils/index.js'
 import { fetchAllYearnGauges } from './fetchAllYearnGauges.js'
 
 const globalCalls = [

package/src/tokens.ts

@@ -0,0 +1,44 @@
+import { type Token, tokens } from '@stake-dao/constants'
+import { chunk, remove, uniq } from 'lodash-es'
+import { decodeAbiParameters, encodeAbiParameters, parseAbiParameters } from 'viem'
+import { batchTokenData } from './bytecodes/index.js'
+import { batchJsonRpc, concatBytecode } from './utils.js'
+
+export const fetchTokensData = async (provider: any, tokensToFetch: string[]) => {
+  const inputArgsChunks = chunk(
+    remove(uniq(tokensToFetch), (t) => !tokens.find((token: Token) => token.address === t)),
+    40,
+  )
+  const decodedPromise = await Promise.allSettled(
+    inputArgsChunks.map(async (inputArgs) => {
+      const inputData = encodeAbiParameters(parseAbiParameters(batchTokenData.inputType || []) as any, [inputArgs])
+      const contractCreationCode = concatBytecode(batchTokenData.bytecode, inputData)
+      const returnedData = await provider.call({
+        data: contractCreationCode,
+      })
+      return decodeAbiParameters(parseAbiParameters(batchTokenData.outputTypeHr || []) as any, returnedData.data)
+    }),
+  )
+
+  return decodedPromise.flatMap((d) => (d.status === 'fulfilled' ? d.value : [])).flat()
+}
+
+export const rpcFetchTokensData = async (chainId: number, rpc: string, tokensToFetch: string[]) => {
+  if (tokensToFetch.length > 0) {
+    const tokensChunks = chunk(tokensToFetch, 40)
+
+    const tokensCalls = tokensChunks.map((chunk) => {
+      const inputData = encodeAbiParameters(parseAbiParameters(batchTokenData.inputType) as any, [chunk])
+      return concatBytecode(batchTokenData.bytecode, inputData)
+    })
+
+    return await batchJsonRpc({
+      rpc,
+      calls: tokensCalls,
+      outputTypeAbi: batchTokenData.outputTypeHr,
+      callsKey: `tokens.ts: rpcFetchTokensData - chainId ${chainId} - rpc ${rpc}`,
+    })
+  }
+
+  return []
+}

package/src/utils.ts

@@ -2,7 +2,15 @@ import { tokens } from '@stake-dao/constants'
 import type { Token } from '@stake-dao/constants'
 import { request } from 'graphql-request'
 import { groupBy } from 'lodash-es'
-import { http, createPublicClient, decodeAbiParameters, extractChain, parseAbiParameters, toHex } from 'viem'
+import {
+  http,
+  type Address,
+  createPublicClient,
+  decodeAbiParameters,
+  extractChain,
+  parseAbiParameters,
+  toHex,
+} from 'viem'
 import * as viemChains from 'viem/chains'
 import { withTwoDec } from './number.js'
 
@@ -124,37 +132,41 @@ export interface BatchJsonRpcArgs {
 export const batchJsonRpc = async (args: BatchJsonRpcArgs) => {
   const { rpc, calls, outputTypeAbi, parse = true, callsKey } = args
 
-  const rpcRequests = await (
-    await fetch(rpc, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(
-        calls.map((calldata, index) => ({
-          id: index,
-          jsonrpc: '2.0',
-          method: 'eth_call',
-          params: [{ data: calldata }, 'latest'],
-        })),
-      ),
-    })
-  ).json()
+  if (calls.length > 0) {
+    const rpcRequests = await (
+      await fetch(rpc, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(
+          calls.map((calldata, index) => ({
+            id: index,
+            jsonrpc: '2.0',
+            method: 'eth_call',
+            params: [{ data: calldata }, 'latest'],
+          })),
+        ),
+      })
+    ).json()
 
-  const rpcResults = rpcRequests.map((res: any, index: number) => {
-    const isError = Object.keys(res).includes('error')
-    const abi = Array.isArray(outputTypeAbi[0]) ? outputTypeAbi[index] : outputTypeAbi
-    const status = isError ? 'error' : 'fulfilled'
-    const value = isError
-      ? `${callsKey} call index ${index}: code ${res.error.code}\n${res.error.message}`
-      : decodeAbiParameters(parse ? (parseAbiParameters(abi) as any) : abi, res.result)
+    const rpcResults = rpcRequests.map((res: any, index: number) => {
+      const isError = Object.keys(res).includes('error')
+      const abi = Array.isArray(outputTypeAbi[0]) ? outputTypeAbi[index] : outputTypeAbi
+      const status = isError ? 'error' : 'fulfilled'
+      const value = isError
+        ? `${callsKey} call index ${index}: code ${res.error.code}\n${res.error.message}`
+        : decodeAbiParameters(parse ? (parseAbiParameters(abi) as any) : abi, res.result)
 
-    if (isError) {
-      console.error(value)
-    }
+      if (isError) {
+        console.error(value)
+      }
 
-    return { status, value }
-  })
+      return { status, value }
+    })
+
+    return rpcResults.flatMap((r) => (r.status === 'fulfilled' ? r.value[0] : []))
+  }
 
-  return rpcResults.flatMap((r) => (r.status === 'fulfilled' ? r.value[0] : []))
+  return []
 }
 
 interface BatchJsonRpcWithBlocksArgs {
@@ -210,7 +222,7 @@ export interface Call {
 
 export const multicall = async (provider: any, calls: Call[], abi: readonly any[]) => {
   const contracts = calls.map((c) => ({
-    address: c.address as `0x${string}`,
+    address: c.address as Address,
     abi,
     functionName: c.name,
     args: c.params ? c.params : [],

package/src/votemarket/curve/config.ts

@@ -1,7 +1,18 @@
 import { lc } from '../../utils.js'
 
 export const GAUGES_CHUNK_SIZE = 30
-export const GAUGES_METADATA_CHUNK_SIZE = 10
+export const GAUGES_METADATA_CHUNK_SIZE = {
+  1: 10,
+  10: 10,
+  100: 10,
+  137: 10,
+  250: 10,
+  252: 10,
+  8453: 10,
+  42161: 10,
+  42220: 10,
+  43114: 10,
+}
 
 export const NOT_LP_GAUGES = {
   42: '0xb9C05B8EE41FDCbd9956114B3aF15834FDEDCb54',

package/src/votemarket/curve/fetchCurveGauges.ts

@@ -61,6 +61,7 @@ export const fetchCurveGauges = async (rpc: Rpcs): Promise<GaugesData> => {
 
   const gauges = rawGauges.map((g) => ({
     gauge: g.gauge,
+    childGauge: g.childGauge,
     weight: formatUnits(g.weight, 0),
     relativeWeight: formatUnits(g.relativeWeight, 0),
     futureRelativeWeight: formatUnits(g.futureRelativeWeight, 0),
@@ -76,10 +77,10 @@ export const fetchCurveGauges = async (rpc: Rpcs): Promise<GaugesData> => {
 
   for (const chainId of Object.keys(gaugesPerChain)) {
     const chainGauges = gaugesPerChain[chainId]!
-    const chunkedChainGauges = chunk(chainGauges, GAUGES_METADATA_CHUNK_SIZE)
+    const chunkedChainGauges = chunk(chainGauges, GAUGES_METADATA_CHUNK_SIZE[chainId])
 
     const gaugesMetadataCalls = chunkedChainGauges.map((gaugeObj) => {
-      const inputParams = [gaugeObj.map((g) => g.gauge)]
+      const inputParams = [gaugeObj.map((g) => g.childGauge)]
 
       const inputData = encodeAbiParameters(
         parseAbiParameters(batchCurveGaugesMetadata.inputType[0]!) as any,
@@ -107,7 +108,7 @@ export const fetchCurveGauges = async (rpc: Rpcs): Promise<GaugesData> => {
   const gaugesLpWithMissingCoins: string[] = []
 
   const parsedGauges = filteredGauges.map((g) => {
-    const gaugeMetadata = gaugesMetadata.find((gm) => equalTlc(gm.gauge, g.gauge))
+    const gaugeMetadata = gaugesMetadata.find((gm) => equalTlc(gm.gauge, g.childGauge))
     const filteredCoins = gaugeMetadata.coins.filter((c) => c._address !== zeroAddress)
 
     const name = gaugeMetadata.lp.name
@@ -123,6 +124,7 @@ export const fetchCurveGauges = async (rpc: Rpcs): Promise<GaugesData> => {
 
     return {
       gauge: g.gauge,
+      childGauge: g.childGauge,
       manager: gaugeMetadata.manager,
       name,
       weight: g.weight,

package/src/votemarket/curve/fetchCurveUserVotes.ts

@@ -28,7 +28,7 @@ export const fetchCurveUserVotes = async (rpc: string, user: string): Promise<Ga
     calls,
     outputTypeAbi: batchCurveUserVotes.outputType![mainnet.id],
     parse: false,
-    callsKey: `votemarket/curve/fetchCurveUserVotes.ts: rawGauges - chainId ${mainnet.id} - rpc ${rpc[mainnet.id]}`,
+    callsKey: `votemarket/curve/fetchCurveUserVotes.ts: rawGauges - chainId ${mainnet.id} - rpc ${rpc}`,
   })
 
   const veBalance = rawVotes[0].veBalance

package/src/votemarket/curve/fetchUserVlCvxClaimable.ts

@@ -0,0 +1,132 @@
+import { ONE_WEEK, Zero, contract, tokenWithAddress } from '@stake-dao/constants'
+import { type Address, formatUnits, parseAbi } from 'viem'
+import { mainnet } from 'viem/chains'
+import { GH_STAKE_DAO_BOUNTIES_REPORT } from '../../endpoints.js'
+import { type Price, getPrices } from '../../prices.js'
+import { rpcFetchTokensData } from '../../tokens.js'
+import { equalTlc, multicall } from '../../utils.js'
+
+type Rpcs = {
+  [chainId: number]: string
+}
+
+type UnknownToken = {
+  name: string
+  symbol: string
+  address: string
+  decimals: number
+  chainId: number
+}
+
+const getMerkleData = async (epoch: number) => {
+  return await fetch(
+    `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/${epoch}/vlCVX/merkle_data.json`,
+  ).then((res) => res.json())
+}
+
+const getClaimedData = async (provider: any, tokens: string[], user: string, contract: string) => {
+  const rawClaimed =
+    tokens.length > 0
+      ? await multicall(
+          provider,
+          tokens.map((t) => ({
+            address: contract,
+            name: 'claimed',
+            params: [user, t],
+          })),
+          parseAbi(['function claimed(address,address) external view returns (uint256)']),
+        )
+      : []
+
+  return tokens.map((t, index) => ({
+    token: t,
+    claimed: rawClaimed[index].result,
+  }))
+}
+
+const getParsedData = (
+  merkleAddress: string,
+  userData: any,
+  unknownTokensData: any[],
+  claimedData: any[],
+  prices: Price[],
+) => {
+  return userData
+    ? Object.keys(userData.tokens).map((token) => {
+        const rewardToken = tokenWithAddress(token) || unknownTokensData.find((t) => equalTlc(t.address, token))
+        const tokenPrice = prices.find((p) => equalTlc(token, p.address))?.usdPrice || 0
+
+        const claimed = claimedData.find((c) => equalTlc(c.token, token))?.claimed
+        const claimable = BigInt(userData.tokens[token].amount) - claimed
+
+        return {
+          token: rewardToken,
+          claimable: formatUnits(claimable, 0),
+          claimableUsd: Number(formatUnits(claimable, rewardToken?.decimals || 18)) * tokenPrice,
+          amount: userData.tokens[token].amount,
+          amountUsd:
+            Number(formatUnits(BigInt(userData.tokens[token].amount), rewardToken?.decimals || 18)) * tokenPrice,
+          proof: userData.tokens[token].proof,
+          merkleAddress: merkleAddress as Address,
+          isClaimed: claimable === Zero,
+        }
+      })
+    : undefined
+}
+
+export const fetchUserVlCvxClaimable = async (provider: any, rpc: Rpcs, user: string) => {
+  const nowEpoch = Math.floor(Date.now() / (1000 * ONE_WEEK)) * ONE_WEEK
+
+  let vlCvxClaimable: any
+  try {
+    vlCvxClaimable = await getMerkleData(nowEpoch)
+  } catch {
+    vlCvxClaimable = await getMerkleData(nowEpoch - ONE_WEEK)
+  }
+
+  const vlCvxUserDelegated = vlCvxClaimable?.delegators.claims[user]
+  const vlCvxUserNotDelegated = vlCvxClaimable?.nonDelegators.claims[user]
+
+  const tokensDelegated = Object.keys(vlCvxUserDelegated?.tokens || {})
+  const tokensNotDelegated = Object.keys(vlCvxUserNotDelegated?.tokens || {})
+
+  const tokens = [...tokensDelegated, ...tokensNotDelegated]
+
+  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)),
+  ])
+
+  const unknownTokens = tokens.filter((t) => !tokenWithAddress(t))
+  const rawUnknownTokensData = await rpcFetchTokensData(mainnet.id, rpc[mainnet.id]!, unknownTokens)
+  const unknownTokensData: UnknownToken[] = rawUnknownTokensData.map((t) => ({
+    name: t.name,
+    symbol: t.symbol,
+    address: t.tokenAddress,
+    decimals: Number(t.decimals),
+    chainId: mainnet.id,
+  }))
+
+  const prices = await getPrices(tokens.map((t) => ({ address: t })) as any[], mainnet.id)
+
+  return [
+    getParsedData(
+      contract('vlCvxDelegatorMerkle', mainnet.id),
+      vlCvxUserDelegated,
+      unknownTokensData,
+      delegatedClaimed,
+      prices,
+    ),
+    getParsedData(
+      contract('vlCvxNotDelegatorMerkle', mainnet.id),
+      vlCvxUserNotDelegated,
+      unknownTokensData,
+      notDelegatedClaimed,
+      prices,
+    ),
+  ]
+    .filter(Boolean)
+    .flat()
+}

package/src/votemarket/fetchCampaigns.ts

@@ -1,12 +1,11 @@
-import { ONE_WEEK, RPC, contracts, tokenWithAddress, tokens } from '@stake-dao/constants'
-import { chunk, filter, range, remove, uniq } from 'lodash-es'
+import { ONE_WEEK, RPC, Zero, contract, contracts, tokenWithAddress, tokens } from '@stake-dao/constants'
+import { filter, range, remove, uniq } from 'lodash-es'
 import { decodeAbiParameters, encodeAbiParameters, formatUnits, parseAbiParameters, zeroAddress } from 'viem'
 import { mainnet } from 'viem/chains'
-import { batchTokenData } from '../bytecodes/index.js'
 import batchCampaigns from '../bytecodes/votemarket/batchCampaigns.js'
 import batchGaugesWeight from '../bytecodes/votemarket/batchGaugesWeight.js'
 import { getPrices } from '../prices.js'
-import { Zero } from '../strategies/utils/index.js'
+import { rpcFetchTokensData } from '../tokens.js'
 import { batchJsonRpc, concatBytecode, equalTlc, rpcCall, rpcGetLastBlockTimetstamp } from '../utils.js'
 import type { Campaign, RawCampaign, RawPeriod } from './types.js'
 
@@ -17,7 +16,7 @@ export const CLOSE_WINDOW_LENGTH = 4 // weeks
 interface FetchCampaignsProps {
   platform: string
   chainId: number
-  rpc: string
+  rpcs: { [chainId: number]: string }
 }
 
 const updateEpoch = ({
@@ -80,7 +79,9 @@ const updateEpoch = ({
   return campaign
 }
 
-export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsProps): Promise<Campaign[]> => {
+export const fetchCampaigns = async ({ platform, chainId, rpcs }: FetchCampaignsProps): Promise<Campaign[]> => {
+  const rpc = rpcs[chainId]!
+
   const block = await rpcGetLastBlockTimetstamp(rpc)
   const nCampaignsRequest = await rpcCall(rpc, [{ to: platform, data: '0x7274e30d' }]) // campaignCount
   const nCampaigns = Number(
@@ -89,7 +90,9 @@ export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsP
 
   const calls = range(0, nCampaigns, CAMPAIGNS_CHUNK_SIZE).map((skip) => {
     const inputParams = [
+      chainId,
       platform,
+      contract('laPosteTokenFactory', chainId),
       skip,
       skip + CAMPAIGNS_CHUNK_SIZE > nCampaigns ? nCampaigns : skip + CAMPAIGNS_CHUNK_SIZE,
     ]
@@ -124,23 +127,7 @@ export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsP
 
   const campaignsTokens: string[] = uniq(rawCampaigns.map((rc) => rc.campaign.rewardToken))
   const tokensToFetch: string[] = remove(campaignsTokens, (t) => !tokenWithAddress(t, chainId))
-
-  let rawTokensData: any[] = []
-  if (tokensToFetch.length > 0) {
-    const tokensChunks = chunk(tokensToFetch, 40)
-
-    const tokensCalls = tokensChunks.map((chunk) => {
-      const inputData = encodeAbiParameters(parseAbiParameters(batchTokenData.inputType) as any, [chunk])
-      return concatBytecode(batchTokenData.bytecode, inputData)
-    })
-
-    rawTokensData = await batchJsonRpc({
-      rpc,
-      calls: tokensCalls,
-      outputTypeAbi: batchTokenData.outputTypeHr,
-      callsKey: `votemarket/fetchCampaigns.ts: rawTokensData - chainId ${chainId} - rpc ${rpc}`,
-    })
-  }
+  const rawTokensData: any[] = tokensToFetch.length > 0 ? await rpcFetchTokensData(chainId, rpc, tokensToFetch) : []
 
   const fetchedTokens: any = [
     ...filter(tokens, (t) => campaignsTokens.find((ct) => equalTlc(ct, t.address))),
@@ -153,21 +140,55 @@ export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsP
     })),
   ]
 
-  // const prices = await getPrices(fetchedTokens as any, chainId)
-  // TMP FOR TEST PURPOSE REMOVE ONCE IN PROD
+  const campaignsNativeTokens: string[] = uniq(
+    rawCampaigns.filter((rc) => Number(rc.rewardChainId) === mainnet.id).map((rc) => rc.rewardAddress),
+  )
+  const nativeTokensToFetch: string[] = remove(campaignsNativeTokens, (t) => !tokenWithAddress(t, mainnet.id))
+  const rawNativeTokensData: any[] =
+    nativeTokensToFetch.length > 0 ? await rpcFetchTokensData(mainnet.id, rpcs[mainnet.id]!, nativeTokensToFetch) : []
+
+  const nativeFetchedTokens: any = [
+    ...filter(tokens, (t) => campaignsNativeTokens.find((ct) => equalTlc(ct, t.address))),
+    ...rawNativeTokensData.map((t) => ({
+      name: t.name,
+      symbol: t.symbol,
+      address: t.tokenAddress,
+      decimals: Number(t.decimals),
+      chainId: mainnet.id,
+    })),
+  ]
+
   const prices = [
-    ...(await getPrices(fetchedTokens as any, chainId)),
-    { address: '0x9E49A0314AE61e9C9E34e4Af62a73FBFfB6DE95A', symbol: 'ARR', usdPrice: 10 },
+    ...(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
   ]
 
+  const allFetchedTokens = [...fetchedTokens, ...nativeFetchedTokens]
+
   const currentTimestamp = block.timestamp
 
   const campaigns = rawCampaigns.map((rc) => {
     const gaugeWeightData = rawGaugesWeights.find((g) => equalTlc(g.gauge, rc.campaign.gauge))
-    const rewardToken = fetchedTokens.find((t) => equalTlc(t.address, rc.campaign.rewardToken) && t.chainId === chainId)
+
+    let receiptRewardToken = undefined
+    let rewardToken = allFetchedTokens.find(
+      (t) => equalTlc(t.address, rc.campaign.rewardToken) && t.chainId === chainId,
+    )
+
+    if (!equalTlc(rewardToken.address, rc.rewardAddress)) {
+      receiptRewardToken = rewardToken
+      rewardToken = allFetchedTokens.find(
+        (t) => equalTlc(t.address, rc.rewardAddress) && t.chainId === Number(rc.rewardChainId),
+      )
+    }
+
     const decimals = rewardToken ? rewardToken.decimals : 18
 
-    const rewardTokenPrice = prices.find((p) => equalTlc(rc.campaign.rewardToken, p.address))?.usdPrice || 0
+    const rewardTokenPrice = prices.find((p) => equalTlc(rc.rewardAddress, p.address))?.usdPrice || 0
 
     const startTimestamp = Number(rc.campaign.startTimestamp)
     const endTimestamp = Number(rc.campaign.endTimestamp)
@@ -194,31 +215,14 @@ export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsP
     const rawCurrentPeriod = rc.periods[indexOfCurrentPeriod]
     const rawPreviousPeriod = rc.periods[indexOfCurrentPeriod - 1]
 
-    // // Simulate previous period update if not updated
-    // if (rc.previousPeriod && !rc.previousPeriod.updated && Number(numberOfPeriods) > Number(rc.periodLeft)) {
-    //   updateEpoch({
-    //     period: rc.previousPeriod,
-    //     campaign: rc.campaign,
-    //     remainingPeriods: Number(rc.periodLeft) + 1,
-    //     totalVotes,
-    //   })
-    // }
-
-    // // Simulate current period update to simulate reward and apr
-    // updateEpoch({
-    //   period: rc.currentPeriod,
-    //   previousPeriod: rc.previousPeriod,
-    //   campaign: rc.campaign,
-    //   remainingPeriods: Number(rc.periodLeft),
-    //   totalVotes,
-    // })
-
     return {
       id: Number(rc.id),
       chainId,
-      gauge: rc.campaign.gauge,
+      rewardChainId: Number(rc.rewardChainId),
       gaugeChainId: Number(rc.campaign.chainId),
+      gauge: rc.campaign.gauge,
       manager: rc.campaign.manager,
+      receiptRewardToken,
       rewardToken,
       rewardTokenPrice,
       numberOfPeriods,
@@ -233,12 +237,14 @@ export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsP
       addresses: rc.addresses,
       isWhitelist: rc.isWhitelistOnly,
       isBlacklist: !rc.isWhitelistOnly && rc.addresses.length > 0,
-      previousPeriod: {
-        rewardPerPeriod: formatUnits(rawPreviousPeriod.rewardPerPeriod, decimals),
-        rewardPerVote: formatUnits(rawPreviousPeriod.rewardPerVote, decimals),
-        leftover: formatUnits(rawPreviousPeriod.leftover, decimals),
-        updated: rawPreviousPeriod.updated,
-      },
+      previousPeriod: rawPreviousPeriod
+        ? {
+            rewardPerPeriod: formatUnits(rawPreviousPeriod.rewardPerPeriod, decimals),
+            rewardPerVote: formatUnits(rawPreviousPeriod.rewardPerVote, decimals),
+            leftover: formatUnits(rawPreviousPeriod.leftover, decimals),
+            updated: rawPreviousPeriod.updated,
+          }
+        : undefined,
       currentPeriod: {
         rewardPerPeriod: formatUnits(rawCurrentPeriod.rewardPerPeriod, decimals),
         rewardPerVote: formatUnits(rawCurrentPeriod.rewardPerVote, decimals),

package/src/votemarket/fetchClaimableData.ts

@@ -1,18 +1,15 @@
-import { arbitrum } from '@stake-dao/constants'
 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'
 
-type Rpcs = {
-  [chainId: number]: string
-}
-
 const CLAIMABLE_CHUNK_SIZE = 10
 
 export const fetchClaimableData = async (
-  rpc: Rpcs,
+  chainId: number,
+  rpc: string,
   platform: string,
   user: string,
   campaigns: number[],
@@ -22,20 +19,18 @@ export const fetchClaimableData = async (
   const inputVotesChunks = chunk(userVotes, CLAIMABLE_CHUNK_SIZE)
 
   const claimableCalls = inputCampaignsChunks.map((campaignsArgs, index) => {
-    const inputData = encodeAbiParameters(parseAbiParameters(batchClaimableData.inputType[arbitrum.id]!) as any, [
-      platform,
-      user,
-      campaignsArgs,
-      inputVotesChunks[index],
-    ])
-    return concatBytecode(batchClaimableData.bytecode[arbitrum.id]!, inputData)
+    const inputData = encodeAbiParameters(
+      parseAbiParameters(batchClaimableData.inputType[chainId] || batchClaimableData.inputType[arbitrum.id]!) as any,
+      [platform, user, campaignsArgs, inputVotesChunks[index]],
+    )
+    return concatBytecode(batchClaimableData.bytecode[chainId] || batchClaimableData.bytecode[arbitrum.id]!, inputData)
   })
 
   const claimable = await batchJsonRpc({
-    rpc: rpc[arbitrum.id]!,
+    rpc,
     calls: claimableCalls,
-    outputTypeAbi: batchClaimableData.outputTypeHr[arbitrum.id],
-    callsKey: `Batch claimable data - chainId ${arbitrum.id} - rpc ${rpc[arbitrum.id]}`,
+    outputTypeAbi: batchClaimableData.outputTypeHr[chainId] || batchClaimableData.outputTypeHr[arbitrum.id]!,
+    callsKey: `Batch claimable data - chainId ${chainId} - rpc ${rpc}`,
   })
 
   return claimable.map((c) => ({

package/src/votemarket/generateProofs/getBlockProof.ts

@@ -1,3 +1,4 @@
+import { Zero } from '@stake-dao/constants'
 import { http, createPublicClient, toHex, toRlp } from 'viem'
 import { mainnet } from 'viem/chains'
 import { BLOCK_HEADER } from './config.js'
@@ -10,7 +11,7 @@ type Rpcs = {
 function encodeRlpBlock(block: Record<string, any>): string {
   const blockHeader = BLOCK_HEADER.map((key) => {
     if (key in block) {
-      if (typeof block[key] === 'bigint' && block[key] === BigInt(0)) {
+      if (typeof block[key] === 'bigint' && block[key] === Zero) {
         return '0x'
       }
       if (typeof block[key] === 'string') {