double /duplicate push notifications

[alltheseas]

I also remember the push notifications not working properly last time I used them. When I would go into the notifications pane, the push notifications would repeat. And they wouldn’t always show at the time they would happen. Not sure if there’s an issue for this

• node

[linear]

SER-71

[alltheseas]

 Problem: Users receive duplicate push notifications, especially when viewing the notifications pane. Notifications also don't always arrive in real-time.       
                                                                                                                                                                  
  Root Causes Identified                                                                                                                                          
                                                                                                                                                                  
  Critical Issues                                                                                                                                                 
                                                                                                                                                                  
  1. Race Condition in Deduplication (notification_manager/mod.rs:334-384)                                                                                        
    - The code uses a check-then-act pattern: query for existing notification → send notification → insert record                                                 
    - Multiple concurrent requests can pass the check before any writes occur                                                                                     
    - Result: Same notification sent multiple times                                                                                                               
  2. Same Event from Multiple Connections                                                                                                                         
    - Events propagate through multiple Nostr relays                                                                                                              
    - Each WebSocket connection processes events independently                                                                                                    
    - Both connections can process the same event concurrently, bypassing deduplication                                                                           
                                                                                                                                                                  
  Secondary Issues                                                                                                                                                
                                                                                                                                                                  
  3. Network fetches in hot path - Mute list lookups add latency (up to 5 second timeout)                                                                         
  4. Clock skew edge cases - Future event checks could behave inconsistently                                                                                      
                                                                                                                                                                  
  Proposed Plan                                                                                                                                                   
                                                                                                                                                                  
  Phase 1: Fix the Race Condition (Critical)                                                                                                                      
                                                                                                                                                                  
  Option A: Optimistic Insert with Conflict Check                                                                                                                 
  // Instead of: query → send → insert                                                                                                                            
  // Do: insert-if-not-exists → send only if insert succeeded                                                                                                     
                                                                                                                                                                  
  // Use INSERT OR IGNORE and check rows_affected                                                                                                                 
  let result = db.execute(                                                                                                                                        
      "INSERT OR IGNORE INTO notifications (id, event_id, pubkey, ...) VALUES (...)",                                                                             
      params![...]                                                                                                                                                
  )?;                                                                                                                                                             
  if result == 0 {                                                                                                                                                
      // Record already existed, skip sending                                                                                                                     
      return Ok(());                                                                                                                                              
  }                                                                                                                                                               
  // Record inserted, we own this notification - send it                                                                                                          
  send_notification(...);                                                                                                                                         
                                                                                                                                                                  
  Option B: Add a Mutex per Event ID                                                                                                                              
  - Use an in-memory lock map to ensure only one task processes a given event at a time                                                                           
  - More complex but provides stronger guarantees                                                                                                                 
                                                                                                                                                                  
  Phase 2: Improve Event Deduplication at Ingestion                                                                                                               
                                                                                                                                                                  
  Add an early deduplication check when events arrive:                                                                                                            
  - Track recently seen event IDs in memory (with TTL)                                                                                                            
  - Skip processing if event was already seen within the window                                                                                                   
  - This catches duplicates before they reach the notification logic                                                                                              
                                                                                                                                                                  
  Phase 3: Optimize Notification Latency                                                                                                                          
                                                                                                                                                                  
  - Pre-fetch and cache mute lists more aggressively                                                                                                              
  - Move mute list lookups off the critical path where possible