fix: complete public Paykit contact payments

Author: ben-kaufman

Bitkit.xcodeproj/project.pbxproj

@@ -911,8 +911,8 @@
 			isa = XCRemoteSwiftPackageReference;
 			repositoryURL = "https://github.com/pubky/paykit-rs";
 			requirement = {
-				kind = revision;
-				revision = cd1253291b1582759d569372d5942b8871527ea1;
+				kind = exactVersion;
+				version = 0.1.0-rc3;
 			};
 		};
 		18D65DFE2EB9649F00252335 /* XCRemoteSwiftPackageReference "vss-rust-client-ffi" */ = {

Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -272,7 +272,7 @@ enum Env {
         case .bitcoin:
             return "/pub/bitkit.to/:rw,/pub/pubky.app/:r,/pub/paykit/v0/:rw"
         default:
-            return "/pub/staging.bitkit.to/:rw,/pub/staging.pubky.app/:r,/pub/staging.paykit/v0/:rw"
+            return "/pub/staging.bitkit.to/:rw,/pub/staging.pubky.app/:r,/pub/paykit/v0/:rw"
         }
     }
 

Bitkit/Constants/Env.swift

@@ -1040,6 +1040,7 @@
 "slashtags__error_deleting_profile" = "Unable To Delete Profile";
 "slashtags__error_pay_title" = "Unable To Pay Contact";
 "slashtags__error_pay_empty_msg" = "The contact you're trying to send to hasn't enabled payments.";
+"slashtags__error_pay_not_opened_msg" = "No compatible payment endpoint is available.";
 "slashtags__auth_depricated_title" = "Deprecated";
 "slashtags__auth_depricated_msg" = "Slashauth is deprecated. Please use Bitkit Beta.";
 "profile__nav_title" = "Profile";

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

@@ -23,12 +23,23 @@ enum PublicPaykitPaymentLaunchResult {
     case opened
     case noEndpoint
     case notOpened
+
+    var contactPaymentFailureMessageKey: String? {
+        switch self {
+        case .opened:
+            nil
+        case .noEndpoint:
+            "slashtags__error_pay_empty_msg"
+        case .notOpened:
+            "slashtags__error_pay_not_opened_msg"
+        }
+    }
 }
 
 enum PublicPaykitService {
     enum MethodId: String, Hashable {
         case bitcoinLightningBolt11 = "btc-lightning-bolt11"
-        case bitcoinLightningLnurl = "btc-lightning-lnurl-pay"
+        case bitcoinLightningLnurl = "btc-lightning-lnurl"
         case bitcoinOnchainP2tr = "btc-bitcoin-p2tr"
         case bitcoinOnchainP2wpkh = "btc-bitcoin-p2wpkh"
         case bitcoinOnchainP2sh = "btc-bitcoin-p2sh"
@@ -50,6 +61,13 @@ enum PublicPaykitService {
             .bitcoinOnchainP2sh,
             .bitcoinOnchainP2pkh,
         ]
+
+        static let onchainPreferenceOrder: [MethodId] = [
+            .bitcoinOnchainP2tr,
+            .bitcoinOnchainP2wpkh,
+            .bitcoinOnchainP2sh,
+            .bitcoinOnchainP2pkh,
+        ]
     }
 
     struct Endpoint: Equatable, Hashable {
@@ -114,7 +132,7 @@ enum PublicPaykitService {
     @MainActor
     static func syncPublishedEndpoints(wallet: WalletViewModel, publish: Bool) async throws {
         guard publish else {
-            await removePublishedEndpoints()
+            try await removePublishedEndpoints()
             return
         }
 
@@ -128,12 +146,36 @@ enum PublicPaykitService {
         try await applyPublishedEndpoints(desiredEndpoints)
     }
 
-    static func removePublishedEndpoints() async {
-        for methodId in MethodId.publishableMethodIds {
-            try? await PubkyService.removePaymentEndpoint(methodId: methodId.rawValue)
+    static func removePublishedEndpoints() async throws {
+        let existingMethodIds = try await currentPublishedMethodIds()
+
+        for methodId in MethodId.publishableMethodIds where existingMethodIds.contains(methodId) {
+            try await PubkyService.removePaymentEndpoint(methodId: methodId.rawValue)
         }
     }
 
+    static func hasPayablePublicEndpoint(publicKey: String) async throws -> Bool {
+        let endpoints = try await payablePublicEndpoints(publicKey: publicKey)
+        return !endpoints.isEmpty
+    }
+
+    static func payablePublicEndpoints(publicKey: String) async throws -> [Endpoint] {
+        let endpoints = try await fetchPublicEndpoints(publicKey: publicKey)
+        return await payableEndpoints(from: endpoints)
+    }
+
+    static func payableEndpoints(from endpoints: [Endpoint]) async -> [Endpoint] {
+        var payableEndpoints: [Endpoint] = []
+
+        for endpoint in endpoints {
+            if await isPayableEndpoint(endpoint) {
+                payableEndpoints.append(endpoint)
+            }
+        }
+
+        return payableEndpoints
+    }
+
     @MainActor
     static func beginPayment(
         to publicKey: String,
@@ -143,28 +185,65 @@ enum PublicPaykitService {
         sheets: SheetViewModel
     ) async throws -> PublicPaykitPaymentLaunchResult {
         let endpoints = try await fetchPublicEndpoints(publicKey: publicKey)
+        let payableEndpoints = await payableEndpoints(from: endpoints)
 
-        guard let preferredEndpoint = await preferredPayableEndpoint(from: endpoints) else {
+        guard !payableEndpoints.isEmpty else {
             return endpoints.isEmpty ? .noEndpoint : .notOpened
         }
 
-        try await app.handleScannedData(preferredEndpoint.paymentRequest)
+        try await app.handleScannedData(paymentRequest(from: payableEndpoints))
 
-        guard PaymentNavigationHelper.appropriateSendRoute(app: app, currency: currency, settings: settings) != nil else {
+        guard let route = contactPaymentRoute(app: app, currency: currency, settings: settings) else {
             return .notOpened
         }
 
         app.contactPaymentContext = ContactPaymentContext(publicKey: publicKey)
-        PaymentNavigationHelper.openPaymentSheet(
-            app: app,
-            currency: currency,
-            settings: settings,
-            sheetViewModel: sheets
-        )
+        sheets.showSheet(.send, data: SendConfig(view: route))
 
         return .opened
     }
 
+    static func paymentRequest(from endpoints: [Endpoint]) -> String {
+        guard let onchainEndpoint = MethodId.onchainPreferenceOrder.compactMap({ methodId in endpoints.first { $0.methodId == methodId } }).first,
+              let bolt11Endpoint = endpoints.first(where: { $0.methodId == .bitcoinLightningBolt11 })
+        else {
+            return endpoints.first?.paymentRequest ?? ""
+        }
+
+        return "bitcoin:\(onchainEndpoint.paymentRequest)?lightning=\(bolt11Endpoint.paymentRequest)"
+    }
+
+    @MainActor
+    private static func contactPaymentRoute(
+        app: AppViewModel,
+        currency: CurrencyViewModel,
+        settings: SettingsViewModel
+    ) -> SendRoute? {
+        guard let route = PaymentNavigationHelper.appropriateSendRoute(app: app, currency: currency, settings: settings) else {
+            return nil
+        }
+
+        switch route {
+        case .quickpay:
+            if app.lnurlPayData != nil {
+                return .lnurlPayAmount
+            }
+
+            if app.scannedLightningInvoice != nil || app.scannedOnchainInvoice != nil {
+                return .amount
+            }
+
+            return route
+        case .confirm:
+            if app.scannedLightningInvoice != nil || app.scannedOnchainInvoice != nil {
+                return .amount
+            }
+            return route
+        default:
+            return route
+        }
+    }
+
     static func onchainMethodId(for address: String) -> MethodId {
         let normalizedAddress = address.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
 
@@ -220,11 +299,22 @@ enum PublicPaykitService {
             )
         }
 
-        for methodId in MethodId.publishableMethodIds where !desiredMethodIds.contains(methodId) {
-            try? await PubkyService.removePaymentEndpoint(methodId: methodId.rawValue)
+        let existingMethodIds = try await currentPublishedMethodIds()
+
+        for methodId in MethodId.publishableMethodIds where existingMethodIds.contains(methodId) && !desiredMethodIds.contains(methodId) {
+            try await PubkyService.removePaymentEndpoint(methodId: methodId.rawValue)
         }
     }
 
+    private static func currentPublishedMethodIds() async throws -> Set<MethodId> {
+        guard let publicKey = await PubkyService.currentPublicKey() else {
+            throw PubkyServiceError.sessionNotActive
+        }
+
+        let paymentEntries = try await PubkyService.getPaymentList(publicKey: publicKey)
+        return Set(paymentEntries.compactMap { MethodId(rawValue: $0.methodId) })
+    }
+
     @MainActor
     private static func buildWalletEndpoints(wallet: WalletViewModel, refreshIfNeeded: Bool) async throws -> [Endpoint] {
         if refreshIfNeeded {
@@ -272,16 +362,6 @@ enum PublicPaykitService {
         return endpoints
     }
 
-    private static func preferredPayableEndpoint(from endpoints: [Endpoint]) async -> Endpoint? {
-        for endpoint in endpoints {
-            if await isPayableEndpoint(endpoint) {
-                return endpoint
-            }
-        }
-
-        return nil
-    }
-
     private static func isPayableEndpoint(_ endpoint: Endpoint) async -> Bool {
         switch endpoint.methodId {
         case .bitcoinLightningBolt11:

Bitkit/Services/PublicPaykitService.swift

@@ -67,6 +67,7 @@ class AppViewModel: ObservableObject {
     /// Payment hashes for which we navigated to the pending screen.
     /// When payment succeeds/fails, we show toast and publish resolution so SendPendingScreen can navigate.
     private var pendingPaymentHashes: Set<String> = []
+    private var pendingContactPaymentContexts: [String: ContactPaymentContext] = [:]
 
     /// When a payment that was shown on the pending screen succeeds or fails, this is set so SendPendingScreen can navigate.
     /// Consumed by SendPendingScreen via consumeSendSheetPendingResolution.
@@ -293,8 +294,20 @@ extension AppViewModel {
 // MARK: Pending payment tracking
 
 extension AppViewModel {
-    func addPendingPaymentHash(_ hash: String) {
+    func addPendingPaymentHash(_ hash: String, contactPublicKey: String? = nil) {
         pendingPaymentHashes.insert(hash)
+
+        if let contactPublicKey {
+            pendingContactPaymentContexts[hash] = ContactPaymentContext(publicKey: contactPublicKey)
+        }
+    }
+
+    func contactPaymentContext(forPendingPaymentHash hash: String) -> ContactPaymentContext? {
+        pendingContactPaymentContexts[hash]
+    }
+
+    func consumeContactPaymentContext(forPendingPaymentHash hash: String) {
+        pendingContactPaymentContexts.removeValue(forKey: hash)
     }
 
     /// Called by SendPendingScreen when it consumes a resolution. Clears the published value.

Bitkit/ViewModels/AppViewModel.swift

@@ -40,7 +40,7 @@ struct AddContactView: View {
             NavigationBar(title: t("contacts__add_title"))
                 .padding(.horizontal, 16)
 
-            if isLoading && fetchedProfile == nil {
+            if isLoading {
                 loadingContent
             } else if let profile = fetchedProfile {
                 resultContent(profile)
@@ -259,8 +259,7 @@ struct AddContactView: View {
 
     private func loadPaymentEndpoints(publicKey: String) async {
         do {
-            let endpoints = try await PublicPaykitService.fetchPublicEndpoints(publicKey: publicKey)
-            hasPublicPaymentEndpoint = !endpoints.isEmpty
+            hasPublicPaymentEndpoint = try await PublicPaykitService.hasPayablePublicEndpoint(publicKey: publicKey)
         } catch {
             Logger.warn("Failed to load public payment endpoints for \(publicKey): \(error)", context: "AddContactView")
             hasPublicPaymentEndpoint = false
@@ -282,12 +281,21 @@ struct AddContactView: View {
                 sheets: sheets
             )
 
-            if case .noEndpoint = result {
+            switch result {
+            case .opened:
+                break
+            case .noEndpoint:
                 app.toast(
                     type: .warning,
                     title: t("slashtags__error_pay_title"),
                     description: t("slashtags__error_pay_empty_msg")
                 )
+            case .notOpened:
+                app.toast(
+                    type: .warning,
+                    title: t("slashtags__error_pay_title"),
+                    description: t("slashtags__error_pay_not_opened_msg")
+                )
             }
         } catch {
             Logger.error("Failed to pay public pubky \(publicKey): \(error)", context: "AddContactView")