@stake-dao/reader 0.4.26 → 0.4.28

package/src/votemarket/fetchCampaigns.ts

@@ -1,11 +1,18 @@
-import { tokenWithAddress, tokens } from '@stake-dao/constants'
-import { chunk, range, remove, uniq } from 'lodash-es'
-import { decodeAbiParameters, encodeAbiParameters, formatUnits, parseAbiParameters } from 'viem'
+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, zeroAddress } from 'viem'
+import { mainnet } from 'viem/chains'
 import { batchTokenData } from '../bytecodes/index.js'
 import batchCampaigns from '../bytecodes/votemarket/batchCampaigns.js'
-import { batchJsonRpc, concatBytecode, equalTlc, rpcCall } from '../utils.js'
+import batchGaugesWeight from '../bytecodes/votemarket/batchGaugesWeight.js'
+import { getPrices } from '../prices.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
+export const CLOSE_WINDOW_LENGTH = 4 // weeks
 
 interface FetchCampaignsProps {
   platform: string
@@ -13,16 +20,68 @@ interface FetchCampaignsProps {
   rpc: string
 }
 
-export type Gauge = {
-  gauge: string
-  inflationRate: string
-  relativeWeight: string
-  futureRelativeWeight: 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
 
-export type GaugesData = { totalGaugesWeight: string; gauges: Gauge[] }
+    // -- Mark the period as updated
+    period.updated = true
+  }
+
+  return campaign
+}
 
-export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsProps): Promise<any> => {
+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),
@@ -47,10 +106,24 @@ export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsP
     callsKey: `votemarket/fetchCampaigns.ts: rawCampaigns - chainId ${chainId} - rpc ${rpc}`,
   })
 
-  const tokensToFetch: string[] = remove(
-    uniq(rawCampaigns.map((rc) => rc.campaign.rewardToken)),
-    (t) => !tokenWithAddress(t, chainId),
-  )
+  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))
 
   let rawTokensData: any[] = []
   if (tokensToFetch.length > 0) {
@@ -69,8 +142,8 @@ export const fetchCampaigns = async ({ platform, chainId, rpc }: FetchCampaignsP
     })
   }
 
-  const fetchedTokens = [
-    ...tokens,
+  const fetchedTokens: any = [
+    ...filter(tokens, (t) => campaignsTokens.find((ct) => equalTlc(ct, t.address))),
     ...rawTokensData.map((t) => ({
       name: t.name,
       symbol: t.symbol,
@@ -80,34 +153,86 @@ 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 prices = [
+    ...(await getPrices(fetchedTokens as any, chainId)),
+    { address: '0x9E49A0314AE61e9C9E34e4Af62a73FBFfB6DE95A', symbol: 'ARR', usdPrice: 10 },
+  ]
+
+  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
 
+    const rewardTokenPrice = prices.find((p) => equalTlc(rc.campaign.rewardToken, p.address))?.usdPrice || 0
+
+    const startTimestamp = Number(rc.campaign.startTimestamp)
+    const endTimestamp = Number(rc.campaign.endTimestamp)
+    const numberOfPeriods = Number(rc.campaign.numberOfPeriods)
+
+    const totalVotes = gaugeWeightData.weight
+
+    // Simulate previous period update if not updated
+    if (rc.previousPeriod && !rc.previousPeriod.updated) {
+      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,
-      numberOfPeriods: Number(rc.campaign.numberOfPeriods),
+      rewardTokenPrice,
+      numberOfPeriods,
+      periodLeft: Number(rc.periodLeft),
       maxRewardPerVote: formatUnits(rc.campaign.maxRewardPerVote, decimals),
       totalRewardAmount: formatUnits(rc.campaign.totalRewardAmount, decimals),
       totalDistributed: formatUnits(rc.campaign.totalDistributed, decimals),
-      startTimestamp: Number(rc.campaign.startTimestamp),
-      endTimestamp: Number(rc.campaign.endTimestamp),
+      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(rc.previousPeriod.rewardPerPeriod, decimals),
+        rewardPerVote: formatUnits(rc.previousPeriod.rewardPerVote, decimals),
+        leftover: formatUnits(rc.previousPeriod.leftover, decimals),
+        updated: rc.previousPeriod.updated,
+      },
       currentPeriod: {
         rewardPerPeriod: formatUnits(rc.currentPeriod.rewardPerPeriod, decimals),
         rewardPerVote: formatUnits(rc.currentPeriod.rewardPerVote, decimals),
         leftover: formatUnits(rc.currentPeriod.leftover, decimals),
         updated: rc.currentPeriod.updated,
       },
-      periodLeft: Number(rc.periodLeft),
+      status: {
+        voteOpen: endTimestamp - ONE_WEEK > currentTimestamp,
+        voteClosed: currentTimestamp > endTimestamp - ONE_WEEK,
+        claimOpen: currentTimestamp > startTimestamp,
+        claimClosed: currentTimestamp > endTimestamp + CLAIM_WINDOW_LENGTH * ONE_WEEK,
+        expired: currentTimestamp > endTimestamp + (CLAIM_WINDOW_LENGTH + CLOSE_WINDOW_LENGTH) * 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]
+}

package/src/votemarket/generateProofs/getGaugeProof.ts

@@ -0,0 +1,75 @@
+import { http, createPublicClient, encodeAbiParameters, fromRlp, keccak256, toHex, toRlp } from 'viem'
+import { mainnet } from 'viem/chains'
+import { GaugeControllerConstants } from './config.js'
+
+type Rpcs = {
+  [chainId: number]: string
+}
+
+// Helper function to encode gauge time
+function _encodeGaugeTime(gauge: `0x${string}`, time: bigint, baseSlot: number): `0x${string}` {
+  const gaugeEncoded = keccak256(
+    encodeAbiParameters([{ type: 'uint256' }, { type: 'address' }], [BigInt(baseSlot), gauge]),
+  )
+  return keccak256(encodeAbiParameters([{ type: 'bytes32' }, { type: 'uint256' }], [gaugeEncoded, time]))
+}
+
+// Function to get storage slot for non-Curve protocols
+function getGaugeTimeStorageSlot(gauge: `0x${string}`, time: bigint, baseSlot: number): bigint {
+  const finalSlot = _encodeGaugeTime(gauge, time, baseSlot)
+  return BigInt(finalSlot)
+}
+
+// Function to get storage slot for Curve protocol (pre-Vyper 0.3)
+function getGaugeTimeStorageSlotPreVyper03(gauge: `0x${string}`, time: bigint, baseSlot: number): bigint {
+  const intermediateHash = _encodeGaugeTime(gauge, time, baseSlot)
+  const finalSlot = keccak256(encodeAbiParameters([{ type: 'bytes32' }], [intermediateHash]))
+  return BigInt(finalSlot)
+}
+
+// Main function to generate gauge proof
+export async function generateGaugeProof(
+  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 pointWeightsBaseSlot = GaugeControllerConstants.GAUGES_SLOTS[protocol].pointWeights
+
+  const positionFunctions: Record<string, any> = {
+    curve: getGaugeTimeStorageSlotPreVyper03,
+    default: getGaugeTimeStorageSlot,
+  }
+
+  const getPosition = positionFunctions[protocol] || positionFunctions.default
+  const pointWeightsPosition = getPosition!(gaugeAddress, currentPeriod, pointWeightsBaseSlot)
+
+  const slots = [toHex(pointWeightsPosition)]
+
+  const proof = await publicClient.getProof({
+    address: GaugeControllerConstants.GAUGE_CONTROLLER[protocol] as `0x${string}`,
+    storageKeys: slots,
+    blockNumber,
+  })
+
+  const decodedAccountProof = proof.accountProof.map((p) => fromRlp(p))
+  const accountProof = toRlp(decodedAccountProof)
+
+  const decodedStorageProof = proof.storageProof[0]!.proof.map((p) => fromRlp(p))
+  let storageProof = toRlp(decodedStorageProof)
+
+  // Add length prefix to match Python output for storage proof
+  const storageProofLength = (storageProof.length - 2) / 2 // subtract 2 for '0x' prefix
+  const storageProofLengthHex = storageProofLength.toString(16).padStart(4, '0')
+
+  // 0xf9 is the RLP prefix for a list longer than 55 bytes, followed by the length of the length (2 bytes), and then the length itself
+  storageProof = `0xf9${storageProofLengthHex}${storageProof.slice(2)}`
+
+  return [accountProof, storageProof]
+}

package/src/votemarket/generateProofs/getUserProof.ts

@@ -0,0 +1,74 @@
+import { http, createPublicClient, encodeAbiParameters, fromRlp, keccak256, toHex, toRlp } from 'viem'
+import { mainnet } from 'viem/chains'
+import { GaugeControllerConstants } from './config.js'
+
+type Rpcs = {
+  [chainId: number]: string
+}
+
+// Helper function to encode user gauge data
+function _encodeUserGaugeData(user: `0x${string}`, gauge: `0x${string}`, baseSlot: number): `0x${string}` {
+  const userEncoded = keccak256(
+    encodeAbiParameters([{ type: 'uint256' }, { type: 'address' }], [BigInt(baseSlot), user]),
+  )
+  return keccak256(encodeAbiParameters([{ type: 'bytes32' }, { type: 'address' }], [userEncoded, gauge]))
+}
+
+// Function to get storage slot for non-Curve protocols
+function getUserGaugeStorageSlot(user: `0x${string}`, gauge: `0x${string}`, baseSlot: number): bigint {
+  const finalSlot = _encodeUserGaugeData(user, gauge, baseSlot)
+  return BigInt(finalSlot)
+}
+
+// Function to get storage slot for Curve protocol (pre-Vyper 0.3)
+function getUserGaugeStorageSlotPreVyper03(user: `0x${string}`, gauge: `0x${string}`, baseSlot: number): bigint {
+  const intermediateHash = _encodeUserGaugeData(user, gauge, baseSlot)
+  const finalSlot = keccak256(encodeAbiParameters([{ type: 'bytes32' }], [intermediateHash]))
+  return BigInt(finalSlot)
+}
+
+// Main function to generate user proof
+export async function generateUserProof(
+  rpc: Rpcs,
+  protocol: string,
+  gaugeAddress: `0x${string}`,
+  user: `0x${string}`,
+  blockNumber: bigint,
+): Promise<[string, string]> {
+  const publicClient = createPublicClient({
+    chain: mainnet,
+    transport: http(rpc[mainnet.id]),
+  })
+
+  const lastUserVoteBaseSlot = GaugeControllerConstants.GAUGES_SLOTS[protocol].lastUserVote
+  const voteUserSlopeBaseSlot = GaugeControllerConstants.GAUGES_SLOTS[protocol].voteUserSlope
+
+  const lastUserVoteSlot = getUserGaugeStorageSlot(user, gaugeAddress, lastUserVoteBaseSlot)
+
+  const positionFunctions: Record<string, any> = {
+    curve: getUserGaugeStorageSlotPreVyper03,
+    default: getUserGaugeStorageSlot,
+  }
+
+  const getPosition = positionFunctions[protocol] || positionFunctions.default
+  const voteUserSlopeSlot = getPosition(user, gaugeAddress, voteUserSlopeBaseSlot)
+
+  const voteUserSlopeSlope = voteUserSlopeSlot
+  const voteUserSlopeEnd = voteUserSlopeSlot + 2n
+
+  const slots = [toHex(lastUserVoteSlot), toHex(voteUserSlopeSlope), toHex(voteUserSlopeEnd)]
+
+  const proof = await publicClient.getProof({
+    address: GaugeControllerConstants.GAUGE_CONTROLLER[protocol] as `0x${string}`,
+    storageKeys: slots,
+    blockNumber,
+  })
+
+  const decodedAccountProof = proof.accountProof.map((p) => fromRlp(p))
+  const accountProof = toRlp(decodedAccountProof)
+
+  const decodedStorageProof = proof.storageProof.map((sp) => sp.proof.map((p) => fromRlp(p)))
+  const storageProof = toRlp(decodedStorageProof)
+
+  return [accountProof, storageProof]
+}

package/src/votemarket/types.ts

@@ -0,0 +1,67 @@
+export type Period = {
+  rewardPerPeriod: string
+  rewardPerVote: string
+  leftover: string
+  updated: boolean
+}
+
+export type Campaign = {
+  id: number
+  chainId: number
+  gauge: string
+  gaugeChainId: number
+  manager: string
+  rewardToken: {
+    name: string
+    symbol: string
+    address: string
+    decimals: number
+    chainId: number
+  }
+  rewardTokenPrice: number
+  numberOfPeriods: number
+  maxRewardPerVote: string
+  totalRewardAmount: string
+  totalDistributed: string
+  startTimestamp: number
+  endTimestamp: number
+  hook: string
+  isClosed: boolean
+  addresses: string[]
+  isWhitelist: boolean
+  isBlacklist: boolean
+  previousPeriod: Period
+  currentPeriod: Period
+  periodLeft: number
+  status: {
+    voteOpen: boolean
+    voteClosed: boolean
+    claimOpen: boolean
+    claimClosed: boolean
+    expired: boolean
+  }
+  claimableAmount?: string
+}
+
+// RAW
+
+export type RawPeriod = {
+  rewardPerPeriod: bigint
+  rewardPerVote: bigint
+  leftover: bigint
+  updated: boolean
+}
+
+export type RawCampaign = {
+  chainId: bigint
+  endTimestamp: bigint
+  gauge: string
+  hook: string
+  manager: string
+  maxRewardPerVote: bigint
+  numberOfPeriods: number
+  rewardToken: bigint
+  startTimestamp: bigint
+  totalDistributed: bigint
+  totalRewardAmount: bigint
+}