refactor(spv): remove mid-session restart workaround (blocked upstream)

Removes the mid-session wallet import restart workaround introduced in
this branch. The mechanism — restart_spv_for_new_wallet, SpvManager::restart,
SpvManager::try_filter_committed_height, TaskError::SpvRestartFailed, and
four covering tests — is blocked by rust-dashcore#651 (constraint #4):
SegmentCache::first_valid_offset under-reports after a fresh
DiskStorageManager reload, so get_start_height() returns a value near the
chain tip, and FiltersManager re-scans only a single filter instead of
re-covering all historical heights for the new wallet.

register_wallet now unconditionally calls handle_wallet_unlocked on the
SPV path, matching the fresh-start behaviour. Mid-session imports that
need full history rescanning should use the "Clear SPV Data" button
(clear_data_dir / full wipe + resync from checkpoint), which remains
correct and unaffected.

Closes #829. Blocked by rust-dashcore#651.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: lklimek

src/backend_task/error.rs

@@ -667,19 +667,6 @@ pub enum TaskError {
     #[error("Could not broadcast the transaction. Please check your connection and retry.")]
     SpvBroadcastFailed { detail: String },
 
-    /// The SPV client could not be restarted after a mid-session wallet import.
-    ///
-    /// Mid-session imports require a restart so the filter scan can re-cover
-    /// historical heights below the current sync tip. If the restart fails the
-    /// newly imported wallet may show zero balance until the app is restarted.
-    #[error(
-        "Could not restart background sync to discover this wallet's history. Please restart the application to pick up the new wallet."
-    )]
-    SpvRestartFailed {
-        #[source]
-        source: crate::spv::SpvError,
-    },
-
     // ──────────────────────────────────────────────────────────────────────────
     // UTXO / asset-lock transaction build errors
     // ──────────────────────────────────────────────────────────────────────────

src/context/wallet_lifecycle.rs

@@ -143,108 +143,12 @@ impl AppContext {
         // 3. Bootstrap any additional addresses and load into SPV
         self.bootstrap_wallet_addresses(&wallet_arc);
         if self.core_backend_mode() == CoreBackendMode::Spv {
-            // Mid-session imports land here after the SPV loop has already
-            // advanced `filter_committed_height` past any historical heights
-            // where the new wallet may hold UTXOs. `FiltersManager` reads
-            // `earliest_required_height` and `filter_committed_height` at
-            // construction and never rewinds, so simply loading the wallet
-            // into the running WalletManager would leave those heights
-            // unscanned. Restart the SPV run instead — on-disk filters /
-            // headers / blocks are preserved, only the in-memory filter
-            // scanner is rebuilt against the new wallet set.
-            //
-            // Fresh app / first-import path: SPV hasn't scanned anything yet
-            // (filter_committed_height == 0) — the normal wallet-load path is
-            // correct and cheaper. Same for the case where SPV isn't running.
-            // Check filter_committed_height non-blockingly. When the lock is
-            // held (e.g. a concurrent wallet load is in flight) treat it as
-            // "already scanned" to be safe: the cost of an unnecessary restart
-            // is a short re-scan of persisted filters; the cost of skipping a
-            // needed restart is zero balance until the user restarts.
-            let filter_height = self
-                .spv_manager
-                .try_filter_committed_height()
-                .unwrap_or(u32::MAX);
-            let needs_restart = self.spv_manager.status().status.is_active() && filter_height > 0;
-            if needs_restart {
-                self.restart_spv_for_new_wallet();
-            } else {
-                self.handle_wallet_unlocked(&wallet_arc);
-            }
+            self.handle_wallet_unlocked(&wallet_arc);
         }
 
         Ok((seed_hash, wallet_arc))
     }
 
-    /// Restart the SPV run so the filter scanner is rebuilt with the current
-    /// wallet set, then re-queue every wallet load through the normal
-    /// bootstrap path. Called when a new wallet is imported mid-session and
-    /// the existing SPV run has already scanned past historical heights where
-    /// the new wallet may hold UTXOs.
-    ///
-    /// Spawned as a subtask so the caller (sync `register_wallet`) returns
-    /// immediately — the UI continues to render while SPV winds down and
-    /// starts again.
-    pub(crate) fn restart_spv_for_new_wallet(self: &Arc<Self>) {
-        let expected_wallets = self
-            .wallets
-            .read()
-            .map(|guard| {
-                guard
-                    .values()
-                    .filter(|w| {
-                        w.read()
-                            .ok()
-                            .is_some_and(|g| g.is_open() && g.seed_bytes().is_ok())
-                    })
-                    .count()
-            })
-            .unwrap_or(0);
-
-        let progress_banner = crate::ui::components::message_banner::MessageBanner::set_global(
-            self.egui_ctx(),
-            "Restarting background sync to discover this wallet's history.",
-            crate::ui::MessageType::Info,
-        );
-
-        let ctx = Arc::clone(self);
-        self.subtasks
-            .spawn_sync("spv_restart_for_import", async move {
-                let outcome = ctx.spv_manager.restart(expected_wallets).await;
-                // Always clear the progress banner — both paths replace it
-                // with a concrete result message.
-                progress_banner.clear();
-                match outcome {
-                    Ok(()) => {
-                        tracing::info!(
-                            expected_wallets,
-                            "SPV restart completed after wallet import; re-bootstrapping wallets"
-                        );
-                        ctx.connection_status
-                            .set_spv_status(ctx.spv_manager.status().status);
-                        ctx.connection_status.refresh_state();
-                        // `bootstrap_loaded_wallets` re-queues every open wallet via
-                        // `handle_wallet_unlocked -> queue_spv_wallet_load`, which is
-                        // exactly what the restarted SPV's wait loop is blocking on.
-                        ctx.bootstrap_loaded_wallets();
-                    }
-                    Err(err) => {
-                        let task_err = TaskError::SpvRestartFailed { source: err };
-                        tracing::error!(
-                            error = %task_err,
-                            "SPV restart after wallet import failed; newly imported wallet may show a zero balance until the application is restarted"
-                        );
-                        crate::ui::components::message_banner::MessageBanner::set_global(
-                            ctx.egui_ctx(),
-                            &task_err,
-                            crate::ui::MessageType::Error,
-                        )
-                        .with_details(&task_err);
-                    }
-                }
-            });
-    }
-
     pub fn bootstrap_wallet_addresses(&self, wallet: &Arc<RwLock<Wallet>>) {
         if let Ok(mut guard) = wallet.write() {
             // Bootstrap when no addresses exist (fresh wallet) or when

src/spv/manager.rs

@@ -7,7 +7,7 @@ use dash_sdk::dash_spv::client::config::MempoolStrategy;
 use dash_sdk::dash_spv::client::event_handler::EventHandler;
 use dash_sdk::dash_spv::network::NetworkEvent;
 use dash_sdk::dash_spv::network::PeerNetworkManager;
-use dash_sdk::dash_spv::storage::{BlockHeaderStorage, DiskStorageManager};
+use dash_sdk::dash_spv::storage::DiskStorageManager;
 use dash_sdk::dash_spv::sync::SyncEvent;
 use dash_sdk::dash_spv::sync::SyncProgress as SpvSyncProgress;
 use dash_sdk::dash_spv::sync::SyncState;
@@ -711,120 +711,6 @@ impl SpvManager {
         wm.filter_committed_height()
     }
 
-    /// Non-blocking variant of `filter_committed_height`. Returns `None` when
-    /// the WalletManager lock is currently held elsewhere (e.g. a wallet load
-    /// is in flight). Callers on sync paths should treat `None` conservatively.
-    pub fn try_filter_committed_height(&self) -> Option<u32> {
-        self.wallet
-            .try_read()
-            .ok()
-            .map(|wm| wm.filter_committed_height())
-    }
-
-    /// Stop the running SPV loop, wait for it to exit cleanly, then start it
-    /// again with the given expected wallet count.
-    ///
-    /// The on-disk state (headers, filters, blocks) survives the restart — only
-    /// the in-memory `WalletManager`/`FiltersManager` derived state is rebuilt.
-    /// The filter scan re-reads persisted filters against the fresh wallet set
-    /// from genesis (or the earliest birth height), which is the whole point of
-    /// the mid-session import workaround.
-    ///
-    /// Returns once `start()` has been invoked; sync itself runs in the
-    /// background via the main loop task. The caller is expected to re-queue
-    /// wallet loads (e.g. via `bootstrap_loaded_wallets`) after this returns.
-    ///
-    /// Timing: `stop()` cancels the loop asynchronously — this method polls
-    /// the `stop_token` guard until the main loop clears it (see bottom of
-    /// `start()`'s spawned task). If the loop fails to exit within the timeout
-    /// we still try to start again; stale state is cleared by the normal
-    /// `run_spv_loop` setup path.
-    pub async fn restart(self: &Arc<Self>, expected_wallet_count: usize) -> SpvResult<()> {
-        const STOP_WAIT_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
-        const STOP_POLL_INTERVAL: std::time::Duration = std::time::Duration::from_millis(50);
-
-        tracing::info!(
-            expected_wallet_count,
-            "SpvManager::restart() — stopping current run"
-        );
-        self.stop();
-
-        let deadline = tokio::time::Instant::now() + STOP_WAIT_TIMEOUT;
-        loop {
-            let still_running = self
-                .stop_token
-                .lock()
-                .map(|g| g.is_some())
-                .map_err(|_| SpvError::LockPoisoned("stop_token".into()))?;
-            if !still_running {
-                break;
-            }
-            if tokio::time::Instant::now() >= deadline {
-                tracing::warn!(
-                    "SpvManager::restart(): timed out waiting for previous run to exit; starting anyway"
-                );
-                // Clear the stop_token so the next start() isn't a no-op.
-                if let Ok(mut guard) = self.stop_token.lock() {
-                    *guard = None;
-                }
-                break;
-            }
-            tokio::time::sleep(STOP_POLL_INTERVAL).await;
-        }
-
-        // Determine the rescan floor: the earliest block header height stored on
-        // disk. FiltersManager can only iterate heights that have stored headers,
-        // so setting synced_height below this floor triggers missing-header panics.
-        // After stop() the storage Arc is still alive here (cleared in start() setup).
-        let rescan_floor: u32 = {
-            let storage_opt = self
-                .storage
-                .lock()
-                .ok()
-                .and_then(|guard| guard.as_ref().map(Arc::clone));
-            if let Some(storage_arc) = storage_opt {
-                let storage = storage_arc.lock().await;
-                storage.get_start_height().await.unwrap_or(0)
-            } else {
-                0
-            }
-        };
-        tracing::info!(
-            rescan_floor,
-            "SpvManager::restart() — rescan floor determined"
-        );
-
-        // Reset WalletManager's filter_committed_height to the rescan floor so the
-        // next FiltersManager starts scanning from there instead of reading the stale
-        // committed height and declaring itself "already synced".
-        // We reset filter_committed_height (not synced_height) because at
-        // rust-dashcore 309fac8 these became independent fields — FiltersManager::new()
-        // reads filter_committed_height() for its "already synced" guard.
-        // Using get_start_height() as the floor avoids missing-header panics that occur
-        // when iterating below the checkpoint (storage starts there).
-        {
-            let mut wm = self.wallet.write().await;
-            wm.update_filter_committed_height(rescan_floor);
-            tracing::info!(
-                rescan_floor,
-                "SpvManager::restart() — reset WalletManager filter_committed_height to rescan_floor"
-            );
-        }
-
-        // Clear the seed→wallet_id map so bootstrap_loaded_wallets re-imports
-        // cleanly instead of hitting the "wallet already exists" branch.
-        if let Ok(mut wallet_map) = self.det_wallets.write() {
-            wallet_map.clear();
-        }
-
-        tracing::info!(
-            expected_wallet_count,
-            "SpvManager::restart() — starting fresh SPV run"
-        );
-        self.start(expected_wallet_count)
-            .map_err(SpvError::SyncFailed)
-    }
-
     pub fn wallet(&self) -> Arc<AsyncRwLock<WalletManager<ManagedWalletInfo>>> {
         Arc::clone(&self.wallet)
     }