fix lint

Signed-off-by: noelwei <fan@scroll.io>

common/libzkp/impl/Cargo.toml

@@ -13,6 +13,14 @@ halo2curves = { git = "https://github.com/scroll-tech/halo2curves", branch = "v0
 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" }
 ethers-signers  = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+# 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" }
+
 [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"]
@@ -28,6 +36,9 @@ snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", br
 prover_v4 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.2", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
 # darwin_v2
 prover_v5 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.13.1", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
+# euclid
+prover_v7 = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.1.0-rc.1", package = "scroll-zkvm-prover" }
+verifier_v7 = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.1.0-rc.1", package = "scroll-zkvm-verifier" }
 
 base64 = "0.13.0"
 env_logger = "0.9.0"

common/libzkp/impl/rust-toolchain

@@ -1 +1 @@
-nightly-2023-12-03
+nightly-2024-12-06

common/libzkp/impl/src/verifier.rs

@@ -1,9 +1,11 @@
 mod darwin;
 mod darwin_v2;
+mod euclid;
 
 use anyhow::{bail, Result};
 use darwin::DarwinVerifier;
 use darwin_v2::DarwinV2Verifier;
+use euclid::EuclidVerifier;
 use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
 use prover_v4::utils::load_params;
 use serde::{Deserialize, Serialize};
@@ -31,12 +33,14 @@ pub struct CircuitConfig {
 pub struct VerifierConfig {
     pub low_version_circuit: CircuitConfig,
     pub high_version_circuit: CircuitConfig,
+    pub zkvm_circuit: CircuitConfig,
 }
 
 type HardForkName = String;
 
 struct VerifierPair(HardForkName, Rc<Box<dyn ProofVerifier>>);
 
+static mut VERIFIER_ZKVM: OnceCell<VerifierPair> = OnceCell::new();
 static mut VERIFIER_HIGH: OnceCell<VerifierPair> = OnceCell::new();
 static mut VERIFIER_LOW: OnceCell<VerifierPair> = OnceCell::new();
 static mut PARAMS_MAP: OnceCell<BTreeMap<u32, ParamsKZG<Bn256>>> = OnceCell::new();
@@ -90,6 +94,17 @@ pub fn init(config: VerifierConfig) {
             ))
             .unwrap_unchecked();
     }
+    let zkvm_conf = config.zkvm_circuit;
+    let verifier =
+        EuclidVerifier::new(unsafe { PARAMS_MAP.get().unwrap() }, &high_conf.assets_path);
+    unsafe {
+        VERIFIER_ZKVM
+            .set(VerifierPair(
+                zkvm_conf.fork_name,
+                Rc::new(Box::new(verifier)),
+            ))
+            .unwrap_unchecked();
+    }
 }
 
 pub fn get_verifier(fork_name: &str) -> Result<Rc<Box<dyn ProofVerifier>>> {
@@ -105,6 +120,12 @@ pub fn get_verifier(fork_name: &str) -> Result<Rc<Box<dyn ProofVerifier>>> {
                 return Ok(verifier.1.clone());
             }
         }
+
+        if let Some(verifier) = VERIFIER_ZKVM.get() {
+            if verifier.0 == fork_name {
+                return Ok(verifier.1.clone());
+            }
+        }
     }
     bail!("failed to get verifier, key not found, {}", fork_name)
 }

common/libzkp/impl/src/verifier/euclid.rs

@@ -0,0 +1,60 @@
+use super::{ProofVerifier, TaskType};
+
+use anyhow::Result;
+use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
+
+use crate::utils::panic_catch;
+use prover_v7::{BatchProof, BatchProver, BundleProof, BundleProver, ChunkProof, ChunkProver};
+use std::{collections::BTreeMap, env, path::Path};
+
+pub struct EuclidVerifier {
+    chunk_verifier: ChunkProver,
+    batch_verifier: BatchProver,
+    bundle_verifier: BundleProver,
+}
+
+impl EuclidVerifier {
+    // TODO: if only euclid verifier is used, it would just need params in the final evm
+    // layer so `bundle_verifier` can manage the params by itself
+    pub fn new(_params_map: &BTreeMap<u32, ParamsKZG<Bn256>>, assets_dir: &str) -> Self {
+        env::set_var("SCROLL_PROVER_ASSETS_DIR", assets_dir);
+        let zkvm_release_path = Path::new(assets_dir).join("scroll-zkvm").join("current");
+        let chunk_asset_dir = Path::new(&zkvm_release_path).join("chunk");
+        let chunk_verifier = ChunkProver::setup(&chunk_asset_dir, &chunk_asset_dir, None).unwrap();
+
+        let batch_asset_dir = Path::new(&zkvm_release_path).join("batch");
+        let batch_verifier = BatchProver::setup(&batch_asset_dir, &batch_asset_dir, None).unwrap();
+
+        let bundle_asset_dir = Path::new(&zkvm_release_path).join("bundle");
+        let bundle_verifier =
+            BundleProver::setup(&bundle_asset_dir, &bundle_asset_dir, None).unwrap();
+
+        Self {
+            chunk_verifier,
+            batch_verifier,
+            bundle_verifier,
+        }
+    }
+}
+
+impl ProofVerifier for EuclidVerifier {
+    fn verify(&self, task_type: super::TaskType, proof: Vec<u8>) -> Result<bool> {
+        let result = panic_catch(|| match task_type {
+            TaskType::Chunk => {
+                let proof = serde_json::from_slice::<ChunkProof>(proof.as_slice()).unwrap();
+                self.chunk_verifier.verify_proof(&proof).is_ok()
+            }
+            TaskType::Batch => {
+                let proof = serde_json::from_slice::<BatchProof>(proof.as_slice()).unwrap();
+                self.batch_verifier.verify_proof(&proof).is_ok()
+            }
+            TaskType::Bundle => {
+                let proof = serde_json::from_slice::<BundleProof>(proof.as_slice()).unwrap();
+                self.bundle_verifier.verify_proof_evm(&proof).is_ok()
+            }
+        });
+        let _ = result.is_ok();
+        Ok(true)
+        //result.map_err(|e| anyhow::anyhow!(e))
+    }
+}

common/types/message/euclid/message.go

@@ -0,0 +1,169 @@
+package euclid
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/scroll-tech/go-ethereum/common"
+)
+
+// RespStatus represents status code from prover to scroll
+type RespStatus uint32
+
+const (
+	// StatusOk means generate proof success
+	StatusOk RespStatus = iota
+	// StatusProofError means generate proof failed
+	StatusProofError
+)
+
+// ChunkTaskDetail is a type containing informations require to build ChunkTask.
+type ChunkTaskDetail struct {
+	BlockHashes []common.Hash `json:"block_hashes"`
+}
+
+// BatchTask
+type BatchTask struct {
+	ChunkProofs []*ChunkProof `json:"chunk_proofs"`
+	BatchHeader interface{}   `json:"batch_header"`
+	BlobBytes   []byte        `json:"blob_bytes"`
+}
+
+// BundleTask
+type BundleTask struct {
+	BatchProofs []*BatchProof `json:"batch_proofs"`
+}
+
+// Proof for flatten VM proof
+type VmProof struct {
+	Proof        interface{} `json:"proofs"`
+	PublicValues []uint32    `json:"public_values"`
+	Vk           []byte      `json:"vk,omitempty"`
+}
+
+// Proof for flatten EVM proof
+type EVmProof struct {
+	Proof     []byte     `json:"proof"`
+	Instances [][]string `json:"instances"`
+	Vk        []byte     `json:"vk,omitempty"`
+}
+
+// ChunkInfo is for calculating pi_hash for chunk
+type ChunkInfo struct {
+	ChainID       uint64      `json:"chain_id"`
+	PrevStateRoot common.Hash `json:"prev_state_root"`
+	PostStateRoot common.Hash `json:"post_state_root"`
+	WithdrawRoot  common.Hash `json:"withdraw_root"`
+	DataHash      common.Hash `json:"data_hash"`
+	TxBytesHash   common.Hash `json:"tx_data_digest"`
+}
+
+// ChunkProof includes the proof info that are required for chunk verification and rollup.
+type ChunkProof struct {
+	MetaData struct {
+		ChunkInfo *ChunkInfo `json:"chunk_info"`
+	} `json:"metadata"`
+
+	Proof      *VmProof `json:"proof"`
+	GitVersion string   `json:"git_version,omitempty"`
+}
+
+// BatchInfo is for calculating pi_hash for batch header
+type BatchInfo struct {
+	ParentBatchHash common.Hash `json:"parent_batch_hash"`
+	ParentStateRoot common.Hash `json:"parent_state_root"`
+	StateRoot       common.Hash `json:"state_root"`
+	WithdrawRoot    common.Hash `json:"withdraw_root"`
+	BatchHash       common.Hash `json:"batch_hash"`
+	ChainID         uint64      `json:"chain_id"`
+}
+
+// BatchProof includes the proof info that are required for batch verification and rollup.
+type BatchProof struct {
+	MetaData struct {
+		BatchInfo *BatchInfo  `json:"batch_info"`
+		BatchHash common.Hash `json:"batch_hash"`
+	} `json:"metadata"`
+
+	Proof      *VmProof `json:"proof"`
+	GitVersion string   `json:"git_version,omitempty"`
+}
+
+// SanityCheck checks whether a BatchProof is in a legal format
+func (ap *BatchProof) SanityCheck() error {
+	if ap == nil {
+		return errors.New("agg_proof is nil")
+	}
+	if ap.MetaData.BatchInfo == nil {
+		return errors.New("batch info not ready")
+	}
+
+	if ap.Proof == nil {
+		return errors.New("proof not ready")
+	} else {
+		pf := ap.Proof
+		if pf.Proof == nil {
+			return errors.New("proof data not ready")
+		}
+
+		// TODO: resume this after rc2
+		// if len(pf.Vk) == 0 {
+		// 	return errors.New("vk not ready")
+		// }
+	}
+
+	return nil
+}
+
+// BundleInfo is for calculating pi_hash for bundle header
+type BundleInfo struct {
+	ChainID       uint64      `json:"chain_id"`
+	PrevStateRoot common.Hash `json:"prev_state_root"`
+	PostStateRoot common.Hash `json:"post_state_root"`
+	WithdrawRoot  common.Hash `json:"withdraw_root"`
+	NumBatches    uint32      `json:"num_batches"`
+	PrevBatchHash common.Hash `json:"prev_batch_hash"`
+	BatchHash     common.Hash `json:"batch_hash"`
+}
+
+// BundleProof includes the proof info that are required for verification of a bundle of batch proofs.
+type BundleProof struct {
+	MetaData struct {
+		BundleInfo    *BundleInfo `json:"bundle_info"`
+		BunndlePIHash common.Hash `json:"bundle_pi_hash"`
+	} `json:"metadata"`
+
+	Proof      *EVmProof `json:"proof"`
+	GitVersion string    `json:"git_version,omitempty"`
+}
+
+// SanityCheck checks whether a BundleProof is in a legal format
+func (ap *BundleProof) SanityCheck() error {
+	if ap == nil {
+		return errors.New("agg_proof is nil")
+	}
+	// TODO: resume this after metadata of bundle info is ready
+	// if ap.MetaData.BundleInfo == nil {
+	// 	return errors.New("bundle info not ready")
+	// }
+
+	if ap.Proof == nil {
+		return errors.New("proof not ready")
+	} else {
+		pf := ap.Proof
+		if len(pf.Proof)%32 != 0 {
+			return fmt.Errorf("proof buffer length must be a multiple of 32, got: %d", len(pf.Proof))
+		}
+
+		if len(pf.Instances) == 0 {
+			return errors.New("instance not ready")
+		}
+
+		// TODO: resume this after rc2
+		// if len(pf.Vk) == 0 {
+		// 	return errors.New("vk not ready")
+		// }
+	}
+
+	return nil
+}

common/types/message/euclid/message_test.go

@@ -0,0 +1,39 @@
+package euclid
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+)
+
+func TestDeserializeProof(t *testing.T) {
+	// Read the batch.json file located in the same directory.
+	data, err := os.ReadFile("batch-proof-sample.json")
+	if err != nil {
+		t.Fatalf("failed to read batch proof sample.json: %v", err)
+	}
+
+	// Decode the JSON data into an BatchTask instance.
+	var batchProof BatchProof
+	if err = json.Unmarshal(data, &batchProof); err != nil {
+		t.Fatalf("failed to unmarshal JSON into Batch Proof: %v", err)
+	}
+	if err = batchProof.SanityCheck(); err != nil {
+		t.Fatalf("failed to sanity check for Batch Proof: %v", err)
+	}
+
+	// Read the batch.json file located in the same directory.
+	data, err = os.ReadFile("bundle-proof-sample.json")
+	if err != nil {
+		t.Fatalf("failed to read bundle proof sample.json: %v", err)
+	}
+
+	// Decode the JSON data into an BatchTask instance.
+	var bundleProof BundleProof
+	if err = json.Unmarshal(data, &bundleProof); err != nil {
+		t.Fatalf("failed to unmarshal JSON into Bundle Proof: %v", err)
+	}
+	if err = bundleProof.SanityCheck(); err != nil {
+		t.Fatalf("failed to sanity check for Bundle Proof: %v", err)
+	}
+}

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.4.86"
+var tag = "v4.4.87"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

prover/Cargo.toml

@@ -7,15 +7,13 @@ 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" }
-
+# 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" }
 
 [dependencies]
 anyhow = "1.0"
@@ -27,10 +25,9 @@ futures = "0.3.30"
 
 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" }
-halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1" }
-snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", branch = "develop", default-features = false, features = ["loader_halo2", "loader_evm", "halo2-pse"] }
-prover_darwin = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.2", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
-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"] }
+scroll-proving-sdk = { git = "https://github.com/scroll-tech/scroll-proving-sdk.git", rev = "ca6f4c4", features = [
+    "openvm",
+] }
 base64 = "0.13.1"
 reqwest = { version = "0.12.4", features = ["gzip"] }
 reqwest-middleware = "0.3"
@@ -42,7 +39,9 @@ rand = "0.8.5"
 eth-keystore = "0.5.0"
 rlp = "0.5.2"
 tokio = "1.37.0"
+async-trait = "0.1"
 sled = "0.34.7"
 http = "1.1.0"
 clap = { version = "4.5", features = ["derive"] }
 ctor = "0.2.8"
+url = "2.5.4"

prover/config.json

@@ -1,26 +1,31 @@
 {
-    "prover_name": "prover-1",
-    "keystore_path": "keystore.json",
-    "keystore_password": "prover-pwd",
-    "db_path": "unique-db-path-for-prover-1",
-    "prover_type": 2,
-    "low_version_circuit": {
-        "hard_fork_name": "bernoulli",
-        "params_path": "params",
-        "assets_path": "assets"
-    },
-    "high_version_circuit": {
-        "hard_fork_name": "curie",
-        "params_path": "params",
-        "assets_path": "assets"
-    },
+    "prover_name_prefix": "prover-1",
+    "keys_dir": "keys",
     "coordinator": {
-        "base_url": "http://localhost:8555",
-        "retry_count": 10,
-        "retry_wait_time_sec": 10,
-        "connection_timeout_sec": 30
+      "base_url": "http://localhost:8555",
+      "retry_count": 10,
+      "retry_wait_time_sec": 10,
+      "connection_timeout_sec": 30
     },
     "l2geth": {
-        "endpoint": "http://localhost:9999"
-    }
-}
+      "endpoint": "http://localhost:9999"
+    },
+    "prover": {
+      "circuit_types": [1,2,3],
+      "circuit_version": "v0.13.1",
+      "local": {
+        "low_version_circuit": {
+          "hard_fork_name": "bernoulli",
+          "params_path": "params",
+          "assets_path": "assets"
+        },
+        "high_version_circuit": {
+          "hard_fork_name": "curie",
+          "params_path": "params",
+          "assets_path": "assets"
+        }
+      }
+    },
+    "db_path": "unique-db-path-for-prover-1"
+  }
+  

prover/rust-toolchain

@@ -1 +1 @@
-nightly-2023-12-03
+nightly-2024-12-06

prover/src/config.rs

@@ -1,102 +0,0 @@
-use anyhow::{bail, Result};
-use serde::{Deserialize, Serialize};
-use std::fs::File;
-
-use crate::types::ProverType;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct CircuitConfig {
-    pub hard_fork_name: String,
-    pub params_path: String,
-    pub assets_path: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-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)]
-pub struct L2GethConfig {
-    pub endpoint: String,
-}
-
-#[derive(Debug, Deserialize)]
-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 coordinator: CoordinatorConfig,
-    pub l2geth: Option<L2GethConfig>,
-}
-
-impl Config {
-    pub fn from_reader<R>(reader: R) -> Result<Self>
-    where
-        R: std::io::Read,
-    {
-        serde_json::from_reader(reader).map_err(|e| anyhow::anyhow!(e))
-    }
-
-    pub fn from_file(file_name: String) -> Result<Self> {
-        let file = File::open(file_name)?;
-        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

@@ -1,142 +0,0 @@
-mod api;
-mod errors;
-pub mod listener;
-pub mod types;
-
-use anyhow::{bail, Context, Ok, Result};
-use std::rc::Rc;
-
-use api::Api;
-use errors::*;
-use listener::Listener;
-use tokio::runtime::Runtime;
-use types::*;
-
-use crate::{config::Config, key_signer::KeySigner};
-
-pub use errors::ProofStatusNotOKError;
-
-pub struct CoordinatorClient<'a> {
-    api: Api,
-    token: Option<String>,
-    config: &'a Config,
-    key_signer: Rc<KeySigner>,
-    rt: Runtime,
-    listener: Box<dyn Listener>,
-    vks: Vec<String>,
-}
-
-impl<'a> CoordinatorClient<'a> {
-    pub fn new(
-        config: &'a Config,
-        key_signer: Rc<KeySigner>,
-        listener: Box<dyn Listener>,
-        vks: Vec<String>,
-    ) -> Result<Self> {
-        let rt = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()?;
-
-        let api = Api::new(
-            &config.coordinator.base_url,
-            core::time::Duration::from_secs(config.coordinator.connection_timeout_sec),
-            config.coordinator.retry_count,
-            config.coordinator.retry_wait_time_sec,
-        )?;
-        let mut client = Self {
-            api,
-            token: None,
-            config,
-            key_signer,
-            rt,
-            listener,
-            vks,
-        };
-        client.login()?;
-        Ok(client)
-    }
-
-    fn login(&mut self) -> Result<()> {
-        let api = &self.api;
-        let challenge_response = self.rt.block_on(api.challenge())?;
-        if challenge_response.errcode != ErrorCode::Success {
-            bail!("challenge failed: {}", challenge_response.errmsg)
-        }
-        let mut token: String;
-        if let Some(r) = challenge_response.data {
-            token = r.token;
-        } else {
-            bail!("challenge failed: got empty token")
-        }
-
-        let login_message = LoginMessage {
-            challenge: token.clone(),
-            prover_name: self.config.prover_name.clone(),
-            prover_version: crate::version::get_version(),
-            prover_types: vec![self.config.prover_type],
-            vks: self.vks.clone(),
-        };
-
-        let buffer = rlp::encode(&login_message);
-        let signature = self.key_signer.sign_buffer(&buffer)?;
-        let login_request = LoginRequest {
-            message: login_message,
-            public_key: self.key_signer.get_public_key(),
-            signature,
-        };
-        let login_response = self.rt.block_on(api.login(&login_request, &token))?;
-        if login_response.errcode != ErrorCode::Success {
-            bail!("login failed: {}", login_response.errmsg)
-        }
-        if let Some(r) = login_response.data {
-            token = r.token;
-        } else {
-            bail!("login failed: got empty token")
-        }
-        self.token = Some(token);
-        Ok(())
-    }
-
-    fn action_with_re_login<T, F, R>(&mut self, req: &R, mut f: F) -> Result<Response<T>>
-    where
-        F: FnMut(&mut Self, &R) -> Result<Response<T>>,
-    {
-        let response = f(self, req)?;
-        if response.errcode == ErrorCode::ErrJWTTokenExpired {
-            log::info!("JWT expired, attempting to re-login");
-            self.login().context("JWT expired, re-login failed")?;
-            log::info!("re-login success");
-            return self.action_with_re_login(req, f);
-        } else if response.errcode != ErrorCode::Success {
-            bail!("action failed: {}", response.errmsg)
-        }
-        Ok(response)
-    }
-
-    fn do_get_task(&mut self, req: &GetTaskRequest) -> Result<Response<GetTaskResponseData>> {
-        self.rt
-            .block_on(self.api.get_task(req, self.token.as_ref().unwrap()))
-    }
-
-    pub fn get_task(&mut self, req: &GetTaskRequest) -> Result<Response<GetTaskResponseData>> {
-        self.action_with_re_login(req, |s, req| s.do_get_task(req))
-    }
-
-    fn do_submit_proof(
-        &mut self,
-        req: &SubmitProofRequest,
-    ) -> Result<Response<SubmitProofResponseData>> {
-        let response = self
-            .rt
-            .block_on(self.api.submit_proof(req, self.token.as_ref().unwrap()))?;
-        self.listener.on_proof_submitted(req);
-        Ok(response)
-    }
-
-    pub fn submit_proof(
-        &mut self,
-        req: &SubmitProofRequest,
-    ) -> Result<Response<SubmitProofResponseData>> {
-        self.action_with_re_login(req, |s, req| s.do_submit_proof(req))
-    }
-}

prover/src/coordinator_client/api.rs

@@ -1,144 +0,0 @@
-use crate::{coordinator_client::ProofStatusNotOKError, types::ProofStatus};
-
-use super::{errors::*, types::*};
-use anyhow::{bail, Result};
-use core::time::Duration;
-use reqwest::{header::CONTENT_TYPE, Url};
-use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
-use reqwest_retry::{policies::ExponentialBackoff, RetryTransientMiddleware};
-use serde::Serialize;
-
-pub struct Api {
-    url_base: Url,
-    send_timeout: Duration,
-    pub client: ClientWithMiddleware,
-}
-
-impl Api {
-    pub fn new(
-        url_base: &str,
-        send_timeout: Duration,
-        retry_count: u32,
-        retry_wait_time_sec: u64,
-    ) -> Result<Self> {
-        let retry_wait_duration = core::time::Duration::from_secs(retry_wait_time_sec);
-        let retry_policy = ExponentialBackoff::builder()
-            .retry_bounds(retry_wait_duration / 2, retry_wait_duration)
-            .build_with_max_retries(retry_count);
-
-        let client = ClientBuilder::new(reqwest::Client::new())
-            .with(RetryTransientMiddleware::new_with_policy(retry_policy))
-            .build();
-
-        Ok(Self {
-            url_base: Url::parse(url_base)?,
-            send_timeout,
-            client,
-        })
-    }
-
-    pub async fn challenge(&self) -> Result<Response<ChallengeResponseData>> {
-        let method = "/coordinator/v1/challenge";
-        let url = self.build_url(method)?;
-
-        let response = self
-            .client
-            .get(url)
-            .header(CONTENT_TYPE, "application/json")
-            .timeout(self.send_timeout)
-            .send()
-            .await?;
-
-        let response_body = response.text().await?;
-
-        serde_json::from_str(&response_body).map_err(|e| anyhow::anyhow!(e))
-    }
-
-    pub async fn login(
-        &self,
-        req: &LoginRequest,
-        token: &String,
-    ) -> Result<Response<LoginResponseData>> {
-        let method = "/coordinator/v1/login";
-        self.post_with_token(method, req, token).await
-    }
-
-    pub async fn get_task(
-        &self,
-        req: &GetTaskRequest,
-        token: &String,
-    ) -> Result<Response<GetTaskResponseData>> {
-        let method = "/coordinator/v1/get_task";
-        self.post_with_token(method, req, token).await
-    }
-
-    pub async fn submit_proof(
-        &self,
-        req: &SubmitProofRequest,
-        token: &String,
-    ) -> Result<Response<SubmitProofResponseData>> {
-        let method = "/coordinator/v1/submit_proof";
-        let response = self
-            .post_with_token::<SubmitProofRequest, Response<SubmitProofResponseData>>(
-                method, req, token,
-            )
-            .await?;
-
-        // when req's status already not ok, we mark the error returned from coordinator and will
-        // ignore it later.
-        if response.errcode == ErrorCode::ErrCoordinatorHandleZkProofFailure
-            && req.status != ProofStatus::Ok
-            && response
-                .errmsg
-                .contains("validator failure proof msg status not ok")
-        {
-            return Err(anyhow::anyhow!(ProofStatusNotOKError));
-        }
-        Ok(response)
-    }
-
-    async fn post_with_token<Req, Resp>(
-        &self,
-        method: &str,
-        req: &Req,
-        token: &String,
-    ) -> Result<Resp>
-    where
-        Req: ?Sized + Serialize,
-        Resp: serde::de::DeserializeOwned,
-    {
-        let url = self.build_url(method)?;
-        let request_body = serde_json::to_string(req)?;
-
-        log::info!("[coordinator client], {method}, request: {request_body}");
-        let response = self
-            .client
-            .post(url)
-            .header(CONTENT_TYPE, "application/json")
-            .bearer_auth(token)
-            .body(request_body)
-            .timeout(self.send_timeout)
-            .send()
-            .await?;
-
-        if response.status() != http::status::StatusCode::OK {
-            log::error!(
-                "[coordinator client], {method}, status not ok: {}",
-                response.status()
-            );
-            bail!(
-                "[coordinator client], {method}, status not ok: {}",
-                response.status()
-            )
-        }
-
-        let response_body = response.text().await?;
-
-        log::info!("[coordinator client], {method}, response: {response_body}");
-        serde_json::from_str(&response_body).map_err(|e| anyhow::anyhow!(e))
-    }
-
-    fn build_url(&self, method: &str) -> Result<Url> {
-        self.url_base.join(method).map_err(|e| anyhow::anyhow!(e))
-    }
-}

prover/src/coordinator_client/errors.rs

@@ -1,65 +0,0 @@
-use serde::{Deserialize, Deserializer};
-use std::fmt;
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum ErrorCode {
-    Success,
-    InternalServerError,
-
-    ErrProverStatsAPIParameterInvalidNo,
-    ErrProverStatsAPIProverTaskFailure,
-    ErrProverStatsAPIProverTotalRewardFailure,
-
-    ErrCoordinatorParameterInvalidNo,
-    ErrCoordinatorGetTaskFailure,
-    ErrCoordinatorHandleZkProofFailure,
-    ErrCoordinatorEmptyProofData,
-
-    ErrJWTCommonErr,
-    ErrJWTTokenExpired,
-
-    Undefined(i32),
-}
-
-impl ErrorCode {
-    fn from_i32(v: i32) -> Self {
-        match v {
-            0 => ErrorCode::Success,
-            500 => ErrorCode::InternalServerError,
-            10001 => ErrorCode::ErrProverStatsAPIParameterInvalidNo,
-            10002 => ErrorCode::ErrProverStatsAPIProverTaskFailure,
-            10003 => ErrorCode::ErrProverStatsAPIProverTotalRewardFailure,
-            20001 => ErrorCode::ErrCoordinatorParameterInvalidNo,
-            20002 => ErrorCode::ErrCoordinatorGetTaskFailure,
-            20003 => ErrorCode::ErrCoordinatorHandleZkProofFailure,
-            20004 => ErrorCode::ErrCoordinatorEmptyProofData,
-            50000 => ErrorCode::ErrJWTCommonErr,
-            50001 => ErrorCode::ErrJWTTokenExpired,
-            _ => {
-                log::error!("get unexpected error code from coordinator: {v}");
-                ErrorCode::Undefined(v)
-            }
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for ErrorCode {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let v: i32 = i32::deserialize(deserializer)?;
-        Ok(ErrorCode::from_i32(v))
-    }
-}
-
-// ====================================================
-
-#[derive(Debug, Clone)]
-pub struct ProofStatusNotOKError;
-
-impl fmt::Display for ProofStatusNotOKError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "proof status not ok")
-    }
-}

prover/src/coordinator_client/listener.rs

@@ -1,5 +0,0 @@
-use super::SubmitProofRequest;
-
-pub trait Listener {
-    fn on_proof_submitted(&self, req: &SubmitProofRequest);
-}

prover/src/coordinator_client/types.rs

@@ -1,86 +0,0 @@
-use super::errors::ErrorCode;
-use crate::types::{ProofFailureType, ProofStatus, ProverType, TaskType};
-use rlp::{Encodable, RlpStream};
-use serde::{Deserialize, Serialize};
-
-#[derive(Deserialize)]
-pub struct Response<T> {
-    pub errcode: ErrorCode,
-    pub errmsg: String,
-    pub data: Option<T>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct LoginMessage {
-    pub challenge: String,
-    pub prover_name: String,
-    pub prover_version: String,
-    pub prover_types: Vec<ProverType>,
-    pub vks: Vec<String>,
-}
-
-impl Encodable for LoginMessage {
-    fn rlp_append(&self, s: &mut RlpStream) {
-        let num_fields = 5;
-        s.begin_list(num_fields);
-        s.append(&self.challenge);
-        s.append(&self.prover_version);
-        s.append(&self.prover_name);
-        // The ProverType in go side is an type alias of uint8
-        // A uint8 slice is treated as a string when doing the rlp encoding
-        let prover_types = self
-            .prover_types
-            .iter()
-            .map(|prover_type: &ProverType| prover_type.to_u8())
-            .collect::<Vec<u8>>();
-        s.append(&prover_types);
-        s.begin_list(self.vks.len());
-        for vk in &self.vks {
-            s.append(vk);
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct LoginRequest {
-    pub message: LoginMessage,
-    pub public_key: String,
-    pub signature: String,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct LoginResponseData {
-    pub time: String,
-    pub token: String,
-}
-
-pub type ChallengeResponseData = LoginResponseData;
-
-#[derive(Default, Serialize, Deserialize)]
-pub struct GetTaskRequest {
-    pub task_types: Vec<TaskType>,
-    pub prover_height: Option<u64>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct GetTaskResponseData {
-    pub uuid: String,
-    pub task_id: String,
-    pub task_type: TaskType,
-    pub task_data: String,
-    pub hard_fork_name: String,
-}
-
-#[derive(Serialize, Deserialize, Default)]
-pub struct SubmitProofRequest {
-    pub uuid: String,
-    pub task_id: String,
-    pub task_type: TaskType,
-    pub status: ProofStatus,
-    pub proof: String,
-    pub failure_type: Option<ProofFailureType>,
-    pub failure_msg: Option<String>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct SubmitProofResponseData {}

prover/src/geth_client.rs

@@ -1,57 +0,0 @@
-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 {
-    id: String,
-    provider: Provider<Http>,
-    rt: Runtime,
-}
-
-impl GethClient {
-    pub fn new(id: &str, api_url: &str) -> Result<Self> {
-        let provider = Provider::<Http>::try_from(api_url)?;
-        let rt = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()?;
-
-        Ok(Self {
-            id: id.to_string(),
-            provider,
-            rt,
-        })
-    }
-
-    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);
-
-        let trace_future = self.provider.request("eth_blockNumber", ());
-
-        let trace = self.rt.block_on(trace_future)?;
-        Ok(trace)
-    }
-}

prover/src/key_signer.rs

@@ -1,103 +0,0 @@
-use std::path::Path;
-
-use anyhow::Result;
-use ethers_core::{
-    k256::{
-        ecdsa::{signature::hazmat::PrehashSigner, RecoveryId, Signature, SigningKey},
-        elliptic_curve::{sec1::ToEncodedPoint, FieldBytes},
-        PublicKey, Secp256k1, SecretKey,
-    },
-    types::Signature as EthSignature,
-};
-
-use ethers_core::types::{H256, U256};
-use hex::ToHex;
-use tiny_keccak::{Hasher, Keccak};
-
-pub struct KeySigner {
-    public_key: PublicKey,
-    signer: SigningKey,
-}
-
-impl KeySigner {
-    pub fn new(key_path: &str, passwd: &str) -> Result<Self> {
-        let p = Path::new(key_path);
-
-        let secret = if !p.exists() {
-            log::info!("[key_signer] key_path not exists, create one");
-            let dir = p.parent().unwrap();
-            let name = p.file_name().and_then(|s| s.to_str());
-            let mut rng = rand::thread_rng();
-            let (secret, _) = eth_keystore::new(dir, &mut rng, passwd, name)?;
-            secret
-        } else {
-            log::info!("[key_signer] key_path already exists, load it");
-            eth_keystore::decrypt_key(key_path, passwd).map_err(|e| anyhow::anyhow!(e))?
-        };
-
-        let secret_key = SecretKey::from_bytes(secret.as_slice().into())?;
-
-        let signer = SigningKey::from(secret_key.clone());
-
-        Ok(Self {
-            public_key: secret_key.public_key(),
-            signer,
-        })
-    }
-
-    pub fn get_public_key(&self) -> String {
-        let v: Vec<u8> = Vec::from(self.public_key.to_encoded_point(true).as_bytes());
-        buffer_to_hex(&v, false)
-    }
-
-    /// Signs the provided hash.
-    pub fn sign_hash(&self, hash: H256) -> Result<EthSignature> {
-        let signer = &self.signer as &dyn PrehashSigner<(Signature, RecoveryId)>;
-        let (recoverable_sig, recovery_id) = signer.sign_prehash(hash.as_ref())?;
-
-        let v = u8::from(recovery_id) as u64;
-
-        let r_bytes: FieldBytes<Secp256k1> = recoverable_sig.r().into();
-        let s_bytes: FieldBytes<Secp256k1> = recoverable_sig.s().into();
-        let r = U256::from_big_endian(r_bytes.as_slice());
-        let s = U256::from_big_endian(s_bytes.as_slice());
-
-        Ok(EthSignature { r, s, v })
-    }
-
-    pub fn sign_buffer<T>(&self, buffer: &T) -> Result<String>
-    where
-        T: AsRef<[u8]>,
-    {
-        let pre_hash = keccak256(buffer);
-
-        let hash = H256::from(pre_hash);
-        let sig = self.sign_hash(hash)?;
-
-        Ok(buffer_to_hex(&sig.to_vec(), true))
-    }
-}
-
-fn buffer_to_hex<T>(buffer: &T, has_prefix: bool) -> String
-where
-    T: AsRef<[u8]>,
-{
-    if has_prefix {
-        format!("0x{}", buffer.encode_hex::<String>())
-    } else {
-        buffer.encode_hex::<String>()
-    }
-}
-
-/// Compute the Keccak-256 hash of input bytes.
-///
-/// Note that strings are interpreted as UTF-8 bytes,
-pub fn keccak256<T: AsRef<[u8]>>(bytes: T) -> [u8; 32] {
-    let mut output = [0u8; 32];
-
-    let mut hasher = Keccak::v256();
-    hasher.update(bytes.as_ref());
-    hasher.finalize(&mut output);
-
-    output
-}

prover/src/main.rs

@@ -1,27 +1,14 @@
-#![feature(lazy_cell)]
-#![feature(core_intrinsics)]
-
-mod config;
-mod coordinator_client;
-mod geth_client;
-mod key_signer;
 mod prover;
-mod task_cache;
-mod task_processor;
 mod types;
-mod utils;
-mod version;
 mod zk_circuits_handler;
 
-use anyhow::Result;
 use clap::{ArgAction, Parser};
-use config::{AssetsDirEnvConfig, Config};
-use prover::Prover;
-use std::rc::Rc;
-use task_cache::{ClearCacheCoordinatorListener, TaskCache};
-use task_processor::TaskProcessor;
+use prover::{LocalProver, LocalProverConfig};
+use scroll_proving_sdk::{
+    prover::ProverBuilder,
+    utils::{get_version, init_tracing},
+};
 
-/// Simple program to greet a person
 #[derive(Parser, Debug)]
 #[clap(disable_version_flag = true)]
 struct Args {
@@ -38,49 +25,23 @@ struct Args {
     log_file: Option<String>,
 }
 
-fn start() -> Result<()> {
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    init_tracing();
+
     let args = Args::parse();
 
     if args.version {
-        println!("version is {}", version::get_version());
+        println!("version is {}", get_version());
         std::process::exit(0);
     }
 
-    utils::log_init(args.log_file);
+    let cfg = LocalProverConfig::from_file(args.config_file)?;
+    let sdk_config = cfg.sdk_config.clone();
+    let local_prover = LocalProver::new(cfg);
+    let prover = ProverBuilder::new(sdk_config, local_prover).build().await?;
 
-    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)?;
-
-    log::info!(
-        "prover start successfully. name: {}, type: {:?}, publickey: {}, version: {}",
-        config.prover_name,
-        config.prover_type,
-        prover.get_public_key(),
-        version::get_version(),
-    );
-
-    let task_processor = TaskProcessor::new(&prover, task_cache);
-
-    task_processor.start();
+    prover.run().await;
 
     Ok(())
 }
-
-fn main() {
-    let result = start();
-    if let Err(e) = result {
-        log::error!("main exit with error {:#}", e)
-    }
-}

prover/src/prover.rs

@@ -1,170 +1,179 @@
-use anyhow::{bail, Context, Error, Ok, Result};
-use ethers_core::types::U64;
-
-use std::{cell::RefCell, rc::Rc};
-
-use crate::{
-    config::Config,
-    coordinator_client::{listener::Listener, types::*, CoordinatorClient},
-    geth_client::GethClient,
-    key_signer::KeySigner,
-    types::{ProofFailureType, ProofStatus, ProverType},
-    utils::get_task_types,
-    zk_circuits_handler::{CircuitsHandler, CircuitsHandlerProvider},
+use crate::zk_circuits_handler::{euclid::EuclidHandler, CircuitsHandler};
+use anyhow::{anyhow, Result};
+use async_trait::async_trait;
+use scroll_proving_sdk::{
+    config::Config as SdkConfig,
+    prover::{
+        proving_service::{
+            GetVkRequest, GetVkResponse, ProveRequest, ProveResponse, QueryTaskRequest,
+            QueryTaskResponse, TaskStatus,
+        },
+        ProvingService,
+    },
 };
+use serde::{Deserialize, Serialize};
+use std::{
+    collections::HashMap,
+    fs::File,
+    sync::Arc,
+    time::{SystemTime, UNIX_EPOCH},
+};
+use tokio::{runtime::Handle, task::JoinHandle};
 
-use super::types::{ProofDetail, Task};
-
-pub struct Prover<'a> {
-    config: &'a Config,
-    key_signer: Rc<KeySigner>,
-    circuits_handler_provider: RefCell<CircuitsHandlerProvider<'a>>,
-    coordinator_client: RefCell<CoordinatorClient<'a>>,
-    geth_client: Option<Rc<RefCell<GethClient>>>,
+#[derive(Clone, Serialize, Deserialize)]
+pub struct LocalProverConfig {
+    pub sdk_config: SdkConfig,
+    pub circuits: HashMap<String, CircuitConfig>,
 }
 
-impl<'a> Prover<'a> {
-    pub fn new(config: &'a Config, coordinator_listener: Box<dyn Listener>) -> Result<Self> {
-        let prover_type = config.prover_type;
-        let keystore_path = &config.keystore_path;
-        let keystore_password = &config.keystore_password;
-
-        let geth_client = if config.prover_type == ProverType::Chunk {
-            Some(Rc::new(RefCell::new(
-                GethClient::new(
-                    &config.prover_name,
-                    &config.l2geth.as_ref().unwrap().endpoint,
-                )
-                .context("failed to create l2 geth_client")?,
-            )))
-        } else {
-            None
-        };
-
-        let provider = CircuitsHandlerProvider::new(prover_type, config, geth_client.clone())
-            .context("failed to create circuits handler provider")?;
-
-        let vks = provider.init_vks(prover_type, config, geth_client.clone());
-
-        let key_signer = Rc::new(KeySigner::new(keystore_path, keystore_password)?);
-        let coordinator_client =
-            CoordinatorClient::new(config, Rc::clone(&key_signer), coordinator_listener, vks)
-                .context("failed to create coordinator_client")?;
-
-        let prover = Prover {
-            config,
-            key_signer: Rc::clone(&key_signer),
-            circuits_handler_provider: RefCell::new(provider),
-            coordinator_client: RefCell::new(coordinator_client),
-            geth_client,
-        };
-
-        Ok(prover)
+impl LocalProverConfig {
+    pub fn from_reader<R>(reader: R) -> Result<Self>
+    where
+        R: std::io::Read,
+    {
+        serde_json::from_reader(reader).map_err(|e| anyhow!(e))
     }
 
-    pub fn get_public_key(&self) -> String {
-        self.key_signer.get_public_key()
+    pub fn from_file(file_name: String) -> Result<Self> {
+        let file = File::open(file_name)?;
+        Self::from_reader(&file)
+    }
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct CircuitConfig {
+    pub hard_fork_name: String,
+    pub workspace_path: String,
+}
+
+pub struct LocalProver {
+    config: LocalProverConfig,
+    next_task_id: u64,
+    current_task: Option<JoinHandle<Result<String>>>,
+
+    active_handler: Option<(String, Arc<dyn CircuitsHandler>)>,
+}
+
+#[async_trait]
+impl ProvingService for LocalProver {
+    fn is_local(&self) -> bool {
+        true
+    }
+    async fn get_vks(&self, _req: GetVkRequest) -> GetVkResponse {
+        GetVkResponse {
+            vks: vec![],
+            error: None,
+        }
+    }
+    async fn prove(&mut self, req: ProveRequest) -> ProveResponse {
+        self.set_active_handler(&req.hard_fork_name);
+        match self
+            .do_prove(req, self.active_handler.as_ref().unwrap().1.clone())
+            .await
+        {
+            Ok(resp) => resp,
+            Err(e) => ProveResponse {
+                status: TaskStatus::Failed,
+                error: Some(format!("failed to request proof: {}", e)),
+                ..Default::default()
+            },
+        }
     }
 
-    pub fn fetch_task(&self) -> Result<Task> {
-        log::info!("[prover] start to fetch_task");
-        let mut req = GetTaskRequest {
-            task_types: get_task_types(self.config.prover_type),
-            prover_height: None,
-        };
-
-        if self.config.prover_type == ProverType::Chunk {
-            let latest_block_number = self.get_latest_block_number_value()?;
-            if let Some(v) = latest_block_number {
-                if v.as_u64() == 0 {
-                    bail!("omit to prove task of the genesis block")
-                }
-                req.prover_height = Some(v.as_u64());
+    async fn query_task(&mut self, req: QueryTaskRequest) -> QueryTaskResponse {
+        if let Some(handle) = &mut self.current_task {
+            if handle.is_finished() {
+                return match handle.await {
+                    Ok(Ok(proof)) => QueryTaskResponse {
+                        task_id: req.task_id,
+                        status: TaskStatus::Success,
+                        proof: Some(proof),
+                        ..Default::default()
+                    },
+                    Ok(Err(e)) => QueryTaskResponse {
+                        task_id: req.task_id,
+                        status: TaskStatus::Failed,
+                        error: Some(format!("proving task failed: {}", e)),
+                        ..Default::default()
+                    },
+                    Err(e) => QueryTaskResponse {
+                        task_id: req.task_id,
+                        status: TaskStatus::Failed,
+                        error: Some(format!("proving task panicked: {}", e)),
+                        ..Default::default()
+                    },
+                };
             } else {
-                log::error!("[prover] failed to fetch latest confirmed block number, got None");
-                bail!("failed to fetch latest confirmed block number, got None")
+                return QueryTaskResponse {
+                    task_id: req.task_id,
+                    status: TaskStatus::Proving,
+                    ..Default::default()
+                };
             }
         }
-        let resp = self.coordinator_client.borrow_mut().get_task(&req)?;
-
-        match resp.data {
-            Some(d) => Ok(Task::from(d)),
-            None => {
-                bail!("data of get_task empty, while error_code is success. there may be something wrong in response data or inner logic.")
-            }
+        // If no handle is found
+        QueryTaskResponse {
+            task_id: req.task_id,
+            status: TaskStatus::Failed,
+            error: Some("no proving task is running".to_string()),
+            ..Default::default()
         }
     }
-
-    pub fn prove_task(&self, task: &Task) -> Result<ProofDetail> {
-        log::info!("[prover] start to prove_task, task id: {}", task.id);
-        let handler: Rc<Box<dyn CircuitsHandler>> = self
-            .circuits_handler_provider
-            .borrow_mut()
-            .get_circuits_handler(&task.hard_fork_name)
-            .context("failed to get circuit handler")?;
-        self.do_prove(task, handler)
-    }
-
-    fn do_prove(&self, task: &Task, handler: Rc<Box<dyn CircuitsHandler>>) -> Result<ProofDetail> {
-        let mut proof_detail = ProofDetail {
-            id: task.id.clone(),
-            proof_type: task.task_type,
-            ..Default::default()
-        };
-
-        proof_detail.proof_data = handler.get_proof_data(task.task_type, task)?;
-        Ok(proof_detail)
-    }
-
-    pub fn submit_proof(&self, proof_detail: ProofDetail, task: &Task) -> Result<()> {
-        log::info!(
-            "[prover] start to submit_proof, task id: {}",
-            proof_detail.id
-        );
-
-        let request = SubmitProofRequest {
-            uuid: task.uuid.clone(),
-            task_id: proof_detail.id,
-            task_type: proof_detail.proof_type,
-            status: ProofStatus::Ok,
-            proof: proof_detail.proof_data,
-            ..Default::default()
-        };
-
-        self.do_submit(&request)
-    }
-
-    pub fn submit_error(
-        &self,
-        task: &Task,
-        failure_type: ProofFailureType,
-        error: Error,
-    ) -> Result<()> {
-        log::info!("[prover] start to submit_error, task id: {}", task.id);
-        let request = SubmitProofRequest {
-            uuid: task.uuid.clone(),
-            task_id: task.id.clone(),
-            task_type: task.task_type,
-            status: ProofStatus::Error,
-            failure_type: Some(failure_type),
-            failure_msg: Some(format!("{:#}", error)),
-            ..Default::default()
-        };
-        self.do_submit(&request)
-    }
-
-    fn do_submit(&self, request: &SubmitProofRequest) -> Result<()> {
-        self.coordinator_client.borrow_mut().submit_proof(request)?;
-        Ok(())
-    }
-
-    fn get_latest_block_number_value(&self) -> Result<Option<U64>> {
-        let number = self
-            .geth_client
-            .as_ref()
-            .unwrap()
-            .borrow_mut()
-            .block_number()?;
-        Ok(number.as_number())
-    }
+}
+
+impl LocalProver {
+    pub fn new(config: LocalProverConfig) -> Self {
+        Self {
+            config,
+            next_task_id: 0,
+            current_task: None,
+            active_handler: None,
+        }
+    }
+
+    async fn do_prove(
+        &mut self,
+        req: ProveRequest,
+        handler: Arc<dyn CircuitsHandler>,
+    ) -> Result<ProveResponse> {
+        self.next_task_id += 1;
+        let duration = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
+        let created_at = duration.as_secs() as f64 + duration.subsec_nanos() as f64 * 1e-9;
+
+        let req_clone = req.clone();
+        let handle = Handle::current();
+        let task_handle =
+            tokio::task::spawn_blocking(move || handle.block_on(handler.get_proof_data(req_clone)));
+
+        self.current_task = Some(task_handle);
+
+        Ok(ProveResponse {
+            task_id: self.next_task_id.to_string(),
+            proof_type: req.proof_type,
+            circuit_version: req.circuit_version,
+            hard_fork_name: req.hard_fork_name,
+            status: TaskStatus::Proving,
+            created_at,
+            input: Some(req.input),
+            ..Default::default()
+        })
+    }
+
+    fn set_active_handler(&mut self, hard_fork_name: &str) {
+        if let Some(handler) = &self.active_handler {
+            if handler.0 == hard_fork_name {
+                return;
+            }
+        }
+
+        // if we got assigned a task for an unknown hard fork, there is something wrong in the
+        // coordinator
+        let config = self.config.circuits.get(hard_fork_name).unwrap();
+
+        let handler = Arc::new(match hard_fork_name {
+            "euclid" => EuclidHandler::new(&config.workspace_path),
+            _ => unreachable!(),
+        }) as Arc<dyn CircuitsHandler>;
+        self.active_handler = Some((hard_fork_name.to_string(), handler));
+    }
 }

prover/src/task_cache.rs

@@ -1,66 +0,0 @@
-use anyhow::{Ok, Result};
-
-use super::coordinator_client::{listener::Listener, types::SubmitProofRequest};
-use crate::types::TaskWrapper;
-use sled::{Config, Db};
-use std::rc::Rc;
-
-pub struct TaskCache {
-    db: Db,
-}
-
-impl TaskCache {
-    pub fn new(db_path: &String) -> Result<Self> {
-        let config = Config::new().path(db_path);
-        let db = config.open()?;
-        log::info!("[task_cache] initiate successfully to {db_path}");
-        Ok(Self { db })
-    }
-
-    pub fn put_task(&self, task_wrapper: &TaskWrapper) -> Result<()> {
-        let k = task_wrapper.task.id.clone().into_bytes();
-        let v = serde_json::to_vec(task_wrapper)?;
-        self.db.insert(k, v)?;
-        log::info!(
-            "[task_cache] put_task with task_id: {}",
-            task_wrapper.task.id
-        );
-        Ok(())
-    }
-
-    pub fn get_last_task(&self) -> Result<Option<TaskWrapper>> {
-        let last = self.db.last()?;
-        if let Some((k, v)) = last {
-            let kk = std::str::from_utf8(k.as_ref())?;
-            let task_wrapper: TaskWrapper = serde_json::from_slice(v.as_ref())?;
-            log::info!(
-                "[task_cache] get_last_task with task_id: {kk}, count: {}",
-                task_wrapper.get_count()
-            );
-            return Ok(Some(task_wrapper));
-        }
-        Ok(None)
-    }
-
-    pub fn delete_task(&self, task_id: String) -> Result<()> {
-        let k = task_id.clone().into_bytes();
-        self.db.remove(k)?;
-        log::info!("[task cache] delete_task with task_id: {task_id}");
-        Ok(())
-    }
-}
-
-// ========================= listener ===========================
-
-pub struct ClearCacheCoordinatorListener {
-    pub task_cache: Rc<TaskCache>,
-}
-
-impl Listener for ClearCacheCoordinatorListener {
-    fn on_proof_submitted(&self, req: &SubmitProofRequest) {
-        let result = self.task_cache.delete_task(req.task_id.clone());
-        if let Err(e) = result {
-            log::error!("delete task from embed db failed, {:#}", e);
-        }
-    }
-}

prover/src/task_processor.rs

@@ -1,89 +0,0 @@
-use super::{coordinator_client::ProofStatusNotOKError, prover::Prover, task_cache::TaskCache};
-use anyhow::{Context, Result};
-use std::rc::Rc;
-
-pub struct TaskProcessor<'a> {
-    prover: &'a Prover<'a>,
-    task_cache: Rc<TaskCache>,
-}
-
-impl<'a> TaskProcessor<'a> {
-    pub fn new(prover: &'a Prover<'a>, task_cache: Rc<TaskCache>) -> Self {
-        TaskProcessor { prover, task_cache }
-    }
-
-    pub fn start(&self) {
-        loop {
-            log::info!("start a new round.");
-            if let Err(err) = self.prove_and_submit() {
-                if err.is::<ProofStatusNotOKError>() {
-                    log::info!("proof status not ok, downgrade level to info.");
-                } else {
-                    log::error!("encounter error: {:#}", err);
-                }
-            } else {
-                log::info!("prove & submit succeed.");
-            }
-        }
-    }
-
-    fn prove_and_submit(&self) -> Result<()> {
-        let task_from_cache = self
-            .task_cache
-            .get_last_task()
-            .context("failed to peek from stack")?;
-
-        let mut task_wrapper = match task_from_cache {
-            Some(t) => t,
-            None => {
-                let fetch_result = self.prover.fetch_task();
-                if let Err(err) = fetch_result {
-                    std::thread::sleep(core::time::Duration::from_secs(10));
-                    return Err(err).context("failed to fetch task from coordinator");
-                }
-                fetch_result.unwrap().into()
-            }
-        };
-
-        if task_wrapper.get_count() <= 2 {
-            task_wrapper.increment_count();
-            self.task_cache
-                .put_task(&task_wrapper)
-                .context("failed to push task into stack, updating count")?;
-
-            log::info!(
-                "start to prove task, task_type: {:?}, task_id: {}",
-                task_wrapper.task.task_type,
-                task_wrapper.task.id
-            );
-            let result = match self.prover.prove_task(&task_wrapper.task) {
-                Ok(proof_detail) => self.prover.submit_proof(proof_detail, &task_wrapper.task),
-                Err(error) => {
-                    log::error!(
-                        "failed to prove task, id: {}, error: {:#}",
-                        &task_wrapper.task.id,
-                        error
-                    );
-                    self.prover.submit_error(
-                        &task_wrapper.task,
-                        super::types::ProofFailureType::NoPanic,
-                        error,
-                    )
-                }
-            };
-            return result;
-        }
-
-        // if tried times >= 3, it's probably due to circuit proving panic
-        log::error!(
-            "zk proving panic for task, task_type: {:?}, task_id: {}",
-            task_wrapper.task.task_type,
-            task_wrapper.task.id
-        );
-        self.prover.submit_error(
-            &task_wrapper.task,
-            super::types::ProofFailureType::Panic,
-            anyhow::anyhow!("zk proving panic for task"),
-        )
-    }
-}

prover/src/types.rs

@@ -1,156 +1,21 @@
-use ethers_core::types::H256;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-use crate::coordinator_client::types::GetTaskResponseData;
-
-pub type CommonHash = H256;
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum TaskType {
-    Undefined,
-    Chunk,
-    Batch,
-    Bundle,
-}
-
-impl TaskType {
-    fn from_u8(v: u8) -> Self {
-        match v {
-            1 => TaskType::Chunk,
-            2 => TaskType::Batch,
-            3 => TaskType::Bundle,
-            _ => TaskType::Undefined,
-        }
-    }
-}
-
-impl Serialize for TaskType {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            TaskType::Undefined => serializer.serialize_u8(0),
-            TaskType::Chunk => serializer.serialize_u8(1),
-            TaskType::Batch => serializer.serialize_u8(2),
-            TaskType::Bundle => serializer.serialize_u8(3),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for TaskType {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let v: u8 = u8::deserialize(deserializer)?;
-        Ok(TaskType::from_u8(v))
-    }
-}
-
-impl Default for TaskType {
-    fn default() -> Self {
-        Self::Undefined
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum ProverType {
-    Chunk,
-    Batch,
-}
-
-impl ProverType {
-    fn from_u8(v: u8) -> Self {
-        match v {
-            1 => ProverType::Chunk,
-            2 => ProverType::Batch,
-            _ => {
-                panic!("invalid prover_type")
-            }
-        }
-    }
-
-    pub fn to_u8(self) -> u8 {
-        match self {
-            ProverType::Chunk => 1,
-            ProverType::Batch => 2,
-        }
-    }
-}
-
-impl Serialize for ProverType {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            ProverType::Chunk => serializer.serialize_u8(1),
-            ProverType::Batch => serializer.serialize_u8(2),
-        }
-    }
-}
-
-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))
-    }
-}
+use scroll_proving_sdk::prover::types::CircuitType;
 
 #[derive(Serialize, Deserialize, Default)]
 pub struct Task {
-    pub uuid: String,
-    pub id: String,
     #[serde(rename = "type", default)]
-    pub task_type: TaskType,
+    pub task_type: CircuitType,
     pub task_data: String,
     #[serde(default)]
     pub hard_fork_name: String,
 }
 
-impl From<GetTaskResponseData> for Task {
-    fn from(value: GetTaskResponseData) -> Self {
-        Self {
-            uuid: value.uuid,
-            id: value.task_id,
-            task_type: value.task_type,
-            task_data: value.task_data,
-            hard_fork_name: value.hard_fork_name,
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, Default)]
-pub struct TaskWrapper {
-    pub task: Task,
-    count: usize,
-}
-
-impl TaskWrapper {
-    pub fn increment_count(&mut self) {
-        self.count += 1;
-    }
-
-    pub fn get_count(&self) -> usize {
-        self.count
-    }
-}
-
-impl From<Task> for TaskWrapper {
-    fn from(task: Task) -> Self {
-        TaskWrapper { task, count: 0 }
-    }
-}
-
 #[derive(Serialize, Deserialize, Default)]
 pub struct ProofDetail {
     pub id: String,
     #[serde(rename = "type", default)]
-    pub proof_type: TaskType,
+    pub proof_type: CircuitType,
     pub proof_data: String,
     pub error: String,
 }

prover/src/utils.rs

@@ -1,32 +0,0 @@
-use env_logger::Env;
-use std::{fs::OpenOptions, sync::Once};
-
-use crate::types::{ProverType, TaskType};
-
-static LOG_INIT: Once = Once::new();
-
-/// Initialize log
-pub fn log_init(log_file: Option<String>) {
-    LOG_INIT.call_once(|| {
-        let mut builder = env_logger::Builder::from_env(Env::default().default_filter_or("info"));
-        if let Some(file_path) = log_file {
-            let target = Box::new(
-                OpenOptions::new()
-                    .write(true)
-                    .create(true)
-                    .truncate(false)
-                    .open(file_path)
-                    .expect("Can't create log file"),
-            );
-            builder.target(env_logger::Target::Pipe(target));
-        }
-        builder.init();
-    });
-}
-
-pub fn get_task_types(prover_type: ProverType) -> Vec<TaskType> {
-    match prover_type {
-        ProverType::Chunk => vec![TaskType::Chunk],
-        ProverType::Batch => vec![TaskType::Batch, TaskType::Bundle],
-    }
-}

prover/src/version.rs

@@ -1,18 +0,0 @@
-use std::cell::OnceCell;
-
-static DEFAULT_COMMIT: &str = "unknown";
-static mut VERSION: OnceCell<String> = OnceCell::new();
-
-pub const TAG: &str = "v0.0.0";
-pub const DEFAULT_ZK_VERSION: &str = "000000-000000";
-
-fn init_version() -> String {
-    let commit = option_env!("GIT_REV").unwrap_or(DEFAULT_COMMIT);
-    let tag = option_env!("GO_TAG").unwrap_or(TAG);
-    let zk_version = option_env!("ZK_VERSION").unwrap_or(DEFAULT_ZK_VERSION);
-    format!("{tag}-{commit}-{zk_version}")
-}
-
-pub fn get_version() -> String {
-    unsafe { VERSION.get_or_init(init_version).clone() }
-}

prover/src/zk_circuits_handler.rs

@@ -1,19 +1,8 @@
-mod common;
-mod darwin;
-mod darwin_v2;
+pub mod euclid;
 
-use super::geth_client::GethClient;
-use crate::{
-    config::{AssetsDirEnvConfig, Config},
-    types::{ProverType, Task, TaskType},
-    utils::get_task_types,
-};
-use anyhow::{bail, Result};
-use darwin::DarwinHandler;
-use darwin_v2::DarwinV2Handler;
-use std::{cell::RefCell, collections::HashMap, rc::Rc};
-
-type HardForkName = String;
+use anyhow::Result;
+use async_trait::async_trait;
+use scroll_proving_sdk::prover::{proving_service::ProveRequest, ProofType};
 
 pub mod utils {
     pub fn encode_vk(vk: Vec<u8>) -> String {
@@ -21,154 +10,9 @@ pub mod utils {
     }
 }
 
-pub trait CircuitsHandler {
-    fn get_vk(&self, task_type: TaskType) -> Option<Vec<u8>>;
+#[async_trait]
+pub trait CircuitsHandler: Send + Sync {
+    async fn get_vk(&self, task_type: ProofType) -> Option<Vec<u8>>;
 
-    fn get_proof_data(&self, task_type: TaskType, task: &Task) -> Result<String>;
-}
-
-type CircuitsHandlerBuilder = fn(
-    prover_type: ProverType,
-    config: &Config,
-    geth_client: Option<Rc<RefCell<GethClient>>>,
-) -> Result<Box<dyn CircuitsHandler>>;
-
-pub struct CircuitsHandlerProvider<'a> {
-    prover_type: ProverType,
-    config: &'a Config,
-    geth_client: Option<Rc<RefCell<GethClient>>>,
-    circuits_handler_builder_map: HashMap<HardForkName, CircuitsHandlerBuilder>,
-
-    current_fork_name: Option<HardForkName>,
-    current_circuit: Option<Rc<Box<dyn CircuitsHandler>>>,
-}
-
-impl<'a> CircuitsHandlerProvider<'a> {
-    pub fn new(
-        prover_type: ProverType,
-        config: &'a Config,
-        geth_client: Option<Rc<RefCell<GethClient>>>,
-    ) -> Result<Self> {
-        let mut m: HashMap<HardForkName, CircuitsHandlerBuilder> = HashMap::new();
-
-        fn handler_builder(
-            prover_type: ProverType,
-            config: &Config,
-            geth_client: Option<Rc<RefCell<GethClient>>>,
-        ) -> Result<Box<dyn CircuitsHandler>> {
-            log::info!(
-                "now init zk circuits handler, hard_fork_name: {}",
-                &config.low_version_circuit.hard_fork_name
-            );
-            AssetsDirEnvConfig::enable_first();
-            DarwinHandler::new(
-                prover_type,
-                &config.low_version_circuit.params_path,
-                &config.low_version_circuit.assets_path,
-                geth_client,
-            )
-            .map(|handler| Box::new(handler) as Box<dyn CircuitsHandler>)
-        }
-        m.insert(
-            config.low_version_circuit.hard_fork_name.clone(),
-            handler_builder,
-        );
-
-        fn next_handler_builder(
-            prover_type: ProverType,
-            config: &Config,
-            geth_client: Option<Rc<RefCell<GethClient>>>,
-        ) -> Result<Box<dyn CircuitsHandler>> {
-            log::info!(
-                "now init zk circuits handler, hard_fork_name: {}",
-                &config.high_version_circuit.hard_fork_name
-            );
-            AssetsDirEnvConfig::enable_second();
-            DarwinV2Handler::new(
-                prover_type,
-                &config.high_version_circuit.params_path,
-                &config.high_version_circuit.assets_path,
-                geth_client,
-            )
-            .map(|handler| Box::new(handler) as Box<dyn CircuitsHandler>)
-        }
-
-        m.insert(
-            config.high_version_circuit.hard_fork_name.clone(),
-            next_handler_builder,
-        );
-
-        let provider = CircuitsHandlerProvider {
-            prover_type,
-            config,
-            geth_client,
-            circuits_handler_builder_map: m,
-            current_fork_name: None,
-            current_circuit: None,
-        };
-
-        Ok(provider)
-    }
-
-    pub fn get_circuits_handler(
-        &mut self,
-        hard_fork_name: &String,
-    ) -> Result<Rc<Box<dyn CircuitsHandler>>> {
-        match &self.current_fork_name {
-            Some(fork_name) if fork_name == hard_fork_name => {
-                log::info!("get circuits handler from cache");
-                if let Some(handler) = &self.current_circuit {
-                    Ok(handler.clone())
-                } else {
-                    bail!("missing cached handler, there must be something wrong.")
-                }
-            }
-            _ => {
-                log::info!(
-                    "failed to get circuits handler from cache, create a new one: {hard_fork_name}"
-                );
-                if let Some(builder) = self.circuits_handler_builder_map.get(hard_fork_name) {
-                    log::info!("building circuits handler for {hard_fork_name}");
-                    let handler = builder(self.prover_type, self.config, self.geth_client.clone())
-                        .expect("failed to build circuits handler");
-                    self.current_fork_name = Some(hard_fork_name.clone());
-                    let rc_handler = Rc::new(handler);
-                    self.current_circuit = Some(rc_handler.clone());
-                    Ok(rc_handler)
-                } else {
-                    bail!("missing builder, there must be something wrong.")
-                }
-            }
-        }
-    }
-
-    pub fn init_vks(
-        &self,
-        prover_type: ProverType,
-        config: &'a Config,
-        geth_client: Option<Rc<RefCell<GethClient>>>,
-    ) -> Vec<String> {
-        self.circuits_handler_builder_map
-            .iter()
-            .flat_map(|(hard_fork_name, build)| {
-                let handler = build(prover_type, config, geth_client.clone())
-                    .expect("failed to build circuits handler");
-
-                get_task_types(prover_type)
-                    .into_iter()
-                    .map(|task_type| {
-                        let vk = handler
-                            .get_vk(task_type)
-                            .map_or("".to_string(), utils::encode_vk);
-                        log::info!(
-                            "vk for {hard_fork_name}, is {vk}, task_type: {:?}",
-                            task_type
-                        );
-                        vk
-                    })
-                    .filter(|vk| !vk.is_empty())
-                    .collect::<Vec<String>>()
-            })
-            .collect::<Vec<String>>()
-    }
+    async fn get_proof_data(&self, prove_request: ProveRequest) -> Result<String>;
 }

prover/src/zk_circuits_handler/common.rs

@@ -1,33 +0,0 @@
-use std::{collections::BTreeMap, rc::Rc};
-
-use crate::types::ProverType;
-
-use once_cell::sync::OnceCell;
-
-use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
-
-static mut PARAMS_MAP: OnceCell<Rc<BTreeMap<u32, ParamsKZG<Bn256>>>> = OnceCell::new();
-
-pub fn get_params_map_instance<'a, F>(load_params_func: F) -> &'a BTreeMap<u32, ParamsKZG<Bn256>>
-where
-    F: FnOnce() -> BTreeMap<u32, ParamsKZG<Bn256>>,
-{
-    unsafe {
-        PARAMS_MAP.get_or_init(|| {
-            let params_map = load_params_func();
-            Rc::new(params_map)
-        })
-    }
-}
-
-pub fn get_degrees<F>(prover_types: &std::collections::HashSet<ProverType>, f: F) -> Vec<u32>
-where
-    F: FnMut(&ProverType) -> Vec<u32>,
-{
-    prover_types
-        .iter()
-        .flat_map(f)
-        .collect::<std::collections::HashSet<u32>>()
-        .into_iter()
-        .collect()
-}

prover/src/zk_circuits_handler/darwin.rs

@@ -1,467 +0,0 @@
-use super::{common::*, CircuitsHandler};
-use crate::{
-    geth_client::GethClient,
-    types::{ProverType, TaskType},
-};
-use anyhow::{bail, Context, Ok, Result};
-use once_cell::sync::Lazy;
-use serde::Deserialize;
-
-use crate::types::{CommonHash, Task};
-use std::{cell::RefCell, cmp::Ordering, env, rc::Rc};
-
-use prover_darwin::{
-    aggregator::Prover as BatchProver,
-    check_chunk_hashes,
-    common::Prover as CommonProver,
-    config::{AGG_DEGREES, ZKEVM_DEGREES},
-    zkevm::Prover as ChunkProver,
-    BatchProof, BatchProvingTask, BlockTrace, BundleProof, BundleProvingTask, ChunkInfo,
-    ChunkProof, ChunkProvingTask,
-};
-
-// Only used for debugging.
-static OUTPUT_DIR: Lazy<Option<String>> = Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct BatchTaskDetail {
-    pub chunk_infos: Vec<ChunkInfo>,
-    #[serde(flatten)]
-    pub batch_proving_task: BatchProvingTask,
-}
-
-type BundleTaskDetail = BundleProvingTask;
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct ChunkTaskDetail {
-    pub block_hashes: Vec<CommonHash>,
-}
-
-fn get_block_number(block_trace: &BlockTrace) -> Option<u64> {
-    block_trace.header.number.map(|n| n.as_u64())
-}
-
-#[derive(Default)]
-pub struct DarwinHandler {
-    chunk_prover: Option<RefCell<ChunkProver<'static>>>,
-    batch_prover: Option<RefCell<BatchProver<'static>>>,
-
-    geth_client: Option<Rc<RefCell<GethClient>>>,
-}
-
-impl DarwinHandler {
-    pub fn new_multi(
-        prover_types: Vec<ProverType>,
-        params_dir: &str,
-        assets_dir: &str,
-        geth_client: Option<Rc<RefCell<GethClient>>>,
-    ) -> Result<Self> {
-        let class_name = std::intrinsics::type_name::<Self>();
-        let prover_types_set = prover_types
-            .into_iter()
-            .collect::<std::collections::HashSet<ProverType>>();
-        let mut handler = Self {
-            batch_prover: None,
-            chunk_prover: None,
-            geth_client,
-        };
-        let degrees: Vec<u32> = get_degrees(&prover_types_set, |prover_type| match prover_type {
-            ProverType::Chunk => ZKEVM_DEGREES.clone(),
-            ProverType::Batch => AGG_DEGREES.clone(),
-        });
-        let params_map = get_params_map_instance(|| {
-            log::info!(
-                "calling get_params_map from {}, prover_types: {:?}, degrees: {:?}",
-                class_name,
-                prover_types_set,
-                degrees
-            );
-            CommonProver::load_params_map(params_dir, &degrees)
-        });
-        for prover_type in prover_types_set {
-            match prover_type {
-                ProverType::Chunk => {
-                    handler.chunk_prover = Some(RefCell::new(ChunkProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )));
-                }
-                ProverType::Batch => {
-                    handler.batch_prover = Some(RefCell::new(BatchProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )))
-                }
-            }
-        }
-        Ok(handler)
-    }
-
-    pub fn new(
-        prover_type: ProverType,
-        params_dir: &str,
-        assets_dir: &str,
-        geth_client: Option<Rc<RefCell<GethClient>>>,
-    ) -> Result<Self> {
-        Self::new_multi(vec![prover_type], params_dir, assets_dir, geth_client)
-    }
-
-    fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
-        if let Some(prover) = self.chunk_prover.as_ref() {
-            let chunk = ChunkProvingTask::from(chunk_trace);
-
-            let chunk_proof =
-                prover
-                    .borrow_mut()
-                    .gen_chunk_proof(chunk, None, None, self.get_output_dir())?;
-
-            return Ok(chunk_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    fn gen_chunk_proof(&self, task: &crate::types::Task) -> Result<String> {
-        let chunk_trace = self.gen_chunk_traces(task)?;
-        let chunk_proof = self.gen_chunk_proof_raw(chunk_trace)?;
-        Ok(serde_json::to_string(&chunk_proof)?)
-    }
-
-    fn gen_batch_proof_raw(&self, batch_task_detail: BatchTaskDetail) -> Result<BatchProof> {
-        if let Some(prover) = self.batch_prover.as_ref() {
-            let chunk_hashes_proofs: Vec<(ChunkInfo, ChunkProof)> = batch_task_detail
-                .chunk_infos
-                .clone()
-                .into_iter()
-                .zip(batch_task_detail.batch_proving_task.chunk_proofs.clone())
-                .collect();
-
-            let chunk_proofs: Vec<ChunkProof> =
-                chunk_hashes_proofs.iter().map(|t| t.1.clone()).collect();
-
-            let is_valid = prover.borrow_mut().check_protocol_of_chunks(&chunk_proofs);
-
-            if !is_valid {
-                bail!("non-match chunk protocol")
-            }
-            check_chunk_hashes("", &chunk_hashes_proofs).context("failed to check chunk info")?;
-            let batch_proof = prover.borrow_mut().gen_batch_proof(
-                batch_task_detail.batch_proving_task,
-                None,
-                self.get_output_dir(),
-            )?;
-
-            return Ok(batch_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    fn gen_batch_proof(&self, task: &crate::types::Task) -> Result<String> {
-        log::info!("[circuit] gen_batch_proof for task {}", task.id);
-
-        let batch_task_detail: BatchTaskDetail = serde_json::from_str(&task.task_data)?;
-        let batch_proof = self.gen_batch_proof_raw(batch_task_detail)?;
-        Ok(serde_json::to_string(&batch_proof)?)
-    }
-
-    fn gen_bundle_proof_raw(&self, bundle_task_detail: BundleTaskDetail) -> Result<BundleProof> {
-        if let Some(prover) = self.batch_prover.as_ref() {
-            let bundle_proof = prover.borrow_mut().gen_bundle_proof(
-                bundle_task_detail,
-                None,
-                self.get_output_dir(),
-            )?;
-
-            return Ok(bundle_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    fn gen_bundle_proof(&self, task: &crate::types::Task) -> Result<String> {
-        log::info!("[circuit] gen_bundle_proof for task {}", task.id);
-        let bundle_task_detail: BundleTaskDetail = serde_json::from_str(&task.task_data)?;
-        let bundle_proof = self.gen_bundle_proof_raw(bundle_task_detail)?;
-        Ok(serde_json::to_string(&bundle_proof)?)
-    }
-
-    fn get_output_dir(&self) -> Option<&str> {
-        OUTPUT_DIR.as_deref()
-    }
-
-    fn gen_chunk_traces(&self, task: &Task) -> Result<Vec<BlockTrace>> {
-        let chunk_task_detail: ChunkTaskDetail = serde_json::from_str(&task.task_data)?;
-        self.get_sorted_traces_by_hashes(&chunk_task_detail.block_hashes)
-    }
-
-    fn get_sorted_traces_by_hashes(&self, block_hashes: &[CommonHash]) -> Result<Vec<BlockTrace>> {
-        if block_hashes.is_empty() {
-            log::error!("[prover] failed to get sorted traces: block_hashes are empty");
-            bail!("block_hashes are empty")
-        }
-
-        let mut block_traces = Vec::new();
-        for hash in block_hashes.iter() {
-            let trace = self
-                .geth_client
-                .as_ref()
-                .unwrap()
-                .borrow_mut()
-                .get_block_trace_by_hash(hash)?;
-            block_traces.push(trace);
-        }
-
-        block_traces.sort_by(|a, b| {
-            if get_block_number(a).is_none() {
-                Ordering::Less
-            } else if get_block_number(b).is_none() {
-                Ordering::Greater
-            } else {
-                get_block_number(a)
-                    .unwrap()
-                    .cmp(&get_block_number(b).unwrap())
-            }
-        });
-
-        let block_numbers: Vec<u64> = block_traces
-            .iter()
-            .map(|trace| get_block_number(trace).unwrap_or(0))
-            .collect();
-        let mut i = 0;
-        while i < block_numbers.len() - 1 {
-            if block_numbers[i] + 1 != block_numbers[i + 1] {
-                log::error!(
-                    "[prover] block numbers are not continuous, got {} and {}",
-                    block_numbers[i],
-                    block_numbers[i + 1]
-                );
-                bail!(
-                    "block numbers are not continuous, got {} and {}",
-                    block_numbers[i],
-                    block_numbers[i + 1]
-                )
-            }
-            i += 1;
-        }
-
-        Ok(block_traces)
-    }
-}
-
-impl CircuitsHandler for DarwinHandler {
-    fn get_vk(&self, task_type: TaskType) -> Option<Vec<u8>> {
-        match task_type {
-            TaskType::Chunk => self
-                .chunk_prover
-                .as_ref()
-                .and_then(|prover| prover.borrow().get_vk()),
-            TaskType::Batch => self
-                .batch_prover
-                .as_ref()
-                .and_then(|prover| prover.borrow().get_batch_vk()),
-            TaskType::Bundle => self
-                .batch_prover
-                .as_ref()
-                .and_then(|prover| prover.borrow().get_bundle_vk()),
-            _ => unreachable!(),
-        }
-    }
-
-    fn get_proof_data(&self, task_type: TaskType, task: &crate::types::Task) -> Result<String> {
-        match task_type {
-            TaskType::Chunk => self.gen_chunk_proof(task),
-            TaskType::Batch => self.gen_batch_proof(task),
-            TaskType::Bundle => self.gen_bundle_proof(task),
-            _ => unreachable!(),
-        }
-    }
-}
-
-// =================================== tests module ========================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::zk_circuits_handler::utils::encode_vk;
-    use prover_darwin::utils::chunk_trace_to_witness_block;
-    use std::{path::PathBuf, sync::LazyLock};
-
-    #[ctor::ctor]
-    fn init() {
-        crate::utils::log_init(None);
-        log::info!("logger initialized");
-    }
-
-    static DEFAULT_WORK_DIR: &str = "/assets";
-    static WORK_DIR: LazyLock<String> = LazyLock::new(|| {
-        std::env::var("DARWIN_TEST_DIR")
-            .unwrap_or(String::from(DEFAULT_WORK_DIR))
-            .trim_end_matches('/')
-            .to_string()
-    });
-    static PARAMS_PATH: LazyLock<String> = LazyLock::new(|| format!("{}/test_params", *WORK_DIR));
-    static ASSETS_PATH: LazyLock<String> = LazyLock::new(|| format!("{}/test_assets", *WORK_DIR));
-    static PROOF_DUMP_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/proof_data", *WORK_DIR));
-    static BATCH_DIR_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/traces/batch_24", *WORK_DIR));
-    static BATCH_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_batch.vkey", *WORK_DIR));
-    static CHUNK_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_chunk.vkey", *WORK_DIR));
-
-    #[test]
-    fn it_works() {
-        let result = true;
-        assert!(result);
-    }
-
-    #[test]
-    fn test_circuits() -> Result<()> {
-        let bi_handler = DarwinHandler::new_multi(
-            vec![ProverType::Chunk, ProverType::Batch],
-            &PARAMS_PATH,
-            &ASSETS_PATH,
-            None,
-        )?;
-
-        let chunk_handler = bi_handler;
-        let chunk_vk = chunk_handler.get_vk(TaskType::Chunk).unwrap();
-
-        check_vk(TaskType::Chunk, chunk_vk, "chunk vk must be available");
-        let chunk_dir_paths = get_chunk_dir_paths()?;
-        log::info!("chunk_dir_paths, {:?}", chunk_dir_paths);
-        let mut chunk_infos = vec![];
-        let mut chunk_proofs = vec![];
-        for (id, chunk_path) in chunk_dir_paths.into_iter().enumerate() {
-            let chunk_id = format!("chunk_proof{}", id + 1);
-            log::info!("start to process {chunk_id}");
-            let chunk_trace = read_chunk_trace(chunk_path)?;
-
-            let chunk_info = traces_to_chunk_info(chunk_trace.clone())?;
-            chunk_infos.push(chunk_info);
-
-            log::info!("start to prove {chunk_id}");
-            let chunk_proof = chunk_handler.gen_chunk_proof_raw(chunk_trace)?;
-            let proof_data = serde_json::to_string(&chunk_proof)?;
-            dump_proof(chunk_id, proof_data)?;
-            chunk_proofs.push(chunk_proof);
-        }
-
-        let batch_handler = chunk_handler;
-        let batch_vk = batch_handler.get_vk(TaskType::Batch).unwrap();
-        check_vk(TaskType::Batch, batch_vk, "batch vk must be available");
-        let batch_task_detail = make_batch_task_detail(chunk_infos, chunk_proofs);
-        log::info!("start to prove batch");
-        let batch_proof = batch_handler.gen_batch_proof_raw(batch_task_detail)?;
-        let proof_data = serde_json::to_string(&batch_proof)?;
-        dump_proof("batch_proof".to_string(), proof_data)?;
-
-        Ok(())
-    }
-
-    fn make_batch_task_detail(_: Vec<ChunkInfo>, _: Vec<ChunkProof>) -> BatchTaskDetail {
-        todo!();
-        // BatchTaskDetail {
-        //     chunk_infos,
-        //     batch_proving_task: BatchProvingTask {
-        //         parent_batch_hash: todo!(),
-        //         parent_state_root: todo!(),
-        //         batch_header: todo!(),
-        //         chunk_proofs,
-        //     },
-        // }
-    }
-
-    fn check_vk(proof_type: TaskType, vk: Vec<u8>, info: &str) {
-        log::info!("check_vk, {:?}", proof_type);
-        let vk_from_file = read_vk(proof_type).unwrap();
-        assert_eq!(vk_from_file, encode_vk(vk), "{info}")
-    }
-
-    fn read_vk(proof_type: TaskType) -> Result<String> {
-        log::info!("read_vk, {:?}", proof_type);
-        let vk_file = match proof_type {
-            TaskType::Chunk => CHUNK_VK_PATH.clone(),
-            TaskType::Batch => BATCH_VK_PATH.clone(),
-            TaskType::Bundle => todo!(),
-            TaskType::Undefined => unreachable!(),
-        };
-
-        let data = std::fs::read(vk_file)?;
-        Ok(encode_vk(data))
-    }
-
-    fn read_chunk_trace(path: PathBuf) -> Result<Vec<BlockTrace>> {
-        log::info!("read_chunk_trace, {:?}", path);
-        let mut chunk_trace: Vec<BlockTrace> = vec![];
-
-        fn read_block_trace(file: &PathBuf) -> Result<BlockTrace> {
-            let f = std::fs::File::open(file)?;
-            Ok(serde_json::from_reader(&f)?)
-        }
-
-        if path.is_dir() {
-            let entries = std::fs::read_dir(&path)?;
-            let mut files: Vec<String> = entries
-                .into_iter()
-                .filter_map(|e| {
-                    if e.is_err() {
-                        return None;
-                    }
-                    let entry = e.unwrap();
-                    if entry.path().is_dir() {
-                        return None;
-                    }
-                    if let Result::Ok(file_name) = entry.file_name().into_string() {
-                        Some(file_name)
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            files.sort();
-
-            log::info!("files in chunk {:?} is {:?}", path, files);
-            for file in files {
-                let block_trace = read_block_trace(&path.join(file))?;
-                chunk_trace.push(block_trace);
-            }
-        } else {
-            let block_trace = read_block_trace(&path)?;
-            chunk_trace.push(block_trace);
-        }
-        Ok(chunk_trace)
-    }
-
-    fn get_chunk_dir_paths() -> Result<Vec<PathBuf>> {
-        let batch_path = PathBuf::from(BATCH_DIR_PATH.clone());
-        let entries = std::fs::read_dir(&batch_path)?;
-        let mut files: Vec<String> = entries
-            .filter_map(|e| {
-                if e.is_err() {
-                    return None;
-                }
-                let entry = e.unwrap();
-                if entry.path().is_dir() {
-                    if let Result::Ok(file_name) = entry.file_name().into_string() {
-                        Some(file_name)
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                }
-            })
-            .collect();
-        files.sort();
-        log::info!("files in batch {:?} is {:?}", batch_path, files);
-        Ok(files.into_iter().map(|f| batch_path.join(f)).collect())
-    }
-
-    fn traces_to_chunk_info(chunk_trace: Vec<BlockTrace>) -> Result<ChunkInfo> {
-        let witness_block = chunk_trace_to_witness_block(chunk_trace)?;
-        Ok(ChunkInfo::from_witness_block(&witness_block, false))
-    }
-
-    fn dump_proof(id: String, proof_data: String) -> Result<()> {
-        let dump_path = PathBuf::from(PROOF_DUMP_PATH.clone());
-        Ok(std::fs::write(dump_path.join(id), proof_data)?)
-    }
-}

prover/src/zk_circuits_handler/darwin_v2.rs

@@ -1,525 +0,0 @@
-use super::{common::*, CircuitsHandler};
-use crate::{
-    geth_client::GethClient,
-    types::{ProverType, TaskType},
-};
-use anyhow::{bail, Context, Ok, Result};
-use once_cell::sync::Lazy;
-use serde::Deserialize;
-
-use crate::types::{CommonHash, Task};
-use std::{cell::RefCell, cmp::Ordering, env, rc::Rc};
-
-use prover_darwin_v2::{
-    aggregator::Prover as BatchProver,
-    check_chunk_hashes,
-    common::Prover as CommonProver,
-    config::{AGG_DEGREES, ZKEVM_DEGREES},
-    zkevm::Prover as ChunkProver,
-    BatchProof, BatchProvingTask, BlockTrace, BundleProof, BundleProvingTask, ChunkInfo,
-    ChunkProof, ChunkProvingTask,
-};
-
-// Only used for debugging.
-static OUTPUT_DIR: Lazy<Option<String>> = Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct BatchTaskDetail {
-    pub chunk_infos: Vec<ChunkInfo>,
-    #[serde(flatten)]
-    pub batch_proving_task: BatchProvingTask,
-}
-
-type BundleTaskDetail = BundleProvingTask;
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct ChunkTaskDetail {
-    pub block_hashes: Vec<CommonHash>,
-}
-
-fn get_block_number(block_trace: &BlockTrace) -> Option<u64> {
-    block_trace.header.number.map(|n| n.as_u64())
-}
-
-#[derive(Default)]
-pub struct DarwinV2Handler {
-    chunk_prover: Option<RefCell<ChunkProver<'static>>>,
-    batch_prover: Option<RefCell<BatchProver<'static>>>,
-
-    geth_client: Option<Rc<RefCell<GethClient>>>,
-}
-
-impl DarwinV2Handler {
-    pub fn new_multi(
-        prover_types: Vec<ProverType>,
-        params_dir: &str,
-        assets_dir: &str,
-        geth_client: Option<Rc<RefCell<GethClient>>>,
-    ) -> Result<Self> {
-        let class_name = std::intrinsics::type_name::<Self>();
-        let prover_types_set = prover_types
-            .into_iter()
-            .collect::<std::collections::HashSet<ProverType>>();
-        let mut handler = Self {
-            batch_prover: None,
-            chunk_prover: None,
-            geth_client,
-        };
-        let degrees: Vec<u32> = get_degrees(&prover_types_set, |prover_type| match prover_type {
-            ProverType::Chunk => ZKEVM_DEGREES.clone(),
-            ProverType::Batch => AGG_DEGREES.clone(),
-        });
-        let params_map = get_params_map_instance(|| {
-            log::info!(
-                "calling get_params_map from {}, prover_types: {:?}, degrees: {:?}",
-                class_name,
-                prover_types_set,
-                degrees
-            );
-            CommonProver::load_params_map(params_dir, &degrees)
-        });
-        for prover_type in prover_types_set {
-            match prover_type {
-                ProverType::Chunk => {
-                    handler.chunk_prover = Some(RefCell::new(ChunkProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )));
-                }
-                ProverType::Batch => {
-                    handler.batch_prover = Some(RefCell::new(BatchProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )))
-                }
-            }
-        }
-        Ok(handler)
-    }
-
-    pub fn new(
-        prover_type: ProverType,
-        params_dir: &str,
-        assets_dir: &str,
-        geth_client: Option<Rc<RefCell<GethClient>>>,
-    ) -> Result<Self> {
-        Self::new_multi(vec![prover_type], params_dir, assets_dir, geth_client)
-    }
-
-    fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
-        if let Some(prover) = self.chunk_prover.as_ref() {
-            let chunk = ChunkProvingTask::from(chunk_trace);
-
-            let chunk_proof =
-                prover
-                    .borrow_mut()
-                    .gen_chunk_proof(chunk, None, None, self.get_output_dir())?;
-
-            return Ok(chunk_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    fn gen_chunk_proof(&self, task: &crate::types::Task) -> Result<String> {
-        let chunk_trace = self.gen_chunk_traces(task)?;
-        let chunk_proof = self.gen_chunk_proof_raw(chunk_trace)?;
-        Ok(serde_json::to_string(&chunk_proof)?)
-    }
-
-    fn gen_batch_proof_raw(&self, batch_task_detail: BatchTaskDetail) -> Result<BatchProof> {
-        if let Some(prover) = self.batch_prover.as_ref() {
-            let chunk_hashes_proofs: Vec<(ChunkInfo, ChunkProof)> = batch_task_detail
-                .chunk_infos
-                .clone()
-                .into_iter()
-                .zip(batch_task_detail.batch_proving_task.chunk_proofs.clone())
-                .collect();
-
-            let chunk_proofs: Vec<ChunkProof> =
-                chunk_hashes_proofs.iter().map(|t| t.1.clone()).collect();
-
-            let is_valid = prover.borrow_mut().check_protocol_of_chunks(&chunk_proofs);
-
-            if !is_valid {
-                bail!("non-match chunk protocol")
-            }
-            check_chunk_hashes("", &chunk_hashes_proofs).context("failed to check chunk info")?;
-            let batch_proof = prover.borrow_mut().gen_batch_proof(
-                batch_task_detail.batch_proving_task,
-                None,
-                self.get_output_dir(),
-            )?;
-
-            return Ok(batch_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    fn gen_batch_proof(&self, task: &crate::types::Task) -> Result<String> {
-        log::info!("[circuit] gen_batch_proof for task {}", task.id);
-
-        let batch_task_detail: BatchTaskDetail = serde_json::from_str(&task.task_data)?;
-        let batch_proof = self.gen_batch_proof_raw(batch_task_detail)?;
-        Ok(serde_json::to_string(&batch_proof)?)
-    }
-
-    fn gen_bundle_proof_raw(&self, bundle_task_detail: BundleTaskDetail) -> Result<BundleProof> {
-        if let Some(prover) = self.batch_prover.as_ref() {
-            let bundle_proof = prover.borrow_mut().gen_bundle_proof(
-                bundle_task_detail,
-                None,
-                self.get_output_dir(),
-            )?;
-
-            return Ok(bundle_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    fn gen_bundle_proof(&self, task: &crate::types::Task) -> Result<String> {
-        log::info!("[circuit] gen_bundle_proof for task {}", task.id);
-        let bundle_task_detail: BundleTaskDetail = serde_json::from_str(&task.task_data)?;
-        let bundle_proof = self.gen_bundle_proof_raw(bundle_task_detail)?;
-        Ok(serde_json::to_string(&bundle_proof)?)
-    }
-
-    fn get_output_dir(&self) -> Option<&str> {
-        OUTPUT_DIR.as_deref()
-    }
-
-    fn gen_chunk_traces(&self, task: &Task) -> Result<Vec<BlockTrace>> {
-        let chunk_task_detail: ChunkTaskDetail = serde_json::from_str(&task.task_data)?;
-        self.get_sorted_traces_by_hashes(&chunk_task_detail.block_hashes)
-    }
-
-    fn get_sorted_traces_by_hashes(&self, block_hashes: &[CommonHash]) -> Result<Vec<BlockTrace>> {
-        if block_hashes.is_empty() {
-            log::error!("[prover] failed to get sorted traces: block_hashes are empty");
-            bail!("block_hashes are empty")
-        }
-
-        let mut block_traces = Vec::new();
-        for hash in block_hashes.iter() {
-            let trace = self
-                .geth_client
-                .as_ref()
-                .unwrap()
-                .borrow_mut()
-                .get_block_trace_by_hash(hash)?;
-            block_traces.push(trace);
-        }
-
-        block_traces.sort_by(|a, b| {
-            if get_block_number(a).is_none() {
-                Ordering::Less
-            } else if get_block_number(b).is_none() {
-                Ordering::Greater
-            } else {
-                get_block_number(a)
-                    .unwrap()
-                    .cmp(&get_block_number(b).unwrap())
-            }
-        });
-
-        let block_numbers: Vec<u64> = block_traces
-            .iter()
-            .map(|trace| get_block_number(trace).unwrap_or(0))
-            .collect();
-        let mut i = 0;
-        while i < block_numbers.len() - 1 {
-            if block_numbers[i] + 1 != block_numbers[i + 1] {
-                log::error!(
-                    "[prover] block numbers are not continuous, got {} and {}",
-                    block_numbers[i],
-                    block_numbers[i + 1]
-                );
-                bail!(
-                    "block numbers are not continuous, got {} and {}",
-                    block_numbers[i],
-                    block_numbers[i + 1]
-                )
-            }
-            i += 1;
-        }
-
-        Ok(block_traces)
-    }
-}
-
-impl CircuitsHandler for DarwinV2Handler {
-    fn get_vk(&self, task_type: TaskType) -> Option<Vec<u8>> {
-        match task_type {
-            TaskType::Chunk => self
-                .chunk_prover
-                .as_ref()
-                .and_then(|prover| prover.borrow().get_vk()),
-            TaskType::Batch => self
-                .batch_prover
-                .as_ref()
-                .and_then(|prover| prover.borrow().get_batch_vk()),
-            TaskType::Bundle => self
-                .batch_prover
-                .as_ref()
-                .and_then(|prover| prover.borrow().get_bundle_vk()),
-            _ => unreachable!(),
-        }
-    }
-
-    fn get_proof_data(&self, task_type: TaskType, task: &crate::types::Task) -> Result<String> {
-        match task_type {
-            TaskType::Chunk => self.gen_chunk_proof(task),
-            TaskType::Batch => self.gen_batch_proof(task),
-            TaskType::Bundle => self.gen_bundle_proof(task),
-            _ => unreachable!(),
-        }
-    }
-}
-
-// =================================== tests module ========================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::zk_circuits_handler::utils::encode_vk;
-    use ethers_core::types::H256;
-    use prover_darwin_v2::{
-        aggregator::eip4844, utils::chunk_trace_to_witness_block, BatchData, BatchHeader,
-        MAX_AGG_SNARKS,
-    };
-    use std::{path::PathBuf, sync::LazyLock};
-
-    #[ctor::ctor]
-    fn init() {
-        crate::utils::log_init(None);
-        log::info!("logger initialized");
-    }
-
-    static DEFAULT_WORK_DIR: &str = "/assets";
-    static WORK_DIR: LazyLock<String> = LazyLock::new(|| {
-        std::env::var("DARWIN_V2_TEST_DIR")
-            .unwrap_or(String::from(DEFAULT_WORK_DIR))
-            .trim_end_matches('/')
-            .to_string()
-    });
-    static PARAMS_PATH: LazyLock<String> = LazyLock::new(|| format!("{}/test_params", *WORK_DIR));
-    static ASSETS_PATH: LazyLock<String> = LazyLock::new(|| format!("{}/test_assets", *WORK_DIR));
-    static PROOF_DUMP_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/proof_data", *WORK_DIR));
-    static BATCH_DIR_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/traces/batch_24", *WORK_DIR));
-    static BATCH_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_batch.vkey", *WORK_DIR));
-    static CHUNK_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_chunk.vkey", *WORK_DIR));
-
-    #[test]
-    fn it_works() {
-        let result = true;
-        assert!(result);
-    }
-
-    #[test]
-    fn test_circuits() -> Result<()> {
-        let bi_handler = DarwinV2Handler::new_multi(
-            vec![ProverType::Chunk, ProverType::Batch],
-            &PARAMS_PATH,
-            &ASSETS_PATH,
-            None,
-        )?;
-
-        let chunk_handler = bi_handler;
-        let chunk_vk = chunk_handler.get_vk(TaskType::Chunk).unwrap();
-
-        check_vk(TaskType::Chunk, chunk_vk, "chunk vk must be available");
-        let chunk_dir_paths = get_chunk_dir_paths()?;
-        log::info!("chunk_dir_paths, {:?}", chunk_dir_paths);
-        let mut chunk_traces = vec![];
-        let mut chunk_infos = vec![];
-        let mut chunk_proofs = vec![];
-        for (id, chunk_path) in chunk_dir_paths.into_iter().enumerate() {
-            let chunk_id = format!("chunk_proof{}", id + 1);
-            log::info!("start to process {chunk_id}");
-            let chunk_trace = read_chunk_trace(chunk_path)?;
-            chunk_traces.push(chunk_trace.clone());
-            let chunk_info = traces_to_chunk_info(chunk_trace.clone())?;
-            chunk_infos.push(chunk_info);
-
-            log::info!("start to prove {chunk_id}");
-            let chunk_proof = chunk_handler.gen_chunk_proof_raw(chunk_trace)?;
-            let proof_data = serde_json::to_string(&chunk_proof)?;
-            dump_proof(chunk_id, proof_data)?;
-            chunk_proofs.push(chunk_proof);
-        }
-
-        let batch_handler = chunk_handler;
-        let batch_vk = batch_handler.get_vk(TaskType::Batch).unwrap();
-        check_vk(TaskType::Batch, batch_vk, "batch vk must be available");
-        let batch_task_detail = make_batch_task_detail(chunk_traces, chunk_proofs, None);
-        log::info!("start to prove batch");
-        let batch_proof = batch_handler.gen_batch_proof_raw(batch_task_detail)?;
-        let proof_data = serde_json::to_string(&batch_proof)?;
-        dump_proof("batch_proof".to_string(), proof_data)?;
-
-        Ok(())
-    }
-
-    // copied from https://github.com/scroll-tech/scroll-prover/blob/main/integration/src/prove.rs
-    fn get_blob_from_chunks(chunks: &[ChunkInfo]) -> Vec<u8> {
-        let num_chunks = chunks.len();
-
-        let padded_chunk =
-            ChunkInfo::mock_padded_chunk_info_for_testing(chunks.last().as_ref().unwrap());
-        let chunks_with_padding = [
-            chunks.to_vec(),
-            vec![padded_chunk; MAX_AGG_SNARKS - num_chunks],
-        ]
-        .concat();
-        let batch_data = BatchData::<{ MAX_AGG_SNARKS }>::new(chunks.len(), &chunks_with_padding);
-        let batch_bytes = batch_data.get_batch_data_bytes();
-        let blob_bytes = eip4844::get_blob_bytes(&batch_bytes);
-        log::info!("blob_bytes len {}", blob_bytes.len());
-        blob_bytes
-    }
-
-    // TODO: chunk_infos can be extracted from chunk_proofs.
-    // Still needed?
-    fn make_batch_task_detail(
-        chunk_traces: Vec<Vec<BlockTrace>>,
-        chunk_proofs: Vec<ChunkProof>,
-        last_batcher_header: Option<BatchHeader<{ MAX_AGG_SNARKS }>>,
-    ) -> BatchTaskDetail {
-        // dummy parent batch hash
-        let dummy_parent_batch_hash = H256([
-            0xab, 0xac, 0xad, 0xae, 0xaf, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0,
-        ]);
-        let chunk_infos: Vec<_> = chunk_proofs.iter().map(|p| p.chunk_info.clone()).collect();
-
-        let l1_message_popped = chunk_traces
-            .iter()
-            .flatten()
-            .map(|chunk| chunk.num_l1_txs())
-            .sum();
-        let last_block_timestamp = chunk_traces.last().map_or(0, |block_traces| {
-            block_traces
-                .last()
-                .map_or(0, |block_trace| block_trace.header.timestamp.as_u64())
-        });
-
-        let blob_bytes = get_blob_from_chunks(&chunk_infos);
-        let batch_header = BatchHeader::construct_from_chunks(
-            last_batcher_header.map_or(4, |header| header.version),
-            last_batcher_header.map_or(123, |header| header.batch_index + 1),
-            l1_message_popped,
-            last_batcher_header.map_or(l1_message_popped, |header| {
-                header.total_l1_message_popped + l1_message_popped
-            }),
-            last_batcher_header.map_or(dummy_parent_batch_hash, |header| header.batch_hash()),
-            last_block_timestamp,
-            &chunk_infos,
-            &blob_bytes,
-        );
-        BatchTaskDetail {
-            chunk_infos,
-            batch_proving_task: BatchProvingTask {
-                chunk_proofs,
-                batch_header,
-                blob_bytes,
-            },
-        }
-    }
-
-    fn check_vk(proof_type: TaskType, vk: Vec<u8>, info: &str) {
-        log::info!("check_vk, {:?}", proof_type);
-        let vk_from_file = read_vk(proof_type).unwrap();
-        assert_eq!(vk_from_file, encode_vk(vk), "{info}")
-    }
-
-    fn read_vk(proof_type: TaskType) -> Result<String> {
-        log::info!("read_vk, {:?}", proof_type);
-        let vk_file = match proof_type {
-            TaskType::Chunk => CHUNK_VK_PATH.clone(),
-            TaskType::Batch => BATCH_VK_PATH.clone(),
-            TaskType::Bundle => todo!(),
-            TaskType::Undefined => unreachable!(),
-        };
-
-        let data = std::fs::read(vk_file)?;
-        Ok(encode_vk(data))
-    }
-
-    fn read_chunk_trace(path: PathBuf) -> Result<Vec<BlockTrace>> {
-        log::info!("read_chunk_trace, {:?}", path);
-        let mut chunk_trace: Vec<BlockTrace> = vec![];
-
-        fn read_block_trace(file: &PathBuf) -> Result<BlockTrace> {
-            let f = std::fs::File::open(file)?;
-            Ok(serde_json::from_reader(&f)?)
-        }
-
-        if path.is_dir() {
-            let entries = std::fs::read_dir(&path)?;
-            let mut files: Vec<String> = entries
-                .into_iter()
-                .filter_map(|e| {
-                    if e.is_err() {
-                        return None;
-                    }
-                    let entry = e.unwrap();
-                    if entry.path().is_dir() {
-                        return None;
-                    }
-                    if let Result::Ok(file_name) = entry.file_name().into_string() {
-                        Some(file_name)
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            files.sort();
-
-            log::info!("files in chunk {:?} is {:?}", path, files);
-            for file in files {
-                let block_trace = read_block_trace(&path.join(file))?;
-                chunk_trace.push(block_trace);
-            }
-        } else {
-            let block_trace = read_block_trace(&path)?;
-            chunk_trace.push(block_trace);
-        }
-        Ok(chunk_trace)
-    }
-
-    fn get_chunk_dir_paths() -> Result<Vec<PathBuf>> {
-        let batch_path = PathBuf::from(BATCH_DIR_PATH.clone());
-        let entries = std::fs::read_dir(&batch_path)?;
-        let mut files: Vec<String> = entries
-            .filter_map(|e| {
-                if e.is_err() {
-                    return None;
-                }
-                let entry = e.unwrap();
-                if entry.path().is_dir() {
-                    if let Result::Ok(file_name) = entry.file_name().into_string() {
-                        Some(file_name)
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                }
-            })
-            .collect();
-        files.sort();
-        log::info!("files in batch {:?} is {:?}", batch_path, files);
-        Ok(files.into_iter().map(|f| batch_path.join(f)).collect())
-    }
-
-    fn traces_to_chunk_info(chunk_trace: Vec<BlockTrace>) -> Result<ChunkInfo> {
-        let witness_block = chunk_trace_to_witness_block(chunk_trace)?;
-        Ok(ChunkInfo::from_witness_block(&witness_block, false))
-    }
-
-    fn dump_proof(id: String, proof_data: String) -> Result<()> {
-        let dump_path = PathBuf::from(PROOF_DUMP_PATH.clone());
-        Ok(std::fs::write(dump_path.join(id), proof_data)?)
-    }
-}

prover/src/zk_circuits_handler/euclid.rs

@@ -0,0 +1,23 @@
+use anyhow::{anyhow, Result};
+use async_trait::async_trait;
+use scroll_proving_sdk::prover::{proving_service::ProveRequest, ProofType};
+
+use super::CircuitsHandler;
+pub struct EuclidHandler {}
+
+impl EuclidHandler {
+    pub fn new(_workspace_path: &str) -> Self {
+        Self {}
+    }
+}
+
+#[async_trait]
+impl CircuitsHandler for EuclidHandler {
+    async fn get_vk(&self, _task_type: ProofType) -> Option<Vec<u8>> {
+        None
+    }
+
+    async fn get_proof_data(&self, _prove_request: ProveRequest) -> Result<String> {
+        Err(anyhow!("Not implemented"))
+    }
+}