Refactor to match changes

Author: Scherso

Cargo.lock

@@ -11,7 +11,7 @@ keywords = ["proof-of-work", "pow", "ddos", "firewall", "crypto"]
 categories = ["cryptography", "algorithms", "concurrency"]
 
 [dependencies]
-ironshield-types = { version = "0.2", path = "../types" }
+ironshield-types = { version = "0.2" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 hex = "0.4"
@@ -30,6 +30,6 @@ path = "src/lib.rs"
 [features]
 default = ["parallel"]
 # Core features
-parallel = ["rayon"] 
+parallel = ["rayon"]
 # Testing features - use inverted logic
 no-parallel = []  # Disables parallel when enabled

Cargo.toml

@@ -9,11 +9,10 @@ mod solve;
 mod verify;
 
 // Re-export public functions from modules
-pub use solve::find_solution_single_threaded;
 pub use solve::PoWConfig;
 
 #[cfg(all(feature = "parallel", not(feature = "no-parallel")))]
-pub use solve::find_solution_multi_threaded;
+pub use solve::find_solution;
 
 pub use verify::verify_ironshield_solution;
 
@@ -113,7 +112,7 @@ mod tests {
         );
 
         // Solve the challenge
-        let result = find_solution_single_threaded(&challenge, None);
+        let result = find_solution(&challenge, None, None, None, None);
         assert!(result.is_ok(), "Should find solution for integration test");
 
         let response = result.unwrap();
@@ -140,7 +139,7 @@ mod tests {
         );
 
         // Solve the challenge
-        let result = find_solution_single_threaded(&challenge, None);
+        let result = find_solution(&challenge, None, None, None, None);
         assert!(result.is_ok(), "Should find solution for IronShield integration test");
 
         let response = result.unwrap();
@@ -168,7 +167,7 @@ mod tests {
         );
 
         // Solve the challenge using multi-threaded version
-        let result = find_solution_multi_threaded(&challenge, None, None, None, None);
+        let result = find_solution(&challenge, None, None, None, None);
         assert!(result.is_ok(), "Should find solution for IronShield multi-threaded integration test");
 
         let response = result.unwrap();

src/lib.rs

@@ -103,7 +103,7 @@ impl PoWConfig {
 /// ```
 /// use ironshield_core::{
 ///     IronShieldChallenge,
-///     find_solution_multi_threaded,
+///     find_solution,
 ///     SigningKey
 /// };
 ///
@@ -117,7 +117,7 @@ impl PoWConfig {
 ///      );
 ///
 ///     // JavaScript worker coordination mode
-///     let response = find_solution_multi_threaded(&challenge, None, Some(0), Some(8), None)?;
+///     let response = find_solution(&challenge, None, Some(0), Some(8), None)?;
 ///     println!("Found solution: {}", response.solution);
 /// #   Ok(())
 /// # }
@@ -285,41 +285,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_find_solution_single_threaded_easy() {
-        // Create a challenge with very high threshold (easy to solve).
-        let dummy_key = SigningKey::from_bytes(&[0u8; 32]);
-        let challenge = IronShieldChallenge::new(
-            "test_website".to_string(),
-            1, // Easiest difficulty.
-            dummy_key,
-            [0x00; 32],
-        );
-
-        let result = find_solution_single_threaded(&challenge, None);
-        assert!(result.is_ok(), "Should find solution for easy challenge");
-
-        let response = result.unwrap();
-        assert_eq!(response.solved_challenge.challenge_signature, challenge.challenge_signature);
-        assert!(response.solution >= 0, "Solution should be non-negative");
-    }
-
-    #[test]
-    fn test_find_solution_single_threaded_custom_config() {
-        // Test with custom configuration.
-        let dummy_key = SigningKey::from_bytes(&[0u8; 32]);
-        let challenge = IronShieldChallenge::new(
-            "test_website".to_string(),
-            1, // Easiest difficulty.
-            dummy_key,
-            [0x00; 32],
-        );
-
-        let config = PoWConfig::custom(10_000, 1_000);
-        let result = find_solution_single_threaded(&challenge, Some(config));
-        assert!(result.is_ok(), "Should find solution with custom config");
-    }
-
 
     #[test]
     fn test_performance_optimization_correctness() {
@@ -361,7 +326,7 @@ mod tests {
             [0x00; 32],
         );
 
-        let result = find_solution_multi_threaded(&challenge, None, None, None, None);
+        let result = find_solution(&challenge, None, None, None, None);
         assert!(result.is_ok(), "Should find solution for easy challenge");
 
         let response = result.unwrap();
@@ -373,40 +338,6 @@ mod tests {
                 "Multi-threaded solution should pass verification");
     }
 
-    #[test]
-    #[cfg(all(feature = "parallel", not(feature = "no-parallel")))]
-    fn test_find_solution_multi_threaded_vs_single_threaded() {
-        // Test that multithreaded and single-threaded versions find valid solutions
-        // for the same challenge (solutions may differ due to search order).
-        let dummy_key = SigningKey::from_bytes(&[0u8; 32]);
-        let challenge = IronShieldChallenge::new(
-            "test_website".to_string(),
-            1000, // Medium difficulty.
-            dummy_key,
-            [0x00; 32],
-        );
-
-        // Solve with single-threaded version.
-        let single_result = find_solution_single_threaded(&challenge, None);
-        assert!(single_result.is_ok(), "Single-threaded should find solution");
-
-        // Solve with multithreaded version.
-        let multi_result = find_solution_multi_threaded(&challenge, None, None, None, None);
-        assert!(multi_result.is_ok(), "Multi-threaded should find solution");
-
-        let single_response = single_result.unwrap();
-        let multi_response = multi_result.unwrap();
-
-        // Both solutions should be valid (but may be different nonces).
-        assert!(crate::verify::verify_ironshield_solution(&single_response),
-                "Single-threaded solution should be valid");
-        assert!(crate::verify::verify_ironshield_solution(&multi_response),
-                "Multi-threaded solution should be valid");
-
-        // Both should have the same challenge signature.
-        assert_eq!(single_response.solved_challenge.challenge_signature, multi_response.solved_challenge.challenge_signature);
-    }
-
     #[test]
     #[cfg(all(feature = "parallel", not(feature = "no-parallel")))]
     fn test_find_solution_multi_threaded_deterministic_correctness() {
@@ -421,7 +352,7 @@ mod tests {
         );
 
         // Should find a solution relatively quickly with 50% probability per attempt.
-        let result = find_solution_multi_threaded(&challenge, None, None, None, None);
+        let result = find_solution(&challenge, None, None, None, None);
         assert!(result.is_ok(), "Should find solution for medium difficulty challenge");
 
         let response = result.unwrap();

src/solve.rs

@@ -27,7 +27,7 @@ use ironshield_types::*;
 ///
 /// # Example
 /// ```
-/// use ironshield_core::{find_solution_single_threaded, verify_ironshield_solution, IronShieldChallenge, SigningKey};
+/// use ironshield_core::{find_solution, verify_ironshield_solution, IronShieldChallenge, SigningKey};
 ///
 /// let dummy_key = SigningKey::from_bytes(&[0u8; 32]);
 /// let challenge = IronShieldChallenge::new(
@@ -37,7 +37,7 @@ use ironshield_types::*;
 ///     [0x00; 32],
 /// );
 ///
-/// let response = find_solution_single_threaded(&challenge, None).unwrap();
+/// let response = find_solution(&challenge, None, None, None, None).unwrap();
 /// assert!(verify_ironshield_solution(&response));
 /// ```
 pub fn verify_ironshield_solution(response: &IronShieldChallengeResponse) -> bool {
@@ -79,7 +79,7 @@ mod tests {
         );
 
         // Find a solution using the solver
-        let result = crate::solve::find_solution_single_threaded(&challenge, None);
+        let result = crate::solve::find_solution(&challenge, None, None, None, None);
         assert!(result.is_ok(), "Should find solution for reasonable challenge");
 
         let response = result.unwrap();