feat(context): re-key AppContext.wallets map from seed_hash to wallet_id

Commit 4 of the seed_hash → wallet_id refactor. This is the
behavioral change — the wallets map key is now wallet_id bytes
instead of seed_hash bytes.

AppContext::new (DB load):
  Map key = wallet.wallet_id() if populated (v40+ wallets that
  have been opened), else wallet.seed_hash() as fallback for
  locked wallets that haven't been unlocked since v40.

register_wallet:
  Uses wallet.wallet_id().unwrap_or(seed_hash) — newly created
  wallets always have wallet_id (seed is open at creation time).

register_with_platform_wallet_manager:
  After computing wallet_id from the seed, re-keys the map entry
  from seed_hash to wallet_id if the wallet was inserted before
  wallet_id was available (password-protected wallet's first
  unlock since v40). Uses write lock + remove + insert pattern.
  Also sets managed.wallet_id = Some(wallet_id) (real wallet_id
  bytes, no longer seed_hash as transition placeholder).

handle_wallet_locked:
  Uses wallet.wallet_id() for identification (with seed_hash
  fallback). Does NOT remove the map entry — locked wallets
  stay visible in the UI.

get_platform_wallet / require_platform_wallet:
  Parameter renamed seed_hash → wallet_key for clarity. The
  underlying logic is unchanged (map lookup by key).

Post this commit, code that passes wallet_id bytes to
get_platform_wallet will find the correct entry. Code that still
passes seed_hash bytes will fail for wallets that have been
re-keyed — but all identity/contact discovery code flows through
platform-wallet which populates wallet_id bytes, so post-v40
(all identities re-discovered) the lookup values are correct.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: shumkov

src/context/mod.rs

@@ -325,7 +325,13 @@ impl AppContext {
             }
         }
         .into_iter()
-        .map(|w| (w.seed_hash(), Arc::new(RwLock::new(w))))
+        .map(|w| {
+            // Use wallet_id as the map key when available (v40+ wallets
+            // that have been opened at least once). Fall back to
+            // seed_hash for wallets that haven't been unlocked since v40.
+            let key = w.wallet_id().unwrap_or_else(|| w.seed_hash());
+            (key, Arc::new(RwLock::new(w)))
+        })
         .collect();
 
         let single_key_wallets: BTreeMap<_, _> = match db.get_single_key_wallets(network) {

src/context/wallet_lifecycle.rs

@@ -63,17 +63,18 @@ impl AppContext {
         Ok(())
     }
 
-    /// Get a `PlatformWallet` by `WalletId`.
+    /// Get a `PlatformWallet` by wallet map key.
     ///
-    /// Returns `None` if the wallet doesn't exist or is locked (no platform_wallet).
+    /// The map is keyed by `WalletId` (post-v40). Returns `None` if the
+    /// wallet doesn't exist or is locked (no platform_wallet).
     pub(crate) fn get_platform_wallet(
         &self,
-        seed_hash: &WalletId,
+        wallet_key: &WalletId,
     ) -> Option<Arc<PlatformWallet>> {
         self.wallets
             .read()
             .ok()
-            .and_then(|wallets| wallets.get(seed_hash).cloned())
+            .and_then(|wallets| wallets.get(wallet_key).cloned())
             .and_then(|w| w.read().ok().and_then(|g| g.platform_wallet.clone()))
     }
 
@@ -90,14 +91,14 @@ impl AppContext {
         })
     }
 
-    /// Get a `PlatformWallet` by seed hash, or return `TaskError::WalletNotFound`.
+    /// Get a `PlatformWallet` by wallet map key, or return `TaskError::WalletNotFound`.
     ///
     /// Convenience wrapper for backend tasks that need the platform wallet.
     pub(crate) fn require_platform_wallet(
         &self,
-        seed_hash: &WalletId,
+        wallet_key: &WalletId,
     ) -> Result<Arc<PlatformWallet>, TaskError> {
-        self.get_platform_wallet(seed_hash)
+        self.get_platform_wallet(wallet_key)
             .ok_or(TaskError::WalletNotFound)
     }
 
@@ -225,19 +226,23 @@ impl AppContext {
                 }
             })?;
 
-        let seed_hash = wallet.seed_hash();
+        // Use wallet_id as the map key (wallet_id is always available
+        // for newly-created wallets because the seed is open).
+        let map_key = wallet
+            .wallet_id()
+            .unwrap_or_else(|| wallet.seed_hash());
 
         // 2. Register in-memory
         let wallet_arc = Arc::new(RwLock::new(wallet));
         let mut wallets = self.wallets.write()?;
-        wallets.insert(seed_hash, wallet_arc.clone());
+        wallets.insert(map_key, wallet_arc.clone());
         self.has_wallet.store(true, Ordering::Relaxed);
         drop(wallets);
 
         // 3. Create PlatformWallet and load into SPV
         self.handle_wallet_unlocked(&wallet_arc);
 
-        Ok((seed_hash, wallet_arc))
+        Ok((map_key, wallet_arc))
     }
 
     pub fn bootstrap_wallet_addresses(&self, _wallet: &Arc<RwLock<Wallet>>) {
@@ -331,13 +336,24 @@ impl AppContext {
                     );
                 }
 
-                // Store on the Wallet struct itself
-                if let Ok(wallets) = self.wallets.read() {
-                    if let Some(wallet_arc) = wallets.get(&seed_hash) {
+                // Store platform_wallet + wallet_id on the Wallet struct,
+                // and re-key the map entry from seed_hash to wallet_id if
+                // it was inserted before wallet_id was computed (password-
+                // protected wallets unlocked for the first time since v40).
+                if let Ok(mut wallets) = self.wallets.write() {
+                    // Try wallet_id first (normal case), then seed_hash
+                    // (first-unlock-since-v40 case).
+                    let wallet_arc = wallets
+                        .get(&wallet_id)
+                        .cloned()
+                        .or_else(|| wallets.remove(&seed_hash));
+                    if let Some(wallet_arc) = wallet_arc {
                         if let Ok(mut wallet) = wallet_arc.write() {
                             wallet.platform_wallet = Some(Arc::clone(&platform_wallet));
                             wallet.wallet_id = Some(wallet_id);
                         }
+                        // Ensure the entry is keyed by wallet_id.
+                        wallets.insert(wallet_id, wallet_arc);
                     }
                 }
 
@@ -358,8 +374,11 @@ impl AppContext {
     }
 
     pub fn handle_wallet_locked(self: &Arc<Self>, wallet: &Arc<RwLock<Wallet>>) {
-        let seed_hash = match wallet.read() {
-            Ok(guard) => guard.seed_hash(),
+        let (map_key, seed_hash) = match wallet.read() {
+            Ok(guard) => {
+                let key = guard.wallet_id().unwrap_or_else(|| guard.seed_hash());
+                (key, guard.seed_hash())
+            }
             Err(err) => {
                 tracing::warn!(error = %err, "Unable to read wallet during lock handling");
                 return;
@@ -371,9 +390,17 @@ impl AppContext {
             guard.platform_wallet = None;
         }
 
+        // Remove from wallet_id_mapping. The mapping is keyed by
+        // seed_hash (the "old" key side of the bridge).
         if let Ok(mut mapping) = self.wallet_id_mapping.lock() {
             mapping.remove_by_seed_hash(&seed_hash);
         }
+
+        // Note: we do NOT remove the wallet from the AppContext.wallets
+        // map here — locking a wallet keeps it visible in the UI, just
+        // without platform_wallet access. The map entry stays at its
+        // current key (wallet_id or seed_hash fallback).
+        let _ = map_key; // suppress unused warning
     }
 
     /// Queue async SyncNotes -> CheckNullifiers for an already-initialized
@@ -928,11 +955,7 @@ impl AppContext {
             managed.key_storage = mi_key_storage;
             managed.dpns_names = mi_dpns_names;
             managed.status = mi_status;
-            // Note: `managed.wallet_id` receives `seed_hash` bytes during
-            // the M2 transition period. Evo-tool's wallet maps are still
-            // keyed by seed_hash; the M2 refactor commits 4-7 will switch
-            // the value to the real wallet_id and re-key the maps.
-            managed.wallet_id = Some(seed_hash);
+            managed.wallet_id = Some(wallet_id);
             managed.top_ups = qualified_identity.top_ups.clone();
             managed.dashpay_profile = mi_dashpay_profile;
             managed.dashpay_payments = mi_dashpay_payments;
@@ -963,7 +986,7 @@ impl AppContext {
                         managed.key_storage = mi_key_storage;
                         managed.dpns_names = mi_dpns_names;
                         managed.status = mi_status;
-                        managed.wallet_id = Some(seed_hash); // M2: seed_hash bytes during transition
+                        managed.wallet_id = Some(wallet_id);
                         managed.top_ups = qualified_identity.top_ups.clone();
                         managed.dashpay_profile = mi_dashpay_profile;
                         managed.dashpay_payments = mi_dashpay_payments;