@exodus/ethereum-api 8.62.3 → 8.63.0

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.63.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.62.4...@exodus/ethereum-api@8.63.0) (2026-01-14)
+
+
+### Features
+
+
+* feat: add 'latest' evm nonce support (#7267)
+
+
+
+## [8.62.4](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.62.3...@exodus/ethereum-api@8.62.4) (2026-01-14)
+
+
+### Bug Fixes
+
+
+* fix: absolute canonical nonce (#7238)
+
+
+
 ## [8.62.3](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.62.2...@exodus/ethereum-api@8.62.3) (2026-01-13)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.62.3",
+  "version": "8.63.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",
@@ -67,5 +67,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "d1618b4c41ccde490c3e4aaa8dd239c0c5393a7b"
+  "gitHead": "db8bd0629b287cd2031a12ff2a3fed3fc765bbab"
 }

package/src/create-asset-utils.js

@@ -7,7 +7,7 @@ import { ClarityMonitor } from './tx-log/clarity-monitor.js'
 import { ClarityMonitorV2 } from './tx-log/clarity-monitor-v2.js'
 import { EthereumMonitor } from './tx-log/ethereum-monitor.js'
 import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor.js'
-import { resolveNonce } from './tx-send/nonce-utils.js'
+import { BLOCK_TAG_PENDING, resolveNonce } from './tx-send/nonce-utils.js'
 
 // Determines the appropriate `monitorType`, `serverUrl` and `monitorInterval`
 // to use for a given config.
@@ -184,7 +184,16 @@ export const getNonceFactory = ({ assetClientInterface, useAbsoluteBalanceAndNon
   assert(assetClientInterface, 'expected assetClientInterface')
   assert(typeof useAbsoluteBalanceAndNonce === 'boolean', 'expected useAbsoluteBalanceAndNonce')
 
-  const getNonce = async ({ asset, fromAddress, walletAccount, triedNonce, forceFromNode }) => {
+  const getNonce = async ({
+    asset,
+    fromAddress,
+    walletAccount,
+    forceFromNode,
+    // NOTE: By default, Exodus assumes the client will by default want
+    //       to send transactions on top of those which are currently
+    //       pending at the public mempool.
+    tag = BLOCK_TAG_PENDING,
+  }) => {
     assert(asset, 'expected asset')
     assert(typeof fromAddress === 'string', 'expected fromAddress')
     assert(walletAccount, 'expected walletAccount')
@@ -198,13 +207,8 @@ export const getNonceFactory = ({ assetClientInterface, useAbsoluteBalanceAndNon
       asset,
       fromAddress,
       txLog,
-      triedNonce,
       forceFromNode,
-      // For assets where we'll fall back to querying the coin node, we
-      // search for pending transactions. For base assets with history,
-      // we'll fall back to the `TxLog` since this also has a knowledge
-      // of which transactions are currently in pending.
-      tag: 'pending',
+      tag,
       useAbsoluteNonce: useAbsoluteBalanceAndNonce,
     })
   }

package/src/custom-fees.js

@@ -51,7 +51,7 @@ export const createCustomFeesApi = ({ baseAsset }) => {
     },
     unit: 'gwei/gas',
     feeUnitPriceToNumber: (feeNumberUnit) => feeNumberUnit.toNumber(Gwei),
-    numberToFeeUnitPrice: (value) => new NumberUnit(value, Gwei),
+    numberToFeeUnitPrice: (value) => NumberUnit.create(value, Gwei),
     isEnabled: ({ feeData }) => Boolean(feeData.rbfEnabled),
   }
 }

package/src/get-balances.js

@@ -5,66 +5,8 @@ import {
   getUnconfirmedSentBalance,
 } from '@exodus/asset-lib'
 import assert from 'minimalistic-assert'
-import ms from 'ms'
-
-const DEFAULT_CANONICAL_ABSOLUTE_BALANCE_SEARCH_DEPTH = ms('5m')
-
-// Defines whether a `Tx` is an absolute balance
-// node that can be sorted in terms of transaction
-// ordering.
-//
-export const isCanonicalAbsoluteBalanceTx = (tx) =>
-  Boolean(
-    tx?.data?.balanceChange &&
-      typeof tx.data.blockNumber === 'number' &&
-      typeof tx.data.transactionIndex === 'number'
-  )
-
-// Attempts to find the most recent `absoluteBalance` Tx for
-// a given `txLog`.
-//
-// NOTE: Returns `null` if nothing is found.
-// NOTE: Uses `tx.data.blockNumber` and `tx.data.transactionIndex`,
-//       which are not guaranteed to exist in older transaction
-//       histories.
-export const getLatestCanonicalAbsoluteBalanceTx = ({
-  // Due to nondeterministic sorting for records in close
-  // proximity to one-another on high TPS chains, the
-  // order of the `reversedTxLog` cannot be trusted to be
-  // exactly precise since two consecutive blocks may share
-  // the same timestamp. Therefore, when finding an absolute
-  // balance node, we use the`searchDepthMs` to take into
-  // account extra nodes chronologically deeper than what we
-  // presume to be the latest to make sure we resolve to the
-  // correct node.
-  searchDepthMs = DEFAULT_CANONICAL_ABSOLUTE_BALANCE_SEARCH_DEPTH,
-  reversedTxLog,
-}) => {
-  assert(reversedTxLog, 'expected reversedTxLog')
-
-  let latest = null
-
-  for (const tx of reversedTxLog) {
-    if (latest) {
-      const diff = +latest.date - +tx.date
-
-      if (diff >= searchDepthMs) break
-    }
 
-    if (!isCanonicalAbsoluteBalanceTx(tx)) continue
-
-    if (
-      !latest ||
-      tx.data.blockNumber > latest.data.blockNumber ||
-      (tx.data.blockNumber === latest.data.blockNumber &&
-        tx.data.transactionIndex > latest.data.transactionIndex)
-    ) {
-      latest = tx
-    }
-  }
-
-  return latest
-}
+import { getLatestCanonicalAbsoluteBalanceTx } from './tx-log/clarity-utils/index.js'
 
 /**
  * TODO: Balance model gaps for EVM staking assets

package/src/tx-log/clarity-utils/absolute.js

@@ -0,0 +1,92 @@
+import assert from 'minimalistic-assert'
+import ms from 'ms'
+
+const DEFAULT_CANONICAL_ABSOLUTE_TX_SEARCH_DEPTH = ms('5m')
+
+const ABSOLUTE_FIELD_NAME_BALANCE_CHANGE = 'balanceChange'
+const ABSOLUTE_FIELD_NAME_NONCE_CHANGE = 'nonceChange'
+
+const ABSOLUTE_BALANCE_FIELDS = new Set([
+  ABSOLUTE_FIELD_NAME_BALANCE_CHANGE,
+  ABSOLUTE_FIELD_NAME_NONCE_CHANGE,
+])
+
+// Defines whether a `Tx` is an absolute balance
+// node that can be sorted in terms of transaction
+// ordering.
+//
+const isCanonicalAbsoluteTx = (tx, fieldName) => {
+  assert(ABSOLUTE_BALANCE_FIELDS.has(fieldName), `unsupported fieldName, "${fieldName}"`)
+
+  return Boolean(
+    tx?.data?.[fieldName] &&
+      typeof tx.data.blockNumber === 'number' &&
+      typeof tx.data.transactionIndex === 'number'
+  )
+}
+
+export const isCanonicalAbsoluteBalanceTx = (tx) =>
+  isCanonicalAbsoluteTx(tx, ABSOLUTE_FIELD_NAME_BALANCE_CHANGE)
+export const isCanonicalAbsoluteNonceTx = (tx) =>
+  isCanonicalAbsoluteTx(tx, ABSOLUTE_FIELD_NAME_NONCE_CHANGE)
+
+// Attempts to find the most recent absolute Tx for a given
+// `txLog`.
+//
+// NOTE: Returns `null` if nothing is found.
+// NOTE: Uses `tx.data.blockNumber` and `tx.data.transactionIndex`,
+//       which are not guaranteed to exist in older transaction
+//       histories.
+const getLatestCanonicalAbsoluteTx = ({
+  // Due to nondeterministic sorting for records in close
+  // proximity to one-another on high TPS chains, the
+  // order of the `reversedTxLog` cannot be trusted to be
+  // exactly precise since two consecutive blocks may share
+  // the same timestamp. Therefore, when finding an absolute
+  // balance node, we use the`searchDepthMs` to take into
+  // account extra nodes chronologically deeper than what we
+  // presume to be the latest to make sure we resolve to the
+  // correct node.
+  searchDepthMs = DEFAULT_CANONICAL_ABSOLUTE_TX_SEARCH_DEPTH,
+  reversedTxLog,
+  fieldName,
+}) => {
+  assert(reversedTxLog, 'expected reversedTxLog')
+
+  let latest = null
+
+  for (const tx of reversedTxLog) {
+    if (latest) {
+      const diff = +latest.date - +tx.date
+
+      if (diff >= searchDepthMs) break
+    }
+
+    if (!isCanonicalAbsoluteTx(tx, fieldName)) continue
+
+    if (
+      !latest ||
+      tx.data.blockNumber > latest.data.blockNumber ||
+      (tx.data.blockNumber === latest.data.blockNumber &&
+        tx.data.transactionIndex > latest.data.transactionIndex)
+    ) {
+      latest = tx
+    }
+  }
+
+  return latest
+}
+
+export const getLatestCanonicalAbsoluteBalanceTx = ({ searchDepthMs, reversedTxLog }) =>
+  getLatestCanonicalAbsoluteTx({
+    searchDepthMs,
+    reversedTxLog,
+    fieldName: ABSOLUTE_FIELD_NAME_BALANCE_CHANGE,
+  })
+
+export const getLatestCanonicalAbsoluteNonceTx = ({ searchDepthMs, reversedTxLog }) =>
+  getLatestCanonicalAbsoluteTx({
+    searchDepthMs,
+    reversedTxLog,
+    fieldName: ABSOLUTE_FIELD_NAME_NONCE_CHANGE,
+  })

package/src/tx-log/clarity-utils/index.js

@@ -1,2 +1,8 @@
 export { default as getLogItemsFromServerTx } from './get-log-items-from-server-tx.js'
 export { default as filterEffects } from './filter-effects.js'
+export {
+  isCanonicalAbsoluteBalanceTx,
+  isCanonicalAbsoluteNonceTx,
+  getLatestCanonicalAbsoluteBalanceTx,
+  getLatestCanonicalAbsoluteNonceTx,
+} from './absolute.js'

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

@@ -1,44 +1,75 @@
+import assert from 'minimalistic-assert'
+
 import { getNonce } from '../eth-like-util.js'
+import { getLatestCanonicalAbsoluteNonceTx } from '../tx-log/clarity-utils/absolute.js'
+
+export const BLOCK_TAG_LATEST = 'latest'
+export const BLOCK_TAG_PENDING = 'pending'
+
+const VALID_BLOCK_TAGS = new Set([BLOCK_TAG_LATEST, BLOCK_TAG_PENDING])
+
+// NOTE: We do not yet support tags at arbitrary block heights.
+const assertValidBlockTag = (tag) => assert(VALID_BLOCK_TAGS.has(tag), `invalid tag "${tag}"`)
 
 export const resolveNonce = async ({
   asset,
   forceFromNode,
   fromAddress,
-  providedNonce,
   txLog = [],
-  triedNonce,
-  tag = 'latest', // use 'pending' for unconfirmed txs
+  tag = BLOCK_TAG_LATEST,
   useAbsoluteNonce,
 }) => {
+  assertValidBlockTag(tag)
+
   const nonceFromNode =
     asset.baseAsset?.api?.features?.noHistory || forceFromNode
       ? await getNonce({ asset: asset.baseAsset, address: fromAddress, tag })
       : 0
 
-  const nonceFromLog = getNonceFromTxLog({ txLog, useAbsoluteNonce })
+  const nonceFromLog = getNonceFromTxLog({ txLog, useAbsoluteNonce, tag })
+
+  return Math.max(nonceFromNode, nonceFromLog)
+}
+
+const getLatestTxWithNonceChange = ({ reversedTxLog }) => {
+  assert(reversedTxLog, 'expected reversedTxLog')
+
+  const maybeLatestAbsoluteNonceTx = getLatestCanonicalAbsoluteNonceTx({
+    reversedTxLog,
+  })
 
-  return Math.max(
-    nonceFromNode,
-    nonceFromLog,
-    providedNonce ?? 0,
-    triedNonce === undefined ? 0 : triedNonce + 1
-  )
+  if (maybeLatestAbsoluteNonceTx) return maybeLatestAbsoluteNonceTx
+
+  for (const tx of reversedTxLog) {
+    if (tx.data.nonceChange) {
+      return tx
+    }
+  }
 }
 
-export const getNonceFromTxLog = ({ txLog, useAbsoluteNonce }) => {
+const getNonceFromTxLog = ({ txLog, useAbsoluteNonce, tag }) => {
   let absoluteNonce = 0
+
   if (useAbsoluteNonce) {
     const reversedTxLog = txLog.reverse()
-    for (const tx of reversedTxLog) {
-      if (tx.data.nonceChange) {
-        absoluteNonce = parseInt(tx.data.nonceChange.to, 10)
-        break
-      }
+    const maybeLatestTxWithNonceChange = getLatestTxWithNonceChange({ reversedTxLog })
+
+    if (maybeLatestTxWithNonceChange) {
+      // NOTE: This is the latest nonce currently confirmed by
+      //       Clarity, which lags behind `CLARITY_MIN_CONFIRMS`
+      //       depth:
+      //
+      //       https://github.com/ExodusMovement/clarity/blob/4a6ea30fce33246d1ef1440e61b0a84b876900d6/deployment/eth-clarity-indexer/values.yaml#L34
+      absoluteNonce = parseInt(maybeLatestTxWithNonceChange.data.nonceChange.to, 10)
     }
   }
 
   const nonceFromLog = [...txLog]
     .filter((tx) => tx.sent && !tx.dropped && tx.data.nonce != null)
+    // NOTE: If we're only considering the `'latest'` block `tag`,
+    //       then we should not take into account unconfirmed
+    //       transactions when computing the `nonce`.
+    .filter((tx) => tag !== BLOCK_TAG_LATEST || !tx.pending)
     .reduce((nonce, tx) => Math.max(tx.data.nonce + 1, nonce), 0)
 
   return Math.max(absoluteNonce, nonceFromLog)

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

@@ -83,15 +83,22 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
         })
       } else if (nonceTooLowErr && !unsignedTx.txMeta.isHardware) {
         console.info('trying to send again...') // inject logger factory from platform
+
         // let's try to fix the nonce issue
-        const newNonce = await baseAsset.getNonce({
+        let newNonce = await baseAsset.getNonce({
           asset,
           fromAddress,
           walletAccount,
-          triedNonce: parsedTx.nonce,
           forceFromNode: true,
         })
 
+        // TODO: We should only do this for non-replacement transactions.
+        const triedNonce = parsedTx.nonce
+
+        if (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`: