feat(prover): dynamicly detect sentry endpoint from coordinator

.coderabbit.yaml

@@ -1,15 +0,0 @@
-# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
-language: "en-US"
-early_access: false
-reviews:
-  profile: "chill"
-  request_changes_workflow: false
-  high_level_summary: true
-  poem: true
-  review_status: true
-  collapse_walkthrough: false
-  auto_review:
-    enabled: true
-    drafts: false
-chat:
-  auto_reply: true

.github/workflows/docker.yml

@@ -49,8 +49,8 @@ jobs:
           platforms: linux/amd64,linux/arm64
           push: true
           tags: |
-            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
@@ -94,8 +94,8 @@ jobs:
           platforms: linux/amd64,linux/arm64
           push: true
           tags: |
-            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
@@ -139,8 +139,8 @@ jobs:
           platforms: linux/amd64,linux/arm64
           push: true
           tags: |
-            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
@@ -184,8 +184,8 @@ jobs:
           platforms: linux/amd64,linux/arm64
           push: true
           tags: |
-            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
@@ -229,8 +229,8 @@ jobs:
           platforms: linux/amd64,linux/arm64
           push: true
           tags: |
-            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
@@ -274,8 +274,8 @@ jobs:
           platforms: linux/amd64,linux/arm64
           push: true
           tags: |
-            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
@@ -318,8 +318,8 @@ jobs:
           file: ./build/dockerfiles/coordinator-api.Dockerfile
           push: true
           tags: |
-            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
@@ -363,7 +363,7 @@ jobs:
           platforms: linux/amd64,linux/arm64
           push: true
           tags: |
-            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest

build/dockerfiles/bridgehistoryapi-api.Dockerfile

@@ -17,7 +17,6 @@ RUN --mount=target=. \
 FROM ubuntu:20.04
 
 ENV CGO_LDFLAGS="-Wl,--no-as-needed -ldl"
-RUN apt update && apt install vim netcat-openbsd net-tools curl -y
 COPY --from=builder /bin/bridgehistoryapi-api /bin/
 WORKDIR /app
 ENTRYPOINT ["bridgehistoryapi-api"]

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 apt update && apt install ca-certificates vim netcat-openbsd net-tools curl -y
+RUN apt update && apt install ca-certificates -y
 RUN update-ca-certificates
 COPY --from=builder /bin/bridgehistoryapi-fetcher /bin/
 WORKDIR /app

build/dockerfiles/coordinator-api.Dockerfile

@@ -40,7 +40,6 @@ FROM ubuntu:20.04
 ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/src/coordinator/internal/logic/verifier/lib
 ENV CGO_LDFLAGS="-Wl,--no-as-needed -ldl"
 # ENV CHAIN_ID=534353
-RUN apt update && apt install vim netcat-openbsd net-tools curl jq -y
 RUN mkdir -p /src/coordinator/internal/logic/verifier/lib
 COPY --from=builder /bin/lib /src/coordinator/internal/logic/verifier/lib
 COPY --from=builder /bin/coordinator_api /bin/

build/dockerfiles/coordinator-cron.Dockerfile

@@ -19,8 +19,9 @@ RUN --mount=target=. \
 
 # Pull coordinator into a second stage deploy ubuntu container
 FROM ubuntu:20.04
+
 ENV CGO_LDFLAGS="-Wl,--no-as-needed -ldl"
-RUN apt update && apt install vim netcat-openbsd net-tools curl -y
+
 COPY --from=builder /bin/coordinator_cron /bin/
 WORKDIR /app
 ENTRYPOINT ["coordinator_cron"]

build/dockerfiles/gas_oracle.Dockerfile

@@ -21,7 +21,7 @@ RUN --mount=target=. \
 # Pull gas_oracle into a second stage deploy ubuntu container
 FROM ubuntu:20.04
 
-RUN apt update && apt install vim netcat-openbsd net-tools curl ca-certificates -y
+RUN apt update && apt install ca-certificates -y
 
 ENV CGO_LDFLAGS="-ldl"
 

build/dockerfiles/rollup_relayer.Dockerfile

@@ -21,7 +21,7 @@ RUN --mount=target=. \
 # Pull rollup_relayer into a second stage deploy ubuntu container
 FROM ubuntu:20.04
 
-RUN apt update && apt install vim netcat-openbsd net-tools curl ca-certificates -y
+RUN apt update && apt install ca-certificates -y
 
 ENV CGO_LDFLAGS="-ldl"
 

common/testcontainers/testcontainers.go

@@ -21,10 +21,9 @@ import (
 
 // TestcontainerApps testcontainers struct
 type TestcontainerApps struct {
-	postgresContainer   *postgres.PostgresContainer
-	l2GethContainer     *testcontainers.DockerContainer
-	poSL1Container      compose.ComposeStack
-	web3SignerContainer *testcontainers.DockerContainer
+	postgresContainer *postgres.PostgresContainer
+	l2GethContainer   *testcontainers.DockerContainer
+	poSL1Container    compose.ComposeStack
 
 	// common time stamp in nanoseconds.
 	Timestamp int
@@ -113,47 +112,6 @@ func (t *TestcontainerApps) StartPoSL1Container() error {
 	return nil
 }
 
-func (t *TestcontainerApps) StartWeb3SignerContainer(chainId int) error {
-	if t.web3SignerContainer != nil && t.web3SignerContainer.IsRunning() {
-		return nil
-	}
-	var (
-		err     error
-		rootDir string
-	)
-	if rootDir, err = findProjectRootDir(); err != nil {
-		return fmt.Errorf("failed to find project root directory: %v", err)
-	}
-
-	// web3signerconf/keyconf.yaml may contain multiple keys configured and web3signer then choses one corresponding to from field of tx
-	web3SignerConfDir := filepath.Join(rootDir, "common", "testcontainers", "web3signerconf")
-
-	req := testcontainers.ContainerRequest{
-		Image:        "consensys/web3signer:develop",
-		ExposedPorts: []string{"9000/tcp"},
-		Cmd:          []string{"--key-config-path", "/web3signerconf/", "eth1", "--chain-id", fmt.Sprintf("%d", chainId)},
-		Files: []testcontainers.ContainerFile{
-			{
-				HostFilePath:      web3SignerConfDir,
-				ContainerFilePath: "/",
-				FileMode:          0o777,
-			},
-		},
-		WaitingFor: wait.ForLog("ready to handle signing requests"),
-	}
-	genericContainerReq := testcontainers.GenericContainerRequest{
-		ContainerRequest: req,
-		Started:          true,
-	}
-	container, err := testcontainers.GenericContainer(context.Background(), genericContainerReq)
-	if err != nil {
-		log.Printf("failed to start web3signer container: %s", err)
-		return err
-	}
-	t.web3SignerContainer, _ = container.(*testcontainers.DockerContainer)
-	return nil
-}
-
 // GetPoSL1EndPoint returns the endpoint of the running PoS L1 endpoint
 func (t *TestcontainerApps) GetPoSL1EndPoint() (string, error) {
 	if t.poSL1Container == nil {
@@ -195,14 +153,6 @@ func (t *TestcontainerApps) GetL2GethEndPoint() (string, error) {
 	return endpoint, nil
 }
 
-// GetL2GethEndPoint returns the endpoint of the running L2Geth container
-func (t *TestcontainerApps) GetWeb3SignerEndpoint() (string, error) {
-	if t.web3SignerContainer == nil || !t.web3SignerContainer.IsRunning() {
-		return "", errors.New("web3signer is not running")
-	}
-	return t.web3SignerContainer.PortEndpoint(context.Background(), "9000/tcp", "http")
-}
-
 // GetGormDBClient returns a gorm.DB by connecting to the running postgres container
 func (t *TestcontainerApps) GetGormDBClient() (*gorm.DB, error) {
 	endpoint, err := t.GetDBEndPoint()
@@ -251,11 +201,6 @@ func (t *TestcontainerApps) Free() {
 			t.poSL1Container = nil
 		}
 	}
-	if t.web3SignerContainer != nil && t.web3SignerContainer.IsRunning() {
-		if err := t.web3SignerContainer.Terminate(ctx); err != nil {
-			log.Printf("failed to stop web3signer container: %s", err)
-		}
-	}
 }
 
 // findProjectRootDir find project root directory

common/testcontainers/testcontainers_test.go

@@ -44,11 +44,6 @@ func TestNewTestcontainerApps(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotNil(t, ethclient)
 
-	assert.NoError(t, testApps.StartWeb3SignerContainer(1))
-	endpoint, err = testApps.GetWeb3SignerEndpoint()
-	assert.NoError(t, err)
-	assert.NotEmpty(t, endpoint)
-
 	// test free testcontainers
 	testApps.Free()
 	endpoint, err = testApps.GetDBEndPoint()
@@ -62,8 +57,4 @@ func TestNewTestcontainerApps(t *testing.T) {
 	endpoint, err = testApps.GetPoSL1EndPoint()
 	assert.EqualError(t, err, "PoS L1 container is not running")
 	assert.Empty(t, endpoint)
-
-	endpoint, err = testApps.GetWeb3SignerEndpoint()
-	assert.EqualError(t, err, "web3signer is not running")
-	assert.Empty(t, endpoint)
 }

common/testcontainers/web3signerconf/keyconf.yaml

@@ -1,7 +0,0 @@
-type: "file-raw"
-keyType: "SECP256K1"
-privateKey: "0x1313131313131313131313131313131313131313131313131313131313131313"
----
-type: "file-raw"
-keyType: "SECP256K1"
-privateKey: "0x1212121212121212121212121212121212121212121212121212121212121212"

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.4.66"
+var tag = "v4.4.63"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

coordinator/conf/config.json

@@ -2,9 +2,6 @@
   "prover_manager": {
     "provers_per_session": 1,
     "session_attempts": 5,
-    "bundle_collection_time_sec": 180,
-    "batch_collection_time_sec": 180,
-    "chunk_collection_time_sec": 180,
     "verifier": {
       "mock_mode": true,
       "low_version_circuit": {
@@ -19,7 +16,11 @@
         "fork_name": "darwinV2",
         "min_prover_version": "v4.4.45"
       }
-    }
+    },
+    "bundle_collection_time_sec": 180,
+    "batch_collection_time_sec": 180,
+    "chunk_collection_time_sec": 180,
+    "prover_sentry_endpoint": ""
   },
   "db": {
     "driver_name": "postgres",

coordinator/internal/config/config.go

@@ -24,6 +24,8 @@ type ProverManager struct {
 	ChunkCollectionTimeSec int `json:"chunk_collection_time_sec"`
 	// BundleCollectionTimeSec bundle Proof collection time (in seconds).
 	BundleCollectionTimeSec int `json:"bundle_collection_time_sec"`
+	// ProverSentryEndpoint the sentry endpoint being sent to each prover in login response
+	ProverSentryEndpoint string `json:"prover_sentry_endpoint"`
 }
 
 // L2 loads l2geth configuration items.

coordinator/internal/controller/api/auth.go

@@ -3,11 +3,14 @@ package api
 import (
 	"errors"
 	"fmt"
+	"time"
 
 	jwt "github.com/appleboy/gin-jwt/v2"
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 
+	commonTypes "scroll-tech/common/types"
+
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/logic/auth"
 	"scroll-tech/coordinator/internal/logic/verifier"
@@ -16,12 +19,14 @@ import (
 
 // AuthController is login API
 type AuthController struct {
+	cfg        *config.Config
 	loginLogic *auth.LoginLogic
 }
 
 // NewAuthController returns an LoginController instance
 func NewAuthController(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *AuthController {
 	return &AuthController{
+		cfg:        cfg,
 		loginLogic: auth.NewLoginLogic(db, cfg, vf),
 	}
 }
@@ -98,3 +103,13 @@ func (a *AuthController) IdentityHandler(c *gin.Context) interface{} {
 
 	return nil
 }
+
+// LoginResponse replies to client for /login
+func (a *AuthController) LoginResponse(c *gin.Context, code int, message string, time time.Time) {
+	resp := types.LoginSchema{
+		Time:           time,
+		Token:          message,
+		SentryEndpoint: a.cfg.ProverManager.ProverSentryEndpoint,
+	}
+	commonTypes.RenderSuccess(c, resp)
+}

coordinator/internal/middleware/login_jwt.go

@@ -24,7 +24,7 @@ func LoginMiddleware(conf *config.Config) *jwt.GinJWTMiddleware {
 		TokenLookup:     "header: Authorization, query: token, cookie: jwt",
 		TokenHeadName:   "Bearer",
 		TimeFunc:        time.Now,
-		LoginResponse:   loginResponse,
+		LoginResponse:   api.Auth.LoginResponse,
 	})
 
 	if err != nil {

coordinator/internal/types/auth.go

@@ -24,8 +24,9 @@ const (
 
 // LoginSchema for /login response
 type LoginSchema struct {
-	Time  time.Time `json:"time"`
-	Token string    `json:"token"`
+	Time           time.Time `json:"time"`
+	Token          string    `json:"token"`
+	SentryEndpoint string    `json:"sentry_endpoint,omitempty"`
 }
 
 // Message the login message struct

prover/Cargo.lock

@@ -155,6 +155,17 @@ dependencies = [
  "bytes",
 ]
 
+[[package]]
+name = "alterable_logger"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "914a2c81a0e8d57d88d11554612d5e0afe5f942cecbcc239b10a394fd7ce404b"
+dependencies = [
+ "arc-swap",
+ "log",
+ "once_cell",
+]
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -1081,6 +1092,16 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
 
+[[package]]
+name = "debugid"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef552e6f588e446098f6ba40d89ac146c8c7b64aade83c051ee00bb5d2bc18d"
+dependencies = [
+ "serde",
+ "uuid 1.10.0",
+]
+
 [[package]]
 name = "der"
 version = "0.7.9"
@@ -1091,6 +1112,15 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "deranged"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+dependencies = [
+ "powerfmt",
+]
+
 [[package]]
 name = "derivative"
 version = "2.2.0"
@@ -1304,7 +1334,7 @@ dependencies = [
  "sha2",
  "sha3 0.10.8",
  "thiserror",
- "uuid",
+ "uuid 0.8.2",
 ]
 
 [[package]]
@@ -1609,6 +1639,18 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "findshlibs"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40b9e59cd0f7e0806cca4be089683ecb6434e602038df21fe6bf6711b2f07f64"
+dependencies = [
+ "cc",
+ "lazy_static",
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "fixed-hash"
 version = "0.8.0"
@@ -2159,6 +2201,17 @@ dependencies = [
  "digest 0.10.7",
 ]
 
+[[package]]
+name = "hostname"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9c7c7c8ac16c798734b8a24560c1362120597c40d5e1459f09498f8f6c8f2ba"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "windows",
+]
+
 [[package]]
 name = "http"
 version = "0.2.12"
@@ -2780,6 +2833,12 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "num-derive"
 version = "0.3.3"
@@ -2974,6 +3033,17 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "os_info"
+version = "3.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae99c7fa6dd38c7cafe1ec085e804f8f555a2f8659b0dbe03f1f9963a9b51092"
+dependencies = [
+ "log",
+ "serde",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "pairing"
 version = "0.23.0"
@@ -3205,6 +3275,12 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.17"
@@ -3277,6 +3353,7 @@ dependencies = [
 name = "prover"
 version = "0.1.0"
 dependencies = [
+ "alterable_logger",
  "anyhow",
  "base64 0.13.1",
  "clap",
@@ -3294,10 +3371,13 @@ dependencies = [
  "prover 0.12.0",
  "prover 0.13.0",
  "rand",
+ "regex",
  "reqwest 0.12.4",
  "reqwest-middleware",
  "reqwest-retry",
  "rlp",
+ "sentry",
+ "sentry-log",
  "serde",
  "serde_json",
  "sled",
@@ -3483,9 +3563,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.10.4"
+version = "1.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
+checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -3561,6 +3641,7 @@ dependencies = [
  "base64 0.22.1",
  "bytes",
  "encoding_rs",
+ "futures-channel",
  "futures-core",
  "futures-util",
  "h2 0.4.5",
@@ -4127,6 +4208,124 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
 
+[[package]]
+name = "sentry"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5484316556650182f03b43d4c746ce0e3e48074a21e2f51244b648b6542e1066"
+dependencies = [
+ "httpdate",
+ "native-tls",
+ "reqwest 0.12.4",
+ "sentry-backtrace",
+ "sentry-contexts",
+ "sentry-core",
+ "sentry-debug-images",
+ "sentry-panic",
+ "sentry-tracing",
+ "tokio",
+ "ureq",
+]
+
+[[package]]
+name = "sentry-backtrace"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40aa225bb41e2ec9d7c90886834367f560efc1af028f1c5478a6cce6a59c463a"
+dependencies = [
+ "backtrace",
+ "once_cell",
+ "regex",
+ "sentry-core",
+]
+
+[[package]]
+name = "sentry-contexts"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a8dd746da3d16cb8c39751619cefd4fcdbd6df9610f3310fd646b55f6e39910"
+dependencies = [
+ "hostname",
+ "libc",
+ "os_info",
+ "rustc_version 0.4.0",
+ "sentry-core",
+ "uname",
+]
+
+[[package]]
+name = "sentry-core"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "161283cfe8e99c8f6f236a402b9ccf726b201f365988b5bb637ebca0abbd4a30"
+dependencies = [
+ "once_cell",
+ "rand",
+ "sentry-types",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "sentry-debug-images"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc6b25e945fcaa5e97c43faee0267eebda9f18d4b09a251775d8fef1086238a"
+dependencies = [
+ "findshlibs",
+ "once_cell",
+ "sentry-core",
+]
+
+[[package]]
+name = "sentry-log"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75bbcc61886955045a1dd4bdb173412a80bb2571be3c5bfcf7eb8f55a442bbf5"
+dependencies = [
+ "log",
+ "sentry-core",
+]
+
+[[package]]
+name = "sentry-panic"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc74f229c7186dd971a9491ffcbe7883544aa064d1589bd30b83fb856cd22d63"
+dependencies = [
+ "sentry-backtrace",
+ "sentry-core",
+]
+
+[[package]]
+name = "sentry-tracing"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd3c5faf2103cd01eeda779ea439b68c4ee15adcdb16600836e97feafab362ec"
+dependencies = [
+ "sentry-backtrace",
+ "sentry-core",
+ "tracing-core",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "sentry-types"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d68cdf6bc41b8ff3ae2a9c4671e97426dcdd154cc1d4b6b72813f285d6b163f"
+dependencies = [
+ "debugid",
+ "hex",
+ "rand",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "time",
+ "url",
+ "uuid 1.10.0",
+]
+
 [[package]]
 name = "serde"
 version = "1.0.203"
@@ -4589,6 +4788,37 @@ dependencies = [
  "num_cpus",
 ]
 
+[[package]]
+name = "time"
+version = "0.3.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
+
+[[package]]
+name = "time-macros"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
 [[package]]
 name = "tiny-keccak"
 version = "2.0.2"
@@ -4623,6 +4853,7 @@ dependencies = [
  "bytes",
  "libc",
  "mio",
+ "num_cpus",
  "pin-project-lite",
  "socket2",
  "windows-sys 0.48.0",
@@ -4760,6 +4991,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
 dependencies = [
  "once_cell",
+ "valuable",
 ]
 
 [[package]]
@@ -4772,6 +5004,15 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+dependencies = [
+ "tracing-core",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"
@@ -4823,6 +5064,15 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "uname"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b72f89f0ca32e4db1c04e2a72f5345d59796d4866a1ee0609084569f73683dc8"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "unarray"
 version = "0.1.4"
@@ -4868,6 +5118,19 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
+[[package]]
+name = "ureq"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72139d247e5f97a3eff96229a7ae85ead5328a39efe76f8bf5a06313d505b6ea"
+dependencies = [
+ "base64 0.22.1",
+ "log",
+ "native-tls",
+ "once_cell",
+ "url",
+]
+
 [[package]]
 name = "url"
 version = "2.5.0"
@@ -4877,6 +5140,7 @@ dependencies = [
  "form_urlencoded",
  "idna",
  "percent-encoding",
+ "serde",
 ]
 
 [[package]]
@@ -4901,6 +5165,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "uuid"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.0"
@@ -5090,6 +5363,16 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
+dependencies = [
+ "windows-core",
+ "windows-targets 0.52.5",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.52.0"

prover/Cargo.toml

@@ -21,6 +21,7 @@ bls12_381 = { git = "https://github.com/scroll-tech/bls12_381", branch = "feat/i
 anyhow = "1.0"
 log = "0.4"
 env_logger = "0.11.3"
+alterable_logger = "1.0.0"
 serde = { version = "1.0.198", features = ["derive"] }
 serde_json = "1.0.116"
 futures = "0.3.30"
@@ -46,3 +47,6 @@ sled = "0.34.7"
 http = "1.1.0"
 clap = { version = "4.5", features = ["derive"] }
 ctor = "0.2.8"
+sentry = "0.34.0"
+sentry-log = "0.34.0"
+regex = "1.10.6"

prover/Makefile

@@ -35,8 +35,10 @@ else
     ZK_VERSION=${ZKEVM_COMMIT}-${HALO2_GPU_VERSION}
 endif
 
+RELEASE_VERSION=${GO_TAG}-${GIT_REV}-${ZK_VERSION}
+
 prover:
-	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo build --release
+	RELEASE_VERSION=${RELEASE_VERSION} cargo build --release
 
 tests_binary:
 	cargo clean && cargo test --release --no-run

prover/src/config.rs

@@ -1,4 +1,5 @@
 use anyhow::{bail, Result};
+use regex::Regex;
 use serde::{Deserialize, Serialize};
 use std::fs::File;
 
@@ -49,6 +50,21 @@ impl Config {
         let file = File::open(file_name)?;
         Config::from_reader(&file)
     }
+
+    pub fn partner_name(&self) -> String {
+        let prover_name = &self.prover_name;
+        let scroll_prefix = Regex::new(r"^scroll-.*").unwrap();
+        let idc_prefix = Regex::new(r"^idc-.*").unwrap();
+
+        if scroll_prefix.is_match(prover_name) || idc_prefix.is_match(prover_name) {
+            let parts = prover_name.split('-').collect::<Vec<&str>>();
+            format!("{}-{}", parts[0], parts[1])
+        } else {
+            let split_re = Regex::new(r"[-_]").unwrap();
+            let parts = split_re.split(prover_name).collect::<Vec<&str>>();
+            parts[0].to_string()
+        }
+    }
 }
 
 static SCROLL_PROVER_ASSETS_DIR_ENV_NAME: &str = "SCROLL_PROVER_ASSETS_DIR";

prover/src/coordinator_client.rs

@@ -4,7 +4,7 @@ pub mod listener;
 pub mod types;
 
 use anyhow::{bail, Context, Ok, Result};
-use std::rc::Rc;
+use std::{cell::OnceCell, rc::Rc};
 
 use api::Api;
 use errors::*;
@@ -14,11 +14,12 @@ use types::*;
 
 use crate::{config::Config, key_signer::KeySigner};
 
-pub use errors::ProofStatusNotOKError;
+pub use errors::{GetEmptyTaskError, ProofStatusNotOKError};
 
 pub struct CoordinatorClient<'a> {
     api: Api,
     token: Option<String>,
+    sentry_endpoint: OnceCell<Option<String>>,
     config: &'a Config,
     key_signer: Rc<KeySigner>,
     rt: Runtime,
@@ -46,6 +47,7 @@ impl<'a> CoordinatorClient<'a> {
         let mut client = Self {
             api,
             token: None,
+            sentry_endpoint: OnceCell::new(),
             config,
             key_signer,
             rt,
@@ -90,6 +92,9 @@ impl<'a> CoordinatorClient<'a> {
         }
         if let Some(r) = login_response.data {
             token = r.token;
+            let _ = self
+                .sentry_endpoint
+                .set(r.sentry_endpoint.filter(|s| !s.is_empty()));
         } else {
             bail!("login failed: got empty token")
         }
@@ -139,4 +144,8 @@ impl<'a> CoordinatorClient<'a> {
     ) -> Result<Response<SubmitProofResponseData>> {
         self.action_with_re_login(req, |s, req| s.do_submit_proof(req))
     }
+
+    pub fn get_sentry_dsn(&self) -> Option<String> {
+        self.sentry_endpoint.get().and_then(|v| v.clone())
+    }
 }

prover/src/coordinator_client/api.rs

@@ -69,7 +69,15 @@ impl Api {
         token: &String,
     ) -> Result<Response<GetTaskResponseData>> {
         let method = "/coordinator/v1/get_task";
-        self.post_with_token(method, req, token).await
+        let response = self
+            .post_with_token::<GetTaskRequest, Response<GetTaskResponseData>>(method, req, token)
+            .await?;
+
+        if response.errcode == ErrorCode::ErrCoordinatorEmptyProofData {
+            log::info!("coordinator return empty task");
+            return Err(anyhow::anyhow!(GetEmptyTaskError));
+        }
+        Ok(response)
     }
 
     pub async fn submit_proof(

prover/src/coordinator_client/errors.rs

@@ -55,6 +55,15 @@ impl<'de> Deserialize<'de> for ErrorCode {
 
 // ====================================================
 
+#[derive(Debug, Clone)]
+pub struct GetEmptyTaskError;
+
+impl fmt::Display for GetEmptyTaskError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "get empty task")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ProofStatusNotOKError;
 
@@ -63,3 +72,30 @@ impl fmt::Display for ProofStatusNotOKError {
         write!(f, "proof status not ok")
     }
 }
+
+// =================================== tests module ========================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::{Context, Ok, Result};
+
+    #[ctor::ctor]
+    fn init() {
+        crate::utils::log_init(None);
+        log::info!("logger initialized");
+    }
+
+    #[test]
+    fn test_anyhow_error_is() -> Result<()> {
+        let err: Result<()> =
+            Err(anyhow::anyhow!(GetEmptyTaskError)).context("this is a test context");
+
+        assert!(
+            err.unwrap_err().is::<GetEmptyTaskError>(),
+            "error matches after anyhow context"
+        );
+
+        Ok(())
+    }
+}

prover/src/coordinator_client/types.rs

@@ -52,6 +52,7 @@ pub struct LoginRequest {
 pub struct LoginResponseData {
     pub time: String,
     pub token: String,
+    pub sentry_endpoint: Option<String>,
 }
 
 pub type ChallengeResponseData = LoginResponseData;

prover/src/main.rs

@@ -1,5 +1,6 @@
 #![feature(lazy_cell)]
 #![feature(core_intrinsics)]
+#![feature(const_option)]
 
 mod config;
 mod coordinator_client;
@@ -38,6 +39,62 @@ struct Args {
     log_file: Option<String>,
 }
 
+fn start_loop<'a>(
+    config: &'a Config,
+    prover: &'a Prover<'a>,
+    task_cache: Rc<TaskCache>,
+    log_file: Option<String>,
+    current_dsn: Option<String>,
+) -> Option<String> {
+    let mut new_dsn: Option<String> = None;
+    let should_stop = || {
+        new_dsn = prover.coordinator_client.borrow().get_sentry_dsn();
+
+        current_dsn != new_dsn
+    };
+
+    let _guard = current_dsn.clone().map(|dsn| {
+        log::info!("successfully get dsn from coordinator");
+        let gurad = sentry::init((
+            dsn,
+            sentry::ClientOptions {
+                release: Some(version::get_version_cow()),
+                environment: Some(utils::get_environment()),
+                ..Default::default()
+            },
+        ));
+        utils::set_logger_with_sentry(log_file);
+        gurad
+    });
+
+    _guard.iter().for_each(|_| {
+        sentry::configure_scope(|scope| {
+            scope.set_tag("prover_type", config.prover_type);
+            scope.set_tag("partner_name", config.partner_name());
+            scope.set_tag("prover_name", config.prover_name.clone());
+
+            let public_key = sentry::protocol::Value::from(prover.get_public_key());
+            scope.set_extra("public_key", public_key);
+        });
+
+        sentry::capture_message("test message on start", sentry::Level::Info);
+    });
+
+    log::info!(
+        "prover start successfully. name: {}, type: {:?}, publickey: {}, version: {}",
+        config.prover_name,
+        config.prover_type,
+        prover.get_public_key(),
+        version::get_version(),
+    );
+
+    let task_processor = TaskProcessor::new(prover, task_cache);
+
+    task_processor.start(should_stop);
+
+    new_dsn
+}
+
 fn start() -> Result<()> {
     let args = Args::parse();
 
@@ -46,10 +103,10 @@ fn start() -> Result<()> {
         std::process::exit(0);
     }
 
-    utils::log_init(args.log_file);
-
     let config: Config = Config::from_file(args.config_file)?;
 
+    utils::log_init(args.log_file.clone());
+
     if let Err(e) = AssetsDirEnvConfig::init() {
         log::error!("AssetsDirEnvConfig init failed: {:#}", e);
         std::process::exit(-2);
@@ -63,19 +120,16 @@ fn start() -> Result<()> {
 
     let prover = Prover::new(&config, coordinator_listener)?;
 
-    log::info!(
-        "prover start successfully. name: {}, type: {:?}, publickey: {}, version: {}",
-        config.prover_name,
-        config.prover_type,
-        prover.get_public_key(),
-        version::get_version(),
-    );
-
-    let task_processor = TaskProcessor::new(&prover, task_cache);
-
-    task_processor.start();
-
-    Ok(())
+    let mut current_dsn = None;
+    loop {
+        current_dsn = start_loop(
+            &config,
+            &prover,
+            task_cache.clone(),
+            args.log_file.clone(),
+            current_dsn,
+        );
+    }
 }
 
 fn main() {

prover/src/prover.rs

@@ -19,7 +19,7 @@ pub struct Prover<'a> {
     config: &'a Config,
     key_signer: Rc<KeySigner>,
     circuits_handler_provider: RefCell<CircuitsHandlerProvider<'a>>,
-    coordinator_client: RefCell<CoordinatorClient<'a>>,
+    pub coordinator_client: RefCell<CoordinatorClient<'a>>,
     geth_client: Option<Rc<RefCell<GethClient>>>,
 }
 

prover/src/task_processor.rs

@@ -1,4 +1,8 @@
-use super::{coordinator_client::ProofStatusNotOKError, prover::Prover, task_cache::TaskCache};
+use super::{
+    coordinator_client::{GetEmptyTaskError, ProofStatusNotOKError},
+    prover::Prover,
+    task_cache::TaskCache,
+};
 use anyhow::{Context, Result};
 use std::rc::Rc;
 
@@ -12,11 +16,20 @@ impl<'a> TaskProcessor<'a> {
         TaskProcessor { prover, task_cache }
     }
 
-    pub fn start(&self) {
+    pub fn start<F>(&self, mut should_stop: F)
+    where
+        F: FnMut() -> bool,
+    {
         loop {
+            if should_stop() {
+                log::info!("task processor should stop.");
+                break;
+            }
             log::info!("start a new round.");
             if let Err(err) = self.prove_and_submit() {
-                if err.is::<ProofStatusNotOKError>() {
+                if err.is::<GetEmptyTaskError>() {
+                    log::info!("get empty task, skip.");
+                } else if err.is::<ProofStatusNotOKError>() {
                     log::info!("proof status not ok, downgrade level to info.");
                 } else {
                     log::error!("encounter error: {:#}", err);

prover/src/types.rs

@@ -1,3 +1,5 @@
+use std::fmt::Display;
+
 use ethers_core::types::H256;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
@@ -101,6 +103,13 @@ impl<'de> Deserialize<'de> for ProverType {
     }
 }
 
+impl Display for ProverType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(format!("{:?}", self).as_str())?;
+        Ok(())
+    }
+}
+
 #[derive(Serialize, Deserialize, Default)]
 pub struct Task {
     pub uuid: String,
@@ -243,3 +252,27 @@ impl Default for ProofStatus {
         Self::Ok
     }
 }
+
+// =================================== tests module ========================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::{Ok, Result};
+
+    #[ctor::ctor]
+    fn init() {
+        crate::utils::log_init(None);
+        log::info!("logger initialized");
+    }
+
+    #[test]
+    fn test_prover_type_display() -> Result<()> {
+        let chunk = ProverType::Chunk;
+        let batch = ProverType::Batch;
+
+        assert_eq!(chunk.to_string(), "Chunk");
+        assert_eq!(batch.to_string(), "Batch");
+        Ok(())
+    }
+}

prover/src/utils.rs

@@ -1,27 +1,36 @@
 use env_logger::Env;
-use std::{fs::OpenOptions, sync::Once};
+use std::{borrow::Cow, fs::OpenOptions};
 
 use crate::types::{ProverType, TaskType};
 
-static LOG_INIT: Once = Once::new();
+pub fn build_logger(log_file: Option<String>) -> env_logger::Logger {
+    let mut builder = env_logger::Builder::from_env(Env::default().default_filter_or("info"));
+    if let Some(file_path) = log_file {
+        let target = Box::new(
+            OpenOptions::new()
+                .write(true)
+                .create(true)
+                .truncate(false)
+                .open(file_path)
+                .expect("Can't create log file"),
+        );
+        builder.target(env_logger::Target::Pipe(target));
+    }
+    builder.build()
+}
 
-/// Initialize log
 pub fn log_init(log_file: Option<String>) {
-    LOG_INIT.call_once(|| {
-        let mut builder = env_logger::Builder::from_env(Env::default().default_filter_or("info"));
-        if let Some(file_path) = log_file {
-            let target = Box::new(
-                OpenOptions::new()
-                    .write(true)
-                    .create(true)
-                    .truncate(false)
-                    .open(file_path)
-                    .expect("Can't create log file"),
-            );
-            builder.target(env_logger::Target::Pipe(target));
-        }
-        builder.init();
-    });
+    let logger = build_logger(log_file);
+    let max_level = logger.filter();
+    let boxed_logger = Box::new(logger);
+    alterable_logger::configure(max_level, boxed_logger);
+}
+
+pub fn set_logger_with_sentry(log_file: Option<String>) {
+    let logger = build_logger(log_file);
+    let max_level = logger.filter();
+    let boxed_logger = Box::new(sentry_log::SentryLogger::with_dest(logger));
+    alterable_logger::configure(max_level, boxed_logger);
 }
 
 pub fn get_task_types(prover_type: ProverType) -> Vec<TaskType> {
@@ -30,3 +39,20 @@ pub fn get_task_types(prover_type: ProverType) -> Vec<TaskType> {
         ProverType::Batch => vec![TaskType::Batch, TaskType::Bundle],
     }
 }
+
+static ENV_UNKNOWN: &str = "unknown";
+static ENV_DEVNET: &str = "devnet";
+static ENV_SEPOLIA: &str = "sepolia";
+static ENV_MAINNET: &str = "mainnet";
+
+pub fn get_environment() -> Cow<'static, str> {
+    let env: &'static str = match std::env::var("CHAIN_ID") {
+        Ok(chain_id) => match chain_id.as_str() {
+            "534352" => ENV_MAINNET,
+            "534351" => ENV_SEPOLIA,
+            _ => ENV_DEVNET,
+        },
+        Err(_) => ENV_UNKNOWN,
+    };
+    std::borrow::Cow::Borrowed(env)
+}

prover/src/version.rs

@@ -1,18 +1,36 @@
-use std::cell::OnceCell;
+use std::borrow::Cow;
 
-static DEFAULT_COMMIT: &str = "unknown";
-static mut VERSION: OnceCell<String> = OnceCell::new();
-
-pub const TAG: &str = "v0.0.0";
-pub const DEFAULT_ZK_VERSION: &str = "000000-000000";
-
-fn init_version() -> String {
-    let commit = option_env!("GIT_REV").unwrap_or(DEFAULT_COMMIT);
-    let tag = option_env!("GO_TAG").unwrap_or(TAG);
-    let zk_version = option_env!("ZK_VERSION").unwrap_or(DEFAULT_ZK_VERSION);
-    format!("{tag}-{commit}-{zk_version}")
-}
+static RELEASE_VERSION: Option<&str> = option_env!("RELEASE_VERSION");
+const DEFAULT_VERSION: &str = "v0.0.0-unknown-000000-000000";
 
 pub fn get_version() -> String {
-    unsafe { VERSION.get_or_init(init_version).clone() }
+    RELEASE_VERSION.unwrap_or(DEFAULT_VERSION).to_string()
+}
+
+pub fn get_version_cow() -> Cow<'static, str> {
+    let v = RELEASE_VERSION.unwrap_or(DEFAULT_VERSION);
+    std::borrow::Cow::Borrowed(v)
+}
+
+// =================================== tests module ========================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::{Ok, Result};
+
+    #[ctor::ctor]
+    fn init() {
+        crate::utils::log_init(None);
+        log::info!("logger initialized");
+    }
+
+    #[test]
+    fn test_get_version_cow() -> Result<()> {
+        let version = get_version_cow();
+
+        assert_eq!(get_version(), DEFAULT_VERSION);
+        assert_eq!(&version, DEFAULT_VERSION);
+        Ok(())
+    }
 }

rollup/conf/config.json

@@ -24,12 +24,7 @@
         "l1_base_fee_default": 15000000000,
         "l1_blob_base_fee_default": 1
       },
-      "gas_oracle_sender_signer_config": {
-        "signer_type": "PrivateKey",
-        "private_key_signer_config": {
-          "private_key": "1313131313131313131313131313131313131313131313131313131313131313"
-        }
-      }
+      "gas_oracle_sender_private_key": "1313131313131313131313131313131313131313131313131313131313131313"
     }
   },
   "l2_config": {
@@ -65,24 +60,9 @@
       "enable_test_env_bypass_features": true,
       "finalize_batch_without_proof_timeout_sec": 7200,
       "finalize_bundle_without_proof_timeout_sec": 7200,
-      "gas_oracle_sender_signer_config": {
-        "signer_type": "PrivateKey",
-        "private_key_signer_config": {
-          "private_key": "1313131313131313131313131313131313131313131313131313131313131313"
-        }
-      },
-      "commit_sender_signer_config": {
-        "signer_type": "PrivateKey",
-        "private_key_signer_config": {
-          "private_key": "1414141414141414141414141414141414141414141414141414141414141414"
-        }
-      },
-      "finalize_sender_signer_config": {
-        "signer_type": "PrivateKey",
-        "private_key_signer_config": {
-          "private_key": "1515151515151515151515151515151515151515151515151515151515151515"
-        }
-      },
+      "gas_oracle_sender_private_key": "1313131313131313131313131313131313131313131313131313131313131313",
+      "commit_sender_private_key": "1414141414141414141414141414141414141414141414141414141414141414",
+      "finalize_sender_private_key": "1515151515151515151515151515151515151515151515151515151515151515",
       "l1_commit_gas_limit_multiplier": 1.2
     },
     "chunk_proposer_config": {

rollup/internal/config/config_test.go

@@ -61,25 +61,24 @@ func TestConfig(t *testing.T) {
 		assert.NoError(t, err)
 
 		os.Setenv("SCROLL_ROLLUP_DB_CONFIG_DSN", "postgres://test:test@postgresql:5432/scroll?sslmode=disable")
-		os.Setenv("SCROLL_ROLLUP_L1_CONFIG_RELAYER_CONFIG_GAS_ORACLE_SENDER_SIGNER_CONFIG_PRIVATE_KEY_SIGNER_CONFIG_PRIVATE_KEY", "1616161616161616161616161616161616161616161616161616161616161616")
-		os.Setenv("SCROLL_ROLLUP_L2_CONFIG_RELAYER_CONFIG_GAS_ORACLE_SENDER_SIGNER_CONFIG_PRIVATE_KEY_SIGNER_CONFIG_PRIVATE_KEY", "1717171717171717171717171717171717171717171717171717171717171717")
-		os.Setenv("SCROLL_ROLLUP_L2_CONFIG_RELAYER_CONFIG_COMMIT_SENDER_SIGNER_CONFIG_PRIVATE_KEY_SIGNER_CONFIG_PRIVATE_KEY", "1818181818181818181818181818181818181818181818181818181818181818")
-		os.Setenv("SCROLL_ROLLUP_L2_CONFIG_RELAYER_CONFIG_FINALIZE_SENDER_SIGNER_CONFIG_PRIVATE_KEY_SIGNER_CONFIG_PRIVATE_KEY", "1919191919191919191919191919191919191919191919191919191919191919")
+		os.Setenv("SCROLL_ROLLUP_L1_CONFIG_RELAYER_CONFIG_GAS_ORACLE_SENDER_PRIVATE_KEY", "1616161616161616161616161616161616161616161616161616161616161616")
+		os.Setenv("SCROLL_ROLLUP_L2_CONFIG_RELAYER_CONFIG_GAS_ORACLE_SENDER_PRIVATE_KEY", "1717171717171717171717171717171717171717171717171717171717171717")
+		os.Setenv("SCROLL_ROLLUP_L2_CONFIG_RELAYER_CONFIG_COMMIT_SENDER_PRIVATE_KEY", "1818181818181818181818181818181818181818181818181818181818181818")
+		os.Setenv("SCROLL_ROLLUP_L2_CONFIG_RELAYER_CONFIG_FINALIZE_SENDER_PRIVATE_KEY", "1919191919191919191919191919191919191919191919191919191919191919")
 
 		cfg2, err := NewConfig("../../conf/config.json")
 		assert.NoError(t, err)
 
 		assert.NotEqual(t, cfg.DBConfig.DSN, cfg2.DBConfig.DSN)
-		assert.NotEqual(t, cfg.L1Config.RelayerConfig.GasOracleSenderSignerConfig, cfg2.L1Config.RelayerConfig.GasOracleSenderSignerConfig)
-		assert.NotEqual(t, cfg.L2Config.RelayerConfig.GasOracleSenderSignerConfig, cfg2.L2Config.RelayerConfig.GasOracleSenderSignerConfig)
-		assert.NotEqual(t, cfg.L2Config.RelayerConfig.CommitSenderSignerConfig, cfg2.L2Config.RelayerConfig.CommitSenderSignerConfig)
-		assert.NotEqual(t, cfg.L2Config.RelayerConfig.FinalizeSenderSignerConfig, cfg2.L2Config.RelayerConfig.FinalizeSenderSignerConfig)
+		assert.NotEqual(t, cfg.L1Config.RelayerConfig.GasOracleSenderPrivateKey, cfg2.L1Config.RelayerConfig.GasOracleSenderPrivateKey)
+		assert.NotEqual(t, cfg.L2Config.RelayerConfig.GasOracleSenderPrivateKey, cfg2.L2Config.RelayerConfig.GasOracleSenderPrivateKey)
+		assert.NotEqual(t, cfg.L2Config.RelayerConfig.CommitSenderPrivateKey, cfg2.L2Config.RelayerConfig.CommitSenderPrivateKey)
+		assert.NotEqual(t, cfg.L2Config.RelayerConfig.FinalizeSenderPrivateKey, cfg2.L2Config.RelayerConfig.FinalizeSenderPrivateKey)
 
 		assert.Equal(t, cfg2.DBConfig.DSN, "postgres://test:test@postgresql:5432/scroll?sslmode=disable")
-		assert.Equal(t, "1414141414141414141414141414141414141414141414141414141414141414", cfg.L2Config.RelayerConfig.CommitSenderSignerConfig.PrivateKeySignerConfig.PrivateKey)
-		assert.Equal(t, "1616161616161616161616161616161616161616161616161616161616161616", cfg2.L1Config.RelayerConfig.GasOracleSenderSignerConfig.PrivateKeySignerConfig.PrivateKey)
-		assert.Equal(t, "1717171717171717171717171717171717171717171717171717171717171717", cfg2.L2Config.RelayerConfig.GasOracleSenderSignerConfig.PrivateKeySignerConfig.PrivateKey)
-		assert.Equal(t, "1818181818181818181818181818181818181818181818181818181818181818", cfg2.L2Config.RelayerConfig.CommitSenderSignerConfig.PrivateKeySignerConfig.PrivateKey)
-		assert.Equal(t, "1919191919191919191919191919191919191919191919191919191919191919", cfg2.L2Config.RelayerConfig.FinalizeSenderSignerConfig.PrivateKeySignerConfig.PrivateKey)
+		assert.Equal(t, "1616161616161616161616161616161616161616161616161616161616161616", cfg2.L1Config.RelayerConfig.GasOracleSenderPrivateKey)
+		assert.Equal(t, "1717171717171717171717171717171717171717171717171717171717171717", cfg2.L2Config.RelayerConfig.GasOracleSenderPrivateKey)
+		assert.Equal(t, "1818181818181818181818181818181818181818181818181818181818181818", cfg2.L2Config.RelayerConfig.CommitSenderPrivateKey)
+		assert.Equal(t, "1919191919191919191919191919191919191919191919191919191919191919", cfg2.L2Config.RelayerConfig.FinalizeSenderPrivateKey)
 	})
 }

rollup/internal/config/relayer.go

@@ -54,11 +54,10 @@ type RelayerConfig struct {
 	ChainMonitor *ChainMonitor `json:"chain_monitor"`
 	// L1CommitGasLimitMultiplier multiplier for fallback gas limit in commitBatch txs
 	L1CommitGasLimitMultiplier float64 `json:"l1_commit_gas_limit_multiplier,omitempty"`
-
-	// Configs of transaction signers (GasOracle, Commit, Finalize)
-	GasOracleSenderSignerConfig *SignerConfig `json:"gas_oracle_sender_signer_config"`
-	CommitSenderSignerConfig    *SignerConfig `json:"commit_sender_signer_config"`
-	FinalizeSenderSignerConfig  *SignerConfig `json:"finalize_sender_signer_config"`
+	// The private key of the relayer
+	GasOracleSenderPrivateKey string `json:"gas_oracle_sender_private_key"`
+	CommitSenderPrivateKey    string `json:"commit_sender_private_key"`
+	FinalizeSenderPrivateKey  string `json:"finalize_sender_private_key"`
 
 	// Indicates if bypass features specific to testing environments are enabled.
 	EnableTestEnvBypassFeatures bool `json:"enable_test_env_bypass_features"`
@@ -68,22 +67,12 @@ type RelayerConfig struct {
 	FinalizeBundleWithoutProofTimeoutSec uint64 `json:"finalize_bundle_without_proof_timeout_sec"`
 }
 
-// AlternativeGasTokenConfig The configuration for handling token exchange rates when updating the gas price oracle.
-type AlternativeGasTokenConfig struct {
-	Enabled           bool    `json:"enabled"`
-	Mode              string  `json:"mode"`
-	FixedExchangeRate float64 `json:"fixed_exchange_rate"` // fixed exchange rate of L2 gas token / L1 gas token
-	TokenSymbolPair   string  `json:"token_symbol_pair"`   // The pair should be L2 gas token symbol + L1 gas token symbol
-}
-
 // GasOracleConfig The config for updating gas price oracle.
 type GasOracleConfig struct {
 	// MinGasPrice store the minimum gas price to set.
 	MinGasPrice uint64 `json:"min_gas_price"`
 	// GasPriceDiff is the minimum percentage of gas price difference to update gas oracle.
 	GasPriceDiff uint64 `json:"gas_price_diff"`
-	// AlternativeGasTokenConfig The configuration for handling token exchange rates when updating the gas price oracle.
-	AlternativeGasTokenConfig *AlternativeGasTokenConfig `json:"alternative_gas_token_config"`
 
 	// The following configs are only for updating L1 gas price, used for sender in L2.
 	// The weight for L1 base fee.
@@ -95,21 +84,3 @@ type GasOracleConfig struct {
 	L1BaseFeeDefault                   uint64 `json:"l1_base_fee_default"`
 	L1BlobBaseFeeDefault               uint64 `json:"l1_blob_base_fee_default"`
 }
-
-// SignerConfig - config of signer, contains type and config corresponding to type
-type SignerConfig struct {
-	SignerType             string                  `json:"signer_type"` // type of signer can be PrivateKey or RemoteSigner
-	PrivateKeySignerConfig *PrivateKeySignerConfig `json:"private_key_signer_config"`
-	RemoteSignerConfig     *RemoteSignerConfig     `json:"remote_signer_config"`
-}
-
-// PrivateKeySignerConfig - config of private signer, contains private key
-type PrivateKeySignerConfig struct {
-	PrivateKey string `json:"private_key"` // private key of signer in case of PrivateKey signerType
-}
-
-// RemoteSignerConfig - config of private signer, contains address and remote URL
-type RemoteSignerConfig struct {
-	RemoteSignerUrl string `json:"remote_signer_url"` // remote signer url (web3signer) in case of RemoteSigner signerType
-	SignerAddress   string `json:"signer_address"`    // address of signer
-}

rollup/internal/controller/relayer/l1_relayer.go

@@ -10,6 +10,8 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
@@ -21,7 +23,6 @@ import (
 	"scroll-tech/rollup/internal/config"
 	"scroll-tech/rollup/internal/controller/sender"
 	"scroll-tech/rollup/internal/orm"
-	rutils "scroll-tech/rollup/internal/utils"
 )
 
 // Layer1Relayer is responsible for updating L1 gas price oracle contract on L2.
@@ -53,13 +54,18 @@ type Layer1Relayer struct {
 // NewLayer1Relayer will return a new instance of Layer1RelayerClient
 func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfig, chainCfg *params.ChainConfig, serviceType ServiceType, reg prometheus.Registerer) (*Layer1Relayer, error) {
 	var gasOracleSender *sender.Sender
-	var err error
 
 	switch serviceType {
 	case ServiceTypeL1GasOracle:
-		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderSignerConfig, "l1_relayer", "gas_oracle_sender", types.SenderTypeL1GasOracle, db, reg)
+		pKey, err := crypto.ToECDSA(common.FromHex(cfg.GasOracleSenderPrivateKey))
 		if err != nil {
-			return nil, fmt.Errorf("new gas oracle sender failed, err: %w", err)
+			return nil, fmt.Errorf("new gas oracle sender failed, err: %v", err)
+		}
+
+		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, pKey, "l1_relayer", "gas_oracle_sender", types.SenderTypeL1GasOracle, db, reg)
+		if err != nil {
+			addr := crypto.PubkeyToAddress(pKey.PublicKey)
+			return nil, fmt.Errorf("new gas oracle sender failed for address %s, err: %v", addr.Hex(), err)
 		}
 
 		// Ensure test features aren't enabled on the scroll mainnet.
@@ -152,31 +158,6 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 			baseFee = block.BaseFee
 		}
 
-		// include the token exchange rate in the fee data if alternative gas token enabled
-		if r.cfg.GasOracleConfig.AlternativeGasTokenConfig != nil && r.cfg.GasOracleConfig.AlternativeGasTokenConfig.Enabled {
-			// The exchange rate represent the number of native token on L1 required to exchange for 1 native token on L2.
-			var exchangeRate float64
-			switch r.cfg.GasOracleConfig.AlternativeGasTokenConfig.Mode {
-			case "Fixed":
-				exchangeRate = r.cfg.GasOracleConfig.AlternativeGasTokenConfig.FixedExchangeRate
-			case "BinanceApi":
-				exchangeRate, err = rutils.GetExchangeRateFromBinanceApi(r.cfg.GasOracleConfig.AlternativeGasTokenConfig.TokenSymbolPair, 5)
-				if err != nil {
-					log.Error("Failed to get gas token exchange rate from Binance api", "tokenSymbolPair", r.cfg.GasOracleConfig.AlternativeGasTokenConfig.TokenSymbolPair, "err", err)
-					return
-				}
-			default:
-				log.Error("Invalid alternative gas token mode", "mode", r.cfg.GasOracleConfig.AlternativeGasTokenConfig.Mode)
-				return
-			}
-			if exchangeRate == 0 {
-				log.Error("Invalid exchange rate", "exchangeRate", exchangeRate)
-				return
-			}
-			baseFee = uint64(math.Ceil(float64(baseFee) / exchangeRate))
-			blobBaseFee = uint64(math.Ceil(float64(blobBaseFee) / exchangeRate))
-		}
-
 		if r.shouldUpdateGasOracle(baseFee, blobBaseFee, isCurie) {
 			// It indicates the committing batch has been stuck for a long time, it's likely that the L1 gas fee spiked.
 			// If we are not committing batches due to high fees then we shouldn't update fees to prevent users from paying high l1_data_fee
@@ -191,11 +172,6 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 			} else if err != nil {
 				return
 			}
-
-			if err != nil {
-				fmt.Println(111)
-			}
-
 			var data []byte
 			if isCurie {
 				data, err = r.l1GasOracleABI.Pack("setL1BaseFeeAndBlobBaseFee", new(big.Int).SetUint64(baseFee), new(big.Int).SetUint64(blobBaseFee))

rollup/internal/controller/relayer/l2_relayer.go

@@ -2,9 +2,9 @@ package relayer
 
 import (
 	"context"
+	"crypto/ecdsa"
 	"errors"
 	"fmt"
-	"math"
 	"math/big"
 	"sort"
 	"strings"
@@ -76,33 +76,18 @@ type Layer2Relayer struct {
 
 // NewLayer2Relayer will return a new instance of Layer2RelayerClient
 func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.DB, cfg *config.RelayerConfig, chainCfg *params.ChainConfig, initGenesis bool, serviceType ServiceType, reg prometheus.Registerer) (*Layer2Relayer, error) {
+	gasOracleSenderPrivateKey, commitSenderPrivateKey, finalizeSenderPrivateKey, err := parsePrivateKeys(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse private keys provided by config, err: %v", err)
+	}
 
 	var gasOracleSender, commitSender, finalizeSender *sender.Sender
-	var err error
-
-	// check that all 3 signer addresses are different, because there will be a problem in managing nonce for different senders
-	gasOracleSenderAddr, err := addrFromSignerConfig(cfg.GasOracleSenderSignerConfig)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse addr from gas oracle signer config, err: %v", err)
-	}
-	commitSenderAddr, err := addrFromSignerConfig(cfg.CommitSenderSignerConfig)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse addr from commit sender config, err: %v", err)
-	}
-	finalizeSenderAddr, err := addrFromSignerConfig(cfg.FinalizeSenderSignerConfig)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse addr from finalize sender config, err: %v", err)
-	}
-	if gasOracleSenderAddr == commitSenderAddr || gasOracleSenderAddr == finalizeSenderAddr || commitSenderAddr == finalizeSenderAddr {
-		return nil, fmt.Errorf("gas oracle, commit, and finalize sender addresses must be different. Got: Gas Oracle=%s, Commit=%s, Finalize=%s",
-			gasOracleSenderAddr.Hex(), commitSenderAddr.Hex(), finalizeSenderAddr.Hex())
-	}
-
 	switch serviceType {
 	case ServiceTypeL2GasOracle:
-		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderSignerConfig, "l2_relayer", "gas_oracle_sender", types.SenderTypeL2GasOracle, db, reg)
+		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, gasOracleSenderPrivateKey, "l2_relayer", "gas_oracle_sender", types.SenderTypeL2GasOracle, db, reg)
 		if err != nil {
-			return nil, fmt.Errorf("new gas oracle sender failed, err: %w", err)
+			addr := crypto.PubkeyToAddress(gasOracleSenderPrivateKey.PublicKey)
+			return nil, fmt.Errorf("new gas oracle sender failed for address %s, err: %w", addr.Hex(), err)
 		}
 
 		// Ensure test features aren't enabled on the ethereum mainnet.
@@ -111,14 +96,16 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		}
 
 	case ServiceTypeL2RollupRelayer:
-		commitSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.CommitSenderSignerConfig, "l2_relayer", "commit_sender", types.SenderTypeCommitBatch, db, reg)
+		commitSender, err = sender.NewSender(ctx, cfg.SenderConfig, commitSenderPrivateKey, "l2_relayer", "commit_sender", types.SenderTypeCommitBatch, db, reg)
 		if err != nil {
-			return nil, fmt.Errorf("new commit sender failed, err: %w", err)
+			addr := crypto.PubkeyToAddress(commitSenderPrivateKey.PublicKey)
+			return nil, fmt.Errorf("new commit sender failed for address %s, err: %w", addr.Hex(), err)
 		}
 
-		finalizeSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.FinalizeSenderSignerConfig, "l2_relayer", "finalize_sender", types.SenderTypeFinalizeBatch, db, reg)
+		finalizeSender, err = sender.NewSender(ctx, cfg.SenderConfig, finalizeSenderPrivateKey, "l2_relayer", "finalize_sender", types.SenderTypeFinalizeBatch, db, reg)
 		if err != nil {
-			return nil, fmt.Errorf("new finalize sender failed, err: %w", err)
+			addr := crypto.PubkeyToAddress(finalizeSenderPrivateKey.PublicKey)
+			return nil, fmt.Errorf("new finalize sender failed for address %s, err: %w", addr.Hex(), err)
 		}
 
 		// Ensure test features aren't enabled on the ethereum mainnet.
@@ -325,32 +312,6 @@ func (r *Layer2Relayer) ProcessGasPriceOracle() {
 			return
 		}
 		suggestGasPriceUint64 := uint64(suggestGasPrice.Int64())
-
-		// include the token exchange rate in the fee data if alternative gas token enabled
-		if r.cfg.GasOracleConfig.AlternativeGasTokenConfig != nil && r.cfg.GasOracleConfig.AlternativeGasTokenConfig.Enabled {
-			// The exchange rate represent the number of native token on L1 required to exchange for 1 native token on L2.
-			var exchangeRate float64
-			switch r.cfg.GasOracleConfig.AlternativeGasTokenConfig.Mode {
-			case "Fixed":
-				exchangeRate = r.cfg.GasOracleConfig.AlternativeGasTokenConfig.FixedExchangeRate
-			case "BinanceApi":
-				exchangeRate, err = rutils.GetExchangeRateFromBinanceApi(r.cfg.GasOracleConfig.AlternativeGasTokenConfig.TokenSymbolPair, 5)
-				if err != nil {
-					log.Error("Failed to get gas token exchange rate from Binance api", "tokenSymbolPair", r.cfg.GasOracleConfig.AlternativeGasTokenConfig.TokenSymbolPair, "err", err)
-					return
-				}
-			default:
-				log.Error("Invalid alternative gas token mode", "mode", r.cfg.GasOracleConfig.AlternativeGasTokenConfig.Mode)
-				return
-			}
-			if exchangeRate == 0 {
-				log.Error("Invalid exchange rate", "exchangeRate", exchangeRate)
-				return
-			}
-			suggestGasPriceUint64 = uint64(math.Ceil(float64(suggestGasPriceUint64) * exchangeRate))
-			suggestGasPrice = new(big.Int).SetUint64(suggestGasPriceUint64)
-		}
-
 		expectedDelta := r.lastGasPrice * r.gasPriceDiff / gasPriceDiffPrecision
 		if r.lastGasPrice > 0 && expectedDelta == 0 {
 			expectedDelta = 1
@@ -1326,20 +1287,35 @@ func (r *Layer2Relayer) StopSenders() {
 	}
 }
 
-func addrFromSignerConfig(config *config.SignerConfig) (common.Address, error) {
-	switch config.SignerType {
-	case sender.PrivateKeySignerType:
-		privKey, err := crypto.ToECDSA(common.FromHex(config.PrivateKeySignerConfig.PrivateKey))
-		if err != nil {
-			return common.Address{}, fmt.Errorf("parse sender private key failed: %w", err)
-		}
-		return crypto.PubkeyToAddress(privKey.PublicKey), nil
-	case sender.RemoteSignerType:
-		if config.RemoteSignerConfig.SignerAddress == "" {
-			return common.Address{}, fmt.Errorf("signer address is empty")
-		}
-		return common.HexToAddress(config.RemoteSignerConfig.SignerAddress), nil
-	default:
-		return common.Address{}, fmt.Errorf("failed to determine signer address, unknown signer type: %v", config.SignerType)
+func parsePrivateKeys(cfg *config.RelayerConfig) (*ecdsa.PrivateKey, *ecdsa.PrivateKey, *ecdsa.PrivateKey, error) {
+	parseKey := func(hexKey string) (*ecdsa.PrivateKey, error) {
+		return crypto.ToECDSA(common.FromHex(hexKey))
 	}
+
+	gasOracleKey, err := parseKey(cfg.GasOracleSenderPrivateKey)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("parse gas oracle sender private key failed: %w", err)
+	}
+
+	commitKey, err := parseKey(cfg.CommitSenderPrivateKey)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("parse commit sender private key failed: %w", err)
+	}
+
+	finalizeKey, err := parseKey(cfg.FinalizeSenderPrivateKey)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("parse finalize sender private key failed: %w", err)
+	}
+
+	// Check if all three private keys are different
+	addrGasOracle := crypto.PubkeyToAddress(gasOracleKey.PublicKey)
+	addrCommit := crypto.PubkeyToAddress(commitKey.PublicKey)
+	addrFinalize := crypto.PubkeyToAddress(finalizeKey.PublicKey)
+
+	if addrGasOracle == addrCommit || addrGasOracle == addrFinalize || addrCommit == addrFinalize {
+		return nil, nil, nil, fmt.Errorf("gas oracle, commit, and finalize sender addresses must be different. Got: Gas Oracle=%s, Commit=%s, Finalize=%s",
+			addrGasOracle.Hex(), addrCommit.Hex(), addrFinalize.Hex())
+	}
+
+	return gasOracleKey, commitKey, finalizeKey, nil
 }

rollup/internal/controller/sender/estimategas.go

@@ -25,8 +25,8 @@ func (s *Sender) estimateLegacyGas(to *common.Address, data []byte, fallbackGasL
 
 	gasLimit, _, err := s.estimateGasLimit(to, data, nil, gasPrice, nil, nil, nil)
 	if err != nil {
-		log.Error("estimateLegacyGas estimateGasLimit failure", "gas price", gasPrice, "from", s.transactionSigner.GetAddr().String(),
-			"nonce", s.transactionSigner.GetNonce(), "to address", to.String(), "fallback gas limit", fallbackGasLimit, "error", err)
+		log.Error("estimateLegacyGas estimateGasLimit failure", "gas price", gasPrice, "from", s.auth.From.String(),
+			"nonce", s.auth.Nonce.Uint64(), "to address", to.String(), "fallback gas limit", fallbackGasLimit, "error", err)
 		if fallbackGasLimit == 0 {
 			return nil, err
 		}
@@ -56,7 +56,7 @@ func (s *Sender) estimateDynamicGas(to *common.Address, data []byte, baseFee uin
 	gasLimit, accessList, err := s.estimateGasLimit(to, data, nil, nil, gasTipCap, gasFeeCap, nil)
 	if err != nil {
 		log.Error("estimateDynamicGas estimateGasLimit failure",
-			"from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "to address", to.String(),
+			"from", s.auth.From.String(), "nonce", s.auth.Nonce.Uint64(), "to address", to.String(),
 			"fallback gas limit", fallbackGasLimit, "error", err)
 		if fallbackGasLimit == 0 {
 			return nil, err
@@ -93,7 +93,7 @@ func (s *Sender) estimateBlobGas(to *common.Address, data []byte, sidecar *gethT
 	gasLimit, accessList, err := s.estimateGasLimit(to, data, sidecar, nil, gasTipCap, gasFeeCap, blobGasFeeCap)
 	if err != nil {
 		log.Error("estimateBlobGas estimateGasLimit failure",
-			"from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "to address", to.String(),
+			"from", s.auth.From.String(), "nonce", s.auth.Nonce.Uint64(), "to address", to.String(),
 			"fallback gas limit", fallbackGasLimit, "error", err)
 		if fallbackGasLimit == 0 {
 			return nil, err
@@ -117,7 +117,7 @@ func (s *Sender) estimateBlobGas(to *common.Address, data []byte, sidecar *gethT
 
 func (s *Sender) estimateGasLimit(to *common.Address, data []byte, sidecar *gethTypes.BlobTxSidecar, gasPrice, gasTipCap, gasFeeCap, blobGasFeeCap *big.Int) (uint64, *types.AccessList, error) {
 	msg := ethereum.CallMsg{
-		From:      s.transactionSigner.GetAddr(),
+		From:      s.auth.From,
 		To:        to,
 		GasPrice:  gasPrice,
 		GasTipCap: gasTipCap,
@@ -136,8 +136,7 @@ func (s *Sender) estimateGasLimit(to *common.Address, data []byte, sidecar *geth
 		return 0, nil, err
 	}
 
-	if s.config.TxType == LegacyTxType ||
-		s.transactionSigner.GetType() == RemoteSignerType { // web3signer doesn't support access list
+	if s.config.TxType == LegacyTxType {
 		return gasLimitWithoutAccessList, nil, nil
 	}
 

rollup/internal/controller/sender/sender.go

@@ -3,6 +3,7 @@ package sender
 import (
 	"bytes"
 	"context"
+	"crypto/ecdsa"
 	"errors"
 	"fmt"
 	"math/big"
@@ -11,6 +12,7 @@ import (
 
 	"github.com/holiman/uint256"
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/consensus/misc"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
@@ -65,15 +67,16 @@ type FeeData struct {
 
 // Sender Transaction sender to send transaction to l1/l2 geth
 type Sender struct {
-	config            *config.SenderConfig
-	gethClient        *gethclient.Client
-	client            *ethclient.Client // The client to retrieve on chain data or send transaction.
-	transactionSigner *TransactionSigner
-	chainID           *big.Int // The chain id of the endpoint
-	ctx               context.Context
-	service           string
-	name              string
-	senderType        types.SenderType
+	config     *config.SenderConfig
+	gethClient *gethclient.Client
+	client     *ethclient.Client // The client to retrieve on chain data or send transaction.
+	chainID    *big.Int          // The chain id of the endpoint
+	ctx        context.Context
+	service    string
+	name       string
+	senderType types.SenderType
+
+	auth *bind.TransactOpts
 
 	db                    *gorm.DB
 	pendingTransactionOrm *orm.PendingTransaction
@@ -85,7 +88,7 @@ type Sender struct {
 }
 
 // NewSender returns a new instance of transaction sender
-func NewSender(ctx context.Context, config *config.SenderConfig, signerConfig *config.SignerConfig, service, name string, senderType types.SenderType, db *gorm.DB, reg prometheus.Registerer) (*Sender, error) {
+func NewSender(ctx context.Context, config *config.SenderConfig, priv *ecdsa.PrivateKey, service, name string, senderType types.SenderType, db *gorm.DB, reg prometheus.Registerer) (*Sender, error) {
 	if config.EscalateMultipleNum <= config.EscalateMultipleDen {
 		return nil, fmt.Errorf("invalid params, EscalateMultipleNum; %v, EscalateMultipleDen: %v", config.EscalateMultipleNum, config.EscalateMultipleDen)
 	}
@@ -100,17 +103,18 @@ func NewSender(ctx context.Context, config *config.SenderConfig, signerConfig *c
 	if err != nil {
 		return nil, fmt.Errorf("failed to get chain ID, err: %w", err)
 	}
-	transactionSigner, err := NewTransactionSigner(signerConfig, chainID)
+
+	auth, err := bind.NewKeyedTransactorWithChainID(priv, chainID)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create transaction signer, err: %w", err)
+		return nil, fmt.Errorf("failed to create transactor with chain ID %v, err: %w", chainID, err)
 	}
 
 	// Set pending nonce
-	nonce, err := client.PendingNonceAt(ctx, transactionSigner.GetAddr())
+	nonce, err := client.PendingNonceAt(ctx, auth.From)
 	if err != nil {
-		return nil, fmt.Errorf("failed to get pending nonce for address %s, err: %w", transactionSigner.GetAddr(), err)
+		return nil, fmt.Errorf("failed to get pending nonce for address %s, err: %w", auth.From.Hex(), err)
 	}
-	transactionSigner.SetNonce(nonce)
+	auth.Nonce = big.NewInt(int64(nonce))
 
 	sender := &Sender{
 		ctx:                   ctx,
@@ -118,7 +122,7 @@ func NewSender(ctx context.Context, config *config.SenderConfig, signerConfig *c
 		gethClient:            gethclient.New(rpcClient),
 		client:                client,
 		chainID:               chainID,
-		transactionSigner:     transactionSigner,
+		auth:                  auth,
 		db:                    db,
 		pendingTransactionOrm: orm.NewPendingTransaction(db),
 		confirmCh:             make(chan *Confirmation, 128),
@@ -142,7 +146,7 @@ func (s *Sender) GetChainID() *big.Int {
 // Stop stop the sender module.
 func (s *Sender) Stop() {
 	close(s.stopCh)
-	log.Info("sender stopped", "name", s.name, "service", s.service, "address", s.transactionSigner.GetAddr().String())
+	log.Info("sender stopped", "name", s.name, "service", s.service, "address", s.auth.From.String())
 }
 
 // ConfirmChan channel used to communicate with transaction sender
@@ -213,18 +217,18 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 
 	if feeData, err = s.getFeeData(target, data, sidecar, baseFee, blobBaseFee, fallbackGasLimit); err != nil {
 		s.metrics.sendTransactionFailureGetFee.WithLabelValues(s.service, s.name).Inc()
-		log.Error("failed to get fee data", "from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "fallback gas limit", fallbackGasLimit, "err", err)
+		log.Error("failed to get fee data", "from", s.auth.From.String(), "nonce", s.auth.Nonce.Uint64(), "fallback gas limit", fallbackGasLimit, "err", err)
 		return common.Hash{}, fmt.Errorf("failed to get fee data, err: %w", err)
 	}
 
 	if tx, err = s.createAndSendTx(feeData, target, data, sidecar, nil); err != nil {
 		s.metrics.sendTransactionFailureSendTx.WithLabelValues(s.service, s.name).Inc()
-		log.Error("failed to create and send tx (non-resubmit case)", "from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "err", err)
+		log.Error("failed to create and send tx (non-resubmit case)", "from", s.auth.From.String(), "nonce", s.auth.Nonce.Uint64(), "err", err)
 		return common.Hash{}, fmt.Errorf("failed to create and send transaction, err: %w", err)
 	}
 
 	if err = s.pendingTransactionOrm.InsertPendingTransaction(s.ctx, contextID, s.getSenderMeta(), tx, blockNumber); err != nil {
-		log.Error("failed to insert transaction", "from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "err", err)
+		log.Error("failed to insert transaction", "from", s.auth.From.String(), "nonce", s.auth.Nonce.Uint64(), "err", err)
 		return common.Hash{}, fmt.Errorf("failed to insert transaction, err: %w", err)
 	}
 	return tx.Hash(), nil
@@ -232,7 +236,7 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 
 func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, data []byte, sidecar *gethTypes.BlobTxSidecar, overrideNonce *uint64) (*gethTypes.Transaction, error) {
 	var (
-		nonce  = s.transactionSigner.GetNonce()
+		nonce  = s.auth.Nonce.Uint64()
 		txData gethTypes.TxData
 	)
 
@@ -264,7 +268,7 @@ func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, data
 			}
 		} else {
 			if target == nil {
-				log.Error("blob transaction to address cannot be nil", "address", s.transactionSigner.GetAddr().String(), "chainID", s.chainID.Uint64(), "nonce", s.transactionSigner.GetNonce())
+				log.Error("blob transaction to address cannot be nil", "address", s.auth.From.String(), "chainID", s.chainID.Uint64(), "nonce", s.auth.Nonce.Uint64())
 				return nil, errors.New("blob transaction to address cannot be nil")
 			}
 
@@ -285,15 +289,14 @@ func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, data
 	}
 
 	// sign and send
-	tx := gethTypes.NewTx(txData)
-	signedTx, err := s.transactionSigner.SignTransaction(s.ctx, tx)
+	signedTx, err := s.auth.Signer(s.auth.From, gethTypes.NewTx(txData))
 	if err != nil {
-		log.Error("failed to sign tx", "address", s.transactionSigner.GetAddr().String(), "err", err)
+		log.Error("failed to sign tx", "address", s.auth.From.String(), "err", err)
 		return nil, err
 	}
 
 	if err = s.client.SendTransaction(s.ctx, signedTx); err != nil {
-		log.Error("failed to send tx", "tx hash", signedTx.Hash().String(), "from", s.transactionSigner.GetAddr().String(), "nonce", signedTx.Nonce(), "err", err)
+		log.Error("failed to send tx", "tx hash", signedTx.Hash().String(), "from", s.auth.From.String(), "nonce", signedTx.Nonce(), "err", err)
 		// Check if contain nonce, and reset nonce
 		// only reset nonce when it is not from resubmit
 		if strings.Contains(err.Error(), "nonce too low") && overrideNonce == nil {
@@ -322,19 +325,19 @@ func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, data
 
 	// update nonce when it is not from resubmit
 	if overrideNonce == nil {
-		s.transactionSigner.SetNonce(nonce + 1)
+		s.auth.Nonce = big.NewInt(int64(nonce + 1))
 	}
 	return signedTx, nil
 }
 
 // resetNonce reset nonce if send signed tx failed.
 func (s *Sender) resetNonce(ctx context.Context) {
-	nonce, err := s.client.PendingNonceAt(ctx, s.transactionSigner.GetAddr())
+	nonce, err := s.client.PendingNonceAt(ctx, s.auth.From)
 	if err != nil {
-		log.Warn("failed to reset nonce", "address", s.transactionSigner.GetAddr().String(), "err", err)
+		log.Warn("failed to reset nonce", "address", s.auth.From.String(), "err", err)
 		return
 	}
-	s.transactionSigner.SetNonce(nonce)
+	s.auth.Nonce = big.NewInt(int64(nonce))
 }
 
 func (s *Sender) resubmitTransaction(tx *gethTypes.Transaction, baseFee, blobBaseFee uint64) (*gethTypes.Transaction, error) {
@@ -346,7 +349,7 @@ func (s *Sender) resubmitTransaction(tx *gethTypes.Transaction, baseFee, blobBas
 	txInfo := map[string]interface{}{
 		"tx_hash": tx.Hash().String(),
 		"tx_type": s.config.TxType,
-		"from":    s.transactionSigner.GetAddr().String(),
+		"from":    s.auth.From.String(),
 		"nonce":   tx.Nonce(),
 	}
 
@@ -470,7 +473,7 @@ func (s *Sender) resubmitTransaction(tx *gethTypes.Transaction, baseFee, blobBas
 	s.metrics.resubmitTransactionTotal.WithLabelValues(s.service, s.name).Inc()
 	tx, err := s.createAndSendTx(&feeData, tx.To(), tx.Data(), tx.BlobTxSidecar(), &nonce)
 	if err != nil {
-		log.Error("failed to create and send tx (resubmit case)", "from", s.transactionSigner.GetAddr().String(), "nonce", nonce, "err", err)
+		log.Error("failed to create and send tx (resubmit case)", "from", s.auth.From.String(), "nonce", nonce, "err", err)
 		return nil, err
 	}
 	return tx, nil
@@ -512,7 +515,7 @@ func (s *Sender) checkPendingTransaction() {
 				err := s.db.Transaction(func(dbTX *gorm.DB) error {
 					// Update the status of the transaction to TxStatusConfirmed.
 					if err := s.pendingTransactionOrm.UpdatePendingTransactionStatusByTxHash(s.ctx, tx.Hash(), types.TxStatusConfirmed, dbTX); err != nil {
-						log.Error("failed to update transaction status by tx hash", "hash", tx.Hash().String(), "sender meta", s.getSenderMeta(), "from", s.transactionSigner.GetAddr().String(), "nonce", tx.Nonce(), "err", err)
+						log.Error("failed to update transaction status by tx hash", "hash", tx.Hash().String(), "sender meta", s.getSenderMeta(), "from", s.auth.From.String(), "nonce", tx.Nonce(), "err", err)
 						return err
 					}
 					// Update other transactions with the same nonce and sender address as failed.
@@ -569,7 +572,7 @@ func (s *Sender) checkPendingTransaction() {
 				"service", s.service,
 				"name", s.name,
 				"hash", tx.Hash().String(),
-				"from", s.transactionSigner.GetAddr().String(),
+				"from", s.auth.From.String(),
 				"nonce", tx.Nonce(),
 				"submitBlockNumber", txnToCheck.SubmitBlockNumber,
 				"currentBlockNumber", blockNumber,
@@ -577,7 +580,7 @@ func (s *Sender) checkPendingTransaction() {
 
 			if newTx, err := s.resubmitTransaction(tx, baseFee, blobBaseFee); err != nil {
 				s.metrics.resubmitTransactionFailedTotal.WithLabelValues(s.service, s.name).Inc()
-				log.Error("failed to resubmit transaction", "context ID", txnToCheck.ContextID, "sender meta", s.getSenderMeta(), "from", s.transactionSigner.GetAddr().String(), "nonce", tx.Nonce(), "err", err)
+				log.Error("failed to resubmit transaction", "context ID", txnToCheck.ContextID, "sender meta", s.getSenderMeta(), "from", s.auth.From.String(), "nonce", tx.Nonce(), "err", err)
 			} else {
 				err := s.db.Transaction(func(dbTX *gorm.DB) error {
 					// Update the status of the original transaction as replaced, while still checking its confirmation status.
@@ -620,7 +623,7 @@ func (s *Sender) getSenderMeta() *orm.SenderMeta {
 	return &orm.SenderMeta{
 		Name:    s.name,
 		Service: s.service,
-		Address: s.transactionSigner.GetAddr(),
+		Address: s.auth.From,
 		Type:    s.senderType,
 	}
 }

rollup/internal/controller/sender/sender_test.go

@@ -38,9 +38,7 @@ import (
 )
 
 var (
-	privateKeyString     string
 	privateKey           *ecdsa.PrivateKey
-	signerConfig         *config.SignerConfig
 	cfg                  *config.Config
 	testApps             *testcontainers.TestcontainerApps
 	txTypes              = []string{"LegacyTx", "DynamicFeeTx", "DynamicFeeTx"}
@@ -55,9 +53,6 @@ func TestMain(m *testing.M) {
 		if testApps != nil {
 			testApps.Free()
 		}
-		if testAppsSignerTest != nil {
-			testAppsSignerTest.Free()
-		}
 	}()
 	m.Run()
 }
@@ -70,14 +65,7 @@ func setupEnv(t *testing.T) {
 	var err error
 	cfg, err = config.NewConfig("../../../conf/config.json")
 	assert.NoError(t, err)
-	privateKeyString = "1212121212121212121212121212121212121212121212121212121212121212"
-	signerConfig = &config.SignerConfig{
-		SignerType: "PrivateKey",
-		PrivateKeySignerConfig: &config.PrivateKeySignerConfig{
-			PrivateKey: privateKeyString,
-		},
-	}
-	priv, err := crypto.HexToECDSA(privateKeyString)
+	priv, err := crypto.HexToECDSA("1212121212121212121212121212121212121212121212121212121212121212")
 	assert.NoError(t, err)
 	privateKey = priv
 
@@ -160,7 +148,7 @@ func testNewSender(t *testing.T) {
 		// exit by Stop()
 		cfgCopy1 := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy1.TxType = txType
-		newSender1, err := NewSender(context.Background(), &cfgCopy1, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+		newSender1, err := NewSender(context.Background(), &cfgCopy1, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		newSender1.Stop()
 
@@ -168,7 +156,7 @@ func testNewSender(t *testing.T) {
 		cfgCopy2 := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy2.TxType = txType
 		subCtx, cancel := context.WithCancel(context.Background())
-		_, err = NewSender(subCtx, &cfgCopy2, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+		_, err = NewSender(subCtx, &cfgCopy2, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		cancel()
 	}
@@ -182,7 +170,7 @@ func testSendAndRetrieveTransaction(t *testing.T) {
 
 		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 
 		hash, err := s.SendTransaction("0", &common.Address{}, nil, txBlob[i], 0)
@@ -218,7 +206,7 @@ func testFallbackGasLimit(t *testing.T) {
 		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		cfgCopy.Confirmations = rpc.LatestBlockNumber
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 
 		client, err := ethclient.Dial(cfgCopy.Endpoint)
@@ -274,7 +262,7 @@ func testResubmitZeroGasPriceTransaction(t *testing.T) {
 
 		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		feeData := &FeeData{
 			gasPrice:  big.NewInt(0),
@@ -314,7 +302,7 @@ func testAccessListTransactionGasLimit(t *testing.T) {
 
 		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 
 		l2GasOracleABI, err := bridgeAbi.L2GasPriceOracleMetaData.GetAbi()
@@ -355,7 +343,7 @@ func testResubmitNonZeroGasPriceTransaction(t *testing.T) {
 		cfgCopy.EscalateMultipleNum = 110
 		cfgCopy.EscalateMultipleDen = 100
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		feeData := &FeeData{
 			gasPrice:      big.NewInt(1000000000),
@@ -404,7 +392,7 @@ func testResubmitUnderpricedTransaction(t *testing.T) {
 		cfgCopy.EscalateMultipleNum = 109
 		cfgCopy.EscalateMultipleDen = 100
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		feeData := &FeeData{
 			gasPrice:  big.NewInt(1000000000),
@@ -441,7 +429,7 @@ func testResubmitDynamicFeeTransactionWithRisingBaseFee(t *testing.T) {
 	cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 	cfgCopy.TxType = txType
 
-	s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+	s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 	assert.NoError(t, err)
 
 	patchGuard := gomonkey.ApplyMethodFunc(s.client, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
@@ -450,7 +438,7 @@ func testResubmitDynamicFeeTransactionWithRisingBaseFee(t *testing.T) {
 	defer patchGuard.Reset()
 
 	tx := gethTypes.NewTx(&gethTypes.DynamicFeeTx{
-		Nonce:     s.transactionSigner.GetNonce(),
+		Nonce:     s.auth.Nonce.Uint64(),
 		To:        &common.Address{},
 		Data:      nil,
 		Gas:       21000,
@@ -483,7 +471,7 @@ func testResubmitBlobTransactionWithRisingBaseFeeAndBlobBaseFee(t *testing.T) {
 	cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 	cfgCopy.TxType = DynamicFeeTxType
 
-	s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+	s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 	assert.NoError(t, err)
 
 	patchGuard := gomonkey.ApplyMethodFunc(s.client, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
@@ -495,7 +483,7 @@ func testResubmitBlobTransactionWithRisingBaseFeeAndBlobBaseFee(t *testing.T) {
 	assert.NoError(t, err)
 	tx := gethTypes.NewTx(&gethTypes.BlobTx{
 		ChainID:    uint256.MustFromBig(s.chainID),
-		Nonce:      s.transactionSigner.GetNonce(),
+		Nonce:      s.auth.Nonce.Uint64(),
 		GasTipCap:  uint256.MustFromBig(big.NewInt(0)),
 		GasFeeCap:  uint256.MustFromBig(big.NewInt(0)),
 		Gas:        21000,
@@ -551,7 +539,7 @@ func testResubmitNonceGappedTransaction(t *testing.T) {
 		// stop background check pending transaction
 		cfgCopy.CheckPendingTime = math.MaxUint32
 
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 
 		patchGuard1 := gomonkey.ApplyMethodFunc(s.client, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
@@ -600,7 +588,7 @@ func testCheckPendingTransactionTxConfirmed(t *testing.T) {
 
 		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeCommitBatch, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeCommitBatch, db, nil)
 		assert.NoError(t, err)
 
 		patchGuard1 := gomonkey.ApplyMethodFunc(s.client, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
@@ -642,7 +630,7 @@ func testCheckPendingTransactionResubmitTxConfirmed(t *testing.T) {
 		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		cfgCopy.EscalateBlocks = 0
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeFinalizeBatch, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeFinalizeBatch, db, nil)
 		assert.NoError(t, err)
 
 		patchGuard1 := gomonkey.ApplyMethodFunc(s.client, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
@@ -702,7 +690,7 @@ func testCheckPendingTransactionReplacedTxConfirmed(t *testing.T) {
 		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		cfgCopy.EscalateBlocks = 0
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeL1GasOracle, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeL1GasOracle, db, nil)
 		assert.NoError(t, err)
 
 		patchGuard1 := gomonkey.ApplyMethodFunc(s.client, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
@@ -772,7 +760,7 @@ func testCheckPendingTransactionTxMultipleTimesWithOnlyOneTxPending(t *testing.T
 		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		cfgCopy.EscalateBlocks = 0
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeCommitBatch, db, nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeCommitBatch, db, nil)
 		assert.NoError(t, err)
 
 		patchGuard1 := gomonkey.ApplyMethodFunc(s.client, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
@@ -849,7 +837,7 @@ func testBlobTransactionWithBlobhashOpContractCall(t *testing.T) {
 
 	cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 	cfgCopy.TxType = DynamicFeeTxType
-	s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeL1GasOracle, db, nil)
+	s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeL1GasOracle, db, nil)
 	assert.NoError(t, err)
 	defer s.Stop()
 
@@ -901,7 +889,7 @@ func testSendBlobCarryingTxOverLimit(t *testing.T) {
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(sqlDB))
-	s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeCommitBatch, db, nil)
+	s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeCommitBatch, db, nil)
 	assert.NoError(t, err)
 
 	for i := 0; i < int(cfgCopy.MaxPendingBlobTxs); i++ {

rollup/internal/controller/sender/transaction_signer.go

@@ -1,156 +0,0 @@
-package sender
-
-import (
-	"context"
-	"fmt"
-	"math/big"
-
-	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/common/hexutil"
-	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/crypto"
-	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/scroll-tech/go-ethereum/rpc"
-
-	"scroll-tech/rollup/internal/config"
-)
-
-const (
-	// PrivateKeySignerType
-	PrivateKeySignerType = "PrivateKey"
-
-	// RemoteSignerType
-	RemoteSignerType = "RemoteSigner"
-)
-
-// TransactionSigner signs given transactions
-type TransactionSigner struct {
-	config    *config.SignerConfig
-	auth      *bind.TransactOpts
-	rpcClient *rpc.Client
-	nonce     uint64
-	addr      common.Address
-}
-
-func NewTransactionSigner(config *config.SignerConfig, chainID *big.Int) (*TransactionSigner, error) {
-	switch config.SignerType {
-	case PrivateKeySignerType:
-		privKey, err := crypto.ToECDSA(common.FromHex(config.PrivateKeySignerConfig.PrivateKey))
-		if err != nil {
-			return nil, fmt.Errorf("parse sender private key failed: %w", err)
-		}
-		auth, err := bind.NewKeyedTransactorWithChainID(privKey, chainID)
-		if err != nil {
-			return nil, fmt.Errorf("failed to create transactor with chain ID %v, err: %w", chainID, err)
-		}
-		return &TransactionSigner{
-			config: config,
-			auth:   auth,
-			addr:   crypto.PubkeyToAddress(privKey.PublicKey),
-		}, nil
-	case RemoteSignerType:
-		if config.RemoteSignerConfig.SignerAddress == "" {
-			return nil, fmt.Errorf("failed to create RemoteSigner, signer address is empty")
-		}
-		rpcClient, err := rpc.Dial(config.RemoteSignerConfig.RemoteSignerUrl)
-		if err != nil {
-			return nil, fmt.Errorf("failed to dial rpc client, err: %w", err)
-		}
-		return &TransactionSigner{
-			config:    config,
-			rpcClient: rpcClient,
-			addr:      common.HexToAddress(config.RemoteSignerConfig.SignerAddress),
-		}, nil
-	default:
-		return nil, fmt.Errorf("failed to create new transaction signer, unknown type: %v", config.SignerType)
-	}
-}
-
-func (ts *TransactionSigner) SignTransaction(ctx context.Context, tx *gethTypes.Transaction) (*gethTypes.Transaction, error) {
-	switch ts.config.SignerType {
-	case PrivateKeySignerType:
-		signedTx, err := ts.auth.Signer(ts.addr, tx)
-		if err != nil {
-			log.Info("failed to sign tx", "address", ts.addr.String(), "err", err)
-			return nil, err
-		}
-		return signedTx, nil
-	case RemoteSignerType:
-		rpcTx, err := txDataToRpcTx(&ts.addr, tx)
-		if err != nil {
-			return nil, fmt.Errorf("failed to convert txData to rpc transaction, err: %w", err)
-		}
-		var result hexutil.Bytes
-		err = ts.rpcClient.CallContext(ctx, &result, "eth_signTransaction", rpcTx)
-		if err != nil {
-			log.Info("failed to call remote rpc", "err", err)
-			return nil, err
-		}
-		signedTx := new(gethTypes.Transaction)
-		if err := signedTx.UnmarshalBinary(result); err != nil {
-			return nil, err
-		}
-		return signedTx, nil
-	default:
-		// this shouldn't happen, because SignerType is checked during creation
-		return nil, fmt.Errorf("shouldn't happen, unknown signer type")
-	}
-}
-
-func (ts *TransactionSigner) SetNonce(nonce uint64) {
-	ts.nonce = nonce
-}
-
-func (ts *TransactionSigner) GetNonce() uint64 {
-	return ts.nonce
-}
-
-func (ts *TransactionSigner) GetAddr() common.Address {
-	return ts.addr
-}
-
-func (ts *TransactionSigner) GetType() string {
-	return ts.config.SignerType
-}
-
-// RpcTransaction transaction that will be send through rpc to web3Signer
-type RpcTransaction struct {
-	From                 *common.Address `json:"from"`
-	To                   *common.Address `json:"to"`
-	Gas                  uint64          `json:"gas"`
-	GasPrice             *big.Int        `json:"gasPrice,omitempty"`
-	MaxPriorityFeePerGas *big.Int        `json:"maxPriorityFeePerGas,omitempty"`
-	MaxFeePerGas         *big.Int        `json:"maxFeePerGas,omitempty"`
-	Nonce                uint64          `json:"nonce"`
-	Value                *big.Int        `json:"value"`
-	Data                 string          `json:"data"`
-}
-
-func txDataToRpcTx(from *common.Address, tx *gethTypes.Transaction) (*RpcTransaction, error) {
-	switch tx.Type() {
-	case gethTypes.LegacyTxType:
-		return &RpcTransaction{
-			From:     from,
-			To:       tx.To(),
-			Gas:      tx.Gas(),
-			GasPrice: tx.GasPrice(),
-			Nonce:    tx.Nonce(),
-			Value:    tx.Value(),
-			Data:     common.Bytes2Hex(tx.Data()),
-		}, nil
-	case gethTypes.DynamicFeeTxType:
-		return &RpcTransaction{
-			From:                 from,
-			To:                   tx.To(),
-			Gas:                  tx.Gas(),
-			MaxPriorityFeePerGas: tx.GasTipCap(),
-			MaxFeePerGas:         tx.GasFeeCap(),
-			Nonce:                tx.Nonce(),
-			Value:                tx.Value(),
-			Data:                 common.Bytes2Hex(tx.Data()),
-		}, nil
-	default: // other tx types (BlobTx) currently not supported by web3signer
-		return nil, fmt.Errorf("failed to convert tx to RpcTransaction, unsupported tx type, %d", tx.Type())
-	}
-}

rollup/internal/controller/sender/transaction_signer_test.go

@@ -1,122 +0,0 @@
-package sender
-
-import (
-	"context"
-	"math/big"
-	"os"
-	"testing"
-
-	"github.com/holiman/uint256"
-	"github.com/scroll-tech/go-ethereum/common"
-	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/stretchr/testify/assert"
-
-	"scroll-tech/common/testcontainers"
-
-	"scroll-tech/rollup/internal/config"
-)
-
-var (
-	testAppsSignerTest *testcontainers.TestcontainerApps
-	chainId            int
-)
-
-func setupEnvSignerTest(t *testing.T) {
-	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.LogfmtFormat()))
-	glogger.Verbosity(log.LvlInfo)
-	log.Root().SetHandler(glogger)
-
-	chainId = 1
-	testAppsSignerTest = testcontainers.NewTestcontainerApps()
-	assert.NoError(t, testAppsSignerTest.StartWeb3SignerContainer(chainId))
-}
-
-func TestTransactionSigner(t *testing.T) {
-	setupEnvSignerTest(t)
-	t.Run("test both signer types", testBothSignerTypes)
-}
-
-func testBothSignerTypes(t *testing.T) {
-	endpoint, err := testAppsSignerTest.GetWeb3SignerEndpoint()
-	assert.NoError(t, err)
-
-	// create remote signer
-	remoteSignerConf := &config.SignerConfig{
-		SignerType: RemoteSignerType,
-		RemoteSignerConfig: &config.RemoteSignerConfig{
-			SignerAddress:   "0x1C5A77d9FA7eF466951B2F01F724BCa3A5820b63",
-			RemoteSignerUrl: endpoint,
-		},
-	}
-	remoteSigner, err := NewTransactionSigner(remoteSignerConf, big.NewInt(int64(chainId)))
-	assert.NoError(t, err)
-	remoteSigner.SetNonce(2)
-
-	// create private key signer
-	privateKeySignerConf := &config.SignerConfig{
-		SignerType: PrivateKeySignerType,
-		PrivateKeySignerConfig: &config.PrivateKeySignerConfig{
-			PrivateKey: "1212121212121212121212121212121212121212121212121212121212121212",
-		},
-	}
-	privateKeySigner, err := NewTransactionSigner(privateKeySignerConf, big.NewInt(int64(chainId)))
-	assert.NoError(t, err)
-	privateKeySigner.SetNonce(2)
-
-	assert.Equal(t, remoteSigner.GetAddr(), privateKeySigner.GetAddr())
-
-	to := common.BytesToAddress([]byte{0, 1, 2, 3})
-	data := []byte("data")
-
-	// check LegacyTx and DynamicFeeTx - transactions supported by web3signer
-	txDatas := []gethTypes.TxData{
-		&gethTypes.LegacyTx{
-			Nonce:    remoteSigner.GetNonce(),
-			GasPrice: big.NewInt(1000),
-			Gas:      10000,
-			To:       &to,
-			Data:     data,
-		},
-		&gethTypes.DynamicFeeTx{
-			Nonce:     remoteSigner.GetNonce(),
-			Gas:       10000,
-			To:        &to,
-			Data:      data,
-			ChainID:   big.NewInt(int64(chainId)),
-			GasTipCap: big.NewInt(2000),
-			GasFeeCap: big.NewInt(3000),
-		},
-	}
-	var signedTx1 *gethTypes.Transaction
-	var signedTx2 *gethTypes.Transaction
-	for _, txData := range txDatas {
-		tx := gethTypes.NewTx(txData)
-
-		signedTx1, err = remoteSigner.SignTransaction(context.Background(), tx)
-		assert.NoError(t, err)
-
-		signedTx2, err = privateKeySigner.SignTransaction(context.Background(), tx)
-		assert.NoError(t, err)
-
-		assert.Equal(t, signedTx1.Hash(), signedTx2.Hash())
-	}
-
-	// BlobTx is not supported
-	txData := &gethTypes.BlobTx{
-		Nonce:      remoteSigner.GetNonce(),
-		Gas:        10000,
-		To:         to,
-		Data:       data,
-		ChainID:    uint256.NewInt(1),
-		GasTipCap:  uint256.NewInt(2000),
-		GasFeeCap:  uint256.NewInt(3000),
-		BlobFeeCap: uint256.NewInt(1),
-		BlobHashes: []common.Hash{},
-		Sidecar:    nil,
-	}
-	tx := gethTypes.NewTx(txData)
-
-	_, err = remoteSigner.SignTransaction(context.Background(), tx)
-	assert.Error(t, err)
-}

rollup/internal/controller/watcher/bundle_proposer.go

@@ -2,7 +2,6 @@ package watcher
 
 import (
 	"context"
-	"errors"
 	"time"
 
 	"github.com/prometheus/client_golang/prometheus"
@@ -147,12 +146,6 @@ func (p *BundleProposer) proposeBundle() error {
 	if err != nil {
 		return err
 	}
-
-	if firstChunk == nil {
-		log.Error("first chunk not found", "start chunk index", batches[0].StartChunkIndex, "start batch index", batches[0].Index, "firstUnbundledBatchIndex", firstUnbundledBatchIndex)
-		return errors.New("first chunk not found in proposeBundle")
-	}
-
 	hardforkName := forks.GetHardforkName(p.chainCfg, firstChunk.StartBlockNumber, firstChunk.StartBlockTime)
 	codecVersion := encoding.CodecVersion(batches[0].CodecVersion)
 	for i := 1; i < len(batches); i++ {

rollup/internal/utils/exchange_rate.go

@@ -1,73 +0,0 @@
-package utils
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strconv"
-	"time"
-
-	"github.com/scroll-tech/go-ethereum/log"
-)
-
-var BinanceApiEndpoint string = "https://api.binance.com/api/v3/ticker/price?symbol=%s"
-
-type BinanceResponse struct {
-	Price string `json:"price"`
-}
-
-func GetExchangeRateFromBinanceApi(tokenSymbolPair string, maxRetries int) (float64, error) {
-	for i := 0; i < maxRetries; i++ {
-		if i > 0 {
-			time.Sleep(5 * time.Second)
-		}
-
-		// make HTTP GET request
-		resp, err := http.Get(fmt.Sprintf(BinanceApiEndpoint, tokenSymbolPair))
-		if err != nil {
-			log.Error("error making HTTP request", "err", err)
-			continue
-		}
-		defer func() {
-			err = resp.Body.Close()
-			if err != nil {
-				log.Error("error closing response body", "err", err)
-			}
-		}()
-
-		// check for successful response
-		if resp.StatusCode != http.StatusOK {
-			log.Error("unexpected status code", "code", resp.StatusCode)
-			continue
-		}
-
-		// read response body
-		body, err := io.ReadAll(resp.Body)
-		if err != nil {
-			log.Error("error reading response body", "err", err)
-			continue
-		}
-
-		// unmarshal JSON response
-		var data BinanceResponse
-		err = json.Unmarshal(body, &data)
-		if err != nil {
-			log.Error("error unmarshaling JSON", "err", err)
-			continue
-		}
-
-		// convert price string to float64
-		price, err := strconv.ParseFloat(data.Price, 64)
-		if err != nil {
-			log.Error("error parsing price string", "err", err)
-			continue
-		}
-
-		// successful response, return price
-		return price, nil
-	}
-
-	// all retries failed, return error
-	return 0, fmt.Errorf("failed to get exchange rate after %d retries", maxRetries)
-}

rollup/tests/bridge_test.go

@@ -105,12 +105,12 @@ func setupEnv(t *testing.T) {
 	l2Cfg.Confirmations = 0
 	l2Cfg.RelayerConfig.SenderConfig.Confirmations = 0
 
-	pKey, err := crypto.ToECDSA(common.FromHex(l2Cfg.RelayerConfig.CommitSenderSignerConfig.PrivateKeySignerConfig.PrivateKey))
+	pKey, err := crypto.ToECDSA(common.FromHex(l2Cfg.RelayerConfig.CommitSenderPrivateKey))
 	assert.NoError(t, err)
 	l1Auth, err = bind.NewKeyedTransactorWithChainID(pKey, l1GethChainID)
 	assert.NoError(t, err)
 
-	pKey, err = crypto.ToECDSA(common.FromHex(l2Cfg.RelayerConfig.GasOracleSenderSignerConfig.PrivateKeySignerConfig.PrivateKey))
+	pKey, err = crypto.ToECDSA(common.FromHex(l2Cfg.RelayerConfig.GasOracleSenderPrivateKey))
 	assert.NoError(t, err)
 	l2Auth, err = bind.NewKeyedTransactorWithChainID(pKey, l2GethChainID)
 	assert.NoError(t, err)

tests/integration-test/contracts_test.go

@@ -68,7 +68,7 @@ func testGreeter(t *testing.T) {
 
 	chainID, err := l2Cli.ChainID(context.Background())
 	assert.NoError(t, err)
-	pKey, err := crypto.ToECDSA(common.FromHex(rollupApp.Config.L2Config.RelayerConfig.CommitSenderSignerConfig.PrivateKeySignerConfig.PrivateKey))
+	pKey, err := crypto.ToECDSA(common.FromHex(rollupApp.Config.L2Config.RelayerConfig.CommitSenderPrivateKey))
 	assert.NoError(t, err)
 	auth, err := bind.NewKeyedTransactorWithChainID(pKey, chainID)
 	assert.NoError(t, err)