remove halo2 dependency and refactor types to better accomodate openvm

Author: omerfirmak

Cargo.lock

@@ -3,24 +3,13 @@ name = "scroll-proving-sdk"
 version = "0.1.0"
 edition = "2021"
 
-[patch.crates-io]
-ethers-signers  = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
-halo2curves = { git = "https://github.com/scroll-tech/halo2curves", branch = "v0.1.0" }
-[patch."https://github.com/privacy-scaling-explorations/halo2.git"]
-halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1"  }
-[patch."https://github.com/privacy-scaling-explorations/poseidon.git"]
-poseidon = { git = "https://github.com/scroll-tech/poseidon.git", branch = "main" }
-[patch."https://github.com/privacy-scaling-explorations/bls12_381"]
-bls12_381 = { git = "https://github.com/scroll-tech/bls12_381", branch = "feat/impl_scalar_field" }
-
 [dependencies]
 anyhow = "1.0"
 log = "0.4"
 serde = { version = "1.0.198", features = ["derive"] }
 serde_json = "1.0.116"
 ethers-core = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
 ethers-providers = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
-prover_darwin_v2 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.13.1", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
 reqwest = { version = "0.12.4", features = ["gzip"] }
 reqwest-middleware = "0.3"
 reqwest-retry = "0.5"
@@ -37,3 +26,22 @@ tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 axum = "0.6.0"
 dotenv = "0.15"
 rocksdb = "0.23.0"
+sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "omerfirmak-patch-1", features = [
+    "scroll",
+], optional = true }
+sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "omerfirmak-patch-1", features = [
+    "scroll",
+], optional = true }
+url = "2.5.4"
+
+[features]
+openvm = ["dep:sbv-utils", "dep:sbv-primitives"]
+
+[patch.crates-io]
+# patched add rkyv support & MSRV 1.77
+ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
+alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.18" }
+revm = { git = "https://github.com/scroll-tech/revm", branch = "scroll-evm-executor/v50" }
+revm-interpreter = { git = "https://github.com/scroll-tech/revm", branch = "scroll-evm-executor/v50" }
+revm-precompile = { git = "https://github.com/scroll-tech/revm", branch = "scroll-evm-executor/v50" }
+revm-primitives = { git = "https://github.com/scroll-tech/revm", branch = "scroll-evm-executor/v50" }

Cargo.toml

@@ -83,10 +83,10 @@ impl ProvingService for CloudProver {
     async fn get_vks(&self, req: GetVkRequest) -> GetVkResponse {
         todo!()
     }
-    async fn prove(&self, req: ProveRequest) -> ProveResponse {
+    async fn prove(&mut self, req: ProveRequest) -> ProveResponse {
         todo!()
     }
-    async fn query_task(&self, req: QueryTaskRequest) -> QueryTaskResponse {
+    async fn query_task(&mut self, req: QueryTaskRequest) -> QueryTaskResponse {
         todo!()
     }
 }
@@ -109,10 +109,7 @@ async fn main() -> anyhow::Result<()> {
     let cfg = CloudProverConfig::from_file_and_env(args.config_file)?;
     let sdk_config = cfg.sdk_config.clone();
     let cloud_prover = CloudProver::new(cfg);
-    let prover = ProverBuilder::new(sdk_config)
-        .with_proving_service(Box::new(cloud_prover))
-        .build()
-        .await?;
+    let prover = ProverBuilder::new(sdk_config, cloud_prover).build().await?;
 
     prover.run().await;
 

examples/cloud.rs

@@ -59,10 +59,10 @@ impl ProvingService for LocalProver {
     async fn get_vks(&self, req: GetVkRequest) -> GetVkResponse {
         todo!()
     }
-    async fn prove(&self, req: ProveRequest) -> ProveResponse {
+    async fn prove(&mut self, req: ProveRequest) -> ProveResponse {
         todo!()
     }
-    async fn query_task(&self, req: QueryTaskRequest) -> QueryTaskResponse {
+    async fn query_task(&mut self, req: QueryTaskRequest) -> QueryTaskResponse {
         todo!()
     }
 }
@@ -81,10 +81,7 @@ async fn main() -> anyhow::Result<()> {
     let cfg = LocalProverConfig::from_file_and_env(args.config_file)?;
     let sdk_config = cfg.sdk_config.clone();
     let local_prover = LocalProver::new(cfg);
-    let prover = ProverBuilder::new(sdk_config)
-        .with_proving_service(Box::new(local_prover))
-        .build()
-        .await?;
+    let prover = ProverBuilder::new(sdk_config, local_prover).build().await?;
 
     prover.run().await;
 

examples/local.rs

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "nightly-2023-12-03"
+channel = "nightly-2024-12-06"

rust-toolchain.toml

@@ -1,4 +1,7 @@
-use crate::prover::CircuitType;
+use crate::{
+    coordinator_handler::ProverType,
+    prover::{CircuitType, ProofType},
+};
 use anyhow::{anyhow, Result};
 use dotenv::dotenv;
 use serde::{Deserialize, Serialize};
@@ -32,7 +35,8 @@ pub struct L2GethConfig {
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ProverConfig {
-    pub circuit_types: Vec<CircuitType>,
+    pub circuit_type: CircuitType,
+    pub supported_proof_types: Vec<ProofType>,
     pub circuit_version: String,
     #[serde(default = "default_n_workers")]
     pub n_workers: usize,
@@ -94,22 +98,23 @@ impl Config {
                 l2geth.endpoint = val;
             }
         }
-        if let Some(val) = Self::get_env_var("CIRCUIT_TYPES")? {
+
+        if let Some(val) = Self::get_env_var("PROOF_TYPES")? {
             let values_vec: Vec<&str> = val
                 .trim_matches(|c| c == '[' || c == ']')
                 .split(',')
                 .map(|s| s.trim())
                 .collect();
 
-            self.prover.circuit_types = values_vec
+            self.prover.supported_proof_types = values_vec
                 .iter()
                 .map(|value| match value.parse::<u8>() {
-                    Ok(num) => CircuitType::from_u8(num),
+                    Ok(num) => ProofType::from_u8(num),
                     Err(e) => {
                         panic!("Failed to parse circuit type: {}", e);
                     }
                 })
-                .collect::<Vec<CircuitType>>();
+                .collect::<Vec<ProofType>>();
         }
 
         if let Some(val) = Self::get_env_var("N_WORKERS")? {
@@ -122,4 +127,30 @@ impl Config {
 
         Ok(())
     }
+
+    pub fn coordinator_prover_type(&self) -> Vec<ProverType> {
+        if self.prover.circuit_type == CircuitType::OpenVM {
+            vec![ProverType::OpenVM]
+        } else {
+            let mut prover_types = vec![];
+            if self
+                .prover
+                .supported_proof_types
+                .iter()
+                .any(|t| *t == ProofType::Bundle || *t == ProofType::Batch)
+            {
+                prover_types.push(ProverType::Batch)
+            }
+
+            if self
+                .prover
+                .supported_proof_types
+                .contains(&ProofType::Chunk)
+            {
+                prover_types.push(ProverType::Chunk)
+            }
+
+            prover_types
+        }
+    }
 }

src/config.rs

@@ -1,16 +1,12 @@
 use super::{
     api::Api, error::ErrorCode, GetTaskRequest, GetTaskResponseData, KeySigner, LoginMessage,
-    LoginRequest, Response, SubmitProofRequest, SubmitProofResponseData,
-};
-use crate::{
-    config::CoordinatorConfig,
-    prover::{CircuitType, ProverProviderType},
-    utils::get_version,
+    LoginRequest, ProverType, Response, SubmitProofRequest, SubmitProofResponseData,
 };
+use crate::{config::CoordinatorConfig, prover::ProverProviderType, utils::get_version};
 use tokio::sync::{Mutex, MutexGuard};
 
 pub struct CoordinatorClient {
-    circuit_types: Vec<CircuitType>,
+    prover_types: Vec<ProverType>,
     vks: Vec<String>,
     pub prover_name: String,
     pub prover_provider_type: ProverProviderType,
@@ -22,15 +18,15 @@ pub struct CoordinatorClient {
 impl CoordinatorClient {
     pub fn new(
         cfg: CoordinatorConfig,
-        circuit_types: Vec<CircuitType>,
+        prover_types: Vec<ProverType>,
         vks: Vec<String>,
         prover_name: String,
         prover_provider_type: ProverProviderType,
         key_signer: KeySigner,
     ) -> anyhow::Result<Self> {
         let api = Api::new(cfg)?;
         let client = Self {
-            circuit_types,
+            prover_types,
             vks,
             prover_name,
             prover_provider_type,
@@ -111,22 +107,12 @@ impl CoordinatorClient {
             .as_ref()
             .ok_or_else(|| anyhow::anyhow!("Missing challenge token"))?;
 
-        let mut prover_types = vec![];
-        if self.circuit_types.contains(&CircuitType::Bundle)
-            || self.circuit_types.contains(&CircuitType::Batch)
-        {
-            prover_types.push(CircuitType::Batch)
-        }
-        if self.circuit_types.contains(&CircuitType::Chunk) {
-            prover_types.push(CircuitType::Chunk)
-        }
-
         let login_message = LoginMessage {
             challenge: login_response_data.token.clone(),
             prover_version: get_version().to_string(),
             prover_name: self.prover_name.clone(),
             prover_provider_type: self.prover_provider_type,
-            prover_types,
+            prover_types: self.prover_types.clone(),
             vks: self.vks.clone(),
         };
 

src/coordinator_handler/coordinator_client.rs

@@ -1,6 +1,6 @@
 use super::error::ErrorCode;
 use crate::{
-    prover::{CircuitType, ProverProviderType},
+    prover::{ProofType, ProverProviderType},
     tracing_handler::CommonHash,
 };
 use rlp::{Encodable, RlpStream};
@@ -13,13 +13,60 @@ pub struct Response<T> {
     pub data: Option<T>,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ProverType {
+    Undefined,
+    Chunk,
+    Batch,
+    OpenVM,
+}
+
+impl ProverType {
+    pub fn from_u8(v: u8) -> Self {
+        match v {
+            1 => ProverType::Chunk,
+            2 => ProverType::Batch,
+            3 => ProverType::OpenVM,
+            _ => ProverType::Undefined,
+        }
+    }
+
+    pub fn to_u8(&self) -> u8 {
+        match self {
+            ProverType::Undefined => 0,
+            ProverType::Chunk => 1,
+            ProverType::Batch => 2,
+            ProverType::OpenVM => 3,
+        }
+    }
+}
+
+impl Serialize for ProverType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_u8(self.to_u8())
+    }
+}
+
+impl<'de> Deserialize<'de> for ProverType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let v: u8 = u8::deserialize(deserializer)?;
+        Ok(ProverType::from_u8(v))
+    }
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct LoginMessage {
     pub challenge: String,
     pub prover_version: String,
     pub prover_name: String,
     pub prover_provider_type: ProverProviderType,
-    pub prover_types: Vec<CircuitType>,
+    pub prover_types: Vec<ProverType>,
     pub vks: Vec<String>,
 }
 
@@ -36,7 +83,7 @@ impl Encodable for LoginMessage {
         let prover_types = self
             .prover_types
             .iter()
-            .map(|prover_type: &CircuitType| prover_type.to_u8())
+            .map(|prover_type| prover_type.to_u8())
             .collect::<Vec<u8>>();
         s.append(&prover_types);
         s.begin_list(self.vks.len());
@@ -63,15 +110,15 @@ pub type ChallengeResponseData = LoginResponseData;
 
 #[derive(Default, Serialize, Deserialize)]
 pub struct GetTaskRequest {
-    pub task_types: Vec<CircuitType>,
+    pub task_types: Vec<ProofType>,
     pub prover_height: Option<u64>,
 }
 
 #[derive(Serialize, Deserialize, Clone)]
 pub struct GetTaskResponseData {
     pub uuid: String,
     pub task_id: String,
-    pub task_type: CircuitType,
+    pub task_type: ProofType,
     pub task_data: String,
     pub hard_fork_name: String,
 }
@@ -85,7 +132,7 @@ pub struct ChunkTaskDetail {
 pub struct SubmitProofRequest {
     pub uuid: String,
     pub task_id: String,
-    pub task_type: CircuitType,
+    pub task_type: ProofType,
     pub status: ProofStatus,
     pub proof: String,
     pub failure_type: Option<ProofFailureType>,
@@ -203,7 +250,7 @@ mod tests {
             prover_version: "v4.4.45-37af5ef5-38a68e2-1c5093c".to_string(),
             prover_name: "test".to_string(),
             prover_provider_type: ProverProviderType::Internal,
-            prover_types: vec![CircuitType::Chunk],
+            prover_types: vec![ProverType::Chunk],
             vks: vec!["mock_vk".to_string()],
         };