Fixed lint issues

0xMimir · 0xMimir · commit 0b6a7fd0f894 · 2025-08-14T11:41:39.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -64,6 +64,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Use consistent `use` statements for fields. Replace `mina_hasher::Fp` with
   `mina_curves::pasta::Fp`.
   ([#1269](https://github.com/o1-labs/openmina/pull/1269/)).
+- **Proof systems**: Updated proof systems to use same version as Ocaml node
 - **CI**: set fail-fast to false to prevent cancellation of other jobs
   ([#1305](https://github.com/o1-labs/openmina/pull/1305))
 
diff --git a/ledger/src/account/account.rs b/ledger/src/account/account.rs
@@ -128,7 +128,7 @@ impl TokenSymbol {
 
         let value = FromBytes::read(&s[..]).expect("Shoudn't fail");
         let bigint = BigInteger256::new(value);
-        F::try_from(bigint).unwrap() // Never fail, `self` contain 6 bytes at most
+        F::from(bigint) // Never fail, `self` contain 6 bytes at most
     }
 }
 
diff --git a/ledger/src/proofs/block.rs b/ledger/src/proofs/block.rs
@@ -501,7 +501,7 @@ mod floating_point {
 
         pub fn constant(value: &BigInteger256, precision: usize) -> anyhow::Result<Self> {
             Ok(Self {
-                value: (*value).try_into()?,
+                value: (*value).into(),
                 precision,
             })
         }
@@ -1881,10 +1881,10 @@ pub(super) fn generate_block_proof(
     };
 
     let dlog_plonk_index = super::merge::dlog_plonk_index(block_wrap_prover);
-    let verifier_index = &*block_wrap_prover.index.verifier_index.as_ref().unwrap();
+    let verifier_index = block_wrap_prover.index.verifier_index.as_ref().unwrap();
 
     let tx_dlog_plonk_index = super::merge::dlog_plonk_index(tx_wrap_prover);
-    let tx_verifier_index = &*tx_wrap_prover.index.verifier_index.as_ref().unwrap();
+    let tx_verifier_index = tx_wrap_prover.index.verifier_index.as_ref().unwrap();
 
     let dlog_plonk_index_cvar = dlog_plonk_index.to_cvar(CircuitVar::Var);
     let tx_dlog_plonk_index_cvar = tx_dlog_plonk_index.to_cvar(CircuitVar::Constant);
diff --git a/ledger/src/proofs/caching.rs b/ledger/src/proofs/caching.rs
@@ -221,12 +221,7 @@ where
                 let lagrange_bases = srs
                     .lagrange_bases
                     .iter()
-                    .map(|(key, value)| {
-                        (
-                            *key,
-                            value.iter().map(|poly| PolyComm::from(poly)).collect(),
-                        )
-                    })
+                    .map(|(key, value)| (*key, value.iter().map(PolyComm::from).collect()))
                     .collect();
 
                 HashMapCache::new_from_hashmap(lagrange_bases)
@@ -452,7 +447,6 @@ impl From<&VerifierIndexCached> for VerifierIndex<Fq> {
             domain: domain.into(),
             max_poly_size: *max_poly_size,
             srs: {
-                let srs = srs;
                 let s: SRS<_> = SRS::from(srs);
                 Arc::new(s)
             },
diff --git a/ledger/src/proofs/field.rs b/ledger/src/proofs/field.rs
@@ -143,7 +143,7 @@ impl FromFpFq for Fq {
     fn from_fp(fp: Fp) -> Self {
         // `Fp` is smaller than `Fq`, so the conversion is fine
         let bigint: BigInteger256 = fp.into();
-        bigint.try_into().unwrap()
+        Self::from(bigint)
     }
     fn from_fq(fq: Fq) -> Self {
         fq
diff --git a/ledger/src/proofs/merge.rs b/ledger/src/proofs/merge.rs
@@ -95,7 +95,7 @@ fn merge_main(
 }
 
 pub fn dlog_plonk_index(wrap_prover: &Prover<Fq>) -> PlonkVerificationKeyEvals<Fp> {
-    PlonkVerificationKeyEvals::from(&*wrap_prover.index.verifier_index.as_ref().unwrap())
+    PlonkVerificationKeyEvals::from(wrap_prover.index.verifier_index.as_ref().unwrap())
 }
 
 impl From<&v2::PicklesProofProofsVerified2ReprStableV2StatementProofStateDeferredValuesPlonkFeatureFlags> for crate::proofs::step::FeatureFlags::<bool> {
@@ -260,7 +260,7 @@ pub(super) fn generate_merge_proof(
 
     let dlog_plonk_index = dlog_plonk_index(wrap_prover);
     let dlog_plonk_index_cvar = dlog_plonk_index.to_cvar(CircuitVar::Var);
-    let verifier_index = &*wrap_prover.index.verifier_index.as_ref().unwrap();
+    let verifier_index = wrap_prover.index.verifier_index.as_ref().unwrap();
 
     let tx_data = make_step_transaction_data(&dlog_plonk_index_cvar);
     let for_step_datas = [&tx_data, &tx_data];
diff --git a/ledger/src/proofs/public_input/prepared_statement.rs b/ledger/src/proofs/public_input/prepared_statement.rs
@@ -91,7 +91,7 @@ impl PreparedStatement {
 
         let to_fq = |fp: Fp| -> Fq {
             let bigint: BigInteger256 = fp.into();
-            bigint.try_into().unwrap() // Never fail, `Fq` is larger than `Fp`
+            Fq::from(bigint) // Never fail, `Fq` is larger than `Fp`
         };
 
         // Fp
@@ -226,7 +226,7 @@ impl PreparedStatement {
 
         let to_fq = |fp: Fp| -> Fq {
             let bigint: BigInteger256 = fp.into();
-            bigint.try_into().unwrap() // Never fail, `Fq` is larger than `Fp`
+            Fq::from(bigint) // Never fail, `Fq` is larger than `Fp`
         };
 
         let var = |x| Packed::Field(CircuitVar::Var(x));
diff --git a/ledger/src/proofs/public_input/scalars.rs b/ledger/src/proofs/public_input/scalars.rs
@@ -50,7 +50,7 @@ where
 
     let value = FromBytes::read(&bytes[..]).expect("Should not fail");
     let bigint = BigInteger256::new(value);
-    bigint.try_into().unwrap() // Never fail, we hardcode them with string literals
+    F::from(bigint) // Never fail, we hardcode them with string literals
 }
 
 fn field<F: FieldWitness>(s: &str) -> F {
diff --git a/ledger/src/proofs/step.rs b/ledger/src/proofs/step.rs
@@ -1067,7 +1067,7 @@ pub mod step_verifier {
             let v = if s_odd { s - F2::one() } else { s };
             // TODO: Remove this ugly hack
             let v: BigInteger256 = (v / F2::from(2u64)).into();
-            (F::try_from(v).unwrap(), s_odd.to_boolean()) // `unwrap` never fail
+            (F::from(v), s_odd.to_boolean()) // `unwrap` never fail
         });
 
         scale_fast2(g, s_parts, num_bits, w)
diff --git a/ledger/src/proofs/transaction.rs b/ledger/src/proofs/transaction.rs
@@ -3686,7 +3686,7 @@ pub fn messages_for_next_wrap_proof_padding() -> Fp {
             old_bulletproof_challenges: vec![], // Filled with padding, in `hash()` below
         };
         let hash: [u64; 4] = msg.hash();
-        Fp::try_from(BigInteger256::new(hash)).unwrap() // Never fail
+        Fp::from(BigInteger256::new(hash)) // Never fail
     })
 }
 
@@ -4247,7 +4247,7 @@ pub(super) fn generate_tx_proof(
     let statement_with_sok = statement.with_digest(sok_digest);
 
     let dlog_plonk_index =
-        PlonkVerificationKeyEvals::from(&*tx_wrap_prover.index.verifier_index.as_ref().unwrap());
+        PlonkVerificationKeyEvals::from(tx_wrap_prover.index.verifier_index.as_ref().unwrap());
 
     let statement_with_sok = Rc::new(w.exists(statement_with_sok));
     transaction_snark::main(&statement_with_sok, tx_witness, w)?;
diff --git a/ledger/src/proofs/wrap.rs b/ledger/src/proofs/wrap.rs
@@ -200,9 +200,9 @@ pub fn create_oracle_with_public_input<F: FieldWitness>(
     use poly_commitment::commitment::shift_scalar;
 
     // TODO: Don't clone the SRS here
-    let mut srs = (*verifier_index.srs).clone();
+    let srs = (*verifier_index.srs).clone();
     let log_size_of_group = verifier_index.domain.log_size_of_group;
-    let lgr_comm = make_lagrange::<F>(&mut srs, log_size_of_group);
+    let lgr_comm = make_lagrange::<F>(&srs, log_size_of_group);
 
     let lgr_comm: Vec<PolyComm<F::OtherCurve>> =
         lgr_comm.into_iter().take(public_input.len()).collect();
@@ -501,20 +501,21 @@ fn make_public_input(
         unfinalized_proofs.to_field_elements(&mut fields);
     }
 
-    let to_fp = |v: [u64; 4]| Fp::try_from(BigInteger256::new(v)).unwrap(); // Never fail, `messages_for_next_step_proof_hash` was a `Fp`
+    let to_fp = |v: [u64; 4]| Fp::from(BigInteger256::new(v)); // Never fail, `messages_for_next_step_proof_hash` was a `Fp`
     to_fp(messages_for_next_step_proof_hash).to_field_elements(&mut fields);
 
     // `messages_for_next_wrap_proof_hash` were `Fq` previously, so we have to
     // build a `Fp` from them with care: they can overflow
     let to_fp = |v: [u64; 4]| {
-        match Fp::try_from(BigInteger256::new(v)) {
-            Ok(fp) => fp, // fast-path: we get the `Fp` without modulo/reducing
-            Err(_) => {
-                // slow path: we build the `Fp` bit by bit, so it will reduce it
-                let bits = crate::proofs::transaction::bigint_to_bits::<255>(BigInteger256::new(v));
-                super::util::field_of_bits(&bits)
-            }
-        }
+        // match Fp::try_from(BigInteger256::new(v)) {
+        //     Ok(fp) => fp, // fast-path: we get the `Fp` without modulo/reducing
+        //     Err(_) => {
+        //         // slow path: we build the `Fp` bit by bit, so it will reduce it
+        //         let bits = crate::proofs::transaction::bigint_to_bits::<255>(BigInteger256::new(v));
+        //         super::util::field_of_bits(&bits)
+        //     }
+        // }
+        Fp::from(BigInteger256::new(v))
     };
     for msg in messages_for_next_wrap_proof_hash.iter().copied().map(to_fp) {
         msg.to_field_elements(&mut fields);
@@ -687,7 +688,7 @@ pub fn wrap<C: ProofConstants + ForWrapData>(
         prover_index: step_prover_index,
     });
 
-    let to_fq = |[a, b]: [u64; 2]| Fq::try_from(BigInteger256::new([a, b, 0, 0])).unwrap(); // Never fail with 2 limbs
+    let to_fq = |[a, b]: [u64; 2]| Fq::from(BigInteger256::new([a, b, 0, 0])); // Never fail with 2 limbs
     let to_fqs = |v: &[[u64; 2]]| v.iter().copied().map(to_fq).collect::<Vec<_>>();
 
     let messages_for_next_wrap_proof = MessagesForNextWrapProof {
@@ -845,7 +846,7 @@ impl Check<Fq> for ShiftedValue<Fp> {
             let shifted: Fq = {
                 let ShiftedValue { shifted } = self.clone();
                 let f: BigInteger256 = shifted.into();
-                f.try_into().unwrap() // Never fail, `Fq` is larger than `Fp`
+                f.into() // Never fail, `Fq` is larger than `Fp`
             };
             field::equal(shifted, forbidden, w)
         });
@@ -2178,7 +2179,7 @@ pub mod wrap_verifier {
 
         let combined_inner_product: Fq = {
             let bigint: BigInteger256 = advice.combined_inner_product.shifted.into();
-            bigint.try_into().unwrap() // Never fail, `Fq` is larger than `Fp`
+            bigint.into() // Never fail, `Fq` is larger than `Fp`
         };
         sponge.absorb(&[combined_inner_product], w);
 
diff --git a/ledger/src/staged_ledger/staged_ledger.rs b/ledger/src/staged_ledger/staged_ledger.rs
@@ -2010,7 +2010,7 @@ mod tests_ocaml {
         sync::atomic::{AtomicUsize, Ordering::Relaxed},
     };
 
-    use ark_ec::{AffineCurve, ProjectiveCurve};
+    use ark_ec::{AffineRepr, CurveGroup};
     use ark_ff::Zero;
     use mina_curves::pasta::Fq;
     use mina_signer::{Keypair, Signature, Signer};
@@ -3772,14 +3772,15 @@ mod tests_ocaml {
         Vec<Option<usize>>,
     ) {
         fn keypair_from_private(private: &str) -> Keypair {
+            use std::ops::Mul;
+
             let bytes = bs58::decode(private).into_vec().unwrap();
             let bytes = &bytes[1..]; // ignore base58 check byte
 
             let secret = mina_signer::ScalarField::from_bytes(&bytes[1..]).unwrap();
-            let public: mina_signer::CurvePoint =
-                mina_signer::CurvePoint::prime_subgroup_generator()
-                    .mul(secret)
-                    .into_affine();
+            let public: mina_signer::CurvePoint = mina_signer::CurvePoint::generator()
+                .mul(secret)
+                .into_affine();
 
             if !public.is_on_curve() {
                 panic!()
diff --git a/ledger/src/verifier/mod.rs b/ledger/src/verifier/mod.rs
@@ -390,11 +390,11 @@ pub mod common {
 
         let signature_prefix = openmina_core::NetworkConfig::global().signature_prefix;
         let hash = hash_with_kimchi(signature_prefix, &[**msg, *x, *y, *rx]);
-        let hash: Fq = Fq::try_from(hash.into_bigint()).unwrap(); // Never fail, `Fq` is larger than `Fp`
+        let hash: Fq = Fq::from(hash.into_bigint()); // Never fail, `Fq` is larger than `Fp`
 
         let sv: CurvePoint = CurvePoint::generator().mul(*s).into_affine();
         // Perform addition and infinity check in projective coordinates for performance
-        let rv = pubkey.point().mul(hash).neg() + &sv;
+        let rv = pubkey.point().mul(hash).neg() + sv;
         if rv.is_zero() {
             return false;
         }
@@ -425,11 +425,11 @@ pub mod common {
         inputs.append_field(*rx);
 
         let hash = legacy::hash_with_kimchi(signature_prefix, &inputs.to_fields());
-        let hash: Fq = Fq::try_from(hash.into_bigint()).unwrap(); // Never fail, `Fq` is larger than `Fp`
+        let hash: Fq = Fq::from(hash.into_bigint()); // Never fail, `Fq` is larger than `Fp`
 
         let sv: CurvePoint = CurvePoint::generator().mul(*s).into_affine();
         // Perform addition and infinity check in projective coordinates for performance
-        let rv = pubkey.point().mul(hash).neg() + &sv;
+        let rv = pubkey.point().mul(hash).neg() + sv;
         if rv.is_zero() {
             return false;
         }
diff --git a/poseidon/src/hash.rs b/poseidon/src/hash.rs
@@ -169,16 +169,14 @@ impl Inputs {
                 // `current` are zero (we just shift-left them)
                 current[0] |= item;
             } else {
-                self.fields
-                    .push(BigInteger256::new(current).try_into().unwrap()); // Never fail
+                self.fields.push(BigInteger256::new(current).into()); // Never fail
                 current = [item, 0, 0, 0];
                 nbits = item_nbits;
             }
         }
 
         if nbits > 0 {
-            self.fields
-                .push(BigInteger256::new(current).into()); // Never fail
+            self.fields.push(BigInteger256::new(current).into()); // Never fail
         }
 
         self.fields

Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ impl TokenSymbol {`
`128`	`128`
`129`	`129`	`let value = FromBytes::read(&s[..]).expect("Shoudn't fail");`
`130`	`130`	`let bigint = BigInteger256::new(value);`
`131`		- F::try_from(bigint).unwrap() // Never fail, `self` contain 6 bytes at most
	`131`	+ F::from(bigint) // Never fail, `self` contain 6 bytes at most
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ impl FromFpFq for Fq {`
`143`	`143`	`fn from_fp(fp: Fp) -> Self {`
`144`	`144`	// `Fp` is smaller than `Fq`, so the conversion is fine
`145`	`145`	`let bigint: BigInteger256 = fp.into();`
`146`		`- bigint.try_into().unwrap()`
	`146`	`+ Self::from(bigint)`
`147`	`147`	`}`
`148`	`148`	`fn from_fq(fq: Fq) -> Self {`
`149`	`149`	`fq`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ fn merge_main(`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`pub fn dlog_plonk_index(wrap_prover: &Prover<Fq>) -> PlonkVerificationKeyEvals<Fp> {`
`98`		`- PlonkVerificationKeyEvals::from(&*wrap_prover.index.verifier_index.as_ref().unwrap())`
	`98`	`+ PlonkVerificationKeyEvals::from(wrap_prover.index.verifier_index.as_ref().unwrap())`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`impl From<&v2::PicklesProofProofsVerified2ReprStableV2StatementProofStateDeferredValuesPlonkFeatureFlags> for crate::proofs::step::FeatureFlags::<bool> {`
`@@ -260,7 +260,7 @@ pub(super) fn generate_merge_proof(`
`260`	`260`
`261`	`261`	`let dlog_plonk_index = dlog_plonk_index(wrap_prover);`
`262`	`262`	`let dlog_plonk_index_cvar = dlog_plonk_index.to_cvar(CircuitVar::Var);`
`263`		`- let verifier_index = &*wrap_prover.index.verifier_index.as_ref().unwrap();`
	`263`	`+ let verifier_index = wrap_prover.index.verifier_index.as_ref().unwrap();`
`264`	`264`
`265`	`265`	`let tx_data = make_step_transaction_data(&dlog_plonk_index_cvar);`
`266`	`266`	`let for_step_datas = [&tx_data, &tx_data];`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ where`
`50`	`50`
`51`	`51`	`let value = FromBytes::read(&bytes[..]).expect("Should not fail");`
`52`	`52`	`let bigint = BigInteger256::new(value);`
`53`		`- bigint.try_into().unwrap() // Never fail, we hardcode them with string literals`
	`53`	`+ F::from(bigint) // Never fail, we hardcode them with string literals`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`fn field<F: FieldWitness>(s: &str) -> F {`