deprecate halo2 provers, start openvm prover

Author: omerfirmak

coordinator/internal/types/prover.go

@@ -27,6 +27,8 @@ const (
 	ProverTypeChunk
 	// ProverTypeBatch signals it's a batch prover, which can prove batch_tasks and bundle_tasks
 	ProverTypeBatch
+	// ProverTypeOpenVM signals it's an openvm prover
+	ProverTypeOpenVM
 )
 
 // MakeProverType make ProverType from ProofType

prover/src/config.rs

@@ -1,38 +1,36 @@
-use anyhow::{bail, Result};
+use anyhow::Result;
 use serde::{Deserialize, Serialize};
-use std::fs::File;
+use std::{collections::HashMap, fs::File};
 
 use crate::types::ProverType;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct CircuitConfig {
     pub hard_fork_name: String,
-    pub params_path: String,
-    pub assets_path: String,
+    pub workspace_path: String,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct CoordinatorConfig {
     pub base_url: String,
     pub retry_count: u32,
     pub retry_wait_time_sec: u64,
     pub connection_timeout_sec: u64,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct L2GethConfig {
     pub endpoint: String,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Clone)]
 pub struct Config {
     pub prover_name: String,
     pub keystore_path: String,
     pub keystore_password: String,
     pub db_path: String,
     pub prover_type: ProverType,
-    pub low_version_circuit: CircuitConfig,
-    pub high_version_circuit: CircuitConfig,
+    pub circuits: HashMap<String, CircuitConfig>,
     pub coordinator: CoordinatorConfig,
     pub l2geth: Option<L2GethConfig>,
 }
@@ -50,53 +48,3 @@ impl Config {
         Config::from_reader(&file)
     }
 }
-
-static SCROLL_PROVER_ASSETS_DIR_ENV_NAME: &str = "SCROLL_PROVER_ASSETS_DIR";
-static mut SCROLL_PROVER_ASSETS_DIRS: Vec<String> = vec![];
-
-#[derive(Debug)]
-pub struct AssetsDirEnvConfig {}
-
-impl AssetsDirEnvConfig {
-    pub fn init() -> Result<()> {
-        let value = std::env::var(SCROLL_PROVER_ASSETS_DIR_ENV_NAME)?;
-        let dirs: Vec<&str> = value.split(',').collect();
-        if dirs.len() != 2 {
-            bail!("env variable SCROLL_PROVER_ASSETS_DIR value must be 2 parts seperated by comma.")
-        }
-        unsafe {
-            SCROLL_PROVER_ASSETS_DIRS = dirs.into_iter().map(|s| s.to_string()).collect();
-            log::info!(
-                "init SCROLL_PROVER_ASSETS_DIRS: {:?}",
-                SCROLL_PROVER_ASSETS_DIRS
-            );
-        }
-        Ok(())
-    }
-
-    pub fn enable_first() {
-        unsafe {
-            log::info!(
-                "set env {SCROLL_PROVER_ASSETS_DIR_ENV_NAME} to {}",
-                &SCROLL_PROVER_ASSETS_DIRS[0]
-            );
-            std::env::set_var(
-                SCROLL_PROVER_ASSETS_DIR_ENV_NAME,
-                &SCROLL_PROVER_ASSETS_DIRS[0],
-            );
-        }
-    }
-
-    pub fn enable_second() {
-        unsafe {
-            log::info!(
-                "set env {SCROLL_PROVER_ASSETS_DIR_ENV_NAME} to {}",
-                &SCROLL_PROVER_ASSETS_DIRS[1]
-            );
-            std::env::set_var(
-                SCROLL_PROVER_ASSETS_DIR_ENV_NAME,
-                &SCROLL_PROVER_ASSETS_DIRS[1],
-            );
-        }
-    }
-}

prover/src/coordinator_client.rs

@@ -4,7 +4,6 @@ pub mod listener;
 pub mod types;
 
 use anyhow::{bail, Context, Ok, Result};
-use std::rc::Rc;
 
 use api::Api;
 use errors::*;
@@ -16,20 +15,20 @@ use crate::{config::Config, key_signer::KeySigner};
 
 pub use errors::ProofStatusNotOKError;
 
-pub struct CoordinatorClient<'a> {
+pub struct CoordinatorClient {
     api: Api,
     token: Option<String>,
-    config: &'a Config,
-    key_signer: Rc<KeySigner>,
+    config: Config,
+    key_signer: KeySigner,
     rt: Runtime,
     listener: Box<dyn Listener>,
     vks: Vec<String>,
 }
 
-impl<'a> CoordinatorClient<'a> {
+impl CoordinatorClient {
     pub fn new(
-        config: &'a Config,
-        key_signer: Rc<KeySigner>,
+        config: Config,
+        key_signer: KeySigner,
         listener: Box<dyn Listener>,
         vks: Vec<String>,
     ) -> Result<Self> {

prover/src/geth_client.rs

@@ -1,11 +1,7 @@
-use crate::types::CommonHash;
 use anyhow::Result;
 use ethers_core::types::BlockNumber;
 use tokio::runtime::Runtime;
 
-use serde::{de::DeserializeOwned, Serialize};
-use std::fmt::Debug;
-
 use ethers_providers::{Http, Provider};
 
 pub struct GethClient {
@@ -28,24 +24,6 @@ impl GethClient {
         })
     }
 
-    pub fn get_block_trace_by_hash<T>(&mut self, hash: &CommonHash) -> Result<T>
-    where
-        T: Serialize + DeserializeOwned + Debug + Send,
-    {
-        log::info!(
-            "{}: calling get_block_trace_by_hash, hash: {:#?}",
-            self.id,
-            hash
-        );
-
-        let trace_future = self
-            .provider
-            .request("scroll_getBlockTraceByNumberOrHash", [format!("{hash:#x}")]);
-
-        let trace = self.rt.block_on(trace_future)?;
-        Ok(trace)
-    }
-
     pub fn block_number(&mut self) -> Result<BlockNumber> {
         log::info!("{}: calling block_number", self.id);
 

prover/src/main.rs

@@ -15,7 +15,7 @@ mod zk_circuits_handler;
 
 use anyhow::Result;
 use clap::{ArgAction, Parser};
-use config::{AssetsDirEnvConfig, Config};
+use config::Config;
 use prover::Prover;
 use std::rc::Rc;
 use task_cache::{ClearCacheCoordinatorListener, TaskCache};
@@ -49,29 +49,23 @@ fn start() -> Result<()> {
     utils::log_init(args.log_file);
 
     let config: Config = Config::from_file(args.config_file)?;
-
-    if let Err(e) = AssetsDirEnvConfig::init() {
-        log::error!("AssetsDirEnvConfig init failed: {:#}", e);
-        std::process::exit(-2);
-    }
-
     let task_cache = Rc::new(TaskCache::new(&config.db_path)?);
 
     let coordinator_listener = Box::new(ClearCacheCoordinatorListener {
         task_cache: task_cache.clone(),
     });
 
-    let prover = Prover::new(&config, coordinator_listener)?;
+    let prover = Prover::new(config.clone(), coordinator_listener)?;
 
     log::info!(
-        "prover start successfully. name: {}, type: {:?}, publickey: {}, version: {}",
+        "starting prover. name: {}, type: {:?}, publickey: {}, version: {}",
         config.prover_name,
         config.prover_type,
-        prover.get_public_key(),
+        prover.public_key,
         version::get_version(),
     );
 
-    let task_processor = TaskProcessor::new(&prover, task_cache);
+    let task_processor = TaskProcessor::new(prover, task_cache);
 
     task_processor.start();