add compatibile mode and more logs

noel2004 · noel2004 · commit 8a15836d207c · 2025-10-09T14:30:43.000+09:00
diff --git a/coordinator/conf/config_proxy.json b/coordinator/conf/config_proxy.json
@@ -11,16 +11,7 @@
     },      
     "verifier": {
       "min_prover_version": "v4.4.45",
-      "verifiers": [
-        {
-          "assets_path": "assets",
-          "fork_name": "euclidV2"
-        },
-        {
-          "assets_path": "assets",
-          "fork_name": "feynman"
-        }
-      ]
+      "verifiers": []
     }
   },
   "coordinators": {
diff --git a/coordinator/internal/config/proxy_config.go b/coordinator/internal/config/proxy_config.go
@@ -39,6 +39,7 @@ type UpStream struct {
 	RetryCount           uint   `json:"retry_count"`
 	RetryWaitTime        uint   `json:"retry_wait_time_sec"`
 	ConnectionTimeoutSec uint   `json:"connection_timeout_sec"`
+	CompatibileMode      bool   `json:"compatibile_mode,omitempty"`
 }
 
 // Config load configuration items.
diff --git a/coordinator/internal/controller/proxy/auth.go b/coordinator/internal/controller/proxy/auth.go
@@ -60,6 +60,7 @@ func (a *AuthController) Login(c *gin.Context) (interface{}, error) {
 	}
 
 	session := a.proverMgr.GetOrCreate(loginParam.PublicKey)
+	log.Debug("start handling login", "cli", loginParam.Message.ProverName)
 
 	for n, cli := range a.clients {
 
diff --git a/coordinator/internal/controller/proxy/client.go b/coordinator/internal/controller/proxy/client.go
@@ -8,16 +8,20 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/crypto"
+
 	ctypes "scroll-tech/common/types"
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/types"
 )
 
 // Client wraps an http client with a preset host for coordinator API calls
 type upClient struct {
-	httpClient *http.Client
-	baseURL    string
-	loginToken string
+	httpClient      *http.Client
+	baseURL         string
+	loginToken      string
+	compatibileMode bool
 }
 
 // NewClient creates a new Client with the specified host
@@ -26,7 +30,8 @@ func newUpClient(cfg *config.UpStream) *upClient {
 		httpClient: &http.Client{
 			Timeout: time.Duration(cfg.ConnectionTimeoutSec) * time.Second,
 		},
-		baseURL: cfg.BaseUrl,
+		baseURL:         cfg.BaseUrl,
+		compatibileMode: cfg.CompatibileMode,
 	}
 }
 
@@ -40,8 +45,8 @@ type loginSchema struct {
 	Token string `json:"token"`
 }
 
-// FullLogin performs the complete login process: get challenge then login
-func (c *upClient) Login(ctx context.Context, genLogin func(string) (*types.LoginParameter, error)) (*types.LoginSchema, error) {
+// Login performs the complete login process: get challenge then login
+func (c *upClient) Login(ctx context.Context, genLogin func(string) (*types.LoginParameter, error)) (*ctypes.Response, error) {
 	// Step 1: Get challenge
 	url := fmt.Sprintf("%s/coordinator/v1/challenge", c.baseURL)
 
@@ -93,26 +98,7 @@ func (c *upClient) Login(ctx context.Context, genLogin func(string) (*types.Logi
 	if err != nil {
 		return nil, fmt.Errorf("failed to perform login request: %w", err)
 	}
-
-	parsedResp, err = handleHttpResp(loginResp)
-	if err != nil {
-		return nil, err
-	} else if parsedResp.ErrCode != 0 {
-		return nil, fmt.Errorf("login failed: %d (%s)", parsedResp.ErrCode, parsedResp.ErrMsg)
-	}
-
-	var loginResult loginSchema
-	err = parsedResp.DecodeData(&loginResult)
-	if err != nil {
-		return nil, fmt.Errorf("login parsing data fail: %v", err)
-	}
-	c.loginToken = loginResult.Token
-
-	// TODO: we need to parse time if we start making use of it
-
-	return &types.LoginSchema{
-		Token: loginResult.Token,
-	}, nil
+	return handleHttpResp(loginResp)
 }
 
 func handleHttpResp(resp *http.Response) (*ctypes.Response, error) {
@@ -130,8 +116,40 @@ func handleHttpResp(resp *http.Response) (*ctypes.Response, error) {
 	return nil, fmt.Errorf("login request failed with status: %d", resp.StatusCode)
 }
 
+func (c *upClient) proxyLoginCompatibleMode(ctx context.Context, param *types.LoginParameter) (*ctypes.Response, error) {
+	mimePrivK, err := buildPrivateKey([]byte(param.PublicKey))
+	if err != nil {
+		return nil, err
+	}
+	mimePkHex := common.Bytes2Hex(crypto.CompressPubkey(&mimePrivK.PublicKey))
+
+	genLoginParam := func(challenge string) (*types.LoginParameter, error) {
+
+		// Create login parameter with proxy settings
+		loginParam := &types.LoginParameter{
+			Message:   param.Message,
+			PublicKey: mimePkHex,
+		}
+		loginParam.Message.Challenge = challenge
+
+		// Sign the message with the private key
+		if err := loginParam.SignWithKey(mimePrivK); err != nil {
+			return nil, fmt.Errorf("failed to sign login parameter: %w", err)
+		}
+
+		return loginParam, nil
+	}
+
+	return c.Login(ctx, genLoginParam)
+}
+
 // ProxyLogin makes a POST request to /v1/proxy_login with LoginParameter
 func (c *upClient) ProxyLogin(ctx context.Context, param *types.LoginParameter) (*ctypes.Response, error) {
+
+	if c.compatibileMode {
+		return c.proxyLoginCompatibleMode(ctx, param)
+	}
+
 	url := fmt.Sprintf("%s/coordinator/v1/proxy_login", c.baseURL)
 
 	jsonData, err := json.Marshal(param)
diff --git a/coordinator/internal/controller/proxy/client_manager.go b/coordinator/internal/controller/proxy/client_manager.go
@@ -67,7 +67,13 @@ func NewClientManager(name string, cliCfg *config.ProxyClient, cfg *config.UpStr
 	}, nil
 }
 
-func (cliMgr *ClientManager) doLogin(ctx context.Context, loginCli *upClient) time.Time {
+func (cliMgr *ClientManager) doLogin(ctx context.Context, loginCli *upClient) {
+	if cliMgr.cfg.CompatibileMode {
+		loginCli.loginToken = "dummy"
+		log.Info("Skip login process for compatibile mode")
+		return
+	}
+
 	// Calculate wait time between 2 seconds and cfg.RetryWaitTime
 	minWait := 2 * time.Second
 	waitDuration := time.Duration(cliMgr.cfg.RetryWaitTime) * time.Second
@@ -77,18 +83,31 @@ func (cliMgr *ClientManager) doLogin(ctx context.Context, loginCli *upClient) ti
 
 	for {
 		log.Info("attempting login to upstream coordinator", "name", cliMgr.name)
-		loginResult, err := loginCli.Login(ctx, cliMgr.genLoginParam)
-		if err == nil && loginResult != nil {
-			log.Info("login to upstream coordinator successful", "name", cliMgr.name, "time", loginResult.Time)
-			return loginResult.Time
+		loginResp, err := loginCli.Login(ctx, cliMgr.genLoginParam)
+		if err == nil && loginResp.ErrCode == 0 {
+			var loginResult loginSchema
+			err = loginResp.DecodeData(&loginResult)
+			if err != nil {
+				log.Error("login parsing data fail", "error", err)
+			} else {
+				loginCli.loginToken = loginResult.Token
+				log.Info("login to upstream coordinator successful", "name", cliMgr.name, "time", loginResult.Time)
+				// TODO: we need to parse time if we start making use of it
+				return
+			}
+		} else if err != nil {
+			log.Error("login process fail", "error", err)
+		} else {
+			log.Error("login get fail resp", "code", loginResp.ErrCode, "msg", loginResp.ErrMsg)
 		}
+
 		log.Info("login to upstream coordinator failed, retrying", "name", cliMgr.name, "error", err, "waitDuration", waitDuration)
 
 		timer := time.NewTimer(waitDuration)
 		select {
 		case <-ctx.Done():
 			timer.Stop()
-			return time.Now()
+			return
 		case <-timer.C:
 			// Continue to next retry
 		}
diff --git a/coordinator/internal/controller/proxy/get_task.go b/coordinator/internal/controller/proxy/get_task.go
@@ -108,13 +108,16 @@ func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 	session := ptc.proverMgr.Get(publicKey)
 
 	getTask := func(upStream string, cli Client) (tryNext bool) {
+		log.Debug("Start get task", "up", upStream, "cli", session.CliName)
 		resp, err := session.GetTask(ctx, &getTaskParameter, cli, upStream)
 		if err != nil {
+			log.Error("Upstream error for get task", "error", err, "up", upStream, "cli", session.CliName)
 			types.RenderFailure(ctx, types.ErrCoordinatorGetTaskFailure, err)
 			return
 		} else if resp.ErrCode != types.ErrCoordinatorEmptyProofData {
 
 			if resp.ErrCode != 0 {
+				log.Error("Upstream has error resp for get task", "code", resp.ErrCode, "msg", resp.ErrMsg, "up", upStream, "cli", session.CliName)
 				// simply dispatch the error from upstream to prover
 				types.RenderFailure(ctx, resp.ErrCode, fmt.Errorf("%s", resp.ErrMsg))
 				return
@@ -124,9 +127,10 @@ func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 			if err = resp.DecodeData(&task); err == nil {
 				task.TaskID = formUpstreamWithTaskName(upStream, task.TaskID)
 				ptc.priorityUpstream.Set(publicKey, upStream)
-				// TODO: log the new id in debug level
+				log.Debug("Upstream get task", "up", upStream, "cli", session.CliName, "taskID", task.TaskID, "taskType", task.TaskType)
 				types.RenderSuccess(ctx, &task)
 			} else {
+				log.Error("Upstream has wrong data for get task", "error", err, "up", upStream, "cli", session.CliName)
 				types.RenderFailure(ctx, types.InternalServerError, fmt.Errorf("decode task fail: %v", err))
 			}
 
@@ -140,10 +144,11 @@ func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 	priorityUpstream, exist := ptc.priorityUpstream.Get(publicKey)
 	if exist {
 		cli := ptc.clients[priorityUpstream]
+		log.Debug("Try get task from priority stream", "up", priorityUpstream)
 		if cli != nil && !getTask(priorityUpstream, cli) {
 			return
 		} else if cli == nil {
-			// TODO: log error
+			log.Warn("A upstream is removed or lost for some reason while running", "up", priorityUpstream)
 		}
 	}
 	ptc.priorityUpstream.Delete(publicKey)
@@ -166,6 +171,7 @@ func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 		}
 	}
 
+	log.Debug("get no task from upstream", "cli", session.CliName)
 	// if all get task failed, throw empty proof resp
 	types.RenderFailure(ctx, types.ErrCoordinatorEmptyProofData, fmt.Errorf("get empty prover task"))
 }
diff --git a/coordinator/internal/controller/proxy/prover_session.go b/coordinator/internal/controller/proxy/prover_session.go
@@ -7,6 +7,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/scroll-tech/go-ethereum/log"
+
 	ctypes "scroll-tech/common/types"
 	"scroll-tech/coordinator/internal/types"
 )
@@ -40,6 +42,7 @@ func (m *ProverManager) GetOrCreate(userKey string) *proverSession {
 
 	ret := &proverSession{
 		proverToken: make(map[string]loginToken),
+		CliName:     "pending for login",
 	}
 
 	m.data[userKey] = ret
@@ -60,6 +63,8 @@ type loginToken struct {
 
 // Client wraps an http client with a preset host for coordinator API calls
 type proverSession struct {
+	CliName string
+
 	sync.RWMutex
 	proverToken   map[string]loginToken
 	completionCtx context.Context
@@ -97,11 +102,18 @@ func (c *proverSession) maintainLogin(ctx context.Context, cliMgr Client, up str
 				LoginSchema: result,
 				phase:       curPhase + 1,
 			}
+			log.Info("maintain login status", "upstream", up, "cli", param.Message.ProverName, "phase", curPhase+1)
 		}
 		c.Unlock()
+		if nerr != nil {
+			log.Error("maintain login fail", "error", nerr, "upstream", up, "cli", param.Message.ProverName, "phase", curPhase)
+		}
 	}()
 	c.Unlock()
 
+	log.Debug("start proxy login process", "upstream", up, "cli", param.Message.ProverName)
+	c.CliName = param.Message.ProverName
+
 	cli := cliMgr.Client(ctx)
 	if cli == nil {
 		return nil, fmt.Errorf("get upstream cli fail")
diff --git a/coordinator/internal/controller/proxy/submit_proof.go b/coordinator/internal/controller/proxy/submit_proof.go
@@ -6,6 +6,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/scroll-tech/go-ethereum/log"
 
 	"scroll-tech/common/types"
 	"scroll-tech/coordinator/internal/config"
@@ -59,22 +60,26 @@ func (spc *SubmitProofController) SubmitProof(ctx *gin.Context) {
 	upstream, realTaskID := upstreamFromTaskName(submitParameter.TaskID)
 	cli, existed := spc.clients[upstream]
 	if !existed {
-		// TODO: log error
+		log.Warn("A upstream for submitting is removed or lost for some reason while running", "up", upstream)
 		nerr := fmt.Errorf("Invalid upstream name (%s) from taskID %s", upstream, submitParameter.TaskID)
 		types.RenderFailure(ctx, types.ErrCoordinatorParameterInvalidNo, nerr)
 		return
 	}
+	log.Debug("Start submitting", "up", upstream, "cli", session.CliName, "id", realTaskID, "status", submitParameter.Status)
 	submitParameter.TaskID = realTaskID
 
 	resp, err := session.SubmitProof(ctx, &submitParameter, cli, upstream)
 	if err != nil {
+		log.Error("Upstream has error resp for submit", "code", resp.ErrCode, "msg", resp.ErrMsg, "up", upstream, "cli", session.CliName)
 		types.RenderFailure(ctx, types.ErrCoordinatorGetTaskFailure, err)
 		return
 	} else if resp.ErrCode != 0 {
+		log.Error("Upstream has error resp for get task", "code", resp.ErrCode, "msg", resp.ErrMsg, "up", upstream, "cli", session.CliName)
 		// simply dispatch the error from upstream to prover
 		types.RenderFailure(ctx, resp.ErrCode, fmt.Errorf("%s", resp.ErrMsg))
 		return
 	} else {
+		log.Debug("Submit proof to upstream", "up", upstream, "cli", session.CliName, "taskID", realTaskID)
 		spc.priorityUpstream.Delete(upstream)
 		types.RenderSuccess(ctx, resp.Data)
 		return
diff --git a/coordinator/internal/logic/submitproof/proof_receiver.go b/coordinator/internal/logic/submitproof/proof_receiver.go
@@ -216,7 +216,7 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 	switch message.ProofType(proofParameter.TaskType) {
 	case message.ProofTypeChunk:
 		chunkProof := &message.OpenVMChunkProof{}
-		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &chunkProof); unmarshalErr != nil {
+		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &chunkProof); unmarshalErr == nil {
 			return unmarshalErr
 		}
 		success, verifyErr = m.verifier.VerifyChunkProof(chunkProof, hardForkName)
diff --git a/coordinator/test/proxy_test.go b/coordinator/test/proxy_test.go
@@ -31,12 +31,15 @@ func testProxyClientCfg() *config.ProxyClient {
 	}
 }
 
+var testCompatibileMode bool
+
 func testProxyUpStreamCfg(coordinatorURL string) *config.UpStream {
 
 	return &config.UpStream{
 		BaseUrl:              fmt.Sprintf("http://%s", coordinatorURL),
 		RetryWaitTime:        3,
 		ConnectionTimeoutSec: 30,
+		CompatibileMode:      testCompatibileMode,
 	}
 
 }
@@ -263,7 +266,17 @@ func testProxyProof(t *testing.T) {
 }
 
 func TestProxyClient(t *testing.T) {
+	testCompatibileMode = false
+	// Set up the test environment.
+	setEnv(t)
+	t.Run("TestProxyClient", testProxyClient)
+	t.Run("TestProxyHandshake", testProxyHandshake)
+	t.Run("TestProxyGetTask", testProxyGetTask)
+	t.Run("TestProxyValidProof", testProxyProof)
+}
 
+func TestProxyClientCompatibleMode(t *testing.T) {
+	testCompatibileMode = true
 	// Set up the test environment.
 	setEnv(t)
 	t.Run("TestProxyClient", testProxyClient)

Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,7 @@ type UpStream struct {`
`39`	`39`	RetryCount uint `json:"retry_count"`
`40`	`40`	RetryWaitTime uint `json:"retry_wait_time_sec"`
`41`	`41`	ConnectionTimeoutSec uint `json:"connection_timeout_sec"`
	`42`	+ CompatibileMode bool `json:"compatibile_mode,omitempty"`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	`// Config load configuration items.`
Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,7 @@ func (a AuthController) Login(c gin.Context) (interface{}, error) {`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`session := a.proverMgr.GetOrCreate(loginParam.PublicKey)`
	`63`	`+ log.Debug("start handling login", "cli", loginParam.Message.ProverName)`
`63`	`64`
`64`	`65`	`for n, cli := range a.clients {`
`65`	`66`
Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,7 @@ func (m ProofReceiverLogic) HandleZkProof(ctx gin.Context, proofParameter coor`
`216`	`216`	`switch message.ProofType(proofParameter.TaskType) {`
`217`	`217`	`case message.ProofTypeChunk:`
`218`	`218`	`chunkProof := &message.OpenVMChunkProof{}`
`219`		`- if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &chunkProof); unmarshalErr != nil {`
	`219`	`+ if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &chunkProof); unmarshalErr == nil {`
`220`	`220`	`return unmarshalErr`
`221`	`221`	`}`
`222`	`222`	`success, verifyErr = m.verifier.VerifyChunkProof(chunkProof, hardForkName)`
Original file line number	Diff line number	Diff line change
`@@ -31,12 +31,15 @@ func testProxyClientCfg() *config.ProxyClient {`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
	`34`	`+var testCompatibileMode bool`
	`35`	`+`
`34`	`36`	`func testProxyUpStreamCfg(coordinatorURL string) *config.UpStream {`
`35`	`37`
`36`	`38`	`return &config.UpStream{`
`37`	`39`	`BaseUrl: fmt.Sprintf("http://%s", coordinatorURL),`
`38`	`40`	`RetryWaitTime: 3,`
`39`	`41`	`ConnectionTimeoutSec: 30,`
	`42`	`+ CompatibileMode: testCompatibileMode,`
`40`	`43`	`}`
`41`	`44`
`42`	`45`	`}`
`@@ -263,7 +266,17 @@ func testProxyProof(t *testing.T) {`
`263`	`266`	`}`
`264`	`267`
`265`	`268`	`func TestProxyClient(t *testing.T) {`
	`269`	`+ testCompatibileMode = false`
	`270`	`+ // Set up the test environment.`
	`271`	`+ setEnv(t)`
	`272`	`+ t.Run("TestProxyClient", testProxyClient)`
	`273`	`+ t.Run("TestProxyHandshake", testProxyHandshake)`
	`274`	`+ t.Run("TestProxyGetTask", testProxyGetTask)`
	`275`	`+ t.Run("TestProxyValidProof", testProxyProof)`
	`276`	`+}`
`266`	`277`
	`278`	`+func TestProxyClientCompatibleMode(t *testing.T) {`
	`279`	`+ testCompatibileMode = true`
`267`	`280`	`// Set up the test environment.`
`268`	`281`	`setEnv(t)`
`269`	`282`	`t.Run("TestProxyClient", testProxyClient)`