@exodus/ethereum-api 8.62.1 → 8.62.3

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.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)
+
+
+### Bug Fixes
+
+
+* fix: when using absolute balances, ensure we process the most recent record (#7127)
+
+
+
 ## [8.62.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.62.0...@exodus/ethereum-api@8.62.1) (2026-01-01)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.62.1",
+  "version": "8.62.3",
   "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": "18e9c9aa3976c189bbba24d8cad7c413ddec336d"
+  "gitHead": "d1618b4c41ccde490c3e4aaa8dd239c0c5393a7b"
 }

package/src/get-balances.js

@@ -5,6 +5,66 @@ 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
+}
 
 /**
  * TODO: Balance model gaps for EVM staking assets
@@ -32,7 +92,6 @@ import assert from 'minimalistic-assert'
  *
  * See: docs/balances-model.md for the intended balance model spec.
  */
-
 export const getAbsoluteBalance = ({ asset, txLog }) => {
   assert(asset, 'asset is required')
   assert(txLog, 'txLog is required')
@@ -41,13 +100,26 @@ export const getAbsoluteBalance = ({ asset, txLog }) => {
     return asset.currency.ZERO
   }
 
+  // NOTE: We reverse the `txLog` to prioritize the handling
+  //       of the most recent transactions first. The reason
+  //       we do this is to terminate early if we find an
+  //       absolute balance node.
+  const reversedTxLog = txLog.reverse()
+
+  const maybeLatestAbsoluteBalanceTx = getLatestCanonicalAbsoluteBalanceTx({ reversedTxLog })
+
   let balance = asset.currency.ZERO
   let hasAbsoluteBalance = false
 
-  const reversedTxLog = txLog.reverse()
-
   for (const tx of reversedTxLog) {
     if (tx.data.balanceChange) {
+      // If we are aware of the existence of the most
+      // recent absolute balance, then we can ignore
+      // any competing instances.
+      if (maybeLatestAbsoluteBalanceTx && tx.txId !== maybeLatestAbsoluteBalanceTx.txId) {
+        continue
+      }
+
       hasAbsoluteBalance = true
       balance = balance.add(asset.currency.baseUnit(tx.data.balanceChange.to))
 

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 }) {
@@ -510,7 +533,6 @@ export function createEthereumStakingService({
       walletAccount,
       address: to,
       amount: amount || asset.currency.ZERO,
-      shouldLog: true,
       txInput,
       gasPrice,
       gasLimit,

package/src/staking/matic/service.js

@@ -430,7 +430,6 @@ export function createPolygonStakingService({
       walletAccount,
       address: to,
       amount: asset.currency.ZERO,
-      shouldLog: true,
       txInput,
       gasPrice,
       gasLimit,

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,
@@ -24,6 +25,8 @@ export default function getLogItemsFromServerTx({
   const txId = serverTx.hash
   const nonce = parseInt(serverTx.nonce, 10)
   const gasLimit = parseInt(serverTx.gas, 10)
+  const blockNumber = serverTx.blockNumber
+  const transactionIndex = parseInt(serverTx.transactionIndex, 10)
   const error = serverTx.error || (serverTx.status === '0' ? 'Failed' : null)
   const feeAmount = getFeeAmount(asset, serverTx)
   const internalTransfers = filterEffects(serverTx.effects, 'internal') || []
@@ -91,6 +94,8 @@ export default function getLogItemsFromServerTx({
             nonceChange: nonceUpdate,
             ...methodId,
             ...(sent?.length > 0 ? { sent } : undefined),
+            ...(isFiniteInteger(blockNumber) ? { blockNumber } : null),
+            ...(isFiniteInteger(transactionIndex) ? { transactionIndex } : null),
           },
           ...(ourWalletWasSender
             ? { from: [], to: toAddress, feeAmount, feeCoinName: asset.feeAsset.name }
@@ -149,7 +154,15 @@ export default function getLogItemsFromServerTx({
         ...logItemCommonProperties,
         coinAmount,
         coinName: tokenName,
-        data: { data, nonce, gasLimit, balanceChange, ...methodId },
+        data: {
+          data,
+          nonce,
+          gasLimit,
+          balanceChange,
+          ...methodId,
+          ...(isFiniteInteger(blockNumber) ? { blockNumber } : null),
+          ...(isFiniteInteger(transactionIndex) ? { transactionIndex } : null),
+        },
         ...(isConsideredSent
           ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: token.feeAsset.name }
           : { from: tokenFromAddresses }),

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)
 }