@exodus/ethereum-api 9.0.0-alpha.2 → 9.0.0

package/src/tx-log/ethereum-monitor.js

@@ -1,31 +1,33 @@
-import { isRpcBalanceAsset, getAssetAddresses } from '@exodus/ethereum-lib'
+import { BaseMonitor } from '@exodus/asset-lib'
+import { getAssetAddresses } from '@exodus/ethereum-lib'
+import lodash from 'lodash'
 
+import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
+import { fromHexToString } from '../number-utils.js'
 import {
   checkPendingTransactions,
+  excludeUnchangedTokenBalances,
   getAllLogItemsByAsset,
-  getLogItemsFromServerTx,
   getDeriveDataNeededForTick,
   getDeriveTransactionsToCheck,
   getHistoryFromServer,
-  excludeUnchangedTokenBalances,
-} from './monitor-utils'
-
+  getLogItemsFromServerTx,
+  isUnverifiablePendingTxExpired,
+  verifyRpcPendingTxStatusBatch,
+} from './monitor-utils/index.js'
 import {
   enableWSUpdates,
   subscribeToGasPriceNotifications,
   subscribeToWSNotifications,
-} from './ws-updates'
-
-import { isEmpty } from 'lodash'
+} from './ws-updates.js'
 
-import { BaseMonitor } from '@exodus/asset-lib'
-import { fromHexToString } from '../number-utils'
+const { isEmpty } = lodash
 
 // The base ethereum monitor class handles listening for, fetching,
 // formatting, and populating-to-state all ETH/ETC/ERC20 transactions.
 
 export class EthereumMonitor extends BaseMonitor {
-  constructor({ server, config, ...args }) {
+  constructor({ server, config, rpcBalanceAssetNames, webSocketEnabled = true, ...args }) {
     super(args)
     this.server = server
     this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
@@ -37,6 +39,8 @@ export class EthereumMonitor extends BaseMonitor {
     this.addHook('before-start', (...args) => this.beforeStart(...args))
     this.addHook('after-stop', (...args) => this.afterStop(...args))
     this.subscribedToGasPriceMap = new Map()
+    this._webSocketEnabled = webSocketEnabled
+    this.rpcBalanceAssetNames = rpcBalanceAssetNames
   }
 
   setServer(config = {}) {
@@ -71,16 +75,21 @@ export class EthereumMonitor extends BaseMonitor {
 
   // eslint-disable-next-line no-undef
   async checkPendingTransactions(params) {
-    const { pendingTransactionsToCheck, pendingTransactionsGroupedByAddressAndNonce } =
-      checkPendingTransactions(params)
+    const {
+      pendingTransactionsToCheck,
+      pendingTransactionsGroupedByAddressAndNonce,
+      recentPendingTransactions,
+    } = checkPendingTransactions(params)
     const txsToRemove = []
     const {
       assetSource: { walletAccount },
     } = params
 
-    const updateTx = (tx, asset, { isTxConfirmed, remove }) => {
+    const updateTx = (tx, asset, { isTxConfirmed, remove, preserve }) => {
       if (remove) {
         txsToRemove.push({ tx, assetSource: { asset, walletAccount } })
+      } else if (preserve) {
+        params.logItemsByAsset[asset].push(tx)
       } else {
         params.logItemsByAsset[asset].push({
           ...tx,
@@ -97,10 +106,15 @@ export class EthereumMonitor extends BaseMonitor {
             assetSource: { asset: assetName, walletAccount },
           })
         } else if (tokenTxSet && tokenTxSet.has(tx.txId)) {
-          params.logItemsByAsset[assetName].push({
-            ...tokenTxSet.get(tx.txId),
-            ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error: 'Dropped' }),
-          })
+          // Optional: the stored tx may name a token since removed from the registry
+          params.logItemsByAsset[assetName]?.push(
+            preserve
+              ? tokenTxSet.get(tx.txId)
+              : {
+                  ...tokenTxSet.get(tx.txId),
+                  ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error: 'Dropped' }),
+                }
+          )
         }
       })
 
@@ -113,20 +127,50 @@ export class EthereumMonitor extends BaseMonitor {
       if (replaced) {
         await updateTx(tx, assetName, { remove: true })
         delete pendingTransactionsToCheck[tx.txId]
+        delete recentPendingTransactions[tx.txId]
       }
     }
 
+    // Batch verify all pending txs with a single RPC call
+    const txIds = Object.keys(pendingTransactionsToCheck)
+    const statuses = await verifyRpcPendingTxStatusBatch({
+      server: this.server,
+      logger: this.logger,
+      txIds,
+    })
+
     for (const { tx, assetName } of Object.values(pendingTransactionsToCheck)) {
-      if (params.refresh) {
-        await updateTx(tx, assetName, { remove: true })
-      } else {
-        // FIXME: Fetching unconfirmed txs from node helps to avoid
-        // flagging on-chain confirmed txs as dropped in the wallet.
-        // Once the real bug is found, remove this logic
-        const response = await this.server.getTransactionByHash(tx.txId)
-        const isTxConfirmed = response?.result?.blockNumber !== null
-        this.logger.warn(`tx ${tx.txId} confirmed: ${isTxConfirmed}`)
-        await updateTx(tx, assetName, { isTxConfirmed })
+      const txStatus = statuses[tx.txId]
+      if (txStatus?.status === 'confirmed') {
+        await updateTx(tx, assetName, { isTxConfirmed: true })
+      } else if (txStatus?.status === 'dropped') {
+        if (params.refresh) {
+          await updateTx(tx, assetName, { remove: true })
+        } else {
+          await updateTx(tx, assetName, { isTxConfirmed: false })
+        }
+      } else if (params.refresh) {
+        // No txStatus at all means the whole verification batch failed - evidence
+        // about nothing, so preserve unconditionally; the age ceiling only applies
+        // to a per-entry 'unknown' verdict (evidence about that one hash).
+        if (!txStatus || txStatus.status === 'pending' || !isUnverifiablePendingTxExpired(tx)) {
+          // Still in the mempool (or not verifiable yet) but missing from the history
+          // server response: re-add it so the refresh overwrite cannot wipe it and
+          // break tx-log-based nonce resolution.
+          await updateTx(tx, assetName, { preserve: true })
+        } else {
+          // Unverifiable past the age ceiling: purge so a hash the node keeps
+          // erroring on cannot pin nonce derivation forever.
+          await updateTx(tx, assetName, { remove: true })
+        }
+      }
+      // non-refresh: 'pending' or unknown - tx still in mempool, do nothing
+    }
+
+    if (params.refresh) {
+      // Too recent for a reliable on-chain verdict - always survive the refresh overwrite
+      for (const { tx, assetName } of Object.values(recentPendingTransactions)) {
+        await updateTx(tx, assetName, { preserve: true })
       }
     }
 
@@ -154,7 +198,7 @@ export class EthereumMonitor extends BaseMonitor {
       server: this.server,
       ourWalletAddress: derivedData.ourWalletAddress,
       minimumConfirmations: derivedData.minimumConfirmations,
-      index: refresh ? 0 : derivedIndex ?? 0,
+      index: refresh ? 0 : (derivedIndex ?? 0),
     })
     const hasNewIndex = !derivedIndex || index > derivedIndex
 
@@ -188,7 +232,7 @@ export class EthereumMonitor extends BaseMonitor {
     await this.updateTxLogByAsset({ logItemsByAsset, walletAccount, refresh })
 
     if (refresh || hasNewIndex) {
-      const unknownTokenAddresses = this._getUnknownTokenAddresses({
+      const unknownTokenAddresses = this.getUnknownTokenAddresses({
         transactions: allTransactionsFromServer,
         tokensByAddress,
       })
@@ -198,19 +242,13 @@ export class EthereumMonitor extends BaseMonitor {
     }
   }
 
-  async updateGasPrice({ gasPrice, baseFeePerGas }) {
+  async updateGasPrice(fetchedGasPrices) {
     try {
-      const feeConfig = {
-        gasPrice: `${parseInt(gasPrice, 16)} wei`,
-      }
-      if (baseFeePerGas) {
-        feeConfig.baseFeePerGas = `${parseInt(baseFeePerGas, 16)} wei`
-      }
-
-      this.logger.debug(
-        `Update ${this.asset.name} gas price: ${feeConfig.gasPrice}, baseFeePerGas: ${feeConfig.baseFeePerGas}`
-      )
-      await this.aci.updateFeeConfig({ assetName: this.asset.name, feeConfig })
+      await executeEthLikeFeeMonitorUpdate({
+        assetClientInterface: this.aci,
+        feeAsset: this.asset,
+        fetchedGasPrices,
+      })
     } catch (e) {
       this.logger.warn('error updating gasPrice', e)
     }
@@ -218,9 +256,9 @@ export class EthereumMonitor extends BaseMonitor {
 
   async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
     const asset = this.asset
-    const newAccountState = {}
+    const newAccountState = Object.create(null)
     const server = this.server
-    if (isRpcBalanceAsset(asset)) {
+    if (this.rpcBalanceAssetNames.includes(asset.name)) {
       const result = await server.getBalanceProxied(ourWalletAddress)
       const balance = fromHexToString(result)
       newAccountState.balance = asset.currency.baseUnit(balance)
@@ -228,7 +266,7 @@ export class EthereumMonitor extends BaseMonitor {
 
     const tokenBalancePairs = await Promise.all(
       tokens
-        .filter((token) => isRpcBalanceAsset(token) && token.contract.address)
+        .filter((token) => this.rpcBalanceAssetNames.includes(token.name) && token.contract.address)
         .map(async (token) => {
           const { confirmed } = await server.balanceOf(ourWalletAddress, token.contract.address)
           const value = token.currency.baseUnit(confirmed[token.contract.address] || 0)
@@ -243,7 +281,7 @@ export class EthereumMonitor extends BaseMonitor {
 
   async getReceiveAddressesByWalletAccount() {
     const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
-    const addressesByAccount = {}
+    const addressesByAccount = Object.create(null)
     for (const walletAccount of walletAccounts) {
       addressesByAccount[walletAccount] = await this.aci.getReceiveAddresses({
         assetName: this.asset.name,
@@ -256,6 +294,8 @@ export class EthereumMonitor extends BaseMonitor {
   }
 
   async _subscribeToWSNotifications() {
+    if (this._webSocketEnabled === false) return
+
     const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
     subscribeToWSNotifications({
       addressesByWalletAccount,
@@ -264,7 +304,7 @@ export class EthereumMonitor extends BaseMonitor {
     })
   }
 
-  _getUnknownTokenAddresses({ transactions, tokensByAddress }) {
+  getUnknownTokenAddresses({ transactions, tokensByAddress }) {
     const set = transactions.reduce((acc, txn) => {
       const transfers = txn.erc20 || []
       transfers.forEach((transfer) => {
@@ -279,6 +319,12 @@ export class EthereumMonitor extends BaseMonitor {
   }
 
   async beforeStart() {
+    await this._enableWSUpdates()
+  }
+
+  async _enableWSUpdates() {
+    if (this._webSocketEnabled === false) return
+
     const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
     enableWSUpdates({
       interval: this.interval,

package/src/tx-log/ethereum-no-history-monitor.js

@@ -1,26 +1,30 @@
+import { BaseMonitor } from '@exodus/asset-lib'
+import { SynchronizedTime } from '@exodus/basic-utils'
 import { Tx } from '@exodus/models'
+import lodash from 'lodash'
 
+import { applyRemoteConfigEip7702Whitelist, createEip7702Whitelist } from '../eip7702-whitelist.js'
+import { getBatchedRpcBalances } from './monitor-utils/get-batched-rpc-balances.js'
+import { UNCONFIRMED_TX_LIMIT } from './monitor-utils/get-derive-transactions-to-check.js'
 import {
+  excludeUnchangedTokenBalances,
+  getCurrentBlackListStatus,
+  getCurrentEIP7702Delegation,
   getDeriveDataNeededForTick,
   getDeriveTransactionsToCheck,
-  excludeUnchangedTokenBalances,
-} from './monitor-utils'
-
-import { isEmpty, unionBy, zipObject } from 'lodash'
+} from './monitor-utils/index.js'
 
-import { BaseMonitor } from '@exodus/asset-lib'
-
-import { UNCONFIRMED_TX_LIMIT } from './monitor-utils/get-derive-transactions-to-check'
-import { fromHexToString } from '../number-utils'
-import { SynchronizedTime } from '@exodus/basic-utils'
+const { isEmpty, unionBy, zipObject } = lodash
 
 // The base ethereum monitor no history class handles listening for assets with no history
 
 export class EthereumNoHistoryMonitor extends BaseMonitor {
-  constructor({ server, config, ...args }) {
+  constructor({ server, config, eip7702Supported, eip7702Whitelist, getBlackListStatus, ...args }) {
     super(args)
     this.server = server
     this.config = { ...config }
+    this.eip7702Whitelist = eip7702Whitelist ?? createEip7702Whitelist(eip7702Supported)
+    this.getBlackListStatus = getBlackListStatus
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
       getTxLog: (...args) => this.aci.getTxLog(...args),
@@ -28,6 +32,12 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
   }
 
   setServer(config) {
+    applyRemoteConfigEip7702Whitelist({
+      eip7702Whitelist: this.eip7702Whitelist,
+      remoteConfig: config,
+      logger: this.logger,
+    })
+
     const uri = config?.server || this.server.defaultUri
 
     if (uri === this.server.uri) {
@@ -38,33 +48,12 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
   }
 
   async getBalances({ tokens, ourWalletAddress }) {
-    const batch = Object.create(null)
-    const request = this.server.getBalanceRequest(ourWalletAddress)
-    batch[this.asset.name] = request
-    for (const token of tokens) {
-      const request = this.server.balanceOfRequest(ourWalletAddress, token.contract.address)
-      batch[token.name] = request
-    }
-
-    const pairs = Object.entries(batch)
-    if (pairs.length === 0) {
-      return {}
-    }
-
-    const requests = pairs.map((pair) => pair[1])
-    const responses = await this.server.sendBatchRequest(requests)
-    const entries = pairs.map((pair, idx) => {
-      const balanceHex = responses[idx]
-      const name = pair[0]
-      const balance = fromHexToString(balanceHex)
-      return [name, balance]
-    })
-    return Object.fromEntries(entries)
+    return getBatchedRpcBalances({ baseAsset: this.asset, ourWalletAddress, tokens })
   }
 
   async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
     const asset = this.asset
-    const newAccountState = {}
+    const newAccountState = Object.create(null)
     const balances = await this.getBalances({ tokens, ourWalletAddress })
     const balance = balances[asset.name]
     newAccountState.balance = asset.currency.baseUnit(balance)
@@ -72,6 +61,7 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
     const tokenBalanceEntries = tokenBalancePairs
       .map((pair) => {
         const token = tokens.find((token) => token.name === pair[0])
+        if (!token) return null
         const value = token.currency.baseUnit(pair[1] || 0)
         return [token.name, value]
       })
@@ -129,20 +119,17 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
     const txsToRemove = []
     const now = SynchronizedTime.now()
 
-    if (isEmpty(pendingTransactions))
-      return {
-        txsToUpdate,
-        txsToRemove,
-      }
+    if (isEmpty(pendingTransactions)) return { txsToUpdate, txsToRemove }
 
     for (const { tx, assetName } of pendingTransactions) {
       const txFromNode = pendingTxsFromNode[tx.txId]
-      if (now - tx.date.getTime() > UNCONFIRMED_TX_LIMIT && txFromNode?.blockHash == null) {
+      const isConfirmed = Boolean(txFromNode?.blockHash)
+      if (now - tx.date.getTime() > UNCONFIRMED_TX_LIMIT && !txFromNode) {
         txsToRemove.push({
           tx,
           assetSource: { asset: assetName, walletAccount },
         })
-      } else if (txFromNode?.blockHash !== null) {
+      } else if (isConfirmed) {
         txsToUpdate.push({
           tx: { ...tx, confirmations: 1 },
           assetSource: { asset: assetName, walletAccount },
@@ -157,6 +144,7 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
   }
 
   async tick({ refresh, walletAccount }) {
+    const shouldCheckBlacklist = this.tickCount[walletAccount] === 0
     const assets = await this.aci.getAssetsForNetwork({ baseAssetName: this.asset.name })
     const tokens = Object.values(assets).filter((asset) => asset.baseAsset.name !== asset.name)
 
@@ -189,7 +177,30 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
       ourWalletAddress,
     })
 
-    await this.updateAccountState({ newData: { ...accountState }, walletAccount })
+    const eip7702Delegation = await getCurrentEIP7702Delegation({
+      server: this.server,
+      address: ourWalletAddress,
+      eip7702Supported: this.eip7702Whitelist.get(),
+      currentDelegation: currentAccountState?.eip7702Delegation,
+      logger: this.logger,
+    })
+    const isBlacklisted = shouldCheckBlacklist
+      ? await getCurrentBlackListStatus({
+          getBlackListStatus: this.getBlackListStatus,
+          address: ourWalletAddress,
+          currentIsBlacklisted: currentAccountState?.isBlacklisted,
+          logger: this.logger,
+        })
+      : undefined
+
+    // All updates must go through newData (accountState param is only used for mem merging)
+    const newData = {
+      ...accountState,
+      ...(isBlacklisted !== undefined && { isBlacklisted }),
+      ...(eip7702Delegation !== undefined && { eip7702Delegation }),
+    }
+
+    await this.updateAccountState({ accountState, newData, walletAccount })
 
     await this.removeFromTxLog(txsToRemove)
     await this.updateTxLogByAsset({ logItemsByAsset, walletAccount, refresh })