Revert "add to zero bin"

This reverts commit d098b24.

evm_arithmetization/tests/two_to_one_block.rs

@@ -162,6 +162,7 @@ fn get_test_block_proof(
     Ok(wrapped_block_proof)
 }
 
+#[ignore]
 #[test]
 fn test_two_to_one_block_aggregation() -> anyhow::Result<()> {
     init_logger();

zero/src/bin/leader.rs

@@ -79,7 +79,7 @@ async fn main() -> Result<()> {
         if let paladin::config::Runtime::InMemory = args.paladin.runtime {
             args.prover_state_config
                 .into_prover_state_manager()
-                .initialize(args.use_test_config)?;
+                .initialize()?;
         }
     }
 

zero/src/bin/leader/cli.rs

@@ -29,10 +29,6 @@ pub(crate) struct Cli {
     // Mode to use for worker for setup (affinity or default)
     #[arg(long = "worker-run-mode", help_heading = WORKER_HELP_HEADING, value_enum, default_value = "default")]
     pub(crate) worker_run_mode: WorkerRunMode,
-
-    /// Run in an unsafe but fast configuration for testing purposes
-    #[arg(long)]
-    pub(crate) use_test_config: bool,
 }
 
 /// Defines the mode for worker setup in terms of job allocation:

zero/src/bin/verifier.rs

@@ -30,7 +30,7 @@ fn main() -> Result<()> {
     let verifier = args
         .prover_state_config
         .into_prover_state_manager()
-        .verifier(args.use_test_config)?;
+        .verifier()?;
 
     if input_proofs.into_iter().all(|block_proof| {
         verifier

zero/src/bin/verifier/cli.rs

@@ -13,7 +13,4 @@ pub(crate) struct Cli {
     /// and the verifier state.
     #[clap(flatten)]
     pub(crate) prover_state_config: CliProverStateConfig,
-    /// Run in an unsafe but fast configuration for testing
-    #[arg(long)]
-    pub(crate) use_test_config: bool,
 }

zero/src/bin/worker.rs

@@ -20,8 +20,6 @@ struct Cli {
     paladin: paladin::config::Config,
     #[clap(flatten)]
     prover_state_config: CliProverStateConfig,
-    #[arg(long)]
-    use_test_config: bool,
 }
 
 #[tokio::main]
@@ -33,7 +31,7 @@ async fn main() -> Result<()> {
 
     args.prover_state_config
         .into_prover_state_manager()
-        .initialize(args.use_test_config)?;
+        .initialize()?;
 
     let runtime = WorkerRuntime::from_config(&args.paladin, register()).await?;
     runtime.main_loop().await?;

zero/src/prover_state/circuit.rs

@@ -5,9 +5,6 @@ use std::{
     str::FromStr,
 };
 
-use evm_arithmetization::testing_utils::{
-    TEST_RECURSION_CONFIG, TEST_STARK_CONFIG, TEST_THRESHOLD_DEGREE_BITS,
-};
 pub use evm_arithmetization::NUM_TABLES;
 use evm_arithmetization::{AllRecursiveCircuits, AllStark, StarkConfig};
 
@@ -246,26 +243,15 @@ impl CircuitConfig {
     }
 
     /// Build the circuits from the current config.
-    pub fn as_all_recursive_circuits(&self, use_test_config: bool) -> AllRecursiveCircuits {
-        if use_test_config {
-            AllRecursiveCircuits::new(
-                &AllStark::default(),
-                self.as_degree_bits_ranges(),
-                &TEST_STARK_CONFIG,
-                Some(&TEST_RECURSION_CONFIG),
-                Some(&TEST_RECURSION_CONFIG),
-                Some(TEST_THRESHOLD_DEGREE_BITS),
-            )
-        } else {
-            AllRecursiveCircuits::new(
-                &AllStark::default(),
-                self.as_degree_bits_ranges(),
-                &StarkConfig::standard_fast_config(),
-                None,
-                None,
-                None,
-            )
-        }
+    pub fn as_all_recursive_circuits(&self) -> AllRecursiveCircuits {
+        AllRecursiveCircuits::new(
+            &AllStark::default(),
+            self.as_degree_bits_ranges(),
+            &StarkConfig::standard_fast_config(),
+            None,
+            None,
+            None,
+        )
     }
 }
 

zero/src/prover_state/mod.rs

@@ -283,16 +283,14 @@ impl ProverStateManager {
     }
 
     /// Initialize global prover state from the configuration.
-    pub fn initialize(&self, use_test_config: bool) -> anyhow::Result<()> {
+    pub fn initialize(&self) -> anyhow::Result<()> {
         info!("initializing prover state...");
 
         let state = match self.persistence {
             CircuitPersistence::None => {
                 info!("generating circuits...");
                 ProverState {
-                    state: self
-                        .circuit_config
-                        .as_all_recursive_circuits(use_test_config),
+                    state: self.circuit_config.as_all_recursive_circuits(),
                 }
             }
             CircuitPersistence::Disk(strategy) => {
@@ -312,9 +310,8 @@ impl ProverStateManager {
                     }
                     Err(_) => {
                         info!("failed to load preprocessed circuits from disk. generating circuits...");
-                        let all_recursive_circuits = self
-                            .circuit_config
-                            .as_all_recursive_circuits(use_test_config);
+                        let all_recursive_circuits =
+                            self.circuit_config.as_all_recursive_circuits();
                         info!("saving preprocessed circuits to disk");
                         persistence::persist_all_to_disk(
                             &all_recursive_circuits,
@@ -346,14 +343,12 @@ impl ProverStateManager {
     }
 
     /// Loads a verifier state from disk or generate it.
-    pub fn verifier(&self, use_test_config: bool) -> anyhow::Result<VerifierState> {
+    pub fn verifier(&self) -> anyhow::Result<VerifierState> {
         info!("initializing verifier state...");
         match self.persistence {
             CircuitPersistence::None => {
                 info!("generating circuit...");
-                let prover_state = self
-                    .circuit_config
-                    .as_all_recursive_circuits(use_test_config);
+                let prover_state = self.circuit_config.as_all_recursive_circuits();
                 Ok(VerifierState {
                     state: prover_state.final_verifier_data(),
                 })
@@ -369,9 +364,7 @@ impl ProverStateManager {
                     }
                     Err(_) => {
                         info!("failed to load preprocessed verifier circuit from disk. generating it...");
-                        let prover_state = self
-                            .circuit_config
-                            .as_all_recursive_circuits(use_test_config);
+                        let prover_state = self.circuit_config.as_all_recursive_circuits();
 
                         info!("saving preprocessed verifier circuit to disk");
                         let state = prover_state.final_verifier_data();