perf: keep request creation ahead of refreshes

app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt

@@ -612,6 +612,7 @@ class PaykitPaymentRequestRepo @Inject constructor(
                             priority,
                             if (forceFresh) priority else messagePriority,
                             observationOnly = true,
+                            combineReceiveObservation = !forceFresh,
                         )
                     }
                     operationMutex.withLock {
@@ -747,6 +748,7 @@ class PaykitPaymentRequestRepo @Inject constructor(
     ): Result<PaykitPaymentRequestCreation> = withContext(ioDispatcher) {
         runSuspendCatching {
             if (!creationMutex.tryLock()) throw PaykitPaymentRequestError.OperationInProgress
+            var endReview: (() -> Unit)? = null
             _isCreatingRequest.update { true }
             try {
                 operationMutex.withLock {
@@ -756,6 +758,7 @@ class PaykitPaymentRequestRepo @Inject constructor(
                     if (draft.amount.atomic == 0uL || !isAvailable()) throw PaykitPaymentRequestError.RequestUnavailable
                     if (draft.expiresAt <= proposalDate) throw PaykitPaymentRequestError.RequestExpired
 
+                    endReview = paykitSdkService.beginPaymentReview()
                     val selectedSavedKey = savedPublicKeys.firstOrNull {
                         PubkyPublicKeyFormat.matches(it, target.publicKey)
                     }
@@ -794,6 +797,7 @@ class PaykitPaymentRequestRepo @Inject constructor(
                     publishCreatedRequest(request, generation, expectedIdentity)
                 }
             } finally {
+                endReview?.invoke()
                 _isCreatingRequest.update { false }
                 creationMutex.unlock()
             }
@@ -1285,8 +1289,21 @@ class PaykitPaymentRequestRepo @Inject constructor(
         priority: Priority = Priority.Ordered,
         messagePriority: Priority = Priority.Ordered,
         observationOnly: Boolean = false,
+        combineReceiveObservation: Boolean = false,
     ): RequestSnapshot {
         if (mode == PaykitPaymentRequestRefreshMode.FULL) processPendingMessages(priority = messagePriority)
+        if (combineReceiveObservation && observationOnly && mode != PaykitPaymentRequestRefreshMode.STORED &&
+            priority == Priority.Background && messagePriority == Priority.Background
+        ) {
+            val observation = paykitSdkService.receiveAndObserveState(
+                requireNotNull(expectedIdentity),
+                ::logIntakeFailures,
+            )
+            return RequestSnapshot(
+                observation.paymentRequests,
+                observation.linkedPeers.filter { it.state == LinkedPeerState.BLOCKED },
+            )
+        }
         if (mode != PaykitPaymentRequestRefreshMode.STORED) {
             paykitSdkService.receivePrivateMessagesFromLinkedPeers(messagePriority).also(::logIntakeFailures)
         }

app/src/main/java/to/bitkit/services/PaykitSdkService.kt

@@ -983,6 +983,50 @@ class PaykitSdkService @Inject constructor(
         }
     }
 
+    internal suspend fun receiveAndObserveState(
+        expectedIdentity: String,
+        onReceive: (List<PrivateStreamCounterpartyIntakeReport>) -> Unit,
+    ): PaykitStateObservation {
+        isSetup.await()
+        val generation = runtimeGeneration
+        return operationLock.withLock(Priority.Background) {
+            check(runtimeGeneration == generation) { "Paykit runtime changed before inbox refresh" }
+            checkRefreshAdmission(Priority.Background)
+            withPaykitKey { handle ->
+                val key = cachedPaykitKey
+                check(key == null || PubkyPublicKeyFormat.matches(key.publicKey, expectedIdentity)) {
+                    "Paykit inbox identity changed"
+                }
+                val reports = withStateRevisionTracking(
+                    handle,
+                    beforeOperation = {
+                        operationLock.withoutLock {
+                            check(runtimeGeneration == generation && sdk === handle && cachedPaykitKey == key) {
+                                "Paykit runtime changed before inbox receive"
+                            }
+                            checkRefreshAdmission(Priority.Background)
+                        }
+                    },
+                ) { completeSdkCall { handle.receivePrivateMessagesFromLinkedPeers() } }
+                onReceive(reports)
+                operationLock.withoutLock {
+                    check(runtimeGeneration == generation && sdk === handle && cachedPaykitKey == key) {
+                        "Paykit runtime changed during inbox refresh"
+                    }
+                    checkRefreshAdmission(Priority.Background)
+                    val observation = completeSdkCall { handle.observeState() }
+                    check(PubkyPublicKeyFormat.matches(observation.publicKey, expectedIdentity)) {
+                        "Paykit observation identity changed"
+                    }
+                    key?.let {
+                        check(observation.keyGeneration == it.generation) { "Paykit observation key changed" }
+                    }
+                    observation
+                }
+            }
+        }
+    }
+
     suspend fun receivePrivateMessages(counterparty: String) = receivePrivateMessages(counterparty, Priority.Ordered)
 
     internal suspend fun receivePrivateMessages(counterparty: String, priority: Priority) = run {
@@ -1771,32 +1815,38 @@ class PaykitSdkService @Inject constructor(
         beforeOperation: suspend () -> Unit = {},
         block: suspend (PaykitSdk) -> T,
     ): T = withPaykitKey { handle ->
-        withPaykitBackupStateTracking(
-            readRevision = {
-                val started = TimeSource.Monotonic.markNow()
-                try {
-                    runSuspendCatching { completeSdkCall { handle.backupStateRevision() } }
-                        .onFailure(::invalidatePaykitKeyIfNeeded)
-                        .getOrThrow()
-                } finally {
-                    if (BuildConfig.DEBUG) {
-                        Logger.debug("Read Paykit backup revision duration='${started.elapsedNow()}'", context = TAG)
-                    }
-                }
-            },
-            readStateRevision = { handle.stateRevision() },
-            readObservedSnapshot = {
-                handle.observedBackupStateRevision()?.let {
-                    PaykitBackupStateSnapshot(it.stateRevision, it.backupRevision)
+        withStateRevisionTracking(handle, beforeOperation) { block(handle) }
+    }
+
+    private suspend fun <T> withStateRevisionTracking(
+        handle: PaykitSdk,
+        beforeOperation: suspend () -> Unit,
+        block: suspend () -> T,
+    ): T = withPaykitBackupStateTracking(
+        readRevision = {
+            val started = TimeSource.Monotonic.markNow()
+            try {
+                runSuspendCatching { completeSdkCall { handle.backupStateRevision() } }
+                    .onFailure(::invalidatePaykitKeyIfNeeded)
+                    .getOrThrow()
+            } finally {
+                if (BuildConfig.DEBUG) {
+                    Logger.debug("Read Paykit backup revision duration='${started.elapsedNow()}'", context = TAG)
                 }
-            },
-            cachedSnapshot = cachedBackupState,
-            onSnapshot = { cachedBackupState = it },
-            onChange = ::notifyBackupStateChanged,
-            beforeOperation = beforeOperation,
-        ) {
-            block(handle)
-        }
+            }
+        },
+        readStateRevision = { handle.stateRevision() },
+        readObservedSnapshot = {
+            handle.observedBackupStateRevision()?.let {
+                PaykitBackupStateSnapshot(it.stateRevision, it.backupRevision)
+            }
+        },
+        cachedSnapshot = cachedBackupState,
+        onSnapshot = { cachedBackupState = it },
+        onChange = ::notifyBackupStateChanged,
+        beforeOperation = beforeOperation,
+    ) {
+        block()
     }
 
     private suspend fun handle(): PaykitSdk = handleMutex.withLock {

app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt

@@ -964,7 +964,11 @@ class AppViewModel @Inject constructor(
             refreshPrivateOnlyPaykitApp("contact sync", onlyIfNeeded = !identityChanged)
             if (!state.contactsLoaded || !synchronizeSavedPaykitContacts(state.contactKeys, isStillCurrent)) return
             if (isPaymentRequestPollingStopped.value) return
-            val result = refreshIncomingPaykitPaymentRequests(forceFresh = true, onlyWhileActive = true)
+            val result = refreshIncomingPaykitPaymentRequests(
+                forceFresh = true,
+                refreshPriority = Priority.Background,
+                onlyWhileActive = true,
+            )
             if (!isPaymentRequestPollingStopped.value) refreshPaymentRequestTargets(force = true)
             result
         } finally {
@@ -1045,7 +1049,11 @@ class AppViewModel @Inject constructor(
             isStillCurrent = isStillCurrent,
         )
         if (isPaymentRequestPollingStopped.value) return
-        refreshIncomingPaykitPaymentRequests(forceFresh = true, onlyWhileActive = true)
+        refreshIncomingPaykitPaymentRequests(
+            forceFresh = true,
+            refreshPriority = Priority.Background,
+            onlyWhileActive = true,
+        )
         if (!isPaymentRequestPollingStopped.value) refreshPaymentRequestTargets(force = true)
     }
 

app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoSubscriptionTest.kt

@@ -21,6 +21,7 @@ import com.synonym.paykit.PaymentRequestRecord
 import com.synonym.paykit.PaymentRequestRecurrence
 import com.synonym.paykit.PaymentRequestTerms
 import com.synonym.paykit.PrivateJsonObject
+import com.synonym.paykit.PrivateStreamCounterpartyIntakeReport
 import com.synonym.paykit.PubkyIdentityCapability
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -53,6 +54,7 @@ import to.bitkit.models.PaykitAmount
 import to.bitkit.models.PaykitAsset
 import to.bitkit.models.PaykitRequestPricing
 import to.bitkit.services.PaykitPaymentRequestProposalTerms
+import to.bitkit.services.PaykitSdkOperationLock.Priority
 import to.bitkit.services.PaykitSdkService
 import to.bitkit.test.BaseUnitTest
 import kotlin.test.assertEquals
@@ -116,6 +118,11 @@ class PaykitPaymentRequestRepoSubscriptionTest : BaseUnitTest(StandardTestDispat
         whenever(paykitSdkService.receivePrivateMessagesFromLinkedPeers(any())).doSuspendableAnswer {
             paykitSdkService.receivePrivateMessagesFromLinkedPeers()
         }
+        whenever(paykitSdkService.receiveAndObserveState(any(), any())).doSuspendableAnswer {
+            val reports = paykitSdkService.receivePrivateMessagesFromLinkedPeers(Priority.Background)
+            it.getArgument<(List<PrivateStreamCounterpartyIntakeReport>) -> Unit>(1)(reports)
+            paykitSdkService.observeState(it.getArgument(0), Priority.Background)
+        }
         stubRequestReads()
         whenever(paykitSdkService.processOutboundPrivateMessages(any(), any())).doSuspendableAnswer {
             paykitSdkService.processOutboundPrivateMessages(it.getArgument(0))