feat(wallet-core): record private sends and route their estimates via privatePending

Third of three stacked changes for the blockbook privatePending hint
(trezor/blockbook#1639). First change with observable behavior: it fills the slice
from the two flows whose signed nonce is already in scope, and routes their gas
estimates.

- isMevPrivateSend(symbol, isMevProtectionEnabled) predicate (wallet-utils) - the
  exact condition under which getMevProtectedTxData broadcasts through the relay;
- record the private nonce+txid after a successful pushTransaction in the send flow
  (pushSendFormTransactionThunk) and in WalletConnect eth_sendTransaction, gated by
  isMevPrivateSend so public sends never declare;
- adopt buildEvmEstimateSpecific at the send and allowance estimate sites, passing
  the account's private-pending nonces so the estimate simulates against the relay's
  pending-private state - presence-only, so a keystroke with nothing in flight never
  routes to the relay.

Deferred (see PR description): staking / Merkl-claim / stablecoin-yield writes need
signed-nonce capture first (PrecomposedTransactionFinal carries no nonce); until
then those private flows fall back to blockbook's recentSenders heuristic, which is
acceptable because #1639 keeps that heuristic as the fallback. IndexedDB persistence
also deferred.

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

Author: pragmaxim

suite-common/wallet-core/src/allowance/composeAllowanceTransactionThunk.ts

@@ -7,13 +7,18 @@ import {
     type FeeLevelLabel,
     type PrecomposedLevels,
 } from '@suite-common/wallet-types';
-import { findToken, getAccountIdentity } from '@suite-common/wallet-utils';
+import {
+    buildEvmEstimateSpecific,
+    findToken,
+    getAccountIdentity,
+} from '@suite-common/wallet-utils';
 import TrezorConnect from '@trezor/connect';
 import { BigNumber, typedObjectFromEntries } from '@trezor/utils';
 
 import { ALLOWANCE_MODULE_PREFIX } from './allowanceConstants';
 import { buildAllowanceTransaction } from './buildAllowanceTransaction';
 import { ETHEREUM_ADJUST_GAS_LIMIT } from '../fees/feesUtils';
+import { selectAccountPrivatePendingNonces } from '../privatePending/privatePendingReducer';
 import { type ComposeFeeLevelsError } from '../send/sendFormTypes';
 
 export interface ComposeAllowanceTransactionThunkParams {
@@ -36,7 +41,10 @@ export const composeAllowanceTransactionThunk = createThunk<
     { rejectValue: ComposeFeeLevelsError }
 >(
     `${ALLOWANCE_MODULE_PREFIX}/composeAllowanceTransactionThunk`,
-    async ({ feeInfo, account, contract, selectedFee, customFee, data }, { rejectWithValue }) => {
+    async (
+        { feeInfo, account, contract, selectedFee, customFee, data },
+        { rejectWithValue, getState },
+    ) => {
         const token = findToken(account.tokens, contract);
 
         if (!token) {
@@ -51,12 +59,17 @@ export const composeAllowanceTransactionThunk = createThunk<
             identity: getAccountIdentity(account),
             request: {
                 blocks: [2],
-                specific: {
-                    from: account.descriptor,
-                    to: contract,
-                    value: '0x0',
-                    data,
-                },
+                // Route the estimate to the relay's pending-private state when this account has
+                // in-flight private txs (presence-only; no-op otherwise). See trezor/blockbook#1639.
+                specific: buildEvmEstimateSpecific(
+                    {
+                        from: account.descriptor,
+                        to: contract,
+                        value: '0x0',
+                        data,
+                    },
+                    selectAccountPrivatePendingNonces(getState(), account.key),
+                ),
             },
         });
 

suite-common/wallet-core/src/send/sendFormEthereumThunks.ts

@@ -23,6 +23,7 @@ import {
 import {
     asAmountSubunit,
     asAmountUnit,
+    buildEvmEstimateSpecific,
     calculateMax,
     calculateTotal,
     calculateTotalGasCost,
@@ -57,6 +58,7 @@ import {
     type SignTransactionError,
     type SignTransactionThunkArguments,
 } from './sendFormTypes';
+import { selectAccountPrivatePendingNonces } from '../privatePending/privatePendingReducer';
 import { selectAddressDisplayType } from '../settings/walletSettingsReducer';
 import { selectAccountTransactions } from '../transactions/transactionsSelectors';
 
@@ -319,10 +321,15 @@ export const composeEthereumTransactionFeeLevelsThunk = createThunk<
             identity: getAccountIdentity(account),
             request: {
                 blocks: [2],
-                specific: {
-                    from: account.descriptor,
-                    ...ethereumEstimateFeeParams,
-                },
+                // Route the estimate to the relay's pending-private state when this account has
+                // in-flight private txs (presence-only; no-op otherwise). See trezor/blockbook#1639.
+                specific: buildEvmEstimateSpecific(
+                    {
+                        from: account.descriptor,
+                        ...ethereumEstimateFeeParams,
+                    },
+                    selectAccountPrivatePendingNonces(getState(), account.key),
+                ),
             },
         });
 

suite-common/wallet-core/src/send/sendFormThunks.ts

@@ -35,6 +35,7 @@ import {
     isEvmApprovalTxByTextSignature,
     isEvmYieldTxByTextSignature,
     isExchangeTradingForm,
+    isMevPrivateSend,
     isRbfCancelTransaction,
     subunitsToUnits,
     tryGetAccountIdentity,
@@ -84,6 +85,7 @@ import {
 import { accountsActions } from '../accounts/accountsActions';
 import { selectAccountByKey } from '../accounts/accountsSelectors';
 import { syncAccountsWithBlockchainThunk } from '../blockchain/blockchainThunks';
+import { privatePendingActions } from '../privatePending/privatePendingActions';
 import {
     selectAreSatsAmountUnit,
     selectBitcoinAmountUnit,
@@ -478,6 +480,24 @@ export const pushSendFormTransactionThunk = createThunk<
                     ethereumNonce: resolvedEthereumNonce,
                 }),
             );
+
+            // Record a genuinely-private (MEV-protected / relay-routed) EVM send so the account's
+            // subsequent getAccountInfo / estimateFee requests declare it to blockbook as
+            // privatePending (trezor/blockbook#1639). Gated by isMevPrivateSend so public sends never
+            // declare; the entry is pruned once the nonce confirms (see privatePendingReducer).
+            if (
+                selectedAccount.networkType === 'ethereum' &&
+                resolvedEthereumNonce !== undefined &&
+                isMevPrivateSend(selectedAccount.symbol, isMevProtectionEnabled)
+            ) {
+                dispatch(
+                    privatePendingActions.privatePendingAdded({
+                        accountKey: selectedAccount.key,
+                        nonce: Number(resolvedEthereumNonce),
+                        txid,
+                    }),
+                );
+            }
         } else {
             dispatch(
                 notificationsActions.addToast({

suite-common/wallet-utils/src/sendFormUtils.ts

@@ -682,6 +682,14 @@ export const getMevProtectedTxData = (
     return hex;
 };
 
+// Whether a send is genuinely private, i.e. exactly the case where getMevProtectedTxData drops
+// disableAlternativeRPC and the tx is broadcast through the alternative relay (MEV protection on AND
+// a relay-capable network). This is the condition under which the tx must be recorded and declared
+// to blockbook as privatePending. isMevProtectionEnabled is expected to already fold in the
+// message-system feature flag, as the send and walletconnect flows do.
+export const isMevPrivateSend = (symbol: NetworkSymbol, isMevProtectionEnabled: boolean): boolean =>
+    isMevProtectionEnabled && getNetwork(symbol).features.includes('mev-protection');
+
 export const isExchangeTradingForm = (
     form: FormStateTrading | undefined,
 ): form is FormStateTradingExchange => form?.activeSection === 'exchange';

suite-common/walletconnect/src/adapters/ethereum.ts

@@ -9,11 +9,17 @@ import { type Network, getNetwork, networksCollection } from '@suite-common/wall
 import { ETH_CONTRACT_CALL_BACKUP_GAS_LIMIT } from '@suite-common/wallet-constants';
 import {
     ethereumGetCurrentNonceThunk,
+    privatePendingActions,
     selectAccounts,
     selectIsMevProtectionEnabled,
 } from '@suite-common/wallet-core';
 import { type Account } from '@suite-common/wallet-types';
-import { getAccountIdentity, getMevProtectedTxData, sanitizeHex } from '@suite-common/wallet-utils';
+import {
+    getAccountIdentity,
+    getMevProtectedTxData,
+    isMevPrivateSend,
+    sanitizeHex,
+} from '@suite-common/wallet-utils';
 import TrezorConnect, {
     type CallMethodResponse,
     type EthereumSignTypedData,
@@ -219,6 +225,25 @@ const ethereumRequestThunk = createThunk<
                 throw new Error('eth_sendTransaction push error');
             }
 
+            // Record a genuinely-private (MEV-protected / relay-routed) WalletConnect send so the
+            // account's subsequent read requests declare it to blockbook as privatePending
+            // (trezor/blockbook#1639); pruned once the nonce confirms. Uses the same combined MEV
+            // condition as the broadcast above.
+            if (
+                isMevPrivateSend(
+                    account.symbol,
+                    isMevProtectionEnabled && isMevProtectionFeatureEnabled,
+                )
+            ) {
+                dispatch(
+                    privatePendingActions.privatePendingAdded({
+                        accountKey: account.key,
+                        nonce: Number(nonce),
+                        txid: pushResponse.payload.txid,
+                    }),
+                );
+            }
+
             return pushResponse.payload.txid;
         }
         case 'wallet_switchEthereumChain': {