Feat/platform wallet

Cargo.toml

@@ -18,7 +18,7 @@ qrcode = "0.14.1"
 nix = { version = "0.31.1", features = ["signal"] }
 eframe = { version = "0.33.3", features = ["persistence", "wgpu"] }
 base64 = "0.22.1"
-dash-sdk = { git = "https://github.com/dashpay/platform", rev = "a10190399d7033e7e56e3f756411e9a5dab87829", features = [
+dash-sdk = { path = "../platform/packages/rs-sdk", features = [
     "core_key_wallet",
     "core_key_wallet_manager",
     "core_bincode",
@@ -28,6 +28,7 @@ dash-sdk = { git = "https://github.com/dashpay/platform", rev = "a10190399d7033e
     "core_spv",
     "shielded",
 ] }
+platform-wallet = { path = "../platform/packages/rs-platform-wallet" }
 rs-sdk-trusted-context-provider = { git = "https://github.com/dashpay/platform", rev = "a10190399d7033e7e56e3f756411e9a5dab87829" }
 zip32 = "0.2.0"
 grovestark = { git = "https://www.github.com/dashpay/grovestark", rev = "5b9e289cca54c79b1305d5f4f40bf1148f1eb0e3" }
@@ -113,6 +114,16 @@ name = "det-cli"
 path = "src/bin/det_cli/main.rs"
 required-features = ["cli"]
 
+[[test]]
+name = "e2e"
+path = "tests/e2e/main.rs"
+required-features = ["testing"]
+
+[[test]]
+name = "backend-e2e"
+path = "tests/backend-e2e/main.rs"
+required-features = ["testing"]
+
 [build-dependencies]
 winres = "0.1"
 
@@ -130,3 +141,19 @@ check-cfg = ["cfg(tokio_unstable)", "cfg(feature, values(\"testing\", \"mcp\", \
 [lints.clippy]
 uninlined_format_args = "allow"
 
+# Override the git dashcore crates with local versions (since the platform
+# workspace uses `git = "https://github.com/dashpay/rust-dashcore"` for its
+# dashcore deps and we have local changes in rust-dashcore).
+[patch."https://github.com/dashpay/rust-dashcore"]
+dashcore = { path = "../rust-dashcore/dash" }
+dash-spv = { path = "../rust-dashcore/dash-spv" }
+key-wallet = { path = "../rust-dashcore/key-wallet" }
+key-wallet-manager = { path = "../rust-dashcore/key-wallet-manager" }
+dashcore-rpc = { path = "../rust-dashcore/rpc-client" }
+dashcore-rpc-json = { path = "../rust-dashcore/rpc-json" }
+
+# dashcore_hashes is published on crates.io but we need the local version
+# to match our local dashcore changes.
+[patch.crates-io]
+dashcore_hashes = { path = "../rust-dashcore/hashes" }
+

src/app.rs

@@ -117,6 +117,10 @@ pub struct AppState {
     /// Shared MCP context -- follows network switches via `ArcSwap`.
     #[cfg(feature = "mcp")]
     pub mcp_app_context: Option<Arc<arc_swap::ArcSwap<AppContext>>>,
+    /// Keeps the temporary data directory alive for the lifetime of `AppState`
+    /// when running under the `testing` feature.
+    #[cfg(feature = "testing")]
+    _temp_dir: Option<tempfile::TempDir>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -210,21 +214,31 @@ impl AppState {
         Self::new_inner(ctx, db, data_dir)
     }
 
-    /// Creates a new `AppState` using an in-memory database for testing.
+    /// Creates a new `AppState` using an in-memory database and an isolated
+    /// temporary data directory for testing.
     ///
     /// Available only when the `testing` feature is active. This prevents tests
-    /// from reading or writing the production database.
+    /// from reading or writing the production database and ensures parallel
+    /// tests never share the same data directory.
     #[cfg(feature = "testing")]
     pub fn new(ctx: egui::Context) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
-        let data_dir = app_user_data_dir_path()?;
+        // Create an isolated temp directory so parallel tests never collide.
+        let temp_dir = tempfile::tempdir()
+            .map_err(|e| format!("Failed to create temp data dir: {}", e))?;
+        let data_dir = temp_dir.path().to_path_buf();
         ensure_data_dir_exists(&data_dir)?;
+
+        // Copy the bundled .env.example so Config::load_from succeeds.
         ensure_env_file(&data_dir);
 
         let db = Arc::new(
             crate::database::test_helpers::create_test_database()
                 .map_err(|e| format!("Failed to create test database: {}", e))?,
         );
-        Self::new_inner(ctx, db, data_dir)
+        let mut state = Self::new_inner(ctx, db, data_dir)?;
+        // Keep the temp dir alive for the lifetime of AppState.
+        state._temp_dir = Some(temp_dir);
+        Ok(state)
     }
 
     fn new_inner(
@@ -791,6 +805,8 @@ impl AppState {
             accessibility_retries: 0,
             #[cfg(feature = "mcp")]
             mcp_app_context,
+            #[cfg(feature = "testing")]
+            _temp_dir: None,
         };
 
         // Initialize welcome screen if needed (after mainnet_app_context is owned by the struct)
@@ -879,6 +895,39 @@ impl AppState {
         }
     }
 
+    /// Flush all platform wallet persisters across every network context.
+    ///
+    /// Called during shutdown to ensure any staged-but-unflushed changesets
+    /// (e.g. from `FlushStrategy::Manual`) are written before the process exits.
+    fn flush_all_wallet_persistence(&self) {
+        let contexts: Vec<&Arc<AppContext>> = [
+            Some(&self.mainnet_app_context),
+            self.testnet_app_context.as_ref(),
+            self.devnet_app_context.as_ref(),
+            self.local_app_context.as_ref(),
+        ]
+        .into_iter()
+        .flatten()
+        .collect();
+
+        for ctx in contexts {
+            if let Ok(wallets) = ctx.wallets.read() {
+                for wallet_arc in wallets.values() {
+                    if let Ok(wallet) = wallet_arc.read() {
+                        if let Some(pw) = &wallet.platform_wallet {
+                            if let Err(e) = pw.flush_persist() {
+                                tracing::warn!(
+                                    error = %e,
+                                    "Failed to flush wallet persistence on shutdown"
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     fn context_available_for_network(&self, network: Network) -> bool {
         match network {
             Network::Mainnet => true, // Mainnet is always available
@@ -1200,6 +1249,7 @@ impl App for AppState {
                 MessageType::Warning,
             );
             tracing::debug!("Close requested, starting async shutdown");
+            self.flush_all_wallet_persistence();
             self.shutdown_receiver = Some(self.subtasks.shutdown_async());
             self.shutdown_started = Some(std::time::Instant::now());
             ctx.request_repaint();
@@ -1655,6 +1705,7 @@ impl App for AppState {
             return;
         }
         tracing::debug!("on_exit: fallback blocking shutdown");
+        self.flush_all_wallet_persistence();
         if let Err(e) = self.subtasks.shutdown() {
             tracing::error!("Error during task shutdown: {}", e);
         }

src/backend_task/core/create_asset_lock.rs

@@ -3,6 +3,7 @@ use crate::backend_task::error::TaskError;
 use crate::context::AppContext;
 use crate::model::wallet::Wallet;
 use dash_sdk::dpp::balances::credits::CREDITS_PER_DUFF;
+use dash_sdk::dpp::dashcore::OutPoint;
 use dash_sdk::dpp::fee::Credits;
 use std::sync::{Arc, RwLock};
 
@@ -11,98 +12,125 @@ impl AppContext {
         &self,
         wallet: Arc<RwLock<Wallet>>,
         amount: Credits,
-        allow_take_fee_from_amount: bool,
+        _allow_take_fee_from_amount: bool,
         identity_index: u32,
     ) -> Result<BackendTaskSuccessResult, TaskError> {
         let amount_duffs = amount / CREDITS_PER_DUFF;
 
-        let (asset_lock_transaction, _private_key, _change_address, _used_utxos) = {
-            let mut wallet_guard = wallet.write()?;
-
-            wallet_guard
-                .registration_asset_lock_transaction(
-                    self,
-                    self.network,
-                    amount_duffs,
-                    allow_take_fee_from_amount,
-                    identity_index,
-                    None,
-                )
-                .map_err(|e| TaskError::AssetLockTransactionBuildFailed { detail: e })?
+        let (platform_wallet, _seed_hash) = {
+            let guard = wallet.read()?;
+            let pw = guard
+                .platform_wallet
+                .clone()
+                .ok_or(TaskError::WalletNotFound)?;
+            (pw, guard.seed_hash())
         };
 
-        let tx_id = asset_lock_transaction.txid();
-
-        {
-            let mut proofs = self.transactions_waiting_for_finality.lock()?;
-            proofs.insert(tx_id, None);
-        }
-
-        if let Err(e) = self
-            .broadcast_raw_transaction(&asset_lock_transaction)
+        let (tx, _private_key) = platform_wallet
+            .asset_locks()
+            .build_asset_lock_transaction(
+                amount_duffs,
+                0,
+                platform_wallet::AssetLockFundingType::IdentityRegistration,
+                identity_index,
+            )
             .await
-        {
-            if let Ok(mut proofs) = self.transactions_waiting_for_finality.lock() {
-                proofs.remove(&tx_id);
-            } else {
-                tracing::warn!(
-                    "Failed to clean up finality tracking for tx {tx_id}: Mutex poisoned"
-                );
-            }
-            return Err(e);
-        }
+            .map_err(|e| TaskError::AssetLockTransactionBuildFailed {
+                detail: e.to_string(),
+            })?;
 
-        Ok(BackendTaskSuccessResult::Message(format!(
-            "Asset lock transaction broadcast successfully. TX ID: {}",
-            tx_id
-        )))
+        let result = self
+            .broadcast_and_track_asset_lock_via_manager(
+                tx,
+                amount_duffs,
+                platform_wallet::AssetLockFundingType::IdentityRegistration,
+                identity_index,
+                &platform_wallet,
+            )
+            .await?;
+
+        Ok(result)
     }
 
     pub async fn create_top_up_asset_lock(
         &self,
         wallet: Arc<RwLock<Wallet>>,
         amount: Credits,
-        allow_take_fee_from_amount: bool,
+        _allow_take_fee_from_amount: bool,
         identity_index: u32,
-        top_up_index: u32,
+        _topup_index: u32,
     ) -> Result<BackendTaskSuccessResult, TaskError> {
         let amount_duffs = amount / CREDITS_PER_DUFF;
 
-        let (asset_lock_transaction, _private_key, _change_address, _used_utxos) = {
-            let mut wallet_guard = wallet.write()?;
-
-            wallet_guard
-                .top_up_asset_lock_transaction(
-                    self,
-                    self.network,
-                    amount_duffs,
-                    allow_take_fee_from_amount,
-                    identity_index,
-                    top_up_index,
-                    None,
-                )
-                .map_err(|e| TaskError::AssetLockTransactionBuildFailed { detail: e })?
+        let (platform_wallet, _seed_hash) = {
+            let guard = wallet.read()?;
+            let pw = guard
+                .platform_wallet
+                .clone()
+                .ok_or(TaskError::WalletNotFound)?;
+            (pw, guard.seed_hash())
         };
 
+        let (tx, _private_key) = platform_wallet
+            .asset_locks()
+            .build_asset_lock_transaction(
+                amount_duffs,
+                0,
+                platform_wallet::AssetLockFundingType::IdentityTopUp,
+                identity_index,
+            )
+            .await
+            .map_err(|e| TaskError::AssetLockTransactionBuildFailed {
+                detail: e.to_string(),
+            })?;
+
+        let result = self
+            .broadcast_and_track_asset_lock_via_manager(
+                tx,
+                amount_duffs,
+                platform_wallet::AssetLockFundingType::IdentityTopUp,
+                identity_index,
+                &platform_wallet,
+            )
+            .await?;
+
+        Ok(result)
+    }
+
+    /// Build, register, and broadcast an asset lock transaction via
+    /// AssetLockManager. The TX is tracked internally by the manager;
+    /// the proof will arrive later via SPV events.
+    async fn broadcast_and_track_asset_lock_via_manager(
+        &self,
+        asset_lock_transaction: dash_sdk::dpp::dashcore::Transaction,
+        amount_duffs: u64,
+        funding_type: platform_wallet::AssetLockFundingType,
+        identity_index: u32,
+        platform_wallet: &platform_wallet::PlatformWallet,
+    ) -> Result<BackendTaskSuccessResult, TaskError> {
         let tx_id = asset_lock_transaction.txid();
+        let out_point = OutPoint::new(tx_id, 0);
 
-        {
-            let mut proofs = self.transactions_waiting_for_finality.lock()?;
-            proofs.insert(tx_id, None);
-        }
+        // Register with AssetLockManager so SPV events can resolve it.
+        platform_wallet.asset_locks().recover_asset_lock_blocking(
+            asset_lock_transaction.clone(),
+            amount_duffs,
+            0,
+            funding_type,
+            identity_index,
+            out_point,
+            None,
+        );
 
+        // Broadcast via SPV P2P peers.
         if let Err(e) = self
-            .broadcast_raw_transaction(&asset_lock_transaction)
+            .wallet_manager
+            .broadcast_transaction(&asset_lock_transaction)
             .await
         {
-            if let Ok(mut proofs) = self.transactions_waiting_for_finality.lock() {
-                proofs.remove(&tx_id);
-            } else {
-                tracing::warn!(
-                    "Failed to clean up finality tracking for tx {tx_id}: Mutex poisoned"
-                );
-            }
-            return Err(e);
+            return Err(TaskError::AssetLockTransactionBuildFailed {
+                detail: e.to_string(),
+            });
         }
 
         Ok(BackendTaskSuccessResult::Message(format!(