fix login

coordinator/internal/controller/api/auth.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"errors"
 	"fmt"
 
 	jwt "github.com/appleboy/gin-jwt/v2"
@@ -36,7 +37,11 @@ func (a *AuthController) Login(c *gin.Context) (interface{}, error) {
 	// if not exist, the jwt token will intercept it
 	brearToken := c.GetHeader("Authorization")
 	if brearToken != "Bearer "+login.Message.Challenge {
-		return "", fmt.Errorf("check challenge failure for the not equal challenge string")
+		return "", errors.New("check challenge failure for the not equal challenge string")
+	}
+
+	if err := a.loginLogic.Check(&login); err != nil {
+		return "", fmt.Errorf("check the login parameter failure: %w", err)
 	}
 
 	// check the challenge is used, if used, return failure

coordinator/internal/controller/api/controller.go

@@ -30,5 +30,5 @@ func InitController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.D
 
 	Auth = NewAuthController(db, cfg, vf)
 	GetTask = NewGetTaskController(cfg, chainCfg, db, reg)
-	SubmitProof = NewSubmitProofController(cfg, db, vf, reg)
+	SubmitProof = NewSubmitProofController(cfg, chainCfg, db, vf, reg)
 }

coordinator/internal/controller/api/submit_proof.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
 	"scroll-tech/common/types"
@@ -20,9 +21,9 @@ type SubmitProofController struct {
 }
 
 // NewSubmitProofController create the submit proof api controller instance
-func NewSubmitProofController(cfg *config.Config, db *gorm.DB, vf *verifier.Verifier, reg prometheus.Registerer) *SubmitProofController {
+func NewSubmitProofController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, vf *verifier.Verifier, reg prometheus.Registerer) *SubmitProofController {
 	return &SubmitProofController{
-		submitProofReceiverLogic: submitproof.NewSubmitProofReceiverLogic(cfg.ProverManager, db, vf, reg),
+		submitProofReceiverLogic: submitproof.NewSubmitProofReceiverLogic(cfg.ProverManager, chainCfg, db, vf, reg),
 	}
 }
 

coordinator/internal/logic/auth/login.go

@@ -16,6 +16,12 @@ import (
 	"scroll-tech/coordinator/internal/types"
 )
 
+var (
+	proofChunkTypeString  = fmt.Sprintf("%d", message.ProofTypeChunk)
+	proofBatchTypeString  = fmt.Sprintf("%d", message.ProofTypeBatch)
+	proofBundleTypeString = fmt.Sprintf("%d", message.ProofTypeBundle)
+)
+
 // LoginLogic the auth logic
 type LoginLogic struct {
 	cfg          *config.Config
@@ -29,6 +35,9 @@ type LoginLogic struct {
 func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *LoginLogic {
 	l := &LoginLogic{
 		cfg:          cfg,
+		chunkVks:     make(map[string]struct{}),
+		batchVKs:     make(map[string]struct{}),
+		bundleVks:    make(map[string]struct{}),
 		challengeOrm: orm.NewChallenge(db),
 	}
 
@@ -65,34 +74,36 @@ func (l *LoginLogic) Check(login *types.LoginParameter) error {
 			l.cfg.ProverManager.MinProverVersion, login.Message.ProverVersion)
 	}
 
-	var vks map[string]struct{}
-	for _, proverType := range login.Message.ProverTypes {
-		if message.ProofType(proverType) == message.ProofTypeChunk {
-			for vk := range l.chunkVks {
-				vks[vk] = struct{}{}
+	if len(login.Message.ProverTypes) > 0 {
+		vks := make(map[string]struct{})
+		for _, proverType := range login.Message.ProverTypes {
+			if proverType == proofChunkTypeString {
+				for vk := range l.chunkVks {
+					vks[vk] = struct{}{}
+				}
 			}
-		}
-		if message.ProofType(proverType) == message.ProofTypeBatch {
-			for vk := range l.batchVKs {
-				vks[vk] = struct{}{}
+			if proverType == proofBatchTypeString {
+				for vk := range l.batchVKs {
+					vks[vk] = struct{}{}
+				}
 			}
-		}
-		if message.ProofType(proverType) == message.ProofTypeBundle {
-			for vk := range l.bundleVks {
-				vks[vk] = struct{}{}
+			if proverType == proofBundleTypeString {
+				for vk := range l.bundleVks {
+					vks[vk] = struct{}{}
+				}
 			}
 		}
-	}
 
-	for _, vk := range login.Message.VKs {
-		if _, ok := vks[vk]; !ok {
-			log.Error("vk inconsistency", "prover vk", vk)
-			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)
+		for _, vk := range login.Message.VKs {
+			if _, ok := vks[vk]; !ok {
+				log.Error("vk inconsistency", "prover vk", vk)
+				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 fmt.Errorf("incompatible vk. please check your params files or config files")
 			}
-			// if the prover reports a same prover version
-			return fmt.Errorf("incompatible vk. please check your params files or config files")
 		}
 	}
 	return nil

coordinator/internal/logic/verifier/mock.go

@@ -10,24 +10,8 @@ import (
 
 // NewVerifier Sets up a mock verifier.
 func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
-	batchVKMap := map[string]string{
-		"shanghai":  "",
-		"bernoulli": "",
-		"london":    "",
-		"istanbul":  "",
-		"homestead": "",
-		"eip155":    "",
-	}
-	chunkVKMap := map[string]string{
-		"shanghai":  "",
-		"bernoulli": "",
-		"london":    "",
-		"istanbul":  "",
-		"homestead": "",
-		"eip155":    "",
-	}
-	batchVKMap[cfg.ForkName] = ""
-	chunkVKMap[cfg.ForkName] = ""
+	batchVKMap := map[string]string{cfg.ForkName: "mock_batch_vk"}
+	chunkVKMap := map[string]string{cfg.ForkName: "mock_chunk_vk"}
 	return &Verifier{cfg: cfg, ChunkVKMap: chunkVKMap, BatchVKMap: batchVKMap}, nil
 }
 

coordinator/internal/logic/verifier/verifier.go

@@ -18,36 +18,20 @@ import (
 	"io/fs"
 	"os"
 	"path"
-	coordinatorType "scroll-tech/common/types/message"
 	"unsafe"
 
 	"github.com/scroll-tech/go-ethereum/log"
 
+	coordinatorType "scroll-tech/common/types/message"
+
 	"scroll-tech/coordinator/internal/config"
 )
 
 // NewVerifier Sets up a rust ffi to call verify.
 func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 	if cfg.MockMode {
-		batchVKMap := map[string]string{
-			"shanghai":  "",
-			"bernoulli": "",
-			"london":    "",
-			"istanbul":  "",
-			"homestead": "",
-			"eip155":    "",
-		}
-		chunkVKMap := map[string]string{
-			"shanghai":  "",
-			"bernoulli": "",
-			"london":    "",
-			"istanbul":  "",
-			"homestead": "",
-			"eip155":    "",
-		}
-
-		batchVKMap[cfg.ForkName] = ""
-		chunkVKMap[cfg.ForkName] = ""
+		batchVKMap := map[string]string{cfg.ForkName: "mock_batch_vk"}
+		chunkVKMap := map[string]string{cfg.ForkName: "mock_chunk_vk"}
 		return &Verifier{cfg: cfg, ChunkVKMap: chunkVKMap, BatchVKMap: batchVKMap}, nil
 	}
 	paramsPathStr := C.CString(cfg.ParamsPath)

coordinator/internal/types/auth.go

@@ -33,7 +33,7 @@ type Message struct {
 	Challenge     string   `form:"challenge" json:"challenge" binding:"required"`
 	ProverVersion string   `form:"prover_version" json:"prover_version" binding:"required"`
 	ProverName    string   `form:"prover_name" json:"prover_name" binding:"required"`
-	ProverTypes   []int    `form:"prover_types" json:"prover_types"`
+	ProverTypes   []string `form:"prover_types" json:"prover_types"`
 	VKs           []string `form:"vks" json:"vks"`
 }
 

coordinator/internal/types/auth_test.go

@@ -1,11 +1,14 @@
 package types
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/stretchr/testify/assert"
+
+	"scroll-tech/common/types/message"
 )
 
 func TestAuthMessageSignAndVerify(t *testing.T) {
@@ -20,6 +23,7 @@ func TestAuthMessageSignAndVerify(t *testing.T) {
 				ProverName:    "test1",
 				ProverVersion: "v0.0.1",
 				Challenge:     "abcdef",
+				ProverTypes:   []string{"2"},
 				VKs:           []string{"vk1", "vk2"},
 			},
 			PublicKey: publicKeyHex,
@@ -42,3 +46,30 @@ func TestAuthMessageSignAndVerify(t *testing.T) {
 		assert.NoError(t, verifyErr)
 	})
 }
+
+// TestGenerateSignature this unit test isn't for test, just generate the signature for manually test.
+func TestGenerateSignature(t *testing.T) {
+	privateKey, err := crypto.GenerateKey()
+	assert.NoError(t, err)
+	publicKeyHex := common.Bytes2Hex(crypto.CompressPubkey(&privateKey.PublicKey))
+
+	t.Log("publicKey: ", publicKeyHex)
+
+	authMsg := LoginParameter{
+		Message: Message{
+			ProverName:    "test",
+			ProverVersion: "v4.1.115-4dd11c6-000000-000000",
+			Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MTk1MDgwNjUsIm9yaWdfaWF0IjoxNzE5NTA0NDY1LCJyYW5kb20iOiI1ZXp0UWtKYy1vZXNfOGZGeV9leG85bmdCN2thMzVjeEdFcHpQQUpKamVrPSJ9.5_lq2WXSvic0h6F6uqGsKtbnHSjb-2zCMHk7YAVC_e4",
+			ProverTypes:   []string{fmt.Sprintf("%d", message.ProofTypeChunk)},
+			VKs:           []string{"mock_chunk_vk"},
+		},
+		PublicKey: publicKeyHex,
+	}
+	err = authMsg.SignWithKey(privateKey)
+	assert.NoError(t, err)
+	t.Log("signature: ", authMsg.Signature)
+
+	verify, err := authMsg.Verify()
+	assert.NoError(t, err)
+	assert.True(t, verify)
+}