@exodus/ethereum-api 8.62.2 → 8.62.4

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.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)
+
+
+### Bug Fixes
+
+
+* fix: enfore sanity checking about clarity string numerics for canonical tx props (#7262)
+
+
+
 ## [8.62.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.62.1...@exodus/ethereum-api@8.62.2) (2026-01-07)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.62.2",
+  "version": "8.62.4",
   "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": "be4898d14d842c79dfcc327501c390dfaf56157b"
+  "gitHead": "138043f1b7f97c9acc7b7b89b0561f26b80757d5"
 }

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/staking/ethereum/service.js

@@ -23,6 +23,14 @@ const MINIMUM_DELEGATION_GAS_LIMIT = 180_000
 
 const EXTRA_GAS_LIMIT = 20_000 // extra gas Limit to prevent tx failing if something change on pool state (till tx is in mempool)
 
+// Estimates based on real life transaction averages.
+// Overestimated averages by 4x.
+const STAKING_OPERATION_FALLBACK_FEE_ESTIMATES = {
+  delegate: '0.00081512',
+  undelegate: '0.000554',
+  claimUndelegatedBalance: '0.0001800912',
+}
+
 const getStakingApi = memoize(
   (asset) => new EthereumStaking(asset, undefined, asset.server),
   (asset) => asset.name
@@ -346,61 +354,76 @@ export function createEthereumStakingService({
 
   async function estimateDelegateOperation({ walletAccount, operation, args, feeData }) {
     const asset = await getAsset(assetName)
-    const staking = getStakingApi(asset)
-
-    const requestedAmount = args.amount
-      ? amountToCurrency({ asset, amount: args.amount })
-      : asset.currency.ZERO
 
-    let delegatorAddress
-    ;({ delegatorAddress, feeData } = await getTransactionProps({ feeData, walletAccount }))
-
-    if (operation === 'undelegate') {
-      return estimateUndelegate({ walletAccount, amount: requestedAmount, feeData })
-    }
+    try {
+      const staking = getStakingApi(asset)
 
-    const NAMING_MAP = {
-      delegate: 'stake',
-      undelegate: 'unstake',
-      claimUndelegatedBalance: 'claimWithdrawRequest',
-    }
+      const requestedAmount = args.amount
+        ? amountToCurrency({ asset, amount: args.amount })
+        : asset.currency.ZERO
 
-    const delegateOperation = staking[NAMING_MAP[operation]].bind(staking)
+      let delegatorAddress
+      ;({ delegatorAddress, feeData } = await getTransactionProps({ feeData, walletAccount }))
 
-    if (!delegateOperation) throw new Error('Invalid staking operation')
+      if (operation === 'undelegate') {
+        return estimateUndelegate({ walletAccount, amount: requestedAmount, feeData })
+      }
 
-    const { amount, data } = await delegateOperation({ ...args, amount: requestedAmount })
+      const NAMING_MAP = {
+        delegate: 'stake',
+        undelegate: 'unstake',
+        claimUndelegatedBalance: 'claimWithdrawRequest',
+      }
 
-    const { fee } = await (operation === 'claimUndelegatedBalance'
-      ? estimateTxFee({
-          from: delegatorAddress,
-          to: staking.accountingAddress,
-          amount,
-          txInput: data,
-          feeData,
-        })
-      : // The `gasUsed` of a delegation transaction can vary
-        // significantly depending upon whether it will result
-        // in the activation of new slots (i.e. validator creation).
-        //
-        // This can result in transaction `revert` due to slippage
-        // from incompatible transaction ordering.
-        //
-        // To mitigate this, we:
-        // 1. Simulate the delegation at an amplified deposit amount
-        //    to show enhanced fees close to a proximity buffer.
-        // 2. Originate the transaction from the WETH contract,
-        //    which guarantees deep native ether liquidity which
-        //    exceeds any rational user deposit.
-        estimateTxFee({
-          from: WETH9_ADDRESS,
-          to: staking.poolAddress,
-          amount: amount.add(asset.currency.defaultUnit(SLOT_ACTIVATION_PROXIMITY_ETH)),
-          txInput: data,
-          feeData,
-        }))
+      const delegateOperation = staking[NAMING_MAP[operation]].bind(staking)
+
+      if (!delegateOperation) throw new Error('Invalid staking operation')
+
+      const { amount, data } = await delegateOperation({ ...args, amount: requestedAmount })
+
+      const { fee } = await (operation === 'claimUndelegatedBalance'
+        ? estimateTxFee({
+            from: delegatorAddress,
+            to: staking.accountingAddress,
+            amount,
+            txInput: data,
+            feeData,
+          })
+        : // The `gasUsed` of a delegation transaction can vary
+          // significantly depending upon whether it will result
+          // in the activation of new slots (i.e. validator creation).
+          //
+          // This can result in transaction `revert` due to slippage
+          // from incompatible transaction ordering.
+          //
+          // To mitigate this, we:
+          // 1. Simulate the delegation at an amplified deposit amount
+          //    to show enhanced fees close to a proximity buffer.
+          // 2. Originate the transaction from the WETH contract,
+          //    which guarantees deep native ether liquidity which
+          //    exceeds any rational user deposit.
+          estimateTxFee({
+            from: WETH9_ADDRESS,
+            to: staking.poolAddress,
+            amount: amount.add(asset.currency.defaultUnit(SLOT_ACTIVATION_PROXIMITY_ETH)),
+            txInput: data,
+            feeData,
+          }))
+
+      return fee
+    } catch (error) {
+      const fallbackFee = STAKING_OPERATION_FALLBACK_FEE_ESTIMATES[operation]
+      if (fallbackFee) {
+        console.warn(
+          `ETH staking fee estimation failed for '${operation}', using fallback:`,
+          error.message
+        )
+        return asset.currency.defaultUnit(fallbackFee)
+      }
 
-    return fee
+      error.message = `StakingFeeEstimationError: Failed to estimate fee for '${operation}' (and no fallback configured). Cause: ${error.message}`
+      throw error
+    }
   }
 
   async function estimateTxFee({ from, to, amount, txInput, feeData }) {

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/get-log-items-from-server-tx.js

@@ -9,9 +9,10 @@ import isConsideredSentTokenTx from '../monitor-utils/is-considered-sent-token-t
 import filterEffects from './filter-effects.js'
 import getNamesOfTokensTransferredByServerTx from './get-names-of-tokens-transferred-by-server-tx.js'
 
-// This function takes a server transaction object fetched from magnifier,
-// and transforms it into Tx models to update the exodus state.
+const isFiniteInteger = (n) => Number.isFinite(n) && Number.isInteger(n)
 
+// This function takes a server transaction object fetched from clarity,
+// and transforms it into Tx models to update the exodus state.
 export default function getLogItemsFromServerTx({
   serverTx,
   asset,
@@ -93,8 +94,8 @@ export default function getLogItemsFromServerTx({
             nonceChange: nonceUpdate,
             ...methodId,
             ...(sent?.length > 0 ? { sent } : undefined),
-            blockNumber,
-            transactionIndex,
+            ...(isFiniteInteger(blockNumber) ? { blockNumber } : null),
+            ...(isFiniteInteger(transactionIndex) ? { transactionIndex } : null),
           },
           ...(ourWalletWasSender
             ? { from: [], to: toAddress, feeAmount, feeCoinName: asset.feeAsset.name }
@@ -159,8 +160,8 @@ export default function getLogItemsFromServerTx({
           gasLimit,
           balanceChange,
           ...methodId,
-          blockNumber,
-          transactionIndex,
+          ...(isFiniteInteger(blockNumber) ? { blockNumber } : null),
+          ...(isFiniteInteger(transactionIndex) ? { transactionIndex } : null),
         },
         ...(isConsideredSent
           ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: token.feeAsset.name }

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-log/monitor-utils/get-value-of-transfers.js

@@ -4,19 +4,17 @@
 // array is a transfer for that asset. If we sent more than we received, the value is negative.
 
 export default function getValueOfTransfers(ourWalletAddress, asset, transfers) {
-  return transfers
-    .reduce((balanceDifference, { from, to, value }) => {
-      const transferAmount = asset.currency.baseUnit(value)
+  return transfers.reduce((balanceDifference, { from, to, value }) => {
+    const transferAmount = asset.currency.baseUnit(value)
 
-      if (from === ourWalletAddress) {
-        balanceDifference = balanceDifference.sub(transferAmount)
-      }
+    if (from === ourWalletAddress) {
+      balanceDifference = balanceDifference.sub(transferAmount)
+    }
 
-      if (to === ourWalletAddress) {
-        balanceDifference = balanceDifference.add(transferAmount)
-      }
+    if (to === ourWalletAddress) {
+      balanceDifference = balanceDifference.add(transferAmount)
+    }
 
-      return balanceDifference
-    }, asset.currency.ZERO)
-    .to(asset.ticker)
+    return balanceDifference
+  }, asset.currency.ZERO)
 }

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

@@ -1,4 +1,7 @@
+import assert from 'minimalistic-assert'
+
 import { getNonce } from '../eth-like-util.js'
+import { getLatestCanonicalAbsoluteNonceTx } from '../tx-log/clarity-utils/absolute.js'
 
 export const resolveNonce = async ({
   asset,
@@ -25,15 +28,31 @@ export const resolveNonce = async ({
   )
 }
 
+const getLatestTxWithNonceChange = ({ reversedTxLog }) => {
+  assert(reversedTxLog, 'expected reversedTxLog')
+
+  const maybeLatestAbsoluteNonceTx = getLatestCanonicalAbsoluteNonceTx({
+    reversedTxLog,
+  })
+
+  if (maybeLatestAbsoluteNonceTx) return maybeLatestAbsoluteNonceTx
+
+  for (const tx of reversedTxLog) {
+    if (tx.data.nonceChange) {
+      return tx
+    }
+  }
+}
+
 export const getNonceFromTxLog = ({ txLog, useAbsoluteNonce }) => {
   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) {
+      absoluteNonce = parseInt(maybeLatestTxWithNonceChange.data.nonceChange.to, 10)
     }
   }