@stake-dao/reader 0.4.34 → 0.4.36

package/src/lockers/fetch/index.ts

@@ -1,11 +1,11 @@
-import { type Locker, ONE_YEAR, Zero, delegationWithId, lockers } from '@stake-dao/constants'
+import { type Locker, ONE_YEAR, RPC, Zero, contract, lockers } from '@stake-dao/constants'
 import { formatUnits, parseAbi, zeroAddress } from 'viem'
-import { fraxtal, mainnet } from 'viem/chains'
+import { mainnet } from 'viem/chains'
 import lockersMulticallAbi from '../../abis/lockersMulticall.js'
 import { getSdtInflationData } from '../../index.js'
 import type { Price } from '../../prices.js'
 import { handlePromise } from '../../strategies/utils/promise.js'
-import { type Call, type MultiChainCall, equalTlc, multicall, multichainMulticall } from '../../utils.js'
+import { type Call, type MultiChainCall, equalTlc, multicall, multichainMulticall, rpcCall } from '../../utils.js'
 import { extractFees, feeCalls } from '../utils/callsForLockers/feeCalls.js'
 import callsForLockers from '../utils/callsForLockers/index.js'
 import getBribesRewardsData, { type TBribesRewards } from '../utils/getBribesRewardsData.js'
@@ -73,7 +73,7 @@ export const fetchLockers = async ({ provider, chainId, prices, withAirdropGraph
     lockersFeeCalls.push(...feeCalls(locker.id, locker.modules.accumulator))
   }
 
-  const [rawLockersData, rawLockersSideChainData, rawLockersRewardsData] = await handlePromise(
+  const [rawLockersData, rawLockersSideChainData, rawLockersRewardsData, rawVeSdtTotalSupply] = await handlePromise(
     [
       multicall(provider, lockersCalls.concat(lockersFeeCalls), lockersMulticallAbi),
       multichainMulticall(lockersSideChainsCalls, lockersMulticallAbi),
@@ -84,6 +84,7 @@ export const fetchLockers = async ({ provider, chainId, prices, withAirdropGraph
           'function reward_data(address) external view returns (address,address,uint256,uint256,uint256,uint256)',
         ]),
       ),
+      rpcCall(RPC[mainnet.id], [{ to: contract('veSdt', mainnet.id), data: '0x18160ddd' }]),
     ],
     'lockerMulticalls',
   )
@@ -91,6 +92,7 @@ export const fetchLockers = async ({ provider, chainId, prices, withAirdropGraph
   const lockersFees = extractFees(chainLockers, rawLockersData)
 
   const sdtInflationData = chainId === mainnet.id ? await getSdtInflationData(provider) : undefined
+  const veSdtTotalSupply = BigInt(rawVeSdtTotalSupply[0].result)
 
   const lockerData = chainLockers.map(async (locker) => {
     const lockerCallsLength = callsForLockers(
@@ -135,7 +137,7 @@ export const fetchLockers = async ({ provider, chainId, prices, withAirdropGraph
         ? formatUnits(chunkedRawLockersData[7].result, locker.token.decimals)
         : '0'
     const amountTokenNotLock = formatUnits(chunkedRawLockersData[8].result, locker.token.decimals)
-    const veSdtTotalSupply = chainId === mainnet.id ? chunkedRawLockersData[9].result : '0'
+    // const veSdtTotalSupply = chainId === mainnet.id ? chunkedRawLockersData[9].result : '0'
 
     const voteBooster = parseVoteBoosterData(locker, chunkedRawLockersData)
     const peg = parsePeg(locker, chunkedRawLockersData)
@@ -209,57 +211,28 @@ export const fetchLockers = async ({ provider, chainId, prices, withAirdropGraph
       }
     })
 
-    let bribeMinApr = 0
-    let bribeMaxApr = 0
-    let bribeRewards: TBribesRewards | undefined = undefined
+    let _workingSupply = chainId === mainnet.id ? gaugeWorkingSupply : totalSupplyStaked
+    let _veSdtTotalSupply = veSdtTotalSupply
+    let _veBalanceOfLocker = veBalanceOfLocker
 
-    if (chainId === mainnet.id || chainId === fraxtal.id) {
-      let _workingSupply = gaugeWorkingSupply
-      let _veSdtTotalSupply = veSdtTotalSupply
-      let _veBalanceOfLocker = veBalanceOfLocker
-
-      if (locker.id === 'fxs') {
-        _workingSupply = httpCalls.sdfxsWorkingData.working_supply.toString()
-        _veSdtTotalSupply = BigInt(httpCalls.sdfxsWorkingData.veSDT_total_supply)
-        _veBalanceOfLocker = (httpCalls.sdfxsWorkingData.veBalance * 4).toString()
-      }
+    if (locker.id === 'fxs') {
+      _workingSupply = httpCalls.sdfxsWorkingData.working_supply.toString()
+      _veSdtTotalSupply = BigInt(httpCalls.sdfxsWorkingData.veSDT_total_supply)
+      _veBalanceOfLocker = (httpCalls.sdfxsWorkingData.veBalance * 4).toString()
+    }
 
-      const data = getBribesRewardsData(
-        locker,
-        httpCalls.bribesData,
-        _veSdtTotalSupply,
-        totalSupplyStaked,
-        _veBalanceOfLocker,
-        _workingSupply,
-      )
-
-      bribeMinApr = data.bribeMinApr
-      bribeMaxApr = data.bribeMaxApr
-      bribeRewards = data.bribeRewards
-    } else if (locker.id === 'cake') {
-      let _veBalanceOfLocker = Number(veBalanceOfLocker)
-
-      // Add sidechain veBalance
-      if (sideChains && sideChains.length > 0) {
-        _veBalanceOfLocker +=
-          sideChains?.reduce((acc: number, sideChain) => acc + Number(sideChain.veBalanceOfLocker), 0) || 0
-      }
+    const data = getBribesRewardsData(
+      locker,
+      httpCalls.bribesData,
+      _veSdtTotalSupply,
+      totalSupplyStaked,
+      _veBalanceOfLocker,
+      _workingSupply,
+    )
 
-      const apr =
-        (httpCalls.bribesData?.[delegationWithId(locker.id)!] || 0) * (_veBalanceOfLocker / Number(totalSupplyStaked))
-
-      bribeMinApr = apr
-      bribeMaxApr = apr
-      bribeRewards = {
-        bribeMinApr: apr,
-        bribeMaxApr: apr,
-        bribeAverageApr: apr,
-        minBoost: '0',
-        maxBoost: '0',
-        hideBoostTab: true,
-        token: `sd${locker.id}`,
-      }
-    }
+    const bribeMinApr: number = data.bribeMinApr
+    const bribeMaxApr: number = data.bribeMaxApr
+    const bribeRewards: TBribesRewards | undefined = data.bribeRewards
 
     // Total APR
     const minRewardsAprs = rewardsData.reduce((x, y) => x + y.apr, 0) + bribeMinApr

package/src/lockers/utils/getBribesRewardsData.ts

@@ -27,6 +27,7 @@ const getBribesRewardsData = (
     { id: 'bal', value: bribesData?.[delegationWithId('bal')!] / 100 || 0 },
     { id: 'fxs', value: bribesData?.[delegationWithId('fxs')!] / 100 || 0 }, // 1 FXS = 4 veFXS
     { id: 'angle', value: bribesData?.[delegationWithId('angle')!] / 100 || 0 },
+    { id: 'cake', value: bribesData?.[delegationWithId('cake')!] / 100 || 0 },
     { id: 'pendle', value: bribesData?.[delegationWithId('pendle')!] / 100 || 0 },
     { id: 'fxn', value: bribesData?.[delegationWithId('fxn')!] / 100 || 0 },
   ]

package/src/strategies/pendle/fetch.ts

@@ -180,12 +180,14 @@ export const fetchPendle = async ({ prices, provider, rpc, explorerApiKey, explo
     if (pendleStratApiData.underlyingRewardApy > 0) {
       const extraApiData = pendleApiExtraData.find((el) => equalTlc(el.address, s.lpToken.address))
       extraRewards = extraApiData.underlyingRewardApyBreakdown.map((r) => {
-        const nonBoostedApr = (r.absoluteApy * (100 - STRAT_FEES)) / 2.5
+        // const nonBoostedApr = (r.absoluteApy * (100 - STRAT_FEES)) / 2.5
+        const nonBoostedApr =
+          r.absoluteApy * 100 * (extraApiData.totalSy / (extraApiData.totalSy + extraApiData.totalPt))
         return {
-          address: r.address,
-          name: r.name,
-          symbol: r.symbol,
-          decimals: r.decimals,
+          address: r.asset.address,
+          name: r.asset.name,
+          symbol: r.asset.symbol,
+          decimals: r.asset.decimals,
           apy: nonBoostedApr * boost,
         }
       })

package/src/utils.ts

@@ -140,16 +140,34 @@ export const ethGetTxsReceipts = async (rpc: string, txHashes: string[]) => {
   return request
 }
 
+export const ethEstimateGas = async (rpc: string, from: string, to: string, data: string) => {
+  const request = (
+    await fetch(rpc, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        id: 0,
+        jsonrpc: '2.0',
+        method: 'eth_estimateGas',
+        params: [{ from, to, data }],
+      }),
+    })
+  ).json()
+
+  return request
+}
+
 export interface BatchJsonRpcArgs {
   rpc: string
   calls: string[]
   outputTypeAbi: any | any[]
   parse?: boolean
+  raw?: boolean
   callsKey: string
 }
 
 export const batchJsonRpc = async (args: BatchJsonRpcArgs) => {
-  const { rpc, calls, outputTypeAbi, parse = true, callsKey } = args
+  const { rpc, calls, outputTypeAbi, parse = true, raw = false, callsKey } = args
 
   if (calls.length > 0) {
     const rpcRequests = await (
@@ -173,7 +191,9 @@ export const batchJsonRpc = async (args: BatchJsonRpcArgs) => {
       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)
+        : raw
+          ? [res.result]
+          : decodeAbiParameters(parse ? (parseAbiParameters(abi) as any) : abi, res.result)
 
       if (isError) {
         console.error(value)

package/src/votemarket/fetchCampaigns.ts

@@ -25,7 +25,6 @@ export const CLOSE_WINDOW_LENGTH = 4 // weeks
 interface FetchCampaignsProps {
   platform: string
   gaugeController: string
-  veToken: string
   chainId: number
   rpcs: { [chainId: number]: string }
   etherscanApiKey?: string
@@ -93,10 +92,16 @@ const updateEpoch = ({
   return 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,
-  veToken,
   chainId,
   rpcs,
   etherscanApiKey,
@@ -171,7 +176,6 @@ export const fetchCampaigns = async ({
     .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, [
-      veToken,
       gaugeController,
       restrictedVoteChunk,
     ])
@@ -333,21 +337,9 @@ export const fetchCampaigns = async ({
       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,
-      },
-      periods: rc.periods,
+      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/types.ts

@@ -42,6 +42,7 @@ export type Campaign = {
   previousPeriod: Period
   currentPeriod: Period
   periodLeft: number
+  periods: Period[]
   status: {
     voteOpen: boolean
     voteClosed: boolean