feat(platform-wallet): use dashcore WalletManager directly, delete SpvWalletAdapter

PR-30 Phase 2: Replace custom SpvWalletAdapter with dashcore's
WalletManager<PlatformWalletInfo> for SPV integration.

Key changes:
- PlatformWalletInfo uses ManagedWalletState<PlatformWalletPersisterBridge>
  for automatic changeset persistence during check_core_transaction (C2)
- Arc<WalletBalance> shared between PlatformWalletInfo and CoreWallet
  for lock-free balance reads; updated via BalanceUpdated events (C1)
- Delete SpvWalletAdapter (~330 lines) — WalletManager implements
  WalletInterface directly
- Delete SpvSyncState (~55 lines) — WalletManager tracks heights
- Delete PlatformWalletInfoWriteGuard — balance via events not Drop
- SpvRuntime holds Arc<RwLock<WalletManager<PlatformWalletInfo>>>
- PlatformWalletManager shares Arc<RwLock<PlatformWalletInfo>> between
  WalletManager (SPV) and PlatformWallet handles (sub-wallets)
- wallets map behind RwLock for interior mutability (&self methods) (W3)
- Trait impls split to platform_wallet_traits.rs (W8)
- Remove dead CoreWallet state accessors (I1)
- PlatformWalletPersisterBridge bridges WalletChangeSet to
  PlatformWalletChangeSet for persistence
- Remove notify_wallets_changed (W5)

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

Author: shumkov

packages/rs-platform-wallet/Cargo.toml

@@ -14,7 +14,7 @@ platform-encryption = { path = "../rs-platform-encryption" }
 
 # Key wallet dependencies (from rust-dashcore)
 key-wallet = { workspace = true }
-key-wallet-manager = { workspace = true }
+key-wallet-manager = { workspace = true, features = [] }
 dash-spv = { workspace = true }
 
 # Core dependencies
@@ -51,6 +51,6 @@ static_assertions = "1.1"
 
 [features]
 default = ["bls", "eddsa"]
-bls = ["key-wallet/bls"]
-eddsa = ["key-wallet/eddsa"]
+bls = ["key-wallet/bls", "key-wallet-manager/bls"]
+eddsa = ["key-wallet/eddsa", "key-wallet-manager/eddsa"]
 shielded = ["dep:grovedb-commitment-tree", "dep:zip32", "dash-sdk/shielded", "dpp/shielded-client"]

packages/rs-platform-wallet/examples/basic_usage.rs

@@ -6,7 +6,6 @@
 use std::sync::Arc;
 
 use dash_sdk::Sdk;
-use key_wallet::wallet::managed_wallet_info::wallet_info_interface::WalletInfoInterface;
 use key_wallet::Network;
 use platform_wallet::changeset::PlatformWalletPersistence;
 use platform_wallet::error::PlatformWalletError;
@@ -74,10 +73,10 @@ fn main() -> Result<(), PlatformWalletError> {
     // All mutable state is behind a single lock — one acquisition gives
     // access to everything.
     {
-        let info = core.state_blocking();
-        let utxos = info.wallet_info.get_spendable_utxos();
-        let tx_count = info.wallet_info.transaction_history().len();
-        let birth = info.wallet_info.birth_height();
+        let info = wallet.state_blocking();
+        let utxos = info.managed_state.wallet_info().get_spendable_utxos();
+        let tx_count = info.managed_state.wallet_info().transaction_history().len();
+        let birth = info.managed_state.wallet_info().birth_height();
         let id_count = info.identity_manager.identities().len();
         println!("UTXOs: {}, transactions: {}, birth_height: {}", utxos.len(), tx_count, birth);
         println!("Managed identities: {}", id_count);

packages/rs-platform-wallet/src/manager.rs

@@ -1,12 +1,12 @@
 //! Multi-wallet manager with SPV coordination.
 
-use std::collections::BTreeMap;
 use std::sync::Arc;
 
 use tokio::sync::{broadcast, RwLock};
 
 use key_wallet::wallet::initialization::WalletAccountCreationOptions;
 use key_wallet::Network;
+use key_wallet_manager::WalletManager;
 
 use crate::changeset::{Merge, PlatformWalletPersistence};
 
@@ -23,8 +23,10 @@ pub struct WalletCreationOptions {
 use crate::error::PlatformWalletError;
 use crate::events::PlatformWalletEvent;
 use crate::spv::SpvRuntime;
-use crate::wallet::platform_wallet::WalletId;
+use crate::wallet::persister::PlatformWalletPersisterBridge;
+use crate::wallet::platform_wallet::{PlatformWalletInfo, WalletId};
 use crate::wallet::PlatformWallet;
+use crate::wallet::core::WalletBalance;
 
 /// Multi-wallet coordinator with SPV sync and event broadcasting.
 ///
@@ -34,13 +36,20 @@ use crate::wallet::PlatformWallet;
 /// broadcasts unified [`PlatformWalletEvent`]s (sync progress, network
 /// changes, wallet updates, finality proofs) to subscribers.
 ///
-/// Each managed [`PlatformWallet`] shares its underlying `Wallet` and
-/// `ManagedWalletInfo` with the SPV adapter through `Arc<RwLock<…>>`,
-/// so balance and UTXO updates from SPV are immediately visible to all
-/// wallet operations.
+/// Internally holds a `WalletManager<PlatformWalletInfo>` that implements
+/// `WalletInterface` for DashSpvClient, and a separate map of
+/// `PlatformWallet` handles. Both share the same `Arc<RwLock<PlatformWalletInfo>>`
+/// per wallet, so balance and UTXO updates from SPV are immediately visible
+/// to all wallet operations.
 pub struct PlatformWalletManager {
     sdk: Arc<dash_sdk::Sdk>,
-    wallets: Arc<RwLock<BTreeMap<WalletId, Arc<PlatformWallet>>>>,
+    /// Core-layer wallet manager implementing `WalletInterface`.
+    /// Shared with `SpvRuntime` so DashSpvClient drives block/mempool
+    /// processing directly through it.
+    wallet_manager: Arc<RwLock<WalletManager<PlatformWalletInfo>>>,
+    /// Platform-level wallet handles (sub-wallets, identity, dashpay, etc.).
+    /// Interior mutability via `RwLock` so methods take `&self`.
+    wallets: RwLock<std::collections::BTreeMap<WalletId, Arc<PlatformWallet>>>,
     event_tx: broadcast::Sender<PlatformWalletEvent>,
     spv: Arc<SpvRuntime>,
     persister: Arc<dyn PlatformWalletPersistence>,
@@ -50,11 +59,15 @@ impl PlatformWalletManager {
     /// Create a new PlatformWalletManager.
     pub fn new(sdk: Arc<dash_sdk::Sdk>, persister: Arc<dyn PlatformWalletPersistence>) -> Self {
         let (event_tx, _) = broadcast::channel(256);
-        let wallets = Arc::new(RwLock::new(BTreeMap::new()));
-        let spv = Arc::new(SpvRuntime::new(Arc::clone(&wallets), event_tx.clone()));
+        let wallet_manager = Arc::new(RwLock::new(WalletManager::new(sdk.network)));
+        let spv = Arc::new(SpvRuntime::new(
+            Arc::clone(&wallet_manager),
+            event_tx.clone(),
+        ));
         Self {
             sdk,
-            wallets,
+            wallet_manager,
+            wallets: RwLock::new(std::collections::BTreeMap::new()),
             event_tx,
             spv,
             persister,
@@ -98,9 +111,9 @@ impl PlatformWalletManager {
         seed_bytes: [u8; 64],
         options: WalletCreationOptions,
     ) -> Result<Arc<PlatformWallet>, PlatformWalletError> {
-        use key_wallet::wallet::managed_wallet_info::wallet_info_interface::WalletInfoInterface;
         use key_wallet::wallet::managed_wallet_info::ManagedWalletInfo;
         use key_wallet::wallet::Wallet;
+        use key_wallet_manager::ManagedWalletState;
 
         let wallet =
             Wallet::from_seed_bytes(seed_bytes, network, options.accounts).map_err(|e| {
@@ -115,11 +128,40 @@ impl PlatformWalletManager {
         }
         let wallet_id = wallet_info.wallet_id;
 
+        // Build ManagedWalletState with the persister bridge.
+        let bridge = PlatformWalletPersisterBridge::new(wallet_id, Arc::clone(&self.persister));
+        let managed_state = ManagedWalletState::new(wallet, wallet_info, bridge);
+        let balance = Arc::new(WalletBalance::new());
+
+        // Build the shared state Arc.
+        let state = Arc::new(RwLock::new(PlatformWalletInfo {
+            managed_state,
+            balance: Arc::clone(&balance),
+            identity_manager: crate::wallet::identity::IdentityManager::new(),
+            tracked_asset_locks: std::collections::BTreeMap::new(),
+            platform_address_balances: std::collections::BTreeMap::new(),
+            token_watched: std::collections::BTreeMap::new(),
+            token_balances: std::collections::BTreeMap::new(),
+        }));
+
+        // Insert into WalletManager (shares the same Arc).
+        {
+            let mut wm = self.wallet_manager.write().await;
+            wm.insert_wallet_state(wallet_id, Arc::clone(&state))
+                .map_err(|e| {
+                    PlatformWalletError::WalletCreation(format!(
+                        "Failed to register wallet in WalletManager: {}",
+                        e
+                    ))
+                })?;
+        }
+
+        // Build the PlatformWallet handle from the shared state.
         let broadcaster = Arc::new(crate::broadcaster::SpvBroadcaster::new(Arc::clone(&self.spv)));
-        let platform_wallet = PlatformWallet::new(
+        let platform_wallet = PlatformWallet::from_shared_state(
             Arc::clone(&self.sdk),
-            wallet,
-            wallet_info,
+            wallet_id,
+            state,
             self.event_tx.clone(),
             Arc::clone(&self.persister),
             broadcaster,
@@ -134,19 +176,15 @@ impl PlatformWalletManager {
         })?;
         if !changeset.is_empty() {
             platform_wallet.apply(&changeset);
-            // TODO: Once apply() actually restores wallet state (transactions,
-            // UTXOs) from the changeset, set birth_height from the persisted
-            // chain height here so SPV doesn't rescan from genesis on restart.
-            // Until then, birth_height must come from WalletCreationOptions.
         }
 
         let platform_wallet = Arc::new(platform_wallet);
 
-        // Register with the manager so SPV processes this wallet.
-        let mut wallets = self.wallets.write().await;
-        wallets.insert(wallet_id, Arc::clone(&platform_wallet));
-        drop(wallets);
-        self.spv.notify_wallets_changed();
+        // Register the PlatformWallet handle.
+        {
+            let mut wallets = self.wallets.write().await;
+            wallets.insert(wallet_id, Arc::clone(&platform_wallet));
+        }
 
         Ok(platform_wallet)
     }
@@ -156,11 +194,18 @@ impl PlatformWalletManager {
         &self,
         wallet_id: &WalletId,
     ) -> Result<Arc<PlatformWallet>, PlatformWalletError> {
-        let mut wallets = self.wallets.write().await;
-        let removed = wallets
-            .remove(wallet_id)
-            .ok_or_else(|| PlatformWalletError::WalletNotFound(hex::encode(wallet_id)))?;
-        self.spv.notify_wallets_changed();
+        // Remove from PlatformWallet handles.
+        let removed = {
+            let mut wallets = self.wallets.write().await;
+            wallets
+                .remove(wallet_id)
+                .ok_or_else(|| PlatformWalletError::WalletNotFound(hex::encode(wallet_id)))?
+        };
+        // Remove from WalletManager.
+        {
+            let mut wm = self.wallet_manager.write().await;
+            let _ = wm.remove_wallet(wallet_id);
+        }
         Ok(removed)
     }
 

packages/rs-platform-wallet/src/spv/mod.rs

@@ -1,6 +1,4 @@
 mod event_forwarder;
 mod runtime;
-mod sync_state;
-mod wallet_adapter;
 
 pub use runtime::SpvRuntime;

packages/rs-platform-wallet/src/spv/runtime.rs

@@ -6,7 +6,6 @@
 //! Asset-lock finality tracking (IS/CL proof waiting) is handled by
 //! `AssetLockManager` directly — it subscribes to the shared event channel.
 
-use std::collections::BTreeMap;
 use std::sync::Arc;
 
 use tokio::sync::{broadcast, RwLock};
@@ -19,63 +18,55 @@ use dash_spv::network::PeerNetworkManager;
 use dash_spv::storage::DiskStorageManager;
 use dash_spv::{ClientConfig, DashSpvClient, Hash};
 
-use key_wallet_manager::WalletInterface;
+use key_wallet_manager::{WalletInterface, WalletManager};
 
 use crate::error::PlatformWalletError;
 use crate::events::PlatformWalletEvent;
 use crate::spv::event_forwarder::SpvEventForwarder;
-use crate::spv::wallet_adapter::SpvWalletAdapter;
-use crate::wallet::platform_wallet::WalletId;
-use crate::wallet::PlatformWallet;
+use crate::wallet::platform_wallet::PlatformWalletInfo;
 
 type SpvClient =
-    DashSpvClient<SpvWalletAdapter, PeerNetworkManager, DiskStorageManager, SpvEventForwarder>;
+    DashSpvClient<WalletManager<PlatformWalletInfo>, PeerNetworkManager, DiskStorageManager, SpvEventForwarder>;
 
 /// SPV client runtime — owns the `DashSpvClient` and tracks sync height.
 ///
-/// Holds references to the wallets collection and event channel at construction
-/// time, so callers just need `start(config)` / `stop()`.
+/// Holds a reference to the shared `WalletManager<PlatformWalletInfo>` and
+/// event channel at construction time, so callers just need `start(config)` /
+/// `stop()`.
 ///
 /// Asset-lock finality tracking (InstantLock / ChainLock waiting) is handled
 /// directly by `AssetLockManager` via SPV event subscriptions — the runtime
 /// only drives SPV sync and forwards events.
 pub struct SpvRuntime {
     event_tx: broadcast::Sender<PlatformWalletEvent>,
-    /// Shared sync state — atomics accessible without holding the adapter lock.
-    sync_state: Arc<super::sync_state::SpvSyncState>,
-    adapter: Arc<RwLock<SpvWalletAdapter>>,
+    /// Shared `WalletManager<PlatformWalletInfo>` — implements `WalletInterface`,
+    /// so DashSpvClient can drive block/mempool processing directly through it.
+    /// `WalletManager` bumps its own structural revision when wallets are
+    /// added/removed, so no external `notify_wallets_changed()` is needed.
+    wallet_manager: Arc<RwLock<WalletManager<PlatformWalletInfo>>>,
     client: RwLock<Option<SpvClient>>,
 }
 
 impl SpvRuntime {
-    /// Create a new SPV runtime bound to a wallets collection and event channel.
+    /// Create a new SPV runtime bound to a wallet manager and event channel.
     pub fn new(
-        wallets: Arc<RwLock<BTreeMap<WalletId, Arc<PlatformWallet>>>>,
+        wallet_manager: Arc<RwLock<WalletManager<PlatformWalletInfo>>>,
         event_tx: broadcast::Sender<PlatformWalletEvent>,
     ) -> Self {
-        let sync_state = Arc::new(super::sync_state::SpvSyncState::new());
-        let adapter = Arc::new(RwLock::new(SpvWalletAdapter::new(
-            wallets,
-            Arc::clone(&sync_state),
-        )));
         Self {
             event_tx,
-            sync_state,
-            adapter,
+            wallet_manager,
             client: RwLock::new(None),
         }
     }
 
-    /// Current synced height. Always returns the correct value even during
-    /// block processing (atomics are outside the adapter's RwLock).
+    /// Current synced height. Reads a plain field on WalletManager (sync, no
+    /// per-wallet lock).
     pub fn synced_height(&self) -> u32 {
-        self.sync_state.synced_height()
-    }
-
-    /// Signal that the wallet set changed (added/removed).
-    /// SPV will rebuild the bloom filter on the next tick.
-    pub fn notify_wallets_changed(&self) {
-        self.sync_state.bump_monitor_revision();
+        self.wallet_manager
+            .try_read()
+            .map(|wm| wm.synced_height())
+            .unwrap_or(0)
     }
 
     /// Reset filter_committed_height to 0, forcing a filter rescan from
@@ -84,8 +75,9 @@ impl SpvRuntime {
     /// Useful when wallet state isn't persisted: cached committed height
     /// from a previous run would skip historical blocks, leaving the
     /// wallet with zero balance.
-    pub fn reset_filter_committed_height(&self) {
-        self.sync_state.update_filter_committed_height(0);
+    pub async fn reset_filter_committed_height(&self) {
+        let mut wm = self.wallet_manager.write().await;
+        wm.update_filter_committed_height(0).await;
     }
 
     /// Start SPV sync.
@@ -110,7 +102,7 @@ impl SpvRuntime {
             config,
             network_manager,
             storage_manager,
-            Arc::clone(&self.adapter),
+            Arc::clone(&self.wallet_manager),
             Arc::new(forwarder),
         )
         .await