fix ci bridgehistoryapi-api.Dockerfile

common/version/version.go

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

coordinator/internal/controller/api/auth.go

@@ -44,7 +44,7 @@ func (a *AuthController) Login(c *gin.Context) (interface{}, error) {
 		return "", fmt.Errorf("check the login parameter failure: %w", err)
 	}
 
-	hardForkNames, err := a.loginLogic.ProverHardForkName(&login)
+	hardForkName, err := a.loginLogic.ProverHardForkName(&login)
 	if err != nil {
 		return "", fmt.Errorf("prover hard name failure:%w", err)
 	}
@@ -55,7 +55,7 @@ func (a *AuthController) Login(c *gin.Context) (interface{}, error) {
 	}
 
 	returnData := types.LoginParameterWithHardForkName{
-		HardForkName:   hardForkNames,
+		HardForkName:   hardForkName,
 		LoginParameter: login,
 	}
 

coordinator/internal/logic/auth/login.go

@@ -25,12 +25,12 @@ type LoginLogic struct {
 	batchVKs     map[string]struct{}
 	bundleVks    map[string]struct{}
 
-	proverVersionHardForkMap map[string][]string
+	proverVersionHardForkMap map[string]string
 }
 
 // NewLoginLogic new a LoginLogic
 func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *LoginLogic {
-	proverVersionHardForkMap := make(map[string][]string)
+	proverVersionHardForkMap := make(map[string]string)
 	if version.CheckScrollRepoVersion(cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion) {
 		log.Error("config file error, low verifier min_prover_version should not more than high verifier min_prover_version",
 			"low verifier min_prover_version", cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion,
@@ -38,12 +38,8 @@ func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *Logi
 		panic("verifier config file error")
 	}
 
-	var highHardForks []string
-	highHardForks = append(highHardForks, cfg.ProverManager.Verifier.HighVersionCircuit.ForkName)
-	highHardForks = append(highHardForks, cfg.ProverManager.Verifier.LowVersionCircuit.ForkName)
-	proverVersionHardForkMap[cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion] = highHardForks
-
-	proverVersionHardForkMap[cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion] = []string{cfg.ProverManager.Verifier.LowVersionCircuit.ForkName}
+	proverVersionHardForkMap[cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion] = cfg.ProverManager.Verifier.LowVersionCircuit.ForkName
+	proverVersionHardForkMap[cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion] = cfg.ProverManager.Verifier.HighVersionCircuit.ForkName
 
 	return &LoginLogic{
 		cfg:                      cfg,
@@ -117,8 +113,8 @@ func (l *LoginLogic) ProverHardForkName(login *types.LoginParameter) (string, er
 	}
 
 	proverVersion := proverVersionSplits[0]
-	if hardForkNames, ok := l.proverVersionHardForkMap[proverVersion]; ok {
-		return strings.Join(hardForkNames, ","), nil
+	if hardForkName, ok := l.proverVersionHardForkMap[proverVersion]; ok {
+		return hardForkName, nil
 	}
 
 	return "", fmt.Errorf("invalid prover prover_version:%s", login.Message.ProverVersion)

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -120,14 +120,12 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	//if _, ok := taskCtx.HardForkNames[hardForkName]; !ok {
-	//	bp.recoverActiveAttempts(ctx, batchTask)
-	//	log.Error("incompatible prover version",
-	//		"requisite hard fork name", hardForkName,
-	//		"prover hard fork name", taskCtx.HardForkNames,
-	//		"task_id", batchTask.Hash)
-	//	return nil, ErrCoordinatorInternalFailure
-	//}
+	if hardForkName != taskCtx.HardForkName {
+		bp.recoverActiveAttempts(ctx, batchTask)
+		log.Error("incompatible prover version. requisite hard fork name:%s, prover hard fork name:%s, batch task_id:%s",
+			hardForkName, taskCtx.HardForkName, "task_id", batchTask.Hash)
+		return nil, ErrCoordinatorInternalFailure
+	}
 
 	proverTask := orm.ProverTask{
 		TaskID:          batchTask.Hash,

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -117,14 +117,12 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	//if _, ok := taskCtx.HardForkNames[hardForkName]; !ok {
-	//	bp.recoverActiveAttempts(ctx, bundleTask)
-	//	log.Error("incompatible prover version",
-	//		"requisite hard fork name", hardForkName,
-	//		"prover hard fork name", taskCtx.HardForkNames,
-	//		"task_id", bundleTask.Hash)
-	//	return nil, ErrCoordinatorInternalFailure
-	//}
+	if hardForkName != taskCtx.HardForkName {
+		bp.recoverActiveAttempts(ctx, bundleTask)
+		log.Error("incompatible prover version. requisite hard fork name:%s, prover hard fork name:%s, bundle task_id:%s",
+			hardForkName, taskCtx.HardForkName, "task_id", bundleTask.Hash)
+		return nil, ErrCoordinatorInternalFailure
+	}
 
 	proverTask := orm.ProverTask{
 		TaskID:          bundleTask.Hash,

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -115,14 +115,12 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	//if _, ok := taskCtx.HardForkNames[hardForkName]; !ok {
-	//	cp.recoverActiveAttempts(ctx, chunkTask)
-	//	log.Error("incompatible prover version",
-	//		"requisite hard fork name", hardForkName,
-	//		"prover hard fork name", taskCtx.HardForkNames,
-	//		"task_id", chunkTask.Hash)
-	//	return nil, ErrCoordinatorInternalFailure
-	//}
+	if hardForkName != taskCtx.HardForkName {
+		cp.recoverActiveAttempts(ctx, chunkTask)
+		log.Error("incompatible prover version. requisite hard fork name:%s, prover hard fork name:%s, chunk task_id:%s",
+			hardForkName, taskCtx.HardForkName, "task_id", chunkTask.Hash)
+		return nil, ErrCoordinatorInternalFailure
+	}
 
 	proverTask := orm.ProverTask{
 		TaskID:          chunkTask.Hash,

coordinator/internal/logic/provertask/prover_task.go

@@ -3,7 +3,6 @@ package provertask
 import (
 	"errors"
 	"fmt"
-	"strings"
 	"sync"
 
 	"github.com/gin-gonic/gin"
@@ -50,13 +49,12 @@ type proverTaskContext struct {
 	PublicKey     string
 	ProverName    string
 	ProverVersion string
-	HardForkNames map[string]struct{}
+	HardForkName  string
 }
 
 // checkParameter check the prover task parameter illegal
 func (b *BaseProverTask) checkParameter(ctx *gin.Context) (*proverTaskContext, error) {
 	var ptc proverTaskContext
-	ptc.HardForkNames = make(map[string]struct{})
 
 	publicKey, publicKeyExist := ctx.Get(coordinatorType.PublicKey)
 	if !publicKeyExist {
@@ -76,14 +74,11 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context) (*proverTaskContext, e
 	}
 	ptc.ProverVersion = proverVersion.(string)
 
-	hardForkNamesStr, hardForkNameExist := ctx.Get(coordinatorType.HardForkName)
+	hardForkName, hardForkNameExist := ctx.Get(coordinatorType.HardForkName)
 	if !hardForkNameExist {
 		return nil, errors.New("get hard fork name from context failed")
 	}
-	hardForkNames := strings.Split(hardForkNamesStr.(string), ",")
-	for _, hardForkName := range hardForkNames {
-		ptc.HardForkNames[hardForkName] = struct{}{}
-	}
+	ptc.HardForkName = hardForkName.(string)
 
 	isBlocked, err := b.proverBlockListOrm.IsPublicKeyBlocked(ctx.Copy(), publicKey.(string))
 	if err != nil {

coordinator/internal/logic/verifier/verifier.go

@@ -104,8 +104,6 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 	if err := v.loadLowVersionVKs(cfg); err != nil {
 		return nil, err
 	}
-
-	v.loadCurieVersionVKs()
 	return v, nil
 }
 
@@ -221,8 +219,3 @@ func (v *Verifier) loadLowVersionVKs(cfg *config.VerifierConfig) error {
 	v.ChunkVKMap[chunkVK] = struct{}{}
 	return nil
 }
-
-func (v *Verifier) loadCurieVersionVKs() {
-	v.BatchVKMap["AAAAGgAAAARX2S0K1wF333B1waOsnG/vcASJmWG9YM6SNWCBy1ywD9jfGkei+f0wNYpkjW7JO12EfU7CjYVBo+PGku3zaQJI64lbn6BwyTBa4RfrPFpV5mP47ix0sXZ+Wt5wklMLRW7OIJb1yfCDm+gkSsp3/Zqrxt4SY4rQ4WtHfynTCQ0KDi78jNuiFvwxO3ub3DkgGVaxMkGxTRP/Vz6E7MCZMUBR5wZFcMzJn+73f0wYjDxfj00krg9O1VrwVxbVV1ycLR6oQLcOgm/l+xwth8io0vDpF9OY21gD5DgJn9GgcYe8KoRVEbEqApLZPdBibpcSMTY9czZI2LnFcqrDDmYvhEwgjhZrsTog2xLXOODoOupZ/is5ekQ9Gi0y871b1mLlCGA="] = struct{}{}
-	v.ChunkVKMap["AAAAGQAAAATyWEABRbJ6hQQ5/zLX1gTasr7349minA9rSgMS6gDeHwZKqikRiO3md+pXjjxMHnKQtmXYgMXhJSvlmZ+Ws+cheuly2X1RuNQzcZuRImaKPR9LJsVZYsXfJbuqdKX8p0Gj8G83wMJOmTzNVUyUol0w0lTU+CEiTpHOnxBsTF3EWaW3s1u4ycOgWt1c9M6s7WmaBZLYgAWYCunO5CLCLApNGbCASeck/LuSoedEri5u6HccCKU2khG6zl6W07jvYSbDVLJktbjRiHv+/HQix+K14j8boo8Z/unhpwXCsPxkQA=="] = struct{}{}
-}

coordinator/internal/logic/verifier/verifier_test.go

@@ -29,19 +29,10 @@ func TestFFI(t *testing.T) {
 	as := assert.New(t)
 
 	cfg := &config.VerifierConfig{
-		MockMode: false,
-		LowVersionCircuit: &config.CircuitConfig{
-			ParamsPath:       *paramsPath,
-			AssetsPath:       *assetsPathLo,
-			ForkName:         "darwin",
-			MinProverVersion: "",
-		},
-		HighVersionCircuit: &config.CircuitConfig{
-			ParamsPath:       *paramsPath,
-			AssetsPath:       *assetsPathHi,
-			ForkName:         "darwinV2",
-			MinProverVersion: "",
-		},
+		MockMode:     false,
+		ParamsPath:   *paramsPath,
+		AssetsPathLo: *assetsPathLo,
+		AssetsPathHi: *assetsPathHi,
 	}
 
 	v, err := NewVerifier(cfg)

coordinator/internal/types/auth_test.go

@@ -60,8 +60,8 @@ func TestGenerateSignature(t *testing.T) {
 	authMsg := LoginParameter{
 		Message: Message{
 			ProverName:    "test",
-			ProverVersion: "v4.4.45-37af5ef5-38a68e2-1c5093c",
-			Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MjQ4Mzg0ODUsIm9yaWdfaWF0IjoxNzI0ODM0ODg1LCJyYW5kb20iOiJ6QmdNZGstNGc4UzNUNTFrVEFsYk1RTXg2TGJ4SUs4czY3ejM2SlNuSFlJPSJ9.x9PvihhNx2w4_OX5uCrv8QJCNYVQkIi-K2k8XFXYmik",
+			ProverVersion: "v4.4.43",
+			Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MjQzODg4MTEsIm9yaWdfaWF0IjoxNzI0Mzg1MjExLCJyYW5kb20iOiItZ2UxTjhRc1NlTzhxRVdBTk5KWWtFVjU3ekhJX1JmTGw5Mjdkb2pMTm5JPSJ9.TmcRyXTyfCAHIk5WXdpShck0qUUesTDmi_0IhD87GmA",
 			ProverTypes:   []ProverType{ProverTypeChunk},
 			VKs:           []string{"mock_vk"},
 		},

prover/src/types.rs

@@ -54,7 +54,7 @@ impl Default for TaskType {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ProverType {
     Chunk,
     Batch,

prover/src/zk_circuits_handler/darwin.rs

@@ -46,24 +46,16 @@ pub struct DarwinHandler {
 }
 
 impl DarwinHandler {
-    pub fn new_multi(
-        prover_types: Vec<ProverType>,
+    pub fn new(
+        prover_type: 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,
-        };
-        for prover_type in prover_types_set {
-            match prover_type {
-                ProverType::Chunk => {
+        match prover_type {
+            ProverType::Chunk => Ok(Self {
+                chunk_prover: {
                     let degrees = prover_darwin::config::ZKEVM_DEGREES.clone();
                     let params_map = super::common::get_params_map(|| {
                         log::info!(
@@ -74,12 +66,16 @@ impl DarwinHandler {
                         );
                         CommonProver::load_params_map(params_dir, &degrees)
                     });
-                    handler.chunk_prover = Some(RefCell::new(ChunkProver::from_params_and_assets(
+                    Some(RefCell::new(ChunkProver::from_params_and_assets(
                         params_map, assets_dir,
-                    )));
-                }
+                    )))
+                },
+                batch_prover: None,
+                geth_client,
+            }),
 
-                ProverType::Batch => {
+            ProverType::Batch => Ok(Self {
+                batch_prover: {
                     let degrees = prover_darwin::config::AGG_DEGREES.clone();
                     let params_map = super::common::get_params_map(|| {
                         log::info!(
@@ -90,22 +86,14 @@ impl DarwinHandler {
                         );
                         CommonProver::load_params_map(params_dir, &degrees)
                     });
-                    handler.batch_prover = Some(RefCell::new(BatchProver::from_params_and_assets(
+                    Some(RefCell::new(BatchProver::from_params_and_assets(
                         params_map, assets_dir,
                     )))
-                }
-            }
+                },
+                chunk_prover: None,
+                geth_client,
+            }),
         }
-        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> {
@@ -318,14 +306,9 @@ mod tests {
 
     #[test]
     fn test_circuits() -> Result<()> {
-        let bi_handler = DarwinHandler::new_multi(
-            vec![ProverType::Chunk, ProverType::Batch],
-            &PARAMS_PATH,
-            &ASSETS_PATH,
-            None,
-        )?;
+        let chunk_handler =
+            DarwinHandler::new(ProverType::Chunk, &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");
@@ -348,7 +331,8 @@ mod tests {
             chunk_proofs.push(chunk_proof);
         }
 
-        let batch_handler = chunk_handler;
+        let batch_handler =
+            DarwinHandler::new(ProverType::Batch, &PARAMS_PATH, &ASSETS_PATH, None)?;
         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);

prover/src/zk_circuits_handler/darwin_v2.rs

@@ -46,66 +46,54 @@ pub struct DarwinV2Handler {
 }
 
 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,
-        };
-        for prover_type in prover_types_set {
-            match prover_type {
-                ProverType::Chunk => {
-                    let degrees = prover_darwin::config::ZKEVM_DEGREES.clone();
-                    let params_map = super::common::get_params_map(|| {
-                        log::info!(
-                            "calling get_params_map from {}, prover_type: {:?}, degrees: {:?}",
-                            class_name,
-                            prover_type,
-                            degrees
-                        );
-                        CommonProver::load_params_map(params_dir, &degrees)
-                    });
-                    handler.chunk_prover = Some(RefCell::new(ChunkProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )));
-                }
-
-                ProverType::Batch => {
-                    let degrees = prover_darwin::config::AGG_DEGREES.clone();
-                    let params_map = super::common::get_params_map(|| {
-                        log::info!(
-                            "calling get_params_map from {}, prover_type: {:?}, degrees: {:?}",
-                            class_name,
-                            prover_type,
-                            degrees
-                        );
-                        CommonProver::load_params_map(params_dir, &degrees)
-                    });
-                    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)
+        let class_name = std::intrinsics::type_name::<Self>();
+        match prover_type {
+            ProverType::Chunk => Ok(Self {
+                chunk_prover: {
+                    let degrees = prover_darwin_v2::config::ZKEVM_DEGREES.clone();
+                    let params_map = super::common::get_params_map(|| {
+                        log::info!(
+                            "calling get_params_map from {}, prover_type: {:?}, degrees: {:?}",
+                            class_name,
+                            prover_type,
+                            degrees
+                        );
+                        CommonProver::load_params_map(params_dir, &degrees)
+                    });
+                    Some(RefCell::new(ChunkProver::from_params_and_assets(
+                        params_map, assets_dir,
+                    )))
+                },
+                batch_prover: None,
+                geth_client,
+            }),
+
+            ProverType::Batch => Ok(Self {
+                batch_prover: {
+                    let degrees = prover_darwin_v2::config::AGG_DEGREES.clone();
+                    let params_map = super::common::get_params_map(|| {
+                        log::info!(
+                            "calling get_params_map from {}, prover_type: {:?}, degrees: {:?}",
+                            class_name,
+                            prover_type,
+                            degrees
+                        );
+                        CommonProver::load_params_map(params_dir, &degrees)
+                    });
+                    Some(RefCell::new(BatchProver::from_params_and_assets(
+                        params_map, assets_dir,
+                    )))
+                },
+                chunk_prover: None,
+                geth_client,
+            }),
+        }
     }
 
     fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
@@ -322,14 +310,9 @@ mod tests {
 
     #[test]
     fn test_circuits() -> Result<()> {
-        let bi_handler = DarwinV2Handler::new_multi(
-            vec![ProverType::Chunk, ProverType::Batch],
-            &PARAMS_PATH,
-            &ASSETS_PATH,
-            None,
-        )?;
+        let chunk_handler =
+            DarwinV2Handler::new(ProverType::Chunk, &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");
@@ -353,7 +336,8 @@ mod tests {
             chunk_proofs.push(chunk_proof);
         }
 
-        let batch_handler = chunk_handler;
+        let batch_handler =
+            DarwinV2Handler::new(ProverType::Batch, &PARAMS_PATH, &ASSETS_PATH, None)?;
         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);