@exodus/ethereum-api 8.74.1 → 8.75.1

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.75.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.75.0...@exodus/ethereum-api@8.75.1) (2026-05-19)
+
+
+### Bug Fixes
+
+
+* fix: use correct fromAddress for gasLimit multiplication (#8078)
+
+
+
+## [8.75.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.74.1...@exodus/ethereum-api@8.75.0) (2026-05-13)
+
+
+### Features
+
+
+* feat(ethereum): add no-history receive logs for portfolio transfers (#7967)
+
+
+### Bug Fixes
+
+
+* fix: stale truncated balances after new transaction (#7897)
+
+
+
 ## [8.74.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.74.0...@exodus/ethereum-api@8.74.1) (2026-05-12)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.74.1",
+  "version": "8.75.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",
@@ -23,13 +23,13 @@
   },
   "dependencies": {
     "@exodus/asset": "^2.0.4",
-    "@exodus/asset-lib": "^5.9.0",
+    "@exodus/asset-lib": "^5.9.1",
     "@exodus/assets": "^11.4.0",
     "@exodus/basic-utils": "^3.0.1",
     "@exodus/bip44-constants": "^195.0.0",
     "@exodus/crypto": "^1.0.0-rc.26",
     "@exodus/currency": "^6.0.1",
-    "@exodus/ethereum-lib": "^5.24.1",
+    "@exodus/ethereum-lib": "^5.24.2",
     "@exodus/ethereum-meta": "^2.9.1",
     "@exodus/ethereumholesky-meta": "^2.0.5",
     "@exodus/ethereumjs": "^1.11.0",
@@ -67,5 +67,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "7f184588091acba3b358e4af13783ee1e2bab4ba"
+  "gitHead": "ee5bf2d01055d8822c6421fa0ad4da84d4a33402"
 }

package/src/allowance/index.js

@@ -120,11 +120,9 @@ export const buildLegacyApproveTx = async ({
   const baseAsset = asset.baseAsset
 
   return {
-    asset: baseAsset.name,
-    receiver: {
-      address: unsignedTx.txData.to,
-      amount: buffer2currency({ asset: baseAsset, value: unsignedTx.txData.value }),
-    },
+    asset: baseAsset,
+    address: unsignedTx.txData.to,
+    amount: buffer2currency({ asset: baseAsset, value: unsignedTx.txData.value }),
     txInput: unsignedTx.txData.data,
     gasPrice: buffer2currency({ asset: baseAsset, value: unsignedTx.txData.gasPrice }),
     tipGasPrice: unsignedTx.txData.tipGasPrice
@@ -132,13 +130,12 @@ export const buildLegacyApproveTx = async ({
       : undefined,
     gasLimit: bufferToInt(unsignedTx.txData.gasLimit),
     fromAddress: unsignedTx.txMeta.fromAddress,
-    silent: true,
   }
 }
 
 // @deprecated use buildApproveTx instead
 export const createApprove =
-  ({ assetClientInterface, sendTx }) =>
+  ({ assetClientInterface } = Object.create(null)) =>
   async ({
     spenderAddress,
     asset,
@@ -164,7 +161,16 @@ export const createApprove =
         walletAccount,
       })
 
-      const txData = await sendTx({ walletAccount, ...approveTx, ...extras })
+      const { unsignedTx } = await asset.baseAsset.api.createTx({
+        walletAccount,
+        ...approveTx,
+        ...extras,
+      })
+      const txData = await asset.baseAsset.api.sendTx({
+        asset: asset.baseAsset,
+        walletAccount,
+        unsignedTx,
+      })
 
       if (!txData || !txData.txId) {
         throw new Error(`Failed to approve ${asset.displayTicker} - ${spenderAddress}`)
@@ -185,25 +191,20 @@ export const createApprove =
       walletAccount,
     })
 
-    const { txId, rawTx } = await assetClientInterface.signTransaction({
-      assetName: asset.baseAsset.name,
-      unsignedTx,
-      walletAccount,
-    })
+    const { txId } = await asset.baseAsset.api.sendTx({ asset, walletAccount, unsignedTx })
 
-    await asset.baseAsset.api.broadcastTx(rawTx.toString('hex'))
     return { txId }
   }
 
 const createSendApprovalAndWatchConfirmation =
-  ({ sendTx, watchTxConfirmation }) =>
+  ({ watchTxConfirmation }) =>
   async (data) => {
     // To change the approve amount you first have to reduce the addresses`
     // allowance to zero by calling `approve(_spender, 0)` if it is not
     // already 0 to mitigate the race condition described here:
     // see: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     // see: https://etherscan.io/address/0xdac17f958d2ee523a2206206994597c13d831ec7#code
-    const approve = createApprove({ sendTx })
+    const approve = createApprove()
     const { txId } = await approve(data)
     await watchTxConfirmation(
       { asset: data.asset.baseAsset.name, walletAccount: data.walletAccount },
@@ -215,11 +216,10 @@ const createSendApprovalAndWatchConfirmation =
   }
 
 export const createApproveSpendingTokens =
-  ({ sendTx, watchTxConfirmation }) =>
+  ({ watchTxConfirmation }) =>
   async (data) => {
     const txIds = []
     const sendApprovalAndWatchConfirmation = createSendApprovalAndWatchConfirmation({
-      sendTx,
       watchTxConfirmation,
     })
     if (ZERO_ALLOWANCE_ASSETS.includes(data.asset.name) && !data.approveAmount.isZero) {
@@ -235,7 +235,7 @@ export const createApproveSpendingTokens =
       data.gasLimit = Math.max(data.gasLimit || 0, APPROVAL_GAS_LIMIT)
     }
 
-    const tokenApprovalTxId = await sendApprovalAndWatchConfirmation({ ...data, sendTx })
+    const tokenApprovalTxId = await sendApprovalAndWatchConfirmation(data)
     txIds.push(tokenApprovalTxId)
 
     return txIds

package/src/create-asset-utils.js

@@ -12,7 +12,9 @@ import { ClarityMonitorV2 } from './tx-log/clarity-monitor-v2.js'
 import { ClarityTruncatedHistoryMonitor } from './tx-log/clarity-truncated-history-monitor.js'
 import { EthereumMonitor } from './tx-log/ethereum-monitor.js'
 import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor.js'
+import { getOptimisticTxLogEffects } from './tx-log/get-optimistic-txlog-effects.js'
 import { BLOCK_TAG_LATEST, BLOCK_TAG_PENDING, resolveNonce } from './tx-send/nonce-utils.js'
+import { signTx } from './tx-sign/index.js'
 
 // Determines the appropriate `monitorType`, `serverUrl` and `monitorInterval`
 // to use for a given config.
@@ -121,7 +123,126 @@ const broadcastPrivateBundleFactory =
     return null
   }
 
-export const createTransactionPrivacyFactory = ({ assetName, privacyRpcUrl }) => {
+const assertSendPrivateTxProps = ({ asset, unsignedTx, walletAccount }) => {
+  assert(asset, 'expected asset')
+  assert(unsignedTx, 'expected unsignedTx')
+  assert(walletAccount, 'expected walletAccount')
+}
+
+export const createTransactionPrivacyResult = ({
+  assetClientInterface,
+  broadcastPrivateBundle,
+  broadcastPrivateTx,
+  privacyServer,
+}) => {
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(typeof broadcastPrivateBundle === 'function')
+  assert(typeof broadcastPrivateTx === 'function')
+  assert(privacyServer, 'expected privacyServer')
+
+  const sendPrivateTx = async ({ asset, unsignedTx, walletAccount }) => {
+    assertSendPrivateTxProps({ asset, unsignedTx, walletAccount })
+
+    const { rawTx, txId } = await signTx({
+      asset,
+      assetClientInterface,
+      unsignedTx,
+      walletAccount,
+    })
+
+    await broadcastPrivateTx(rawTx.toString('hex'))
+
+    const fromAddress = unsignedTx.txMeta?.fromAddress
+    assert(typeof fromAddress === 'string', 'expected fromAddress')
+
+    const { nonce, optimisticTxLogEffects } = await getOptimisticTxLogEffects({
+      asset,
+      assetClientInterface,
+      fromAddress,
+      txId,
+      unsignedTx,
+      walletAccount,
+    })
+
+    for (const optimisticTxLogEffect of optimisticTxLogEffects) {
+      await assetClientInterface.updateTxLogAndNotify(optimisticTxLogEffect)
+    }
+
+    return { nonce, txId }
+  }
+
+  const sendPrivateBundle = async ({ unsignedTxBundle }) => {
+    assert(
+      Array.isArray(unsignedTxBundle) && unsignedTxBundle.length > 0,
+      'expected non-empty unsignedTxBundle'
+    )
+
+    unsignedTxBundle.forEach(assertSendPrivateTxProps)
+
+    const signTxResults = await Promise.all(
+      unsignedTxBundle.map(({ asset, unsignedTx, walletAccount }) =>
+        signTx({ assetClientInterface, asset, unsignedTx, walletAccount })
+      )
+    )
+
+    const maybeBundleResult = await broadcastPrivateBundle({
+      txs: signTxResults.map(({ rawTx }) => rawTx.toString('hex')),
+    })
+
+    const bundleHash = maybeBundleResult?.bundleHash || undefined
+
+    const getOptimisticTxLogEffectsResults = []
+
+    for (const [i, { txId }] of signTxResults.entries()) {
+      const { asset, unsignedTx, walletAccount } = unsignedTxBundle[i]
+
+      const fromAddress = unsignedTx.txMeta?.fromAddress
+      assert(typeof fromAddress === 'string', 'expected fromAddress')
+
+      void getOptimisticTxLogEffectsResults.push(
+        await getOptimisticTxLogEffects({
+          asset,
+          assetClientInterface,
+          fromAddress,
+          txId,
+          unsignedTx,
+          walletAccount,
+          // TODO: use consistent naming
+          bundleId: bundleHash,
+        })
+      )
+    }
+
+    const optimisticTxLogEffects = getOptimisticTxLogEffectsResults.flatMap(
+      ({ optimisticTxLogEffects }) => optimisticTxLogEffects
+    )
+
+    for (const optimisticTxLogEffect of optimisticTxLogEffects) {
+      await assetClientInterface.updateTxLogAndNotify(optimisticTxLogEffect)
+    }
+
+    return {
+      bundleHash,
+      txIds: signTxResults.map(({ txId }) => txId),
+    }
+  }
+
+  return {
+    broadcastPrivateBundle,
+    broadcastPrivateTx,
+    privacyServer,
+    sendPrivateTx,
+    sendPrivateBundle,
+  }
+}
+
+export const createTransactionPrivacyFactory = ({
+  assetClientInterface,
+  assetName,
+  privacyRpcUrl,
+}) => {
+  assert(assetClientInterface, 'expected assetClientInterface')
+
   if (!privacyRpcUrl) return Object.create(null)
 
   const privacyServer = createEvmServer({
@@ -130,11 +251,16 @@ export const createTransactionPrivacyFactory = ({ assetName, privacyRpcUrl }) =>
     monitorType: 'no-history',
   })
 
-  return {
-    broadcastPrivateBundle: broadcastPrivateBundleFactory({ privacyServer }),
-    broadcastPrivateTx: (...args) => privacyServer.sendRawTransaction(...args),
+  const broadcastPrivateBundle = broadcastPrivateBundleFactory({ privacyServer })
+
+  const broadcastPrivateTx = (...args) => privacyServer.sendRawTransaction(...args)
+
+  return createTransactionPrivacyResult({
+    assetClientInterface,
+    broadcastPrivateBundle,
+    broadcastPrivateTx,
     privacyServer,
-  }
+  })
 }
 
 export const createHistoryMonitorFactory = ({

package/src/create-asset.js

@@ -195,11 +195,17 @@ export const createAssetFactory = ({
       server,
     })
 
-    const { broadcastPrivateBundle, broadcastPrivateTx, privacyServer } =
-      createTransactionPrivacyFactory({
-        assetName: asset.name,
-        privacyRpcUrl,
-      })
+    const {
+      broadcastPrivateBundle,
+      broadcastPrivateTx,
+      privacyServer,
+      sendPrivateTx,
+      sendPrivateBundle,
+    } = createTransactionPrivacyFactory({
+      assetClientInterface,
+      assetName: asset.name,
+      privacyRpcUrl,
+    })
 
     const features = {
       accountState: true,
@@ -354,16 +360,18 @@ export const createAssetFactory = ({
       chainId,
       monitorType,
       estimateL1DataFee,
-      broadcastPrivateBundle,
-      broadcastPrivateTx,
       forceGasLimitEstimation,
       eip7702Supported,
       getEIP7702Delegation: (addr) => getEIP7702Delegation({ address: addr, server }),
       getNonce,
-      privacyServer,
       server,
       ...(erc20FuelBuffer && { erc20FuelBuffer }),
       ...(fuelThreshold && { fuelThreshold: asset.currency.defaultUnit(fuelThreshold) }),
+      broadcastPrivateBundle,
+      broadcastPrivateTx,
+      privacyServer,
+      sendPrivateTx,
+      sendPrivateBundle,
     }
     return overrideCallback({
       asset: fullAsset,

package/src/gas-estimation.js

@@ -157,7 +157,7 @@ export async function fetchGasLimit({
   const gasLimitMultiplier = await resolveGasLimitMultiplier({
     asset,
     feeData,
-    fromAddress: providedFromAddress,
+    fromAddress,
     toAddress: txToAddress,
   })
 

package/src/get-balances.js

@@ -9,6 +9,63 @@ import assert from 'minimalistic-assert'
 
 import { getLatestCanonicalAbsoluteBalanceTx } from './tx-log/clarity-utils/index.js'
 
+/**
+ * Native balance helper for {@link getAbsoluteBalance}. Only consults
+ * `accountState` when the txLog is empty; otherwise the caller walks the
+ * txLog for a `balanceChange`. Inside the empty-txLog branch, picks a
+ * signal in decreasing order of trust:
+ *
+ *   1. Non-zero `accountState.balance` (authoritative — RPC `eth_getBalance`
+ *      result or `accountInfo` `account_balance` row from truncated history).
+ *   2. `truncatedAccountState.balance` (state at the cursor), default ZERO.
+ *
+ * ZERO is treated as "no signal" because `EthereumLikeAccountState` defaults
+ * `balance` to ZERO; we cannot distinguish "model default" from "chain says
+ * you hold 0". The truncated baseline acts as the explicit fallback.
+ */
+const getBaseBalanceFromAccountState = ({ asset, txLog, accountState }) => {
+  if (txLog.size === 0) {
+    const balance = getBalanceFromAccountStateIfAny({ asset, accountState })
+    if (balance && !balance.isZero) return balance
+
+    return getTruncatedBaseBalance({ accountState }) ?? asset.currency.ZERO
+  }
+
+  return null
+}
+
+/**
+ * Token counterpart of {@link getBaseBalance}. Tokens are sparse — there's no
+ * model default for `tokenBalances[name]`, so any value present (including an
+ * explicit ZERO from `accountInfo` after the user drained the token) is
+ * authoritative and returned as-is. Only when the key is missing entirely do
+ * we fall through to the truncated baseline / txLog walk.
+ */
+const getTokenBalanceFromAccountState = ({ asset, txLog, accountState }) => {
+  const balance = getBalanceFromAccountStateIfAny({ asset, accountState })
+  if (balance) return balance
+
+  if (txLog.size === 0) {
+    return getTruncatedTokenBalance({ asset, accountState }) ?? asset.currency.ZERO
+  }
+
+  return null
+}
+
+/**
+ * Cursor-baseline native balance from {@link accountState.truncatedAccountState},
+ * sourced from Clarity `truncated` `accountInfo` rows on initial `cursor=0`
+ * fetch. Returns `undefined` when the snapshot isn't populated (e.g. the
+ * server didn't ship a baseline for this account).
+ */
+const getTruncatedBaseBalance = ({ accountState }) => accountState?.truncatedAccountState?.balance
+
+/**
+ * Token counterpart of {@link getTruncatedBaseBalance}.
+ */
+const getTruncatedTokenBalance = ({ asset, accountState }) =>
+  accountState?.truncatedAccountState?.tokenBalances?.[asset.name]
+
 /**
  * TODO: Balance model gaps for EVM staking assets
  *
@@ -39,15 +96,12 @@ export const getAbsoluteBalance = ({ asset, txLog, accountState }) => {
   assert(asset, 'asset is required')
   assert(txLog, 'txLog is required')
 
-  const accountStateBalance = getBalanceFromAccountStateIfAny({ asset, accountState })
-
-  if (txLog.size === 0) {
-    return accountStateBalance || asset.currency.ZERO
-  }
-
-  // Prefer an explicit `accountState` snapshot (e.g. populated from Clarity `accountInfo`
-  // in truncated-history mode) over walking a potentially truncated `txLog`.
+  const isBase = asset.name === asset.baseAsset.name
+  const accountStateBalance = isBase
+    ? getBaseBalanceFromAccountState({ asset, txLog, accountState })
+    : getTokenBalanceFromAccountState({ asset, txLog, accountState })
   if (accountStateBalance) {
+    // Authoritative `accountState` snapshot (or empty-txLog terminal value).
     return accountStateBalance
   }
 
@@ -98,6 +152,25 @@ export const getAbsoluteBalance = ({ asset, txLog, accountState }) => {
   }
 
   if (!hasAbsoluteBalance) {
+    // Last line of defense: under truncated history the post-cursor txLog can
+    // omit the most recent `balanceChange` (e.g. only a pending send remains).
+    // Anchor on the `accountInfo` snapshot, mirroring the same precedence as
+    // {@link getBaseBalanceFromAccountState} / {@link getTokenBalanceFromAccountState}:
+    // prefer the current `accountState.balance` (`account_balance` row), and
+    // fall back to `truncatedAccountState.balance` (cursor baseline) when the
+    // former is the model default ZERO.
+    const accountBalance = isBase
+      ? accountState?.balance
+      : accountState?.tokenBalances?.[asset.name]
+    if (accountBalance && (!isBase || !accountBalance.isZero)) {
+      return balance.add(accountBalance)
+    }
+
+    const truncatedBalance = isBase
+      ? getTruncatedBaseBalance({ accountState })
+      : getTruncatedTokenBalance({ asset, accountState })
+    if (truncatedBalance) return balance.add(truncatedBalance)
+
     console.warn('No absolute balance found', { assetName: asset.name, txLogSize: txLog.size })
     return
   }

package/src/staking/ethereum/service.js

@@ -66,7 +66,6 @@ import NumberUnit from '@exodus/currency'
 import assert from 'minimalistic-assert'
 
 import { estimateGasLimit, scaleGasLimitEstimate } from '../../gas-estimation.js'
-import { getOptimisticTxLogEffects } from '../../tx-log/get-optimistic-txlog-effects.js'
 import { createWatchTx as defaultCreateWatch } from '../../watch-tx.js'
 import { stakingProviderClientFactory } from '../staking-provider-client.js'
 import { amountToCurrency, DISABLE_BALANCE_CHECKS, resolveFeeData } from '../utils/index.js'
@@ -281,8 +280,6 @@ export function createEthereumStakingService({
       asset,
       fromAddress: delegatorAddress,
       walletAccount,
-      tag: 'latest',
-      forceFromNode: true,
     })
 
     return {
@@ -369,14 +366,12 @@ export function createEthereumStakingService({
         plan: null,
         gasLimit: null,
         unsignedTx: null,
-        signedTx: null,
         txId: null,
       },
       undelegate: {
         plan: null,
         gasLimit: null,
         unsignedTx: null,
-        signedTx: null,
         txId: null,
       },
     }
@@ -465,34 +460,16 @@ export function createEthereumStakingService({
       revertOnSimulationError,
     })
 
-    // 4. Sign transactions
-    const signedTxEntries = await Promise.all(
-      Object.entries(txSteps)
-        .filter(([, txStep]) => txStep.unsignedTx)
-        .map(async ([key, txStep]) => {
-          const signedTx = await assetClientInterface.signTransaction({
-            assetName: asset.baseAsset.name,
-            unsignedTx: txStep.unsignedTx,
-            walletAccount,
-          })
-          const txId = `0x${signedTx.txId.toString('hex')}`
-          return [key, { signedTx, txId }]
-        })
-    )
-
-    for (const [key, { signedTx, txId }] of signedTxEntries) {
-      txSteps[key].signedTx = signedTx
-      txSteps[key].txId = txId
-    }
+    const unsignedTxBundle = createdTxEntries.map(([_, unsignedTx]) => ({
+      asset,
+      unsignedTx,
+      walletAccount,
+    }))
 
+    // 4. Sign transactions
+    //
     // 5. Broadcast transactions via bundle and get bundle hash
-    const bundleResponse = await asset.broadcastPrivateBundle({
-      txs: Object.values(txSteps)
-        .filter((txStep) => txStep.signedTx)
-        .map(({ signedTx }) => signedTx.rawTx),
-    })
-    const bundleHash = bundleResponse?.bundleHash
-
+    //
     // 6. Optimistic tx-log effects: reflect tx presence and fee consumption only.
     // The ETH returned to the user via the contract's internal transfer is not
     // captured here — it will be picked up once the tx is confirmed on-chain.
@@ -518,26 +495,14 @@ export function createEthereumStakingService({
     // That is incompatible with the current tx-log side-effect hook, which only
     // receives tx-local data (method id, calldata, nonce, gas, etc.) and not
     // staking snapshots or precomputed ETH-return amounts.
-    const optimisticEffects = await Promise.all(
-      Object.values(txSteps)
-        .filter((txStep) => txStep.txId)
-        .map((txStep) =>
-          getOptimisticTxLogEffects({
-            asset: asset.baseAsset,
-            assetClientInterface,
-            fromAddress: delegatorAddress,
-            txId: txStep.txId,
-            unsignedTx: txStep.unsignedTx,
-            walletAccount,
-            bundleId: bundleHash ?? undefined,
-          })
-        )
-    )
+    const {
+      bundleHash,
+      txIds: [...txIds],
+    } = await asset.baseAsset.sendPrivateBundle({ unsignedTxBundle })
 
-    for (const { optimisticTxLogEffects } of optimisticEffects) {
-      for (const effect of optimisticTxLogEffects) {
-        await assetClientInterface.updateTxLogAndNotify(effect)
-      }
+    for (const txStep of Object.values(txSteps)) {
+      if (!txStep.unsignedTx) continue
+      assert((txStep.txId = txIds.shift()), 'expected txId')
     }
 
     // Testnet assets do not support delegations tracking
@@ -770,7 +735,7 @@ export function createEthereumStakingService({
     waitForConfirmation = false,
     feeData,
   }) {
-    const sendTxArgs = {
+    const { unsignedTx } = await asset.baseAsset.api.createTx({
       asset,
       walletAccount,
       address: to,
@@ -781,9 +746,9 @@ export function createEthereumStakingService({
       // HACK: Override the `tipGasPrice` to use a custom `maxPriorityFeePerGas`.
       tipGasPrice,
       feeData,
-    }
+    })
 
-    const { txId } = await asset.baseAsset.api.sendTx(sendTxArgs)
+    const { txId } = await asset.baseAsset.api.sendTx({ asset, walletAccount, unsignedTx })
 
     const baseAsset = asset.baseAsset
     if (waitForConfirmation) {

package/src/tx-log/clarity-truncated-history-monitor.js

@@ -143,8 +143,9 @@ export class ClarityTruncatedHistoryMonitor extends ClarityMonitor {
       currentTokenBalances,
     })
 
-    // Pre-cursor snapshot from Clarity `accountInfo`, then RPC `accountState` (empty here) overlays.
+    // Clarity `accountInfo`, then RPC `accountState` (empty here) overlays.
     const prevTokenBalances = derivedData.currentAccountState?.tokenBalances
+    const prevTruncatedAccountState = derivedData.currentAccountState?.truncatedAccountState
     const newData = {
       ...balanceFromAccountInfo,
       ...accountState,
@@ -161,6 +162,23 @@ export class ClarityTruncatedHistoryMonitor extends ClarityMonitor {
       }
     }
 
+    if (
+      prevTruncatedAccountState ||
+      balanceFromAccountInfo.truncatedAccountState ||
+      accountState.truncatedAccountState
+    ) {
+      newData.truncatedAccountState = {
+        ...prevTruncatedAccountState,
+        ...balanceFromAccountInfo.truncatedAccountState,
+        ...accountState.truncatedAccountState,
+        tokenBalances: {
+          ...prevTruncatedAccountState?.tokenBalances,
+          ...balanceFromAccountInfo.truncatedAccountState?.tokenBalances,
+          ...accountState.truncatedAccountState?.tokenBalances,
+        },
+      }
+    }
+
     try {
       this.aci.updateAccountStateBatch({
         assetName,

package/src/tx-log/clarity-truncated-history-monitor.md

@@ -3,7 +3,7 @@
 Extends `ClarityMonitor`. Used when Clarity only serves a **recent window** of txs and attaches pre-cursor snapshots in `accountInfo`.
 
 - Sends `truncated=true` on `getAllTransactions`.
-- Folds `accountInfo` into `accountState`.
+- Folds `accountInfo` into `accountState`, including truncated-history baselines.
 - Forces `rpcBalanceAssetNames = []` (no per-asset RPC `eth_getBalance` batch).
 
 Plugins opting in: `bsc-plugin`, `basemainnet-plugin`, `ethereum-plugin`.
@@ -16,18 +16,18 @@ Plugins opting in: `bsc-plugin`, `basemainnet-plugin`, `ethereum-plugin`.
 flowchart TD
   A[Clarity HTTP<br/>GET /addresses/:addr/transactions<br/>truncated=true & cursor] --> B[response]
   B --> B1[transactions.confirmed + .pending]
-  B --> B2[accountInfo rows<br/>rebase/special tokens only]
+  B --> B2[accountInfo rows<br/>account_balance or truncated baseline]
   B --> B3[cursor]
 
   B1 --> C[normalizeTransactionsResponse<br/>filter spam + stale pending]
   C --> D[getAllLogItemsByAsset<br/>bucket per assetName]
   D --> E[aci.updateTxLogAndNotifyBatch<br/>per asset]
 
-  B2 --> F[extractBalanceFromClarityAccountInfo<br/>balance? nonce? tokenBalances?]
+  B2 --> F[extractBalanceFromClarityAccountInfo<br/>balance? tokenBalances?<br/>truncatedAccountState?]
 
   E --> G[accountState]
   F --> G
-  B3 --> G[accountState<br/>balance, nonce, tokenBalances,<br/>clarityCursor]
+  B3 --> G[accountState<br/>balance, tokenBalances,<br/>truncatedAccountState,<br/>clarityCursor]
 
   G --> H1[getBalances - asset.api.getBalances]
   G --> H2[resolveNonce - tx send path]
@@ -35,13 +35,13 @@ flowchart TD
   H1 --> I1{txLog empty?}
   I1 -- yes --> I2[accountState.balance]
   I1 -- no --> I3{accountState<br/>balance<br/>non-zero?}
-  I3 -- yes --> I2
-  I3 -- no --> I4[walk txLog for latest<br/>balanceChange]
+  I3 -- yes + token account balance --> I2
+  I3 -- no / native --> I4[walk txLog<br/>use truncated baseline only when no balanceChange exists]
 
   H2 --> J1[max - nonceFromTxLog,<br/>accountState.nonce]
 ```
 
-Left-to-right: `accountInfo` only writes `accountState` for what Clarity can't derive from `walletChanges` (rebase tokens). Regular ERC-20s and ETH flow through the tx log. `getBalances` and `resolveNonce` then read `accountState` + `txLog` together.
+Left-to-right: `accountInfo` can write native balance baselines, authoritative token balances, and truncated baselines to `accountState`. Native ETH still prioritizes tx history when history exists. Rows with `source: 'account_balance'` go into `balance`/`tokenBalances`; rows with `source: 'truncated'` go into `truncatedAccountState`.
 
 ---
 
@@ -106,7 +106,7 @@ Wallet `0x3F80…9164` on Ethereum. Two txs + the one real `accountInfo` row:
   "accountInfo": [
     {
       "type": "token",
-      "balanceType": "account_balance",
+      "source": "account_balance",
       "value": "20191469428776270391810",
       "blockNumber": 24933420,
       "assetId": "0x2a8e…5e86",
@@ -129,9 +129,13 @@ Wallet `0x3F80…9164` on Ethereum. Two txs + the one real `accountInfo` row:
 {
   clarityCursor: <Buffer LE 24211168>,
   tokenBalances: {
-    ousd_ethereum_48fcf72d: NumberUnit('20191.469… OUSD'),   // from accountInfo
+    ousd_ethereum_48fcf72d: NumberUnit('20191.469… OUSD'),   // account_balance row
   },
-  balance: ZERO,   // unchanged by monitor; derived live by getBalances
+  truncatedAccountState: {
+    balance: ZERO,
+    tokenBalances: {},
+  },
+  balance: ZERO,   // no native balance row in this response
   nonce:   0,      // unchanged by monitor; derived live by resolveNonce
 }
 ```
@@ -151,25 +155,30 @@ ethereum (ETH)                     walk txLog → latest             43_326_434_
 usdc                               walk txLog → latest             95_948_474_200 base
                                    walletChange.to
 ousd_ethereum_48fcf72d             accountState short-circuit      20_191_469_428_… base
-                                   (non-zero tokenBalances)        (from accountInfo)
+                                   (account_balance row)           (from accountInfo)
 ```
 
 Source: `getAbsoluteBalance` in `src/get-balances.js`, ordered branches:
 
-1. `txLog.size === 0` → `getBalanceFromAccountState`
-2. `accountState` non-zero → return it (`getBalanceFromAccountStateIfAny` skips default `ZERO` via `NumberUnit.isZero` getter)
-3. Walk reversed `txLog` for canonical `balanceChange` tx
+1. Non-zero `accountState` balance → return it.
+2. `txLog.size === 0` → return `truncatedAccountState` balance or `ZERO`.
+3. Token value exists in `accountState.tokenBalances` → return accountState balance, including explicit zero.
+4. Walk reversed `txLog` for canonical `balanceChange` tx.
+5. If no absolute balance exists, fall back to the txLog-derived balance path.
 
 ### `resolveNonce` (`src/tx-send/nonce-utils.js`)
 
 ```js
 nonce = Math.max(
   nonceFromTxLog, // latest canonical `type: 'nonce'` walletChange
-  accountState.nonce || 0 // populated from accountInfo row if sent
+  accountState.nonce || 0 // any `accountInfo` `type: 'nonce'` row, regardless of source
 )
 ```
 
-`accountInfo` `nonce` row patches the gap when truncation hides the latest `nonceChange`.
+Both `account_balance` and `truncated` source nonce rows collapse into `accountState.nonce`
+(the max wins) — they represent the same chain-known nonce, just at different observation
+points. `accountInfo` `nonce` row patches the gap when truncation hides the latest
+`nonceChange`.
 
 ---
 
@@ -192,9 +201,11 @@ case 'clarity-truncated-history':  // normalized to clarity-v2
 
 1. Accept `?truncated=true` on `GET /addresses/:addr/transactions`.
 2. Attach `accountInfo: []` (or omit) when nothing to snapshot.
-3. Emit `accountInfo` **only** for assets that can't be derived from `walletChanges` (rebase / `balanceType: 'account_balance'`).
-4. Row shapes: `{ type: 'balance' | 'nonce' | 'token', value, blockNumber, assetId?, assetName?, decimals? }`. Sorted client-side by `blockNumber` desc; first value per type/assetId wins.
-5. Unknown `assetId` → client drops the row.
+3. Emit `source: 'account_balance'` rows for current account/token balances. These may appear on every fetch.
+4. Emit `source: 'truncated'` rows on the initial `cursor=0` fetch for state that existed before the returned history window.
+5. Row shapes: `{ type: 'balance' | 'nonce' | 'token', source: 'account_balance' | 'truncated', value, blockNumber, assetId?, assetName?, decimals? }`. Sorted client-side by `blockNumber` desc; first value per type/assetId wins for `balance`/`token`. `nonce` rows are collapsed via `Math.max` regardless of source.
+6. Unknown `assetId` → client drops the row.
+7. `value` arrives as a decimal string. `null`, `undefined`, and empty-string `""` mean "no value" and the row is skipped.
 
 If the backend can't emit `accountInfo`, the monitor degrades gracefully to `clarity-v2` behavior (tx-log walk only).
 
@@ -202,7 +213,7 @@ If the backend can't emit `accountInfo`, the monitor degrades gracefully to `cla
 
 ## Tests
 
-- `src/tx-log/__tests__/clarity-truncated-history-monitor.test.js` — `truncated: true`, no RPC balance batch, accountInfo → `tokenBalances`.
+- `src/tx-log/__tests__/clarity-truncated-history-monitor.test.js` — `truncated: true`, no RPC balance batch, accountInfo → `balance`, token `tokenBalances`, and `truncatedAccountState`.
 - `src/__tests__/create-asset-utils.test.js` — factory → `ClarityTruncatedHistoryMonitor`.
-- `src/__tests__/get-balances.test.js` — accountState short-circuit (truncated history cases).
+- `src/__tests__/get-balances.test.js` — accountState token short-circuit and truncated baseline cases.
 - `src/__tests__/balances-model.test.js` — default-ZERO accountState still falls through (regression for `NumberUnit.isZero` getter).

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

@@ -123,6 +123,34 @@ export const getOptimisticTxLogEffects = async ({
     },
   }
 
+  const receiveWalletAccount = await findOtherPortfolioReceiveWalletAccount({
+    amount,
+    asset,
+    assetClientInterface,
+    methodId,
+    selfSend,
+    to,
+    txToAddress,
+    walletAccount,
+  })
+
+  const receiveSideEffects = receiveWalletAccount
+    ? getOtherPortfolioReceiveEffects({
+        amount,
+        asset,
+        confirmations,
+        date,
+        fromAddress,
+        gasLimit,
+        methodId,
+        maybeTipGasPrice,
+        nonce,
+        receiveWalletAccount,
+        txId,
+        data,
+      })
+    : []
+
   const optimisticTxLogEffects = [
     {
       assetName: asset.name,
@@ -156,11 +184,116 @@ export const getOptimisticTxLogEffects = async ({
       ],
     },
     ...methodOptimisticSideEffects,
+    ...receiveSideEffects,
   ].filter(Boolean)
 
   return { optimisticTxLogEffects, nonce }
 }
 
+const findOtherPortfolioReceiveWalletAccount = async ({
+  amount,
+  asset,
+  assetClientInterface,
+  methodId,
+  selfSend,
+  to,
+  txToAddress,
+  walletAccount,
+}) => {
+  // Exclude cases where another-portfolio receive logs would be misleading:
+  // history-backed assets, self-sends, incomplete/zero-value transfers, and
+  // token approvals/swaps/router calls that are not plain ERC-20 transfers.
+  if (!asset.baseAsset.api.features.noHistory || selfSend || !to || amount.isZero) return
+
+  if (isEthereumLikeToken(asset)) {
+    const isPlainTransfer =
+      txToAddress?.toLowerCase() === asset.contract.address.toLowerCase() &&
+      methodId === asset.contract.transfer.methodId
+    if (!isPlainTransfer) return
+  }
+
+  try {
+    return await getWalletAccountForReceiveAddress({
+      assetClientInterface,
+      baseAsset: asset.baseAsset,
+      sendingWalletAccount: walletAccount,
+      to,
+    })
+  } catch {}
+}
+
+const getOtherPortfolioReceiveEffects = ({
+  amount,
+  asset,
+  confirmations,
+  date,
+  fromAddress,
+  gasLimit,
+  methodId,
+  maybeTipGasPrice,
+  nonce,
+  receiveWalletAccount,
+  txId,
+  data,
+}) => {
+  const receiveProps = {
+    confirmations,
+    date,
+    selfSend: false,
+    from: [fromAddress],
+    txId,
+    data: {
+      gasLimit,
+      nonce,
+      ...(maybeTipGasPrice ? { tipGasPrice: maybeTipGasPrice.toBaseString() } : null),
+      ...(methodId ? { methodId } : null),
+      ...(data ? { data: bufferToHex(data) } : null),
+    },
+  }
+
+  return [
+    {
+      assetName: asset.name,
+      walletAccount: receiveWalletAccount,
+      txs: [
+        {
+          ...receiveProps,
+          coinAmount: amount.abs(),
+          coinName: asset.name,
+          currencies: {
+            [asset.name]: asset.currency,
+            [asset.feeAsset.name]: asset.feeAsset.currency,
+          },
+        },
+      ],
+    },
+  ]
+}
+
+const getWalletAccountForReceiveAddress = async ({
+  assetClientInterface,
+  baseAsset,
+  sendingWalletAccount,
+  to,
+}) => {
+  const normalizedTo = to.toLowerCase()
+  const walletAccounts = await assetClientInterface.getWalletAccounts({ assetName: baseAsset.name })
+
+  for (const walletAccount of walletAccounts) {
+    if (walletAccount === sendingWalletAccount) continue
+
+    const receiveAddresses = await assetClientInterface.getReceiveAddresses({
+      assetName: baseAsset.name,
+      walletAccount,
+      useCache: true,
+    })
+
+    if (receiveAddresses.some((address) => String(address).toLowerCase() === normalizedTo)) {
+      return walletAccount
+    }
+  }
+}
+
 const operationTxLogSideEffects = async ({
   txToAddress,
   methodId,

package/src/tx-log/monitor-utils/extract-balance-from-clarity-account-info.js

@@ -2,38 +2,60 @@
  * Maps Clarity `accountInfo` rows (GET .../transactions?truncated=true) into fields aligned
  * with Ethereum-like account state: `balance`, `tokenBalances`, `nonce` (plus base units
  * for amounts via `currency.baseUnit`).
- * Rows are applied newest-first by `blockNumber` so duplicate types resolve like
- * walletChanges-derived snapshots.
+ * `account_balance` source rows are stored in `balance`/`tokenBalances`; truncated source rows
+ * are stored in `truncatedAccountState`.
+ *
+ * NOTE: All `row.value` payloads arrive over the wire as decimal strings (e.g. `"0"`,
+ * `"20191469428776270391810"`). They're parsed with `currency.baseUnit(...)` for amounts
+ * and `Number(...)` for nonce. `null`, `undefined`, and empty-string `""` all mean "row
+ * carries no value" and the row is skipped — `currency.baseUnit("")` throws and `Number("")`
+ * returns 0, both of which would silently corrupt accountState.
  */
+const ACCOUNT_BALANCE = 'account_balance'
+const TRUNCATED = 'truncated'
+
+const hasValue = (value) => value !== null && value !== undefined && value !== ''
+
+const warnUnknownSource = (row) => {
+  console.warn('Unknown accountInfo source', row)
+}
+
 export const extractBalanceFromClarityAccountInfo = ({ accountInfo, asset, tokensByAddress }) => {
   if (!accountInfo || accountInfo.length === 0) return {}
 
   const sorted = [...accountInfo].sort((a, b) => (b.blockNumber || 0) - (a.blockNumber || 0))
 
   const result = {}
-  let haveBalance = false
-  let haveNonce = false
   const seenAssetIds = new Set()
   const tokenBalances = Object.create(null)
+  const truncatedTokenBalances = Object.create(null)
+  let truncatedBalance
 
   for (const row of sorted) {
     switch (row.type) {
       case 'balance':
-        if (!haveBalance && row.value != null) {
-          result.balance = asset.currency.baseUnit(row.value)
-          haveBalance = true
+        if (hasValue(row.value)) {
+          const balance = asset.currency.baseUnit(row.value)
+          if (row.source === ACCOUNT_BALANCE) {
+            result.balance = balance
+          } else if (row.source === TRUNCATED) {
+            truncatedBalance = balance
+          } else {
+            warnUnknownSource(row)
+          }
         }
 
         break
 
       case 'nonce': {
-        if (haveNonce) break
+        // Nonce collapses regardless of source — both `account_balance` and
+        // `truncated` rows represent the latest chain-known nonce; max wins
+        // for safety against out-of-order rows.
+        if (!hasValue(row.value)) break
         const nonce = Number(row.value)
+        if (!Number.isFinite(nonce) || nonce < 0) break
 
-        if (Number.isFinite(nonce) && nonce >= 0) {
-          result.nonce = nonce
-          haveNonce = true
-        }
+        result.nonce = Math.max(result.nonce ?? 0, nonce)
 
         break
       }
@@ -41,10 +63,19 @@ export const extractBalanceFromClarityAccountInfo = ({ accountInfo, asset, token
       case 'token': {
         const assetId = row.assetId?.toLowerCase()
 
-        if (!assetId || seenAssetIds.has(assetId) || row.value == null) break
+        if (!assetId || seenAssetIds.has(assetId) || !hasValue(row.value)) break
         const token = tokensByAddress.get(assetId)
         if (!token) break
-        tokenBalances[token.name] = token.currency.baseUnit(row.value)
+
+        const balance = token.currency.baseUnit(row.value)
+        if (row.source === ACCOUNT_BALANCE) {
+          tokenBalances[token.name] = balance
+        } else if (row.source === TRUNCATED) {
+          truncatedTokenBalances[token.name] = balance
+        } else {
+          warnUnknownSource(row)
+        }
+
         seenAssetIds.add(assetId)
         break
       }
@@ -58,5 +89,20 @@ export const extractBalanceFromClarityAccountInfo = ({ accountInfo, asset, token
     result.tokenBalances = tokenBalances
   }
 
+  const hasTruncatedTokenBalances = Object.keys(truncatedTokenBalances).length > 0
+  if (truncatedBalance || hasTruncatedTokenBalances) {
+    const truncatedAccountState = Object.create(null)
+
+    if (truncatedBalance) {
+      truncatedAccountState.balance = truncatedBalance
+    }
+
+    if (hasTruncatedTokenBalances) {
+      truncatedAccountState.tokenBalances = truncatedTokenBalances
+    }
+
+    result.truncatedAccountState = truncatedAccountState
+  }
+
   return result
 }

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

@@ -28,8 +28,8 @@ export const resolveNonce = async ({
 
   const nonceFromTxLog = getNonceFromTxLog({ txLog, useAbsoluteNonce, tag })
 
-  // Fallback to accountState nonce when txLog has no nonce info (truncated history).
-  // accountState.nonce is populated from Clarity accountInfo during monitor ticks.
+  // `accountState.nonce` is the single source of truth — clarity-truncated-history
+  // collapses both `account_balance` and `truncated` source nonces into this field.
   const nonceFromAccountState = accountState?.nonce || 0
 
   return Math.max(nonceFromTxLog, nonceFromAccountState)

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

@@ -1,8 +1,9 @@
-import { normalizeTxId, parseUnsignedTx, updateNonce } from '@exodus/ethereum-lib'
+import { parseUnsignedTx, updateNonce } from '@exodus/ethereum-lib'
 import { safeString } from '@exodus/safe-string'
 import assert from 'minimalistic-assert'
 
 import { getOptimisticTxLogEffects } from '../tx-log/index.js'
+import { signTx } from '../tx-sign/index.js'
 import { ARBITRARY_ADDRESS } from '../tx-type/index.js'
 import { handleBroadcastError } from './broadcast-error-handler.js'
 
@@ -10,16 +11,6 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
   assert(createTx, 'createTx is required')
 
-  async function signTx({ asset, unsignedTx, walletAccount }) {
-    const { rawTx, txId } = await assetClientInterface.signTransaction({
-      assetName: asset.baseAsset.name,
-      unsignedTx,
-      walletAccount,
-    })
-
-    return { rawTx, txId: normalizeTxId(txId) }
-  }
-
   return async ({ asset, walletAccount, unsignedTx: providedUnsignedTx, ...legacyParams }) => {
     const baseAsset = asset.baseAsset
 
@@ -41,6 +32,7 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
     // Are there any signin-level errors that should be caught here?
     let { txId, rawTx } = await signTx({
       asset,
+      assetClientInterface,
       unsignedTx,
       walletAccount,
     })
@@ -92,7 +84,12 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
           unsignedTx.txData.nonce = newNonce
         }
 
-        ;({ txId, rawTx } = await signTx({ asset, unsignedTx, walletAccount }))
+        ;({ txId, rawTx } = await signTx({
+          asset,
+          assetClientInterface,
+          unsignedTx,
+          walletAccount,
+        }))
 
         try {
           await baseAsset.api.broadcastTx(rawTx.toString('hex'))

package/src/tx-sign/index.js

@@ -0,0 +1,17 @@
+import { normalizeTxId } from '@exodus/ethereum-lib'
+import assert from 'minimalistic-assert'
+
+export const signTx = async ({ asset, assetClientInterface, unsignedTx, walletAccount }) => {
+  assert(asset, 'expected asset')
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(unsignedTx, 'expected unsignedTx')
+  assert(walletAccount, 'expected walletAccount')
+
+  const { rawTx, txId } = await assetClientInterface.signTransaction({
+    assetName: asset.baseAsset.name,
+    unsignedTx,
+    walletAccount,
+  })
+
+  return { rawTx, txId: normalizeTxId(txId) }
+}