@exodus/ethereum-api 8.76.2 → 8.76.4

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.4](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.3...@exodus/ethereum-api@8.76.4) (2026-06-02)
+
+
+### Bug Fixes
+
+
+* fix(ethereum-api): eliminate send-all dust on HYPE and other forceGasLimitEstimation networks (#7747)
+
+
+
+## [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.4",
   "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": "f0c007138096bf627e21fc9e757637394fe2a5b0"
 }

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/create-asset.js

@@ -276,7 +276,7 @@ export const createAssetFactory = ({
     })
 
     const getFeeAsync = async (...args) => {
-      const { unsignedTx, ...rest } = await createTx(...args)
+      const { unsignedTx, amount, ...rest } = await createTx(...args)
       return rest
     }
 

package/src/gas-estimation.js

@@ -119,6 +119,7 @@ export async function fetchGasLimit({
   bip70,
   txType = TX_TYPE_TRANSFER,
   throwOnError = true,
+  isSendAll = false,
 }) {
   if (bip70?.bitpay?.data && bip70?.bitpay?.gasPrice) {
     // from on chain stats https://dune.xyz/queries/189123
@@ -178,7 +179,15 @@ export async function fetchGasLimit({
     })
 
     const scaledGasLimitEstimate = scaleGasLimitEstimate({ estimatedGasLimit, gasLimitMultiplier })
-    if (!isToken) return scaledGasLimitEstimate
+    if (!isToken) {
+      // For native send-all on EOA targets, return the raw `eth_estimateGas`
+      // result (no 2x safety pad). Combined with the EIP-1559 tip override
+      // applied in tx-create.js (also gated on `isSendAll && !isContract`),
+      // this is the no-dust path: gasLimit ≈ gasUsed, so nothing comes back
+      // as refund. For contracts we keep the safety pad because contract
+      // gas can be nondeterministic against estimates.
+      return isSendAll && !isContractTxToAddress ? estimatedGasLimit : scaledGasLimitEstimate
+    }
 
     // NOTE: If we've enabled `fixGasLimit`s for a token,
     //       we need to make sure that transaction we're

package/src/move-funds.js

@@ -4,6 +4,7 @@ import assert from 'minimalistic-assert'
 
 import { getNonce, getTokenBalanceFromNode } from './eth-like-util.js'
 import { fetchGasLimit } from './gas-estimation.js'
+import { AmountIncludesFeeUnderflowError } from './tx-create.js'
 
 export const moveFundsFactory = ({ baseAssetName, assetClientInterface, createTx, server }) => {
   assert(baseAssetName, 'baseAssetName is required')
@@ -73,37 +74,69 @@ export const moveFundsFactory = ({ baseAssetName, assetClientInterface, createTx
       fromAddress,
       toAddress,
       amount,
+      // `isSendAll` and `amountIncludesFee` are no-ops on the token branch
+      // (both gated on `!isToken` / `!isEthereumLikeToken(asset)` downstream),
+      // so don't pass them. Keeps the API surface honest about which flags
+      // actually take effect for each branch.
+      ...(isToken ? null : { isSendAll: true }),
     })
 
-    const fee = feeData.gasPrice.mul(gasLimit)
-
-    const afterFee = ethBalance.sub(fee)
-    if (isToken) {
-      if (afterFee.isNegative) {
-        throw new MoveFundsError('token-fee-insufficient', { fromAddress })
-      }
-    } else {
-      if (!afterFee.isPositive) {
+    let createTxResult
+    try {
+      createTxResult = await createTx({
+        asset,
+        walletAccount,
+        fromAddress,
+        // Native sweep: pass the full balance and let createTx subtract the
+        // accurate fee. Token sweep: pass the full token balance unchanged
+        // (the native gas fee is paid separately from native balance).
+        address: toAddress,
+        amount,
+        nonce,
+        gasLimit,
+        gasPrice: feeData.gasPrice,
+        // TODO: drop this. Move funds has no fee picker, so it's always
+        // `feeData.gasPrice` (same as `gasPrice` above) and a no-op anyway.
+        // If we ever need a custom fee, thread it through prepareSendFundsTx.
+        customFee: feeData.gasPrice,
+        // Both flags are no-ops for tokens (see fetchGasLimit call above).
+        ...(isToken ? null : { isSendAll: true, amountIncludesFee: true }),
+      })
+    } catch (err) {
+      // createTx throws `AmountIncludesFeeUnderflowError` for the native
+      // sweep when the accurate fee (including OP-stack L1 data fee) exceeds
+      // the balance we passed in. Translate to the typed MoveFundsError so
+      // consumers (mobile/desktop MoveFunds screens) render the right copy.
+      if (!isToken && err instanceof AmountIncludesFeeUnderflowError) {
         throw new MoveFundsError('balance-negative', { fromAddress })
       }
 
-      amount = amount.sub(fee)
+      throw err
     }
 
-    const { unsignedTx } = await createTx({
-      asset,
-      walletAccount,
-      fromAddress,
-      address: toAddress,
-      amount,
-      nonce,
-      gasLimit,
-      gasPrice: feeData.gasPrice,
-      customFee: feeData.gasPrice,
-      isSendAll: true,
-    })
+    // Token sweep equivalent of the native underflow gate: createTx doesn't
+    // validate ETH balance vs gas for token transfers, so check it here using
+    // the authoritative fee returned from `calculateFee`. This catches the
+    // OP-stack edge case where balance covers `gasPrice * gasLimit` but not
+    // the additional L1 data fee.
+    if (isToken && ethBalance.sub(createTxResult.fee).isNegative) {
+      throw new MoveFundsError('token-fee-insufficient', { fromAddress })
+    }
 
-    return { fromAddress, toAddress, amount, fee, privateKey, unsignedTx }
+    // Trust createTx for both amount and fee. For native sweep `amount` is
+    // the post-subtraction value (input balance minus accurate fee). For
+    // token sweep `amount` is the input token balance unchanged, since we
+    // don't pass `amountIncludesFee`. In both cases `fee` includes the
+    // OP-stack L1 data fee from `calculateFee`, which matters more for
+    // tokens than for native because ERC-20 calldata is larger.
+    return {
+      fromAddress,
+      toAddress,
+      amount: createTxResult.amount,
+      fee: createTxResult.fee,
+      privateKey,
+      unsignedTx: createTxResult.unsignedTx,
+    }
   }
 
   const sendFunds = async ({ privateKey, unsignedTx }) => {

package/src/tx-create.js

@@ -20,6 +20,62 @@ import {
   TX_TYPE_TRANSFER,
 } from './tx-type/index.js'
 
+// Thrown by `resolveAmountIncludesFeeTxAttributes` when the fee subtraction
+// implied by `amountIncludesFee` would drive the resulting tx value below
+// zero (i.e. the caller's balance can't cover the computed fee). Exported so
+// callers like MoveFunds can `instanceof`-check and translate it into their
+// own user-facing error type without string-matching the message.
+export class AmountIncludesFeeUnderflowError extends Error {
+  constructor() {
+    super('transaction gas cost exceeds fee-inclusive amount')
+    this.name = 'AmountIncludesFeeUnderflowError'
+  }
+}
+
+async function calculateFee({
+  asset,
+  chainId,
+  eip1559Enabled,
+  gasLimit,
+  gasPrice,
+  tipGasPrice,
+  nonce,
+  txInput,
+  txToAddress,
+  txValue,
+}) {
+  const ethjsTx = createEthereumJsTx({
+    txData: {
+      nonce,
+      gasPrice: currency2buffer(gasPrice),
+      tipGasPrice: tipGasPrice ? currency2buffer(tipGasPrice) : undefined,
+      gasLimit,
+      to: txToAddress,
+      value: currency2buffer(txValue),
+      data: txInput,
+      chainId,
+    },
+    txMeta: {
+      eip1559Enabled,
+    },
+  })
+  const transactionBuffer = ethjsTx.serialize()
+
+  const baseFee = gasPrice.mul(gasLimit)
+  const optimismL1DataFee = asset.baseAsset.estimateL1DataFee
+    ? await asset.baseAsset.estimateL1DataFee({
+        unsignedTx: { txData: { transactionBuffer, chainId } },
+      })
+    : undefined
+
+  const l1DataFee = optimismL1DataFee
+    ? asset.baseAsset.currency.baseUnit(optimismL1DataFee)
+    : asset.baseAsset.currency.ZERO
+
+  const fee = baseFee.add(l1DataFee)
+  return { fee, transactionBuffer }
+}
+
 async function createUnsignedTxWithFees({
   asset,
   chainId,
@@ -57,35 +113,19 @@ async function createUnsignedTxWithFees({
     isContractTxToAddress,
   })
 
-  const ethjsTx = createEthereumJsTx({
-    txData: {
-      nonce,
-      gasPrice: currency2buffer(gasPrice),
-      tipGasPrice: tipGasPrice ? currency2buffer(tipGasPrice) : undefined,
-      gasLimit,
-      to: txToAddress,
-      value: currency2buffer(txValue),
-      data: txInput,
-      chainId,
-    },
-    txMeta: {
-      eip1559Enabled,
-    },
+  const { fee, transactionBuffer } = await calculateFee({
+    asset,
+    chainId,
+    eip1559Enabled,
+    gasLimit,
+    gasPrice,
+    tipGasPrice,
+    nonce,
+    txInput,
+    txToAddress,
+    txValue,
   })
-  const transactionBuffer = ethjsTx.serialize()
 
-  const baseFee = gasPrice.mul(gasLimit)
-  const optimismL1DataFee = asset.baseAsset.estimateL1DataFee
-    ? await asset.baseAsset.estimateL1DataFee({
-        unsignedTx: { txData: { transactionBuffer, chainId } },
-      })
-    : undefined
-
-  const l1DataFee = optimismL1DataFee
-    ? asset.baseAsset.currency.baseUnit(optimismL1DataFee)
-    : asset.baseAsset.currency.ZERO
-
-  const fee = baseFee.add(l1DataFee)
   const extraFeeData = getExtraFeeData({ asset, amount, txValue })
   const unsignedTx = {
     txData: { transactionBuffer, chainId },
@@ -102,6 +142,7 @@ async function createUnsignedTxWithFees({
   return {
     unsignedTx,
     fee,
+    amount,
     extraFeeData,
     // exhcange compatibility until the use usignedTx, remove me!
     gasPrice,
@@ -110,6 +151,60 @@ async function createUnsignedTxWithFees({
   }
 }
 
+// TODO: Move this into tx attribute resolution once gasLimit is resolved there.
+// `amountIncludesFee` changes the tx value, so the fee subtraction should happen
+// in the same flow that finalizes amount, txValue, txInput, txToAddress, and
+// gasLimit.
+async function resolveAmountIncludesFeeTxAttributes({
+  amountIncludesFee,
+  asset,
+  chainId,
+  eip1559Enabled,
+  gasLimit,
+  gasPrice,
+  tipGasPrice,
+  txAttributes,
+}) {
+  const { amount, nonce, txInput, txToAddress, txValue } = txAttributes
+
+  // `amountIncludesFee` is a hint: subtract any fee that is paid in the same
+  // currency as `amount`. On EVM today, gas is paid in the native asset, so
+  // for ERC-20 sends and zero-value calldata (i.e approve()) flows there is nothing in the
+  // amount's currency to subtract. Pass through silently in those cases, so
+  // consumers can set this flag based on intent without needing to know
+  // whether the asset is a token or whether the call carries zero native
+  // value.
+  if (!amountIncludesFee || isEthereumLikeToken(asset) || amount.isZero) {
+    return { txAttributes }
+  }
+
+  const { fee } = await calculateFee({
+    asset,
+    chainId,
+    eip1559Enabled,
+    gasLimit,
+    gasPrice,
+    tipGasPrice,
+    nonce,
+    txInput,
+    txToAddress,
+    txValue,
+  })
+  const reducedAmount = amount.sub(fee)
+
+  if (!reducedAmount.gte(asset.currency.ZERO)) {
+    throw new AmountIncludesFeeUnderflowError()
+  }
+
+  return {
+    txAttributes: {
+      ...txAttributes,
+      amount: reducedAmount,
+      txValue: reducedAmount,
+    },
+  }
+}
+
 const resolveTxFactoryGasPrices = async ({
   assetClientInterface,
   baseAsset,
@@ -384,7 +479,12 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
     gasPrice: providedGasPrice,
     bip70,
     customFee: providedCustomFee,
+    // Intent flag: the user is trying to empty the wallet. Used for send-all-only
+    // dust behavior such as the EIP-1559 tip override.
     isSendAll,
+    // Amount semantics flag: the provided amount includes the fee budget, so the
+    // final tx value should be reduced by the computed fee.
+    amountIncludesFee = false,
     bumpTxId,
   }) => {
     assert(asset, 'asset is required')
@@ -520,6 +620,7 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
         bip70,
         amount: resolvedTxAttributes.amount,
         txType,
+        isSendAll,
       }))
 
     // HACK: We cannot ensure the no dust invariant for `isSendAll`
@@ -532,8 +633,21 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
     const isSendAllBaseAsset =
       isSendAll && !isEthereumLikeToken(asset) && !resolvedTxAttributes.isContractTxToAddress
 
+    const finalTipGasPrice = isSendAllBaseAsset && eip1559Enabled ? gasPrice : tipGasPrice
+
+    const { txAttributes: finalTxAttributes } = await resolveAmountIncludesFeeTxAttributes({
+      amountIncludesFee,
+      asset,
+      chainId,
+      eip1559Enabled,
+      gasLimit,
+      gasPrice,
+      tipGasPrice: finalTipGasPrice,
+      txAttributes: resolvedTxAttributes,
+    })
+
     return createUnsignedTxWithFees({
-      ...resolvedTxAttributes,
+      ...finalTxAttributes,
       asset,
       chainId,
       gasLimit,
@@ -545,7 +659,7 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
       // fixed gas cost transaction, no dust balance should remain,
       // since any deviation in the underlying `baseFeePerGas` will
       // result only affect the tip for the miner - no dust remains.
-      tipGasPrice: isSendAllBaseAsset && eip1559Enabled ? gasPrice : tipGasPrice,
+      tipGasPrice: finalTipGasPrice,
       eip1559Enabled,
     })
   }

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