@exodus/ethereum-api 9.0.0-alpha.3 → 9.0.1

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

@@ -1,21 +1,46 @@
 import { BaseMonitor } from '@exodus/asset-lib'
-import { getAssetAddresses, isRpcBalanceAsset } from '@exodus/ethereum-lib'
-import { isEmpty } from 'lodash'
+import { getAssetAddresses } from '@exodus/ethereum-lib'
+import lodash from 'lodash'
+import assert from 'minimalistic-assert'
 
+import { applyRemoteConfigEip7702Whitelist, createEip7702Whitelist } from '../eip7702-whitelist.js'
+import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
+import {
+  filterEffects,
+  getLogItemsFromServerTx,
+  normalizeTransactionsResponse,
+} from './clarity-utils/index.js'
+import { getBatchedRpcBalances } from './monitor-utils/get-batched-rpc-balances.js'
 import {
-  getAllLogItemsByAsset,
   checkPendingTransactions,
-  getDeriveTransactionsToCheck,
   excludeUnchangedTokenBalances,
-} from './monitor-utils'
-import { getLogItemsFromServerTx, getDeriveDataNeededForTick, filterEffects } from './clarity-utils'
-import { fromHexToString } from '../number-utils'
+  getAllLogItemsByAsset,
+  getCurrentBlackListStatus,
+  getCurrentEIP7702Delegation,
+  getDeriveDataNeededForTick,
+  getDeriveTransactionsToCheck,
+  isUnverifiablePendingTxExpired,
+  verifyRpcPendingTxStatusBatch,
+} from './monitor-utils/index.js'
+
+const { isEmpty } = lodash
 
 export class ClarityMonitor extends BaseMonitor {
-  constructor({ server, config, ...args }) {
+  constructor({
+    server,
+    config,
+    rpcBalanceAssetNames,
+    eip7702Supported,
+    eip7702Whitelist,
+    getBlackListStatus,
+    ...args
+  }) {
     super(args)
     this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
     this.server = server
+    this.rpcBalanceAssetNames = rpcBalanceAssetNames
+    this.eip7702Whitelist = eip7702Whitelist ?? createEip7702Whitelist(eip7702Supported)
+    this.getBlackListStatus = getBlackListStatus
     this.getAllLogItemsByAsset = getAllLogItemsByAsset
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
@@ -26,6 +51,12 @@ export class ClarityMonitor 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) {
@@ -60,19 +91,23 @@ export class ClarityMonitor 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 { walletAccount } = params
 
-    const updateTx = (tx, asset, { error, remove }) => {
+    const updateTx = (tx, asset, { error, remove, preserve, isTxConfirmed }) => {
       if (remove) {
         txsToRemove.push({ tx, assetSource: { asset, walletAccount } })
+      } else if (preserve) {
+        params.logItemsByAsset[asset].push(tx)
       } else {
         params.logItemsByAsset[asset].push({
           ...tx,
-          dropped: true,
-          error,
+          ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error }),
         })
       }
 
@@ -85,11 +120,15 @@ export class ClarityMonitor extends BaseMonitor {
             assetSource: { asset: assetName, walletAccount },
           })
         } else if (tokenTxSet && tokenTxSet.has(tx.txId)) {
-          params.logItemsByAsset[assetName].push({
-            ...tokenTxSet.get(tx.txId),
-            error,
-            dropped: true,
-          })
+          // 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 }),
+                }
+          )
         }
       })
       return Promise.all(promises)
@@ -101,19 +140,82 @@ export class ClarityMonitor 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 await updateTx(tx, assetName, { error: 'Dropped' })
+      const txStatus = statuses[tx.txId]
+      if (params.refresh) {
+        if (txStatus?.status === 'dropped') {
+          await updateTx(tx, assetName, { remove: true })
+        } else if (txStatus?.status === 'confirmed') {
+          // Confirmed on-chain but missing from the indexer response: mark it
+          // confirmed so it stops being a pending entry that would otherwise be
+          // preserved (exempt from the age ceiling) on every refresh forever.
+          await updateTx(tx, assetName, { isTxConfirmed: true })
+        } else if (
+          // 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).
+          !txStatus ||
+          txStatus.status === 'pending' ||
+          !isUnverifiablePendingTxExpired(tx)
+        ) {
+          // Still live on-chain (or not verifiable yet) but missing from the indexer
+          // 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 })
+        }
+      } else if (txStatus?.status === 'dropped') {
+        await updateTx(tx, assetName, { error: 'Dropped' })
+      }
+      // non-refresh: 'confirmed', 'pending' or unknown - tx is fine, wait for Clarity to confirm
+    }
+
+    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 })
+      }
     }
 
     return { txsToRemove }
   }
 
+  async persistSecurityState({ walletAccount, accountState, isBlacklisted, eip7702Delegation }) {
+    const securityStatePatch = {
+      ...(isBlacklisted !== undefined && { isBlacklisted }),
+      ...(eip7702Delegation !== undefined && { eip7702Delegation }),
+    }
+
+    if (isEmpty(securityStatePatch)) {
+      return
+    }
+
+    await this.updateAccountState({
+      walletAccount,
+      accountState,
+      newData: securityStatePatch,
+    })
+  }
+
   async tick({ walletAccount, refresh }) {
     await this.subscribeWalletAddresses()
+    const tickCount = this.tickCount[walletAccount]
+    const shouldCheckBlacklist = tickCount === 0
 
     const assets = await this.aci.getAssetsForNetwork({ baseAssetName: this.asset.name })
     const tokens = Object.values(assets).filter((asset) => asset.baseAsset.name !== asset.name)
@@ -123,44 +225,116 @@ export class ClarityMonitor extends BaseMonitor {
       return map
     }, new Map())
     const assetName = this.asset.name
-
     const derivedData = await this.deriveData({ assetName, walletAccount, tokens })
-    const response = await this.getHistoryFromServer({ walletAccount, derivedData, refresh })
-    const allTxs = [...response.transactions.pending, ...response.transactions.confirmed]
-    const hasNewTxs = allTxs.length > 0
-
-    const logItemsByAsset = this.getAllLogItemsByAsset({
-      getLogItemsFromServerTx,
-      ourWalletAddress: derivedData.ourWalletAddress,
-      allTransactionsFromServer: allTxs,
-      asset: this.asset,
-      tokensByAddress,
-      assets,
+    const { eip7702Delegation, isBlacklisted } = await this.getSecurityAccountState({
+      derivedData,
+      shouldCheckBlacklist,
     })
 
-    const { txsToRemove } = await this.checkPendingTransactions({
-      txlist: allTxs,
+    await this.persistSecurityState({
       walletAccount,
-      refresh,
-      logItemsByAsset,
-      asset: this.asset,
-      ...derivedData,
+      accountState: derivedData.currentAccountState,
+      isBlacklisted,
+      eip7702Delegation,
     })
 
-    const accountState = await this.getNewAccountState({
-      tokens,
-      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
-      ourWalletAddress: derivedData.ourWalletAddress,
-    })
-    await this.updateAccountState({
-      walletAccount,
-      newData: { clarityCursor: response.cursor, ...accountState },
-    })
+    const batch = this.aci.createOperationsBatch()
+    let allTxs = []
+    let hasNewTxs = false
+    let historyResponse
+    let historyError
+    let processedLogItemsByAsset
+
+    try {
+      const response = await this.getHistoryFromServer({ walletAccount, derivedData, refresh })
+
+      ;({ allTxs } = await normalizeTransactionsResponse({
+        asset: this.asset,
+        fromAddress: derivedData.ourWalletAddress,
+        response,
+        walletAccount,
+      }))
+
+      hasNewTxs = allTxs.length > 0
+
+      const logItemsByAsset = this.getAllLogItemsByAsset({
+        getLogItemsFromServerTx,
+        ourWalletAddress: derivedData.ourWalletAddress,
+        allTransactionsFromServer: allTxs,
+        asset: this.asset,
+        tokensByAddress,
+        assets,
+      })
+
+      const { txsToRemove } = await this.checkPendingTransactions({
+        txlist: allTxs,
+        walletAccount,
+        refresh,
+        logItemsByAsset,
+        asset: this.asset,
+        ...derivedData,
+      })
+
+      this.aci.removeTxLogBatch({
+        assetName,
+        walletAccount,
+        txs: txsToRemove,
+        batch,
+      })
+
+      for (const [assetName, txs] of Object.entries(logItemsByAsset)) {
+        this.aci.updateTxLogAndNotifyBatch({
+          assetName,
+          walletAccount,
+          txs,
+          refresh,
+          batch,
+        })
+      }
+
+      historyResponse = response
+      processedLogItemsByAsset = logItemsByAsset
+    } catch (error) {
+      historyError = error
+    }
+
+    const newData = {
+      ...(await this.resolveAccountState({
+        derivedData,
+        tokens,
+        tokensByAddress,
+        historyResponse,
+        logItemsByAsset: processedLogItemsByAsset,
+        refresh,
+      })),
+      ...(historyResponse && { clarityCursor: historyResponse.cursor }),
+    }
+
+    try {
+      // Persist balance and account metadata even when the history path fails
+      // during startup bursts or other temporary backend pressure.
+      this.aci.updateAccountStateBatch({
+        assetName,
+        walletAccount,
+        accountState: derivedData.currentAccountState,
+        newData,
+        batch,
+      })
+
+      await this.aci.executeOperationsBatch(batch)
+    } catch (batchError) {
+      if (!historyError) throw batchError
+      this.logger.warn('error persisting account state after history failure', batchError)
+    }
+
+    if (historyError) {
+      throw historyError instanceof Error
+        ? historyError
+        : new Error(String(historyError), { cause: historyError })
+    }
 
-    await this.removeFromTxLog(txsToRemove)
-    await this.updateTxLogByAsset({ logItemsByAsset, walletAccount, refresh })
     if (refresh || hasNewTxs) {
-      const unknownTokenAddresses = this._getUnknownTokenAddresses({
+      const unknownTokenAddresses = this.getUnknownTokenAddresses({
         transactions: allTxs,
         tokensByAddress,
       })
@@ -170,24 +344,40 @@ export class ClarityMonitor extends BaseMonitor {
     }
   }
 
-  async deriveDataNeededForTick({ assetName, walletAccount }) {
-    const receiveAddress = await this.aci.getReceiveAddress({
-      assetName,
-      walletAccount,
-      useCache: true,
+  async resolveAccountState({ derivedData, tokens }) {
+    return this.getNewAccountState({
+      tokens,
+      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
+      ourWalletAddress: derivedData.ourWalletAddress,
     })
-    const currentAccountState = await this.aci.getAccountState({ assetName, walletAccount })
-    return {
-      ourWalletAddress: receiveAddress.toLowerCase(),
-      currentAccountState,
-    }
+  }
+
+  async getSecurityAccountState({ derivedData, shouldCheckBlacklist }) {
+    const eip7702Delegation = await getCurrentEIP7702Delegation({
+      server: this.server,
+      address: derivedData.ourWalletAddress,
+      eip7702Supported: this.eip7702Whitelist.get(),
+      currentDelegation: derivedData.currentAccountState?.eip7702Delegation,
+      logger: this.logger,
+    })
+
+    const isBlacklisted = shouldCheckBlacklist
+      ? await getCurrentBlackListStatus({
+          getBlackListStatus: this.getBlackListStatus,
+          address: derivedData.ourWalletAddress,
+          currentIsBlacklisted: derivedData.currentAccountState?.isBlacklisted,
+          logger: this.logger,
+        })
+      : undefined
+
+    return { eip7702Delegation, isBlacklisted }
   }
 
   async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
     const asset = this.asset
-    const newAccountState = {}
+    const newAccountState = Object.create(null)
     const balances = await this.getBalances({ tokens, ourWalletAddress })
-    if (isRpcBalanceAsset(asset)) {
+    if (this.rpcBalanceAssetNames.includes(asset.name)) {
       const balance = balances[asset.name]
       newAccountState.balance = asset.currency.baseUnit(balance)
     }
@@ -208,7 +398,7 @@ export class ClarityMonitor 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,
@@ -223,42 +413,28 @@ export class ClarityMonitor extends BaseMonitor {
   async subscribeWalletAddresses() {
     const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
     Object.entries(addressesByWalletAccount).forEach(([walletAccount, addresses]) => {
-      const address = String([...addresses][0]).toLowerCase() // Only check m/0/0
-      this.server.connectTransactions({ walletAccount, address })
+      try {
+        const [rawAddress] = addresses
+        assert(rawAddress, 'rawAddress should be defined')
+
+        const address = String(rawAddress).toLowerCase() // Only check m/0/0
+        this.server.connectTransactions({ walletAccount, address })
+      } catch (e) {
+        this.logger.error(e)
+      }
     })
   }
 
   async getBalances({ tokens, ourWalletAddress }) {
-    const batch = {}
-    if (isRpcBalanceAsset(this.asset)) {
-      const request = this.server.getBalanceRequest(ourWalletAddress)
-      batch[this.asset.name] = request
-    }
-
-    for (const token of tokens) {
-      if (isRpcBalanceAsset(token) && token.contract.address) {
-        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 getBatchedRpcBalances({
+      baseAsset: this.asset,
+      ourWalletAddress,
+      tokens,
+      rpcBalanceAssetNames: this.rpcBalanceAssetNames,
     })
-    return Object.fromEntries(entries)
   }
 
-  _getUnknownTokenAddresses({ transactions, tokensByAddress }) {
+  getUnknownTokenAddresses({ transactions, tokensByAddress }) {
     const set = transactions.reduce((acc, txn) => {
       const transfers = filterEffects(txn.effects, 'erc20') || []
       transfers.forEach((transfer) => {
@@ -272,24 +448,21 @@ export class ClarityMonitor extends BaseMonitor {
     return [...set]
   }
 
-  async updateGasPrice({ gasPrice, baseFeePerGas }) {
+  // NOTE: Here, fetchedGasPrices is the result of a call to `ClarityMonitor.getFee()`.
+  async updateGasPrice(fetchedGasPrices) {
     try {
-      const feeConfig = { gasPrice: `${fromHexToString(gasPrice).toString()} wei` }
-      if (baseFeePerGas) {
-        feeConfig.baseFeePerGas = `${fromHexToString(baseFeePerGas)} 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)
     }
   }
 
   async onTransaction({ walletAccount }) {
-    return this.tick({ walletAccount })
+    return this.tickWalletAccounts({ walletAccount })
   }
 
   async onFeeUpdated(fee) {

package/src/tx-log/clarity-truncated-history-monitor.js

@@ -0,0 +1,130 @@
+import { ClarityMonitor } from './clarity-monitor.js'
+import { extractBalanceFromClarityAccountInfo } from './monitor-utils/index.js'
+
+const omitTokensWithConfirmedBalanceChange = ({ tokenBalances, logItemsByAsset }) => {
+  if (!tokenBalances || !logItemsByAsset) return tokenBalances
+  const result = { ...tokenBalances }
+  for (const [assetName, txs] of Object.entries(logItemsByAsset)) {
+    if (txs.some((tx) => tx.confirmations > 0 && tx.data?.balanceChange)) delete result[assetName]
+  }
+
+  return result
+}
+
+/**
+ * Clarity v2 + HTTP `getAllTransactions` with `truncated: true` so the backend can attach
+ * `accountInfo` (pre-cursor balance/nonce/token snapshots). Merges that data in
+ * `resolveAccountState` before optional RPC follow-up; does not use `rpcBalanceAssetNames`
+ * (forced empty).
+ */
+export class ClarityTruncatedHistoryMonitor extends ClarityMonitor {
+  constructor({ rpcBalanceAssetNames, ...args } = {}) {
+    super({ ...args, rpcBalanceAssetNames: [] })
+  }
+
+  async getStateUpdate(_args) {
+    return { accountState: Object.create(null) }
+  }
+
+  async resolveAccountState({
+    derivedData,
+    tokens,
+    tokensByAddress,
+    historyResponse,
+    logItemsByAsset,
+    refresh,
+  }) {
+    let currentAccountState = derivedData.currentAccountState
+    let resetBalances
+
+    // When refreshing, we need to clear out old asset
+    // balances in `accountState` since these can surface
+    // values populated from alternative monitors i.e.
+    // `no-history`, which can be written at arbitrary
+    // points in time.
+    //
+    // Since the `truncated-history-monitor` does not
+    // guarantee an `accountState` write for an asset,
+    // (these are only provided when the history is
+    // truncated), we must ensure older checkpoints cannot
+    // be inadvertently relied upon.
+    //
+    if (refresh) {
+      const defaultAccountState = this.asset.api.createAccountState().create()
+      resetBalances = {
+        balance: defaultAccountState.balance,
+        tokenBalances: defaultAccountState.tokenBalances,
+      }
+      currentAccountState = (currentAccountState ?? defaultAccountState).merge(resetBalances)
+    }
+
+    const balanceFromAccountInfo = extractBalanceFromClarityAccountInfo({
+      accountInfo: historyResponse?.accountInfo,
+      asset: this.asset,
+      tokensByAddress,
+    })
+
+    const prevTokenBalances = omitTokensWithConfirmedBalanceChange({
+      tokenBalances: currentAccountState?.tokenBalances,
+      logItemsByAsset,
+    })
+
+    const { accountState } = await this.getStateUpdate({
+      derivedData,
+      tokens,
+      currentTokenBalances: {
+        ...prevTokenBalances,
+        ...balanceFromAccountInfo.tokenBalances,
+      },
+    })
+
+    // Clarity `accountInfo`, then RPC `accountState` (empty here) overlays.
+    const prevTruncatedAccountState = currentAccountState?.truncatedAccountState
+    const newData = {
+      ...resetBalances,
+      ...balanceFromAccountInfo,
+      ...accountState,
+    }
+
+    if (prevTokenBalances || balanceFromAccountInfo.tokenBalances || accountState.tokenBalances) {
+      newData.tokenBalances = {
+        ...prevTokenBalances,
+        ...balanceFromAccountInfo.tokenBalances,
+        ...accountState.tokenBalances,
+      }
+    }
+
+    if (
+      prevTruncatedAccountState ||
+      balanceFromAccountInfo.truncatedAccountState ||
+      accountState.truncatedAccountState
+    ) {
+      newData.truncatedAccountState = {
+        ...prevTruncatedAccountState,
+        ...balanceFromAccountInfo.truncatedAccountState,
+        ...accountState.truncatedAccountState,
+        tokenBalances: {
+          ...prevTruncatedAccountState?.tokenBalances,
+          ...balanceFromAccountInfo.truncatedAccountState?.tokenBalances,
+          ...accountState.truncatedAccountState?.tokenBalances,
+        },
+      }
+    }
+
+    return newData
+  }
+
+  async getHistoryFromServer({ walletAccount, derivedData, refresh }) {
+    const address = derivedData.ourWalletAddress
+    const currentCursor = derivedData.currentAccountState?.clarityCursor
+    const cursor = currentCursor && !refresh ? currentCursor : null
+    return this.server.getAllTransactions({
+      walletAccount,
+      address,
+      cursor,
+      refresh,
+      withInput: true,
+      truncated: true,
+    })
+  }
+}