test(rs-platform-wallet/e2e): address review feedback batch — gate live test, framework polish

Restores `#[ignore]` on `transfer_between_two_platform_addresses` so a stock
`cargo test -p platform-wallet --all-features` (the workflow runs heavy
nextest with no env wiring) stays green; live runs now opt in via
`cargo test -- --ignored`. Adds dedicated `Sdk(String)` / `Spv(String)`
variants to `FrameworkError` and routes `SdkBuilder::build` /
`TrustedHttpContextProvider` / DAPI parse / SPV storage / mn-list-sync
failures through them so the underlying error string survives instead
of being swallowed by `NotImplemented(&'static str)`. Plumbs the
slot-locked workdir into `spv::start_spv` / `build_client_config` so
the deferred SPV runtime tracks the cross-process slot lock instead
of sharing `<workdir_base>/spv-data`. Reorders `Registry` mutators
(insert / remove / set_status) to persist the JSON snapshot before
swapping into `self.state` — a failed write now leaves both memory
and disk on the prior state, restoring the module's "persist before
returning" contract. README + transfer.rs doc comments updated to
reflect the gated default.

Addresses thepastaclaw findings on PR #3549:
- 03f92b9df0f8 / 0f93a68e9734 / fb5e6b538a41 (BLOCKING — #[ignore] gate)
- 5ed6efab6c58 / 06120f3487d4 (Sdk/Spv variants)
- 113e838341f5 (slot-locked SPV workdir)
- 41049103cb71 (registry persist-before-mutate)

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

Author: lklimek

packages/rs-platform-wallet/tests/e2e/README.md

@@ -47,12 +47,19 @@ stable enough to drive from tests. See [Future Core support](#future-core-suppor
 - Network access to Dash testnet DAPI nodes (default) or a local/devnet cluster.
 - Rust toolchain (stable, matches workspace `rust-toolchain.toml`).
 
-Tests run by default once `tests/.env` exists with a valid bank mnemonic. They are
-NOT marked `#[ignore]`. If `PLATFORM_WALLET_E2E_BANK_MNEMONIC` is unset or the bank
-is under-funded the harness panics with an actionable message naming the bank's
-primary receive address — the failure is operator-actionable, not silent. CI jobs
-that run `cargo test` without setting up the operator env will surface that panic;
-gate those jobs at the workflow level (e.g. only run e2e on a dedicated job).
+Tests are gated behind `#[ignore]` so a stock `cargo test` (or workspace-wide
+invocation) stays green for contributors and CI jobs that lack a funded testnet
+bank wallet, live DAPI access, and the operator `.env`. To execute the live suite
+once setup is in place, opt in explicitly with `--ignored`:
+
+```bash
+cargo test --test e2e -- --ignored --nocapture
+```
+
+If `PLATFORM_WALLET_E2E_BANK_MNEMONIC` is unset when an opt-in run starts, the
+harness panics with an actionable message naming the bank's primary receive
+address — the failure is operator-actionable, not silent. An under-funded bank
+wallet panics with the same "top up at <address>" pointer.
 
 ---
 

packages/rs-platform-wallet/tests/e2e/cases/transfer.rs

@@ -1,19 +1,20 @@
 //! Self-transfer of credits between two platform-payment addresses
 //! owned by the same test wallet.
 //!
-//! Runs by default (no `#[ignore]`). Operator setup lives in
-//! `tests/.env` (template: `tests/.env.example`). A missing
-//! `PLATFORM_WALLET_E2E_BANK_MNEMONIC` surfaces as a
+//! Gated behind `#[ignore]` so a stock `cargo test -p platform-wallet`
+//! (or workspace-wide invocation) stays green for contributors and CI
+//! jobs that lack a funded testnet bank wallet, live DAPI access, and
+//! the operator `.env`. Operator setup lives in `tests/.env`
+//! (template: `tests/.env.example`); a missing
+//! `PLATFORM_WALLET_E2E_BANK_MNEMONIC` would otherwise surface as a
 //! [`FrameworkError::Bank`](crate::framework::FrameworkError::Bank)
-//! during context init; an under-funded bank wallet panics with the
-//! README's "top up at <address>" pointer so operators get an
-//! actionable target.
+//! during context init, escalated to a panic by `setup().expect(..)`.
 //!
 //! ```bash
 //! cp packages/rs-platform-wallet/tests/.env.example \
 //!    packages/rs-platform-wallet/tests/.env
 //! # edit tests/.env to set PLATFORM_WALLET_E2E_BANK_MNEMONIC
-//! cargo test --test e2e -- --nocapture
+//! cargo test --test e2e -- --ignored --nocapture
 //! ```
 
 use std::collections::BTreeMap;
@@ -60,6 +61,7 @@ const TRANSFER_FLOOR: u64 = 1_000_000;
 const STEP_TIMEOUT: Duration = Duration::from_secs(60);
 
 #[tokio_shared_rt::test(shared)]
+#[ignore = "requires PLATFORM_WALLET_E2E_BANK_MNEMONIC and live testnet access; run with `cargo test -- --ignored`"]
 async fn transfer_between_two_platform_addresses() {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(

packages/rs-platform-wallet/tests/e2e/framework/harness.rs

@@ -137,7 +137,7 @@ impl E2eContext {
         // // Pass the SDK's live address list so SPV peers stay in
         // // lock-step with the DAPI endpoints the SDK is actually
         // // talking to (port-swapped to the effective P2P port).
-        // let spv_runtime = spv::start_spv(&manager, &config, sdk.address_list()).await?;
+        // let spv_runtime = spv::start_spv(&manager, &config, &workdir, sdk.address_list()).await?;
         // spv::wait_for_mn_list_synced(&spv_runtime, SPV_READY_TIMEOUT).await?;
         // // `set_context_provider` is `ArcSwap`-backed, safe to
         // // call after construction.

packages/rs-platform-wallet/tests/e2e/framework/mod.rs

@@ -107,6 +107,19 @@ pub enum FrameworkError {
     /// [`config`].
     #[error("e2e config: {0}")]
     Config(String),
+
+    /// SDK construction / wiring failure (e.g. `SdkBuilder::build`,
+    /// `TrustedHttpContextProvider::new`, DAPI address parsing).
+    /// Carries the upstream error stringified so CI logs and any
+    /// `Result`-matching caller see the underlying cause.
+    #[error("e2e sdk: {0}")]
+    Sdk(String),
+
+    /// SPV (`dash-spv`) construction / sync failure. Distinct from
+    /// [`Self::Sdk`] so SPV-only deferred-runtime issues are easy to
+    /// filter when the SPV path comes back online (Task #15).
+    #[error("e2e spv: {0}")]
+    Spv(String),
 }
 
 /// Convenience alias used across the harness.

packages/rs-platform-wallet/tests/e2e/framework/registry.rs

@@ -97,38 +97,53 @@ impl PersistentTestWalletRegistry {
         &self.path
     }
 
-    /// Insert (or overwrite) an entry, persisting before returning.
-    /// Last-write-wins on duplicate: failing the insert would risk
-    /// leaking the new entry, while a sweep can still recover.
+    /// Insert (or overwrite) an entry, persisting before mutating
+    /// the in-memory map: the snapshot is built off the current state,
+    /// written to disk, and only swapped in once the write succeeds.
+    /// A failed write therefore leaves both memory and disk on the
+    /// previous state — preserving the module's "persist before
+    /// returning" contract under partial failure.
+    /// Last-write-wins on duplicate.
     pub fn insert(&self, hash: WalletSeedHash, entry: RegistryEntry) -> FrameworkResult<()> {
         let snapshot = {
-            let mut guard = self.state.lock();
-            guard.insert(hash, entry);
-            guard.clone()
+            let guard = self.state.lock();
+            let mut snapshot = guard.clone();
+            snapshot.insert(hash, entry);
+            snapshot
         };
-        atomic_write_json(&self.path, &snapshot)
+        atomic_write_json(&self.path, &snapshot)?;
+        *self.state.lock() = snapshot;
+        Ok(())
     }
 
     /// Remove an entry. Missing-key is OK — teardown is best-effort.
+    /// Persists before mutating in-memory state (see [`Self::insert`]).
     pub fn remove(&self, hash: &WalletSeedHash) -> FrameworkResult<()> {
         let snapshot = {
-            let mut guard = self.state.lock();
-            guard.remove(hash);
-            guard.clone()
+            let guard = self.state.lock();
+            let mut snapshot = guard.clone();
+            snapshot.remove(hash);
+            snapshot
         };
-        atomic_write_json(&self.path, &snapshot)
+        atomic_write_json(&self.path, &snapshot)?;
+        *self.state.lock() = snapshot;
+        Ok(())
     }
 
-    /// Update [`EntryStatus`]; no-op if the entry is absent.
+    /// Update [`EntryStatus`]; no-op if the entry is absent. Persists
+    /// before mutating in-memory state (see [`Self::insert`]).
     pub fn set_status(&self, hash: &WalletSeedHash, status: EntryStatus) -> FrameworkResult<()> {
         let snapshot = {
-            let mut guard = self.state.lock();
-            if let Some(entry) = guard.get_mut(hash) {
+            let guard = self.state.lock();
+            let mut snapshot = guard.clone();
+            if let Some(entry) = snapshot.get_mut(hash) {
                 entry.status = status;
             }
-            guard.clone()
+            snapshot
         };
-        atomic_write_json(&self.path, &snapshot)
+        atomic_write_json(&self.path, &snapshot)?;
+        *self.state.lock() = snapshot;
+        Ok(())
     }
 
     /// Snapshot of all entries (Active / Failed). The startup sweep

packages/rs-platform-wallet/tests/e2e/framework/sdk.rs

@@ -34,7 +34,7 @@ pub fn build_sdk(config: &Config) -> FrameworkResult<Arc<Sdk>> {
         .build()
         .map_err(|e| {
             tracing::error!(target: "platform_wallet::e2e::sdk", "SdkBuilder::build failed: {e}");
-            FrameworkError::NotImplemented("sdk::build_sdk — SdkBuilder::build failed (see logs)")
+            FrameworkError::Sdk(format!("SdkBuilder::build failed: {e}"))
         })?;
 
     Ok(Arc::new(sdk))
@@ -70,9 +70,9 @@ fn build_trusted_context_provider(
             target: "platform_wallet::e2e::sdk",
             "TrustedHttpContextProvider construction failed: {e}"
         );
-        FrameworkError::NotImplemented(
-            "sdk::build_trusted_context_provider — TrustedHttpContextProvider failed (see logs)",
-        )
+        FrameworkError::Sdk(format!(
+            "TrustedHttpContextProvider construction failed: {e}"
+        ))
     })
 }
 
@@ -97,9 +97,10 @@ fn build_sdk_builder(config: &Config, network: Network) -> FrameworkResult<SdkBu
                 "no DAPI addresses configured for {other:?} — set {} to a comma-separated list of DAPI URLs",
                 super::config::vars::DAPI_ADDRESSES,
             );
-            Err(FrameworkError::NotImplemented(
-                "sdk::build_sdk_builder — no DAPI addresses configured (see logs)",
-            ))
+            Err(FrameworkError::Config(format!(
+                "no DAPI addresses configured for {other:?} — set {} to a comma-separated list of DAPI URLs",
+                super::config::vars::DAPI_ADDRESSES,
+            )))
         }
     }
 }
@@ -115,9 +116,7 @@ where
                     target: "platform_wallet::e2e::sdk",
                     "invalid DAPI address {s:?}: {e}"
                 );
-                FrameworkError::NotImplemented(
-                    "sdk::parse_addresses — invalid DAPI address (see logs)",
-                )
+                FrameworkError::Config(format!("invalid DAPI address {s:?}: {e}"))
             })
         })
         .collect()

packages/rs-platform-wallet/tests/e2e/framework/spv.rs

@@ -12,6 +12,7 @@
 //! [`PROGRESS_LOG_INTERVAL`] for debuggability.
 
 use std::net::{IpAddr, SocketAddr};
+use std::path::Path;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
@@ -39,9 +40,12 @@ const PROGRESS_LOG_INTERVAL: Duration = Duration::from_secs(30);
 
 /// Spawn the SPV client backing the harness's
 /// [`PlatformWalletManager`]. Storage is anchored under
-/// `config.workdir_base.join("spv-data")`. Returns the same handle
-/// as [`PlatformWalletManager::spv_arc`]; shut it down via
-/// [`SpvRuntime::stop`].
+/// `<workdir>/spv-data` where `workdir` is the slot the harness
+/// already locked via [`super::workdir::pick_available_workdir`] —
+/// concurrent processes get distinct slots and therefore distinct
+/// SPV stores, so RocksDB never sees cross-process contention.
+/// Returns the same handle as [`PlatformWalletManager::spv_arc`];
+/// shut it down via [`SpvRuntime::stop`].
 ///
 /// `address_list` is the SDK's live DAPI address list (typically
 /// `sdk.address_list()`). P2P peers are seeded from those same
@@ -51,13 +55,14 @@ const PROGRESS_LOG_INTERVAL: Duration = Duration::from_secs(30);
 pub async fn start_spv<P>(
     manager: &Arc<PlatformWalletManager<P>>,
     config: &Config,
+    workdir: &Path,
     address_list: &AddressList,
 ) -> FrameworkResult<Arc<SpvRuntime>>
 where
     P: PlatformWalletPersistence + 'static,
 {
     let spv = manager.spv_arc();
-    let client_config = build_client_config(config, address_list)?;
+    let client_config = build_client_config(config, workdir, address_list)?;
 
     spv.spawn_in_background(client_config);
     tracing::info!(
@@ -126,8 +131,8 @@ pub async fn wait_for_mn_list_synced(spv: &SpvRuntime, timeout: Duration) -> Fra
                     target: "platform_wallet::e2e::spv",
                     "mn-list sync entered Error state"
                 );
-                return Err(FrameworkError::NotImplemented(
-                    "spv::wait_for_mn_list_synced — mn-list entered Error state (see logs)",
+                return Err(FrameworkError::Spv(
+                    "wait_for_mn_list_synced: mn-list entered Error state".to_string(),
                 ));
             }
         }
@@ -146,9 +151,9 @@ pub async fn wait_for_mn_list_synced(spv: &SpvRuntime, timeout: Duration) -> Fra
                 target: "platform_wallet::e2e::spv",
                 "timed out after {effective_timeout:?} waiting for mn-list sync"
             );
-            return Err(FrameworkError::NotImplemented(
-                "spv::wait_for_mn_list_synced — timed out (see logs)",
-            ));
+            return Err(FrameworkError::Spv(format!(
+                "wait_for_mn_list_synced: timed out after {effective_timeout:?}"
+            )));
         }
 
         tokio::time::sleep(READINESS_POLL_INTERVAL).await;
@@ -202,27 +207,29 @@ fn log_pipeline_snapshot(
 }
 
 /// Build the SPV [`ClientConfig`] for `config.network`. Storage
-/// under `<workdir>/spv-data`, full validation, bloom-filter
-/// mempool tracking, and DAPI peers (extracted from `address_list`)
-/// seeded with the effective P2P port — sticks to the SDK's live
-/// endpoints to skip DNS-discovered peers that lack compact-block-filter
-/// support.
+/// under `<workdir>/spv-data` (the slot-locked dir, NOT
+/// `workdir_base`), full validation, bloom-filter mempool tracking,
+/// and DAPI peers (extracted from `address_list`) seeded with the
+/// effective P2P port — sticks to the SDK's live endpoints to skip
+/// DNS-discovered peers that lack compact-block-filter support.
 fn build_client_config(
     config: &Config,
+    workdir: &Path,
     address_list: &AddressList,
 ) -> FrameworkResult<ClientConfig> {
     let network = config.network;
 
-    let storage_path = config.workdir_base.join("spv-data");
+    let storage_path = workdir.join("spv-data");
     std::fs::create_dir_all(&storage_path).map_err(|e| {
         tracing::error!(
             target: "platform_wallet::e2e::spv",
             "failed to create SPV storage dir {}: {e}",
             storage_path.display()
         );
-        FrameworkError::NotImplemented(
-            "spv::build_client_config — failed to create SPV storage dir (see logs)",
-        )
+        FrameworkError::Spv(format!(
+            "failed to create SPV storage dir {}: {e}",
+            storage_path.display()
+        ))
     })?;
 
     let mut client_config = ClientConfig::new(network)
@@ -238,9 +245,7 @@ fn build_client_config(
             target: "platform_wallet::e2e::spv",
             "invalid SPV ClientConfig: {e}"
         );
-        FrameworkError::NotImplemented(
-            "spv::build_client_config — invalid SPV ClientConfig (see logs)",
-        )
+        FrameworkError::Spv(format!("invalid SPV ClientConfig: {e}"))
     })?;
 
     Ok(client_config)