chore: fmt + clippy

Author: roynalnaruto

prover/src/aggregator/verifier.rs

@@ -58,10 +58,9 @@ impl<'params> Verifier<'params> {
         // [`LAYER4_CONFIG_PATH`].
         env::set_var("COMPRESSION_CONFIG", &*LAYER4_CONFIG_PATH);
 
-        let params = params_map.get(&*LAYER4_DEGREE).expect(&format!(
-            "KZG params don't contain degree={:?}",
-            LAYER4_DEGREE
-        ));
+        let params = params_map
+            .get(&*LAYER4_DEGREE)
+            .unwrap_or_else(|| panic!("KZG params don't contain degree={:?}", LAYER4_DEGREE));
 
         Self {
             inner: common::Verifier::from_params(params, &raw_vk),

prover/src/config.rs

@@ -163,11 +163,7 @@ impl LayerId {
     ///
     /// Every SNARK layer on top of the [`innermost layer`][LayerId::Inner] has an accumulator.
     pub fn accumulator(&self) -> bool {
-        if let Self::Inner = self {
-            false
-        } else {
-            true
-        }
+        !matches!(self, Self::Inner)
     }
 }
 

prover/src/proof/proof_v2.rs

@@ -91,19 +91,19 @@ impl<Inner: Proof + serde::de::DeserializeOwned> ProofV2<Inner> {
     /// Read and deserialize the proof.
     pub fn from_json<P: AsRef<Path>>(dir: P, suffix: &str) -> Result<Self, ProverError> {
         let path = Self::path_proof(dir, suffix);
-        Ok(read_json_deep(path)?)
+        read_json_deep(path)
     }
 
     /// Serialize the proof and other peripheral data, before dumping in the provided directory.
     pub fn dump<P: AsRef<Path>>(&self, dir: P, suffix: &str) -> Result<(), ProverError> {
         // Dump the verifying key.
-        write(Self::path_vk(&dir, &suffix), &self.vk)?;
+        write(Self::path_vk(&dir, suffix), &self.vk)?;
 
         // Dump the proof itself.
-        write_json(Self::path_proof(&dir, &suffix), &self)?;
+        write_json(Self::path_proof(&dir, suffix), &self)?;
 
         // Dump any other data for the inner data.
-        self.inner.dump(&dir, &suffix)?;
+        self.inner.dump(&dir, suffix)?;
 
         Ok(())
     }
@@ -210,7 +210,7 @@ impl BundleProofV2 {
         }
 
         Ok(Self {
-            inner: BundleProofV2Metadata::default(),
+            inner: BundleProofV2Metadata,
             proof: proof.to_vec(),
             instances: instances.to_vec(),
             vk: vk.to_vec(),
@@ -275,7 +275,7 @@ impl Proof for ChunkProofV2Metadata {
     }
 
     fn dump<P: AsRef<Path>>(&self, dir: P, suffix: &str) -> Result<(), ProverError> {
-        write(Self::path_protocol(&dir, &suffix), &self.protocol)?;
+        write(Self::path_protocol(&dir, suffix), &self.protocol)?;
 
         Ok(())
     }
@@ -310,7 +310,7 @@ impl Proof for BatchProofV2Metadata {
     }
 
     fn dump<P: AsRef<Path>>(&self, dir: P, suffix: &str) -> Result<(), ProverError> {
-        write(Self::path_protocol(&dir, &suffix), &self.protocol)?;
+        write(Self::path_protocol(&dir, suffix), &self.protocol)?;
 
         Ok(())
     }

prover/src/utils/io.rs

@@ -118,7 +118,7 @@ pub fn try_read<P: AsRef<Path>>(path: P) -> Option<Vec<u8>> {
 ///
 /// Panics if any i/o error encountered.
 pub fn force_read<P: AsRef<Path> + std::fmt::Debug>(path: P) -> Vec<u8> {
-    self::read(path.as_ref()).expect(&format!("no file found! path={path:?}"))
+    self::read(path.as_ref()).unwrap_or_else(|_| panic!("no file found! path={path:?}"))
 }
 
 /// Wrapper functionality to write bytes to a file.

prover/src/zkevm/circuit/builder.rs

@@ -136,10 +136,8 @@ fn block_traces_to_witness_block(block_traces: Vec<BlockTrace>) -> Result<Block,
     }
 
     let mut traces = block_traces.into_iter();
-    let mut builder = CircuitInputBuilder::new_from_l2_trace(
-        get_super_circuit_params(),
-        traces.next().unwrap(),
-    )?;
+    let mut builder =
+        CircuitInputBuilder::new_from_l2_trace(get_super_circuit_params(), traces.next().unwrap())?;
     for (idx, block_trace) in traces.enumerate() {
         log::debug!(
             "add_more_l2_trace idx {}, block num {:?}",

prover/src/zkevm/prover.rs

@@ -122,7 +122,7 @@ impl<'params> Prover<'params> {
                 &chunk_info_reconstructed,
                 chunk_info_provided,
             )
-            .map_err(|e| ChunkProverError::Custom(e))?;
+            .map_err(ChunkProverError::Custom)?;
         }
 
         // Generate the final Layer-2 SNARK.

prover/src/zkevm/verifier.rs

@@ -48,10 +48,9 @@ impl<'params> Verifier<'params> {
         // [`LAYER2_CONFIG_PATH`].
         env::set_var("COMPRESSION_CONFIG", &*LAYER2_CONFIG_PATH);
 
-        let params = params_map.get(&*LAYER2_DEGREE).expect(&format!(
-            "KZG params don't contain degree={:?}",
-            LAYER2_DEGREE
-        ));
+        let params = params_map
+            .get(&*LAYER2_DEGREE)
+            .unwrap_or_else(|| panic!("KZG params don't contain degree={:?}", LAYER2_DEGREE));
 
         Self {
             inner: common::Verifier::from_params(params, &raw_vk),

testool/src/statetest/executor.rs

@@ -637,15 +637,12 @@ pub fn run_test(
         #[cfg(feature = "inner-prove")]
         {
             eth_types::constants::set_env_coinbase(&st.env.current_coinbase);
-            prover::test::inner_prove(&test_id, &witness_block);
+            prover::inner_prove(&test_id, &witness_block);
         }
         #[cfg(feature = "chunk-prove")]
         {
             eth_types::constants::set_env_coinbase(&st.env.current_coinbase);
-            prover::test::chunk_prove(
-                &test_id,
-                prover::ChunkProvingTask::new(vec![_scroll_trace], prover::ChunkKind::Halo2),
-            );
+            prover::chunk_prove(&test_id, prover::ChunkProvingTask::new(vec![_scroll_trace]));
         }
 
         #[cfg(not(any(feature = "inner-prove", feature = "chunk-prove")))]