Merge branch 'develop' into fix-override-config-private-key

build/dockerfiles/bridgehistoryapi-api.Dockerfile

@@ -17,7 +17,6 @@ RUN --mount=target=. \
 FROM ubuntu:20.04
 
 ENV CGO_LDFLAGS="-Wl,--no-as-needed -ldl"
-
 COPY --from=builder /bin/bridgehistoryapi-api /bin/
 WORKDIR /app
 ENTRYPOINT ["bridgehistoryapi-api"]

build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile

@@ -17,7 +17,8 @@ RUN --mount=target=. \
 FROM ubuntu:20.04
 
 ENV CGO_LDFLAGS="-Wl,--no-as-needed -ldl"
-
+RUN apt update && apt install ca-certificates -y
+RUN update-ca-certificates
 COPY --from=builder /bin/bridgehistoryapi-fetcher /bin/
 WORKDIR /app
 ENTRYPOINT ["bridgehistoryapi-fetcher"]

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.4.55"
+var tag = "v4.4.57"
 
 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)
 	}
 
-	hardForkName, err := a.loginLogic.ProverHardForkName(&login)
+	hardForkNames, 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:   hardForkName,
+		HardForkName:   hardForkNames,
 		LoginParameter: login,
 	}
 

coordinator/internal/logic/auth/login.go

@@ -25,21 +25,25 @@ 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,
 			"high verifier min_prover_version", cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion)
 		panic("verifier config file error")
 	}
 
-	proverVersionHardForkMap[cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion] = cfg.ProverManager.Verifier.LowVersionCircuit.ForkName
-	proverVersionHardForkMap[cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion] = cfg.ProverManager.Verifier.HighVersionCircuit.ForkName
+	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}
 
 	return &LoginLogic{
 		cfg:                      cfg,
@@ -113,8 +117,8 @@ func (l *LoginLogic) ProverHardForkName(login *types.LoginParameter) (string, er
 	}
 
 	proverVersion := proverVersionSplits[0]
-	if hardForkName, ok := l.proverVersionHardForkMap[proverVersion]; ok {
-		return hardForkName, nil
+	if hardForkNames, ok := l.proverVersionHardForkMap[proverVersion]; ok {
+		return strings.Join(hardForkNames, ","), nil
 	}
 
 	return "", fmt.Errorf("invalid prover prover_version:%s", login.Message.ProverVersion)

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -120,12 +120,14 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		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
-	}
+	//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
+	//}
 
 	proverTask := orm.ProverTask{
 		TaskID:          batchTask.Hash,

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -117,12 +117,14 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 		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
-	}
+	//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
+	//}
 
 	proverTask := orm.ProverTask{
 		TaskID:          bundleTask.Hash,

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -115,12 +115,14 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		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
-	}
+	//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
+	//}
 
 	proverTask := orm.ProverTask{
 		TaskID:          chunkTask.Hash,

coordinator/internal/logic/provertask/prover_task.go

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

coordinator/internal/logic/verifier/verifier.go

@@ -104,6 +104,8 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 	if err := v.loadLowVersionVKs(cfg); err != nil {
 		return nil, err
 	}
+
+	v.loadCurieVersionVKs()
 	return v, nil
 }
 
@@ -219,3 +221,8 @@ 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,10 +29,19 @@ func TestFFI(t *testing.T) {
 	as := assert.New(t)
 
 	cfg := &config.VerifierConfig{
-		MockMode:     false,
-		ParamsPath:   *paramsPath,
-		AssetsPathLo: *assetsPathLo,
-		AssetsPathHi: *assetsPathHi,
+		MockMode: false,
+		LowVersionCircuit: &config.CircuitConfig{
+			ParamsPath:       *paramsPath,
+			AssetsPath:       *assetsPathLo,
+			ForkName:         "darwin",
+			MinProverVersion: "",
+		},
+		HighVersionCircuit: &config.CircuitConfig{
+			ParamsPath:       *paramsPath,
+			AssetsPath:       *assetsPathHi,
+			ForkName:         "darwinV2",
+			MinProverVersion: "",
+		},
 	}
 
 	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.43",
-			Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MjQzODg4MTEsIm9yaWdfaWF0IjoxNzI0Mzg1MjExLCJyYW5kb20iOiItZ2UxTjhRc1NlTzhxRVdBTk5KWWtFVjU3ekhJX1JmTGw5Mjdkb2pMTm5JPSJ9.TmcRyXTyfCAHIk5WXdpShck0qUUesTDmi_0IhD87GmA",
+			ProverVersion: "v4.4.45-37af5ef5-38a68e2-1c5093c",
+			Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MjQ4Mzg0ODUsIm9yaWdfaWF0IjoxNzI0ODM0ODg1LCJyYW5kb20iOiJ6QmdNZGstNGc4UzNUNTFrVEFsYk1RTXg2TGJ4SUs4czY3ejM2SlNuSFlJPSJ9.x9PvihhNx2w4_OX5uCrv8QJCNYVQkIi-K2k8XFXYmik",
 			ProverTypes:   []ProverType{ProverTypeChunk},
 			VKs:           []string{"mock_vk"},
 		},

prover/src/types.rs

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

prover/src/zk_circuits_handler/darwin.rs

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