@exodus/ethereum-api 8.79.0 → 8.79.1

package/CHANGELOG.md

@@ -3,6 +3,39 @@
 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)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.79.0",
+  "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",
@@ -67,5 +67,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "85b01e122492dcdd4205ed06df8f4c0af545d25b"
+  "gitHead": "53bdb90b8e90413468dc13cf8960ef2aa64dac4b"
 }

package/src/create-asset-utils.js

@@ -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/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,
   }
 }

package/src/hooks/staking-freshness.js

@@ -0,0 +1,65 @@
+import { isPendingTxInLog } from '@exodus/ethereum-lib'
+
+import { EthereumStaking } from '../staking/ethereum/api.js'
+import { MaticStakingApi } from '../staking/matic/api.js'
+
+const STAKING_FIELDS = ['delegate', 'undelegate', 'undelegatePending', 'claimUndelegate', 'rewards']
+
+// Inspect both logs: Polygon calls without token transfers only live in ETH's
+// log. Any interaction with a staking contract is conservatively relevant.
+export const getStakingActivity = ({ assetName, txLogs }) => {
+  const addresses =
+    assetName === 'polygon'
+      ? [MaticStakingApi.EVERSTAKE_VALIDATOR_CONTRACT_ADDR, MaticStakingApi.STAKING_MANAGER_ADDR]
+      : Object.values(EthereumStaking.addresses[assetName] || {})
+  const contracts = new Set(addresses.map((address) => address.toLowerCase()))
+  const isContract = (address) =>
+    typeof address === 'string' && contracts.has(address.toLowerCase())
+  const entries = new Map()
+  let pending = false
+  for (const txs of txLogs) {
+    for (const tx of txs) {
+      const relevant =
+        isContract(tx.to) ||
+        (Array.isArray(tx.from) ? tx.from.some(isContract) : isContract(tx.from)) ||
+        (tx.coinName === assetName &&
+          STAKING_FIELDS.some((field) => tx.data?.[field] !== undefined))
+      if (!relevant) continue
+      const isPending = isPendingTxInLog(tx)
+      pending ||= isPending
+      // Do not include increasing confirmation counts or processor-added metadata:
+      // neither constitutes a new staking event. Include block identity for reorgs.
+      entries.set(`${tx.coinName}:${tx.txId}`, [
+        tx.txId,
+        isPending,
+        tx.confirmations > 0,
+        tx.error || null,
+        !!tx.dropped,
+        tx.data?.replacedBy || null,
+        tx.data?.blockHash || tx.blockHash || null,
+        tx.data?.blockNumber || tx.blockHeight || null,
+      ])
+    }
+  }
+  return {
+    pending,
+    fingerprint: JSON.stringify([...entries].sort(([a], [b]) => a.localeCompare(b))),
+  }
+}
+
+export const stakingStateInterval = (info) => {
+  // A pending validator activation/exit is chain state, not a pending local tx.
+  // It must never keep a wallet on the one-minute transaction cadence forever.
+  const active =
+    info.isDelegating ||
+    info.isUndelegateInProgress ||
+    info.canClaimUndelegatedBalance ||
+    [
+      'delegatedBalance',
+      'pendingBalance',
+      'pendingDepositedBalance',
+      'unclaimedUndelegatedBalance',
+      'liquidRewards',
+    ].some((key) => info[key]?.isPositive)
+  return (active ? 5 : 15) * 60_000
+}

package/src/index.js

@@ -42,6 +42,8 @@ export { getHistoricalBalanceFactory } from './get-historical-balance.js'
 export { createEncodeMultisigContract } from './multisig-address.js'
 
 export { FantomStaking, stakingProviderClientFactory } from './staking/index.js'
+export { EthLikeRpcRequestAccumulator } from './multicall3/index.js'
+export { createCachedStakingRead } from './staking/cached-read.js'
 export { ethereumStakingDeps } from './staking/ethereum/deps.js'
 export { getEthereumStakingInfo, createEthereumStakingService } from './staking/ethereum/service.js'
 export { EthereumStaking } from './staking/ethereum/api.js'

package/src/staking/api/index.js

@@ -7,6 +7,7 @@ export const stakingApiFactory = ({
   server, // coin node server
   stakingConfiguration,
   stakingDependencies,
+  createRpcRequestAccumulator,
 }) => {
   assert(assetName, '"assetName" is required')
   assert(currency, '"currency" is required')
@@ -18,7 +19,14 @@ export const stakingApiFactory = ({
   const { contracts, minAmount } = stakingConfiguration
   const { stakingServerFactory, stakingServiceFactory } = stakingDependencies
 
-  const stakingServer = stakingServerFactory({ assetName, currency, server, minAmount, contracts })
+  const stakingServer = stakingServerFactory({
+    assetName,
+    currency,
+    server,
+    minAmount,
+    contracts,
+    createRpcRequestAccumulator,
+  })
 
   const stakingService = stakingServiceFactory({
     assetClientInterface,

package/src/staking/cached-read.js

@@ -0,0 +1,33 @@
+// Background-only caching. Callers outside the monitor always request fresh data.
+// Keep this state in memory: restored accounts must be discovered again immediately.
+export const createCachedStakingRead = ({
+  read,
+  interval = 15 * 60_000,
+  now = () => performance.now(),
+}) => {
+  const entries = new Map()
+  return async (key, { useCache = false } = {}) => {
+    let entry = entries.get(key)
+    if (!entry) {
+      entry = { generation: 0 }
+      entries.set(key, entry)
+    }
+    if (useCache) {
+      if (entry.pending) return entry.pending
+      if (entry.deadline > now()) return entry.value
+    }
+    const generation = ++entry.generation
+    const pending = Promise.resolve().then(() => read(key))
+    entry.pending = pending
+    try {
+      const value = await pending
+      if (entry.generation === generation) {
+        entry.value = value
+        entry.deadline = now() + interval
+      }
+      return value
+    } finally {
+      if (entry.generation === generation) entry.pending = undefined
+    }
+  }
+}

package/src/staking/ethereum/api.js

@@ -5,6 +5,8 @@ import { retry } from '@exodus/simple-retry'
 
 import { EVM_ERROR_REASONS, withErrorReason } from '../../error-wrapper.js'
 import { getServerByName } from '../../exodus-eth-server/index.js'
+import { EthLikeRpcRequestAccumulator } from '../../multicall3/index.js'
+import { createCachedStakingRead } from '../cached-read.js'
 
 // TODO: Shouldn't this be a function of `ethereumStakingState.minDelegateAmount`?
 const MIN_AMOUNT = '0.1'
@@ -93,6 +95,45 @@ export class EthereumStaking {
     })
   }
 
+  // Do not use Multicall for these reads without verifying the deployed Accounting
+  // implementation (currently unverified). JSON-RPC batching preserves msg.sender
+  // and isolated eth_call execution, including autocompound simulation semantics.
+  async getStakingState(address) {
+    const read = () => {
+      const requests = new EthLikeRpcRequestAccumulator()
+      for (const method of [
+        'autocompoundBalanceOf',
+        'pendingBalanceOf',
+        'pendingDepositedBalanceOf',
+        'withdrawRequest',
+      ]) {
+        requests.contractStaticCallRequest(this.contractAccounting, method, address)
+      }
+      return requests.flush(this.server || getServerByName(this.asset.name))
+    }
+    const [[active], [pending], [deposited], [requested, readyForClaim]] = await withErrorReason({
+      promise: retry(read, { delayTimesMs: RETRY_DELAYS })(),
+      errorReasonInfo: EVM_ERROR_REASONS.ethCallFailed,
+      hint: safeString`stakingEthReadFunctionContract`,
+      baseAssetName: this.asset.name,
+    })
+    const { currency } = this.asset
+    return {
+      activeStakedBalance: currency.baseUnit(active),
+      pendingBalance: currency.baseUnit(pending),
+      pendingDepositedBalance: currency.baseUnit(deposited),
+      withdrawRequest: {
+        requested: currency.baseUnit(requested),
+        readyForClaim: currency.baseUnit(readyForClaim),
+        canSendClaimRequest: requested !== '0' && requested === readyForClaim,
+      },
+    }
+  }
+
+  getCachedTotalRewards = createCachedStakingRead({
+    read: (address) => this.getTotalRewards(address, { throwOnError: true }),
+  })
+
   // === ACCOUNTING ===
 
   /** Return total deposited and activated pool balance */
@@ -163,7 +204,7 @@ export class EthereumStaking {
     return compoundBalance.sub(depositedBalance)
   }
 
-  async getTotalRewards(address) {
+  async getTotalRewards(address, { throwOnError = false } = {}) {
     // use external everstake API to get total rewards
     const url = new URL(EVERSTAKE_API_URL)
 
@@ -177,11 +218,21 @@ export class EthereumStaking {
 
     try {
       const response = await fetch(url.toString(), options)
+      if (!response.ok) throw new Error('Failed to fetch ETH total rewards')
       const rewards = await response.json()
       if (rewards === 'address') return this.asset.currency.ZERO // address not found
+      if (
+        !(
+          (typeof rewards === 'string' && /^\d+$/.test(rewards)) ||
+          (Number.isSafeInteger(rewards) && rewards >= 0)
+        )
+      ) {
+        throw new Error('Malformed ETH total rewards')
+      }
       return this.asset.currency.baseUnit(rewards)
     } catch (error) {
       console.warn('Error fetching ETH total rewards:', error)
+      if (throwOnError) throw error
       return this.asset.currency.ZERO
     }
   }

package/src/staking/ethereum/deps.js

@@ -14,11 +14,15 @@ export const stakingServiceFactory = ({ assetClientInterface, server, stakingSer
 
   return {
     ...service,
-    getStakingInfo: ({ address }) =>
+    getStakingInfo: ({ address, useCache = false, useQueueCache = useCache, background = false }) =>
       getEthereumStakingInfo({
         address,
         asset: stakingServer.asset,
         server,
+        staking: stakingServer,
+        useCache,
+        useQueueCache,
+        background,
       }),
     stake: service.delegate,
     unstake: service.undelegate,

package/src/staking/ethereum/everstake.js

@@ -2,6 +2,7 @@ import { fetch as exodusFetch } from '@exodus/fetch'
 import { TraceId } from '@exodus/traceparent'
 import assert from 'minimalistic-assert'
 
+import { createCachedStakingRead } from '../cached-read.js'
 import { UNSTAKE_DEFAULTS } from './api.js'
 
 const BASE_URL = 'https://eth-clarity.a.exodus.io/api/v2/ethereum/proxy/everstake/'
@@ -79,6 +80,12 @@ export const simulateEverstakeUnstake = async ({
   }
 }
 
+// The queue is global, not delegator-specific. Share successful background reads
+// across wallets; explicit refreshes bypass both its deadline and in-flight work.
+export const getCachedEverstakeValidatorsQueue = createCachedStakingRead({
+  read: () => getEverstakeValidatorsQueue(),
+})
+
 export const getEverstakeValidatorsQueue = async () => {
   // https://swagger.eth-api-b2c.everstake.one/#/Staking/validatorsQueue
   const result = await fetch('v1/validators/queue')

package/src/staking/ethereum/service.js

@@ -70,7 +70,7 @@ 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'
 import { EthereumStaking } from './api.js'
-import { getEverstakeValidatorsQueue } from './everstake.js'
+import { getCachedEverstakeValidatorsQueue } from './everstake.js'
 import { simulateUndelegateTransactions } from './staking-utils.js'
 
 const WETH9_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'
@@ -99,7 +99,7 @@ const STAKING_OPERATION_FALLBACK_FEE_ESTIMATES = {
 
 const getStakingApi = memoize(
   (asset) => new EthereumStaking(asset.name, asset.currency, undefined, asset.server),
-  (asset) => asset.name
+  (asset) => asset
 )
 
 export async function getUndelegatePendingData({
@@ -775,25 +775,29 @@ export function createEthereumStakingService({
   }
 }
 
-export async function getEthereumStakingInfo({ address, asset, server }) {
-  const { name: assetName, currency } = asset
+export async function getEthereumStakingInfo({
+  address,
+  asset,
+  server,
+  staking = new EthereumStaking(asset.name, asset.currency, undefined, server),
+  useCache = false,
+  useQueueCache = useCache,
+  background = false,
+}) {
+  const { currency } = asset
   const delegator = address.toLowerCase()
-  const staking = new EthereumStaking(assetName, currency, undefined, server)
-
   const [
-    activeStakedBalance,
-    pendingBalance,
-    pendingDepositedBalance,
-    withdrawRequest,
+    { activeStakedBalance, pendingBalance, pendingDepositedBalance, withdrawRequest },
     rewardsBalance,
     everstakeValidatorsQueue,
   ] = await Promise.all([
-    staking.autocompoundBalanceOf(delegator),
-    staking.pendingBalanceOf(delegator),
-    staking.pendingDepositedBalanceOf(delegator),
-    staking.withdrawRequest(delegator),
-    staking.getTotalRewards(delegator),
-    getEverstakeValidatorsQueue().catch(() => null),
+    staking.getStakingState(delegator),
+    // Provider availability must not prevent restoring on-chain stake. Omit
+    // failed metadata so the monitor preserves the last successful rewards.
+    staking
+      .getCachedTotalRewards(delegator, { useCache })
+      .catch(() => (background ? null : currency.ZERO)),
+    getCachedEverstakeValidatorsQueue('ethereum', { useCache: useQueueCache }).catch(() => null),
   ])
 
   const delegatedBalance = activeStakedBalance.add(pendingBalance).add(pendingDepositedBalance)
@@ -813,7 +817,7 @@ export async function getEthereumStakingInfo({ address, asset, server }) {
   const unclaimedUndelegatedBalance = requested
 
   return {
-    rewardsBalance,
+    ...(rewardsBalance !== null && { rewardsBalance }),
     isDelegating,
     activeStakedBalance, // balance staked into the validator
     delegatedBalance, // balance staked into the validator + pending
@@ -823,8 +827,12 @@ export async function getEthereumStakingInfo({ address, asset, server }) {
     unclaimedUndelegatedBalance,
     canClaimUndelegatedBalance,
     isUndelegateInProgress,
-    validatorActivationTime: everstakeValidatorsQueue?.validatorActivationTime,
-    validatorExitTime: everstakeValidatorsQueue?.validatorExitTime,
-    validatorWithdrawTime: everstakeValidatorsQueue?.validatorWithdrawTime,
+    // Do not replace previous queue estimates with undefined on a transient failure.
+    ...(!background && {
+      validatorActivationTime: undefined,
+      validatorExitTime: undefined,
+      validatorWithdrawTime: undefined,
+    }),
+    ...everstakeValidatorsQueue,
   }
 }

package/src/tx-log/monitor-utils/get-transfers-by-token-name.js

@@ -1,4 +1,5 @@
-import lodash from 'lodash'
+import { omit } from '@exodus/basic-utils'
+import lodash from 'lodash' // oxlint-disable-line @exodus/oxlint-plugin-restricted-imports/prefer-basic-utils -- groupBy not in basic-utils
 
 // Sorts an array of token transfer events into an object of transfer event arrays,
 // whose keys are the names of the tokens which are being transferred in the corresponding array.
@@ -12,5 +13,5 @@ export default function getTransfersByTokenName(transfers, tokensByAddress) {
     transfers,
     (transfer) => tokensByAddress.get(transfer.address.toLowerCase())?.name || 'UNKNOWN'
   )
-  return lodash.omit(transfersByTokenName, 'UNKNOWN')
+  return omit(transfersByTokenName, ['UNKNOWN'])
 }