@exodus/ethereum-api 8.76.1 → 8.76.3

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 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)
+
+
+### Bug Fixes
+
+
+* fix(ethereum-api): persist rawCoinAmount in tx-log monitor readers (#8131)
+
+
+
 ## [8.76.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.0...@exodus/ethereum-api@8.76.1) (2026-05-26)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.76.1",
+  "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": "50c5568a3fb1663b61344b18a044ebc69bfd45f0"
+  "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-create.js

@@ -257,14 +257,29 @@ const createBumpUnsignedTx = async ({
     }
   }
 
-  const toAddress = (replacedTokenTx || replacedTx).to
+  const sourceTx = replacedTokenTx || replacedTx
+  const toAddress = sourceTx.to
+
+  // For self-sends `coinAmount` is `0` (correct for balance accounting, the
+  // wallet's net delta really is zero), so we can't reconstruct the on-chain
+  // value from it. Recover from `data.rawCoinAmount`, which the tx-log
+  // writers persist alongside `coinAmount` for exactly this purpose.
+  if (sourceTx.selfSend && !sourceTx.data?.rawCoinAmount) {
+    throw new Error(
+      `Cannot bump self-send transaction ${bumpTxId}: original transfer amount is unrecoverable from the tx log (data.rawCoinAmount missing). Re-broadcast the send with a higher fee instead.`
+    )
+  }
 
-  const amount = (replacedTokenTx || replacedTx).coinAmount.negate()
+  const amount = sourceTx.data?.rawCoinAmount
+    ? asset.currency.baseUnit(sourceTx.data.rawCoinAmount)
+    : sourceTx.coinAmount.negate()
 
   const txValue = assertValidTxValue({
     asset,
     amount,
-    txValue: replacedTx.coinAmount.negate(),
+    txValue: replacedTx.data?.rawCoinAmount
+      ? baseAsset.currency.baseUnit(replacedTx.data.rawCoinAmount)
+      : replacedTx.coinAmount.negate(),
   })
 
   const isDuplex = Boolean(replacedTokenTx && txValue.gt(baseAsset.currency.ZERO))

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

@@ -2,6 +2,7 @@ import lodash from 'lodash'
 
 import { getWalletUpdates } from '../monitor-utils/get-balance-updates.js'
 import getFeeAmount from '../monitor-utils/get-fee-amount.js'
+import getRawTransferAmount from '../monitor-utils/get-raw-transfer-amount.js'
 import getTransfersByTokenName from '../monitor-utils/get-transfers-by-token-name.js'
 import getValueOfTransfers from '../monitor-utils/get-value-of-transfers.js'
 import isConfirmedServerTx from '../monitor-utils/is-confirmed-server-tx.js'
@@ -62,6 +63,18 @@ export default function getLogItemsFromServerTx({
 
     if (shouldAttachTx) {
       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,
@@ -90,6 +103,7 @@ export default function getLogItemsFromServerTx({
             data,
             nonce,
             gasLimit,
+            rawCoinAmount,
             balanceChange: baseBalanceUpdate,
             nonceChange: nonceUpdate,
             ...methodId,
@@ -130,6 +144,14 @@ export default function getLogItemsFromServerTx({
 
     const tokenTransferToAddress = tryFindExternalRecipient(tokenTransfers, ourWalletAddress)
     const coinAmount = getValueOfTransfers(ourWalletAddress, token, tokenTransfers)
+    // 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: tokenTransfers,
+    }).toBaseString()
 
     const tokenFromAddresses = lodash.uniq(
       tokenTransfers.filter(({ to }) => to === ourWalletAddress).map(({ from }) => from)
@@ -158,6 +180,7 @@ export default function getLogItemsFromServerTx({
           data,
           nonce,
           gasLimit,
+          rawCoinAmount,
           balanceChange,
           ...methodId,
           ...(isFiniteInteger(blockNumber) ? { blockNumber } : null),

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

@@ -158,6 +158,7 @@ export const getOptimisticTxLogEffects = async ({
       txs: [
         {
           ...sharedProps,
+          data: { ...sharedProps.data, rawCoinAmount: amount.abs().toBaseString() },
           coinAmount: selfSend ? asset.currency.ZERO : amount.abs().negate(),
           coinName: asset.name,
           currencies: {
@@ -173,6 +174,7 @@ export const getOptimisticTxLogEffects = async ({
       txs: [
         {
           ...sharedProps,
+          data: { ...sharedProps.data, rawCoinAmount: txValue.abs().toBaseString() },
           coinAmount: selfSend ? baseAsset.currency.ZERO : txValue.abs().negate(),
           coinName: baseAsset.name,
           currencies: {

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

@@ -2,6 +2,7 @@ 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'
@@ -50,6 +51,18 @@ export default function getLogItemsFromServerTx({
 
     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,
@@ -78,6 +91,7 @@ export default function getLogItemsFromServerTx({
             data,
             nonce,
             gasLimit,
+            rawCoinAmount,
             ...methodId,
             ...(sent?.length > 0 ? { sent } : undefined),
           },
@@ -108,11 +122,25 @@ export default function getLogItemsFromServerTx({
 
     const token = assets[tokenName]
     const tokenTransferToAddress = tryFindExternalRecipient(tokenTransfers, ourWalletAddress)
-    const coinAmount = getValueOfTransfers(
+    // 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,
-      token,
-      lodash.filter(tokenTransfers, { events: confirmations > 0 })
-    )
+      asset: token,
+      transfers: filteredTokenTransfers,
+    }).toBaseString()
     const tokenFromAddresses = lodash.uniq(
       tokenTransfers.filter(({ to }) => to === ourWalletAddress).map(({ from }) => from)
     )
@@ -136,7 +164,7 @@ export default function getLogItemsFromServerTx({
         ...logItemCommonProperties,
         coinAmount,
         coinName: tokenName,
-        data: { data, nonce, gasLimit, ...methodId },
+        data: { data, nonce, gasLimit, rawCoinAmount, ...methodId },
         ...(isConsideredSent
           ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: asset.feeAsset.name }
           : { from: tokenFromAddresses }),

package/src/tx-log/monitor-utils/get-raw-transfer-amount.js

@@ -0,0 +1,29 @@
+// Returns the absolute raw transferred amount for `ourWalletAddress`, in
+// `asset` base units, as a NumberUnit. Unlike `getValueOfTransfers` (which
+// returns the signed net delta), this preserves the raw transfer value even
+// when sender and receiver net to zero — e.g. self-sends. Used by tx-log
+// writers to persist `data.rawCoinAmount` so the bump path can reconstruct
+// the original on-chain value when accelerating a self-send.
+//
+// Each transfer is expected to have the shape `{ from, to, value }`. For the
+// base-asset entry, pass `[serverTx]` (the tx itself has the same shape at
+// its top level); for token entries, pass the array of token transfers for
+// that token.
+//
+// Outgoing transfers (from === ourWalletAddress) take precedence: when our
+// wallet sent anything, the raw amount is the sum of what we sent. We fall
+// back to incoming so receiver-only entries still report a non-zero raw
+// amount for consistency, even though the bump path only consults it on the
+// sender side.
+
+export default function getRawTransferAmount({ ourWalletAddress, asset, transfers }) {
+  const outgoing = transfers
+    .filter(({ from }) => from === ourWalletAddress)
+    .reduce((sum, { value }) => sum.add(asset.currency.baseUnit(value)), asset.currency.ZERO)
+
+  if (!outgoing.isZero) return outgoing
+
+  return transfers
+    .filter(({ to }) => to === ourWalletAddress)
+    .reduce((sum, { value }) => sum.add(asset.currency.baseUnit(value)), asset.currency.ZERO)
+}

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,
-        })
-    )
-  }
-}