@exodus/ethereum-api 8.76.1 → 8.76.2

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.76.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.1...@exodus/ethereum-api@8.76.2) (2026-05-27)
+
+
+### Bug Fixes
+
+
+* fix(ethereum-api): persist rawCoinAmount in tx-log monitor readers (#8131)
+
+
+
 ## [8.76.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.0...@exodus/ethereum-api@8.76.1) (2026-05-26)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.76.1",
+  "version": "8.76.2",
   "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",
@@ -70,5 +70,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "50c5568a3fb1663b61344b18a044ebc69bfd45f0"
+  "gitHead": "6c398eaf7bcaecf41b720833f1dae5b8c56b3d57"
 }

package/src/tx-create.js

@@ -257,14 +257,29 @@ const createBumpUnsignedTx = async ({
     }
   }
 
-  const toAddress = (replacedTokenTx || replacedTx).to
+  const sourceTx = replacedTokenTx || replacedTx
+  const toAddress = sourceTx.to
+
+  // For self-sends `coinAmount` is `0` (correct for balance accounting, the
+  // wallet's net delta really is zero), so we can't reconstruct the on-chain
+  // value from it. Recover from `data.rawCoinAmount`, which the tx-log
+  // writers persist alongside `coinAmount` for exactly this purpose.
+  if (sourceTx.selfSend && !sourceTx.data?.rawCoinAmount) {
+    throw new Error(
+      `Cannot bump self-send transaction ${bumpTxId}: original transfer amount is unrecoverable from the tx log (data.rawCoinAmount missing). Re-broadcast the send with a higher fee instead.`
+    )
+  }
 
-  const amount = (replacedTokenTx || replacedTx).coinAmount.negate()
+  const amount = sourceTx.data?.rawCoinAmount
+    ? asset.currency.baseUnit(sourceTx.data.rawCoinAmount)
+    : sourceTx.coinAmount.negate()
 
   const txValue = assertValidTxValue({
     asset,
     amount,
-    txValue: replacedTx.coinAmount.negate(),
+    txValue: replacedTx.data?.rawCoinAmount
+      ? baseAsset.currency.baseUnit(replacedTx.data.rawCoinAmount)
+      : replacedTx.coinAmount.negate(),
   })
 
   const isDuplex = Boolean(replacedTokenTx && txValue.gt(baseAsset.currency.ZERO))

package/src/tx-log/clarity-utils/get-log-items-from-server-tx.js

@@ -2,6 +2,7 @@ import lodash from 'lodash'
 
 import { getWalletUpdates } from '../monitor-utils/get-balance-updates.js'
 import getFeeAmount from '../monitor-utils/get-fee-amount.js'
+import getRawTransferAmount from '../monitor-utils/get-raw-transfer-amount.js'
 import getTransfersByTokenName from '../monitor-utils/get-transfers-by-token-name.js'
 import getValueOfTransfers from '../monitor-utils/get-value-of-transfers.js'
 import isConfirmedServerTx from '../monitor-utils/is-confirmed-server-tx.js'
@@ -62,6 +63,18 @@ export default function getLogItemsFromServerTx({
 
     if (shouldAttachTx) {
       const coinAmount = getValueOfTransfers(ourWalletAddress, asset, ethereumTransfers)
+      // `rawCoinAmount` mirrors the field written by `getOptimisticTxLogEffects`
+      // and is consumed by the bump path (`tx-create.js`) to recover the
+      // user-signed on-chain `value` when accelerating a self-send (where
+      // `coinAmount` is zero). For the base-asset entry the raw amount is the
+      // top-level `value` field of the tx itself, not the sum of internal
+      // transfers — that's what the user signed and what we must restore on
+      // bump.
+      const rawCoinAmount = getRawTransferAmount({
+        ourWalletAddress,
+        asset,
+        transfers: [serverTx],
+      }).toBaseString()
       const selfSend = isSelfSendTx({
         coinAmount,
         ourWalletWasSender,
@@ -90,6 +103,7 @@ export default function getLogItemsFromServerTx({
             data,
             nonce,
             gasLimit,
+            rawCoinAmount,
             balanceChange: baseBalanceUpdate,
             nonceChange: nonceUpdate,
             ...methodId,
@@ -130,6 +144,14 @@ export default function getLogItemsFromServerTx({
 
     const tokenTransferToAddress = tryFindExternalRecipient(tokenTransfers, ourWalletAddress)
     const coinAmount = getValueOfTransfers(ourWalletAddress, token, tokenTransfers)
+    // See base-entry comment above; for token entries the raw amount is the
+    // absolute total tokens our wallet moved in this tx (sum of outgoing, or
+    // incoming for receive-only entries).
+    const rawCoinAmount = getRawTransferAmount({
+      ourWalletAddress,
+      asset: token,
+      transfers: tokenTransfers,
+    }).toBaseString()
 
     const tokenFromAddresses = lodash.uniq(
       tokenTransfers.filter(({ to }) => to === ourWalletAddress).map(({ from }) => from)
@@ -158,6 +180,7 @@ export default function getLogItemsFromServerTx({
           data,
           nonce,
           gasLimit,
+          rawCoinAmount,
           balanceChange,
           ...methodId,
           ...(isFiniteInteger(blockNumber) ? { blockNumber } : null),

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

@@ -158,6 +158,7 @@ export const getOptimisticTxLogEffects = async ({
       txs: [
         {
           ...sharedProps,
+          data: { ...sharedProps.data, rawCoinAmount: amount.abs().toBaseString() },
           coinAmount: selfSend ? asset.currency.ZERO : amount.abs().negate(),
           coinName: asset.name,
           currencies: {
@@ -173,6 +174,7 @@ export const getOptimisticTxLogEffects = async ({
       txs: [
         {
           ...sharedProps,
+          data: { ...sharedProps.data, rawCoinAmount: txValue.abs().toBaseString() },
           coinAmount: selfSend ? baseAsset.currency.ZERO : txValue.abs().negate(),
           coinName: baseAsset.name,
           currencies: {

package/src/tx-log/monitor-utils/get-log-items-from-server-tx.js

@@ -2,6 +2,7 @@ import lodash from 'lodash'
 
 import getFeeAmount from './get-fee-amount.js'
 import getNamesOfTokensTransferredByServerTx from './get-names-of-tokens-transferred-by-server-tx.js'
+import getRawTransferAmount from './get-raw-transfer-amount.js'
 import getTransfersByTokenName from './get-transfers-by-token-name.js'
 import getValueOfTransfers from './get-value-of-transfers.js'
 import isConfirmedServerTx from './is-confirmed-server-tx.js'
@@ -50,6 +51,18 @@ export default function getLogItemsFromServerTx({
 
     if (sendingTransferPresent || receivingTransferPresent || nftTransferPresent) {
       const coinAmount = getValueOfTransfers(ourWalletAddress, asset, ethereumTransfers)
+      // `rawCoinAmount` mirrors the field written by `getOptimisticTxLogEffects`
+      // and is consumed by the bump path (`tx-create.js`) to recover the
+      // user-signed on-chain `value` when accelerating a self-send (where
+      // `coinAmount` is zero). For the base-asset entry the raw amount is the
+      // top-level `value` field of the tx itself, not the sum of internal
+      // transfers — that's what the user signed and what we must restore on
+      // bump.
+      const rawCoinAmount = getRawTransferAmount({
+        ourWalletAddress,
+        asset,
+        transfers: [serverTx],
+      }).toBaseString()
       const selfSend = isSelfSendTx({
         coinAmount,
         ourWalletWasSender,
@@ -78,6 +91,7 @@ export default function getLogItemsFromServerTx({
             data,
             nonce,
             gasLimit,
+            rawCoinAmount,
             ...methodId,
             ...(sent?.length > 0 ? { sent } : undefined),
           },
@@ -108,11 +122,25 @@ export default function getLogItemsFromServerTx({
 
     const token = assets[tokenName]
     const tokenTransferToAddress = tryFindExternalRecipient(tokenTransfers, ourWalletAddress)
-    const coinAmount = getValueOfTransfers(
+    // Transfers from this reader's server source are tagged with
+    // `events: true` once the tx is included in a block (event-log derived)
+    // and `events: false` while still pending (tx-data derived). Only one
+    // flavor is real for a given lifecycle state; filtering avoids
+    // double-counting if both ever coexist for the same transfer. Both
+    // `coinAmount` and `rawCoinAmount` must see the same set so they stay
+    // consistent.
+    const filteredTokenTransfers = lodash.filter(tokenTransfers, {
+      events: confirmations > 0,
+    })
+    const coinAmount = getValueOfTransfers(ourWalletAddress, token, filteredTokenTransfers)
+    // See base-entry comment above; for token entries the raw amount is the
+    // absolute total tokens our wallet moved in this tx (sum of outgoing, or
+    // incoming for receive-only entries).
+    const rawCoinAmount = getRawTransferAmount({
       ourWalletAddress,
-      token,
-      lodash.filter(tokenTransfers, { events: confirmations > 0 })
-    )
+      asset: token,
+      transfers: filteredTokenTransfers,
+    }).toBaseString()
     const tokenFromAddresses = lodash.uniq(
       tokenTransfers.filter(({ to }) => to === ourWalletAddress).map(({ from }) => from)
     )
@@ -136,7 +164,7 @@ export default function getLogItemsFromServerTx({
         ...logItemCommonProperties,
         coinAmount,
         coinName: tokenName,
-        data: { data, nonce, gasLimit, ...methodId },
+        data: { data, nonce, gasLimit, rawCoinAmount, ...methodId },
         ...(isConsideredSent
           ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: asset.feeAsset.name }
           : { from: tokenFromAddresses }),

package/src/tx-log/monitor-utils/get-raw-transfer-amount.js

@@ -0,0 +1,29 @@
+// Returns the absolute raw transferred amount for `ourWalletAddress`, in
+// `asset` base units, as a NumberUnit. Unlike `getValueOfTransfers` (which
+// returns the signed net delta), this preserves the raw transfer value even
+// when sender and receiver net to zero — e.g. self-sends. Used by tx-log
+// writers to persist `data.rawCoinAmount` so the bump path can reconstruct
+// the original on-chain value when accelerating a self-send.
+//
+// Each transfer is expected to have the shape `{ from, to, value }`. For the
+// base-asset entry, pass `[serverTx]` (the tx itself has the same shape at
+// its top level); for token entries, pass the array of token transfers for
+// that token.
+//
+// Outgoing transfers (from === ourWalletAddress) take precedence: when our
+// wallet sent anything, the raw amount is the sum of what we sent. We fall
+// back to incoming so receiver-only entries still report a non-zero raw
+// amount for consistency, even though the bump path only consults it on the
+// sender side.
+
+export default function getRawTransferAmount({ ourWalletAddress, asset, transfers }) {
+  const outgoing = transfers
+    .filter(({ from }) => from === ourWalletAddress)
+    .reduce((sum, { value }) => sum.add(asset.currency.baseUnit(value)), asset.currency.ZERO)
+
+  if (!outgoing.isZero) return outgoing
+
+  return transfers
+    .filter(({ to }) => to === ourWalletAddress)
+    .reduce((sum, { value }) => sum.add(asset.currency.baseUnit(value)), asset.currency.ZERO)
+}