Bug: App hangs for more than 15 seconds after favoriting a user

[tkhumush]

What happens
When I add a user to my favorite list, the app will stop responding for a very long time.

** Versions **
Damus version: 1.16 (1236) f844ed9
Operating system version: 26.1
Device: e.g. iPhone 17 Pro

Steps To Reproduce
Steps to reproduce the behavior:

1. Open Damus
2. Open a user profile
3. Click the heart symbol next to the lightning bolt.

Additional context
App will resume after it completes the task successfully.

[linear]

IOS-2203

[askeew]

@danieldaquino
Can this be an issue with new local relay model since favourites does a home.resubscribe(.following) when adding a contact as favourite? When I tested favourites it was on master which did not have the new local relay model.

[alltheseas]

@askeew can you please test on local relay model (i.e. latest master)?

[askeew]

@alltheseas
Favorites is broken on the new relay model. When you favourite a user and then restart the app, the favorited users are not loaded. This worked in "old relay model".

I could not recreate the issue that it hangs consistently when I favourite a user. But it could be a performance issue with the local relay model.

Scrolling in feed freezes randomly and feels broken.
Searching for users freezes randomly and feels broken.

I tested reverted back master to when favourites was merged in august. Scrolling in feed freezes randomly and feels broken. Favorited users is working (but with small hit area and wrong alignment).

Back to latest master and favourites works as expected. But still random freezes on feed which feels broken.

Conclusion: Damus feed is unreliable and unstable so features built on top of it cannot be quality assured. It's hard to rule out if it's the feed that is broken or favourites.

[alltheseas]

 Analysis of GitHub Issue #3424: App Freeze on Favorite Action

  Root Cause Analysis

  The freeze occurs through this call chain:

  1. FavoriteButtonView.swift:18 - User taps favorite button
  2. ContactCardManager.swift:18-26 - toggleFavorite() runs and calls notify(.favoriteUpdated())
  3. ContentView.swift:463-465 - Notification triggers home.resubscribe(.following)
  4. HomeModel.swift:162-182 - resubscribe() uses a 3-second debouncer, then calls subscribe_to_home_filters()
  5. HomeModel.swift:607-685 - subscribe_to_home_filters() does significant work on the main thread

  The Problem

  The subscribe_to_home_filters() method at HomeModel.swift:607 is too heavy-handed for a simple favorite toggle:

  func subscribe_to_home_filters(friends fs: [Pubkey]? = nil) {
      // All this runs synchronously on main thread:
      let friends = fs ?? get_friends()                    // Line 621 - Get all friends
      var home_filters = home_filter.chunked(...)          // Line 627 - Chunk filters
      let all_favorites = damus_state.contactCards.favorites  // Line 638
      let favorited_not_followed = Array(all_favorites.subtracting(Set(friends)))  // Line 639 - Set operations

      self.homeHandlerTask?.cancel()  // Line 648 - Cancel existing stream
      self.homeHandlerTask = Task {   // Line 649 - Create new stream
          for await item in damus_state.nostrNetwork.reader.advancedStream(...) {
              // Stream from NDB + Network in parallel
          }
      }
  }

  Key issues:

  1. Overkill response - Adding a single favorite rebuilds ALL home subscriptions
  2. Main thread blocking - Filter construction and set operations run synchronously
  3. Task cancellation overhead - Canceling and recreating the entire home stream (Line 648-649)
  4. NDB + Network parallel query - The advancedStream with .ndbAndNetworkParallel mode may have heavy initialization

  Supporting Evidence from Issue

  The reporter notes that other features also freeze (feed scrolling, search), suggesting the network/relay layer (advancedStream) is the deeper issue. Favorites just exposes this problem because it unnecessarily triggers a full resubscription.

  ---
  Recommended Fixes

  Option A: Quick Fix - Remove Full Resubscribe for Favorites

  ContentView.swift:463-465 - The favorite notification shouldn't trigger a full resubscribe:

  // Current (problematic):
  .onReceive(handle_notify(.favoriteUpdated)) { _ in
      home.resubscribe(.following)  // Too heavy!
  }

  // Proposed fix - Just filter/update events locally:
  .onReceive(handle_notify(.favoriteUpdated)) { _ in
      home.filter_events()  // Much lighter - just re-filter existing events
  }

  If new posts from the favorite need to appear, add an incremental subscription for just that one pubkey instead of rebuilding everything.

  Option B: Make Favorite Updates Incremental

  Instead of calling subscribe_to_home_filters() which rebuilds everything, create a method that adds/removes a single pubkey filter:

  // In HomeModel.swift
  func updateFavoriteSubscription(added: Pubkey?, removed: Pubkey?) {
      // Add incremental filter for new favorite
      // Or locally filter out removed favorite's events
      // Don't touch the main home stream
  }

  Option C: Move Heavy Work Off Main Thread

  If full resubscription is truly needed, move the synchronous work to a background queue:

  func subscribe_to_home_filters(friends fs: [Pubkey]? = nil) {
      Task.detached(priority: .userInitiated) {
          // Build filters on background thread
          let friends = fs ?? await MainActor.run { self.get_friends() }
          // ... build all filters ...

          await MainActor.run {
              self.homeHandlerTask?.cancel()
              self.homeHandlerTask = Task { /* stream */ }
          }
      }
  }

  ---
  Recommended Action Plan

  1. Immediate fix: Change ContentView.swift:464 from home.resubscribe(.following) to home.filter_events() - this eliminates the freeze without losing functionality for existing events
  2. Follow-up: Implement incremental subscription updates for favorites so new posts appear without full resubscription
  3. Investigation needed: The broader freezes in feed/search suggest the advancedStream / network layer needs profiling - that's a separate issue

[alltheseas]

@askeew please consider the following fixes:

Problem

When a user favorites someone, the app triggers home.resubscribe(.following) which:

1. Cancels the entire home feed subscription
2. Rebuilds filters for ALL followed users + favorites
3. Creates a new network stream from scratch

This is overkill for adding a single favorite and blocks the main thread, causing a 15+ second freeze.

Solution

Replace the full resubscription with an incremental approach:

• Adding a favorite: Start a small background subscription for just that one user (50 posts max)
• Removing a favorite: Filter their posts out of the existing event list locally

The main home stream is never touched, so the UI stays responsive.

Files Changed

File	Change
ContactCardNotify.swift	Added FavoriteUpdate payload with pubkey + add/remove action
ContactCardManager.swift	Pass the pubkey and action in notifications
HomeModel.swift	Added handleFavoriteUpdate() and addFavoriteSubscription() for incremental updates
ContentView.swift	Use new incremental handler instead of resubscribe()

Example Code

diff --git a/damus/ContentView.swift b/damus/ContentView.swift
  index 88260424..5003a1bd 100644
  --- a/damus/ContentView.swift
  +++ b/damus/ContentView.swift
  @@ -460,8 +460,8 @@ struct ContentView: View {
           .onReceive(handle_notify(.present_full_screen_item)) { item in
               self.active_full_screen_item = item
           }
  -        .onReceive(handle_notify(.favoriteUpdated)) { _ in
  -            home.resubscribe(.following)
  +        .onReceive(handle_notify(.favoriteUpdated)) { update in
  +            home.handleFavoriteUpdate(update)
           }
           .onReceive(handle_notify(.zapping)) { zap_ev in
               guard !zap_ev.is_custom else {
  diff --git a/damus/Features/ContactCard/ContactCardManager.swift b/damus/Features/ContactCard/ContactCardManager.swift
  index 2f1b04c0..439f1e4a 100644
  --- a/damus/Features/ContactCard/ContactCardManager.swift
  +++ b/damus/Features/ContactCard/ContactCardManager.swift
  @@ -65,7 +65,7 @@ class ContactCardManager: ContactCard {
           }

           latestContactCardEvents[targetPubkey] = ev
  -        notify(.favoriteUpdated())
  +        notify(.favoriteUpdated(FavoriteUpdate(pubkey: targetPubkey, isFavorite: isFavorite)))
       }

       var filter: (NostrEvent) -> Bool {
  @@ -115,7 +115,7 @@ class ContactCardManager: ContactCard {

           Task { await postbox.send(ev) }
           latestContactCardEvents[target] = ev
  -        notify(.favoriteUpdated())
  +        notify(.favoriteUpdated(FavoriteUpdate(pubkey: target, isFavorite: favorite)))
       }
   }

  diff --git a/damus/Features/Timeline/Models/HomeModel.swift b/damus/Features/Timeline/Models/HomeModel.swift
  index 98929186..27e0a2fb 100644
  --- a/damus/Features/Timeline/Models/HomeModel.swift
  +++ b/damus/Features/Timeline/Models/HomeModel.swift
  @@ -683,7 +683,54 @@ class HomeModel: ContactsDelegate, ObservableObject {
               }
           }
       }
  -    
  +
  +    /// Handle incremental favorite updates without rebuilding all subscriptions
  +    func handleFavoriteUpdate(_ update: FavoriteUpdate) {
  +        guard damus_state.settings.enable_favourites_feature else { return }
  +
  +        if update.isFavorite {
  +            // Add a lightweight subscription for the newly favorited user
  +            addFavoriteSubscription(for: update.pubkey)
  +        } else {
  +            // Filter out events from unfavorited user (if they're not a friend)
  +            if !damus_state.contacts.is_friend(update.pubkey) {
  +                events.filter { ev in ev.pubkey != update.pubkey }
  +            }
  +        }
  +    }
  +
  +    /// Add a subscription for a single favorited user's posts
  +    private func addFavoriteSubscription(for pubkey: Pubkey) {
  +        // Don't add if already following this user
  +        guard !damus_state.contacts.is_friend(pubkey) else { return }
  +
  +        var home_filter_kinds: [NostrKind] = [.text, .longform, .boost, .highlight]
  +        if !damus_state.settings.onlyzaps_mode {
  +            home_filter_kinds.append(.like)
  +        }
  +        if damus_state.settings.show_music_statuses || damus_state.settings.show_general_statuses {
  +            home_filter_kinds.append(.status)
  +        }
  +
  +        var filter = NostrFilter(kinds: home_filter_kinds)
  +        filter.authors = [pubkey]
  +        filter.limit = 50
  +
  +        Task {
  +            for await item in damus_state.nostrNetwork.reader.advancedStream(
  +                filters: [filter],
  +                streamMode: .ndbAndNetworkParallel(optimizeNetworkFilter: true)
  +            ) {
  +                switch item {
  +                case .event(let lender):
  +                    await lender.justUseACopy({ await process_event(ev: $0, context: .home) })
  +                case .eose, .ndbEose, .networkEose:
  +                    break
  +                }
  +            }
  +        }
  +    }
  +
       /// Adapter pattern to make migration easier
       enum SubscriptionContext {
           case home
  diff --git a/damus/Notify/ContactCardNotify.swift b/damus/Notify/ContactCardNotify.swift
  index c92b6eaa..33c1d489 100644
  --- a/damus/Notify/ContactCardNotify.swift
  +++ b/damus/Notify/ContactCardNotify.swift
  @@ -1,6 +1,11 @@
  +struct FavoriteUpdate {
  +    let pubkey: Pubkey
  +    let isFavorite: Bool
  +}
  +
   struct FavoriteNotify: Notify {
  -    typealias Payload = Void
  -    var payload: Void
  +    typealias Payload = FavoriteUpdate
  +    var payload: FavoriteUpdate
   }

   extension NotifyHandler {
  @@ -10,7 +15,7 @@ extension NotifyHandler {
   }

   extension Notifications {
  -    static func favoriteUpdated() -> Notifications<FavoriteNotify> {
  -        .init(.init(payload: ()))
  +    static func favoriteUpdated(_ update: FavoriteUpdate) -> Notifications<FavoriteNotify> {
  +        .init(.init(payload: update))
       }
   }