refactor(jolt-field): Land Solinas field from akita-field in jolt-field

.github/workflows/rust.yml

@@ -45,6 +45,25 @@ jobs:
       - name: taplo fmt --check
         run: taplo fmt --check
 
+  field-stack:
+    name: Shared field feature matrix
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+      - name: Install nextest
+        uses: taiki-e/install-action@nextest
+      - name: Require one jolt-field identity (bootstrap akita-field pin allowed)
+        run: scripts/check-shared-field-identity.sh
+      - name: Check no backend
+        run: cargo check -p jolt-field --no-default-features
+      - name: Check BN254 backend
+        run: cargo check -p jolt-field --no-default-features --features bn254
+      - name: Test Solinas backend
+        run: cargo nextest run -p jolt-field --no-default-features --features solinas --cargo-quiet
+      - name: Check combined backends
+        run: cargo check -p jolt-field --no-default-features --features bn254,solinas
+
   clippy:
     runs-on: ubuntu-latest
     steps:

Cargo.toml

@@ -49,6 +49,7 @@ members = [
   "crates/jolt-kernels",
   "crates/jolt-kernels-derive",
   "crates/jolt-prover",
+  "crates/jolt-field-two",
   "crates/jolt-prover-legacy",
   "tracer",
   "common",

crates/jolt-blindfold/src/prove.rs

@@ -1,5 +1,5 @@
 use jolt_crypto::{HomomorphicCommitment, VectorCommitment, VectorCommitmentOpening};
-use jolt_field::{Field, RingAccumulator, WithAccumulator};
+use jolt_field::Field;
 use jolt_poly::{BindingOrder, EqPolynomial, Polynomial, UnivariatePoly};
 use jolt_r1cs::{ConstraintMatrices, ConstraintMatrixEvalError, SparseRow};
 use jolt_sumcheck::{CompressedSumcheckProof, SUMCHECK_ROUND_TRANSCRIPT_LABEL};
@@ -126,10 +126,7 @@ where
         row_point: &[F],
         entry_point: &[F],
         name: &'static str,
-    ) -> Result<(VectorCommitmentOpening<F>, F), ProverError<F>>
-    where
-        <F as WithAccumulator>::Accumulator: RingAccumulator<Element = F>,
-    {
+    ) -> Result<(VectorCommitmentOpening<F>, F), ProverError<F>> {
         open_committed_rows::<F, VC>(setup, rows, blindings, row_point, entry_point, name)
     }
 }
@@ -166,7 +163,6 @@ where
     VC::Output: HomomorphicCommitment<F> + AppendToTranscript,
     T: Transcript<Challenge = F>,
     R: RngCore,
-    <F as WithAccumulator>::Accumulator: RingAccumulator<Element = F>,
 {
     let mut row_committer = DirectBlindFoldRowCommitter;
     prove_with_row_committer::<F, VC, T, R, DirectBlindFoldRowCommitter>(
@@ -194,7 +190,6 @@ where
     T: Transcript<Challenge = F>,
     R: RngCore,
     C: BlindFoldRowCommitter<F, VC>,
-    <F as WithAccumulator>::Accumulator: RingAccumulator<Element = F>,
 {
     validate_witness::<F, VC>(setup, protocol, witness)?;
 
@@ -696,7 +691,6 @@ fn open_committed_rows<F, VC>(
 where
     F: Field,
     VC: VectorCommitment<Field = F>,
-    <F as WithAccumulator>::Accumulator: RingAccumulator<Element = F>,
 {
     let row_count = basis_len_from_point_len("row point", row_point.len())?;
     ensure_len(name, row_count, rows.len())?;
@@ -1038,7 +1032,6 @@ where
     F: Field,
     VC: VectorCommitment<Field = F>,
     C: BlindFoldRowCommitter<F, VC>,
-    <F as WithAccumulator>::Accumulator: RingAccumulator<Element = F>,
 {
     let row_vars = log2_power_of_two("witness row count", witness_rows.len())?;
     let entry_vars = log2_power_of_two("witness row length", witness_rows[0].len())?;

crates/jolt-blindfold/src/verify.rs

@@ -1,5 +1,5 @@
 use jolt_crypto::{HomomorphicCommitment, VectorCommitment, VectorCommitmentOpening};
-use jolt_field::{Field, FieldCore, RingAccumulator, WithAccumulator};
+use jolt_field::{Field, FieldCore};
 use jolt_poly::EqPolynomial;
 use jolt_r1cs::{ConstraintMatrices, MatrixColumnContributions};
 use jolt_sumcheck::{BooleanHypercube, SumcheckClaim, SUMCHECK_ROUND_TRANSCRIPT_LABEL};
@@ -18,7 +18,6 @@ impl<F, Com> BlindFoldProtocol<F, Com>
 where
     F: Field + AppendToTranscript,
     Com: Copy + HomomorphicCommitment<F> + AppendToTranscript,
-    <F as WithAccumulator>::Accumulator: RingAccumulator<Element = F>,
 {
     pub fn verify<VC, T>(
         &self,
@@ -126,7 +125,6 @@ impl<F, Com> BlindFoldProtocol<F, Com>
 where
     F: Field + AppendToTranscript,
     Com: Copy + HomomorphicCommitment<F> + AppendToTranscript,
-    <F as WithAccumulator>::Accumulator: RingAccumulator<Element = F>,
 {
     fn verify_outer_folded_r1cs<VC, T>(
         &self,
@@ -247,7 +245,6 @@ impl<F, Com> BlindFoldProtocol<F, Com>
 where
     F: Field + AppendToTranscript,
     Com: Copy + HomomorphicCommitment<F> + AppendToTranscript,
-    <F as WithAccumulator>::Accumulator: RingAccumulator<Element = F>,
 {
     fn verify_folded_eval_witness_bindings<VC, T>(
         &self,
@@ -365,7 +362,6 @@ impl WitnessCoordinate {
         F: Field,
         VC: VectorCommitment<Field = F>,
         VC::Output: Copy + HomomorphicCommitment<F>,
-        <F as WithAccumulator>::Accumulator: RingAccumulator<Element = F>,
     {
         let witness_row_count = folded.witness_row_commitments.len();
         if witness_row_count == 0 || !witness_row_count.is_power_of_two() {
@@ -400,7 +396,6 @@ impl<F, Com> BlindFoldProtocol<F, Com>
 where
     F: Field + AppendToTranscript,
     Com: Copy + HomomorphicCommitment<F> + AppendToTranscript,
-    <F as WithAccumulator>::Accumulator: RingAccumulator<Element = F>,
 {
     fn verify_inner_folded_r1cs<VC, T>(
         &self,

crates/jolt-blindfold/tests/support/mod.rs

@@ -12,7 +12,7 @@ use jolt_claims::{challenge, constant, derived, opening, Expr};
 use jolt_crypto::{
     Bn254, Bn254G1, JoltGroup, Pedersen, PedersenSetup, VectorCommitment, VectorCommitmentOpening,
 };
-use jolt_field::{FixedBytes, Fr, FromPrimitiveInt, Invertible};
+use jolt_field::{CanonicalBytes, FieldCore, Fr, FromPrimitiveInt};
 use jolt_poly::{CompressedPoly, EqPolynomial};
 use jolt_r1cs::{ClaimSourceTable, ConstraintMatrices, R1csBuilder};
 use jolt_sumcheck::{
@@ -108,7 +108,7 @@ pub fn f(value: u64) -> F {
 pub fn rng_field(rng: &mut impl RngCore) -> F {
     let mut bytes = [0u8; 32];
     rng.fill_bytes(&mut bytes);
-    F::from_bytes_array(&bytes)
+    <F as jolt_field::CanonicalRepr>::from_le_bytes_mod_order(&bytes)
 }
 
 pub fn inverse(value: F) -> F {
@@ -145,7 +145,7 @@ impl StatisticalProjection {
 }
 
 pub fn field_low_u64(value: F) -> u64 {
-    let bytes = value.to_bytes_array();
+    let bytes = value.to_bytes_le_vec();
     u64::from_le_bytes([
         bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
     ])

crates/jolt-claims/src/protocols/jolt/geometry/claim_reductions/bytecode.rs

@@ -561,7 +561,7 @@ mod tests {
     use super::super::super::bytecode::{read_raf_public_values, BytecodeReadRafEvaluationInputs};
     use super::*;
     use crate::protocols::jolt::JoltPolynomialId;
-    use jolt_field::{Fr, FromPrimitiveInt, Invertible};
+    use jolt_field::{FieldCore, Fr, FromPrimitiveInt};
     use jolt_lookup_tables::InstructionLookupTable;
     use jolt_riscv::{
         instructions::Noop, Flags, InterleavedBitsMarker, JoltInstruction, JoltInstructionKind,

crates/jolt-claims/src/protocols/jolt/geometry/claim_reductions/precommitted.rs

@@ -494,7 +494,7 @@ mod tests {
 
     use super::*;
     use crate::protocols::jolt::geometry::dimensions::TracePolynomialOrder;
-    use jolt_field::{Fr, FromPrimitiveInt, Invertible};
+    use jolt_field::{FieldCore, Fr, FromPrimitiveInt};
 
     #[test]
     fn cycle_skip_scale_counts_inactive_cycle_rounds() {

crates/jolt-claims/src/protocols/jolt/geometry/dimensions.rs

@@ -490,7 +490,7 @@ mod tests {
         PrecommittedClaimReduction, PrecommittedReductionLayout,
     };
     use super::*;
-    use jolt_field::{Fr, FromPrimitiveInt, Invertible};
+    use jolt_field::{FieldCore, Fr, FromPrimitiveInt};
     use jolt_poly::EqPolynomial;
 
     fn dimensions() -> JoltOneHotDimensions {

crates/jolt-crypto/benches/crypto.rs

@@ -5,7 +5,7 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use jolt_crypto::{
     Bn254, Bn254G1, Bn254G2, JoltGroup, PairingGroup, Pedersen, PedersenSetup, VectorCommitment,
 };
-use jolt_field::{Fr, FromPrimitiveInt, RandomSampling};
+use jolt_field::{FieldCore, Fr, FromPrimitiveInt};
 use rand_chacha::ChaCha20Rng;
 use rand_core::SeedableRng;
 

crates/jolt-crypto/fuzz/fuzz_targets/group_arith.rs

@@ -1,14 +1,14 @@
 #![no_main]
 use jolt_crypto::{Bn254, Bn254G1, JoltGroup};
-use jolt_field::{Fr, ReducingBytes};
+use jolt_field::{Fr, CanonicalRepr};
 use libfuzzer_sys::fuzz_target;
 
 fn parse_input(data: &[u8]) -> Option<(Fr, Fr, Bn254G1)> {
     if data.len() < 64 {
         return None;
     }
-    let s1 = <Fr as ReducingBytes>::from_le_bytes_mod_order(&data[..32]);
-    let s2 = <Fr as ReducingBytes>::from_le_bytes_mod_order(&data[32..64]);
+    let s1 = <Fr as CanonicalRepr>::from_le_bytes_mod_order(&data[..32]);
+    let s2 = <Fr as CanonicalRepr>::from_le_bytes_mod_order(&data[32..64]);
     let g = Bn254::g1_generator();
     let p = g.scalar_mul(&s1);
     Some((s1, s2, p))

crates/jolt-crypto/fuzz/fuzz_targets/pedersen_commit.rs

@@ -1,6 +1,6 @@
 #![no_main]
 use jolt_crypto::{Bn254, Bn254G1, VectorCommitment, JoltGroup, Pedersen, PedersenSetup};
-use jolt_field::{Fr, FromPrimitiveInt, ReducingBytes};
+use jolt_field::{Fr, FromPrimitiveInt, CanonicalRepr};
 use libfuzzer_sys::fuzz_target;
 
 /// Fixed small setup (4 generators) — deterministic so we don't waste fuzzer
@@ -23,9 +23,9 @@ fuzz_target!(|data: &[u8]| {
     let setup = fixed_setup();
 
     let values: Vec<Fr> = (0..4)
-        .map(|i| <Fr as ReducingBytes>::from_le_bytes_mod_order(&data[i * 32..(i + 1) * 32]))
+        .map(|i| <Fr as CanonicalRepr>::from_le_bytes_mod_order(&data[i * 32..(i + 1) * 32]))
         .collect();
-    let blinding = <Fr as ReducingBytes>::from_le_bytes_mod_order(&data[128..160]);
+    let blinding = <Fr as CanonicalRepr>::from_le_bytes_mod_order(&data[128..160]);
 
     // Commit-verify round-trip
     let c = Pedersen::<Bn254G1>::commit(&setup, &values, &blinding);