fix(trades): handle takes left Canceled by the old optimistic cancel

lib/features/order/providers/trade_state_provider.dart

@@ -41,13 +41,47 @@ final tradeStatusLookupProvider =
       },
     );
 
-/// Reads the local user's role in a trade through the bridge; injectable so
-/// screens that must know whether they already participate can be tested
-/// without the Rust side.
+/// The local user's role in an order they still take part in
+/// ([participatingRole]), read through the bridge; injectable so screens that
+/// must know whether they already participate can be tested without the Rust
+/// side.
 final tradeRoleLookupProvider = Provider<Future<TradeRole?> Function(String)>(
-  (ref) => (orderId) => orders_api.getTradeRole(orderId: orderId),
+  (ref) =>
+      (orderId) async =>
+          participatingRole(await orders_api.listTrades(), orderId),
 );
 
+/// The role of the user's trade on [orderId] among [trades], or null when
+/// they no longer take part in it: no row at all, or only a take that has
+/// ended ([isEndedTake]).
+///
+/// Every row for the order is read, not just one: a database from before
+/// takes replaced their order's earlier row can hold two, and a live one
+/// among them still makes the user a participant.
+TradeRole? participatingRole(Iterable<TradeInfo> trades, String orderId) {
+  for (final trade in trades) {
+    if (trade.order.id == orderId && !isEndedTake(trade)) return trade.role;
+  }
+  return null;
+}
+
+/// Whether [trade] is a take whose row has ended, which leaves the user
+/// nothing to follow on its order.
+///
+/// A trade that truly ended leaves its order in a status mostrod never takes
+/// it out of: a take needs `Pending`, and only a waiting state goes back to
+/// it. So once the order can be taken again, such a row is what a take that
+/// never went active left behind: older builds marked it `Canceled` as soon
+/// as its cancel went out. Holding on to it sent the user to that dead trade
+/// instead of letting them take the order again (#434). Rust already takes
+/// over such a row: the confirmed take replaces every earlier row of its
+/// order.
+///
+/// Never a maker's row: its order is theirs, and the take screen is not
+/// where they manage it.
+bool isEndedTake(TradeInfo trade) =>
+    !trade.order.isMine && isTerminalTradeStatus(trade.order.status);
+
 /// Takes an order through the bridge; injectable so the take screen's
 /// outcomes (loading, already taken, rejected) can be tested without Rust.
 final takeOrderActionProvider = Provider<
@@ -88,7 +122,7 @@ final tradeStatusProvider = StreamProvider.family
         final status = await lookup(orderId);
         if (status != null) {
           yield status;
-          if (_isTerminal(status)) return;
+          if (isTerminalTradeStatus(status)) return;
         }
         await Future.delayed(const Duration(seconds: 2));
       }
@@ -111,8 +145,9 @@ final tradeUpdatesProvider = StreamProvider.autoDispose<TradeUpdate>((
   }
 });
 
-/// Whether the UI can stop polling. Escrow settlement still awaits payout.
-bool _isTerminal(OrderStatus s) => const {
+/// Whether a trade in [s] has ended: nothing moves it out again, so the UI
+/// can stop polling. Escrow settlement still awaits payout.
+bool isTerminalTradeStatus(OrderStatus s) => const {
   OrderStatus.success,
   OrderStatus.settledByAdmin,
   OrderStatus.completedByAdmin,
@@ -122,6 +157,33 @@ bool _isTerminal(OrderStatus s) => const {
   OrderStatus.canceledByAdmin,
 }.contains(s);
 
+/// The status a trade shows: its [row]'s persisted one, or the [live] one
+/// from [tradeStatusProvider], which reads the order book first.
+///
+/// The row wins in two cases:
+/// * **It has ended** ([isTerminalTradeStatus]). Whatever the book says about
+///   the order later is no longer this trade. The one way such a row can be
+///   wrong is the cancel's optimistic write on an active trade: a cooperative
+///   cancel the peer never accepts, on a trade that then completes.
+/// * **It is a take ([isTake]) and the book says `pending`.** A public
+///   `pending` means nobody holds the order, so it is never a take's status.
+///   Older builds marked a take `Canceled` as soon as its cancel went out,
+///   even before it went active; once the daemon put the order back in the
+///   book, that `pending` read as the user's own order, with a Cancel the
+///   daemon refuses (`IsNotYourOrder`). A take parked at `WaitingTakerBond`
+///   is another: publicly its order is still `pending`.
+///
+/// Otherwise the live status, or the row's while there is none yet.
+OrderStatus shownTradeStatus({
+  required OrderStatus row,
+  required OrderStatus? live,
+  required bool isTake,
+}) {
+  if (live == null || isTerminalTradeStatus(row)) return row;
+  if (isTake && live == OrderStatus.pending) return row;
+  return live;
+}
+
 /// Loads the buyer/seller role for a trade from the persistent DB.
 ///
 /// Returns `true` when the local user is the buyer, `false` for seller, or

lib/features/trades/providers/trade_rows_provider.dart

@@ -34,7 +34,8 @@ class TradeRow {
 
   final String orderId;
 
-  /// Live when the order is still moving, else the persisted status.
+  /// Live when the order is still moving, else the persisted status — see
+  /// [shownTradeStatus], which the trade screen shares.
   final rust_types.OrderStatus status;
   final TradeRowState state;
   final bool isSelling;
@@ -59,16 +60,6 @@ class TradeRow {
   final String? peerHandle;
 }
 
-const _terminal = {
-  rust_types.OrderStatus.success,
-  rust_types.OrderStatus.settledByAdmin,
-  rust_types.OrderStatus.completedByAdmin,
-  rust_types.OrderStatus.canceled,
-  rust_types.OrderStatus.expired,
-  rust_types.OrderStatus.cooperativelyCanceled,
-  rust_types.OrderStatus.canceledByAdmin,
-};
-
 const _successes = {
   rust_types.OrderStatus.success,
   rust_types.OrderStatus.settledByAdmin,
@@ -89,10 +80,14 @@ final tradeRowsProvider = Provider<AsyncValue<List<TradeRow>>>((ref) {
 TradeRow _row(Ref ref, rust_types.TradeInfo trade, {required bool canRate}) {
   final order = trade.order;
   final persisted = order.status;
-  final status =
-      _terminal.contains(persisted)
-          ? persisted
-          : ref.watch(tradeStatusProvider(order.id)).valueOrNull ?? persisted;
+  final status = shownTradeStatus(
+    row: persisted,
+    live:
+        isTerminalTradeStatus(persisted)
+            ? null
+            : ref.watch(tradeStatusProvider(order.id)).valueOrNull,
+    isTake: !order.isMine,
+  );
   final ratedByMe =
       trade.ratedAt != null ||
       (_successes.contains(status) && ref.watch(ratedByMeProvider(order.id)));

lib/features/trades/screens/trade_detail_screen.dart

@@ -36,6 +36,7 @@ import 'package:mostro/shared/widgets/mostro_reactive_button.dart';
 import 'package:mostro/src/rust/api/disputes.dart' as disputes_api;
 import 'package:mostro/src/rust/api/orders.dart' as orders_api;
 import 'package:mostro/src/rust/api/reputation.dart' as reputation_api;
+import 'package:mostro/src/rust/api/types.dart' show TradeInfo;
 
 export 'package:mostro/features/trades/models/trade_status.dart';
 
@@ -189,9 +190,23 @@ class _TradeDetailScreenState extends ConsumerState<TradeDetailScreen> {
   /// await: the seller's payment can land while the cancel dialog is open.
   TradeStatus _liveStatus(TradeStatus fallback) {
     final live = ref.read(tradeStatusProvider(widget.orderId)).valueOrNull;
-    return live == null ? fallback : tradeStatusFromOrderStatus(live);
+    if (live == null) return fallback;
+    final trade = ref.read(tradeInfoProvider(widget.orderId)).valueOrNull;
+    return tradeStatusFromOrderStatus(_shown(live, trade));
   }
 
+  /// What [live] shows for this trade once its [trade] row is read in
+  /// ([shownTradeStatus]); [live] itself while the row has not loaded, or
+  /// when there is none.
+  static OrderStatus _shown(OrderStatus live, TradeInfo? trade) =>
+      trade == null
+          ? live
+          : shownTradeStatus(
+            row: trade.order.status,
+            live: live,
+            isTake: !trade.order.isMine,
+          );
+
   Future<void> _cancelOrder(TradeStatus status) async {
     final l10n = AppLocalizations.of(context);
     final confirmed = await showDialog<bool>(
@@ -207,8 +222,14 @@ class _TradeDetailScreenState extends ConsumerState<TradeDetailScreen> {
                     dialogRef
                         .watch(tradeStatusProvider(widget.orderId))
                         .valueOrNull;
+                final trade =
+                    dialogRef
+                        .watch(tradeInfoProvider(widget.orderId))
+                        .valueOrNull;
                 final now =
-                    live == null ? status : tradeStatusFromOrderStatus(live);
+                    live == null
+                        ? status
+                        : tradeStatusFromOrderStatus(_shown(live, trade));
                 return Text(_cancelDialogContent(l10n, now));
               },
             ),
@@ -405,7 +426,8 @@ class _TradeDetailScreenState extends ConsumerState<TradeDetailScreen> {
       debugPrint('[TradeDetailScreen] trade status failed: ${live.error}');
     }
     if (!live.hasValue) return TradeStatus.loading;
-    final status = tradeStatusFromOrderStatus(live.value!);
+    final trade = ref.watch(tradeInfoProvider(widget.orderId)).valueOrNull;
+    final status = tradeStatusFromOrderStatus(_shown(live.value!, trade));
     if (status != TradeStatus.pendingRating) return status;
     final rating = ref.watch(tradeRatingProvider(widget.orderId));
     if (rating.isLoading && !rating.hasValue) return TradeStatus.loading;
@@ -439,13 +461,18 @@ class _TradeDetailScreenState extends ConsumerState<TradeDetailScreen> {
     // A step advanced by the relay: a nudge, the crossfades below, and a
     // fresh deadline — every step has its own expiration, owned by a
     // different party, so the clock loaded for the previous step is stale.
+    // Judged on what the screen shows: a book change the row outranks is
+    // not a step of this trade.
     ref.listen<AsyncValue<OrderStatus>>(tradeStatusProvider(widget.orderId), (
       previous,
       next,
     ) {
+      final trade = ref.read(tradeInfoProvider(widget.orderId)).valueOrNull;
       final before = previous?.valueOrNull;
       final after = next.valueOrNull;
-      if (before != null && after != null && before != after) {
+      if (before != null &&
+          after != null &&
+          _shown(before, trade) != _shown(after, trade)) {
         HapticFeedback.mediumImpact();
         _loadExpiresAt();
       }

specs/004-mostro-p2p-client/contracts/orders.md

@@ -749,3 +749,24 @@ The seller pay-invoice flow uses two complementary providers from
   advancing past the pay-invoice screen; the NWC widget's local
   `onPaymentSuccess` callback only flips a spinner flag and does not
   navigate.
+
+`tradeStatusProvider` reads the order book first, and the book holds the
+order's public view. So the My Trades list and `TradeDetailScreen` show a
+trade through `shownTradeStatus`, where the trade row wins in two cases:
+
+- **The row has ended** (success or a cancelled family): whatever the book
+  says about the order afterwards is no longer this trade.
+- **A take, and the book says `pending`**: a public `pending` means nobody
+  holds the order, so it is never a take's status. That covers a take left
+  `Canceled` by builds that wrote the status before the daemon answered
+  (the daemon later put the order back in the book), and a take parked at
+  `WaitingTakerBond`, whose order is still `pending` in public.
+
+Every other live status wins over an open row.
+
+The take screen sends a user who already takes part in the order to the
+trade instead of offering to take it again (`tradeRoleLookupProvider`,
+`participatingRole`). A take whose row has ended does not count: once its
+order can be taken again, such a row can only be what a take that never
+went active left behind, and `take_order` replaces it with the new take's
+row. A maker's row always counts, and so does any row still open.

test/features/order/providers/trade_state_provider_test.dart

@@ -4,6 +4,7 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:mostro/features/order/providers/trade_state_provider.dart';
 import 'package:mostro/src/rust/api/types.dart';
 
+import '../../../support/fake_trades.dart';
 import '../../../support/provider_harness.dart';
 
 void main() {
@@ -47,4 +48,133 @@ void main() {
     expect(lookups, 2);
     expect(requestedOrders, ['order-payout', 'order-payout']);
   });
+
+  group('shownTradeStatus', () {
+    test('an ended row wins over any live status', () {
+      for (final row in OrderStatus.values.where(isTerminalTradeStatus)) {
+        for (final live in OrderStatus.values) {
+          for (final isTake in [true, false]) {
+            expect(
+              shownTradeStatus(row: row, live: live, isTake: isTake),
+              row,
+              reason: 'row=$row live=$live isTake=$isTake',
+            );
+          }
+        }
+      }
+    });
+
+    test('a public pending never shows over a take that is still open', () {
+      final open = OrderStatus.values.where((s) => !isTerminalTradeStatus(s));
+      for (final row in open) {
+        expect(
+          shownTradeStatus(row: row, live: OrderStatus.pending, isTake: true),
+          row,
+          reason: 'row=$row',
+        );
+        // The maker's own order is `pending` for real.
+        expect(
+          shownTradeStatus(row: row, live: OrderStatus.pending, isTake: false),
+          OrderStatus.pending,
+          reason: 'row=$row',
+        );
+      }
+    });
+
+    test('any other live status wins over an open row', () {
+      final open = OrderStatus.values.where((s) => !isTerminalTradeStatus(s));
+      for (final row in open) {
+        for (final live in OrderStatus.values) {
+          if (live == OrderStatus.pending) continue;
+          for (final isTake in [true, false]) {
+            expect(
+              shownTradeStatus(row: row, live: live, isTake: isTake),
+              live,
+              reason: 'row=$row live=$live isTake=$isTake',
+            );
+          }
+        }
+      }
+    });
+
+    test('the row stands in while there is no live status yet', () {
+      expect(
+        shownTradeStatus(
+          row: OrderStatus.waitingPayment,
+          live: null,
+          isTake: true,
+        ),
+        OrderStatus.waitingPayment,
+      );
+    });
+  });
+
+  group('participatingRole', () {
+    const orderId = 'order-x';
+
+    test('no row on the order is no role', () {
+      expect(participatingRole(const [], orderId), isNull);
+      expect(
+        participatingRole([fakeTrade(id: 'other')], orderId),
+        isNull,
+        reason: 'another order\'s row',
+      );
+    });
+
+    test('a take still open is a participant', () {
+      for (final status in OrderStatus.values.where(
+        (s) => !isTerminalTradeStatus(s),
+      )) {
+        expect(
+          participatingRole([
+            fakeTrade(
+              id: 'x',
+              orderId: orderId,
+              status: status,
+              role: TradeRole.seller,
+            ),
+          ], orderId),
+          TradeRole.seller,
+          reason: '$status',
+        );
+      }
+    });
+
+    test('a take that has ended is not', () {
+      for (final status in OrderStatus.values.where(isTerminalTradeStatus)) {
+        final ended = fakeTrade(id: 'x', orderId: orderId, status: status);
+        expect(isEndedTake(ended), isTrue, reason: '$status');
+        expect(participatingRole([ended], orderId), isNull, reason: '$status');
+      }
+    });
+
+    test("a maker's row always is, ended or not", () {
+      final maker = fakeTrade(
+        id: 'x',
+        orderId: orderId,
+        status: OrderStatus.canceled,
+        isMine: true,
+      );
+      expect(isEndedTake(maker), isFalse);
+      expect(participatingRole([maker], orderId), TradeRole.buyer);
+    });
+
+    test('an open row wins over an ended one on the same order', () {
+      // Databases from before a take replaced its order's earlier row can
+      // hold both, in either order.
+      final ended = fakeTrade(
+        id: 'ended',
+        orderId: orderId,
+        status: OrderStatus.canceled,
+      );
+      final open = fakeTrade(
+        id: 'open',
+        orderId: orderId,
+        status: OrderStatus.active,
+        role: TradeRole.seller,
+      );
+      expect(participatingRole([ended, open], orderId), TradeRole.seller);
+      expect(participatingRole([open, ended], orderId), TradeRole.seller);
+    });
+  });
 }