Implement zap notification support for push notifications

The code paths for generating zap notifications were very different from
the paths used by most other notifications. In this commit, I include
the logic and data structures necessary for formatting zap notifications
in the same fashion as local notifications.

A good amount of refactoring and moving functions/structures around was
necessary to reuse zap local notification logic. I also attempted to
make the notification generation process more consistent between zaps
and other notifications, without changing too much of existing logic to
avoid even more regression risk.

General push notifications + local notifications test
-----------------------------------------------------

PASS

Device: iPhone 15 Pro simulator
iOS: 17.0.1
Damus: This commit
Setup:
- Two phones running Damus on different accounts
- Local relay with strfry-push-notify test setup
- Apple push notification test tool

Coverage:
1. Mention notifications
2. DM notifications
3. Reaction notifications
4. Repost notifications

Steps for each notification type:
1. Trigger a notification (local and then push)
2. Ensure that the notification is received on the other device
3. Ensure that the notification is formatted correctly
4. Ensure that DMs are decrypted correctly
5. Ensure that profile names are unfurled correctly
6. Click on the notification and ensure that the app opens to the correct screen

Result: PASS (all notifications received and formatted correctly)

Notes:
- For some reason my relay is not receiving zap events, so I could not
  test zap notifications yet.

- Reply notifications do not seem to be implemented yet

- These apply to the tests below as well

Changelog-Added: Zap notification support for push notifications
Signed-off-by: Daniel D’Aquino <daniel@daquino.me>
Signed-off-by: William Casarin <jb55@jb55.com>

damus/Nostr/MakeZapRequest.swift

@@ -0,0 +1,36 @@
+//
+//  MakeZapRequest.swift
+//  damus
+//
+//  Created by Daniel D’Aquino on 2023-11-27.
+//
+
+import Foundation
+
+enum MakeZapRequest {
+    case priv(ZapRequest, PrivateZapRequest)
+    case normal(ZapRequest)
+    
+    var private_inner_request: ZapRequest {
+        switch self {
+        case .priv(_, let pzr):
+            return pzr.req
+        case .normal(let zr):
+            return zr
+        }
+    }
+    
+    var potentially_anon_outer_request: ZapRequest {
+        switch self {
+        case .priv(let zr, _):
+            return zr
+        case .normal(let zr):
+            return zr
+        }
+    }
+}
+
+struct PrivateZapRequest {
+    let req: ZapRequest
+    let enc: String
+}

damus/Nostr/NostrEvent+.swift

@@ -62,11 +62,6 @@ func zap_target_to_tags(_ target: ZapTarget) -> [[String]] {
     }
 }
 
-struct PrivateZapRequest {
-    let req: ZapRequest
-    let enc: String
-}
-
 func make_private_zap_request_event(identity: FullKeypair, enc_key: FullKeypair, target: ZapTarget, message: String) -> PrivateZapRequest? {
     // target tags must be the same as zap request target tags
     let tags = zap_target_to_tags(target)
@@ -81,78 +76,6 @@ func make_private_zap_request_event(identity: FullKeypair, enc_key: FullKeypair,
     return PrivateZapRequest(req: ZapRequest(ev: note), enc: enc)
 }
 
-func decrypt_private_zap(our_privkey: Privkey, zapreq: NostrEvent, target: ZapTarget) -> NostrEvent? {
-    guard let anon_tag = zapreq.tags.first(where: { t in
-        t.count >= 2 && t[0].matches_str("anon")
-    }) else {
-        return nil
-    }
-    
-    let enc_note = anon_tag[1].string()
-
-    var note = decrypt_note(our_privkey: our_privkey, their_pubkey: zapreq.pubkey, enc_note: enc_note, encoding: .bech32)
-    
-    // check to see if the private note was from us
-    if note == nil {
-        guard let our_private_keypair = generate_private_keypair(our_privkey: our_privkey, id: NoteId(target.id), created_at: zapreq.created_at) else {
-            return nil
-        }
-        // use our private keypair and their pubkey to get the shared secret
-        note = decrypt_note(our_privkey: our_private_keypair.privkey, their_pubkey: target.pubkey, enc_note: enc_note, encoding: .bech32)
-    }
-    
-    guard let note else {
-        return nil
-    }
-        
-    guard note.kind == 9733 else {
-        return nil
-    }
-    
-    let zr_etag = zapreq.referenced_ids.first
-    let note_etag = note.referenced_ids.first
-    
-    guard zr_etag == note_etag else {
-        return nil
-    }
-    
-    let zr_ptag = zapreq.referenced_pubkeys.first
-    let note_ptag = note.referenced_pubkeys.first
-    
-    guard let zr_ptag, let note_ptag, zr_ptag == note_ptag else {
-        return nil
-    }
-    
-    guard validate_event(ev: note) == .ok else {
-        return nil
-    }
-    
-    return note
-}
-
-enum MakeZapRequest {
-    case priv(ZapRequest, PrivateZapRequest)
-    case normal(ZapRequest)
-    
-    var private_inner_request: ZapRequest {
-        switch self {
-        case .priv(_, let pzr):
-            return pzr.req
-        case .normal(let zr):
-            return zr
-        }
-    }
-    
-    var potentially_anon_outer_request: ZapRequest {
-        switch self {
-        case .priv(let zr, _):
-            return zr
-        case .normal(let zr):
-            return zr
-        }
-    }
-}
-
 func make_first_contact_event(keypair: Keypair) -> NostrEvent? {
     let bootstrap_relays = load_bootstrap_relays(pubkey: keypair.pubkey)
     let rw_relay_info = RelayInfo(read: true, write: true)