@stake-dao/reader 0.4.27 → 0.4.29

package/src/utils.ts

@@ -2,9 +2,8 @@ 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 } from 'viem'
+import { http, createPublicClient, decodeAbiParameters, extractChain, parseAbiParameters, toHex } from 'viem'
 import * as viemChains from 'viem/chains'
-import { AGNOSTIC_QUERY_URL } from './endpoints.js'
 import { withTwoDec } from './number.js'
 
 export const isProtocolToken = (protocol: string, tokenSymbol: string) =>
@@ -70,6 +69,26 @@ export const projectWorkingBalance = (veBalance: bigint, veTotal: bigint, balanc
   return [balance, derived + adjusted].reduce((m, e) => (e < m ? e : m))
 }
 
+export const rpcGetLastBlockTimetstamp = async (rpc: string) => {
+  const request = await (
+    await fetch(rpc, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        id: 0,
+        jsonrpc: '2.0',
+        method: 'eth_getBlockByNumber',
+        params: ['latest', false],
+      }),
+    })
+  ).json()
+
+  return {
+    number: Number(request.result.number),
+    timestamp: Number(request.result.timestamp),
+  }
+}
+
 interface RpcCallArgs {
   to: string
   data: string
@@ -138,6 +157,51 @@ export const batchJsonRpc = async (args: BatchJsonRpcArgs) => {
   return rpcResults.flatMap((r) => (r.status === 'fulfilled' ? r.value[0] : []))
 }
 
+interface BatchJsonRpcWithBlocksArgs {
+  rpc: string
+  call: string
+  outputTypeAbi: any | any[]
+  parse?: boolean
+  callsKey: string
+  blocks: number[]
+}
+
+export const batchJsonRpcWithBlocks = async (args: BatchJsonRpcWithBlocksArgs) => {
+  const { rpc, call, outputTypeAbi, parse = true, callsKey, blocks } = args
+
+  const rpcRequests = await (
+    await fetch(rpc, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(
+        blocks.map((block, index) => ({
+          id: index,
+          jsonrpc: '2.0',
+          method: 'eth_call',
+          params: [{ data: call }, toHex(block)],
+        })),
+      ),
+    })
+  ).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)
+
+    if (isError) {
+      console.error(value)
+    }
+
+    return { status, value }
+  })
+
+  return rpcResults.flatMap((r) => (r.status === 'fulfilled' ? r.value : []))
+}
+
 export interface Call {
   address: string // Address of the contract
   name: string // Function name on the contract (example: balanceOf)
@@ -157,23 +221,6 @@ export const multicall = async (provider: any, calls: Call[], abi: readonly any[
   return results
 }
 
-export const agnostic = async (query: string, apiKey: string, defaultErrorValue?: any): Promise<any> => {
-  try {
-    const response = await fetch(AGNOSTIC_QUERY_URL, {
-      body: query,
-      method: 'POST',
-      headers: {
-        Authorization: apiKey,
-      },
-    })
-    const data = await response.json()
-    return data.rows
-  } catch (e) {
-    console.error(e)
-    return defaultErrorValue
-  }
-}
-
 export const graphql = async (url: string, query: string, params?: any, defaultErrorValue?: any): Promise<any> => {
   try {
     return await request(url, query, params)

package/src/votemarket/curve/config.ts

@@ -1,6 +1,6 @@
 import { lc } from '../../utils.js'
 
-export const GAUGES_CHUNK_SIZE = 35
+export const GAUGES_CHUNK_SIZE = 30
 export const GAUGES_METADATA_CHUNK_SIZE = 10
 
 export const NOT_LP_GAUGES = {
@@ -41,3 +41,7 @@ export const BROKEN_GAUGES = [
   lc('0x4dC4A289a8E33600D8bD4cf5F6313E43a37adec7'), // chainId 1 - Curve.fi RSV/3Crv not in registry
   lc('0x82049b520cAc8b05E703bb35d1691B5005A92848'), // chainId 100 - Curve.fi x3CRV RewardGauge Deposit
 ]
+
+export const CHAIN_NATIVE_COIN = {
+  1: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+}

package/src/votemarket/curve/fetchCurveGauges.ts

@@ -5,8 +5,15 @@ import { mainnet } from 'viem/chains'
 import { batchCurveGauges, batchCurveGaugesMetadata, batchCurveOldLps } from '../../bytecodes/index.js'
 import { concatBytecode } from '../../index.js'
 import { batchJsonRpc, equalTlc, rpcCall } from '../../utils.js'
-import { BROKEN_GAUGES, GAUGES_CHUNK_SIZE, GAUGES_METADATA_CHUNK_SIZE, NOT_LP_GAUGES_INDEX } from './config.js'
-
+import {
+  BROKEN_GAUGES,
+  CHAIN_NATIVE_COIN,
+  GAUGES_CHUNK_SIZE,
+  GAUGES_METADATA_CHUNK_SIZE,
+  NOT_LP_GAUGES_INDEX,
+} from './config.js'
+
+// TODO
 export type Gauge = {
   gauge: string
   inflationRate: string
@@ -116,12 +123,14 @@ export const fetchCurveGauges = async (rpc: Rpcs): Promise<GaugesData> => {
 
     return {
       gauge: g.gauge,
+      manager: gaugeMetadata.manager,
       name,
       weight: g.weight,
       relativeWeight: g.relativeWeight,
       futureRelativeWeight: g.futureRelativeWeight,
       isKilled: g.isKilled,
       chainId: g.chainId,
+      pool: gaugeMetadata.pool,
       lp: {
         name: gaugeMetadata.lp.name,
         symbol: gaugeMetadata.lp.symbol,
@@ -156,6 +165,8 @@ export const fetchCurveGauges = async (rpc: Rpcs): Promise<GaugesData> => {
         symbol: c.symbol,
         address: c._address,
         decimals: Number(c.decimals),
+
+        ...(equalTlc(c._address, '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') ? CHAIN_NATIVE_COIN[g.chainId] : {}),
       }))
       .filter((c) => c.address !== zeroAddress)
 
@@ -163,6 +174,8 @@ export const fetchCurveGauges = async (rpc: Rpcs): Promise<GaugesData> => {
       ...g,
       name: missingData ? missingData.name : g.name,
       coins,
+      pool: missingData ? missingData.pool : g.pool,
+      inController: true,
     }
   })
 

package/src/votemarket/curve/fetchSnapshotUserData.ts

@@ -10,6 +10,7 @@ interface SnapshotProposal {
   end: number
   state: string
   choices: string[]
+  scores: number[]
   snapshot: string
   space: {
     strategies: SnapshotStrategy[]
@@ -41,20 +42,25 @@ query Proposals {
         }
         orderBy: "created"
         orderDirection: desc
-    ){
-        id 
+    ) {
+        id
         title
+        choices
         start
         end
-        state
         snapshot
-        choices
+        state
+        created
+        scores
         space {
-            strategies {
-                name
-                network
-                params
-            }
+          id
+          name
+          symbol
+          strategies {
+            name
+            network
+            params
+          }
         }
     }
 }
@@ -67,6 +73,7 @@ export const fetchSnapshotUserData = async (
   if (spaces.length === 0) {
     return undefined
   }
+
   const responses = await Promise.all(
     spaces.map((space) => graphql('https://hub.snapshot.org/graphql', SNAPSHOT_PROPOSAL_QUERY(space))),
   )

package/src/votemarket/fetchCampaigns.ts

@@ -1,11 +1,14 @@
-import { ONE_WEEK, tokenWithAddress, tokens } from '@stake-dao/constants'
+import { ONE_WEEK, RPC, contracts, tokenWithAddress, tokens } from '@stake-dao/constants'
 import { chunk, filter, range, remove, uniq } from 'lodash-es'
-import { decodeAbiParameters, encodeAbiParameters, formatUnits, parseAbiParameters } from 'viem'
+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 { batchJsonRpc, concatBytecode, equalTlc, rpcCall } from '../utils.js'
-import type { Campaign } from './types.js'
+import { Zero } from '../strategies/utils/index.js'
+import { batchJsonRpc, concatBytecode, equalTlc, rpcCall, rpcGetLastBlockTimetstamp } from '../utils.js'
+import type { Campaign, RawCampaign, RawPeriod } from './types.js'
 
 export const CAMPAIGNS_CHUNK_SIZE = 10
 export const CLAIM_WINDOW_LENGTH = 24 // weeks
@@ -17,7 +20,68 @@ interface FetchCampaignsProps {
   rpc: 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
+}
+
 export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsProps): Promise<Campaign[]> => {
+  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),
@@ -42,6 +106,22 @@ export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsP
     callsKey: `votemarket/fetchCampaigns.ts: rawCampaigns - chainId ${chainId} - rpc ${rpc}`,
   })
 
+  const campaignsGauges: string[] = uniq(rawCampaigns.map((rc) => rc.campaign.gauge))
+  const rawGaugesWeights = await batchJsonRpc({
+    rpc: RPC[mainnet.id],
+    calls: [
+      concatBytecode(
+        batchGaugesWeight.bytecode[mainnet.id]!,
+        encodeAbiParameters(parseAbiParameters(batchGaugesWeight.inputType[mainnet.id]!) as any, [
+          contracts.curveGaugeController![1]!,
+          campaignsGauges,
+        ]),
+      ),
+    ],
+    outputTypeAbi: batchGaugesWeight.outputTypeHr[mainnet.id]!,
+    callsKey: `votemarket/fetchCampaigns.ts: rawGaugesWeights - chainId ${mainnet.id} - rpc ${RPC[mainnet.id]}`,
+  })
+
   const campaignsTokens: string[] = uniq(rawCampaigns.map((rc) => rc.campaign.rewardToken))
   const tokensToFetch: string[] = remove(campaignsTokens, (t) => !tokenWithAddress(t, chainId))
 
@@ -73,11 +153,17 @@ export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsP
     })),
   ]
 
-  const prices = await getPrices(fetchedTokens as any, chainId)
+  // const prices = await getPrices(fetchedTokens as any, chainId)
+  // TMP FOR TEST PURPOSE REMOVE ONCE IN PROD
+  const prices = [
+    ...(await getPrices(fetchedTokens as any, chainId)),
+    { address: '0x9E49A0314AE61e9C9E34e4Af62a73FBFfB6DE95A', symbol: 'ARR', usdPrice: 10 },
+  ]
 
-  const currentTimestamp = Math.floor(Date.now() / 1000)
+  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)
     const decimals = rewardToken ? rewardToken.decimals : 18
 
@@ -85,33 +171,80 @@ export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsP
 
     const startTimestamp = Number(rc.campaign.startTimestamp)
     const endTimestamp = Number(rc.campaign.endTimestamp)
+    const numberOfPeriods = Number(rc.campaign.numberOfPeriods)
+
+    const totalVotes = gaugeWeightData.weight
+
+    rc.periods.forEach((_, index) => {
+      if (!rc.periods[index].updated) {
+        updateEpoch({
+          period: rc.periods[index],
+          previousPeriod: index > 0 ? rc.periods[index - 1] : undefined,
+          campaign: rc.campaign,
+          remainingPeriods: Number(rc.campaign.numberOfPeriods) - index,
+          totalVotes,
+        })
+      }
+    })
+
+    const indexOfCurrentPeriod =
+      rc.periods.length > numberOfPeriods - Number(rc.periodLeft)
+        ? numberOfPeriods - Number(rc.periodLeft)
+        : rc.periods.length - 1
+    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: Number(rc.campaign.chainId),
+      chainId,
       gauge: rc.campaign.gauge,
+      gaugeChainId: Number(rc.campaign.chainId),
       manager: rc.campaign.manager,
       rewardToken,
       rewardTokenPrice,
-      numberOfPeriods: Number(rc.campaign.numberOfPeriods),
+      numberOfPeriods,
+      periodLeft: Number(rc.periodLeft),
       maxRewardPerVote: formatUnits(rc.campaign.maxRewardPerVote, decimals),
       totalRewardAmount: formatUnits(rc.campaign.totalRewardAmount, decimals),
       totalDistributed: formatUnits(rc.campaign.totalDistributed, decimals),
       startTimestamp,
       endTimestamp,
       hook: rc.campaign.hook,
-      isKilled: rc.isKilled,
+      isClosed: rc.isClosed,
       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,
+      },
       currentPeriod: {
-        rewardPerPeriod: formatUnits(rc.currentPeriod.rewardPerPeriod, decimals),
-        rewardPerVote: formatUnits(rc.currentPeriod.rewardPerVote, decimals),
-        leftover: formatUnits(rc.currentPeriod.leftover, decimals),
-        updated: rc.currentPeriod.updated,
+        rewardPerPeriod: formatUnits(rawCurrentPeriod.rewardPerPeriod, decimals),
+        rewardPerVote: formatUnits(rawCurrentPeriod.rewardPerVote, decimals),
+        leftover: formatUnits(rawCurrentPeriod.leftover, decimals),
+        updated: rawCurrentPeriod.updated,
       },
-      totalPeriods: (endTimestamp - startTimestamp) / ONE_WEEK,
-      periodLeft: Number(rc.periodLeft),
       status: {
         voteOpen: endTimestamp - ONE_WEEK > currentTimestamp,
         voteClosed: currentTimestamp > endTimestamp - ONE_WEEK,

package/src/votemarket/fetchClaimableData.ts

@@ -0,0 +1,50 @@
+import { arbitrum } from '@stake-dao/constants'
+import { chunk } from 'lodash-es'
+import { encodeAbiParameters, formatUnits, parseAbiParameters } from 'viem'
+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,
+  platform: string,
+  user: string,
+  campaigns: number[],
+  userVotes: any[][],
+) => {
+  const inputCampaignsChunks = chunk(campaigns, CLAIMABLE_CHUNK_SIZE)
+  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 claimable = await batchJsonRpc({
+    rpc: rpc[arbitrum.id]!,
+    calls: claimableCalls,
+    outputTypeAbi: batchClaimableData.outputTypeHr[arbitrum.id],
+    callsKey: `Batch claimable data - chainId ${arbitrum.id} - rpc ${rpc[arbitrum.id]}`,
+  })
+
+  return claimable.map((c) => ({
+    campaignId: Number(c.campaignId),
+    claimInfo: c.claimInfo.map((ci) => ({
+      ...ci,
+      epoch: Number(ci.epoch),
+      blockNumber: Number(ci.blockNumber),
+      claimable: formatUnits(ci.claimable, 0),
+    })),
+  }))
+}

package/src/votemarket/fetchEpochVotes.ts

@@ -0,0 +1,48 @@
+import { chunk } from 'lodash-es'
+import { encodeAbiParameters, parseAbiParameters } from 'viem'
+import { mainnet } from 'viem/chains'
+import batchVotes from '../bytecodes/votemarket/batchVotes.js'
+import { concatBytecode } from '../index.js'
+import { batchJsonRpcWithBlocks } from '../utils.js'
+
+type Rpcs = {
+  [chainId: number]: string
+}
+
+export const fetchEpochsVotes = async (rpc: Rpcs, gaugeController: string, user: string, epochs: number[]) => {
+  const blocksForEpoch = (
+    await Promise.allSettled(
+      epochs.map((epoch) => fetch(`https://coins.llama.fi/block/ethereum/${epoch}`).then((res) => res.json())),
+    )
+  ).map((r) => (r.status === 'fulfilled' ? Number(r.value.height) : 0))
+
+  if (blocksForEpoch.includes(0)) {
+    throw Error(`Block not found for epoch at timestamp ${epochs[blocksForEpoch.indexOf(0)]}`)
+  }
+
+  const inputData = encodeAbiParameters(parseAbiParameters(batchVotes.inputType[mainnet.id]!) as any, [
+    gaugeController,
+    user,
+  ])
+  const call = concatBytecode(batchVotes.bytecode[mainnet.id]!, inputData)
+
+  const blocksChunks = chunk(blocksForEpoch, 10)
+  const votes = (
+    await Promise.all(
+      blocksChunks.map((b) =>
+        batchJsonRpcWithBlocks({
+          rpc: rpc[1]!,
+          call,
+          outputTypeAbi: batchVotes.outputTypeHr[mainnet.id],
+          callsKey: `Batch block votes data - chainId ${mainnet.id} - rpc ${rpc[mainnet.id]}`,
+          blocks: b,
+        }),
+      ),
+    )
+  ).flat()
+
+  return votes.map((v, index) => ({
+    votes: v,
+    epoch: epochs[index],
+  }))
+}

package/src/votemarket/generateProofs/config.ts

@@ -0,0 +1,53 @@
+export const GaugeControllerConstants = {
+  GAUGES_SLOTS: {
+    curve: {
+      pointWeights: 12,
+      lastUserVote: 11,
+      voteUserSlope: 9,
+    },
+    balancer: {
+      pointWeights: 1000000008,
+      lastUserVote: 1000000007,
+      voteUserSlope: 1000000005,
+    },
+    frax: {
+      pointWeights: 10000000011,
+      lastUserVote: 1000000010,
+      voteUserSlope: 1000000008,
+    },
+    fxn: {
+      pointWeights: 10000000011,
+      lastUserVote: 1000000010,
+      voteUserSlope: 1000000008,
+    },
+  },
+  GAUGE_CONTROLLER: {
+    curve: '0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB',
+    balancer: '0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD',
+    frax: '0x3669C421b77340B2979d1A00a792CC2ee0FcE737',
+    fxn: '0xe60eB8098B34eD775ac44B1ddE864e098C6d7f37',
+  },
+}
+
+export const BLOCK_HEADER = [
+  'parentHash',
+  'sha3Uncles',
+  'miner',
+  'stateRoot',
+  'transactionsRoot',
+  'receiptsRoot',
+  'logsBloom',
+  'difficulty',
+  'number',
+  'gasLimit',
+  'gasUsed',
+  'timestamp',
+  'extraData',
+  'mixHash',
+  'nonce',
+  'baseFeePerGas',
+  'withdrawalsRoot',
+  'blobGasUsed',
+  'excessBlobGas',
+  'parentBeaconBlockRoot',
+]

package/src/votemarket/generateProofs/getBlockProof.ts

@@ -0,0 +1,48 @@
+import { http, createPublicClient, toHex, toRlp } from 'viem'
+import { mainnet } from 'viem/chains'
+import { BLOCK_HEADER } from './config.js'
+import { generateGaugeProof } from './getGaugeProof.js'
+
+type Rpcs = {
+  [chainId: number]: string
+}
+
+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)) {
+        return '0x'
+      }
+      if (typeof block[key] === 'string') {
+        return block[key]
+      }
+      return toHex(block[key])
+    }
+    return undefined
+  }).filter((value): value is `0x${string}` => value !== undefined)
+
+  return toRlp(blockHeader)
+}
+
+// Main function to generate block proof
+export async function generateBlockProof(
+  rpc: Rpcs,
+  protocol: string,
+  gaugeAddress: `0x${string}`,
+  currentPeriod: bigint,
+  blockNumber: bigint,
+): Promise<[string, string]> {
+  const publicClient = createPublicClient({
+    chain: mainnet,
+    transport: http(rpc[mainnet.id]),
+  })
+
+  const block = await publicClient.getBlock({
+    blockNumber,
+  })
+
+  const blockHeaderRlp = encodeRlpBlock(block)
+
+  const [proof, _] = await generateGaugeProof(rpc, protocol, gaugeAddress, currentPeriod, blockNumber)
+  return [blockHeaderRlp, proof]
+}