Viem Migration - Failed onchain TXs are not detected

apps/cowswap-frontend/src/common/hooks/useGetReceipt.ts

@@ -5,7 +5,7 @@ import { SupportedChainId } from '@cowprotocol/cow-sdk'
 import { Command } from '@cowprotocol/types'
 
 import { useConfig } from 'wagmi'
-import { waitForTransactionReceipt } from 'wagmi/actions'
+import { getTransaction, getTransactionReceipt } from 'wagmi/actions'
 
 import type { TransactionReceipt, Hex } from 'viem'
 
@@ -19,21 +19,56 @@ interface RetryResult<T> {
 
 export type GetReceipt = (hash: string) => RetryResult<TransactionReceipt>
 
+/**
+ * Thrown when a transaction hash is not found on-chain or in the mempool.
+ * This typically occurs with MetaMask Smart Transactions (STX) where a synthetic hash
+ * is returned to the dapp but the transaction is cancelled before being broadcast.
+ */
+export class TransactionNotBroadcastError extends Error {
+  constructor(hash: string) {
+    super(`Transaction ${hash} not found on-chain or in mempool`)
+    this.name = 'TransactionNotBroadcastError'
+  }
+}
+
 export function useGetReceipt(chainId: SupportedChainId): GetReceipt {
   const config = useConfig()
 
   const getReceipt = useCallback<GetReceipt>(
     (hash) => {
       const retryOptions = RETRY_OPTIONS_BY_CHAIN_ID[chainId] || DEFAULT_RETRY_OPTIONS
 
-      return retry(() => {
-        return waitForTransactionReceipt(config, { hash: hash as Hex }).then((receipt) => {
-          if (receipt === null) {
-            console.debug('[useGetReceipt] Retrying for hash', hash)
+      return retry(async () => {
+        // Check if the receipt is already available (non-blocking, returns immediately).
+        // Swallow all errors — any failure just means "no receipt yet" and we proceed to
+        // check whether the transaction exists at all.
+        const receipt = await getTransactionReceipt(config, { hash: hash as Hex }).catch(() => null)
+        if (receipt) return receipt
+
+        // No receipt. Check whether the transaction exists anywhere (mempool or chain).
+        // If it doesn't exist, the hash was never broadcast — e.g. MetaMask Smart Transactions
+        // returns a synthetic hash that is cancelled before any real tx is submitted.
+        let txExists: boolean
+        try {
+          await getTransaction(config, { hash: hash as Hex })
+          txExists = true
+        } catch (e: unknown) {
+          const name = (e as { name?: string })?.name
+          if (name === 'TransactionNotFoundError') {
+            txExists = false
+          } else {
+            // Network / RPC error (e.g. 402, timeout): we can't determine if the tx exists.
+            // Retry the check on the next attempt rather than making an assumption.
             throw new RetryableError()
           }
-          return receipt
-        })
+        }
+
+        if (!txExists) {
+          throw new TransactionNotBroadcastError(hash)
+        }
+
+        // Transaction is in the mempool but not yet mined — retry
+        throw new RetryableError()
       }, retryOptions)
     },
     [config, chainId],

apps/cowswap-frontend/src/legacy/hooks/useWrapCallback.ts

@@ -4,6 +4,7 @@ import {
   calculateGasMargin,
   formatTokenAmount,
   getIsNativeToken,
+  getProviderErrorMessage,
   getRawCurrentChainIdFromUrl,
   isRejectRequestProviderError,
 } from '@cowprotocol/common-utils'
@@ -46,6 +47,7 @@ export interface WrapUnwrapContext {
   addTransaction: TransactionAdder
   closeModals: Command
   openTransactionConfirmationModal: Command
+  openErrorModal: (message: string) => void
   analytics: ReturnType<typeof useCowAnalytics>
 }
 
@@ -73,6 +75,7 @@ export async function wrapUnwrapCallback(
     addTransaction,
     openTransactionConfirmationModal,
     closeModals,
+    openErrorModal,
     analytics,
   } = context
   const isNativeIn = getIsNativeToken(amount.currency)
@@ -98,8 +101,6 @@ export async function wrapUnwrapCallback(
 
     return { hash }
   } catch (error: unknown) {
-    useModals && closeModals()
-
     const isRejected = isRejectRequestProviderError(error)
     const action = isRejected ? t`Reject` : t`Error`
     sendWrapEvent(analytics, action as WrapAction, operationMessage, amount)
@@ -108,6 +109,13 @@ export async function wrapUnwrapCallback(
     console.error(errorMessage, error)
 
     if (isRejected) {
+      useModals && closeModals()
+      return null
+    }
+
+    if (useModals) {
+      // Show the error inside the modal (transitions from pending → error screen)
+      openErrorModal(getProviderErrorMessage(error) || t`Transaction failed`)
       return null
     }
 

apps/cowswap-frontend/src/legacy/state/enhancedTransactions/reducer.ts

@@ -165,6 +165,10 @@ export default createReducer(initialState, (builder) =>
       tx.receipt = receipt
       tx.confirmedTime = now()
 
+      if (receipt.status === 'reverted') {
+        tx.errorMessage = 'Transaction failed'
+      }
+
       if (tx.linkedTransactionHash) {
         delete transactions[chainId]?.[tx.linkedTransactionHash]
       }

apps/cowswap-frontend/src/modules/onchainTransactions/onchainTransactionsEvents.ts

@@ -13,15 +13,21 @@ interface TxReplacedPayload {
   transaction: EnhancedTransactionDetails
 }
 
+interface TxCancelledNotBroadcastPayload {
+  transaction: EnhancedTransactionDetails
+}
+
 export enum OnchainTxEvents {
   BEFORE_TX_FINALIZE = 'BEFORE_TX_FINALIZE',
   TX_REPLACED = 'TX_REPLACED',
+  TX_CANCELLED_NOT_BROADCAST = 'TX_CANCELLED_NOT_BROADCAST',
 }
 
 // Define types for event payloads
 export interface OnchainTxEventPayloadMap {
   [OnchainTxEvents.BEFORE_TX_FINALIZE]: FinalizeTxPayload
   [OnchainTxEvents.TX_REPLACED]: TxReplacedPayload
+  [OnchainTxEvents.TX_CANCELLED_NOT_BROADCAST]: TxCancelledNotBroadcastPayload
 }
 
 export const ONCHAIN_TRANSACTIONS_EVENTS = Object.freeze(

apps/cowswap-frontend/src/modules/onchainTransactions/updaters/FinalizeTxUpdater/hooks/usePendingTransactionsContext.ts

@@ -34,7 +34,9 @@ export function usePendingTransactionsContext(): CheckEthereumTransactions | nul
     async () => {
       if (!lastBlockNumber || !account) return null
 
-      const transactionsCount = await getTransactionCount(config, { address: account })
+      // Fallback to 0 on failure so receipt checking can still run even when the nonce fetch fails
+      // (e.g. temporary RPC errors). The nonce-based replacement check will simply be skipped.
+      const transactionsCount = await getTransactionCount(config, { address: account }).catch(() => 0)
 
       const params: CheckEthereumTransactions = {
         chainId,

apps/cowswap-frontend/src/modules/onchainTransactions/updaters/FinalizeTxUpdater/services/checkOnChainTransaction.ts

@@ -1,11 +1,29 @@
+import { SupportedChainId } from '@cowprotocol/cow-sdk'
+
 import { checkedTransaction } from 'legacy/state/enhancedTransactions/actions'
 import { EnhancedTransactionDetails } from 'legacy/state/enhancedTransactions/reducer'
 
+import { TransactionNotBroadcastError } from 'common/hooks/useGetReceipt'
+
 import { finalizeEthereumTransaction } from './finalizeEthereumTransaction'
 import { handleTransactionReplacement } from './handleTransactionReplacement'
 
+import { ONCHAIN_TRANSACTIONS_EVENTS, OnchainTxEvents } from '../../../onchainTransactionsEvents'
 import { CheckEthereumTransactions } from '../types'
 
+// Grace period before treating a "not found" hash as definitely not broadcast.
+// Allows time for freshly submitted transactions to propagate to the node.
+// Fast chains (Arbitrum, Base) mine transactions in <5 seconds, so a shorter
+// grace period is safe and avoids long "stuck pending" UX after STX cancellations.
+const NOT_BROADCAST_GRACE_PERIOD_MS: Record<number, number> = {
+  [SupportedChainId.MAINNET]: 60_000,
+  [SupportedChainId.GNOSIS_CHAIN]: 30_000,
+  [SupportedChainId.ARBITRUM_ONE]: 15_000,
+  [SupportedChainId.BASE]: 15_000,
+  [SupportedChainId.SEPOLIA]: 30_000,
+}
+const DEFAULT_NOT_BROADCAST_GRACE_PERIOD_MS = 30_000
+
 // TODO: Add proper return type annotation
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function checkOnChainTransaction(transaction: EnhancedTransactionDetails, params: CheckEthereumTransactions) {
@@ -34,7 +52,23 @@ export function checkOnChainTransaction(transaction: EnhancedTransactionDetails,
     .catch((error) => {
       setTxLastBlockNumber()
 
-      if (!error.isCancelledError) {
+      if (error instanceof TransactionNotBroadcastError) {
+        // The hash doesn't exist on-chain or in the mempool — it was likely a MetaMask Smart
+        // Transaction synthetic hash that was cancelled before the tx was ever broadcast.
+        // Wait for the grace period before acting to allow for node propagation delays.
+        const gracePeriodMs = NOT_BROADCAST_GRACE_PERIOD_MS[chainId] ?? DEFAULT_NOT_BROADCAST_GRACE_PERIOD_MS
+        const pendingMs = Date.now() - transaction.addedTime
+        if (pendingMs >= gracePeriodMs) {
+          console.log('[FinalizeTxUpdater] Transaction not found on-chain after grace period, marking as replaced.', {
+            hash,
+          })
+          ONCHAIN_TRANSACTIONS_EVENTS.emit(OnchainTxEvents.TX_CANCELLED_NOT_BROADCAST, { transaction })
+          handleTransactionReplacement(transaction, params)
+        }
+        return
+      }
+
+      if (!error.isCancelledError && !error.isRetryableError) {
         console.error(`[FinalizeTxUpdater] Failed to get transaction receipt for tx: ${hash}`, error)
       }
 

apps/cowswap-frontend/src/modules/onchainTransactions/updaters/OnchainTransactionEventsUpdater.tsx

@@ -9,8 +9,10 @@ import {
 } from '@cowprotocol/events'
 import { useAddSnackbar } from '@cowprotocol/snackbars'
 
+import { Trans } from '@lingui/react/macro'
 import { WIDGET_EVENT_EMITTER } from 'widgetEventEmitter'
 
+import { ONCHAIN_TRANSACTIONS_EVENTS, OnchainTxEvents } from 'modules/onchainTransactions/onchainTransactionsEvents'
 import { TransactionContentWithLink } from 'modules/orders'
 import { getCowSoundError } from 'modules/sounds'
 
@@ -62,5 +64,27 @@ export function OnchainTransactionEventsUpdater() {
     }
   }, [addSnackbar])
 
+  useEffect(() => {
+    const handler = ONCHAIN_TRANSACTIONS_EVENTS.on({
+      event: OnchainTxEvents.TX_CANCELLED_NOT_BROADCAST,
+      handler({ transaction }) {
+        getCowSoundError().play()
+        addSnackbar({
+          id: `cancelled-not-broadcast-${transaction.hash}`,
+          icon: 'alert',
+          content: (
+            <TransactionContentWithLink transactionHash={transaction.hash}>
+              <Trans>Transaction cancelled: it was not submitted to the blockchain.</Trans>
+            </TransactionContentWithLink>
+          ),
+        })
+      },
+    })
+
+    return () => {
+      ONCHAIN_TRANSACTIONS_EVENTS.off(handler)
+    }
+  }, [addSnackbar])
+
   return null
 }

apps/cowswap-frontend/src/modules/trade/containers/TradeWidget/TradeWidgetModals.tsx

@@ -51,7 +51,8 @@ export function TradeWidgetModals({
 
   const { isOpen: isTradeReviewOpen, error: confirmError, pendingTrade } = useTradeConfirmState()
   const { field } = useSelectTokenWidgetState()
-  const [{ isOpen: isWrapNativeOpen }, setWrapNativeScreenState] = useWrapNativeScreenState()
+  const [{ isOpen: isWrapNativeOpen, errorMessage: wrapNativeError }, setWrapNativeScreenState] =
+    useWrapNativeScreenState()
   const {
     approveInProgress,
     isPendingInProgress,
@@ -163,6 +164,14 @@ export function TradeWidgetModals({
   }
 
   if (isWrapNativeOpen) {
+    if (wrapNativeError) {
+      return (
+        <TransactionErrorContent
+          message={wrapNativeError}
+          onDismiss={() => setWrapNativeScreenState({ isOpen: false })}
+        />
+      )
+    }
     return <WrapNativeModal />
   }
 

apps/cowswap-frontend/src/modules/trade/hooks/useWrapNativeFlow.ts

@@ -96,6 +96,9 @@ function useWrapNativeContext(amount: Nullish<CurrencyAmount<Currency>>): WrapUn
       openTransactionConfirmationModal() {
         setWrapNativeState({ isOpen: true })
       },
+      openErrorModal(errorMessage: string) {
+        setWrapNativeState({ isOpen: true, errorMessage })
+      },
     }
   }, [
     wethChainId,

apps/cowswap-frontend/src/modules/trade/state/wrapNativeStateAtom.ts

@@ -2,6 +2,7 @@ import { atom } from 'jotai'
 
 interface WrapNativeState {
   isOpen: boolean
+  errorMessage?: string
 }
 
 export const wrapNativeStateAtom = atom<WrapNativeState>({

apps/cowswap-frontend/src/modules/tradeFormValidation/types.ts

@@ -27,7 +27,7 @@ export interface TradeFormButtonContext {
 
   connectWallet: Command
 
-  wrapNativeFlow(): void
+  wrapNativeFlow(): Promise<unknown>
 }
 
 export interface TradeFormValidationCommonContext {

libs/common-utils/src/misc.ts

@@ -9,7 +9,10 @@ interface Market<T = string> {
   quoteToken: T
 }
 
-const PROVIDER_REJECT_REQUEST_CODES = [4001, -32000] // See https://eips.ethereum.org/EIPS/eip-1193
+// 4001 is the standard EIP-1193 user rejection code.
+// -32000 is a generic server error used by nodes for things like "intrinsic gas too low";
+// it is NOT included here because relying on it alone causes node errors to be silently swallowed.
+const PROVIDER_REJECT_REQUEST_CODES = [4001] // See https://eips.ethereum.org/EIPS/eip-1193
 const PROVIDER_REJECT_REQUEST_ERROR_MESSAGES = [
   'User denied message signature',
   'User rejected',
@@ -123,7 +126,12 @@ export function getChainIdValues(): ChainId[] {
  */
 export function getProviderErrorMessage(error: unknown): string | undefined {
   if (typeof error === 'string') return error
-  if (error && typeof error === 'object' && 'message' in error) return error.message as string
+  if (error && typeof error === 'object') {
+    // Prefer viem's shortMessage (concise, human-readable) over the full message
+    // which includes verbose request arguments and hex data.
+    if ('shortMessage' in error && typeof error.shortMessage === 'string') return error.shortMessage
+    if ('message' in error) return error.message as string
+  }
   return error?.toString()
 }