@exodus/ethereum-api 9.0.3 → 10.0.0

package/CHANGELOG.md

@@ -3,6 +3,19 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [10.0.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@9.0.3...@exodus/ethereum-api@10.0.0) (2026-10-05)
+
+
+### ⚠ BREAKING CHANGES
+
+* **ethereum-api:** remove magnifier evm monitor (#8828)
+
+### Code Refactoring
+
+* **ethereum-api:** remove magnifier evm monitor ([#8828](https://github.com/ExodusMovement/assets/issues/8828)) ([d179ae1](https://github.com/ExodusMovement/assets/commit/d179ae145410f2a8033718a1889a7ea6676001e1))
+
+
+
 ## [9.0.3](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@9.0.2...@exodus/ethereum-api@9.0.3) (2026-10-05)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "9.0.3",
+  "version": "10.0.0",
   "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",
@@ -66,5 +66,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "e783e7a31c40807698ae2b9629e1c2dd5c03c228"
+  "gitHead": "83a0e678debb92fbfcefd92e7bd0453d1a92136b"
 }

package/src/create-asset-utils.js

@@ -15,7 +15,6 @@ import {
 } from './multicall3/index.js'
 import { ClarityMonitor } from './tx-log/clarity-monitor.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'
 import { getOptimisticTxLogEffects } from './tx-log/get-optimistic-txlog-effects.js'
 import { BLOCK_TAG_LATEST, BLOCK_TAG_PENDING, resolveNonce } from './tx-send/nonce-utils.js'
@@ -355,15 +354,6 @@ export const createHistoryMonitorFactory = ({
           ...args,
         })
         break
-      case 'magnifier':
-        monitor = new EthereumMonitor({
-          assetClientInterface,
-          interval: ms(monitorInterval || '15s'),
-          server,
-          rpcBalanceAssetNames,
-          ...args,
-        })
-        break
       default:
         throw new Error(`Monitor type ${monitorType} of evm asset ${assetName} is unknown`)
     }

package/src/error-wrapper.js

@@ -281,6 +281,13 @@ export function getEvmErrorReason(errorMessage) {
   return null
 }
 
+export function getFetchGasLimitErrorReason(errorMessage) {
+  const reason = getEvmErrorReason(errorMessage)?.reason
+  return reason && reason !== EVM_ERROR_REASONS.executionReverted.reason
+    ? { reason, type: EVM_ERROR_TYPES.CONTRACT_CALL }
+    : EVM_ERROR_REASONS.fetchGasLimitFailed
+}
+
 const MAX_HINT_LENGTH = 100
 // TODO: move this to be a generic error for all assets
 export class EthLikeError extends Error {
@@ -374,7 +381,8 @@ export const withErrorReason = async ({ promise, errorReasonInfo, hint, baseAsse
 
     throw new EthLikeError({
       message: err.message,
-      errorReasonInfo,
+      errorReasonInfo:
+        typeof errorReasonInfo === 'function' ? errorReasonInfo(err.message) : errorReasonInfo,
       hint,
       traceId: err.traceId,
       baseAssetName,

package/src/eth-like-util.js

@@ -4,7 +4,12 @@ import { safeString } from '@exodus/safe-string'
 import SolidityContract from '@exodus/solidity-contract'
 import assert from 'minimalistic-assert'
 
-import { EthLikeError, EVM_ERROR_REASONS, withErrorReason } from './error-wrapper.js'
+import {
+  EthLikeError,
+  EVM_ERROR_REASONS,
+  getFetchGasLimitErrorReason,
+  withErrorReason,
+} from './error-wrapper.js'
 import { getServer } from './exodus-eth-server/index.js'
 import { fromHexToString } from './number-utils.js'
 
@@ -60,7 +65,7 @@ export async function getNonce({ asset, address, tag = 'latest' }) {
 export async function estimateGas({ asset, ...args }) {
   return withErrorReason({
     promise: getServer(asset).estimateGas(args),
-    errorReasonInfo: EVM_ERROR_REASONS.fetchGasLimitFailed,
+    errorReasonInfo: getFetchGasLimitErrorReason,
     hint: safeString`estimateGas`,
     baseAssetName: asset.baseAsset.name,
   })

package/src/exodus-eth-server/index.js

@@ -1,6 +1,5 @@
 import assert from 'minimalistic-assert'
 
-import { create } from './api.js'
 import ApiCoinNodesServer from './api-coin-nodes.js'
 import ClarityServer from './clarity.js'
 import ClarityServerV2 from './clarity-v2.js'
@@ -12,7 +11,6 @@ export const ValidMonitorTypes = [
   'clarity-v2',
   'clarity-truncated-history',
   'clarity-v3',
-  'magnifier',
 ]
 
 export function createEvmServer({ assetName, serverUrl, monitorType }) {
@@ -30,8 +28,6 @@ export function createEvmServer({ assetName, serverUrl, monitorType }) {
     case 'clarity-truncated-history':
     case 'clarity-v3':
       return new ClarityServerV2({ baseAssetName: assetName, uri: serverUrl })
-    case 'magnifier':
-      return create(serverUrl, assetName)
     default:
       throw new Error(`No server API found for ${assetName} and type ${monitorType}`)
   }

package/src/get-balance-for-address.js

@@ -11,7 +11,7 @@ export const createGetBalanceForAddress = ({ asset, server }) => {
     }
 
     if (balance && typeof balance === 'object' && typeof balance.confirmed?.value === 'string') {
-      // Magnifier/Clarity reponse
+      // Clarity response
       return asset.currency.baseUnit(balance.confirmed.value)
     }
 

package/src/index.js

@@ -31,7 +31,6 @@ export {
 export { createEvmServer, getServer } from './exodus-eth-server/index.js'
 
 export {
-  EthereumMonitor,
   EthereumNoHistoryMonitor,
   ClarityMonitor,
   getOptimisticTxLogEffects,

package/src/nft-utils.js

@@ -2,7 +2,7 @@ import { safeString } from '@exodus/safe-string'
 import SolidityContract from '@exodus/solidity-contract'
 import assert from 'minimalistic-assert'
 
-import { EthLikeError, EVM_ERROR_REASONS } from './error-wrapper.js'
+import { EthLikeError, EVM_ERROR_REASONS, getFetchGasLimitErrorReason } from './error-wrapper.js'
 import { fetchGasLimit } from './gas-estimation.js'
 
 export const getNftArguments = async ({ asset, nft, fromAddress, toAddress }) => {
@@ -45,9 +45,13 @@ export const getNftArguments = async ({ asset, nft, fromAddress, toAddress }) =>
       }
     })
   ).catch((e) => {
+    const [first, ...rest] = e.errors.map((err) => getFetchGasLimitErrorReason(err.message))
     throw new EthLikeError({
       message: errors.join('\n'),
-      errorReasonInfo: EVM_ERROR_REASONS.fetchGasLimitFailed,
+      errorReasonInfo:
+        first && rest.every(({ reason }) => reason === first.reason)
+          ? first
+          : EVM_ERROR_REASONS.fetchGasLimitFailed,
       hint: safeString`getNftArguments`,
       traceId: e.traceId,
     })

package/src/server-based-fee-monitor.js

@@ -6,7 +6,7 @@ import { calculateEthLikeFeeMonitorUpdate } from './fee-utils.js'
 /**
  * Generic eth server based fee monitor.
  *
- * Compatible with all servers, clarity, magnifier and api-coin (they all implement the gasPrice method).
+ * Compatible with all servers, clarity and api-coin (they all implement the gasPrice method).
  *
  * Usage in the index files:
  *

package/src/tx-log/index.js

@@ -1,4 +1,3 @@
-export { EthereumMonitor } from './ethereum-monitor.js'
 export { EthereumNoHistoryMonitor } from './ethereum-no-history-monitor.js'
 export { ClarityMonitor } from './clarity-monitor.js'
 export { ClarityTruncatedHistoryMonitor } from './clarity-truncated-history-monitor.js'

package/src/tx-log/monitor-utils/index.js

@@ -1,8 +1,6 @@
 export { default as getDeriveDataNeededForTick } from './get-derive-data-needed-for-tick.js'
 
 export { default as getAllLogItemsByAsset } from './get-all-log-items-by-asset.js'
-export { default as getLogItemsFromServerTx } from './get-log-items-from-server-tx.js'
-export { default as getHistoryFromServer } from './get-history-from-server.js'
 export { default as checkPendingTransactions } from './check-pending-transactions.js'
 export { default as getDeriveTransactionsToCheck } from './get-derive-transactions-to-check.js'
 export { default as getCurrentEIP7702Delegation } from './get-current-eip7702-delegation.js'

package/src/exodus-eth-server/api.js

@@ -1,276 +0,0 @@
-import { randomUUID } from '@exodus/crypto/randomUUID'
-import { bufferToHex } from '@exodus/ethereumjs/util'
-import fetchival from '@exodus/fetch/experimental/fetchival'
-import { retry } from '@exodus/simple-retry'
-import SolidityContract from '@exodus/solidity-contract'
-import ms from 'ms'
-
-import { fromHexToString } from '../number-utils.js'
-import { getFallbackGasPriceEstimation } from './utils.js'
-import createWebSocket from './ws.js'
-
-const RETRY_DELAYS = ['10s']
-
-export function create(defaultURL, ensAssetName) {
-  let API_URL = defaultURL
-  const ws = createWebSocket(() => {
-    const obj = new URL(API_URL)
-    obj.protocol = 'wss:'
-    return `${obj}`
-  })
-
-  function baseUrl(version = 'v1') {
-    return new URL(version === 'v1' ? API_URL : API_URL.replace('v1', version))
-  }
-
-  async function request(module, params = {}, { version = 'v1', method = 'get' } = {}) {
-    try {
-      return await fetchival(baseUrl(version), { timeout: ms('15s') })(module).method(
-        method,
-        params
-      )
-    } catch (err) {
-      let nerr = err
-      if (err.response && (err.response.status === 500 || err.response.status === 400)) {
-        try {
-          const data = await err.response.json()
-          const msg = data.error.replace(/^RPC error \(code: -\d+\): /, '')
-          nerr = new Error(msg)
-        } catch {}
-
-        nerr.finalError = true
-      }
-
-      throw nerr
-    }
-  }
-
-  // Default retry function
-  const requestWithRetry = retry(request, { delayTimesMs: RETRY_DELAYS })
-
-  return {
-    getURL() {
-      return API_URL
-    },
-
-    setURL(newURL) {
-      if (newURL === API_URL) return // prevents useless WS reconnections
-
-      API_URL = newURL || defaultURL
-
-      if (ws.isCreated()) {
-        ws.close()
-        ws.open()
-      }
-    },
-
-    stop() {
-      ws.close()
-    },
-
-    ws,
-
-    async getBalance(address, opts) {
-      opts = { startblock: 'earliest', endblock: 'pending', ...opts }
-      return requestWithRetry('balance', { address, from: opts.startblock, to: opts.endblock })
-    },
-
-    async getBalanceProxied(address, tag = 'latest') {
-      return requestWithRetry('proxy', { method: 'eth_getBalance', address, tag })
-    },
-
-    async balanceOf(address, tokenAddress, tag = 'latest') {
-      const contract = SolidityContract.simpleErc20(tokenAddress)
-      const callData = contract.balanceOf.build(address)
-      const data = {
-        data: bufferToHex(callData),
-        to: tokenAddress,
-        tag,
-      }
-      const result = await retry(this.ethCall, { delayTimesMs: RETRY_DELAYS })(data)
-      const balance = fromHexToString(result)
-      return {
-        confirmed: {
-          [tokenAddress]: balance,
-        },
-      }
-    },
-
-    async getHistory(address, opts) {
-      opts = { startblock: 'earliest', endblock: 'pending', limit: 1000, ...opts }
-      return requestWithRetry('history', {
-        address,
-        from: opts.startblock,
-        to: opts.endblock,
-        limit: opts.limit,
-      })
-    },
-
-    async getHistoryV2(address, opts = {}) {
-      return requestWithRetry(
-        'history',
-        {
-          address,
-          ...opts,
-        },
-        { version: 'v2' }
-      )
-    },
-
-    async gasPrice() {
-      return requestWithRetry('proxy', { method: 'eth_gasPrice' })
-    },
-
-    async getGasPriceEstimation() {
-      return getFallbackGasPriceEstimation({ server: this })
-    },
-
-    // for fee monitor
-    async getGasPrice() {
-      return requestWithRetry('proxy', { method: 'eth_gasPrice' })
-    },
-
-    async getLatestBlock() {
-      return this.getBlockByNumber('latest')
-    },
-
-    async getBaseFeePerGas() {
-      const response = await this.getLatestBlock()
-      if (response.baseFeePerGas) {
-        return fromHexToString(response.baseFeePerGas)
-      }
-    },
-
-    async getTransactionCount(address, tag = 'latest') {
-      return requestWithRetry('proxy', { method: 'eth_getTransactionCount', address, tag })
-    },
-
-    async getTransactionByHash(hash) {
-      return requestWithRetry('proxy', { method: 'eth_getTransactionByHash', hash })
-    },
-
-    async getTransactionReceipt(txhash) {
-      return requestWithRetry('proxy', { method: 'eth_getTransactionReceipt', txhash })
-    },
-
-    async getCode(address, tag = 'latest') {
-      return requestWithRetry('proxy', { method: 'eth_getCode', address, tag })
-    },
-
-    async getStorageAt(address, slot, tag = 'latest') {
-      return requestWithRetry('proxy', { method: 'eth_getStorageAt', address, slot, tag })
-    },
-
-    async isContract(address) {
-      const code = await requestWithRetry('proxy', { method: 'eth_getCode', address })
-      return code.length > 2
-    },
-
-    async sendRawTransaction(data) {
-      const _data = data instanceof Uint8Array ? Buffer.from(data).toString('hex') : data
-      const hex = _data.startsWith('0x') ? _data : '0x' + _data
-      return requestWithRetry(
-        'proxy',
-        { method: 'eth_sendRawTransaction', params: [hex] },
-        { version: 'v2', method: 'post' }
-      )
-    },
-
-    async estimateGas(data, tag = 'latest') {
-      return requestWithRetry('proxy', { method: 'eth_estimateGas', ...data, tag })
-    },
-
-    /**
-     * Hits a magnifier endpoint returning maximum gas limit that a specified
-     * contract along with method consumed in the past.
-     * @param opts : Object with parameters
-     * @returns {Promise<*>}
-     */
-    async getGasEstimation({ address, data }) {
-      return requestWithRetry('gas-estimation', {
-        address,
-        data,
-      })
-    },
-
-    async ethCall(data, tag = 'latest') {
-      return request('proxy', { method: 'eth_call', ...data, tag })
-    },
-
-    async blockNumber() {
-      return requestWithRetry('proxy', { method: 'eth_blockNumber' })
-    },
-
-    async getBlockByNumber(number, isFullTransactions = false) {
-      return requestWithRetry('proxy', {
-        method: 'eth_getBlockByNumber',
-        number,
-        isFullTransactions,
-      })
-    },
-
-    async getLogs(params) {
-      return requestWithRetry('proxy', { method: 'eth_getLogs', ...params })
-    },
-
-    async simulateRawTransaction(rawTransaction, applyPending = true) {
-      rawTransaction = rawTransaction.replace('0x', '')
-      return request('proxy', {
-        method: 'debug_simulateRawTransaction',
-        rawTransaction,
-        applyPending,
-      })
-    },
-
-    async getCoinbase() {
-      return request('proxy', {
-        method: 'eth_coinbase',
-      })
-    },
-
-    async getBlockByHash(blockHash, fullTx = false) {
-      return request('proxy', {
-        method: 'eth_getBlockByHash',
-        blockHash,
-        fullTx,
-      })
-    },
-
-    async getBlockTransactionCountByHash(blockHash) {
-      return request('proxy', {
-        method: 'eth_getBlockTransactionCountByHash',
-        blockHash,
-      })
-    },
-
-    async getBlockTransactionCountByNumber(quantityOrTag) {
-      return request('proxy', {
-        method: 'eth_getBlockTransactionCountByNumber',
-        quantityOrTag,
-      })
-    },
-
-    async getCompilers() {
-      return request('proxy', {
-        method: 'eth_getCompilers',
-      })
-    },
-
-    async getNetVersion() {
-      return request('proxy', {
-        method: 'net_version',
-      })
-    },
-
-    async proxyToCoinNode(requestData) {
-      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-      if (!requestData.jsonrpc) requestData.jsonrpc = '2.0'
-      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-      if (!requestData.id) requestData.id = randomUUID()
-      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-      if (!requestData.params) requestData.params = []
-
-      return request('proxy', requestData, { version: 'v2', method: 'post' })
-    },
-  }
-}

package/src/exodus-eth-server/ws.js

@@ -1,126 +0,0 @@
-import EventEmitter from 'events/events.js' // forces it to use the module from node_modules
-import ms from 'ms'
-
-const RECONNECT_INTERVAL = ms('10s')
-const PING_INTERVAL = ms('10s')
-const MAX_RECONNECT_DELAY = ms('15s')
-
-export default function createWebSocket(getURL) {
-  const addresses = new Set()
-  const events = new EventEmitter()
-  let ws
-  let pingIntervalId = null
-  let opened = false
-  let isWSOpened = false
-  let openTimeoutId
-
-  function subscribeAddress(address) {
-    const data = JSON.stringify({ type: 'subscribe-address', address })
-    ws.send(data)
-  }
-
-  function subscribeGasPrice() {
-    const data = JSON.stringify({ type: 'subscribe-gasprice' })
-    ws.send(data)
-  }
-
-  function clearPing() {
-    clearInterval(pingIntervalId)
-    pingIntervalId = null
-  }
-
-  function onMessage(data) {
-    data = JSON.parse(data)
-    switch (data.type) {
-      case 'address':
-        events.emit(`address-${data.address}`)
-        break
-      case 'gasprice':
-        events.emit('gasprice', { gasPrice: data.gasprice, baseFeePerGas: data.baseGasPrice })
-        break
-    }
-  }
-
-  function open() {
-    opened = true
-    clearTimeout(openTimeoutId)
-    if (ws) return
-
-    ws = new WebSocket(getURL())
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onerror = (e) => {}
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onmessage = (e) => {
-      try {
-        onMessage(e.data)
-      } catch {}
-    }
-
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onopen = () => {
-      for (const address of addresses.values()) subscribeAddress(address)
-      subscribeGasPrice()
-      if (typeof ws.ping === 'function') {
-        pingIntervalId = setInterval(() => ws.ping(), PING_INTERVAL)
-      } else {
-        console.warn('Client side ping not available')
-      }
-
-      isWSOpened = true
-      events.emit('open')
-    }
-
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onclose = () => {
-      ws = null
-      isWSOpened = false
-      clearPing()
-      if (opened) {
-        openTimeoutId = setTimeout(open, reconnectDelay())
-      }
-
-      events.emit('close')
-    }
-  }
-
-  function close() {
-    opened = false
-    isWSOpened = false
-    clearTimeout(openTimeoutId)
-    if (!ws) return
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onerror = null
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onmessage = null
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onopen = null
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onclose = null
-    try {
-      ws.close()
-    } catch (e) {
-      if (!/WebSocket was closed before the connection was established/.test(e.message)) {
-        throw e
-      }
-    }
-
-    ws = null
-    clearPing()
-    events.emit('close')
-  }
-
-  function reconnectDelay() {
-    const min = RECONNECT_INTERVAL
-    const max = MAX_RECONNECT_DELAY
-    return Math.floor(Math.random() * (max - min + 1) + min)
-  }
-
-  function watch(address) {
-    if (addresses.has(address)) return
-    addresses.add(address)
-
-    if (ws) subscribeAddress(address)
-  }
-
-  return { events, open, close, watch, isCreated: () => !!ws, isOpened: () => isWSOpened }
-}

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

@@ -1,351 +0,0 @@
-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,
-  getDeriveDataNeededForTick,
-  getDeriveTransactionsToCheck,
-  getHistoryFromServer,
-  getLogItemsFromServerTx,
-  isUnverifiablePendingTxExpired,
-  verifyRpcPendingTxStatusBatch,
-} from './monitor-utils/index.js'
-import {
-  enableWSUpdates,
-  subscribeToGasPriceNotifications,
-  subscribeToWSNotifications,
-} from './ws-updates.js'
-
-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, rpcBalanceAssetNames, webSocketEnabled = true, ...args }) {
-    super(args)
-    this.server = server
-    this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
-    this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
-    this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
-      getTxLog: (...args) => this.aci.getTxLog(...args),
-    })
-    this.subscribedToWalletAccountNotificationsMap = new Map()
-    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 = {}) {
-    const uri = config?.serverv1 || this.server.defaultUri
-
-    if (uri === this.server.getURL()) {
-      return
-    }
-
-    this.server.setURL(uri)
-  }
-
-  async deriveData({ assetSource, tokens }) {
-    const { asset: assetName, walletAccount } = assetSource
-
-    const { ourWalletAddress, currentAccountState, minimumConfirmations } =
-      await this.deriveDataNeededForTick({ assetName, walletAccount })
-    const transactionsToCheck = await this.deriveTransactionsToCheck({
-      assetName,
-      walletAccount,
-      tokens,
-      ourWalletAddress,
-    })
-
-    return {
-      ourWalletAddress,
-      currentAccountState,
-      minimumConfirmations,
-      ...transactionsToCheck,
-    }
-  }
-
-  // eslint-disable-next-line no-undef
-  async checkPendingTransactions(params) {
-    const {
-      pendingTransactionsToCheck,
-      pendingTransactionsGroupedByAddressAndNonce,
-      recentPendingTransactions,
-    } = checkPendingTransactions(params)
-    const txsToRemove = []
-    const {
-      assetSource: { walletAccount },
-    } = params
-
-    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,
-          ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error: 'Dropped' }),
-        })
-      }
-
-      // 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)) {
-          // 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' }),
-                }
-          )
-        }
-      })
-
-      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]
-        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)) {
-      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 })
-      }
-    }
-
-    return {
-      txsToRemove,
-    }
-  }
-
-  async tick({ refresh, walletAccount }) {
-    await this._subscribeToWSNotifications() // checks if it's a new walletAccount
-
-    const assets = await this.aci.getAssetsForNetwork({ baseAssetName: this.asset.name })
-    const tokens = Object.values(assets).filter((asset) => asset.baseAsset.name !== 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 assetSource = { asset: this.asset.name, walletAccount }
-
-    const derivedData = await this.deriveData({ assetSource, tokens })
-    const derivedIndex = derivedData.currentAccountState?.index
-
-    const { allTransactionsFromServer, index } = await getHistoryFromServer({
-      server: this.server,
-      ourWalletAddress: derivedData.ourWalletAddress,
-      minimumConfirmations: derivedData.minimumConfirmations,
-      index: refresh ? 0 : (derivedIndex ?? 0),
-    })
-    const hasNewIndex = !derivedIndex || index > derivedIndex
-
-    const logItemsByAsset = getAllLogItemsByAsset({
-      getLogItemsFromServerTx,
-      ourWalletAddress: derivedData.ourWalletAddress,
-      allTransactionsFromServer,
-      asset: this.asset,
-      tokensByAddress,
-      assets,
-    })
-
-    const { txsToRemove } = await this.checkPendingTransactions({
-      txlist: allTransactionsFromServer,
-      assetSource,
-      refresh,
-      logItemsByAsset,
-      asset: this.asset,
-      ...derivedData,
-    })
-
-    const accountState = await this.getNewAccountState({
-      tokens,
-      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
-      ourWalletAddress: derivedData.ourWalletAddress,
-    })
-
-    const newData = { ...accountState, ...(hasNewIndex && { index }) }
-    await this.updateAccountState({ newData, walletAccount })
-    await this.removeFromTxLog(txsToRemove)
-    await this.updateTxLogByAsset({ logItemsByAsset, walletAccount, refresh })
-
-    if (refresh || hasNewIndex) {
-      const unknownTokenAddresses = this.getUnknownTokenAddresses({
-        transactions: allTransactionsFromServer,
-        tokensByAddress,
-      })
-      if (unknownTokenAddresses.length > 0) {
-        this.emit('unknown-tokens', unknownTokenAddresses)
-      }
-    }
-  }
-
-  async updateGasPrice(fetchedGasPrices) {
-    try {
-      await executeEthLikeFeeMonitorUpdate({
-        assetClientInterface: this.aci,
-        feeAsset: this.asset,
-        fetchedGasPrices,
-      })
-    } catch (e) {
-      this.logger.warn('error updating gasPrice', e)
-    }
-  }
-
-  async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
-    const asset = this.asset
-    const newAccountState = Object.create(null)
-    const server = this.server
-    if (this.rpcBalanceAssetNames.includes(asset.name)) {
-      const result = await server.getBalanceProxied(ourWalletAddress)
-      const balance = fromHexToString(result)
-      newAccountState.balance = asset.currency.baseUnit(balance)
-    }
-
-    const tokenBalancePairs = await Promise.all(
-      tokens
-        .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)
-          return [token.name, value]
-        })
-    )
-
-    const tokenBalances = excludeUnchangedTokenBalances(currentTokenBalances, tokenBalancePairs)
-    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 _subscribeToWSNotifications() {
-    if (this._webSocketEnabled === false) return
-
-    const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
-    subscribeToWSNotifications({
-      addressesByWalletAccount,
-      tick: (...args) => this.tick(...args),
-      server: this.server,
-    })
-  }
-
-  getUnknownTokenAddresses({ transactions, tokensByAddress }) {
-    const set = transactions.reduce((acc, txn) => {
-      const transfers = txn.erc20 || []
-      transfers.forEach((transfer) => {
-        const addr = transfer.address.toLowerCase()
-        if (!tokensByAddress.has(addr)) {
-          acc.add(addr)
-        }
-      })
-      return acc
-    }, new Set())
-    return [...set]
-  }
-
-  async beforeStart() {
-    await this._enableWSUpdates()
-  }
-
-  async _enableWSUpdates() {
-    if (this._webSocketEnabled === false) return
-
-    const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
-    enableWSUpdates({
-      interval: this.interval,
-      server: this.server,
-      timer: this.timer,
-      tick: (...args) => this.tick(...args),
-      tickWalletAccounts: () => this.tickWalletAccounts(),
-      addressesByWalletAccount,
-      beforeStart: true,
-    })
-
-    if (this.config.GAS_PRICE_FROM_WEBSOCKET) {
-      subscribeToGasPriceNotifications({
-        server: this.server,
-        updateGasPrice: (newGasPrice) => this.updateGasPrice(newGasPrice),
-        subscribedToGasPriceMap: this.subscribedToGasPriceMap,
-      })
-    }
-  }
-
-  async afterStop() {
-    await this.server.stop()
-  }
-}

package/src/tx-log/monitor-utils/get-history-from-server.js

@@ -1,43 +0,0 @@
-import isConfirmedServerTx from './is-confirmed-server-tx.js'
-
-// Fetches JSON transaction history from the given Ethereum server
-// object (from @exodus/ethereum-api). Starts fetching from the given
-// block cursor and returns the latest cursor and all transactions
-// fetched in the process. minimumConfirmations determines how many
-// confirmations a transaction must have for the cursor to be moved
-// to that transaction's block.
-
-export default async function getHistoryFromServer({
-  server,
-  ourWalletAddress,
-  index,
-  minimumConfirmations,
-  limit = 1000,
-}) {
-  if (limit === 0) return []
-  const allTransactionsFromServer = []
-
-  let isEndOfAddressHistory = false
-  let newIndex = index
-  while (true) {
-    const transactions = await server.getHistoryV2(ourWalletAddress, {
-      index,
-      limit, // the server returns the number of TXs that's less or equal to the limit
-    })
-
-    if (transactions.length === 0) isEndOfAddressHistory = true
-    for (const transaction of transactions) {
-      allTransactionsFromServer.push(transaction)
-      index = transaction.addressIndex + 1 // this index is used to fetch a next page of TXs
-      if (transaction.confirmations >= minimumConfirmations) newIndex = transaction.addressIndex + 1 // this index is used to return from the function
-      if (!isConfirmedServerTx(transaction)) isEndOfAddressHistory = true
-    }
-
-    if (isEndOfAddressHistory) {
-      return {
-        allTransactionsFromServer,
-        index: newIndex,
-      }
-    }
-  }
-}

package/src/tx-log/monitor-utils/get-log-items-from-server-tx.js

@@ -1,203 +0,0 @@
-import lodash from 'lodash'
-
-import getFeeAmount from './get-fee-amount.js'
-import getNamesOfTokensTransferredByServerTx from './get-names-of-tokens-transferred-by-server-tx.js'
-import getRawTransferAmount from './get-raw-transfer-amount.js'
-import getTransfersByTokenName from './get-transfers-by-token-name.js'
-import getValueOfTransfers from './get-value-of-transfers.js'
-import isConfirmedServerTx from './is-confirmed-server-tx.js'
-import isConsideredSentTokenTx from './is-considered-sent-token-tx.js'
-
-// This function takes a server transaction object fetched from magnifier,
-// and transforms it into Tx models to update the exodus state.
-
-const tryFindExternalRecipient = (transfers, ourWalletAddress) =>
-  transfers.find(({ to }) => to !== ourWalletAddress)?.to || ourWalletAddress
-
-function isSelfSendTx({
-  coinAmount,
-  ourWalletWasSender,
-  sendingTransferPresent,
-  receivingTransferPresent,
-}) {
-  return (
-    coinAmount.isZero && sendingTransferPresent && receivingTransferPresent && ourWalletWasSender
-  )
-}
-
-function isNftTransfer({ serverTx, ourWalletAddress }) {
-  if (!Array.isArray(serverTx.erc721) || serverTx.erc721.length === 0) return false
-
-  return serverTx.erc721.some(
-    (transfer) => transfer.to === ourWalletAddress || transfer.from === ourWalletAddress
-  )
-}
-
-export default function getLogItemsFromServerTx({
-  serverTx,
-  asset,
-  ourWalletAddress,
-  tokensByAddress,
-  assets,
-}) {
-  const confirmations = isConfirmedServerTx(serverTx) ? 1 : 0
-  const date = new Date(parseInt(serverTx.timestamp, 16) * 1000) // included even for unconfirmed txs
-  const txId = serverTx.hash
-  const nonce = parseInt(serverTx.nonce, 16)
-  const gasLimit = parseInt(serverTx.gas, 16)
-  const error = serverTx.error || (serverTx.status === false ? 'Failed' : null)
-  const feeAmount = getFeeAmount(asset, serverTx)
-  const ethereumTransfers = [serverTx, ...(serverTx.internal || [])]
-  const tokenTransfersByTokenName = getTransfersByTokenName(serverTx.erc20 || [], tokensByAddress)
-  const toAddress = tryFindExternalRecipient(ethereumTransfers, ourWalletAddress)
-  const ourWalletWasSender = serverTx.from === ourWalletAddress
-  const METHOD_ID_LENGTH = 10
-  const methodId = serverTx.data && {
-    methodId: serverTx.data.slice(0, Math.max(0, METHOD_ID_LENGTH)),
-  }
-  const data = serverTx.data || '0x'
-  const logItemCommonProperties = {
-    confirmations,
-    date,
-    error,
-    txId,
-    dropped: false,
-  }
-
-  const logItemsForServerTxEntries = []
-
-  {
-    const sendingTransferPresent = ethereumTransfers.some(({ from }) => from === ourWalletAddress)
-    const receivingTransferPresent = ethereumTransfers.some(({ to }) => to === ourWalletAddress)
-    const nftTransferPresent = isNftTransfer({ serverTx, ourWalletAddress })
-
-    if (sendingTransferPresent || receivingTransferPresent || nftTransferPresent) {
-      const coinAmount = getValueOfTransfers(ourWalletAddress, asset, ethereumTransfers)
-      // `rawCoinAmount` mirrors the field written by `getOptimisticTxLogEffects`
-      // and is consumed by the bump path (`tx-create.js`) to recover the
-      // user-signed on-chain `value` when accelerating a self-send (where
-      // `coinAmount` is zero). For the base-asset entry the raw amount is the
-      // top-level `value` field of the tx itself, not the sum of internal
-      // transfers — that's what the user signed and what we must restore on
-      // bump.
-      const rawCoinAmount = getRawTransferAmount({
-        ourWalletAddress,
-        asset,
-        transfers: [serverTx],
-      }).toBaseString()
-      const selfSend = isSelfSendTx({
-        coinAmount,
-        ourWalletWasSender,
-        sendingTransferPresent,
-        receivingTransferPresent,
-      })
-      let sent
-      if (sendingTransferPresent) {
-        sent = serverTx.internal
-          .map(({ from, to, value }) => {
-            if (from === ourWalletAddress) {
-              const amount = asset.currency.baseUnit(value).toDefaultString({ unit: true })
-              return { address: to, amount }
-            }
-          })
-          .filter(Boolean)
-      }
-
-      logItemsForServerTxEntries.push([
-        asset.name,
-        {
-          ...logItemCommonProperties,
-          coinAmount,
-          coinName: asset.name,
-          data: {
-            data,
-            nonce,
-            gasLimit,
-            rawCoinAmount,
-            ...methodId,
-            ...(sent?.length > 0 ? { sent } : undefined),
-          },
-          ...(ourWalletWasSender
-            ? { from: [], to: toAddress, feeAmount, feeCoinName: asset.feeAsset.name }
-            : { from: [serverTx.from] }),
-          selfSend,
-          tokens: getNamesOfTokensTransferredByServerTx({
-            asset,
-            tokensByAddress,
-            serverTx,
-            ourWalletAddress,
-          }),
-          currencies: {
-            [asset.name]: asset.currency,
-            [asset.feeAsset.name]: asset.feeAsset.currency,
-          },
-        },
-      ])
-    }
-  }
-
-  // handle erc20
-  Object.entries(tokenTransfersByTokenName).forEach(([tokenName, tokenTransfers]) => {
-    const sendingTransferPresent = tokenTransfers.some(({ from }) => from === ourWalletAddress)
-    const receivingTransferPresent = tokenTransfers.some(({ to }) => to === ourWalletAddress)
-    if (!sendingTransferPresent && !receivingTransferPresent) return
-
-    const token = assets[tokenName]
-    const tokenTransferToAddress = tryFindExternalRecipient(tokenTransfers, ourWalletAddress)
-    // Transfers from this reader's server source are tagged with
-    // `events: true` once the tx is included in a block (event-log derived)
-    // and `events: false` while still pending (tx-data derived). Only one
-    // flavor is real for a given lifecycle state; filtering avoids
-    // double-counting if both ever coexist for the same transfer. Both
-    // `coinAmount` and `rawCoinAmount` must see the same set so they stay
-    // consistent.
-    const filteredTokenTransfers = lodash.filter(tokenTransfers, {
-      events: confirmations > 0,
-    })
-    const coinAmount = getValueOfTransfers(ourWalletAddress, token, filteredTokenTransfers)
-    // See base-entry comment above; for token entries the raw amount is the
-    // absolute total tokens our wallet moved in this tx (sum of outgoing, or
-    // incoming for receive-only entries).
-    const rawCoinAmount = getRawTransferAmount({
-      ourWalletAddress,
-      asset: token,
-      transfers: filteredTokenTransfers,
-    }).toBaseString()
-    const tokenFromAddresses = lodash.uniq(
-      tokenTransfers.filter(({ to }) => to === ourWalletAddress).map(({ from }) => from)
-    )
-
-    const isConsideredSent = isConsideredSentTokenTx({
-      coinAmount,
-      ourWalletWasSender,
-      sendingTransferPresent,
-      receivingTransferPresent,
-    })
-    const selfSend = isSelfSendTx({
-      coinAmount,
-      ourWalletWasSender,
-      sendingTransferPresent,
-      receivingTransferPresent,
-    })
-
-    logItemsForServerTxEntries.push([
-      tokenName,
-      {
-        ...logItemCommonProperties,
-        coinAmount,
-        coinName: tokenName,
-        data: { data, nonce, gasLimit, rawCoinAmount, ...methodId },
-        ...(isConsideredSent
-          ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: asset.feeAsset.name }
-          : { from: tokenFromAddresses }),
-        selfSend,
-        currencies: {
-          [token.name]: token.currency,
-          [token.feeAsset.name]: token.feeAsset.currency,
-        },
-      },
-    ])
-  })
-
-  return Object.fromEntries(logItemsForServerTxEntries)
-}

package/src/tx-log/monitor-utils/get-names-of-tokens-transferred-by-server-tx.js

@@ -1,40 +0,0 @@
-import { FEE_PAYMENT_PREFIX } from '@exodus/ethereum-lib'
-import lodash from 'lodash'
-
-import getValueOfTransfers from './get-value-of-transfers.js'
-
-// For ETH transactions, we store an array of token names inside
-// the TX model. This array is used to display text in the UI for
-// transactions which pay fees for ERC20 token transfers. This
-// function is used to determine that array, choosing which
-// tokens a transaction ostensibly 'paid fees' for.
-
-export default function getNamesOfTokensTransferredByServerTx({
-  asset,
-  tokensByAddress,
-  ourWalletAddress,
-  serverTx,
-}) {
-  // Treat smart contract ETH transfer transactions as ETH transfers, not token transfers
-  if (!getValueOfTransfers(ourWalletAddress, asset, serverTx.internal || []).isZero) {
-    return []
-  }
-
-  const tokenAddresses = (serverTx.erc20 || []).map((event) => event.address)
-  if (
-    tokenAddresses.length === 0 &&
-    serverTx.data &&
-    serverTx.data !== '0x' &&
-    !serverTx.data.startsWith(FEE_PAYMENT_PREFIX)
-  ) {
-    // We may still be transacting with tokens even though we found no `tokenAddresses`. This includes
-    // failed token transactions as well as other transactions sent to a token contract. If we do not
-    // recognize the `to` address in the next step, then we will not treat it as a token contract address.
-    tokenAddresses.push(serverTx.to)
-  }
-
-  return lodash
-    .uniq(tokenAddresses)
-    .map((address) => tokensByAddress.get(address)?.name)
-    .filter(Boolean)
-}

package/src/tx-log/ws-updates.js

@@ -1,71 +0,0 @@
-import ms from 'ms'
-
-const subscribedToAddressNotificationsMap = new Map()
-
-const UPDATE_LOOP_INTERVAL = ms('5m')
-
-export function subscribeToWSNotifications({
-  addressesByWalletAccount,
-  tick,
-  server,
-  beforeStart = false,
-}) {
-  Object.entries(addressesByWalletAccount).forEach(([walletAccount, addresses]) => {
-    const address = String([...addresses][0]).toLowerCase() // Only check m/0/0
-    const mapKey = `${server.getURL()}:${address}` // different chains might have the same addresses
-    if (subscribedToAddressNotificationsMap.has(mapKey)) return
-
-    server.ws.watch(address)
-    server.ws.events.on(`address-${address}`, () => {
-      tick({ refresh: false, walletAccount })
-    })
-    subscribedToAddressNotificationsMap.set(mapKey, true)
-    if (!beforeStart) {
-      // tick for a new wallet account
-      tick({ refresh: false, walletAccount })
-    }
-  })
-}
-
-export function subscribeToGasPriceNotifications({
-  server,
-  updateGasPrice,
-  subscribedToGasPriceMap,
-}) {
-  const mapKey = server.getURL()
-  if (subscribedToGasPriceMap.has(mapKey)) return
-  server.ws.events.on('gasprice', updateGasPrice)
-  subscribedToGasPriceMap.set(mapKey, true)
-}
-
-export function enableWSUpdates({
-  interval,
-  server,
-  timer,
-  tickWalletAccounts,
-  tick,
-  addressesByWalletAccount,
-  beforeStart = false,
-}) {
-  const defaultInterval = interval
-
-  subscribeToWSNotifications({
-    server,
-    beforeStart,
-    tick,
-    addressesByWalletAccount,
-  })
-
-  server.ws.events.on('open', () => {
-    if (timer.isRunning) {
-      timer.setNewInterval(UPDATE_LOOP_INTERVAL)
-    }
-  })
-  server.ws.events.on('close', async () => {
-    if (timer.isRunning) {
-      await timer.setNewInterval(defaultInterval)
-      return tickWalletAccounts()
-    }
-  })
-  server.ws.open()
-}