@exodus/ethereum-api 8.73.1 → 8.73.3

package/src/staking/ethereum/staking-utils.js

@@ -1,4 +1,10 @@
-import { EthereumStaking } from './api.js'
+import NumberUnit from '@exodus/currency'
+import { parseUnsignedTx } from '@exodus/ethereum-lib'
+import { bufferToHex } from '@exodus/ethereumjs/util'
+import assert from 'minimalistic-assert'
+
+import { EthereumStaking, UNSTAKE_DEFAULTS } from './api.js'
+import { simulateEverstakeUnstake } from './everstake.js'
 
 const { DELEGATE, UNSTAKE, UNSTAKE_PENDING, CLAIM_UNSTAKE } = EthereumStaking.METHODS_IDS
 
@@ -8,8 +14,13 @@ const STAKING_MANAGER_CONTRACTS = new Set([
   EthereumStaking.addresses.ethereumholesky.EVERSTAKE_ADDRESS_CONTRACT_POOL.toLowerCase(),
 ])
 
+const METHOD_ID_CHAR_LENGTH = 10
+const FIRST_UINT256_END = METHOD_ID_CHAR_LENGTH + 64
+
 export const isEthereumStakingTx = ({ coinName }) =>
   ['ethereum', 'ethereumgoerli', 'ethereumholesky'].includes(coinName)
+export const isEthereumStakingPoolContract = (address) =>
+  typeof address === 'string' && STAKING_MANAGER_CONTRACTS.has(address.toLowerCase())
 export const isEthereumDelegate = (tx) =>
   isEthereumStakingTx(tx) && STAKING_MANAGER_CONTRACTS.has(tx.to) && tx.data?.methodId === DELEGATE
 export const isEthereumUndelegatePending = (tx) =>
@@ -18,3 +29,259 @@ export const isEthereumUndelegate = (tx) =>
   (isEthereumStakingTx(tx) && tx.data?.methodId === UNSTAKE) || isEthereumUndelegatePending(tx)
 export const isEthereumClaimUndelegate = (tx) =>
   isEthereumStakingTx(tx) && tx.data?.methodId === CLAIM_UNSTAKE
+
+export function decodeEthereumStakingFirstUintArg(transactionData) {
+  const txInputHex =
+    (Buffer.isBuffer(transactionData) ? bufferToHex(transactionData) : transactionData) || '0x'
+  assert(typeof txInputHex === 'string', 'expected string transactionData')
+  assert(
+    txInputHex.length >= FIRST_UINT256_END,
+    'expected staking transaction calldata with first uint256 arg'
+  )
+
+  return BigInt(`0x${txInputHex.slice(METHOD_ID_CHAR_LENGTH, FIRST_UINT256_END)}`)
+}
+
+export async function ethereumUnstakePendingOptimisticSideEffectTxLogs({
+  asset: baseAsset,
+  walletAccount,
+  feeAmount,
+  unstakePendingTxId,
+  nonce,
+  estimatedUnstakePendingGasLimit,
+  tipGasPrice,
+  transactionData,
+  txToAddress,
+  date,
+  bundleId,
+}) {
+  let amount
+  try {
+    const decodedAmount = decodeEthereumStakingFirstUintArg(transactionData)
+    amount = baseAsset.currency.baseUnit(decodedAmount.toString())
+  } catch (e) {
+    console.warn(
+      'Could not decode ETH unstakePending transaction data:',
+      unstakePendingTxId,
+      e.message,
+      transactionData
+    )
+    return []
+  }
+
+  return [
+    {
+      assetName: baseAsset.name,
+      walletAccount,
+      txs: [
+        {
+          confirmations: 0,
+          feeAmount,
+          feeCoinName: baseAsset.feeAsset.name,
+          selfSend: false,
+          to: txToAddress,
+          txId: unstakePendingTxId,
+          data: {
+            gasLimit: estimatedUnstakePendingGasLimit,
+            nonce,
+            ...(tipGasPrice && { tipGasPrice: tipGasPrice.toBaseString() }),
+            methodId: UNSTAKE_PENDING,
+            ...(bundleId ? { bundleId } : {}),
+          },
+          coinAmount: amount,
+          coinName: baseAsset.name,
+          currencies: {
+            [baseAsset.name]: baseAsset.currency,
+            [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
+          },
+          date,
+        },
+      ],
+    },
+  ]
+}
+
+export async function ethereumUnstakeOptimisticSideEffectTxLogs({
+  asset: baseAsset,
+  walletAccount,
+  feeAmount,
+  unstakeTxId,
+  nonce,
+  estimatedUnstakeGasLimit,
+  tipGasPrice,
+  transactionData,
+  txToAddress,
+  fromAddress,
+  allowedInterchangeNum = UNSTAKE_DEFAULTS.allowedInterchangeNum,
+  date,
+  bundleId,
+}) {
+  let amountEth
+  try {
+    const decodedAmountWei = decodeEthereumStakingFirstUintArg(transactionData)
+    amountEth = baseAsset.currency.baseUnit(decodedAmountWei.toString()).toDefaultString()
+  } catch (e) {
+    console.warn(
+      'Could not decode ETH unstake transaction data:',
+      unstakeTxId,
+      e.message,
+      transactionData
+    )
+    return []
+  }
+
+  const result = await simulateEverstakeUnstake({
+    address: fromAddress,
+    amount: amountEth,
+    allowedInterchangeNum,
+  })
+
+  if (!result || result.instantReturnEth <= 0) return []
+
+  const instantAmount = baseAsset.currency.defaultUnit(String(result.instantReturnEth))
+
+  return [
+    {
+      assetName: baseAsset.name,
+      walletAccount,
+      txs: [
+        {
+          confirmations: 0,
+          feeAmount,
+          feeCoinName: baseAsset.feeAsset.name,
+          selfSend: false,
+          to: txToAddress,
+          txId: unstakeTxId,
+          data: {
+            gasLimit: estimatedUnstakeGasLimit,
+            nonce,
+            ...(tipGasPrice && { tipGasPrice: tipGasPrice.toBaseString() }),
+            methodId: UNSTAKE,
+            ...(bundleId ? { bundleId } : {}),
+          },
+          coinAmount: instantAmount,
+          coinName: baseAsset.name,
+          currencies: {
+            [baseAsset.name]: baseAsset.currency,
+            [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
+          },
+          date,
+        },
+      ],
+    },
+  ]
+}
+
+export function buildSimulationRequest({ asset, unsignedTx, gasPrice }) {
+  const parsed = parseUnsignedTx({ asset, unsignedTx })
+  const chainId = unsignedTx.txData?.chainId
+  const from = unsignedTx.txMeta?.fromAddress
+  const to = unsignedTx.txMeta?.toAddress
+
+  assert(gasPrice instanceof NumberUnit, 'expected NumberUnit gasPrice')
+  assert(Number.isInteger(chainId), 'expected integer chainId')
+  assert(typeof from === 'string' && from, 'expected string fromAddress')
+  assert(typeof to === 'string' && to, 'expected string toAddress')
+
+  return {
+    chainId,
+    from,
+    to,
+    gas: `0x${parsed.gasLimit.toString(16)}`,
+    gasPrice: `0x${BigInt(gasPrice.toBaseString()).toString(16)}`,
+    value: `0x${BigInt(parsed.value.toBaseString()).toString(16)}`,
+    data: `0x${parsed.data?.toString('hex')}`,
+    nonce: `0x${parsed.nonce.toString(16)}`,
+  }
+}
+
+export async function simulateUndelegateTransactions({
+  asset,
+  txSteps,
+  senderAddress,
+  gasPrice,
+  blockNumber,
+  revertOnSimulationError,
+}) {
+  const transactions = Object.values(txSteps)
+    .filter((txStep) => txStep.unsignedTx)
+    .map((txStep) =>
+      buildSimulationRequest({ asset: asset.baseAsset, unsignedTx: txStep.unsignedTx, gasPrice })
+    )
+
+  if (transactions.length === 0) return
+
+  const simulationResponse = await asset.baseAsset.api.web3.simulateTransactions({
+    baseAssetName: asset.baseAsset.name,
+    origin: 'exodus-staking',
+    senderAddress,
+    ...(blockNumber === undefined ? undefined : { blockNumber }),
+    transactions,
+  })
+
+  if (simulationResponse?.warnings?.length || simulationResponse?.metadata?.humanReadableError) {
+    if (revertOnSimulationError) {
+      const err = new Error('StakingEthUndelegateSimulationError')
+      err.message = simulationResponse?.metadata?.humanReadableError
+      err.reason = `warnings: ${JSON.stringify(simulationResponse?.warnings)}`
+      err.hint = 'undelegate-eth-simulation-error'
+      throw err
+    } else {
+      console.warn(
+        'Simulation for ETH undelegate returned issues',
+        simulationResponse?.metadata?.humanReadableError
+      )
+    }
+  }
+
+  // Validate undelegatePending simulation results.
+  //
+  // Pass: every ETH entry in willReceive has a parseable balance and their
+  //       sum is positive (i.e. we are actually receiving ETH back).
+  // Fail: any ETH entry has a malformed balance (shape error), or the
+  //       summed ETH is zero/negative (no refund, or only non-ETH entries).
+  //
+  // Our on-chain analysis showed an apparent invariant: successful
+  // unstakePending() calls return exactly the input amount. We intentionally
+  // do not enforce that here because we were not able to prove it via
+  // simulation alone and there may be an off-chain component involved.
+  //
+  // When there's no pending balance (only unstake with
+  // allowedInterchangeNum=0), nothing may come back immediately — that's
+  // valid and we skip the check.
+  if (txSteps.undelegatePending.plan?.amount?.isPositive) {
+    const { balanceChanges = Object.create(null) } = simulationResponse || Object.create(null)
+
+    const asArray = (v) => (Array.isArray(v) ? v : [])
+    let invalidEthReceiveValue = false
+    let sumEthReceive = BigInt(0)
+
+    for (const receive of asArray(balanceChanges.willReceive)) {
+      const isEth = receive?.asset?.symbol === 'ETH' || receive?.asset?.name === 'Ether'
+      if (!isEth) continue
+
+      try {
+        sumEthReceive += BigInt(receive.balance.toBaseString())
+      } catch {
+        invalidEthReceiveValue = true
+      }
+    }
+
+    if (invalidEthReceiveValue || sumEthReceive <= BigInt(0)) {
+      if (revertOnSimulationError) {
+        const err = new Error('StakingEthUndelegateSimulationResultsError')
+        err.message = 'Simulation did not produce expected effects'
+        err.reason = invalidEthReceiveValue
+          ? 'invalid ETH balance.value in balanceChanges: willReceive'
+          : 'missing positive ETH in balanceChanges: willReceive (expected pending refund)'
+        err.hint = 'undelegate-eth-simulation-results-error'
+        throw err
+      } else {
+        console.warn(
+          'Simulation for ETH undelegate returned issues',
+          simulationResponse?.metadata?.humanReadableError
+        )
+      }
+    }
+  }
+}

package/src/tx-log/get-optimistic-txlog-effects.js

@@ -8,6 +8,12 @@ import {
 import { bufferToHex } from '@exodus/ethereumjs/util'
 import assert from 'minimalistic-assert'
 
+import { EthereumStaking } from '../staking/ethereum/api.js'
+import {
+  ethereumUnstakeOptimisticSideEffectTxLogs,
+  ethereumUnstakePendingOptimisticSideEffectTxLogs,
+  isEthereumStakingPoolContract,
+} from '../staking/ethereum/staking-utils.js'
 import { MaticStakingApi } from '../staking/matic/api.js'
 import {
   DELEGATE,
@@ -93,6 +99,7 @@ export const getOptimisticTxLogEffects = async ({
     data,
     date,
     bundleId,
+    fromAddress,
   })
 
   // Fallback to basic logic that only handles transfers + fee decoding
@@ -167,6 +174,7 @@ const operationTxLogSideEffects = async ({
   data,
   date,
   bundleId,
+  fromAddress,
 }) => {
   // Matic Delegate
   if (
@@ -188,6 +196,47 @@ const operationTxLogSideEffects = async ({
     })
   }
 
+  // Ethereum Undelegate
+  if (
+    isEthereumStakingPoolContract(txToAddress) &&
+    methodId === EthereumStaking.METHODS_IDS.UNSTAKE_PENDING
+  ) {
+    return ethereumUnstakePendingOptimisticSideEffectTxLogs({
+      asset,
+      walletAccount,
+      feeAmount,
+      unstakePendingTxId: txId,
+      nonce,
+      estimatedUnstakePendingGasLimit: gasLimit,
+      tipGasPrice,
+      transactionData: data,
+      txToAddress,
+      date,
+      bundleId,
+    })
+  }
+
+  // Ethereum Undelegate (unstake from active validator)
+  if (
+    isEthereumStakingPoolContract(txToAddress) &&
+    methodId === EthereumStaking.METHODS_IDS.UNSTAKE
+  ) {
+    return ethereumUnstakeOptimisticSideEffectTxLogs({
+      asset,
+      walletAccount,
+      feeAmount,
+      unstakeTxId: txId,
+      nonce,
+      estimatedUnstakeGasLimit: gasLimit,
+      tipGasPrice,
+      transactionData: data,
+      txToAddress,
+      fromAddress,
+      date,
+      bundleId,
+    })
+  }
+
   // Add other officially supported operations here
   // Then can fallback to simulation results (TODO)
   // Then finally to the default basic logic

package/src/tx-log-staking-processor/asset-staking-tx-data.js

@@ -28,7 +28,10 @@ const getEthereumStakingTxData = ({ tx, currency }) => {
   const txAmount = tx.coinAmount.toDefaultString()
 
   if (isEthereumDelegate(tx)) {
-    return { delegate: txAmount, txAmount }
+    return {
+      coinAmount: currency.ZERO,
+      data: { delegate: txAmount, txAmount },
+    }
   }
 
   // undelegate must be taken in consideration, if unstaked ETH is still
@@ -38,28 +41,33 @@ const getEthereumStakingTxData = ({ tx, currency }) => {
       .baseUnit(decodeEthLikeStakingTxInputAmount(tx))
       .toDefaultString()
     return {
-      undelegatePending,
-      txAmount,
+      coinAmount: currency.ZERO,
+      data: { undelegatePending, txAmount },
     }
   }
 
   if (isEthereumUndelegate(tx)) {
     const undelegate = currency.baseUnit(decodeEthLikeStakingTxInputAmount(tx)).toDefaultString()
-    return { undelegate, txAmount }
+    return {
+      coinAmount: currency.ZERO,
+      data: { undelegate, txAmount },
+    }
   }
 
   // In the case of the ETH being actually staked and earning,
   // unstake has a withdraw period, after that, unstaked can be claimed.
   if (isEthereumClaimUndelegate(tx)) {
-    return { claimUndelegate: txAmount, txAmount }
+    return {
+      coinAmount: currency.ZERO,
+      data: { claimUndelegate: txAmount, txAmount },
+    }
   }
 }
 
 const getPolygonStakingTxData = ({ tx, currency }) => {
-  if (
-    ['delegate', 'undelegate', 'claimUndelegate'].some((stakeTx) => tx.data?.[stakeTx]) &&
-    tx.coinAmount.isZero
-  ) {
+  if (tx.data?.claimUndelegate) return
+
+  if (['delegate', 'undelegate'].some((stakeTx) => tx.data?.[stakeTx]) && tx.coinAmount.isZero) {
     return
   }
 
@@ -69,22 +77,41 @@ const getPolygonStakingTxData = ({ tx, currency }) => {
     const delegate = currency.baseUnit(decodePolygonStakingTxInputAmount(tx)).toDefaultString()
     // MATIC returned in unstake tx is always reward
     const rewards = calculateRewardsFromStakeTx({ tx, currency })
-    return { delegate, txAmount, ...(rewards ? { rewards } : {}) }
+    return {
+      coinAmount: currency.ZERO,
+      data: {
+        delegate,
+        txAmount,
+        ...(rewards ? { rewards } : {}),
+      },
+    }
   }
 
   if (isPolygonUndelegate(tx)) {
     const undelegate = currency.baseUnit(decodePolygonStakingTxInputAmount(tx)).toDefaultString()
     // MATIC returned in unstake tx is always reward
     const rewards = txAmount
-    return { undelegate, txAmount, rewards }
+    return {
+      coinAmount: currency.ZERO,
+      data: { undelegate, txAmount, rewards },
+    }
   }
 
   if (isPolygonClaimUndelegate(tx)) {
-    return { claimUndelegate: txAmount, txAmount }
+    return {
+      // NOTE: We intentionally omit for compatibility with `rx`:
+      //       https://github.com/ExodusMovement/exodus-mobile/blob/229c9c0634af3e8e17eb1624019682c6fffe29bf/src/utils/getTxTag.js#L186
+      //
+      // coinAmount: currency.ZERO,
+      data: {
+        claimUndelegate: txAmount,
+        txAmount,
+      },
+    }
   }
 }
 
-export const assetStakingTxData = {
+export const assetStakingTxProps = {
   polygon: getPolygonStakingTxData,
   ethereum: getEthereumStakingTxData,
   ethereumholesky: getEthereumStakingTxData,

package/src/tx-log-staking-processor/index.js

@@ -1,9 +1,5 @@
 import { getPolygonUndelegateTxInEthereumTxLog } from '../staking/matic/matic-staking-utils.js'
-import { assetStakingTxData } from './asset-staking-tx-data.js'
-
-const getTxStakingData = ({ assetName, currency, tx }) => {
-  return assetStakingTxData[assetName]({ tx, currency })
-}
+import { assetStakingTxProps } from './asset-staking-tx-data.js'
 
 const getAssetExpandedTxLog = async ({ assetName, aci, txs, walletAccount }) => {
   const additionalTxs = []
@@ -27,14 +23,14 @@ const processTxLog = async ({ asset, assetClientInterface: aci, walletAccount, b
 
   const newTxs = []
   for (const tx of txs) {
-    const stakingData = getTxStakingData({ assetName, currency, tx })
-    if (stakingData) {
-      newTxs.push({
-        ...tx,
-        coinAmount: currency.ZERO,
-        data: { ...tx.data, ...stakingData },
-      })
-    }
+    const stakingProps = assetStakingTxProps[assetName]?.({ tx, currency })
+    if (!stakingProps) continue
+
+    newTxs.push({
+      ...tx,
+      ...stakingProps,
+      data: { ...tx.data, ...stakingProps.data },
+    })
   }
 
   const expandedTxs = await getAssetExpandedTxLog({ assetName, aci, txs, walletAccount })

package/src/tx-send/nonce-utils.js

@@ -55,7 +55,9 @@ const getNonceFromTxLog = ({ txLog, useAbsoluteNonce, tag }) => {
   let absoluteNonce = 0
 
   if (useAbsoluteNonce) {
-    const reversedTxLog = txLog.reverse()
+    // NOTE: Use a copy to avoid mutating the caller's `txLog` array, since
+    //       `Array.prototype.reverse()` reverses in-place.
+    const reversedTxLog = [...txLog].reverse()
     const maybeLatestTxWithNonceChange = getLatestTxWithNonceChange({ reversedTxLog })
 
     if (maybeLatestTxWithNonceChange) {

package/src/etherscan/account.js

@@ -1,50 +0,0 @@
-import assert from 'minimalistic-assert'
-
-import request from './request.js'
-
-const isValidResponseCheck = (x) =>
-  (x.status === '1' && x.message === 'OK') || x.message === 'No transactions found'
-const _request = async (...args) => request(isValidResponseCheck, 'account', ...args)
-
-export async function fetchBalance(address) {
-  const balance = await _request('balance', { address })
-
-  const isValid = /^\d+$/.test(balance)
-  if (!isValid) throw new RangeError(`Invalid balance: ${balance}`)
-
-  return balance
-}
-
-export async function fetchTxlist(address, options) {
-  const params = { startblock: 0, endblock: 'latest', ...options, address }
-  const txlist = await _request('txlist', params)
-
-  // simple check
-  assert(Array.isArray(txlist), `Invalid transactions: ${txlist}`)
-
-  return txlist
-}
-
-export async function fetchTxlistinternal(address, options) {
-  const params = { startblock: 0, endblock: 'latest', ...options, address }
-  const txlist = await _request('txlistinternal', params)
-
-  // simple check
-  assert(Array.isArray(txlist), `Invalid transactions: ${txlist}`)
-
-  return txlist
-}
-
-export async function tokenBalance(token, address) {
-  const params = {
-    [token.length === 42 ? 'contractaddress' : 'tokenname']: token,
-    address,
-    tag: 'latest',
-  }
-  const balance = await _request('tokenbalance', params)
-
-  const isValid = /^\d+$/.test(balance)
-  if (!isValid) throw new RangeError(`Invalid balance: ${balance}`)
-
-  return balance
-}

package/src/etherscan/index.js

@@ -1,28 +0,0 @@
-import createWebSocket from './ws.js'
-
-export const ETHERSCAN_WS_URL = 'wss://socket.etherscan.io/wshandler'
-
-export const ws = createWebSocket(ETHERSCAN_WS_URL)
-
-export function filterTxsSent(addr, etherscanTxs) {
-  return etherscanTxs.filter((tx) => tx.from.toLowerCase() === addr.toLowerCase())
-}
-
-export function filterTxsReceived(addr, etherscanTxs) {
-  return etherscanTxs.filter((tx) => tx.to.toLowerCase() === addr.toLowerCase())
-}
-
-export { fetchBalance, fetchTxlistinternal, fetchTxlist, tokenBalance } from './account.js'
-export {
-  sendRawTransaction,
-  getTransactionCount,
-  estimateGas,
-  getTransactionReceipt,
-  getCode,
-  ethCall,
-  gasPrice,
-} from './proxy.js'
-
-export { setEtherscanApiKey as setApiKey } from './request.js'
-
-export { getLogs } from './logs.js'

package/src/etherscan/logs.js

@@ -1,17 +0,0 @@
-import assert from 'minimalistic-assert'
-
-import request from './request.js'
-
-const isValidResponseCheck = (x) =>
-  (x.status === '1' && x.message === 'OK') || x.message === 'No records found'
-const _request = async (...args) => request(isValidResponseCheck, 'logs', ...args)
-
-export async function getLogs(address, fromBlock, toBlock, options) {
-  const params = { ...options, address, fromBlock, toBlock }
-  const events = await _request('getLogs', params)
-
-  // simple check
-  assert(Array.isArray(events), `Invalid transactions: ${events}`)
-
-  return events
-}

package/src/etherscan/proxy.js

@@ -1,48 +0,0 @@
-import request from './request.js'
-
-const isValidResponseCheck = (x) => x.result !== undefined
-const _request = async (...args) => request(isValidResponseCheck, 'proxy', ...args)
-
-export async function sendRawTransaction(data) {
-  const _data = data instanceof Uint8Array ? Buffer.from(data).toString('hex') : data
-  const txhash = await _request('eth_sendRawTransaction', { hex: '0x' + _data })
-
-  const isValidTxHash = /^0x[\dA-Fa-f]{64}$/.test(txhash)
-  if (!isValidTxHash) throw new Error(`Invalid tx hash: ${txhash}`)
-
-  return txhash.slice(2)
-}
-
-export async function getTransactionCount(address, tag = 'latest') {
-  return _request('eth_getTransactionCount', { address, tag })
-}
-
-export async function getTransactionReceipt(txhash) {
-  return _request('eth_getTransactionReceipt', { txhash })
-}
-
-export async function estimateGas(data) {
-  return _request('eth_estimateGas', data)
-}
-
-export async function getCode(address) {
-  const code = await _request('eth_getCode', { address })
-
-  const isValidCode = /^0x[\dA-Fa-f]*$/.test(code) && code.length % 2 === 0
-  if (!isValidCode) throw new Error(`Invalid address code: ${code}`)
-
-  return code
-}
-
-export async function gasPrice() {
-  const price = await _request('eth_gasPrice')
-
-  const isValidPrice = /^0x[\dA-Fa-f]+$/.test(price)
-  if (!isValidPrice) throw new Error(`Invalid price: ${price}`)
-
-  return price
-}
-
-export async function ethCall(data) {
-  return _request('eth_call', data)
-}

package/src/etherscan/request.js

@@ -1,26 +0,0 @@
-import fetchival from '@exodus/fetch/experimental/fetchival'
-import makeConcurrent from 'make-concurrent'
-import ms from 'ms'
-
-const ETHERSCAN_API_URL = 'https://api.etherscan.io/api'
-const DEFAULT_ETHERSCAN_API_KEY = 'XM3VGRSNW1TMSIR14I9MVFP15X74GNHTRI'
-
-let etherscanApiKey = DEFAULT_ETHERSCAN_API_KEY
-
-export function setEtherscanApiKey(apiKey) {
-  etherscanApiKey = apiKey || DEFAULT_ETHERSCAN_API_KEY
-}
-
-export default makeConcurrent(
-  async function (isValidResponseCheck, module, action, params = {}) {
-    const data = await fetchival(new URL(ETHERSCAN_API_URL), { timeout: ms('15s') }).get({
-      ...params,
-      module,
-      action,
-      apiKey: etherscanApiKey,
-    })
-    if (!isValidResponseCheck(data)) throw new Error(`Invalid response: ${JSON.stringify(data)}`)
-    return data.result
-  },
-  { concurrency: 3 }
-)