damus

nostr ios client
git clone git://jb55.com/damus
Log | Files | Refs | README | LICENSE

NostrEvent+.swift (3421B)

      1 //
      2 //  NostrEvent+.swift
      3 //  damus
      4 //
      5 //  Created by Daniel D’Aquino on 2023-11-17.
      6 //
      7 
      8 import Foundation
      9 
     10 func make_zap_request_event(keypair: FullKeypair, content: String, relays: [RelayDescriptor], target: ZapTarget, zap_type: ZapType) -> MakeZapRequest? {
     11     var tags = zap_target_to_tags(target)
     12     var relay_tag = ["relays"]
     13     relay_tag.append(contentsOf: relays.map { $0.url.absoluteString })
     14     tags.append(relay_tag)
     15 
     16     var kp = keypair
     17     
     18     let now = UInt32(Date().timeIntervalSince1970)
     19 
     20     var privzap_req: PrivateZapRequest?
     21     
     22     var message = content
     23     switch zap_type {
     24     case .pub:
     25         break
     26     case .non_zap:
     27         break
     28     case .anon:
     29         tags.append(["anon"])
     30         kp = generate_new_keypair()
     31     case .priv:
     32         guard let priv_kp = generate_private_keypair(our_privkey: keypair.privkey, id: NoteId(target.id), created_at: now) else {
     33             return nil
     34         }
     35         kp = priv_kp
     36         guard let privreq = make_private_zap_request_event(identity: keypair, enc_key: kp, target: target, message: message) else {
     37             return nil
     38         }
     39         tags.append(["anon", privreq.enc])
     40         message = ""
     41         privzap_req = privreq
     42     }
     43     
     44     guard let ev = NostrEvent(content: message, keypair: kp.to_keypair(), kind: 9734, tags: tags, createdAt: now) else {
     45         return nil
     46     }
     47     let zapreq = ZapRequest(ev: ev)
     48     if let privzap_req {
     49         return .priv(zapreq, privzap_req)
     50     } else {
     51         return .normal(zapreq)
     52     }
     53 }
     54 
     55 func zap_target_to_tags(_ target: ZapTarget) -> [[String]] {
     56     switch target {
     57     case .profile(let pk):
     58         return [["p", pk.hex()]]
     59     case .note(let note_target):
     60         return [["e", note_target.note_id.hex()],
     61                 ["p", note_target.author.hex()]]
     62     }
     63 }
     64 
     65 func make_private_zap_request_event(identity: FullKeypair, enc_key: FullKeypair, target: ZapTarget, message: String) -> PrivateZapRequest? {
     66     // target tags must be the same as zap request target tags
     67     let tags = zap_target_to_tags(target)
     68     
     69     guard let note = NostrEvent(content: message, keypair: identity.to_keypair(), kind: 9733, tags: tags),
     70           let note_json = encode_json(note),
     71           let enc = encrypt_message(message: note_json, privkey: enc_key.privkey, to_pk: target.pubkey, encoding: .bech32)
     72     else {
     73         return nil
     74     }
     75     
     76     return PrivateZapRequest(req: ZapRequest(ev: note), enc: enc)
     77 }
     78 
     79 func make_first_contact_event(keypair: Keypair) -> NostrEvent? {
     80     let bootstrap_relays = load_bootstrap_relays(pubkey: keypair.pubkey)
     81     let rw_relay_info = RelayInfo(read: true, write: true)
     82     var relays: [RelayURL: RelayInfo] = [:]
     83 
     84     for relay in bootstrap_relays {
     85         relays[relay] = rw_relay_info
     86     }
     87     
     88     let relay_json = encode_json(relays)!
     89     let damus_pubkey = "3efdaebb1d8923ebd99c9e7ace3b4194ab45512e2be79c1b7d68d9243e0d2681"
     90     let tags = [
     91         ["p", damus_pubkey],
     92         ["p", keypair.pubkey.hex()] // you're a friend of yourself!
     93     ]
     94     return NostrEvent(content: relay_json, keypair: keypair, kind: NostrKind.contacts.rawValue, tags: tags)
     95 }
     96 
     97 func make_metadata_event(keypair: FullKeypair, metadata: Profile) -> NostrEvent? {
     98     guard let metadata_json = encode_json(metadata) else {
     99         return nil
    100     }
    101     return NostrEvent(content: metadata_json, keypair: keypair.to_keypair(), kind: NostrKind.metadata.rawValue, tags: [])
    102 
    103 }