@exodus/ethereum-api 8.78.2 → 8.79.1

package/CHANGELOG.md

@@ -3,6 +3,81 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.79.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.77.1...@exodus/ethereum-api@8.79.1) (2026-09-09)
+
+
+### Features
+
+* source eip7702 delegation whitelist from remote config ([#8356](https://github.com/ExodusMovement/assets/issues/8356)) ([1a0966b](https://github.com/ExodusMovement/assets/commit/1a0966b08befb6e9310993f323c21d003dea2754))
+
+
+### Bug Fixes
+
+* disable @exodus/hydra/no-param-reassign-prop-only warnings ([#8531](https://github.com/ExodusMovement/assets/issues/8531)) ([ddae556](https://github.com/ExodusMovement/assets/commit/ddae556361285919fe82cd10a81cfeae79ccc6b5))
+* **ethereum-api:** detect legacy delegate transactions ([#8357](https://github.com/ExodusMovement/assets/issues/8357)) ([070e529](https://github.com/ExodusMovement/assets/commit/070e5295f21f12695e97e721ff8c0601c553e447))
+* **ethereum-api:** preserve live pending txs across refresh to prevent nonce reuse ([#8430](https://github.com/ExodusMovement/assets/issues/8430)) ([a24ad82](https://github.com/ExodusMovement/assets/commit/a24ad82d303ce50606143bc5d1d917fbbad45ef1))
+* **ethereum-api:** preserve precision for wei values in tx simulation ([#7920](https://github.com/ExodusMovement/assets/issues/7920)) ([5c99258](https://github.com/ExodusMovement/assets/commit/5c9925871d450167fcf23e33ba62e100a2d71a9b))
+* **ethereum-api:** reference defined ethereum asset in simulate-tx tests ([#8525](https://github.com/ExodusMovement/assets/issues/8525)) ([27a8918](https://github.com/ExodusMovement/assets/commit/27a8918f5ba3112f1830ac0111a43d30921aa3b3))
+* **ethereum:** prevent silently dropped zero-tip private bundles ([#8493](https://github.com/ExodusMovement/assets/issues/8493)) ([67dd1ff](https://github.com/ExodusMovement/assets/commit/67dd1ffd7e1c22e7119b1781968c4be321ab1822))
+* **lint:** add explicit process imports and enforce no-implicit-process ([#8530](https://github.com/ExodusMovement/assets/issues/8530)) ([885c29d](https://github.com/ExodusMovement/assets/commit/885c29decb1db363673da5be91b2bc6d06da8a6c))
+* **lint:** convert console.log/info to console.debug and enforce no-console ([#8529](https://github.com/ExodusMovement/assets/issues/8529)) ([81cf5e9](https://github.com/ExodusMovement/assets/commit/81cf5e90b8157b084cf4cb311c02803c29e622e4))
+* **lint:** fix import/named warnings and upgrade to error ([#8496](https://github.com/ExodusMovement/assets/issues/8496)) ([8d290c9](https://github.com/ExodusMovement/assets/commit/8d290c948a0d3c2c1897287cb133f9d26cad73b0))
+* **lint:** fix JSDoc warnings across multiple packages ([#8519](https://github.com/ExodusMovement/assets/issues/8519)) ([5fefcd5](https://github.com/ExodusMovement/assets/commit/5fefcd5af996efbe9587cecba540efc7f469ceb2))
+* **lint:** fix no-throw-literal warnings and upgrade to error ([#8498](https://github.com/ExodusMovement/assets/issues/8498)) ([8fc68eb](https://github.com/ExodusMovement/assets/commit/8fc68eb65682e0b5a7da9415410ee1dedf309696))
+* **lint:** fix oxlint warnings and convert rules to error ([#8489](https://github.com/ExodusMovement/assets/issues/8489)) ([19d35be](https://github.com/ExodusMovement/assets/commit/19d35be718391303d331978926884f2f376b356f))
+* **lint:** migrate lodash to @exodus/basic-utils ([#8514](https://github.com/ExodusMovement/assets/issues/8514)) ([12c574f](https://github.com/ExodusMovement/assets/commit/12c574f1ac8ab0592700df574b2643141237090a))
+* **simulation:** route recipient changes to dedicated field, guard asset-less entries ([#8370](https://github.com/ExodusMovement/assets/issues/8370)) ([c0a082b](https://github.com/ExodusMovement/assets/commit/c0a082b6c80710408337ff9285a19fb657c656be))
+* upgrade low-complexity lint rules to error ([#8510](https://github.com/ExodusMovement/assets/issues/8510)) ([25016bd](https://github.com/ExodusMovement/assets/commit/25016bdf43526c6bc9efe2771f92f1ae1ebf7cd7))
+
+
+### Performance Improvements
+
+* **ethereum:** reduce background staking request volume ([#8617](https://github.com/ExodusMovement/assets/issues/8617)) ([a9746d9](https://github.com/ExodusMovement/assets/commit/a9746d98ee0a2a04f5fd0131d3f1228cbc0aacf2))
+
+
+
+## [8.79.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.77.1...@exodus/ethereum-api@8.79.0) (2026-08-18)
+
+
+### Features
+
+
+* feat: source eip7702 delegation whitelist from remote config (#8356)
+
+
+### Bug Fixes
+
+
+* fix: disable @exodus/hydra/no-param-reassign-prop-only warnings (#8531)
+
+* fix(ethereum-api): detect legacy delegate transactions (#8357)
+
+* fix(ethereum-api): preserve live pending txs across refresh to prevent nonce reuse (#8430)
+
+* fix(ethereum-api): preserve precision for wei values in tx simulation (#7920)
+
+* fix(ethereum-api): reference defined ethereum asset in simulate-tx tests (#8525)
+
+* fix(ethereum): prevent silently dropped zero-tip private bundles (#8493)
+
+* fix(lint): add explicit process imports and enforce no-implicit-process (#8530)
+
+* fix(lint): convert console.log/info to console.debug and enforce no-console (#8529)
+
+* fix(lint): fix import/named warnings and upgrade to error (#8496)
+
+* fix(lint): fix JSDoc warnings across multiple packages (#8519)
+
+* fix(lint): fix no-throw-literal warnings and upgrade to error (#8498)
+
+* fix(lint): fix oxlint warnings and convert rules to error (#8489)
+
+* fix(simulation): route recipient changes to dedicated field, guard asset-less entries (#8370)
+
+* fix: upgrade low-complexity lint rules to error (#8510)
+
+
+
 ## [8.78.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.77.1...@exodus/ethereum-api@8.78.2) (2026-08-14)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.78.2",
+  "version": "8.79.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",
@@ -17,7 +17,7 @@
     "provenance": false
   },
   "scripts": {
-    "test": "run -T exodus-test --jest"
+    "test": "exodus-test --jest"
   },
   "dependencies": {
     "@exodus/asset": "^2.0.4",
@@ -67,5 +67,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "07b29ff2dc71fb1358ad6b1b6748c3f9fe66c10e"
+  "gitHead": "53bdb90b8e90413468dc13cf8960ef2aa64dac4b"
 }

package/src/allowance/index.js

@@ -1,4 +1,3 @@
-// eslint-disable-next-line @exodus/import/no-deprecated
 import { isNumberUnit } from '@exodus/currency'
 import { buffer2currency, createUnsignedTxFactory } from '@exodus/ethereum-lib'
 import { bufferToInt } from '@exodus/ethereumjs/util'
@@ -46,7 +45,6 @@ export const buildApproveTx = async ({
 }) => {
   assert(asset, 'expected asset')
   assert(feeData, 'expected feeData')
-  // eslint-disable-next-line @exodus/import/no-deprecated
   assert(isNumberUnit(approveAmount), 'expected approveAmount')
   assert(typeof spenderAddress === 'string', 'expected spenderAddress')
   assert(walletAccount, 'expected walletAccount')
@@ -231,7 +229,7 @@ export const createApproveSpendingTokens =
 
       txIds.push(revokeTokenApprovalTxId)
       // Hardcoded min gas limit. Otherwise `fetchGasLimit` will fail since `approve(_spender, 0)` is not yet confirmed
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       data.gasLimit = Math.max(data.gasLimit || 0, APPROVAL_GAS_LIMIT)
     }
 

package/src/create-asset-utils.js

@@ -62,7 +62,7 @@ export const resolveMonitorSettings = (
   }
 
   const fallbackWithWarning = (msg) => {
-    console.log([msg, `Falling back to ${defaultMonitorType}<${defaultServerUrl}>.`].join(' '))
+    console.debug([msg, `Falling back to ${defaultMonitorType}<${defaultServerUrl}>.`].join(' '))
     return defaultResolution
   }
 
@@ -317,7 +317,7 @@ export const createHistoryMonitorFactory = ({
     let monitor
     switch (monitorType) {
       case 'clarity-v3':
-        console.log('clarity-v3 is no longer supported, falling back to clarity-v2')
+        console.debug('clarity-v3 is no longer supported, falling back to clarity-v2')
       // eslint-disable-next-line no-fallthrough
       case 'clarity':
       case 'clarity-v2':
@@ -365,13 +365,13 @@ export const createHistoryMonitorFactory = ({
     }
 
     if (stakingAssetNames.length > 0) {
-      const afterTickHook = createEthereumHooks({
+      const hooks = createEthereumHooks({
         assetClientInterface,
         assetName,
         stakingAssetNames,
         server,
-      })['after-tick']
-      monitor.addHook('after-tick', afterTickHook)
+      })
+      for (const [name, hook] of Object.entries(hooks)) monitor.addHook(name, hook)
     }
 
     return monitor

package/src/create-asset.js

@@ -1,3 +1,4 @@
+import { mapValues } from '@exodus/basic-utils'
 import { createConsoleLogger } from '@exodus/asset-lib'
 import { ASSET_FAMILY, connectAssetsList } from '@exodus/assets'
 import bip44Constants from '@exodus/bip44-constants/by-ticker.js'
@@ -18,7 +19,6 @@ import {
   validateFactory,
 } from '@exodus/ethereum-lib'
 import { toChecksumAddress } from '@exodus/ethereumjs/util'
-import lodash from 'lodash'
 import assert from 'minimalistic-assert'
 
 import { addressHasHistoryFactory } from './address-has-history.js'
@@ -53,8 +53,6 @@ import { createTxFactory } from './tx-create.js'
 import { txSendFactory } from './tx-send/index.js'
 import { createWeb3API } from './web3/index.js'
 
-const { mapValues } = lodash
-
 export const createAssetFactory = ({
   AccountState: CustomAccountState,
   assetsList,
@@ -192,6 +190,10 @@ export const createAssetFactory = ({
       getBalances,
     })
 
+    const createRpcRequestAccumulator = createRpcRequestAccumulatorFactory({
+      multicall3Address,
+    })
+
     const { createToken, getTokens } = createTokenFactory(
       {
         address,
@@ -204,6 +206,7 @@ export const createAssetFactory = ({
         server,
         stakingConfiguration,
         stakingDependencies,
+        createRpcRequestAccumulator,
       },
       assets
     )
@@ -232,10 +235,6 @@ export const createAssetFactory = ({
         supportsTransactionPrivacy,
       })
 
-    const createRpcRequestAccumulator = createRpcRequestAccumulatorFactory({
-      multicall3Address,
-    })
-
     const features = {
       accountState: true,
       customTokens,
@@ -262,6 +261,8 @@ export const createAssetFactory = ({
     const extraData =
       stakingAssetNames.length > 0
         ? {
+            // Persist ownership independently of host annotations and balances.
+            stakingSnapshotOwners: {},
             staking: mapValues(
               stakingConfiguration,
               (assetStakinConfiguration) => assetStakinConfiguration.accountStateExtraData

package/src/create-token-factory.js

@@ -43,6 +43,7 @@ const getCreateBaseToken =
     server,
     stakingConfiguration = Object.create(null),
     stakingDependencies = Object.create(null),
+    createRpcRequestAccumulator,
     ...props
   }) =>
   ({ name, contract, features, ...tokenDef }) => {
@@ -78,6 +79,7 @@ const getCreateBaseToken =
         server,
         stakingConfiguration: stakingConfiguration[name],
         stakingDependencies: stakingDependencies[name],
+        createRpcRequestAccumulator,
       })
     }
 

package/src/ens/index.js

@@ -1,4 +1,3 @@
-// eslint-disable-next-line @exodus/import/no-deprecated
 import { hashSync } from '@exodus/crypto/hash'
 import { ABI } from '@exodus/ethereum-lib'
 import SolidityContract from '@exodus/solidity-contract'
@@ -25,7 +24,6 @@ function namehash(inputName) {
   const name = normalize(inputName)
   if (name) {
     for (const label of name.split('.').reverse()) {
-      // eslint-disable-next-line @exodus/import/no-deprecated
       node = hashSync('keccak256', [node, hashSync('keccak256', label, 'uint8')], 'buffer')
     }
   }

package/src/exodus-eth-server/api-coin-nodes.js

@@ -29,10 +29,15 @@ export default class ApiCoinNodesServer extends EthLikeServer {
     return fetchJsonRetry(this.uri, options)
   }
 
-  async sendBatchRequest(batch) {
+  async sendBatchRequest(batch, { tolerant } = {}) {
     if (isEmpty(batch)) return batch
     const responses = await this.request(batch)
-    return this.parseBatchResponse({ batch, responses, errorMessage: 'Bad rpc batch response' })
+    return this.parseBatchResponse({
+      batch,
+      responses,
+      errorMessage: 'Bad rpc batch response',
+      tolerant,
+    })
   }
 
   async sendRequest(request) {

package/src/exodus-eth-server/api.js

@@ -263,11 +263,11 @@ export function create(defaultURL, ensAssetName) {
     },
 
     async proxyToCoinNode(requestData) {
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       if (!requestData.jsonrpc) requestData.jsonrpc = '2.0'
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       if (!requestData.id) requestData.id = randomUUID()
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       if (!requestData.params) requestData.params = []
 
       return request('proxy', requestData, { version: 'v2', method: 'post' })

package/src/exodus-eth-server/clarity.js

@@ -198,7 +198,7 @@ export default class ClarityServer extends EthLikeServer {
         clearTimeout(timeout)
         const rawTraceparent = response?.traceparent || response?.[0]?.traceparent
         if (rawTraceparent) {
-          // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+          // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
           response.traceparent = TraceId.fromRawTraceparent(rawTraceparent)
         }
 
@@ -208,9 +208,9 @@ export default class ClarityServer extends EthLikeServer {
   }
 
   // Transport: WS only in ClarityServer, WS first → HTTP fallback in ClarityServerV2
-  async sendBatchRequest(batch) {
+  async sendBatchRequest(batch, { tolerant } = {}) {
     const responses = await this.sendRpcRequest(batch)
-    return this.parseBatchResponse({ batch, responses, errorMessage: 'Bad Response' })
+    return this.parseBatchResponse({ batch, responses, errorMessage: 'Bad Response', tolerant })
   }
 
   // Transport: Uses sendRpcRequest - WS only in ClarityServer, WS first → HTTP fallback in ClarityServerV2

package/src/exodus-eth-server/eth-like-server.js

@@ -165,10 +165,11 @@ export class EthLikeServer extends EthLikeServerBase {
    * @param {Array<{ id: number|string }>} args.batch - Requests sent, in the order results are expected.
    * @param {unknown} args.responses - Raw transport payload; expected `[{ id, result }]` but treated as untrusted (gateways may return `{ message }` on error).
    * @param {string} args.errorMessage - Thrown-error prefix per transport (e.g. `'Bad rpc batch response'`, `'Bad Response'`).
-   * @returns {unknown[]} Each request's `result`, ordered to match `batch`.
-   * @throws {Error} When `responses` isn't an array, length mismatches `batch`, or any entry lacks a numeric `id` / defined `result`.
+   * @param {boolean} [args.tolerant] - When true, a request without a valid entry (JSON-RPC error entry, non-numeric `id`, duplicated or out-of-batch `id`, missing from a short response) maps to `undefined` instead of failing the whole batch.
+   * @returns {unknown[]} Each request's `result`, ordered to match `batch`. Entries with a duplicated or out-of-batch `id` are discarded in both modes, so an affected request maps to `undefined` rather than another request's result.
+   * @throws {Error} When `responses` isn't an array; in strict mode also when length mismatches `batch` or any entry lacks a numeric `id` / defined `result`.
    */
-  parseBatchResponse({ batch, responses, errorMessage }) {
+  parseBatchResponse({ batch, responses, errorMessage, tolerant = false }) {
     // Gateways can respond with a JSON object (e.g. `{ message }`) instead of a batch array.
     if (!Array.isArray(responses)) {
       // Untrusted server text: keep only a short string preview, developer-facing (no `hint`).
@@ -179,16 +180,23 @@ export class EthLikeServer extends EthLikeServerBase {
       throw new Error(`${errorMessage}${preview}`)
     }
 
-    const isValid = responses.every(
-      (response) => !isNaN(response?.id) && response?.result !== undefined
-    )
-    if (responses.length !== batch.length || !isValid) {
+    const isValidEntry = (response) => !isNaN(response?.id) && response?.result !== undefined
+
+    if (!tolerant && (responses.length !== batch.length || !responses.every(isValidEntry))) {
       throw new Error(errorMessage)
     }
 
-    // Safe against prototype keys: every `id` is validated numeric by the `isValid` check above.
+    // Safe against prototype keys: only entries with a validated numeric `id` are kept.
     const keyed = Object.fromEntries(
-      responses.map((response) => [`${response.id}`, response.result])
+      responses
+        .filter(isValidEntry)
+        .filter(({ id }, _i, all) => {
+          const key = `${id}`
+          const inBatch = batch.some((request) => `${request.id}` === key)
+          const unique = all.filter(({ id: other }) => `${other}` === key).length === 1
+          return inBatch && unique
+        })
+        .map((response) => [`${response.id}`, response.result])
     )
     return batch.map((request) => keyed[`${request.id}`])
   }

package/src/exodus-eth-server/index.js

@@ -1,9 +1,6 @@
 import {
-  // eslint-disable-next-line @exodus/import/no-deprecated
   DEFAULT_SERVER_URLS,
-  // eslint-disable-next-line @exodus/import/no-deprecated
   ETHEREUM_LIKE_ASSETS,
-  // eslint-disable-next-line @exodus/import/no-deprecated
   ETHEREUM_LIKE_MONITOR_TYPES,
 } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
@@ -80,11 +77,8 @@ export const createWsGateway = ({ uri } = Object.create(null)) => {
 
 // @Deprecated
 const serverMap = Object.fromEntries(
-  // eslint-disable-next-line @exodus/import/no-deprecated
   ETHEREUM_LIKE_ASSETS.map((assetName) => {
-    // eslint-disable-next-line @exodus/import/no-deprecated
     const monitorType = ETHEREUM_LIKE_MONITOR_TYPES[assetName]
-    // eslint-disable-next-line @exodus/import/no-deprecated
     const serverUrl = DEFAULT_SERVER_URLS[assetName]
     return [assetName, createEvmServer({ assetName, serverUrl, monitorType })]
   })

package/src/fee-data/EthLikeFeeData.js

@@ -3,7 +3,6 @@ import {
   mapCurrency as defaultMapCurrency,
   modelToJSON,
 } from '@exodus/asset-lib/src/utils/index.js'
-// eslint-disable-next-line @exodus/import/no-deprecated
 import { isNumberUnit } from '@exodus/currency'
 import lodash from 'lodash'
 
@@ -13,7 +12,6 @@ const PRE_EIP1559_UNIT_KEYS_GUARD = ['gasPrice']
 const EIP1559_UNIT_KEYS_GUARD = ['gasPrice', 'baseFeePerGas']
 
 export const bound = ({ val, multiplier, max, min }) => {
-  // eslint-disable-next-line @exodus/import/no-deprecated
   if (!isNumberUnit(val)) return val
 
   if (multiplier) {

package/src/hooks/monitor.js

@@ -1,67 +1,195 @@
 import assert from 'minimalistic-assert'
 
 import processTxLog from '../tx-log-staking-processor/index.js'
+import { getStakingActivity, stakingStateInterval } from './staking-freshness.js'
+
+// Service-owned fields must never leak between delegator snapshots. Keep host
+// annotations outside this set; new service fields must be added here as well.
+const STAKING_SNAPSHOT_FIELDS = new Set([
+  'rewardsBalance',
+  'isDelegating',
+  'activeStakedBalance',
+  'delegatedBalance',
+  'pendingBalance',
+  'pendingDepositedBalance',
+  'minDelegateAmount',
+  'unclaimedUndelegatedBalance',
+  'canClaimUndelegatedBalance',
+  'isUndelegateInProgress',
+  'validatorActivationTime',
+  'validatorExitTime',
+  'validatorWithdrawTime',
+  'liquidRewards',
+  'withdrawable',
+  'unbondNonce',
+  'minRewardsToWithdraw',
+])
 
 export const createEthereumHooks = ({
   assetClientInterface,
   assetName,
   stakingAssetNames,
   server,
+  now = () => performance.now(),
 }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
   assert(server, 'server is required')
   assert(assetName, 'assetName is required')
-  const afterTickHook = async ({ walletAccount }) => {
-    // args passed from monitor tick method ({ monitor, error })
-    const assets = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: assetName,
-    })
-
-    // some assets may not be available
-    const stakingAssets = stakingAssetNames.map((assetName) => assets[assetName]).filter(Boolean)
-
+  const freshness = new Map()
+  const addresses = new Map()
+  const generations = new Map()
+  const commits = new Map()
+  const afterTickHook = async ({ walletAccount, refresh = false }) => {
+    // Order requests at entry, not after address discovery: discovery itself can
+    // be delayed while a newer explicit refresh is already running.
+    const accountKey = String(walletAccount)
+    const generation = {}
+    generations.set(accountKey, generation)
+    const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: assetName })
+    const stakingAssets = stakingAssetNames.map((name) => assets[name]).filter(Boolean)
     const userAddress = await assetClientInterface.getReceiveAddress({
       assetName,
       walletAccount,
       useCache: true,
     })
-
-    const stakingInfo = {
-      staking: Object.create(null),
-    }
+    const address = userAddress.toString().toLowerCase()
+    if (generations.get(accountKey) !== generation) return
+    const addressChanged = addresses.get(accountKey) !== address
+    addresses.set(accountKey, address)
+    const baseTxLog = await assetClientInterface.getTxLog({ assetName, walletAccount })
+    const patches = Object.create(null)
+    const completed = []
 
     for (const asset of stakingAssets) {
       const stakingApi = asset.api?.staking
       if (!stakingApi?.getStakingInfo) continue
+      const key = JSON.stringify([String(walletAccount), assetName, asset.name, address])
+      const previous = freshness.get(key)
+      try {
+        const txLog =
+          asset.name === assetName
+            ? baseTxLog
+            : await assetClientInterface.getTxLog({ assetName: asset.name, walletAccount })
+        const { pending, fingerprint } = getStakingActivity({
+          assetName: asset.name,
+          txLogs: [baseTxLog, txLog],
+        })
+        const force =
+          refresh || addressChanged || pending || !previous || previous.fingerprint !== fingerprint
+        if (!force && now() < previous.deadline) continue
 
-      const assetStakingInfo = await stakingApi.getStakingInfo({
-        address: userAddress.toString(),
-      })
-      stakingInfo.staking[asset.name] = assetStakingInfo
+        patches[asset.name] = await stakingApi.getStakingInfo({
+          address,
+          background: true,
+          useCache: !force,
+          // Initial per-address discovery is full, but the queue is global.
+          useQueueCache:
+            !refresh && !pending && (!previous || previous.fingerprint === fingerprint),
+        })
+        completed.push([
+          key,
+          { fingerprint, deadline: now() + stakingStateInterval(patches[asset.name]) },
+        ])
+      } catch (error) {
+        // Keep the last successful account state and retry on the next normal
+        // tick. Never interpret transport/contract/provider failures as zero.
+        if (generations.get(accountKey) === generation) freshness.delete(key)
+        console.warn(`Failed to refresh ${asset.name} staking state`, error)
+      }
     }
 
-    const batch = assetClientInterface.createOperationsBatch()
-    assetClientInterface.updateAccountStateBatch({
-      assetName,
-      walletAccount,
-      newData: stakingInfo,
-      batch,
-    })
-
-    const processTxLogsPromises = stakingAssets.map((asset) => {
-      return processTxLog({
-        asset,
-        assetClientInterface,
+    const publish = async () => {
+      if (generations.get(accountKey) !== generation) return
+      const batch = assetClientInterface.createOperationsBatch()
+      // All asynchronous preparation is inside the per-account commit queue.
+      // Newer reads can run concurrently, but cannot commit ahead of an already
+      // executing batch. A superseded preparation is discarded before execute.
+      const current = await assetClientInterface.getAccountState({ assetName, walletAccount })
+      await Promise.all(
+        stakingAssets.map((asset) =>
+          processTxLog({
+            asset,
+            assetClientInterface,
+            walletAccount,
+            batch,
+          })
+        )
+      )
+      const latestAddress = await assetClientInterface.getReceiveAddress({
+        assetName,
         walletAccount,
-        batch,
+        useCache: true,
       })
-    })
+      if (
+        latestAddress.toString().toLowerCase() !== address ||
+        generations.get(accountKey) !== generation
+      ) {
+        return
+      }
 
-    await Promise.all(processTxLogsPromises)
-    await assetClientInterface.executeOperationsBatch(batch)
+      const staking = { ...current.staking }
+      const owners = { ...current.stakingSnapshotOwners }
+      let changed = false
+      // Ownership is persisted with the snapshot, not inferred from in-memory
+      // deadlines. Unknown legacy owners cannot supply failed fields on restore.
+      // Preserve only non-service host metadata when changing snapshot owners.
+      for (const name of new Set([...stakingAssetNames, ...Object.keys(owners)])) {
+        if (owners[name]?.address !== address || owners[name]?.network !== assetName) {
+          staking[name] = Object.fromEntries(
+            Object.entries(staking[name] || {}).filter(([key]) => !STAKING_SNAPSHOT_FIELDS.has(key))
+          )
+          delete owners[name]
+          changed = true
+        }
+      }
+      for (const [name, patch] of Object.entries(patches)) {
+        staking[name] = { ...staking[name], ...patch }
+        owners[name] = { address, network: assetName }
+        changed = true
+      }
+      if (changed) {
+        assetClientInterface.updateAccountStateBatch({
+          assetName,
+          walletAccount,
+          newData: { staking, stakingSnapshotOwners: owners },
+          batch,
+        })
+      }
+      // No await between the final generation/address check and batch execution.
+      await assetClientInterface.executeOperationsBatch(batch)
+      // An in-flight storage commit cannot be cancelled through ACI. It is
+      // serialized before newer commits; never let it publish a stale deadline.
+      const committedAddress = await assetClientInterface.getReceiveAddress({
+        assetName,
+        walletAccount,
+        useCache: true,
+      })
+      if (
+        generations.get(accountKey) === generation &&
+        committedAddress.toString().toLowerCase() === address
+      ) {
+        for (const [key, entry] of completed) freshness.set(key, entry)
+      }
+    }
+    const previousCommit = commits.get(accountKey) || Promise.resolve()
+    const commit = previousCommit.catch(() => {}).then(publish)
+    commits.set(accountKey, commit)
+    try {
+      await commit
+    } finally {
+      if (commits.get(accountKey) === commit) commits.delete(accountKey)
+    }
   }
 
   return {
+    // A restart/resume exposed through monitor.start must rediscover restored
+    // accounts. No host screen lifecycle is assumed; update({refresh:true}) and
+    // direct getStakingInfo({address}) are explicit uncached refresh paths.
+    'before-start': () => {
+      freshness.clear()
+      addresses.clear()
+      generations.clear()
+    },
     'after-tick': afterTickHook,
   }
 }