fix: keep Paykit inbox observation together

Bitkit/AppScene.swift

@@ -691,7 +691,7 @@ struct AppScene: View {
                     guard isPaykitSceneActive, pubkyProfile.authState == .authenticated,
                           PubkyPublicKeyFormat.matches(pk, pubkyProfile.publicKey)
                     else { return }
-                    await refreshIncomingPaykitPaymentRequests(forceFresh: true, onlyWhileActive: true)
+                    await refreshIncomingPaykitPaymentRequests(forceFresh: true, refreshPriority: .background, onlyWhileActive: true)
                 }
             }
             .onReceive(PrivatePaykitService.contactLinkCompletedPublisher.receive(on: DispatchQueue.main)) { completion in

Bitkit/Components/ActivityIndicator.swift

@@ -35,8 +35,9 @@ struct ActivityIndicator: View {
                     style: StrokeStyle(lineWidth: 2.5, lineCap: .round)
                 )
                 .frame(width: size, height: size)
-                .rotationEffect(.degrees(isRotating ? 360 : 0))
-                .animation(.linear(duration: 1.2).repeatForever(autoreverses: false), value: isRotating)
+                .animation(.linear(duration: 1.2).repeatForever(autoreverses: false)) { content in
+                    content.rotationEffect(.degrees(isRotating ? 360 : 0))
+                }
         }
         .opacity(opacity)
         .onAppear {

Bitkit/Services/PaykitPaymentRequestService.swift

@@ -614,6 +614,10 @@ enum PaykitPaymentRequestError: LocalizedError, Equatable {
 
 protocol PaykitPaymentRequestSdkHandling: Sendable {
     func observeState(priority: PaykitSdkOperationLock.Priority, expectedIdentity: String?) async throws -> Paykit.PaykitStateObservation
+    func receiveAndObserveState(
+        expectedIdentity: String,
+        onReceive: @Sendable ([Paykit.PrivateStreamCounterpartyIntakeReport]) -> Date
+    ) async throws -> (observation: Paykit.PaykitStateObservation, synchronizationDate: Date)
     func processOutboundPrivateMessages(counterparty: String) async throws -> Paykit.OutboundPrivateSendReport
     func processOutboundPrivateMessages(counterparty: String, priority: PaykitSdkOperationLock.Priority) async throws -> Paykit
         .OutboundPrivateSendReport
@@ -703,17 +707,29 @@ struct PaykitPaymentRequestService {
         mode: PaykitPaymentRequestRefreshMode = .full,
         priority: PaykitSdkOperationLock.Priority = .ordered,
         messagePriority: PaykitSdkOperationLock.Priority = .ordered,
-        expectedIdentity: String? = nil
+        expectedIdentity: String? = nil,
+        combineReceiveObservation: Bool = false
     ) async throws -> PaykitPaymentRequestSnapshot {
         if mode == .full {
             try await processPendingMessages(priority: messagePriority)
         }
-        if mode >= .inbox {
-            let intakeReports = try await sdk.receivePrivateMessagesFromLinkedPeers(priority: messagePriority)
-            logIntakeFailures(intakeReports)
+        let observation: Paykit.PaykitStateObservation
+        let synchronizationDate: Date
+        if combineReceiveObservation, mode >= .inbox, priority == .background, messagePriority == .background, let expectedIdentity {
+            let received = try await sdk.receiveAndObserveState(expectedIdentity: expectedIdentity) { reports in
+                logIntakeFailures(reports)
+                return now()
+            }
+            observation = received.observation
+            synchronizationDate = received.synchronizationDate
+        } else {
+            if mode >= .inbox {
+                let intakeReports = try await sdk.receivePrivateMessagesFromLinkedPeers(priority: messagePriority)
+                logIntakeFailures(intakeReports)
+            }
+            synchronizationDate = now()
+            observation = try await sdk.observeState(priority: priority, expectedIdentity: expectedIdentity)
         }
-        let synchronizationDate = now()
-        let observation = try await sdk.observeState(priority: priority, expectedIdentity: expectedIdentity)
         let sharedRecords = observation.paymentRequests
         let records = sharedRecords.filter(PaykitSdkService.isBitkitPaymentRequest)
         let blockedPeers = observation.linkedPeers.filter { $0.state == .blocked }
@@ -1826,6 +1842,7 @@ final class PaykitPaymentRequestManager {
             mode: mode,
             forceFresh: forceFresh,
             messagePriority: refreshPriority ?? (forceFresh ? .ordered : messagePriority),
+            combineReceiveObservation: !forceFresh,
             canRefresh: canRefresh
         )
     }
@@ -1854,6 +1871,7 @@ final class PaykitPaymentRequestManager {
         mode: PaykitPaymentRequestRefreshMode = .full,
         forceFresh: Bool = false,
         messagePriority: PaykitSdkOperationLock.Priority = .ordered,
+        combineReceiveObservation: Bool = false,
         canRefresh: @escaping @MainActor () -> Bool = { true }
     ) async -> Bool {
         guard canRefresh() else { return false }
@@ -1864,7 +1882,7 @@ final class PaykitPaymentRequestManager {
             if forceFresh || mode > refreshTask.mode {
                 return await refresh(
                     excludingProtectedRequestId: excludingProtectedRequestId, mode: mode,
-                    messagePriority: messagePriority, canRefresh: canRefresh
+                    messagePriority: messagePriority, combineReceiveObservation: combineReceiveObservation, canRefresh: canRefresh
                 )
             }
             return refreshed
@@ -1884,7 +1902,8 @@ final class PaykitPaymentRequestManager {
                 generation: generation,
                 excludingProtectedRequestId: excludingProtectedRequestId,
                 mode: mode,
-                messagePriority: messagePriority
+                messagePriority: messagePriority,
+                combineReceiveObservation: combineReceiveObservation
             )
             guard generation == refreshGeneration else { return false }
             return refreshed
@@ -1963,7 +1982,8 @@ final class PaykitPaymentRequestManager {
                 request,
                 resultingState: .accepted,
                 markApprovedForPayment: true,
-                preservePending: !request.requiresAcceptance
+                preservePending: !request.requiresAcceptance,
+                failureRefreshMode: .stored
             ) {
                 guard $0.billingPeriod != nil || $0.requiresAcceptance || acceptedRequestIds.contains($0.id) else {
                     throw PaykitPaymentRequestError.requestUnavailable
@@ -2531,12 +2551,14 @@ final class PaykitPaymentRequestManager {
         generation: Int,
         excludingProtectedRequestId: PaykitPaymentRequest.ID?,
         mode: PaykitPaymentRequestRefreshMode,
-        messagePriority: PaykitSdkOperationLock.Priority
+        messagePriority: PaykitSdkOperationLock.Priority,
+        combineReceiveObservation: Bool
     ) async -> Bool {
         do {
             guard let activeIdentity else { return false }
             let snapshot = try await service.synchronize(
-                mode: mode, priority: messagePriority, messagePriority: messagePriority, expectedIdentity: activeIdentity
+                mode: mode, priority: messagePriority, messagePriority: messagePriority, expectedIdentity: activeIdentity,
+                combineReceiveObservation: combineReceiveObservation
             )
             guard generation == refreshGeneration, PubkyPublicKeyFormat.matches(self.activeIdentity, activeIdentity) else { return false }
             async let completedProofKinds = completedPaymentProofKinds(activeIdentity)
@@ -2745,6 +2767,7 @@ final class PaykitPaymentRequestManager {
         resultingState: Paykit.PaymentRequestLifecycleState,
         markApprovedForPayment: Bool = false,
         preservePending: Bool = false,
+        failureRefreshMode: PaykitPaymentRequestRefreshMode = .full,
         operation: (PaykitPaymentRequest) async throws -> Void
     ) async throws {
         guard !request.isExpired(at: now()) else {
@@ -2795,7 +2818,7 @@ final class PaykitPaymentRequestManager {
         } catch {
             guard actionGeneration == stateGeneration else { throw error }
             invalidateRefresh()
-            await refresh(excludingProtectedRequestId: request.id, forceFresh: true)
+            await refresh(excludingProtectedRequestId: request.id, mode: failureRefreshMode, forceFresh: true)
             throw error
         }
     }

Bitkit/Services/PubkyService.swift

@@ -1080,6 +1080,48 @@ actor PaykitSdkService {
         }
     }
 
+    func receiveAndObserveState(
+        expectedIdentity: String,
+        onReceive: @Sendable ([PrivateStreamCounterpartyIntakeReport]) -> Date
+    ) async throws -> (observation: Paykit.PaykitStateObservation, synchronizationDate: Date) {
+        let generation = runtimeGeneration
+        let walletGeneration = try operationLock.walletGeneration()
+        let checkAdmission = {
+            try Task.checkCancellation()
+            guard self.runtimeGeneration == generation, try self.operationLock.walletGeneration() == walletGeneration else {
+                throw PubkyServiceError.identityChanged
+            }
+            try await self.checkRefreshAdmission(.background)
+            try Task.checkCancellation()
+            guard self.runtimeGeneration == generation, try self.operationLock.walletGeneration() == walletGeneration else {
+                throw PubkyServiceError.identityChanged
+            }
+        }
+        return try await withSdk(priority: .background, beforeOperation: checkAdmission) { sdk in
+            let key = self.cachedPaykitKey
+            if let key {
+                guard PubkyPublicKeyFormat.matches(key.publicKey, expectedIdentity) else { throw PubkyServiceError.identityChanged }
+            }
+            let reports = try await self.withStateRevisionTracking(sdk: sdk, beforeOperation: checkAdmission) {
+                try await sdk.receivePrivateMessagesFromLinkedPeers()
+            }
+            let synchronizationDate = onReceive(reports)
+            return try await self.operationLock.withoutLock {
+                try await checkAdmission()
+                guard self.sdk === sdk, self.cachedPaykitKey?.publicKey == key?.publicKey,
+                      self.cachedPaykitKey?.generation == key?.generation
+                else { throw PubkyServiceError.identityChanged }
+                try Task.checkCancellation()
+                let observation = try await sdk.observeState()
+                try Task.checkCancellation()
+                guard PubkyPublicKeyFormat.matches(observation.publicKey, expectedIdentity),
+                      key == nil || observation.keyGeneration == key?.generation
+                else { throw PubkyServiceError.identityChanged }
+                return (observation, synchronizationDate)
+            }
+        }
+    }
+
     @discardableResult
     func receivePrivateMessages(counterparty: String) async throws -> PrivateStreamIntakeReport {
         try await receivePrivateMessages(counterparty: counterparty, priority: .ordered)
@@ -1685,39 +1727,47 @@ actor PaykitSdkService {
         try await withSdk(
             priority: priority, deferDuringPayment: deferDuringPayment, operationName: operationName, beforeOperation: beforeOperation
         ) { sdk in
-            return try await Self.withBackupStateRevisionTracking(
-                readRevision: {
-                    #if DEBUG
-                        let clock = ContinuousClock()
-                        let started = clock.now
-                        defer {
-                            Logger.debug("Read Paykit backup revision duration=\(started.duration(to: clock.now))", context: "PaykitSdkService")
-                        }
-                    #endif
-                    return try await self.withSdkErrorHandling { try await sdk.backupStateRevision() }
-                },
-                readStateRevision: { try sdk.stateRevision() },
-                readObservedSnapshot: {
-                    try sdk.observedBackupStateRevision().map {
-                        BackupStateSnapshot(stateRevision: $0.stateRevision, backupRevision: $0.backupRevision)
-                    }
-                },
-                cachedSnapshot: self.cachedBackupState,
-                onSnapshot: { self.cachedBackupState = $0 },
-                onChange: { self.markWalletBackupDataChanged() },
-                beforeOperation: {
-                    try await beforeOperation()
-                    if deferDuringPayment {
-                        guard await !PaykitPaymentActivity.shared.isActive else { throw OperationDeferral.paymentActive }
-                        try Task.checkCancellation()
-                    }
-                    try await admit()
-                },
-                operation: { try await operation(sdk) }
-            )
+            try await self.withStateRevisionTracking(sdk: sdk, beforeOperation: {
+                try await beforeOperation()
+                if deferDuringPayment {
+                    guard await !PaykitPaymentActivity.shared.isActive else { throw OperationDeferral.paymentActive }
+                    try Task.checkCancellation()
+                }
+                try await admit()
+            }) { try await operation(sdk) }
         }
     }
 
+    private func withStateRevisionTracking<T>(
+        sdk: PaykitSdk,
+        beforeOperation: () async throws -> Void,
+        _ operation: () async throws -> T
+    ) async throws -> T {
+        return try await Self.withBackupStateRevisionTracking(
+            readRevision: {
+                #if DEBUG
+                    let clock = ContinuousClock()
+                    let started = clock.now
+                    defer {
+                        Logger.debug("Read Paykit backup revision duration=\(started.duration(to: clock.now))", context: "PaykitSdkService")
+                    }
+                #endif
+                return try await self.withSdkErrorHandling { try await sdk.backupStateRevision() }
+            },
+            readStateRevision: { try sdk.stateRevision() },
+            readObservedSnapshot: {
+                try sdk.observedBackupStateRevision().map {
+                    BackupStateSnapshot(stateRevision: $0.stateRevision, backupRevision: $0.backupRevision)
+                }
+            },
+            cachedSnapshot: cachedBackupState,
+            onSnapshot: { self.cachedBackupState = $0 },
+            onChange: { self.markWalletBackupDataChanged() },
+            beforeOperation: beforeOperation,
+            operation: operation
+        )
+    }
+
     static func withBackupStateRevisionTracking<T>(
         readRevision: () async throws -> String,
         readStateRevision: () throws -> String? = { nil },

Bitkit/Views/Wallets/Send/SendConfirmationView.swift

@@ -382,7 +382,8 @@ struct SendConfirmationView: View {
                     hasStartedAutomaticPayment: hasStartedAutomaticPayment,
                     isFeeRateMissing: isFeeRateMissing,
                     feeRateLoadFailed: wallet.feeRateLoadFailed,
-                    isPreparingRequest: preparingRequest != nil
+                    isPreparingRequest: preparingRequest != nil,
+                    isSubmittingPayment: isSubmittingPayment
                 ),
                 isSubmitted: hasStartedAutomaticPayment,
                 swipeProgress: $swipeProgress
@@ -806,6 +807,7 @@ struct SendConfirmationView: View {
     }
 
     private func submitPayment(isAutomatic: Bool = false) async throws {
+        guard !isSubmittingPayment else { return }
         guard preparingRequest == nil, walletSwitchContext == nil else { throw CancellationError() }
         if isAutomatic, isFeeRateMissing {
             guard !Self.automaticPaymentAwaitsFeeRate(isFeeRateMissing: isFeeRateMissing, feeRateLoadFailed: wallet.feeRateLoadFailed) else {
@@ -1012,9 +1014,10 @@ struct SendConfirmationView: View {
         hasStartedAutomaticPayment: Bool,
         isFeeRateMissing: Bool,
         feeRateLoadFailed: Bool,
-        isPreparingRequest: Bool = false
+        isPreparingRequest: Bool = false,
+        isSubmittingPayment: Bool = false
     ) -> Bool {
-        isPreparingRequest || hasStartedAutomaticPayment || (isFeeRateMissing && !feeRateLoadFailed)
+        isSubmittingPayment || isPreparingRequest || hasStartedAutomaticPayment || (isFeeRateMissing && !feeRateLoadFailed)
     }
 
     private func openManualCoinSelection() async throws {