Merge branch 'develop' of github.com:scroll-tech/scroll into develop

Co-authored-by: georgehao <georgehao@users.noreply.github.com>

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-db-cli.Dockerfile

@@ -15,7 +15,5 @@ RUN --mount=target=. \
 # Pull db_cli into a second stage deploy alpine container
 FROM alpine:latest
 COPY --from=builder /bin/db_cli /bin/
-RUN apk update && apk add ca-certificates
-RUN update-ca-certificates
 WORKDIR /app
 ENTRYPOINT ["db_cli"]

build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile

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

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.4.54"
+var tag = "v4.4.56"
 
 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,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,8 +38,12 @@ func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *Logi
 		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_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);

prover/src/zk_circuits_handler/darwin_v2.rs

@@ -46,54 +46,66 @@ 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> {
-        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,
-            }),
-        }
+        Self::new_multi(vec![prover_type], params_dir, assets_dir, geth_client)
     }
 
     fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
@@ -310,9 +322,14 @@ mod tests {
 
     #[test]
     fn test_circuits() -> Result<()> {
-        let chunk_handler =
-            DarwinV2Handler::new(ProverType::Chunk, &PARAMS_PATH, &ASSETS_PATH, None)?;
+        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");
@@ -336,8 +353,7 @@ mod tests {
             chunk_proofs.push(chunk_proof);
         }
 
-        let batch_handler =
-            DarwinV2Handler::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_traces, chunk_proofs, None);