nano-rspow-python 0.8.0__tar.gz → 0.10.0__tar.gz

{nano_rspow_python-0.8.0 → nano_rspow_python-0.10.0}/Cargo.lock

@@ -739,7 +739,7 @@ dependencies = [
 
 [[package]]
 name = "nano-rspow"
-version = "0.8.0"
+version = "0.10.0"
 dependencies = [
  "blake2b_simd",
  "bytemuck",
@@ -755,7 +755,7 @@ dependencies = [
 
 [[package]]
 name = "nano-rspow-cli"
-version = "0.8.0"
+version = "0.10.0"
 dependencies = [
  "clap",
  "hex",
@@ -766,7 +766,7 @@ dependencies = [
 
 [[package]]
 name = "nano-rspow-node"
-version = "0.8.0"
+version = "0.10.0"
 dependencies = [
  "hex",
  "nano-rspow",
@@ -778,7 +778,7 @@ dependencies = [
 
 [[package]]
 name = "nano-rspow-python"
-version = "0.8.0"
+version = "0.10.0"
 dependencies = [
  "hex",
  "nano-rspow",
@@ -787,7 +787,7 @@ dependencies = [
 
 [[package]]
 name = "nano-rspow-web"
-version = "0.8.0"
+version = "0.10.0"
 dependencies = [
  "bytemuck",
  "getrandom",

{nano_rspow_python-0.8.0 → nano_rspow_python-0.10.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["nano-rspow", "nano-rspow-python"]
 resolver = "2"
 
 [workspace.package]
-version = "0.8.0"
+version = "0.10.0"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/CasualSecurityInc/nano-rspow"

{nano_rspow_python-0.8.0 → nano_rspow_python-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nano-rspow-python
-Version: 0.8.0
+Version: 0.10.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: License :: OSI Approved :: MIT License

{nano_rspow_python-0.8.0 → nano_rspow_python-0.10.0}/nano-rspow/README.md

@@ -1,6 +1,6 @@
 # nano-rspow
 
-nano-rspow is a fast, zero-configuration hybrid CPU/GPU proof-of-work generator and block signing library for [Nano](https://www.nano.org).
+nano-rspow is a fast, zero-configuration hybrid CPU/GPU proof-of-work generator for [Nano](https://www.nano.org).
 
 Developed for high-throughput node operations, client-side web integrations, and native app developers, this repository packages an optimized Blake2b hashing engine under a transparent, auto-detecting **hybrid race architecture**. It seamlessly runs multi-threaded CPU solvers (powered by `rayon` and Web Workers) or GPU pipelines (`wgpu`, `OpenCL`, and WebGPU) depending on target hardware availability. No boilerplate, no device selection headaches—just instant, maximum-performance PoW generation everywhere.
 
@@ -8,7 +8,7 @@ Developed for high-throughput node operations, client-side web integrations, and
 
 ## 🎯 Who is this for?
 
-* **Exchange & Wallet Integrators** wanting low-latency, high-volume block generation and local signing.
+* **Exchange & Wallet Integrators** wanting low-latency, high-volume block generation in-process / without the complexity of adding a another external service.
 * **Server-side Developers** using Node.js or Python who need native bindings running at C-level execution speed.
 * **Frontend Web Developers** building sleek wallets or dApps requiring non-blocking WASM and hardware-accelerated WebGPU directly in user browsers.
 * **Power Users & Node Operators** looking for an ultra-fast benchmarking tool to tune threshold multipliers.
@@ -18,21 +18,24 @@ Developed for high-throughput node operations, client-side web integrations, and
 ## ⚡ Quick Start
 
 ### 1. Standalone CLI
-Compile and run the native generator directly on your machine:
+Install from crates.io (requires a Rust toolchain):
+```bash
+cargo install nano-rspow-cli
+nano-rspow-cli benchmark --count 10
+```
+Alternatively, build from this repository:
 ```bash
-# Build binary in release mode (output at target/release/nano-rspow-cli)
 cargo build -p nano-rspow-cli --release
-
-# Run the compiled binary
 ./target/release/nano-rspow-cli benchmark --count 10
 ```
-Alternatively, you can use `cargo run -p nano-rspow-cli -- <args>` to automatically build and execute in one step.
+Or use `cargo run -p nano-rspow-cli -- <args>` to build and execute in one step.
 
-### 2. Node.js & CLI (Zero-Install)
-Execute the high-performance CLI instantly using precompiled native binaries:
+### 2. Node.js (Programmatic API)
+Use the native bindings for in-process PoW generation:
 ```bash
-npx -p nano-rspow-node nano-rspow generate 718CC2121C3E641059BC1C2CFC45666C99E8AE922F7A807B7D07B62C995D79E2 --backend cpu
+npm install nano-rspow-node
 ```
+See [nano-rspow-node/README.md](nano-rspow-node/README.md) for API usage.
 
 ### 3. Interactive Web Dashboard
 Build and open the self-contained HTML5 benchmarking tool with real-time performance stats, non-blocking Web Worker fallback, WebGPU execution, and customizable cellular-signal difficulty thresholds:
@@ -52,7 +55,7 @@ Below is the directory mapping for each target, along with their primary release
 | **Node.js & TS** | [nano-rspow-node/README.md](nano-rspow-node/README.md) | [Public NPM package](https://www.npmjs.com/package/nano-rspow-node) |
 | **Python** | [nano-rspow-python/](nano-rspow-python/) | [PyPI (pip)](https://pypi.org/project/nano-rspow-python/) |
 | **Web (WASM / WebGPU)** | [nano-rspow-web/README.md](nano-rspow-web/README.md) | [Public NPM package](https://www.npmjs.com/package/nano-rspow-web) + [🎛️ Demo](https://csi.ninzin.net/nano-rspow/) |
-| **CLI Tool** | [nano-rspow-cli/](nano-rspow-cli/) | [GitHub Releases](https://github.com/CasualSecurityInc/nano-rspow/releases) |
+| **CLI Tool** | [nano-rspow-cli/](nano-rspow-cli/) | [crates.io](https://crates.io/crates/nano-rspow-cli) · [GitHub Releases](https://github.com/CasualSecurityInc/nano-rspow/releases) |
 
 ---
 

nano_rspow_python-0.10.0/nano-rspow/src/cpu.rs

@@ -0,0 +1,376 @@
+//! CPU backend: multi-threaded Blake2b PoW generation.
+//!
+//! Uses pre-spun native threads with per-thread mpsc command channels.
+//! Each worker thread independently searches random nonces using
+//! XorShift1024* — the same algorithm as the reference Nano node.
+
+use std::sync::{Arc, atomic::Ordering};
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::sync::atomic::AtomicBool;
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::sync::mpsc::{self, RecvTimeoutError};
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::thread::{self, JoinHandle};
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Duration;
+
+#[cfg(not(target_arch = "wasm32"))]
+use rand::Rng;
+
+use crate::{Backend, CancelToken, GeneratorDiagnostics, difficulty};
+
+/// XorShift1024* PRNG — same algorithm as the reference Nano node's `XorShift1024Star`.
+struct XorShift1024Star {
+    state: [u64; 16],
+    p: usize,
+}
+
+impl XorShift1024Star {
+    fn new(seed: u64) -> Self {
+        // Splitmix64 to populate state from a single seed
+        let mut s = seed;
+        let mut state = [0u64; 16];
+        for x in state.iter_mut() {
+            s = s.wrapping_add(0x9e3779b97f4a7c15);
+            let mut z = s;
+            z = (z ^ (z >> 30)).wrapping_mul(0xbf58476d1ce4e5b9);
+            z = (z ^ (z >> 27)).wrapping_mul(0x94d049bb133111eb);
+            *x = z ^ (z >> 31);
+        }
+        Self { state, p: 0 }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    fn new_from_system() -> Self {
+        Self::new(rand::rng().random())
+    }
+
+    #[inline]
+    fn next(&mut self) -> u64 {
+        let s0 = self.state[self.p];
+        self.p = (self.p + 1) & 15;
+        let mut s1 = self.state[self.p];
+        s1 ^= s1 << 31;
+        self.state[self.p] = s1 ^ s0 ^ (s1 >> 11) ^ (s0 >> 30);
+        self.state[self.p].wrapping_mul(1181783497276652981)
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+enum WorkCommand {
+    Search {
+        hash: [u8; 32],
+        threshold: u64,
+        done: Arc<AtomicBool>,
+        cancel: Arc<AtomicBool>,
+        result_tx: mpsc::Sender<u64>,
+    },
+    Stop,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) struct CpuBackend {
+    threads: Vec<JoinHandle<()>>,
+    senders: Vec<mpsc::Sender<WorkCommand>>,
+}
+
+#[cfg(target_arch = "wasm32")]
+pub(crate) struct CpuBackend;
+
+impl CpuBackend {
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn new() -> Self {
+        let thread_count = std::thread::available_parallelism()
+            .map(|n| n.get())
+            .unwrap_or(4);
+
+        let mut threads = Vec::new();
+        let mut senders = Vec::new();
+
+        for _ in 0..thread_count {
+            let (cmd_tx, cmd_rx) = mpsc::channel::<WorkCommand>();
+            senders.push(cmd_tx);
+
+            threads.push(thread::spawn(move || {
+                let mut rng = XorShift1024Star::new_from_system();
+
+                loop {
+                    let cmd = match cmd_rx.recv() {
+                        Ok(cmd) => cmd,
+                        Err(_) => return,
+                    };
+
+                    match cmd {
+                        WorkCommand::Stop => return,
+                        WorkCommand::Search { hash, threshold, done, cancel, result_tx } => {
+                            const BATCH: usize = 256;
+
+                            loop {
+                                if done.load(Ordering::Relaxed) || cancel.load(Ordering::Relaxed) {
+                                    break;
+                                }
+
+                                for _ in 0..BATCH {
+                                    let nonce = rng.next();
+                                    if difficulty::compute(&hash, nonce) >= threshold {
+                                        if !done.swap(true, Ordering::AcqRel) {
+                                            let _ = result_tx.send(nonce);
+                                        }
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }));
+        }
+
+        Self { threads, senders }
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl Drop for CpuBackend {
+    fn drop(&mut self) {
+        for sender in &self.senders {
+            let _ = sender.send(WorkCommand::Stop);
+        }
+        for thread in self.threads.drain(..) {
+            let _ = thread.join();
+        }
+    }
+}
+
+impl Backend for CpuBackend {
+    fn name(&self) -> &'static str {
+        "cpu"
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    fn generate(&self, hash: &[u8; 32], threshold: u64, cancel: &CancelToken) -> Option<u64> {
+        let done = Arc::new(AtomicBool::new(false));
+        let (result_tx, result_rx) = mpsc::channel();
+
+        for sender in &self.senders {
+            let _ = sender.send(WorkCommand::Search {
+                hash: *hash,
+                threshold,
+                done: Arc::clone(&done),
+                cancel: Arc::clone(&cancel.flag),
+                result_tx: result_tx.clone(),
+            });
+        }
+        drop(result_tx);
+
+        loop {
+            match result_rx.recv_timeout(Duration::from_millis(10)) {
+                Ok(nonce) => return Some(nonce),
+                Err(RecvTimeoutError::Timeout) => {
+                    if cancel.is_cancelled() {
+                        done.store(true, Ordering::Relaxed);
+                        return None;
+                    }
+                }
+                Err(RecvTimeoutError::Disconnected) => return None,
+            }
+        }
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    fn generate(&self, hash: &[u8; 32], threshold: u64, cancel: &CancelToken) -> Option<u64> {
+        let cancelled = Arc::clone(&cancel.flag);
+        let hash = *hash;
+
+        let mut rng = XorShift1024Star::new(rand::random());
+        const BATCH: usize = 256;
+
+        while !cancelled.load(Ordering::Relaxed) {
+            for _ in 0..BATCH {
+                let nonce = rng.next();
+                if difficulty::compute(&hash, nonce) >= threshold {
+                    return Some(nonce);
+                }
+            }
+        }
+        None
+    }
+
+    fn diagnostics(&self) -> GeneratorDiagnostics {
+        GeneratorDiagnostics {
+            backend: "cpu".to_string(),
+            gpu: None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::thresholds;
+
+    #[test]
+    fn xorshift_is_deterministic() {
+        let mut a = XorShift1024Star::new(42);
+        let mut b = XorShift1024Star::new(42);
+        for _ in 0..1000 {
+            assert_eq!(a.next(), b.next());
+        }
+    }
+
+    #[test]
+    fn xorshift_distinct_seeds_differ() {
+        let mut a = XorShift1024Star::new(1);
+        let mut b = XorShift1024Star::new(2);
+        // Should produce different sequences
+        let va: Vec<u64> = (0..10).map(|_| a.next()).collect();
+        let vb: Vec<u64> = (0..10).map(|_| b.next()).collect();
+        assert_ne!(va, vb);
+    }
+
+    #[test]
+    fn cpu_generates_valid_work_dev_threshold() {
+        let hash = [0u8; 32];
+        let backend = CpuBackend::new();
+        let cancel = CancelToken::new();
+        let nonce = backend.generate(&hash, thresholds::DEV, &cancel).unwrap();
+        let diff = difficulty::compute(&hash, nonce);
+        assert!(
+            diff >= thresholds::DEV,
+            "nonce {nonce:#018x} produced difficulty {diff:#018x} < threshold {:#018x}",
+            thresholds::DEV
+        );
+    }
+
+    #[test]
+    fn cpu_respects_cancellation() {
+        let hash = [0u8; 32];
+        let backend = CpuBackend::new();
+        let cancel = CancelToken::new();
+        // Cancel immediately — should return None
+        cancel.cancel();
+        let result = backend.generate(&hash, u64::MAX, &cancel);
+        assert!(result.is_none());
+    }
+
+    /// Round-trip: generate then validate using the same known vectors
+    /// from difficulty.rs.
+    #[test]
+    fn roundtrip_work_validate() {
+        use crate::difficulty;
+
+        // Official known-good test vector hash from the nano-node core implementation
+        let hash = hex::decode("718CC2121C3E641059BC1C2CFC45666C99E8AE922F7A807B7D07B62C995D79E2")
+            .unwrap();
+        let hash: [u8; 32] = hash.try_into().unwrap();
+
+        let backend = CpuBackend::new();
+        let cancel = CancelToken::new();
+        let nonce = backend.generate(&hash, thresholds::DEV, &cancel).unwrap();
+        let diff = difficulty::compute(&hash, nonce);
+        assert!(diff >= thresholds::DEV);
+    }
+
+    #[test]
+    fn cpu_reuses_threads_across_generate_calls() {
+        let hash = [0u8; 32];
+        let backend = CpuBackend::new();
+        let cancel = CancelToken::new();
+
+        // Multiple calls on the same backend should all produce valid work
+        for _ in 0..5 {
+            let nonce = backend.generate(&hash, thresholds::DEV, &cancel).unwrap();
+            let diff = difficulty::compute(&hash, nonce);
+            assert!(
+                diff >= thresholds::DEV,
+                "nonce {nonce:#018x} produced difficulty {diff:#018x} < threshold {:#018x}",
+                thresholds::DEV
+            );
+        }
+    }
+
+    #[test]
+    fn cpu_concurrent_generates_produce_unique_work() {
+        use std::sync::Arc;
+        use std::thread;
+
+        let backend = Arc::new(CpuBackend::new());
+        let hash = [0u8; 32];
+        let cancel = CancelToken::new();
+
+        // Spawn several threads that all call generate() concurrently
+        let handles: Vec<_> = (0..4)
+            .map(|_| {
+                let backend = Arc::clone(&backend);
+                let cancel = cancel.clone();
+                thread::spawn(move || {
+                    backend.generate(&hash, thresholds::DEV, &cancel)
+                })
+            })
+            .collect();
+
+        let mut nonces = Vec::new();
+        for h in handles {
+            if let Some(nonce) = h.join().unwrap() {
+                nonces.push(nonce);
+            }
+        }
+
+        // All nonces should be valid
+        for &nonce in &nonces {
+            let diff = difficulty::compute(&hash, nonce);
+            assert!(diff >= thresholds::DEV);
+        }
+    }
+
+    /// Verifies that drop() cleanly joins threads even when workers were
+    /// mid-search. We spawn generate on a thread, cancel after a short delay,
+    /// drop the backend, and verify the thread returns cleanly.
+    #[test]
+    fn cpu_drop_after_generate_does_not_panic() {
+        use std::thread;
+
+        let hash = [0u8; 32];
+        let backend = CpuBackend::new();
+        let cancel = CancelToken::new();
+
+        let cancel_clone = cancel.clone();
+        let handle = thread::spawn(move || {
+            backend.generate(&hash, u64::MAX, &cancel_clone)
+        });
+
+        thread::sleep(std::time::Duration::from_millis(100));
+        cancel.cancel();
+
+        // Thread should return None or Some (shouldn't hang)
+        let result = handle.join().unwrap();
+        assert!(result.is_none());
+    }
+
+    /// Each worker thread uses system-entropy RNG seeds, so two threads
+    /// searching the same hash should produce different nonce sequences
+    /// and (almost certainly) different winning nonces.
+    #[test]
+    fn cpu_workers_produce_different_nonces() {
+        let hash = [0u8; 32];
+        let backend = CpuBackend::new();
+        let cancel = CancelToken::new();
+
+        let nonce1 = backend.generate(&hash, thresholds::DEV, &cancel).unwrap();
+        let nonce2 = backend.generate(&hash, thresholds::DEV, &cancel).unwrap();
+        let nonce3 = backend.generate(&hash, thresholds::DEV, &cancel).unwrap();
+
+        // Three nonces from a seeded RNG with 2^64 space should all be distinct.
+        assert_ne!(nonce1, nonce2, "same nonce on consecutive generate calls");
+        assert_ne!(nonce2, nonce3, "same nonce on consecutive generate calls");
+    }
+}

nano_rspow_python-0.8.0/nano-rspow/src/cpu.rs

@@ -1,196 +0,0 @@
-//! CPU backend: multi-threaded Blake2b PoW generation.
-//!
-//! Uses rayon for parallelism. Each worker thread independently searches
-//! random nonces using XorShift1024* (same RNG as rsnano-node).
-
-use std::sync::{Arc, atomic::Ordering};
-
-#[cfg(not(target_arch = "wasm32"))]
-use std::sync::atomic::{AtomicBool, AtomicU64};
-
-#[cfg(not(target_arch = "wasm32"))]
-use rayon::prelude::*;
-
-use crate::{Backend, CancelToken, GeneratorDiagnostics, difficulty};
-
-/// XorShift1024* PRNG — same algorithm as rsnano-node's `XorShift1024Star`.
-/// Fast, non-cryptographic, good for PoW nonce exploration.
-struct XorShift1024Star {
-    state: [u64; 16],
-    p: usize,
-}
-
-impl XorShift1024Star {
-    fn new(seed: u64) -> Self {
-        // Splitmix64 to populate state from a single seed
-        let mut s = seed;
-        let mut state = [0u64; 16];
-        for x in state.iter_mut() {
-            s = s.wrapping_add(0x9e3779b97f4a7c15);
-            let mut z = s;
-            z = (z ^ (z >> 30)).wrapping_mul(0xbf58476d1ce4e5b9);
-            z = (z ^ (z >> 27)).wrapping_mul(0x94d049bb133111eb);
-            *x = z ^ (z >> 31);
-        }
-        Self { state, p: 0 }
-    }
-
-    #[inline]
-    fn next(&mut self) -> u64 {
-        let s0 = self.state[self.p];
-        self.p = (self.p + 1) & 15;
-        let mut s1 = self.state[self.p];
-        s1 ^= s1 << 31;
-        self.state[self.p] = s1 ^ s0 ^ (s1 >> 11) ^ (s0 >> 30);
-        self.state[self.p].wrapping_mul(1181783497276652981)
-    }
-}
-
-pub(crate) struct CpuBackend;
-
-impl CpuBackend {
-    pub fn new() -> Self {
-        Self
-    }
-}
-
-impl Backend for CpuBackend {
-    fn name(&self) -> &'static str {
-        "cpu"
-    }
-
-    fn generate(&self, hash: &[u8; 32], threshold: u64, cancel: &CancelToken) -> Option<u64> {
-        let cancelled = Arc::clone(&cancel.flag);
-        let hash = *hash;
-
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let found = Arc::new(AtomicBool::new(false));
-            let result = Arc::new(AtomicU64::new(0));
-
-            // Use rayon's thread pool — one worker per available CPU core.
-            // Each worker starts from a different random seed and searches in batches.
-            let thread_count = rayon::current_num_threads();
-
-            (0..thread_count).into_par_iter().for_each(|thread_idx| {
-                let mut rng = XorShift1024Star::new(
-                    // Distinct seed per thread using splitmix on thread index
-                    thread_idx as u64 ^ 0xdeadbeef_cafebabe,
-                );
-
-                const BATCH: usize = 256;
-
-                while !cancelled.load(Ordering::Relaxed) && !found.load(Ordering::Relaxed) {
-                    for _ in 0..BATCH {
-                        let nonce = rng.next();
-                        if difficulty::compute(&hash, nonce) >= threshold {
-                            // Atomically claim the result
-                            if !found.swap(true, Ordering::AcqRel) {
-                                result.store(nonce, Ordering::Release);
-                            }
-                            return;
-                        }
-                    }
-                }
-            });
-
-            if found.load(Ordering::Acquire) {
-                Some(result.load(Ordering::Acquire))
-            } else {
-                None
-            }
-        }
-
-        #[cfg(target_arch = "wasm32")]
-        {
-            // WASM single-threaded fallback uses a random seed
-            let mut rng = XorShift1024Star::new(rand::random());
-            const BATCH: usize = 256;
-
-            while !cancelled.load(Ordering::Relaxed) {
-                for _ in 0..BATCH {
-                    let nonce = rng.next();
-                    if difficulty::compute(&hash, nonce) >= threshold {
-                        return Some(nonce);
-                    }
-                }
-            }
-            None
-        }
-    }
-
-    fn diagnostics(&self) -> GeneratorDiagnostics {
-        GeneratorDiagnostics {
-            backend: "cpu".to_string(),
-            gpu: None,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::thresholds;
-
-    #[test]
-    fn xorshift_is_deterministic() {
-        let mut a = XorShift1024Star::new(42);
-        let mut b = XorShift1024Star::new(42);
-        for _ in 0..1000 {
-            assert_eq!(a.next(), b.next());
-        }
-    }
-
-    #[test]
-    fn xorshift_distinct_seeds_differ() {
-        let mut a = XorShift1024Star::new(1);
-        let mut b = XorShift1024Star::new(2);
-        // Should produce different sequences
-        let va: Vec<u64> = (0..10).map(|_| a.next()).collect();
-        let vb: Vec<u64> = (0..10).map(|_| b.next()).collect();
-        assert_ne!(va, vb);
-    }
-
-    #[test]
-    fn cpu_generates_valid_work_dev_threshold() {
-        let hash = [0u8; 32];
-        let backend = CpuBackend::new();
-        let cancel = CancelToken::new();
-        let nonce = backend.generate(&hash, thresholds::DEV, &cancel).unwrap();
-        let diff = difficulty::compute(&hash, nonce);
-        assert!(
-            diff >= thresholds::DEV,
-            "nonce {nonce:#018x} produced difficulty {diff:#018x} < threshold {:#018x}",
-            thresholds::DEV
-        );
-    }
-
-    #[test]
-    fn cpu_respects_cancellation() {
-        let hash = [0u8; 32];
-        let backend = CpuBackend::new();
-        let cancel = CancelToken::new();
-        // Cancel immediately — should return None
-        cancel.cancel();
-        let result = backend.generate(&hash, u64::MAX, &cancel);
-        assert!(result.is_none());
-    }
-
-    /// Round-trip: generate then validate using the same known vectors
-    /// from difficulty.rs.
-    #[test]
-    fn roundtrip_work_validate() {
-        use crate::difficulty;
-
-        // Official known-good test vector hash from the nano-node core implementation
-        let hash = hex::decode("718CC2121C3E641059BC1C2CFC45666C99E8AE922F7A807B7D07B62C995D79E2")
-            .unwrap();
-        let hash: [u8; 32] = hash.try_into().unwrap();
-
-        let backend = CpuBackend::new();
-        let cancel = CancelToken::new();
-        let nonce = backend.generate(&hash, thresholds::DEV, &cancel).unwrap();
-        let diff = difficulty::compute(&hash, nonce);
-        assert!(diff >= thresholds::DEV);
-    }
-}