feat(key-wallet-manager): switch to single-map WalletManager with Arc<RwLock<T>> per wallet

PR-30 Phase 1: Refactor WalletManager to use a single map with per-wallet
Arc<RwLock<T>> instead of two separate maps (wallets + wallet_infos).

Key changes:
- New ManagedWalletState struct bundling Wallet + ManagedWalletInfo + Persister
- New WalletPersistence trait (store returns Result, NoPersistence default)
- WalletInfoInterface gains wallet()/wallet_mut() methods
- WalletTransactionChecker::check_core_transaction no longer takes wallet param
- ManagedWalletInfo gets check_core_transaction_with_wallet helper
- WalletManager uses BTreeMap<WalletId, Arc<RwLock<T>>> for shared state
- insert_wallet_state() for external callers to inject pre-built state
- Sync methods (monitored_addresses, watched_outpoints, monitor_revision,
  update_synced_height, process_instant_send_lock) made async for proper
  lock acquisition; synced_height/filter_committed_height stay sync
- ManagedWalletState fields pub(crate) with public accessor methods

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

Author: shumkov

dash-spv/src/client/lifecycle.rs

@@ -128,7 +128,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager, H: EventHandler>
         // Create mempool state and build mempool manager if tracking is enabled
         let mempool_state = Arc::new(RwLock::new(MempoolState::default()));
         if config.enable_mempool_tracking {
-            let initial_revision = wallet.read().await.monitor_revision();
+            let initial_revision = wallet.read().await.monitor_revision().await;
             managers.mempool = Some(MempoolManager::new(
                 wallet.clone(),
                 mempool_state.clone(),

dash-spv/src/sync/filters/manager.rs

@@ -500,7 +500,7 @@ impl<H: BlockHeaderStorage, FH: FilterHeaderStorage, F: FilterStorage, W: Wallet
             let end = batch.end_height();
             if end > self.progress.committed_height() {
                 self.progress.update_committed_height(end);
-                self.wallet.write().await.update_filter_committed_height(end);
+                self.wallet.write().await.update_filter_committed_height(end).await;
             }
             self.processing_height = end + 1;
 
@@ -675,7 +675,7 @@ impl<H: BlockHeaderStorage, FH: FilterHeaderStorage, F: FilterStorage, W: Wallet
 
         // Match against wallet's current addresses
         let wallet = self.wallet.read().await;
-        let addresses = wallet.monitored_addresses();
+        let addresses = wallet.monitored_addresses().await;
         let matches = check_compact_filters_for_addresses(batch.filters(), addresses);
         drop(wallet);
 
@@ -821,7 +821,7 @@ mod tests {
 
         // Set wallet committed height via synced_height (MockWallet default delegates)
         let mut wallet = MockWallet::new();
-        wallet.update_synced_height(50);
+        wallet.update_synced_height(50).await;
         let wallet = Arc::new(RwLock::new(wallet));
 
         // Pre-populate filter storage with filters at heights 1..=100
@@ -1049,7 +1049,7 @@ mod tests {
         assert_eq!(manager.state(), SyncState::WaitForEvents);
 
         // Wallet committed to height 100, so scan_start will be 101
-        manager.wallet.write().await.update_synced_height(100);
+        manager.wallet.write().await.update_synced_height(100).await;
         // Filter headers only reached 50, so its below scan_start
         manager.progress.update_filter_header_tip_height(50);
         // Chain tip higher so the Synced early-return is not taken
@@ -1126,7 +1126,7 @@ mod tests {
         // Simulate restart where everything is already synced but state is WaitForEvents.
         // committed == stored == filter_header_tip — start_download detects synced state.
         manager.set_state(SyncState::WaitForEvents);
-        manager.wallet.write().await.update_synced_height(100);
+        manager.wallet.write().await.update_synced_height(100).await;
         manager.progress.update_committed_height(100);
         manager.progress.update_stored_height(100);
         manager.progress.update_filter_header_tip_height(100);

dash-spv/src/sync/mempool/manager.rs

@@ -135,8 +135,8 @@ impl<W: WalletInterface> MempoolManager<W> {
         requests: &RequestSender,
     ) -> SyncResult<()> {
         let wallet = self.wallet.read().await;
-        let addresses = wallet.monitored_addresses();
-        let outpoints = wallet.watched_outpoints();
+        let addresses = wallet.monitored_addresses().await;
+        let outpoints = wallet.watched_outpoints().await;
         drop(wallet);
 
         if addresses.is_empty() && outpoints.is_empty() {
@@ -379,7 +379,7 @@ impl<W: WalletInterface> MempoolManager<W> {
         drop(state);
         if marked {
             let mut wallet = self.wallet.write().await;
-            wallet.process_instant_send_lock(*txid);
+            wallet.process_instant_send_lock(*txid).await;
         }
     }
 

dash-spv/src/sync/mempool/sync_manager.rs

@@ -127,7 +127,7 @@ impl<W: WalletInterface + 'static> SyncManager for MempoolManager<W> {
         // shared `SyncManager::run` loop or a `WalletEvent` bridge — complexity
         // that isn't justified given the 100ms tick latency is negligible for bloom
         // filter rebuilds and the read lock is non-contending.
-        let current_revision = self.wallet.read().await.monitor_revision();
+        let current_revision = self.wallet.read().await.monitor_revision().await;
         if current_revision != self.last_monitor_revision {
             tracing::info!("Wallet monitor revision changed, rebuilding bloom filter");
             self.rebuild_filter(requests).await?;
@@ -621,7 +621,7 @@ mod tests {
 
         let mut mock = MockWallet::new();
         mock.set_addresses(vec![addr.clone()]);
-        let initial_revision = mock.monitor_revision();
+        let initial_revision = mock.monitor_revision().await;
         let wallet = Arc::new(RwLock::new(mock));
         let mempool_state = Arc::new(RwLock::new(MempoolState::default()));
         let (tx, mut rx) = mpsc::unbounded_channel::<NetworkRequest>();
@@ -734,7 +734,7 @@ mod tests {
 
         let mut mock = MockWallet::new();
         mock.set_addresses(vec![addr]);
-        let initial_revision = mock.monitor_revision();
+        let initial_revision = mock.monitor_revision().await;
         let wallet = Arc::new(RwLock::new(mock));
         let mempool_state = Arc::new(RwLock::new(MempoolState::default()));
         let (tx, mut rx) = mpsc::unbounded_channel::<NetworkRequest>();
@@ -785,7 +785,7 @@ mod tests {
         ]);
         let addr = dashcore::Address::from_script(&script, dashcore::Network::Testnet).unwrap();
         mock.set_addresses(vec![addr]);
-        let initial_revision = mock.monitor_revision();
+        let initial_revision = mock.monitor_revision().await;
         let wallet = Arc::new(RwLock::new(mock));
         let mempool_state = Arc::new(RwLock::new(MempoolState::default()));
         let (tx_chan, mut rx) = mpsc::unbounded_channel::<NetworkRequest>();

key-wallet-ffi/src/wallet_manager_tests.rs

@@ -459,7 +459,7 @@ mod tests {
             let manager_ref = &*manager;
             manager_ref.runtime.block_on(async {
                 let mut manager_guard = manager_ref.manager.write().await;
-                manager_guard.update_synced_height(new_height);
+                manager_guard.update_synced_height(new_height).await;
             });
         }
 

key-wallet-manager/Cargo.toml

@@ -12,12 +12,15 @@ default = []
 parallel-filters = ["dep:rayon"]
 bincode = ["key-wallet/bincode", "dep:bincode"]
 test-utils = ["key-wallet/test-utils"]
+bls = ["key-wallet/bls"]
+eddsa = ["key-wallet/eddsa"]
 
 [dependencies]
 key-wallet = { path = "../key-wallet", default-features = false }
 dashcore = { path = "../dash" }
 async-trait = "0.1"
 tokio = { version = "1", features = ["macros", "rt", "sync"] }
+tracing = "0.1"
 zeroize = { version = "1.8", features = ["derive"] }
 rayon = { version = "1.11", optional = true }
 bincode = { version = "2.0.1", optional = true }

key-wallet-manager/examples/wallet_creation.rs

@@ -8,30 +8,29 @@
 use key_wallet::account::StandardAccountType;
 use key_wallet::wallet::initialization::WalletAccountCreationOptions;
 use key_wallet::wallet::managed_wallet_info::transaction_building::AccountTypePreference;
-use key_wallet::wallet::managed_wallet_info::ManagedWalletInfo;
 use key_wallet::{AccountType, Network};
-use key_wallet_manager::WalletInterface;
-use key_wallet_manager::WalletManager;
+use key_wallet_manager::{ManagedWalletState, WalletInterface, WalletManager};
 
-fn main() {
+#[tokio::main]
+async fn main() {
     println!("=== Wallet Creation Example ===\n");
 
     // Example 1: Basic wallet creation with WalletManager
     println!("1. Creating a basic wallet with WalletManager...");
 
-    let mut manager = WalletManager::<ManagedWalletInfo>::new(Network::Testnet);
+    let mut manager = WalletManager::<ManagedWalletState>::new(Network::Testnet);
 
     let result = manager.create_wallet_with_random_mnemonic(WalletAccountCreationOptions::Default);
 
     let wallet_id = match result {
         Ok(wallet_id) => {
-            println!("✅ Wallet created successfully!");
+            println!("Wallet created successfully!");
             println!("   Wallet ID: {}", hex::encode(wallet_id));
             println!("   Total wallets: {}", manager.wallet_count());
             wallet_id
         }
         Err(e) => {
-            println!("❌ Failed to create wallet: {:?}", e);
+            println!("Failed to create wallet: {:?}", e);
             return;
         }
     };
@@ -50,12 +49,12 @@ fn main() {
 
     let wallet_id2 = match result {
         Ok(wallet_id2) => {
-            println!("✅ Wallet created from mnemonic!");
+            println!("Wallet created from mnemonic!");
             println!("   Wallet ID: {}", hex::encode(wallet_id2));
             wallet_id2
         }
         Err(e) => {
-            println!("❌ Failed to create wallet from mnemonic: {:?}", e);
+            println!("Failed to create wallet from mnemonic: {:?}", e);
             return;
         }
     };
@@ -64,26 +63,28 @@ fn main() {
     println!("\n3. Managing wallet accounts...");
 
     // Add a new account to the first wallet
-    let account_result = manager.create_account(
-        &wallet_id, // Account index 1 (0 is created by default)
-        AccountType::Standard {
-            index: 1,
-            standard_account_type: StandardAccountType::BIP44Account,
-        },
-        None,
-    );
+    let account_result = manager
+        .create_account(
+            &wallet_id, // Account index 1 (0 is created by default)
+            AccountType::Standard {
+                index: 1,
+                standard_account_type: StandardAccountType::BIP44Account,
+            },
+            None,
+        )
+        .await;
 
     match account_result {
         Ok(_) => {
-            println!("✅ Account created successfully!");
+            println!("Account created successfully!");
 
             // Get all accounts
-            if let Ok(accounts) = manager.get_accounts(&wallet_id) {
+            if let Ok(accounts) = manager.get_accounts(&wallet_id).await {
                 println!("   Total accounts: {}", accounts.len());
             }
         }
         Err(e) => {
-            println!("❌ Failed to create account: {:?}", e);
+            println!("Failed to create account: {:?}", e);
         }
     }
 
@@ -92,26 +93,28 @@ fn main() {
 
     // Note: This might fail with InvalidNetwork error if the account collection
     // isn't properly initialized in the managed wallet info
-    let address_result = manager.get_receive_address(
-        &wallet_id,
-        0, // Account index
-        AccountTypePreference::BIP44,
-        false, // Don't advance index
-    );
+    let address_result = manager
+        .get_receive_address(
+            &wallet_id,
+            0, // Account index
+            AccountTypePreference::BIP44,
+            false, // Don't advance index
+        )
+        .await;
 
     match address_result {
         Ok(result) => {
             if let Some(address) = result.address {
-                println!("✅ Receive address: {}", address);
+                println!("Receive address: {}", address);
                 if let Some(account_type) = result.account_type_used {
                     println!("   Account type used: {:?}", account_type);
                 }
             } else {
-                println!("⚠️  No address generated");
+                println!("No address generated");
             }
         }
         Err(e) => {
-            println!("⚠️  Could not get address: {:?}", e);
+            println!("Could not get address: {:?}", e);
             println!("   (This is expected with the current implementation)");
         }
     }
@@ -125,8 +128,8 @@ fn main() {
     // Example 6: Getting wallet balance
     println!("\n6. Checking wallet balances...");
 
-    for (i, wallet_id) in [wallet_id, wallet_id2].iter().enumerate() {
-        match manager.get_wallet_balance(wallet_id) {
+    for (i, wid) in [wallet_id, wallet_id2].iter().enumerate() {
+        match manager.get_wallet_balance(wid).await {
             Ok(balance) => {
                 println!("   Wallet {}: {} satoshis", i + 1, balance.total());
             }
@@ -142,13 +145,13 @@ fn main() {
     // Example 7: Block height tracking
     println!("\n7. Block height tracking...");
 
-    println!("   Current height (Testnet): {:?}", manager.synced_height());
+    println!("   Current height (Testnet): {:?}", WalletInterface::synced_height(&manager));
 
     // Update height
-    manager.update_synced_height(850_000);
-    println!("   Updated height to: {:?}", manager.synced_height());
+    WalletInterface::update_synced_height(&mut manager, 850_000).await;
+    println!("   Updated height to: {:?}", WalletInterface::synced_height(&manager));
 
     println!("\n=== Summary ===");
     println!("Total wallets created: {}", manager.wallet_count());
-    println!("✅ Example completed successfully!");
+    println!("Example completed successfully!");
 }