simplify coordinator

Author: colinlyguo

common/types/message/message.go

@@ -14,7 +14,6 @@ const (
 	EuclidFork   = "euclid"
 	EuclidV2Fork = "euclidV2"
 
-	EuclidForkNameForProver   = "euclidv1"
 	EuclidV2ForkNameForProver = "euclidv2"
 )
 
@@ -99,22 +98,22 @@ func (e *Byte48) UnmarshalJSON(input []byte) error {
 // BatchTaskDetail is a type containing BatchTask detail.
 type BatchTaskDetail struct {
 	// use one of the string of EuclidFork / EuclidV2Fork
-	ForkName        string       `json:"fork_name"`
-	ChunkInfos      []*ChunkInfo `json:"chunk_infos"`
-	ChunkProofs     []ChunkProof `json:"chunk_proofs"`
-	BatchHeader     interface{}  `json:"batch_header"`
-	BlobBytes       []byte       `json:"blob_bytes"`
-	KzgProof        Byte48       `json:"kzg_proof,omitempty"`
-	KzgCommitment   Byte48       `json:"kzg_commitment,omitempty"`
-	ChallengeDigest common.Hash  `json:"challenge_digest,omitempty"`
+	ForkName        string              `json:"fork_name"`
+	ChunkInfos      []*ChunkInfo        `json:"chunk_infos"`
+	ChunkProofs     []*OpenVMChunkProof `json:"chunk_proofs"`
+	BatchHeader     interface{}         `json:"batch_header"`
+	BlobBytes       []byte              `json:"blob_bytes"`
+	KzgProof        Byte48              `json:"kzg_proof,omitempty"`
+	KzgCommitment   Byte48              `json:"kzg_commitment,omitempty"`
+	ChallengeDigest common.Hash         `json:"challenge_digest,omitempty"`
 }
 
 // BundleTaskDetail consists of all the information required to describe the task to generate a proof for a bundle of batches.
 type BundleTaskDetail struct {
 	// use one of the string of EuclidFork / EuclidV2Fork
-	ForkName    string            `json:"fork_name"`
-	BatchProofs []BatchProof      `json:"batch_proofs"`
-	BundleInfo  *OpenVMBundleInfo `json:"bundle_info,omitempty"`
+	ForkName    string              `json:"fork_name"`
+	BatchProofs []*OpenVMBatchProof `json:"batch_proofs"`
+	BundleInfo  *OpenVMBundleInfo   `json:"bundle_info,omitempty"`
 }
 
 // ChunkInfo is for calculating pi_hash for chunk
@@ -143,157 +142,6 @@ type BlockContextV2 struct {
 	NumL1Msgs uint16      `json:"num_l1_msgs"`
 }
 
-// SubCircuitRowUsage tracing info added in v0.11.0rc8
-type SubCircuitRowUsage struct {
-	Name      string `json:"name"`
-	RowNumber uint64 `json:"row_number"`
-}
-
-// ChunkProof
-type ChunkProof interface {
-	Proof() []byte
-}
-
-// NewChunkProof creates a new ChunkProof instance.
-func NewChunkProof(hardForkName string) ChunkProof {
-	switch hardForkName {
-	case EuclidFork, EuclidV2Fork:
-		return &OpenVMChunkProof{}
-	default:
-		return &Halo2ChunkProof{}
-	}
-}
-
-// Halo2ChunkProof includes the proof info that are required for chunk verification and rollup.
-type Halo2ChunkProof struct {
-	StorageTrace []byte `json:"storage_trace,omitempty"`
-	Protocol     []byte `json:"protocol"`
-	RawProof     []byte `json:"proof"`
-	Instances    []byte `json:"instances"`
-	Vk           []byte `json:"vk"`
-	// cross-reference between cooridinator computation and prover compution
-	ChunkInfo  *ChunkInfo           `json:"chunk_info,omitempty"`
-	GitVersion string               `json:"git_version,omitempty"`
-	RowUsages  []SubCircuitRowUsage `json:"row_usages,omitempty"`
-}
-
-// Proof returns the proof bytes of a ChunkProof
-func (ap *Halo2ChunkProof) Proof() []byte {
-	return ap.RawProof
-}
-
-// BatchProof
-type BatchProof interface {
-	SanityCheck() error
-	Proof() []byte
-}
-
-// NewBatchProof creates a new BatchProof instance.
-func NewBatchProof(hardForkName string) BatchProof {
-	switch hardForkName {
-	case EuclidFork, EuclidV2Fork:
-		return &OpenVMBatchProof{}
-	default:
-		return &Halo2BatchProof{}
-	}
-}
-
-// Halo2BatchProof includes the proof info that are required for batch verification and rollup.
-type Halo2BatchProof struct {
-	Protocol  []byte `json:"protocol"`
-	RawProof  []byte `json:"proof"`
-	Instances []byte `json:"instances"`
-	Vk        []byte `json:"vk"`
-	// cross-reference between cooridinator computation and prover compution
-	BatchHash  common.Hash `json:"batch_hash"`
-	GitVersion string      `json:"git_version,omitempty"`
-}
-
-// Proof returns the proof bytes of a BatchProof
-func (ap *Halo2BatchProof) Proof() []byte {
-	return ap.RawProof
-}
-
-// SanityCheck checks whether a BatchProof is in a legal format
-func (ap *Halo2BatchProof) SanityCheck() error {
-	if ap == nil {
-		return errors.New("agg_proof is nil")
-	}
-
-	if len(ap.RawProof) == 0 {
-		return errors.New("proof not ready")
-	}
-
-	if len(ap.RawProof)%32 != 0 {
-		return fmt.Errorf("proof buffer length must be a multiple of 32, got: %d", len(ap.RawProof))
-	}
-
-	if len(ap.Instances) == 0 {
-		return errors.New("instance not ready")
-	}
-
-	if len(ap.Vk) == 0 {
-		return errors.New("vk not ready")
-	}
-
-	return nil
-}
-
-// BundleProof
-type BundleProof interface {
-	SanityCheck() error
-	Proof() []byte
-}
-
-// NewBundleProof creates a new BundleProof instance.
-func NewBundleProof(hardForkName string) BundleProof {
-	switch hardForkName {
-	case EuclidFork, EuclidV2Fork:
-		return &OpenVMBundleProof{}
-	default:
-		return &Halo2BundleProof{}
-	}
-}
-
-// BundleProof includes the proof info that are required for verification of a bundle of batch proofs.
-type Halo2BundleProof struct {
-	RawProof  []byte `json:"proof"`
-	Instances []byte `json:"instances"`
-	Vk        []byte `json:"vk"`
-	// cross-reference between cooridinator computation and prover compution
-	GitVersion string `json:"git_version,omitempty"`
-}
-
-// Proof returns the proof bytes of a BundleProof
-func (ap *Halo2BundleProof) Proof() []byte {
-	return ap.RawProof
-}
-
-// SanityCheck checks whether a BundleProof is in a legal format
-func (ap *Halo2BundleProof) SanityCheck() error {
-	if ap == nil {
-		return errors.New("agg_proof is nil")
-	}
-
-	if len(ap.RawProof) == 0 {
-		return errors.New("proof not ready")
-	}
-
-	if len(ap.RawProof)%32 != 0 {
-		return fmt.Errorf("proof buffer length must be a multiple of 32, got: %d", len(ap.RawProof))
-	}
-
-	if len(ap.Instances) == 0 {
-		return errors.New("instance not ready")
-	}
-
-	if len(ap.Vk) == 0 {
-		return errors.New("vk not ready")
-	}
-
-	return nil
-}
-
 // Proof for flatten VM proof
 type OpenVMProof struct {
 	Proof        []byte `json:"proofs"`

coordinator/cmd/api/app/mock_app.go

@@ -90,13 +90,6 @@ func (c *CoordinatorApp) MockConfig(store bool) error {
 	cfg.ProverManager = &coordinatorConfig.ProverManager{
 		ProversPerSession: 1,
 		Verifier: &coordinatorConfig.VerifierConfig{
-			MockMode: true,
-			LowVersionCircuit: &coordinatorConfig.CircuitConfig{
-				ParamsPath:       "",
-				AssetsPath:       "",
-				ForkName:         "darwin",
-				MinProverVersion: "v4.4.57",
-			},
 			HighVersionCircuit: &coordinatorConfig.CircuitConfig{
 				ParamsPath:       "",
 				AssetsPath:       "",

coordinator/cmd/tool/tool.go

@@ -62,9 +62,9 @@ func action(ctx *cli.Context) error {
 		return fmt.Errorf("failed to get batch proofs for bundle task id:%s, no batch found", taskID)
 	}
 
-	var batchProofs []message.BatchProof
+	var batchProofs []*message.OpenVMBatchProof
 	for _, batch := range batches {
-		proof := message.NewBatchProof("darwinV2")
+		proof := &message.OpenVMBatchProof{}
 		if encodeErr := json.Unmarshal(batch.Proof, &proof); encodeErr != nil {
 			log.Error("failed to unmarshal batch proof")
 			return fmt.Errorf("failed to unmarshal proof: %w, bundle hash: %v, batch hash: %v", encodeErr, taskID, batch.Hash)

coordinator/conf/config.json

@@ -7,13 +7,6 @@
     "batch_collection_time_sec": 180,
     "chunk_collection_time_sec": 180,
     "verifier": {
-      "mock_mode": true,
-      "low_version_circuit": {
-        "params_path": "params",
-        "assets_path": "assets",
-        "fork_name": "darwin",
-        "min_prover_version": "v4.4.43"
-      },
       "high_version_circuit": {
         "params_path": "params",
         "assets_path": "assets",

coordinator/internal/config/config.go

@@ -59,8 +59,6 @@ type CircuitConfig struct {
 
 // VerifierConfig load zk verifier config.
 type VerifierConfig struct {
-	MockMode           bool           `json:"mock_mode"`
-	LowVersionCircuit  *CircuitConfig `json:"low_version_circuit"`
 	HighVersionCircuit *CircuitConfig `json:"high_version_circuit"`
 }
 

coordinator/internal/controller/api/controller.go

@@ -26,7 +26,7 @@ func InitController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.D
 		panic("proof receiver new verifier failure")
 	}
 
-	log.Info("verifier created", "chunkVerifier", vf.ChunkVKMap, "batchVerifier", vf.BatchVKMap, "bundleVerifier", vf.BundleVkMap, "openVmVerifier", vf.OpenVMVkMap)
+	log.Info("verifier created", "openVmVerifier", vf.OpenVMVkMap)
 
 	Auth = NewAuthController(db, cfg, vf)
 	GetTask = NewGetTaskController(cfg, chainCfg, db, reg)

coordinator/internal/logic/auth/login.go

@@ -22,9 +22,6 @@ import (
 type LoginLogic struct {
 	cfg          *config.Config
 	challengeOrm *orm.Challenge
-	chunkVks     map[string]struct{}
-	batchVKs     map[string]struct{}
-	bundleVks    map[string]struct{}
 
 	openVmVks map[string]struct{}
 
@@ -34,28 +31,14 @@ type LoginLogic struct {
 // NewLoginLogic new a LoginLogic
 func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *LoginLogic {
 	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")
-	}
 
 	var highHardForks []string
 	highHardForks = append(highHardForks, cfg.ProverManager.Verifier.HighVersionCircuit.ForkName)
-	if cfg.ProverManager.Verifier.HighVersionCircuit.ForkName != message.EuclidFork && cfg.ProverManager.Verifier.HighVersionCircuit.ForkName != message.EuclidV2Fork {
-		highHardForks = append(highHardForks, cfg.ProverManager.Verifier.LowVersionCircuit.ForkName)
-	}
 	highHardForks = append(highHardForks, message.EuclidFork, message.EuclidV2Fork)
 	proverVersionHardForkMap[cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion] = highHardForks
 
-	proverVersionHardForkMap[cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion] = []string{cfg.ProverManager.Verifier.LowVersionCircuit.ForkName}
-
 	return &LoginLogic{
 		cfg:                      cfg,
-		chunkVks:                 vf.ChunkVKMap,
-		batchVKs:                 vf.BatchVKMap,
-		bundleVks:                vf.BundleVkMap,
 		openVmVks:                vf.OpenVMVkMap,
 		challengeOrm:             orm.NewChallenge(db),
 		proverVersionHardForkMap: proverVersionHardForkMap,
@@ -75,49 +58,25 @@ func (l *LoginLogic) Check(login *types.LoginParameter) error {
 		return errors.New("auth message verify failure")
 	}
 
-	// FIXME: for backward compatibility, set prover version as darwin prover version,
-	// change v4.4.56 to l.cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion after Euclid upgrade, including the log.
-	// hardcode the prover version because l.cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion is used in another check and should be set as v4.4.89 for darwinV2 provers.
-	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, "v4.4.56") {
-		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s",
-			"v4.4.56", login.Message.ProverVersion)
+	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 len(login.Message.ProverTypes) > 0 {
-		vks := make(map[string]struct{})
-		for _, proverType := range login.Message.ProverTypes {
-			switch proverType {
-			case types.ProverTypeChunk:
-				for vk := range l.chunkVks {
-					vks[vk] = struct{}{}
-				}
-			case types.ProverTypeBatch:
-				for vk := range l.batchVKs {
-					vks[vk] = struct{}{}
-				}
-				for vk := range l.bundleVks {
-					vks[vk] = struct{}{}
-				}
-			case types.ProverTypeOpenVM:
-				for vk := range l.openVmVks {
-					vks[vk] = struct{}{}
-				}
-			default:
-				log.Error("invalid prover_type", "value", proverType, "prover name", login.Message.ProverName, "prover_version", login.Message.ProverVersion)
-			}
-		}
+	vks := make(map[string]struct{})
+	for vk := range l.openVmVks {
+		vks[vk] = struct{}{}
+	}
 
-		for _, vk := range login.Message.VKs {
-			if _, ok := vks[vk]; !ok {
-				log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
-					"prover_version", login.Message.ProverVersion, "message", login.Message)
-				if !version.CheckScrollProverVersion(login.Message.ProverVersion) {
-					return fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s",
-						version.Version, login.Message.ProverVersion)
-				}
-				// if the prover reports a same prover version
-				return errors.New("incompatible vk. please check your params files or config files")
+	for _, vk := range login.Message.VKs {
+		if _, ok := vks[vk]; !ok {
+			log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
+				"prover_version", login.Message.ProverVersion, "message", login.Message)
+			if !version.CheckScrollProverVersion(login.Message.ProverVersion) {
+				return fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s",
+					version.Version, login.Message.ProverVersion)
 			}
+			// if the prover reports a same prover version
+			return errors.New("incompatible vk. please check your params files or config files")
 		}
 	}
 
@@ -142,12 +101,6 @@ func (l *LoginLogic) ProverHardForkName(login *types.LoginParameter) (string, er
 	}
 
 	proverVersion := proverVersionSplits[0]
-
-	// allowing darwin provers to login, because darwin provers can prove darwinV2 chunk tasks
-	if proverVersion == "v4.4.56" {
-		return "darwin", nil
-	}
-
 	if hardForkNames, ok := l.proverVersionHardForkMap[proverVersion]; ok {
 		return strings.Join(hardForkNames, ","), nil
 	}