@exodus/ethereum-api 10.2.1 → 10.2.2

package/CHANGELOG.md

@@ -3,6 +3,15 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [10.2.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@10.2.1...@exodus/ethereum-api@10.2.2) (2026-10-22)
+
+
+### Bug Fixes
+
+* **ethereum-api:** record pending tx in tx log before broadcast ([#9045](https://github.com/ExodusMovement/assets/issues/9045)) ([a38699c](https://github.com/ExodusMovement/assets/commit/a38699c2ed4d8ad0f03b45fa38725ed6020ed685))
+
+
+
 ## [10.2.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@10.2.0...@exodus/ethereum-api@10.2.1) (2026-10-21)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "10.2.1",
+  "version": "10.2.2",
   "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": "58cc7d254c0b21139ba3ad069fa18998d8ddf458"
+  "gitHead": "8b769034df65590a5fcab8a40d0929c162b117c5"
 }

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

@@ -16,6 +16,13 @@ import {
 
 const { isEmpty, unionBy, zipObject } = lodash
 
+const getMissingNonce = (tx, txFromNode) => {
+  if (Number.isInteger(tx.data?.nonce) || !txFromNode) return
+
+  const nonce = parseInt(txFromNode.nonce, 16)
+  return Number.isSafeInteger(nonce) ? nonce : undefined
+}
+
 // The base ethereum monitor no history class handles listening for assets with no history
 
 export class EthereumNoHistoryMonitor extends BaseMonitor {
@@ -132,11 +139,23 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
           tx,
           assetSource: { asset: assetName, walletAccount },
         })
-      } else if (isConfirmed) {
-        txsToUpdate.push({
-          tx: { ...tx, confirmations: 1 },
-          assetSource: { asset: assetName, walletAccount },
-        })
+        continue
+      }
+
+      const nonce = getMissingNonce(tx, txFromNode)
+      if (!isConfirmed && nonce === undefined) continue
+
+      txsToUpdate.push({
+        tx: {
+          ...tx,
+          ...(isConfirmed && { confirmations: 1 }),
+          ...(nonce !== undefined && { data: { ...tx.data, nonce } }),
+        },
+        assetSource: { asset: assetName, walletAccount },
+      })
+
+      if (nonce !== undefined) {
+        txsToUpdate.push(...(await this.getTokenTxsWithNonce({ tx, nonce, walletAccount })))
       }
     }
 
@@ -146,6 +165,23 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
     }
   }
 
+  async getTokenTxsWithNonce({ tx, nonce, walletAccount }) {
+    const tokenTxs = await Promise.all(
+      tx.tokens.map(async (assetName) => {
+        const tokenTxSet = await this.aci.getTxLog({ assetName, walletAccount })
+        const tokenTx = tokenTxSet.get(tx.txId)
+        if (!tokenTx || Number.isInteger(tokenTx.data.nonce)) return
+
+        return {
+          tx: { ...tokenTx, data: { ...tokenTx.data, nonce } },
+          assetSource: { asset: assetName, walletAccount },
+        }
+      })
+    )
+
+    return tokenTxs.filter(Boolean)
+  }
+
   async tick({ refresh, walletAccount }) {
     const shouldCheckBlacklist = this.tickCount[walletAccount] === 0
     const assets = await this.aci.getAssetsForNetwork({ baseAssetName: this.asset.name })

package/src/tx-send/broadcast-error-handler.js

@@ -33,13 +33,23 @@ export const handleBroadcastError = async (
     return { shouldRetry: false }
   }
 
+  const throwError = (errorReasonInfo) => {
+    throw new EthLikeError({
+      message: err.message,
+      errorReasonInfo,
+      hint,
+      traceId: err.traceId,
+      baseAssetName: asset.baseAsset.name,
+    })
+  }
+
   let txAlreadyExists = false
   if (isAmbiguousError) {
     try {
       txAlreadyExists = await transactionExists({ asset, txId })
     } catch (verifyErr) {
-      // Can't verify - fall through to original error handling
       console.warn('Could not verify tx existence:', verifyErr.message)
+      throwError(EVM_ERROR_REASONS.broadcastTxFailed)
     }
   }
 
@@ -53,11 +63,5 @@ export const handleBroadcastError = async (
   // If we "fix" a bump tx by advancing the nonce, we create a brand-new tx instead of replacing the pending one.
   if (isNonceTooLow && !isHardware && !isBumpTx && !isRetryNonceTx) return { shouldRetry: true }
 
-  throw new EthLikeError({
-    message: err.message,
-    errorReasonInfo: errorInfo,
-    hint,
-    traceId: err.traceId,
-    baseAssetName: asset.baseAsset.name,
-  })
+  throwError(errorInfo)
 }

package/src/tx-send/tx-send.js

@@ -1,23 +1,66 @@
 import { parseUnsignedTx, updateNonce } from '@exodus/ethereum-lib'
 import { safeString } from '@exodus/safe-string'
+import delay from 'delay'
 import assert from 'minimalistic-assert'
+import ms from 'ms'
 
+import { EthLikeError, EVM_ERROR_REASONS } from '../error-wrapper.js'
 import { getOptimisticTxLogEffects } from '../tx-log/index.js'
 import { signTx } from '../tx-sign/index.js'
 import { ARBITRARY_ADDRESS } from '../tx-type/index.js'
 import { handleBroadcastError } from './broadcast-error-handler.js'
 
+const RESEND_DELAYS = [ms('1s'), ms('3s')]
+
+const isOutcomeUnknown = (error) =>
+  error instanceof EthLikeError && error.reason === EVM_ERROR_REASONS.broadcastTxFailed.reason
+
+const isRejectedByNode = (error) => error instanceof EthLikeError && !isOutcomeUnknown(error)
+
+const omitNonce = (optimisticTxLogEffects) =>
+  optimisticTxLogEffects.map(({ txs, ...optimisticTxLogEffect }) => ({
+    ...optimisticTxLogEffect,
+    txs: txs.map(({ data: { nonce: _nonce, ...data }, ...tx }) => ({ ...tx, data })),
+  }))
+
 const txSendFactory = ({ assetClientInterface, createTx }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
   assert(createTx, 'createTx is required')
 
-  return async ({
-    asset,
-    walletAccount,
-    unsignedTx: providedUnsignedTx,
-    onTxSigned,
-    ...legacyParams
-  }) => {
+  const writeTxLog = async (optimisticTxLogEffects) => {
+    const batch = assetClientInterface.createOperationsBatch()
+    for (const optimisticTxLogEffect of optimisticTxLogEffects) {
+      assetClientInterface.updateTxLogAndNotifyBatch({ ...optimisticTxLogEffect, batch })
+    }
+
+    await assetClientInterface.executeOperationsBatch(batch)
+  }
+
+  const removeTxLog = async (optimisticTxLogEffects) => {
+    const batch = assetClientInterface.createOperationsBatch()
+    for (const { assetName, walletAccount, txs } of optimisticTxLogEffects) {
+      assetClientInterface.removeTxLogBatch({
+        assetName,
+        walletAccount,
+        txs: txs.map(({ txId }) => ({ txId })),
+        batch,
+      })
+    }
+
+    await assetClientInterface.executeOperationsBatch(batch)
+  }
+
+  const tryRemoveTxLog = async (optimisticTxLogEffects) => {
+    try {
+      await removeTxLog(optimisticTxLogEffects)
+      return true
+    } catch (removeError) {
+      console.warn('Could not remove rejected tx from tx log:', removeError.message)
+      return false
+    }
+  }
+
+  return async ({ asset, walletAccount, unsignedTx: providedUnsignedTx, ...legacyParams }) => {
     const baseAsset = asset.baseAsset
 
     const { unsignedTx } = providedUnsignedTx
@@ -35,99 +78,154 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
       `The receiving wallet address must not be ${ARBITRARY_ADDRESS}`
     )
 
-    // Are there any signin-level errors that should be caught here?
-    let { txId, rawTx } = await signTx({
-      asset,
-      assetClientInterface,
-      unsignedTx,
-      walletAccount,
-    })
-    // A caller that must find the tx after a lost broadcast response learns its hash before the network sees it.
-    await onTxSigned?.({ txId })
+    const signAndRecordTx = async () => {
+      const { txId, rawTx } = await signTx({
+        asset,
+        assetClientInterface,
+        unsignedTx,
+        walletAccount,
+      })
 
-    try {
-      await baseAsset.api.broadcastTx(rawTx.toString('hex'))
-    } catch (err) {
-      const isBumpTx = !!unsignedTx.txMeta.bumpTxId
-      const { shouldRetry } = await handleBroadcastError(err, {
+      const { nonce, optimisticTxLogEffects } = await getOptimisticTxLogEffects({
         asset,
+        assetClientInterface,
+        fromAddress,
         txId,
-        isHardware: !!unsignedTx.txMeta.isHardware,
-        hint: isBumpTx ? safeString`bumpTx` : safeString`broadcastTx`,
-        isBumpTx,
+        unsignedTx,
+        walletAccount,
       })
 
-      if (shouldRetry) {
-        console.debug('trying to send again...') // inject logger factory from platform
-
-        // let's try to fix the nonce issue
-        let newNonce = await baseAsset.getNonce({
-          asset,
-          fromAddress,
-          walletAccount,
-          forceFromNode: true,
-        })
+      await writeTxLog(omitNonce(optimisticTxLogEffects))
 
-        const triedNonce = parsedTx.nonce
-        // Defensive: avoid retrying the same nonce if node nonce is stale (non-replacement sends only).
-        if (!isBumpTx && typeof triedNonce === 'number') {
-          newNonce = Math.max(newNonce, triedNonce + 1)
-        }
+      return { txId, rawTx, nonce, optimisticTxLogEffects }
+    }
 
-        // NOTE: An `unsignedTx.txData.transactionBuffer` may be optional
-        //       in `unsignedTx`, since a `providedUnsignedTx` may be
-        //       truthy but composed only of `legacyParams`:
-        //       https://github.com/ExodusMovement/assets/blob/4e3e873e3f5bfa8fce36f60be7d95a3dba9546e4/ethereum/ethereum-lib/src/unsigned-tx/parse-unsigned-tx.js#L104C5-L104C6
-        //
-        // TODO: should return an unsignedTx -> i.e. completely replicate the transaction
-        if (unsignedTx.txData.transactionBuffer) {
-          // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-          unsignedTx.txData.transactionBuffer = updateNonce({
-            chainId: baseAsset.chainId,
-            newNonce,
-            unsignedTx,
-          })
-        } else {
-          // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-          unsignedTx.txData.nonce = newNonce
+    const resend = async ({ rawTx, txId }) => {
+      for (const resendDelay of RESEND_DELAYS) {
+        await delay(resendDelay)
+        try {
+          await baseAsset.api.broadcastTx(rawTx.toString('hex'))
+          return true
+        } catch (err) {
+          try {
+            await handleBroadcastError(err, {
+              asset,
+              txId,
+              isHardware: false,
+              hint: safeString`resend:broadcastTx`,
+              isBumpTx: false,
+              isRetryNonceTx: true,
+            })
+            return true
+          } catch (error) {
+            if (!isOutcomeUnknown(error)) return false
+          }
         }
+      }
 
-        ;({ txId, rawTx } = await signTx({
-          asset,
-          assetClientInterface,
-          unsignedTx,
-          walletAccount,
-        }))
-        await onTxSigned?.({ txId })
+      return false
+    }
 
+    const broadcast = async ({ rawTx, txId, optimisticTxLogEffects, ...handlerOptions }) => {
+      try {
+        await baseAsset.api.broadcastTx(rawTx.toString('hex'))
+        return { shouldRetry: false }
+      } catch (err) {
         try {
-          await baseAsset.api.broadcastTx(rawTx.toString('hex'))
-        } catch (retryErr) {
-          await handleBroadcastError(retryErr, {
+          const { shouldRetry } = await handleBroadcastError(err, {
             asset,
             txId,
-            isHardware: false,
-            hint: safeString`retry:broadcastTx`,
-            isBumpTx: false, // retry path is only for non-bump anyway
-            isRetryNonceTx: true,
+            ...handlerOptions,
           })
+          return { shouldRetry, broadcastError: err }
+        } catch (error) {
+          if (isRejectedByNode(error)) {
+            await tryRemoveTxLog(optimisticTxLogEffects)
+            throw error
+          }
+
+          if (isOutcomeUnknown(error) && (await resend({ rawTx, txId }))) {
+            return { shouldRetry: false }
+          }
+
+          throw error
         }
       }
     }
 
-    const { nonce, optimisticTxLogEffects } = await getOptimisticTxLogEffects({
-      asset,
-      assetClientInterface,
-      fromAddress,
+    // Are there any signin-level errors that should be caught here?
+    let { txId, rawTx, nonce, optimisticTxLogEffects } = await signAndRecordTx()
+
+    const isBumpTx = !!unsignedTx.txMeta.bumpTxId
+    const { shouldRetry, broadcastError } = await broadcast({
+      rawTx,
       txId,
-      unsignedTx,
-      walletAccount,
+      optimisticTxLogEffects,
+      isHardware: !!unsignedTx.txMeta.isHardware,
+      hint: isBumpTx ? safeString`bumpTx` : safeString`broadcastTx`,
+      isBumpTx,
     })
 
-    for (const optimisticTxLogEffect of optimisticTxLogEffects) {
-      await assetClientInterface.updateTxLogAndNotify(optimisticTxLogEffect)
+    if (shouldRetry) {
+      console.debug('trying to send again...') // inject logger factory from platform
+
+      if (!(await tryRemoveTxLog(optimisticTxLogEffects))) {
+        throw new EthLikeError({
+          message: broadcastError.message,
+          errorReasonInfo: EVM_ERROR_REASONS.nonceTooLow,
+          hint: safeString`broadcastTx`,
+          traceId: broadcastError.traceId,
+          baseAssetName: baseAsset.name,
+        })
+      }
+
+      // let's try to fix the nonce issue
+      let newNonce = await baseAsset.getNonce({
+        asset,
+        fromAddress,
+        walletAccount,
+        forceFromNode: true,
+      })
+
+      const triedNonce = parsedTx.nonce
+      // Defensive: avoid retrying the same nonce if node nonce is stale (non-replacement sends only).
+      if (!isBumpTx && typeof triedNonce === 'number') {
+        newNonce = Math.max(newNonce, triedNonce + 1)
+      }
+
+      // NOTE: An `unsignedTx.txData.transactionBuffer` may be optional
+      //       in `unsignedTx`, since a `providedUnsignedTx` may be
+      //       truthy but composed only of `legacyParams`:
+      //       https://github.com/ExodusMovement/assets/blob/4e3e873e3f5bfa8fce36f60be7d95a3dba9546e4/ethereum/ethereum-lib/src/unsigned-tx/parse-unsigned-tx.js#L104C5-L104C6
+      //
+      // TODO: should return an unsignedTx -> i.e. completely replicate the transaction
+      if (unsignedTx.txData.transactionBuffer) {
+        // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
+        unsignedTx.txData.transactionBuffer = updateNonce({
+          chainId: baseAsset.chainId,
+          newNonce,
+          unsignedTx,
+        })
+      } else {
+        // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
+        unsignedTx.txData.nonce = newNonce
+      }
+
+      ;({ txId, rawTx, nonce, optimisticTxLogEffects } = await signAndRecordTx())
+
+      await broadcast({
+        rawTx,
+        txId,
+        optimisticTxLogEffects,
+        isHardware: false,
+        hint: safeString`retry:broadcastTx`,
+        isBumpTx: false, // retry path is only for non-bump anyway
+        isRetryNonceTx: true,
+      })
     }
 
+    await writeTxLog(optimisticTxLogEffects)
+
     return { txId, nonce }
   }
 }