fix: add value equality to Order

lib/data/models/order.dart

@@ -268,4 +268,48 @@ class Order implements Payload {
       createdAt: createdAt,
     );
   }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    return other is Order &&
+        other.id == id &&
+        other.kind == kind &&
+        other.status == status &&
+        other.amount == amount &&
+        other.fiatCode == fiatCode &&
+        other.minAmount == minAmount &&
+        other.maxAmount == maxAmount &&
+        other.fiatAmount == fiatAmount &&
+        other.paymentMethod == paymentMethod &&
+        other.premium == premium &&
+        other.masterBuyerPubkey == masterBuyerPubkey &&
+        other.masterSellerPubkey == masterSellerPubkey &&
+        other.buyerTradePubkey == buyerTradePubkey &&
+        other.sellerTradePubkey == sellerTradePubkey &&
+        other.buyerInvoice == buyerInvoice &&
+        other.createdAt == createdAt &&
+        other.expiresAt == expiresAt;
+  }
+
+  @override
+  int get hashCode => Object.hashAll([
+        id,
+        kind,
+        status,
+        amount,
+        fiatCode,
+        minAmount,
+        maxAmount,
+        fiatAmount,
+        paymentMethod,
+        premium,
+        masterBuyerPubkey,
+        masterSellerPubkey,
+        buyerTradePubkey,
+        sellerTradePubkey,
+        buyerInvoice,
+        createdAt,
+        expiresAt,
+      ]);
 }

test/data/models/dispute_equality_test.dart

@@ -0,0 +1,53 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mostro_mobile/data/models/dispute.dart';
+import 'package:mostro_mobile/data/models/enums/order_type.dart';
+import 'package:mostro_mobile/data/models/enums/status.dart';
+import 'package:mostro_mobile/data/models/order.dart';
+
+void main() {
+  Order order({Status status = Status.dispute}) => Order(
+        id: 'order-1',
+        kind: OrderType.sell,
+        status: status,
+        amount: 50000,
+        fiatCode: 'USD',
+        fiatAmount: 100,
+        paymentMethod: 'Wire transfer',
+        createdAt: 1700000000,
+        expiresAt: 1700003600,
+      );
+
+  Dispute dispute({Order? attached}) => Dispute(
+        disputeId: 'dispute-1',
+        orderId: 'order-1',
+        status: 'initiated',
+        order: attached,
+        adminPubkey: 'admin-pubkey',
+        adminTookAt: DateTime.utc(2026, 1, 1),
+        createdAt: DateTime.utc(2025, 12, 31),
+        action: 'dispute-initiated-by-you',
+      );
+
+  group('Dispute value equality with an attached order', () {
+    test('disputes holding equal-but-distinct orders are equal', () {
+      expect(dispute(attached: order()), equals(dispute(attached: order())));
+      expect(
+        dispute(attached: order()).hashCode,
+        equals(dispute(attached: order()).hashCode),
+      );
+    });
+
+    test('disputes holding different orders are not equal', () {
+      expect(
+        dispute(attached: order()),
+        isNot(equals(
+          dispute(attached: order(status: Status.settledHoldInvoice)),
+        )),
+      );
+    });
+
+    test('an attached order is not equal to no order at all', () {
+      expect(dispute(attached: order()), isNot(equals(dispute())));
+    });
+  });
+}

test/features/order/models/order_state_test.dart

@@ -108,12 +108,12 @@ void main() {
       expect(build().hashCode, build().hashCode);
     });
 
-    // `Order` declares no `==`/`hashCode`, so two structurally identical
-    // orders are different values and the surrounding states compare unequal.
-    // Tracked as a separate defect; pinned here so a fix shows up as a
-    // deliberate change rather than a silent behaviour shift.
-    test('states holding equal-but-distinct orders compare unequal today', () {
-      expect(baseState(), isNot(baseState()));
+    // `Order` defines value equality, so two structurally identical orders are
+    // the same value and the surrounding states compare equal. This is what
+    // keeps Riverpod from notifying listeners when nothing actually changed.
+    test('states holding equal-but-distinct orders are equal', () {
+      expect(baseState(), equals(baseState()));
+      expect(baseState().hashCode, equals(baseState().hashCode));
     });
 
     test('states differing in any field are not equal', () {

test/models/order_test.dart

@@ -74,4 +74,128 @@ void main() {
       expect(order.premium, equals(1));
     });
   });
+
+  group('Order value equality', () {
+    Order build({
+      String? id = 'order-1',
+      Status status = Status.pending,
+      int amount = 50000,
+      int? minAmount,
+      int? maxAmount,
+      int fiatAmount = 100,
+      String paymentMethod = 'Wire transfer',
+      int premium = 0,
+      String? masterBuyerPubkey,
+      String? masterSellerPubkey,
+      String? buyerTradePubkey,
+      String? sellerTradePubkey,
+      String? buyerInvoice,
+      int? createdAt = 1700000000,
+      int? expiresAt = 1700003600,
+    }) =>
+        Order(
+          id: id,
+          kind: OrderType.sell,
+          status: status,
+          amount: amount,
+          fiatCode: 'USD',
+          minAmount: minAmount,
+          maxAmount: maxAmount,
+          fiatAmount: fiatAmount,
+          paymentMethod: paymentMethod,
+          premium: premium,
+          masterBuyerPubkey: masterBuyerPubkey,
+          masterSellerPubkey: masterSellerPubkey,
+          buyerTradePubkey: buyerTradePubkey,
+          sellerTradePubkey: sellerTradePubkey,
+          buyerInvoice: buyerInvoice,
+          createdAt: createdAt,
+          expiresAt: expiresAt,
+        );
+
+    test('two distinct instances built from the same data are equal', () {
+      expect(build(), equals(build()));
+      expect(build().hashCode, equals(build().hashCode));
+    });
+
+    test('an instance equals itself', () {
+      final order = build();
+
+      expect(order, equals(order));
+    });
+
+    test('is not equal to a value of another type', () {
+      expect(build(), isNot(equals('not an order')));
+    });
+
+    test('differing in any compared field breaks equality', () {
+      expect(build(), isNot(equals(build(id: 'order-2'))));
+      expect(build(), isNot(equals(build(status: Status.active))));
+      expect(build(), isNot(equals(build(amount: 60000))));
+      expect(build(), isNot(equals(build(minAmount: 10))));
+      expect(build(), isNot(equals(build(maxAmount: 20))));
+      expect(build(), isNot(equals(build(fiatAmount: 200))));
+      expect(build(), isNot(equals(build(paymentMethod: 'Cash'))));
+      expect(build(), isNot(equals(build(premium: 5))));
+      expect(build(), isNot(equals(build(masterBuyerPubkey: 'mb'))));
+      expect(build(), isNot(equals(build(masterSellerPubkey: 'ms'))));
+      expect(build(), isNot(equals(build(buyerTradePubkey: 'bt'))));
+      expect(build(), isNot(equals(build(sellerTradePubkey: 'st'))));
+      expect(build(), isNot(equals(build(buyerInvoice: 'lnbc1'))));
+      expect(build(), isNot(equals(build(createdAt: 1))));
+      expect(build(), isNot(equals(build(expiresAt: 2))));
+    });
+
+    test('differing in kind breaks equality', () {
+      final sell = build();
+      final buy = Order(
+        id: sell.id,
+        kind: OrderType.buy,
+        status: sell.status,
+        amount: sell.amount,
+        fiatCode: sell.fiatCode,
+        fiatAmount: sell.fiatAmount,
+        paymentMethod: sell.paymentMethod,
+        premium: sell.premium,
+        createdAt: sell.createdAt,
+        expiresAt: sell.expiresAt,
+      );
+
+      expect(sell, isNot(equals(buy)));
+    });
+
+    test('differing in fiatCode breaks equality', () {
+      final usd = build();
+      final ves = Order(
+        id: usd.id,
+        kind: usd.kind,
+        status: usd.status,
+        amount: usd.amount,
+        fiatCode: 'VES',
+        fiatAmount: usd.fiatAmount,
+        paymentMethod: usd.paymentMethod,
+        premium: usd.premium,
+        createdAt: usd.createdAt,
+        expiresAt: usd.expiresAt,
+      );
+
+      expect(usd, isNot(equals(ves)));
+    });
+
+    test('copyWith result equals an order built with the same values', () {
+      final updated = build().copyWith(
+        status: Status.active,
+        buyerInvoice: 'lnbc1',
+      );
+
+      expect(
+        updated,
+        equals(build(status: Status.active, buyerInvoice: 'lnbc1')),
+      );
+    });
+
+    test('equal orders collapse in a set', () {
+      expect({build(), build()}, hasLength(1));
+    });
+  });
 }