@stake-dao/reader 0.4.57 → 0.4.59

package/src/votemarket/curve/fetchUserVlCvxClaimable.ts

@@ -1,7 +1,7 @@
 import { 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 { GH_STAKE_DAO_BOUNTIES_REPORT, STAKE_DAO_API } from '../../endpoints.js'
 import { type Price, getPrices } from '../../prices.js'
 import { rpcFetchTokensData } from '../../tokens.js'
 import { equalTlc, multicall } from '../../utils.js'
@@ -18,44 +18,52 @@ type UnknownToken = {
   chainId: number
 }
 
-const getMerkleData = async () => {
-  const [delegators, nonDelegators] = await Promise.all([
+const getMerkleData = async (chainId: number) => {
+  const [delegators, nonDelegators, votiumMerkle] = await Promise.all([
+    chainId === mainnet.id
+      ? fetch(
+          `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/latest/vlCVX/vlcvx_merkle_delegators.json`,
+        ).then((res) => res.json())
+      : {},
     fetch(
-      `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/latest/vlCVX/vlcvx_merkle_delegators.json`,
+      `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/latest/vlCVX/vlcvx_merkle${
+        chainId === mainnet.id ? '' : `_${chainId}`
+      }.json`,
     ).then((res) => res.json()),
-    fetch(`${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/latest/vlCVX/vlcvx_merkle.json`).then(
-      (res) => res.json(),
-    ),
+    chainId === mainnet.id
+      ? fetch(`${STAKE_DAO_API}/votemarket/votium_merkles.json`).then((res) => res.json())
+      : { claims: {} },
   ])
 
-  return { delegators, nonDelegators }
+  return { delegators, nonDelegators, votiumMerkle }
 }
 
-const isRootMatch = (contractRoot: string, fileRoot: string) =>
-  (contractRoot === ZERO_ROOT && fileRoot === ZERO_ROOT) || equalTlc(contractRoot, fileRoot)
-
-const validateMerkleRoots = (delegatorRoot: string, nonDelegatorRoot: string, merkleData: any) => {
-  const delegatorMatches = isRootMatch(delegatorRoot, merkleData.delegators.merkleRoot)
-  const nonDelegatorMatches = isRootMatch(nonDelegatorRoot, merkleData.nonDelegators.merkleRoot)
+const validateMerkleRoots = (delegatorRoot: string, nonDelegatorRoot: string, merkleData: any, isMainnet: boolean) => {
+  const delegatorMatches = isMainnet ? equalTlc(delegatorRoot, merkleData.delegators.merkleRoot) : false
+  const nonDelegatorMatches = equalTlc(nonDelegatorRoot, merkleData.nonDelegators.merkleRoot)
   return delegatorMatches || nonDelegatorMatches
 }
 
-const getMerkleRoots = async (provider: any) => {
+const getMerkleRoots = async (provider: any, user: string) => {
   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)']),
+    contracts.flatMap((address) => [
+      { address, name: 'root', params: [] },
+      { address, name: 'recipients', params: [user] },
+    ]),
+    parseAbi([
+      'function root() external view returns (bytes32)',
+      'function recipients(address) external view returns (address)',
+    ]),
   )
 
   return {
     delegatorRoot: result[0].result,
-    nonDelegatorRoot: result[1].result,
+    delegatorRecipient: result[1].result,
+    nonDelegatorRoot: result[2].result,
+    nonDelegatorRecipient: result[3].result,
   }
 }
 
@@ -64,11 +72,7 @@ const getClaimedData = async (provider: any, tokens: string[], user: string, con
     tokens.length > 0
       ? await multicall(
           provider,
-          tokens.map((t) => ({
-            address: contract,
-            name: 'claimed',
-            params: [user, t],
-          })),
+          tokens.flatMap((t) => [{ address: contract, name: 'claimed', params: [user, t] }]),
           parseAbi(['function claimed(address,address) external view returns (uint256)']),
         )
       : []
@@ -79,12 +83,33 @@ const getClaimedData = async (provider: any, tokens: string[], user: string, con
   }))
 }
 
+const getVotiumClaimedData = async (provider: any, merkle: any) => {
+  const rawClaimed = await multicall(
+    provider,
+    Object.keys(merkle).map((t) => ({
+      address: contract('votiumMerkle'),
+      name: 'isClaimed',
+      params: [t, merkle[t].index],
+    })),
+    parseAbi(['function isClaimed(address,uint256) external view returns(bool)']),
+  )
+
+  return Object.keys(merkle).map((t, index) => ({
+    ...merkle[t],
+    token: t,
+    claimed: rawClaimed[index].result,
+  }))
+}
+
 const getParsedData = (
+  user: string,
+  recipient: string,
   merkleAddress: string,
   userData: any,
   unknownTokensData: any[],
   claimedData: any[],
   prices: Price[],
+  chainId: number,
 ) => {
   return userData
     ? Object.keys(userData.tokens).map((token) => {
@@ -95,6 +120,8 @@ const getParsedData = (
         const claimable = BigInt(userData.tokens[token].amount) - claimed
 
         return {
+          user,
+          recipient,
           token: rewardToken,
           claimable: formatUnits(claimable, 0),
           claimableUsd: Number(formatUnits(claimable, rewardToken?.decimals || 18)) * tokenPrice,
@@ -104,71 +131,114 @@ const getParsedData = (
           proof: userData.tokens[token].proof,
           merkleAddress: merkleAddress as Address,
           isClaimed: claimable === Zero,
+          chainId,
         }
       })
     : undefined
 }
 
-const ZERO_ROOT = '0x0000000000000000000000000000000000000000000000000000000000000000'
+const getVotiumParsedData = (user: string, userData: any[], unknownTokensData: any[], prices: Price[]) => {
+  return userData
+    ? userData.map((ud) => {
+        const rewardToken = tokenWithAddress(ud.token) || unknownTokensData.find((t) => equalTlc(t.address, ud.token))
+
+        const tokenPrice = prices.find((p) => equalTlc(ud.token, p.address))?.usdPrice || 0
 
-export const fetchUserVlCvxClaimable = async (provider: any, rpc: Rpcs, user: string) => {
-  const { delegatorRoot, nonDelegatorRoot } = await getMerkleRoots(provider)
+        return {
+          user,
+          recipient: user,
+          token: rewardToken,
+          claimable: ud.claimed ? '0' : formatUnits(BigInt(ud.amount), 0),
+          claimableUsd: ud.claimed
+            ? 0
+            : Number(formatUnits(BigInt(ud.amount), rewardToken?.decimals || 18)) * tokenPrice,
+          amount: formatUnits(BigInt(ud.amount), 0),
+          amountUsd: Number(formatUnits(BigInt(ud.amount), rewardToken?.decimals || 18)) * tokenPrice,
+          proof: ud.proof,
+          merkleAddress: contract('votiumMerkle'),
+          isClaimed: ud.claimed,
+          index: ud.index,
+          chainId: mainnet.id,
+        }
+      })
+    : undefined
+}
+
+export const fetchUserVlCvxClaimable = async (provider: any, rpc: Rpcs, user: string, chainId: number) => {
+  const { delegatorRoot, delegatorRecipient, nonDelegatorRoot, nonDelegatorRecipient } = await getMerkleRoots(
+    provider,
+    user,
+  )
 
   let vlCvxClaimable: any
+  let votiumMerkleData: any
 
   try {
-    const merkleData = await getMerkleData()
-    if (validateMerkleRoots(delegatorRoot, nonDelegatorRoot, merkleData)) {
-      vlCvxClaimable = merkleData
+    const merkleData = await getMerkleData(chainId)
+    if (validateMerkleRoots(delegatorRoot, nonDelegatorRoot, merkleData, chainId === mainnet.id)) {
+      vlCvxClaimable = { delegators: merkleData.delegators, nonDelegators: merkleData.nonDelegators }
     }
+    votiumMerkleData = merkleData.votiumMerkle.claims[user]
   } catch {}
 
-  if (!vlCvxClaimable) {
-    throw new Error('Could not find valid merkle data')
+  if (!vlCvxClaimable && !votiumMerkleData) {
+    console.error('Could not find valid merkle data')
+    return []
   }
 
-  const vlCvxUserDelegated = vlCvxClaimable?.delegators.claims[user]
-  const vlCvxUserNotDelegated = vlCvxClaimable?.nonDelegators.claims[user]
+  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 tokensVotium = Object.keys(votiumMerkleData?.tokens || {})
 
-  const tokens = [...tokensDelegated, ...tokensNotDelegated]
+  const tokens = [...tokensDelegated, ...tokensNotDelegated, ...tokensVotium]
 
   if (!tokens.length) return []
 
-  const [delegatedClaimed, notDelegatedClaimed] = await Promise.all([
+  const [delegatedClaimed, notDelegatedClaimed, votiumClaimed] = await Promise.all([
     getClaimedData(provider, tokensDelegated, user, contract('vlCvxDelegatorMerkle')),
     getClaimedData(provider, tokensNotDelegated, user, contract('vlCvxNotDelegatorMerkle')),
+    votiumMerkleData?.tokens && Object.keys(votiumMerkleData?.tokens).length > 0
+      ? getVotiumClaimedData(provider, votiumMerkleData?.tokens)
+      : [],
   ])
 
   const unknownTokens = tokens.filter((t) => !tokenWithAddress(t))
-  const rawUnknownTokensData = await rpcFetchTokensData(mainnet.id, rpc[mainnet.id]!, unknownTokens)
+  const rawUnknownTokensData = await rpcFetchTokensData(chainId, rpc[chainId]!, unknownTokens)
   const unknownTokensData: UnknownToken[] = rawUnknownTokensData.map((t) => ({
     name: t.name,
     symbol: t.symbol,
     address: t.tokenAddress,
     decimals: Number(t.decimals),
-    chainId: mainnet.id,
+    chainId,
   }))
 
-  const prices = await getPrices(tokens.map((t) => ({ address: t })) as any[], mainnet.id)
+  const prices = await getPrices(tokens.map((t) => ({ address: t })) as any[], chainId)
 
   return [
     getParsedData(
-      contract('vlCvxDelegatorMerkle', mainnet.id),
+      user,
+      delegatorRecipient,
+      contract('vlCvxDelegatorMerkle'),
       vlCvxUserDelegated,
       unknownTokensData,
       delegatedClaimed,
       prices,
+      chainId,
     ),
     getParsedData(
-      contract('vlCvxNotDelegatorMerkle', mainnet.id),
+      user,
+      nonDelegatorRecipient,
+      contract('vlCvxNotDelegatorMerkle', chainId),
       vlCvxUserNotDelegated,
       unknownTokensData,
       notDelegatedClaimed,
       prices,
+      chainId,
     ),
+    getVotiumParsedData(user, votiumClaimed, unknownTokensData, prices),
   ]
     .filter(Boolean)
     .flat()

package/src/votemarket/fetchCampaigns/index.ts

@@ -0,0 +1,98 @@
+import { contract } from '@stake-dao/constants'
+import { range } from 'lodash-es'
+import { decodeAbiParameters, encodeAbiParameters, parseAbiParameters } from 'viem'
+import { arbitrum } from 'viem/chains'
+import batchCampaigns from '../../bytecodes/votemarket/batchCampaigns.js'
+import { batchJsonRpc, concatBytecode, equalTlc, rpcCall } from '../../utils.js'
+import type { Campaign } from '../types.js'
+import { fetchPendingRemoteCampaigns } from './pendingRemote.js'
+import { processRawCampaigns } from './processRawCampaigns.js'
+
+export const CAMPAIGNS_CHUNK_SIZE = 10
+export const CLAIM_WINDOW_LENGTH = 24 // weeks
+export const CLOSE_WINDOW_LENGTH = 4 // weeks
+
+interface FetchCampaignsProps {
+  platform: string
+  gaugeController: string
+  chainId: number
+  rpcs: { [chainId: number]: string }
+  etherscanApiKey?: string
+  fromBlock?: number
+  mainnetVmRemote?: string
+}
+
+export const fetchCampaigns = async ({
+  platform,
+  gaugeController,
+  chainId,
+  rpcs,
+  etherscanApiKey,
+  fromBlock,
+  mainnetVmRemote,
+}: FetchCampaignsProps): Promise<Campaign[]> => {
+  const rpc = rpcs[chainId]!
+
+  const nCampaignsRequest = await rpcCall(rpc, [{ to: platform, data: '0x7274e30d' }]) // campaignCount
+  const nCampaigns = Number(
+    decodeAbiParameters([{ type: 'uint256', name: 'campaignCount' }], nCampaignsRequest[0].result),
+  )
+
+  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,
+    ]
+
+    const inputData = encodeAbiParameters(parseAbiParameters(batchCampaigns.inputType[1]!) as any, inputParams)
+    return concatBytecode(batchCampaigns.bytecode[1]!, inputData)
+  })
+
+  let rawCampaigns = await batchJsonRpc({
+    rpc,
+    calls,
+    outputTypeAbi: batchCampaigns.outputType![1]!,
+    parse: false,
+    callsKey: `votemarket/fetchCampaigns.ts: rawCampaigns - chainId ${chainId} - rpc ${rpc}`,
+  })
+
+  if (chainId === arbitrum.id && etherscanApiKey && fromBlock && mainnetVmRemote) {
+    const nextIndex = rawCampaigns.length > 0 ? Math.max(...rawCampaigns.map((rc) => Number(rc.id))) + 1 : 0
+    const { remoteCampaigns: pendingRemoteCampaigns } = await fetchPendingRemoteCampaigns({
+      mainnetVmRemote,
+      chainId,
+      fromBlock,
+      etherscanApiKey,
+      nextIndex,
+      votemarket: platform,
+    })
+
+    rawCampaigns = [
+      ...rawCampaigns,
+      ...pendingRemoteCampaigns.filter((rmtC) => {
+        const existingCampaign = rawCampaigns.find(
+          (rc) =>
+            rc.addresses.length === rmtC.addresses.length &&
+            rc.addresses.every((rca, index) => equalTlc(rca, rmtC.addresses[index])) &&
+            equalTlc(rc.rewardAddress, rmtC.rewardAddress) &&
+            rc.rewardChainId === rmtC.rewardChainId &&
+            rc.campaign.startTimestamp === rmtC.campaign.startTimestamp &&
+            rc.campaign.endTimestamp === rmtC.campaign.endTimestamp &&
+            rc.campaign.numberOfPeriods === rmtC.campaign.numberOfPeriods &&
+            rc.campaign.maxRewardPerVote === rmtC.campaign.maxRewardPerVote &&
+            rc.campaign.totalRewardAmount === rmtC.campaign.totalRewardAmount &&
+            equalTlc(rc.campaign.gauge, rmtC.campaign.gauge) &&
+            equalTlc(rc.campaign.hook, rmtC.campaign.hook) &&
+            equalTlc(rc.campaign.manager, rmtC.campaign.manager),
+        )
+
+        return typeof existingCampaign === 'undefined'
+      }),
+    ]
+  }
+
+  return await processRawCampaigns({ rawCampaigns, platform, chainId, gaugeController, rpcs })
+}

package/src/votemarket/{fetchPendingRemoteCampaigns.ts → fetchCampaigns/pendingRemote.ts}

@@ -2,6 +2,7 @@ import { LA_POSTE_MESSAGE_SENT_EVENT, ONE_WEEK, One, Zero, contract } from '@sta
 import { range } from 'lodash-es'
 import { decodeAbiParameters, decodeEventLog, parseAbiParameters, zeroAddress } from 'viem'
 import { mainnet } from 'viem/chains'
+import { equalTlc } from '../../utils.js'
 
 export const CAMPAIGNS_CHUNK_SIZE = 10
 export const CLAIM_WINDOW_LENGTH = 24 // weeks
@@ -13,6 +14,7 @@ interface FetchPendingRemoteCampaignsProps {
   fromBlock: number
   etherscanApiKey: string
   nextIndex: number
+  votemarket: string
 }
 
 export const fetchPendingRemoteCampaigns = async ({
@@ -21,6 +23,7 @@ export const fetchPendingRemoteCampaigns = async ({
   fromBlock,
   etherscanApiKey,
   nextIndex,
+  votemarket,
 }: FetchPendingRemoteCampaignsProps) => {
   const queryParams = {
     chainid: `${mainnet.id}`,
@@ -59,6 +62,9 @@ export const fetchPendingRemoteCampaigns = async ({
             decodedEvent.args.message.payload,
           )
 
+          // Skip if the target is not the protocol's votmarket
+          if (!equalTlc(payload[0].votemarket, votemarket)) continue
+
           // Create Campaign (actionType === 0)
           if (payload[0].actionType === Zero) {
             const decodedParams = decodeAbiParameters(
@@ -131,6 +137,7 @@ export const fetchPendingRemoteCampaigns = async ({
       })),
       rewardAddress: campaignParams.rewardToken,
       rewardChainId: BigInt(mainnet.id),
+      eventTimestamp: element.eventTimestamp,
     }
 
     nextIndex++

package/src/votemarket/{fetchCampaigns.ts → fetchCampaigns/processRawCampaigns.ts}

@@ -1,96 +1,26 @@
-import { ONE_WEEK, Zero, contract, contracts, tokenWithAddress, tokens } from '@stake-dao/constants'
-import { chunk, filter, range, remove, uniq } from 'lodash-es'
-import {
-  decodeAbiParameters,
-  encodeAbiParameters,
-  formatEther,
-  formatUnits,
-  parseAbiParameters,
-  zeroAddress,
-} from 'viem'
-import { arbitrum, mainnet } from 'viem/chains'
-import batchCampaigns from '../bytecodes/votemarket/batchCampaigns.js'
-import batchCampaignsRestrictedVotes from '../bytecodes/votemarket/batchCampaignsRestrictedVotes.js'
-import batchGaugesWeight from '../bytecodes/votemarket/batchGaugesWeight.js'
-import { getPrices } from '../prices.js'
-import { rpcFetchTokensData } from '../tokens.js'
-import { batchJsonRpc, concatBytecode, equalTlc, rpcCall, rpcGetLastBlockTimetstamp } from '../utils.js'
-import campaignsUnderlyingTokens from './campaignsUnderlyingTokens.js'
-import { fetchPendingRemoteCampaigns } from './fetchPendingRemoteCampaigns.js'
-import type { Campaign, RawCampaign, RawPeriod } from './types.js'
+import { ONE_WEEK, Zero, tokenWithAddress, tokens } from '@stake-dao/constants'
+import { chunk, filter, remove, uniq } from 'lodash-es'
+import { encodeAbiParameters, formatEther, formatUnits, parseAbiParameters } from 'viem'
+import { mainnet } from 'viem/chains'
+import batchCampaignsRestrictedVotes from '../../bytecodes/votemarket/batchCampaignsRestrictedVotes.js'
+import batchGaugesWeight from '../../bytecodes/votemarket/batchGaugesWeight.js'
+import { getPrices } from '../../prices.js'
+import { rpcFetchTokensData } from '../../tokens.js'
+import { batchJsonRpc, concatBytecode, equalTlc, lc, rpcGetLastBlockTimetstamp } from '../../utils.js'
+import campaignsUnderlyingTokens from '../campaignsUnderlyingTokens.js'
+import type { Campaign } from '../types.js'
+import { updateEpoch } from './updateEpoch.js'
 
 export const CAMPAIGNS_CHUNK_SIZE = 10
 export const CLAIM_WINDOW_LENGTH = 24 // weeks
 export const CLOSE_WINDOW_LENGTH = 4 // weeks
 
-interface FetchCampaignsProps {
+interface ProcessRawCampaignsProps {
+  rawCampaigns: any[]
   platform: string
   gaugeController: string
   chainId: number
   rpcs: { [chainId: number]: string }
-  etherscanApiKey?: string
-  fromBlock?: number
-  mainnetVmRemote?: string
-}
-
-const updateEpoch = ({
-  period,
-  previousPeriod,
-  campaign,
-  totalVotes,
-  remainingPeriods,
-}: {
-  period: RawPeriod
-  previousPeriod?: RawPeriod
-  campaign: RawCampaign
-  totalVotes: bigint
-  remainingPeriods: number
-}) => {
-  // -- _checkForUpgrade is handled in solidity BatchCampaigns.sol
-  // -- If not first period, check if previousPeriod is updated
-  if (!period.updated && (previousPeriod?.updated || typeof previousPeriod === 'undefined')) {
-    // Calculate remaining periods and total reward.
-    const totalRewardForRemainingPeriods: bigint = campaign.totalRewardAmount - campaign.totalDistributed
-
-    // -- Update the period data.
-    const newRewardPerPeriod =
-      remainingPeriods > 0 ? totalRewardForRemainingPeriods / BigInt(remainingPeriods) : totalRewardForRemainingPeriods
-    period.rewardPerPeriod = newRewardPerPeriod
-
-    // -- Update the reward per vote
-    // If no votes, rollover the leftover to the next epoch.
-    if (totalVotes === Zero) {
-      period.leftover = period.rewardPerPeriod
-    } else {
-      // Calculate reward per vote
-      let rewardPerVote = (newRewardPerPeriod * BigInt(1e18)) / totalVotes
-
-      // Cap reward per vote at max reward per vote
-      if (rewardPerVote > campaign.maxRewardPerVote) {
-        rewardPerVote = campaign.maxRewardPerVote
-
-        // Calculate leftover rewards
-        const leftOver = newRewardPerPeriod - (rewardPerVote * totalVotes) / BigInt(1e18)
-
-        // Handle leftover rewards
-        if (campaign.hook === zeroAddress) {
-          // Store leftover in the period if there is no hook.
-          period.leftover = period.leftover + leftOver
-        }
-      }
-
-      // Save the calculated reward per vote.
-      period.rewardPerVote = rewardPerVote
-    }
-
-    // -- Update the total distributed amount
-    campaign.totalDistributed = campaign.totalDistributed + newRewardPerPeriod - period.leftover
-
-    // -- Mark the period as updated
-    period.updated = true
-  }
-
-  return campaign
 }
 
 const formatPeriod = (rawPeriod: any, decimals: number) => ({
@@ -100,77 +30,15 @@ const formatPeriod = (rawPeriod: any, decimals: number) => ({
   updated: rawPeriod.updated,
 })
 
-export const fetchCampaigns = async ({
+export const processRawCampaigns = async ({
+  rawCampaigns,
   platform,
   gaugeController,
   chainId,
   rpcs,
-  etherscanApiKey,
-  fromBlock,
-  mainnetVmRemote,
-}: FetchCampaignsProps): Promise<Campaign[]> => {
+}: ProcessRawCampaignsProps): Promise<Campaign[]> => {
   const rpc = rpcs[chainId]!
-
   const block = await rpcGetLastBlockTimetstamp(rpc)
-  const nCampaignsRequest = await rpcCall(rpc, [{ to: platform, data: '0x7274e30d' }]) // campaignCount
-  const nCampaigns = Number(
-    decodeAbiParameters([{ type: 'uint256', name: 'campaignCount' }], nCampaignsRequest[0].result),
-  )
-
-  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,
-    ]
-
-    const inputData = encodeAbiParameters(parseAbiParameters(batchCampaigns.inputType[1]!) as any, inputParams)
-    return concatBytecode(batchCampaigns.bytecode[1]!, inputData)
-  })
-
-  let rawCampaigns = await batchJsonRpc({
-    rpc,
-    calls,
-    outputTypeAbi: batchCampaigns.outputType![1]!,
-    parse: false,
-    callsKey: `votemarket/fetchCampaigns.ts: rawCampaigns - chainId ${chainId} - rpc ${rpc}`,
-  })
-
-  if (chainId === arbitrum.id && etherscanApiKey && fromBlock && mainnetVmRemote) {
-    const nextIndex = rawCampaigns.length > 0 ? Math.max(...rawCampaigns.map((rc) => Number(rc.id))) + 1 : 0
-    const { remoteCampaigns: pendingRemoteCampaigns } = await fetchPendingRemoteCampaigns({
-      mainnetVmRemote,
-      chainId,
-      fromBlock,
-      etherscanApiKey,
-      nextIndex,
-    })
-
-    rawCampaigns = [
-      ...rawCampaigns,
-      ...pendingRemoteCampaigns.filter((rmtC) => {
-        const existingCampaign = rawCampaigns.find(
-          (rc) =>
-            rc.addresses.length === rmtC.addresses.length &&
-            rc.addresses.every((rca, index) => equalTlc(rca, rmtC.addresses[index])) &&
-            equalTlc(rc.rewardAddress, rmtC.rewardAddress) &&
-            rc.rewardChainId === rmtC.rewardChainId &&
-            rc.campaign.startTimestamp === rmtC.campaign.startTimestamp &&
-            rc.campaign.endTimestamp === rmtC.campaign.endTimestamp &&
-            rc.campaign.numberOfPeriods === rmtC.campaign.numberOfPeriods &&
-            rc.campaign.maxRewardPerVote === rmtC.campaign.maxRewardPerVote &&
-            rc.campaign.totalRewardAmount === rmtC.campaign.totalRewardAmount &&
-            equalTlc(rc.campaign.gauge, rmtC.campaign.gauge) &&
-            equalTlc(rc.campaign.hook, rmtC.campaign.hook) &&
-            equalTlc(rc.campaign.manager, rmtC.campaign.manager),
-        )
-
-        return typeof existingCampaign === 'undefined'
-      }),
-    ]
-  }
 
   const callsRestrictedVotes = rawCampaigns
     .filter((rc) => rc.addresses.length > 0)
@@ -200,7 +68,7 @@ export const fetchCampaigns = async ({
       concatBytecode(
         batchGaugesWeight.bytecode[mainnet.id]!,
         encodeAbiParameters(parseAbiParameters(batchGaugesWeight.inputType[mainnet.id]!) as any, [
-          contracts.curveGaugeController![1]!,
+          gaugeController,
           campaignsGauges,
         ]),
       ),
@@ -324,7 +192,9 @@ export const fetchCampaigns = async ({
     )
 
     return {
+      key: `${chainId}-${lc(platform.slice(2, 6))}-${lc(platform.slice(-4))}-${Number(rc.id)}`,
       id: Number(rc.id),
+      platform,
       chainId,
       rewardChainId: Number(rc.rewardChainId),
       gaugeChainId: Number(rc.campaign.chainId),

package/src/votemarket/fetchCampaigns/updateEpoch.ts

@@ -0,0 +1,63 @@
+import { Zero } from '@stake-dao/constants'
+import { zeroAddress } from 'viem'
+import type { RawCampaign, RawPeriod } from '../types.js'
+
+export const updateEpoch = ({
+  period,
+  previousPeriod,
+  campaign,
+  totalVotes,
+  remainingPeriods,
+}: {
+  period: RawPeriod
+  previousPeriod?: RawPeriod
+  campaign: RawCampaign
+  totalVotes: bigint
+  remainingPeriods: number
+}) => {
+  // -- _checkForUpgrade is handled in solidity BatchCampaigns.sol
+  // -- If not first period, check if previousPeriod is updated
+  if (!period.updated && (previousPeriod?.updated || typeof previousPeriod === 'undefined')) {
+    // Calculate remaining periods and total reward.
+    const totalRewardForRemainingPeriods: bigint = campaign.totalRewardAmount - campaign.totalDistributed
+
+    // -- Update the period data.
+    const newRewardPerPeriod =
+      remainingPeriods > 0 ? totalRewardForRemainingPeriods / BigInt(remainingPeriods) : totalRewardForRemainingPeriods
+    period.rewardPerPeriod = newRewardPerPeriod
+
+    // -- Update the reward per vote
+    // If no votes, rollover the leftover to the next epoch.
+    if (totalVotes === Zero) {
+      period.leftover = period.rewardPerPeriod
+    } else {
+      // Calculate reward per vote
+      let rewardPerVote = (newRewardPerPeriod * BigInt(1e18)) / totalVotes
+
+      // Cap reward per vote at max reward per vote
+      if (rewardPerVote > campaign.maxRewardPerVote) {
+        rewardPerVote = campaign.maxRewardPerVote
+
+        // Calculate leftover rewards
+        const leftOver = newRewardPerPeriod - (rewardPerVote * totalVotes) / BigInt(1e18)
+
+        // Handle leftover rewards
+        if (campaign.hook === zeroAddress) {
+          // Store leftover in the period if there is no hook.
+          period.leftover = period.leftover + leftOver
+        }
+      }
+
+      // Save the calculated reward per vote.
+      period.rewardPerVote = rewardPerVote
+    }
+
+    // -- Update the total distributed amount
+    campaign.totalDistributed = campaign.totalDistributed + newRewardPerPeriod - period.leftover
+
+    // -- Mark the period as updated
+    period.updated = true
+  }
+
+  return campaign
+}