fix tests

Author: BidhanRoy

src/zklora/libs/zklora_halo2/src/circuit.rs

@@ -4,7 +4,7 @@ use halo2_proofs::{
     poly::Rotation,
     pasta::Fp,
 };
-use ff::PrimeField;
+use ff::Field;
 
 use crate::quantize_to_field;
 

src/zklora/libs/zklora_halo2/src/lib.rs

@@ -15,7 +15,7 @@ const SCALE_FACTOR: u64 = 10_000; // 10^4 for 4 decimal places
 const SCALE_FACTOR_F64: f64 = SCALE_FACTOR as f64;
 
 /// Convert a floating-point value to a field element using fixed-point arithmetic
-fn quantize_to_field<F: PrimeField>(value: f64) -> F {
+fn quantize_to_field<F: PrimeField + Field>(value: f64) -> F {
     // Handle special cases
     if value == 0.0 {
         return F::zero();
@@ -43,7 +43,7 @@ fn quantize_to_field<F: PrimeField>(value: f64) -> F {
 }
 
 /// Convert a field element back to a floating-point value
-fn dequantize_from_field<F: PrimeField>(value: F) -> f64 {
+fn dequantize_from_field<F: PrimeField + Field>(value: F) -> f64 {
     // Handle special cases
     if value == F::zero() {
         return 0.0;
@@ -56,9 +56,11 @@ fn dequantize_from_field<F: PrimeField>(value: F) -> f64 {
     }
 
     // Convert to bytes and then to u64
-    let bytes = value.to_repr();
+    let bytes = value.to_repr().as_ref();
     let mut u64_bytes = [0u8; 8];
-    u64_bytes.copy_from_slice(&bytes[0..8]);
+    if bytes.len() >= 8 {
+        u64_bytes.copy_from_slice(&bytes[..8]);
+    }
     let scaled = u64::from_le_bytes(u64_bytes);
 
     // Dequantize by dividing by scale factor
@@ -252,6 +254,24 @@ mod tests {
         assert_eq!(dequantize_from_field(neg_one_field), -1.0);
     }
 
+    #[test]
+    fn test_large_field_values() {
+        // Test values close to u64::MAX to verify byte representation handling
+        let large_value = (u64::MAX >> 1) as f64 / SCALE_FACTOR_F64;
+        let field_val: Fp = quantize_to_field(large_value);
+        let roundtrip = dequantize_from_field(field_val);
+        let epsilon = 1e-4;
+        assert!((large_value - roundtrip).abs() < epsilon,
+            "Large value roundtrip failed for {}: got {}", large_value, roundtrip);
+
+        // Test values requiring full field representation
+        let max_safe_value = ((1u64 << 53) - 1) as f64 / SCALE_FACTOR_F64;
+        let field_val: Fp = quantize_to_field(max_safe_value);
+        let roundtrip = dequantize_from_field(field_val);
+        assert!((max_safe_value - roundtrip).abs() < epsilon,
+            "Max safe value roundtrip failed for {}: got {}", max_safe_value, roundtrip);
+    }
+
     #[test]
     fn test_proof_generation_and_verification() {
         Python::with_gil(|py| {