@exodus/ethereum-api 8.57.1 → 8.59.0

package/CHANGELOG.md

@@ -3,6 +3,40 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.59.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.57.0...@exodus/ethereum-api@8.59.0) (2025-11-10)
+
+
+### Features
+
+
+* feat: enable implicit transaction bumps (#6798)
+
+
+### Bug Fixes
+
+
+* fix: correct response to insufficient evm nonce during txSend (#6901)
+
+* fix: enable replacement transaction underpriced errors to satisfy evm transaction existence checks (#6900)
+
+
+
+## [8.58.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.57.0...@exodus/ethereum-api@8.58.0) (2025-11-10)
+
+
+### Features
+
+
+* feat: enable implicit transaction bumps (#6798)
+
+
+### Bug Fixes
+
+
+* fix: correct response to insufficient evm nonce during txSend (#6901)
+
+
+
 ## [8.57.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.57.0...@exodus/ethereum-api@8.57.1) (2025-11-10)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.57.1",
+  "version": "8.59.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",
@@ -29,7 +29,7 @@
     "@exodus/bip44-constants": "^195.0.0",
     "@exodus/crypto": "^1.0.0-rc.26",
     "@exodus/currency": "^6.0.1",
-    "@exodus/ethereum-lib": "^5.18.6",
+    "@exodus/ethereum-lib": "^5.19.0",
     "@exodus/ethereum-meta": "^2.9.1",
     "@exodus/ethereumholesky-meta": "^2.0.5",
     "@exodus/ethereumjs": "^1.8.0",
@@ -67,5 +67,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "342bc790d18d382ec34f846446d678a3b6342ab7"
+  "gitHead": "94c7625c1fb029ef261d0ef61e32c7c66d359812"
 }

package/src/error-wrapper.js

@@ -7,6 +7,7 @@ export const reasons = {
   ethCallErc20Failed: 'Eth call erc20 failed',
   insufficientFunds: 'Insufficient funds',
   bumpTxFailed: 'Bump tx failed',
+  transactionUnderpriced: 'Transaction underpriced',
 }
 
 const MAX_HINT_LENGTH = 100

package/src/fee-utils.js

@@ -197,6 +197,7 @@ export const executeEthLikeFeeMonitorUpdate = async ({
   return nextFeeConfig
 }
 
+// TODO: rename to getEffectiveGasPriceForFeeData
 export const resolveGasPrice = ({ feeData }) => {
   assert(feeData, 'feeData is required')
 

package/src/get-fee.js

@@ -1,4 +1,9 @@
-import { calculateBumpedGasPrice, calculateExtraEth } from '@exodus/ethereum-lib'
+import {
+  calculateBumpedGasPrice,
+  calculateBumpedGasPriceForFeeData,
+  calculateExtraEth,
+} from '@exodus/ethereum-lib'
+import assert from 'minimalistic-assert'
 
 import {
   ensureSaneEip1559GasPriceForTipGasPrice,
@@ -26,27 +31,68 @@ export const getExtraFeeData = ({ asset, amount }) => {
   }
 }
 
-export const getFeeFactoryGasPrices = ({ customFee, feeData }) => {
-  feeData = getNormalizedFeeDataForCustomFee({ customFee, feeData })
-  const gasPrice = customFee || resolveGasPrice({ feeData })
+const getGasPricesResult = ({ gasPrice, feeData }) => {
   const { tipGasPrice, eip1559Enabled } = feeData
-
-  // The `gasPrice` must be at least the `tipGasPrice`.
   return {
     gasPrice: eip1559Enabled
-      ? ensureSaneEip1559GasPriceForTipGasPrice({ gasPrice, tipGasPrice })
+      ? // NOTE: The `gasPrice` must be at least the `tipGasPrice`.
+        ensureSaneEip1559GasPriceForTipGasPrice({ gasPrice, tipGasPrice })
       : gasPrice,
     feeData,
   }
 }
 
+const getGasPricesForTxToReplace = ({ baseAsset, feeData, txToReplace }) => {
+  const { eip1559Enabled } = feeData
+
+  const effectiveGasPrice = resolveGasPrice({ feeData })
+  const { tipGasPrice: effectiveTipGasPrice } = feeData
+
+  const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPriceForFeeData({
+    baseAsset,
+    feeData,
+    tx: txToReplace,
+  })
+
+  const gasPrice = bumpedGasPrice.gt(effectiveGasPrice) ? bumpedGasPrice : effectiveGasPrice
+  if (!eip1559Enabled) return getGasPricesResult({ gasPrice, feeData })
+
+  const tipGasPrice = bumpedTipGasPrice.gt(effectiveTipGasPrice)
+    ? bumpedTipGasPrice
+    : effectiveTipGasPrice
+
+  return getGasPricesResult({
+    gasPrice,
+    feeData: { ...feeData, tipGasPrice },
+  })
+}
+
+export const getAggregateTransactionPricing = ({ baseAsset, customFee, feeData, txToReplace }) => {
+  assert(baseAsset, 'expected baseAsset')
+
+  if (customFee) {
+    return getGasPricesResult({
+      gasPrice: customFee,
+      feeData: getNormalizedFeeDataForCustomFee({ customFee, feeData }),
+    })
+  }
+
+  if (txToReplace) return getGasPricesForTxToReplace({ baseAsset, feeData, txToReplace })
+
+  return getGasPricesResult({
+    gasPrice: resolveGasPrice({ feeData }),
+    feeData,
+  })
+}
+
 export const getFeeFactory =
   () =>
   ({ asset, feeData, customFee, txInput, gasLimit: providedGasLimit, amount }) => {
     const {
       feeData: { tipGasPrice, eip1559Enabled },
       gasPrice,
-    } = getFeeFactoryGasPrices({
+    } = getAggregateTransactionPricing({
+      baseAsset: asset.baseAsset,
       customFee,
       feeData,
     })
@@ -63,6 +109,7 @@ export const getFeeFactory =
     return { ...maybeReturnTipGasPrice, fee, gasPrice, extraFeeData }
   }
 
+// TODO: sanity check this usage
 // Used in Mobile
 export const getExtraFeeForBump = ({ tx, feeData, balance, unconfirmedBalance }) => {
   if (!balance || !unconfirmedBalance) return null

package/src/staking/matic/service.js

@@ -1,7 +1,7 @@
 import { memoize } from '@exodus/basic-utils'
 
 import { estimateGasLimit, scaleGasLimitEstimate } from '../../gas-estimation.js'
-import { getFeeFactoryGasPrices } from '../../get-fee.js'
+import { getAggregateTransactionPricing } from '../../get-fee.js'
 import { createWatchTx as defaultCreateWatch } from '../../watch-tx.js'
 import { stakingProviderClientFactory } from '../staking-provider-client.js'
 import {
@@ -315,7 +315,7 @@ export function createPolygonStakingService({
     const erc20ApproveGas = 80_000
     const delegateGas = 250_000
 
-    const { gasPrice } = getFeeFactoryGasPrices({ feeData })
+    const { gasPrice } = getAggregateTransactionPricing({ baseAsset: ethereum, feeData })
 
     const gasLimitWithBuffer = scaleGasLimitEstimate({
       estimatedGasLimit: BigInt(erc20ApproveGas + delegateGas),

package/src/tx-create.js

@@ -1,17 +1,18 @@
-import { calculateBumpedGasPrice, currency2buffer, isEthereumLikeToken } from '@exodus/ethereum-lib'
+import { currency2buffer, isEthereumLikeToken } from '@exodus/ethereum-lib'
 import createEthereumJsTx from '@exodus/ethereum-lib/src/unsigned-tx/create-ethereumjs-tx.js'
 import assert from 'minimalistic-assert'
 
 import { ensureSaneEip1559GasPriceForTipGasPrice } from './fee-utils.js'
 import { fetchGasLimit } from './gas-estimation.js'
-import { getExtraFeeData, getFeeFactoryGasPrices } from './get-fee.js'
+import { getAggregateTransactionPricing, getExtraFeeData } from './get-fee.js'
 import { getNftArguments } from './nft-utils.js'
-import { getHighestIncentivePendingTxByNonce } from './tx-log/index.js'
+import { getHighestIncentiveTxByNonce } from './tx-log/index.js'
 import {
   assertTxAttributes,
   isValidTxType,
   resolveTxAttributesByTxType,
   resolveTxFromAddress,
+  resolveTxNonce,
   TX_TYPE_TRANSFER,
 } from './tx-type/index.js'
 
@@ -105,19 +106,40 @@ async function createUnsignedTxWithFees({
   }
 }
 
-const resolveTxFactoryGasPrices = ({
+const resolveTxFactoryGasPrices = async ({
+  assetClientInterface,
+  baseAsset,
   customFee: providedCustomFee,
   feeData,
   gasPrice: providedGasPrice,
   tipGasPrice: providedTipGasPrice,
+  txToReplace,
+  nonce,
+  walletAccount,
 }) => {
-  assert(feeData)
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(baseAsset, 'expected baseAsset')
+  assert(feeData, 'expected feeData')
+  assert(Number.isInteger(nonce), 'expected integer nonce')
+  assert(walletAccount, 'expected walletAccount')
 
   const {
     gasPrice: maybeGasPrice,
     feeData: { tipGasPrice: maybeTipGasPrice, eip1559Enabled },
-  } = getFeeFactoryGasPrices({ customFee: providedCustomFee, feeData })
+  } = getAggregateTransactionPricing({
+    baseAsset,
+    customFee: providedCustomFee,
+    feeData,
+    txToReplace,
+  })
 
+  // When we determine the `gasPrice` for a transaction, we must be
+  // cognizant of any transactions which are pending for the current
+  // `nonce`, as this may be higher compared to the current `gasPrice`
+  // that we are recommending from the network.
+  //
+  // In this instance, the `gasPrice` we recommend should be
+  // sufficient to avoid `replacement transaction underpriced` errors.
   const resolvedGasPrice = providedGasPrice ?? maybeGasPrice
 
   if (!eip1559Enabled) return { eip1559Enabled, resolvedGasPrice }
@@ -212,14 +234,7 @@ const createBumpUnsignedTx = async ({
 
   const gasLimit = replacedTx.data.gasLimit
 
-  const {
-    gasPrice: currentGasPrice,
-    baseFeePerGas: currentBaseFee,
-    eip1559Enabled,
-    tipGasPrice: currentTipGasPrice,
-  } = feeData
-
-  const maybeHighestIncentivePendingTxForNonce = await getHighestIncentivePendingTxByNonce({
+  const maybeTxToReplace = await getHighestIncentiveTxByNonce({
     assetClientInterface,
     asset,
     nonce: resolvedTxAttributes.nonce,
@@ -227,31 +242,23 @@ const createBumpUnsignedTx = async ({
   })
 
   assert(
-    maybeHighestIncentivePendingTxForNonce,
+    maybeTxToReplace,
     `unable to resolve pending transaction for nonce ${resolvedTxAttributes.nonce}`
   )
 
-  const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
-    baseAsset,
-    // HACK: Although the `bumpTxId` defines the characteristics of
-    //       of a transaction the user would like to accelerate, for
-    //       acceleration to be successful, the transaction must be
-    //       priced to exceed the miner incentive of whichever
-    //       transaction is currently pending at the specified nonce.
-    tx: maybeHighestIncentivePendingTxForNonce,
-    currentGasPrice,
-    currentBaseFee,
-    currentTipGasPrice,
+  const {
     eip1559Enabled,
+    resolvedGasPrice: gasPrice,
+    resolvedTipGasPrice: tipGasPrice,
+  } = await resolveTxFactoryGasPrices({
+    assetClientInterface,
+    baseAsset,
+    feeData,
+    nonce,
+    txToReplace: maybeTxToReplace,
+    walletAccount,
   })
 
-  const { resolvedGasPrice: gasPrice, resolvedTipGasPrice: tipGasPrice } =
-    resolveTxFactoryGasPrices({
-      feeData,
-      gasPrice: bumpedGasPrice,
-      tipGasPrice: bumpedTipGasPrice,
-    })
-
   return createUnsignedTxWithFees({
     ...resolvedTxAttributes,
     asset,
@@ -289,10 +296,11 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
     assert(walletAccount, 'walletAccount is required')
     assert(isValidTxType(txType), 'invalid txType')
 
-    const feeData = await assetClientInterface.getFeeConfig({ assetName: asset.baseAsset.name })
+    const baseAsset = asset.baseAsset
+    const feeData = await assetClientInterface.getFeeConfig({ assetName: baseAsset.name })
 
     const baseAssetTxLog = await assetClientInterface.getTxLog({
-      assetName: asset.baseAsset.name,
+      assetName: baseAsset.name,
       walletAccount,
     })
 
@@ -318,15 +326,34 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
       })
     }
 
+    const nonce = await resolveTxNonce({
+      asset,
+      fromAddress,
+      nonce: providedNonce,
+      walletAccount,
+    })
+
+    const maybeTxToReplace = await getHighestIncentiveTxByNonce({
+      assetClientInterface,
+      asset: baseAsset,
+      nonce,
+      walletAccount,
+    })
+
     const {
       eip1559Enabled,
       resolvedGasPrice: gasPrice,
       resolvedTipGasPrice: tipGasPrice,
-    } = resolveTxFactoryGasPrices({
+    } = await resolveTxFactoryGasPrices({
+      assetClientInterface,
+      baseAsset,
       customFee: providedCustomFee,
       feeData,
       gasPrice: providedGasPrice,
+      nonce,
       tipGasPrice: providedTipGasPrice,
+      txToReplace: maybeTxToReplace,
+      walletAccount,
     })
 
     if (nft) {
@@ -342,10 +369,10 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
       })
 
       const resolvedTxAttributes = await resolveTxAttributesByTxType({
-        asset: asset.baseAsset,
+        asset: baseAsset,
         assetClientInterface,
         fromAddress,
-        nonce: providedNonce,
+        nonce,
         txInput,
         toAddress: providedToAddress,
         txToAddress,
@@ -369,7 +396,7 @@ export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonc
       assetClientInterface,
       amount: providedAmount,
       fromAddress,
-      nonce: providedNonce,
+      nonce,
       txInput: providedTxInput,
       toAddress: providedToAddress,
       txType,

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

@@ -6,7 +6,12 @@ import assert from 'minimalistic-assert'
 
 // Returns the most competitively priced pending
 // transaction from the `TxLog` for a given `nonce`.
-export const getHighestIncentivePendingTxByNonce = async ({
+//
+// NOTE: If a transaction was successfully included,
+//       it is the de-facto highest incentive
+//       transaction - irrespective of other
+//       attempts for that nonce.
+export const getHighestIncentiveTxByNonce = async ({
   assetClientInterface,
   asset,
   nonce,
@@ -17,17 +22,29 @@ export const getHighestIncentivePendingTxByNonce = async ({
   assert(Number.isInteger(nonce), 'expected integer nonce')
   assert(walletAccount, 'expected walletAccount')
 
-  // https://github.com/ExodusMovement/assets/blob/fbe3702861cba3b21885a65b15f038fcd8541891/shield/asset-lib/src/balances-utils.js#L26
-  const isUnconfirmed = (tx) => !tx.failed && tx.pending
-
-  const [maybeHighestIncentiveTx] = [
+  const txLogSendsByFeeAmountDesc = [
     ...(await assetClientInterface.getTxLog({ assetName: asset.name, walletAccount })),
   ]
-    .filter(isUnconfirmed)
     .filter((tx) => tx.data.nonce === nonce && tx.sent)
     .sort((a, b) => (a.feeAmount.gt(b.feeAmount) ? -1 : b.feeAmount.gt(a.feeAmount) ? 1 : 0))
 
-  return maybeHighestIncentiveTx
+  // If any of the transactions competing for this `nonce`
+  // were successful, then we can return this transaction
+  // as it effectively had the highest game-theoretical
+  // incentive regardless of other (potentially higher fee)
+  // transactions that were sent.
+  //
+  // https://github.com/ExodusMovement/exodus-hydra/blob/e59004097f15974a975d14e1823de5d7b1c28308/features/activity-txs/redux/utils/activity-formatters/format-tx-activity.js#L13
+  const maybeConfirmedTx = txLogSendsByFeeAmountDesc.find((tx) => !tx.failed && !tx.pending)
+  if (maybeConfirmedTx) return maybeConfirmedTx
+
+  // https://github.com/ExodusMovement/assets/blob/fbe3702861cba3b21885a65b15f038fcd8541891/shield/asset-lib/src/balances-utils.js#L26
+  const isUnconfirmed = (tx) => !tx.failed && tx.pending
+
+  // NOTE: When trying to find the highest incentive of a
+  //       transaction, consider those which are either still
+  //       pending.
+  return txLogSendsByFeeAmountDesc.find(isUnconfirmed)
 }
 
 export const getOptimisticTxLogEffects = async ({
@@ -77,7 +94,7 @@ export const getOptimisticTxLogEffects = async ({
 
   const baseAsset = asset.baseAsset
 
-  const maybeTxToReplace = await getHighestIncentivePendingTxByNonce({
+  const maybeTxToReplace = await getHighestIncentiveTxByNonce({
     asset,
     assetClientInterface,
     nonce,

package/src/tx-log/index.js

@@ -3,5 +3,5 @@ export { EthereumNoHistoryMonitor } from './ethereum-no-history-monitor.js'
 export { ClarityMonitor } from './clarity-monitor.js'
 export {
   getOptimisticTxLogEffects,
-  getHighestIncentivePendingTxByNonce,
+  getHighestIncentiveTxByNonce,
 } from './get-optimistic-txlog-effects.js'

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

@@ -59,11 +59,19 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
     try {
       await baseAsset.api.broadcastTx(rawTx.toString('hex'))
     } catch (err) {
+      const transactionUnderpricedErr = err.message.match(/transaction underpriced/i)
       const nonceTooLowErr = err.message.match(/nonce (is |)too low/i)
       const insufficientFundsErr = err.message.match(/insufficient funds/i)
-      const txAlreadyExists = nonceTooLowErr
-        ? await transactionExists({ asset, txId })
-        : err.message.match(/already known/i)
+
+      // NOTE: We've found that `geth` can return the following errors
+      //       for transactions which may be already known. In this
+      //       case, we validate that the transaction is known to the
+      //       network.
+      const txAlreadyExists =
+        nonceTooLowErr || transactionUnderpricedErr
+          ? await transactionExists({ asset, txId })
+          : err.message.match(/already known/i) ||
+            err.message.match(/transaction already imported/i)
 
       if (txAlreadyExists) {
         console.info('tx already broadcast') // inject logger factory from platform

package/src/tx-type/index.js

@@ -121,7 +121,12 @@ export const resolveTxFromAddress = async ({
   })
 }
 
-const resolveTxNonce = async ({ asset, fromAddress, nonce: providedNonce, walletAccount }) => {
+export const resolveTxNonce = async ({
+  asset,
+  fromAddress,
+  nonce: providedNonce,
+  walletAccount,
+}) => {
   assert(asset, 'expected asset')
   assert(typeof fromAddress === 'string', 'expected string fromAddress')
   assert(walletAccount, 'expected walletAccount')