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-rc62";
 			};
 		};
 		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/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

@@ -587,11 +587,9 @@ class ContactsManager: ObservableObject {
             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
         )
 
@@ -603,25 +601,23 @@ class ContactsManager: ObservableObject {
         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"
             )
         }
@@ -649,7 +645,7 @@ class ContactsManager: ObservableObject {
             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.
+                // The preview already resolved this profile.
                 try await saveContact(contact.publicKey, contact.displayName)
                 imported.append(contact)
                 existingKeys.insert(contact.publicKey)
@@ -1148,20 +1144,6 @@ class ContactsManager: ObservableObject {
         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 {

Bitkit/Managers/PubkyProfileManager.swift

@@ -1,4 +1,5 @@
 import Foundation
+import enum Paykit.PaykitError
 import struct Paykit.PubkySessionBootstrapResult
 import SwiftUI
 
@@ -1163,11 +1164,8 @@ class PubkyProfileManager: ObservableObject {
         await PrivatePaykitService.shared.closeAndClear()
         await PrivatePaykitAddressReservationStore.shared.clearContactAssignments()
         await PubkyImageCache.shared.clear()
-        UserDefaults.standard.removeObject(forKey: cachedNameKey)
-        UserDefaults.standard.removeObject(forKey: cachedImageUriKey)
-        UserDefaults.standard.removeObject(forKey: cachedProfileOwnerKey)
+        clearCachedIdentityMetadata()
         UserDefaults.standard.removeObject(forKey: profileSetupPendingKey)
-        ContactsManager.restoreContactProfileOverrides(nil)
         clearPublicPaykitSharingState()
         notifyAppStateBackupChanged()
     }
@@ -1193,9 +1191,9 @@ class PubkyProfileManager: ObservableObject {
         }
 
         do {
-            try await PublicPaykitService.syncLocalReceiverMarker(publicSharingEnabled: false, privateSharingEnabled: false)
+            try await PublicPaykitService.syncPaykitApp(privateSharingEnabled: false)
         } catch PubkyServiceError.sessionNotActive {
-            Logger.debug("Skipping Paykit receiver marker cleanup because no session is active", context: context)
+            Logger.debug("Skipping Paykit app capability update because no session is active", context: context)
         } catch {
             firstError = firstError ?? error
         }
@@ -1310,6 +1308,7 @@ class PubkyProfileManager: ObservableObject {
     // MARK: - Cached Profile Metadata
 
     private static let cachedNameKey = "pubky_profile_name"
+    private static let cachedIdentityKey = "pubky_profile_identity"
     private static let cachedImageUriKey = "pubky_profile_image_uri"
     private static let cachedProfileOwnerKey = "pubky_profile_owner"
     private static let profileSetupPendingKey = "pubky_profile_setup_pending"
@@ -1341,10 +1340,20 @@ class PubkyProfileManager: ObservableObject {
         cachedProfileOwner = profile.publicKey
         UserDefaults.standard.set(profile.name, forKey: Self.cachedNameKey)
         UserDefaults.standard.set(profile.imageUrl, forKey: Self.cachedImageUriKey)
+        UserDefaults.standard.set(profile.publicKey, forKey: Self.cachedIdentityKey)
         UserDefaults.standard.set(profile.publicKey, forKey: Self.cachedProfileOwnerKey)
     }
 
+    static func activateCachedIdentity(publicKey: String, previousPublicKey: String?) {
+        let owner = UserDefaults.standard.string(forKey: cachedIdentityKey) ?? previousPublicKey
+        if let owner, !PubkyPublicKeyFormat.matches(owner, publicKey) {
+            clearCachedIdentityMetadata()
+        }
+        UserDefaults.standard.set(publicKey, forKey: cachedIdentityKey)
+    }
+
     static func clearCachedIdentityMetadata() {
+        UserDefaults.standard.removeObject(forKey: cachedIdentityKey)
         UserDefaults.standard.removeObject(forKey: cachedNameKey)
         UserDefaults.standard.removeObject(forKey: cachedImageUriKey)
         UserDefaults.standard.removeObject(forKey: cachedProfileOwnerKey)
@@ -1364,6 +1373,7 @@ class PubkyProfileManager: ObservableObject {
         cachedProfileOwner = nil
         UserDefaults.standard.removeObject(forKey: Self.cachedNameKey)
         UserDefaults.standard.removeObject(forKey: Self.cachedImageUriKey)
+        UserDefaults.standard.removeObject(forKey: Self.cachedIdentityKey)
         UserDefaults.standard.removeObject(forKey: Self.cachedProfileOwnerKey)
     }
 
@@ -1653,6 +1663,15 @@ class PubkyProfileManager: ObservableObject {
                 let publicKey = try await importSession(savedSessionSecret)
                 return .restored(publicKey: publicKey)
             } catch {
+                if let error = error as? PaykitError {
+                    switch error {
+                    case .ConcurrentUpdate, .SharedStateBusy, .Transport:
+                        Logger.warn("Deferred session restoration, keeping saved session", context: "PubkyProfileManager")
+                        return .restorationFailed
+                    default:
+                        break
+                    }
+                }
                 Logger.warn("Failed to import saved session, attempting re-sign-in: \(error)", context: "PubkyProfileManager")
             }
         }

Bitkit/Managers/ScannerManager.swift

@@ -139,7 +139,7 @@ class ScannerManager: ObservableObject {
            let wallet
         {
             Task {
-                await contactsManager.refreshContactReceiverPaths(publicKey: publicKey, wallet: wallet)
+                await contactsManager.refreshContactLink(publicKey: publicKey, wallet: wallet)
             }
         }
         return true

Bitkit/Models/PaykitPaymentStateBackup.swift

@@ -4,25 +4,23 @@ import Paykit
 struct PaykitPaymentStateBackup: Codable {
     let subscriptions: [String: Subscription]
     let pendingProofs: [Proof]
+    var acceptedOneTimeRequests: [String: [RequestID]]? = nil
 
     struct RequestID: Codable {
         let paymentRequestId: String
         let counterparty: String
-        let counterpartyReceiverPath: String
         let billingPeriodStartsAt: String?
 
         init(_ id: PaykitPaymentRequest.ID, billingPeriod: PaykitBillingPeriod?) {
             paymentRequestId = id.paymentRequestId
             counterparty = id.counterparty
-            counterpartyReceiverPath = id.counterpartyReceiverPath
             billingPeriodStartsAt = billingPeriod?.sdkValue.startsAt
         }
 
         func restored(billingPeriod: PaykitBillingPeriod?) -> PaykitPaymentRequest.ID {
             PaykitPaymentRequest.ID(
                 paymentRequestId: paymentRequestId,
                 counterparty: counterparty,
-                counterpartyReceiverPath: counterpartyReceiverPath,
                 billingPeriodStartsAt: billingPeriod?.startsAt
             )
         }
@@ -62,6 +60,7 @@ struct PaykitPaymentStateBackup: Codable {
 
         let identity: String
         let requestId: RequestID
+        let paymentAppId: String
         let paymentEndpointIdentifier: String
         let kind: PaykitPaymentProofKind
         let paymentStarted: Bool
@@ -76,6 +75,7 @@ struct PaykitPaymentStateBackup: Codable {
         init(_ proof: PendingPaykitPaymentProof) {
             identity = proof.identity
             requestId = RequestID(proof.requestId, billingPeriod: proof.billingPeriod)
+            paymentAppId = proof.paymentAppId
             paymentEndpointIdentifier = proof.paymentEndpointIdentifier
             kind = proof.kind
             paymentStarted = proof.paymentStarted
@@ -98,6 +98,7 @@ struct PaykitPaymentStateBackup: Codable {
             return PendingPaykitPaymentProof(
                 identity: identity,
                 requestId: requestId.restored(billingPeriod: period),
+                paymentAppId: paymentAppId,
                 paymentEndpointIdentifier: paymentEndpointIdentifier,
                 kind: kind,
                 billingPeriod: period,

Bitkit/Models/PubkyAuthRequest.swift

@@ -2,24 +2,67 @@ import BitkitCore
 import Foundation
 import Paykit
 
-enum PubkyAuthClaim: String, Equatable {
-    case watchOnlyAccountV1 = "watch-only-account-v1"
+struct PubkyAuthClaim: Equatable {
+    private enum Item: String {
+        case paykitAccessV1 = "paykit-access-v1"
+        case watchOnlyAccountV1 = "watch-only-account-v1"
+    }
+
+    static let watchOnlyAccountV1 = Self(items: [.watchOnlyAccountV1])
+    static let paykitAccessV1 = Self(items: [.paykitAccessV1])
+
+    private let items: [Item]
+
+    private init(items: [Item]) {
+        self.items = items
+    }
+
+    init?(rawValue: String) {
+        let values = rawValue.split(separator: ".", omittingEmptySubsequences: false)
+        let items = values.compactMap { Item(rawValue: String($0)) }
+        guard !items.isEmpty, items.count == values.count, Set(items).count == items.count else { return nil }
+        self.items = items
+    }
+
+    var rawValue: String {
+        // Preserve the requested order because the SDK binds this value into the signature and relay channel.
+        items.map(\.rawValue).joined(separator: ".")
+    }
 
     static let queryParameter = "x-bitkit-claim"
-    static let watchOnlyAccountCapabilities = "/pub/paykit/v0/bitkit/server/:rw,/pub/paykit/v0/private/bitkit/server/:rw"
-    private static let watchOnlyAccountCapabilitySet = Set(watchOnlyAccountCapabilities.split(separator: ",").map(String.init))
+    static let requiredCapabilities = Paykit.requiredSessionCapabilities()
 
-    static func matchesWatchOnlyAccountCapabilities(_ capabilities: String) -> Bool {
-        guard let requestedCapabilitySet = capabilitySet(capabilities) else { return false }
-        return requestedCapabilitySet == watchOnlyAccountCapabilitySet
+    var includesWatchOnlyAccount: Bool {
+        items.contains(.watchOnlyAccountV1)
+    }
+
+    var includesPaykitAccess: Bool {
+        items.contains(.paykitAccessV1)
+    }
+
+    func encode(accountPayload: Data?, paykitKey: PaykitIdentitySecretKey?) throws -> Data {
+        guard includesWatchOnlyAccount == (accountPayload != nil),
+              includesPaykitAccess == (paykitKey != nil)
+        else {
+            throw PubkyAuthRequestError.invalidUrl
+        }
+        if let accountPayload,
+           accountPayload.count != WatchOnlyAccountClaimCodec.payloadLength || accountPayload.first != 1
+        {
+            throw WatchOnlyAccountError.invalidExtendedPublicKey
+        }
+        var payload = accountPayload ?? Data([1])
+        if let paykitKey {
+            payload.append(contentsOf: withUnsafeBytes(of: paykitKey.keyGeneration().bigEndian, Array.init))
+            payload.append(paykitKey.exportBytes())
+        }
+        return payload
     }
 
-    private static func capabilitySet(_ capabilities: String) -> Set<String>? {
-        let entries = capabilities
+    static func matchesRequiredCapabilities(_ capabilities: String) -> Bool {
+        capabilities
             .split(separator: ",", omittingEmptySubsequences: false)
-            .map { $0.trimmingCharacters(in: .whitespaces) }
-        guard !entries.contains(where: \.isEmpty) else { return nil }
-        return Set(entries)
+            .allSatisfy { $0.trimmingCharacters(in: .whitespaces) == requiredCapabilities }
     }
 }
 
@@ -293,15 +336,15 @@ struct PubkyAuthRequest {
             throw PubkyAuthRequestError.duplicateBitkitClaim
         }
         guard let claimValue = claimValues.first else {
-            if requiresBitkitClaim || PubkyAuthClaim.matchesWatchOnlyAccountCapabilities(capabilities) {
+            if requiresBitkitClaim {
                 throw PubkyAuthRequestError.missingBitkitClaim
             }
             return nil
         }
         guard let claim = PubkyAuthClaim(rawValue: claimValue) else {
             throw PubkyAuthRequestError.unsupportedBitkitClaim(claimValue)
         }
-        guard PubkyAuthClaim.matchesWatchOnlyAccountCapabilities(capabilities) else {
+        guard PubkyAuthClaim.matchesRequiredCapabilities(capabilities) else {
             throw PubkyAuthRequestError.invalidBitkitClaimCapabilities
         }
 

Bitkit/Models/PubkyProfile.swift

@@ -134,7 +134,7 @@ struct PubkyProfile {
         self = PubkyProfileData.from(paykitProfile: paykitProfile).toProfile(publicKey: publicKey)
     }
 
-    init(resolution: Paykit.ContactProfileResolution) {
+    init(resolution: Paykit.ProfileResolution) {
         let publicKey = Self.normalizedPublicKey(resolution.publicKey)
         if let paykitProfile = resolution.paykitProfile {
             self.init(publicKey: publicKey, paykitProfile: paykitProfile)

Bitkit/Resources/Localization/en.lproj/Localizable.strings

@@ -711,6 +711,8 @@
 "pubky_auth__watch_only_account_name_error" = "Enter an account name between 1 and 64 characters.";
 "pubky_auth__watch_only_intro_approve" = "Approve";
 "pubky_auth__watch_only_intro_description" = "To earn, you need to share a watch-only Bitcoin account with Paykit. It can view sales activity, but cannot spend funds.";
+"pubky_auth__paykit_access_title" = "PRIVATE PAYKIT ACCESS";
+"pubky_auth__paykit_access_description" = "Read and manage your private Paykit data, and send Paykit messages on your behalf. Your Pubky identity secret and wallet spending keys are not shared.";
 "pubky_auth__watch_only_intro_relay" = "Your authorization will be delivered to <accent>{relay}</accent>.";
 "pubky_auth__watch_only_intro_nav_title" = "Earn";
 "pubky_auth__watch_only_intro_title" = "<accent>EARN BITCOIN</accent>\nFROM YOUR\nCONTENT";