@exodus/ethereum-api 8.64.5 → 8.64.7

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

@@ -1,4 +1,5 @@
 import { retry } from '@exodus/simple-retry'
+import { TraceId } from '@exodus/traceparent'
 import assert from 'minimalistic-assert'
 
 import ClarityServer, { RPC_REQUEST_TIMEOUT } from './clarity.js'
@@ -43,14 +44,31 @@ const fetchJson = async (url, fetchOptions) => {
   const response = await fetch(url, fetchOptions)
 
   if (!response.ok) {
-    throw new Error(
+    const traceId = TraceId.fromResponse(response)
+    const error = new Error(
       `${url} returned ${response.status}: ${
         response.statusText || 'Unknown Status Text'
       }. Body: ${await getTextFromResponse(response)}`
     )
+    if (traceId) {
+      error.traceId = traceId
+    }
+
+    throw error
+  }
+
+  const json = await response.json()
+
+  // Only capture trace ID if there's an RPC error in the response
+  // (handleJsonRPCResponse will extract it when throwing the error)
+  if (json.error) {
+    const traceId = TraceId.fromResponse(response)
+    if (traceId) {
+      json.__traceId = traceId
+    }
   }
 
-  return response.json()
+  return json
 }
 
 async function fetchJsonRetry(url, fetchOptions) {
@@ -126,9 +144,6 @@ export default class ClarityServerV2 extends ClarityServer {
       //       See: https://github.com/ExodusMovement/clarity/blob/d3c2a7f501a4391da630592bca3bf57c3ddd5e89/src/modules/ethereum-like/gas-price/index.js#L192C5-L219C6
       return await this.getGasPriceEstimation()
     } catch {
-      console.log(
-        `failed to query ${this.baseAssetName} gas-price-estimation endpoint, falling back to websocket`
-      )
       // HACK: The `getGasPriceEstimation` endpoint is not guaranteed
       //       to exist for all assets. In this case, we'll fallback
       //       to legacy behaviour, which is to query via the WebSocket.
@@ -185,8 +200,9 @@ export default class ClarityServerV2 extends ClarityServer {
     }
   }
 
-  fetchRpcHttpRequest = ({ baseApiPath, body }) =>
-    fetchHttpRequest({ baseApiPath, path: '/rpc', method: 'POST', body })
+  fetchRpcHttpRequest = ({ baseApiPath, body }) => {
+    return fetchHttpRequest({ baseApiPath, path: '/rpc', method: 'POST', body })
+  }
 
   async sendRpcRequest(rpcRequest) {
     try {
@@ -201,6 +217,8 @@ export default class ClarityServerV2 extends ClarityServer {
     }
   }
 
+  // Maybe some functions from clarity should be overriden to have handleJsonRPCResponse as well
+
   async sendRawTransaction(...params) {
     const { baseApiPath } = this
     const request = this.sendRawTransactionRequest(...params)

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

@@ -1,11 +1,13 @@
 import { bufferToHex } from '@exodus/ethereumjs/util'
 import { safeString } from '@exodus/safe-string'
 import SolidityContract from '@exodus/solidity-contract'
+import { TraceId } from '@exodus/traceparent'
 import EventEmitter from 'events/events.js'
 import io from 'socket.io-client'
 
 import { fromHexToString } from '../number-utils.js'
 import { errorMessageToSafeHint } from './errors.js'
+import { getFallbackGasPriceEstimation } from './utils.js'
 
 export const RPC_REQUEST_TIMEOUT = 'RPC_REQUEST_TIMEOUT'
 
@@ -103,12 +105,20 @@ export default class ClarityServer extends EventEmitter {
 
       const revisedError = new Error(`Bad rpc response: ${message}`)
       revisedError.hint = safeString`Bad rpc response: ${errorMessageToSafeHint(message)}`
+
+      // Preserve trace ID: from HTTP (__traceId) or WebSocket (traceparent in JSON body)
+      const traceId = response?.__traceId || response?.traceparent
+      if (traceId) {
+        revisedError.traceId = traceId
+      }
+
       throw revisedError
     }
 
     return result
   }
 
+  // Transport: WS only in ClarityServer, HTTP only in ClarityServerV2 (overridden)
   async getAllTransactions(params) {
     const transactions = { pending: [], confirmed: [] }
     const cursor = await this.getTransactions({
@@ -128,6 +138,7 @@ export default class ClarityServer extends EventEmitter {
     return { cursor, transactions }
   }
 
+  // Transport: WS only (uses transactions socket, not RPC socket)
   async getTransactions({ walletAccount, address, cursor, onChunk }) {
     const socket = this.connectTransactions({ walletAccount, address })
     const listener = (isPending, chunk, callback) => {
@@ -148,6 +159,7 @@ export default class ClarityServer extends EventEmitter {
       .finally(() => socket.off('transactionsChunk', listener))
   }
 
+  // Transport: WS only (uses fee socket)
   getFeeFromWebSocket() {
     const socket = this.connectFee()
     return new Promise((resolve, reject) => {
@@ -164,27 +176,40 @@ export default class ClarityServer extends EventEmitter {
     })
   }
 
+  // Transport: WS only in ClarityServer, HTTP first → WS fallback in ClarityServerV2 (overridden)
   async getFee() {
     return this.getFeeFromWebSocket()
   }
 
+  // Transport: Depends on getFee() - WS only in ClarityServer, HTTP first → WS fallback in ClarityServerV2
   // for fee monitors
   async getGasPrice() {
     const fee = await this.getFee()
     return fee?.gasPrice
   }
 
+  async getGasPriceEstimation() {
+    return getFallbackGasPriceEstimation({ server: this })
+  }
+
   async sendRpcRequest(rpcRequest) {
     const rpcSocket = this.connectRpc()
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => reject(new Error(RPC_REQUEST_TIMEOUT)), 3000)
       rpcSocket.emit('request', rpcRequest, (response) => {
         clearTimeout(timeout)
+        const rawTraceparent = response?.traceparent || response?.[0]?.traceparent
+        if (rawTraceparent) {
+          // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+          response.traceparent = TraceId.fromRawTraceparent(rawTraceparent)
+        }
+
         resolve(response)
       })
     })
   }
 
+  // Transport: WS only in ClarityServer, WS first → HTTP fallback in ClarityServerV2
   async sendBatchRequest(batch) {
     const responses = await this.sendRpcRequest(batch)
     // FIXME: this falls apart if responses is not an array
@@ -201,12 +226,14 @@ export default class ClarityServer extends EventEmitter {
     return batch.map((request) => keyed[`${request.id}`])
   }
 
+  // Transport: Uses sendRpcRequest - WS only in ClarityServer, WS first → HTTP fallback in ClarityServerV2
   async sendRequest(request) {
     const response = await this.sendRpcRequest(request)
 
     return this.handleJsonRPCResponse(response)
   }
 
+  // Transport: Via getCode → sendRequest → WS first → HTTP fallback in ClarityServerV2
   async isContract(address) {
     const code = await this.getCode(address)
     return code.length > 2
@@ -322,11 +349,13 @@ export default class ClarityServer extends EventEmitter {
     })
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async proxyToCoinNode(params) {
     const request = this.buildRequest(params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async balanceOf(address, tokenAddress, tag = 'latest') {
     const request = this.balanceOfRequest(address, tokenAddress, tag)
     const result = await this.sendRequest(request)
@@ -338,69 +367,83 @@ export default class ClarityServer extends EventEmitter {
     }
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getBalance(...params) {
-    const request = this.getBalanceRequest(...params)
+    const request = this.getBalanceRequest(...params) // eth_getBalance
     return this.sendRequest(request)
   }
 
+  // Transport: Via getBalance → sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getBalanceProxied(...params) {
-    return this.getBalance(...params)
+    return this.getBalance(...params) // eth_getBalance
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async gasPrice(...params) {
     const request = this.gasPriceRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: WS only in ClarityServer, HTTP only in ClarityServerV2 (overridden)
   async estimateGas(...params) {
     const request = this.estimateGasRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: WS only in ClarityServer, HTTP only in ClarityServerV2 (overridden)
   async sendRawTransaction(...params) {
     const request = this.sendRawTransactionRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getCode(...params) {
     const request = this.getCodeRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getStorageAt(...params) {
     const request = this.getStorageAtRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: WS only in ClarityServer, HTTP only in ClarityServerV2 (overridden)
   async getTransactionCount(...params) {
     const request = this.getTransactionCountRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getTransactionByHash(...params) {
     const request = this.getTransactionByHashRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getTransactionReceipt(...params) {
     const request = this.getTransactionReceiptRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async ethCall(...params) {
     const request = this.ethCallRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async blockNumber(...params) {
     const request = this.blockNumberRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via getBlockByNumber → sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getLatestBlock() {
     return this.getBlockByNumber('latest')
   }
 
+  // Transport: Via getLatestBlock → getBlockByNumber → sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getBaseFeePerGas() {
     const response = await this.getLatestBlock()
     if (response.baseFeePerGas) {
@@ -408,46 +451,55 @@ export default class ClarityServer extends EventEmitter {
     }
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getBlockByHash(...params) {
     const request = this.getBlockByHashRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getBlockTransactionCountByNumber(...params) {
     const request = this.getBlockTransactionCountByNumberRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getBlockByNumber(...params) {
     const request = this.getBlockByNumberRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async simulateV1(...params) {
     const request = this.simulateV1Request(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async simulateRawTransaction(...params) {
     const request = this.simulateRawTransactionRequest(...params)
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getCoinbase() {
     const request = this.coinbaseRequest()
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getCompilers() {
     const request = this.getCompilersRequest()
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getNetVersion() {
     const request = this.getNetVersion()
     return this.sendRequest(request)
   }
 
+  // Transport: Via sendRequest → WS first → HTTP fallback in ClarityServerV2
   async getLogs(...params) {
     const request = this.getLogsRequest(...params)
     return this.sendRequest(request)

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

@@ -22,7 +22,7 @@ export function createEvmServer({ assetName, serverUrl, monitorType }) {
   assert(monitorType, 'monitorType is required')
   switch (monitorType) {
     case 'no-history':
-      return new ApiCoinNodesServer({ uri: serverUrl })
+      return new ApiCoinNodesServer({ baseAssetName: assetName, uri: serverUrl })
     case 'clarity':
       return new ClarityServer({ baseAssetName: assetName, uri: serverUrl })
     case 'clarity-v2':

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

@@ -0,0 +1,31 @@
+import assert from 'minimalistic-assert'
+
+const desc = (a, b) => (a > b ? -1 : b > a ? 1 : 0)
+
+export const getFallbackGasPriceEstimation = async ({ server }) => {
+  const [latestBlock, gasPrice] = await Promise.all([server.getLatestBlock(), server.getGasPrice()])
+
+  assert(latestBlock, 'expected latestBlock')
+  assert(gasPrice, 'expected gasPrice')
+
+  const baseFeePerGas = latestBlock.baseFeePerGas
+  if (!baseFeePerGas) return { gasPrice }
+
+  const [max, min] = [BigInt(gasPrice), BigInt(baseFeePerGas)].sort(desc)
+
+  const toHex = (b) => `0x${b.toString(16)}`
+
+  // TODO: Use `eth_feeHistory` or `eth_maxPriorityFeePerGas`
+  //       instead (requires allowlist at the RPC).
+  // HACK: Infer the RPC's implicit `tipGasPrice`:
+  //       https://github.com/ethereum/go-ethereum/blob/d3dd48e59db28ea04bd92e4337cdd488ccb8fbec/internal/ethapi/api.go#L69C1-L79C2
+  const maxPriorityFeePerGas50Percentile = max - min
+
+  const rewardPercentiles = {
+    25: toHex(maxPriorityFeePerGas50Percentile / BigInt(2)),
+    50: toHex(maxPriorityFeePerGas50Percentile),
+    75: toHex((maxPriorityFeePerGas50Percentile * BigInt(3)) / BigInt(2)),
+  }
+
+  return { gasPrice, baseFeePerGas, rewardPercentiles }
+}

package/src/fee-utils.js

@@ -1,14 +1,5 @@
 import assert from 'minimalistic-assert'
 
-export const shouldFetchEthLikeFallbackGasPrices = async ({ eip1559Enabled, server }) => {
-  const [gasPrice, baseFeePerGas] = await Promise.all([
-    server.getGasPrice(),
-    eip1559Enabled ? server.getBaseFeePerGas() : undefined,
-  ])
-
-  return { gasPrice, baseFeePerGas }
-}
-
 export const applyMultiplierToPrice = ({ feeAsset, gasPriceMultiplier, price }) => {
   assert(typeof price === 'string', 'price should be a string')
   return feeAsset.currency

package/src/index.js

@@ -88,7 +88,13 @@ export {
   fromHexToBN,
 } from './number-utils.js'
 
-export { reasons as errorReasons, withErrorReason, EthLikeError } from './error-wrapper.js'
+export {
+  EVM_ERROR_REASONS,
+  EVM_ERROR_TYPES,
+  getEvmErrorReason,
+  withErrorReason,
+  EthLikeError,
+} from './error-wrapper.js'
 
 export { txSendFactory } from './tx-send/index.js'
 

package/src/nft-utils.js

@@ -1,7 +1,8 @@
+import { safeString } from '@exodus/safe-string'
 import SolidityContract from '@exodus/solidity-contract'
 import assert from 'minimalistic-assert'
 
-import * as ErrorWrapper from './error-wrapper.js'
+import { EthLikeError, EVM_ERROR_REASONS } from './error-wrapper.js'
 import { fetchGasLimit } from './gas-estimation.js'
 
 export const getNftArguments = async ({ asset, nft, fromAddress, toAddress }) => {
@@ -44,10 +45,11 @@ export const getNftArguments = async ({ asset, nft, fromAddress, toAddress }) =>
       }
     })
   ).catch((e) => {
-    throw new ErrorWrapper.EthLikeError({
+    throw new EthLikeError({
       message: errors.join('\n'),
-      reason: ErrorWrapper.reasons.fetchGasLimitFailed,
-      hint: 'getNftArguments',
+      errorReasonInfo: EVM_ERROR_REASONS.fetchGasLimitFailed,
+      hint: safeString`getNftArguments`,
+      traceId: e.traceId,
     })
   })
   return {

package/src/optimism-gas/index.js

@@ -1,7 +1,9 @@
 import { createContract, createEthereumJsTx } from '@exodus/ethereum-lib'
 import { bufferToHex } from '@exodus/ethereumjs/util'
+import { safeString } from '@exodus/safe-string'
 import assert from 'minimalistic-assert'
 
+import { EVM_ERROR_REASONS, withErrorReason } from '../error-wrapper.js'
 import { fromHexToBigInt } from '../number-utils.js'
 
 export const estimateL1DataFeeFactory = ({ l1GasOracleAddress, server }) => {
@@ -14,7 +16,12 @@ export const estimateL1DataFeeFactory = ({ l1GasOracleAddress, server }) => {
     const callData = gasContract.getL1Fee.build(serialized)
     const buffer = Buffer.from(callData)
     const data = bufferToHex(buffer)
-    const hex = await server.ethCall({ to: l1GasOracleAddress, data }, 'latest')
+    const hex = await withErrorReason({
+      promise: server.ethCall({ to: l1GasOracleAddress, data }, 'latest'),
+      errorReasonInfo: EVM_ERROR_REASONS.ethCallFailed,
+      hint: safeString`estimateL1DataFee`,
+      baseAssetName: server.baseAssetName,
+    })
     const l1DataFee = fromHexToBigInt(hex)
     const padFee = l1DataFee / BigInt(4)
     const maxL1DataFee = l1DataFee + padFee

package/src/server-based-fee-monitor.js

@@ -1,10 +1,7 @@
 import { FeeMonitor } from '@exodus/asset-lib'
 import assert from 'minimalistic-assert'
 
-import {
-  calculateEthLikeFeeMonitorUpdate,
-  shouldFetchEthLikeFallbackGasPrices,
-} from './fee-utils.js'
+import { calculateEthLikeFeeMonitorUpdate } from './fee-utils.js'
 
 /**
  * Generic eth server based fee monitor.
@@ -25,11 +22,6 @@ export const serverBasedFeeMonitorFactoryFactory = ({ asset, interval, server, a
   assert(server, 'server is required')
   assert(aci, 'aci is required')
 
-  const shouldFetchGasPrices = async () => {
-    const { eip1559Enabled } = await aci.getFeeConfig({ assetName: asset.name })
-    return shouldFetchEthLikeFallbackGasPrices({ eip1559Enabled, server })
-  }
-
   const FeeMonitorClass = class ServerBaseEthereumFeeMonitor extends FeeMonitor {
     constructor({ updateFee }) {
       assert(updateFee, 'updateFee is required')
@@ -44,7 +36,7 @@ export const serverBasedFeeMonitorFactoryFactory = ({ asset, interval, server, a
       return calculateEthLikeFeeMonitorUpdate({
         assetClientInterface: aci,
         feeAsset: asset,
-        fetchedGasPrices: await shouldFetchGasPrices(),
+        fetchedGasPrices: await server.getGasPriceEstimation(),
       })
     }
   }

package/src/staking/ethereum/api.js

@@ -1,7 +1,9 @@
 import { createContract } from '@exodus/ethereum-lib'
 import { bufferToHex } from '@exodus/ethereumjs/util'
+import { safeString } from '@exodus/safe-string'
 import { retry } from '@exodus/simple-retry'
 
+import { EVM_ERROR_REASONS, withErrorReason } from '../../error-wrapper.js'
 import { getServerByName } from '../../exodus-eth-server/index.js'
 
 // TODO: Shouldn't this be a function of `ethereumStakingState.minDelegateAmount`?
@@ -78,7 +80,12 @@ export class EthereumStaking {
     if (typeof from === 'string' && from.length > 0) data.from = from
 
     const eth = this.server || getServerByName(this.asset.name)
-    return retry((...args) => eth.ethCall(...args), { delayTimesMs: RETRY_DELAYS })(data)
+    return withErrorReason({
+      promise: retry((...args) => eth.ethCall(...args), { delayTimesMs: RETRY_DELAYS })(data),
+      errorReasonInfo: EVM_ERROR_REASONS.ethCallFailed,
+      hint: safeString`stakingEthReadFunctionContract`,
+      baseAssetName: eth.baseAssetName,
+    })
   }
 
   // === ACCOUNTING ===

package/src/staking/matic/api.js

@@ -1,9 +1,11 @@
 import { createContract } from '@exodus/ethereum-lib'
 import ethAssets from '@exodus/ethereum-meta'
 import { bufferToHex } from '@exodus/ethereumjs/util'
+import { safeString } from '@exodus/safe-string'
 import { retry } from '@exodus/simple-retry'
 import BN from 'bn.js'
 
+import { EVM_ERROR_REASONS, withErrorReason } from '../../error-wrapper.js'
 import { getServerByName } from '../../exodus-eth-server/index.js'
 import { fromHexToBN, fromHexToString, splitIn32BytesArray } from '../../number-utils.js'
 
@@ -43,7 +45,12 @@ export class MaticStakingApi {
     }
 
     const eth = this.server || getServerByName('ethereum')
-    return retry((...args) => eth.ethCall(...args), { delayTimesMs: RETRY_DELAYS })(data)
+    return withErrorReason({
+      promise: retry((...args) => eth.ethCall(...args), { delayTimesMs: RETRY_DELAYS })(data),
+      errorReasonInfo: EVM_ERROR_REASONS.ethCallFailed,
+      hint: safeString`stakingMaticReadFunctionContract`,
+      baseAssetName: eth.baseAssetName,
+    })
   }
 
   getWithdrawalDelay = async () => {

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

@@ -0,0 +1,58 @@
+import { EthLikeError, EVM_ERROR_REASONS, getEvmErrorReason } from '../error-wrapper.js'
+import { transactionExists } from '../eth-like-util.js'
+
+/**
+ * Handles broadcast errors by parsing the error message and either throwing
+ * an appropriate EthLikeError or returning info for retry logic.
+ *
+ * @param {Error} err - The error from broadcastTx.
+ * @param {Object} options - Context for error handling.
+ * @param {Object} options.asset - The asset.
+ * @param {string} options.txId - The transaction ID.
+ * @param {boolean} options.isHardware - Whether this is a hardware wallet.
+ * @param {string} options.hint - Hint for the error.
+ * @returns {Promise<{ shouldRetry: boolean }>} - Returns if nonce too low and can retry.
+ * @throws {EthLikeError} - Throws for all other error cases.
+ */
+export const handleBroadcastError = async (err, { asset, txId, isHardware, hint, isBumpTx }) => {
+  const message = err.message
+
+  const errorInfo = getEvmErrorReason(message) || EVM_ERROR_REASONS.broadcastTxFailed
+
+  const isNonceTooLow = errorInfo.reason === EVM_ERROR_REASONS.nonceTooLow.reason
+  const isAmbiguousError =
+    isNonceTooLow || errorInfo.reason === EVM_ERROR_REASONS.transactionUnderpriced.reason
+
+  if (errorInfo.reason === EVM_ERROR_REASONS.alreadyKnown.reason) {
+    console.info('tx already broadcast')
+    return { shouldRetry: false }
+  }
+
+  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)
+    }
+  }
+
+  if (txAlreadyExists) {
+    console.info('tx already broadcast')
+    return { shouldRetry: false }
+  }
+
+  // NOTE: Don't auto-retry nonce repair for bump/replacement txs.
+  // A replacement must keep the *same nonce* as the tx it's replacing.
+  // 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) return { shouldRetry: true }
+
+  throw new EthLikeError({
+    message: err.message,
+    errorReasonInfo: errorInfo,
+    hint,
+    traceId: err.traceId,
+    baseAssetName: asset.baseAsset.name,
+  })
+}