update configuration of verifier@coordinator

Author: noel2004

coordinator/cmd/api/app/mock_app.go

@@ -90,12 +90,12 @@ func (c *CoordinatorApp) MockConfig(store bool) error {
 	cfg.ProverManager = &coordinatorConfig.ProverManager{
 		ProversPerSession: 1,
 		Verifier: &coordinatorConfig.VerifierConfig{
-			HighVersionCircuit: &coordinatorConfig.CircuitConfig{
-				AssetsPath:       "",
-				ForkName:         "euclidV2",
-				MinProverVersion: "v4.4.89",
+			MinProverVersion: "v4.4.89",
+			Verifiers: []coordinatorConfig.AssetConfig{{
+				AssetsPath: "",
+				ForkName:   "euclidV2",
 			},
-		},
+			}},
 		BatchCollectionTimeSec: 60,
 		ChunkCollectionTimeSec: 60,
 		SessionAttempts:        10,

coordinator/cmd/tool/verify.go

@@ -13,21 +13,22 @@ import (
 
 	"scroll-tech/common/types/message"
 
+	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/urfave/cli/v2"
 )
 
 func verify(cCtx *cli.Context) error {
 	var forkName, proofType, proofPath string
 	if cCtx.Args().Len() <= 2 {
-		forkName = cfg.ProverManager.Verifier.HighVersionCircuit.ForkName
+		forkName = cfg.ProverManager.Verifier.Verifiers[0].ForkName
 		proofType = cCtx.Args().First()
 		proofPath = cCtx.Args().Get(1)
 	} else {
 		forkName = cCtx.Args().First()
 		proofType = cCtx.Args().Get(1)
 		proofPath = cCtx.Args().Get(2)
 	}
-	fmt.Println("verify proof in: ", proofPath, "type", proofType, "forkName", forkName)
+	log.Info("verify proof in: ", proofPath, "type", proofType, "forkName", forkName)
 
 	// Load the content of the proof file
 	data, err := os.ReadFile(filepath.Clean(proofPath))

coordinator/conf/config.json

@@ -7,11 +7,12 @@
     "batch_collection_time_sec": 180,
     "chunk_collection_time_sec": 180,
     "verifier": {
-      "high_version_circuit": {
-        "assets_path": "assets",
-        "fork_name": "euclidV2",
-        "min_prover_version": "v4.4.45"
-      }
+      "assets_path": "assets",
+      "min_prover_version": "v4.4.45",
+      "accept_vks": [{
+        "file": "euclidvk.json",
+        "fork_name": "euclidV2"
+      }]
     }
   },
   "db": {

coordinator/internal/config/config.go

@@ -55,16 +55,17 @@ type Config struct {
 	Auth          *Auth            `json:"auth"`
 }
 
-// CircuitConfig circuit items.
-type CircuitConfig struct {
-	AssetsPath       string `json:"assets_path"`
-	ForkName         string `json:"fork_name"`
-	MinProverVersion string `json:"min_prover_version"`
+// AssetConfig contain assets configurated for each fork, the defaul vkfile name is "OpenVmVk.json".
+type AssetConfig struct {
+	AssetsPath string `json:"assets_path"`
+	ForkName   string `json:"fork_name"`
+	Vkfile     string `json:"vk_file,omitempty"`
 }
 
 // VerifierConfig load zk verifier config.
 type VerifierConfig struct {
-	HighVersionCircuit *CircuitConfig `json:"high_version_circuit"`
+	MinProverVersion string        `json:"min_prover_version"`
+	Verifiers        []AssetConfig `json:"verifiers"`
 }
 
 // NewConfig returns a new instance of Config.

coordinator/internal/logic/auth/login.go

@@ -31,9 +31,11 @@ type LoginLogic struct {
 func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *LoginLogic {
 	proverVersionHardForkMap := make(map[string][]string)
 
-	var highHardForks []string
-	highHardForks = append(highHardForks, cfg.ProverManager.Verifier.HighVersionCircuit.ForkName)
-	proverVersionHardForkMap[cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion] = highHardForks
+	var hardForks []string
+	for _, cfg := range cfg.ProverManager.Verifier.Verifiers {
+		hardForks = append(hardForks, cfg.ForkName)
+	}
+	proverVersionHardForkMap[cfg.ProverManager.Verifier.MinProverVersion] = hardForks
 
 	return &LoginLogic{
 		cfg:                      cfg,
@@ -56,8 +58,8 @@ func (l *LoginLogic) Check(login *types.LoginParameter) error {
 		return errors.New("auth message verify failure")
 	}
 
-	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion) {
-		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", l.cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion, login.Message.ProverVersion)
+	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.Verifier.MinProverVersion) {
+		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", l.cfg.ProverManager.Verifier.MinProverVersion, login.Message.ProverVersion)
 	}
 
 	vks := make(map[string]struct{})

coordinator/internal/logic/verifier/verifier.go

@@ -26,7 +26,7 @@ type rustCircuitConfig struct {
 	AssetsPath string `json:"assets_path"`
 }
 
-func newRustCircuitConfig(cfg *config.CircuitConfig) *rustCircuitConfig {
+func newRustCircuitConfig(cfg config.AssetConfig) *rustCircuitConfig {
 	return &rustCircuitConfig{
 		ForkName:   cfg.ForkName,
 		AssetsPath: cfg.AssetsPath,
@@ -37,13 +37,17 @@ func newRustCircuitConfig(cfg *config.CircuitConfig) *rustCircuitConfig {
 // Define a brand new struct here is to eliminate side effects in case fields
 // in `*config.VerifierConfig` being changed
 type rustVerifierConfig struct {
-	HighVersionCircuit *rustCircuitConfig `json:"high_version_circuit"`
+	Circuits []*rustCircuitConfig `json:"circuits"`
 }
 
 func newRustVerifierConfig(cfg *config.VerifierConfig) *rustVerifierConfig {
-	return &rustVerifierConfig{
-		HighVersionCircuit: newRustCircuitConfig(cfg.HighVersionCircuit),
+
+	out := &rustVerifierConfig{}
+
+	for _, cfg := range cfg.Verifiers {
+		out.Circuits = append(out.Circuits, newRustCircuitConfig(cfg))
 	}
+	return out
 }
 
 type rustVkDump struct {
@@ -70,8 +74,10 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 		BundleVk:    make(map[string][]byte),
 	}
 
-	if err := v.loadOpenVMVks(cfg.HighVersionCircuit); err != nil {
-		return nil, err
+	for _, cfg := range cfg.Verifiers {
+		if err := v.loadOpenVMVks(cfg); err != nil {
+			return nil, err
+		}
 	}
 
 	return v, nil
@@ -124,9 +130,13 @@ func (v *Verifier) VerifyBundleProof(proof *message.OpenVMBundleProof, forkName
 // 	return base64.StdEncoding.EncodeToString(byt), nil
 // }
 
-func (v *Verifier) loadOpenVMVks(cfg *config.CircuitConfig) error {
+func (v *Verifier) loadOpenVMVks(cfg config.AssetConfig) error {
 
-	vkFile := path.Join(cfg.AssetsPath, "openVmVk.json")
+	vkFileName := cfg.Vkfile
+	if vkFileName == "" {
+		vkFileName = "openVmVk.json"
+	}
+	vkFile := path.Join(cfg.AssetsPath, vkFileName)
 
 	f, err := os.Open(filepath.Clean(vkFile))
 	if err != nil {

coordinator/test/api_test.go

@@ -85,11 +85,11 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 		ProverManager: &config.ProverManager{
 			ProversPerSession: proversPerSession,
 			Verifier: &config.VerifierConfig{
-				HighVersionCircuit: &config.CircuitConfig{
-					AssetsPath:       "",
-					ForkName:         "euclidV2",
-					MinProverVersion: "v4.4.89",
-				},
+				MinProverVersion: "v4.4.89",
+				Verifiers: []config.AssetConfig{{
+					AssetsPath: "",
+					ForkName:   "euclidV2",
+				}},
 			},
 			BatchCollectionTimeSec:  10,
 			ChunkCollectionTimeSec:  10,

crates/libzkp/src/verifier.rs

@@ -5,6 +5,7 @@ use euclidv2::EuclidV2Verifier;
 use eyre::Result;
 use serde::{Deserialize, Serialize};
 use std::{
+    collections::HashMap,
     path::Path,
     sync::{Arc, Mutex, OnceLock},
 };
@@ -46,36 +47,42 @@ pub struct CircuitConfig {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct VerifierConfig {
-    pub high_version_circuit: CircuitConfig,
+    pub circuits: Vec<CircuitConfig>,
 }
 
 type HardForkName = String;
 
-struct VerifierPair(HardForkName, Arc<Mutex<dyn ProofVerifier + Send>>);
-static VERIFIER_HIGH: OnceLock<VerifierPair> = OnceLock::new();
+type VerifierType = Arc<Mutex<dyn ProofVerifier + Send>>;
+static VERIFIERS: OnceLock<HashMap<HardForkName, VerifierType>> = OnceLock::new();
 
 pub fn init(config: VerifierConfig) {
-    let verifier = EuclidV2Verifier::new(&config.high_version_circuit.assets_path);
+    let mut verifiers: HashMap<HardForkName, VerifierType> = Default::default();
 
-    let ret = VERIFIER_HIGH
-        .set(VerifierPair(
-            config.high_version_circuit.fork_name.to_lowercase(),
-            Arc::new(Mutex::new(verifier)),
-        ))
-        .is_ok();
+    for cfg in &config.circuits {
+        let verifier = EuclidV2Verifier::new(&cfg.assets_path);
+        let ret = verifiers.insert(cfg.fork_name.to_lowercase(), Arc::new(Mutex::new(verifier)));
+        assert!(
+            ret.is_none(),
+            "DO NOT init the same fork {} twice",
+            cfg.fork_name
+        );
+        tracing::info!("load verifier config for fork {}", cfg.fork_name);
+    }
 
+    let ret = VERIFIERS.set(verifiers).is_ok();
     assert!(ret);
 }
 
 pub fn get_verifier(fork_name: &str) -> Result<Arc<Mutex<dyn ProofVerifier>>> {
-    if let Some(verifier) = VERIFIER_HIGH.get() {
-        if verifier.0 == fork_name {
-            return Ok(verifier.1.clone());
+    if let Some(verifiers) = VERIFIERS.get() {
+        if let Some(verifier) = verifiers.get(fork_name) {
+            return Ok(verifier.clone());
         }
+
         Err(eyre::eyre!(
-            "failed to get verifier, key not found: {}, expected {}",
+            "failed to get verifier, key not found: {}, has {:?}",
             fork_name,
-            verifier.0,
+            verifiers.keys().collect::<Vec<_>>(),
         ))
     } else {
         Err(eyre::eyre!(

zkvm-prover/config.json.template

@@ -26,7 +26,11 @@
   "circuits": {
     "euclidV2": {
       "hard_fork_name": "euclidV2",
-      "workspace_path": ".work"
-    }
+      "workspace_path": ".work/euclid"
+    },
+    "feynman": {
+      "hard_fork_name": "feynman",
+      "workspace_path": ".work/feynman1"
+    },    
   }
 }