nano-rspow-python 0.16.0__tar.gz → 0.17.0__tar.gz

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/Cargo.lock

@@ -757,7 +757,7 @@ dependencies = [
 
 [[package]]
 name = "nano-rspow"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "blake2b_simd",
  "bytemuck",
@@ -773,7 +773,7 @@ dependencies = [
 
 [[package]]
 name = "nano-rspow-cli"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "clap",
  "hex",
@@ -785,14 +785,14 @@ dependencies = [
 
 [[package]]
 name = "nano-rspow-ffi"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "nano-rspow",
 ]
 
 [[package]]
 name = "nano-rspow-node"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "hex",
  "nano-rspow",
@@ -804,7 +804,7 @@ dependencies = [
 
 [[package]]
 name = "nano-rspow-python"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "hex",
  "nano-rspow",
@@ -813,7 +813,7 @@ dependencies = [
 
 [[package]]
 name = "nano-rspow-web"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "bytemuck",
  "getrandom",

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/Cargo.toml

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

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nano-rspow-python
-Version: 0.16.0
+Version: 0.17.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.9
@@ -50,6 +50,7 @@ line protocol as `nano-rspow generate --stream`:
 ```python
 import nano_rspow
 from nano_rspow import WorkType
+from nano_rspow.thresholds import current
 
 root = "718CC2121C3E641059BC1C2CFC45666C99E8AE922F7A807B7D07B62C995D79E2"
 result = nano_rspow.generate_work(root, WorkType.Send)
@@ -57,6 +58,12 @@ result = nano_rspow.generate_work(root, WorkType.Send)
 print(result.nonce_hex)
 assert result.is_valid
 assert nano_rspow.validate_work(root, result.nonce_hex, WorkType.Send)
+assert current.SEND == 0xfffffff800000000
+
+# Use an arbitrary threshold when a node requires more than the public floor.
+threshold = "fffffff900000000"
+result = nano_rspow.generate_work_with_threshold(root, threshold)
+assert nano_rspow.validate_work_with_threshold(root, result.nonce_hex, threshold)
 ```
 
 ## API reference
@@ -69,6 +76,15 @@ Generates work for a 32-byte hexadecimal block root. Raises `ValueError` for inv
 
 Tests a hexadecimal nonce against a block root and the threshold selected by `work_type`. Raises `ValueError` for invalid input.
 
+### `generate_work_with_threshold(hash_hex, threshold_hex) -> WorkResult`
+
+Generates work for any hexadecimal threshold. Use it when a node requires a
+stricter threshold than the public Nano floor or when handling historical data.
+
+### `validate_work_with_threshold(hash_hex, work_hex, threshold_hex) -> bool`
+
+Validates a nonce against any hexadecimal threshold.
+
 ### `compute_difficulty(hash_hex, nonce_hex) -> str`
 
 Returns the raw difficulty as a 16-character lowercase hexadecimal string. Raises `ValueError` for invalid input.
@@ -81,10 +97,8 @@ Returns the selected backend name, such as `cpu`, `wgpu`, or `opencl`.
 
 | Value | Use |
 | --- | --- |
-| `Send` | Epoch 2 send and change blocks |
-| `Receive` | Epoch 2 receive blocks |
-| `LegacyEpoch1` | Historical epoch-1 validation only |
-| `Epoch1` | Compatibility alias for `LegacyEpoch1` |
+| `Send` | Current send and change blocks |
+| `Receive` | Current receive, open, and epoch blocks |
 
 ### `WorkResult`
 
@@ -92,5 +106,14 @@ Returns the selected backend name, such as `cpu`, `wgpu`, or `opencl`.
 
 ### `thresholds`
 
-The `nano_rspow.thresholds` submodule provides `EPOCH2_SEND`, `EPOCH2_RECEIVE`, `LEGACY_EPOCH1`, `EPOCH1`, `BETA_LEGACY_EPOCH1`, `BETA_EPOCH1`, `DEV`, and `BASE`.
+The `nano_rspow.thresholds` submodule separates values by applicability:
+
+- `thresholds.current.SEND` and `.RECEIVE` are the current public mainnet floors.
+- `thresholds.legacy.EPOCH1` and `.BETA_EPOCH1` are historical values.
+- `thresholds.testing.DEV` is for tests only.
+
+Nano nodes may require a stricter arbitrary threshold. Use the explicit
+custom-threshold APIs for that case. See Nano's
+[Work Generation guide](https://docs.nano.org/integration-guides/work-generation/)
+for current network requirements.
 

{nano_rspow_python-0.16.0/nano-rspow-python → nano_rspow_python-0.17.0}/README.md

@@ -26,6 +26,7 @@ line protocol as `nano-rspow generate --stream`:
 ```python
 import nano_rspow
 from nano_rspow import WorkType
+from nano_rspow.thresholds import current
 
 root = "718CC2121C3E641059BC1C2CFC45666C99E8AE922F7A807B7D07B62C995D79E2"
 result = nano_rspow.generate_work(root, WorkType.Send)
@@ -33,6 +34,12 @@ result = nano_rspow.generate_work(root, WorkType.Send)
 print(result.nonce_hex)
 assert result.is_valid
 assert nano_rspow.validate_work(root, result.nonce_hex, WorkType.Send)
+assert current.SEND == 0xfffffff800000000
+
+# Use an arbitrary threshold when a node requires more than the public floor.
+threshold = "fffffff900000000"
+result = nano_rspow.generate_work_with_threshold(root, threshold)
+assert nano_rspow.validate_work_with_threshold(root, result.nonce_hex, threshold)
 ```
 
 ## API reference
@@ -45,6 +52,15 @@ Generates work for a 32-byte hexadecimal block root. Raises `ValueError` for inv
 
 Tests a hexadecimal nonce against a block root and the threshold selected by `work_type`. Raises `ValueError` for invalid input.
 
+### `generate_work_with_threshold(hash_hex, threshold_hex) -> WorkResult`
+
+Generates work for any hexadecimal threshold. Use it when a node requires a
+stricter threshold than the public Nano floor or when handling historical data.
+
+### `validate_work_with_threshold(hash_hex, work_hex, threshold_hex) -> bool`
+
+Validates a nonce against any hexadecimal threshold.
+
 ### `compute_difficulty(hash_hex, nonce_hex) -> str`
 
 Returns the raw difficulty as a 16-character lowercase hexadecimal string. Raises `ValueError` for invalid input.
@@ -57,10 +73,8 @@ Returns the selected backend name, such as `cpu`, `wgpu`, or `opencl`.
 
 | Value | Use |
 | --- | --- |
-| `Send` | Epoch 2 send and change blocks |
-| `Receive` | Epoch 2 receive blocks |
-| `LegacyEpoch1` | Historical epoch-1 validation only |
-| `Epoch1` | Compatibility alias for `LegacyEpoch1` |
+| `Send` | Current send and change blocks |
+| `Receive` | Current receive, open, and epoch blocks |
 
 ### `WorkResult`
 
@@ -68,4 +82,13 @@ Returns the selected backend name, such as `cpu`, `wgpu`, or `opencl`.
 
 ### `thresholds`
 
-The `nano_rspow.thresholds` submodule provides `EPOCH2_SEND`, `EPOCH2_RECEIVE`, `LEGACY_EPOCH1`, `EPOCH1`, `BETA_LEGACY_EPOCH1`, `BETA_EPOCH1`, `DEV`, and `BASE`.
+The `nano_rspow.thresholds` submodule separates values by applicability:
+
+- `thresholds.current.SEND` and `.RECEIVE` are the current public mainnet floors.
+- `thresholds.legacy.EPOCH1` and `.BETA_EPOCH1` are historical values.
+- `thresholds.testing.DEV` is for tests only.
+
+Nano nodes may require a stricter arbitrary threshold. Use the explicit
+custom-threshold APIs for that case. See Nano's
+[Work Generation guide](https://docs.nano.org/integration-guides/work-generation/)
+for current network requirements.

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow/README.md

@@ -4,6 +4,16 @@ nano-rspow generates and validates [Nano](https://www.nano.org) proof of work on
 
 The native core selects an available GPU backend when possible and otherwise uses its multi-threaded CPU backend. The browser package tries WebGPU, then falls back to single-threaded WebAssembly CPU execution.
 
+## Current Nano thresholds
+
+For current Nano mainnet blocks, use the send/change floor
+`fffffff800000000` or the receive/open/epoch floor `fffffe0000000000`.
+These are convenience presets, not an upper limit: every binding also accepts
+an arbitrary threshold when the node that will publish the block requires a
+stricter value. Historical Epoch 1 thresholds are isolated in explicitly named
+legacy APIs. See Nano's [Work Generation guide](https://docs.nano.org/integration-guides/work-generation/)
+for the network requirements.
+
 ---
 
 ## 🎯 Who is this for?

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow/benches/pow_benchmark.rs

@@ -4,13 +4,13 @@
 //!
 //! Tiers mirror the CLI `benchmark` command:
 //!   dev        0xfe00000000000000  (very low — fast iteration)
-//!   ep2_recv   0xfffffe0000000000  (epoch-2 receive — common real-world)
+//!   receive    0xfffffe0000000000  (current receive/open/epoch)
 //!   legacy_epoch1  0xffffffc000000000  (legacy-only)
-//!   ep2_send   0xfffffff800000000  (epoch-2 send/change — hardest)
+//!   send       0xfffffff800000000  (current send/change)
 //!
 //! CPU benchmarks run at `dev` threshold only (higher tiers take 1-2 s each,
 //! making Criterion wall-time impractical).  GPU benchmarks run at `dev` and
-//! `ep2_recv`; `legacy_epoch1` and `ep2_send` are included but marked slow so
+//! `receive`; `legacy_epoch1` and `send` are included but marked slow so
 //! they only run when specifically requested (`cargo bench -- legacy_epoch1`).
 
 use criterion::{Criterion, SamplingMode, Throughput, criterion_group, criterion_main};
@@ -25,7 +25,7 @@ const BENCH_HASH: [u8; 32] = [
 // ── difficulty_compute ────────────────────────────────────────────────────────
 
 fn bench_difficulty(c: &mut Criterion) {
-    // Official known-good nonce for BENCH_HASH at epoch-2-send threshold.
+    // Official known-good nonce for BENCH_HASH at the current send threshold.
     let nonce = 0x2bf29ef00786a6bc_u64;
     c.bench_function("difficulty_compute", |b| {
         b.iter(|| difficulty::compute(&BENCH_HASH, std::hint::black_box(nonce)));
@@ -41,7 +41,7 @@ fn bench_cpu_generation(c: &mut Criterion) {
     // Only dev threshold: higher tiers take 1-2 s per sample.
     group.bench_function("dev", |b| {
         let generator = nano_rspow::WorkGenerator::cpu();
-        b.iter(|| generator.generate(&BENCH_HASH, thresholds::DEV).unwrap());
+        b.iter(|| generator.generate(&BENCH_HASH, thresholds::testing::DEV).unwrap());
     });
 
     group.finish();
@@ -65,13 +65,13 @@ fn bench_gpu_generation(c: &mut Criterion) {
         group.throughput(Throughput::Elements(1));
 
         group.bench_function("dev", |b| {
-            b.iter(|| generator.generate(&BENCH_HASH, thresholds::DEV).unwrap());
+            b.iter(|| generator.generate(&BENCH_HASH, thresholds::testing::DEV).unwrap());
         });
 
-        group.bench_function("ep2_recv", |b| {
+        group.bench_function("receive", |b| {
             b.iter(|| {
                 generator
-                    .generate(&BENCH_HASH, thresholds::EPOCH2_RECEIVE)
+                    .generate(&BENCH_HASH, thresholds::current::RECEIVE)
                     .unwrap()
             });
         });
@@ -88,13 +88,13 @@ fn bench_gpu_generation(c: &mut Criterion) {
         group.sampling_mode(SamplingMode::Flat);
 
         group.bench_function("legacy_epoch1", |b| {
-            b.iter(|| generator.generate(&BENCH_HASH, thresholds::LEGACY_EPOCH1).unwrap());
+            b.iter(|| generator.generate(&BENCH_HASH, thresholds::legacy::EPOCH1).unwrap());
         });
 
-        group.bench_function("ep2_send", |b| {
+        group.bench_function("send", |b| {
             b.iter(|| {
                 generator
-                    .generate(&BENCH_HASH, thresholds::EPOCH2_SEND)
+                    .generate(&BENCH_HASH, thresholds::current::SEND)
                     .unwrap()
             });
         });

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow/src/cpu.rs

@@ -242,12 +242,12 @@ mod tests {
         let hash = [0u8; 32];
         let backend = CpuBackend::new();
         let cancel = CancelToken::new();
-        let nonce = backend.generate(&hash, thresholds::DEV, &cancel).unwrap();
+        let nonce = backend.generate(&hash, thresholds::testing::DEV, &cancel).unwrap();
         let diff = difficulty::compute(&hash, nonce);
         assert!(
-            diff >= thresholds::DEV,
+            diff >= thresholds::testing::DEV,
             "nonce {nonce:#018x} produced difficulty {diff:#018x} < threshold {:#018x}",
-            thresholds::DEV
+            thresholds::testing::DEV
         );
     }
 
@@ -275,9 +275,9 @@ mod tests {
 
         let backend = CpuBackend::new();
         let cancel = CancelToken::new();
-        let nonce = backend.generate(&hash, thresholds::DEV, &cancel).unwrap();
+        let nonce = backend.generate(&hash, thresholds::testing::DEV, &cancel).unwrap();
         let diff = difficulty::compute(&hash, nonce);
-        assert!(diff >= thresholds::DEV);
+        assert!(diff >= thresholds::testing::DEV);
     }
 
     #[test]
@@ -288,12 +288,12 @@ mod tests {
 
         // 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 nonce = backend.generate(&hash, thresholds::testing::DEV, &cancel).unwrap();
             let diff = difficulty::compute(&hash, nonce);
             assert!(
-                diff >= thresholds::DEV,
+                diff >= thresholds::testing::DEV,
                 "nonce {nonce:#018x} produced difficulty {diff:#018x} < threshold {:#018x}",
-                thresholds::DEV
+                thresholds::testing::DEV
             );
         }
     }
@@ -313,7 +313,7 @@ mod tests {
                 let backend = Arc::clone(&backend);
                 let cancel = cancel.clone();
                 thread::spawn(move || {
-                    backend.generate(&hash, thresholds::DEV, &cancel)
+                    backend.generate(&hash, thresholds::testing::DEV, &cancel)
                 })
             })
             .collect();
@@ -328,7 +328,7 @@ mod tests {
         // All nonces should be valid
         for &nonce in &nonces {
             let diff = difficulty::compute(&hash, nonce);
-            assert!(diff >= thresholds::DEV);
+            assert!(diff >= thresholds::testing::DEV);
         }
     }
 
@@ -365,9 +365,9 @@ mod tests {
         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();
+        let nonce1 = backend.generate(&hash, thresholds::testing::DEV, &cancel).unwrap();
+        let nonce2 = backend.generate(&hash, thresholds::testing::DEV, &cancel).unwrap();
+        let nonce3 = backend.generate(&hash, thresholds::testing::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");

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow/src/difficulty.rs

@@ -73,7 +73,7 @@ mod tests {
             "difficulty mismatch: got {actual:#018x}, expected {expected_difficulty:#018x}"
         );
         assert!(
-            actual >= thresholds::LEGACY_EPOCH1,
+            actual >= thresholds::legacy::EPOCH1,
             "work must meet legacy epoch1 threshold"
         );
     }
@@ -87,7 +87,7 @@ mod tests {
 
         let actual = compute(&hash, work);
         assert_eq!(actual, expected_difficulty);
-        assert!(actual >= thresholds::LEGACY_EPOCH1);
+        assert!(actual >= thresholds::legacy::EPOCH1);
     }
 
     /// Vector 3 — boundary: work exactly at the legacy epoch-1 threshold should be valid.
@@ -96,7 +96,7 @@ mod tests {
         // We brute-force a nonce that's right at the boundary using CPU search
         // (very low dev threshold for speed)
         let hash = [0u8; 32];
-        let threshold = thresholds::DEV; // Very low — tests finish fast
+        let threshold = thresholds::testing::DEV; // Very low — tests finish fast
 
         // Search for a valid nonce
         let nonce = (0u64..).find(|&n| compute(&hash, n) >= threshold).unwrap();
@@ -110,7 +110,7 @@ mod tests {
         // work = 0 almost certainly produces difficulty below any real threshold
         let hash = hex_to_array("718CC2121C3E641059BC1C2CFC45666C99E8AE922F7A807B7D07B62C995D79E2");
         let work = 0u64;
-        assert!(!is_valid(&hash, work, thresholds::LEGACY_EPOCH1));
+        assert!(!is_valid(&hash, work, thresholds::legacy::EPOCH1));
     }
 
     /// Vector 5 — determinism: same inputs always produce same output.

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow/src/lib.rs

@@ -16,7 +16,7 @@
 //!
 //! // Validate a known-good work value (nonce) matching the above test vector
 //! let work = u64::from_str_radix("2bf29ef00786a6bc", 16).unwrap();
-//! let result = nano_rspow::work_validate(&hash, work, thresholds::LEGACY_EPOCH1);
+//! let result = nano_rspow::work_validate(&hash, work, thresholds::current::RECEIVE);
 //! assert!(result.is_valid());
 //! ```
 
@@ -221,7 +221,7 @@ pub fn recommend_local_pow() -> bool {
 
         let estimated_total_hps = hashes_per_sec * core_count;
         
-        // Target: ~15 MH/s minimum for reasonable EPOCH2_SEND speed
+        // Target: ~15 MH/s minimum for reasonable current send-threshold speed.
         estimated_total_hps >= 15_000_000.0
     };
 
@@ -260,7 +260,7 @@ mod tests {
     fn assert_repeated_generate_valid(generator: &WorkGenerator) {
         let hash = test_hash();
         for _ in 0..3 {
-            let result = generator.generate(&hash, thresholds::DEV).unwrap();
+            let result = generator.generate(&hash, thresholds::testing::DEV).unwrap();
             assert!(result.is_valid());
         }
     }
@@ -272,7 +272,7 @@ mod tests {
         for _ in 0..4 {
             let g = Arc::clone(&g);
             handles.push(thread::spawn(move || {
-                let result = g.generate(&hash, thresholds::DEV).unwrap();
+                let result = g.generate(&hash, thresholds::testing::DEV).unwrap();
                 assert!(result.is_valid());
             }));
         }

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow/src/opencl_backend/mod.rs

@@ -27,7 +27,9 @@ impl OpenClBackend {
     pub fn new(_config: OpenClConfig) -> Result<Self, WorkError> {
         let platforms = ocl::core::get_platform_ids();
         if platforms.is_err() || platforms.as_ref().map(|p| p.is_empty()).unwrap_or(true) {
-            return Err(WorkError::GpuInit("No OpenCL platforms available".to_string()));
+            return Err(WorkError::GpuInit(
+                "No OpenCL platforms available".to_string(),
+            ));
         }
 
         let pro_que = ProQue::builder()
@@ -83,8 +85,8 @@ impl Backend for OpenClBackend {
 
         // Convert the 32-byte hash into 4 x u64 (little-endian)
         let mut h = [0u64; 4];
-        for (i, chunk) in hash.chunks_exact(8).enumerate() {
-            h[i] = u64::from_le_bytes(chunk.try_into().unwrap());
+        for (output, chunk) in h.iter_mut().zip(hash.as_chunks::<8>().0) {
+            *output = u64::from_le_bytes(*chunk);
         }
 
         let mut base_nonce: u64 = rand::random();

nano_rspow_python-0.17.0/nano-rspow/src/thresholds.rs

@@ -0,0 +1,75 @@
+//! Nano PoW threshold presets.
+//!
+//! Use [`current`] for blocks published to current Nano mainnet nodes. The
+//! [`legacy`] and [`testing`] modules are deliberately separate so historical
+//! and test-only values are not mistaken for current network requirements.
+//!
+//! Source: rsnano-node `work/src/work_thresholds.rs` and the original
+//! C++ nano-node `nano/lib/work.cpp`.
+
+/// Current Nano mainnet minimum thresholds.
+pub mod current {
+    /// Minimum threshold for send and change blocks.
+    pub const SEND: u64 = 0xfffffff800000000;
+
+    /// Minimum threshold for receive, open, and epoch blocks.
+    pub const RECEIVE: u64 = 0xfffffe0000000000;
+}
+
+/// Historical thresholds for validating or benchmarking Epoch 1 blocks.
+pub mod legacy {
+    /// Epoch 1 mainnet threshold.
+    ///
+    /// This value is not required when publishing a current mainnet block.
+    pub const EPOCH1: u64 = 0xffffffc000000000;
+
+    /// Epoch 1 beta-network threshold.
+    pub const BETA_EPOCH1: u64 = 0xfffff00000000000;
+}
+
+/// Non-mainnet thresholds intended only for development and tests.
+pub mod testing {
+    /// Low-difficulty development threshold.
+    pub const DEV: u64 = 0xfe00000000000000;
+}
+
+/// Compute a difficulty multiplier relative to a base threshold.
+///
+/// A multiplier of 1.0 means exactly at base difficulty. >1.0 means harder.
+pub fn to_multiplier(difficulty: u64, base: u64) -> f64 {
+    debug_assert!(base > 0);
+    let max = u64::MAX as f64;
+    (max - base as f64) / (max - difficulty as f64)
+}
+
+/// Compute the difficulty from a multiplier and base threshold.
+pub fn from_multiplier(multiplier: f64, base: u64) -> u64 {
+    debug_assert!(multiplier >= 1.0);
+    let max = u64::MAX as f64;
+    u64::MAX - ((max - base as f64) / multiplier) as u64
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn current_send_is_eight_times_legacy_epoch1() {
+        let m = to_multiplier(current::SEND, legacy::EPOCH1);
+        assert!((m - 8.0).abs() < 0.01, "expected 8.0, got {m}");
+    }
+
+    #[test]
+    fn current_receive_is_one_eighth_of_legacy_epoch1() {
+        let m = to_multiplier(current::RECEIVE, legacy::EPOCH1);
+        assert!((m - 0.125).abs() < 0.001, "expected 0.125, got {m}");
+    }
+
+    #[test]
+    fn roundtrip_multiplier() {
+        let m = 2.5_f64;
+        let d = from_multiplier(m, current::SEND);
+        let m2 = to_multiplier(d, current::SEND);
+        assert!((m - m2).abs() < 0.001);
+    }
+}

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow/src/types.rs

@@ -26,7 +26,7 @@ impl WorkResult {
         self.difficulty >= self.threshold
     }
 
-    /// Returns the multiplier relative to the epoch 2 base threshold.
+    /// Returns the multiplier relative to this result's required threshold.
     pub fn multiplier(&self) -> f64 {
         thresholds::to_multiplier(self.difficulty, self.threshold)
     }
@@ -128,7 +128,7 @@ mod tests {
         let r = WorkResult {
             nonce: 0x2bf29ef00786a6bc,
             difficulty: 0xffffffd21c3933f4,
-            threshold: thresholds::LEGACY_EPOCH1,
+            threshold: thresholds::legacy::EPOCH1,
         };
         assert!(r.is_valid());
         assert_eq!(r.nonce_hex(), "2bf29ef00786a6bc");
@@ -139,7 +139,7 @@ mod tests {
         let r = WorkResult {
             nonce: 0,
             difficulty: 0,
-            threshold: thresholds::LEGACY_EPOCH1,
+            threshold: thresholds::legacy::EPOCH1,
         };
         assert!(!r.is_valid());
     }

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow/src/wgpu_backend/mod.rs

@@ -435,11 +435,11 @@ impl Backend for WgpuBackend {
 
         let mut hash0 = [0u32; 4];
         let mut hash1 = [0u32; 4];
-        for (i, chunk) in hash[..16].chunks_exact(4).enumerate() {
-            hash0[i] = u32::from_le_bytes(chunk.try_into().unwrap());
+        for (output, chunk) in hash0.iter_mut().zip(hash[..16].as_chunks::<4>().0) {
+            *output = u32::from_le_bytes(*chunk);
         }
-        for (i, chunk) in hash[16..].chunks_exact(4).enumerate() {
-            hash1[i] = u32::from_le_bytes(chunk.try_into().unwrap());
+        for (output, chunk) in hash1.iter_mut().zip(hash[16..].as_chunks::<4>().0) {
+            *output = u32::from_le_bytes(*chunk);
         }
 
         let threshold_lo = threshold as u32;

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0/nano-rspow-python}/README.md

@@ -26,6 +26,7 @@ line protocol as `nano-rspow generate --stream`:
 ```python
 import nano_rspow
 from nano_rspow import WorkType
+from nano_rspow.thresholds import current
 
 root = "718CC2121C3E641059BC1C2CFC45666C99E8AE922F7A807B7D07B62C995D79E2"
 result = nano_rspow.generate_work(root, WorkType.Send)
@@ -33,6 +34,12 @@ result = nano_rspow.generate_work(root, WorkType.Send)
 print(result.nonce_hex)
 assert result.is_valid
 assert nano_rspow.validate_work(root, result.nonce_hex, WorkType.Send)
+assert current.SEND == 0xfffffff800000000
+
+# Use an arbitrary threshold when a node requires more than the public floor.
+threshold = "fffffff900000000"
+result = nano_rspow.generate_work_with_threshold(root, threshold)
+assert nano_rspow.validate_work_with_threshold(root, result.nonce_hex, threshold)
 ```
 
 ## API reference
@@ -45,6 +52,15 @@ Generates work for a 32-byte hexadecimal block root. Raises `ValueError` for inv
 
 Tests a hexadecimal nonce against a block root and the threshold selected by `work_type`. Raises `ValueError` for invalid input.
 
+### `generate_work_with_threshold(hash_hex, threshold_hex) -> WorkResult`
+
+Generates work for any hexadecimal threshold. Use it when a node requires a
+stricter threshold than the public Nano floor or when handling historical data.
+
+### `validate_work_with_threshold(hash_hex, work_hex, threshold_hex) -> bool`
+
+Validates a nonce against any hexadecimal threshold.
+
 ### `compute_difficulty(hash_hex, nonce_hex) -> str`
 
 Returns the raw difficulty as a 16-character lowercase hexadecimal string. Raises `ValueError` for invalid input.
@@ -57,10 +73,8 @@ Returns the selected backend name, such as `cpu`, `wgpu`, or `opencl`.
 
 | Value | Use |
 | --- | --- |
-| `Send` | Epoch 2 send and change blocks |
-| `Receive` | Epoch 2 receive blocks |
-| `LegacyEpoch1` | Historical epoch-1 validation only |
-| `Epoch1` | Compatibility alias for `LegacyEpoch1` |
+| `Send` | Current send and change blocks |
+| `Receive` | Current receive, open, and epoch blocks |
 
 ### `WorkResult`
 
@@ -68,4 +82,13 @@ Returns the selected backend name, such as `cpu`, `wgpu`, or `opencl`.
 
 ### `thresholds`
 
-The `nano_rspow.thresholds` submodule provides `EPOCH2_SEND`, `EPOCH2_RECEIVE`, `LEGACY_EPOCH1`, `EPOCH1`, `BETA_LEGACY_EPOCH1`, `BETA_EPOCH1`, `DEV`, and `BASE`.
+The `nano_rspow.thresholds` submodule separates values by applicability:
+
+- `thresholds.current.SEND` and `.RECEIVE` are the current public mainnet floors.
+- `thresholds.legacy.EPOCH1` and `.BETA_EPOCH1` are historical values.
+- `thresholds.testing.DEV` is for tests only.
+
+Nano nodes may require a stricter arbitrary threshold. Use the explicit
+custom-threshold APIs for that case. See Nano's
+[Work Generation guide](https://docs.nano.org/integration-guides/work-generation/)
+for current network requirements.

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow-python/nano_rspow.pyi

@@ -9,16 +9,12 @@ class WorkType(IntEnum):
     """Nano network work type — determines the difficulty threshold.
 
     Values:
-        Send:    Epoch 2 send/change threshold (0xfffffff800000000)
-        Receive: Epoch 2 receive threshold     (0xfffffe0000000000)
-        LegacyEpoch1: Legacy threshold only     (0xffffffc000000000)
-        Epoch1: LegacyEpoch1 compatibility alias (deprecated)
+        Send:    Current send/change threshold (0xfffffff800000000)
+        Receive: Current receive/open/epoch threshold (0xfffffe0000000000)
     """
 
     Send = 0
     Receive = 1
-    Epoch1 = 2
-    LegacyEpoch1 = 3
 
 class WorkResult:
     """The result of a PoW generation or validation.
@@ -83,6 +79,10 @@ def validate_work(hash_hex: str, work_hex: str, work_type: WorkType) -> bool:
     """
     ...
 
+def validate_work_with_threshold(hash_hex: str, work_hex: str, threshold_hex: str) -> bool:
+    """Validate a nonce against an arbitrary hexadecimal threshold."""
+    ...
+
 def compute_difficulty(hash_hex: str, nonce_hex: str) -> str:
     """Compute the raw PoW difficulty for a hash+nonce pair.
 
@@ -110,32 +110,18 @@ def cli_main() -> int:
     ...
 
 class thresholds:
-    """Nano PoW threshold constants for all network epochs.
-
-    Constants are sourced from the Rust core library and match
-    the values used by rsnano-node and the C++ nano-node.
-    """
-
-    EPOCH2_SEND: int
-    """Epoch 2 send/change threshold (current live network default for sends)."""
-
-    EPOCH2_RECEIVE: int
-    """Epoch 2 receive threshold."""
-
-    LEGACY_EPOCH1: int
-    """Legacy epoch 1 threshold; not for current mainnet epoch blocks."""
-
-    EPOCH1: int
-    """Deprecated compatibility alias for LEGACY_EPOCH1."""
-
-    BETA_LEGACY_EPOCH1: int
-    """Beta network legacy epoch 1 threshold."""
+    """Grouped threshold presets from the Rust core library."""
 
-    BETA_EPOCH1: int
-    """Deprecated compatibility alias for BETA_LEGACY_EPOCH1."""
+    class current:
+        """Current Nano mainnet threshold presets."""
+        SEND: int
+        RECEIVE: int
 
-    DEV: int
-    """Dev network threshold (very low, for testing)."""
+    class legacy:
+        """Historical Epoch 1 threshold presets."""
+        EPOCH1: int
+        BETA_EPOCH1: int
 
-    BASE: int
-    """The highest threshold — used as the base for multiplier calculations."""
+    class testing:
+        """Test-only threshold presets."""
+        DEV: int

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow-python/src/lib.rs

@@ -17,11 +17,11 @@
 //! print(result.nonce_hex)
 //! print(result.is_valid)
 //!
-//! # Validate existing work
-//! valid = nano_rspow.validate_work(
+//! # Validate historical work with an explicit threshold
+//! valid = nano_rspow.validate_work_with_threshold(
 //!     "718CC2121C3E641059BC1C2CFC45666C99E8AE922F7A807B7D07B62C995D79E2",
 //!     "2bf29ef00786a6bc",
-//!     WorkType.LegacyEpoch1,
+//!     "ffffffc000000000",
 //! )
 //! ```
 
@@ -49,26 +49,21 @@ fn get_generator() -> &'static WorkGenerator {
 
 /// Nano network work type — determines the difficulty threshold.
 ///
-/// Values mirror the thresholds defined in `nano-rspow/src/thresholds.rs`:
-/// - `Send`    → epoch 2 send/change (0xfffffff800000000)
-/// - `Receive` → epoch 2 receive     (0xfffffe0000000000)
-/// - `LegacyEpoch1` → legacy threshold only (0xffffffc000000000)
-/// - `Epoch1`  → deprecated compatibility alias for `LegacyEpoch1`
+/// Values mirror the current mainnet presets in `nano-rspow/src/thresholds.rs`:
+/// - `Send`    → send/change (0xfffffff800000000)
+/// - `Receive` → receive/open/epoch (0xfffffe0000000000)
 #[pyclass(eq, eq_int, from_py_object)]
 #[derive(Clone, Copy, PartialEq)]
 enum WorkType {
     Send = 0,
     Receive = 1,
-    Epoch1 = 2,
-    LegacyEpoch1 = 3,
 }
 
 impl WorkType {
     fn threshold(self) -> u64 {
         match self {
-            WorkType::Send => thresholds::EPOCH2_SEND,
-            WorkType::Receive => thresholds::EPOCH2_RECEIVE,
-            WorkType::Epoch1 | WorkType::LegacyEpoch1 => thresholds::LEGACY_EPOCH1,
+            WorkType::Send => thresholds::current::SEND,
+            WorkType::Receive => thresholds::current::RECEIVE,
         }
     }
 }
@@ -146,6 +141,11 @@ fn parse_hash(hash_hex: &str) -> PyResult<[u8; 32]> {
     Ok(hash)
 }
 
+fn parse_threshold(threshold_hex: &str) -> PyResult<u64> {
+    u64::from_str_radix(threshold_hex.trim().trim_start_matches("0x"), 16)
+        .map_err(|e| PyValueError::new_err(format!("Invalid threshold hex: {e}")))
+}
+
 // ---------------------------------------------------------------------------
 // Public API — module-level functions
 // ---------------------------------------------------------------------------
@@ -196,11 +196,7 @@ fn generate_work_with_threshold(
     threshold_hex: &str,
 ) -> PyResult<WorkResult> {
     let hash = parse_hash(hash_hex)?;
-    let threshold = u64::from_str_radix(
-        threshold_hex.trim().trim_start_matches("0x"),
-        16,
-    )
-    .map_err(|e| PyValueError::new_err(format!("Invalid threshold hex: {e}")))?;
+    let threshold = parse_threshold(threshold_hex)?;
     let generator = get_generator();
 
     let result = py.detach(move || generator.generate(&hash, threshold));
@@ -240,6 +236,24 @@ fn validate_work(hash_hex: &str, work_hex: &str, work_type: WorkType) -> PyResul
     Ok(result.is_valid())
 }
 
+/// Validate a work nonce against an arbitrary hexadecimal threshold.
+///
+/// Use this function when a node requires a threshold stricter than the
+/// current mainnet presets, or when validating historical work.
+#[pyfunction]
+fn validate_work_with_threshold(
+    hash_hex: &str,
+    work_hex: &str,
+    threshold_hex: &str,
+) -> PyResult<bool> {
+    let hash = parse_hash(hash_hex)?;
+    let nonce = u64::from_str_radix(work_hex.trim().trim_start_matches("0x"), 16)
+        .map_err(|e| PyValueError::new_err(format!("Invalid work hex: {e}")))?;
+    let threshold = parse_threshold(threshold_hex)?;
+
+    Ok(::nano_rspow::work_validate(&hash, nonce, threshold).is_valid())
+}
+
 /// Compute the raw PoW difficulty for a hash+nonce pair.
 ///
 /// This is a low-level function useful for validation tooling
@@ -272,7 +286,7 @@ fn backend_name() -> &'static str {
     get_generator().backend_name()
 }
 
-const CLI_HELP: &str = "nano-rspow-python generates Nano proof of work from stdin.\n\nUsage:\n  nano-rspow-python [--help]\n\nWith no arguments, read one request per line and write one result per line.\nEmpty lines are ignored. The only accepted argument is --help.\n\nInput:\n  <hash_hex>\n  <hash_hex>:<threshold_hex>\n\nThe optional threshold must use a 0x prefix. Without one, the current\nepoch-2 send/change threshold is used.\n\nOutput:\n  <hash_hex>:0x<threshold_hex>:<work_hex>\n";
+const CLI_HELP: &str = "nano-rspow-python generates Nano proof of work from stdin.\n\nUsage:\n  nano-rspow-python [--help]\n\nWith no arguments, read one request per line and write one result per line.\nEmpty lines are ignored. The only accepted argument is --help.\n\nInput:\n  <hash_hex>\n  <hash_hex>:<threshold_hex>\n\nThe optional threshold must use a 0x prefix. Without one, the current\nsend/change threshold is used.\n\nOutput:\n  <hash_hex>:0x<threshold_hex>:<work_hex>\n";
 
 fn parse_cli_request(line: &str) -> Result<(String, [u8; 32], u64), String> {
     let parts: Vec<&str> = line.split(':').collect();
@@ -291,7 +305,7 @@ fn parse_cli_request(line: &str) -> Result<(String, [u8; 32], u64), String> {
         u64::from_str_radix(&threshold_text[2..], 16)
             .map_err(|error| format!("invalid threshold {threshold_text:?}: {error}"))?
     } else {
-        thresholds::EPOCH2_SEND
+        thresholds::current::SEND
     };
 
     Ok((hash_text, hash, threshold))
@@ -361,21 +375,29 @@ fn cli_main(py: Python<'_>) -> PyResult<i32> {
 // Threshold constants submodule
 // ---------------------------------------------------------------------------
 
-/// Register the ``thresholds`` submodule with Nano PoW threshold constants.
-///
-/// Constants are sourced from ``nano-rspow/src/thresholds.rs`` and match
-/// the values used by rsnano-node and the C++ nano-node.
+/// Register grouped Nano PoW threshold preset submodules.
 fn register_thresholds(parent: &Bound<'_, PyModule>) -> PyResult<()> {
     let sub = PyModule::new(parent.py(), "thresholds")?;
-    sub.add("EPOCH2_SEND", thresholds::EPOCH2_SEND)?;
-    sub.add("EPOCH2_RECEIVE", thresholds::EPOCH2_RECEIVE)?;
-    sub.add("LEGACY_EPOCH1", thresholds::LEGACY_EPOCH1)?;
-    sub.add("EPOCH1", thresholds::LEGACY_EPOCH1)?;
-    sub.add("BETA_LEGACY_EPOCH1", thresholds::BETA_LEGACY_EPOCH1)?;
-    sub.add("BETA_EPOCH1", thresholds::BETA_LEGACY_EPOCH1)?;
-    sub.add("DEV", thresholds::DEV)?;
-    sub.add("BASE", thresholds::BASE)?;
+    let current = PyModule::new(parent.py(), "current")?;
+    current.add("SEND", thresholds::current::SEND)?;
+    current.add("RECEIVE", thresholds::current::RECEIVE)?;
+    let legacy = PyModule::new(parent.py(), "legacy")?;
+    legacy.add("EPOCH1", thresholds::legacy::EPOCH1)?;
+    legacy.add("BETA_EPOCH1", thresholds::legacy::BETA_EPOCH1)?;
+    let testing = PyModule::new(parent.py(), "testing")?;
+    testing.add("DEV", thresholds::testing::DEV)?;
+    sub.add_submodule(&current)?;
+    sub.add_submodule(&legacy)?;
+    sub.add_submodule(&testing)?;
     parent.add_submodule(&sub)?;
+
+    // Register each level so `from nano_rspow.thresholds import current` works
+    // in addition to attribute access on the extension module.
+    let modules = parent.py().import("sys")?.getattr("modules")?;
+    modules.set_item("nano_rspow.thresholds", &sub)?;
+    modules.set_item("nano_rspow.thresholds.current", &current)?;
+    modules.set_item("nano_rspow.thresholds.legacy", &legacy)?;
+    modules.set_item("nano_rspow.thresholds.testing", &testing)?;
     Ok(())
 }
 
@@ -394,6 +416,7 @@ fn nano_rspow(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(generate_work, m)?)?;
     m.add_function(wrap_pyfunction!(generate_work_with_threshold, m)?)?;
     m.add_function(wrap_pyfunction!(validate_work, m)?)?;
+    m.add_function(wrap_pyfunction!(validate_work_with_threshold, m)?)?;
     m.add_function(wrap_pyfunction!(compute_difficulty, m)?)?;
     m.add_function(wrap_pyfunction!(backend_name, m)?)?;
     m.add_function(wrap_pyfunction!(cli_main, m)?)?;

{nano_rspow_python-0.16.0 → nano_rspow_python-0.17.0}/nano-rspow-python/tests/test_pow.py

@@ -7,6 +7,7 @@ Test vectors are sourced from the same data used in the Rust core library:
 
 import nano_rspow
 from nano_rspow import WorkType, WorkResult
+from nano_rspow.thresholds import current, legacy, testing
 
 
 # ---------------------------------------------------------------------------
@@ -25,8 +26,8 @@ RSNANO_WORK = "3c82cc724905ee95"
 RSNANO_DIFFICULTY_INT = 18446743921403126366
 
 # Threshold constants from thresholds.rs
-EPOCH2_SEND = 0xfffffff800000000
-EPOCH2_RECEIVE = 0xFFFFFE0000000000
+CURRENT_SEND = 0xfffffff800000000
+CURRENT_RECEIVE = 0xFFFFFE0000000000
 LEGACY_EPOCH1 = 0xFFFFFFc000000000
 DEV = 0xFE00000000000000
 
@@ -75,18 +76,22 @@ class TestValidateWork:
 
     def test_known_valid_legacy_epoch1(self):
         """Known-good work from nano-work-server validates at legacy epoch-1 difficulty."""
-        assert nano_rspow.validate_work(VECTOR_HASH, VECTOR_WORK, WorkType.LegacyEpoch1)
+        assert nano_rspow.validate_work_with_threshold(
+            VECTOR_HASH, VECTOR_WORK, f"{LEGACY_EPOCH1:016x}"
+        )
 
     def test_known_invalid(self):
         """Work = 0 should not meet any real threshold."""
-        assert not nano_rspow.validate_work(
-            VECTOR_HASH, "0000000000000000", WorkType.LegacyEpoch1
+        assert not nano_rspow.validate_work_with_threshold(
+            VECTOR_HASH, "0000000000000000", f"{LEGACY_EPOCH1:016x}"
         )
 
     def test_invalid_hash_hex_raises(self):
         """Non-hex hash should raise ValueError."""
         try:
-            nano_rspow.validate_work("zzzz", VECTOR_WORK, WorkType.LegacyEpoch1)
+            nano_rspow.validate_work_with_threshold(
+                "zzzz", VECTOR_WORK, f"{LEGACY_EPOCH1:016x}"
+            )
             assert False, "Expected ValueError"
         except ValueError:
             pass
@@ -110,11 +115,12 @@ class TestGenerateWork:
         # Round-trip validation
         assert nano_rspow.validate_work(zero_hash, result.nonce_hex, WorkType.Receive)
 
-    def test_generate_legacy_epoch1_known_hash(self):
-        """Generate work for a known hash at legacy epoch-1 difficulty."""
-        result = nano_rspow.generate_work(VECTOR_HASH, WorkType.LegacyEpoch1)
+    def test_generate_custom_threshold_roundtrip(self):
+        """Generate and validate work at a caller-supplied historical threshold."""
+        threshold = f"{LEGACY_EPOCH1:016x}"
+        result = nano_rspow.generate_work_with_threshold(VECTOR_HASH, threshold)
         assert result.is_valid
-        assert nano_rspow.validate_work(VECTOR_HASH, result.nonce_hex, WorkType.LegacyEpoch1)
+        assert nano_rspow.validate_work_with_threshold(VECTOR_HASH, result.nonce_hex, threshold)
 
     def test_str_returns_nonce(self):
         """str(result) should return the nonce hex."""
@@ -136,8 +142,8 @@ class TestWorkType:
         """Enum integer values should be stable."""
         assert WorkType.Send == 0
         assert WorkType.Receive == 1
-        assert WorkType.Epoch1 == 2
-        assert WorkType.LegacyEpoch1 == 3
+        assert not hasattr(WorkType, "LegacyEpoch1")
+        assert not hasattr(WorkType, "Dev")
 
     def test_equality(self):
         """Enum equality should work."""
@@ -148,22 +154,21 @@ class TestWorkType:
 class TestThresholds:
     """Tests for the threshold constants submodule."""
 
-    def test_epoch2_send(self):
-        """EPOCH2_SEND must match the Rust constant."""
-        assert nano_rspow.thresholds.EPOCH2_SEND == 0xfffffff800000000
+    def test_current_send(self):
+        assert nano_rspow.thresholds.current.SEND == CURRENT_SEND
+        assert current.SEND == CURRENT_SEND
+        assert not hasattr(nano_rspow.thresholds, "LEGACY_EPOCH1")
 
-    def test_epoch2_receive(self):
-        assert nano_rspow.thresholds.EPOCH2_RECEIVE == 0xFFFFFE0000000000
+    def test_current_receive(self):
+        assert nano_rspow.thresholds.current.RECEIVE == CURRENT_RECEIVE
 
     def test_legacy_epoch1(self):
-        assert nano_rspow.thresholds.LEGACY_EPOCH1 == 0xFFFFFFc000000000
+        assert nano_rspow.thresholds.legacy.EPOCH1 == LEGACY_EPOCH1
+        assert legacy.EPOCH1 == LEGACY_EPOCH1
 
     def test_dev(self):
-        assert nano_rspow.thresholds.DEV == 0xFE00000000000000
-
-    def test_base_equals_epoch2_send(self):
-        """BASE should equal EPOCH2_SEND (the hardest threshold)."""
-        assert nano_rspow.thresholds.BASE == nano_rspow.thresholds.EPOCH2_SEND
+        assert nano_rspow.thresholds.testing.DEV == DEV
+        assert testing.DEV == DEV
 
 
 class TestBackendName:

nano_rspow_python-0.16.0/nano-rspow/src/thresholds.rs

@@ -1,79 +0,0 @@
-//! Nano PoW threshold constants for all network epochs.
-//!
-//! Source: rsnano-node `work/src/work_thresholds.rs` and the original
-//! C++ nano-node `nano/lib/work.cpp`.
-
-/// Epoch 2 send/change threshold (current live network default for sends).
-/// 8x harder than LEGACY_EPOCH1.
-pub const EPOCH2_SEND: u64 = 0xfffffff800000000;
-
-/// Epoch 2 receive threshold.
-/// 8x easier than LEGACY_EPOCH1.
-pub const EPOCH2_RECEIVE: u64 = 0xfffffe0000000000;
-
-/// Legacy epoch 1 threshold.
-///
-/// This is retained for historical block validation and compatibility only.
-/// It is not the threshold required for current mainnet epoch blocks.
-pub const LEGACY_EPOCH1: u64 = 0xffffffc000000000;
-
-/// Deprecated alias for [`LEGACY_EPOCH1`].
-#[deprecated(note = "use LEGACY_EPOCH1; this threshold is legacy-only")]
-pub const EPOCH1: u64 = LEGACY_EPOCH1;
-
-/// Beta network epoch 1 threshold (64x lower than live epoch 1).
-pub const BETA_LEGACY_EPOCH1: u64 = 0xfffff00000000000;
-
-/// Deprecated alias for [`BETA_LEGACY_EPOCH1`].
-#[deprecated(note = "use BETA_LEGACY_EPOCH1; this threshold is legacy-only")]
-pub const BETA_EPOCH1: u64 = BETA_LEGACY_EPOCH1;
-
-/// Dev network threshold (very low, for testing).
-pub const DEV: u64 = 0xfe00000000000000;
-
-/// The highest threshold across all epochs — used as the base for multiplier
-/// calculations.
-pub const BASE: u64 = EPOCH2_SEND;
-
-/// Compute a difficulty multiplier relative to a base threshold.
-///
-/// A multiplier of 1.0 means exactly at base difficulty. >1.0 means harder.
-pub fn to_multiplier(difficulty: u64, base: u64) -> f64 {
-    debug_assert!(base > 0);
-    let max = u64::MAX as f64;
-    (max - base as f64) / (max - difficulty as f64)
-}
-
-/// Compute the difficulty from a multiplier and base threshold.
-pub fn from_multiplier(multiplier: f64, base: u64) -> u64 {
-    debug_assert!(multiplier >= 1.0);
-    let max = u64::MAX as f64;
-    u64::MAX - ((max - base as f64) / multiplier) as u64
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn multiplier_epoch2_vs_legacy_epoch1() {
-        // rsnano confirms live epoch_2 is 8x epoch_1
-        let m = to_multiplier(EPOCH2_SEND, LEGACY_EPOCH1);
-        assert!((m - 8.0).abs() < 0.01, "expected 8.0, got {m}");
-    }
-
-    #[test]
-    fn multiplier_epoch2_receive_vs_legacy_epoch1() {
-        // epoch_2_receive is 1/8 of epoch_1
-        let m = to_multiplier(EPOCH2_RECEIVE, LEGACY_EPOCH1);
-        assert!((m - 0.125).abs() < 0.001, "expected 0.125, got {m}");
-    }
-
-    #[test]
-    fn roundtrip_multiplier() {
-        let m = 2.5_f64;
-        let d = from_multiplier(m, LEGACY_EPOCH1);
-        let m2 = to_multiplier(d, LEGACY_EPOCH1);
-        assert!((m - m2).abs() < 0.001);
-    }
-}