commit 77f52683366c438139e575bc62817d323891a5a0 parent c72c0079cc0df88c180effb757b8d5915a14d30a Author: William Casarin <jb55@jb55.com> Date: Wed, 1 Mar 2023 07:43:44 -0800 Private Zaps This adds private zaps, which have messages and authors encrypted to the target. Keys are deterministically generated so that both the receiver and sender can decrypt. Changelog-Added: Private Zaps Diffstat:
18 files changed, 359 insertions(+), 92 deletions(-)
diff --git a/damus/Components/ZapButton.swift b/damus/Components/ZapButton.swift @@ -138,7 +138,7 @@ struct ZapButton_Previews: PreviewProvider { func send_zap(damus_state: DamusState, event: NostrEvent, lnurl: String, is_custom: Bool, comment: String?, amount_sats: Int?, zap_type: ZapType) { - guard let privkey = damus_state.keypair.privkey else { + guard let keypair = damus_state.keypair.to_full() else { return } @@ -146,7 +146,8 @@ func send_zap(damus_state: DamusState, event: NostrEvent, lnurl: String, is_cust let relays = Array(damus_state.pool.descriptors.prefix(10)) let target = ZapTarget.note(id: event.id, author: event.pubkey) let content = comment ?? "" - let zapreq = make_zap_request_event(pubkey: damus_state.pubkey, privkey: privkey, content: content, relays: relays, target: target, is_anon: zap_type == .anon) + + let zapreq = make_zap_request_event(keypair: keypair, content: content, relays: relays, target: target, zap_type: zap_type) Task { var mpayreq = damus_state.lnurls.lookup(target.pubkey) diff --git a/damus/Models/HomeModel.swift b/damus/Models/HomeModel.swift @@ -130,14 +130,14 @@ class HomeModel: ObservableObject { } } - func handle_zap_event_with_zapper(_ ev: NostrEvent, our_pubkey: String, zapper: String) { - guard let zap = Zap.from_zap_event(zap_ev: ev, zapper: zapper) else { + func handle_zap_event_with_zapper(_ ev: NostrEvent, our_keypair: Keypair, zapper: String) { + guard let zap = Zap.from_zap_event(zap_ev: ev, zapper: zapper, our_privkey: our_keypair.privkey) else { return } damus_state.zaps.add_zap(zap: zap) - guard zap.target.pubkey == our_pubkey else { + guard zap.target.pubkey == our_keypair.pubkey else { return } @@ -155,8 +155,9 @@ class HomeModel: ObservableObject { return } + let our_keypair = damus_state.keypair if let local_zapper = damus_state.profiles.lookup_zapper(pubkey: ptag) { - handle_zap_event_with_zapper(ev, our_pubkey: damus_state.pubkey, zapper: local_zapper) + handle_zap_event_with_zapper(ev, our_keypair: our_keypair, zapper: local_zapper) return } @@ -175,7 +176,7 @@ class HomeModel: ObservableObject { DispatchQueue.main.async { self.damus_state.profiles.zappers[ptag] = zapper - self.handle_zap_event_with_zapper(ev, our_pubkey: self.damus_state.pubkey, zapper: zapper) + self.handle_zap_event_with_zapper(ev, our_keypair: our_keypair, zapper: zapper) } } diff --git a/damus/Models/Notifications/ZapGroup.swift b/damus/Models/Notifications/ZapGroup.swift @@ -21,7 +21,13 @@ class ZapGroup { } func zap_requests() -> [NostrEvent] { - zaps.map { z in z.request.ev } + zaps.map { z in + if let priv = z.private_request { + return priv + } else { + return z.request.ev + } + } } init(zaps: [Zap]) { diff --git a/damus/Models/ZapsModel.swift b/damus/Models/ZapsModel.swift @@ -65,7 +65,7 @@ class ZapsModel: ObservableObject { return } - guard let zap = Zap.from_zap_event(zap_ev: ev, zapper: zapper) else { + guard let zap = Zap.from_zap_event(zap_ev: ev, zapper: zapper, our_privkey: state.keypair.privkey) else { return } diff --git a/damus/Nostr/NostrEvent.swift b/damus/Nostr/NostrEvent.swift @@ -157,7 +157,7 @@ class NostrEvent: Codable, Identifiable, CustomStringConvertible, Equatable, Has pubkey = refkey.ref_id } - let dec = decrypt_dm(key, pubkey: pubkey, content: self.content) + let dec = decrypt_dm(key, pubkey: pubkey, content: self.content, encoding: .base64) self.decrypted_content = dec return dec @@ -577,25 +577,115 @@ func zap_target_to_tags(_ target: ZapTarget) -> [[String]] { } } -func make_zap_request_event(pubkey: String, privkey: String, content: String, relays: [RelayDescriptor], target: ZapTarget, is_anon: Bool) -> NostrEvent { +func make_private_zap_request_event(identity: FullKeypair, enc_key: FullKeypair, target: ZapTarget, message: String) -> String? { + // target tags must be the same as zap request target tags + let tags = zap_target_to_tags(target) + + let note = NostrEvent(content: message, pubkey: identity.pubkey, kind: 9733, tags: tags) + note.id = calculate_event_id(ev: note) + note.sig = sign_event(privkey: identity.privkey, ev: note) + + guard let note_json = encode_json(note) else { + return nil + } + return encrypt_message(message: note_json, privkey: enc_key.privkey, to_pk: target.pubkey, encoding: .bech32) +} + +func decrypt_private_zap(our_privkey: String, zapreq: NostrEvent, target: ZapTarget) -> NostrEvent? { + guard let anon_tag = zapreq.tags.first(where: { t in t.count >= 2 && t[0] == "anon" }) else { + return nil + } + + let enc_note = anon_tag[1] + + 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: 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 +} + +func generate_private_keypair(our_privkey: String, id: String, created_at: Int64) -> FullKeypair? { + let to_hash = our_privkey + id + String(created_at) + guard let dat = to_hash.data(using: .utf8) else { + return nil + } + let privkey_bytes = sha256(dat) + let privkey = hex_encode(privkey_bytes) + guard let pubkey = privkey_to_pubkey(privkey: privkey) else { + return nil + } + + return FullKeypair(pubkey: pubkey, privkey: privkey) +} + +func make_zap_request_event(keypair: FullKeypair, content: String, relays: [RelayDescriptor], target: ZapTarget, zap_type: ZapType) -> NostrEvent? { var tags = zap_target_to_tags(target) var relay_tag = ["relays"] relay_tag.append(contentsOf: relays.map { $0.url.absoluteString }) tags.append(relay_tag) - var priv = privkey - var pub = pubkey + var kp = keypair + + let now = Int64(Date().timeIntervalSince1970) - if is_anon { + var message = content + switch zap_type { + case .pub: + break + case .non_zap: + break + case .anon: tags.append(["anon"]) - let kp = generate_new_keypair() - pub = kp.pubkey - priv = kp.privkey! + kp = generate_new_keypair().to_full()! + case .priv: + guard let priv_kp = generate_private_keypair(our_privkey: keypair.privkey, id: target.id, created_at: now) else { + return nil + } + kp = priv_kp + guard let privreq = make_private_zap_request_event(identity: keypair, enc_key: kp, target: target, message: message) else { + return nil + } + tags.append(["anon", privreq]) + message = "" } - let ev = NostrEvent(content: content, pubkey: pub, kind: 9734, tags: tags) + let ev = NostrEvent(content: message, pubkey: kp.pubkey, kind: 9734, tags: tags, createdAt: now) ev.id = calculate_event_id(ev: ev) - ev.sig = sign_event(privkey: priv, ev: ev) + ev.sig = sign_event(privkey: kp.privkey, ev: ev) return ev } @@ -625,14 +715,14 @@ func event_to_json(ev: NostrEvent) -> String { return str } -func decrypt_dm(_ privkey: String?, pubkey: String, content: String) -> String? { +func decrypt_dm(_ privkey: String?, pubkey: String, content: String, encoding: EncEncoding) -> String? { guard let privkey = privkey else { return nil } guard let shared_sec = get_shared_secret(privkey: privkey, pubkey: pubkey) else { return nil } - guard let dat = decode_dm_base64(content) else { + guard let dat = (encoding == .base64 ? decode_dm_base64(content) : decode_dm_bech32(content)) else { return nil } guard let dat = aes_decrypt(data: dat.content, iv: dat.iv, shared_sec: shared_sec) else { @@ -641,6 +731,13 @@ func decrypt_dm(_ privkey: String?, pubkey: String, content: String) -> String? return String(data: dat, encoding: .utf8) } +func decrypt_note(our_privkey: String, their_pubkey: String, enc_note: String, encoding: EncEncoding) -> NostrEvent? { + guard let dec = decrypt_dm(our_privkey, pubkey: their_pubkey, content: enc_note, encoding: encoding) else { + return nil + } + + return decode_nostr_event_json(json: dec) +} func get_shared_secret(privkey: String, pubkey: String) -> [UInt8]? { guard let privkey_bytes = try? privkey.bytes else { @@ -686,6 +783,39 @@ struct DirectMessageBase64 { let iv: [UInt8] } + + +func encode_dm_bech32(content: [UInt8], iv: [UInt8]) -> String { + let content_bech32 = bech32_encode(hrp: "pzap", content) + let iv_bech32 = bech32_encode(hrp: "iv", iv) + return content_bech32 + "_" + iv_bech32 +} + +func decode_dm_bech32(_ all: String) -> DirectMessageBase64? { + let parts = all.split(separator: "_") + guard parts.count == 2 else { + return nil + } + + let content_bech32 = String(parts[0]) + let iv_bech32 = String(parts[1]) + + guard let content_tup = try? bech32_decode(content_bech32) else { + return nil + } + guard let iv_tup = try? bech32_decode(iv_bech32) else { + return nil + } + guard content_tup.hrp == "pzap" else { + return nil + } + guard iv_tup.hrp == "iv" else { + return nil + } + + return DirectMessageBase64(content: content_tup.data.bytes, iv: iv_tup.data.bytes) +} + func encode_dm_base64(content: [UInt8], iv: [UInt8]) -> String { let content_b64 = base64_encode(content) let iv_b64 = base64_encode(iv) diff --git a/damus/Util/Zap.swift b/damus/Util/Zap.swift @@ -7,12 +7,6 @@ import Foundation -enum ZapSource { - case author(String) - // TODO: anonymous - //case anonymous -} - public struct NoteZapTarget: Equatable { public let note_id: String public let author: String @@ -55,8 +49,10 @@ struct Zap { public let zapper: String /// zap authorizer public let target: ZapTarget public let request: ZapRequest + public let is_anon: Bool + public let private_request: NostrEvent? - public static func from_zap_event(zap_ev: NostrEvent, zapper: String) -> Zap? { + public static func from_zap_event(zap_ev: NostrEvent, zapper: String, our_privkey: String?) -> Zap? { /// Make sure that we only create a zap event if it is authorized by the profile or event guard zapper == zap_ev.pubkey else { return nil @@ -83,14 +79,26 @@ struct Zap { guard let desc = get_zap_description(zap_ev, inv_desc: zap_invoice.description) else { return nil } + guard let zap_req = decode_nostr_event_json(desc) else { return nil } + + guard validate_event(ev: zap_req) == .ok else { + return nil + } + guard let target = determine_zap_target(zap_req) else { return nil } - return Zap(event: zap_ev, invoice: zap_invoice, zapper: zapper, target: target, request: ZapRequest(ev: zap_req)) + let private_request = our_privkey.flatMap { + decrypt_private_zap(our_privkey: $0, zapreq: zap_req, target: target) + } + + let is_anon = private_request == nil && event_is_anonymous(ev: zap_req) + + return Zap(event: zap_ev, invoice: zap_invoice, zapper: zapper, target: target, request: ZapRequest(ev: zap_req), is_anon: is_anon, private_request: private_request) } } @@ -285,7 +293,7 @@ func fetch_static_payreq(_ lnurl: String) async -> LNUrlPayRequest? { return endpoint } -func fetch_zap_invoice(_ payreq: LNUrlPayRequest, zapreq: NostrEvent, sats: Int, zap_type: ZapType, comment: String?) async -> String? { +func fetch_zap_invoice(_ payreq: LNUrlPayRequest, zapreq: NostrEvent?, sats: Int, zap_type: ZapType, comment: String?) async -> String? { guard var base_url = payreq.callback.flatMap({ URLComponents(string: $0) }) else { return nil } @@ -295,11 +303,10 @@ func fetch_zap_invoice(_ payreq: LNUrlPayRequest, zapreq: NostrEvent, sats: Int, var query = [URLQueryItem(name: "amount", value: "\(amount)")] - if zappable && zap_type != .non_zap { - if let json = encode_json(zapreq) { - print("zapreq json: \(json)") - query.append(URLQueryItem(name: "nostr", value: json)) - } + if let zapreq, zappable && zap_type != .non_zap { + let json = event_to_json(ev: zapreq) + print("zapreq json: \(json)") + query.append(URLQueryItem(name: "nostr", value: json)) } // add a lud12 comment as well if we have it diff --git a/damus/Views/DMChatView.swift b/damus/Views/DMChatView.swift @@ -181,13 +181,12 @@ struct DMChatView_Previews: PreviewProvider { } } +enum EncEncoding { + case base64 + case bech32 +} -func create_dm(_ message: String, to_pk: String, tags: [[String]], keypair: Keypair, created_at: Int64? = nil) -> NostrEvent? -{ - guard let privkey = keypair.privkey else { - return nil - } - +func encrypt_message(message: String, privkey: String, to_pk: String, encoding: EncEncoding = .base64) -> String? { let iv = random_bytes(count: 16).bytes guard let shared_sec = get_shared_secret(privkey: privkey, pubkey: to_pk) else { return nil @@ -196,7 +195,26 @@ func create_dm(_ message: String, to_pk: String, tags: [[String]], keypair: Keyp guard let enc_message = aes_encrypt(data: utf8_message, iv: iv, shared_sec: shared_sec) else { return nil } - let enc_content = encode_dm_base64(content: enc_message.bytes, iv: iv) + + switch encoding { + case .base64: + return encode_dm_base64(content: enc_message.bytes, iv: iv) + case .bech32: + return encode_dm_bech32(content: enc_message.bytes, iv: iv) + } + +} + +func create_dm(_ message: String, to_pk: String, tags: [[String]], keypair: Keypair, created_at: Int64? = nil) -> NostrEvent? +{ + guard let privkey = keypair.privkey else { + return nil + } + + guard let enc_content = encrypt_message(message: message, privkey: privkey, to_pk: to_pk) else { + return nil + } + let created = created_at ?? Int64(Date().timeIntervalSince1970) let ev = NostrEvent(content: enc_content, pubkey: keypair.pubkey, kind: 4, tags: tags, createdAt: created) diff --git a/damus/Views/EventView.swift b/damus/Views/EventView.swift @@ -29,29 +29,29 @@ func eventviewsize_to_font(_ size: EventViewKind) -> Font { struct EventView: View { let event: NostrEvent - let has_action_bar: Bool + let options: EventViewOptions let damus: DamusState let pubkey: String @EnvironmentObject var action_bar: ActionBarModel - init(damus: DamusState, event: NostrEvent, has_action_bar: Bool) { + init(damus: DamusState, event: NostrEvent, options: EventViewOptions) { self.event = event - self.has_action_bar = has_action_bar + self.options = options self.damus = damus self.pubkey = event.pubkey } init(damus: DamusState, event: NostrEvent) { self.event = event - self.has_action_bar = false + self.options = [] self.damus = damus self.pubkey = event.pubkey } init(damus: DamusState, event: NostrEvent, pubkey: String) { self.event = event - self.has_action_bar = false + self.options = [.no_action_bar] self.damus = damus self.pubkey = pubkey } @@ -68,7 +68,7 @@ struct EventView: View { Reposted(damus: damus, pubkey: event.pubkey, profile: prof) } .buttonStyle(PlainButtonStyle()) - TextEvent(damus: damus, event: inner_ev, pubkey: inner_ev.pubkey, has_action_bar: has_action_bar, booster_pubkey: event.pubkey) + TextEvent(damus: damus, event: inner_ev, pubkey: inner_ev.pubkey, options: options) .padding([.top], 1) } } else { @@ -81,7 +81,7 @@ struct EventView: View { EmptyView() } } else { - TextEvent(damus: damus, event: event, pubkey: pubkey, has_action_bar: has_action_bar, booster_pubkey: nil) + TextEvent(damus: damus, event: event, pubkey: pubkey, options: options) .padding([.top], 6) } } @@ -176,11 +176,7 @@ struct EventView_Previews: PreviewProvider { EventView(damus: test_damus_state(), event: NostrEvent(content: "hello there https://jb55.com/s/Oct12-150217.png https://jb55.com/red-me.jb55 cool", pubkey: "pk"), show_friend_icon: true, size: .big) */ - EventView( - damus: test_damus_state(), - event: test_event, - has_action_bar: true - ) + EventView( damus: test_damus_state(), event: test_event ) } .padding() } diff --git a/damus/Views/Events/MutedEventView.swift b/damus/Views/Events/MutedEventView.swift @@ -57,7 +57,7 @@ struct MutedEventView: View { if selected { SelectedEventView(damus: damus_state, event: event) } else { - EventView(damus: damus_state, event: event, has_action_bar: true) + EventView(damus: damus_state, event: event) .onTapGesture { nav_target = event.id navigating = true diff --git a/damus/Views/Events/TextEvent.swift b/damus/Views/Events/TextEvent.swift @@ -7,12 +7,22 @@ import SwiftUI +struct EventViewOptions: OptionSet { + let rawValue: UInt8 + static let no_action_bar = EventViewOptions(rawValue: 1 << 0) + static let no_replying_to = EventViewOptions(rawValue: 1 << 1) + static let no_images = EventViewOptions(rawValue: 1 << 2) +} + struct TextEvent: View { let damus: DamusState let event: NostrEvent let pubkey: String - let has_action_bar: Bool - let booster_pubkey: String? + let options: EventViewOptions + + var has_action_bar: Bool { + !options.contains(.no_action_bar) + } var body: some View { HStack(alignment: .top) { @@ -62,7 +72,7 @@ struct TextEvent: View { struct TextEvent_Previews: PreviewProvider { static var previews: some View { - TextEvent(damus: test_damus_state(), event: test_event, pubkey: "pk", has_action_bar: true, booster_pubkey: nil) + TextEvent(damus: test_damus_state(), event: test_event, pubkey: "pk", options: []) } } diff --git a/damus/Views/Events/ZapEvent.swift b/damus/Views/Events/ZapEvent.swift @@ -13,21 +13,44 @@ struct ZapEvent: View { var body: some View { VStack(alignment: .leading) { - Text("⚡️ \(format_msats(zap.invoice.amount))", comment: "Text indicating the zap amount. i.e. number of satoshis that were tipped to a user") - .font(.headline) - .padding([.top], 2) + HStack(alignment: .center) { + Text("⚡️ \(format_msats(zap.invoice.amount))", comment: "Text indicating the zap amount. i.e. number of satoshis that were tipped to a user") + .font(.headline) + .padding([.top], 2) + + if zap.private_request != nil { + Image(systemName: "lock.fill") + .foregroundColor(Color("DamusGreen")) + .help("Only you can see this message and who sent it.") + } + } - TextEvent(damus: damus, event: zap.request.ev, pubkey: zap.request.ev.pubkey, has_action_bar: false, booster_pubkey: nil) - .padding([.top], 1) + if let priv = zap.private_request { + + TextEvent(damus: damus, event: priv, pubkey: priv.pubkey, options: [.no_action_bar, .no_replying_to]) + .padding([.top], 1) + } else { + TextEvent(damus: damus, event: zap.request.ev, pubkey: zap.request.ev.pubkey, options: [.no_action_bar, .no_replying_to]) + .padding([.top], 1) + } } } } -/* + +let test_zap_invoice = ZapInvoice(description: .description("description"), amount: 10000, string: "lnbc1", expiry: 1000000, payment_hash: Data(), created_at: 1000000) +let test_zap_request_ev = NostrEvent(content: "hi", pubkey: "pk", kind: 9734) +let test_zap_request = ZapRequest(ev: test_zap_request_ev) +let test_zap = Zap(event: test_event, invoice: test_zap_invoice, zapper: "zapper", target: .profile("pk"), request: test_zap_request, is_anon: false, private_request: nil) + +let test_private_zap = Zap(event: test_event, invoice: test_zap_invoice, zapper: "zapper", target: .profile("pk"), request: test_zap_request, is_anon: false, private_request: test_event) + struct ZapEvent_Previews: PreviewProvider { static var previews: some View { - ZapEvent() + VStack { + ZapEvent(damus: test_damus_state(), zap: test_zap) + + ZapEvent(damus: test_damus_state(), zap: test_private_zap) + } } } - -*/ diff --git a/damus/Views/Notifications/EventGroupView.swift b/damus/Views/Notifications/EventGroupView.swift @@ -14,6 +14,19 @@ enum EventGroupType { case zap(ZapGroup) case profile_zap(ZapGroup) + var zap_group: ZapGroup? { + switch self { + case .profile_zap(let grp): + return grp + case .zap(let grp): + return grp + case .reaction: + return nil + case .repost: + return nil + } + } + var events: [NostrEvent] { switch self { case .repost(let grp): @@ -46,10 +59,28 @@ func determine_reacting_to(our_pubkey: String, ev: NostrEvent?) -> ReactingTo { return .tagged_in } -func event_author_name(profiles: Profiles, _ ev: NostrEvent) -> String { - let alice_pk = ev.pubkey - let alice_prof = profiles.lookup(id: alice_pk) - return Profile.displayName(profile: alice_prof, pubkey: alice_pk) +func event_author_name(profiles: Profiles, pubkey: String) -> String { + let alice_prof = profiles.lookup(id: pubkey) + return Profile.displayName(profile: alice_prof, pubkey: pubkey) +} + +func event_group_author_name(profiles: Profiles, ind: Int, group: EventGroupType) -> String { + if let zapgrp = group.zap_group { + let zap = zapgrp.zaps[ind] + + if let privzap = zap.private_request { + return event_author_name(profiles: profiles, pubkey: privzap.pubkey) + } + + if zap.is_anon { + return "Anonymous" + } + + return event_author_name(profiles: profiles, pubkey: zap.request.ev.pubkey) + } else { + let ev = group.events[ind] + return event_author_name(profiles: profiles, pubkey: ev.pubkey) + } } /** @@ -99,18 +130,16 @@ func reacting_to_text(profiles: Profiles, our_pubkey: String, group: EventGroupT case 0: return NSLocalizedString("??", comment: "") case 1: - let ev = group.events.first! - let profile = profiles.lookup(id: ev.pubkey) - let display_name = Profile.displayName(profile: profile, pubkey: ev.pubkey) + let display_name = event_group_author_name(profiles: profiles, ind: 0, group: group) return String(format: bundle.localizedString(forKey: localization_key, value: bundleForLocale(locale: Locale(identifier: "en-US")).localizedString(forKey: localization_key, value: nil, table: nil), table: nil), locale: locale, display_name) case 2: - let alice_name = event_author_name(profiles: profiles, group.events[0]) - let bob_name = event_author_name(profiles: profiles, group.events[1]) + let alice_name = event_group_author_name(profiles: profiles, ind: 0, group: group) + let bob_name = event_group_author_name(profiles: profiles, ind: 1, group: group) return String(format: bundle.localizedString(forKey: localization_key, value: bundleForLocale(locale: Locale(identifier: "en-US")).localizedString(forKey: localization_key, value: nil, table: nil), table: nil), locale: locale, alice_name, bob_name) default: - let alice_name = event_author_name(profiles: profiles, group.events.first!) + let alice_name = event_group_author_name(profiles: profiles, ind: 0, group: group) let count = group.events.count - 1 return String(format: bundle.localizedString(forKey: localization_key, value: bundleForLocale(locale: Locale(identifier: "en-US")).localizedString(forKey: localization_key, value: nil, table: nil), table: nil), locale: locale, count, alice_name) diff --git a/damus/Views/Notifications/NotificationItemView.swift b/damus/Views/Notifications/NotificationItemView.swift @@ -52,7 +52,7 @@ struct NotificationItemView: View { case .reply(let ev): NavigationLink(destination: BuildThreadV2View(damus: state, event_id: ev.id)) { - EventView(damus: state, event: ev, has_action_bar: true) + EventView(damus: state, event: ev) } .buttonStyle(.plain) } diff --git a/damus/Views/ReplyView.swift b/damus/Views/ReplyView.swift @@ -45,7 +45,7 @@ struct ReplyView: View { ParticipantsView(damus_state: damus, references: $references, originalReferences: $originalReferences) } ScrollView { - EventView(damus: damus, event: replying_to, has_action_bar: false) + EventView(damus: damus, event: replying_to, options: [.no_action_bar]) } PostView(replying_to: replying_to, references: references, damus_state: damus) } diff --git a/damus/Views/Timeline/InnerTimelineView.swift b/damus/Views/Timeline/InnerTimelineView.swift @@ -36,7 +36,7 @@ struct InnerTimelineView: View { EmptyTimelineView() } else { ForEach(events.filter(filter), id: \.id) { (ev: NostrEvent) in - EventView(damus: damus, event: ev, has_action_bar: true) + EventView(damus: damus, event: ev) .onTapGesture { nav_target = ev navigating = true diff --git a/damus/Views/Zaps/CustomizeZapView.swift b/damus/Views/Zaps/CustomizeZapView.swift @@ -11,6 +11,7 @@ import Combine enum ZapType { case pub case anon + case priv case non_zap } @@ -80,11 +81,29 @@ struct CustomizeZapView: View { self.state = state } + var zap_type_desc: String { + switch zap_type { + case .pub: + return "Everyone on can see that you zapped" + case .anon: + return "Noone can see that you zapped" + case .priv: + let pk = event.pubkey + let prof = state.profiles.lookup(id: pk) + let name = Profile.displayName(profile: prof, pubkey: pk) + return String(format: "Only '%@' can see that you zapped them", + name) + case .non_zap: + return "No zaps are sent, only a lightning payment." + } + } + var ZapTypePicker: some View { Picker(NSLocalizedString("Zap Type", comment: "Header text to indicate that the picker below it is to choose the type of zap to send."), selection: $zap_type) { Text("Public", comment: "Picker option to indicate that a zap should be sent publicly and identify the user as who sent it.").tag(ZapType.pub) - Text("Anonymous", comment: "Picker option to indicate that a zap should be sent anonymously and not identify the user as who sent it.").tag(ZapType.anon) - Text("Non-Zap", comment: "Picker option to indicate that sats should be sent to the user's wallet as a regular Lightning payment, not as a zap.").tag(ZapType.non_zap) + Text("Private", comment: "Picker option to indicate that a zap should be sent privately and not identify the user to the public.").tag(ZapType.priv) + Text("Anon", comment: "Picker option to indicate that a zap should be sent anonymously and not identify the user as who sent it.").tag(ZapType.anon) + Text("None", comment: "Picker option to indicate that sats should be sent to the user's wallet as a regular Lightning payment, not as a zap.").tag(ZapType.non_zap) } .pickerStyle(.segmented) } @@ -180,15 +199,17 @@ struct CustomizeZapView: View { }, header: { Text("Comment", comment: "Header text to indicate that the text field below it is a comment that will be used to send as part of a zap to the user.") }) - - Section(content: { - ZapTypePicker - }, header: { - Text("Zap Type", comment: "Header text to indicate that the picker below it is to choose the type of zap to send.") - }) - } .dismissKeyboardOnTap() + + Section(content: { + ZapTypePicker + }, header: { + Text("Zap Type", comment: "Header text to indicate that the picker below it is to choose the type of zap to send.") + }, footer: { + Text(zap_type_desc) + }) + if zapping { Text("Zapping...", comment: "Text to indicate that the app is in the process of sending a zap.") diff --git a/damus/Views/Zaps/ZapsView.swift b/damus/Views/Zaps/ZapsView.swift @@ -21,7 +21,7 @@ struct ZapsView: View { LazyVStack { ForEach(model.zaps, id: \.event.id) { zap in ZapEvent(damus: state, zap: zap) - .padding() + .padding([.horizontal]) } } } diff --git a/damusTests/ZapTests.swift b/damusTests/ZapTests.swift @@ -17,7 +17,32 @@ final class ZapTests: XCTestCase { override func tearDownWithError() throws { // Put teardown code here. This method is called after the invocation of each test method in the class. } - + + func test_private_zap() throws { + let alice = generate_new_keypair().to_full()! + let bob = generate_new_keypair().to_full()! + let target = ZapTarget.profile(bob.pubkey) + + let message = "hey bob!" + let zapreq = make_zap_request_event(keypair: alice, content: message, relays: [], target: target, zap_type: .priv) + + XCTAssertNotNil(zapreq) + guard let zapreq else { + return + } + + let decrypted = decrypt_private_zap(our_privkey: bob.privkey, zapreq: zapreq, target: target) + + XCTAssertNotNil(decrypted) + guard let decrypted else { + return + } + + XCTAssertEqual(zapreq.content, "") + XCTAssertEqual(decrypted.pubkey, alice.pubkey) + XCTAssertEqual(message, decrypted.content) + } + func testZap() throws { let zapjson = "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" @@ -33,7 +58,7 @@ final class ZapTests: XCTestCase { return } - guard let zap = Zap.from_zap_event(zap_ev: ev, zapper: "9630f464cca6a5147aa8a35f0bcdd3ce485324e732fd39e09233b1d848238f31") else { + guard let zap = Zap.from_zap_event(zap_ev: ev, zapper: "9630f464cca6a5147aa8a35f0bcdd3ce485324e732fd39e09233b1d848238f31", our_privkey: nil) else { XCTAssert(false) return }