@exodus/ethereum-api 8.50.0 → 8.50.1

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.50.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.50.0...@exodus/ethereum-api@8.50.1) (2025-09-22)
+
+**Note:** Version bump only for package @exodus/ethereum-api
+
+
+
+
+
 ## [8.50.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.49.0...@exodus/ethereum-api@8.50.0) (2025-09-17)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.50.0",
+  "version": "8.50.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",
@@ -66,5 +66,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "05a8eb8fc2b399e3497825462f429970f559b8cc"
+  "gitHead": "e54f136a2e7ff694cd12dc1a7b0ef34eb707ef0e"
 }

package/src/tx-create.js

@@ -8,6 +8,7 @@ import { ensureSaneEip1559GasPriceForTipGasPrice } from './fee-utils.js'
 import { ARBITRARY_ADDRESS, fetchGasLimit, resolveDefaultTxInput } from './gas-estimation.js'
 import { getExtraFeeData, getFeeFactoryGasPrices } from './get-fee.js'
 import { getNftArguments } from './nft-utils.js'
+import { getHighestIncentivePendingTxByNonce } from './tx-log/index.js'
 
 async function createUnsignedTxWithFees({
   asset,
@@ -134,6 +135,7 @@ const createBumpUnsignedTx = async ({
   const txToAddress = isToken ? asset.contract.address : toAddress
   const coinAmount = (replacedTokenTx || replacedTx).coinAmount.negate()
   const gasLimit = replacedTx.data.gasLimit
+  const nonce = replacedTx.data.nonce
 
   const value = isToken ? baseAsset.currency.ZERO : coinAmount
 
@@ -143,9 +145,27 @@ const createBumpUnsignedTx = async ({
     eip1559Enabled,
     tipGasPrice: currentTipGasPrice,
   } = feeData
+
+  const maybeHighestIncentivePendingTxForNonce = await getHighestIncentivePendingTxByNonce({
+    assetClientInterface,
+    asset,
+    nonce,
+    walletAccount,
+  })
+
+  assert(
+    maybeHighestIncentivePendingTxForNonce,
+    `unable to resolve pending transaction for nonce ${nonce}`
+  )
+
   const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
     baseAsset,
-    tx: replacedTx,
+    // 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,
@@ -153,7 +173,6 @@ const createBumpUnsignedTx = async ({
   })
   const gasPrice = bumpedGasPrice
   const tipGasPrice = bumpedTipGasPrice
-  const nonce = replacedTx.data.nonce
   const data = replacedTokenTx
     ? asset.contract.transfer.build(toAddress.toLowerCase(), coinAmount.toBaseString())
     : replacedTx.data.data || '0x'

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

@@ -0,0 +1,130 @@
+import { isNumberUnit } from '@exodus/currency'
+import { isEthereumLikeToken } from '@exodus/ethereum-lib'
+import assert from 'minimalistic-assert'
+
+// Returns the most competitively priced pending
+// transaction from the `TxLog` for a given `nonce`.
+export const getHighestIncentivePendingTxByNonce = async ({
+  assetClientInterface,
+  asset,
+  nonce,
+  walletAccount,
+}) => {
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(asset, 'expected asset')
+  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] = [
+    ...(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
+}
+
+export const getOptimisticTxLogEffects = async ({
+  asset,
+  amount = asset.currency.ZERO,
+  assetClientInterface,
+  confirmations = 0,
+  feeAmount,
+  fromAddress,
+  gasLimit,
+  nonce,
+  txId,
+  toAddress,
+  tipGasPrice: maybeTipGasPrice,
+  walletAccount,
+}) => {
+  assert(isNumberUnit(amount), 'expected NumberUnit amount')
+  assert(asset, 'expected asset')
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(Number.isInteger(confirmations), 'expected integer confirmations')
+  assert(isNumberUnit(feeAmount), 'expected feeAmount')
+  assert(typeof fromAddress === 'string', 'expected string fromAddress')
+  assert(Number.isInteger(gasLimit), 'expected integer gasLimit')
+  assert(Number.isInteger(nonce), 'expected integer nonce')
+  assert(typeof toAddress === 'string', 'expected string toAddress')
+  assert(txId, 'expected txId')
+  assert(walletAccount, 'expected walletAccount')
+
+  if (maybeTipGasPrice) assert(isNumberUnit(maybeTipGasPrice), 'expected NumberUnit tipGasPrice')
+
+  const baseAsset = asset.baseAsset
+
+  // TODO: This is incorrect for token transfers.
+  const selfSend = fromAddress.toLowerCase() === toAddress.toLowerCase()
+
+  assert(asset.feeAsset.name === baseAsset.name, 'inconsistent feeAsset')
+
+  const maybeTxToReplace = await getHighestIncentivePendingTxByNonce({
+    asset,
+    assetClientInterface,
+    nonce,
+    walletAccount,
+  })
+
+  const replacedTxId =
+    maybeTxToReplace && maybeTxToReplace.feeAmount.lt(feeAmount) ? maybeTxToReplace.txId : undefined
+
+  if (!replacedTxId && maybeTxToReplace) {
+    console.log('Attempting to replace a transaction using an insufficient fee!')
+  }
+
+  const sharedProps = {
+    confirmations,
+    feeAmount,
+    feeCoinName: asset.feeAsset.name,
+    selfSend,
+    to: toAddress,
+    txId,
+    data: {
+      gasLimit,
+      replacedTxId,
+      nonce,
+      ...(maybeTipGasPrice ? { tipGasPrice: maybeTipGasPrice.toBaseString() } : null),
+    },
+  }
+
+  const optimisticTxLogEffects = [
+    {
+      assetName: asset.name,
+      walletAccount,
+      txs: [
+        {
+          ...sharedProps,
+          coinAmount: selfSend ? asset.currency.ZERO : amount.abs().negate(),
+          coinName: asset.name,
+          currencies: {
+            [asset.name]: asset.currency,
+            [asset.feeAsset.name]: asset.feeAsset.currency,
+          },
+        },
+      ],
+    },
+    isEthereumLikeToken(asset) && {
+      assetName: baseAsset.name,
+      walletAccount,
+      txs: [
+        {
+          ...sharedProps,
+          coinAmount: baseAsset.currency.ZERO,
+          coinName: baseAsset.name,
+          currencies: {
+            [baseAsset.name]: baseAsset.currency,
+            [asset.feeAsset.name]: asset.feeAsset.currency,
+          },
+          tokens: [asset.name],
+        },
+      ],
+    },
+  ].filter(Boolean)
+
+  return { optimisticTxLogEffects }
+}

package/src/tx-log/index.js

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

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

@@ -1,14 +1,10 @@
-import {
-  isEthereumLikeToken,
-  normalizeTxId,
-  parseUnsignedTx,
-  updateNonce,
-} from '@exodus/ethereum-lib'
+import { normalizeTxId, parseUnsignedTx, updateNonce } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
 
 import * as ErrorWrapper from '../error-wrapper.js'
 import { transactionExists } from '../eth-like-util.js'
 import { ARBITRARY_ADDRESS } from '../gas-estimation.js'
+import { getOptimisticTxLogEffects } from '../tx-log/index.js'
 
 const txSendFactory = ({ assetClientInterface, createTx }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
@@ -25,7 +21,6 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
   }
 
   return async ({ asset, walletAccount, unsignedTx: providedUnsignedTx, ...legacyParams }) => {
-    const assetName = asset.name
     const baseAsset = asset.baseAsset
 
     const resolveUnsignedTx = async () => {
@@ -57,16 +52,13 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
     const tipGasPrice = parsedTx.tipGasPrice
     const gasLimit = parsedTx.gasLimit
     const amount = parsedTx.amount
-    const to = parsedTx.to
-    const eip1559Enabled = parsedTx.eip1559Enabled
+    const toAddress = parsedTx.to
 
     // unknown data from buffer...
     const fromAddress = unsignedTx.txMeta.fromAddress
-    const selfSend = fromAddress === to
-    const replacedTxId = unsignedTx.txMeta.bumpTxId
 
     assert(
-      to.toLowerCase() !== ARBITRARY_ADDRESS,
+      toAddress.toLowerCase() !== ARBITRARY_ADDRESS,
       `The receiving wallet address must not be ${ARBITRARY_ADDRESS}`
     )
 
@@ -154,64 +146,23 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
       }
     }
 
-    const txData = eip1559Enabled
-      ? {
-          gasLimit,
-          replacedTxId,
-          nonce,
-          ...(tipGasPrice ? { tipGasPrice: tipGasPrice.toBaseString() } : Object.create(null)),
-        }
-      : {
-          gasLimit,
-          replacedTxId,
-          nonce,
-        }
-
-    await assetClientInterface.updateTxLogAndNotify({
-      assetName: asset.name,
+    const { optimisticTxLogEffects } = await getOptimisticTxLogEffects({
+      amount,
+      asset,
+      assetClientInterface,
+      feeAmount,
+      fromAddress,
+      gasLimit,
+      nonce,
+      txId,
+      toAddress,
+      tipGasPrice,
       walletAccount,
-      txs: [
-        {
-          txId,
-          confirmations: 0,
-          coinAmount: selfSend ? asset.currency.ZERO : amount.abs().negate(),
-          coinName: asset.name,
-          feeAmount,
-          feeCoinName: asset.feeAsset.name,
-          selfSend,
-          to,
-          currencies: {
-            [assetName]: asset.currency,
-            [asset.feeAsset.name]: asset.feeAsset.currency,
-          },
-          data: txData,
-        },
-      ],
     })
 
-    const isToken = isEthereumLikeToken(asset)
-    if (isToken) {
-      await assetClientInterface.updateTxLogAndNotify({
-        assetName: baseAsset.name,
-        walletAccount,
-        txs: [
-          {
-            txId,
-            coinAmount: baseAsset.currency.ZERO,
-            coinName: baseAsset.name,
-            feeAmount,
-            feeCoinName: baseAsset.name,
-            selfSend,
-            to,
-            token: asset.name,
-            currencies: {
-              [baseAsset.name]: baseAsset.currency,
-              [asset.feeAsset.name]: asset.feeAsset.currency,
-            },
-            data: txData,
-          },
-        ],
-      })
+    // NOTE: `optimisticTxLogEffects` **must** be written sequentially.
+    for (const optimisticTxLogEffect of optimisticTxLogEffects) {
+      await assetClientInterface.updateTxLogAndNotify(optimisticTxLogEffect)
     }
 
     return { txId, nonce }