@stake-dao/reader 0.5.14 → 0.5.16

package/src/strategies/v2/parse.ts

@@ -38,237 +38,254 @@ const baseTokens = {
   },
 }
 
+const protocols = {
+  '0xc715e373': 'curve',
+}
+
+const SUPPORTED_PROTOCOLS = Object.keys(protocols)
+
 export const parseV2Strats = (global: any, rawStrats: any[], extra: any) => {
   try {
-    return rawStrats.map((s) => {
-      const isLending = s.asset.name.startsWith('Llamalend')
-
-      const lpToken = parseAsset(s.asset)
-      const coins = s.asset.components.map((c) => parseAsset(c.childAsset))
-
-      let name = coins.map((c) => c.symbol).join('/')
-      if (name.length > 26 || lpToken?.name?.startsWith('CrossCurve')) name = lpToken.symbol
-      if (isLending) name = s.asset.name
-
-      const lpPriceInUsd =
-        Number(s.gauge.totalSupply) > 0
-          ? Number(s.gauge.totalSupplyUSD) / Number(formatUnits(BigInt(s.gauge.totalSupply || '0'), 18))
-          : 0
-
-      const compoundedYieldKey = isLending ? 'LENDING_INTEREST' : 'TRADING_FEES'
-      const tradingApy = (s.gauge.aprDetails.find((el) => el.yieldType === compoundedYieldKey)?.aprUSD || 0) * 100
-      const otherRewards = s.gauge.aprDetails.filter((el) => el.yieldType !== compoundedYieldKey && el.asset)
-      const merklRewards = (extra?.merklApi || [])
-        .filter((r) => equalTlc(r.explorerAddress, lpToken?.address))
-        .map((r) => ({
-          token: parseAsset(r.rewardsRecord.breakdowns[0]?.token),
-          aprInToken: r.apr / r.rewardsRecord.breakdowns[0]?.token.price || 1,
-          apr: r.apr,
-          streaming: true,
-          periodFinish: 2000000000,
-          yieldType: 'OFFCHAIN',
-        }))
-
-      // Compute rewards from the hook incentive (Votemarket)
-      const hookIncentivesPrices = extra?.hookIncentivesPrices || []
-      const gaugeUsd = Number(s.gauge.totalSupplyUSD)
-
-      const incentivesByToken = (extra?.hookIncentives || [])
-        .filter((r) => equalTlc(r.vault, s.address))
-        .reduce((acc, r) => {
-          const rewardAddress = r.reward
-          const price = hookIncentivesPrices.find((p) => equalTlc(rewardAddress, p.address))?.usdPrice || 0
-
-          const amountToken = Number.parseFloat(formatUnits(r.amount, r.rewardDecimals))
-          const duration = Number.parseInt(r.end) - Number.parseInt(r.start)
-
-          if (duration <= 0) return acc
-
-          const tokensPerSecond = amountToken / duration
-          const yearlyTokens = tokensPerSecond * ONE_YEAR
-          const yearlyRewardsUsd = yearlyTokens * price
-
-          if (!acc[rewardAddress]) {
-            acc[rewardAddress] = {
-              meta: r,
-              price: price,
-              totalYearlyUsd: 0,
-              maxPeriodFinish: Number.parseInt(r.end),
+    const res: any[] = []
+
+    for (const s of rawStrats) {
+      if (SUPPORTED_PROTOCOLS.includes(s.protocolId)) {
+        const protocol = protocols[s.protocolId]
+        const isLending = s.asset.name.startsWith('Llamalend')
+
+        const lpToken = parseAsset(s.asset)
+        const coins = s.asset.components.map((c) => parseAsset(c.childAsset))
+
+        let name = coins.map((c) => c.symbol).join('/')
+        if (name.length > 26 || lpToken?.name?.startsWith('CrossCurve')) name = lpToken.symbol
+        if (isLending) name = s.asset.name
+
+        const lpPriceInUsd =
+          Number(s.gauge.totalSupply) > 0
+            ? Number(s.gauge.totalSupplyUSD) / Number(formatUnits(BigInt(s.gauge.totalSupply || '0'), 18))
+            : 0
+
+        const compoundedYieldKey = isLending ? 'LENDING_INTEREST' : 'TRADING_FEES'
+        const tradingApy = (s.gauge.aprDetails.find((el) => el.yieldType === compoundedYieldKey)?.aprUSD || 0) * 100
+        const otherRewards = s.gauge.aprDetails.filter((el) => el.yieldType !== compoundedYieldKey && el.asset)
+        const merklRewards = (extra?.merklApi || [])
+          .filter((r) => equalTlc(r.explorerAddress, lpToken?.address))
+          .map((r) => ({
+            token: parseAsset(r.rewardsRecord.breakdowns[0]?.token),
+            aprInToken: r.apr / r.rewardsRecord.breakdowns[0]?.token.price || 1,
+            apr: r.apr,
+            streaming: true,
+            periodFinish: 2000000000,
+            yieldType: 'OFFCHAIN',
+          }))
+
+        // Compute rewards from the hook incentive (Votemarket)
+        const hookIncentivesPrices = extra?.baseRewardsPrices || []
+        const gaugeUsd = Number(s.gauge.totalSupplyUSD)
+
+        const incentivesByToken = (extra?.hookIncentives || [])
+          .filter((r) => equalTlc(r.vault, s.address))
+          .reduce((acc, r) => {
+            const rewardAddress = r.reward
+            const price = hookIncentivesPrices.find((p) => equalTlc(rewardAddress, p.address))?.usdPrice || 0
+
+            const amountToken = Number.parseFloat(formatUnits(r.amount, r.rewardDecimals))
+            const duration = Number.parseInt(r.end) - Number.parseInt(r.start)
+
+            if (duration <= 0) return acc
+
+            const tokensPerSecond = amountToken / duration
+            const yearlyTokens = tokensPerSecond * ONE_YEAR
+            const yearlyRewardsUsd = yearlyTokens * price
+
+            if (!acc[rewardAddress]) {
+              acc[rewardAddress] = {
+                meta: r,
+                price: price,
+                totalYearlyUsd: 0,
+                maxPeriodFinish: Number.parseInt(r.end),
+              }
             }
-          }
 
-          acc[rewardAddress].totalYearlyUsd += yearlyRewardsUsd
-          acc[rewardAddress].maxPeriodFinish = Math.max(acc[rewardAddress].maxPeriodFinish, Number.parseInt(r.end))
+            acc[rewardAddress].totalYearlyUsd += yearlyRewardsUsd
+            acc[rewardAddress].maxPeriodFinish = Math.max(acc[rewardAddress].maxPeriodFinish, Number.parseInt(r.end))
 
-          return acc
-        }, {})
+            return acc
+          }, {})
 
-      const hookIncentives = Object.values(incentivesByToken).map((group: any) => {
-        const { meta, price, totalYearlyUsd, maxPeriodFinish } = group
+        const hookIncentives = Object.values(incentivesByToken).map((group: any) => {
+          const { meta, price, totalYearlyUsd, maxPeriodFinish } = group
 
-        const apr = gaugeUsd > 0 ? (totalYearlyUsd / gaugeUsd) * 100 : 0
-
-        return {
-          token: parseAsset({
-            id: meta.id.toString(),
-            name: meta.rewardSymbol,
-            symbol: meta.rewardSymbol,
-            address: meta.reward,
-            decimals: meta.rewardDecimals,
-          }),
-          aprInToken: price > 0 ? apr / price : 0,
-          apr,
-          streaming: true,
-          periodFinish: maxPeriodFinish,
-          yieldType: 'VOTEMARKET',
-        }
-      })
-
-      const rewards = otherRewards
-        .map((r) => ({
-          token: parseAsset(r.asset),
-          aprInToken: r.apr,
-          apr: Number(r.aprUSD) * 100,
-          streaming: true,
-          periodFinish: 2000000000,
-          yieldType: r.yieldType,
-        }))
-        .concat(merklRewards)
-        .concat(hookIncentives)
-        .sort((a, b) => {
-          if (a.token.address === baseTokens.curve[s.chainId]) return -1
-          if (b.token.address === baseTokens.curve[s.chainId]) return 1
-          return 0
+          let _gaugeUsd = gaugeUsd
+          if (_gaugeUsd === 0) {
+            _gaugeUsd = 10_000
+          }
+          const apr = _gaugeUsd > 0 ? (totalYearlyUsd / _gaugeUsd) * 100 : 0
+
+          return {
+            token: parseAsset({
+              id: meta.id.toString(),
+              name: meta.rewardSymbol,
+              symbol: meta.rewardSymbol,
+              address: meta.reward,
+              decimals: meta.rewardDecimals,
+            }),
+            aprInToken: price > 0 ? apr / price : 0,
+            apr,
+            streaming: true,
+            periodFinish: maxPeriodFinish,
+            yieldType: 'VOTEMARKET',
+          }
         })
 
-      const metadata: any = {}
-      for (const m of s.gauge.metadata) metadata[m.key] = m.value
-
-      // Current
-      const totalSupply = BigInt(s.totalSupply)
-      const convexSupply = BigInt(s.sidecarBalance)
-      const stakeDaoSupply = totalSupply - convexSupply
-
-      // Optimal
-      const stakeDaoOptSupply =
-        totalSupply > BigInt(metadata.optimalDepositBalance || '0')
-          ? BigInt(metadata.optimalDepositBalance || '0')
-          : totalSupply
-      const convexOptSupply = totalSupply - stakeDaoOptSupply
-
-      const useVeBoost = s.chainId === mainnet.id && s.gauge?.address !== '0xd8b712d29381748dB89c36BCa0138d7c75866ddF' // MIM/3crv
-
-      const baseReward = rewards.find(
-        (r) => r.yieldType === 'STAKING_REWARDS' && equalTlc(r.token.address, baseTokens.curve[s.chainId]),
-      )
-      const baseRewardPrice =
-        extra.baseRewardsPrices.find((r) => equalTlc(r.address, baseTokens.curve[s.chainId]))?.usdPrice || 0
-      const maxApr = baseReward?.apr || 0
-
-      const onlyboost = getOnlyboostData(
-        {
-          active: s.sidecar !== zeroAddress,
-          convexImpl: s.sidecar,
-          totalSupply,
-          convexSupply,
-          stakeDaoSupply,
-          convexStrategyHoldings: BigInt(metadata.convexTotalSupply || '0'),
-          convexWorkingBalance: BigInt(metadata.workingBalanceConvex || '0'),
-          convexRewardRate: BigInt(metadata.convexRewardRate || '0'),
-          convexOptSupply,
-          stakeDaoOptSupply,
-          claimableData: [],
-        },
-        s.chainId,
-        global[useVeBoost ? 'stakeDaoVeBoost' : 'stakeDaoVeBalance'],
-        global[useVeBoost ? 'convexVeBoost' : 'convexVeBalance'],
-        global.veCrvTotalSupply,
-        BigInt(s.gauge.totalSupply),
-        stakeDaoSupply,
-        BigInt(metadata.workingBalance || '0'),
-        totalSupply,
-        lpPriceInUsd,
-        maxApr,
-        baseRewardPrice,
-      )
-
-      const boost = onlyboost.boost
-      const baseRewardApr = (maxApr / 2.5) * boost * ((100 - V2_FEES) / 100)
-
-      let baseRewardAdded = false
-      const aprDetails = [{ label: isLending ? 'Lending' : 'Trading Fees (APY)', value: [tradingApy] }]
-
-      for (const r of rewards) {
-        if (
-          baseReward &&
-          r.yieldType === 'STAKING_REWARDS' &&
-          r.token.symbol === baseReward.token.symbol &&
-          !baseRewardAdded
-        ) {
-          aprDetails.push({
-            label: `${r.token.symbol} APR (incl. ${withTwoDec(boost)}x boost)`,
-            value: [baseRewardApr || 0],
+        const rewards = otherRewards
+          .map((r) => ({
+            token: parseAsset(r.asset),
+            aprInToken: r.apr,
+            apr: Number(r.aprUSD) * 100,
+            streaming: true,
+            periodFinish: 2000000000,
+            yieldType: r.yieldType,
+          }))
+          .concat(merklRewards)
+          .concat(hookIncentives)
+          .sort((a, b) => {
+            if (a.token.address === baseTokens[protocol][s.chainId]) return -1
+            if (b.token.address === baseTokens[protocol][s.chainId]) return 1
+            return 0
           })
 
-          baseRewardAdded = true
-        } else {
-          const label =
-            r.yieldType === 'VOTEMARKET'
-              ? `${r.token.symbol} APR (Extra Rewards from Votemarket)`
-              : `${r.token.symbol} APR`
-          aprDetails.push({ label, value: [r.apr || 0] })
+        const metadata: any = {}
+        for (const m of s.gauge.metadata) metadata[m.key] = m.value
+
+        // Current
+        const totalSupply = BigInt(s.totalSupply)
+        const convexSupply = BigInt(s.sidecarBalance)
+        const stakeDaoSupply = totalSupply - convexSupply
+
+        // Optimal
+        const stakeDaoOptSupply =
+          totalSupply > BigInt(metadata.optimalDepositBalance || '0')
+            ? BigInt(metadata.optimalDepositBalance || '0')
+            : totalSupply
+        const convexOptSupply = totalSupply - stakeDaoOptSupply
+
+        const useVeBoost = s.chainId === mainnet.id && s.gauge?.address !== '0xd8b712d29381748dB89c36BCa0138d7c75866ddF' // MIM/3crv
+
+        const baseReward = rewards.find(
+          (r) => r.yieldType === 'STAKING_REWARDS' && equalTlc(r.token.address, baseTokens[protocol][s.chainId]),
+        )
+        const baseRewardPrice =
+          extra.baseRewardsPrices.find((r) => equalTlc(r.address, baseTokens[protocol][s.chainId]))?.usdPrice || 0
+        const maxApr = baseReward?.apr || 0
+
+        const onlyboost = getOnlyboostData(
+          {
+            active: s.sidecar !== zeroAddress,
+            convexImpl: s.sidecar,
+            totalSupply,
+            convexSupply,
+            stakeDaoSupply,
+            convexStrategyHoldings: BigInt(metadata.convexTotalSupply || '0'),
+            convexWorkingBalance: BigInt(metadata.workingBalanceConvex || '0'),
+            convexRewardRate: BigInt(metadata.convexRewardRate || '0'),
+            convexOptSupply,
+            stakeDaoOptSupply,
+            claimableData: [],
+          },
+          s.chainId,
+          global[useVeBoost ? 'stakeDaoVeBoost' : 'stakeDaoVeBalance'],
+          global[useVeBoost ? 'convexVeBoost' : 'convexVeBalance'],
+          global.veCrvTotalSupply,
+          BigInt(s.gauge.totalSupply),
+          stakeDaoSupply,
+          BigInt(metadata.workingBalance || '0'),
+          totalSupply,
+          lpPriceInUsd,
+          maxApr,
+          baseRewardPrice,
+        )
+
+        const boost = onlyboost.boost
+        const baseRewardApr = (maxApr / 2.5) * boost * ((100 - V2_FEES) / 100)
+
+        let baseRewardAdded = false
+        const aprDetails = [{ label: isLending ? 'Lending' : 'Trading Fees (APY)', value: [tradingApy] }]
+
+        for (const r of rewards) {
+          if (
+            baseReward &&
+            r.yieldType === 'STAKING_REWARDS' &&
+            r.token.symbol === baseReward.token.symbol &&
+            !baseRewardAdded
+          ) {
+            aprDetails.push({
+              label: `${r.token.symbol} APR (incl. ${withTwoDec(boost)}x boost)`,
+              value: [baseRewardApr || 0],
+            })
+
+            baseRewardAdded = true
+          } else {
+            const label =
+              r.yieldType === 'VOTEMARKET'
+                ? `${r.token.symbol} APR (Extra Rewards from Votemarket)`
+                : `${r.token.symbol} APR`
+            aprDetails.push({ label, value: [r.apr || 0] })
+          }
         }
-      }
 
-      let aprTotal = aprDetails.reduce((total, x) => {
-        for (const v of x.value) total += v
-        return total
-      }, 0)
-      if (aprTotal > 1e18) aprTotal = 2727
-
-      return {
-        key: s.id,
-        tokensFilter: getTokenTypes({ isLending, coins }),
-        isLending,
-        name,
-        type: 'factory-stable-ng',
-        version: 2,
-        protocol: 'curve',
-        chainId: s.chainId,
-        vault: s.address,
-        lpToken,
-        gaugeAddress: s.gauge.address,
-        gauge: {
-          address: s.gauge.address,
-          totalSupply: s.gauge.totalSupply,
-          totalSupplyUsd: s.gauge.totalSupplyUSD,
-          extraRewards: [],
-        },
-        coins,
-        underlyingCoins: [],
-        lpPriceInUsd,
-        streaming: true,
-        tvl: Number(s.totalSupplyUSD) > 10000000000 ? 0 : Number(s.totalSupplyUSD),
-        apr: {
-          boost,
-          current: { total: aprTotal, details: aprDetails },
-        },
-        rewards,
-        tradingApy,
-        minApr: maxApr / 2.5,
-        maxApr,
-        totalSupply: s.totalSupply,
-        workingBalance: metadata?.workingBalance || '0',
-        onlyboost,
-        convexPool:
-          metadata.pid && metadata.convexBaseRewardPool
-            ? {
-                id: Number(metadata.pid),
-                crvRewards: metadata.convexBaseRewardPool,
-              }
-            : undefined,
+        let aprTotal = aprDetails.reduce((total, x) => {
+          for (const v of x.value) total += v
+          return total
+        }, 0)
+        if (aprTotal > 1e18) aprTotal = 2727
+
+        res.push({
+          key: s.id,
+          tokensFilter: getTokenTypes({ isLending, coins }),
+          isLending,
+          name,
+          type: 'factory-stable-ng',
+          version: 2,
+          protocol,
+          chainId: s.chainId,
+          vault: s.address,
+          lpToken,
+          gaugeAddress: s.gauge.address,
+          gauge: {
+            address: s.gauge.address,
+            totalSupply: s.gauge.totalSupply,
+            totalSupplyUsd: s.gauge.totalSupplyUSD,
+            extraRewards: [],
+          },
+          coins,
+          underlyingCoins: [],
+          lpPriceInUsd,
+          streaming: true,
+          tvl: Number(s.totalSupplyUSD) > 10000000000 ? 0 : Number(s.totalSupplyUSD),
+          apr: {
+            boost,
+            current: { total: aprTotal, details: aprDetails },
+          },
+          rewards,
+          tradingApy,
+          minApr: maxApr / 2.5,
+          maxApr,
+          totalSupply: s.totalSupply,
+          workingBalance: metadata?.workingBalance || '0',
+          onlyboost,
+          convexPool:
+            metadata.pid && metadata.convexBaseRewardPool
+              ? {
+                  id: Number(metadata.pid),
+                  crvRewards: metadata.convexBaseRewardPool,
+                }
+              : undefined,
+        })
       }
-    })
+    }
+
+    return res
   } catch (e) {
     console.error(e)
     return []

package/src/votemarket/balancer/fetchUserVlAuraClaimable.ts

@@ -0,0 +1,159 @@
+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 { 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 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) => {
+        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 {
+          user,
+          recipient,
+          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,
+          chainId,
+        }
+      })
+    : undefined
+}
+
+const getMerkleData = async (chainId: number) => {
+  const merkleData = await fetch(
+    `${GH_STAKE_DAO_BOUNTIES_REPORT}/refs/heads/main/bounties-reports/latest/vlAURA/vlaura_merkle${
+      chainId === mainnet.id ? '' : `_${chainId}`
+    }.json`,
+  ).then((res) => res.json())
+
+  return { merkleData }
+}
+
+const validateMerkleRoots = (fetchedRoot: string, merkleData: any) => {
+  return equalTlc(fetchedRoot, merkleData.merkleRoot)
+}
+
+const getMerkleRoots = async (provider: any, user: string) => {
+  const contracts = [contract('vlAuraMerkle', mainnet.id)]
+
+  const result = await multicall(
+    provider,
+    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 {
+    merkleRoot: result[0].result,
+    merkleRecipient: result[1].result,
+  }
+}
+
+const getClaimedData = async (provider: any, tokens: string[], user: string, contract: string) => {
+  const rawClaimed =
+    tokens.length > 0
+      ? await multicall(
+          provider,
+          tokens.flatMap((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,
+  }))
+}
+
+export const fetchUserVlAuraClaimable = async (provider: any, rpc: Rpcs, user: string, chainId: number) => {
+  const { merkleRoot, merkleRecipient } = await getMerkleRoots(provider, user)
+
+  let vlAuraClaimable: any
+
+  try {
+    const { merkleData } = await getMerkleData(chainId)
+    if (validateMerkleRoots(merkleRoot, merkleData)) {
+      vlAuraClaimable = merkleData
+    }
+  } catch {}
+
+  if (!vlAuraClaimable) {
+    console.error('Could not find valid merkle data')
+    return []
+  }
+
+  const vlAuraUser = vlAuraClaimable.claims?.[user]
+
+  const tokens = Object.keys(vlAuraUser?.tokens || {})
+
+  if (!tokens.length) return []
+
+  const claimed = await getClaimedData(provider, tokens, user, contract('vlAuraMerkle'))
+
+  const unknownTokens = tokens.filter((t) => !tokenWithAddress(t))
+  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,
+  }))
+
+  const prices = await getPrices(tokens.map((t) => ({ address: t })) as any[], chainId)
+
+  return [
+    getParsedData(
+      user,
+      merkleRecipient,
+      contract('vlAuraMerkle'),
+      vlAuraUser,
+      unknownTokensData,
+      claimed,
+      prices,
+      chainId,
+    ),
+  ]
+    .filter(Boolean)
+    .flat()
+}

package/src/votemarket/fetchDirectIncentives.ts

@@ -0,0 +1,23 @@
+import { encodeAbiParameters, parseAbiParameters } from 'viem'
+import { mainnet } from 'viem/chains'
+import batchDirectIncentives from '../bytecodes/votemarket/batchDirectIncentives.js'
+import { concatBytecode } from '../index.js'
+import { batchJsonRpc } from '../utils.js'
+
+export const fetchDirectIncentives = async (rpc: string, campaignRewardDistributor: string, start: number) => {
+  const inputData = encodeAbiParameters(parseAbiParameters(batchDirectIncentives.inputType[mainnet.id]!) as any, [
+    campaignRewardDistributor,
+    start,
+  ])
+
+  const call = concatBytecode(batchDirectIncentives.bytecode[mainnet.id]!, inputData)
+
+  const directIncentives = await batchJsonRpc({
+    rpc,
+    calls: [call],
+    outputTypeAbi: batchDirectIncentives.outputTypeHr[mainnet.id],
+    callsKey: `fetch direct incentives - rpc ${rpc}`,
+  })
+
+  return directIncentives
+}