Pending Zaps

A fairly large change that replaces Zaps in the codebase with "Zapping"
which is a tagged union consisting of a resolved Zap and a Pending Zap.
These are both counted as Zaps everywhere in Damus, except pending zaps
can be cancelled (most of the time).

damus/Nostr/NostrKind.swift

@@ -22,4 +22,6 @@ enum NostrKind: Int {
     case list = 30000
     case zap = 9735
     case zap_request = 9734
+    case nwc_request = 23194
+    case nwc_response = 23195
 }

damus/Nostr/Relay.swift

@@ -10,21 +10,46 @@ import Foundation
 public struct RelayInfo: Codable {
     let read: Bool?
     let write: Bool?
-    let ephemeral: Bool?
     
-    init(read: Bool, write: Bool, ephemeral: Bool = false) {
+    init(read: Bool, write: Bool) {
         self.read = read
         self.write = write
-        self.ephemeral = ephemeral
     }
 
-    static let rw = RelayInfo(read: true, write: true, ephemeral: false)
-    static let ephemeral = RelayInfo(read: true, write: true, ephemeral: true)
+    static let rw = RelayInfo(read: true, write: true)
+}
+
+enum RelayVariant {
+    case regular
+    case ephemeral
+    case nwc
 }
 
 public struct RelayDescriptor {
-    public let url: RelayURL
-    public let info: RelayInfo
+    let url: RelayURL
+    let info: RelayInfo
+    let variant: RelayVariant
+    
+    init(url: RelayURL, info: RelayInfo, variant: RelayVariant = .regular) {
+        self.url = url
+        self.info = info
+        self.variant = variant
+    }
+    
+    var ephemeral: Bool {
+        switch variant {
+        case .regular:
+            return false
+        case .ephemeral:
+            return true
+        case .nwc:
+            return true
+        }
+    }
+    
+    static func nwc(url: RelayURL) -> RelayDescriptor {
+        return RelayDescriptor(url: url, info: .rw, variant: .nwc)
+    }
 }
 
 enum RelayFlags: Int {

damus/Nostr/RelayPool.swift

@@ -43,7 +43,7 @@ class RelayPool {
     }
     
     var our_descriptors: [RelayDescriptor] {
-        return all_descriptors.filter { d in !(d.info.ephemeral ?? false) }
+        return all_descriptors.filter { d in !d.ephemeral }
     }
     
     var all_descriptors: [RelayDescriptor] {
@@ -91,7 +91,8 @@ class RelayPool {
         }
     }
     
-    func add_relay(_ url: RelayURL, info: RelayInfo) throws {
+    func add_relay(_ desc: RelayDescriptor) throws {
+        let url = desc.url
         let relay_id = get_relay_id(url)
         if get_relay(relay_id) != nil {
             throw RelayError.RelayAlreadyExists
@@ -99,8 +100,7 @@ class RelayPool {
         let conn = RelayConnection(url: url) { event in
             self.handle_event(relay_id: relay_id, event: event)
         }
-        let descriptor = RelayDescriptor(url: url, info: info)
-        let relay = Relay(descriptor: descriptor, connection: conn)
+        let relay = Relay(descriptor: desc, connection: conn)
         self.relays.append(relay)
     }
     
@@ -196,7 +196,7 @@ class RelayPool {
                 continue
             }
             
-            if (relay.descriptor.info.ephemeral ?? false) && skip_ephemeral {
+            if relay.descriptor.ephemeral && skip_ephemeral {
                 continue
             }
             
@@ -266,7 +266,7 @@ func add_rw_relay(_ pool: RelayPool, _ url: String) {
     guard let url = RelayURL(url) else {
         return
     }
-    try? pool.add_relay(url, info: RelayInfo.rw)
+    try? pool.add_relay(RelayDescriptor(url: url, info: .rw))
 }