@exodus/ethereum-api 8.78.2 → 8.79.1

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/simulation/simulate-message-api.js

@@ -30,7 +30,7 @@ const convertToAPIPayload = ({ address, message, url }) => {
 
 export const handleActionResponse = ({ simulationResult, response }) => {
   if (['BLOCK', 'WARN'].includes(response.action)) {
-    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+    // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
     simulationResult.action = response.action
   }
 }

package/src/simulation/simulate-transactions-api.js

@@ -194,7 +194,7 @@ export const simulateTransactionsApi = async ({
     }
   }
 
-  // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+  // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
   simulationResult.metadata.simulatedLocally = false
 
   const { expectedStateChanges = {}, error } = response.simulationResults.aggregated

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({
@@ -178,7 +178,7 @@ export function createEthereumStakingService({
   stakingProvider = stakingProviderClientFactory(),
 }) {
   if (deprectedArg && !assetName) {
-    console.log('using deprecated ARG `asset` instead of `assetName`')
+    console.debug('using deprecated ARG `asset` instead of `assetName`')
     assetName = deprectedArg.name
   }
 
@@ -212,7 +212,7 @@ export function createEthereumStakingService({
 
     const { to, data } = await staking.stake({ amount })
 
-    console.log(
+    console.debug(
       `delegator address ${delegatorAddress} staking ${amount.toDefaultString({
         unit: true,
       })}`
@@ -376,7 +376,7 @@ export function createEthereumStakingService({
       },
     }
 
-    console.log(
+    console.debug(
       `delegator address ${delegatorAddress} unstaking ${requestedAmount.toDefaultString({
         unit: true,
       })} - pending amount: ${pendingAmount.toDefaultString({ unit: true })}`
@@ -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/staking/utils/index.js

@@ -1,10 +1,8 @@
-// eslint-disable-next-line @exodus/import/no-deprecated
 import { isNumberUnit } from '@exodus/currency'
 
 export const DISABLE_BALANCE_CHECKS = '0x0'
 
 export function amountToCurrency({ asset, amount }) {
-  // eslint-disable-next-line @exodus/import/no-deprecated
   return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
 }
 

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

@@ -19,6 +19,7 @@ import {
   getCurrentEIP7702Delegation,
   getDeriveDataNeededForTick,
   getDeriveTransactionsToCheck,
+  isUnverifiablePendingTxExpired,
   verifyRpcPendingTxStatusBatch,
 } from './monitor-utils/index.js'
 
@@ -90,19 +91,23 @@ export class ClarityMonitor extends BaseMonitor {
 
   // eslint-disable-next-line no-undef
   async checkPendingTransactions(params) {
-    const { pendingTransactionsToCheck, pendingTransactionsGroupedByAddressAndNonce } =
-      checkPendingTransactions(params)
+    const {
+      pendingTransactionsToCheck,
+      pendingTransactionsGroupedByAddressAndNonce,
+      recentPendingTransactions,
+    } = checkPendingTransactions(params)
     const txsToRemove = []
     const { walletAccount } = params
 
-    const updateTx = (tx, asset, { error, remove }) => {
+    const updateTx = (tx, asset, { error, remove, preserve, isTxConfirmed }) => {
       if (remove) {
         txsToRemove.push({ tx, assetSource: { asset, walletAccount } })
+      } else if (preserve) {
+        params.logItemsByAsset[asset].push(tx)
       } else {
         params.logItemsByAsset[asset].push({
           ...tx,
-          dropped: true,
-          error,
+          ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error }),
         })
       }
 
@@ -115,11 +120,15 @@ export class ClarityMonitor extends BaseMonitor {
             assetSource: { asset: assetName, walletAccount },
           })
         } else if (tokenTxSet && tokenTxSet.has(tx.txId)) {
-          params.logItemsByAsset[assetName].push({
-            ...tokenTxSet.get(tx.txId),
-            error,
-            dropped: true,
-          })
+          // Optional: the stored tx may name a token since removed from the registry
+          params.logItemsByAsset[assetName]?.push(
+            preserve
+              ? tokenTxSet.get(tx.txId)
+              : {
+                  ...tokenTxSet.get(tx.txId),
+                  ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error }),
+                }
+          )
         }
       })
       return Promise.all(promises)
@@ -131,28 +140,55 @@ export class ClarityMonitor extends BaseMonitor {
       if (replaced) {
         await updateTx(tx, assetName, { remove: true })
         delete pendingTransactionsToCheck[tx.txId]
+        delete recentPendingTransactions[tx.txId]
       }
     }
 
-    // Batch verify all pending txs with a single RPC call (skip if refresh)
+    // Batch verify all pending txs with a single RPC call
     const txIds = Object.keys(pendingTransactionsToCheck)
-    const statuses = params.refresh
-      ? {}
-      : await verifyRpcPendingTxStatusBatch({
-          server: this.server,
-          logger: this.logger,
-          txIds,
-        })
+    const statuses = await verifyRpcPendingTxStatusBatch({
+      server: this.server,
+      logger: this.logger,
+      txIds,
+    })
 
     for (const { tx, assetName } of Object.values(pendingTransactionsToCheck)) {
+      const txStatus = statuses[tx.txId]
       if (params.refresh) {
-        await updateTx(tx, assetName, { remove: true })
-      } else {
-        const txStatus = statuses[tx.txId]
         if (txStatus?.status === 'dropped') {
-          await updateTx(tx, assetName, { error: 'Dropped' })
+          await updateTx(tx, assetName, { remove: true })
+        } else if (txStatus?.status === 'confirmed') {
+          // Confirmed on-chain but missing from the indexer response: mark it
+          // confirmed so it stops being a pending entry that would otherwise be
+          // preserved (exempt from the age ceiling) on every refresh forever.
+          await updateTx(tx, assetName, { isTxConfirmed: true })
+        } else if (
+          // No txStatus at all means the whole verification batch failed - evidence
+          // about nothing, so preserve unconditionally; the age ceiling only applies
+          // to a per-entry 'unknown' verdict (evidence about that one hash).
+          !txStatus ||
+          txStatus.status === 'pending' ||
+          !isUnverifiablePendingTxExpired(tx)
+        ) {
+          // Still live on-chain (or not verifiable yet) but missing from the indexer
+          // response: re-add it so the refresh overwrite cannot wipe it and break
+          // tx-log-based nonce resolution.
+          await updateTx(tx, assetName, { preserve: true })
+        } else {
+          // Unverifiable past the age ceiling: purge so a hash the node keeps
+          // erroring on cannot pin nonce derivation forever.
+          await updateTx(tx, assetName, { remove: true })
         }
-        // status === 'confirmed' or 'pending' - tx is fine, wait for Clarity to confirm
+      } else if (txStatus?.status === 'dropped') {
+        await updateTx(tx, assetName, { error: 'Dropped' })
+      }
+      // non-refresh: 'confirmed', 'pending' or unknown - tx is fine, wait for Clarity to confirm
+    }
+
+    if (params.refresh) {
+      // Too recent for a reliable on-chain verdict - always survive the refresh overwrite
+      for (const { tx, assetName } of Object.values(recentPendingTransactions)) {
+        await updateTx(tx, assetName, { preserve: true })
       }
     }
 

package/src/tx-log/ethereum-monitor.js

@@ -12,6 +12,7 @@ import {
   getDeriveTransactionsToCheck,
   getHistoryFromServer,
   getLogItemsFromServerTx,
+  isUnverifiablePendingTxExpired,
   verifyRpcPendingTxStatusBatch,
 } from './monitor-utils/index.js'
 import {
@@ -74,16 +75,21 @@ export class EthereumMonitor extends BaseMonitor {
 
   // eslint-disable-next-line no-undef
   async checkPendingTransactions(params) {
-    const { pendingTransactionsToCheck, pendingTransactionsGroupedByAddressAndNonce } =
-      checkPendingTransactions(params)
+    const {
+      pendingTransactionsToCheck,
+      pendingTransactionsGroupedByAddressAndNonce,
+      recentPendingTransactions,
+    } = checkPendingTransactions(params)
     const txsToRemove = []
     const {
       assetSource: { walletAccount },
     } = params
 
-    const updateTx = (tx, asset, { isTxConfirmed, remove }) => {
+    const updateTx = (tx, asset, { isTxConfirmed, remove, preserve }) => {
       if (remove) {
         txsToRemove.push({ tx, assetSource: { asset, walletAccount } })
+      } else if (preserve) {
+        params.logItemsByAsset[asset].push(tx)
       } else {
         params.logItemsByAsset[asset].push({
           ...tx,
@@ -100,10 +106,15 @@ export class EthereumMonitor extends BaseMonitor {
             assetSource: { asset: assetName, walletAccount },
           })
         } else if (tokenTxSet && tokenTxSet.has(tx.txId)) {
-          params.logItemsByAsset[assetName].push({
-            ...tokenTxSet.get(tx.txId),
-            ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error: 'Dropped' }),
-          })
+          // Optional: the stored tx may name a token since removed from the registry
+          params.logItemsByAsset[assetName]?.push(
+            preserve
+              ? tokenTxSet.get(tx.txId)
+              : {
+                  ...tokenTxSet.get(tx.txId),
+                  ...(isTxConfirmed ? { confirmations: 1 } : { dropped: true, error: 'Dropped' }),
+                }
+          )
         }
       })
 
@@ -116,30 +127,50 @@ export class EthereumMonitor extends BaseMonitor {
       if (replaced) {
         await updateTx(tx, assetName, { remove: true })
         delete pendingTransactionsToCheck[tx.txId]
+        delete recentPendingTransactions[tx.txId]
       }
     }
 
-    // Batch verify all pending txs with a single RPC call (skip if refresh)
+    // Batch verify all pending txs with a single RPC call
     const txIds = Object.keys(pendingTransactionsToCheck)
-    const statuses = params.refresh
-      ? {}
-      : await verifyRpcPendingTxStatusBatch({
-          server: this.server,
-          logger: this.logger,
-          txIds,
-        })
+    const statuses = await verifyRpcPendingTxStatusBatch({
+      server: this.server,
+      logger: this.logger,
+      txIds,
+    })
 
     for (const { tx, assetName } of Object.values(pendingTransactionsToCheck)) {
-      if (params.refresh) {
-        await updateTx(tx, assetName, { remove: true })
-      } else {
-        const txStatus = statuses[tx.txId]
-        if (txStatus?.status === 'confirmed') {
-          await updateTx(tx, assetName, { isTxConfirmed: true })
-        } else if (txStatus?.status === 'dropped') {
+      const txStatus = statuses[tx.txId]
+      if (txStatus?.status === 'confirmed') {
+        await updateTx(tx, assetName, { isTxConfirmed: true })
+      } else if (txStatus?.status === 'dropped') {
+        if (params.refresh) {
+          await updateTx(tx, assetName, { remove: true })
+        } else {
           await updateTx(tx, assetName, { isTxConfirmed: false })
         }
-        // status === 'pending' or missing - tx still in mempool, do nothing
+      } else if (params.refresh) {
+        // No txStatus at all means the whole verification batch failed - evidence
+        // about nothing, so preserve unconditionally; the age ceiling only applies
+        // to a per-entry 'unknown' verdict (evidence about that one hash).
+        if (!txStatus || txStatus.status === 'pending' || !isUnverifiablePendingTxExpired(tx)) {
+          // Still in the mempool (or not verifiable yet) but missing from the history
+          // server response: re-add it so the refresh overwrite cannot wipe it and
+          // break tx-log-based nonce resolution.
+          await updateTx(tx, assetName, { preserve: true })
+        } else {
+          // Unverifiable past the age ceiling: purge so a hash the node keeps
+          // erroring on cannot pin nonce derivation forever.
+          await updateTx(tx, assetName, { remove: true })
+        }
+      }
+      // non-refresh: 'pending' or unknown - tx still in mempool, do nothing
+    }
+
+    if (params.refresh) {
+      // Too recent for a reliable on-chain verdict - always survive the refresh overwrite
+      for (const { tx, assetName } of Object.values(recentPendingTransactions)) {
+        await updateTx(tx, assetName, { preserve: true })
       }
     }
 

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

@@ -82,7 +82,7 @@ export const getOptimisticTxLogEffects = async ({
     maybeTxToReplace && maybeTxToReplace.feeAmount.lt(feeAmount) ? maybeTxToReplace.txId : undefined
 
   if (!replacedTxId && maybeTxToReplace) {
-    console.log('Attempting to replace a transaction using an insufficient fee!')
+    console.debug('Attempting to replace a transaction using an insufficient fee!')
   }
 
   // Contains effects for smart-contract initiated token movements.