345 lines
9.3 KiB
Swift
345 lines
9.3 KiB
Swift
//
|
|
// Zap.swift
|
|
// damus
|
|
//
|
|
// Created by William Casarin on 2023-01-15.
|
|
//
|
|
|
|
import Foundation
|
|
|
|
public struct NoteZapTarget: Equatable {
|
|
public let note_id: String
|
|
public let author: String
|
|
}
|
|
|
|
public enum ZapTarget: Equatable {
|
|
case profile(String)
|
|
case note(NoteZapTarget)
|
|
|
|
public static func note(id: String, author: String) -> ZapTarget {
|
|
return .note(NoteZapTarget(note_id: id, author: author))
|
|
}
|
|
|
|
var pubkey: String {
|
|
switch self {
|
|
case .profile(let pk):
|
|
return pk
|
|
case .note(let note_target):
|
|
return note_target.author
|
|
}
|
|
}
|
|
|
|
var id: String {
|
|
switch self {
|
|
case .note(let note_target):
|
|
return note_target.note_id
|
|
case .profile(let pk):
|
|
return pk
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ZapRequest {
|
|
let ev: NostrEvent
|
|
}
|
|
|
|
struct Zap {
|
|
public let event: NostrEvent
|
|
public let invoice: ZapInvoice
|
|
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, 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
|
|
}
|
|
guard let bolt11_str = event_tag(zap_ev, name: "bolt11") else {
|
|
return nil
|
|
}
|
|
guard let bolt11 = decode_bolt11(bolt11_str) else {
|
|
return nil
|
|
}
|
|
/// Any amount invoices are not allowed
|
|
guard let zap_invoice = invoice_to_zap_invoice(bolt11) else {
|
|
return nil
|
|
}
|
|
// Some endpoints don't have this, let's skip the check for now. We're mostly trusting the zapper anyways
|
|
/*
|
|
guard let preimage = event_tag(zap_ev, name: "preimage") else {
|
|
return nil
|
|
}
|
|
guard preimage_matches_invoice(preimage, inv: zap_invoice) else {
|
|
return nil
|
|
}
|
|
*/
|
|
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
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
|
|
/// Fetches the description from either the invoice, or tags, depending on the type of invoice
|
|
func get_zap_description(_ ev: NostrEvent, inv_desc: InvoiceDescription) -> String? {
|
|
switch inv_desc {
|
|
case .description(let string):
|
|
return string
|
|
case .description_hash(let deschash):
|
|
guard let desc = event_tag(ev, name: "description") else {
|
|
return nil
|
|
}
|
|
guard let data = desc.data(using: .utf8) else {
|
|
return nil
|
|
}
|
|
guard sha256(data) == deschash else {
|
|
return nil
|
|
}
|
|
|
|
return desc
|
|
}
|
|
}
|
|
|
|
func invoice_to_zap_invoice(_ invoice: Invoice) -> ZapInvoice? {
|
|
guard case .specific(let amt) = invoice.amount else {
|
|
return nil
|
|
}
|
|
|
|
return ZapInvoice(description: invoice.description, amount: amt, string: invoice.string, expiry: invoice.expiry, payment_hash: invoice.payment_hash, created_at: invoice.created_at)
|
|
}
|
|
|
|
func preimage_matches_invoice<T>(_ preimage: String, inv: LightningInvoice<T>) -> Bool {
|
|
guard let raw_preimage = hex_decode(preimage) else {
|
|
return false
|
|
}
|
|
|
|
let hashed = sha256(Data(raw_preimage))
|
|
|
|
return inv.payment_hash == hashed
|
|
}
|
|
|
|
func determine_zap_target(_ ev: NostrEvent) -> ZapTarget? {
|
|
guard let ptag = event_tag(ev, name: "p") else {
|
|
return nil
|
|
}
|
|
|
|
if let etag = event_tag(ev, name: "e") {
|
|
return ZapTarget.note(id: etag, author: ptag)
|
|
}
|
|
|
|
return .profile(ptag)
|
|
}
|
|
|
|
func decode_bolt11(_ s: String) -> Invoice? {
|
|
var bs = blocks()
|
|
bs.num_blocks = 0
|
|
blocks_init(&bs)
|
|
|
|
let bytes = s.utf8CString
|
|
let _ = bytes.withUnsafeBufferPointer { p in
|
|
damus_parse_content(&bs, p.baseAddress)
|
|
}
|
|
|
|
guard bs.num_blocks == 1 else {
|
|
blocks_free(&bs)
|
|
return nil
|
|
}
|
|
|
|
let block = bs.blocks[0]
|
|
|
|
guard let converted = convert_block(block, tags: []) else {
|
|
blocks_free(&bs)
|
|
return nil
|
|
}
|
|
|
|
guard case .invoice(let invoice) = converted else {
|
|
blocks_free(&bs)
|
|
return nil
|
|
}
|
|
|
|
blocks_free(&bs)
|
|
return invoice
|
|
}
|
|
|
|
func event_tag(_ ev: NostrEvent, name: String) -> String? {
|
|
for tag in ev.tags {
|
|
if tag.count >= 2 && tag[0] == name {
|
|
return tag[1]
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func decode_nostr_event_json(_ desc: String) -> NostrEvent? {
|
|
let decoder = JSONDecoder()
|
|
guard let dat = desc.data(using: .utf8) else {
|
|
return nil
|
|
}
|
|
guard let ev = try? decoder.decode(NostrEvent.self, from: dat) else {
|
|
return nil
|
|
}
|
|
|
|
return ev
|
|
}
|
|
|
|
func decode_zap_request(_ desc: String) -> ZapRequest? {
|
|
let decoder = JSONDecoder()
|
|
guard let jsonData = desc.data(using: .utf8) else {
|
|
return nil
|
|
}
|
|
guard let jsonArray = try? JSONSerialization.jsonObject(with: jsonData) as? [[Any]] else {
|
|
return nil
|
|
}
|
|
|
|
for array in jsonArray {
|
|
guard array.count == 2 else {
|
|
continue
|
|
}
|
|
let mkey = array.first.flatMap { $0 as? String }
|
|
if let key = mkey, key == "application/nostr" {
|
|
guard let dat = try? JSONSerialization.data(withJSONObject: array[1], options: []) else {
|
|
return nil
|
|
}
|
|
|
|
guard let zap_req = try? decoder.decode(NostrEvent.self, from: dat) else {
|
|
return nil
|
|
}
|
|
|
|
guard zap_req.kind == 9734 else {
|
|
return nil
|
|
}
|
|
|
|
/// Ensure the signature on the zap request is correct
|
|
guard case .ok = validate_event(ev: zap_req) else {
|
|
return nil
|
|
}
|
|
|
|
return ZapRequest(ev: zap_req)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
|
|
|
|
func fetch_zapper_from_lnurl(_ lnurl: String) async -> String? {
|
|
guard let endpoint = await fetch_static_payreq(lnurl) else {
|
|
return nil
|
|
}
|
|
|
|
guard let allows = endpoint.allowsNostr, allows else {
|
|
return nil
|
|
}
|
|
|
|
guard let key = endpoint.nostrPubkey, key.count == 64 else {
|
|
return nil
|
|
}
|
|
|
|
return endpoint.nostrPubkey
|
|
}
|
|
|
|
func decode_lnurl(_ lnurl: String) -> URL? {
|
|
guard let decoded = try? bech32_decode(lnurl) else {
|
|
return nil
|
|
}
|
|
guard decoded.hrp == "lnurl" else {
|
|
return nil
|
|
}
|
|
guard let url = URL(string: String(decoding: decoded.data, as: UTF8.self)) else {
|
|
return nil
|
|
}
|
|
return url
|
|
}
|
|
|
|
func fetch_static_payreq(_ lnurl: String) async -> LNUrlPayRequest? {
|
|
guard let url = decode_lnurl(lnurl) else {
|
|
return nil
|
|
}
|
|
|
|
guard let ret = try? await URLSession.shared.data(from: url) else {
|
|
return nil
|
|
}
|
|
|
|
let json_str = String(decoding: ret.0, as: UTF8.self)
|
|
|
|
guard let endpoint: LNUrlPayRequest = decode_json(json_str) else {
|
|
return nil
|
|
}
|
|
|
|
return endpoint
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
let zappable = payreq.allowsNostr ?? false
|
|
let amount: Int64 = Int64(sats) * 1000
|
|
|
|
var query = [URLQueryItem(name: "amount", value: "\(amount)")]
|
|
|
|
if let zapreq, zappable && zap_type != .non_zap, let json = encode_json(zapreq) {
|
|
print("zapreq json: \(json)")
|
|
query.append(URLQueryItem(name: "nostr", value: json))
|
|
}
|
|
|
|
// add a lud12 comment as well if we have it
|
|
if zap_type != .priv, let comment, let limit = payreq.commentAllowed, limit != 0 {
|
|
let limited_comment = String(comment.prefix(limit))
|
|
query.append(URLQueryItem(name: "comment", value: limited_comment))
|
|
}
|
|
|
|
base_url.queryItems = query
|
|
|
|
guard let url = base_url.url else {
|
|
return nil
|
|
}
|
|
|
|
print("url \(url)")
|
|
|
|
var ret: (Data, URLResponse)? = nil
|
|
do {
|
|
ret = try await URLSession.shared.data(from: url)
|
|
} catch {
|
|
print(error.localizedDescription)
|
|
return nil
|
|
}
|
|
|
|
guard let ret else {
|
|
return nil
|
|
}
|
|
|
|
let json_str = String(decoding: ret.0, as: UTF8.self)
|
|
guard let result: LNUrlPayResponse = decode_json(json_str) else {
|
|
print("fetch_zap_invoice error: \(json_str)")
|
|
return nil
|
|
}
|
|
|
|
return result.pr
|
|
}
|