feat: add purplepag.es as profile-only relay

Add wss://purplepag.es as a system relay that's always included for all
users but only used for profile metadata queries (kinds 0, 3, 10002).

- Add `profilesOnly` variant to RelayVariant enum
- Add `isProfileRelated` check to NostrRequestType to detect profile queries
- Filter profiles-only relays in send_raw to only receive profile requests
- Always include purplepag.es in relay list via UserRelayListManager

Closes: #1331
Changelog-Added: Added purplepag.es as profile-only relay for improved profile metadata fetching
Signed-off-by: alltheseas

Author: alltheseas

damus/Core/Networking/NostrNetworkManager/UserRelayListManager.swift

@@ -35,11 +35,17 @@ extension NostrNetworkManager {
         }
 
         private func computeRelaysToConnectTo(with relayList: NIP65.RelayList) -> [RelayPool.RelayDescriptor] {
-            let regularRelayDescriptorList = relayList.toRelayDescriptors()
+            var descriptors = relayList.toRelayDescriptors()
+
+            // Always add profiles-only relays for profile metadata
+            if let purplePagesURL = RelayURL("wss://purplepag.es") {
+                descriptors.append(.profilesOnly(url: purplePagesURL))
+            }
+
             if let nwcWallet = delegate.nwcWallet {
-                return regularRelayDescriptorList + [.nwc(url: nwcWallet.relay)]
+                descriptors.append(.nwc(url: nwcWallet.relay))
             }
-            return regularRelayDescriptorList
+            return descriptors
         }
 
         // MARK: - Getting the user's relay list

damus/Core/Nostr/NostrRequest.swift

@@ -33,11 +33,28 @@ enum NostrRequestType {
         guard case .typical(let req) = self else {
             return true
         }
-        
+
         return req.is_read
     }
 }
 
+extension NostrRequestType {
+    /// Profile-related kinds that should be queried on profiles-only relays
+    static let profileKinds: Set<NostrKind> = [.metadata, .contacts, .relay_list]
+
+    /// Whether this request is for profile-related data only
+    var isProfileRelated: Bool {
+        guard case .typical(let req) = self else { return false }
+        guard case .subscribe(let sub) = req else { return false }
+
+        // Check if ALL filters contain ONLY profile-related kinds
+        return sub.filters.allSatisfy { filter in
+            guard let kinds = filter.kinds else { return false }  // No kinds specified = could be anything
+            return kinds.allSatisfy { Self.profileKinds.contains($0) }
+        }
+    }
+}
+
 /// Models a standard request/message that is sent to a Nostr relay.
 enum NostrRequest {
     /// Subscribes to receive information from the relay

damus/Core/Nostr/Relay.swift

@@ -32,6 +32,7 @@ enum RelayVariant {
     case regular
     case ephemeral
     case nwc
+    case profilesOnly  // Only used for profile metadata queries (kind 0, 3, 10002)
 }
 
 extension RelayPool {
@@ -55,12 +56,22 @@ extension RelayPool {
                 return true
             case .nwc:
                 return true
+            case .profilesOnly:
+                return false  // Not ephemeral - filtering is handled separately via isProfileRelated check
             }
         }
-        
+
+        var isProfilesOnly: Bool {
+            variant == .profilesOnly
+        }
+
         static func nwc(url: RelayURL) -> RelayDescriptor {
             return RelayDescriptor(url: url, info: .readWrite, variant: .nwc)
         }
+
+        static func profilesOnly(url: RelayURL) -> RelayDescriptor {
+            return RelayDescriptor(url: url, info: .read, variant: .profilesOnly)
+        }
     }
 }
 

damus/Core/Nostr/RelayPool.swift

@@ -425,7 +425,19 @@ actor RelayPool {
             if relay.descriptor.ephemeral && skip_ephemeral {
                 continue    // Do not send requests to ephemeral relays if we want to skip them
             }
-            
+
+            if relay.descriptor.isProfilesOnly && !req.isProfileRelated {
+                continue    // Only send profile-related requests to profiles-only relays
+            }
+
+            // TEMP DEBUG: Log what's being sent to purplepag.es
+            if relay.descriptor.isProfilesOnly,
+               case .typical(let nostrReq) = req,
+               case .subscribe(let sub) = nostrReq {
+                let kinds = sub.filters.compactMap { $0.kinds }.flatMap { $0 }.map { $0.rawValue }
+                print("🟣 PURPLEPAGES: sending subscription with kinds: \(kinds)")
+            }
+
             guard relay.connection.isConnected else {
                 Task { await queue_req(r: req, relay: relay.id, skip_ephemeral: skip_ephemeral) }
                 continue
@@ -465,16 +477,19 @@ actor RelayPool {
     }
 
     func record_seen(relay_id: RelayURL, event: NostrConnectionEvent) {
-        if case .nostr_event(let ev) = event {
-            if case .event(_, let nev) = ev {
-                if seen[nev.id]?.contains(relay_id) == true {
-                    return
-                }
-                seen[nev.id, default: Set()].insert(relay_id)
-                counts[relay_id, default: 0] += 1
-                notify(.update_stats(note_id: nev.id))
-            }
+        guard case .nostr_event(let ev) = event else { return }
+        guard case .event(_, let nev) = ev else { return }
+
+        // TEMP DEBUG: Log events received from purplepag.es
+        if relay_id.absoluteString.contains("purplepag") {
+            print("🟣 PURPLEPAGES: received kind \(nev.kind) event")
         }
+
+        guard seen[nev.id]?.contains(relay_id) != true else { return }
+
+        seen[nev.id, default: Set()].insert(relay_id)
+        counts[relay_id, default: 0] += 1
+        notify(.update_stats(note_id: nev.id))
     }
 
     func resubscribeAll(relayId: RelayURL) async {