feat(wallet-core): track and declare private-pending nonces (slice + delivery + prune)

Second of three stacked changes for the blockbook privatePending hint
(trezor/blockbook#1639). Adds the durable model and the delivery/prune machinery;
no producer writes yet, so the slice stays empty and this is still a functional
no-op end to end.

Why a dedicated slice: the private/relay bit is transient (computed only at
broadcast in getMevProtectedTxData) and lives on neither the fake nor the real tx
object, and blockbook overwrites the fake pending tx with its real (unmarked) tx
mid-flight - so a tx-object marker cannot survive and a tx-list-derived set cannot
tell private from public. A small Redux slice keyed by (accountKey, nonce) is the
sole authoritative source; nonce is invariant across the fake->real swap.

- new suite-common/wallet-core/src/privatePending slice (Redux only for now;
  IndexedDB persistence deferred - Redux already survives WS reconnect, only an
  app restart mid-tx regresses, matching today's heuristic fallback);
- DELIVERY: attach the hint (and confirmedNonce:true) to the UNCONDITIONAL basic
  getAccountInfo call in fetchAndUpdateAccountThunk, gated on there being an
  in-flight private nonce. It must ride the basic call, not the gated details:'txs'
  one, because a blockbook-invisible private tx does not make the account
  "outdated" so the txs call is skipped for exactly the flows that need the hint;
- PRUNE (STOP): drop entries with nonce < confirmedNonce (mined) or past a TTL
  backstop, on every basic refresh - instance-agnostic, so it self-heals across
  load-balanced blockbook replicas.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: pragmaxim

packages/suite/src/reducers/wallet/index.ts

@@ -10,6 +10,7 @@ import {
     type FiatRatesState,
     type FormDraftState,
     type PhishingState,
+    type PrivatePendingState,
     type SendState,
     type StablecoinYieldState,
     type StakeState,
@@ -27,6 +28,7 @@ import {
     prepareStakeReducer,
     prepareTransactionsReducer,
     prepareWalletSettingsReducer,
+    privatePendingReducer,
     stablecoinYieldReducer,
     tronStakeReducer,
 } from '@suite-common/wallet-core';
@@ -67,6 +69,7 @@ export type WalletState = {
     accountsRefreshTime: AccountsRefreshTimeState;
     selectedAccount: SelectedAccountStatus;
     fees: FeesState;
+    privatePending: PrivatePendingState;
     blockchain: BlockchainNetworks;
     explorer: ExplorerConfig;
     trading: TradingState;
@@ -94,6 +97,7 @@ export const walletReducers: Reducer<
     accountsRefreshTime: accountsRefreshTimeReducer,
     selectedAccount: selectedAccountReducer,
     fees: feesReducer,
+    privatePending: privatePendingReducer,
     blockchain: blockchainReducer,
     explorer: explorerReducer,
     trading: tradingReducer,

suite-common/wallet-core/src/accounts/accountsThunks.ts

@@ -30,6 +30,8 @@ import {
 import { accountRefreshed } from './accountsRefreshTimeReducer';
 import { selectAccountByKey } from './accountsSelectors';
 import { selectBlockchainHeightBySymbol, selectGapLimit } from '../blockchain/blockchainReducer';
+import { privatePendingActions } from '../privatePending/privatePendingActions';
+import { selectAccountPrivatePendingHint } from '../privatePending/privatePendingReducer';
 import { selectBitcoinAmountUnit } from '../settings/walletSettingsReducer';
 import { transactionsActions } from '../transactions/transactionsActions';
 import { selectTransactions } from '../transactions/transactionsSelectors';
@@ -132,6 +134,19 @@ export const fetchAndUpdateAccountThunk = createThunk(
                 ? selectGapLimit(getState(), account.symbol)
                 : undefined;
 
+        // Declare the wallet's in-flight PRIVATE (relay) txs on the UNCONDITIONAL basic refresh so
+        // blockbook routes the pending nonce deterministically even for txs its node cannot see - and
+        // even after reconnecting to a different (load-balanced) instance, since this call fires on
+        // every connect / periodic sync / block. It rides the basic (not the gated details:'txs')
+        // call because a blockbook-invisible private tx does not make the account "outdated", so the
+        // txs call may be skipped. selectAccountPrivatePendingHint is undefined when nothing is in
+        // flight, so the hint (and the extra confirmedNonce round-trip below) are sent only when
+        // relevant - which is also the over-declaration guard. See trezor/blockbook#1639.
+        const privatePendingHint =
+            account.networkType === 'ethereum'
+                ? selectAccountPrivatePendingHint(getState(), account.key)
+                : undefined;
+
         const basic = await TrezorConnect.getAccountInfo({
             coin: account.symbol,
             identity: tryGetAccountIdentity(account),
@@ -141,10 +156,30 @@ export const fetchAndUpdateAccountThunk = createThunk(
             tokenAccountsPubKeys,
             protocols: account.networkType === 'ethereum' ? ['erc4626'] : undefined,
             gap,
+            // confirmedNonce is the trustworthy mined nonce used to prune settled private nonces
+            // below; request it only when a private tx is in flight, to avoid the extra backend call.
+            confirmedNonce: privatePendingHint ? true : undefined,
+            privatePending: privatePendingHint,
         });
 
         if (!basic.success) return;
 
+        // Prune the declared private nonces against the mined nonce on every basic refresh, BEFORE
+        // the not-outdated early-return below, so a settled or relay-dropped private nonce stops
+        // being declared. confirmedNonce is instance-agnostic, so this self-heals after reconnecting
+        // to a different blockbook instance.
+        if (privatePendingHint) {
+            const confirmedNonce = Number.parseInt(basic.payload.misc?.confirmedNonce ?? '', 10);
+            if (!Number.isNaN(confirmedNonce)) {
+                dispatch(
+                    privatePendingActions.privatePendingPruned({
+                        accountKey: account.key,
+                        confirmedNonce,
+                    }),
+                );
+            }
+        }
+
         const accountOutdated = isAccountOutdated(account, basic.payload);
         const accountTransactions = selectTransactions(getState());
         const accountTxs = getAccountTransactions(account.key, accountTransactions);

suite-common/wallet-core/src/index.ts

@@ -37,6 +37,8 @@ export * from './fees/feesReducer';
 export * from './fees/feesThunks';
 export * from './fees/feesUtils';
 export * from './fees/hooks/useRefetchFees';
+export * from './privatePending/privatePendingActions';
+export * from './privatePending/privatePendingReducer';
 export * from './fiat-rates/fiatRatesMiddleware';
 export * from './fiat-rates/fiatRatesReducer';
 export * from './fiat-rates/fiatRatesSelectors';

suite-common/wallet-core/src/privatePending/privatePendingActions.ts

@@ -0,0 +1,36 @@
+import { createAction } from '@reduxjs/toolkit';
+
+import { type AccountKey } from '@suite-common/wallet-types';
+
+export const PRIVATE_PENDING_MODULE_PREFIX = '@common/wallet-core/privatePending';
+
+// Record a genuinely-private (MEV-protected / relay-routed) in-flight tx at broadcast time. Upsert by
+// nonce so a speed-up/cancel at the same nonce rewrites the txid rather than orphaning the entry.
+const privatePendingAdded = createAction(
+    `${PRIVATE_PENDING_MODULE_PREFIX}/added`,
+    (payload: { accountKey: AccountKey; nonce: number; txid: string }) => ({
+        payload: { ...payload, submittedAt: Date.now() },
+    }),
+);
+
+// STOP condition: drop entries for one account that are now mined (nonce < confirmedNonce) or older
+// than the TTL backstop. Dispatched on every basic getAccountInfo response so it self-heals across
+// load-balanced blockbook instances (confirmedNonce is instance-agnostic). now is stamped here to
+// keep the reducer pure.
+const privatePendingPruned = createAction(
+    `${PRIVATE_PENDING_MODULE_PREFIX}/pruned`,
+    (payload: { accountKey: AccountKey; confirmedNonce: number }) => ({
+        payload: { ...payload, now: Date.now() },
+    }),
+);
+
+const privatePendingAccountRemoved = createAction(
+    `${PRIVATE_PENDING_MODULE_PREFIX}/accountRemoved`,
+    (payload: { accountKey: AccountKey }) => ({ payload }),
+);
+
+export const privatePendingActions = {
+    privatePendingAdded,
+    privatePendingPruned,
+    privatePendingAccountRemoved,
+};

suite-common/wallet-core/src/privatePending/privatePendingReducer.ts

@@ -0,0 +1,103 @@
+import { createReducer } from '@reduxjs/toolkit';
+
+import { type AccountKey } from '@suite-common/wallet-types';
+
+import { privatePendingActions } from './privatePendingActions';
+
+// A private in-flight tx must never be declared forever: if the relay drops it and it never mines,
+// confirmedNonce never advances past its nonce, so this TTL is the backstop that stops declaring a
+// nonce that will never confirm (bounds the trezor/blockbook#1629 over-declaration window). Kept a
+// little above the send flow's fake-pending-tx TTL (~15 min) so a slow relay inclusion is not
+// dropped prematurely (which would re-open under-declaration).
+export const PRIVATE_PENDING_TTL_MS = 20 * 60 * 1000;
+
+export interface PrivatePendingEntry {
+    nonce: number;
+    txid: string;
+    submittedAt: number;
+}
+
+// Keyed by account.key (a template-literal type, hence the string index). Only genuinely-private
+// (MEV-protected) in-flight txs are recorded here; this slice is the sole source of truth for the
+// privatePending hint - deliberately NOT derived from the tx list, which cannot represent the
+// private/public bit and misses the staking / walletconnect / claim flows that leave no tx-list
+// artifact.
+export type PrivatePendingState = {
+    [accountKey: string]: PrivatePendingEntry[];
+};
+
+export type PrivatePendingRootState = {
+    wallet: { privatePending: PrivatePendingState };
+};
+
+export const privatePendingInitialState: PrivatePendingState = {};
+
+export const privatePendingReducer = createReducer(privatePendingInitialState, builder => {
+    builder
+        .addCase(privatePendingActions.privatePendingAdded, (state, { payload }) => {
+            const { accountKey, nonce, txid, submittedAt } = payload;
+            if (!state[accountKey]) {
+                state[accountKey] = [];
+            }
+            const existing = state[accountKey].find(entry => entry.nonce === nonce);
+            if (existing) {
+                existing.txid = txid;
+                existing.submittedAt = submittedAt;
+            } else {
+                state[accountKey].push({ nonce, txid, submittedAt });
+            }
+        })
+        .addCase(privatePendingActions.privatePendingPruned, (state, { payload }) => {
+            const { accountKey, confirmedNonce, now } = payload;
+            const entries = state[accountKey];
+            if (!entries) return;
+            const kept = entries.filter(
+                entry =>
+                    entry.nonce >= confirmedNonce &&
+                    now - entry.submittedAt < PRIVATE_PENDING_TTL_MS,
+            );
+            if (kept.length > 0) {
+                state[accountKey] = kept;
+            } else {
+                delete state[accountKey];
+            }
+        })
+        .addCase(privatePendingActions.privatePendingAccountRemoved, (state, { payload }) => {
+            delete state[payload.accountKey];
+        });
+});
+
+const selectAccountPrivatePendingEntries = (
+    state: PrivatePendingRootState,
+    accountKey: AccountKey,
+    // Optional chaining tolerates a partial store that omits this slice (e.g. hook unit tests with a
+    // hand-built mock state); the real store always initializes it via combineReducers.
+): PrivatePendingEntry[] | undefined => state.wallet.privatePending?.[accountKey];
+
+// The unpruned private nonces for this account, ascending. The routing/floor source for both hint
+// sites. Deliberately independent of the tx list so the no-fake-tx flows stay covered.
+export const selectAccountPrivatePendingNonces = (
+    state: PrivatePendingRootState,
+    accountKey: AccountKey,
+): number[] => {
+    const entries = selectAccountPrivatePendingEntries(state, accountKey);
+
+    return entries ? entries.map(entry => entry.nonce).sort((a, b) => a - b) : [];
+};
+
+// The getAccountInfo hint object, or undefined when nothing is in flight (a safe no-op, like
+// confirmedNonce's default). Returning undefined for the empty case is also what gates the extra
+// confirmedNonce round-trip and the relay routing off for accounts with no private tx in flight.
+export const selectAccountPrivatePendingHint = (
+    state: PrivatePendingRootState,
+    accountKey: AccountKey,
+): { nonces: number[]; txids: string[] } | undefined => {
+    const entries = selectAccountPrivatePendingEntries(state, accountKey);
+    if (!entries || entries.length === 0) return undefined;
+    const sorted = [...entries].sort((a, b) => a.nonce - b.nonce);
+
+    return {
+        nonces: sorted.map(entry => entry.nonce),
+        txids: sorted.map(entry => entry.txid),
+    };
+};