@exodus/ethereum-api 10.2.3 → 10.3.1

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.
 
+## [10.3.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@10.3.0...@exodus/ethereum-api@10.3.1) (2026-11-03)
+
+
+### Bug Fixes
+
+* authenticate EVM replacements and remaining outgoing history ([#9094](https://github.com/ExodusMovement/assets/issues/9094)) ([3cca521](https://github.com/ExodusMovement/assets/commit/3cca521f813fdb5e03c9d0dfaa4030b5c3b17bca))
+
+
+
+## [10.3.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@10.2.3...@exodus/ethereum-api@10.3.0) (2026-10-30)
+
+
+### Features
+
+* **ethereum-api:** self-heal tx log with clarity tip mode ([#9123](https://github.com/ExodusMovement/assets/issues/9123)) ([67cbc64](https://github.com/ExodusMovement/assets/commit/67cbc641606e18f1c4cdf66ee0d76b3e7fdd70fd))
+
+
+
 ## [10.2.3](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@10.2.2...@exodus/ethereum-api@10.2.3) (2026-10-23)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "10.2.3",
+  "version": "10.3.1",
   "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",
@@ -65,5 +65,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "1fc0966a5723988e8151f3f93486d31cd95ede4f"
+  "gitHead": "cc266df454f96bb8efd03909701476c54985e3d7"
 }

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

@@ -63,10 +63,14 @@ export default class ClarityServerV2 extends ClarityServer {
     this.updateBaseApiPath(uri) // pass in the uri from remote config to override assets-gateway
   }
 
-  getTransactionsFromBlockNumber = async ({ address, blockNumber, withInput, truncated }) => {
+  getTransactionsFromBlockNumber = async ({ address, blockNumber, withInput, truncated, tip }) => {
     const url = new URL(`${this.baseApiPath}/addresses/${encodeURIComponent(address)}/transactions`)
     url.searchParams.set('cursor', blockNumber || '0')
 
+    if (tip) {
+      url.searchParams.set('mode', 'tip')
+    }
+
     if (withInput) {
       url.searchParams.set('withInput', 'true')
     }
@@ -122,8 +126,12 @@ export default class ClarityServerV2 extends ClarityServer {
    * into the backend's truncation mode + `accountInfo` pre-cursor snapshots (used by
    * `ClarityTruncatedHistoryMonitor`). For `clarity`/`clarity-v2`/`clarity-v3` flows,
    * leave the default so Clarity returns full history.
+   *
+   * Pass `tip: true` for incremental syncs: Clarity pages like the default mode until the
+   * chain tip, then returns the newest txs with a cursor anchored at the oldest of them and
+   * `hasMore: false`, so each call re-reads that window.
    */
-  async getAllTransactions({ address, cursor, withInput = true, truncated = false }) {
+  async getAllTransactions({ address, cursor, withInput = true, truncated = false, tip = false }) {
     let { blockNumber } = decodeCursor(cursor)
 
     let transactions = []
@@ -139,6 +147,7 @@ export default class ClarityServerV2 extends ClarityServer {
         blockNumber: blockNumber.toString(),
         withInput,
         truncated,
+        tip,
       })
 
       const txs = result.transactions || []
@@ -149,6 +158,23 @@ export default class ClarityServerV2 extends ClarityServer {
 
       const nextBlockNumber = BigInt(result.cursor)
 
+      if (tip) {
+        transactions.push(...txs)
+
+        if (!result.hasMore) {
+          blockNumber = nextBlockNumber
+          break
+        }
+
+        if (nextBlockNumber <= blockNumber) {
+          console.warn(`Tip mode cursor did not advance past ${blockNumber} with hasMore, stopping`)
+          break
+        }
+
+        blockNumber = nextBlockNumber
+        continue
+      }
+
       if (txs.length === 0) {
         // fetch until no more new transactions
         blockNumber = nextBlockNumber

package/src/hooks/monitor.js

@@ -54,7 +54,7 @@ export const createEthereumHooks = ({
   const addresses = new Map()
   const generations = new Map()
   const commits = new Map()
-  const afterTickHook = async ({ walletAccount, refresh = false }) => {
+  const afterTickHook = async ({ walletAccount, refresh = false, monitor }) => {
     // Order requests at entry, not after address discovery: discovery itself can
     // be delayed while a newer explicit refresh is already running.
     const accountKey = String(walletAccount)
@@ -126,6 +126,7 @@ export const createEthereumHooks = ({
           processTxLog({
             asset,
             assetClientInterface,
+            monitor,
             walletAccount,
             batch,
           })

package/src/transaction-authentication.js

@@ -0,0 +1,93 @@
+import { verifyTransactionSignature } from '@exodus/ethereum-lib'
+import assert from 'minimalistic-assert'
+
+export async function fetchAuthenticatedTransaction({
+  baseAsset,
+  txId,
+  address,
+  server = baseAsset.server,
+  missingTransactionMessage = 'Signed transaction is required',
+}) {
+  assert(typeof address === 'string', 'Wallet address is required for authentication')
+  const transaction = await server.getTransactionByHash(txId)
+  assert(transaction, missingTransactionMessage)
+  assert(
+    verifyTransactionSignature({
+      transaction,
+      txId,
+      address,
+      chainId: baseAsset.chainId,
+    }),
+    `Cannot authenticate transaction ${txId}`
+  )
+  return transaction
+}
+
+export function rpcInteger(value) {
+  const integer = BigInt(value)
+  const number = Number(integer)
+  assert(Number.isSafeInteger(number) && number >= 0, 'Transaction integer exceeds safe range')
+  return number
+}
+
+// A signed envelope authenticates these fields. Receipts, token events, internal
+// transfers and inclusion status are separate execution claims, not signed data.
+export async function authenticateHistoryTransactions({
+  transactions,
+  baseAsset,
+  address,
+  server = baseAsset.server,
+}) {
+  const authenticated = []
+  const cache = new Map()
+  for (const item of transactions) {
+    if (item.from?.toLowerCase() !== address.toLowerCase()) {
+      authenticated.push(item)
+      continue
+    }
+    let signed = cache.get(item.hash)
+    if (!signed) {
+      signed = await fetchAuthenticatedTransaction({ baseAsset, txId: item.hash, address, server })
+      cache.set(item.hash, signed)
+    }
+    authenticated.push({
+      ...item,
+      hash: signed.hash,
+      from: signed.from.toLowerCase(),
+      to: signed.to?.toLowerCase() ?? null,
+      value: BigInt(signed.value).toString(),
+      nonce: rpcInteger(signed.nonce),
+      gas: rpcInteger(signed.gas),
+      input: signed.input,
+    })
+  }
+  return authenticated
+}
+
+export async function authenticateReplacement({ baseAsset, tx, address }) {
+  const signed = await fetchAuthenticatedTransaction({
+    baseAsset,
+    txId: tx.txId,
+    address,
+    missingTransactionMessage: `ERR_BUMP_TX_DROPPED: transaction ${tx.txId} is no longer available`,
+  })
+  const type = rpcInteger(signed.type ?? '0x0')
+  // The current replacement serializer supports legacy and fee-market envelopes.
+  // Never silently discard access lists, blob commitments or 7702 authorizations.
+  assert([0, 2].includes(type), 'Unsupported replacement transaction envelope')
+  assert(!signed.accessList?.length, 'Cannot replace a transaction with an access list')
+  const nonce = rpcInteger(signed.nonce)
+  const gasLimit = rpcInteger(signed.gas)
+  const gasPrice = BigInt(type === 2 ? signed.maxFeePerGas : signed.gasPrice)
+  const pricingTx = tx.update({
+    feeAmount: baseAsset.currency.baseUnit(gasPrice * BigInt(gasLimit)),
+    data: {
+      ...tx.data,
+      nonce,
+      gasLimit,
+      gasPrice: gasPrice.toString(),
+      tipGasPrice: type === 2 ? BigInt(signed.maxPriorityFeePerGas).toString() : undefined,
+    },
+  })
+  return { signed, nonce, gasLimit, pricingTx }
+}

package/src/tx-create.js

@@ -1,5 +1,4 @@
 import {
-  assertValidTxValue,
   currency2buffer,
   getHighestIncentiveTxByNonce,
   isEthereumLikeToken,
@@ -7,6 +6,7 @@ import {
 import createEthereumJsTx from '@exodus/ethereum-lib/src/unsigned-tx/create-ethereumjs-tx.js'
 import assert from 'minimalistic-assert'
 
+import { authenticateReplacement } from './transaction-authentication.js'
 import { ensureSaneEip1559GasPriceForTipGasPrice } from './fee-utils.js'
 import { fetchGasLimit } from './gas-estimation.js'
 import { getAggregateTransactionPricing, getExtraFeeData } from './get-fee.js'
@@ -17,6 +17,7 @@ import {
   resolveTxAttributesByTxType,
   resolveTxFromAddress,
   resolveTxNonce,
+  TX_TYPE_CREATE_CONTRACT,
   TX_TYPE_TRANSFER,
 } from './tx-type/index.js'
 
@@ -327,86 +328,45 @@ const createBumpUnsignedTx = async ({
 
   const baseAsset = asset.baseAsset
   const replacedTx = baseAssetTxLog.get(bumpTxId)
-  const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: baseAsset.name })
   if (!replacedTx || !replacedTx.pending) {
     throw new Error(`Cannot bump transaction ${bumpTxId}: not found or confirmed`)
   }
 
-  let replacedTokenTx
-  if (replacedTx.tokens.length > 0) {
-    const [tokenAssetName] = replacedTx.tokens
-    const tokenTxSet = await assetClientInterface.getTxLog({
-      assetName: tokenAssetName,
-      walletAccount,
-    })
-    replacedTokenTx = tokenTxSet.get(bumpTxId)
-
-    if (replacedTokenTx) {
-      // Attempt to overwrite the asset to reflect the fact that
-      // we're performing a token transaction.
-      asset = assets[tokenAssetName]
-      if (!asset) {
-        throw new Error(
-          `unable to find ${tokenAssetName} during token bump transaction: asset was not available in assetsForNetwork`
-        )
-      }
-    }
-  }
-
-  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 = sourceTx.data?.rawCoinAmount
-    ? asset.currency.baseUnit(sourceTx.data.rawCoinAmount)
-    : sourceTx.coinAmount.negate()
-
-  const txValue = assertValidTxValue({
-    asset,
-    amount,
-    txValue: replacedTx.data?.rawCoinAmount
-      ? baseAsset.currency.baseUnit(replacedTx.data.rawCoinAmount)
-      : replacedTx.coinAmount.negate(),
+  const walletAddress = await assetClientInterface.getReceiveAddress({
+    assetName: baseAsset.name,
+    walletAccount,
   })
-
-  const isDuplex = Boolean(replacedTokenTx && txValue.gt(baseAsset.currency.ZERO))
-
-  const txInput = replacedTx.data.data || '0x'
-
-  const isTokenTx =
-    !isDuplex /* nonpayable */ &&
-    replacedTokenTx &&
-    Object.keys(asset.contract.methodIds).includes(txInput.slice(0, 10))
-
-  const txToAddress = isTokenTx ? asset.contract.address : undefined
-
-  const replacedTxNonce = replacedTx.data.nonce
-
   assert(
-    Number.isInteger(replacedTxNonce),
-    `Cannot bump transaction ${bumpTxId}: data object seems to be corrupted`
+    fromAddress.toLowerCase() === walletAddress.toLowerCase(),
+    'Replacement sender must be the wallet address'
   )
-
-  // If we have evaluated a bump transaction and the `providedNonce` differs
-  // from the `bumpNonce`, we've encountered a conflict and cannot respect
-  // the caller's request.
-  if (maybeProvidedNonce && maybeProvidedNonce !== replacedTxNonce) {
+  const { signed, nonce, gasLimit, pricingTx } = await authenticateReplacement({
+    baseAsset,
+    tx: replacedTx,
+    address: fromAddress,
+  })
+  if (maybeProvidedNonce !== undefined && maybeProvidedNonce !== nonce) {
     throw new Error('incorrect nonce for replacement transaction')
   }
-
-  const nonce = maybeProvidedNonce ?? replacedTxNonce
-
+  // Reuse the exact signed call. In particular, never reconstruct token calldata
+  // from indexer effects or use a tx-log recipient as the outer destination.
+  const txInput = signed.input
+  const txToAddress = signed.to ?? null
+  const txValue = baseAsset.currency.baseUnit(BigInt(signed.value))
+  let toAddress = txToAddress
+  let amount = asset === baseAsset ? txValue : asset.currency.ZERO
+  if (
+    asset !== baseAsset &&
+    asset.contract?.address.toLowerCase() === txToAddress?.toLowerCase() &&
+    Object.hasOwn(asset.contract.methodIds, txInput.slice(0, 10))
+  ) {
+    const { method, values } = asset.contract.decodeInput(Buffer.from(txInput.slice(2), 'hex'))
+    if (method === 'transfer' || method === 'approve') {
+      toAddress = values[0]
+      amount = asset.currency.baseUnit(values[1])
+    }
+  }
   await verifyBumpTxCanReplace({ baseAsset, bumpTxId, fromAddress, nonce })
-
   const resolvedTxAttributes = await resolveTxAttributesByTxType({
     asset,
     assetClientInterface,
@@ -416,36 +376,46 @@ const createBumpUnsignedTx = async ({
     txInput,
     toAddress,
     txToAddress,
-    txType,
+    txType: txToAddress === null ? TX_TYPE_CREATE_CONTRACT : TX_TYPE_TRANSFER,
     txValue,
     walletAccount,
   })
 
-  const gasLimit = replacedTx.data.gasLimit
-
-  const maybeTxToReplace = await getHighestIncentiveTxByNonce({
+  const prices = await resolveTxFactoryGasPrices({
     assetClientInterface,
-    asset,
-    nonce: resolvedTxAttributes.nonce,
-    walletAccount,
+    baseAsset,
+    feeData,
+    nonce,
+    txToReplace: pricingTx,
   })
+  const { eip1559Enabled } = prices
+  let { resolvedGasPrice: gasPrice, resolvedTipGasPrice: tipGasPrice } = prices
 
-  assert(
-    maybeTxToReplace,
-    `unable to resolve pending transaction for nonce ${resolvedTxAttributes.nonce}`
-  )
-
-  const {
-    eip1559Enabled,
-    resolvedGasPrice: gasPrice,
-    resolvedTipGasPrice: tipGasPrice,
-  } = await resolveTxFactoryGasPrices({
+  const competingTx = await getHighestIncentiveTxByNonce({
     assetClientInterface,
-    baseAsset,
-    feeData,
+    asset: baseAsset,
     nonce,
-    txToReplace: maybeTxToReplace,
+    walletAccount,
   })
+  if (competingTx && competingTx.txId !== bumpTxId) {
+    const competing = await authenticateReplacement({
+      baseAsset,
+      tx: competingTx,
+      address: fromAddress,
+    })
+    assert(competing.nonce === nonce, 'Replacement nonce does not match signed transaction')
+    const competingPrices = await resolveTxFactoryGasPrices({
+      assetClientInterface,
+      baseAsset,
+      feeData,
+      nonce,
+      txToReplace: competing.pricingTx,
+    })
+    if (competingPrices.resolvedGasPrice.gt(gasPrice)) gasPrice = competingPrices.resolvedGasPrice
+    if (eip1559Enabled && competingPrices.resolvedTipGasPrice.gt(tipGasPrice)) {
+      tipGasPrice = competingPrices.resolvedTipGasPrice
+    }
+  }
 
   return createUnsignedTxWithFees({
     ...resolvedTxAttributes,
@@ -540,6 +510,24 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
       walletAccount,
     })
 
+    if (maybeTxToReplace) {
+      const walletAddress = await assetClientInterface.getReceiveAddress({
+        assetName: baseAsset.name,
+        walletAccount,
+      })
+      assert(
+        fromAddress.toLowerCase() === walletAddress.toLowerCase(),
+        'Replacement sender must be the wallet address'
+      )
+    }
+    const pricingTxToReplace = maybeTxToReplace
+      ? await authenticateReplacement({ baseAsset, tx: maybeTxToReplace, address: fromAddress })
+      : undefined
+    assert(
+      !pricingTxToReplace || pricingTxToReplace.nonce === nonce,
+      'Replacement nonce does not match signed transaction'
+    )
+
     const {
       eip1559Enabled,
       resolvedGasPrice: gasPrice,
@@ -552,7 +540,7 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
       gasPrice: providedGasPrice,
       nonce,
       tipGasPrice: providedTipGasPrice,
-      txToReplace: maybeTxToReplace,
+      txToReplace: pricingTxToReplace?.pricingTx,
     })
 
     if (nft) {

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

@@ -0,0 +1,85 @@
+import { BaseMonitor } from '@exodus/asset-lib'
+import { Tx } from '@exodus/models'
+import assert from 'minimalistic-assert'
+
+import { fetchAuthenticatedTransaction, rpcInteger } from '../transaction-authentication.js'
+
+export class AuthenticatedEthereumMonitor extends BaseMonitor {
+  async verifyNewSentTransactions({ assetName = this.asset.name, logItems, walletAccount }) {
+    if (logItems.length === 0) return
+    let address
+    let txLog
+    for (const item of logItems) {
+      const tx = Tx.fromJSON(item)
+      if (tx.dropped) {
+        txLog ??= await this.aci.getTxLog({ assetName, walletAccount })
+        const existing = txLog.get(tx.txId)
+        // A disappeared envelope must not prevent marking the stored transaction
+        // dropped. Only its status may change without reauthentication.
+        if (existing && tx.equals(existing.update({ dropped: true, error: tx.error }))) continue
+      }
+      if (!tx.sent) {
+        if (!tx.from?.length) continue
+        address ??= await this.aci.getReceiveAddress({
+          assetName: this.asset.name,
+          walletAccount,
+          useCache: true,
+        })
+        if (!tx.from.some((from) => from.toLowerCase() === address.toLowerCase())) continue
+      }
+      assert(
+        (await this.verifyTransactionAuthentication({ tx, assetName, walletAccount })) === true,
+        `Cannot authenticate outgoing transaction ${tx.txId}`
+      )
+    }
+  }
+
+  async verifyTransactionAuthentication(params) {
+    if (typeof this.asset.verifyTransactionAuthentication === 'function') {
+      return super.verifyTransactionAuthentication(params)
+    }
+    const address = await this.aci.getReceiveAddress({
+      assetName: this.asset.name,
+      walletAccount: params.walletAccount,
+      useCache: true,
+    })
+    const transaction = await fetchAuthenticatedTransaction({
+      baseAsset: this.asset,
+      txId: params.tx.txId,
+      address,
+      server: this.server,
+    })
+    const tx = params.tx
+    // Bind the fields used by acceleration even for entries already in the log.
+    // Token destinations/amounts describe effects rather than the outer envelope;
+    // replacement creation always uses the verified envelope itself.
+    if (tx.data.nonce !== undefined && tx.data.nonce !== rpcInteger(transaction.nonce)) return false
+    if (tx.data.gasLimit !== undefined && tx.data.gasLimit !== rpcInteger(transaction.gas)) {
+      return false
+    }
+    if (
+      tx.data.data !== undefined &&
+      tx.data.data.toLowerCase() !== transaction.input.toLowerCase()
+    ) {
+      return false
+    }
+    if (params.assetName === this.asset.name) {
+      // Base-asset fee entries for token operations can display the token
+      // recipient. That execution effect is not the envelope's destination.
+      if (
+        tx.tokens.length === 0 &&
+        tx.to &&
+        tx.to.toLowerCase() !== (transaction.to ?? address).toLowerCase()
+      ) {
+        return false
+      }
+      if (
+        tx.data.rawCoinAmount !== undefined &&
+        BigInt(tx.data.rawCoinAmount) !== BigInt(transaction.value)
+      ) {
+        return false
+      }
+    }
+    return true
+  }
+}

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

@@ -1,9 +1,10 @@
-import { BaseMonitor } from '@exodus/asset-lib'
 import { getAssetAddresses } from '@exodus/ethereum-lib'
 import lodash from 'lodash'
 import assert from 'minimalistic-assert'
 
+import { AuthenticatedEthereumMonitor } from './authenticated-monitor.js'
 import { applyRemoteConfigEip7702Whitelist, createEip7702Whitelist } from '../eip7702-whitelist.js'
+import { authenticateHistoryTransactions } from '../transaction-authentication.js'
 import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
 import {
   filterEffects,
@@ -25,7 +26,7 @@ import {
 
 const { isEmpty } = lodash
 
-export class ClarityMonitor extends BaseMonitor {
+export class ClarityMonitor extends AuthenticatedEthereumMonitor {
   constructor({
     server,
     config,
@@ -42,6 +43,7 @@ export class ClarityMonitor extends BaseMonitor {
     this.eip7702Whitelist = eip7702Whitelist ?? createEip7702Whitelist(eip7702Supported)
     this.getBlackListStatus = getBlackListStatus
     this.getAllLogItemsByAsset = getAllLogItemsByAsset
+    this.emittedUnknownTokenAddresses = new Set()
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
       getTxLog: (...args) => this.aci.getTxLog(...args),
@@ -240,7 +242,6 @@ export class ClarityMonitor extends BaseMonitor {
 
     const batch = this.aci.createOperationsBatch()
     let allTxs = []
-    let hasNewTxs = false
     let historyResponse
     let historyError
     let processedLogItemsByAsset
@@ -255,7 +256,12 @@ export class ClarityMonitor extends BaseMonitor {
         walletAccount,
       }))
 
-      hasNewTxs = allTxs.length > 0
+      allTxs = await authenticateHistoryTransactions({
+        transactions: allTxs,
+        baseAsset: this.asset,
+        server: this.server,
+        address: derivedData.ourWalletAddress,
+      })
 
       const logItemsByAsset = this.getAllLogItemsByAsset({
         getLogItemsFromServerTx,
@@ -266,6 +272,10 @@ export class ClarityMonitor extends BaseMonitor {
         assets,
       })
 
+      if (this.isTipSync({ derivedData, refresh })) {
+        await this.warnReaddedTxs({ walletAccount, logItemsByAsset })
+      }
+
       const { txsToRemove } = await this.checkPendingTransactions({
         txlist: allTxs,
         walletAccount,
@@ -275,6 +285,12 @@ export class ClarityMonitor extends BaseMonitor {
         ...derivedData,
       })
 
+      await this.updateTxLogByAssetBatch({
+        logItemsByAsset,
+        walletAccount,
+        refresh,
+        batch,
+      })
       this.aci.removeTxLogBatch({
         assetName,
         walletAccount,
@@ -282,16 +298,6 @@ export class ClarityMonitor extends BaseMonitor {
         batch,
       })
 
-      for (const [assetName, txs] of Object.entries(logItemsByAsset)) {
-        this.aci.updateTxLogAndNotifyBatch({
-          assetName,
-          walletAccount,
-          txs,
-          refresh,
-          batch,
-        })
-      }
-
       historyResponse = response
       processedLogItemsByAsset = logItemsByAsset
     } catch (error) {
@@ -333,13 +339,44 @@ export class ClarityMonitor extends BaseMonitor {
         : new Error(String(historyError), { cause: historyError })
     }
 
-    if (refresh || hasNewTxs) {
-      const unknownTokenAddresses = this.getUnknownTokenAddresses({
-        transactions: allTxs,
-        tokensByAddress,
-      })
-      if (unknownTokenAddresses.length > 0) {
-        this.emit('unknown-tokens', unknownTokenAddresses)
+    const unknownTokenAddresses = this.getUnknownTokenAddresses({
+      transactions: allTxs,
+      tokensByAddress,
+    })
+    const addressesToEmit = refresh
+      ? unknownTokenAddresses
+      : unknownTokenAddresses.filter((address) => !this.emittedUnknownTokenAddresses.has(address))
+    for (const address of unknownTokenAddresses) this.emittedUnknownTokenAddresses.add(address)
+    if (addressesToEmit.length > 0) {
+      this.emit('unknown-tokens', addressesToEmit)
+    }
+  }
+
+  async warnReaddedTxs({ walletAccount, logItemsByAsset }) {
+    const isConfirmed = (tx) => tx.confirmations > 0 && Number.isInteger(tx.data?.blockNumber)
+
+    for (const [assetName, txs] of Object.entries(logItemsByAsset)) {
+      const confirmedTxs = txs.filter(isConfirmed)
+      if (confirmedTxs.length === 0) continue
+
+      const txLog = await this.aci.getTxLog({ assetName, walletAccount })
+      const missingTxs = confirmedTxs.filter((tx) => !txLog.has(tx.txId))
+      if (missingTxs.length === 0) continue
+
+      let newestLoggedBlock = -1
+      for (const tx of txLog) {
+        if (isConfirmed(tx)) newestLoggedBlock = Math.max(newestLoggedBlock, tx.data.blockNumber)
+      }
+
+      const readdedTxIds = missingTxs
+        .filter((tx) => tx.data.blockNumber <= newestLoggedBlock)
+        .map((tx) => tx.txId)
+      if (readdedTxIds.length > 0) {
+        this.logger.warn('clarity tip window re-added txs missing from tx log', {
+          assetName,
+          walletAccount,
+          txIds: readdedTxIds,
+        })
       }
     }
   }
@@ -482,11 +519,15 @@ export class ClarityMonitor extends BaseMonitor {
     this.server.dispose()
   }
 
+  isTipSync({ derivedData, refresh }) {
+    return !refresh && Boolean(derivedData.currentAccountState?.clarityCursor)
+  }
+
   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 })
+    const tip = this.isTipSync({ derivedData, refresh })
+    const cursor = tip ? derivedData.currentAccountState.clarityCursor : null
+    return this.server.getAllTransactions({ walletAccount, address, cursor, tip })
   }
 
   listenToServerEvents() {

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

@@ -137,15 +137,15 @@ export class ClarityTruncatedHistoryMonitor extends ClarityMonitor {
 
   async getHistoryFromServer({ walletAccount, derivedData, refresh }) {
     const address = derivedData.ourWalletAddress
-    const currentCursor = derivedData.currentAccountState?.clarityCursor
-    const cursor = currentCursor && !refresh ? currentCursor : null
+    const tip = this.isTipSync({ derivedData, refresh })
+    const cursor = tip ? derivedData.currentAccountState.clarityCursor : null
     return this.server.getAllTransactions({
       walletAccount,
       address,
       cursor,
-      refresh,
       withInput: true,
       truncated: true,
+      tip,
     })
   }
 }

package/src/tx-log/clarity-truncated-history-monitor.md

@@ -3,6 +3,7 @@
 Extends `ClarityMonitor`. Used when Clarity only serves a **recent window** of txs and attaches pre-cursor snapshots in `accountInfo`.
 
 - Sends `truncated=true` on `getAllTransactions`.
+- Incremental ticks use Clarity `mode=tip`, like `clarity-v2`. The tip page carries `accountInfo`, so `account_balance` rows still update rebasing tokens. First sync and refresh use default mode.
 - Folds `accountInfo` into `accountState`, including truncated-history baselines.
 - Forces `rpcBalanceAssetNames = []` (no per-asset RPC `eth_getBalance` batch).
 
@@ -217,6 +218,7 @@ If the backend can't emit `accountInfo`, the monitor degrades gracefully to `cla
 
 ## Tests
 
+- `src/tx-log/__tests__/clarity-tip-mode.test.js` — `clarity-v2` tip mode (dropped tx re-added, stable cursor, default mode on refresh); this monitor's tip ticks send `truncated=true` and `account_balance` rows track a rebase; refresh uses default mode and still collects `accountInfo`.
 - `src/tx-log/__tests__/clarity-truncated-history-monitor.test.js` — `truncated: true`, no RPC balance batch, accountInfo → `balance`, token `tokenBalances`, and `truncatedAccountState`.
 - `src/__tests__/create-asset-utils.test.js` — factory → `ClarityTruncatedHistoryMonitor`.
 - `src/__tests__/get-balances.test.js` — accountState token short-circuit and truncated baseline cases.

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

@@ -55,9 +55,8 @@ export default function getLogItemsFromServerTx({
   const toAddress = tryFindExternalRecipient(ethereumTransfers, ourWalletAddress)
   const ourWalletWasSender = serverTx.from === ourWalletAddress
   const METHOD_ID_LENGTH = 10
-  const methodId = serverTx.input && {
-    methodId: serverTx.input.slice(0, Math.max(0, METHOD_ID_LENGTH)),
-  }
+  const serverMethodId = serverTx.methodId ?? serverTx.input?.slice(0, METHOD_ID_LENGTH)
+  const methodId = serverMethodId && { methodId: serverMethodId }
   const data = (ourWalletWasSender ? serverTx.input : methodId?.methodId) || '0x'
   const walletUpdates = getWalletUpdates(ourWalletAddress, serverTx.walletChanges || [])
   const { baseBalanceUpdate, nonceUpdate, tokenBalancesUpdate } = walletUpdates

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

@@ -1,8 +1,8 @@
-import { BaseMonitor } from '@exodus/asset-lib'
 import { SynchronizedTime } from '@exodus/basic-utils'
 import { Tx } from '@exodus/models'
 import lodash from 'lodash'
 
+import { AuthenticatedEthereumMonitor } from './authenticated-monitor.js'
 import { applyRemoteConfigEip7702Whitelist, createEip7702Whitelist } from '../eip7702-whitelist.js'
 import { getBatchedRpcBalances } from './monitor-utils/get-batched-rpc-balances.js'
 import { UNCONFIRMED_TX_LIMIT } from './monitor-utils/get-derive-transactions-to-check.js'
@@ -25,7 +25,7 @@ const getMissingNonce = (tx, txFromNode) => {
 
 // The base ethereum monitor no history class handles listening for assets with no history
 
-export class EthereumNoHistoryMonitor extends BaseMonitor {
+export class EthereumNoHistoryMonitor extends AuthenticatedEthereumMonitor {
   constructor({ server, config, eip7702Supported, eip7702Whitelist, getBlackListStatus, ...args }) {
     super(args)
     this.server = server

package/src/tx-log-staking-processor/index.js

@@ -1,3 +1,5 @@
+import assert from 'minimalistic-assert'
+
 import { getPolygonUndelegateTxInEthereumTxLog } from '../staking/matic/matic-staking-utils.js'
 import { assetStakingTxProps } from './asset-staking-tx-data.js'
 
@@ -17,7 +19,13 @@ const getAssetExpandedTxLog = async ({ assetName, aci, txs, walletAccount }) =>
   return additionalTxs
 }
 
-const processTxLog = async ({ asset, assetClientInterface: aci, walletAccount, batch }) => {
+const processTxLog = async ({
+  asset,
+  assetClientInterface: aci,
+  walletAccount,
+  batch,
+  monitor,
+}) => {
   const { name: assetName, currency } = asset
   const txs = await aci.getTxLog({ assetName, walletAccount })
 
@@ -36,6 +44,11 @@ const processTxLog = async ({ asset, assetClientInterface: aci, walletAccount, b
   const expandedTxs = await getAssetExpandedTxLog({ assetName, aci, txs, walletAccount })
   newTxs.push(...expandedTxs)
 
+  if (expandedTxs.length > 0) {
+    assert(monitor, 'History monitor is required to authenticate new staking transactions')
+    await monitor.verifyNewSentTransactions({ assetName, logItems: expandedTxs, walletAccount })
+  }
+
   if (newTxs.length > 0) {
     aci.updateTxLogAndNotifyBatch({ assetName, walletAccount, txs: newTxs, batch })
   }