@exodus/ethereum-api 8.76.2 → 8.76.3

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.76.3](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.2...@exodus/ethereum-api@8.76.3) (2026-06-01)
+
+**Note:** Version bump only for package @exodus/ethereum-api
+
+
+
+
+
 ## [8.76.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.1...@exodus/ethereum-api@8.76.2) (2026-05-27)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.76.2",
+  "version": "8.76.3",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Ethereum and EVM-based blockchains",
   "type": "module",
   "main": "src/index.js",
@@ -70,5 +70,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "6c398eaf7bcaecf41b720833f1dae5b8c56b3d57"
+  "gitHead": "aac7087b928f14da94a1a071b5abaf0983136c2a"
 }

package/src/create-asset-utils.js

@@ -5,10 +5,9 @@ import assert from 'minimalistic-assert'
 import ms from 'ms'
 
 import { EVM_ERROR_REASONS, withErrorReason } from './error-wrapper.js'
-import { createEvmServer, createWsGateway, ValidMonitorTypes } from './exodus-eth-server/index.js'
+import { createEvmServer, ValidMonitorTypes } from './exodus-eth-server/index.js'
 import { createEthereumHooks } from './hooks/index.js'
 import { ClarityMonitor } from './tx-log/clarity-monitor.js'
-import { ClarityMonitorV2 } from './tx-log/clarity-monitor-v2.js'
 import { ClarityTruncatedHistoryMonitor } from './tx-log/clarity-truncated-history-monitor.js'
 import { EthereumMonitor } from './tx-log/ethereum-monitor.js'
 import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor.js'
@@ -284,6 +283,9 @@ export const createHistoryMonitorFactory = ({
   return (args) => {
     let monitor
     switch (monitorType) {
+      case 'clarity-v3':
+        console.log('clarity-v3 is no longer supported, falling back to clarity-v2')
+      // eslint-disable-next-line no-fallthrough
       case 'clarity':
       case 'clarity-v2':
         monitor = new ClarityMonitor({
@@ -306,18 +308,6 @@ export const createHistoryMonitorFactory = ({
           ...args,
         })
         break
-      case 'clarity-v3':
-        monitor = new ClarityMonitorV2({
-          assetClientInterface,
-          interval: ms(monitorInterval || '5m'),
-          server,
-          rpcBalanceAssetNames,
-          wsGatewayClient: createWsGateway({ uri: wsGatewayUri }),
-          eip7702Supported,
-          getBlackListStatus,
-          ...args,
-        })
-        break
       case 'no-history':
         monitor = new EthereumNoHistoryMonitor({
           assetClientInterface,

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

@@ -1,637 +0,0 @@
-import { BaseMonitor } from '@exodus/asset-lib'
-import { getAssetAddresses } from '@exodus/ethereum-lib'
-import lodash from 'lodash'
-import assert from 'minimalistic-assert'
-
-import WsGateway from '../exodus-eth-server/ws-gateway.js'
-import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
-import { fromHexToString } from '../number-utils.js'
-import {
-  filterEffects,
-  getLogItemsFromServerTx,
-  normalizeTransactionsResponse,
-} from './clarity-utils/index.js'
-import {
-  checkPendingTransactions,
-  excludeUnchangedTokenBalances,
-  getAllLogItemsByAsset,
-  getCurrentBlackListStatus,
-  getCurrentEIP7702Delegation,
-  getDeriveDataNeededForTick,
-  getDeriveTransactionsToCheck,
-  verifyRpcPendingTxStatusBatch,
-} from './monitor-utils/index.js'
-
-const { isEmpty } = lodash
-
-export class ClarityMonitorV2 extends BaseMonitor {
-  #wsClient = null
-  #walletAccountByAddress = new Map()
-  #walletAccountInfo = new Map()
-  #rpcBalanceAssetNames = []
-  constructor({
-    server,
-    wsGatewayClient,
-    rpcBalanceAssetNames,
-    eip7702Supported,
-    getBlackListStatus,
-    config,
-    ...args
-  } = {}) {
-    super(args)
-    assert(wsGatewayClient instanceof WsGateway, 'expected WsGateway wsGatewayClient')
-
-    this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
-    this.server = server
-    this.#wsClient = wsGatewayClient
-    this.#rpcBalanceAssetNames = rpcBalanceAssetNames
-    this.eip7702Supported = eip7702Supported
-    this.getBlackListStatus = getBlackListStatus
-    this.getAllLogItemsByAsset = getAllLogItemsByAsset
-    this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
-    this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
-      getTxLog: (...args) => this.aci.getTxLog(...args),
-    })
-
-    this.addHook('before-start', (...args) => this.beforeStart(...args))
-    this.addHook('after-stop', (...args) => this.afterStop(...args))
-  }
-
-  setServer(config) {
-    const uri = config?.server || this.server.defaultUri
-
-    this.#wsClient.on('connected', () => this.subscribeAllWalletAccounts())
-    this.#wsClient.start()
-
-    if (uri === this.server.uri) {
-      return
-    }
-
-    this.server.setURI(uri)
-    if (this.config.GAS_PRICE_FROM_WEBSOCKET) {
-      this.server.connectFee()
-    }
-  }
-
-  async deriveData({ assetName, walletAccount, tokens }) {
-    const { ourWalletAddress, currentAccountState } = await this.deriveDataNeededForTick({
-      assetName,
-      walletAccount,
-    })
-    const transactionsToCheck = await this.deriveTransactionsToCheck({
-      assetName,
-      walletAccount,
-      tokens,
-      ourWalletAddress,
-    })
-
-    return {
-      ourWalletAddress,
-      currentAccountState,
-      ...transactionsToCheck,
-    }
-  }
-
-  // eslint-disable-next-line no-undef
-  async checkPendingTransactions(params) {
-    const { pendingTransactionsToCheck, pendingTransactionsGroupedByAddressAndNonce } =
-      checkPendingTransactions(params)
-    const txsToRemove = []
-    const { walletAccount } = params
-
-    const updateTx = (tx, asset, { error, remove }) => {
-      if (remove) {
-        txsToRemove.push({ tx, assetSource: { asset, walletAccount } })
-      } else {
-        params.logItemsByAsset[asset].push({
-          ...tx,
-          dropped: true,
-          error,
-        })
-      }
-
-      // in case this is an ETH fee tx that has associated ERC20 send txs
-      const promises = tx.tokens.map(async (assetName) => {
-        const tokenTxSet = await this.aci.getTxLog({ assetName, walletAccount })
-        if (remove) {
-          txsToRemove.push({
-            tx: tokenTxSet.get(tx.txId),
-            assetSource: { asset: assetName, walletAccount },
-          })
-        } else if (tokenTxSet && tokenTxSet.has(tx.txId)) {
-          params.logItemsByAsset[assetName].push({
-            ...tokenTxSet.get(tx.txId),
-            error,
-            dropped: true,
-          })
-        }
-      })
-      return Promise.all(promises)
-    }
-
-    for (const { tx, assetName, replaced = false } of Object.values(
-      pendingTransactionsGroupedByAddressAndNonce
-    )) {
-      if (replaced) {
-        await updateTx(tx, assetName, { remove: true })
-        delete pendingTransactionsToCheck[tx.txId]
-      }
-    }
-
-    // Batch verify all pending txs with a single RPC call (skip if refresh)
-    const txIds = Object.keys(pendingTransactionsToCheck)
-    const statuses = params.refresh
-      ? {}
-      : 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 {
-        const txStatus = statuses[tx.txId]
-        if (txStatus?.status === 'dropped') {
-          await updateTx(tx, assetName, { error: 'Dropped' })
-        }
-        // status === 'confirmed' or 'pending' - tx is fine, wait for Clarity to confirm
-      }
-    }
-
-    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(walletAccount)
-
-    const walletAccountInfo = this.#walletAccountInfo.get(walletAccount)
-
-    if (!walletAccountInfo) {
-      return this.logger.warn('walletAccountInfo is empty', { walletAccount })
-    }
-
-    const { derivedData, tokensByAddress, assets, tokens, assetName } = walletAccountInfo
-    const { eip7702Delegation, isBlacklisted } = await this.getSecurityAccountState({
-      derivedData,
-      walletAccount,
-    })
-
-    await this.persistSecurityState({
-      walletAccount,
-      accountState: derivedData.currentAccountState,
-      isBlacklisted,
-      eip7702Delegation,
-    })
-
-    const accountState = await this.getNewAccountState({
-      tokens,
-      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
-      ourWalletAddress: derivedData.ourWalletAddress,
-    })
-
-    const batch = this.aci.createOperationsBatch()
-    const newData = { ...accountState }
-    let allTxs = []
-    let hasNewTxs = false
-    let historyError
-
-    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,
-        })
-      }
-
-      if (response.cursor) {
-        newData.clarityCursor = response.cursor
-      }
-    } catch (error) {
-      historyError = error
-    }
-
-    try {
-      this.aci.updateAccountStateBatch({
-        assetName,
-        walletAccount,
-        accountState,
-        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
-    }
-
-    if (refresh || hasNewTxs) {
-      const unknownTokenAddresses = this.getUnknownTokenAddresses({
-        transactions: allTxs,
-        tokensByAddress,
-      })
-      if (unknownTokenAddresses.length > 0) {
-        this.emit('unknown-tokens', unknownTokenAddresses)
-      }
-    }
-  }
-
-  async processAndFillTransactionsToState({
-    allTxs,
-    derivedData,
-    tokensByAddress,
-    assets,
-    tokens,
-    assetName,
-    walletAccount,
-    refresh,
-    cursor,
-  }) {
-    const hasNewTxs = allTxs.length > 0
-
-    const { eip7702Delegation, isBlacklisted } = await this.getSecurityAccountState({
-      derivedData,
-      walletAccount,
-    })
-
-    await this.persistSecurityState({
-      walletAccount,
-      accountState: derivedData.currentAccountState,
-      isBlacklisted,
-      eip7702Delegation,
-    })
-
-    const accountState = await this.getNewAccountState({
-      tokens,
-      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
-      ourWalletAddress: derivedData.ourWalletAddress,
-    })
-
-    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,
-    })
-
-    const batch = this.aci.createOperationsBatch()
-
-    this.aci.removeTxLogBatch({
-      assetName,
-      walletAccount,
-      txs: txsToRemove,
-      batch,
-    })
-
-    for (const [assetName, txs] of Object.entries(logItemsByAsset)) {
-      this.aci.updateTxLogAndNotifyBatch({
-        assetName,
-        walletAccount,
-        txs,
-        refresh,
-        batch,
-      })
-    }
-
-    // All updates must go through newData (accountState param is only used for mem merging)
-    const newData = { ...accountState }
-
-    if (cursor) {
-      newData.clarityCursor = cursor
-    }
-
-    this.aci.updateAccountStateBatch({
-      assetName,
-      walletAccount,
-      accountState,
-      newData,
-      batch,
-    })
-
-    await this.aci.executeOperationsBatch(batch)
-
-    if (refresh || hasNewTxs) {
-      const unknownTokenAddresses = this.getUnknownTokenAddresses({
-        transactions: allTxs,
-        tokensByAddress,
-      })
-      if (unknownTokenAddresses.length > 0) {
-        this.emit('unknown-tokens', unknownTokenAddresses)
-      }
-    }
-  }
-
-  async getSecurityAccountState({ derivedData, walletAccount }) {
-    const shouldCheckBlacklist = this.tickCount[walletAccount] === 0
-    const eip7702Delegation = await getCurrentEIP7702Delegation({
-      server: this.server,
-      address: derivedData.ourWalletAddress,
-      eip7702Supported: this.eip7702Supported,
-      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 addSingleTx({ tx, address, cursor }) {
-    const walletAccounts = this.#walletAccountByAddress.get(address)
-
-    if (!walletAccounts || walletAccounts.length === 0) {
-      return
-    }
-
-    for (const walletAccount of walletAccounts) {
-      const walletAccountInfo = this.#walletAccountInfo.get(walletAccount)
-
-      if (!walletAccountInfo) {
-        continue
-      }
-
-      const { derivedData, tokensByAddress, assets, tokens, assetName } = walletAccountInfo
-
-      await this.processAndFillTransactionsToState({
-        allTxs: [tx],
-        derivedData,
-        tokensByAddress,
-        assets,
-        tokens,
-        assetName,
-        walletAccount,
-        refresh: false,
-        cursor,
-      })
-    }
-  }
-
-  async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
-    const asset = this.asset
-    const newAccountState = Object.create(null)
-    const balances = await this.getBalances({ tokens, ourWalletAddress })
-    if (this.#rpcBalanceAssetNames.includes(asset.name)) {
-      const balance = balances[asset.name]
-      newAccountState.balance = asset.currency.baseUnit(balance)
-    }
-
-    const tokenBalancePairs = Object.entries(balances).filter((entry) => entry[0] !== asset.name)
-    const tokenBalanceEntries = tokenBalancePairs
-      .map((pair) => {
-        const token = tokens.find((token) => token.name === pair[0])
-        const value = token.currency.baseUnit(pair[1] || 0)
-        return [token.name, value]
-      })
-      .filter(Boolean)
-
-    const tokenBalances = excludeUnchangedTokenBalances(currentTokenBalances, tokenBalanceEntries)
-    if (!isEmpty(tokenBalances)) newAccountState.tokenBalances = tokenBalances
-    return newAccountState
-  }
-
-  async getReceiveAddressesByWalletAccount() {
-    const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
-    const addressesByAccount = Object.create(null)
-    for (const walletAccount of walletAccounts) {
-      addressesByAccount[walletAccount] = await this.aci.getReceiveAddresses({
-        assetName: this.asset.name,
-        walletAccount,
-        useCache: true,
-      })
-    }
-
-    return addressesByAccount
-  }
-
-  async fillAssetsTokensAndData({ walletAccount }) {
-    const assetName = this.asset.name
-    const assets = await this.aci.getAssetsForNetwork({ baseAssetName: assetName })
-    const tokens = Object.values(assets).filter((asset) => assetName !== asset.name)
-
-    const tokensByAddress = tokens.reduce((map, token) => {
-      const addresses = getAssetAddresses(token)
-      for (const address of addresses) map.set(address.toLowerCase(), token)
-      return map
-    }, new Map())
-
-    const derivedData = await this.deriveData({ assetName, walletAccount, tokens })
-
-    this.#walletAccountInfo.set(walletAccount, {
-      assets,
-      tokens,
-      tokensByAddress,
-      derivedData,
-      assetName,
-    })
-  }
-
-  async subscribeAllWalletAccounts() {
-    const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
-    const entriesAddressesByWalletAccount = Object.entries(addressesByWalletAccount)
-
-    for (const [walletAccount] of entriesAddressesByWalletAccount) {
-      await this.subscribeWalletAddresses(walletAccount)
-    }
-  }
-
-  async subscribeWalletAddresses(walletAccount) {
-    const addressesByWalletAccount = await this.aci.getReceiveAddresses({
-      assetName: this.asset.name,
-      walletAccount,
-      useCache: true,
-    })
-
-    const address = addressesByWalletAccount[0].toLowerCase() // Only check m/0/0
-    await this.fillAssetsTokensAndData({ walletAccount })
-
-    if (!this.#walletAccountByAddress.has(address)) {
-      this.#walletAccountByAddress.set(address, [])
-    }
-
-    const walletAccounts = this.#walletAccountByAddress.get(address)
-
-    if (!walletAccounts.includes(walletAccount)) {
-      walletAccounts.push(walletAccount)
-      this.#walletAccountByAddress.set(address, walletAccounts)
-    }
-
-    this.server.connectTransactions({ walletAccount, address })
-
-    this.#wsClient.subscribeWalletAddresses({
-      network: this.asset.name,
-      addresses: [address],
-    })
-  }
-
-  async getBalances({ tokens, ourWalletAddress }) {
-    const batch = Object.create(null)
-    if (this.#rpcBalanceAssetNames.includes(this.asset.name)) {
-      const request = this.server.getBalanceRequest(ourWalletAddress)
-      batch[this.asset.name] = request
-    }
-
-    for (const token of tokens) {
-      if (this.#rpcBalanceAssetNames.includes(token.name) && 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 Object.fromEntries(entries)
-  }
-
-  getUnknownTokenAddresses({ transactions, tokensByAddress }) {
-    const set = transactions.reduce((acc, txn) => {
-      const transfers = filterEffects(txn.effects, 'erc20') || []
-      transfers.forEach((transfer) => {
-        const addr = transfer.address.toLowerCase()
-        if (!tokensByAddress.has(addr)) {
-          acc.add(addr)
-        }
-      })
-      return acc
-    }, new Set())
-    return [...set]
-  }
-
-  // NOTE: Here, fetchedGasPrices is the result of a call to `ClarityMonitor.getFee()`.
-  async updateGasPrice(fetchedGasPrices) {
-    try {
-      await executeEthLikeFeeMonitorUpdate({
-        assetClientInterface: this.aci,
-        feeAsset: this.asset,
-        fetchedGasPrices,
-      })
-    } catch (e) {
-      this.logger.warn('error updating gasPrice', e)
-    }
-  }
-
-  async onFeeUpdated(fee) {
-    return this.updateGasPrice(fee)
-  }
-
-  async beforeStart() {
-    this.listenToServerEvents()
-    if (this.config.GAS_PRICE_FROM_WEBSOCKET) {
-      this.server.connectFee()
-    }
-  }
-
-  async afterStop() {
-    this.server.dispose()
-    this.#wsClient.dispose(this.asset.name)
-  }
-
-  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 })
-  }
-
-  listenToServerEvents() {
-    this.server.on('feeUpdated', (...args) => this.onFeeUpdated(...args))
-    this.#wsClient.on(
-      `${this.asset.name}:new_transaction`,
-      async ({ transaction, address, cursor }) =>
-        this.addSingleTx({
-          tx: transaction,
-          address,
-          cursor,
-        })
-    )
-  }
-}