chore: remove unused util methods

Author: roynalnaruto

prover/src/aggregator/prover.rs

@@ -1,4 +1,4 @@
-use std::env;
+use std::{env, path::PathBuf};
 
 use aggregator::{decode_bytes, BatchData, BatchHash, BatchHeader, ChunkInfo, MAX_AGG_SNARKS};
 use eth_types::H256;
@@ -14,7 +14,7 @@ use crate::{
         FD_SP1_CHUNK_PROTOCOL,
     },
     types::BundleProvingTask,
-    utils::{force_to_read, try_to_read},
+    utils::{force_read, try_read},
     BatchProofV2, BatchProofV2Metadata, BatchProvingTask, BundleProofV2, ChunkKind, ChunkProof,
     ChunkProofV2, ParamsMap, ProverError,
 };
@@ -68,12 +68,14 @@ impl<'params> Prover<'params> {
         // The SNARK protocols for both variants of the Layer-2 SNARK must be available in the
         // assets directory before setting up the batch prover. The SNARK protocols are
         // specifically for the halo2-route and sp1-route of generating chunk proofs.
-        let halo2_protocol = force_to_read(assets_dir, &FD_HALO2_CHUNK_PROTOCOL);
-        let sp1_protocol = force_to_read(assets_dir, &FD_SP1_CHUNK_PROTOCOL);
+        let halo2_protocol =
+            force_read(PathBuf::from(assets_dir).join(FD_HALO2_CHUNK_PROTOCOL.clone()));
+        let sp1_protocol =
+            force_read(PathBuf::from(assets_dir).join(FD_SP1_CHUNK_PROTOCOL.clone()));
 
         // Try to read the verifying key for both Layer-4 and Layer-6 compression circuits.
-        let raw_vk_batch = try_to_read(assets_dir, &BATCH_VK_FILENAME);
-        let raw_vk_bundle = try_to_read(assets_dir, &BUNDLE_VK_FILENAME);
+        let raw_vk_batch = try_read(PathBuf::from(assets_dir).join(BATCH_VK_FILENAME.clone()));
+        let raw_vk_bundle = try_read(PathBuf::from(assets_dir).join(BUNDLE_VK_FILENAME.clone()));
 
         if raw_vk_batch.is_none() {
             log::warn!(

prover/src/aggregator/verifier.rs

@@ -1,4 +1,4 @@
-use std::env;
+use std::{env, path::PathBuf};
 
 use aggregator::CompressionCircuit;
 use halo2_proofs::{
@@ -11,7 +11,7 @@ use crate::{
     common,
     config::{LAYER4_CONFIG_PATH, LAYER4_DEGREE},
     consts::{batch_vk_filename, DEPLOYMENT_CODE_FILENAME},
-    utils::{deploy_and_call, force_to_read, try_to_read},
+    utils::{deploy_and_call, force_read, try_read},
     BatchProofV2, BatchProverError, BundleProofV2, ParamsMap, ProverError,
 };
 
@@ -49,10 +49,12 @@ impl<'params> Verifier<'params> {
     /// Panics if the verifying key is not found in the assets directory.
     pub fn from_params_and_assets(params_map: &'params ParamsMap, assets_dir: &str) -> Self {
         // Read verifying key in the assets directory.
-        let raw_vk = force_to_read(assets_dir, &batch_vk_filename());
+        let path = PathBuf::from(assets_dir).join(batch_vk_filename());
+        let raw_vk = force_read(&path);
 
         // Try to read the bytecode to deploy the verifier contract.
-        let deployment_code = try_to_read(assets_dir, &DEPLOYMENT_CODE_FILENAME);
+        let path = PathBuf::from(assets_dir).join(DEPLOYMENT_CODE_FILENAME.clone());
+        let deployment_code = try_read(&path);
 
         // The Layer-4 compressioe circuit is configured with the shape as per
         // [`LAYER4_CONFIG_PATH`].

prover/src/test/batch.rs

@@ -1,11 +1,14 @@
-use std::sync::{LazyLock, Mutex};
+use std::{
+    path::PathBuf,
+    sync::{LazyLock, Mutex},
+};
 
 use crate::{
     aggregator::{Prover, Verifier},
     config::{LayerId, BATCH_PROVER_DEGREES},
     consts::DEPLOYMENT_CODE_FILENAME,
     types::BundleProvingTask,
-    utils::{force_to_read, read_env_var},
+    utils::{force_read, read_env_var},
     BatchProvingTask, ParamsMap,
 };
 
@@ -37,7 +40,8 @@ pub fn batch_prove(test: &str, batch: BatchProvingTask) {
 
         let params = prover.prover_impl.params(LayerId::Layer4.degree());
 
-        let deployment_code = force_to_read(&assets_dir, &DEPLOYMENT_CODE_FILENAME);
+        let path = PathBuf::from(assets_dir).join(DEPLOYMENT_CODE_FILENAME.clone());
+        let deployment_code = force_read(&path);
 
         let pk = prover
             .prover_impl
@@ -70,7 +74,8 @@ pub fn bundle_prove(test: &str, bundle: BundleProvingTask) {
 
         let params = prover.prover_impl.params(LayerId::Layer4.degree());
 
-        let deployment_code = force_to_read(&assets_dir, &DEPLOYMENT_CODE_FILENAME);
+        let path = PathBuf::from(assets_dir).join(DEPLOYMENT_CODE_FILENAME.clone());
+        let deployment_code = force_read(&path);
 
         let pk = prover
             .prover_impl

prover/src/utils/io.rs

@@ -45,21 +45,6 @@ pub fn serialize_instance(instance: &[Vec<Fr>]) -> Vec<u8> {
     serde_json::to_vec(&instances_for_serde).unwrap()
 }
 
-pub fn try_to_read(dir: &str, filename: &str) -> Option<Vec<u8>> {
-    let mut path = PathBuf::from(dir);
-    path.push(filename);
-
-    if path.exists() {
-        self::read(&path).ok()
-    } else {
-        None
-    }
-}
-
-pub fn force_to_read(dir: &str, filename: &str) -> Vec<u8> {
-    try_to_read(dir, filename).unwrap_or_else(|| panic!("File {filename} must exist in {dir}"))
-}
-
 pub fn write_file(folder: &mut PathBuf, filename: &str, buf: &[u8]) {
     folder.push(filename);
     let mut fd = std::fs::File::create(folder.as_path()).unwrap();

prover/src/zkevm/prover.rs

@@ -1,4 +1,4 @@
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, path::PathBuf};
 
 use aggregator::ChunkInfo;
 use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
@@ -10,7 +10,7 @@ use crate::{
     consts::CHUNK_VK_FILENAME,
     proof::compare_chunk_info,
     types::ChunkProvingTask,
-    utils::try_to_read,
+    utils::try_read,
     zkevm::{
         circuit::{calculate_row_usage_of_witness_block, chunk_trace_to_witness_block},
         ChunkProverError, ChunkVerifier, RowUsage,
@@ -41,7 +41,8 @@ impl<'params> Prover<'params> {
         assets_dir: &str,
     ) -> Self {
         // Try to read the verifying key from disk, but don't panic if not found.
-        let raw_vk = try_to_read(assets_dir, &CHUNK_VK_FILENAME);
+        let path = PathBuf::from(assets_dir).join(CHUNK_VK_FILENAME.clone());
+        let raw_vk = try_read(&path);
 
         // Build the inner prover.
         let prover_impl = common::Prover::from_params_map(params_map);

prover/src/zkevm/verifier.rs

@@ -1,4 +1,4 @@
-use std::env;
+use std::{env, path::PathBuf};
 
 use aggregator::CompressionCircuit;
 use halo2_proofs::{
@@ -11,7 +11,7 @@ use crate::{
     common,
     config::{LAYER2_CONFIG_PATH, LAYER2_DEGREE},
     consts::chunk_vk_filename,
-    utils::force_to_read,
+    utils::force_read,
     ChunkProofV2, ChunkProverError, ParamsMap, ProverError,
 };
 
@@ -42,7 +42,8 @@ impl<'params> Verifier<'params> {
     /// Panics if the verifying key cannot be located in the given assets directory.
     pub fn from_params_and_assets(params_map: &'params ParamsMap, assets_dir: &str) -> Self {
         // Read the verifying key or panic.
-        let raw_vk = force_to_read(assets_dir, &chunk_vk_filename());
+        let path = PathBuf::from(assets_dir).join(chunk_vk_filename());
+        let raw_vk = force_read(&path);
 
         // The Layer-2 compression circuit is configured with the shape as per
         // [`LAYER2_CONFIG_PATH`].