fix(twap): label open orders as unfillable when Safe fallback handler is reset

apps/cowswap-frontend/src/entities/twap/services/mapTwapOrderToStoreOrder.ts

@@ -37,5 +37,6 @@ export function mapTwapOrderToStoreOrder(order: TwapOrderItem, tokensByAddress:
     status,
     apiAdditionalInfo: enrichedOrder,
     isCancelling: order.status === TwapOrderStatus.Cancelling,
+    isUnfillable: order.isUnfillable,
   }
 }

apps/cowswap-frontend/src/modules/ordersTable/containers/OrderRow/OrderRow.styled.tsx

@@ -195,6 +195,16 @@ export const CancelledDisplay = styled.div`
   font-size: 12px;
 `
 
+export const UnfillableDisplay = styled.div`
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  cursor: help;
+  color: var(${UI.COLOR_DANGER});
+  font-weight: 500;
+  font-size: 12px;
+`
+
 export const ExpiredDisplay = styled.div`
   display: flex;
   align-items: center;

apps/cowswap-frontend/src/modules/ordersTable/hooks/useOrdersTableList.ts

@@ -57,11 +57,19 @@ export function useOrdersTableList(
 
           const isPending = PENDING_STATES.includes(order.status)
           const isSigning = order.status === OrderStatus.PRESIGNATURE_PENDING
+          // Composable (TWAP) orders are emulated and carry a derived `isUnfillable` flag
+          // (e.g. Safe fallback handler reset). Regular orders derive it from balance/allowance here.
+          const isComposableOrder = getIsComposableCowOrder(order)
 
           // Check if order is unfillable (insufficient balance or allowance)
           const params = getOrderParams(chainId, balancesAndAllowances, order, pendingOrdersPermitValidityState)
           let isUnfillable = params.hasEnoughBalance === false || params.hasEnoughAllowance === false
 
+          // Respect the derived unfillable flag already computed for composable orders
+          if (isComposableOrder && order.isUnfillable) {
+            isUnfillable = true
+          }
+
           // For TWAP orders, also check child orders
           if (!isParsedOrder(item) && item.children) {
             const hasUnfillableChild = item.children.some((childOrder) => {
@@ -80,8 +88,9 @@ export function useOrdersTableList(
             isUnfillable = isUnfillable || hasUnfillableChild
           }
 
-          // Update the unfillable flag whenever the state changes, not just when becoming unfillable
-          if (isPending && order.isUnfillable !== isUnfillable) {
+          // Persist the recomputed flag for regular orders only; composable orders derive it from
+          // their emulated state, so writing it back here would fight that source.
+          if (isPending && !isComposableOrder && order.isUnfillable !== isUnfillable) {
             setIsOrderUnfillable({ chainId, id: order.id, isUnfillable })
           }
 

apps/cowswap-frontend/src/modules/ordersTable/pure/TwapOrderStatus/TwapOrderStatus.pure.tsx

@@ -1,7 +1,9 @@
 import React, { ReactNode } from 'react'
 
+import { HoverTooltip } from '@cowprotocol/ui'
+
 import { Trans } from '@lingui/react/macro'
-import { Check, Clock, X } from 'react-feather'
+import { AlertTriangle, Check, Clock, X } from 'react-feather'
 
 import { OrderStatus } from 'legacy/state/orders/actions'
 
@@ -39,6 +41,34 @@ export function TwapOrderStatus({ childOrders, orderStatus, children }: FillsAtS
     )
   }
 
+  // An open order is unfillable when it can no longer be executed (e.g. the Safe's ComposableCoW
+  // fallback handler was reset). Surface it instead of the default "pending execution" display.
+  const isUnfillable = childOrders.some((childOrder) => childOrder.isUnfillable)
+
+  if (isUnfillable) {
+    return (
+      <>
+        <b>
+          <HoverTooltip
+            wrapInContainer
+            content={
+              <Trans>
+                This order can’t be executed at the moment (for example, the Safe’s fallback handler was reset), so it
+                won’t be filled until the issue is resolved.
+              </Trans>
+            }
+          >
+            <styledEl.UnfillableDisplay>
+              <AlertTriangle size={14} strokeWidth={2.5} />
+              <Trans>Unfillable</Trans>
+            </styledEl.UnfillableDisplay>
+          </HoverTooltip>
+        </b>
+        <i></i>
+      </>
+    )
+  }
+
   // Third priority: Check for scheduled orders
   const hasScheduledOrder = childOrders.some((childOrder) => childOrder.status === OrderStatus.SCHEDULED)
 

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

@@ -43,6 +43,9 @@ export interface TwapOrderItem {
   id: string
   safeTxParams?: SafeTransactionParams
   executionInfo: TwapOrdersExecution
+  // True when an open order cannot be executed because the Safe's ComposableCoW
+  // fallback handler is missing/reset by the user (see issue #5426)
+  isUnfillable?: boolean
 }
 
 export type TwapOrdersAuthResult = { [key: string]: boolean | undefined }

apps/cowswap-frontend/src/modules/twap/updaters/TwapOrdersUpdater.tsx

@@ -12,6 +12,7 @@ import type { ComposableCowContractData } from 'modules/advancedOrders'
 
 import { TWAP_PENDING_STATUSES } from '../const'
 import { useAllTwapOrdersInfo } from '../hooks/useAllTwapOrdersInfo'
+import { useIsFallbackHandlerRequired } from '../hooks/useFallbackHandlerVerification'
 import { useFetchTwapOrdersFromSafe } from '../hooks/useFetchTwapOrdersFromSafe'
 import { useTwapOrdersAuthMulticall } from '../hooks/useTwapOrdersAuthMulticall'
 import { useTwapOrdersExecutions } from '../hooks/useTwapOrdersExecutions'
@@ -52,6 +53,12 @@ export function TwapOrdersUpdater(props: {
   // eslint-disable-next-line react-hooks/refs
   twapOrderExecutions.current = _twapOrderExecutions
 
+  // When the Safe's fallback handler is missing/reset, open orders will never execute (they are "broken")
+  const isFallbackHandlerBroken = useIsFallbackHandlerRequired()
+  const isFallbackHandlerBrokenRef = useRef(isFallbackHandlerBroken)
+  // eslint-disable-next-line react-hooks/refs
+  isFallbackHandlerBrokenRef.current = isFallbackHandlerBroken
+
   // Here we can split all orders in two groups: 1. Not signed + expired, 2. Open + cancelled
   const pendingTwapOrderIds = useMemo(() => {
     // eslint-disable-next-line react-hooks/refs
@@ -96,6 +103,7 @@ export function TwapOrdersUpdater(props: {
       allOrdersInfo,
       ordersAuthResult,
       twapOrderExecutions.current,
+      isFallbackHandlerBrokenRef.current,
     )
 
     /**

apps/cowswap-frontend/src/modules/twap/utils/buildTwapOrdersItems.ts

@@ -13,6 +13,7 @@ import {
   type TwapOrdersAuthResult,
   type TwapOrdersExecution,
   type TwapOrdersSafeData,
+  TwapOrderStatus,
 } from '../types'
 
 import type { Hex } from 'viem'
@@ -23,6 +24,7 @@ export function buildTwapOrdersItems(
   ordersInfo: TwapOrderInfo[],
   ordersAuthResult: TwapOrdersAuthResult,
   twapOrderExecutions: TwapOrdersExecutionMap,
+  isFallbackHandlerBroken: boolean,
 ): TwapOrdersList {
   return ordersInfo.reduce<TwapOrdersList>((acc, { safeData, id }) => {
     acc[id] = getTwapOrderItem(
@@ -32,6 +34,7 @@ export function buildTwapOrdersItems(
       id as `0x${string}`,
       ordersAuthResult[id],
       twapOrderExecutions[id] ?? DEFAULT_TWAP_EXECUTION,
+      isFallbackHandlerBroken,
     )
     return acc
   }, {})
@@ -44,6 +47,7 @@ function getTwapOrderItem(
   id: Hex,
   authorized: boolean | undefined,
   executionInfo: TwapOrdersExecution,
+  isFallbackHandlerBroken: boolean,
 ): TwapOrderItem {
   const { conditionalOrderParams, safeTxParams } = safeData
   const { isExecuted, submissionDate, executionDate: _executionDate } = safeTxParams
@@ -52,6 +56,10 @@ function getTwapOrderItem(
   const order = parseTwapOrderStruct(conditionalOrderParams.staticInput as `0x${string}`)
   const status = getTwapOrderStatus(order, isExecuted, executionDate, authorized, executionInfo)
 
+  // An open (Pending) order will never be picked up by watchtower when the Safe's
+  // ComposableCoW fallback handler has been reset/removed, so surface it as Unfillable.
+  const isUnfillable = isFallbackHandlerBroken && status === TwapOrderStatus.Pending
+
   return {
     order,
     status,
@@ -62,5 +70,6 @@ function getTwapOrderItem(
     executedDate: _executionDate || undefined,
     safeTxParams,
     executionInfo,
+    isUnfillable,
   }
 }

apps/cowswap-frontend/src/modules/twap/utils/mapPartOrderToStoreOrder.ts

@@ -1,7 +1,7 @@
 import { EnrichedOrder, getAddressKey } from '@cowprotocol/cow-sdk'
 import { TokensByAddress } from '@cowprotocol/tokens'
 
-import { Order } from 'legacy/state/orders/actions'
+import { Order, OrderStatus } from 'legacy/state/orders/actions'
 
 import { getIsLastPartOrder } from './getIsLastPartOrder'
 import { getPartOrderStatus } from './getPartOrderStatus'
@@ -19,6 +19,9 @@ export function mapPartOrderToStoreOrder(
   const isCancelling = item.isCancelling || parent.status === TwapOrderStatus.Cancelling
   const status = getPartOrderStatus(enrichedOrder, parent, isVirtualPart)
 
+  // A broken fallback handler blocks the whole order, so mark still-open parts as unfillable too
+  const isUnfillable = !!parent.isUnfillable && (status === OrderStatus.PENDING || status === OrderStatus.SCHEDULED)
+
   const inputToken = tokensByAddress[getAddressKey(enrichedOrder.sellToken)]
   const outputToken = tokensByAddress[getAddressKey(enrichedOrder.buyToken)]
 
@@ -39,5 +42,6 @@ export function mapPartOrderToStoreOrder(
     status,
     apiAdditionalInfo: enrichedOrder,
     isCancelling,
+    isUnfillable,
   }
 }