feat(kotlin-sdk): send, receive and accept DashPay private contact requests

packages/kotlin-sdk/KotlinExampleApp/app/src/main/java/org/dashfoundation/example/di/AppContainer.kt

@@ -154,6 +154,22 @@ class AppContainer(private val context: Context) {
             loadWallets = {
                 val activatedManager = walletManagerStore.activate(sdk.network, sdk)
                 activatedManager.loadPersistedWallets()
+                // Open the shielded store right after the load: Rust then
+                // restores, with no keys, the unconfirmed private contact
+                // request payments of every wallet that bound a shielded
+                // account in an earlier process. Until it does, their public
+                // contact requests are refused (code 71), and a later bind
+                // may never come (no mnemonic, declined biometric). The same
+                // path the bind opens, so the bind's call is a no-op.
+                if (shieldedService.isAvailable) {
+                    try {
+                        activatedManager.configureShielded(shieldedDbPath(activatedManager.network))
+                    } catch (e: kotlinx.coroutines.CancellationException) {
+                        throw e
+                    } catch (e: Exception) {
+                        android.util.Log.w(TAG, "Failed to configure the shielded store after the load", e)
+                    }
+                }
                 org.dashfoundation.example.ui.dashpay.DashPayWalletLoad(
                     value = activatedManager,
                     loadedWalletIdsHex = activatedManager.wallets.value.keys,
@@ -207,6 +223,10 @@ class AppContainer(private val context: Context) {
      * `bindShielded` and the start-if-not-running guards make repeated calls
      * (on every wallet-set change) safe.
      */
+    /** The per-network commitment-tree store, as iOS `ShieldedService.dbPath(for:)` names it. */
+    private fun shieldedDbPath(network: org.dashfoundation.dashsdk.Network): String =
+        java.io.File(context.filesDir, "shielded_tree_${network.networkName}.sqlite").absolutePath
+
     private suspend fun rebindWalletScopedServices(
         manager: org.dashfoundation.dashsdk.wallet.PlatformWalletManager,
     ) {
@@ -243,10 +263,7 @@ class AppContainer(private val context: Context) {
                 // and doesn't throw. dbPath mirrors iOS's
                 // `ShieldedService.dbPath(for:)` naming
                 // (`shielded_tree_<networkName>.sqlite`), rooted in filesDir.
-                val shieldedDbPath = java.io.File(
-                    context.filesDir,
-                    "shielded_tree_${manager.network.networkName}.sqlite",
-                ).absolutePath
+                val shieldedDbPath = shieldedDbPath(manager.network)
                 shieldedService.bind(
                     manager = manager,
                     walletId = wallet.walletId,

packages/kotlin-sdk/KotlinExampleApp/app/src/main/java/org/dashfoundation/example/ui/dashpay/AddContactScreen.kt

@@ -98,6 +98,18 @@ fun AddContactScreen(identityIdHex: String, navController: NavHostController) {
     var accountLabel by remember { mutableStateOf("") }
     var isSending by remember { mutableStateOf(false) }
     var errorMessage by remember { mutableStateOf<String?>(null) }
+    // Set when an accept's private reply may have gone through (its result
+    // could not be confirmed): the screen only offers to close, never to
+    // submit again, as the send screen does for an unconfirmed spend.
+    var unconfirmedNotice by remember { mutableStateOf<String?>(null) }
+    // Whether the wallet has a private request to the resolved recipient in
+    // flight, or paid and not yet read back (`privateRepliesPending`). While
+    // it does, Send and the collision accept are off and the screen offers a
+    // private sync, which settles it. Read from the wallet, so reopening this
+    // screen keeps it. A failed read keeps them off until a read succeeds.
+    var recipientPending by remember { mutableStateOf(PrivateRepliesPendingSnapshot()) }
+    var isSyncingPrivate by remember { mutableStateOf(false) }
+    var pendingReadVersion by remember { mutableStateOf(0) }
     var collisionRecipient by remember { mutableStateOf<ByteArray?>(null) }
     var previewProfile by remember { mutableStateOf<DashPayProfile?>(null) }
 
@@ -107,7 +119,14 @@ fun AddContactScreen(identityIdHex: String, navController: NavHostController) {
         AddMode.IDENTITY_ID -> parsedIdentityId
     }
     val recipientIsSelf = resolvedRecipient?.contentEquals(idBytes) == true
-    val canSend = resolvedRecipient != null && !recipientIsSelf && !isSending
+    val canSend = resolvedRecipient != null && !recipientIsSelf && !isSending &&
+        unconfirmedNotice == null && recipientPending.allowsSubmission(resolvedRecipient.toHex())
+    val recipientBlocked = resolvedRecipient != null &&
+        (
+            recipientPending.isRestoringPrivatePayments ||
+                recipientPending.isPending(resolvedRecipient.toHex()) ||
+                recipientPending.isUnavailable
+            )
 
     // Scan-to-send: consume the QR string handed back by the scanner screen
     // (the house pattern — observe the saved-state flow, then null it out).
@@ -168,6 +187,18 @@ fun AddContactScreen(identityIdHex: String, navController: NavHostController) {
     // Cache-only profile for the preview card (local read; most unknown
     // identities won't have one).
     val recipientHex = resolvedRecipient?.toHex()
+    LaunchedEffect(recipientHex, wallet, pendingReadVersion) {
+        val contactIds = listOfNotNull(resolvedRecipient)
+        recipientPending = recipientPending.recorded(
+            privateRepliesPending(wallet, idBytes, contactIds),
+            contactIds.map { it.toHex() },
+        ).withReadiness(privateContactReadiness(wallet, idBytes))
+    }
+    // Binding the shielded account restores the wallet's private payments:
+    // read the readiness again then.
+    LaunchedEffect(container.shieldedService) {
+        container.shieldedService.isBound.collect { pendingReadVersion++ }
+    }
     LaunchedEffect(recipientHex) {
         val recipient = resolvedRecipient
         val w = wallet
@@ -204,25 +235,62 @@ fun AddContactScreen(identityIdHex: String, navController: NavHostController) {
                 kickDashPaySync(scope, m)
                 navController.popBackStack()
             } catch (e: Exception) {
-                errorMessage = e.message ?: "Send failed"
+                when (val outcome = ContactRequestSubmissionOutcome.of(e)) {
+                    // Nothing was sent, and the wallet may hold nothing for
+                    // it: the screen shows it as pending and offers the
+                    // private sync that settles it.
+                    ContactRequestSubmissionOutcome.PrivateRequestPending ->
+                        recipientPending = recipientPending.withRefusal(recipient.toHex())
+                    // Nothing was sent: the screen shows the wallet restoring
+                    // its private payments until its readiness says restored.
+                    ContactRequestSubmissionOutcome.PrivatePaymentsNotRestored ->
+                        recipientPending = recipientPending.withRestoringRefusal()
+                    ContactRequestSubmissionOutcome.MayHaveGoneThrough -> {
+                        kickDashPaySync(scope, m)
+                        unconfirmedNotice = ContactRequestSubmissionOutcome.MAY_HAVE_GONE_THROUGH_MESSAGE
+                    }
+                    is ContactRequestSubmissionOutcome.Failed -> errorMessage = outcome.message
+                }
             } finally {
                 isSending = false
+                pendingReadVersion++
+            }
+        }
+    }
+
+    /**
+     * Read the private store, which settles a pending private request, then
+     * re-read the recipient's pending state: Send comes back once nothing is
+     * pending, for the user to try again.
+     */
+    fun syncPrivateRequests() {
+        val w = wallet ?: return
+        val m = manager ?: return
+        isSyncingPrivate = true
+        scope.launch {
+            try {
+                syncPrivateContactRequests(w, m)?.let { errorMessage = it }
+            } finally {
+                isSyncingPrivate = false
+                pendingReadVersion++
             }
         }
     }
 
     fun acceptIncoming(recipient: ByteArray) {
         val w = wallet ?: return
         val m = manager ?: return
+        // A private reply to this contact may be pending in the wallet.
+        if (!recipientPending.allowsSubmission(recipient.toHex())) return
         isSending = true
         errorMessage = null
         scope.launch {
             try {
-                val ok = w.dashpay.acceptIncomingRequest(
+                val ok = acceptIncomingContactRequest(
+                    wallet = w,
+                    manager = m,
                     ourIdentityId = idBytes,
                     senderId = recipient,
-                    signerHandle = m.signerHandle,
-                    coreSignerHandle = m.mnemonicResolverHandle,
                 )
                 if (ok) {
                     kickDashPaySync(scope, m)
@@ -232,9 +300,23 @@ fun AddContactScreen(identityIdHex: String, navController: NavHostController) {
                         "accept it from Requests."
                 }
             } catch (e: Exception) {
-                errorMessage = "Accept failed: ${e.message ?: "unknown error"}"
+                when (val outcome = ContactRequestSubmissionOutcome.of(e)) {
+                    ContactRequestSubmissionOutcome.MayHaveGoneThrough -> {
+                        // Pending, not failed: the next sync settles it.
+                        kickDashPaySync(scope, m)
+                        unconfirmedNotice = ContactRequestSubmissionOutcome.MAY_HAVE_GONE_THROUGH_MESSAGE
+                    }
+                    // Nothing was sent: the screen offers the private sync.
+                    ContactRequestSubmissionOutcome.PrivateRequestPending ->
+                        recipientPending = recipientPending.withRefusal(recipient.toHex())
+                    ContactRequestSubmissionOutcome.PrivatePaymentsNotRestored ->
+                        recipientPending = recipientPending.withRestoringRefusal()
+                    is ContactRequestSubmissionOutcome.Failed ->
+                        errorMessage = "Accept failed: ${outcome.message}"
+                }
             } finally {
                 isSending = false
+                pendingReadVersion++
             }
         }
     }
@@ -334,6 +416,27 @@ fun AddContactScreen(identityIdHex: String, navController: NavHostController) {
                     enabled = canSend,
                     modifier = Modifier.fillMaxWidth().testTag("dashpay.addContact.send"),
                 ) { attemptSend() }
+                if (recipientBlocked) {
+                    Text(
+                        ContactRequestSubmissionOutcome.rowMessage(
+                            pending = recipientPending.isPending(recipient.toHex()),
+                            restoring = recipientPending.isRestoringPrivatePayments,
+                            unavailable = recipientPending.isUnavailable,
+                            error = null,
+                        ).orEmpty(),
+                        style = MaterialTheme.typography.bodySmall,
+                        modifier = Modifier.testTag("dashpay.addContact.pending"),
+                    )
+                    // A private sync settles a pending request; it does not
+                    // restore private payments, so it is not offered for that.
+                    if (!recipientPending.isRestoringPrivatePayments) {
+                        TextButton(
+                            onClick = { syncPrivateRequests() },
+                            enabled = !isSyncingPrivate,
+                            modifier = Modifier.testTag("dashpay.addContact.syncPrivate"),
+                        ) { Text(if (isSyncingPrivate) "Syncing private requests…" else "Sync private requests") }
+                    }
+                }
             }
 
             if (errorMessage != null) {
@@ -366,6 +469,17 @@ fun AddContactScreen(identityIdHex: String, navController: NavHostController) {
             },
         )
     }
+
+    unconfirmedNotice?.let { notice ->
+        AlertDialog(
+            onDismissRequest = { navController.popBackStack() },
+            title = { Text("Submitted") },
+            text = { Text(notice) },
+            confirmButton = {
+                TextButton(onClick = { navController.popBackStack() }) { Text("Done") }
+            },
+        )
+    }
 }
 
 @Composable