Implement CSPP phase 1 items

CLAUDE.md

@@ -0,0 +1 @@
+ARCHITECTURE.md

android/app/build.gradle.kts

@@ -1,6 +1,5 @@
 plugins {
     id("com.android.application")
-    id("org.jetbrains.kotlin.android")
     id("org.jetbrains.kotlin.plugin.compose")
     id("org.jlleitschuh.gradle.ktlint")
 }
@@ -72,9 +71,6 @@ android {
         buildConfig = true
         compose = true
     }
-    composeOptions {
-        kotlinCompilerExtensionVersion = "1.4.3"
-    }
     packaging {
         resources {
             excludes += "/META-INF/{AL2.0,LGPL2.1}"
@@ -85,9 +81,9 @@ android {
 dependencies {
 
     implementation("androidx.core:core-ktx:1.17.0")
-    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.9.3")
-    implementation("androidx.activity:activity-compose:1.12.0")
-    implementation(platform("androidx.compose:compose-bom:2025.08.01"))
+    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.10.0")
+    implementation("androidx.activity:activity-compose:1.12.4")
+    implementation(platform("androidx.compose:compose-bom:2025.12.01"))
     implementation("androidx.compose.ui:ui")
     implementation("androidx.compose.ui:ui-graphics")
     implementation("androidx.compose.ui:ui-tooling-preview")
@@ -96,37 +92,37 @@ dependencies {
     testImplementation("junit:junit:4.13.2")
     androidTestImplementation("androidx.test.ext:junit:1.3.0")
     androidTestImplementation("androidx.test.espresso:espresso-core:3.7.0")
-    androidTestImplementation(platform("androidx.compose:compose-bom:2025.08.01"))
+    androidTestImplementation(platform("androidx.compose:compose-bom:2025.12.01"))
     androidTestImplementation("androidx.compose.ui:ui-test-junit4")
     debugImplementation("androidx.compose.ui:ui-tooling")
     debugImplementation("androidx.compose.ui:ui-test-manifest")
 
     // Uniffi
-    implementation("net.java.dev.jna:jna:5.17.0@aar")
+    implementation("net.java.dev.jna:jna:5.18.1@aar")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2")
 
     // Jetpack compose / flow
-    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.9.3")
-    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.9.3")
-    implementation("androidx.compose.runtime:runtime-livedata:1.9.0")
+    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.10.0")
+    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.10.0")
+    implementation("androidx.compose.runtime:runtime-livedata:1.10.1")
     // lifecycle process for app-level lifecycle observation
-    implementation("androidx.lifecycle:lifecycle-process:2.9.3")
+    implementation("androidx.lifecycle:lifecycle-process:2.10.0")
 
     implementation("androidx.biometric:biometric-ktx:1.4.0-alpha02")
-    implementation("androidx.security:security-crypto:1.1.0-alpha06")
+    implementation("androidx.security:security-crypto:1.1.0")
 
     // Camera and QR scanning
     implementation("androidx.camera:camera-camera2:1.5.1")
     implementation("androidx.camera:camera-lifecycle:1.5.1")
     implementation("androidx.camera:camera-view:1.5.1")
-    implementation("com.google.accompanist:accompanist-permissions:0.34.0")
-    implementation("com.google.android.gms:play-services-mlkit-barcode-scanning:18.3.0")
-    implementation("com.google.zxing:core:3.5.3")
+    implementation("com.google.accompanist:accompanist-permissions:0.37.3")
+    implementation("com.google.android.gms:play-services-mlkit-barcode-scanning:18.3.1")
+    implementation("com.google.zxing:core:3.5.4")
 
     // Coil for image loading (including SVG support)
-    implementation("io.coil-kt.coil3:coil-compose:3.0.4")
-    implementation("io.coil-kt.coil3:coil-svg:3.0.4")
+    implementation("io.coil-kt.coil3:coil-compose:3.3.0")
+    implementation("io.coil-kt.coil3:coil-svg:3.3.0")
 
     // Navigation 3 for idiomatic Android navigation
     implementation("androidx.navigation3:navigation3-runtime:1.0.0")

android/app/src/main/java/org/bitcoinppl/cove/AppManager.kt

@@ -160,6 +160,15 @@ class AppManager private constructor() : FfiReconcile {
         return manager
     }
 
+    fun clearWalletManager() {
+        try {
+            walletManager?.close()
+        } catch (e: Exception) {
+            Log.w(tag, "Error closing WalletManager: ${e.message}")
+        }
+        walletManager = null
+    }
+
     fun clearSendFlowManager() {
         try {
             sendFlowManager?.close()
@@ -383,6 +392,7 @@ class AppManager private constructor() : FfiReconcile {
             Log.d(tag, "Invalid word group detected")
             alertState = TaggedItem(AppAlertState.InvalidWordGroup)
         } catch (e: ImportWalletException.WalletAlreadyExists) {
+            Log.w(tag, "Attempted to import words for an existing hot wallet: ${e.v1}")
             alertState = TaggedItem(AppAlertState.DuplicateWallet(e.v1))
             try {
                 rust.selectWallet(e.v1)
@@ -410,7 +420,20 @@ class AppManager private constructor() : FfiReconcile {
                 val id = wallet.id()
                 Log.d(tag, "Imported Wallet: $id")
                 alertState = TaggedItem(AppAlertState.ImportedSuccessfully)
-                rust.selectWallet(id)
+
+                // if we're not already on this wallet, navigate to it
+                if (walletManager?.id != id) {
+                    rust.selectWallet(id)
+                }
+
+                // upgrade watch-only → cold in-place
+                if (walletManager?.id == id && walletManager?.walletMetadata?.walletType != WalletType.HOT) {
+                    try {
+                        walletManager?.rust?.setWalletType(WalletType.COLD)
+                    } catch (e: Exception) {
+                        Log.e(tag, "Failed to set wallet type to cold", e)
+                    }
+                }
             } finally {
                 wallet.close()
             }
@@ -606,6 +629,12 @@ class AppManager private constructor() : FfiReconcile {
                     wallets = runCatching { database.wallets().all() }.getOrElse { emptyList() }
                 }
 
+                is AppStateReconcileMessage.ClearCachedWalletManager -> {
+                    if (walletManager?.id == message.v1) {
+                        clearWalletManager()
+                    }
+                }
+
                 is AppStateReconcileMessage.ShowLoadingPopup -> {
                     alertState = TaggedItem(AppAlertState.Loading)
                 }

android/app/src/main/java/org/bitcoinppl/cove/MainActivity.kt

@@ -77,11 +77,17 @@ import org.bitcoinppl.cove_core.AfterPinAction
 import org.bitcoinppl.cove_core.AlertDisplayType
 import org.bitcoinppl.cove_core.AppAction
 import org.bitcoinppl.cove_core.AppAlertState
+import org.bitcoinppl.cove_core.ColdWalletRoute
 import org.bitcoinppl.cove_core.Database
+import org.bitcoinppl.cove_core.HotWalletRoute
+import org.bitcoinppl.cove_core.ImportType
 import org.bitcoinppl.cove_core.NewWalletRoute
+import org.bitcoinppl.cove_core.NumberOfBip39Words
 import org.bitcoinppl.cove_core.Route
 import org.bitcoinppl.cove_core.RouteFactory
 import org.bitcoinppl.cove_core.TapSignerRoute
+import org.bitcoinppl.cove_core.Wallet
+import org.bitcoinppl.cove_core.WalletType
 import org.bitcoinppl.cove_core.types.ColorSchemeSelection
 
 class MainActivity : FragmentActivity() {
@@ -411,6 +417,57 @@ private fun GlobalAlertDialog(
             )
         }
 
+        is AppAlertState.HotWalletKeyMissing -> {
+            val walletId = state.walletId
+            AlertDialog(
+                onDismissRequest = onDismiss,
+                title = { Text(state.title()) },
+                text = { Text(state.message()) },
+                confirmButton = {
+                    Column(horizontalAlignment = Alignment.End) {
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.pushRoute(Route.NewWallet(NewWalletRoute.HotWallet(HotWalletRoute.Import(NumberOfBip39Words.TWELVE, ImportType.MANUAL))))
+                        }) { Text("Import 12 Words") }
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.pushRoute(Route.NewWallet(NewWalletRoute.HotWallet(HotWalletRoute.Import(NumberOfBip39Words.TWENTY_FOUR, ImportType.MANUAL))))
+                        }) { Text("Import 24 Words") }
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.alertState = TaggedItem(AppAlertState.ConfirmWatchOnly)
+                        }) { Text("Use as Watch Only") }
+                        TextButton(onClick = {
+                            onDismiss()
+                            try {
+                                app.getWalletManager(walletId).rust.setWalletType(WalletType.COLD)
+                            } catch (e: Exception) {
+                                Log.e("GlobalAlert", "Failed to set wallet type to cold", e)
+                                app.alertState =
+                                    TaggedItem(
+                                        AppAlertState.General(
+                                            title = "Error",
+                                            message = e.message ?: "Failed to convert wallet",
+                                        ),
+                                    )
+                            }
+                        }) { Text("Use with Hardware Wallet") }
+                    }
+                },
+            )
+        }
+
+        is AppAlertState.ConfirmWatchOnly -> {
+            AlertDialog(
+                onDismissRequest = onDismiss,
+                title = { Text(state.title()) },
+                text = { Text(state.message()) },
+                confirmButton = {
+                    TextButton(onClick = onDismiss) { Text("I Understand") }
+                },
+            )
+        }
+
         is AppAlertState.NoCameraPermission -> {
             val context = LocalContext.current
             AlertDialog(
@@ -649,6 +706,99 @@ private fun GlobalAlertDialog(
             )
         }
 
+        is AppAlertState.CantSendOnWatchOnlyWallet -> {
+            AlertDialog(
+                onDismissRequest = onDismiss,
+                title = { Text(state.title()) },
+                text = { Text(state.message()) },
+                confirmButton = {
+                    Column(horizontalAlignment = Alignment.End) {
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.alertState = TaggedItem(AppAlertState.WatchOnlyImportHardware)
+                        }) { Text("Import Hardware Wallet") }
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.alertState = TaggedItem(AppAlertState.WatchOnlyImportWords)
+                        }) { Text("Import Words") }
+                        TextButton(onClick = onDismiss) { Text("Cancel") }
+                    }
+                },
+            )
+        }
+
+        is AppAlertState.WatchOnlyImportHardware -> {
+            AlertDialog(
+                onDismissRequest = onDismiss,
+                title = { Text(state.title()) },
+                text = { Text(state.message()) },
+                confirmButton = {
+                    Column(horizontalAlignment = Alignment.End) {
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.pushRoute(Route.NewWallet(NewWalletRoute.ColdWallet(ColdWalletRoute.QR_CODE)))
+                        }) { Text("QR Code") }
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.scanNfc()
+                        }) { Text("NFC") }
+                        TextButton(onClick = {
+                            onDismiss()
+                            val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+                            val text =
+                                clipboard.primaryClip
+                                    ?.getItemAt(0)
+                                    ?.text
+                                    ?.toString()
+                            if (!text.isNullOrBlank()) {
+                                try {
+                                    val wallet = Wallet.newFromXpub(xpub = text.trim())
+                                    val id = wallet.id()
+                                    app.rust.selectWallet(id)
+                                    app.resetRoute(Route.SelectedWallet(id))
+                                } catch (e: Exception) {
+                                    app.alertState =
+                                        TaggedItem(
+                                            AppAlertState.ErrorImportingHardwareWallet(e.message ?: "Unknown error"),
+                                        )
+                                }
+                            }
+                        }) { Text("Paste") }
+                        TextButton(onClick = onDismiss) { Text("Cancel") }
+                    }
+                },
+            )
+        }
+
+        is AppAlertState.WatchOnlyImportWords -> {
+            AlertDialog(
+                onDismissRequest = onDismiss,
+                title = { Text(state.title()) },
+                text = { Text(state.message()) },
+                confirmButton = {
+                    Column(horizontalAlignment = Alignment.End) {
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.pushRoute(Route.NewWallet(NewWalletRoute.HotWallet(HotWalletRoute.Import(NumberOfBip39Words.TWENTY_FOUR, ImportType.QR))))
+                        }) { Text("Scan QR") }
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.pushRoute(Route.NewWallet(NewWalletRoute.HotWallet(HotWalletRoute.Import(NumberOfBip39Words.TWENTY_FOUR, ImportType.NFC))))
+                        }) { Text("NFC") }
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.pushRoute(Route.NewWallet(NewWalletRoute.HotWallet(HotWalletRoute.Import(NumberOfBip39Words.TWELVE, ImportType.MANUAL))))
+                        }) { Text("12 Words") }
+                        TextButton(onClick = {
+                            onDismiss()
+                            app.pushRoute(Route.NewWallet(NewWalletRoute.HotWallet(HotWalletRoute.Import(NumberOfBip39Words.TWENTY_FOUR, ImportType.MANUAL))))
+                        }) { Text("24 Words") }
+                        TextButton(onClick = onDismiss) { Text("Cancel") }
+                    }
+                },
+            )
+        }
+
         else -> {
             AlertDialog(
                 onDismissRequest = onDismiss,

android/app/src/main/java/org/bitcoinppl/cove/WalletManager.kt

@@ -286,6 +286,10 @@ class WalletManager :
             is WalletManagerReconcileMessage.SendFlowException -> {
                 sendFlowErrorAlert = TaggedItem(message.v1)
             }
+
+            is WalletManagerReconcileMessage.HotWalletKeyMissing -> {
+                AppManager.getInstance().alertState = TaggedItem(AppAlertState.HotWalletKeyMissing(message.v1))
+            }
         }
     }
 

android/app/src/main/java/org/bitcoinppl/cove/flows/NewWalletFlow/hot_wallet/HotWalletImportScreen.kt

@@ -251,11 +251,13 @@ fun HotWalletImportScreen(
         try {
             val walletMetadata = manager.importWallet(enteredWords)
             app.rust.selectWallet(walletMetadata.id)
+            app.clearWalletManager()
             app.resetRoute(Route.SelectedWallet(walletMetadata.id))
         } catch (e: ImportWalletException.InvalidWordGroup) {
             Log.d("HotWalletImport", "Invalid word group while importing hot wallet")
             alertState = AlertState.InvalidWords
         } catch (e: ImportWalletException.WalletAlreadyExists) {
+            Log.w("HotWalletImport", "Attempted to import words for an existing hot wallet: ${e.v1}")
             duplicateWalletId = e.v1
             alertState = AlertState.DuplicateWallet
         } catch (e: Exception) {

android/app/src/main/java/org/bitcoinppl/cove/flows/SelectedWalletFlow/SelectedWalletContainer.kt

@@ -21,13 +21,16 @@ import org.bitcoinppl.cove.components.FullPageLoadingView
 import org.bitcoinppl.cove.wallet.WalletExportState
 import org.bitcoinppl.cove.wallet.WalletSheetsHost
 import org.bitcoinppl.cove.wallet.rememberWalletExportLaunchers
+import org.bitcoinppl.cove.TaggedItem
+import org.bitcoinppl.cove_core.AppAlertState
 import org.bitcoinppl.cove_core.Database
 import org.bitcoinppl.cove_core.DiscoveryState
 import org.bitcoinppl.cove_core.FoundAddress
 import org.bitcoinppl.cove_core.Route
 import org.bitcoinppl.cove_core.RouteFactory
 import org.bitcoinppl.cove_core.SendRoute
 import org.bitcoinppl.cove_core.WalletManagerAction
+import org.bitcoinppl.cove_core.WalletType
 import org.bitcoinppl.cove_core.types.WalletId
 
 // delay to allow UI to settle before updating balance
@@ -184,7 +187,10 @@ fun SelectedWalletContainer(
                 },
                 canGoBack = canGoBack,
                 onSend = {
-                    // check balance before navigating to send flow
+                    if (wm.walletMetadata?.walletType == WalletType.WATCH_ONLY) {
+                        app.alertState = TaggedItem(AppAlertState.CantSendOnWatchOnlyWallet)
+                        return@SelectedWalletScreen
+                    }
                     val balance = wm.balance.spendable().asSats()
                     if (balance > 0u.toULong()) {
                         app.pushRoute(Route.Send(SendRoute.SetAmount(id, null, null)))

android/app/src/main/java/org/bitcoinppl/cove/flows/SelectedWalletFlow/SelectedWalletScreen.kt

@@ -176,6 +176,7 @@ fun SelectedWalletScreen(
     // state for wallet name rename dropdown
     var showRenameMenu by remember { mutableStateOf(false) }
     val isColdWallet = manager?.walletMetadata?.walletType == WalletType.COLD
+    val isWatchOnly = manager?.walletMetadata?.walletType == WalletType.WATCH_ONLY
 
     // force white status bar icons for midnight blue background
     ForceLightStatusBarIcons()
@@ -417,6 +418,7 @@ fun SelectedWalletScreen(
                                     onToggleSensitive = { manager?.dispatch(WalletManagerAction.ToggleSensitiveVisibility) },
                                     onSend = onSend,
                                     onReceive = onReceive,
+                                    isWatchOnly = isWatchOnly,
                                 )
                             }