diff --git a/damus/ContentView.swift b/damus/ContentView.swift index 23969458..f9411c9f 100644 --- a/damus/ContentView.swift +++ b/damus/ContentView.swift @@ -381,6 +381,8 @@ struct ContentView: View { self.confirm_mute = true } .onReceive(handle_notify(.attached_wallet)) { nwc in + try? damus_state.nostrNetwork.userRelayList.load() // Reload relay list to apply changes + // update the lightning address on our profile when we attach a // wallet with an associated guard let ds = self.damus_state, @@ -472,7 +474,7 @@ struct ContentView: View { } } .onReceive(handle_notify(.disconnect_relays)) { () in - damus_state.nostrNetwork.pool.disconnect() + damus_state.nostrNetwork.disconnect() } .onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) { obj in print("txn: 📙 DAMUS ACTIVE NOTIFY") @@ -518,7 +520,7 @@ struct ContentView: View { break case .active: print("txn: 📙 DAMUS ACTIVE") - damus_state.nostrNetwork.pool.ping() + damus_state.nostrNetwork.ping() @unknown default: break } @@ -717,8 +719,7 @@ struct ContentView: View { // Purple API is an experimental feature. If not enabled, do not connect `StoreObserver` with Purple API to avoid leaking receipts } - damus_state.nostrNetwork.pool.register_handler(sub_id: sub_id, handler: home.handle_event) - damus_state.nostrNetwork.connect() + if #available(iOS 17, *) { if damus_state.settings.developer_mode && damus_state.settings.reset_tips_on_launch { @@ -734,6 +735,11 @@ struct ContentView: View { Log.error("Failed to configure tips: %s", for: .tips, error.localizedDescription) } } + damus_state.nostrNetwork.connect() + // TODO: Move this to a better spot. Not sure what is the best signal to listen to for sending initial filters + DispatchQueue.main.asyncAfter(deadline: .now() + 3, execute: { + self.home.send_initial_filters() + }) } func music_changed(_ state: MusicState) { @@ -943,169 +949,11 @@ enum FindEventType { } enum FoundEvent { + // TODO: Why not return the profile record itself? Right now the code probably just wants to trigger ndb to ingest the profile record and be available at ndb in parallel, but it would be cleaner if the function that uses this simply does that ndb query on their behalf. case profile(Pubkey) case event(NostrEvent) } -/// Finds an event from NostrDB if it exists, or from the network -/// -/// This is the callback version. There is also an asyc/await version of this function. -/// -/// - Parameters: -/// - state: Damus state -/// - query_: The query, including the event being looked for, and the relays to use when looking -/// - callback: The function to call with results -func find_event(state: DamusState, query query_: FindEvent, callback: @escaping (FoundEvent?) -> ()) { - return find_event_with_subid(state: state, query: query_, subid: UUID().description, callback: callback) -} - -/// Finds an event from NostrDB if it exists, or from the network -/// -/// This is a the async/await version of `find_event`. Use this when using callbacks is impossible or cumbersome. -/// -/// - Parameters: -/// - state: Damus state -/// - query_: The query, including the event being looked for, and the relays to use when looking -/// - callback: The function to call with results -func find_event(state: DamusState, query query_: FindEvent) async -> FoundEvent? { - await withCheckedContinuation { continuation in - find_event(state: state, query: query_) { event in - var already_resumed = false - if !already_resumed { // Ensure we do not resume twice, as it causes a crash - continuation.resume(returning: event) - already_resumed = true - } - } - } -} - -func find_event_with_subid(state: DamusState, query query_: FindEvent, subid: String, callback: @escaping (FoundEvent?) -> ()) { - - var filter: NostrFilter? = nil - let find_from = query_.find_from - let query = query_.type - - switch query { - case .profile(let pubkey): - if let profile_txn = state.ndb.lookup_profile(pubkey), - let record = profile_txn.unsafeUnownedValue, - record.profile != nil - { - callback(.profile(pubkey)) - return - } - filter = NostrFilter(kinds: [.metadata], limit: 1, authors: [pubkey]) - - case .event(let evid): - if let ev = state.events.lookup(evid) { - callback(.event(ev)) - return - } - - filter = NostrFilter(ids: [evid], limit: 1) - } - - var attempts: Int = 0 - var has_event = false - guard let filter else { return } - - state.nostrNetwork.pool.subscribe_to(sub_id: subid, filters: [filter], to: find_from) { relay_id, res in - guard case .nostr_event(let ev) = res else { - return - } - - guard ev.subid == subid else { - return - } - - switch ev { - case .ok: - break - case .event(_, let ev): - has_event = true - state.nostrNetwork.pool.unsubscribe(sub_id: subid) - - switch query { - case .profile: - if ev.known_kind == .metadata { - callback(.profile(ev.pubkey)) - } - case .event: - callback(.event(ev)) - } - case .eose: - if !has_event { - attempts += 1 - if attempts >= state.nostrNetwork.pool.our_descriptors.count { - callback(nil) // If we could not find any events in any of the relays we are connected to, send back nil - } - } - state.nostrNetwork.pool.unsubscribe(sub_id: subid, to: [relay_id]) // We are only finding an event once, so close subscription on eose - case .notice: - break - case .auth: - break - } - } -} - - -/// Finds a replaceable event based on an `naddr` address. -/// -/// This is the callback version of the function. There is another function that makes use of async/await -/// -/// - Parameters: -/// - damus_state: The Damus state -/// - naddr: the `naddr` address -/// - callback: A function to handle the found event -func naddrLookup(damus_state: DamusState, naddr: NAddr, callback: @escaping (NostrEvent?) -> ()) { - let nostrKinds: [NostrKind]? = NostrKind(rawValue: naddr.kind).map { [$0] } - - let filter = NostrFilter(kinds: nostrKinds, authors: [naddr.author]) - - let subid = UUID().description - - damus_state.nostrNetwork.pool.subscribe_to(sub_id: subid, filters: [filter], to: nil) { relay_id, res in - guard case .nostr_event(let ev) = res else { - damus_state.nostrNetwork.pool.unsubscribe(sub_id: subid, to: [relay_id]) - return - } - - if case .event(_, let ev) = ev { - for tag in ev.tags { - if(tag.count >= 2 && tag[0].string() == "d"){ - if (tag[1].string() == naddr.identifier){ - damus_state.nostrNetwork.pool.unsubscribe(sub_id: subid, to: [relay_id]) - callback(ev) - return - } - } - } - } - damus_state.nostrNetwork.pool.unsubscribe(sub_id: subid, to: [relay_id]) - } -} - -/// Finds a replaceable event based on an `naddr` address. -/// -/// This is the async/await version of the function. Another version of this function which makes use of callback functions also exists . -/// -/// - Parameters: -/// - damus_state: The Damus state -/// - naddr: the `naddr` address -/// - callback: A function to handle the found event -func naddrLookup(damus_state: DamusState, naddr: NAddr) async -> NostrEvent? { - await withCheckedContinuation { continuation in - var already_resumed = false - naddrLookup(damus_state: damus_state, naddr: naddr) { event in - if !already_resumed { // Ensure we do not resume twice, as it causes a crash - continuation.resume(returning: event) - already_resumed = true - } - } - } -} - func timeline_name(_ timeline: Timeline?) -> String { guard let timeline else { return "" @@ -1260,4 +1108,3 @@ func logout(_ state: DamusState?) state?.close() notify(.logout) } - diff --git a/damus/Core/Networking/NostrNetworkManager/NostrNetworkManager.swift b/damus/Core/Networking/NostrNetworkManager/NostrNetworkManager.swift index d879ba49..0e435f6d 100644 --- a/damus/Core/Networking/NostrNetworkManager/NostrNetworkManager.swift +++ b/damus/Core/Networking/NostrNetworkManager/NostrNetworkManager.swift @@ -24,7 +24,7 @@ class NostrNetworkManager { /// ## Implementation notes /// /// - This will be marked `private` in the future to prevent other code from accessing the relay pool directly. Code outside this layer should use a higher level interface - let pool: RelayPool // TODO: Make this private and make higher level interface for classes outside the NostrNetworkManager + private let pool: RelayPool // TODO: Make this private and make higher level interface for classes outside the NostrNetworkManager /// A delegate that allows us to interact with the rest of app without introducing hard or circular dependencies private var delegate: Delegate /// Manages the user's relay list, controls RelayPool's connected relays @@ -51,6 +51,14 @@ class NostrNetworkManager { func connect() { self.userRelayList.connect() } + + func disconnect() { + self.pool.disconnect() + } + + func ping() { + self.pool.ping() + } func relaysForEvent(event: NostrEvent) -> [RelayURL] { // TODO(tyiu) Ideally this list would be sorted by the event author's outbox relay preferences @@ -61,6 +69,174 @@ class NostrNetworkManager { return [] } + + // TODO: ORGANIZE THESE + + // MARK: - Communication with the Nostr Network + /// ## Implementation notes + /// + /// - This class hides the relay pool on purpose to avoid other code from dealing with complex relay + nostrDB logic. + /// - Instead, we provide an easy to use interface so that normal code can just get the info they want. + /// - This is also to help us migrate to the relay model. + // TODO: Define a better interface. This is a temporary scaffold to replace direct relay pool access. After that is done, we can refactor this interface to be cleaner and reduce non-sense. + + func sendToNostrDB(event: NostrEvent) { + self.pool.send_raw_to_local_ndb(.typical(.event(event))) + } + + func send(event: NostrEvent) { + self.pool.send(.event(event)) + } + + func query(filters: [NostrFilter], to: [RelayURL]? = nil) async -> [NostrEvent] { + var events: [NostrEvent] = [] + for await item in self.reader.subscribe(filters: filters, to: to) { + switch item { + case .event(let borrow): + try? borrow { event in + events.append(event.toOwned()) + } + case .eose: + break + } + } + return events + } + + /// Finds a replaceable event based on an `naddr` address. + /// + /// - Parameters: + /// - naddr: the `naddr` address + func lookup(naddr: NAddr) async -> NostrEvent? { + var nostrKinds: [NostrKind]? = NostrKind(rawValue: naddr.kind).map { [$0] } + + let filter = NostrFilter(kinds: nostrKinds, authors: [naddr.author]) + + for await item in self.reader.subscribe(filters: [filter]) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + if event?.referenced_params.first?.param.string() == naddr.identifier { + return event + } + case .eose: + break + } + } + return nil + } + + // TODO: Improve this. This is mostly intact to keep compatibility with its predecessor, but we can do better + func findEvent(query: FindEvent) async -> FoundEvent? { + var filter: NostrFilter? = nil + let find_from = query.find_from + let query = query.type + + switch query { + case .profile(let pubkey): + if let profile_txn = delegate.ndb.lookup_profile(pubkey), + let record = profile_txn.unsafeUnownedValue, + record.profile != nil + { + return .profile(pubkey) + } + filter = NostrFilter(kinds: [.metadata], limit: 1, authors: [pubkey]) + case .event(let evid): + if let event = delegate.ndb.lookup_note(evid)?.unsafeUnownedValue?.to_owned() { + return .event(event) + } + filter = NostrFilter(ids: [evid], limit: 1) + } + + var attempts: Int = 0 + var has_event = false + guard let filter else { return nil } + + for await item in self.reader.subscribe(filters: [filter], to: find_from) { + switch item { + case .event(let borrow): + var result: FoundEvent? = nil + try? borrow { event in + switch query { + case .profile: + if event.known_kind == .metadata { + result = .profile(event.pubkey) + } + case .event: + result = .event(event.toOwned()) + } + } + return result + case .eose: + return nil + } + } + return nil + } + + func getRelay(_ id: RelayURL) -> RelayPool.Relay? { + pool.get_relay(id) + } + + var connectedRelays: [RelayPool.Relay] { + self.pool.relays + } + + var ourRelayDescriptors: [RelayPool.RelayDescriptor] { + self.pool.our_descriptors + } + + func relayURLsThatSawNote(id: NoteId) -> Set? { + return self.pool.seen[id] + } + + func determineToRelays(filters: RelayFilters) -> [RelayURL] { + return self.pool.our_descriptors + .map { $0.url } + .filter { !filters.is_filtered(timeline: .search, relay_id: $0) } + } + + // MARK: NWC + // TODO: Move this to NWCManager + + @discardableResult + func nwcPay(url: WalletConnectURL, post: PostBox, invoice: String, delay: TimeInterval? = 5.0, on_flush: OnFlush? = nil, zap_request: NostrEvent? = nil) -> NostrEvent? { + WalletConnect.pay(url: url, pool: self.pool, post: post, invoice: invoice, zap_request: nil) + } + + func requestTransactionList(url: WalletConnectURL, delay: TimeInterval? = 0.0, on_flush: OnFlush? = nil) { + WalletConnect.request_transaction_list(url: url, pool: self.pool, post: self.postbox, delay: delay, on_flush: on_flush) + } + + func requestBalanceInformation(url: WalletConnectURL, delay: TimeInterval? = 0.0, on_flush: OnFlush? = nil) { + WalletConnect.request_balance_information(url: url, pool: self.pool, post: self.postbox, delay: delay, on_flush: on_flush) + } + + /// Send a donation zap to the Damus team + func send_donation_zap(nwc: WalletConnectURL, percent: Int, base_msats: Int64) async { + let percent_f = Double(percent) / 100.0 + let donations_msats = Int64(percent_f * Double(base_msats)) + + let payreq = LNUrlPayRequest(allowsNostr: true, commentAllowed: nil, nostrPubkey: "", callback: "https://sendsats.lol/@damus") + guard let invoice = await fetch_zap_invoice(payreq, zapreq: nil, msats: donations_msats, zap_type: .non_zap, comment: nil) else { + // we failed... oh well. no donation for us. + print("damus-donation failed to fetch invoice") + return + } + + print("damus-donation donating...") + WalletConnect.pay(url: nwc, pool: self.pool, post: self.postbox, invoice: invoice, zap_request: nil, delay: nil) + } + + + // MARK: - App lifecycle functions + + func close() { + pool.close() + } } diff --git a/damus/Core/Networking/NostrNetworkManager/SubscriptionManager.swift b/damus/Core/Networking/NostrNetworkManager/SubscriptionManager.swift index 536c897f..9de44e8b 100644 --- a/damus/Core/Networking/NostrNetworkManager/SubscriptionManager.swift +++ b/damus/Core/Networking/NostrNetworkManager/SubscriptionManager.swift @@ -30,10 +30,10 @@ extension NostrNetworkManager { /// /// - Parameter filters: The nostr filters to specify what kind of data to subscribe to /// - Returns: An async stream of nostr data - func subscribe(filters: [NostrFilter]) -> AsyncStream { + func subscribe(filters: [NostrFilter], to desiredRelays: [RelayURL]? = nil) -> AsyncStream { return AsyncStream { continuation in let streamTask = Task { - for await item in self.pool.subscribe(filters: filters) { + for await item in self.pool.subscribe(filters: filters, to: desiredRelays) { switch item { case .eose: continuation.yield(.eose) case .event(let nostrEvent): diff --git a/damus/Core/Nostr/RelayPool.swift b/damus/Core/Nostr/RelayPool.swift index 5f74727a..be9e1be9 100644 --- a/damus/Core/Nostr/RelayPool.swift +++ b/damus/Core/Nostr/RelayPool.swift @@ -19,6 +19,11 @@ struct QueuedRequest { let skip_ephemeral: Bool } +struct SeenEvent: Hashable { + let relay_id: RelayURL + let evid: NoteId +} + /// Establishes and manages connections and subscriptions to a list of relays. class RelayPool { private(set) var relays: [Relay] = [] @@ -31,6 +36,8 @@ class RelayPool { var keypair: Keypair? var message_received_function: (((String, RelayDescriptor)) -> Void)? var message_sent_function: (((String, Relay)) -> Void)? + var delegate: Delegate? + private(set) var signal: SignalModel = SignalModel() private let network_monitor = NWPathMonitor() private let network_monitor_queue = DispatchQueue(label: "io.damus.network_monitor") @@ -410,3 +417,10 @@ func add_rw_relay(_ pool: RelayPool, _ url: RelayURL) { } +extension RelayPool { + protocol Delegate { + func latestRelayListChanged(_ newEvent: NdbNote) + } +} + + diff --git a/damus/Core/Nostr/RelayURL.swift b/damus/Core/Nostr/RelayURL.swift index 53f6fbe1..2ced393e 100644 --- a/damus/Core/Nostr/RelayURL.swift +++ b/damus/Core/Nostr/RelayURL.swift @@ -7,7 +7,7 @@ import Foundation -public struct RelayURL: Hashable, Equatable, Codable, CodingKeyRepresentable, Identifiable, Comparable, CustomStringConvertible { +public struct RelayURL: Hashable, Equatable, Codable, CodingKeyRepresentable, Identifiable, Comparable, CustomStringConvertible, Sendable { private(set) var url: URL public var id: URL { diff --git a/damus/Core/Storage/DamusState.swift b/damus/Core/Storage/DamusState.swift index dbabdf3f..1155799e 100644 --- a/damus/Core/Storage/DamusState.swift +++ b/damus/Core/Storage/DamusState.swift @@ -164,7 +164,7 @@ class DamusState: HeadlessDamusState { try await self.push_notification_client.revoke_token() } wallet.disconnect() - nostrNetwork.pool.close() + nostrNetwork.close() ndb.close() } diff --git a/damus/Features/Actions/ActionBar/Models/ActionBarModel.swift b/damus/Features/Actions/ActionBar/Models/ActionBarModel.swift index 971639ed..7c9b06d9 100644 --- a/damus/Features/Actions/ActionBar/Models/ActionBarModel.swift +++ b/damus/Features/Actions/ActionBar/Models/ActionBarModel.swift @@ -58,7 +58,7 @@ class ActionBarModel: ObservableObject { self.our_zap = damus.zaps.our_zaps[evid]?.first self.our_reply = damus.replies.our_reply(evid) self.our_quote_repost = damus.quote_reposts.our_events[evid] - self.relays = (damus.nostrNetwork.pool.seen[evid] ?? []).count + self.relays = (damus.nostrNetwork.relayURLsThatSawNote(id: evid) ?? []).count self.objectWillChange.send() } diff --git a/damus/Features/Actions/ActionBar/Views/EventDetailBar.swift b/damus/Features/Actions/ActionBar/Views/EventDetailBar.swift index 03897994..604c4e30 100644 --- a/damus/Features/Actions/ActionBar/Views/EventDetailBar.swift +++ b/damus/Features/Actions/ActionBar/Views/EventDetailBar.swift @@ -61,7 +61,7 @@ struct EventDetailBar: View { } if bar.relays > 0 { - let relays = Array(state.nostrNetwork.pool.seen[target] ?? []) + let relays = Array(state.nostrNetwork.relayURLsThatSawNote(id: target) ?? []) NavigationLink(value: Route.UserRelays(relays: relays)) { let nounString = pluralizedString(key: "relays_count", count: bar.relays) let noun = Text(nounString).foregroundColor(.gray) diff --git a/damus/Features/Chat/Models/ThreadModel.swift b/damus/Features/Chat/Models/ThreadModel.swift index 0e21e586..332b11de 100644 --- a/damus/Features/Chat/Models/ThreadModel.swift +++ b/damus/Features/Chat/Models/ThreadModel.swift @@ -56,12 +56,7 @@ class ThreadModel: ObservableObject { /// The damus state, needed to access the relay pool and load the thread events let damus_state: DamusState - private let profiles_subid = UUID().description - private let base_subid = UUID().description - private let meta_subid = UUID().description - private var subids: [String] { - return [profiles_subid, base_subid, meta_subid] - } + private var listener: Task? // MARK: Initialization @@ -86,17 +81,6 @@ class ThreadModel: ObservableObject { // MARK: Relay pool subscription management - /// Unsubscribe from events in the relay pool. Call this when unloading the view - func unsubscribe() { - self.damus_state.nostrNetwork.pool.remove_handler(sub_id: base_subid) - self.damus_state.nostrNetwork.pool.remove_handler(sub_id: meta_subid) - self.damus_state.nostrNetwork.pool.remove_handler(sub_id: profiles_subid) - self.damus_state.nostrNetwork.pool.unsubscribe(sub_id: base_subid) - self.damus_state.nostrNetwork.pool.unsubscribe(sub_id: meta_subid) - self.damus_state.nostrNetwork.pool.unsubscribe(sub_id: profiles_subid) - Log.info("unsubscribing to thread %s with sub_id %s", for: .render, original_event.id.hex(), base_subid) - } - /// Subscribe to events in this thread. Call this when loading the view. func subscribe() { var meta_events = NostrFilter() @@ -127,10 +111,27 @@ class ThreadModel: ObservableObject { let base_filters = [event_filter, ref_events] let meta_filters = [meta_events, quote_events] - - Log.info("subscribing to thread %s with sub_id %s", for: .render, original_event.id.hex(), base_subid) - damus_state.nostrNetwork.pool.subscribe(sub_id: base_subid, filters: base_filters, handler: handle_event) - damus_state.nostrNetwork.pool.subscribe(sub_id: meta_subid, filters: meta_filters, handler: handle_event) + + self.listener?.cancel() + self.listener = Task { + Log.info("subscribing to thread %s ", for: .render, original_event.id.hex()) + for await item in damus_state.nostrNetwork.reader.subscribe(filters: base_filters + meta_filters) { + switch item { + case .event(let borrow): + try? borrow { event in + handle_event(ev: event.toOwned()) + } + case .eose: + guard let txn = NdbTxn(ndb: damus_state.ndb) else { return } + load_profiles(context: "thread", load: .from_events(Array(event_map.events)), damus_state: damus_state, txn: txn) + } + } + } + } + + func unsubscribe() { + self.listener?.cancel() + self.listener = nil } /// Adds an event to this thread. @@ -175,35 +176,20 @@ class ThreadModel: ObservableObject { /// /// Marked as private because it is this class' responsibility to load events, not the view's. Simplify the interface @MainActor - private func handle_event(relay_id: RelayURL, ev: NostrConnectionEvent) { - let (sub_id, done) = handle_subid_event(pool: damus_state.nostrNetwork.pool, relay_id: relay_id, ev: ev) { sid, ev in - guard subids.contains(sid) else { - return + private func handle_event(ev: NostrEvent) { + if ev.known_kind == .zap { + process_zap_event(state: damus_state, ev: ev) { zap in + } - - if ev.known_kind == .zap { - process_zap_event(state: damus_state, ev: ev) { zap in - - } - } else if ev.is_textlike { - // handle thread quote reposts, we just count them instead of - // adding them to the thread - if let target = ev.is_quote_repost, target == self.selected_event.id { - //let _ = self.damus_state.quote_reposts.add_event(ev, target: target) - } else { - self.add_event(ev, keypair: damus_state.keypair) - } + } else if ev.is_textlike { + // handle thread quote reposts, we just count them instead of + // adding them to the thread + if let target = ev.is_quote_repost, target == self.selected_event.id { + //let _ = self.damus_state.quote_reposts.add_event(ev, target: target) + } else { + self.add_event(ev, keypair: damus_state.keypair) } } - - guard done, let sub_id, subids.contains(sub_id) else { - return - } - - if sub_id == self.base_subid { - guard let txn = NdbTxn(ndb: damus_state.ndb) else { return } - load_profiles(context: "thread", profiles_subid: self.profiles_subid, relay_id: relay_id, load: .from_events(Array(event_map.events)), damus_state: damus_state, txn: txn) - } } // MARK: External control interface diff --git a/damus/Features/Events/EventLoaderView.swift b/damus/Features/Events/EventLoaderView.swift index 6028895b..511314ca 100644 --- a/damus/Features/Events/EventLoaderView.swift +++ b/damus/Features/Events/EventLoaderView.swift @@ -13,6 +13,7 @@ struct EventLoaderView: View { let event_id: NoteId @State var event: NostrEvent? @State var subscription_uuid: String = UUID().description + @State var loadingTask: Task? = nil let content: (NostrEvent) -> Content init(damus_state: DamusState, event_id: NoteId, @ViewBuilder content: @escaping (NostrEvent) -> Content) { @@ -24,34 +25,24 @@ struct EventLoaderView: View { } func unsubscribe() { - damus_state.nostrNetwork.pool.unsubscribe(sub_id: subscription_uuid) + self.loadingTask?.cancel() } func subscribe(filters: [NostrFilter]) { - damus_state.nostrNetwork.pool.register_handler(sub_id: subscription_uuid, handler: handle_event) - damus_state.nostrNetwork.pool.send(.subscribe(.init(filters: filters, sub_id: subscription_uuid))) - } - - func handle_event(relay_id: RelayURL, ev: NostrConnectionEvent) { - guard case .nostr_event(let nostr_response) = ev else { - return + self.loadingTask?.cancel() + self.loadingTask = Task { + for await item in await damus_state.nostrNetwork.reader.subscribe(filters: filters) { + switch item { + case .event(let borrow): + try? borrow { ev in + event = ev.toOwned() + } + break + case .eose: + break + } + } } - - guard case .event(let id, let nostr_event) = nostr_response else { - return - } - - guard id == subscription_uuid else { - return - } - - if event != nil { - return - } - - event = nostr_event - - unsubscribe() } func load() { diff --git a/damus/Features/Events/EventMenu.swift b/damus/Features/Events/EventMenu.swift index c43eb6a1..28691fdd 100644 --- a/damus/Features/Events/EventMenu.swift +++ b/damus/Features/Events/EventMenu.swift @@ -152,7 +152,7 @@ struct MenuItems: View { profileModel.subscribeToFindRelays() } .onDisappear() { - profileModel.unsubscribeFindRelays() + profileModel.findRelaysListener?.cancel() } } } diff --git a/damus/Features/Events/Models/EventsModel.swift b/damus/Features/Events/Models/EventsModel.swift index e2d5fef1..381a6270 100644 --- a/damus/Features/Events/Models/EventsModel.swift +++ b/damus/Features/Events/Models/EventsModel.swift @@ -11,10 +11,10 @@ class EventsModel: ObservableObject { let state: DamusState let target: NoteId let kind: QueryKind - let sub_id = UUID().uuidString let profiles_id = UUID().uuidString var events: EventHolder @Published var loading: Bool + var loadingTask: Task? enum QueryKind { case kind(NostrKind) @@ -68,13 +68,29 @@ class EventsModel: ObservableObject { } func subscribe() { - state.nostrNetwork.pool.subscribe(sub_id: sub_id, - filters: [get_filter()], - handler: handle_nostr_event) + loadingTask?.cancel() + loadingTask = Task { + for await item in state.nostrNetwork.reader.subscribe(filters: [get_filter()]) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + guard let event else { return } + if events.insert(event) { objectWillChange.send() } + case .eose: + break + } + } + self.loading = false + guard let txn = NdbTxn(ndb: self.state.ndb) else { return } + load_profiles(context: "events_model", load: .from_events(events.all_events), damus_state: state, txn: txn) + } } func unsubscribe() { - state.nostrNetwork.pool.unsubscribe(sub_id: sub_id) + loadingTask?.cancel() } private func handle_event(relay_id: RelayURL, ev: NostrEvent) { @@ -82,28 +98,4 @@ class EventsModel: ObservableObject { objectWillChange.send() } } - - func handle_nostr_event(relay_id: RelayURL, ev: NostrConnectionEvent) { - guard case .nostr_event(let nev) = ev, nev.subid == self.sub_id - else { - return - } - - switch nev { - case .event(_, let ev): - handle_event(relay_id: relay_id, ev: ev) - case .notice: - break - case .ok: - break - case .auth: - break - case .eose: - self.loading = false - guard let txn = NdbTxn(ndb: self.state.ndb) else { - return - } - load_profiles(context: "events_model", profiles_subid: profiles_id, relay_id: relay_id, load: .from_events(events.all_events), damus_state: state, txn: txn) - } - } } diff --git a/damus/Features/Events/Models/LoadableNostrEventView.swift b/damus/Features/Events/Models/LoadableNostrEventView.swift index 6d4b4ed3..af9bf348 100644 --- a/damus/Features/Events/Models/LoadableNostrEventView.swift +++ b/damus/Features/Events/Models/LoadableNostrEventView.swift @@ -50,7 +50,7 @@ class LoadableNostrEventViewModel: ObservableObject { /// Asynchronously find an event from NostrDB or from the network (if not available on NostrDB) private func loadEvent(noteId: NoteId) async -> NostrEvent? { - let res = await find_event(state: damus_state, query: .event(evid: noteId)) + let res = await damus_state.nostrNetwork.findEvent(query: .event(evid: noteId)) guard let res, case .event(let ev) = res else { return nil } return ev } @@ -78,7 +78,7 @@ class LoadableNostrEventViewModel: ObservableObject { return .unknown_or_unsupported_kind } case .naddr(let naddr): - guard let event = await naddrLookup(damus_state: damus_state, naddr: naddr) else { return .not_found } + guard let event = await damus_state.nostrNetwork.lookup(naddr: naddr) else { return .not_found } return .loaded(route: Route.Thread(thread: ThreadModel(event: event, damus_state: damus_state))) } } diff --git a/damus/Features/FollowPack/Models/FollowPackModel.swift b/damus/Features/FollowPack/Models/FollowPackModel.swift index 31e2bdc7..b542b50c 100644 --- a/damus/Features/FollowPack/Models/FollowPackModel.swift +++ b/damus/Features/FollowPack/Models/FollowPackModel.swift @@ -13,7 +13,7 @@ class FollowPackModel: ObservableObject { @Published var loading: Bool = false let damus_state: DamusState - let subid = UUID().description + var listener: Task? = nil let limit: UInt32 = 500 init(damus_state: DamusState) { @@ -25,52 +25,40 @@ class FollowPackModel: ObservableObject { func subscribe(follow_pack_users: [Pubkey]) { loading = true - let to_relays = determine_to_relays(pool: damus_state.nostrNetwork.pool, filters: damus_state.relay_filters) + self.listener = Task { + await self.listenForUpdates(follow_pack_users: follow_pack_users) + } + } + + func unsubscribe(to: RelayURL? = nil) { + loading = false + self.listener?.cancel() + } + + func listenForUpdates(follow_pack_users: [Pubkey]) async { + let to_relays = damus_state.nostrNetwork.determineToRelays(filters: damus_state.relay_filters) var filter = NostrFilter(kinds: [.text, .chat]) filter.until = UInt32(Date.now.timeIntervalSince1970) filter.authors = follow_pack_users filter.limit = 500 - damus_state.nostrNetwork.pool.subscribe(sub_id: subid, filters: [filter], handler: handle_event, to: to_relays) - } - - func unsubscribe(to: RelayURL? = nil) { - loading = false - damus_state.nostrNetwork.pool.unsubscribe(sub_id: subid, to: to.map { [$0] }) - } - - func handle_event(relay_id: RelayURL, conn_ev: NostrConnectionEvent) { - guard case .nostr_event(let event) = conn_ev else { - return - } - - switch event { - case .event(let sub_id, let ev): - guard sub_id == self.subid else { - return - } - if ev.is_textlike && should_show_event(state: damus_state, ev: ev) && !ev.is_reply() - { - if self.events.insert(ev) { - self.objectWillChange.send() + for await item in damus_state.nostrNetwork.reader.subscribe(filters: [filter], to: to_relays) { + switch item { + case .event(borrow: let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() } + guard let event else { return } + if event.is_textlike && should_show_event(state: damus_state, ev: event) && !event.is_reply() + { + if self.events.insert(event) { + self.objectWillChange.send() + } + } + case .eose: + continue } - case .notice(let msg): - print("follow pack notice: \(msg)") - case .ok: - break - case .eose(let sub_id): - loading = false - - if sub_id == self.subid { - unsubscribe(to: relay_id) - - guard let txn = NdbTxn(ndb: damus_state.ndb) else { return } - } - - break - case .auth: - break } } } diff --git a/damus/Features/Follows/Models/FollowersModel.swift b/damus/Features/Follows/Models/FollowersModel.swift index 24f052a1..990cd0d1 100644 --- a/damus/Features/Follows/Models/FollowersModel.swift +++ b/damus/Features/Follows/Models/FollowersModel.swift @@ -14,8 +14,8 @@ class FollowersModel: ObservableObject { @Published var contacts: [Pubkey]? = nil var has_contact: Set = Set() - let sub_id: String = UUID().description - let profiles_id: String = UUID().description + var listener: Task? = nil + var profilesListener: Task? = nil var count: Int? { guard let contacts = self.contacts else { @@ -36,12 +36,27 @@ class FollowersModel: ObservableObject { func subscribe() { let filter = get_filter() let filters = [filter] - //print_filters(relay_id: "following", filters: [filters]) - self.damus_state.nostrNetwork.pool.subscribe(sub_id: sub_id, filters: filters, handler: handle_event) + self.listener?.cancel() + self.listener = Task { + for await item in await damus_state.nostrNetwork.reader.subscribe(filters: filters) { + switch item { + case .event(let borrow): + try? borrow { event in + self.handle_event(ev: event.toOwned()) + } + case .eose: + guard let txn = NdbTxn(ndb: self.damus_state.ndb) else { return } + load_profiles(txn: txn) + } + } + } } func unsubscribe() { - self.damus_state.nostrNetwork.pool.unsubscribe(sub_id: sub_id) + self.listener?.cancel() + self.profilesListener?.cancel() + self.listener = nil + self.profilesListener = nil } func handle_contact_event(_ ev: NostrEvent) { @@ -53,7 +68,7 @@ class FollowersModel: ObservableObject { has_contact.insert(ev.pubkey) } - func load_profiles(relay_id: RelayURL, txn: NdbTxn) { + func load_profiles(txn: NdbTxn) { let authors = find_profiles_to_fetch_from_keys(profiles: damus_state.profiles, pks: contacts ?? [], txn: txn) if authors.isEmpty { return @@ -61,38 +76,24 @@ class FollowersModel: ObservableObject { let filter = NostrFilter(kinds: [.metadata], authors: authors) - damus_state.nostrNetwork.pool.subscribe_to(sub_id: profiles_id, filters: [filter], to: [relay_id], handler: handle_event) - } - - func handle_event(relay_id: RelayURL, ev: NostrConnectionEvent) { - guard case .nostr_event(let nev) = ev else { - return - } - switch nev { - case .event(let sub_id, let ev): - guard sub_id == self.sub_id || sub_id == self.profiles_id else { - return + self.profilesListener?.cancel() + self.profilesListener = Task { + for await item in await damus_state.nostrNetwork.reader.subscribe(filters: [filter]) { + switch item { + case .event(let borrow): + try? borrow { event in + self.handle_event(ev: event.toOwned()) + } + case .eose: break + } } - - if ev.known_kind == .contacts { - handle_contact_event(ev) - } - case .notice(let msg): - print("followingmodel notice: \(msg)") - - case .eose(let sub_id): - if sub_id == self.sub_id { - guard let txn = NdbTxn(ndb: self.damus_state.ndb) else { return } - load_profiles(relay_id: relay_id, txn: txn) - } else if sub_id == self.profiles_id { - damus_state.nostrNetwork.pool.unsubscribe(sub_id: profiles_id, to: [relay_id]) - } - - case .ok: - break - case .auth: - break + } + } + + func handle_event(ev: NostrEvent) { + if ev.known_kind == .contacts { + handle_contact_event(ev) } } } diff --git a/damus/Features/Follows/Models/FollowingModel.swift b/damus/Features/Follows/Models/FollowingModel.swift index db7c1275..59a547ac 100644 --- a/damus/Features/Follows/Models/FollowingModel.swift +++ b/damus/Features/Follows/Models/FollowingModel.swift @@ -14,7 +14,7 @@ class FollowingModel { let contacts: [Pubkey] let hashtags: [Hashtag] - let sub_id: String = UUID().description + private var listener: Task? = nil init(damus_state: DamusState, contacts: [Pubkey], hashtags: [Hashtag]) { self.damus_state = damus_state @@ -41,19 +41,17 @@ class FollowingModel { return } let filters = [filter] - //print_filters(relay_id: "following", filters: [filters]) - self.damus_state.nostrNetwork.pool.subscribe(sub_id: sub_id, filters: filters, handler: handle_event) + self.listener?.cancel() + self.listener = Task { + for await item in self.damus_state.nostrNetwork.reader.subscribe(filters: filters) { + // don't need to do anything here really + continue + } + } } func unsubscribe() { - if !needs_sub { - return - } - print("unsubscribing from following \(sub_id)") - self.damus_state.nostrNetwork.pool.unsubscribe(sub_id: sub_id) - } - - func handle_event(relay_id: RelayURL, ev: NostrConnectionEvent) { - // don't need to do anything here really + self.listener?.cancel() + self.listener = nil } } diff --git a/damus/Features/NIP05/Models/NIP05DomainEventsModel.swift b/damus/Features/NIP05/Models/NIP05DomainEventsModel.swift index 55ab6f07..8c0d4cc5 100644 --- a/damus/Features/NIP05/Models/NIP05DomainEventsModel.swift +++ b/damus/Features/NIP05/Models/NIP05DomainEventsModel.swift @@ -15,8 +15,7 @@ class NIP05DomainEventsModel: ObservableObject { let domain: String var filter: NostrFilter - let sub_id = UUID().description - let profiles_subid = UUID().description + var loadingTask: Task? let limit: UInt32 = 500 init(state: DamusState, domain: String) { @@ -29,6 +28,20 @@ class NIP05DomainEventsModel: ObservableObject { } @MainActor func subscribe() { + print("subscribing to notes from friends of friends with '\(domain)' NIP-05 domain") + loadingTask = Task { + await streamItems() + } + loading = true + } + + func unsubscribe() { + loadingTask?.cancel() + loading = false + print("unsubscribing from notes from friends of friends with '\(domain)' NIP-05 domain") + } + + func streamItems() async { filter.limit = self.limit filter.kinds = [.text, .longform, .highlight] @@ -50,16 +63,19 @@ class NIP05DomainEventsModel: ObservableObject { } filter.authors = Array(authors) - print("subscribing to notes from friends of friends with '\(domain)' NIP-05 domain with sub_id \(sub_id)") - state.nostrNetwork.pool.register_handler(sub_id: sub_id, handler: handle_event) - loading = true - state.nostrNetwork.pool.send(.subscribe(.init(filters: [filter], sub_id: sub_id))) - } - - func unsubscribe() { - state.nostrNetwork.pool.unsubscribe(sub_id: sub_id) - loading = false - print("unsubscribing from notes from friends of friends with '\(domain)' NIP-05 domain with sub_id \(sub_id)") + + for await item in state.nostrNetwork.reader.subscribe(filters: [filter]) { + switch item { + case .event(borrow: let borrow): + try? borrow { event in + self.add_event(event.toOwned()) + guard let txn = NdbTxn(ndb: state.ndb) else { return } + load_profiles(context: "search", load: .from_events(self.events.all_events), damus_state: state, txn: txn) + } + case .eose: + continue + } + } } func add_event(_ ev: NostrEvent) { @@ -75,23 +91,4 @@ class NIP05DomainEventsModel: ObservableObject { objectWillChange.send() } } - - func handle_event(relay_id: RelayURL, ev: NostrConnectionEvent) { - let (sub_id, done) = handle_subid_event(pool: state.nostrNetwork.pool, relay_id: relay_id, ev: ev) { sub_id, ev in - if sub_id == self.sub_id && ev.is_textlike && ev.should_show_event { - self.add_event(ev) - } - } - - guard done else { - return - } - - self.loading = false - - if sub_id == self.sub_id { - guard let txn = NdbTxn(ndb: state.ndb) else { return } - load_profiles(context: "search", profiles_subid: self.profiles_subid, relay_id: relay_id, load: .from_events(self.events.all_events), damus_state: state, txn: txn) - } - } } diff --git a/damus/Features/Onboarding/Views/OnboardingSuggestionsView.swift b/damus/Features/Onboarding/Views/OnboardingSuggestionsView.swift index faf1ba8f..264ecff4 100644 --- a/damus/Features/Onboarding/Views/OnboardingSuggestionsView.swift +++ b/damus/Features/Onboarding/Views/OnboardingSuggestionsView.swift @@ -56,7 +56,7 @@ struct OnboardingSuggestionsView: View { // - We don't have other mechanisms to allow the user to edit this yet // // Therefore, it is better to just save it locally, and retrieve this once we build out https://github.com/damus-io/damus/issues/3042 - model.damus_state.nostrNetwork.pool.send_raw_to_local_ndb(.typical(.event(event))) + model.damus_state.nostrNetwork.sendToNostrDB(event: event) } var body: some View { diff --git a/damus/Features/Posting/Models/DraftsModel.swift b/damus/Features/Posting/Models/DraftsModel.swift index b80ae633..ab478691 100644 --- a/damus/Features/Posting/Models/DraftsModel.swift +++ b/damus/Features/Posting/Models/DraftsModel.swift @@ -224,7 +224,7 @@ class Drafts: ObservableObject { } /// Saves the drafts tracked by this class persistently using NostrDB + UserDefaults - func save(damus_state: DamusState) { + func save(damus_state: DamusState) async { var draft_events: [NdbNote] = [] post_artifact_block: if let post_artifacts = self.post { let nip37_draft = try? post_artifacts.to_nip37_draft(action: .posting(.user(damus_state.pubkey)), damus_state: damus_state) @@ -254,7 +254,7 @@ class Drafts: ObservableObject { // TODO: Once it is time to implement draft syncing with relays, please consider the following: // - Privacy: Sending drafts to the network leaks metadata about app activity, and may break user expectations // - Down-sync conflict resolution: Consider how to solve conflicts for different draft versions holding the same ID (e.g. edited in Damus, then another client, then Damus again) - damus_state.nostrNetwork.pool.send_raw_to_local_ndb(.typical(.event(draft_event))) + damus_state.nostrNetwork.sendToNostrDB(event: draft_event) } damus_state.settings.draft_event_ids = draft_events.map({ $0.id.hex() }) diff --git a/damus/Features/Posting/Views/PostView.swift b/damus/Features/Posting/Views/PostView.swift index 18fe208b..cfec7833 100644 --- a/damus/Features/Posting/Views/PostView.swift +++ b/damus/Features/Posting/Views/PostView.swift @@ -105,7 +105,7 @@ struct PostView: View { self.prompt_view = prompt_view self.placeholder_messages = placeholder_messages ?? [POST_PLACEHOLDER] self.initial_text_suffix = initial_text_suffix - self.autoSaveModel = AutoSaveIndicatorView.AutoSaveViewModel(save: { damus_state.drafts.save(damus_state: damus_state) }) + self.autoSaveModel = AutoSaveIndicatorView.AutoSaveViewModel(save: { await damus_state.drafts.save(damus_state: damus_state) }) } @Environment(\.dismiss) var dismiss @@ -231,7 +231,7 @@ struct PostView: View { damus_state.drafts.post = nil } - damus_state.drafts.save(damus_state: damus_state) + Task{ await damus_state.drafts.save(damus_state: damus_state) } } func load_draft() -> Bool { diff --git a/damus/Features/Profile/Models/ProfileModel.swift b/damus/Features/Profile/Models/ProfileModel.swift index 0bfb5519..70d52c86 100644 --- a/damus/Features/Profile/Models/ProfileModel.swift +++ b/damus/Features/Profile/Models/ProfileModel.swift @@ -23,17 +23,21 @@ class ProfileModel: ObservableObject, Equatable { return nil } + private let MAX_SHARE_RELAYS = 4 + var events: EventHolder let pubkey: Pubkey let damus: DamusState var seen_event: Set = Set() - var sub_id = UUID().description - var prof_subid = UUID().description - var conversations_subid = UUID().description - var findRelay_subid = UUID().description + + var findRelaysListener: Task? = nil + var listener: Task? = nil + var profileListener: Task? = nil + var conversationListener: Task? = nil + var conversation_events: Set = Set() - + init(pubkey: Pubkey, damus: DamusState) { self.pubkey = pubkey self.damus = damus @@ -46,7 +50,7 @@ class ProfileModel: ObservableObject, Equatable { guard let contacts = self.contacts else { return false } - + return contacts.referenced_pubkeys.contains(pubkey) } @@ -60,39 +64,53 @@ class ProfileModel: ObservableObject, Equatable { static func == (lhs: ProfileModel, rhs: ProfileModel) -> Bool { return lhs.pubkey == rhs.pubkey } - + func hash(into hasher: inout Hasher) { hasher.combine(pubkey) } - func unsubscribe() { - print("unsubscribing from profile \(pubkey) with sub_id \(sub_id)") - damus.nostrNetwork.pool.unsubscribe(sub_id: sub_id) - damus.nostrNetwork.pool.unsubscribe(sub_id: prof_subid) - if pubkey != damus.pubkey { - damus.nostrNetwork.pool.unsubscribe(sub_id: conversations_subid) + func subscribe() { + print("subscribing to profile \(pubkey)") + listener?.cancel() + listener = Task { + var text_filter = NostrFilter(kinds: [.text, .longform, .highlight]) + text_filter.authors = [pubkey] + text_filter.limit = 500 + for await item in damus.nostrNetwork.reader.subscribe(filters: [text_filter]) { + switch item { + case .event(let borrow): + try? borrow { event in + handleNostrEvent(event.toOwned()) + } + case .eose: break + } + } + guard let txn = NdbTxn(ndb: damus.ndb) else { return } + load_profiles(context: "profile", load: .from_events(events.events), damus_state: damus, txn: txn) + progress += 1 + } + profileListener?.cancel() + profileListener = Task { + var profile_filter = NostrFilter(kinds: [.contacts, .metadata, .boost]) + profile_filter.authors = [pubkey] + for await item in damus.nostrNetwork.reader.subscribe(filters: [profile_filter]) { + switch item { + case .event(let borrow): + try? borrow { event in + handleNostrEvent(event.toOwned()) + } + case .eose: break + } + } + progress += 1 + } + conversationListener?.cancel() + conversationListener = Task { + await listenToConversations() } } - - func subscribe() { - var text_filter = NostrFilter(kinds: [.text, .longform, .highlight]) - var profile_filter = NostrFilter(kinds: [.contacts, .metadata, .boost]) - var relay_list_filter = NostrFilter(kinds: [.relay_list], authors: [pubkey]) - - profile_filter.authors = [pubkey] - - text_filter.authors = [pubkey] - text_filter.limit = 500 - - print("subscribing to textlike events from profile \(pubkey) with sub_id \(sub_id)") - //print_filters(relay_id: "profile", filters: [[text_filter], [profile_filter]]) - damus.nostrNetwork.pool.subscribe(sub_id: sub_id, filters: [text_filter], handler: handle_event) - damus.nostrNetwork.pool.subscribe(sub_id: prof_subid, filters: [profile_filter, relay_list_filter], handler: handle_event) - - subscribe_to_conversations() - } - - private func subscribe_to_conversations() { + + func listenToConversations() async { // Only subscribe to conversation events if the profile is not us. guard pubkey != damus.pubkey else { return @@ -102,10 +120,35 @@ class ProfileModel: ObservableObject, Equatable { let limit: UInt32 = 500 let conversations_filter_them = NostrFilter(kinds: conversation_kinds, pubkeys: [damus.pubkey], limit: limit, authors: [pubkey]) let conversations_filter_us = NostrFilter(kinds: conversation_kinds, pubkeys: [pubkey], limit: limit, authors: [damus.pubkey]) - print("subscribing to conversation events from and to profile \(pubkey) with sub_id \(conversations_subid)") - damus.nostrNetwork.pool.subscribe(sub_id: conversations_subid, filters: [conversations_filter_them, conversations_filter_us], handler: handle_event) + print("subscribing to conversation events from and to profile \(pubkey)") + for await item in self.damus.nostrNetwork.reader.subscribe(filters: [conversations_filter_them, conversations_filter_us]) { + switch item { + case .event(borrow: let borrow): + try? borrow { ev in + if !seen_event.contains(ev.id) { + let event = ev.toOwned() + Task { await self.add_event(event) } + conversation_events.insert(ev.id) + } + else if !conversation_events.contains(ev.id) { + conversation_events.insert(ev.id) + } + } + case .eose: + continue + } + } } - + + func unsubscribe() { + listener?.cancel() + listener = nil + profileListener?.cancel() + profileListener = nil + conversationListener?.cancel() + conversationListener = nil + } + func handle_profile_contact_event(_ ev: NostrEvent) { process_contact_event(state: damus, ev: ev) @@ -120,8 +163,13 @@ class ProfileModel: ObservableObject, Equatable { self.following = count_pubkeys(ev.tags) self.legacy_relay_list = decode_json_relays(ev.content) } + + @MainActor + func add_event(_ ev: NostrEvent) { + guard ev.should_show_event else { + return + } - private func add_event(_ ev: NostrEvent) { if ev.is_textlike || ev.known_kind == .boost { if self.events.insert(ev) { self.objectWillChange.send() @@ -134,72 +182,13 @@ class ProfileModel: ObservableObject, Equatable { } seen_event.insert(ev.id) } - - // Ensure the event public key matches the public key(s) we are querying. - // This is done to protect against a relay not properly filtering events by the pubkey - // See https://github.com/damus-io/damus/issues/1846 for more information - private func relay_filtered_correctly(_ ev: NostrEvent, subid: String?) -> Bool { - if subid == self.conversations_subid { - switch ev.pubkey { - case self.pubkey: - return ev.referenced_pubkeys.contains(damus.pubkey) - case damus.pubkey: - return ev.referenced_pubkeys.contains(self.pubkey) - default: - return false - } - } - - return self.pubkey == ev.pubkey - } - - private func handle_event(relay_id: RelayURL, ev: NostrConnectionEvent) { - switch ev { - case .ws_connection_event: - return - case .nostr_event(let resp): - guard resp.subid == self.sub_id || resp.subid == self.prof_subid || resp.subid == self.conversations_subid else { - return - } - switch resp { - case .ok: - break - case .event(_, let ev): - guard ev.should_show_event else { - break - } - - if !seen_event.contains(ev.id) { - guard relay_filtered_correctly(ev, subid: resp.subid) else { - break - } - - add_event(ev) - - if resp.subid == self.conversations_subid { - conversation_events.insert(ev.id) - } - } else if resp.subid == self.conversations_subid && !conversation_events.contains(ev.id) { - guard relay_filtered_correctly(ev, subid: resp.subid) else { - break - } - - conversation_events.insert(ev.id) - } - case .notice: - break - //notify(.notice, notice) - case .eose: - guard let txn = NdbTxn(ndb: damus.ndb) else { return } - if resp.subid == sub_id { - load_profiles(context: "profile", profiles_subid: prof_subid, relay_id: relay_id, load: .from_events(events.events), damus_state: damus, txn: txn) - } - progress += 1 - break - case .auth: - break - } - } + + private func handleNostrEvent(_ ev: NostrEvent) { + // Ensure the event public key matches this profiles public key + // This is done to protect against a relay not properly filtering events by the pubkey + // See https://github.com/damus-io/damus/issues/1846 for more information + guard self.pubkey == ev.pubkey else { return } + Task { await add_event(ev) } } private func findRelaysHandler(relay_id: RelayURL, ev: NostrConnectionEvent) { @@ -211,12 +200,27 @@ class ProfileModel: ObservableObject, Equatable { func subscribeToFindRelays() { var profile_filter = NostrFilter(kinds: [.contacts]) profile_filter.authors = [pubkey] - - damus.nostrNetwork.pool.subscribe(sub_id: findRelay_subid, filters: [profile_filter], handler: findRelaysHandler) + self.findRelaysListener?.cancel() + self.findRelaysListener = Task { + for await item in await damus.nostrNetwork.reader.subscribe(filters: [profile_filter]) { + switch item { + case .event(let borrow): + try? borrow { event in + if case .contacts = event.known_kind { + // TODO: Is this correct? + self.legacy_relay_list = decode_json_relays(event.content) + } + } + case .eose: + break + } + } + } } func unsubscribeFindRelays() { - damus.nostrNetwork.pool.unsubscribe(sub_id: findRelay_subid) + self.findRelaysListener?.cancel() + self.findRelaysListener = nil } func getCappedRelays() -> [RelayURL] { diff --git a/damus/Features/Profile/Views/ProfileActionSheetView.swift b/damus/Features/Profile/Views/ProfileActionSheetView.swift index 437db548..3b361a8f 100644 --- a/damus/Features/Profile/Views/ProfileActionSheetView.swift +++ b/damus/Features/Profile/Views/ProfileActionSheetView.swift @@ -283,7 +283,7 @@ fileprivate struct ProfileActionSheetZapButton: View { VStack(alignment: .center, spacing: 10) { Button( action: { - send_zap(damus_state: damus_state, target: .profile(self.profile.pubkey), lnurl: lnurl, is_custom: false, comment: nil, amount_sats: nil, zap_type: damus_state.settings.default_zap_type) + Task { await send_zap(damus_state: damus_state, target: .profile(self.profile.pubkey), lnurl: lnurl, is_custom: false, comment: nil, amount_sats: nil, zap_type: damus_state.settings.default_zap_type) } zap_state = .zapping }, label: { diff --git a/damus/Features/Profile/Views/ProfileView.swift b/damus/Features/Profile/Views/ProfileView.swift index 2c6f60d0..2234dcaf 100644 --- a/damus/Features/Profile/Views/ProfileView.swift +++ b/damus/Features/Profile/Views/ProfileView.swift @@ -588,3 +588,4 @@ func check_nip05_validity(pubkey: Pubkey, profiles: Profiles) { } } } + diff --git a/damus/Features/Relays/Models/RelayFilters.swift b/damus/Features/Relays/Models/RelayFilters.swift index 1940b069..b549379e 100644 --- a/damus/Features/Relays/Models/RelayFilters.swift +++ b/damus/Features/Relays/Models/RelayFilters.swift @@ -84,9 +84,3 @@ func load_relay_filters(_ pubkey: Pubkey) -> Set? { s.insert(filter) } } - -func determine_to_relays(pool: RelayPool, filters: RelayFilters) -> [RelayURL] { - return pool.our_descriptors - .map { $0.url } - .filter { !filters.is_filtered(timeline: .search, relay_id: $0) } -} diff --git a/damus/Features/Relays/Views/RelayConfigView.swift b/damus/Features/Relays/Views/RelayConfigView.swift index 0a6b46b3..cc82ad1b 100644 --- a/damus/Features/Relays/Views/RelayConfigView.swift +++ b/damus/Features/Relays/Views/RelayConfigView.swift @@ -32,7 +32,7 @@ struct RelayConfigView: View { init(state: DamusState) { self.state = state - _relays = State(initialValue: state.nostrNetwork.pool.our_descriptors) + _relays = State(initialValue: state.nostrNetwork.ourRelayDescriptors) UITabBar.appearance().isHidden = true } @@ -98,7 +98,7 @@ struct RelayConfigView: View { } } .onReceive(handle_notify(.relays_changed)) { _ in - self.relays = state.nostrNetwork.pool.our_descriptors + self.relays = state.nostrNetwork.ourRelayDescriptors } .onAppear { notify(.display_tabbar(false)) diff --git a/damus/Features/Relays/Views/RelayDetailView.swift b/damus/Features/Relays/Views/RelayDetailView.swift index d2474ed7..fd19aaab 100644 --- a/damus/Features/Relays/Views/RelayDetailView.swift +++ b/damus/Features/Relays/Views/RelayDetailView.swift @@ -30,7 +30,7 @@ struct RelayDetailView: View { func RemoveRelayButton(_ keypair: FullKeypair) -> some View { Button(action: { - self.removeRelay() + Task { await self.removeRelay() } }) { HStack { Text("Disconnect", comment: "Button to disconnect from the relay.") @@ -43,7 +43,7 @@ struct RelayDetailView: View { func ConnectRelayButton(_ keypair: FullKeypair) -> some View { Button(action: { - self.connectRelay() + Task { await self.connectRelay() } }) { HStack { Text("Connect", comment: "Button to connect to the relay.") @@ -177,16 +177,18 @@ struct RelayDetailView: View { } private var relay_object: RelayPool.Relay? { - state.nostrNetwork.pool.get_relay(relay) + // TODO: Concurrency problems? + state.nostrNetwork.connectedRelays.first(where: { $0.descriptor.url == relay }) } private var relay_connection: RelayConnection? { relay_object?.connection } - func removeRelay() { + func removeRelay() async { do { - try state.nostrNetwork.userRelayList.remove(relayURL: self.relay) + // TODO: Concurrency problems? + try await state.nostrNetwork.userRelayList.remove(relayURL: self.relay) dismiss() } catch { @@ -194,9 +196,10 @@ struct RelayDetailView: View { } } - func connectRelay() { + func connectRelay() async { do { - try state.nostrNetwork.userRelayList.insert(relay: NIP65.RelayList.RelayItem(url: relay, rwConfiguration: .readWrite)) + // TODO: Concurrency problems? + try await state.nostrNetwork.userRelayList.insert(relay: NIP65.RelayList.RelayItem(url: relay, rwConfiguration: .readWrite)) dismiss() } catch { diff --git a/damus/Features/Relays/Views/RelayFilterView.swift b/damus/Features/Relays/Views/RelayFilterView.swift index 77c2a608..a4e677e8 100644 --- a/damus/Features/Relays/Views/RelayFilterView.swift +++ b/damus/Features/Relays/Views/RelayFilterView.swift @@ -19,7 +19,7 @@ struct RelayFilterView: View { } var relays: [RelayPool.RelayDescriptor] { - return state.nostrNetwork.pool.our_descriptors + return state.nostrNetwork.ourRelayDescriptors } var body: some View { diff --git a/damus/Features/Relays/Views/RelayStatusView.swift b/damus/Features/Relays/Views/RelayStatusView.swift index d3f6ed61..18aa4ca8 100644 --- a/damus/Features/Relays/Views/RelayStatusView.swift +++ b/damus/Features/Relays/Views/RelayStatusView.swift @@ -56,7 +56,7 @@ struct RelayStatusView: View { struct RelayStatusView_Previews: PreviewProvider { static var previews: some View { - let connection = test_damus_state.nostrNetwork.pool.get_relay(RelayURL("wss://relay.damus.io")!)!.connection + let connection = test_damus_state.nostrNetwork.getRelay(RelayURL("wss://relay.damus.io")!)!.connection RelayStatusView(connection: connection) } } diff --git a/damus/Features/Relays/Views/RelayToggle.swift b/damus/Features/Relays/Views/RelayToggle.swift index 41e0b77c..8fb5474a 100644 --- a/damus/Features/Relays/Views/RelayToggle.swift +++ b/damus/Features/Relays/Views/RelayToggle.swift @@ -36,7 +36,7 @@ struct RelayToggle: View { } private var relay_connection: RelayConnection? { - state.nostrNetwork.pool.get_relay(relay_id)?.connection + state.nostrNetwork.getRelay(relay_id)?.connection } } diff --git a/damus/Features/Relays/Views/RelayView.swift b/damus/Features/Relays/Views/RelayView.swift index 4113254c..85c61d67 100644 --- a/damus/Features/Relays/Views/RelayView.swift +++ b/damus/Features/Relays/Views/RelayView.swift @@ -24,13 +24,13 @@ struct RelayView: View { self.recommended = recommended self.model_cache = state.relay_model_cache _showActionButtons = showActionButtons - let relay_state = RelayView.get_relay_state(pool: state.nostrNetwork.pool, relay: relay) + let relay_state = RelayView.get_relay_state(state: state, relay: relay) self._relay_state = State(initialValue: relay_state) self.disableNavLink = disableNavLink } - static func get_relay_state(pool: RelayPool, relay: RelayURL) -> Bool { - return pool.get_relay(relay) == nil + static func get_relay_state(state: DamusState, relay: RelayURL) -> Bool { + return state.nostrNetwork.getRelay(relay) == nil } var body: some View { @@ -110,7 +110,7 @@ struct RelayView: View { .contentShape(Rectangle()) } .onReceive(handle_notify(.relays_changed)) { _ in - self.relay_state = RelayView.get_relay_state(pool: state.nostrNetwork.pool, relay: self.relay) + self.relay_state = RelayView.get_relay_state(state: state, relay: self.relay) } .onTapGesture { if !disableNavLink { @@ -120,7 +120,7 @@ struct RelayView: View { } private var relay_connection: RelayConnection? { - state.nostrNetwork.pool.get_relay(relay)?.connection + state.nostrNetwork.getRelay(relay)?.connection } func add_action(keypair: FullKeypair) async { diff --git a/damus/Features/Relays/Views/UserRelaysView.swift b/damus/Features/Relays/Views/UserRelaysView.swift index 20f7c44e..9e87ade8 100644 --- a/damus/Features/Relays/Views/UserRelaysView.swift +++ b/damus/Features/Relays/Views/UserRelaysView.swift @@ -22,7 +22,7 @@ struct UserRelaysView: View { static func make_relay_state(state: DamusState, relays: [RelayURL]) -> [(RelayURL, Bool)] { return relays.map({ r in - return (r, state.nostrNetwork.pool.get_relay(r) == nil) + return (r, state.nostrNetwork.getRelay(r) == nil) }).sorted { (a, b) in a.0 < b.0 } } diff --git a/damus/Features/Search/Models/SearchHomeModel.swift b/damus/Features/Search/Models/SearchHomeModel.swift index a8393865..5820f02d 100644 --- a/damus/Features/Search/Models/SearchHomeModel.swift +++ b/damus/Features/Search/Models/SearchHomeModel.swift @@ -39,63 +39,41 @@ class SearchHomeModel: ObservableObject { self.objectWillChange.send() } - func subscribe() { + func load() async { loading = true - let to_relays = determine_to_relays(pool: damus_state.nostrNetwork.pool, filters: damus_state.relay_filters) - - var follow_list_filter = NostrFilter(kinds: [.follow_list]) - follow_list_filter.until = UInt32(Date.now.timeIntervalSince1970) + let to_relays = damus_state.nostrNetwork.ourRelayDescriptors + .map { $0.url } + .filter { !damus_state.relay_filters.is_filtered(timeline: .search, relay_id: $0) } - damus_state.nostrNetwork.pool.subscribe(sub_id: base_subid, filters: [get_base_filter()], handler: handle_event, to: to_relays) - damus_state.nostrNetwork.pool.subscribe(sub_id: follow_pack_subid, filters: [follow_list_filter], handler: handle_event, to: to_relays) - } - - func unsubscribe(to: RelayURL? = nil) { - loading = false - damus_state.nostrNetwork.pool.unsubscribe(sub_id: base_subid, to: to.map { [$0] }) - damus_state.nostrNetwork.pool.unsubscribe(sub_id: follow_pack_subid, to: to.map { [$0] }) - } - - func handle_event(relay_id: RelayURL, conn_ev: NostrConnectionEvent) { - guard case .nostr_event(let event) = conn_ev else { - return + for await item in damus_state.nostrNetwork.reader.subscribe(filters: [get_base_filter()], to: to_relays) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + guard let event else { return } + await self.handleEvent(event) + case .eose: break + } } + loading = false - switch event { - case .event(let sub_id, let ev): - guard sub_id == self.base_subid || sub_id == self.profiles_subid || sub_id == self.follow_pack_subid else { + guard let txn = NdbTxn(ndb: damus_state.ndb) else { return } + load_profiles(context: "universe", load: .from_events(events.all_events), damus_state: damus_state, txn: txn) + } + + @MainActor + func handleEvent(_ ev: NostrEvent) { + if ev.is_textlike && should_show_event(state: damus_state, ev: ev) && !ev.is_reply() { + if !damus_state.settings.multiple_events_per_pubkey && seen_pubkey.contains(ev.pubkey) { return } - if ev.is_textlike && should_show_event(state: damus_state, ev: ev) && !ev.is_reply() - { - if !damus_state.settings.multiple_events_per_pubkey && seen_pubkey.contains(ev.pubkey) { - return - } - seen_pubkey.insert(ev.pubkey) - - if self.events.insert(ev) { - self.objectWillChange.send() - } - } - case .notice(let msg): - print("search home notice: \(msg)") - case .ok: - break - case .eose(let sub_id): - loading = false + seen_pubkey.insert(ev.pubkey) - if sub_id == self.base_subid { - // Make sure we unsubscribe after we've fetched the global events - // global events are not realtime - unsubscribe(to: relay_id) - - guard let txn = NdbTxn(ndb: damus_state.ndb) else { return } - load_profiles(context: "universe", profiles_subid: profiles_subid, relay_id: relay_id, load: .from_events(events.all_events), damus_state: damus_state, txn: txn) + if self.events.insert(ev) { + self.objectWillChange.send() } - - break - case .auth: - break } } } @@ -135,44 +113,35 @@ enum PubkeysToLoad { case from_keys([Pubkey]) } -func load_profiles(context: String, profiles_subid: String, relay_id: RelayURL, load: PubkeysToLoad, damus_state: DamusState, txn: NdbTxn) { +func load_profiles(context: String, load: PubkeysToLoad, damus_state: DamusState, txn: NdbTxn) { let authors = find_profiles_to_fetch(profiles: damus_state.profiles, load: load, cache: damus_state.events, txn: txn) guard !authors.isEmpty else { return } - print("load_profiles[\(context)]: requesting \(authors.count) profiles from \(relay_id)") - - let filter = NostrFilter(kinds: [.metadata], authors: authors) - - damus_state.nostrNetwork.pool.subscribe_to(sub_id: profiles_subid, filters: [filter], to: [relay_id]) { rid, conn_ev in + Task { + print("load_profiles[\(context)]: requesting \(authors.count) profiles from relay pool") + let filter = NostrFilter(kinds: [.metadata], authors: authors) - let now = UInt64(Date.now.timeIntervalSince1970) - switch conn_ev { - case .ws_connection_event: - break - case .nostr_event(let ev): - guard ev.subid == profiles_subid, rid == relay_id else { return } - - switch ev { - case .event(_, let ev): - if ev.known_kind == .metadata { - damus_state.ndb.write_profile_last_fetched(pubkey: ev.pubkey, fetched_at: now) + for await item in damus_state.nostrNetwork.reader.subscribe(filters: [filter]) { + let now = UInt64(Date.now.timeIntervalSince1970) + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + guard let event else { return } + if event.known_kind == .metadata { + damus_state.ndb.write_profile_last_fetched(pubkey: event.pubkey, fetched_at: now) } case .eose: - print("load_profiles[\(context)]: done loading \(authors.count) profiles from \(relay_id)") - damus_state.nostrNetwork.pool.unsubscribe(sub_id: profiles_subid, to: [relay_id]) - case .ok: - break - case .notice: - break - case .auth: break } } - - + + print("load_profiles[\(context)]: done loading \(authors.count) profiles from relay pool") } } diff --git a/damus/Features/Search/Models/SearchModel.swift b/damus/Features/Search/Models/SearchModel.swift index fbb96ab9..0de7e293 100644 --- a/damus/Features/Search/Models/SearchModel.swift +++ b/damus/Features/Search/Models/SearchModel.swift @@ -14,8 +14,8 @@ class SearchModel: ObservableObject { @Published var loading: Bool = false var search: NostrFilter - let sub_id = UUID().description let profiles_subid = UUID().description + var listener: Task? = nil let limit: UInt32 = 500 init(state: DamusState, search: NostrFilter) { @@ -39,17 +39,32 @@ class SearchModel: ObservableObject { search.kinds = [.text, .like, .longform, .highlight, .follow_list] //likes_filter.ids = ref_events.referenced_ids! - - print("subscribing to search '\(search)' with sub_id \(sub_id)") - state.nostrNetwork.pool.register_handler(sub_id: sub_id, handler: handle_event) - loading = true - state.nostrNetwork.pool.send(.subscribe(.init(filters: [search], sub_id: sub_id))) + listener?.cancel() + listener = Task { + self.loading = true + print("subscribing to search") + for await item in await state.nostrNetwork.reader.subscribe(filters: [search]) { + switch item { + case .event(let borrow): + try? borrow { ev in + let event = ev.toOwned() + if event.is_textlike && event.should_show_event { + self.add_event(event) + } + } + case .eose: + break + } + guard let txn = NdbTxn(ndb: state.ndb) else { return } + load_profiles(context: "search", load: .from_events(self.events.all_events), damus_state: state, txn: txn) + } + self.loading = false + } } func unsubscribe() { - state.nostrNetwork.pool.unsubscribe(sub_id: sub_id) - loading = false - print("unsubscribing from search '\(search)' with sub_id \(sub_id)") + listener?.cancel() + listener = nil } func add_event(_ ev: NostrEvent) { @@ -65,25 +80,6 @@ class SearchModel: ObservableObject { objectWillChange.send() } } - - func handle_event(relay_id: RelayURL, ev: NostrConnectionEvent) { - let (sub_id, done) = handle_subid_event(pool: state.nostrNetwork.pool, relay_id: relay_id, ev: ev) { sub_id, ev in - if ev.is_textlike && ev.should_show_event { - self.add_event(ev) - } - } - - guard done else { - return - } - - self.loading = false - - if sub_id == self.sub_id { - guard let txn = NdbTxn(ndb: state.ndb) else { return } - load_profiles(context: "search", profiles_subid: self.profiles_subid, relay_id: relay_id, load: .from_events(self.events.all_events), damus_state: state, txn: txn) - } - } } func event_matches_hashtag(_ ev: NostrEvent, hashtags: [String]) -> Bool { @@ -106,33 +102,3 @@ func event_matches_filter(_ ev: NostrEvent, filter: NostrFilter) -> Bool { } return true } - -func handle_subid_event(pool: RelayPool, relay_id: RelayURL, ev: NostrConnectionEvent, handle: (String, NostrEvent) -> ()) -> (String?, Bool) { - switch ev { - case .ws_connection_event: - return (nil, false) - - case .nostr_event(let res): - switch res { - case .event(let ev_subid, let ev): - handle(ev_subid, ev) - return (ev_subid, false) - - case .ok: - return (nil, false) - - case .notice(let note): - if note.contains("Too many subscription filters") { - // TODO: resend filters? - pool.reconnect(to: [relay_id]) - } - return (nil, false) - - case .eose(let subid): - return (subid, true) - - case .auth: - return (nil, false) - } - } -} diff --git a/damus/Features/Search/Views/SearchHomeView.swift b/damus/Features/Search/Views/SearchHomeView.swift index 163d3982..5f056dfa 100644 --- a/damus/Features/Search/Views/SearchHomeView.swift +++ b/damus/Features/Search/Views/SearchHomeView.swift @@ -14,6 +14,7 @@ struct SearchHomeView: View { @StateObject var model: SearchHomeModel @State var search: String = "" @FocusState private var isFocused: Bool + @State var loadingTask: Task? func content_filter(_ fstate: FilterState) -> ((NostrEvent) -> Bool) { var filters = ContentFilters.defaults(damus_state: damus_state) @@ -84,8 +85,8 @@ struct SearchHomeView: View { ) .refreshable { // Fetch new information by unsubscribing and resubscribing to the relay - model.unsubscribe() - model.subscribe() + loadingTask?.cancel() + loadingTask = Task { await model.load() } } } @@ -93,8 +94,8 @@ struct SearchHomeView: View { SearchResultsView(damus_state: damus_state, search: $search) .refreshable { // Fetch new information by unsubscribing and resubscribing to the relay - model.unsubscribe() - model.subscribe() + loadingTask?.cancel() + loadingTask = Task { await model.load() } } } @@ -129,11 +130,11 @@ struct SearchHomeView: View { } .onAppear { if model.events.events.isEmpty { - model.subscribe() + loadingTask = Task { await model.load() } } } .onDisappear { - model.unsubscribe() + loadingTask?.cancel() } } } diff --git a/damus/Features/Search/Views/SearchingEventView.swift b/damus/Features/Search/Views/SearchingEventView.swift index c3aed87f..7f132bc3 100644 --- a/damus/Features/Search/Views/SearchingEventView.swift +++ b/damus/Features/Search/Views/SearchingEventView.swift @@ -77,7 +77,8 @@ struct SearchingEventView: View { } case .event(let note_id): - find_event(state: state, query: .event(evid: note_id)) { res in + Task { + let res = await state.nostrNetwork.findEvent(query: .event(evid: note_id)) guard case .event(let ev) = res else { self.search_state = .not_found return @@ -85,7 +86,8 @@ struct SearchingEventView: View { self.search_state = .found(ev) } case .profile(let pubkey): - find_event(state: state, query: .profile(pubkey: pubkey)) { res in + Task { + let res = await state.nostrNetwork.findEvent(query: .profile(pubkey: pubkey)) guard case .profile(let pubkey) = res else { self.search_state = .not_found return @@ -93,7 +95,8 @@ struct SearchingEventView: View { self.search_state = .found_profile(pubkey) } case .naddr(let naddr): - naddrLookup(damus_state: state, naddr: naddr) { res in + Task { + let res = await state.nostrNetwork.lookup(naddr: naddr) guard let res = res else { self.search_state = .not_found return diff --git a/damus/Features/Settings/Views/FirstAidSettingsView.swift b/damus/Features/Settings/Views/FirstAidSettingsView.swift index 6a40361b..84fbe48e 100644 --- a/damus/Features/Settings/Views/FirstAidSettingsView.swift +++ b/damus/Features/Settings/Views/FirstAidSettingsView.swift @@ -68,7 +68,7 @@ struct FirstAidSettingsView: View { guard let new_contact_list_event = make_first_contact_event(keypair: damus_state.keypair) else { throw FirstAidError.cannotMakeFirstContactEvent } - damus_state.nostrNetwork.pool.send(.event(new_contact_list_event)) + damus_state.nostrNetwork.send(event: new_contact_list_event) damus_state.settings.latest_contact_event_id_hex = new_contact_list_event.id.hex() } diff --git a/damus/Features/Timeline/Models/HomeModel.swift b/damus/Features/Timeline/Models/HomeModel.swift index a18fd438..8d2da21e 100644 --- a/damus/Features/Timeline/Models/HomeModel.swift +++ b/damus/Features/Timeline/Models/HomeModel.swift @@ -65,12 +65,11 @@ class HomeModel: ContactsDelegate { let resub_debouncer = Debouncer(interval: 3.0) var should_debounce_dms = true - let home_subid = UUID().description - let contacts_subid = UUID().description - let notifications_subid = UUID().description - let dms_subid = UUID().description - let init_subid = UUID().description - let profiles_subid = UUID().description + var homeHandlerTask: Task? + var contactsHandlerTask: Task? + var notificationsHandlerTask: Task? + var dmsHandlerTask: Task? + var nwcHandlerTask: Task? var loading: Bool = false @@ -94,23 +93,10 @@ class HomeModel: ContactsDelegate { preload_events(state: self.damus_state, events: [ev]) } - var pool: RelayPool { - self.damus_state.nostrNetwork.pool - } - var dms: DirectMessagesModel { return damus_state.dms } - func has_sub_id_event(sub_id: String, ev_id: NoteId) -> Bool { - if !has_event.keys.contains(sub_id) { - has_event[sub_id] = Set() - return false - } - - return has_event[sub_id]!.contains(ev_id) - } - func setup_debouncer() { // turn off debouncer after initial load DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) { @@ -140,6 +126,28 @@ class HomeModel: ContactsDelegate { damus_state.drafts.load(from: damus_state) } + enum RelayListLoadingError: Error { + case noRelayList + case relayListParseError + + var humanReadableError: ErrorView.UserPresentableError { + switch self { + case .noRelayList: + return ErrorView.UserPresentableError( + user_visible_description: NSLocalizedString("Your relay list could not be found, so we cannot connect you to your Nostr network.", comment: "Human readable error description for a failure to find the relay list"), + tip: NSLocalizedString("Please check your internet connection and restart the app. If the error persists, please go to Settings > First Aid.", comment: "Human readable tips for what to do for a failure to find the relay list"), + technical_info: "No NIP-65 relay list or legacy kind:3 contact event could be found." + ) + case .relayListParseError: + return ErrorView.UserPresentableError( + user_visible_description: NSLocalizedString("Your relay list appears to be broken, so we cannot connect you to your Nostr network.", comment: "Human readable error description for a failure to parse the relay list due to a bad relay list"), + tip: NSLocalizedString("Please contact support for further help.", comment: "Human readable tips for what to do for a failure to find the relay list"), + technical_info: "Relay list could not be parsed." + ) + } + } + } + // MARK: - ContactsDelegate functions func latest_contact_event_changed(new_event: NostrEvent) { @@ -158,9 +166,6 @@ class HomeModel: ContactsDelegate { print("hit resub debouncer") resub_debouncer.debounce { - print("resub") - self.unsubscribe_to_home_filters() - switch resubbing { case .following: break @@ -175,25 +180,16 @@ class HomeModel: ContactsDelegate { } @MainActor - func process_event(sub_id: String, relay_id: RelayURL, ev: NostrEvent) { - if has_sub_id_event(sub_id: sub_id, ev_id: ev.id) { - return - } - - let last_k = get_last_event_of_kind(relay_id: relay_id, kind: ev.kind) - if last_k == nil || ev.created_at > last_k!.created_at { - last_event_of_kind[relay_id]?[ev.kind] = ev - } - + func process_event(ev: NostrEvent, context: SubscriptionContext) { guard let kind = ev.known_kind else { return } switch kind { case .chat, .longform, .text, .highlight: - handle_text_event(sub_id: sub_id, ev) + handle_text_event(ev, context: context) case .contacts: - handle_contact_event(sub_id: sub_id, relay_id: relay_id, ev: ev) + handle_contact_event(ev: ev) case .metadata: // profile metadata processing is handled by nostrdb break @@ -202,7 +198,7 @@ class HomeModel: ContactsDelegate { case .mute_list: handle_mute_list_event(ev) case .boost: - handle_boost_event(sub_id: sub_id, ev) + handle_boost_event(ev, context: context) case .like: handle_like_event(ev) case .dm: @@ -216,7 +212,7 @@ class HomeModel: ContactsDelegate { case .nwc_request: break case .nwc_response: - handle_nwc_response(ev, relay: relay_id) + handle_nwc_response(ev) case .http_auth: break case .status: @@ -261,7 +257,7 @@ class HomeModel: ContactsDelegate { pdata.status.update_status(st) } - func handle_nwc_response(_ ev: NostrEvent, relay: RelayURL) { + func handle_nwc_response(_ ev: NostrEvent) { Task { @MainActor in // TODO: Adapt KeychainStorage to StringCodable and instead of parsing to WalletConnectURL every time guard let nwc_str = damus_state.settings.nostr_wallet_connect, @@ -269,7 +265,6 @@ class HomeModel: ContactsDelegate { return } - guard nwc.relay == relay else { return } // Don't process NWC responses coming from relays other than our designated one guard ev.referenced_pubkeys.first == nwc.keypair.pubkey else { return // This message is not for us. Ignore it. } @@ -289,9 +284,9 @@ class HomeModel: ContactsDelegate { // since command results are not returned for ephemeral events, // remove the request from the postbox which is likely failing over and over if damus_state.nostrNetwork.postbox.remove_relayer(relay_id: nwc.relay, event_id: resp.req_id) { - Log.debug("HomeModel: got NWC response, removed %s from the postbox [%s]", for: .nwc, resp.req_id.hex(), relay.absoluteString) + Log.debug("HomeModel: got NWC response, removed %s from the postbox", for: .nwc, resp.req_id.hex()) } else { - Log.debug("HomeModel: got NWC response, %s not found in the postbox, nothing to remove [%s]", for: .nwc, resp.req_id.hex(), relay.absoluteString) + Log.debug("HomeModel: got NWC response, %s not found in the postbox, nothing to remove", for: .nwc, resp.req_id.hex()) } damus_state.wallet.handle_nwc_response(response: resp) // This can handle success or error cases @@ -303,7 +298,6 @@ class HomeModel: ContactsDelegate { return } - print("nwc success: \(resp.response.result.debugDescription) [\(relay)]") WalletConnect.handle_zap_success(state: self.damus_state, resp: resp) } } @@ -382,19 +376,11 @@ class HomeModel: ContactsDelegate { self.deleted_events.insert(ev.id) } - func handle_contact_event(sub_id: String, relay_id: RelayURL, ev: NostrEvent) { + func handle_contact_event(ev: NostrEvent) { process_contact_event(state: self.damus_state, ev: ev) - - if sub_id == init_subid { - pool.send(.unsubscribe(init_subid), to: [relay_id]) - if !done_init { - done_init = true - send_home_filters(relay_id: nil) - } - } } - func handle_boost_event(sub_id: String, _ ev: NostrEvent) { + func handle_boost_event(_ ev: NostrEvent, context: SubscriptionContext) { var boost_ev_id = ev.last_refid() if let inner_ev = ev.get_inner_event(cache: damus_state.events) { @@ -409,7 +395,7 @@ class HomeModel: ContactsDelegate { if inner_ev.is_textlike { DispatchQueue.main.async { - self.handle_text_event(sub_id: sub_id, ev) + self.handle_text_event(ev, context: context) } } } @@ -457,94 +443,50 @@ class HomeModel: ContactsDelegate { } } - @MainActor - func handle_event(relay_id: RelayURL, conn_event: NostrConnectionEvent) { - switch conn_event { - case .ws_connection_event(let ev): - switch ev { - case .connected: - if !done_init { - self.loading = true - send_initial_filters(relay_id: relay_id) - } else { - //remove_bootstrap_nodes(damus_state) - send_home_filters(relay_id: relay_id) + /// Send the initial filters, just our contact list and relay list mostly + func send_initial_filters() { + Task { + let filter = NostrFilter(kinds: [.contacts], limit: 1, authors: [damus_state.pubkey]) + for await item in damus_state.nostrNetwork.reader.subscribe(filters: [filter]) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + guard let event else { return } + await process_event(ev: event, context: .initialContactList) + continue + case .eose: + if !done_init { + done_init = true + send_home_filters() + } + break } - - // connect to nwc relays when connected - if let nwc_str = damus_state.settings.nostr_wallet_connect, - let r = pool.get_relay(relay_id), - r.descriptor.variant == .nwc, - let nwc = WalletConnectURL(str: nwc_str), - nwc.relay == relay_id - { - WalletConnect.subscribe(url: nwc, pool: pool) - } - case .error(let merr): - let desc = String(describing: merr) - if desc.contains("Software caused connection abort") { - pool.reconnect(to: [relay_id]) - } - case .disconnected: - pool.reconnect(to: [relay_id]) - default: - break - } - - update_signal_from_pool(signal: self.signal, pool: damus_state.nostrNetwork.pool) - case .nostr_event(let ev): - switch ev { - case .event(let sub_id, let ev): - // globally handle likes - /* - let always_process = sub_id == notifications_subid || sub_id == contacts_subid || sub_id == home_subid || sub_id == dms_subid || sub_id == init_subid || ev.known_kind == .like || ev.known_kind == .boost || ev.known_kind == .zap || ev.known_kind == .contacts || ev.known_kind == .metadata - if !always_process { - // TODO: other views like threads might have their own sub ids, so ignore those events... or should we? - return - } - */ - - self.process_event(sub_id: sub_id, relay_id: relay_id, ev: ev) - case .notice(let msg): - print(msg) - - case .eose(let sub_id): - guard let txn = NdbTxn(ndb: damus_state.ndb) else { - return - } - - if sub_id == dms_subid { - var dms = dms.dms.flatMap { $0.events } - dms.append(contentsOf: incoming_dms) - load_profiles(context: "dms", profiles_subid: profiles_subid, relay_id: relay_id, load: .from_events(dms), damus_state: damus_state, txn: txn) - } else if sub_id == notifications_subid { - load_profiles(context: "notifications", profiles_subid: profiles_subid, relay_id: relay_id, load: .from_keys(notifications.uniq_pubkeys()), damus_state: damus_state, txn: txn) - } else if sub_id == home_subid { - load_profiles(context: "home", profiles_subid: profiles_subid, relay_id: relay_id, load: .from_events(events.events), damus_state: damus_state, txn: txn) - } - - self.loading = false - break - - case .ok: - break - case .auth: - break } } - } - - - /// Send the initial filters, just our contact list mostly - func send_initial_filters(relay_id: RelayURL) { - let filter = NostrFilter(kinds: [.contacts], limit: 1, authors: [damus_state.pubkey]) - let subscription = NostrSubscribe(filters: [filter], sub_id: init_subid) - pool.send(.subscribe(subscription), to: [relay_id]) + + Task { + let relayListFilter = NostrFilter(kinds: [.relay_list], limit: 1, authors: [damus_state.pubkey]) + for await item in damus_state.nostrNetwork.reader.subscribe(filters: [relayListFilter]) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + guard let event else { return } + await process_event(ev: event, context: .initialRelayList) + case .eose: break + } + } + } } /// After initial connection or reconnect, send subscription filters for the home timeline, DMs, and notifications - func send_home_filters(relay_id: RelayURL?) { + func send_home_filters() { // TODO: since times should be based on events from a specific relay // perhaps we could mark this in the relay pool somehow @@ -589,38 +531,99 @@ class HomeModel: ContactsDelegate { let contacts_filter_chunks = contacts_filter.chunked(on: .authors, into: MAX_CONTACTS_ON_FILTER) var contacts_filters = contacts_filter_chunks + [our_contacts_filter, our_blocklist_filter, our_old_blocklist_filter] var dms_filters = [dms_filter, our_dms_filter] - let last_of_kind = get_last_of_kind(relay_id: relay_id) - - contacts_filters = update_filters_with_since(last_of_kind: last_of_kind, filters: contacts_filters) - notifications_filters = update_filters_with_since(last_of_kind: last_of_kind, filters: notifications_filters) - dms_filters = update_filters_with_since(last_of_kind: last_of_kind, filters: dms_filters) //print_filters(relay_id: relay_id, filters: [home_filters, contacts_filters, notifications_filters, dms_filters]) - subscribe_to_home_filters(relay_id: relay_id) + subscribe_to_home_filters() - let relay_ids = relay_id.map { [$0] } - - pool.send(.subscribe(.init(filters: contacts_filters, sub_id: contacts_subid)), to: relay_ids) - pool.send(.subscribe(.init(filters: notifications_filters, sub_id: notifications_subid)), to: relay_ids) - pool.send(.subscribe(.init(filters: dms_filters, sub_id: dms_subid)), to: relay_ids) + + self.contactsHandlerTask?.cancel() + self.contactsHandlerTask = Task { + for await item in damus_state.nostrNetwork.reader.subscribe(filters: contacts_filters) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + var event = ev.toOwned() + } + guard let event else { return } + await self.process_event(ev: event, context: .contacts) + case .eose: continue + } + } + } + self.notificationsHandlerTask?.cancel() + self.notificationsHandlerTask = Task { + for await item in damus_state.nostrNetwork.reader.subscribe(filters: notifications_filters) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + guard let event else { return } + await self.process_event(ev: event, context: .notifications) + case .eose: + guard let txn = NdbTxn(ndb: damus_state.ndb) else { return } + load_profiles(context: "notifications", load: .from_keys(notifications.uniq_pubkeys()), damus_state: damus_state, txn: txn) + } + } + } + self.dmsHandlerTask?.cancel() + self.dmsHandlerTask = Task { + for await item in damus_state.nostrNetwork.reader.subscribe(filters: dms_filters) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + guard let event else { return } + await self.process_event(ev: event, context: .dms) + case .eose: + guard let txn = NdbTxn(ndb: damus_state.ndb) else { return } + var dms = dms.dms.flatMap { $0.events } + dms.append(contentsOf: incoming_dms) + load_profiles(context: "dms", load: .from_events(dms), damus_state: damus_state, txn: txn) + } + } + } + self.nwcHandlerTask?.cancel() + self.nwcHandlerTask = Task { + if let nwc_str = damus_state.settings.nostr_wallet_connect, + let nwc = WalletConnectURL(str: nwc_str) + { + var filter = NostrFilter(kinds: [.nwc_response]) + filter.authors = [nwc.pubkey] + filter.limit = 0 + for await item in damus_state.nostrNetwork.reader.subscribe(filters: [filter], to: [nwc.relay]) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + guard let event else { return } + await self.process_event(ev: event, context: .nwc) + case .eose: continue + } + } + } + + } } func get_last_of_kind(relay_id: RelayURL?) -> [UInt32: NostrEvent] { return relay_id.flatMap { last_event_of_kind[$0] } ?? [:] } - func unsubscribe_to_home_filters() { - pool.send(.unsubscribe(home_subid)) - } - func get_friends() -> [Pubkey] { var friends = damus_state.contacts.get_friend_list() friends.insert(damus_state.pubkey) return Array(friends) } - func subscribe_to_home_filters(friends fs: [Pubkey]? = nil, relay_id: RelayURL? = nil) { + func subscribe_to_home_filters(friends fs: [Pubkey]? = nil) { // TODO: separate likes? var home_filter_kinds: [NostrKind] = [ .text, .longform, .boost, .highlight @@ -649,11 +652,34 @@ class HomeModel: ContactsDelegate { home_filters.append(hashtag_filter) } - let relay_ids = relay_id.map { [$0] } - home_filters = update_filters_with_since(last_of_kind: get_last_of_kind(relay_id: relay_id), filters: home_filters) - let sub = NostrSubscribe(filters: home_filters, sub_id: home_subid) - - pool.send(.subscribe(sub), to: relay_ids) + self.homeHandlerTask?.cancel() + self.homeHandlerTask = Task { + for await item in damus_state.nostrNetwork.reader.subscribe(filters: home_filters) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + guard let event else { return } + await self.process_event(ev: event, context: .home) + case .eose: + guard let txn = NdbTxn(ndb: damus_state.ndb) else { return } + load_profiles(context: "home", load: .from_events(events.events), damus_state: damus_state, txn: txn) + } + } + } + } + + /// Adapter pattern to make migration easier + enum SubscriptionContext { + case initialContactList + case initialRelayList + case home + case notifications + case dms + case contacts + case nwc } func handle_mute_list_event(_ ev: NostrEvent) { @@ -746,7 +772,7 @@ class HomeModel: ContactsDelegate { } - func handle_text_event(sub_id: String, _ ev: NostrEvent) { + func handle_text_event(_ ev: NostrEvent, context: SubscriptionContext) { guard should_show_event(state: damus_state, ev: ev) else { return } @@ -770,10 +796,13 @@ class HomeModel: ContactsDelegate { } } - if sub_id == home_subid { + switch context { + case .home: insert_home_event(ev) - } else if sub_id == notifications_subid { + case .notifications: handle_notification(ev: ev) + case .dms, .contacts, .initialRelayList, .initialContactList, .nwc: + break } } @@ -1191,3 +1220,24 @@ func create_in_app_event_zap_notification(profiles: Profiles, zap: Zap, locale: } } +// MARK: - Extension to bridge NIP-65 relay list structs with app-native objects +// TODO: Do we need this?? + +//extension NIP65.RelayList { +// static func fromLegacyContactList(_ contactList: NdbNote) throws(BridgeError) -> Self { +// guard let relayListInfo = decode_json_relays(contactList.content) else { throw .couldNotDecodeRelayListInfo } +// let relayItems = relayListInfo.map({ url, rwConfiguration in +// return RelayItem(url: url, rwConfiguration: rwConfiguration.toNIP65RWConfiguration() ?? .readWrite) +// }) +// return NIP65.RelayList(relays: relayItems) +// } +// +// static func fromLegacyContactList(_ contactList: NdbNote?) throws(BridgeError) -> Self? { +// guard let contactList = contactList else { return nil } +// return try fromLegacyContactList(contactList) +// } +// +// enum BridgeError: Error { +// case couldNotDecodeRelayListInfo +// } +//} diff --git a/damus/Features/Wallet/Models/WalletConnect/WalletConnect+.swift b/damus/Features/Wallet/Models/WalletConnect/WalletConnect+.swift index 06043f39..1ed038bf 100644 --- a/damus/Features/Wallet/Models/WalletConnect/WalletConnect+.swift +++ b/damus/Features/Wallet/Models/WalletConnect/WalletConnect+.swift @@ -123,8 +123,8 @@ extension WalletConnect { let delay = 0.0 // We don't need a delay when fetching a transaction list or balance - WalletConnect.request_transaction_list(url: nwc, pool: damus_state.nostrNetwork.pool, post: damus_state.nostrNetwork.postbox, delay: delay, on_flush: flusher) - WalletConnect.request_balance_information(url: nwc, pool: damus_state.nostrNetwork.pool, post: damus_state.nostrNetwork.postbox, delay: delay, on_flush: flusher) + damus_state.nostrNetwork.requestTransactionList(url: nwc, delay: delay, on_flush: flusher) + damus_state.nostrNetwork.requestBalanceInformation(url: nwc, delay: delay, on_flush: flusher) return } @@ -153,22 +153,6 @@ extension WalletConnect { } } - /// Send a donation zap to the Damus team - static func send_donation_zap(pool: RelayPool, postbox: PostBox, nwc: WalletConnectURL, percent: Int, base_msats: Int64) async { - let percent_f = Double(percent) / 100.0 - let donations_msats = Int64(percent_f * Double(base_msats)) - - let payreq = LNUrlPayRequest(allowsNostr: true, commentAllowed: nil, nostrPubkey: "", callback: "https://sendsats.lol/@damus") - guard let invoice = await fetch_zap_invoice(payreq, zapreq: nil, msats: donations_msats, zap_type: .non_zap, comment: nil) else { - // we failed... oh well. no donation for us. - print("damus-donation failed to fetch invoice") - return - } - - print("damus-donation donating...") - WalletConnect.pay(url: nwc, pool: pool, post: postbox, invoice: invoice, zap_request: nil, delay: nil) - } - /// Handles a received Nostr Wallet Connect error static func handle_error(zapcache: Zaps, evcache: EventCache, resp: WalletConnect.FullWalletResponse) { // find a pending zap with the nwc request id associated with this response and remove it diff --git a/damus/Features/Wallet/Views/SendPaymentView.swift b/damus/Features/Wallet/Views/SendPaymentView.swift index f9555e6d..2f0e94ed 100644 --- a/damus/Features/Wallet/Views/SendPaymentView.swift +++ b/damus/Features/Wallet/Views/SendPaymentView.swift @@ -185,7 +185,7 @@ struct SendPaymentView: View { sendState = .processing // Process payment - guard let payRequestEv = WalletConnect.pay(url: nwc, pool: damus_state.nostrNetwork.pool, post: damus_state.nostrNetwork.postbox, invoice: invoice.string, zap_request: nil, delay: nil) else { + guard let payRequestEv = damus_state.nostrNetwork.nwcPay(url: nwc, post: damus_state.nostrNetwork.postbox, invoice: invoice.string, zap_request: nil) else { sendState = .failed(error: .init( user_visible_description: NSLocalizedString("The payment request could not be made to your wallet provider.", comment: "A human-readable error message"), tip: NSLocalizedString("Check if your wallet looks configured correctly and try again. If the error persists, please contact support.", comment: "A human-readable tip for an error when a payment request cannot be made to a wallet."), diff --git a/damus/Features/Zaps/Models/ZapsModel.swift b/damus/Features/Zaps/Models/ZapsModel.swift index 9e1e5694..49af62d5 100644 --- a/damus/Features/Zaps/Models/ZapsModel.swift +++ b/damus/Features/Zaps/Models/ZapsModel.swift @@ -11,7 +11,7 @@ class ZapsModel: ObservableObject { let state: DamusState let target: ZapTarget - let zaps_subid = UUID().description + var zapCommsListener: Task? = nil let profiles_subid = UUID().description init(state: DamusState, target: ZapTarget) { @@ -31,46 +31,40 @@ class ZapsModel: ObservableObject { case .note(let note_target): filter.referenced_ids = [note_target.note_id] } - state.nostrNetwork.pool.subscribe(sub_id: zaps_subid, filters: [filter], handler: handle_event) + zapCommsListener?.cancel() + zapCommsListener = Task { + for await item in state.nostrNetwork.reader.subscribe(filters: [filter]) { + switch item { + case .event(let borrow): + var event: NostrEvent? = nil + try? borrow { ev in + event = ev.toOwned() + } + guard let event else { return } + await self.handle_event(ev: event) + case .eose: + let events = state.events.lookup_zaps(target: target).map { $0.request.ev } + guard let txn = NdbTxn(ndb: state.ndb) else { return } + load_profiles(context: "zaps_model", load: .from_events(events), damus_state: state, txn: txn) + } + } + } } func unsubscribe() { - state.nostrNetwork.pool.unsubscribe(sub_id: zaps_subid) + zapCommsListener?.cancel() + zapCommsListener = nil } - + @MainActor - func handle_event(relay_id: RelayURL, conn_ev: NostrConnectionEvent) { - guard case .nostr_event(let resp) = conn_ev else { + func handle_event(ev: NostrEvent) { + guard ev.kind == 9735, + let zapper = state.profiles.lookup_zapper(pubkey: target.pubkey), + let zap = Zap.from_zap_event(zap_ev: ev, zapper: zapper, our_privkey: state.keypair.privkey) + else { return } - guard resp.subid == zaps_subid else { - return - } - - switch resp { - case .ok: - break - case .notice: - break - case .eose: - let events = state.events.lookup_zaps(target: target).map { $0.request.ev } - guard let txn = NdbTxn(ndb: state.ndb) else { return } - load_profiles(context: "zaps_model", profiles_subid: profiles_subid, relay_id: relay_id, load: .from_events(events), damus_state: state, txn: txn) - case .event(_, let ev): - guard ev.kind == 9735, - let zapper = state.profiles.lookup_zapper(pubkey: target.pubkey), - let zap = Zap.from_zap_event(zap_ev: ev, zapper: zapper, our_privkey: state.keypair.privkey) - else { - return - } - - self.state.add_zap(zap: .zap(zap)) - case .auth: - break - } - - - + self.state.add_zap(zap: .zap(zap)) } } diff --git a/damus/Features/Zaps/Views/CustomizeZapView.swift b/damus/Features/Zaps/Views/CustomizeZapView.swift index d7a7502d..cf6befd9 100644 --- a/damus/Features/Zaps/Views/CustomizeZapView.swift +++ b/damus/Features/Zaps/Views/CustomizeZapView.swift @@ -175,7 +175,9 @@ struct CustomizeZapView: View { } else { Button(action: { let amount = model.custom_amount_sats - send_zap(damus_state: state, target: target, lnurl: lnurl, is_custom: true, comment: model.comment, amount_sats: amount, zap_type: model.zap_type) + Task { + await send_zap(damus_state: state, target: target, lnurl: lnurl, is_custom: true, comment: model.comment, amount_sats: amount, zap_type: model.zap_type) + } model.zapping = true }) { HStack { diff --git a/damus/Features/Zaps/Views/NoteZapButton.swift b/damus/Features/Zaps/Views/NoteZapButton.swift index e8d1f859..d7a1c9ef 100644 --- a/damus/Features/Zaps/Views/NoteZapButton.swift +++ b/damus/Features/Zaps/Views/NoteZapButton.swift @@ -72,7 +72,7 @@ struct NoteZapButton: View { func tap() { guard let our_zap else { - send_zap(damus_state: damus_state, target: target, lnurl: lnurl, is_custom: false, comment: nil, amount_sats: nil, zap_type: damus_state.settings.default_zap_type) + Task { await send_zap(damus_state: damus_state, target: target, lnurl: lnurl, is_custom: false, comment: nil, amount_sats: nil, zap_type: damus_state.settings.default_zap_type) } return } @@ -173,13 +173,13 @@ func initial_pending_zap_state(settings: UserSettingsStore) -> PendingZapState { return .external(ExtPendingZapState(state: .fetching_invoice)) } -func send_zap(damus_state: DamusState, target: ZapTarget, lnurl: String, is_custom: Bool, comment: String?, amount_sats: Int?, zap_type: ZapType) { +func send_zap(damus_state: DamusState, target: ZapTarget, lnurl: String, is_custom: Bool, comment: String?, amount_sats: Int?, zap_type: ZapType) async { guard let keypair = damus_state.keypair.to_full() else { return } // Only take the first 10 because reasons - let relays = Array(damus_state.nostrNetwork.pool.our_descriptors.prefix(10)) + let relays = Array(damus_state.nostrNetwork.ourRelayDescriptors.prefix(10)) let content = comment ?? "" guard let mzapreq = make_zap_request_event(keypair: keypair, content: content, relays: relays, target: target, zap_type: zap_type) else { @@ -232,7 +232,7 @@ func send_zap(damus_state: DamusState, target: ZapTarget, lnurl: String, is_cust flusher = .once({ pe in // send donation zap when the pending zap is flushed, this allows user to cancel and not send a donation Task { @MainActor in - await WalletConnect.send_donation_zap(pool: damus_state.nostrNetwork.pool, postbox: damus_state.nostrNetwork.postbox, nwc: nwc_state.url, percent: damus_state.settings.donation_percent, base_msats: amount_msat) + await damus_state.nostrNetwork.send_donation_zap(nwc: nwc_state.url, percent: damus_state.settings.donation_percent, base_msats: amount_msat) } }) } @@ -240,7 +240,7 @@ func send_zap(damus_state: DamusState, target: ZapTarget, lnurl: String, is_cust // we don't have a delay on one-tap nozaps (since this will be from customize zap view) let delay = damus_state.settings.nozaps ? nil : 5.0 - let nwc_req = WalletConnect.pay(url: nwc_state.url, pool: damus_state.nostrNetwork.pool, post: damus_state.nostrNetwork.postbox, invoice: inv, zap_request: zapreq, delay: delay, on_flush: flusher) + let nwc_req = damus_state.nostrNetwork.nwcPay(url: nwc_state.url, post: damus_state.nostrNetwork.postbox, invoice: inv, delay: delay, on_flush: flusher) guard let nwc_req, case .nwc(let pzap_state) = pending_zap_state else { print("nwc: failed to send nwc request for zapreq \(reqid.reqid)") diff --git a/damus/Shared/Utilities/Router.swift b/damus/Shared/Utilities/Router.swift index caf2f0e1..9ab1b3fc 100644 --- a/damus/Shared/Utilities/Router.swift +++ b/damus/Shared/Utilities/Router.swift @@ -130,7 +130,7 @@ enum Route: Hashable { case .FollowersYouKnow(let friendedFollowers, let followers): FollowersYouKnowView(damus_state: damusState, friended_followers: friendedFollowers, followers: followers) case .Script(let load_model): - LoadScript(pool: damusState.nostrNetwork.pool, model: load_model) + LoadScript(pool: RelayPool(ndb: damusState.ndb, keypair: damusState.keypair), model: load_model) case .NIP05DomainEvents(let events, let nip05_domain_favicon): NIP05DomainTimelineView(damus_state: damusState, model: events, nip05_domain_favicon: nip05_domain_favicon) case .NIP05DomainPubkeys(let domain, let nip05_domain_favicon, let pubkeys): @@ -237,7 +237,6 @@ enum Route: Hashable { case .FollowersYouKnow(let friendedFollowers, let followers): hasher.combine("followersYouKnow") hasher.combine(friendedFollowers) - hasher.combine(followers.sub_id) case .Script(let model): hasher.combine("script") hasher.combine(model.data.count) diff --git a/highlighter action extension/ActionViewController.swift b/highlighter action extension/ActionViewController.swift index 46a63b48..0ee8bbc3 100644 --- a/highlighter action extension/ActionViewController.swift +++ b/highlighter action extension/ActionViewController.swift @@ -164,7 +164,7 @@ struct ShareExtensionView: View { break case .active: print("txn: 📙 HIGHLIGHTER ACTIVE") - state.nostrNetwork.pool.ping() + state.nostrNetwork.ping() @unknown default: break } diff --git a/share extension/ShareViewController.swift b/share extension/ShareViewController.swift index 2afa8624..67c38f76 100644 --- a/share extension/ShareViewController.swift +++ b/share extension/ShareViewController.swift @@ -193,7 +193,7 @@ struct ShareExtensionView: View { break case .active: print("txn: 📙 SHARE ACTIVE") - state.nostrNetwork.pool.ping() + state.nostrNetwork.ping() @unknown default: break }