feat: share paykit state across apps

Bitkit.xcodeproj/project.pbxproj

@@ -1178,7 +1178,7 @@
 			repositoryURL = "https://github.com/pubky/paykit-rs";
 			requirement = {
 				kind = exactVersion;
-				version = "0.1.0-rc56";
+				version = "0.1.0-rc69";
 			};
 		};
 		18D65DFE2EB9649F00252335 /* XCRemoteSwiftPackageReference "vss-rust-client-ffi" */ = {

Bitkit/BitkitApp.swift

@@ -13,28 +13,24 @@ struct PaykitSubscriptionNotificationTarget: Codable, Equatable {
     let payerIdentity: String
     let paymentRequestId: String
     let counterparty: String
-    let counterpartyReceiverPath: String
     let billingPeriodStartsAt: String
 
     init?(userInfo: [AnyHashable: Any]) {
         guard let payerIdentity = userInfo["payer_identity"] as? String,
               let paymentRequestId = userInfo["payment_request_id"] as? String,
               let counterparty = userInfo["counterparty"] as? String,
-              let counterpartyReceiverPath = userInfo["counterparty_receiver_path"] as? String,
               let billingPeriodStartsAt = userInfo["billing_period_starts_at"] as? String
         else { return nil }
 
         self.payerIdentity = payerIdentity
         self.paymentRequestId = paymentRequestId
         self.counterparty = counterparty
-        self.counterpartyReceiverPath = counterpartyReceiverPath
         self.billingPeriodStartsAt = billingPeriodStartsAt
     }
 
     func matches(_ request: PaykitPaymentRequest) -> Bool {
         paymentRequestId == request.paymentRequestId &&
             PubkyPublicKeyFormat.matches(counterparty, request.counterparty) &&
-            counterpartyReceiverPath == request.counterpartyReceiverPath &&
             request.billingPeriod.map {
                 PaykitSubscriptionTimestamp.string(from: $0.startsAt) == billingPeriodStartsAt
             } == true
@@ -43,7 +39,6 @@ struct PaykitSubscriptionNotificationTarget: Codable, Equatable {
     func matches(_ requestId: PaykitPaymentRequest.ID) -> Bool {
         paymentRequestId == requestId.paymentRequestId &&
             PubkyPublicKeyFormat.matches(counterparty, requestId.counterparty) &&
-            counterpartyReceiverPath == requestId.counterpartyReceiverPath &&
             requestId.billingPeriodStartsAt.map {
                 PaykitSubscriptionTimestamp.string(from: $0) == billingPeriodStartsAt
             } == true

Bitkit/Extensions/BroadcastError+Connectivity.swift

@@ -37,6 +37,21 @@ extension BroadcastError {
 }
 
 extension Error {
+    func isDefiniteHardwarePreBroadcastFailure() -> Bool {
+        if let error = self as? BroadcastError {
+            switch error {
+            case .InvalidHex, .InvalidTransaction:
+                return true
+            default:
+                return false
+            }
+        }
+        if let error = self as? AppError, let underlyingError = error.underlyingError {
+            return underlyingError.isDefiniteHardwarePreBroadcastFailure()
+        }
+        return false
+    }
+
     func isBroadcastConnectivityFailure() -> Bool {
         if let broadcastError = self as? BroadcastError {
             return broadcastError.isConnectivityFailure

Bitkit/MainNavView.swift

@@ -765,7 +765,7 @@ struct MainNavView: View {
                 ) {
                     navigation.navigate(route)
                     if case let .contactDetail(publicKey) = route {
-                        await contactsManager.refreshContactReceiverPaths(publicKey: publicKey, wallet: wallet)
+                        await contactsManager.refreshContactLink(publicKey: publicKey, wallet: wallet)
                     }
                     clipboardUri = nil
                     return

Bitkit/Managers/ContactsManager.swift

@@ -150,11 +150,12 @@
     private let fetchRemoteProfile: @Sendable (_ publicKey: String, _ priority: PaykitPublicReadPriority) async throws -> PubkyProfile?
     private let saveContactLabel: @Sendable (_ publicKey: String, _ label: String, _ expectedIdentity: String) async throws -> Void
     private let removeContactRecord: @Sendable (_ publicKey: String) async throws -> Void
+    private let removeContactRecords: @Sendable (_ publicKeys: [String]) async throws -> [ContactRecord]
     private let forgetRemovedContacts: @Sendable (_ publicKeys: [String]) async -> Void
     private let currentDate: @Sendable () -> Date
 
     init(
         contactRecords: @escaping @Sendable () async throws -> [ContactRecord] = PubkyService.contactRecords,
         fetchFollows: @escaping @Sendable (String) async throws -> [String] = { try await PubkyService.getContacts(publicKey: $0) },
         fetchRemoteProfile: @escaping @Sendable (_ publicKey: String, _ priority: PaykitPublicReadPriority) async throws -> PubkyProfile? = {
             try await ContactsManager.remoteContactProfile(publicKey: $0, priority: $1)
@@ -165,6 +166,9 @@
         removeContactRecord: @escaping @Sendable (_ publicKey: String) async throws -> Void = {
             _ = try await PubkyService.removeContact(publicKey: $0)
         },
+        removeContactRecords: @escaping @Sendable (_ publicKeys: [String]) async throws -> [ContactRecord] = {
+            try await PubkyService.removeContacts(publicKeys: $0)
+        },
         forgetRemovedContacts: @escaping @Sendable (_ publicKeys: [String]) async -> Void = {
             await PrivatePaykitService.shared.removeSavedContacts(publicKeys: $0)
         },
@@ -175,6 +179,7 @@
         self.fetchRemoteProfile = fetchRemoteProfile
         self.saveContactLabel = saveContactLabel
         self.removeContactRecord = removeContactRecord
+        self.removeContactRecords = removeContactRecords
         self.forgetRemovedContacts = forgetRemovedContacts
         self.currentDate = currentDate
     }
@@ -598,11 +603,9 @@
             try await resolveContactProfile(publicKey: prefixedKey, includePlaceholder: true, retryTransient: true)
         }
 
-        let receiverPaths = try await Self.relevantReceiverPaths(for: prefixedKey)
         _ = try await PubkyService.saveContact(
             publicKey: prefixedKey,
             label: profile.name,
-            receiverPaths: receiverPaths,
             restorePrivateConnection: true
         )
 
@@ -614,25 +617,23 @@
         contacts.sort(by: Self.isOrderedByName)
     }
 
-    func refreshContactReceiverPaths(publicKey: String, wallet: WalletViewModel) async {
+    func refreshContactLink(publicKey: String, wallet: WalletViewModel) async {
         guard let prefixedKey = PubkyPublicKeyFormat.normalized(publicKey),
               let contact = contacts.first(where: { PubkyPublicKeyFormat.matches($0.publicKey, prefixedKey) })
         else { return }
 
         do {
-            let receiverPaths = try await Self.relevantReceiverPaths(for: prefixedKey)
-            _ = try await PubkyService.saveContact(publicKey: prefixedKey, label: contact.profile.name, receiverPaths: receiverPaths)
-            await PrivatePaykitService.shared.startInitialLinkBurst(
+            _ = try await PubkyService.saveContact(publicKey: prefixedKey, label: contact.profile.name)
+            await PrivatePaykitService.shared.refreshSavedContactEndpoints(
                 for: [prefixedKey],
                 savedPublicKeys: contacts.map(\.publicKey),
-                wallet: wallet,
-                reason: "contact receiver refresh"
+                wallet: wallet
             )
         } catch is CancellationError {
             return
         } catch {
             Logger.warn(
-                "Failed to refresh contact receiver paths for \(PubkyPublicKeyFormat.redacted(prefixedKey)): \(error)",
+                "Failed to refresh contact link for \(PubkyPublicKeyFormat.redacted(prefixedKey)): \(error)",
                 context: "ContactsManager"
             )
         }
@@ -643,41 +644,33 @@
     /// Remembers the profiles it saves for this session, so the Contacts list shows them at once rather than only their
     /// saved labels. A placeholder for a follow whose lookup failed is not remembered, so that profile is still looked up.
     /// An import outlives its screens, so a reset or another identity's load while it runs, such as after a sign-out,
-    /// stops it quietly: it saves nothing more, adds nothing to the next session's list and reports no error.
+    /// drops its result quietly: it adds nothing to the next session's list and reports no error.
     func importContacts(
         contacts selected: [PubkyContact],
-        saveContact: (String, String) async throws -> Void = { publicKey, label in
-            _ = try await PubkyService.saveContact(publicKey: publicKey, label: label, restorePrivateConnection: true)
+        saveContacts: ([ContactUpdate], String?) async throws -> Void = { updates, expectedIdentity in
+            _ = try await PubkyService.saveContacts(updates: updates, expectedIdentity: expectedIdentity)
         }
     ) async throws {
         let profilesGeneration = resolvedProfilesGeneration
-        var imported: [PubkyContact] = []
+        let expectedIdentity = resolvedProfilesOwner
         var existingKeys = Set(contacts.map(\.publicKey))
-        var firstError: Error?
+        let imported = selected.filter { existingKeys.insert($0.publicKey).inserted }
+        try Task.checkCancellation()
+        guard !imported.isEmpty else { return }
 
-        for contact in selected {
+        do {
+            try await saveContacts(imported.map { ContactUpdate(publicKey: $0.publicKey, label: $0.displayName) }, expectedIdentity)
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch {
             try Task.checkCancellation()
-            guard profilesGeneration == resolvedProfilesGeneration else { break }
-            guard !existingKeys.contains(contact.publicKey) else { continue }
-            do {
-                // The preview already resolved this profile. Receiver discovery runs during contact refresh.
-                try await saveContact(contact.publicKey, contact.displayName)
-                imported.append(contact)
-                existingKeys.insert(contact.publicKey)
-            } catch is CancellationError {
-                throw CancellationError()
-            } catch {
-                firstError = firstError ?? error
-                Logger.warn(
-                    "Failed to save imported contact '\(PubkyPublicKeyFormat.redacted(contact.publicKey))': \(error)",
-                    context: "ContactsManager"
-                )
-            }
+            guard profilesGeneration == resolvedProfilesGeneration else { return }
+            throw error
         }
 
         try Task.checkCancellation()
         guard profilesGeneration == resolvedProfilesGeneration else {
-            Logger.info("Stopped a contact import that a reset overtook after \(imported.count) saves", context: "ContactsManager")
+            Logger.info("Discarded a contact import that a reset overtook", context: "ContactsManager")
             return
         }
         for contact in imported {
@@ -686,9 +679,6 @@
         let currentKeys = Set(contacts.map(\.publicKey))
         contacts = (contacts + imported.filter { !currentKeys.contains($0.publicKey) }).sorted(by: Self.isOrderedByName)
         Logger.info("Imported \(imported.count) new contacts", context: "ContactsManager")
-        if let firstError {
-            throw firstError
-        }
     }
 
     // MARK: - Update Contact
@@ -867,7 +857,7 @@
         stopProfileRefresh()
         stopPendingProfileLookups()
         let contactRecords = contactRecords
-        let removeContactRecord = removeContactRecord
+        let removeContactRecords = removeContactRecords
         let records: [ContactRecord]
         do {
             records = try await Task.detached {
@@ -885,35 +875,17 @@
             return
         }
 
-        var deletedKeys = Set<String>()
-        var firstError: Error?
-
-        for record in records {
-            guard let contactKey = PubkyPublicKeyFormat.normalized(record.publicKey) else { continue }
-            do {
-                try await Task.detached {
-                    try await removeContactRecord(contactKey)
-                }.value
-                deletedKeys.insert(contactKey)
-            } catch {
-                firstError = firstError ?? error
-                Logger.warn("Failed to delete contact '\(PubkyPublicKeyFormat.redacted(contactKey))': \(error)", context: "ContactsManager")
-            }
-        }
-
-        if let firstError {
-            if !deletedKeys.isEmpty {
-                await forgetRemovedContacts(Array(deletedKeys))
-                for publicKey in deletedKeys {
-                    Self.removeContactProfileOverride(publicKey: publicKey)
-                }
-                contacts.removeAll { deletedKeys.contains($0.publicKey) }
-            }
-            throw firstError
+        let keys = records.compactMap { PubkyPublicKeyFormat.normalized($0.publicKey) }
+        let removed = try await Task.detached { try await removeContactRecords(keys) }.value
+        let deletedKeys = Set(removed.compactMap { PubkyPublicKeyFormat.normalized($0.publicKey) })
+        await forgetRemovedContacts(Array(deletedKeys))
+        Self.removeContactProfileOverrides(publicKeys: deletedKeys)
+        contacts.removeAll { deletedKeys.contains($0.publicKey) }
+        guard deletedKeys.isSuperset(of: keys) else {
+            throw PrivatePaykitError.privateUnavailable
         }
 
         // All remote deletes succeeded, so clear any local-only contacts too.
-        await forgetRemovedContacts(Array(deletedKeys))
         Self.clearContactProfileOverrides()
         await PrivatePaykitService.shared.pruneUnsavedContactState(savedPublicKeys: [])
         contacts.removeAll()
@@ -1160,20 +1132,6 @@
         return true
     }
 
-    private nonisolated static func relevantReceiverPaths(for publicKey: String) async throws -> [String] {
-        do {
-            return try await PubkyService.discoverRelevantReceiverPaths(publicKey: publicKey)
-        } catch is CancellationError {
-            throw CancellationError()
-        } catch {
-            Logger.warn(
-                "Failed to discover Paykit receivers for '\(PubkyPublicKeyFormat.redacted(publicKey))': \(error)",
-                context: "ContactsManager"
-            )
-            return [PaykitReceiverPath.wallet]
-        }
-    }
-
     private nonisolated static let contactProfileOverridesKey = "pubkyContactProfileOverrides"
 
     private nonisolated static func isOrderedByName(_ lhs: PubkyContact, _ rhs: PubkyContact) -> Bool {
@@ -1211,9 +1169,12 @@
 
     private nonisolated static func removeContactProfileOverride(publicKey: String) {
         guard let prefixedKey = PubkyPublicKeyFormat.normalized(publicKey) else { return }
-        var overrides = loadContactProfileOverrides()
-        overrides.removeValue(forKey: prefixedKey)
-        saveContactProfileOverrides(overrides)
+        removeContactProfileOverrides(publicKeys: [prefixedKey])
+    }
+
+    private nonisolated static func removeContactProfileOverrides(publicKeys: Set<String>) {
+        guard !publicKeys.isEmpty else { return }
+        saveContactProfileOverrides(loadContactProfileOverrides().filter { !publicKeys.contains($0.key) })
     }
 
     private nonisolated static func clearContactProfileOverrides() {

Bitkit/Managers/HwWalletManager.swift

@@ -1541,10 +1541,11 @@ final class HwWalletManager {
     }
 
     /// Broadcast a signed funding transaction and return its txid. Does not require a connected device.
-    func broadcastFunding(serializedTx: String) async throws -> String {
+    func broadcastFunding(serializedTx: String, paymentDeadline: PaykitPreciseInstant? = nil) async throws -> String {
         try await OnChainHwService.shared.broadcastRawTx(
             serializedTx: serializedTx,
-            electrumUrl: electrumUrlProvider()
+            electrumUrl: electrumUrlProvider(),
+            paymentDeadline: paymentDeadline
         )
     }