Fixed lint issues

Author: 0xMimir

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
     }
 }
 

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);

ledger/src/proofs/caching.rs

@@ -224,7 +224,7 @@ where
                     .map(|(key, value)| {
                         (
                             *key,
-                            value.iter().map(|poly| PolyComm::from(poly)).collect(),
+                            value.iter().map(PolyComm::from).collect(),
                         )
                     })
                     .collect();
@@ -452,7 +452,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)
             },

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

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];

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));

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 {

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)

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)?;

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);