refactor(jolt-field): decouple Limbs and SignedBigInt from arkworks

- Fix SignedBigInt PartialEq/Ord inconsistency: +0 and -0 now compare
  equal, matching the Ord impl (consistent with SignedBigIntHi32)
- Remove ark_serialize impls from Limbs, SignedBigInt, SignedBigIntHi32
  (unused outside tests)
- Move BigInt<->Limbs conversion from limbs.rs into arkworks/mod.rs as
  From impls, eliminating all arkworks references from limbs.rs and
  signed/ modules

Author: 0xAndoroid

Cargo.toml

@@ -217,55 +217,6 @@ expect_used = "deny"
 [workspace.lints.rust]
 unused_results = "warn"
 
-[workspace.lints.clippy]
-pedantic = { level = "warn", priority = -1 }
-
-# Pedantic overrides — suppressed because they're too noisy for math-heavy ZK code
-missing_errors_doc = "allow"
-missing_panics_doc = "allow"
-must_use_candidate = "allow"
-doc_markdown = "allow"
-similar_names = "allow"
-too_many_lines = "allow"
-module_name_repetitions = "allow"
-struct_excessive_bools = "allow"
-fn_params_excessive_bools = "allow"
-items_after_statements = "allow"
-uninlined_format_args = "allow"
-return_self_not_must_use = "allow"
-default_trait_access = "allow"
-match_same_arms = "allow"
-manual_let_else = "allow"
-used_underscore_binding = "allow"
-no_effect_underscore_binding = "allow"
-needless_pass_by_value = "allow"
-trivially_copy_pass_by_ref = "allow"
-redundant_closure_for_method_calls = "allow"
-unnecessary_wraps = "allow"
-if_not_else = "allow"
-
-# Numeric/math code — ZK cryptography uses these patterns pervasively
-float_cmp = "allow"
-many_single_char_names = "allow"
-wildcard_imports = "allow"
-inline_always = "allow"
-checked_conversions = "allow"
-
-# Cast lints — field arithmetic requires intentional casting
-cast_possible_truncation = "allow"
-cast_sign_loss = "allow"
-cast_precision_loss = "allow"
-cast_possible_wrap = "allow"
-cast_lossless = "allow"
-
-# Code quality — hard denies to catch AI-generated slop
-dbg_macro = "deny"
-todo = "deny"
-unimplemented = "deny"
-print_stdout = "deny"
-print_stderr = "deny"
-undocumented_unsafe_blocks = "deny"
-
 [workspace.dependencies]
 # Cryptography and Math
 ark-bn254 = { git = "https://github.com/a16z/arkworks-algebra", branch = "dev/twist-shout", default-features = false }

crates/jolt-field/Cargo.toml

@@ -13,8 +13,8 @@ categories = ["cryptography"]
 workspace = true
 
 [dependencies]
-ark-ff = { workspace = true }
-ark-serialize = { workspace = true }
+ark-ff = { workspace = true, optional = true }
+ark-serialize = { workspace = true, optional = true }
 ark-bn254 = { workspace = true, features = ["scalar_field"], optional = true }
 num-traits = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
@@ -24,9 +24,11 @@ rand = { workspace = true }
 rand_core = { workspace = true }
 
 [features]
-default = ["bn254"]
-bn254 = ["dep:ark-bn254"]
+default = ["bn254", "dory-pcs"]
+arkworks = ["dep:ark-ff", "dep:ark-serialize"]
+bn254 = ["dep:ark-bn254", "arkworks"]
 dory-pcs = ["dep:dory", "bn254"]
+allocative = ["dep:allocative"]
 
 [dev-dependencies]
 ark-std = { workspace = true }

crates/jolt-field/benches/field_arith.rs

@@ -1,6 +1,8 @@
-#![allow(unused_results)]
+#![expect(unused_results)]
 
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
+
+use criterion::{criterion_group, criterion_main, Criterion};
 use jolt_field::{Field, Fr};
 use rand_chacha::ChaCha20Rng;
 use rand_core::SeedableRng;

crates/jolt-field/src/arkworks/bn254.rs

@@ -291,7 +291,7 @@ impl Fr {
     /// less than the modulus.
     #[inline]
     pub fn from_bigint_unchecked(limbs: Limbs<4>) -> Self {
-        Fr(bn254_ops::from_bigint_unchecked(limbs.to_bigint()))
+        Fr(bn254_ops::from_bigint_unchecked(limbs.into()))
     }
 
     /// Access the internal Montgomery-form limbs.
@@ -315,12 +315,13 @@ impl Field for Fr {
 
     const NUM_BYTES: usize = 32;
 
+    #[expect(clippy::expect_used)]
     fn to_bytes(&self) -> [u8; 32] {
         use ark_serialize::CanonicalSerialize;
         let mut buf = [0u8; 32];
         self.0
             .serialize_compressed(&mut buf[..])
-            .expect("field serialization should not fail");
+            .expect("BN254 Fr always serializes to 32 bytes");
         buf
     }
 
@@ -406,6 +407,7 @@ impl Field for Fr {
 }
 
 #[cfg(test)]
+#[expect(clippy::unwrap_used)]
 mod tests {
     use super::*;
     use crate::Field;

crates/jolt-field/src/arkworks/bn254_ops.rs

@@ -16,14 +16,6 @@ fn mac_with_carry(a: u64, b: u64, c: u64, carry: &mut u64) -> u64 {
     tmp as u64
 }
 
-/// a + b * c → (result, carry)  (no input carry)
-#[inline(always)]
-fn mac_no_carry(a: u64, b: u64, c: u64, carry: &mut u64) -> u64 {
-    let tmp = (a as u128) + (b as u128) * (c as u128);
-    *carry = (tmp >> 64) as u64;
-    tmp as u64
-}
-
 /// *a += b + carry → new carry
 #[inline(always)]
 fn adc(a: &mut u64, b: u64, carry: u64) -> u64 {
@@ -45,8 +37,6 @@ const N: usize = 4;
 const MODULUS: [u64; N] = <FrConfig as MontConfig<N>>::MODULUS.0;
 const INV: u64 = <FrConfig as MontConfig<N>>::INV;
 const R: BigInt<N> = <FrConfig as MontConfig<N>>::R;
-#[allow(dead_code)]
-const R2: BigInt<N> = <FrConfig as MontConfig<N>>::R2;
 
 const MODULUS_HAS_SPARE_BIT: bool = MODULUS[N - 1] >> 63 == 0;
 const MODULUS_NUM_SPARE_BITS: u32 = MODULUS[N - 1].leading_zeros();
@@ -124,7 +114,6 @@ const PRECOMP_TABLE_SIZE: usize = 1 << 14;
 /// `PRECOMP_TABLE[i]` = Montgomery form of `i` for BN254 Fr.
 ///
 /// Uses `Fp::new()` which converts standard form → Montgomery form at compile time.
-#[allow(long_running_const_eval)]
 static PRECOMP_TABLE: [Fr; PRECOMP_TABLE_SIZE] = {
     let mut table: [Fr; PRECOMP_TABLE_SIZE] =
         [Fp::new_unchecked(BigInt([0u64; N])); PRECOMP_TABLE_SIZE];
@@ -165,6 +154,7 @@ fn nplus1_from_low_n_and_top(low_n: [u64; N], top: u64) -> BigInt<5> {
 /// Conditional subtraction for Barrett reduction: reduce a 5-limb intermediate
 /// that is known to be < 4p down to < p (4 limbs).
 #[inline(always)]
+#[expect(clippy::unwrap_used)]
 fn barrett_cond_subtract(r_tmp: BigInt<5>) -> BigInt<N> {
     let (m2_lo, _m2_hi) = MODULUS_TIMES_2;
     let (m3_lo, _m3_hi) = MODULUS_TIMES_3;
@@ -268,26 +258,10 @@ fn mul_bigint5_by_u64_in_place(a: &mut BigInt<5>, b: u64) {
     // Overflow is discarded (caller ensures result fits in 5 limbs)
 }
 
-/// Barrett reduce an L-limb BigInt to a field element.
-///
-/// Folds from high limb to low, applying the 5→4 kernel at each step.
-#[inline(always)]
-pub(crate) fn from_barrett_reduce<const L: usize>(unreduced: BigInt<L>) -> Fr {
-    debug_assert!(L >= N);
-    let mut acc = BigInt::<N>([0u64; N]);
-    let mut i = L;
-    while i > 0 {
-        i -= 1;
-        let c5 = nplus1_from_low_and_high(unreduced.0[i], acc.0);
-        acc = barrett_reduce_5_to_4(c5);
-    }
-    Fp::new_unchecked(acc)
-}
-
 /// Perform N Montgomery reduction steps on a mutable buffer of L >= 2N limbs.
 /// Returns carry from the final step.
 #[inline(always)]
-#[allow(clippy::needless_range_loop)]
+#[expect(clippy::needless_range_loop)]
 fn montgomery_reduce_in_place<const L: usize>(limbs: &mut [u64; L]) -> u64 {
     debug_assert!(L >= 2 * N);
     let mut carry2 = 0u64;
@@ -396,6 +370,7 @@ fn from_unchecked_nplus1(element: BigInt<5>) -> Fr {
 
 /// Barrett reduce BigInt<6> → Fr via two rounds
 #[inline(always)]
+#[expect(clippy::unwrap_used)]
 fn from_unchecked_nplus2(element: BigInt<6>) -> Fr {
     // Round 1: reduce top 5 limbs (indices 1..6)
     let c1 = BigInt::<5>(element.0[1..6].try_into().unwrap());
@@ -486,74 +461,14 @@ pub(crate) fn from_u128(n: u128) -> Fr {
     }
 }
 
-/// Multiply by a sparse RHS with exactly 2 non-zero high limbs at positions N-2 and N-1.
-///
-/// This is used in the Challenge × Field hot path where the challenge value
-/// has only its top 2 limbs set (128-bit challenge stored in high position).
-///
-/// Interleaves multiplication with Montgomery reduction for efficiency.
-#[inline(always)]
-pub(crate) fn mul_by_hi_2limbs(a: Fr, limb_lo: u64, limb_hi: u64) -> Fr {
-    let a_limbs = a.0 .0;
-    let mut r = [0u64; N];
-
-    // Process limb at position N-2 (limb_lo), with interleaved Montgomery step
-    {
-        let mut carry1 = 0u64;
-        r[0] = mac_no_carry(r[0], a_limbs[0], limb_lo, &mut carry1);
-        let k = r[0].wrapping_mul(INV);
-        let mut carry2 = 0u64;
-        let _ = mac_no_carry(r[0], k, MODULUS[0], &mut carry2);
-        for j in 1..N {
-            let new_rj = mac_with_carry(r[j], a_limbs[j], limb_lo, &mut carry1);
-            let new_rj_minus_1 = mac_with_carry(new_rj, k, MODULUS[j], &mut carry2);
-            r[j] = new_rj;
-            r[j - 1] = new_rj_minus_1;
-        }
-        r[N - 1] = carry1.wrapping_add(carry2);
-    }
-
-    // Process limb at position N-1 (limb_hi), with interleaved Montgomery step
-    {
-        let mut carry1 = 0u64;
-        r[0] = mac_no_carry(r[0], a_limbs[0], limb_hi, &mut carry1);
-        let k = r[0].wrapping_mul(INV);
-        let mut carry2 = 0u64;
-        let _ = mac_no_carry(r[0], k, MODULUS[0], &mut carry2);
-        for j in 1..N {
-            let new_rj = mac_with_carry(r[j], a_limbs[j], limb_hi, &mut carry1);
-            let new_rj_minus_1 = mac_with_carry(new_rj, k, MODULUS[j], &mut carry2);
-            r[j] = new_rj;
-            r[j - 1] = new_rj_minus_1;
-        }
-        r[N - 1] = carry1.wrapping_add(carry2);
-    }
-
-    let mut out = Fp::new_unchecked(BigInt::<N>(r));
-    if compare_4(out.0 .0, MODULUS) != core::cmp::Ordering::Less {
-        out.0 = BigInt(sub_4(out.0 .0, MODULUS));
-    }
-    out
-}
-
 /// Wrap a raw BigInt<4> as Fr without any reduction (caller guarantees it's valid).
 #[inline(always)]
 pub(crate) fn from_bigint_unchecked(r: BigInt<N>) -> Fr {
     Fp::new_unchecked(r)
 }
 
-/// Multiply `BigInt<N>` by `u64` and accumulate into `BigInt<5>`.
-#[inline(always)]
-pub(crate) fn mul_u64_accumulate(acc: &mut BigInt<5>, a: &BigInt<N>, b: u64) {
-    let mut carry = 0u64;
-    for i in 0..N {
-        acc.0[i] = mac_with_carry(acc.0[i], a.0[i], b, &mut carry);
-    }
-    let final_carry = adc(&mut acc.0[N], carry, 0);
-    debug_assert!(final_carry == 0, "overflow in mul_u64_accumulate");
-}
-
 #[cfg(test)]
+#[expect(clippy::unwrap_used)]
 mod tests {
     use super::*;
     use ark_ff::{PrimeField, UniformRand};
@@ -697,35 +612,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn barrett_reduce_correct() {
-        let mut rng = test_rng();
-        // Barrett reduce of a product a*b should equal a*b in the field
-        for _ in 0..200 {
-            let a = Fr::rand(&mut rng);
-            let b = Fr::rand(&mut rng);
-            // Compute unreduced product in 8 limbs
-            let a_bigint = a.into_bigint();
-            let b_bigint = b.into_bigint();
-            let mut prod = BigInt::<8>::zero();
-            for i in 0..N {
-                let mut carry = 0u64;
-                for j in 0..N {
-                    prod.0[i + j] =
-                        mac_with_carry(prod.0[i + j], a_bigint.0[i], b_bigint.0[j], &mut carry);
-                }
-                prod.0[i + N] = carry;
-            }
-            // Barrett reduce should give the same result as Montgomery reduce
-            // (both map from standard 8-limb → 4-limb Montgomery)
-            let reduced = from_barrett_reduce::<8>(prod);
-            // Verify it's a valid field element by roundtripping
-            let _ = reduced.into_bigint();
-        }
-        // Barrett reduce of zero should give zero
-        assert_eq!(from_barrett_reduce::<5>(BigInt::<5>::zero()), Fr::zero());
-    }
-
     #[test]
     fn montgomery_reduce_roundtrip() {
         let mut rng = test_rng();
@@ -751,23 +637,4 @@ mod tests {
             assert_eq!(got, expected, "Montgomery reduce roundtrip mismatch");
         }
     }
-
-    #[test]
-    fn mul_by_hi_2limbs_correct() {
-        let mut rng = test_rng();
-        for _ in 0..200 {
-            let a = Fr::rand(&mut rng);
-            let lo: u64 = rng.gen();
-            let hi: u64 = rng.gen();
-            // mul_by_hi_2limbs treats [0, 0, lo, hi] as a raw Montgomery-form scalar
-            let scalar = Fp::new_unchecked(BigInt::new([0, 0, lo, hi]));
-            let expected = a * scalar;
-            let got = mul_by_hi_2limbs(a, lo, hi);
-            assert_eq!(
-                got, expected,
-                "mul_by_hi_2limbs mismatch: lo={}, hi={}",
-                lo, hi
-            );
-        }
-    }
 }

crates/jolt-field/src/arkworks/mod.rs

@@ -3,8 +3,24 @@
 //! Provides the BN254 scalar field (`Fr`) and its low-level arithmetic
 //! (Montgomery/Barrett reduction, precomputed lookup tables, sparse multiplication).
 
+use crate::Limbs;
+use ark_ff::BigInt;
+
 pub mod bn254;
-#[allow(dead_code)]
 pub(crate) mod bn254_ops;
 pub mod montgomery_impl;
 pub mod wide_accumulator;
+
+impl<const N: usize> From<Limbs<N>> for BigInt<N> {
+    #[inline]
+    fn from(limbs: Limbs<N>) -> Self {
+        BigInt(limbs.0)
+    }
+}
+
+impl<const N: usize> From<BigInt<N>> for Limbs<N> {
+    #[inline]
+    fn from(bigint: BigInt<N>) -> Self {
+        Limbs(bigint.0)
+    }
+}

crates/jolt-field/src/arkworks/wide_accumulator.rs

@@ -52,7 +52,7 @@ impl FieldAccumulator for WideAccumulator {
         // The accumulator holds sum_i (a_i_mont × b_i_mont).
         // Montgomery reduction divides by R, yielding the Montgomery form
         // of sum_i (a_i × b_i).
-        let bigint = self.limbs.to_bigint();
+        let bigint = self.limbs.into();
         Fr::from_inner(bn254_ops::from_montgomery_reduce(bigint))
     }
 }

crates/jolt-field/src/dory_interop.rs

@@ -128,6 +128,7 @@ impl arithmetic::Field for Fr {
 }
 
 #[cfg(test)]
+#[expect(clippy::unwrap_used, clippy::expect_used)]
 mod tests {
     use super::*;
     use dory::primitives::arithmetic::Field as DoryField;