fix: persist pending range-order child sessions across isolates and restarts

lib/core/config.dart

@@ -76,6 +76,13 @@ class Config {
   static const int cleanupIntervalMinutes = 30;
   static const int sessionExpirationHours = 720;
 
+  /// Upper bound for a pending range-order child session (persisted without an
+  /// orderId while waiting for mostrod's child new-order message). The handoff
+  /// resolves in seconds, so a record still unlinked after this window never
+  /// will be. Bounded independently of [sessionExpirationHours] so orphan
+  /// records cannot accumulate when session expiration is disabled (0).
+  static const int pendingChildSessionExpirationHours = 48;
+
   // Notification configuration
   static String notificationChannelId = 'mostro_mobile';
   static int notificationId = 38383;

lib/data/repositories/session_storage.dart

@@ -45,13 +45,40 @@ class SessionStorage extends BaseStorage<Session> {
     return Session.fromJson(clone);
   }
 
+  /// Record-key prefix for pending range-order child sessions, which have no
+  /// orderId yet and are keyed by their trade public key instead.
+  static const String pendingChildKeyPrefix = 'pending-child:';
+
   Future<void> putSession(Session session) async {
     if (session.orderId == null) {
       throw ArgumentError('Cannot store a session with an empty orderId');
     }
     await putItem(session.orderId!, session);
   }
 
+  /// Persists a pending range-order child session (no orderId yet), keyed by
+  /// its trade public key. Persisting it matters for two reasons: the session
+  /// must survive an app kill between release and the child new-order message,
+  /// and the background isolate loads sessions from this store to decrypt
+  /// events addressed to the child trade key.
+  Future<void> putPendingChildSession(Session session) async {
+    if (session.orderId != null) {
+      throw ArgumentError(
+        'Pending child session must not have an orderId; use putSession',
+      );
+    }
+    if (session.parentOrderId == null) {
+      throw ArgumentError('Pending child session requires a parentOrderId');
+    }
+    await putItem('$pendingChildKeyPrefix${session.tradeKey.public}', session);
+  }
+
+  /// Removes the pending child session record for [tradeKeyPublic], if any.
+  /// Called once the child order id is known and the session is re-stored
+  /// under its orderId, or when an expired pending child is cleaned up.
+  Future<void> deletePendingChildSession(String tradeKeyPublic) =>
+      deleteItem('$pendingChildKeyPrefix$tradeKeyPublic');
+
   /// Shortcut to get a single session by its ID.
   Future<Session?> getSession(String sessionId) => getItem(sessionId);
 

lib/features/notifications/services/background_notification_service.dart

@@ -9,6 +9,7 @@ import 'package:mostro_mobile/services/logger_service.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
 import 'package:mostro_mobile/core/app.dart';
+import 'package:mostro_mobile/core/config.dart';
 import 'package:mostro_mobile/data/models/mostro_message.dart';
 import 'package:mostro_mobile/data/models/nostr_event.dart';
 import 'package:mostro_mobile/data/models/order.dart';
@@ -342,6 +343,13 @@ Future<MostroMessage?> _handleTradeKeyEvent(NostrEvent event, Session session) a
   final mostroMessage = MostroMessage.fromJson(result[0]);
   mostroMessage.timestamp = event.createdAt?.millisecondsSinceEpoch;
 
+  // If this message belongs to a pending range-order child session, link it to
+  // the child order id right here. The foreground link
+  // (MostroService._maybeLinkChildOrder) never runs while the app is
+  // backgrounded or killed, and this and later events for the child order need
+  // the session stored under its orderId (e.g. role-gated notifications).
+  await _maybeLinkChildOrder(mostroMessage, session);
+
   // If this event transitions the order to Active, learn the counterpart's
   // tradeKey from the Order payload and persist it on the session so the
   // background service can immediately subscribe to P2P chat events.
@@ -353,6 +361,49 @@ Future<MostroMessage?> _handleTradeKeyEvent(NostrEvent event, Session session) a
   return mostroMessage;
 }
 
+/// Links a pending range-order child session to its concrete child order id
+/// when a message for that child arrives while the app is backgrounded.
+/// Mirrors MostroService._maybeLinkChildOrder for the background isolate:
+/// stores the session under its orderId and drops the pending record.
+///
+/// The trigger is any message carrying an order id, not just the child
+/// new-order confirmation: the device may well be woken (FCM) by a later
+/// event — the very take-order message this notification path exists for —
+/// while the new-order message was never delivered to this isolate. The child
+/// trade key is used by exactly one order, so any id other than the parent's
+/// identifies it.
+Future<void> _maybeLinkChildOrder(
+  MostroMessage message,
+  Session session,
+) async {
+  final childOrderId = message.id;
+  if (childOrderId == null || childOrderId.isEmpty) return;
+  if (session.orderId != null || session.parentOrderId == null) return;
+  if (childOrderId == session.parentOrderId) return;
+
+  try {
+    session.orderId = childOrderId;
+
+    final sessionStorage = await _openSessionStorage();
+    await sessionStorage.putSession(session);
+    // Only after the session is durably stored under its orderId, otherwise a
+    // crash in between would lose it entirely.
+    await sessionStorage.deletePendingChildSession(session.tradeKey.public);
+
+    logger.i(
+      'Background linked child order $childOrderId to parent ${session.parentOrderId}',
+    );
+  } catch (e, stackTrace) {
+    // Keep the in-memory session pending so the next attempt (background or
+    // foreground) retries the link instead of assuming a stored orderId.
+    session.orderId = null;
+    logger.e(
+      'Failed to link child order in background: $e',
+      stackTrace: stackTrace,
+    );
+  }
+}
+
 /// Persists the peer on the given session when [message] is an action that
 /// reveals the counterpart's tradeKey (buyer took order / hold invoice
 /// payment accepted), and triggers a live chat subscription in the
@@ -399,17 +450,7 @@ Future<void> _maybeUpdateSessionWithPeer(
     // Setting peer on the session computes the shared key via ECDH.
     session.peer = Peer(publicKey: peerPubkey);
 
-    final db = await openMostroDatabase('mostro.db');
-    const secureStorage = FlutterSecureStorage();
-    final sharedPrefs = SharedPreferencesAsync();
-    final keyStorage = KeyStorage(
-      secureStorage: secureStorage,
-      sharedPrefs: sharedPrefs,
-    );
-    final keyDerivator = KeyDerivator("m/44'/1237'/38383'/0");
-    final keyManager = KeyManager(keyStorage, keyDerivator);
-    await keyManager.init();
-    final sessionStorage = SessionStorage(keyManager, db: db);
+    final sessionStorage = await _openSessionStorage();
     await sessionStorage.putSession(session);
 
     logger.i('Background persisted peer for order ${session.orderId}');
@@ -499,17 +540,26 @@ Future<String?> _loadMostroPubkey() async {
   }
 }
 
+/// Opens a SessionStorage bound to the background isolate's own database and
+/// key manager handles. The isolate has no Riverpod container, so every
+/// persistence helper here has to build its own.
+Future<SessionStorage> _openSessionStorage() async {
+  final db = await openMostroDatabase('mostro.db');
+  const secureStorage = FlutterSecureStorage();
+  final sharedPrefs = SharedPreferencesAsync();
+  final keyStorage = KeyStorage(
+    secureStorage: secureStorage,
+    sharedPrefs: sharedPrefs,
+  );
+  final keyDerivator = KeyDerivator(Config.keyDerivationPath);
+  final keyManager = KeyManager(keyStorage, keyDerivator);
+  await keyManager.init();
+  return SessionStorage(keyManager, db: db);
+}
+
 Future<List<Session>> _loadSessionsFromDatabase() async {
   try {
-    final db = await openMostroDatabase('mostro.db');
-    const secureStorage = FlutterSecureStorage();
-    final sharedPrefs = SharedPreferencesAsync();
-    final keyStorage = KeyStorage(secureStorage: secureStorage, sharedPrefs: sharedPrefs);
-    final keyDerivator = KeyDerivator("m/44'/1237'/38383'/0");
-    final keyManager = KeyManager(keyStorage, keyDerivator);
-
-    await keyManager.init();
-    final sessionStorage = SessionStorage(keyManager, db: db);
+    final sessionStorage = await _openSessionStorage();
     return await sessionStorage.getAll();
   } catch (e) {
     logger.e('Session load error: $e');

lib/services/mostro_service.dart

@@ -188,28 +188,34 @@ class MostroService {
     }
   }
 
+  /// Links a pending range-order child session to its concrete child order id.
+  ///
+  /// The trigger is any message carrying an order id, not just the child
+  /// new-order confirmation: after a restart (or when the confirmation was
+  /// only seen by the background isolate) the first message this notifier sees
+  /// for the child trade key can be a later one, and leaving the session
+  /// pending would keep the child order out of My Trades. The child trade key
+  /// is used by exactly one order, so any id other than the parent's
+  /// identifies it.
   Future<void> _maybeLinkChildOrder(
     MostroMessage message,
     Session session,
   ) async {
-    if (message.action != Action.newOrder || message.id == null) {
-      return;
-    }
-
-    if (session.orderId != null || session.parentOrderId == null) {
-      return;
-    }
+    final childOrderId = message.id;
+    if (childOrderId == null || childOrderId.isEmpty) return;
+    if (session.orderId != null || session.parentOrderId == null) return;
+    if (childOrderId == session.parentOrderId) return;
 
     final sessionNotifier = ref.read(sessionNotifierProvider.notifier);
     await sessionNotifier.linkChildSessionToOrderId(
-      message.id!,
+      childOrderId,
       session.tradeKey.public,
     );
 
-    ref.read(orderNotifierProvider(message.id!).notifier).subscribe();
+    ref.read(orderNotifierProvider(childOrderId).notifier).subscribe();
 
     logger.i(
-      'Linked child order ${message.id} to parent ${session.parentOrderId}',
+      'Linked child order $childOrderId to parent ${session.parentOrderId}',
     );
   }