@exodus/ethereum-api 8.70.2 → 8.71.0

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.71.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.70.2...@exodus/ethereum-api@8.71.0) (2026-04-13)
+
+
+### Features
+
+
+* feat: evm duplex transactions (#7688)
+
+* feat: import ethersproject-abi@5 to exodus/ethereumjs (#7626)
+
+* feat: surface validator queue times to ethereum staking service (#7438)
+
+
+### Bug Fixes
+
+
+* fix: enable duplex transaction bumps and serialize tx.data.data to txLog (#7705)
+
+* fix(ethereum-api): use the right ns key for sockets upon disconnection (#7716)
+
+* fix: EVM balance updates when clarity history fetch fails (#7652)
+
+* fix: remove unsignedTx from getFeeAsync return value (#7164)
+
+* fix: route event-driven ticks through tickWalletAccounts in ClarityMonitor (#7711)
+
+
+
 ## [8.70.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.70.1...@exodus/ethereum-api@8.70.2) (2026-03-27)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.70.2",
+  "version": "8.71.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",
@@ -33,7 +33,6 @@
     "@exodus/ethereum-meta": "^2.9.1",
     "@exodus/ethereumholesky-meta": "^2.0.5",
     "@exodus/ethereumjs": "^1.8.0",
-    "@exodus/ethersproject-abi": "^5.4.2-exodus.2",
     "@exodus/fetch": "^1.3.0",
     "@exodus/models": "^13.0.0",
     "@exodus/safe-string": "^1.4.0",
@@ -69,5 +68,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "959153b1ea9f3fc33398dd5a167c2c29c8af2df1"
+  "gitHead": "0d1117298321691db0e13516ec5178fb2b8e1f73"
 }

package/src/create-asset-utils.js

@@ -1,5 +1,5 @@
 import { BlacklistCheckTypes } from '@exodus/asset-lib'
-import { defaultAbiCoder } from '@exodus/ethersproject-abi'
+import { defaultAbiCoder } from '@exodus/ethereumjs/ethers5-abi'
 import { safeString } from '@exodus/safe-string'
 import assert from 'minimalistic-assert'
 import ms from 'ms'

package/src/create-asset.js

@@ -258,6 +258,11 @@ export const createAssetFactory = ({
       createTx,
     })
 
+    const getFeeAsync = async (...args) => {
+      const { unsignedTx, ...rest } = await createTx(...args)
+      return rest
+    }
+
     const estimateL1DataFee = l1GasOracleAddress
       ? estimateL1DataFeeFactory({ l1GasOracleAddress, server })
       : undefined
@@ -291,7 +296,7 @@ export const createAssetFactory = ({
       ...(getBlackListStatus && { getBlackListStatus }),
       getConfirmationsNumber: () => confirmationsNumber,
       getDefaultAddressPath: () => defaultAddressPath,
-      getFeeAsync: createTx, // createTx alias, remove me when possible
+      getFeeAsync, // createTx alias, remove me when possible
       getFee,
       getFeeData: () => feeData,
       getKeyIdentifier: createGetKeyIdentifier({

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

@@ -79,11 +79,11 @@ export default class ClarityServer extends EventEmitter {
   }
 
   disconnectRpc() {
-    this.disconnectSocket(this.rpcNamespace)
+    this.disconnectSocket(this.formatRpcNamespace())
   }
 
   disconnectFee() {
-    this.disconnectSocket(this.feeNamespace)
+    this.disconnectSocket(this.formatFeeNamespace())
   }
 
   disconnectSocket(namespace) {

package/src/gas-estimation.js

@@ -113,6 +113,7 @@ export async function fetchGasLimit({
   fromAddress: providedFromAddress,
   toAddress: providedToAddress,
   txInput: providedTxInput,
+  txValue: providedTxValue,
   amount: providedAmount,
   contractAddress: providedTxToAddress,
   bip70,
@@ -133,6 +134,7 @@ export async function fetchGasLimit({
     toAddress: providedToAddress,
     txToAddress: providedTxToAddress,
     txInput: providedTxInput,
+    txValue: providedTxValue,
     txType,
   })
 

package/src/get-fee.js

@@ -2,6 +2,7 @@ import {
   calculateBumpedGasPrice,
   calculateBumpedGasPriceForFeeData,
   calculateExtraEth,
+  isEthereumLikeToken,
 } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
 
@@ -17,7 +18,11 @@ const taxes = {
   paxgold: 0.0002,
 }
 
-export const getExtraFeeData = ({ asset, amount }) => {
+export const getExtraFeeData = ({ asset, amount, txValue }) => {
+  if (isEthereumLikeToken(asset) && txValue?.gt(asset.baseAsset.currency.ZERO)) {
+    return { type: 'tax', extraFee: txValue }
+  }
+
   const tax = taxes[asset.name]
   if (!amount || !tax || amount.isZero) {
     return {}
@@ -87,7 +92,7 @@ export const getAggregateTransactionPricing = ({ baseAsset, customFee, feeData,
 
 export const getFeeFactory =
   () =>
-  ({ asset, feeData, customFee, txInput, gasLimit: providedGasLimit, amount }) => {
+  ({ asset, feeData, customFee, txInput, gasLimit: providedGasLimit, amount, txValue }) => {
     const {
       feeData: { tipGasPrice, eip1559Enabled },
       gasPrice,
@@ -103,7 +108,7 @@ export const getFeeFactory =
     // lock in the `tipGasPrice` we used to compute the fees.
     const maybeReturnTipGasPrice = eip1559Enabled ? { tipGasPrice } : null
 
-    const extraFeeData = getExtraFeeData({ asset, amount })
+    const extraFeeData = getExtraFeeData({ asset, amount, txValue })
 
     const fee = gasPrice.mul(gasLimit)
     return { ...maybeReturnTipGasPrice, fee, gasPrice, extraFeeData }

package/src/staking/ethereum/everstake.js

@@ -0,0 +1,53 @@
+import { fetch as exodusFetch } from '@exodus/fetch'
+import { TraceId } from '@exodus/traceparent'
+import assert from 'minimalistic-assert'
+
+const BASE_URL = 'https://eth-clarity.a.exodus.io/api/v2/ethereum/proxy/everstake/'
+
+const fetch = async (path, config = Object.create(null)) => {
+  const url = new URL(path, BASE_URL).toString()
+
+  const response = await exodusFetch(url, config)
+
+  const newErrorWithTrace = (msg) => {
+    const error = new Error(msg)
+    error.traceId = TraceId.fromResponse(response)
+    return error
+  }
+
+  if (!response.ok) throw newErrorWithTrace(`failed to fetch ${path}`)
+
+  const data = await response.json()
+
+  if (!data || typeof data !== 'object') throw newErrorWithTrace('malformed response')
+
+  return data
+}
+
+const isFiniteInteger = (e) => Number.isInteger(e) && Number.isFinite(e)
+
+export const getEverstakeValidatorsQueue = async () => {
+  // https://swagger.eth-api-b2c.everstake.one/#/Staking/validatorsQueue
+  const result = await fetch('v1/validators/queue')
+
+  const {
+    // Estimated time in seconds of delay before validator become active
+    validator_activation_time: validatorActivationTime,
+    // Estimated time in seconds of delay before validator become exited
+    validator_exit_time: validatorExitTime,
+    // Withdraw period in seconds from Beacon chain
+    validator_withdraw_time: validatorWithdrawTime,
+  } = result
+
+  assert(isFiniteInteger(validatorActivationTime), 'expected integer validatorActivationTime')
+  assert(isFiniteInteger(validatorExitTime), 'expected integer validatorExitTime')
+  assert(isFiniteInteger(validatorWithdrawTime), 'expected integer validatorWithdrawTime')
+
+  // NOTE: We convert the values into milliseconds for
+  //       normalized handling on clients.
+  return {
+    validatorActivationTime: validatorActivationTime * 1000,
+    validatorExitTime: validatorExitTime * 1000,
+    validatorWithdrawTime: validatorWithdrawTime * 1000,
+  }
+}

package/src/staking/ethereum/service.js

@@ -6,6 +6,7 @@ import { createWatchTx as defaultCreateWatch } from '../../watch-tx.js'
 import { stakingProviderClientFactory } from '../staking-provider-client.js'
 import { amountToCurrency, DISABLE_BALANCE_CHECKS, resolveFeeData } from '../utils/index.js'
 import { EthereumStaking } from './api.js'
+import { getEverstakeValidatorsQueue } from './everstake.js'
 
 const WETH9_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'
 
@@ -579,12 +580,14 @@ export async function getEthereumStakingInfo({ address, asset, server }) {
     pendingDepositedBalance,
     withdrawRequest,
     rewardsBalance,
+    everstakeValidatorsQueue,
   ] = await Promise.all([
     staking.autocompoundBalanceOf(delegator),
     staking.pendingBalanceOf(delegator),
     staking.pendingDepositedBalanceOf(delegator),
     staking.withdrawRequest(delegator),
     staking.getTotalRewards(delegator),
+    getEverstakeValidatorsQueue().catch(() => null),
   ])
 
   const delegatedBalance = activeStakedBalance.add(pendingBalance).add(pendingDepositedBalance)
@@ -614,5 +617,8 @@ export async function getEthereumStakingInfo({ address, asset, server }) {
     unclaimedUndelegatedBalance,
     canClaimUndelegatedBalance,
     isUndelegateInProgress,
+    validatorActivationTime: everstakeValidatorsQueue?.validatorActivationTime,
+    validatorExitTime: everstakeValidatorsQueue?.validatorExitTime,
+    validatorWithdrawTime: everstakeValidatorsQueue?.validatorWithdrawTime,
   }
 }

package/src/tx-create.js

@@ -1,4 +1,5 @@
 import {
+  assertValidTxValue,
   currency2buffer,
   getHighestIncentiveTxByNonce,
   isEthereumLikeToken,
@@ -85,7 +86,7 @@ async function createUnsignedTxWithFees({
     : asset.baseAsset.currency.ZERO
 
   const fee = baseFee.add(l1DataFee)
-  const extraFeeData = getExtraFeeData({ asset, amount })
+  const extraFeeData = getExtraFeeData({ asset, amount, txValue })
   const unsignedTx = {
     txData: { transactionBuffer, chainId },
     txMeta: {
@@ -262,8 +263,15 @@ const createBumpUnsignedTx = async ({
 
   const amount = (replacedTokenTx || replacedTx).coinAmount.negate()
 
-  const txInput = replacedTokenTx ? null : replacedTx.data.data || '0x'
+  const txValue = assertValidTxValue({
+    asset,
+    amount,
+    txValue: replacedTx.coinAmount.negate(),
+  })
+
+  const isDuplex = Boolean(replacedTokenTx && txValue.gt(baseAsset.currency.ZERO))
 
+  const txInput = replacedTokenTx && !isDuplex ? null : replacedTx.data.data || '0x'
   const replacedTxNonce = replacedTx.data.nonce
 
   assert(
@@ -291,6 +299,7 @@ const createBumpUnsignedTx = async ({
     txInput,
     toAddress,
     txType,
+    txValue,
     walletAccount,
   })
 
@@ -345,6 +354,8 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
     address, // same as toAddress
     txInput: providedTxInput, // Provided when swapping via a DEX contract
     txType = TX_TYPE_TRANSFER, // Defines what kind of transaction is being performed.
+    txValue: providedTxValue, // Override the native ETH value (e.g. payable contract calls with txInput when specifying a token asset)
+    contractAddress: providedTxToAddress, // Controls the final target address of the transaction.
     gasLimit: providedGasLimit, // Provided by exchange when known
     amount: providedAmount, // The NU amount to be sent, to be included in the tx value or tx input
     nonce: providedNonce,
@@ -377,6 +388,8 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
     })
 
     if (bumpTxId) {
+      assert(!providedTxValue && !providedTxToAddress)
+
       return createBumpUnsignedTx({
         chainId,
         asset,
@@ -422,6 +435,8 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
     })
 
     if (nft) {
+      assert(!providedTxValue && !providedTxToAddress)
+
       const {
         contractAddress: txToAddress,
         gasLimit,
@@ -464,7 +479,9 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
       nonce,
       txInput: providedTxInput,
       toAddress: providedToAddress,
+      txToAddress: providedTxToAddress,
       txType,
+      txValue: providedTxValue,
       walletAccount,
     })
 
@@ -478,6 +495,7 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
         fromAddress,
         toAddress: resolvedTxAttributes.toAddress,
         txInput: resolvedTxAttributes.txInput,
+        txValue: resolvedTxAttributes.txValue,
         contractAddress: resolvedTxAttributes.txToAddress,
         bip70,
         amount: resolvedTxAttributes.amount,

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

@@ -173,29 +173,103 @@ export class ClarityMonitorV2 extends BaseMonitor {
     }
 
     const { derivedData, tokensByAddress, assets, tokens, assetName } = walletAccountInfo
-
-    const response = await this.getHistoryFromServer({ walletAccount, derivedData, refresh })
-
-    const { allTxs } = await normalizeTransactionsResponse({
-      asset: this.asset,
-      fromAddress: derivedData.ourWalletAddress,
-      response,
-      walletAccount,
-    })
-
-    const cursor = response.cursor
-
-    await this.processAndFillTransactionsToState({
-      allTxs,
+    const { accountState, eip7702Delegation, isBlacklisted } = await this.getStateUpdate({
       derivedData,
-      tokensByAddress,
-      assets,
       tokens,
-      assetName,
       walletAccount,
-      refresh,
-      cursor,
     })
+    const batch = this.aci.createOperationsBatch()
+    const newData = {
+      ...accountState,
+      ...(isBlacklisted !== undefined && { isBlacklisted }),
+      ...(eip7702Delegation !== undefined && { eip7702Delegation }),
+    }
+    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({
@@ -209,7 +283,6 @@ export class ClarityMonitorV2 extends BaseMonitor {
     refresh,
     cursor,
   }) {
-    const shouldCheckBlacklist = this.tickCount[walletAccount] === 0
     const hasNewTxs = allTxs.length > 0
 
     const logItemsByAsset = this.getAllLogItemsByAsset({
@@ -230,27 +303,11 @@ export class ClarityMonitorV2 extends BaseMonitor {
       ...derivedData,
     })
 
-    const accountState = await this.getNewAccountState({
+    const { accountState, eip7702Delegation, isBlacklisted } = await this.getStateUpdate({
+      derivedData,
       tokens,
-      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
-      ourWalletAddress: derivedData.ourWalletAddress,
-    })
-
-    const eip7702Delegation = await getCurrentEIP7702Delegation({
-      server: this.server,
-      address: derivedData.ourWalletAddress,
-      eip7702Supported: this.eip7702Supported,
-      currentDelegation: derivedData.currentAccountState?.eip7702Delegation,
-      logger: this.logger,
+      walletAccount,
     })
-    const isBlacklisted = shouldCheckBlacklist
-      ? await getCurrentBlackListStatus({
-          getBlackListStatus: this.getBlackListStatus,
-          address: derivedData.ourWalletAddress,
-          currentIsBlacklisted: derivedData.currentAccountState?.isBlacklisted,
-          logger: this.logger,
-        })
-      : undefined
 
     const batch = this.aci.createOperationsBatch()
 
@@ -303,6 +360,33 @@ export class ClarityMonitorV2 extends BaseMonitor {
     }
   }
 
+  async getStateUpdate({ derivedData, tokens, walletAccount }) {
+    const shouldCheckBlacklist = this.tickCount[walletAccount] === 0
+    const accountState = await this.getNewAccountState({
+      tokens,
+      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
+      ourWalletAddress: derivedData.ourWalletAddress,
+    })
+
+    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 { accountState, eip7702Delegation, isBlacklisted }
+  }
+
   async addSingleTx({ tx, address, cursor }) {
     const walletAccounts = this.#walletAccountByAddress.get(address)
 

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

@@ -153,9 +153,7 @@ export class ClarityMonitor extends BaseMonitor {
 
   async tick({ walletAccount, refresh }) {
     await this.subscribeWalletAddresses()
-    // TODO: Investigate routing the onTransaction path through tickWithExtra first,
-    // so tickCount is initialized and this fallback can be removed in a dedicated follow-up.
-    const tickCount = this.tickCount[walletAccount] ?? 0
+    const tickCount = this.tickCount[walletAccount]
     const shouldCheckBlacklist = tickCount === 0
 
     const assets = await this.aci.getAssetsForNetwork({ baseAssetName: this.asset.name })
@@ -167,35 +165,107 @@ export class ClarityMonitor extends BaseMonitor {
     }, new Map())
     const assetName = this.asset.name
     const derivedData = await this.deriveData({ assetName, walletAccount, tokens })
-    const response = await this.getHistoryFromServer({ walletAccount, derivedData, refresh })
-
-    const { allTxs } = await normalizeTransactionsResponse({
-      asset: this.asset,
-      fromAddress: derivedData.ourWalletAddress,
-      response,
-      walletAccount,
+    const { accountState, eip7702Delegation, isBlacklisted } = await this.getStateUpdate({
+      derivedData,
+      tokens,
+      shouldCheckBlacklist,
     })
 
-    const hasNewTxs = allTxs.length > 0
+    const batch = this.aci.createOperationsBatch()
+    const newData = {
+      ...accountState,
+      ...(isBlacklisted !== undefined && { isBlacklisted }),
+      ...(eip7702Delegation !== undefined && { eip7702Delegation }),
+    }
+    let allTxs = []
+    let hasNewTxs = false
+    let historyError
 
-    const logItemsByAsset = this.getAllLogItemsByAsset({
-      getLogItemsFromServerTx,
-      ourWalletAddress: derivedData.ourWalletAddress,
-      allTransactionsFromServer: allTxs,
-      asset: this.asset,
-      tokensByAddress,
-      assets,
-    })
+    try {
+      const response = await this.getHistoryFromServer({ walletAccount, derivedData, refresh })
 
-    const { txsToRemove } = await this.checkPendingTransactions({
-      txlist: allTxs,
-      walletAccount,
-      refresh,
-      logItemsByAsset,
-      asset: this.asset,
-      ...derivedData,
-    })
+      ;({ 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,
+        })
+      }
+
+      newData.clarityCursor = response.cursor
+    } catch (error) {
+      historyError = error
+    }
+
+    try {
+      // Persist balance and account metadata even when the history path fails
+      // during startup bursts or other temporary backend pressure.
+      this.aci.updateAccountStateBatch({
+        assetName,
+        walletAccount,
+        accountState,
+        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 getStateUpdate({ derivedData, tokens, shouldCheckBlacklist }) {
     const accountState = await this.getNewAccountState({
       tokens,
       currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
@@ -209,6 +279,7 @@ export class ClarityMonitor extends BaseMonitor {
       currentDelegation: derivedData.currentAccountState?.eip7702Delegation,
       logger: this.logger,
     })
+
     const isBlacklisted = shouldCheckBlacklist
       ? await getCurrentBlackListStatus({
           getBlackListStatus: this.getBlackListStatus,
@@ -218,52 +289,7 @@ export class ClarityMonitor extends BaseMonitor {
         })
       : undefined
 
-    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,
-      clarityCursor: response.cursor,
-      ...(isBlacklisted !== undefined && { isBlacklisted }),
-      ...(eip7702Delegation !== undefined && { eip7702Delegation }),
-    }
-
-    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)
-      }
-    }
+    return { accountState, eip7702Delegation, isBlacklisted }
   }
 
   async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
@@ -376,7 +402,7 @@ export class ClarityMonitor extends BaseMonitor {
   }
 
   async onTransaction({ walletAccount }) {
-    return this.tick({ walletAccount })
+    return this.tickWalletAccounts({ walletAccount })
   }
 
   async onFeeUpdated(fee) {

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

@@ -36,7 +36,7 @@ export const getOptimisticTxLogEffects = async ({
   // this converts an transactionBuffer to values we can use when creating the tx logs
   const parsedTx = parseUnsignedTx({ asset, unsignedTx })
 
-  const { nonce, to } = parsedTx
+  const { nonce, to, txToAddress } = parsedTx
   assert(Number.isInteger(nonce), 'expected integer nonce')
 
   const amount = parsedTx.amount || asset.currency.ZERO
@@ -45,6 +45,9 @@ export const getOptimisticTxLogEffects = async ({
   const feeAmount = parsedTx.fee
   assert(feeAmount instanceof NumberUnit, 'expected feeAmount')
 
+  const txValue = parsedTx.value
+  assert(txValue instanceof NumberUnit, 'expected txValue')
+
   const maybeTipGasPrice = parsedTx.tipGasPrice
   if (maybeTipGasPrice) {
     assert(maybeTipGasPrice instanceof NumberUnit, 'expected NumberUnit tipGasPrice')
@@ -78,7 +81,7 @@ export const getOptimisticTxLogEffects = async ({
 
   // Contains effects for smart-contract initiated token movements.
   const methodOptimisticSideEffects = await operationTxLogSideEffects({
-    txToAddress: to,
+    txToAddress,
     methodId,
     asset,
     walletAccount,
@@ -109,6 +112,7 @@ export const getOptimisticTxLogEffects = async ({
       ...(maybeTipGasPrice ? { tipGasPrice: maybeTipGasPrice.toBaseString() } : null),
       ...(methodId ? { methodId } : null),
       ...(bundleId ? { bundleId } : null),
+      ...(data ? { data: bufferToHex(data) } : null),
     },
   }
 
@@ -134,7 +138,7 @@ export const getOptimisticTxLogEffects = async ({
       txs: [
         {
           ...sharedProps,
-          coinAmount: baseAsset.currency.ZERO,
+          coinAmount: selfSend ? baseAsset.currency.ZERO : txValue.abs().negate(),
           coinName: baseAsset.name,
           currencies: {
             [baseAsset.name]: baseAsset.currency,

package/src/tx-type/index.js

@@ -1,5 +1,5 @@
 import NumberUnit from '@exodus/currency'
-import { isEthereumLikeToken } from '@exodus/ethereum-lib'
+import { assertValidTxValue, isEthereumLikeToken } from '@exodus/ethereum-lib'
 import { bufferToHex } from '@exodus/ethereumjs/util'
 import assert from 'minimalistic-assert'
 
@@ -154,6 +154,7 @@ export const resolveCriticalTxAttributes = ({
   toAddress: providedToAddress,
   txToAddress: providedTxToAddress,
   txInput: providedTxInput,
+  txValue: providedTxValue,
   txType,
 }) => {
   assert(asset, 'expected asset')
@@ -162,6 +163,8 @@ export const resolveCriticalTxAttributes = ({
   const amount = providedAmount ?? asset.currency.ZERO
   assert(amount instanceof NumberUnit, 'expected providedAmount')
 
+  const txValue = assertValidTxValue({ asset, amount, txValue: providedTxValue })
+
   if (txType === TX_TYPE_CREATE_CONTRACT) {
     assert(asset.name === asset.baseAsset.name, 'must use baseAsset for contract deployments')
     assert(!providedToAddress, 'toAddress must be falsy when creating a contract')
@@ -173,20 +176,28 @@ export const resolveCriticalTxAttributes = ({
       txInput: providedTxInput,
       txToAddress: null,
       txType,
-      txValue: amount,
+      txValue,
     })
   }
 
   assert(txType === TX_TYPE_TRANSFER, 'expected TX_TYPE_TRANSFER')
 
+  // NOTE: As a helper, if the `toAddress` is omitted, we
+  //       will automatically assume the recipient of the
+  //       transaction value to be the `providedTxToAddress`.
+  //
+  //       This means we'll assume the high-level recipient
+  //       of the assets transferred will be the
+  //       `providedTxToAddress`, as opposed to another account
+  //       which would be credited as a side effect.
+  //
   // HACK: If a `toAddress` hasn't been defined, then we
   //       fall back to the `ARBITRARY_ADDRESS`. Note that
   //       this should only be used to help determine the
   //       fee of a transaction where we don't yet know the
   //       intended recipient. Attempts to send to this
   //       sentinel address will ultimately `throw`.
-  const toAddress = providedToAddress || ARBITRARY_ADDRESS
-  const txValue = isEthereumLikeToken(asset) ? asset.baseAsset.currency.ZERO : amount
+  const toAddress = providedToAddress || providedTxToAddress || ARBITRARY_ADDRESS
   const txInput = resolveTxInput({ amount, asset, txInput: providedTxInput, toAddress })
 
   const baseProps = {
@@ -231,6 +242,7 @@ export const resolveTxAttributesByTxType = async ({
   txInput: providedTxInput,
   txToAddress: providedTxToAddress,
   toAddress: providedToAddress,
+  txValue: providedTxValue,
   txType,
   walletAccount,
 }) => {
@@ -260,6 +272,7 @@ export const resolveTxAttributesByTxType = async ({
       toAddress: providedToAddress,
       txInput: providedTxInput,
       txToAddress: providedTxToAddress,
+      txValue: providedTxValue,
       txType,
     }),
   })