Fix error handling gaps in wallet type conversion and downgrade flow

Surface setWalletType errors to the user on both Android and iOS instead
of silently swallowing them. Add navigation after xpub paste import on
iOS. In Rust, propagate keychain and DB errors from downgrade check
instead of swallowing them, add MissingMetadata error variant for the
correct semantic, and propagate get_all errors in duplicate detection.

Author: praveenperera

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

@@ -437,7 +437,15 @@ private fun GlobalAlertDialog(
                             onDismiss()
                             try {
                                 app.rust.setWalletType(walletId, WalletType.COLD)
-                            } catch (_: Exception) {
+                            } 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") }
                     }

ios/Cove/CoveApp.swift

@@ -85,8 +85,18 @@ struct CoveApp: App {
             }
 
             Button("Use with Hardware Wallet") {
-                app.alertState = .none
-                try? app.rust.setWalletType(id: walletId, walletType: .cold)
+                do {
+                    try app.rust.setWalletType(id: walletId, walletType: .cold)
+                    app.alertState = .none
+                } catch {
+                    Log.error("Failed to set wallet type to cold: \(error)")
+                    DispatchQueue.main.async {
+                        app.alertState = .init(.general(
+                            title: "Error",
+                            message: error.localizedDescription
+                        ))
+                    }
+                }
             }
 
             Button("Use as Watch Only", role: .cancel) {
@@ -194,6 +204,7 @@ struct CoveApp: App {
                 do {
                     let wallet = try Wallet.newFromXpub(xpub: text)
                     try app.rust.selectWallet(id: wallet.id())
+                    app.resetRoute(to: .selectedWallet(wallet.id()))
                 } catch {
                     DispatchQueue.main.async {
                         app.alertState = .init(

rust/src/manager/import_wallet_manager.rs

@@ -62,6 +62,9 @@ pub enum ImportWalletError {
     #[error("wallet already exists")]
     WalletAlreadyExists(WalletId),
 
+    #[error("wallet metadata missing for existing wallet")]
+    MissingMetadata(WalletId),
+
     #[error("failed to save wallet: {0}")]
     Database(#[from] database::Error),
 
@@ -137,7 +140,7 @@ impl RustImportWalletManager {
             let mut metadata = Database::global()
                 .wallets
                 .get(&id, network, mode)?
-                .ok_or_else(|| ImportWalletError::WalletAlreadyExists(id.clone()))?;
+                .ok_or_else(|| ImportWalletError::MissingMetadata(id.clone()))?;
 
             let descriptors =
                 mnemonic.clone().into_descriptors(None, network, metadata.address_type);

rust/src/manager/wallet_manager.rs

@@ -258,11 +258,8 @@ impl RustWalletManager {
         let reconciler = MessageSender::new(sender.clone());
         let mut deferred = DeferredSender::new(reconciler.clone());
 
-        let wallet = {
-            let mut wallet = Wallet::try_load_persisted(id.clone())?;
-            downgrade_and_notify_if_needed(&mut wallet.metadata, &mut deferred);
-            wallet
-        };
+        let mut wallet = Wallet::try_load_persisted(id.clone())?;
+        wallet.metadata = downgrade_and_notify_if_needed(wallet.metadata, &mut deferred)?;
 
         let metadata = Database::global()
             .wallets
@@ -1352,39 +1349,43 @@ impl Drop for RustWalletManager {
 
 /// If a hot wallet's private key is missing from the keychain, downgrade it to
 /// watch-only and queue a `HotWalletKeyMissing` notification so the UI can alert the user
+#[must_use]
 fn downgrade_and_notify_if_needed(
-    metadata: &mut WalletMetadata,
+    metadata: WalletMetadata,
     deferred: &mut DeferredSender<Message>,
-) {
+) -> Result<WalletMetadata, Error> {
     if metadata.wallet_type != WalletType::Hot {
-        return;
+        return Ok(metadata);
     }
 
     let has_private_key = match Keychain::global().get_wallet_key(&metadata.id) {
         Ok(Some(_)) => true,
         Ok(None) => false,
         Err(error) => {
-            warn!("failed to read hot wallet private key for {}: {error}", metadata.id);
-            false
+            return Err(Error::UnknownError(format!(
+                "failed to read keychain for {}: {error}",
+                metadata.id
+            )));
         }
     };
 
     if has_private_key {
-        return;
+        return Ok(metadata);
     }
 
-    warn!(
-        "hot wallet {} is missing private key in keychain, downgrading to watch-only",
-        metadata.id
-    );
-    metadata.wallet_type = WalletType::WatchOnly;
-    metadata.hardware_metadata = None;
+    let id = metadata.id.clone();
+    warn!("hot wallet {id} is missing private key in keychain, downgrading to watch-only",);
 
-    if let Err(error) = Database::global().wallets.update_wallet_metadata(metadata.clone()) {
-        error!("failed to persist watch-only downgrade for {}: {error}", metadata.id);
-    }
+    let mut updated = metadata;
+    updated.wallet_type = WalletType::WatchOnly;
+    updated.hardware_metadata = None;
+
+    Database::global().wallets.update_wallet_metadata(updated.clone()).map_err(|e| {
+        Error::UnknownError(format!("failed to persist watch-only downgrade for {id}: {e}",))
+    })?;
 
-    deferred.queue(Message::HotWalletKeyMissing(metadata.id.clone()));
+    deferred.queue(Message::HotWalletKeyMissing(updated.id.clone()));
+    Ok(updated)
 }
 
 /// Get the public descriptor content for export

rust/src/wallet.rs

@@ -297,17 +297,13 @@ impl Wallet {
 
             let existing = database
                 .wallets
-                .get_all(network, mode)
-                .map(|wallets| {
-                    wallets
-                        .into_iter()
-                        .filter_map(|wm| {
-                            let fp = wm.master_fingerprint.as_ref()?;
-                            (fp.as_ref() == &fingerprint).then_some(wm)
-                        })
-                        .next()
+                .get_all(network, mode)?
+                .into_iter()
+                .filter_map(|wm| {
+                    let fp = wm.master_fingerprint.as_ref()?;
+                    (fp.as_ref() == &fingerprint).then_some(wm)
                 })
-                .unwrap_or(None);
+                .next();
 
             if let Some(mut existing_metadata) = existing {
                 if existing_metadata.wallet_type != WalletType::WatchOnly {