@exodus/ethereum-api 8.74.1 → 8.75.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [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.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",
@@ -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": "8cf5e6a5fc7d235c2c57ea51219bb1e3469329c5"
 }

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