WIP: config and client controller

Author: noel2004

coordinator/internal/config/proxy_config.go

@@ -12,6 +12,25 @@ import (
 type ProxyManager struct {
 	// Zk verifier config help to confine the connected prover.
 	Verifier *VerifierConfig `json:"verifier"`
+	Client   *ProxyClient    `json:"proxy_cli"`
+	Auth     *Auth           `json:"auth"`
+}
+
+func (m *ProxyManager) Normalize() {
+	if m.Client.Auth == nil {
+		m.Client.Auth = m.Auth
+	}
+
+	if m.Client.ProxyVersion == "" {
+		m.Client.ProxyVersion = m.Verifier.MinProverVersion
+	}
+}
+
+// Proxy client configuration for connect to upstream as a client
+type ProxyClient struct {
+	ProxyName    string `json:"proxy_name"`
+	ProxyVersion string `json:"proxy_version,omitempty"`
+	Auth         *Auth  `json:"auth,omitempty"`
 }
 
 // Coordinator configuration

coordinator/internal/controller/proxy/client.go

@@ -2,29 +2,28 @@ package proxy
 
 import (
 	"bytes"
-	"crypto/ecdsa"
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"time"
 
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/crypto"
+	"github.com/gin-gonic/gin"
 
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/types"
 )
 
 // Client wraps an http client with a preset host for coordinator API calls
-type Client struct {
+type upClient struct {
 	httpClient *http.Client
 	baseURL    string
 	loginToken string
 }
 
 // NewClient creates a new Client with the specified host
-func NewClient(cfg *config.UpStream) *Client {
-	return &Client{
+func newUpClient(cfg *config.UpStream) *upClient {
+	return &upClient{
 		httpClient: &http.Client{
 			Timeout: time.Duration(cfg.ConnectionTimeoutSec) * time.Second,
 		},
@@ -33,7 +32,7 @@ func NewClient(cfg *config.UpStream) *Client {
 }
 
 // FullLogin performs the complete login process: get challenge then login
-func (c *Client) Login(param types.LoginParameter) (*types.LoginSchema, error) {
+func (c *upClient) Login(ctx context.Context, param types.LoginParameter) (*types.LoginSchema, error) {
 	// Step 1: Get challenge
 	url := fmt.Sprintf("%s/coordinator/v1/challenge", c.baseURL)
 
@@ -93,15 +92,15 @@ func (c *Client) Login(param types.LoginParameter) (*types.LoginSchema, error) {
 }
 
 // ProxyLogin makes a POST request to /v1/proxy_login with LoginParameter
-func (c *Client) ProxyLogin(param types.LoginParameter) (*http.Response, error) {
+func (c *upClient) ProxyLogin(ctx *gin.Context, param types.LoginParameter) (*http.Response, error) {
 	url := fmt.Sprintf("%s/coordinator/v1/proxy_login", c.baseURL)
 
 	jsonData, err := json.Marshal(param)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal proxy login parameter: %w", err)
 	}
 
-	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
 	if err != nil {
 		return nil, fmt.Errorf("failed to create proxy login request: %w", err)
 	}
@@ -113,15 +112,15 @@ func (c *Client) ProxyLogin(param types.LoginParameter) (*http.Response, error)
 }
 
 // GetTask makes a POST request to /v1/get_task with GetTaskParameter
-func (c *Client) GetTask(param types.GetTaskParameter, token string) (*http.Response, error) {
+func (c *upClient) GetTask(ctx *gin.Context, param types.GetTaskParameter, token string) (*http.Response, error) {
 	url := fmt.Sprintf("%s/coordinator/v1/get_task", c.baseURL)
 
 	jsonData, err := json.Marshal(param)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal get task parameter: %w", err)
 	}
 
-	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
 	if err != nil {
 		return nil, fmt.Errorf("failed to create get task request: %w", err)
 	}
@@ -135,15 +134,15 @@ func (c *Client) GetTask(param types.GetTaskParameter, token string) (*http.Resp
 }
 
 // SubmitProof makes a POST request to /v1/submit_proof with SubmitProofParameter
-func (c *Client) SubmitProof(param types.SubmitProofParameter, token string) (*http.Response, error) {
+func (c *upClient) SubmitProof(ctx *gin.Context, param types.SubmitProofParameter, token string) (*http.Response, error) {
 	url := fmt.Sprintf("%s/coordinator/v1/submit_proof", c.baseURL)
 
 	jsonData, err := json.Marshal(param)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal submit proof parameter: %w", err)
 	}
 
-	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
 	if err != nil {
 		return nil, fmt.Errorf("failed to create submit proof request: %w", err)
 	}
@@ -155,53 +154,3 @@ func (c *Client) SubmitProof(param types.SubmitProofParameter, token string) (*h
 
 	return c.httpClient.Do(req)
 }
-
-// transformToValidPrivateKey safely transforms arbitrary bytes into valid private key bytes
-func (c *Client) buildPrivateKey(inputBytes []byte) (*ecdsa.PrivateKey, error) {
-	// Try appending bytes from 0x0 to 0x20 until we get a valid private key
-	for appendByte := byte(0x0); appendByte <= 0x20; appendByte++ {
-		// Append the byte to input
-		extendedBytes := append(inputBytes, appendByte)
-
-		// Calculate 256-bit hash
-		hash := crypto.Keccak256(extendedBytes)
-
-		// Try to create private key from hash
-		if k, err := crypto.ToECDSA(hash); err == nil {
-			return k, nil
-		}
-	}
-
-	return nil, fmt.Errorf("failed to generate valid private key from input bytes")
-}
-
-func (c *Client) generateLoginParameter(privateKeyBytes []byte, challenge string) (*types.LoginParameter, error) {
-	// Generate private key
-	privKey, err := c.buildPrivateKey(privateKeyBytes)
-	if err != nil {
-		return nil, err
-	}
-
-	// Generate public key string
-	publicKeyHex := common.Bytes2Hex(crypto.CompressPubkey(&privKey.PublicKey))
-
-	// Create login parameter with proxy settings
-	loginParam := &types.LoginParameter{
-		Message: types.Message{
-			Challenge:          challenge,
-			ProverName:         "proxy",
-			ProverVersion:      "proxy",
-			ProverProviderType: types.ProverProviderTypeProxy,
-			ProverTypes:        []types.ProverType{}, // Default empty
-			VKs:                []string{},           // Default empty
-		},
-		PublicKey: publicKeyHex,
-	}
-
-	// Sign the message with the private key
-	if err := loginParam.SignWithKey(privKey); err != nil {
-		return nil, fmt.Errorf("failed to sign login parameter: %w", err)
-	}
-
-	return loginParam, nil
-}

coordinator/internal/controller/proxy/client_manager.go

@@ -0,0 +1,86 @@
+package proxy
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"fmt"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/crypto"
+
+	"scroll-tech/coordinator/internal/config"
+	"scroll-tech/coordinator/internal/types"
+)
+
+type Client interface {
+	Client(context.Context) *upClient
+}
+
+type ClientManager struct {
+	cliCfg  *config.ProxyClient
+	cfg     *config.UpStream
+	privKey *ecdsa.PrivateKey
+}
+
+// transformToValidPrivateKey safely transforms arbitrary bytes into valid private key bytes
+func buildPrivateKey(inputBytes []byte) (*ecdsa.PrivateKey, error) {
+	// Try appending bytes from 0x0 to 0x20 until we get a valid private key
+	for appendByte := byte(0x0); appendByte <= 0x20; appendByte++ {
+		// Append the byte to input
+		extendedBytes := append(inputBytes, appendByte)
+
+		// Calculate 256-bit hash
+		hash := crypto.Keccak256(extendedBytes)
+
+		// Try to create private key from hash
+		if k, err := crypto.ToECDSA(hash); err == nil {
+			return k, nil
+		}
+	}
+
+	return nil, fmt.Errorf("failed to generate valid private key from input bytes")
+}
+
+func NewClientManager(cliCfg *config.ProxyClient, cfg *config.UpStream) (*ClientManager, error) {
+
+	privKey, err := buildPrivateKey([]byte(cliCfg.Auth.Secret))
+	if err != nil {
+		return nil, err
+	}
+
+	return &ClientManager{
+		privKey: privKey,
+		cfg:     cfg,
+		cliCfg:  cliCfg,
+	}, nil
+}
+
+func (cliMgr *ClientManager) Client(ctx context.Context) *upClient {
+	return newUpClient(cliMgr.cfg)
+}
+
+func (cliMgr *ClientManager) generateLoginParameter(privKey []byte, challenge string) (*types.LoginParameter, error) {
+
+	// Generate public key string
+	publicKeyHex := common.Bytes2Hex(crypto.CompressPubkey(&cliMgr.privKey.PublicKey))
+
+	// Create login parameter with proxy settings
+	loginParam := &types.LoginParameter{
+		Message: types.Message{
+			Challenge:          challenge,
+			ProverName:         cliMgr.cliCfg.ProxyName,
+			ProverVersion:      cliMgr.cliCfg.ProxyVersion,
+			ProverProviderType: types.ProverProviderTypeProxy,
+			ProverTypes:        []types.ProverType{}, // Default empty
+			VKs:                []string{},           // Default empty
+		},
+		PublicKey: publicKeyHex,
+	}
+
+	// Sign the message with the private key
+	if err := loginParam.SignWithKey(cliMgr.privKey); err != nil {
+		return nil, fmt.Errorf("failed to sign login parameter: %w", err)
+	}
+
+	return loginParam, nil
+}

coordinator/internal/controller/proxy/controller.go

@@ -18,21 +18,28 @@ var (
 
 // Clients manager a series of thread-safe clients for requesting upstream
 // coordinators
-type Clients map[string]*Client
+type Clients map[string]Client
 
 // InitController inits Controller with database
 func InitController(cfg *config.ProxyConfig) {
+	// normalize cfg
+	cfg.ProxyManager.Normalize()
+
 	vf, err := verifier.NewVerifier(cfg.ProxyManager.Verifier)
 	if err != nil {
 		panic("proof receiver new verifier failure")
 	}
 
 	log.Info("verifier created", "openVmVerifier", vf.OpenVMVkMap)
 
-	clients := make(map[string]*Client)
+	clients := make(map[string]Client)
 
-	for nm, cfg := range cfg.Coordinators {
-		clients[nm] = NewClient(cfg)
+	for nm, upCfg := range cfg.Coordinators {
+		cli, err := NewClientManager(cfg.ProxyManager.Client, upCfg)
+		if err != nil {
+			panic("create new client fail")
+		}
+		clients[nm] = cli
 	}
 
 	Auth = NewAuthController(cfg, clients, vf)