@stake-dao/reader 0.4.33 → 0.4.35

package/src/votemarket/fetchCampaigns.ts

@@ -1,12 +1,21 @@
-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 { 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 { fetchPendingRemoteCampaigns } from './fetchPendingRemoteCampaigns.js'
 import type { Campaign, RawCampaign, RawPeriod } from './types.js'
 
 export const CAMPAIGNS_CHUNK_SIZE = 10
@@ -15,8 +24,12 @@ 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
 }
 
 const updateEpoch = ({
@@ -79,7 +92,22 @@ const updateEpoch = ({
   return campaign
 }
 
-export const fetchCampaigns = async ({ platform, chainId, rpcs }: FetchCampaignsProps): Promise<Campaign[]> => {
+const formatPeriod = (rawPeriod: any, decimals: number) => ({
+  rewardPerPeriod: formatUnits(rawPeriod.rewardPerPeriod, decimals),
+  rewardPerVote: formatUnits(rawPeriod.rewardPerVote, decimals),
+  leftover: formatUnits(rawPeriod.leftover, decimals),
+  updated: rawPeriod.updated,
+})
+
+export const fetchCampaigns = async ({
+  platform,
+  gaugeController,
+  chainId,
+  rpcs,
+  etherscanApiKey,
+  fromBlock,
+  mainnetVmRemote,
+}: FetchCampaignsProps): Promise<Campaign[]> => {
   const rpc = rpcs[chainId]!
 
   const block = await rpcGetLastBlockTimetstamp(rpc)
@@ -101,7 +129,7 @@ export const fetchCampaigns = async ({ platform, chainId, rpcs }: FetchCampaigns
     return concatBytecode(batchCampaigns.bytecode[1]!, inputData)
   })
 
-  const rawCampaigns = await batchJsonRpc({
+  let rawCampaigns = await batchJsonRpc({
     rpc,
     calls,
     outputTypeAbi: batchCampaigns.outputType![1]!,
@@ -109,9 +137,64 @@ export const fetchCampaigns = async ({ platform, chainId, rpcs }: FetchCampaigns
     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)
+    .map((rc) => [rc.campaign.chainId, rc.id, rc.campaign.gauge, rc.addresses])
+  const callsRestrictedVotesChunks = chunk(callsRestrictedVotes, CAMPAIGNS_CHUNK_SIZE).map((restrictedVoteChunk) => {
+    const inputData = encodeAbiParameters(parseAbiParameters(batchCampaignsRestrictedVotes.inputType[1]!) as any, [
+      gaugeController,
+      restrictedVoteChunk,
+    ])
+    return concatBytecode(batchCampaignsRestrictedVotes.bytecode[1]!, inputData)
+  })
+
+  const rawCampaignsRestrictedVotes = await batchJsonRpc({
+    rpc: rpcs[mainnet.id]!,
+    calls: callsRestrictedVotesChunks,
+    outputTypeAbi: batchCampaignsRestrictedVotes.outputType![1]!,
+    parse: false,
+    callsKey: `votemarket/fetchCampaigns.ts: rawCampaignsRestrictedVotes - chainId ${mainnet.id} - rpc ${rpcs[
+      mainnet.id
+    ]!}`,
+  })
+
   const campaignsGauges: string[] = uniq(rawCampaigns.map((rc) => rc.campaign.gauge))
   const rawGaugesWeights = await batchJsonRpc({
-    rpc: RPC[mainnet.id],
+    rpc: rpcs[mainnet.id]!,
     calls: [
       concatBytecode(
         batchGaugesWeight.bytecode[mainnet.id]!,
@@ -122,10 +205,12 @@ export const fetchCampaigns = async ({ platform, chainId, rpcs }: FetchCampaigns
       ),
     ],
     outputTypeAbi: batchGaugesWeight.outputTypeHr[mainnet.id]!,
-    callsKey: `votemarket/fetchCampaigns.ts: rawGaugesWeights - chainId ${mainnet.id} - rpc ${RPC[mainnet.id]}`,
+    callsKey: `votemarket/fetchCampaigns.ts: rawGaugesWeights - chainId ${mainnet.id} - rpc ${rpcs[mainnet.id]!}`,
   })
 
-  const campaignsTokens: string[] = uniq(rawCampaigns.map((rc) => rc.campaign.rewardToken))
+  const campaignsTokens: string[] = uniq(
+    rawCampaigns.map((rc) => (!rc.isPendingRemote ? rc.campaign.rewardToken : undefined)).filter(Boolean),
+  )
   const tokensToFetch: string[] = remove(campaignsTokens, (t) => !tokenWithAddress(t, chainId))
   const rawTokensData: any[] = tokensToFetch.length > 0 ? await rpcFetchTokensData(chainId, rpc, tokensToFetch) : []
 
@@ -165,6 +250,7 @@ export const fetchCampaigns = async ({ platform, chainId, rpcs }: FetchCampaigns
     // { 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
+    //{ address: '0xd9879d9dbdc5042d8f1c2710be293909b985dc90', symbol: 'rEYWA', usdPrice: 0.14 }, // tmp rEYWA price
   ]
 
   const allFetchedTokens = [...fetchedTokens, ...nativeFetchedTokens]
@@ -173,17 +259,26 @@ export const fetchCampaigns = async ({ platform, chainId, rpcs }: FetchCampaigns
 
   const campaigns = rawCampaigns.map((rc) => {
     const gaugeWeightData = rawGaugesWeights.find((g) => equalTlc(g.gauge, rc.campaign.gauge))
-
-    let receiptRewardToken = undefined
+    let receiptRewardToken: any = undefined
     let rewardToken = allFetchedTokens.find(
       (t) => equalTlc(t.address, rc.campaign.rewardToken) && t.chainId === chainId,
     )
 
-    if (!equalTlc(rewardToken.address, rc.rewardAddress)) {
+    if (rc.isPendingRemote || !equalTlc(rewardToken.address, rc.rewardAddress)) {
       receiptRewardToken = rewardToken
       rewardToken = allFetchedTokens.find(
         (t) => equalTlc(t.address, rc.rewardAddress) && t.chainId === Number(rc.rewardChainId),
       )
+
+      if (rc.isPendingRemote) {
+        receiptRewardToken = {
+          name: `LaPoste ${rewardToken.name}`,
+          symbol: `p${rewardToken.symbol}`,
+          address: undefined,
+          decimals: rewardToken.decimals,
+          chainId,
+        }
+      }
     }
 
     const decimals = rewardToken ? rewardToken.decimals : 18
@@ -215,6 +310,10 @@ export const fetchCampaigns = async ({ platform, chainId, rpcs }: FetchCampaigns
     const rawCurrentPeriod = rc.periods[indexOfCurrentPeriod]
     const rawPreviousPeriod = rc.periods[indexOfCurrentPeriod - 1]
 
+    const restrictedVotesData = rawCampaignsRestrictedVotes.find(
+      (rvc) => rvc.chainId === rc.campaign.chainId && rvc.campaignId === rc.id && rvc.gauge === rc.campaign.gauge,
+    )
+
     return {
       id: Number(rc.id),
       chainId,
@@ -234,23 +333,13 @@ export const fetchCampaigns = async ({ platform, chainId, rpcs }: FetchCampaigns
       endTimestamp,
       hook: rc.campaign.hook,
       isClosed: rc.isClosed,
+      restrictedVotes: formatEther(restrictedVotesData?.restrictedVotes || Zero),
       addresses: rc.addresses,
       isWhitelist: rc.isWhitelistOnly,
       isBlacklist: !rc.isWhitelistOnly && rc.addresses.length > 0,
-      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),
-        leftover: formatUnits(rawCurrentPeriod.leftover, decimals),
-        updated: rawCurrentPeriod.updated,
-      },
+      previousPeriod: rawPreviousPeriod ? formatPeriod(rawPreviousPeriod, decimals) : undefined,
+      currentPeriod: formatPeriod(rawCurrentPeriod, decimals),
+      periods: rc.periods.map((rawP) => formatPeriod(rawP, decimals)),
       status: {
         voteOpen: endTimestamp - ONE_WEEK > currentTimestamp,
         voteClosed: currentTimestamp > endTimestamp - ONE_WEEK,

package/src/votemarket/fetchPendingRemoteCampaigns.ts

@@ -0,0 +1,141 @@
+import { LA_POSTE_MESSAGE_SENT_EVENT, ONE_WEEK, One, Zero, contract } from '@stake-dao/constants'
+import { range } from 'lodash-es'
+import { decodeAbiParameters, decodeEventLog, parseAbiParameters, zeroAddress } from 'viem'
+import { mainnet } from 'viem/chains'
+
+export const CAMPAIGNS_CHUNK_SIZE = 10
+export const CLAIM_WINDOW_LENGTH = 24 // weeks
+export const CLOSE_WINDOW_LENGTH = 4 // weeks
+
+interface FetchPendingRemoteCampaignsProps {
+  mainnetVmRemote: string
+  chainId: number
+  fromBlock: number
+  etherscanApiKey: string
+  nextIndex: number
+}
+
+export const fetchPendingRemoteCampaigns = async ({
+  mainnetVmRemote,
+  chainId,
+  fromBlock,
+  etherscanApiKey,
+  nextIndex,
+}: FetchPendingRemoteCampaignsProps) => {
+  const queryParams = {
+    chainid: `${mainnet.id}`,
+    module: 'logs',
+    action: 'getLogs',
+    address: contract('laPoste', chainId),
+    topic0: LA_POSTE_MESSAGE_SENT_EVENT.topic,
+    topic0_3_opr: 'and',
+    topic3: mainnetVmRemote.replace('0x', '0x000000000000000000000000'),
+    apikey: etherscanApiKey,
+    fromBlock: `${fromBlock}`,
+  }
+
+  const rawEvents = await fetch(`https://api.etherscan.io/v2/api?${new URLSearchParams(queryParams)}`).then((res) =>
+    res.json(),
+  )
+
+  const campaignsParams: any[] = []
+  const manageParams: any[] = []
+
+  if (rawEvents.message === 'OK') {
+    for (const e of rawEvents.result) {
+      const decodedEvent: any = decodeEventLog({
+        abi: LA_POSTE_MESSAGE_SENT_EVENT.abi,
+        data: e.data,
+        topics: e.topics,
+      })
+
+      try {
+        if (Number(decodedEvent.args.chainId) === chainId) {
+          const payload = decodeAbiParameters(
+            parseAbiParameters([
+              'Payload payload',
+              'struct Payload { uint256 actionType; address sender; bytes parameters }',
+            ]),
+            decodedEvent.args.message.payload,
+          )
+
+          // Create Campaign (actionType === 0)
+          if (payload[0].actionType === Zero) {
+            const decodedParams = decodeAbiParameters(
+              parseAbiParameters([
+                'CampaignCreationParams params',
+                'struct CampaignCreationParams { uint256 chainId; address gauge; address manager; address rewardToken; uint8 numberOfPeriods; uint256 maxRewardPerVote; uint256 totalRewardAmount; address[] addresses; address hook; bool isWhitelist; }',
+              ]),
+              (payload[0] as any).parameters,
+            )
+
+            campaignsParams.push({ decoded: decodedParams[0], eventTimestamp: Number(e.timeStamp) })
+          }
+
+          // Manage Campaign (actionType === 1)
+          if (payload[0].actionType === One) {
+            const decodedParams = decodeAbiParameters(
+              parseAbiParameters([
+                'CampaignManagementParams params',
+                'struct CampaignManagementParams { uint256 campaignId; address rewardToken; uint8 numberOfPeriods; uint256 totalRewardAmount; uint256 maxRewardPerVote; }',
+              ]),
+              (payload[0] as any).parameters,
+            )
+
+            manageParams.push({ decoded: decodedParams[0], eventTimestamp: Number(e.timeStamp) })
+          }
+        }
+      } catch (err) {
+        console.error(err)
+      }
+    }
+  }
+
+  const remoteCampaigns = campaignsParams.map((element) => {
+    const campaignParams = element.decoded
+
+    const totalRewardAmount = campaignParams.totalRewardAmount
+    const maxRewardPerVote = campaignParams.maxRewardPerVote
+    const numberOfPeriods = BigInt(campaignParams.numberOfPeriods)
+
+    const startTimestamp = BigInt(Math.floor(element.eventTimestamp / ONE_WEEK) * ONE_WEEK + ONE_WEEK)
+    const endTimestamp = startTimestamp + numberOfPeriods * BigInt(ONE_WEEK)
+
+    const campaign = {
+      isPendingRemote: true,
+      id: BigInt(nextIndex),
+      addresses: campaignParams.addresses,
+      campaign: {
+        chainId: campaignParams.chainId,
+        startTimestamp,
+        endTimestamp,
+        gauge: campaignParams.gauge,
+        hook: campaignParams.hook,
+        manager: campaignParams.manager,
+        maxRewardPerVote,
+        numberOfPeriods: Number(numberOfPeriods),
+        rewardToken: zeroAddress, // Unknown
+        totalDistributed: Zero,
+        totalRewardAmount,
+      },
+      isKilled: false,
+      isWhitelistOnly: campaignParams.isWhitelist,
+      periodLeft: campaignParams.numberOfPeriods,
+      periods: range(0, Number(numberOfPeriods)).map((index) => ({
+        timestampStart: startTimestamp + BigInt(index) * BigInt(ONE_WEEK),
+        timestampEnd: startTimestamp + BigInt(ONE_WEEK) + BigInt(index) * BigInt(ONE_WEEK),
+        rewardPerPeriod: totalRewardAmount / numberOfPeriods,
+        rewardPerVote: maxRewardPerVote,
+        leftover: Zero,
+        updated: false,
+      })),
+      rewardAddress: campaignParams.rewardToken,
+      rewardChainId: BigInt(mainnet.id),
+    }
+
+    nextIndex++
+    return campaign
+  })
+
+  return { remoteCampaigns, remoteCampaignsUpdate: manageParams }
+}

package/src/votemarket/types.ts

@@ -11,6 +11,7 @@ export type Campaign = {
   gauge: string
   gaugeChainId: number
   manager: string
+  restrictedVotes: string
   rewardChainId: number
   receiptRewardToken: {
     name: string
@@ -41,6 +42,7 @@ export type Campaign = {
   previousPeriod: Period
   currentPeriod: Period
   periodLeft: number
+  periods: Period[]
   status: {
     voteOpen: boolean
     voteClosed: boolean