update

.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

Makefile

@@ -1,6 +1,6 @@
 .PHONY: fmt dev_docker build_test_docker run_test_docker clean update
 
-L2GETH_TAG=scroll-v5.6.3
+L2GETH_TAG=scroll-v5.5.1
 
 help: ## Display this help message
 	@grep -h \
@@ -40,8 +40,8 @@ fmt: ## Format the code
 
 dev_docker: ## Build docker images for development/testing usages
 	docker pull postgres
-	docker build -t scroll_l1geth --platform linux/amd64 ./common/testcontainers/docker/l1geth/
-	docker build -t scroll_l2geth --platform linux/amd64 ./common/testcontainers/docker/l2geth/
+	docker build -t scroll_l1geth ./common/testcontainers/docker/l1geth/
+	docker build -t scroll_l2geth ./common/testcontainers/docker/l2geth/
 
 clean: ## Empty out the bin folder
 	@rm -rf build/bin

README.md

@@ -18,7 +18,7 @@
 ├── <a href="./database">database</a>: Database client and schema definition
 ├── <a href="./prover">prover</a>: Prover client that runs proof generation for zkEVM circuit and aggregation circuit
 ├── <a href="./rollup">rollup</a>: Rollup-related services
-├── <a href="https://github.com/scroll-tech/scroll-contracts.git">scroll-contracts</a>: solidity code for Scroll L1 bridge and rollup contracts and L2 bridge and pre-deployed contracts.
+├── <a href="./scroll-contracts">scroll-contracts</a>: solidity code for Scroll L1 bridge and rollup contracts and L2 bridge and pre-deployed contracts.
 └── <a href="./tests">tests</a>: Integration tests
 </pre>
 

bridge-history-api/conf/config.json

@@ -19,9 +19,7 @@
 		"ScrollChainAddr": "0xa13BAF47339d63B743e7Da8741db5456DAc1E556",
 		"GatewayRouterAddr": "0xF8B1378579659D8F7EE5f3C929c2f3E332E41Fd6",
 		"MessageQueueAddr": "0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B",
-		"BatchBridgeGatewayAddr": "0x5Bcfd99c34cf7E06fc756f6f5aE7400504852bc4",
-		"GasTokenGatewayAddr": "0x0000000000000000000000000000000000000000",
-		"WrappedTokenGatewayAddr": "0x0000000000000000000000000000000000000000"
+		"BatchBridgeGatewayAddr": "0x5Bcfd99c34cf7E06fc756f6f5aE7400504852bc4"
 	},
 	"L2": {
 		"confirmation": 0,

bridge-history-api/internal/config/config.go

@@ -6,7 +6,6 @@ import (
 	"path/filepath"
 
 	"scroll-tech/common/database"
-	"scroll-tech/common/utils"
 )
 
 // FetcherConfig is the configuration of Layer1 or Layer2 fetcher.
@@ -31,8 +30,6 @@ type FetcherConfig struct {
 	GatewayRouterAddr        string `json:"GatewayRouterAddr"`
 	MessageQueueAddr         string `json:"MessageQueueAddr"`
 	BatchBridgeGatewayAddr   string `json:"BatchBridgeGatewayAddr"`
-	GasTokenGatewayAddr      string `json:"GasTokenGatewayAddr"`
-	WrappedTokenGatewayAddr  string `json:"WrappedTokenGatewayAddr"`
 }
 
 // RedisConfig redis config
@@ -67,11 +64,5 @@ func NewConfig(file string) (*Config, error) {
 		return nil, err
 	}
 
-	// Override config with environment variables
-	err = utils.OverrideConfigWithEnv(cfg, "SCROLL_BRIDGE_HISTORY")
-	if err != nil {
-		return nil, err
-	}
-
 	return cfg, nil
 }

bridge-history-api/internal/logic/l1_event_parser.go

@@ -168,14 +168,6 @@ func (e *L1EventParser) ParseL1SingleCrossChainEventLogs(ctx context.Context, lo
 			lastMessage.L2TokenAddress = event.L2Token.String()
 			lastMessage.TokenIDs = utils.ConvertBigIntArrayToString(event.TokenIDs)
 			lastMessage.TokenAmounts = utils.ConvertBigIntArrayToString(event.TokenAmounts)
-		case backendabi.L1DepositWrappedTokenSig:
-			event := backendabi.WrappedTokenMessageEvent{}
-			if err := utils.UnpackLog(backendabi.L1WrappedTokenGatewayABI, &event, "DepositWrappedToken", vlog); err != nil {
-				log.Error("Failed to unpack DepositWrappedToken event", "err", err)
-				return nil, nil, err
-			}
-			lastMessage := l1DepositMessages[len(l1DepositMessages)-1]
-			lastMessage.Sender = event.From.String()
 		case backendabi.L1SentMessageEventSig:
 			event := backendabi.L1SentMessageEvent{}
 			if err := utils.UnpackLog(backendabi.IL1ScrollMessengerABI, &event, "SentMessage", vlog); err != nil {

bridge-history-api/internal/logic/l1_fetcher.go

@@ -51,8 +51,11 @@ type L1FetcherLogic struct {
 // NewL1FetcherLogic creates L1 fetcher logic
 func NewL1FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client) *L1FetcherLogic {
 	addressList := []common.Address{
+		common.HexToAddress(cfg.ETHGatewayAddr),
+
 		common.HexToAddress(cfg.StandardERC20GatewayAddr),
 		common.HexToAddress(cfg.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.WETHGatewayAddr),
 		common.HexToAddress(cfg.DAIGatewayAddr),
 
 		common.HexToAddress(cfg.ERC721GatewayAddr),
@@ -66,8 +69,11 @@ func NewL1FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient
 	}
 
 	gatewayList := []common.Address{
+		common.HexToAddress(cfg.ETHGatewayAddr),
+
 		common.HexToAddress(cfg.StandardERC20GatewayAddr),
 		common.HexToAddress(cfg.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.WETHGatewayAddr),
 		common.HexToAddress(cfg.DAIGatewayAddr),
 
 		common.HexToAddress(cfg.ERC721GatewayAddr),
@@ -99,26 +105,6 @@ func NewL1FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient
 		gatewayList = append(gatewayList, common.HexToAddress(cfg.BatchBridgeGatewayAddr))
 	}
 
-	if common.HexToAddress(cfg.ETHGatewayAddr) != (common.Address{}) {
-		addressList = append(addressList, common.HexToAddress(cfg.ETHGatewayAddr))
-		gatewayList = append(gatewayList, common.HexToAddress(cfg.ETHGatewayAddr))
-	}
-
-	if common.HexToAddress(cfg.WETHGatewayAddr) != (common.Address{}) {
-		addressList = append(addressList, common.HexToAddress(cfg.WETHGatewayAddr))
-		gatewayList = append(gatewayList, common.HexToAddress(cfg.WETHGatewayAddr))
-	}
-
-	if common.HexToAddress(cfg.GasTokenGatewayAddr) != (common.Address{}) {
-		addressList = append(addressList, common.HexToAddress(cfg.GasTokenGatewayAddr))
-		gatewayList = append(gatewayList, common.HexToAddress(cfg.GasTokenGatewayAddr))
-	}
-
-	if common.HexToAddress(cfg.WrappedTokenGatewayAddr) != (common.Address{}) {
-		addressList = append(addressList, common.HexToAddress(cfg.WrappedTokenGatewayAddr))
-		gatewayList = append(gatewayList, common.HexToAddress(cfg.WrappedTokenGatewayAddr))
-	}
-
 	log.Info("L1 Fetcher configured with the following address list", "addresses", addressList, "gateways", gatewayList)
 
 	f := &L1FetcherLogic{
@@ -224,7 +210,7 @@ func (f *L1FetcherLogic) l1FetcherLogs(ctx context.Context, from, to uint64) ([]
 		Topics:    make([][]common.Hash, 1),
 	}
 
-	query.Topics[0] = make([]common.Hash, 16)
+	query.Topics[0] = make([]common.Hash, 15)
 	query.Topics[0][0] = backendabi.L1DepositETHSig
 	query.Topics[0][1] = backendabi.L1DepositERC20Sig
 	query.Topics[0][2] = backendabi.L1DepositERC721Sig
@@ -240,7 +226,6 @@ func (f *L1FetcherLogic) l1FetcherLogs(ctx context.Context, from, to uint64) ([]
 	query.Topics[0][12] = backendabi.L1DropTransactionEventSig
 	query.Topics[0][13] = backendabi.L1ResetDequeuedTransactionEventSig
 	query.Topics[0][14] = backendabi.L1BridgeBatchDepositSig
-	query.Topics[0][15] = backendabi.L1DepositWrappedTokenSig
 
 	eventLogs, err := f.client.FilterLogs(ctx, query)
 	if err != nil {

bridge-history-api/internal/logic/l2_fetcher.go

@@ -54,6 +54,7 @@ func NewL2FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient
 
 		common.HexToAddress(cfg.StandardERC20GatewayAddr),
 		common.HexToAddress(cfg.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.WETHGatewayAddr),
 		common.HexToAddress(cfg.DAIGatewayAddr),
 
 		common.HexToAddress(cfg.ERC721GatewayAddr),
@@ -67,6 +68,7 @@ func NewL2FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient
 
 		common.HexToAddress(cfg.StandardERC20GatewayAddr),
 		common.HexToAddress(cfg.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.WETHGatewayAddr),
 		common.HexToAddress(cfg.DAIGatewayAddr),
 
 		common.HexToAddress(cfg.ERC721GatewayAddr),
@@ -98,11 +100,6 @@ func NewL2FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient
 		gatewayList = append(gatewayList, common.HexToAddress(cfg.BatchBridgeGatewayAddr))
 	}
 
-	if common.HexToAddress(cfg.WETHGatewayAddr) != (common.Address{}) {
-		addressList = append(addressList, common.HexToAddress(cfg.WETHGatewayAddr))
-		gatewayList = append(gatewayList, common.HexToAddress(cfg.WETHGatewayAddr))
-	}
-
 	log.Info("L2 Fetcher configured with the following address list", "addresses", addressList, "gateways", gatewayList)
 
 	f := &L2FetcherLogic{

build/dockerfiles/bridgehistoryapi-api.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 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,8 +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 update-ca-certificates
+
 COPY --from=builder /bin/bridgehistoryapi-fetcher /bin/
 WORKDIR /app
 ENTRYPOINT ["bridgehistoryapi-fetcher"]

build/dockerfiles/coordinator-api.Dockerfile

@@ -33,17 +33,21 @@ FROM base as builder
 COPY . .
 RUN cp -r ./common/libzkp/interface ./coordinator/internal/logic/verifier/lib
 COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/internal/logic/verifier/lib/
-RUN cd ./coordinator && CGO_LDFLAGS="-Wl,--no-as-needed -ldl" make coordinator_api_skip_libzkp && mv ./build/bin/coordinator_api /bin/coordinator_api && mv internal/logic/verifier/lib /bin/
+RUN cd ./coordinator && \
+    CGO_LDFLAGS="-Wl,--no-as-needed -ldl" make coordinator_api_skip_libzkp && \
+    mv ./build/bin/coordinator_api /bin/coordinator_api && \
+    mv internal/logic/verifier/lib /bin/ && \
+    cp ./download_assets.sh /bin/
 
 # Pull coordinator into a second stage deploy ubuntu container
 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/
+COPY --from=builder /bin/download_assets.sh /bin/
+RUN /bin/download_assets.sh
 RUN /bin/coordinator_api --version
 WORKDIR /app
 ENTRYPOINT ["/bin/coordinator_api"]

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/forks/forks.go

@@ -16,10 +16,8 @@ func GetHardforkName(config *params.ChainConfig, blockHeight, blockTimestamp uin
 		return "bernoulli"
 	} else if !config.IsDarwin(blockTimestamp) {
 		return "curie"
-	} else if !config.IsDarwinV2(blockTimestamp) {
-		return "darwin"
 	} else {
-		return "darwinV2"
+		return "darwin"
 	}
 }
 
@@ -32,10 +30,8 @@ func GetCodecVersion(config *params.ChainConfig, blockHeight, blockTimestamp uin
 		return encoding.CodecV1
 	} else if !config.IsDarwin(blockTimestamp) {
 		return encoding.CodecV2
-	} else if !config.IsDarwinV2(blockTimestamp) {
-		return encoding.CodecV3
 	} else {
-		return encoding.CodecV4
+		return encoding.CodecV3
 	}
 }
 
@@ -48,8 +44,6 @@ func GetMaxChunksPerBatch(config *params.ChainConfig, blockHeight, blockTimestam
 		return 15
 	} else if !config.IsDarwin(blockTimestamp) {
 		return 45
-	} else if !config.IsDarwinV2(blockTimestamp) {
-		return 45
 	} else {
 		return 45
 	}

common/libzkp/e2e-test.sh

@@ -6,8 +6,6 @@ export RUST_BACKTRACE=full
 export RUST_LOG=debug
 export RUST_MIN_STACK=100000000
 export PROVER_OUTPUT_DIR=test_zkp_test
-export SCROLL_PROVER_ASSETS_DIR=/assets/test_assets
-export DARWIN_V2_TEST_DIR=/assets
 #export LD_LIBRARY_PATH=/:/usr/local/cuda/lib64
 
 mkdir -p $PROVER_OUTPUT_DIR
@@ -15,16 +13,32 @@ mkdir -p $PROVER_OUTPUT_DIR
 REPO=$(realpath ../..)
 
 function build_test_bins() {
+    cd impl
+    cargo build --release
+    ln -f -s $(realpath target/release/libzkp.so) $REPO/prover/core/lib
+    ln -f -s $(realpath target/release/libzkp.so) $REPO/coordinator/internal/logic/verifier/lib
     cd $REPO/prover
-    make tests_binary
+    go test -tags="gpu ffi" -timeout 0 -c core/prover_test.go
     cd $REPO/coordinator
-    make libzkp
     go test -tags="gpu ffi" -timeout 0 -c ./internal/logic/verifier
     cd $REPO/common/libzkp
 }
 
+function build_test_bins_old() {
+    cd $REPO
+    cd prover
+    make libzkp
+    go test -tags="gpu ffi" -timeout 0 -c core/prover_test.go
+    cd ..
+    cd coordinator
+    make libzkp
+    go test -tags="gpu ffi" -timeout 0 -c ./internal/logic/verifier
+    cd ..
+    cd common/libzkp
+}
+
 build_test_bins
-rm -rf $PROVER_OUTPUT_DIR/*
+#rm -rf test_zkp_test/*
 #rm -rf prover.log verifier.log
-$REPO/prover/prover.test --exact zk_circuits_handler::darwin_v2::tests::test_circuits 2>&1 | tee prover.log
+#$REPO/prover/core.test -test.v 2>&1 | tee prover.log
 $REPO/coordinator/verifier.test -test.v 2>&1 | tee verifier.log

common/libzkp/impl/Cargo.lock

@@ -28,10 +28,44 @@ dependencies = [
  "cpufeatures",
 ]
 
+[[package]]
+name = "aggregator"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
+dependencies = [
+ "ark-std 0.3.0",
+ "bitstream-io",
+ "c-kzg",
+ "ctor",
+ "encoder",
+ "env_logger 0.10.0",
+ "eth-types 0.11.0",
+ "ethers-core",
+ "gadgets 0.11.0",
+ "halo2-base",
+ "halo2-ecc",
+ "halo2_proofs",
+ "hex",
+ "itertools 0.11.0",
+ "log",
+ "num-bigint",
+ "once_cell",
+ "rand",
+ "revm-precompile",
+ "revm-primitives",
+ "serde",
+ "serde_json",
+ "snark-verifier",
+ "snark-verifier-sdk",
+ "strum 0.25.0",
+ "strum_macros 0.25.3",
+ "zkevm-circuits 0.11.0",
+]
+
 [[package]]
 name = "aggregator"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "ark-std 0.3.0",
  "bitstream-io",
@@ -62,40 +96,6 @@ dependencies = [
  "zkevm-circuits 0.12.0",
 ]
 
-[[package]]
-name = "aggregator"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
-dependencies = [
- "ark-std 0.3.0",
- "bitstream-io",
- "c-kzg",
- "ctor",
- "encoder",
- "env_logger 0.10.0",
- "eth-types 0.13.0",
- "ethers-core",
- "gadgets 0.13.0",
- "halo2-base",
- "halo2-ecc",
- "halo2_proofs",
- "hex",
- "itertools 0.11.0",
- "log",
- "num-bigint",
- "once_cell",
- "rand",
- "revm-precompile",
- "revm-primitives",
- "serde",
- "serde_json",
- "snark-verifier",
- "snark-verifier-sdk",
- "strum 0.25.0",
- "strum_macros 0.25.3",
- "zkevm-circuits 0.13.0",
-]
-
 [[package]]
 name = "ahash"
 version = "0.8.3"
@@ -171,9 +171,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.86"
+version = "1.0.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+checksum = "3b13c32d80ecc7ab747b80c3784bce54ee8a7a0cc4fbda9bf4cda2cf6fe90854"
 
 [[package]]
 name = "arc-swap"
@@ -568,10 +568,37 @@ version = "3.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
 
+[[package]]
+name = "bus-mapping"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
+dependencies = [
+ "eth-types 0.11.0",
+ "ethers-core",
+ "ethers-providers",
+ "ethers-signers",
+ "external-tracer 0.11.0",
+ "gadgets 0.11.0",
+ "halo2_proofs",
+ "hex",
+ "itertools 0.11.0",
+ "log",
+ "mock 0.11.0",
+ "mpt-zktrie 0.11.0",
+ "num",
+ "poseidon-circuit",
+ "rand",
+ "revm-precompile",
+ "serde",
+ "serde_json",
+ "strum 0.25.0",
+ "strum_macros 0.25.3",
+]
+
 [[package]]
 name = "bus-mapping"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core",
@@ -593,31 +620,6 @@ dependencies = [
  "strum_macros 0.25.3",
 ]
 
-[[package]]
-name = "bus-mapping"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
-dependencies = [
- "eth-types 0.13.0",
- "ethers-core",
- "ethers-providers",
- "ethers-signers",
- "gadgets 0.13.0",
- "halo2_proofs",
- "hex",
- "itertools 0.11.0",
- "log",
- "mock 0.13.0",
- "mpt-zktrie 0.13.0",
- "num",
- "poseidon-circuit",
- "revm-precompile",
- "serde",
- "serde_json",
- "strum 0.25.0",
- "strum_macros 0.25.3",
-]
-
 [[package]]
 name = "byte-slice-cast"
 version = "1.2.2"
@@ -1182,8 +1184,8 @@ dependencies = [
 
 [[package]]
 name = "eth-types"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
 dependencies = [
  "base64 0.13.1",
  "ethers-core",
@@ -1200,6 +1202,7 @@ dependencies = [
  "revm-primitives",
  "serde",
  "serde_json",
+ "serde_stacker",
  "serde_with",
  "sha3 0.10.8",
  "strum 0.25.0",
@@ -1210,8 +1213,8 @@ dependencies = [
 
 [[package]]
 name = "eth-types"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "base64 0.13.1",
  "ethers-core",
@@ -1366,11 +1369,11 @@ dependencies = [
 
 [[package]]
 name = "external-tracer"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
 dependencies = [
- "eth-types 0.12.0",
- "geth-utils 0.12.0",
+ "eth-types 0.11.0",
+ "geth-utils 0.11.0",
  "log",
  "serde",
  "serde_json",
@@ -1379,11 +1382,11 @@ dependencies = [
 
 [[package]]
 name = "external-tracer"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
- "eth-types 0.13.0",
- "geth-utils 0.13.0",
+ "eth-types 0.12.0",
+ "geth-utils 0.12.0",
  "log",
  "serde",
  "serde_json",
@@ -1561,10 +1564,10 @@ dependencies = [
 
 [[package]]
 name = "gadgets"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
 dependencies = [
- "eth-types 0.12.0",
+ "eth-types 0.11.0",
  "halo2_proofs",
  "poseidon-base",
  "sha3 0.10.8",
@@ -1573,10 +1576,10 @@ dependencies = [
 
 [[package]]
 name = "gadgets"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
- "eth-types 0.13.0",
+ "eth-types 0.12.0",
  "halo2_proofs",
  "poseidon-base",
  "sha3 0.10.8",
@@ -1596,8 +1599,8 @@ dependencies = [
 
 [[package]]
 name = "geth-utils"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
 dependencies = [
  "env_logger 0.10.0",
  "gobuild",
@@ -1606,8 +1609,8 @@ dependencies = [
 
 [[package]]
 name = "geth-utils"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "env_logger 0.10.0",
  "gobuild",
@@ -2353,10 +2356,25 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "mock"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
+dependencies = [
+ "eth-types 0.11.0",
+ "ethers-core",
+ "ethers-signers",
+ "external-tracer 0.11.0",
+ "itertools 0.11.0",
+ "log",
+ "rand",
+ "rand_chacha",
+]
+
 [[package]]
 name = "mock"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core",
@@ -2369,24 +2387,23 @@ dependencies = [
 ]
 
 [[package]]
-name = "mock"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
+name = "mpt-zktrie"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
 dependencies = [
- "eth-types 0.13.0",
- "ethers-core",
- "ethers-signers",
- "external-tracer 0.13.0",
- "itertools 0.11.0",
+ "eth-types 0.11.0",
+ "halo2curves",
+ "hex",
  "log",
- "rand",
- "rand_chacha",
+ "num-bigint",
+ "poseidon-base",
+ "zktrie",
 ]
 
 [[package]]
 name = "mpt-zktrie"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "eth-types 0.12.0",
  "halo2curves",
@@ -2394,21 +2411,7 @@ dependencies = [
  "log",
  "num-bigint",
  "poseidon-base",
- "zktrie 0.3.0 (git+https://github.com/scroll-tech/zktrie.git?branch=main)",
-]
-
-[[package]]
-name = "mpt-zktrie"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
-dependencies = [
- "eth-types 0.13.0",
- "halo2curves",
- "hex",
- "log",
- "num-bigint",
- "poseidon-base",
- "zktrie 0.3.0 (git+https://github.com/scroll-tech/zktrie.git?branch=v0.9)",
+ "zktrie",
 ]
 
 [[package]]
@@ -2869,10 +2872,44 @@ dependencies = [
  "unarray",
 ]
 
+[[package]]
+name = "prover"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
+dependencies = [
+ "aggregator 0.11.0",
+ "anyhow",
+ "base64 0.13.1",
+ "blake2",
+ "bus-mapping 0.11.0",
+ "chrono",
+ "dotenvy",
+ "eth-types 0.11.0",
+ "ethers-core",
+ "git-version",
+ "halo2_proofs",
+ "hex",
+ "itertools 0.11.0",
+ "log",
+ "log4rs",
+ "mpt-zktrie 0.11.0",
+ "num-bigint",
+ "rand",
+ "rand_xorshift",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "serde_stacker",
+ "sha2",
+ "snark-verifier",
+ "snark-verifier-sdk",
+ "zkevm-circuits 0.11.0",
+]
+
 [[package]]
 name = "prover"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "aggregator 0.12.0",
  "anyhow",
@@ -2903,40 +2940,6 @@ dependencies = [
  "zkevm-circuits 0.12.0",
 ]
 
-[[package]]
-name = "prover"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
-dependencies = [
- "aggregator 0.13.0",
- "anyhow",
- "base64 0.13.1",
- "blake2",
- "bus-mapping 0.13.0",
- "chrono",
- "dotenvy",
- "eth-types 0.13.0",
- "ethers-core",
- "git-version",
- "halo2_proofs",
- "hex",
- "itertools 0.11.0",
- "log",
- "log4rs",
- "mpt-zktrie 0.13.0",
- "num-bigint",
- "rand",
- "rand_xorshift",
- "serde",
- "serde_derive",
- "serde_json",
- "serde_stacker",
- "sha2",
- "snark-verifier",
- "snark-verifier-sdk",
- "zkevm-circuits 0.13.0",
-]
-
 [[package]]
 name = "psm"
 version = "0.1.21"
@@ -4540,10 +4543,52 @@ dependencies = [
  "syn 2.0.27",
 ]
 
+[[package]]
+name = "zkevm-circuits"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
+dependencies = [
+ "array-init",
+ "bus-mapping 0.11.0",
+ "either",
+ "env_logger 0.10.0",
+ "eth-types 0.11.0",
+ "ethers-core",
+ "ethers-signers",
+ "ff",
+ "gadgets 0.11.0",
+ "halo2-base",
+ "halo2-ecc",
+ "halo2-mpt-circuits",
+ "halo2_gadgets",
+ "halo2_proofs",
+ "hex",
+ "itertools 0.11.0",
+ "log",
+ "misc-precompiled-circuit",
+ "mock 0.11.0",
+ "mpt-zktrie 0.11.0",
+ "num",
+ "num-bigint",
+ "poseidon-circuit",
+ "rand",
+ "rand_chacha",
+ "rand_xorshift",
+ "rayon",
+ "serde",
+ "serde_json",
+ "sha3 0.10.8",
+ "snark-verifier",
+ "snark-verifier-sdk",
+ "strum 0.25.0",
+ "strum_macros 0.25.3",
+ "subtle",
+]
+
 [[package]]
 name = "zkevm-circuits"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "array-init",
  "bus-mapping 0.12.0",
@@ -4582,61 +4627,18 @@ dependencies = [
  "subtle",
 ]
 
-[[package]]
-name = "zkevm-circuits"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
-dependencies = [
- "array-init",
- "bus-mapping 0.13.0",
- "either",
- "env_logger 0.10.0",
- "eth-types 0.13.0",
- "ethers-core",
- "ethers-signers",
- "ff",
- "gadgets 0.13.0",
- "halo2-base",
- "halo2-ecc",
- "halo2-mpt-circuits",
- "halo2_gadgets",
- "halo2_proofs",
- "hex",
- "itertools 0.11.0",
- "log",
- "misc-precompiled-circuit",
- "mock 0.13.0",
- "mpt-zktrie 0.13.0",
- "num",
- "num-bigint",
- "poseidon-circuit",
- "rand",
- "rand_chacha",
- "rand_xorshift",
- "rayon",
- "serde",
- "serde_json",
- "sha3 0.10.8",
- "snark-verifier",
- "snark-verifier-sdk",
- "strum 0.25.0",
- "strum_macros 0.25.3",
- "subtle",
-]
-
 [[package]]
 name = "zkp"
 version = "0.1.0"
 dependencies = [
- "anyhow",
  "base64 0.13.1",
  "env_logger 0.9.3",
  "halo2_proofs",
  "libc",
  "log",
  "once_cell",
+ "prover 0.11.0",
  "prover 0.12.0",
- "prover 0.13.0",
  "serde",
  "serde_derive",
  "serde_json",
@@ -4649,16 +4651,7 @@ version = "0.3.0"
 source = "git+https://github.com/scroll-tech/zktrie.git?branch=main#23181f209e94137f74337b150179aeb80c72e7c8"
 dependencies = [
  "gobuild",
- "zktrie_rust 0.3.0 (git+https://github.com/scroll-tech/zktrie.git?branch=main)",
-]
-
-[[package]]
-name = "zktrie"
-version = "0.3.0"
-source = "git+https://github.com/scroll-tech/zktrie.git?branch=v0.9#460b8c22af65b7809164548cba1e0253b6db5a70"
-dependencies = [
- "gobuild",
- "zktrie_rust 0.3.0 (git+https://github.com/scroll-tech/zktrie.git?branch=v0.9)",
+ "zktrie_rust",
 ]
 
 [[package]]
@@ -4675,20 +4668,6 @@ dependencies = [
  "strum_macros 0.24.3",
 ]
 
-[[package]]
-name = "zktrie_rust"
-version = "0.3.0"
-source = "git+https://github.com/scroll-tech/zktrie.git?branch=v0.9#460b8c22af65b7809164548cba1e0253b6db5a70"
-dependencies = [
- "hex",
- "lazy_static",
- "num",
- "num-derive",
- "num-traits",
- "strum 0.24.1",
- "strum_macros 0.24.3",
-]
-
 [[package]]
 name = "zstd"
 version = "0.13.0"

common/libzkp/impl/Cargo.toml

@@ -24,10 +24,10 @@ bls12_381 = { git = "https://github.com/scroll-tech/bls12_381", branch = "feat/i
 halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1" }
 snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", branch = "develop", default-features = false, features = ["loader_halo2", "loader_evm", "halo2-pse"] }
 
+# curie
+prover_v3 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.11.4", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
 # darwin
-prover_v4 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.2", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
-# darwin_v2
-prover_v5 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.13.1", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
+prover_v4 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.0", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
 
 base64 = "0.13.0"
 env_logger = "0.9.0"
@@ -37,7 +37,6 @@ once_cell = "1.19"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0.66"
-anyhow = "1.0.86"
 
 [profile.test]
 opt-level = 3

common/libzkp/impl/src/batch.rs

@@ -0,0 +1,69 @@
+use crate::utils::{c_char_to_str, c_char_to_vec, panic_catch};
+use libc::c_char;
+use prover_v3::BatchProof as BatchProofLoVersion;
+use prover_v4::{
+    aggregator::Verifier as VerifierHiVersion, utils::init_env_and_log,
+    BatchProof as BatchProofHiVersion, BundleProof,
+};
+use snark_verifier_sdk::verify_evm_calldata;
+use std::{cell::OnceCell, env};
+
+static mut VERIFIER: OnceCell<VerifierHiVersion> = OnceCell::new();
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_batch_verifier(params_dir: *const c_char, assets_dir: *const c_char) {
+    init_env_and_log("ffi_batch_verify");
+
+    let params_dir = c_char_to_str(params_dir);
+    let assets_dir = c_char_to_str(assets_dir);
+
+    // TODO: add a settings in scroll-prover.
+    env::set_var("SCROLL_PROVER_ASSETS_DIR", assets_dir);
+    let verifier_hi = VerifierHiVersion::from_dirs(params_dir, assets_dir);
+
+    VERIFIER.set(verifier_hi).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_batch_proof(
+    proof: *const c_char,
+    fork_name: *const c_char,
+) -> c_char {
+    let proof = c_char_to_vec(proof);
+    let fork_name_str = c_char_to_str(fork_name);
+    let fork_id = match fork_name_str {
+        "curie" => 3,
+        "darwin" => 4,
+        _ => {
+            log::warn!("unexpected fork_name {fork_name_str}, treated as darwin");
+            4
+        }
+    };
+    let verified = panic_catch(|| {
+        if fork_id == 3 {
+            // As of upgrade #3 (Curie), we verify batch proofs on-chain (EVM).
+            let proof = serde_json::from_slice::<BatchProofLoVersion>(proof.as_slice()).unwrap();
+            verify_evm_calldata(
+                include_bytes!("plonk_verifier_0.11.4.bin").to_vec(),
+                proof.calldata(),
+            )
+        } else {
+            // Post upgrade #4 (Darwin), batch proofs are not EVM-verifiable. Instead they are
+            // halo2 proofs meant to be bundled recursively.
+            let proof = serde_json::from_slice::<BatchProofHiVersion>(proof.as_slice()).unwrap();
+            VERIFIER.get().unwrap().verify_batch_proof(&proof)
+        }
+    });
+    verified.unwrap_or(false) as c_char
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_bundle_proof(proof: *const c_char) -> c_char {
+    let proof = c_char_to_vec(proof);
+    let proof = serde_json::from_slice::<BundleProof>(proof.as_slice()).unwrap();
+    let verified = panic_catch(|| VERIFIER.get().unwrap().verify_bundle_proof(proof));
+    verified.unwrap_or(false) as c_char
+}

common/libzkp/impl/src/chunk.rs

@@ -0,0 +1,63 @@
+use crate::utils::{c_char_to_str, c_char_to_vec, panic_catch};
+use libc::c_char;
+use prover_v3::{zkevm::Verifier as VerifierLoVersion, ChunkProof as ChunkProofLoVersion};
+use prover_v4::{
+    utils::init_env_and_log, zkevm::Verifier as VerifierHiVersion,
+    ChunkProof as ChunkProofHiVersion,
+};
+use std::{cell::OnceCell, env};
+
+static mut VERIFIER_LO_VERSION: OnceCell<VerifierLoVersion> = OnceCell::new();
+static mut VERIFIER_HI_VERSION: OnceCell<VerifierHiVersion> = OnceCell::new();
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_chunk_verifier(
+    params_dir: *const c_char,
+    v3_assets_dir: *const c_char,
+    v4_assets_dir: *const c_char,
+) {
+    init_env_and_log("ffi_chunk_verify");
+
+    let params_dir = c_char_to_str(params_dir);
+    let v3_assets_dir = c_char_to_str(v3_assets_dir);
+    let v4_assets_dir = c_char_to_str(v4_assets_dir);
+
+    // TODO: add a settings in scroll-prover.
+    env::set_var("SCROLL_PROVER_ASSETS_DIR", v3_assets_dir);
+    let verifier_lo = VerifierLoVersion::from_dirs(params_dir, v3_assets_dir);
+    env::set_var("SCROLL_PROVER_ASSETS_DIR", v4_assets_dir);
+    let verifier_hi = VerifierHiVersion::from_dirs(params_dir, v4_assets_dir);
+
+    VERIFIER_LO_VERSION.set(verifier_lo).unwrap();
+    VERIFIER_HI_VERSION.set(verifier_hi).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_chunk_proof(
+    proof: *const c_char,
+    fork_name: *const c_char,
+) -> c_char {
+    let proof = c_char_to_vec(proof);
+
+    let fork_name_str = c_char_to_str(fork_name);
+    let fork_id = match fork_name_str {
+        "curie" => 3,
+        "darwin" => 4,
+        _ => {
+            log::warn!("unexpected fork_name {fork_name_str}, treated as darwin");
+            4
+        }
+    };
+    let verified = panic_catch(|| {
+        if fork_id == 3 {
+            let proof = serde_json::from_slice::<ChunkProofLoVersion>(proof.as_slice()).unwrap();
+            VERIFIER_LO_VERSION.get().unwrap().verify_chunk_proof(proof)
+        } else {
+            let proof = serde_json::from_slice::<ChunkProofHiVersion>(proof.as_slice()).unwrap();
+            VERIFIER_HI_VERSION.get().unwrap().verify_chunk_proof(proof)
+        }
+    });
+    verified.unwrap_or(false) as c_char
+}

common/libzkp/impl/src/lib.rs

@@ -1,63 +1,4 @@
+mod batch;
+mod chunk;
+mod types;
 mod utils;
-mod verifier;
-
-use crate::utils::{c_char_to_str, c_char_to_vec};
-use libc::c_char;
-use prover_v5::utils::init_env_and_log;
-use verifier::{TaskType, VerifierConfig};
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn init(config: *const c_char) {
-    init_env_and_log("ffi_init");
-
-    let config_str = c_char_to_str(config);
-    let verifier_config = serde_json::from_str::<VerifierConfig>(config_str).unwrap();
-    verifier::init(verifier_config);
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn verify_chunk_proof(
-    proof: *const c_char,
-    fork_name: *const c_char,
-) -> c_char {
-    verify_proof(proof, fork_name, TaskType::Chunk)
-}
-
-fn verify_proof(proof: *const c_char, fork_name: *const c_char, task_type: TaskType) -> c_char {
-    let proof = c_char_to_vec(proof);
-
-    let fork_name_str = c_char_to_str(fork_name);
-    let verifier = verifier::get_verifier(fork_name_str);
-
-    if let Err(e) = verifier {
-        log::warn!("failed to get verifier, error: {:#}", e);
-        return 0 as c_char;
-    }
-    match verifier.unwrap().verify(task_type, proof) {
-        Err(e) => {
-            log::error!("{:?} verify failed, error: {:#}", task_type, e);
-            false as c_char
-        }
-        Ok(result) => result as c_char,
-    }
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn verify_batch_proof(
-    proof: *const c_char,
-    fork_name: *const c_char,
-) -> c_char {
-    verify_proof(proof, fork_name, TaskType::Batch)
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn verify_bundle_proof(
-    proof: *const c_char,
-    fork_name: *const c_char,
-) -> c_char {
-    verify_proof(proof, fork_name, TaskType::Bundle)
-}

common/libzkp/impl/src/types.rs

@@ -0,0 +1,22 @@
+use serde::{Deserialize, Serialize};
+
+// Represents the result of a chunk proof checking operation.
+// `ok` indicates whether the proof checking was successful.
+// `error` provides additional details in case the check failed.
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct CheckChunkProofsResponse {
+    pub ok: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+
+// Encapsulates the result from generating a proof.
+// `message` holds the generated proof in byte slice format.
+// `error` provides additional details in case the proof generation failed.
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ProofResult {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub message: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}

common/libzkp/impl/src/verifier.rs

@@ -1,110 +0,0 @@
-mod darwin;
-mod darwin_v2;
-
-use anyhow::{bail, Result};
-use darwin::DarwinVerifier;
-use darwin_v2::DarwinV2Verifier;
-use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
-use prover_v4::utils::load_params;
-use serde::{Deserialize, Serialize};
-use std::{cell::OnceCell, collections::BTreeMap, rc::Rc};
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum TaskType {
-    Chunk,
-    Batch,
-    Bundle,
-}
-
-pub trait ProofVerifier {
-    fn verify(&self, task_type: TaskType, proof: Vec<u8>) -> Result<bool>;
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct CircuitConfig {
-    pub fork_name: String,
-    pub params_path: String,
-    pub assets_path: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct VerifierConfig {
-    pub low_version_circuit: CircuitConfig,
-    pub high_version_circuit: CircuitConfig,
-}
-
-type HardForkName = String;
-
-struct VerifierPair(HardForkName, Rc<Box<dyn ProofVerifier>>);
-
-static mut VERIFIER_HIGH: OnceCell<VerifierPair> = OnceCell::new();
-static mut VERIFIER_LOW: OnceCell<VerifierPair> = OnceCell::new();
-static mut PARAMS_MAP: OnceCell<BTreeMap<u32, ParamsKZG<Bn256>>> = OnceCell::new();
-
-pub fn init(config: VerifierConfig) {
-    let low_conf = config.low_version_circuit;
-
-    std::env::set_var("SCROLL_PROVER_ASSETS_DIR", &low_conf.assets_path);
-    let params_degrees = [
-        *prover_v4::config::LAYER2_DEGREE,
-        *prover_v4::config::LAYER4_DEGREE,
-    ];
-
-    // params should be shared between low and high
-    let mut params_map = BTreeMap::new();
-    for degree in params_degrees {
-        if let std::collections::btree_map::Entry::Vacant(e) = params_map.entry(degree) {
-            match load_params(&low_conf.params_path, degree, None) {
-                Ok(params) => {
-                    e.insert(params);
-                }
-                Err(e) => panic!(
-                    "failed to load params, degree {}, dir {}, err {}",
-                    degree, low_conf.params_path, e
-                ),
-            }
-        }
-    }
-    unsafe {
-        PARAMS_MAP.set(params_map).unwrap_unchecked();
-    }
-
-    let verifier = DarwinVerifier::new(unsafe { PARAMS_MAP.get().unwrap() }, &low_conf.assets_path);
-
-    unsafe {
-        VERIFIER_LOW
-            .set(VerifierPair(
-                low_conf.fork_name,
-                Rc::new(Box::new(verifier)),
-            ))
-            .unwrap_unchecked();
-    }
-    let high_conf = config.high_version_circuit;
-    let verifier =
-        DarwinV2Verifier::new(unsafe { PARAMS_MAP.get().unwrap() }, &high_conf.assets_path);
-    unsafe {
-        VERIFIER_HIGH
-            .set(VerifierPair(
-                high_conf.fork_name,
-                Rc::new(Box::new(verifier)),
-            ))
-            .unwrap_unchecked();
-    }
-}
-
-pub fn get_verifier(fork_name: &str) -> Result<Rc<Box<dyn ProofVerifier>>> {
-    unsafe {
-        if let Some(verifier) = VERIFIER_LOW.get() {
-            if verifier.0 == fork_name {
-                return Ok(verifier.1.clone());
-            }
-        }
-
-        if let Some(verifier) = VERIFIER_HIGH.get() {
-            if verifier.0 == fork_name {
-                return Ok(verifier.1.clone());
-            }
-        }
-    }
-    bail!("failed to get verifier, key not found, {}", fork_name)
-}

common/libzkp/impl/src/verifier/darwin.rs

@@ -1,48 +0,0 @@
-use super::{ProofVerifier, TaskType};
-
-use anyhow::Result;
-use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
-
-use crate::utils::panic_catch;
-use prover_v4::{
-    aggregator::Verifier as AggVerifier, zkevm::Verifier, BatchProof, BundleProof, ChunkProof,
-};
-use std::{collections::BTreeMap, env};
-
-pub struct DarwinVerifier<'params> {
-    verifier: Verifier<'params>,
-    agg_verifier: AggVerifier<'params>,
-}
-
-impl<'params> DarwinVerifier<'params> {
-    pub fn new(params_map: &'params BTreeMap<u32, ParamsKZG<Bn256>>, assets_dir: &str) -> Self {
-        env::set_var("SCROLL_PROVER_ASSETS_DIR", assets_dir);
-        let verifier = Verifier::from_params_and_assets(params_map, assets_dir);
-        let agg_verifier = AggVerifier::from_params_and_assets(params_map, assets_dir);
-
-        Self {
-            verifier,
-            agg_verifier,
-        }
-    }
-}
-
-impl<'params> ProofVerifier for DarwinVerifier<'params> {
-    fn verify(&self, task_type: super::TaskType, proof: Vec<u8>) -> Result<bool> {
-        let result = panic_catch(|| match task_type {
-            TaskType::Chunk => {
-                let proof = serde_json::from_slice::<ChunkProof>(proof.as_slice()).unwrap();
-                self.verifier.verify_chunk_proof(proof)
-            }
-            TaskType::Batch => {
-                let proof = serde_json::from_slice::<BatchProof>(proof.as_slice()).unwrap();
-                self.agg_verifier.verify_batch_proof(&proof)
-            }
-            TaskType::Bundle => {
-                let proof = serde_json::from_slice::<BundleProof>(proof.as_slice()).unwrap();
-                self.agg_verifier.verify_bundle_proof(proof)
-            }
-        });
-        result.map_err(|e| anyhow::anyhow!(e))
-    }
-}

common/libzkp/impl/src/verifier/darwin_v2.rs

@@ -1,48 +0,0 @@
-use super::{ProofVerifier, TaskType};
-
-use anyhow::Result;
-use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
-
-use crate::utils::panic_catch;
-use prover_v5::{
-    aggregator::Verifier as AggVerifier, zkevm::Verifier, BatchProof, BundleProof, ChunkProof,
-};
-use std::{collections::BTreeMap, env};
-
-pub struct DarwinV2Verifier<'params> {
-    verifier: Verifier<'params>,
-    agg_verifier: AggVerifier<'params>,
-}
-
-impl<'params> DarwinV2Verifier<'params> {
-    pub fn new(params_map: &'params BTreeMap<u32, ParamsKZG<Bn256>>, assets_dir: &str) -> Self {
-        env::set_var("SCROLL_PROVER_ASSETS_DIR", assets_dir);
-        let verifier = Verifier::from_params_and_assets(params_map, assets_dir);
-        let agg_verifier = AggVerifier::from_params_and_assets(params_map, assets_dir);
-
-        Self {
-            verifier,
-            agg_verifier,
-        }
-    }
-}
-
-impl<'params> ProofVerifier for DarwinV2Verifier<'params> {
-    fn verify(&self, task_type: super::TaskType, proof: Vec<u8>) -> Result<bool> {
-        let result = panic_catch(|| match task_type {
-            TaskType::Chunk => {
-                let proof = serde_json::from_slice::<ChunkProof>(proof.as_slice()).unwrap();
-                self.verifier.verify_chunk_proof(proof)
-            }
-            TaskType::Batch => {
-                let proof = serde_json::from_slice::<BatchProof>(proof.as_slice()).unwrap();
-                self.agg_verifier.verify_batch_proof(&proof)
-            }
-            TaskType::Bundle => {
-                let proof = serde_json::from_slice::<BundleProof>(proof.as_slice()).unwrap();
-                self.agg_verifier.verify_bundle_proof(proof)
-            }
-        });
-        result.map_err(|e| anyhow::anyhow!(e))
-    }
-}

common/libzkp/interface/libzkp.h

@@ -1,10 +1,11 @@
 // BatchVerifier is used to:
 // - Verify a batch proof
 // - Verify a bundle proof
-void init(char* config);
+void init_batch_verifier(char* params_dir, char* assets_dir);
 
 char verify_batch_proof(char* proof, char* fork_name);
 
-char verify_bundle_proof(char* proof, char* fork_name);
+char verify_bundle_proof(char* proof);
 
+void init_chunk_verifier(char* params_dir, char* v3_assets_dir, char* v4_assets_dir);
 char verify_chunk_proof(char* proof, char* fork_name);

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/types/message/message.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/scroll-tech/da-codec/encoding/codecv3"
 	"github.com/scroll-tech/go-ethereum/common"
 )
 
@@ -51,10 +52,9 @@ type ChunkTaskDetail struct {
 
 // BatchTaskDetail is a type containing BatchTask detail.
 type BatchTaskDetail struct {
-	ChunkInfos  []*ChunkInfo  `json:"chunk_infos"`
-	ChunkProofs []*ChunkProof `json:"chunk_proofs"`
-	BatchHeader interface{}   `json:"batch_header"`
-	BlobBytes   []byte        `json:"blob_bytes"`
+	ChunkInfos  []*ChunkInfo     `json:"chunk_infos"`
+	ChunkProofs []*ChunkProof    `json:"chunk_proofs"`
+	BatchHeader *codecv3.DABatch `json:"batch_header"`
 }
 
 // BundleTaskDetail consists of all the information required to describe the task to generate a proof for a bundle of batches.

common/utils/utils.go

@@ -9,14 +9,10 @@ import (
 	"math/big"
 	"os"
 	"path/filepath"
-	"reflect"
-	"strconv"
-	"strings"
 	"time"
 
 	"github.com/modern-go/reflect2"
 	"github.com/scroll-tech/go-ethereum/core"
-	"github.com/scroll-tech/go-ethereum/log"
 )
 
 // TryTimes try run several times until the function return true.
@@ -82,89 +78,3 @@ func ReadGenesis(genesisPath string) (*core.Genesis, error) {
 	}
 	return genesis, file.Close()
 }
-
-// OverrideConfigWithEnv recursively overrides config values with environment variables
-func OverrideConfigWithEnv(cfg interface{}, prefix string) error {
-	v := reflect.ValueOf(cfg)
-	if v.Kind() != reflect.Ptr || v.IsNil() {
-		return nil
-	}
-	v = v.Elem()
-
-	t := v.Type()
-	for i := 0; i < t.NumField(); i++ {
-		field := t.Field(i)
-		fieldValue := v.Field(i)
-
-		if !fieldValue.CanSet() {
-			continue
-		}
-
-		tag := field.Tag.Get("json")
-		if tag == "" {
-			tag = strings.ToLower(field.Name)
-		}
-
-		envKey := prefix + "_" + strings.ToUpper(tag)
-
-		switch fieldValue.Kind() {
-		case reflect.Ptr:
-			if !fieldValue.IsNil() {
-				err := OverrideConfigWithEnv(fieldValue.Interface(), envKey)
-				if err != nil {
-					return err
-				}
-			}
-		case reflect.Struct:
-			err := OverrideConfigWithEnv(fieldValue.Addr().Interface(), envKey)
-			if err != nil {
-				return err
-			}
-		default:
-			if envValue, exists := os.LookupEnv(envKey); exists {
-				log.Info("Overriding config with env var", "key", envKey)
-				err := setField(fieldValue, envValue)
-				if err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
-// setField sets the value of a field based on the environment variable value
-func setField(field reflect.Value, value string) error {
-	switch field.Kind() {
-	case reflect.String:
-		field.SetString(value)
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		intValue, err := strconv.ParseInt(value, 10, 64)
-		if err != nil {
-			return err
-		}
-		field.SetInt(intValue)
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		uintValue, err := strconv.ParseUint(value, 10, 64)
-		if err != nil {
-			return err
-		}
-		field.SetUint(uintValue)
-	case reflect.Float32, reflect.Float64:
-		floatValue, err := strconv.ParseFloat(value, 64)
-		if err != nil {
-			return err
-		}
-		field.SetFloat(floatValue)
-	case reflect.Bool:
-		boolValue, err := strconv.ParseBool(value)
-		if err != nil {
-			return err
-		}
-		field.SetBool(boolValue)
-	default:
-		return fmt.Errorf("unsupported type: %v", field.Kind())
-	}
-	return nil
-}

common/version/version.go

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

coordinator/cmd/api/app/mock_app.go

@@ -88,25 +88,13 @@ func (c *CoordinatorApp) MockConfig(store bool) error {
 	}
 	// Reset prover manager config for manager test cases.
 	cfg.ProverManager = &coordinatorConfig.ProverManager{
-		ProversPerSession: 1,
-		Verifier: &coordinatorConfig.VerifierConfig{
-			MockMode: true,
-			LowVersionCircuit: &coordinatorConfig.CircuitConfig{
-				ParamsPath:       "",
-				AssetsPath:       "",
-				ForkName:         "darwin",
-				MinProverVersion: "v4.2.0",
-			},
-			HighVersionCircuit: &coordinatorConfig.CircuitConfig{
-				ParamsPath:       "",
-				AssetsPath:       "",
-				ForkName:         "darwinV2",
-				MinProverVersion: "v4.3.0",
-			},
-		},
+		ProversPerSession:      1,
+		Verifier:               &coordinatorConfig.VerifierConfig{MockMode: true},
 		BatchCollectionTimeSec: 60,
 		ChunkCollectionTimeSec: 60,
 		SessionAttempts:        10,
+		MaxVerifierWorkers:     4,
+		MinProverVersion:       "v1.0.0",
 	}
 	endpoint, err := c.testApps.GetDBEndPoint()
 	if err != nil {

coordinator/conf/config.json

@@ -6,20 +6,14 @@
     "batch_collection_time_sec": 180,
     "chunk_collection_time_sec": 180,
     "verifier": {
+      "fork_name": "bernoulli",
       "mock_mode": true,
-      "low_version_circuit": {
-        "params_path": "params",
-        "assets_path": "assets",
-        "fork_name": "darwin",
-        "min_prover_version": "v4.4.43"
-      },
-      "high_version_circuit": {
-        "params_path": "params",
-        "assets_path": "assets",
-        "fork_name": "darwinV2",
-        "min_prover_version": "v4.4.45"
-      }
-    }
+      "params_path": "",
+      "assets_path_lo": "",
+      "assets_path_hi": ""
+    },
+    "max_verifier_workers": 4,
+    "min_prover_version": "v1.0.0"
   },
   "db": {
     "driver_name": "postgres",

coordinator/download_assets.sh

@@ -0,0 +1,126 @@
+#!/bin/sh
+apt update
+apt install wget libdigest-sha-perl -y
+
+RELEASE_VERSION_HI=v0.12.0
+RELEASE_VERSION_LO=v0.11.4
+
+P_CHECKSUMS=$(wget -O- https://circuit-release.s3.us-west-2.amazonaws.com/setup/sha256sum)
+DOWNLOAD_RESULT=$?
+ERROR=$(echo "$P_CHECKSUMS" | grep "Error")
+
+if [ $DOWNLOAD_RESULT -ne 0 ] || [ "$ERROR" != "" ]; then
+	echo "Failed to download params checksums"
+	echo "$P_CHECKSUMS"
+	exit 1
+fi
+
+R_CHECKSUMS_HI=$(wget -O- https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/sha256sum)
+DOWNLOAD_RESULT=$?
+ERROR=$(echo "$R_CHECKSUMS_HI" | grep "Error")
+if [ $DOWNLOAD_RESULT -ne 0 ] || [ "$ERROR" != "" ]; then
+	echo "Failed to download release checksum for $RELEASE_VERSION_HI"
+	echo "$R_CHECKSUMS_HI"
+	exit 1
+fi
+
+R_CHECKSUMS_LO=$(wget -O- https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/sha256sum)
+DOWNLOAD_RESULT=$?
+ERROR=$(echo "$R_CHECKSUMS_LO" | grep "Error")
+if [ $DOWNLOAD_RESULT -ne 0 ] || [ "$ERROR" != "" ]; then
+	echo "Failed to download release checksum for $RELEASE_VERSION_LO"
+	echo "$R_CHECKSUMS_LO"
+	exit 1
+fi
+
+PARAMS20_SHASUM=$(echo "$P_CHECKSUMS" | grep "params20" | cut -d " " -f 1)
+PARAMS21_SHASUM=$(echo "$P_CHECKSUMS" | grep "params21" | cut -d " " -f 1)
+PARAMS24_SHASUM=$(echo "$P_CHECKSUMS" | grep "params24" | cut -d " " -f 1)
+PARAMS25_SHASUM=$(echo "$P_CHECKSUMS" | grep "params25" | cut -d " " -f 1)
+PARAMS26_SHASUM=$(echo "$P_CHECKSUMS" | grep "params26" | cut -d " " -f 1)
+
+# v0.12.0
+VK_CHUNK_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "vk_chunk.vkey" | cut -d " " -f 1)
+VK_BATCH_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "vk_batch.vkey" | cut -d " " -f 1)
+VK_BUNDLE_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "vk_bundle.vkey" | cut -d " " -f 1)
+VRFR_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "evm_verifier.bin" | cut -d " " -f 1)
+CFG2_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "layer2.config" | cut -d " " -f 1)
+CFG4_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "layer4.config" | cut -d " " -f 1)
+
+# v0.11.4
+VK_CHUNK_SHASUM_LO=$(echo "$R_CHECKSUMS_LO" | grep "chunk_vk.vkey" | cut -d " " -f 1)
+VK_BATCH_SHASUM_LO=$(echo "$R_CHECKSUMS_LO" | grep "agg_vk.vkey" | cut -d " " -f 1)
+VRFR_SHASUM_LO=$(echo "$R_CHECKSUMS_LO" | grep "evm_verifier.bin" | cut -d " " -f 1)
+CFG2_SHASUM_LO=$(echo "$R_CHECKSUMS_LO" | grep "layer2.config" | cut -d " " -f 1)
+CFG4_SHASUM_LO=$(echo "$R_CHECKSUMS_LO" | grep "layer4.config" | cut -d " " -f 1)
+
+check_shasum() {
+	SHASUM=$(shasum -a 256 $1 | cut -d " " -f 1)
+	if [ "$SHASUM" != "$2" ]; then
+		echo "Shasum mismatch: expected=$2, actual=$SHASUM"
+		return 1
+	else
+		return 0
+	fi
+}
+
+# check existing file checksums
+check_file() {
+	if [ -f $1 ]; then
+		if ! check_shasum $1 $2; then
+			echo "Removing incorrect file $1"
+			rm $1
+		fi
+	fi
+}
+
+# check existing common file
+check_file "/verifier/params/params20" "$PARAMS20_SHASUM"
+check_file "/verifier/params/params21" "$PARAMS21_SHASUM"
+check_file "/verifier/params/params24" "$PARAMS24_SHASUM"
+check_file "/verifier/params/params25" "$PARAMS25_SHASUM"
+check_file "/verifier/params/params26" "$PARAMS26_SHASUM"
+# check existing vk_hi file v0.12.0
+check_file "/verifier/assets/hi/vk_chunk.vkey" "$VK_CHUNK_SHASUM_HI"
+check_file "/verifier/assets/hi/vk_batch.vkey" "$VK_BATCH_SHASUM_HI"
+check_file "/verifier/assets/hi/vk_bundle.vkey" "$VK_BUNDLE_SHASUM_HI"
+check_file "/verifier/assets/hi/evm_verifier.bin" "$VRFR_SHASUM_HI"
+check_file "/verifier/assets/hi/layer2.config" "$CFG2_SHASUM_HI"
+check_file "/verifier/assets/hi/layer4.config" "$CFG4_SHASUM_HI"
+# check existing vk_lo file v0.11.4
+check_file "/verifier/assets/lo/chunk_vk.vkey" "$VK_CHUNK_SHASUM_LO"
+check_file "/verifier/assets/lo/agg_vk.vkey" "$VK_BATCH_SHASUM_LO"
+check_file "/verifier/assets/lo/evm_verifier.bin" "$VRFR_SHASUM_LO"
+check_file "/verifier/assets/lo/layer2.config" "$CFG2_SHASUM_LO"
+check_file "/verifier/assets/lo/layer4.config" "$CFG4_SHASUM_LO"
+
+# download missing files
+download_file() {
+	if [ ! -f $1 ]; then
+		mkdir -p $(dirname $1)
+		echo "Downloading $1..."
+		wget --progress=dot:mega $2 -O $1
+		echo "Download completed $1"
+		if ! check_shasum $1 $3; then exit 1; fi
+	fi
+}
+
+# download common
+download_file "/verifier/params/params20" "https://circuit-release.s3.us-west-2.amazonaws.com/setup/params20" "$PARAMS20_SHASUM"
+download_file "/verifier/params/params21" "https://circuit-release.s3.us-west-2.amazonaws.com/setup/params21" "$PARAMS21_SHASUM"
+download_file "/verifier/params/params24" "https://circuit-release.s3.us-west-2.amazonaws.com/setup/params24" "$PARAMS24_SHASUM"
+download_file "/verifier/params/params25" "https://circuit-release.s3.us-west-2.amazonaws.com/setup/params25" "$PARAMS25_SHASUM"
+download_file "/verifier/params/params26" "https://circuit-release.s3.us-west-2.amazonaws.com/setup/params26" "$PARAMS26_SHASUM"
+# download hi v0.12.0
+download_file "/verifier/assets/hi/vk_chunk.vkey" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/vk_chunk.vkey" "$VK_CHUNK_SHASUM_HI"
+download_file "/verifier/assets/hi/vk_batch.vkey" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/vk_batch.vkey" "$VK_BATCH_SHASUM_HI"
+download_file "/verifier/assets/hi/vk_bundle.vkey" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/vk_bundle.vkey" "$VK_BUNDLE_SHASUM_HI"
+download_file "/verifier/assets/hi/evm_verifier.bin" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/evm_verifier.bin" "$VRFR_SHASUM_HI"
+download_file "/verifier/assets/hi/layer2.config" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/layer2.config" "$CFG2_SHASUM_HI"
+download_file "/verifier/assets/hi/layer4.config" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/layer4.config" "$CFG4_SHASUM_HI"
+# download low v0.11.4
+download_file "/verifier/assets/lo/chunk_vk.vkey" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/chunk_vk.vkey" "$VK_CHUNK_SHASUM_LO"
+download_file "/verifier/assets/lo/agg_vk.vkey" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/agg_vk.vkey" "$VK_BATCH_SHASUM_LO"
+download_file "/verifier/assets/lo/evm_verifier.bin" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/evm_verifier.bin" "$VRFR_SHASUM_LO"
+download_file "/verifier/assets/lo/layer2.config" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/layer2.config" "$CFG2_SHASUM_LO"
+download_file "/verifier/assets/lo/layer4.config" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/layer4.config" "$CFG4_SHASUM_LO"

coordinator/go.mod

@@ -6,10 +6,7 @@ require (
 	github.com/appleboy/gin-jwt/v2 v2.9.1
 	github.com/gin-gonic/gin v1.9.1
 	github.com/go-resty/resty/v2 v2.7.0
-	github.com/google/uuid v1.6.0
 	github.com/mitchellh/mapstructure v1.5.0
-	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/da-codec v0.0.0-20240819100936-c6af3bbe7068
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
 	github.com/shopspring/decimal v1.3.1
 	github.com/stretchr/testify v1.9.0
@@ -45,6 +42,12 @@ require (
 	google.golang.org/protobuf v1.33.0 // indirect
 )
 
+require (
+	github.com/google/uuid v1.6.0
+	github.com/prometheus/client_golang v1.19.0
+	github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb
+)
+
 require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bits-and-blooms/bitset v1.13.0 // indirect

coordinator/go.sum

@@ -173,8 +173,8 @@ github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjR
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.0.0-20240819100936-c6af3bbe7068 h1:oVGwhg4cCq35B04eG/S4OBXDwXiFH7+LezuH2ZTRBPs=
-github.com/scroll-tech/da-codec v0.0.0-20240819100936-c6af3bbe7068/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb h1:uOKdmDT0LsuS3gfynEjR4zA3Ooh6p2Z3O+IMRj2r8LA=
+github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=

coordinator/internal/config/config.go

@@ -6,7 +6,6 @@ import (
 	"path/filepath"
 
 	"scroll-tech/common/database"
-	"scroll-tech/common/utils"
 )
 
 // ProverManager loads sequencer configuration items.
@@ -24,6 +23,10 @@ type ProverManager struct {
 	ChunkCollectionTimeSec int `json:"chunk_collection_time_sec"`
 	// BundleCollectionTimeSec bundle Proof collection time (in seconds).
 	BundleCollectionTimeSec int `json:"bundle_collection_time_sec"`
+	// Max number of workers in verifier worker pool
+	MaxVerifierWorkers int `json:"max_verifier_workers"`
+	// MinProverVersion is the minimum version of the prover that is required.
+	MinProverVersion string `json:"min_prover_version"`
 }
 
 // L2 loads l2geth configuration items.
@@ -47,19 +50,13 @@ type Config struct {
 	Auth          *Auth            `json:"auth"`
 }
 
-// CircuitConfig circuit items.
-type CircuitConfig struct {
-	ParamsPath       string `json:"params_path"`
-	AssetsPath       string `json:"assets_path"`
-	ForkName         string `json:"fork_name"`
-	MinProverVersion string `json:"min_prover_version"`
-}
-
 // VerifierConfig load zk verifier config.
 type VerifierConfig struct {
-	MockMode           bool           `json:"mock_mode"`
-	LowVersionCircuit  *CircuitConfig `json:"low_version_circuit"`
-	HighVersionCircuit *CircuitConfig `json:"high_version_circuit"`
+	ForkName     string `json:"fork_name"`
+	MockMode     bool   `json:"mock_mode"`
+	ParamsPath   string `json:"params_path"`
+	AssetsPathLo string `json:"assets_path_lo"` // lower version Verifier
+	AssetsPathHi string `json:"assets_path_hi"` // higher version Verifier
 }
 
 // NewConfig returns a new instance of Config.
@@ -75,11 +72,5 @@ func NewConfig(file string) (*Config, error) {
 		return nil, err
 	}
 
-	// Override config with environment variables
-	err = utils.OverrideConfigWithEnv(cfg, "SCROLL_COORDINATOR")
-	if err != nil {
-		return nil, err
-	}
-
 	return cfg, nil
 }

coordinator/internal/controller/api/auth.go

@@ -44,33 +44,21 @@ func (a *AuthController) Login(c *gin.Context) (interface{}, error) {
 		return "", fmt.Errorf("check the login parameter failure: %w", err)
 	}
 
-	hardForkNames, err := a.loginLogic.ProverHardForkName(&login)
-	if err != nil {
-		return "", fmt.Errorf("prover hard name failure:%w", err)
-	}
-
 	// check the challenge is used, if used, return failure
 	if err := a.loginLogic.InsertChallengeString(c, login.Message.Challenge); err != nil {
 		return "", fmt.Errorf("login insert challenge string failure:%w", err)
 	}
-
-	returnData := types.LoginParameterWithHardForkName{
-		HardForkName:   hardForkNames,
-		LoginParameter: login,
-	}
-
-	return returnData, nil
+	return login, nil
 }
 
 // PayloadFunc returns jwt.MapClaims with {public key, prover name}.
 func (a *AuthController) PayloadFunc(data interface{}) jwt.MapClaims {
-	v, ok := data.(types.LoginParameterWithHardForkName)
+	v, ok := data.(types.LoginParameter)
 	if !ok {
 		return jwt.MapClaims{}
 	}
 
 	return jwt.MapClaims{
-		types.HardForkName:  v.HardForkName,
 		types.PublicKey:     v.PublicKey,
 		types.ProverName:    v.Message.ProverName,
 		types.ProverVersion: v.Message.ProverVersion,
@@ -91,10 +79,5 @@ func (a *AuthController) IdentityHandler(c *gin.Context) interface{} {
 	if proverVersion, ok := claims[types.ProverVersion]; ok {
 		c.Set(types.ProverVersion, proverVersion)
 	}
-
-	if hardForkName, ok := claims[types.HardForkName]; ok {
-		c.Set(types.HardForkName, hardForkName)
-	}
-
 	return nil
 }

coordinator/internal/controller/api/controller.go

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

coordinator/internal/controller/api/get_task.go

@@ -108,6 +108,10 @@ func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 
 func (ptc *GetTaskController) proofType(para *coordinatorType.GetTaskParameter) message.ProofType {
 	var proofTypes []message.ProofType
+	if para.TaskType != 0 {
+		proofTypes = append(proofTypes, message.ProofType(para.TaskType))
+	}
+
 	for _, proofType := range para.TaskTypes {
 		proofTypes = append(proofTypes, message.ProofType(proofType))
 	}

coordinator/internal/logic/auth/login.go

@@ -3,7 +3,6 @@ package auth
 import (
 	"errors"
 	"fmt"
-	"strings"
 
 	"github.com/gin-gonic/gin"
 	"github.com/scroll-tech/go-ethereum/log"
@@ -24,35 +23,31 @@ type LoginLogic struct {
 	chunkVks     map[string]struct{}
 	batchVKs     map[string]struct{}
 	bundleVks    map[string]struct{}
-
-	proverVersionHardForkMap map[string][]string
 }
 
 // NewLoginLogic new a LoginLogic
 func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *LoginLogic {
-	proverVersionHardForkMap := make(map[string][]string)
-	if version.CheckScrollRepoVersion(cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion) {
-		log.Error("config file error, low verifier min_prover_version should not more than high verifier min_prover_version",
-			"low verifier min_prover_version", cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion,
-			"high verifier min_prover_version", cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion)
-		panic("verifier config file error")
+	l := &LoginLogic{
+		cfg:          cfg,
+		chunkVks:     make(map[string]struct{}),
+		batchVKs:     make(map[string]struct{}),
+		bundleVks:    make(map[string]struct{}),
+		challengeOrm: orm.NewChallenge(db),
 	}
 
-	var highHardForks []string
-	highHardForks = append(highHardForks, cfg.ProverManager.Verifier.HighVersionCircuit.ForkName)
-	highHardForks = append(highHardForks, cfg.ProverManager.Verifier.LowVersionCircuit.ForkName)
-	proverVersionHardForkMap[cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion] = highHardForks
-
-	proverVersionHardForkMap[cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion] = []string{cfg.ProverManager.Verifier.LowVersionCircuit.ForkName}
-
-	return &LoginLogic{
-		cfg:                      cfg,
-		chunkVks:                 vf.ChunkVKMap,
-		batchVKs:                 vf.BatchVKMap,
-		bundleVks:                vf.BundleVkMap,
-		challengeOrm:             orm.NewChallenge(db),
-		proverVersionHardForkMap: proverVersionHardForkMap,
+	for _, vk := range vf.ChunkVKMap {
+		l.chunkVks[vk] = struct{}{}
 	}
+
+	for _, vk := range vf.BatchVKMap {
+		l.batchVKs[vk] = struct{}{}
+	}
+
+	for _, vk := range vf.BundleVkMap {
+		l.bundleVks[vk] = struct{}{}
+	}
+
+	return l
 }
 
 // InsertChallengeString insert and check the challenge string is existed
@@ -61,16 +56,16 @@ func (l *LoginLogic) InsertChallengeString(ctx *gin.Context, challenge string) e
 }
 
 func (l *LoginLogic) Check(login *types.LoginParameter) error {
-	verify, err := login.Verify()
-	if err != nil || !verify {
-		log.Error("auth message verify failure", "prover_name", login.Message.ProverName,
-			"prover_version", login.Message.ProverVersion, "message", login.Message)
-		return errors.New("auth message verify failure")
+	if login.PublicKey != "" {
+		verify, err := login.Verify()
+		if err != nil || !verify {
+			return errors.New("auth message verify failure")
+		}
 	}
 
-	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion) {
+	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.MinProverVersion) {
 		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s",
-			l.cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, login.Message.ProverVersion)
+			l.cfg.ProverManager.MinProverVersion, login.Message.ProverVersion)
 	}
 
 	if len(login.Message.ProverTypes) > 0 {
@@ -89,14 +84,13 @@ func (l *LoginLogic) Check(login *types.LoginParameter) error {
 					vks[vk] = struct{}{}
 				}
 			default:
-				log.Error("invalid prover_type", "value", proverType, "prover name", login.Message.ProverName, "prover_version", login.Message.ProverVersion)
+				log.Error("invalid prover_type", "value", proverType)
 			}
 		}
 
 		for _, vk := range login.Message.VKs {
 			if _, ok := vks[vk]; !ok {
-				log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
-					"prover_version", login.Message.ProverVersion, "message", login.Message)
+				log.Error("vk inconsistency", "prover vk", vk)
 				if !version.CheckScrollProverVersion(login.Message.ProverVersion) {
 					return fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s",
 						version.Version, login.Message.ProverVersion)
@@ -108,18 +102,3 @@ func (l *LoginLogic) Check(login *types.LoginParameter) error {
 	}
 	return nil
 }
-
-// ProverHardForkName retrieves hard fork name which prover belongs to
-func (l *LoginLogic) ProverHardForkName(login *types.LoginParameter) (string, error) {
-	proverVersionSplits := strings.Split(login.Message.ProverVersion, "-")
-	if len(proverVersionSplits) == 0 {
-		return "", fmt.Errorf("invalid prover prover_version:%s", login.Message.ProverVersion)
-	}
-
-	proverVersion := proverVersionSplits[0]
-	if hardForkNames, ok := l.proverVersionHardForkMap[proverVersion]; ok {
-		return strings.Join(hardForkNames, ","), nil
-	}
-
-	return "", fmt.Errorf("invalid prover prover_version:%s", login.Message.ProverVersion)
-}

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -9,9 +9,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/da-codec/encoding/codecv3"
-	"github.com/scroll-tech/da-codec/encoding/codecv4"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/params"
@@ -31,8 +29,9 @@ import (
 type BatchProverTask struct {
 	BaseProverTask
 
-	batchTaskGetTaskTotal  *prometheus.CounterVec
-	batchTaskGetTaskProver *prometheus.CounterVec
+	batchAttemptsExceedTotal prometheus.Counter
+	batchTaskGetTaskTotal    *prometheus.CounterVec
+	batchTaskGetTaskProver   *prometheus.CounterVec
 }
 
 // NewBatchProverTask new a batch collector
@@ -48,6 +47,10 @@ func NewBatchProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *go
 			proverTaskOrm:      orm.NewProverTask(db),
 			proverBlockListOrm: orm.NewProverBlockList(db),
 		},
+		batchAttemptsExceedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+			Name: "coordinator_batch_attempts_exceed_total",
+			Help: "Total number of batch attempts exceed.",
+		}),
 		batchTaskGetTaskTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
 			Name: "coordinator_batch_get_task_total",
 			Help: "Total number of batch get task.",
@@ -120,15 +123,6 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	//if _, ok := taskCtx.HardForkNames[hardForkName]; !ok {
-	//	bp.recoverActiveAttempts(ctx, batchTask)
-	//	log.Error("incompatible prover version",
-	//		"requisite hard fork name", hardForkName,
-	//		"prover hard fork name", taskCtx.HardForkNames,
-	//		"task_id", batchTask.Hash)
-	//	return nil, ErrCoordinatorInternalFailure
-	//}
-
 	proverTask := orm.ProverTask{
 		TaskID:          batchTask.Hash,
 		ProverPublicKey: taskCtx.PublicKey,
@@ -214,9 +208,17 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		chunkInfos = append(chunkInfos, &chunkInfo)
 	}
 
-	taskDetail, err := bp.getBatchTaskDetail(batch, chunkInfos, chunkProofs)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get batch task detail, taskID:%s err:%w", task.TaskID, err)
+	taskDetail := message.BatchTaskDetail{
+		ChunkInfos:  chunkInfos,
+		ChunkProofs: chunkProofs,
+	}
+
+	if hardForkName == "darwin" {
+		batchHeader, decodeErr := codecv3.NewDABatchFromBytes(batch.BatchHeader)
+		if decodeErr != nil {
+			return nil, fmt.Errorf("failed to decode batch header, taskID:%s err:%w", task.TaskID, decodeErr)
+		}
+		taskDetail.BatchHeader = batchHeader
 	}
 
 	chunkProofsBytes, err := json.Marshal(taskDetail)
@@ -239,34 +241,3 @@ func (bp *BatchProverTask) recoverActiveAttempts(ctx *gin.Context, batchTask *or
 		log.Error("failed to recover batch active attempts", "hash", batchTask.Hash, "error", err)
 	}
 }
-
-func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*message.ChunkInfo, chunkProofs []*message.ChunkProof) (*message.BatchTaskDetail, error) {
-	taskDetail := &message.BatchTaskDetail{
-		ChunkInfos:  chunkInfos,
-		ChunkProofs: chunkProofs,
-	}
-
-	if encoding.CodecVersion(dbBatch.CodecVersion) != encoding.CodecV3 && encoding.CodecVersion(dbBatch.CodecVersion) != encoding.CodecV4 {
-		return taskDetail, nil
-	}
-
-	if encoding.CodecVersion(dbBatch.CodecVersion) == encoding.CodecV3 {
-		batchHeader, decodeErr := codecv3.NewDABatchFromBytes(dbBatch.BatchHeader)
-		if decodeErr != nil {
-			return nil, fmt.Errorf("failed to decode batch header (v3) for batch %d: %w", dbBatch.Index, decodeErr)
-		}
-
-		taskDetail.BatchHeader = batchHeader
-		taskDetail.BlobBytes = dbBatch.BlobBytes
-	} else {
-		batchHeader, decodeErr := codecv4.NewDABatchFromBytes(dbBatch.BatchHeader)
-		if decodeErr != nil {
-			return nil, fmt.Errorf("failed to decode batch header (v4) for batch %d: %w", dbBatch.Index, decodeErr)
-		}
-
-		taskDetail.BatchHeader = batchHeader
-		taskDetail.BlobBytes = dbBatch.BlobBytes
-	}
-
-	return taskDetail, nil
-}

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -27,8 +27,9 @@ import (
 type BundleProverTask struct {
 	BaseProverTask
 
-	bundleTaskGetTaskTotal  *prometheus.CounterVec
-	bundleTaskGetTaskProver *prometheus.CounterVec
+	bundleAttemptsExceedTotal prometheus.Counter
+	bundleTaskGetTaskTotal    *prometheus.CounterVec
+	bundleTaskGetTaskProver   *prometheus.CounterVec
 }
 
 // NewBundleProverTask new a bundle collector
@@ -45,6 +46,10 @@ func NewBundleProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *g
 			proverTaskOrm:      orm.NewProverTask(db),
 			proverBlockListOrm: orm.NewProverBlockList(db),
 		},
+		bundleAttemptsExceedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+			Name: "coordinator_bundle_attempts_exceed_total",
+			Help: "Total number of bundle attempts exceed.",
+		}),
 		bundleTaskGetTaskTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
 			Name: "coordinator_bundle_get_task_total",
 			Help: "Total number of bundle get task.",
@@ -117,15 +122,6 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	//if _, ok := taskCtx.HardForkNames[hardForkName]; !ok {
-	//	bp.recoverActiveAttempts(ctx, bundleTask)
-	//	log.Error("incompatible prover version",
-	//		"requisite hard fork name", hardForkName,
-	//		"prover hard fork name", taskCtx.HardForkNames,
-	//		"task_id", bundleTask.Hash)
-	//	return nil, ErrCoordinatorInternalFailure
-	//}
-
 	proverTask := orm.ProverTask{
 		TaskID:          bundleTask.Hash,
 		ProverPublicKey: taskCtx.PublicKey,

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -27,8 +27,9 @@ import (
 type ChunkProverTask struct {
 	BaseProverTask
 
-	chunkTaskGetTaskTotal  *prometheus.CounterVec
-	chunkTaskGetTaskProver *prometheus.CounterVec
+	chunkAttemptsExceedTotal prometheus.Counter
+	chunkTaskGetTaskTotal    *prometheus.CounterVec
+	chunkTaskGetTaskProver   *prometheus.CounterVec
 }
 
 // NewChunkProverTask new a chunk prover task
@@ -43,6 +44,10 @@ func NewChunkProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *go
 			proverTaskOrm:      orm.NewProverTask(db),
 			proverBlockListOrm: orm.NewProverBlockList(db),
 		},
+		chunkAttemptsExceedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+			Name: "coordinator_chunk_attempts_exceed_total",
+			Help: "Total number of chunk attempts exceed.",
+		}),
 		chunkTaskGetTaskTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
 			Name: "coordinator_chunk_get_task_total",
 			Help: "Total number of chunk get task.",
@@ -65,7 +70,7 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpChunkTask *orm.Chunk
-		tmpChunkTask, getTaskError = cp.chunkOrm.GetAssignedChunk(ctx.Copy(), maxActiveAttempts, maxTotalAttempts, getTaskParameter.ProverHeight)
+		tmpChunkTask, getTaskError = cp.chunkOrm.GetAssignedChunk(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
 		if getTaskError != nil {
 			log.Error("failed to get assigned chunk proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 			return nil, ErrCoordinatorInternalFailure
@@ -74,7 +79,7 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		// Why here need get again? In order to support a task can assign to multiple prover, need also assign `ProvingTaskAssigned`
 		// chunk to prover. But use `proving_status in (1, 2)` will not use the postgres index. So need split the sql.
 		if tmpChunkTask == nil {
-			tmpChunkTask, getTaskError = cp.chunkOrm.GetUnassignedChunk(ctx.Copy(), maxActiveAttempts, maxTotalAttempts, getTaskParameter.ProverHeight)
+			tmpChunkTask, getTaskError = cp.chunkOrm.GetUnassignedChunk(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
 			if getTaskError != nil {
 				log.Error("failed to get unassigned chunk proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 				return nil, ErrCoordinatorInternalFailure
@@ -115,15 +120,6 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	//if _, ok := taskCtx.HardForkNames[hardForkName]; !ok {
-	//	cp.recoverActiveAttempts(ctx, chunkTask)
-	//	log.Error("incompatible prover version",
-	//		"requisite hard fork name", hardForkName,
-	//		"prover hard fork name", taskCtx.HardForkNames,
-	//		"task_id", chunkTask.Hash)
-	//	return nil, ErrCoordinatorInternalFailure
-	//}
-
 	proverTask := orm.ProverTask{
 		TaskID:          chunkTask.Hash,
 		ProverPublicKey: taskCtx.PublicKey,

coordinator/internal/logic/provertask/prover_task.go

@@ -3,7 +3,6 @@ package provertask
 import (
 	"errors"
 	"fmt"
-	"strings"
 	"sync"
 
 	"github.com/gin-gonic/gin"
@@ -50,13 +49,11 @@ type proverTaskContext struct {
 	PublicKey     string
 	ProverName    string
 	ProverVersion string
-	HardForkNames map[string]struct{}
 }
 
 // checkParameter check the prover task parameter illegal
 func (b *BaseProverTask) checkParameter(ctx *gin.Context) (*proverTaskContext, error) {
 	var ptc proverTaskContext
-	ptc.HardForkNames = make(map[string]struct{})
 
 	publicKey, publicKeyExist := ctx.Get(coordinatorType.PublicKey)
 	if !publicKeyExist {
@@ -76,15 +73,6 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context) (*proverTaskContext, e
 	}
 	ptc.ProverVersion = proverVersion.(string)
 
-	hardForkNamesStr, hardForkNameExist := ctx.Get(coordinatorType.HardForkName)
-	if !hardForkNameExist {
-		return nil, errors.New("get hard fork name from context failed")
-	}
-	hardForkNames := strings.Split(hardForkNamesStr.(string), ",")
-	for _, hardForkName := range hardForkNames {
-		ptc.HardForkNames[hardForkName] = struct{}{}
-	}
-
 	isBlocked, err := b.proverBlockListOrm.IsPublicKeyBlocked(ctx.Copy(), publicKey.(string))
 	if err != nil {
 		return nil, fmt.Errorf("failed to check whether the public key %s is blocked before assigning a chunk task, err: %w, proverName: %s, proverVersion: %s", publicKey, err, proverName, proverVersion)

coordinator/internal/logic/submitproof/proof_receiver.go

@@ -187,7 +187,7 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &bundleProof); unmarshalErr != nil {
 			return unmarshalErr
 		}
-		success, verifyErr = m.verifier.VerifyBundleProof(&bundleProof, hardForkName)
+		success, verifyErr = m.verifier.VerifyBundleProof(&bundleProof)
 	}
 
 	if verifyErr != nil || !success {

coordinator/internal/logic/verifier/legacy_vk/upgrade_vks.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+work_dir="$(dirname -- "${BASH_SOURCE[0]}")"
+work_dir="$(cd -- "$work_dir" && pwd)"
+echo $work_dir
+
+rm $work_dir/*.vkey
+
+version=release-v0.11.4
+wget https://circuit-release.s3.us-west-2.amazonaws.com/${version}/chunk_vk.vkey -O $work_dir/chunk_vk.vkey
+wget https://circuit-release.s3.us-west-2.amazonaws.com/${version}/agg_vk.vkey -O $work_dir/agg_vk.vkey

coordinator/internal/logic/verifier/mock.go

@@ -10,8 +10,8 @@ import (
 
 // NewVerifier Sets up a mock verifier.
 func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
-	batchVKMap := map[string]struct{}{"mock_vk": {}}
-	chunkVKMap := map[string]struct{}{"mock_vk": {}}
+	batchVKMap := map[string]string{cfg.ForkName: "mock_vk"}
+	chunkVKMap := map[string]string{cfg.ForkName: "mock_vk"}
 	return &Verifier{cfg: cfg, ChunkVKMap: chunkVKMap, BatchVKMap: batchVKMap}, nil
 }
 
@@ -32,7 +32,7 @@ func (v *Verifier) VerifyBatchProof(proof *message.BatchProof, forkName string)
 }
 
 // VerifyBundleProof return a mock verification result for a BundleProof.
-func (v *Verifier) VerifyBundleProof(proof *message.BundleProof, forkName string) (bool, error) {
+func (v *Verifier) VerifyBundleProof(proof *message.BundleProof) (bool, error) {
 	if string(proof.Proof) == InvalidTestProof {
 		return false, nil
 	}

coordinator/internal/logic/verifier/types.go

@@ -10,7 +10,7 @@ const InvalidTestProof = "this is a invalid proof"
 // Verifier represents a rust ffi to a halo2 verifier.
 type Verifier struct {
 	cfg         *config.VerifierConfig
-	ChunkVKMap  map[string]struct{}
-	BatchVKMap  map[string]struct{}
-	BundleVkMap map[string]struct{}
+	ChunkVKMap  map[string]string
+	BatchVKMap  map[string]string
+	BundleVkMap map[string]string
 }

coordinator/internal/logic/verifier/verifier.go

@@ -11,9 +11,11 @@ package verifier
 import "C" //nolint:typecheck
 
 import (
+	"embed"
 	"encoding/base64"
 	"encoding/json"
 	"io"
+	"io/fs"
 	"os"
 	"path"
 	"unsafe"
@@ -25,87 +27,52 @@ import (
 	"scroll-tech/coordinator/internal/config"
 )
 
-// This struct maps to `CircuitConfig` in common/libzkp/impl/src/verifier.rs
-// Define a brand new struct here is to eliminate side effects in case fields
-// in `*config.CircuitConfig` being changed
-type rustCircuitConfig struct {
-	ForkName   string `json:"fork_name"`
-	ParamsPath string `json:"params_path"`
-	AssetsPath string `json:"assets_path"`
-}
-
-func newRustCircuitConfig(cfg *config.CircuitConfig) *rustCircuitConfig {
-	return &rustCircuitConfig{
-		ForkName:   cfg.ForkName,
-		ParamsPath: cfg.ParamsPath,
-		AssetsPath: cfg.AssetsPath,
-	}
-}
-
-// This struct maps to `VerifierConfig` in common/libzkp/impl/src/verifier.rs
-// Define a brand new struct here is to eliminate side effects in case fields
-// in `*config.VerifierConfig` being changed
-type rustVerifierConfig struct {
-	LowVersionCircuit  *rustCircuitConfig `json:"low_version_circuit"`
-	HighVersionCircuit *rustCircuitConfig `json:"high_version_circuit"`
-}
-
-func newRustVerifierConfig(cfg *config.VerifierConfig) *rustVerifierConfig {
-	return &rustVerifierConfig{
-		LowVersionCircuit:  newRustCircuitConfig(cfg.LowVersionCircuit),
-		HighVersionCircuit: newRustCircuitConfig(cfg.HighVersionCircuit),
-	}
-}
-
 // NewVerifier Sets up a rust ffi to call verify.
 func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 	if cfg.MockMode {
-		chunkVKMap := map[string]struct{}{"mock_vk": {}}
-		batchVKMap := map[string]struct{}{"mock_vk": {}}
-		bundleVKMap := map[string]struct{}{"mock_vk": {}}
+		chunkVKMap := map[string]string{cfg.ForkName: "mock_vk"}
+		batchVKMap := map[string]string{cfg.ForkName: "mock_vk"}
+		bundleVKMap := map[string]string{cfg.ForkName: "mock_vk"}
 		return &Verifier{cfg: cfg, ChunkVKMap: chunkVKMap, BatchVKMap: batchVKMap, BundleVkMap: bundleVKMap}, nil
 	}
-	verifierConfig := newRustVerifierConfig(cfg)
-	configBytes, err := json.Marshal(verifierConfig)
-	if err != nil {
-		return nil, err
-	}
-
-	configStr := C.CString(string(configBytes))
+	paramsPathStr := C.CString(cfg.ParamsPath)
+	assetsPathLoStr := C.CString(cfg.AssetsPathLo)
+	assetsPathHiStr := C.CString(cfg.AssetsPathHi)
 	defer func() {
-		C.free(unsafe.Pointer(configStr))
+		C.free(unsafe.Pointer(paramsPathStr))
+		C.free(unsafe.Pointer(assetsPathLoStr))
+		C.free(unsafe.Pointer(assetsPathHiStr))
 	}()
 
-	C.init(configStr)
+	C.init_batch_verifier(paramsPathStr, assetsPathHiStr)
+	C.init_chunk_verifier(paramsPathStr, assetsPathLoStr, assetsPathHiStr)
 
 	v := &Verifier{
 		cfg:         cfg,
-		ChunkVKMap:  make(map[string]struct{}),
-		BatchVKMap:  make(map[string]struct{}),
-		BundleVkMap: make(map[string]struct{}),
+		ChunkVKMap:  make(map[string]string),
+		BatchVKMap:  make(map[string]string),
+		BundleVkMap: make(map[string]string),
 	}
 
-	bundleVK, err := v.readVK(path.Join(cfg.HighVersionCircuit.AssetsPath, "vk_bundle.vkey"))
+	bundleVK, err := v.readVK(path.Join(cfg.AssetsPathHi, "vk_bundle.vkey"))
 	if err != nil {
 		return nil, err
 	}
-	batchVK, err := v.readVK(path.Join(cfg.HighVersionCircuit.AssetsPath, "vk_batch.vkey"))
+	batchVK, err := v.readVK(path.Join(cfg.AssetsPathHi, "vk_batch.vkey"))
 	if err != nil {
 		return nil, err
 	}
-	chunkVK, err := v.readVK(path.Join(cfg.HighVersionCircuit.AssetsPath, "vk_chunk.vkey"))
+	chunkVK, err := v.readVK(path.Join(cfg.AssetsPathHi, "vk_chunk.vkey"))
 	if err != nil {
 		return nil, err
 	}
-	v.BundleVkMap[bundleVK] = struct{}{}
-	v.BatchVKMap[batchVK] = struct{}{}
-	v.ChunkVKMap[chunkVK] = struct{}{}
+	v.BundleVkMap[cfg.ForkName] = bundleVK
+	v.BatchVKMap[cfg.ForkName] = batchVK
+	v.ChunkVKMap[cfg.ForkName] = chunkVK
 
-	if err := v.loadLowVersionVKs(cfg); err != nil {
+	if err := v.loadEmbedVK(); err != nil {
 		return nil, err
 	}
-
-	v.loadCurieVersionVKs()
 	return v, nil
 }
 
@@ -164,7 +131,7 @@ func (v *Verifier) VerifyChunkProof(proof *message.ChunkProof, forkName string)
 }
 
 // VerifyBundleProof Verify a ZkProof for a bundle of batches, by marshaling it and verifying it via the EVM verifier.
-func (v *Verifier) VerifyBundleProof(proof *message.BundleProof, forkName string) (bool, error) {
+func (v *Verifier) VerifyBundleProof(proof *message.BundleProof) (bool, error) {
 	if v.cfg.MockMode {
 		log.Info("Mock mode, verifier disabled")
 		if string(proof.Proof) == InvalidTestProof {
@@ -179,14 +146,12 @@ func (v *Verifier) VerifyBundleProof(proof *message.BundleProof, forkName string
 	}
 
 	proofStr := C.CString(string(buf))
-	forkNameStr := C.CString(forkName)
 	defer func() {
 		C.free(unsafe.Pointer(proofStr))
-		C.free(unsafe.Pointer(forkNameStr))
 	}()
 
 	log.Info("Start to verify bundle proof ...")
-	verified := C.verify_bundle_proof(proofStr, forkNameStr)
+	verified := C.verify_bundle_proof(proofStr)
 	return verified != 0, nil
 }
 
@@ -202,27 +167,23 @@ func (v *Verifier) readVK(filePat string) (string, error) {
 	return base64.StdEncoding.EncodeToString(byt), nil
 }
 
-// load low version vks, current is darwin
-func (v *Verifier) loadLowVersionVKs(cfg *config.VerifierConfig) error {
-	bundleVK, err := v.readVK(path.Join(cfg.LowVersionCircuit.AssetsPath, "vk_bundle.vkey"))
+//go:embed legacy_vk/*
+var legacyVKFS embed.FS
+
+func (v *Verifier) loadEmbedVK() error {
+	batchVKBytes, err := fs.ReadFile(legacyVKFS, "legacy_vk/agg_vk.vkey")
 	if err != nil {
+		log.Error("load embed batch vk failure", "err", err)
 		return err
 	}
-	batchVK, err := v.readVK(path.Join(cfg.LowVersionCircuit.AssetsPath, "vk_batch.vkey"))
+
+	chunkVkBytes, err := fs.ReadFile(legacyVKFS, "legacy_vk/chunk_vk.vkey")
 	if err != nil {
+		log.Error("load embed chunk vk failure", "err", err)
 		return err
 	}
-	chunkVK, err := v.readVK(path.Join(cfg.LowVersionCircuit.AssetsPath, "vk_chunk.vkey"))
-	if err != nil {
-		return err
-	}
-	v.BundleVkMap[bundleVK] = struct{}{}
-	v.BatchVKMap[batchVK] = struct{}{}
-	v.ChunkVKMap[chunkVK] = struct{}{}
+
+	v.BatchVKMap["curie"] = base64.StdEncoding.EncodeToString(batchVKBytes)
+	v.ChunkVKMap["curie"] = base64.StdEncoding.EncodeToString(chunkVkBytes)
 	return nil
 }
-
-func (v *Verifier) loadCurieVersionVKs() {
-	v.BatchVKMap["AAAAGgAAAARX2S0K1wF333B1waOsnG/vcASJmWG9YM6SNWCBy1ywD9jfGkei+f0wNYpkjW7JO12EfU7CjYVBo+PGku3zaQJI64lbn6BwyTBa4RfrPFpV5mP47ix0sXZ+Wt5wklMLRW7OIJb1yfCDm+gkSsp3/Zqrxt4SY4rQ4WtHfynTCQ0KDi78jNuiFvwxO3ub3DkgGVaxMkGxTRP/Vz6E7MCZMUBR5wZFcMzJn+73f0wYjDxfj00krg9O1VrwVxbVV1ycLR6oQLcOgm/l+xwth8io0vDpF9OY21gD5DgJn9GgcYe8KoRVEbEqApLZPdBibpcSMTY9czZI2LnFcqrDDmYvhEwgjhZrsTog2xLXOODoOupZ/is5ekQ9Gi0y871b1mLlCGA="] = struct{}{}
-	v.ChunkVKMap["AAAAGQAAAATyWEABRbJ6hQQ5/zLX1gTasr7349minA9rSgMS6gDeHwZKqikRiO3md+pXjjxMHnKQtmXYgMXhJSvlmZ+Ws+cheuly2X1RuNQzcZuRImaKPR9LJsVZYsXfJbuqdKX8p0Gj8G83wMJOmTzNVUyUol0w0lTU+CEiTpHOnxBsTF3EWaW3s1u4ycOgWt1c9M6s7WmaBZLYgAWYCunO5CLCLApNGbCASeck/LuSoedEri5u6HccCKU2khG6zl6W07jvYSbDVLJktbjRiHv+/HQix+K14j8boo8Z/unhpwXCsPxkQA=="] = struct{}{}
-}

coordinator/internal/logic/verifier/verifier_test.go

@@ -18,8 +18,8 @@ import (
 
 var (
 	paramsPath      = flag.String("params", "/assets/test_params", "params dir")
-	assetsPathLo    = flag.String("assets_lo", "/assets/test_assets_lo", "assets dir")
-	assetsPathHi    = flag.String("assets", "/assets/test_assets", "assets dir")
+	assetsPathLo    = flag.String("assets", "/assets/test_assets_lo", "assets dir")
+	assetsPathHi    = flag.String("assets", "/assets/test_assets_hi", "assets dir")
 	batchProofPath  = flag.String("batch_proof", "/assets/proof_data/batch_proof", "batch proof file path")
 	chunkProofPath1 = flag.String("chunk_proof1", "/assets/proof_data/chunk_proof1", "chunk proof file path 1")
 	chunkProofPath2 = flag.String("chunk_proof2", "/assets/proof_data/chunk_proof2", "chunk proof file path 2")
@@ -29,38 +29,29 @@ func TestFFI(t *testing.T) {
 	as := assert.New(t)
 
 	cfg := &config.VerifierConfig{
-		MockMode: false,
-		LowVersionCircuit: &config.CircuitConfig{
-			ParamsPath:       *paramsPath,
-			AssetsPath:       *assetsPathLo,
-			ForkName:         "darwin",
-			MinProverVersion: "",
-		},
-		HighVersionCircuit: &config.CircuitConfig{
-			ParamsPath:       *paramsPath,
-			AssetsPath:       *assetsPathHi,
-			ForkName:         "darwinV2",
-			MinProverVersion: "",
-		},
+		MockMode:     false,
+		ParamsPath:   *paramsPath,
+		AssetsPathLo: *assetsPathLo,
+		AssetsPathHi: *assetsPathHi,
 	}
 
 	v, err := NewVerifier(cfg)
 	as.NoError(err)
 
 	chunkProof1 := readChunkProof(*chunkProofPath1, as)
-	chunkOk1, err := v.VerifyChunkProof(chunkProof1, "darwinV2")
+	chunkOk1, err := v.VerifyChunkProof(chunkProof1)
 	as.NoError(err)
 	as.True(chunkOk1)
 	t.Log("Verified chunk proof 1")
 
 	chunkProof2 := readChunkProof(*chunkProofPath2, as)
-	chunkOk2, err := v.VerifyChunkProof(chunkProof2, "darwinV2")
+	chunkOk2, err := v.VerifyChunkProof(chunkProof2)
 	as.NoError(err)
 	as.True(chunkOk2)
 	t.Log("Verified chunk proof 2")
 
 	batchProof := readBatchProof(*batchProofPath, as)
-	batchOk, err := v.VerifyBatchProof(batchProof, "darwinV2")
+	batchOk, err := v.VerifyBatchProof(batchProof, "curie")
 	as.NoError(err)
 	as.True(batchOk)
 	t.Log("Verified batch proof")

coordinator/internal/orm/batch.go

@@ -31,9 +31,6 @@ type Batch struct {
 	WithdrawRoot    string `json:"withdraw_root" gorm:"column:withdraw_root"`
 	ParentBatchHash string `json:"parent_batch_hash" gorm:"column:parent_batch_hash"`
 	BatchHeader     []byte `json:"batch_header" gorm:"column:batch_header"`
-	CodecVersion    int16  `json:"codec_version" gorm:"column:codec_version"`
-	EnableCompress  bool   `json:"enable_compress" gorm:"column:enable_compress"`
-	BlobBytes       []byte `json:"blob_bytes" gorm:"column:blob_bytes"`
 
 	// proof
 	ChunkProofsStatus int16      `json:"chunk_proofs_status" gorm:"column:chunk_proofs_status;default:1"`
@@ -228,19 +225,6 @@ func (o *Batch) GetBatchesByBundleHash(ctx context.Context, bundleHash string) (
 	return batches, nil
 }
 
-// GetBatchByIndex retrieves the batch by the given index.
-func (o *Batch) GetBatchByIndex(ctx context.Context, index uint64) (*Batch, error) {
-	db := o.db.WithContext(ctx)
-	db = db.Model(&Batch{})
-	db = db.Where("index = ?", index)
-
-	var batch Batch
-	if err := db.First(&batch).Error; err != nil {
-		return nil, fmt.Errorf("Batch.GetBatchByIndex error: %w, index: %v", err, index)
-	}
-	return &batch, nil
-}
-
 // InsertBatch inserts a new batch into the database.
 func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, dbTX ...*gorm.DB) (*Batch, error) {
 	if batch == nil {

coordinator/internal/orm/chunk.go

@@ -74,11 +74,11 @@ func (*Chunk) TableName() string {
 
 // GetUnassignedChunk retrieves unassigned chunk based on the specified limit.
 // The returned chunks are sorted in ascending order by their index.
-func (o *Chunk) GetUnassignedChunk(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8, height uint64) (*Chunk, error) {
+func (o *Chunk) GetUnassignedChunk(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8) (*Chunk, error) {
 	var chunk Chunk
 	db := o.db.WithContext(ctx)
-	sql := fmt.Sprintf("SELECT * FROM chunk WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND end_block_number <= %d AND chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
-		int(types.ProvingTaskUnassigned), maxTotalAttempts, maxActiveAttempts, height)
+	sql := fmt.Sprintf("SELECT * FROM chunk WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
+		int(types.ProvingTaskUnassigned), maxTotalAttempts, maxActiveAttempts)
 	err := db.Raw(sql).Scan(&chunk).Error
 	if err != nil {
 		return nil, fmt.Errorf("Chunk.GetUnassignedChunk error: %w", err)
@@ -91,11 +91,11 @@ func (o *Chunk) GetUnassignedChunk(ctx context.Context, maxActiveAttempts, maxTo
 
 // GetAssignedChunk retrieves assigned chunk based on the specified limit.
 // The returned chunks are sorted in ascending order by their index.
-func (o *Chunk) GetAssignedChunk(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8, height uint64) (*Chunk, error) {
+func (o *Chunk) GetAssignedChunk(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8) (*Chunk, error) {
 	var chunk Chunk
 	db := o.db.WithContext(ctx)
-	sql := fmt.Sprintf("SELECT * FROM chunk WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND end_block_number <= %d AND chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
-		int(types.ProvingTaskAssigned), maxTotalAttempts, maxActiveAttempts, height)
+	sql := fmt.Sprintf("SELECT * FROM chunk WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d  AND chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
+		int(types.ProvingTaskAssigned), maxTotalAttempts, maxActiveAttempts)
 	err := db.Raw(sql).Scan(&chunk).Error
 	if err != nil {
 		return nil, fmt.Errorf("Chunk.GetAssignedChunk error: %w", err)

coordinator/internal/orm/l2_block.go

@@ -87,55 +87,6 @@ func (o *L2Block) GetL2BlockByNumber(ctx context.Context, blockNumber uint64) (*
 	return &l2Block, nil
 }
 
-// GetL2BlocksInRange retrieves the L2 blocks within the specified range (inclusive).
-// The range is closed, i.e., it includes both start and end block numbers.
-// The returned blocks are sorted in ascending order by their block number.
-func (o *L2Block) GetL2BlocksInRange(ctx context.Context, startBlockNumber uint64, endBlockNumber uint64) ([]*encoding.Block, error) {
-	if startBlockNumber > endBlockNumber {
-		return nil, fmt.Errorf("L2Block.GetL2BlocksInRange: start block number should be less than or equal to end block number, start block: %v, end block: %v", startBlockNumber, endBlockNumber)
-	}
-
-	db := o.db.WithContext(ctx)
-	db = db.Model(&L2Block{})
-	db = db.Select("header, transactions, withdraw_root, row_consumption")
-	db = db.Where("number >= ? AND number <= ?", startBlockNumber, endBlockNumber)
-	db = db.Order("number ASC")
-
-	var l2Blocks []L2Block
-	if err := db.Find(&l2Blocks).Error; err != nil {
-		return nil, fmt.Errorf("L2Block.GetL2BlocksInRange error: %w, start block: %v, end block: %v", err, startBlockNumber, endBlockNumber)
-	}
-
-	// sanity check
-	if uint64(len(l2Blocks)) != endBlockNumber-startBlockNumber+1 {
-		return nil, fmt.Errorf("L2Block.GetL2BlocksInRange: unexpected number of results, expected: %v, got: %v", endBlockNumber-startBlockNumber+1, len(l2Blocks))
-	}
-
-	var blocks []*encoding.Block
-	for _, v := range l2Blocks {
-		var block encoding.Block
-
-		if err := json.Unmarshal([]byte(v.Transactions), &block.Transactions); err != nil {
-			return nil, fmt.Errorf("L2Block.GetL2BlocksInRange error: %w, start block: %v, end block: %v", err, startBlockNumber, endBlockNumber)
-		}
-
-		block.Header = &gethTypes.Header{}
-		if err := json.Unmarshal([]byte(v.Header), block.Header); err != nil {
-			return nil, fmt.Errorf("L2Block.GetL2BlocksInRange error: %w, start block: %v, end block: %v", err, startBlockNumber, endBlockNumber)
-		}
-
-		block.WithdrawRoot = common.HexToHash(v.WithdrawRoot)
-
-		if err := json.Unmarshal([]byte(v.RowConsumption), &block.RowConsumption); err != nil {
-			return nil, fmt.Errorf("L2Block.GetL2BlocksInRange error: %w, start block: %v, end block: %v", err, startBlockNumber, endBlockNumber)
-		}
-
-		blocks = append(blocks, &block)
-	}
-
-	return blocks, nil
-}
-
 // InsertL2Blocks inserts l2 blocks into the "l2_block" table.
 // for unit test
 func (o *L2Block) InsertL2Blocks(ctx context.Context, blocks []*encoding.Block) error {

coordinator/internal/orm/prover_task.go

@@ -116,6 +116,25 @@ func (o *ProverTask) GetProverTasksByHashes(ctx context.Context, taskType messag
 	return proverTasks, nil
 }
 
+// GetAssignedProverTaskByTaskIDAndProver get prover task taskID and public key
+// TODO: when prover all upgrade need DEPRECATED this function
+func (o *ProverTask) GetAssignedProverTaskByTaskIDAndProver(ctx context.Context, taskType message.ProofType, taskID, proverPublicKey, proverVersion string) (*ProverTask, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&ProverTask{})
+	db = db.Where("task_type", int(taskType))
+	db = db.Where("task_id", taskID)
+	db = db.Where("prover_public_key", proverPublicKey)
+	db = db.Where("prover_version", proverVersion)
+	db = db.Where("proving_status", types.ProverAssigned)
+
+	var proverTask ProverTask
+	err := db.First(&proverTask).Error
+	if err != nil {
+		return nil, fmt.Errorf("ProverTask.GetProverTaskByTaskIDAndProver err:%w, taskID:%s, pubkey:%s, prover_version:%s", err, taskID, proverPublicKey, proverVersion)
+	}
+	return &proverTask, nil
+}
+
 // GetProverTaskByUUIDAndPublicKey get prover task taskID by uuid and public key
 func (o *ProverTask) GetProverTaskByUUIDAndPublicKey(ctx context.Context, uuid, publicKey string) (*ProverTask, error) {
 	db := o.db.WithContext(ctx)

coordinator/internal/types/auth.go

@@ -18,8 +18,6 @@ const (
 	ProverName = "prover_name"
 	// ProverVersion the prover version for context
 	ProverVersion = "prover_version"
-	// HardForkName the hard fork name for context
-	HardForkName = "hard_fork_name"
 )
 
 // LoginSchema for /login response
@@ -37,12 +35,6 @@ type Message struct {
 	VKs           []string     `form:"vks" json:"vks"`
 }
 
-// LoginParameterWithHardForkName constructs new payload for login
-type LoginParameterWithHardForkName struct {
-	LoginParameter
-	HardForkName string `form:"hard_fork_name" json:"hard_fork_name"`
-}
-
 // LoginParameter for /login api
 type LoginParameter struct {
 	Message   Message `form:"message" json:"message" binding:"required"`

coordinator/internal/types/auth_test.go

@@ -60,10 +60,11 @@ func TestGenerateSignature(t *testing.T) {
 	authMsg := LoginParameter{
 		Message: Message{
 			ProverName:    "test",
-			ProverVersion: "v4.4.45-37af5ef5-38a68e2-1c5093c",
-			Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MjQ4Mzg0ODUsIm9yaWdfaWF0IjoxNzI0ODM0ODg1LCJyYW5kb20iOiJ6QmdNZGstNGc4UzNUNTFrVEFsYk1RTXg2TGJ4SUs4czY3ejM2SlNuSFlJPSJ9.x9PvihhNx2w4_OX5uCrv8QJCNYVQkIi-K2k8XFXYmik",
-			ProverTypes:   []ProverType{ProverTypeChunk},
-			VKs:           []string{"mock_vk"},
+			ProverVersion: "v4.4.32-37af5ef5-38a68e2-1c5093c",
+			Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MjEzMjc5MTIsIm9yaWdfaWF0IjoxNzIxMzI0MzEyLCJyYW5kb20iOiJWMVFlT19yNEV5eGRmYUtDalprVExEa0ZIemEyNTdQRG93dTV4SnVxYTdZPSJ9.x-B_TnkTUvs8-hiMfJXejxetAP6rXfeRUmyZ3S0uBiM",
+			ProverTypes:   []ProverType{ProverTypeBatch},
+			VKs: []string{"AAAAGgAAAARX2S0K1wF333B1waOsnG/vcASJmWG9YM6SNWCBy1ywD9jfGkei+f0wNYpkjW7JO12EfU7CjYVBo+PGku3zaQJI64lbn6BwyTBa4RfrPFpV5mP47ix0sXZ+Wt5wklMLRW7OIJb1yfCDm+gkSsp3/Zqrxt4SY4rQ4WtHfynTCQ0KDi78jNuiFvwxO3ub3DkgGVaxMkGxTRP/Vz6E7MCZMUBR5wZFcMzJn+73f0wYjDxfj00krg9O1VrwVxbVV1ycLR6oQLcOgm/l+xwth8io0vDpF9OY21gD5DgJn9GgcYe8KoRVEbEqApLZPdBibpcSMTY9czZI2LnFcqrDDmYvhEwgjhZrsTog2xLXOODoOupZ/is5ekQ9Gi0y871b1mLlCGA=",
+				"AAAAGgAAAARX2S0K1wF333B1waOsnG/vcASJmWG9YM6SNWCBy1ywD1DEjW4Kell67H07wazT5DdzrSh4+amh+cmosQHp9p9snFypyoBGt3UHtoJGQBZlywZWDS9ht5pnaEoGBdaKcQk+lFb+WxTiId0KOAa0mafTZTQw8yToy57Jple64qzlRu1dux30tZZGuerLN1CKzg5Xl2iOpMK+l87jCINwVp5cUtF/XrvhBbU7onKh3KBiy99iUqVyA3Y6iiIZhGKWBSuSA4bNgDYIoVkqjHpdL35aEShoRO6pNXt7rDzxFoPzH0JuPI54nE4OhVrzZXwtkAEosxVa/fszcE092FH+HhhtxZBYe/KEzwdISU9TOPdId3UF/UMYC0MiYOlqffVTgAg="},
 		},
 		PublicKey: publicKeyHex,
 	}

coordinator/internal/types/get_task.go

@@ -3,6 +3,7 @@ package types
 // GetTaskParameter for ProverTasks request parameter
 type GetTaskParameter struct {
 	ProverHeight uint64 `form:"prover_height" json:"prover_height"`
+	TaskType     int    `form:"task_type" json:"task_type"`
 	TaskTypes    []int  `form:"task_types" json:"task_types"`
 }
 

coordinator/test/api_test.go

@@ -33,6 +33,12 @@ import (
 	"scroll-tech/coordinator/internal/route"
 )
 
+const (
+	forkNumberTwo    = 2
+	forkNumberOne    = 1
+	minProverVersion = "v2.0.0"
+)
+
 var (
 	conf *config.Config
 
@@ -66,7 +72,7 @@ func randomURL() string {
 	return fmt.Sprintf("localhost:%d", 10000+2000+id.Int64())
 }
 
-func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL string, forks []string) (*cron.Collector, *http.Server) {
+func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL string, nameForkMap map[string]int64) (*cron.Collector, *http.Server) {
 	var err error
 	db, err = testApps.GetGormDBClient()
 
@@ -84,23 +90,13 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 			ProversPerSession: proversPerSession,
 			Verifier: &config.VerifierConfig{
 				MockMode: true,
-				LowVersionCircuit: &config.CircuitConfig{
-					ParamsPath:       "",
-					AssetsPath:       "",
-					ForkName:         "homestead",
-					MinProverVersion: "v4.2.0",
-				},
-				HighVersionCircuit: &config.CircuitConfig{
-					ParamsPath:       "",
-					AssetsPath:       "",
-					ForkName:         "bernoulli",
-					MinProverVersion: "v4.3.0",
-				},
 			},
 			BatchCollectionTimeSec:  10,
 			ChunkCollectionTimeSec:  10,
 			BundleCollectionTimeSec: 10,
+			MaxVerifierWorkers:      10,
 			SessionAttempts:         5,
+			MinProverVersion:        minProverVersion,
 		},
 		Auth: &config.Auth{
 			ChallengeExpireDurationSec: tokenTimeout,
@@ -109,12 +105,20 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 	}
 
 	var chainConf params.ChainConfig
-	for _, forkName := range forks {
+	for forkName, forkNumber := range nameForkMap {
 		switch forkName {
+		case "shanghai":
+			chainConf.ShanghaiBlock = big.NewInt(forkNumber)
 		case "bernoulli":
-			chainConf.BernoulliBlock = big.NewInt(100)
+			chainConf.BernoulliBlock = big.NewInt(forkNumber)
+		case "london":
+			chainConf.LondonBlock = big.NewInt(forkNumber)
+		case "istanbul":
+			chainConf.IstanbulBlock = big.NewInt(forkNumber)
 		case "homestead":
-			chainConf.HomesteadBlock = big.NewInt(0)
+			chainConf.HomesteadBlock = big.NewInt(forkNumber)
+		case "eip155":
+			chainConf.EIP155Block = big.NewInt(forkNumber)
 		}
 	}
 
@@ -197,7 +201,7 @@ func TestApis(t *testing.T) {
 func testHandshake(t *testing.T) {
 	// Setup coordinator and http server.
 	coordinatorURL := randomURL()
-	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL, []string{"homestead"})
+	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL, map[string]int64{"homestead": forkNumberOne})
 	defer func() {
 		proofCollector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -210,7 +214,7 @@ func testHandshake(t *testing.T) {
 func testFailedHandshake(t *testing.T) {
 	// Setup coordinator and http server.
 	coordinatorURL := randomURL()
-	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL, []string{"homestead"})
+	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL, map[string]int64{"homestead": forkNumberOne})
 	defer func() {
 		proofCollector.Stop()
 	}()
@@ -228,7 +232,7 @@ func testFailedHandshake(t *testing.T) {
 
 func testGetTaskBlocked(t *testing.T) {
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"homestead"})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"homestead": forkNumberOne})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -272,7 +276,7 @@ func testGetTaskBlocked(t *testing.T) {
 
 func testOutdatedProverVersion(t *testing.T) {
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"homestead"})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"homestead": forkNumberOne})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -284,14 +288,12 @@ func testOutdatedProverVersion(t *testing.T) {
 	batchProver := newMockProver(t, "prover_batch_test", coordinatorURL, message.ProofTypeBatch, "v1.999.999")
 	assert.True(t, chunkProver.healthCheckSuccess(t))
 
-	expectedErr := fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s",
-		conf.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, chunkProver.proverVersion)
+	expectedErr := fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", minProverVersion, chunkProver.proverVersion)
 	code, errMsg := chunkProver.tryGetProverTask(t, message.ProofTypeChunk)
 	assert.Equal(t, types.ErrJWTCommonErr, code)
 	assert.Equal(t, expectedErr, errors.New(errMsg))
 
-	expectedErr = fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s",
-		conf.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, batchProver.proverVersion)
+	expectedErr = fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", minProverVersion, batchProver.proverVersion)
 	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch)
 	assert.Equal(t, types.ErrJWTCommonErr, code)
 	assert.Equal(t, expectedErr, errors.New(errMsg))
@@ -299,7 +301,7 @@ func testOutdatedProverVersion(t *testing.T) {
 
 func testValidProof(t *testing.T) {
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"homestead"})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"istanbul": forkNumberTwo})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -382,7 +384,7 @@ func testValidProof(t *testing.T) {
 func testInvalidProof(t *testing.T) {
 	// Setup coordinator and ws server.
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"darwinV2"})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"istanbul": forkNumberTwo})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -470,7 +472,7 @@ func testInvalidProof(t *testing.T) {
 func testProofGeneratedFailed(t *testing.T) {
 	// Setup coordinator and ws server.
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"darwinV2"})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"istanbul": forkNumberTwo})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -571,7 +573,7 @@ func testProofGeneratedFailed(t *testing.T) {
 func testTimeoutProof(t *testing.T) {
 	// Setup coordinator and ws server.
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 1, coordinatorURL, []string{"darwinV2"})
+	collector, httpHandler := setupCoordinator(t, 1, coordinatorURL, map[string]int64{"istanbul": forkNumberTwo})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))

coordinator/test/mock_prover.go

@@ -160,7 +160,7 @@ func (r *mockProver) getProverTask(t *testing.T, proofType message.ProofType) (*
 	resp, err := client.R().
 		SetHeader("Content-Type", "application/json").
 		SetHeader("Authorization", fmt.Sprintf("Bearer %s", token)).
-		SetBody(map[string]interface{}{"prover_height": 100, "task_types": []int{int(proofType)}}).
+		SetBody(map[string]interface{}{"prover_height": 100, "task_type": int(proofType)}).
 		SetResult(&result).
 		Post("http://" + r.coordinatorURL + "/coordinator/v1/get_task")
 	assert.NoError(t, err)

database/config.go

@@ -4,8 +4,6 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
-
-	"scroll-tech/common/utils"
 )
 
 // DBConfig db config
@@ -31,11 +29,5 @@ func NewConfig(file string) (*DBConfig, error) {
 		return nil, err
 	}
 
-	// Override config with environment variables
-	err = utils.OverrideConfigWithEnv(cfg, "SCROLL_ROLLUP_DB_CONFIG")
-	if err != nil {
-		return nil, err
-	}
-
 	return cfg, nil
 }

database/migrate/migrate_test.go

@@ -59,20 +59,20 @@ func testResetDB(t *testing.T) {
 	cur, err := Current(pgDB)
 	assert.NoError(t, err)
 	// total number of tables.
-	assert.Equal(t, int64(24), cur)
+	assert.Equal(t, int64(22), cur)
 }
 
 func testMigrate(t *testing.T) {
 	assert.NoError(t, Migrate(pgDB))
 	cur, err := Current(pgDB)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(24), cur)
+	assert.Equal(t, int64(22), cur)
 }
 
 func testRollback(t *testing.T) {
 	version, err := Current(pgDB)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(24), version)
+	assert.Equal(t, int64(22), version)
 
 	assert.NoError(t, Rollback(pgDB, nil))
 

database/migrate/migrations/00023_add_codec_version_to_chunk_and_enable_encoding_to_chunk_and_batch.sql

@@ -1,23 +0,0 @@
--- +goose Up
--- +goose StatementBegin
-
-ALTER TABLE chunk
-ADD COLUMN codec_version SMALLINT NOT NULL DEFAULT 0,
-ADD COLUMN enable_compress BOOLEAN NOT NULL DEFAULT false;
-
-ALTER TABLE batch
-ADD COLUMN enable_compress BOOLEAN NOT NULL DEFAULT false;
-
--- +goose StatementEnd
-
--- +goose Down
--- +goose StatementBegin
-
-ALTER TABLE IF EXISTS chunk
-DROP COLUMN IF EXISTS enable_compress,
-DROP COLUMN IF EXISTS codec_version;
-
-ALTER TABLE IF EXISTS batch
-DROP COLUMN IF EXISTS enable_compress;
-
--- +goose StatementEnd

database/migrate/migrations/00024_add_blob_bytes_to_batch.sql

@@ -1,15 +0,0 @@
--- +goose Up
--- +goose StatementBegin
-
-ALTER TABLE batch
-ADD COLUMN blob_bytes BYTEA;
-
--- +goose StatementEnd
-
--- +goose Down
--- +goose StatementBegin
-
-ALTER TABLE IF EXISTS batch
-DROP COLUMN IF EXISTS blob_bytes;
-
--- +goose StatementEnd

prover/Cargo.lock

@@ -28,10 +28,44 @@ dependencies = [
  "cpufeatures",
 ]
 
+[[package]]
+name = "aggregator"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
+dependencies = [
+ "ark-std 0.3.0",
+ "bitstream-io",
+ "c-kzg",
+ "ctor 0.1.26",
+ "encoder",
+ "env_logger 0.10.2",
+ "eth-types 0.11.0",
+ "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
+ "gadgets 0.11.0",
+ "halo2-base",
+ "halo2-ecc",
+ "halo2_proofs",
+ "hex",
+ "itertools 0.11.0",
+ "log",
+ "num-bigint",
+ "once_cell",
+ "rand",
+ "revm-precompile",
+ "revm-primitives",
+ "serde",
+ "serde_json",
+ "snark-verifier",
+ "snark-verifier-sdk",
+ "strum 0.25.0",
+ "strum_macros 0.25.3",
+ "zkevm-circuits 0.11.0",
+]
+
 [[package]]
 name = "aggregator"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "ark-std 0.3.0",
  "bitstream-io",
@@ -62,40 +96,6 @@ dependencies = [
  "zkevm-circuits 0.12.0",
 ]
 
-[[package]]
-name = "aggregator"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
-dependencies = [
- "ark-std 0.3.0",
- "bitstream-io",
- "c-kzg",
- "ctor 0.1.26",
- "encoder",
- "env_logger 0.10.2",
- "eth-types 0.13.0",
- "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
- "gadgets 0.13.0",
- "halo2-base",
- "halo2-ecc",
- "halo2_proofs",
- "hex",
- "itertools 0.11.0",
- "log",
- "num-bigint",
- "once_cell",
- "rand",
- "revm-precompile",
- "revm-primitives",
- "serde",
- "serde_json",
- "snark-verifier",
- "snark-verifier-sdk",
- "strum 0.25.0",
- "strum_macros 0.25.3",
- "zkevm-circuits 0.13.0",
-]
-
 [[package]]
 name = "ahash"
 version = "0.8.11"
@@ -632,10 +632,37 @@ version = "3.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
+[[package]]
+name = "bus-mapping"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
+dependencies = [
+ "eth-types 0.11.0",
+ "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
+ "ethers-providers 2.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethers-signers",
+ "external-tracer 0.11.0",
+ "gadgets 0.11.0",
+ "halo2_proofs",
+ "hex",
+ "itertools 0.11.0",
+ "log",
+ "mock 0.11.0",
+ "mpt-zktrie 0.11.0",
+ "num",
+ "poseidon-circuit",
+ "rand",
+ "revm-precompile",
+ "serde",
+ "serde_json",
+ "strum 0.25.0",
+ "strum_macros 0.25.3",
+]
+
 [[package]]
 name = "bus-mapping"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -657,31 +684,6 @@ dependencies = [
  "strum_macros 0.25.3",
 ]
 
-[[package]]
-name = "bus-mapping"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
-dependencies = [
- "eth-types 0.13.0",
- "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
- "ethers-providers 2.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethers-signers",
- "gadgets 0.13.0",
- "halo2_proofs",
- "hex",
- "itertools 0.11.0",
- "log",
- "mock 0.13.0",
- "mpt-zktrie 0.13.0",
- "num",
- "poseidon-circuit",
- "revm-precompile",
- "serde",
- "serde_json",
- "strum 0.25.0",
- "strum_macros 0.25.3",
-]
-
 [[package]]
 name = "byte-slice-cast"
 version = "1.2.2"
@@ -1309,8 +1311,8 @@ dependencies = [
 
 [[package]]
 name = "eth-types"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
 dependencies = [
  "base64 0.13.1",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -1327,6 +1329,7 @@ dependencies = [
  "revm-primitives",
  "serde",
  "serde_json",
+ "serde_stacker",
  "serde_with",
  "sha3 0.10.8",
  "strum 0.25.0",
@@ -1337,8 +1340,8 @@ dependencies = [
 
 [[package]]
 name = "eth-types"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "base64 0.13.1",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -1557,11 +1560,11 @@ dependencies = [
 
 [[package]]
 name = "external-tracer"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
 dependencies = [
- "eth-types 0.12.0",
- "geth-utils 0.12.0",
+ "eth-types 0.11.0",
+ "geth-utils 0.11.0",
  "log",
  "serde",
  "serde_json",
@@ -1570,11 +1573,11 @@ dependencies = [
 
 [[package]]
 name = "external-tracer"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
- "eth-types 0.13.0",
- "geth-utils 0.13.0",
+ "eth-types 0.12.0",
+ "geth-utils 0.12.0",
  "log",
  "serde",
  "serde_json",
@@ -1787,10 +1790,10 @@ dependencies = [
 
 [[package]]
 name = "gadgets"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
 dependencies = [
- "eth-types 0.12.0",
+ "eth-types 0.11.0",
  "halo2_proofs",
  "poseidon-base",
  "sha3 0.10.8",
@@ -1799,10 +1802,10 @@ dependencies = [
 
 [[package]]
 name = "gadgets"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
- "eth-types 0.13.0",
+ "eth-types 0.12.0",
  "halo2_proofs",
  "poseidon-base",
  "sha3 0.10.8",
@@ -1822,8 +1825,8 @@ dependencies = [
 
 [[package]]
 name = "geth-utils"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
 dependencies = [
  "env_logger 0.10.2",
  "gobuild",
@@ -1832,8 +1835,8 @@ dependencies = [
 
 [[package]]
 name = "geth-utils"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "env_logger 0.10.2",
  "gobuild",
@@ -2670,10 +2673,25 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "mock"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
+dependencies = [
+ "eth-types 0.11.0",
+ "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
+ "ethers-signers",
+ "external-tracer 0.11.0",
+ "itertools 0.11.0",
+ "log",
+ "rand",
+ "rand_chacha",
+]
+
 [[package]]
 name = "mock"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -2686,24 +2704,23 @@ dependencies = [
 ]
 
 [[package]]
-name = "mock"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
+name = "mpt-zktrie"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
 dependencies = [
- "eth-types 0.13.0",
- "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
- "ethers-signers",
- "external-tracer 0.13.0",
- "itertools 0.11.0",
+ "eth-types 0.11.0",
+ "halo2curves",
+ "hex",
  "log",
- "rand",
- "rand_chacha",
+ "num-bigint",
+ "poseidon-base",
+ "zktrie",
 ]
 
 [[package]]
 name = "mpt-zktrie"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "eth-types 0.12.0",
  "halo2curves",
@@ -2711,21 +2728,7 @@ dependencies = [
  "log",
  "num-bigint",
  "poseidon-base",
- "zktrie 0.3.0 (git+https://github.com/scroll-tech/zktrie.git?branch=main)",
-]
-
-[[package]]
-name = "mpt-zktrie"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
-dependencies = [
- "eth-types 0.13.0",
- "halo2curves",
- "hex",
- "log",
- "num-bigint",
- "poseidon-base",
- "zktrie 0.3.0 (git+https://github.com/scroll-tech/zktrie.git?branch=v0.9)",
+ "zktrie",
 ]
 
 [[package]]
@@ -3291,8 +3294,8 @@ dependencies = [
  "http 1.1.0",
  "log",
  "once_cell",
+ "prover 0.11.0",
  "prover 0.12.0",
- "prover 0.13.0",
  "rand",
  "reqwest 0.12.4",
  "reqwest-middleware",
@@ -3306,10 +3309,44 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "prover"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
+dependencies = [
+ "aggregator 0.11.0",
+ "anyhow",
+ "base64 0.13.1",
+ "blake2",
+ "bus-mapping 0.11.0",
+ "chrono",
+ "dotenvy",
+ "eth-types 0.11.0",
+ "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
+ "git-version",
+ "halo2_proofs",
+ "hex",
+ "itertools 0.11.0",
+ "log",
+ "log4rs",
+ "mpt-zktrie 0.11.0",
+ "num-bigint",
+ "rand",
+ "rand_xorshift",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "serde_stacker",
+ "sha2",
+ "snark-verifier",
+ "snark-verifier-sdk",
+ "zkevm-circuits 0.11.0",
+]
+
 [[package]]
 name = "prover"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "aggregator 0.12.0",
  "anyhow",
@@ -3340,40 +3377,6 @@ dependencies = [
  "zkevm-circuits 0.12.0",
 ]
 
-[[package]]
-name = "prover"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
-dependencies = [
- "aggregator 0.13.0",
- "anyhow",
- "base64 0.13.1",
- "blake2",
- "bus-mapping 0.13.0",
- "chrono",
- "dotenvy",
- "eth-types 0.13.0",
- "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
- "git-version",
- "halo2_proofs",
- "hex",
- "itertools 0.11.0",
- "log",
- "log4rs",
- "mpt-zktrie 0.13.0",
- "num-bigint",
- "rand",
- "rand_xorshift",
- "serde",
- "serde_derive",
- "serde_json",
- "serde_stacker",
- "sha2",
- "snark-verifier",
- "snark-verifier-sdk",
- "zkevm-circuits 0.13.0",
-]
-
 [[package]]
 name = "psm"
 version = "0.1.21"
@@ -5335,10 +5338,52 @@ dependencies = [
  "syn 2.0.66",
 ]
 
+[[package]]
+name = "zkevm-circuits"
+version = "0.11.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
+dependencies = [
+ "array-init",
+ "bus-mapping 0.11.0",
+ "either",
+ "env_logger 0.10.2",
+ "eth-types 0.11.0",
+ "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
+ "ethers-signers",
+ "ff",
+ "gadgets 0.11.0",
+ "halo2-base",
+ "halo2-ecc",
+ "halo2-mpt-circuits",
+ "halo2_gadgets",
+ "halo2_proofs",
+ "hex",
+ "itertools 0.11.0",
+ "log",
+ "misc-precompiled-circuit",
+ "mock 0.11.0",
+ "mpt-zktrie 0.11.0",
+ "num",
+ "num-bigint",
+ "poseidon-circuit",
+ "rand",
+ "rand_chacha",
+ "rand_xorshift",
+ "rayon",
+ "serde",
+ "serde_json",
+ "sha3 0.10.8",
+ "snark-verifier",
+ "snark-verifier-sdk",
+ "strum 0.25.0",
+ "strum_macros 0.25.3",
+ "subtle",
+]
+
 [[package]]
 name = "zkevm-circuits"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
 dependencies = [
  "array-init",
  "bus-mapping 0.12.0",
@@ -5377,64 +5422,13 @@ dependencies = [
  "subtle",
 ]
 
-[[package]]
-name = "zkevm-circuits"
-version = "0.13.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
-dependencies = [
- "array-init",
- "bus-mapping 0.13.0",
- "either",
- "env_logger 0.10.2",
- "eth-types 0.13.0",
- "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
- "ethers-signers",
- "ff",
- "gadgets 0.13.0",
- "halo2-base",
- "halo2-ecc",
- "halo2-mpt-circuits",
- "halo2_gadgets",
- "halo2_proofs",
- "hex",
- "itertools 0.11.0",
- "log",
- "misc-precompiled-circuit",
- "mock 0.13.0",
- "mpt-zktrie 0.13.0",
- "num",
- "num-bigint",
- "poseidon-circuit",
- "rand",
- "rand_chacha",
- "rand_xorshift",
- "rayon",
- "serde",
- "serde_json",
- "sha3 0.10.8",
- "snark-verifier",
- "snark-verifier-sdk",
- "strum 0.25.0",
- "strum_macros 0.25.3",
- "subtle",
-]
-
 [[package]]
 name = "zktrie"
 version = "0.3.0"
 source = "git+https://github.com/scroll-tech/zktrie.git?branch=main#23181f209e94137f74337b150179aeb80c72e7c8"
 dependencies = [
  "gobuild",
- "zktrie_rust 0.3.0 (git+https://github.com/scroll-tech/zktrie.git?branch=main)",
-]
-
-[[package]]
-name = "zktrie"
-version = "0.3.0"
-source = "git+https://github.com/scroll-tech/zktrie.git?branch=v0.9#460b8c22af65b7809164548cba1e0253b6db5a70"
-dependencies = [
- "gobuild",
- "zktrie_rust 0.3.0 (git+https://github.com/scroll-tech/zktrie.git?branch=v0.9)",
+ "zktrie_rust",
 ]
 
 [[package]]
@@ -5451,20 +5445,6 @@ dependencies = [
  "strum_macros 0.24.3",
 ]
 
-[[package]]
-name = "zktrie_rust"
-version = "0.3.0"
-source = "git+https://github.com/scroll-tech/zktrie.git?branch=v0.9#460b8c22af65b7809164548cba1e0253b6db5a70"
-dependencies = [
- "hex",
- "lazy_static",
- "num",
- "num-derive",
- "num-traits",
- "strum 0.24.1",
- "strum_macros 0.24.3",
-]
-
 [[package]]
 name = "zstd"
 version = "0.13.0"

prover/Cargo.toml

@@ -29,8 +29,8 @@ ethers-core = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "
 ethers-providers = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
 halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1" }
 snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", branch = "develop", default-features = false, features = ["loader_halo2", "loader_evm", "halo2-pse"] }
-prover_darwin = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.2", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
-prover_darwin_v2 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.13.1", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
+prover_curie = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.11.5", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
+prover_darwin = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.0", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
 base64 = "0.13.1"
 reqwest = { version = "0.12.4", features = ["gzip"] }
 reqwest-middleware = "0.3"

prover/config.json

@@ -3,7 +3,7 @@
     "keystore_path": "keystore.json",
     "keystore_password": "prover-pwd",
     "db_path": "unique-db-path-for-prover-1",
-    "prover_type": 2,
+    "proof_type": 2,
     "low_version_circuit": {
         "hard_fork_name": "bernoulli",
         "params_path": "params",

prover/src/coordinator_client.rs

@@ -14,8 +14,6 @@ use types::*;
 
 use crate::{config::Config, key_signer::KeySigner};
 
-pub use errors::ProofStatusNotOKError;
-
 pub struct CoordinatorClient<'a> {
     api: Api,
     token: Option<String>,

prover/src/coordinator_client/api.rs

@@ -1,6 +1,4 @@
-use crate::{coordinator_client::ProofStatusNotOKError, types::ProofStatus};
-
-use super::{errors::*, types::*};
+use super::types::*;
 use anyhow::{bail, Result};
 use core::time::Duration;
 use reqwest::{header::CONTENT_TYPE, Url};
@@ -78,23 +76,7 @@ impl Api {
         token: &String,
     ) -> Result<Response<SubmitProofResponseData>> {
         let method = "/coordinator/v1/submit_proof";
-        let response = self
-            .post_with_token::<SubmitProofRequest, Response<SubmitProofResponseData>>(
-                method, req, token,
-            )
-            .await?;
-
-        // when req's status already not ok, we mark the error returned from coordinator and will
-        // ignore it later.
-        if response.errcode == ErrorCode::ErrCoordinatorHandleZkProofFailure
-            && req.status != ProofStatus::Ok
-            && response
-                .errmsg
-                .contains("validator failure proof msg status not ok")
-        {
-            return Err(anyhow::anyhow!(ProofStatusNotOKError));
-        }
-        Ok(response)
+        self.post_with_token(method, req, token).await
     }
 
     async fn post_with_token<Req, Resp>(

prover/src/coordinator_client/errors.rs

@@ -1,5 +1,4 @@
 use serde::{Deserialize, Deserializer};
-use std::fmt;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ErrorCode {
@@ -52,14 +51,3 @@ impl<'de> Deserialize<'de> for ErrorCode {
         Ok(ErrorCode::from_i32(v))
     }
 }
-
-// ====================================================
-
-#[derive(Debug, Clone)]
-pub struct ProofStatusNotOKError;
-
-impl fmt::Display for ProofStatusNotOKError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "proof status not ok")
-    }
-}

prover/src/main.rs

@@ -1,5 +1,4 @@
 #![feature(lazy_cell)]
-#![feature(core_intrinsics)]
 
 mod config;
 mod coordinator_client;
@@ -38,7 +37,7 @@ struct Args {
     log_file: Option<String>,
 }
 
-fn start() -> Result<()> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args = Args::parse();
 
     if args.version {
@@ -77,10 +76,3 @@ fn start() -> Result<()> {
 
     Ok(())
 }
-
-fn main() {
-    let result = start();
-    if let Err(e) = result {
-        log::error!("main exit with error {:#}", e)
-    }
-}

prover/src/task_processor.rs

@@ -1,4 +1,4 @@
-use super::{coordinator_client::ProofStatusNotOKError, prover::Prover, task_cache::TaskCache};
+use super::{prover::Prover, task_cache::TaskCache};
 use anyhow::{Context, Result};
 use std::rc::Rc;
 
@@ -16,11 +16,7 @@ impl<'a> TaskProcessor<'a> {
         loop {
             log::info!("start a new round.");
             if let Err(err) = self.prove_and_submit() {
-                if err.is::<ProofStatusNotOKError>() {
-                    log::info!("proof status not ok, downgrade level to info.");
-                } else {
-                    log::error!("encounter error: {:#}", err);
-                }
+                log::error!("encounter error: {:#}", err);
             } else {
                 log::info!("prove & submit succeed.");
             }
@@ -58,18 +54,11 @@ impl<'a> TaskProcessor<'a> {
             );
             let result = match self.prover.prove_task(&task_wrapper.task) {
                 Ok(proof_detail) => self.prover.submit_proof(proof_detail, &task_wrapper.task),
-                Err(error) => {
-                    log::error!(
-                        "failed to prove task, id: {}, error: {:#}",
-                        &task_wrapper.task.id,
-                        error
-                    );
-                    self.prover.submit_error(
-                        &task_wrapper.task,
-                        super::types::ProofFailureType::NoPanic,
-                        error,
-                    )
-                }
+                Err(error) => self.prover.submit_error(
+                    &task_wrapper.task,
+                    super::types::ProofFailureType::NoPanic,
+                    error,
+                ),
             };
             return result;
         }

prover/src/types.rs

@@ -54,7 +54,7 @@ impl Default for TaskType {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ProverType {
     Chunk,
     Batch,

prover/src/zk_circuits_handler.rs

@@ -1,6 +1,5 @@
-mod common;
+mod curie;
 mod darwin;
-mod darwin_v2;
 
 use super::geth_client::GethClient;
 use crate::{
@@ -9,8 +8,8 @@ use crate::{
     utils::get_task_types,
 };
 use anyhow::{bail, Result};
+use curie::CurieHandler;
 use darwin::DarwinHandler;
-use darwin_v2::DarwinV2Handler;
 use std::{cell::RefCell, collections::HashMap, rc::Rc};
 
 type HardForkName = String;
@@ -39,7 +38,7 @@ pub struct CircuitsHandlerProvider<'a> {
     geth_client: Option<Rc<RefCell<GethClient>>>,
     circuits_handler_builder_map: HashMap<HardForkName, CircuitsHandlerBuilder>,
 
-    current_fork_name: Option<HardForkName>,
+    current_hard_fork_name: Option<HardForkName>,
     current_circuit: Option<Rc<Box<dyn CircuitsHandler>>>,
 }
 
@@ -61,7 +60,7 @@ impl<'a> CircuitsHandlerProvider<'a> {
                 &config.low_version_circuit.hard_fork_name
             );
             AssetsDirEnvConfig::enable_first();
-            DarwinHandler::new(
+            CurieHandler::new(
                 prover_type,
                 &config.low_version_circuit.params_path,
                 &config.low_version_circuit.assets_path,
@@ -84,7 +83,7 @@ impl<'a> CircuitsHandlerProvider<'a> {
                 &config.high_version_circuit.hard_fork_name
             );
             AssetsDirEnvConfig::enable_second();
-            DarwinV2Handler::new(
+            DarwinHandler::new(
                 prover_type,
                 &config.high_version_circuit.params_path,
                 &config.high_version_circuit.assets_path,
@@ -103,7 +102,7 @@ impl<'a> CircuitsHandlerProvider<'a> {
             config,
             geth_client,
             circuits_handler_builder_map: m,
-            current_fork_name: None,
+            current_hard_fork_name: None,
             current_circuit: None,
         };
 
@@ -114,12 +113,13 @@ impl<'a> CircuitsHandlerProvider<'a> {
         &mut self,
         hard_fork_name: &String,
     ) -> Result<Rc<Box<dyn CircuitsHandler>>> {
-        match &self.current_fork_name {
-            Some(fork_name) if fork_name == hard_fork_name => {
+        match &self.current_hard_fork_name {
+            Some(name) if name == hard_fork_name => {
                 log::info!("get circuits handler from cache");
                 if let Some(handler) = &self.current_circuit {
                     Ok(handler.clone())
                 } else {
+                    log::error!("missing cached handler, there must be something wrong.");
                     bail!("missing cached handler, there must be something wrong.")
                 }
             }
@@ -131,11 +131,12 @@ impl<'a> CircuitsHandlerProvider<'a> {
                     log::info!("building circuits handler for {hard_fork_name}");
                     let handler = builder(self.prover_type, self.config, self.geth_client.clone())
                         .expect("failed to build circuits handler");
-                    self.current_fork_name = Some(hard_fork_name.clone());
+                    self.current_hard_fork_name = Some(hard_fork_name.clone());
                     let rc_handler = Rc::new(handler);
                     self.current_circuit = Some(rc_handler.clone());
                     Ok(rc_handler)
                 } else {
+                    log::error!("missing builder, there must be something wrong.");
                     bail!("missing builder, there must be something wrong.")
                 }
             }

prover/src/zk_circuits_handler/common.rs

@@ -1,33 +0,0 @@
-use std::{collections::BTreeMap, rc::Rc};
-
-use crate::types::ProverType;
-
-use once_cell::sync::OnceCell;
-
-use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
-
-static mut PARAMS_MAP: OnceCell<Rc<BTreeMap<u32, ParamsKZG<Bn256>>>> = OnceCell::new();
-
-pub fn get_params_map_instance<'a, F>(load_params_func: F) -> &'a BTreeMap<u32, ParamsKZG<Bn256>>
-where
-    F: FnOnce() -> BTreeMap<u32, ParamsKZG<Bn256>>,
-{
-    unsafe {
-        PARAMS_MAP.get_or_init(|| {
-            let params_map = load_params_func();
-            Rc::new(params_map)
-        })
-    }
-}
-
-pub fn get_degrees<F>(prover_types: &std::collections::HashSet<ProverType>, f: F) -> Vec<u32>
-where
-    F: FnMut(&ProverType) -> Vec<u32>,
-{
-    prover_types
-        .iter()
-        .flat_map(f)
-        .collect::<std::collections::HashSet<u32>>()
-        .into_iter()
-        .collect()
-}

prover/src/zk_circuits_handler/curie.rs

@@ -1,4 +1,4 @@
-use super::{common::*, CircuitsHandler};
+use super::CircuitsHandler;
 use crate::{
     geth_client::GethClient,
     types::{ProverType, TaskType},
@@ -10,29 +10,21 @@ use serde::Deserialize;
 use crate::types::{CommonHash, Task};
 use std::{cell::RefCell, cmp::Ordering, env, rc::Rc};
 
-use prover_darwin_v2::{
-    aggregator::Prover as BatchProver,
-    check_chunk_hashes,
-    common::Prover as CommonProver,
-    config::{AGG_DEGREES, ZKEVM_DEGREES},
-    zkevm::Prover as ChunkProver,
-    BatchProof, BatchProvingTask, BlockTrace, BundleProof, BundleProvingTask, ChunkInfo,
-    ChunkProof, ChunkProvingTask,
+use prover_curie::{
+    aggregator::Prover as BatchProver, check_chunk_hashes, zkevm::Prover as ChunkProver,
+    BatchProof, BatchProvingTask, BlockTrace, ChunkInfo, ChunkProof, ChunkProvingTask,
 };
 
 // Only used for debugging.
 static OUTPUT_DIR: Lazy<Option<String>> = Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Deserialize)]
 pub struct BatchTaskDetail {
     pub chunk_infos: Vec<ChunkInfo>,
-    #[serde(flatten)]
-    pub batch_proving_task: BatchProvingTask,
+    pub chunk_proofs: Vec<ChunkProof>,
 }
 
-type BundleTaskDetail = BundleProvingTask;
-
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Deserialize)]
 pub struct ChunkTaskDetail {
     pub block_hashes: Vec<CommonHash>,
 }
@@ -42,66 +34,33 @@ fn get_block_number(block_trace: &BlockTrace) -> Option<u64> {
 }
 
 #[derive(Default)]
-pub struct DarwinV2Handler {
-    chunk_prover: Option<RefCell<ChunkProver<'static>>>,
-    batch_prover: Option<RefCell<BatchProver<'static>>>,
+pub struct CurieHandler {
+    chunk_prover: Option<RefCell<ChunkProver>>,
+    batch_prover: Option<RefCell<BatchProver>>,
 
     geth_client: Option<Rc<RefCell<GethClient>>>,
 }
 
-impl DarwinV2Handler {
-    pub fn new_multi(
-        prover_types: Vec<ProverType>,
-        params_dir: &str,
-        assets_dir: &str,
-        geth_client: Option<Rc<RefCell<GethClient>>>,
-    ) -> Result<Self> {
-        let class_name = std::intrinsics::type_name::<Self>();
-        let prover_types_set = prover_types
-            .into_iter()
-            .collect::<std::collections::HashSet<ProverType>>();
-        let mut handler = Self {
-            batch_prover: None,
-            chunk_prover: None,
-            geth_client,
-        };
-        let degrees: Vec<u32> = get_degrees(&prover_types_set, |prover_type| match prover_type {
-            ProverType::Chunk => ZKEVM_DEGREES.clone(),
-            ProverType::Batch => AGG_DEGREES.clone(),
-        });
-        let params_map = get_params_map_instance(|| {
-            log::info!(
-                "calling get_params_map from {}, prover_types: {:?}, degrees: {:?}",
-                class_name,
-                prover_types_set,
-                degrees
-            );
-            CommonProver::load_params_map(params_dir, &degrees)
-        });
-        for prover_type in prover_types_set {
-            match prover_type {
-                ProverType::Chunk => {
-                    handler.chunk_prover = Some(RefCell::new(ChunkProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )));
-                }
-                ProverType::Batch => {
-                    handler.batch_prover = Some(RefCell::new(BatchProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )))
-                }
-            }
-        }
-        Ok(handler)
-    }
-
+impl CurieHandler {
     pub fn new(
         prover_type: ProverType,
         params_dir: &str,
         assets_dir: &str,
         geth_client: Option<Rc<RefCell<GethClient>>>,
     ) -> Result<Self> {
-        Self::new_multi(vec![prover_type], params_dir, assets_dir, geth_client)
+        match prover_type {
+            ProverType::Chunk => Ok(Self {
+                chunk_prover: Some(RefCell::new(ChunkProver::from_dirs(params_dir, assets_dir))),
+                batch_prover: None,
+                geth_client,
+            }),
+
+            ProverType::Batch => Ok(Self {
+                batch_prover: Some(RefCell::new(BatchProver::from_dirs(params_dir, assets_dir))),
+                chunk_prover: None,
+                geth_client,
+            }),
+        }
     }
 
     fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
@@ -124,15 +83,11 @@ impl DarwinV2Handler {
         Ok(serde_json::to_string(&chunk_proof)?)
     }
 
-    fn gen_batch_proof_raw(&self, batch_task_detail: BatchTaskDetail) -> Result<BatchProof> {
+    fn gen_batch_proof_raw(
+        &self,
+        chunk_hashes_proofs: Vec<(ChunkInfo, ChunkProof)>,
+    ) -> Result<BatchProof> {
         if let Some(prover) = self.batch_prover.as_ref() {
-            let chunk_hashes_proofs: Vec<(ChunkInfo, ChunkProof)> = batch_task_detail
-                .chunk_infos
-                .clone()
-                .into_iter()
-                .zip(batch_task_detail.batch_proving_task.chunk_proofs.clone())
-                .collect();
-
             let chunk_proofs: Vec<ChunkProof> =
                 chunk_hashes_proofs.iter().map(|t| t.1.clone()).collect();
 
@@ -142,11 +97,11 @@ impl DarwinV2Handler {
                 bail!("non-match chunk protocol")
             }
             check_chunk_hashes("", &chunk_hashes_proofs).context("failed to check chunk info")?;
-            let batch_proof = prover.borrow_mut().gen_batch_proof(
-                batch_task_detail.batch_proving_task,
-                None,
-                self.get_output_dir(),
-            )?;
+            let batch = BatchProvingTask { chunk_proofs };
+            let batch_proof =
+                prover
+                    .borrow_mut()
+                    .gen_agg_evm_proof(batch, None, self.get_output_dir())?;
 
             return Ok(batch_proof);
         }
@@ -155,32 +110,12 @@ impl DarwinV2Handler {
 
     fn gen_batch_proof(&self, task: &crate::types::Task) -> Result<String> {
         log::info!("[circuit] gen_batch_proof for task {}", task.id);
-
-        let batch_task_detail: BatchTaskDetail = serde_json::from_str(&task.task_data)?;
-        let batch_proof = self.gen_batch_proof_raw(batch_task_detail)?;
+        let chunk_hashes_proofs: Vec<(ChunkInfo, ChunkProof)> =
+            self.gen_chunk_hashes_proofs(task)?;
+        let batch_proof = self.gen_batch_proof_raw(chunk_hashes_proofs)?;
         Ok(serde_json::to_string(&batch_proof)?)
     }
 
-    fn gen_bundle_proof_raw(&self, bundle_task_detail: BundleTaskDetail) -> Result<BundleProof> {
-        if let Some(prover) = self.batch_prover.as_ref() {
-            let bundle_proof = prover.borrow_mut().gen_bundle_proof(
-                bundle_task_detail,
-                None,
-                self.get_output_dir(),
-            )?;
-
-            return Ok(bundle_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    fn gen_bundle_proof(&self, task: &crate::types::Task) -> Result<String> {
-        log::info!("[circuit] gen_bundle_proof for task {}", task.id);
-        let bundle_task_detail: BundleTaskDetail = serde_json::from_str(&task.task_data)?;
-        let bundle_proof = self.gen_bundle_proof_raw(bundle_task_detail)?;
-        Ok(serde_json::to_string(&bundle_proof)?)
-    }
-
     fn get_output_dir(&self) -> Option<&str> {
         OUTPUT_DIR.as_deref()
     }
@@ -190,6 +125,17 @@ impl DarwinV2Handler {
         self.get_sorted_traces_by_hashes(&chunk_task_detail.block_hashes)
     }
 
+    fn gen_chunk_hashes_proofs(&self, task: &Task) -> Result<Vec<(ChunkInfo, ChunkProof)>> {
+        let batch_task_detail: BatchTaskDetail = serde_json::from_str(&task.task_data)?;
+
+        Ok(batch_task_detail
+            .chunk_infos
+            .clone()
+            .into_iter()
+            .zip(batch_task_detail.chunk_proofs.clone())
+            .collect())
+    }
+
     fn get_sorted_traces_by_hashes(&self, block_hashes: &[CommonHash]) -> Result<Vec<BlockTrace>> {
         if block_hashes.is_empty() {
             log::error!("[prover] failed to get sorted traces: block_hashes are empty");
@@ -244,7 +190,7 @@ impl DarwinV2Handler {
     }
 }
 
-impl CircuitsHandler for DarwinV2Handler {
+impl CircuitsHandler for CurieHandler {
     fn get_vk(&self, task_type: TaskType) -> Option<Vec<u8>> {
         match task_type {
             TaskType::Chunk => self
@@ -254,11 +200,8 @@ impl CircuitsHandler for DarwinV2Handler {
             TaskType::Batch => self
                 .batch_prover
                 .as_ref()
-                .and_then(|prover| prover.borrow().get_batch_vk()),
-            TaskType::Bundle => self
-                .batch_prover
-                .as_ref()
-                .and_then(|prover| prover.borrow().get_bundle_vk()),
+                .and_then(|prover| prover.borrow().get_vk()),
+            TaskType::Bundle => None,
             _ => unreachable!(),
         }
     }
@@ -267,7 +210,6 @@ impl CircuitsHandler for DarwinV2Handler {
         match task_type {
             TaskType::Chunk => self.gen_chunk_proof(task),
             TaskType::Batch => self.gen_batch_proof(task),
-            TaskType::Bundle => self.gen_bundle_proof(task),
             _ => unreachable!(),
         }
     }
@@ -279,11 +221,7 @@ impl CircuitsHandler for DarwinV2Handler {
 mod tests {
     use super::*;
     use crate::zk_circuits_handler::utils::encode_vk;
-    use ethers_core::types::H256;
-    use prover_darwin_v2::{
-        aggregator::eip4844, utils::chunk_trace_to_witness_block, BatchData, BatchHeader,
-        MAX_AGG_SNARKS,
-    };
+    use prover_curie::utils::chunk_trace_to_witness_block;
     use std::{path::PathBuf, sync::LazyLock};
 
     #[ctor::ctor]
@@ -294,7 +232,7 @@ mod tests {
 
     static DEFAULT_WORK_DIR: &str = "/assets";
     static WORK_DIR: LazyLock<String> = LazyLock::new(|| {
-        std::env::var("DARWIN_V2_TEST_DIR")
+        std::env::var("CURIE_TEST_DIR")
             .unwrap_or(String::from(DEFAULT_WORK_DIR))
             .trim_end_matches('/')
             .to_string()
@@ -306,9 +244,9 @@ mod tests {
     static BATCH_DIR_PATH: LazyLock<String> =
         LazyLock::new(|| format!("{}/traces/batch_24", *WORK_DIR));
     static BATCH_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_batch.vkey", *WORK_DIR));
+        LazyLock::new(|| format!("{}/test_assets/agg_vk.vkey", *WORK_DIR));
     static CHUNK_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_chunk.vkey", *WORK_DIR));
+        LazyLock::new(|| format!("{}/test_assets/chunk_vk.vkey", *WORK_DIR));
 
     #[test]
     fn it_works() {
@@ -318,27 +256,20 @@ mod tests {
 
     #[test]
     fn test_circuits() -> Result<()> {
-        let bi_handler = DarwinV2Handler::new_multi(
-            vec![ProverType::Chunk, ProverType::Batch],
-            &PARAMS_PATH,
-            &ASSETS_PATH,
-            None,
-        )?;
+        let chunk_handler = CurieHandler::new(ProverType::Chunk, &PARAMS_PATH, &ASSETS_PATH, None)?;
 
-        let chunk_handler = bi_handler;
         let chunk_vk = chunk_handler.get_vk(TaskType::Chunk).unwrap();
 
         check_vk(TaskType::Chunk, chunk_vk, "chunk vk must be available");
         let chunk_dir_paths = get_chunk_dir_paths()?;
         log::info!("chunk_dir_paths, {:?}", chunk_dir_paths);
-        let mut chunk_traces = vec![];
         let mut chunk_infos = vec![];
         let mut chunk_proofs = vec![];
         for (id, chunk_path) in chunk_dir_paths.into_iter().enumerate() {
             let chunk_id = format!("chunk_proof{}", id + 1);
             log::info!("start to process {chunk_id}");
             let chunk_trace = read_chunk_trace(chunk_path)?;
-            chunk_traces.push(chunk_trace.clone());
+
             let chunk_info = traces_to_chunk_info(chunk_trace.clone())?;
             chunk_infos.push(chunk_info);
 
@@ -349,96 +280,30 @@ mod tests {
             chunk_proofs.push(chunk_proof);
         }
 
-        let batch_handler = chunk_handler;
+        let batch_handler = CurieHandler::new(ProverType::Batch, &PARAMS_PATH, &ASSETS_PATH, None)?;
         let batch_vk = batch_handler.get_vk(TaskType::Batch).unwrap();
         check_vk(TaskType::Batch, batch_vk, "batch vk must be available");
-        let batch_task_detail = make_batch_task_detail(chunk_traces, chunk_proofs, None);
+        let chunk_hashes_proofs = chunk_infos.into_iter().zip(chunk_proofs).collect();
         log::info!("start to prove batch");
-        let batch_proof = batch_handler.gen_batch_proof_raw(batch_task_detail)?;
+        let batch_proof = batch_handler.gen_batch_proof_raw(chunk_hashes_proofs)?;
         let proof_data = serde_json::to_string(&batch_proof)?;
         dump_proof("batch_proof".to_string(), proof_data)?;
 
         Ok(())
     }
 
-    // copied from https://github.com/scroll-tech/scroll-prover/blob/main/integration/src/prove.rs
-    fn get_blob_from_chunks(chunks: &[ChunkInfo]) -> Vec<u8> {
-        let num_chunks = chunks.len();
-
-        let padded_chunk =
-            ChunkInfo::mock_padded_chunk_info_for_testing(chunks.last().as_ref().unwrap());
-        let chunks_with_padding = [
-            chunks.to_vec(),
-            vec![padded_chunk; MAX_AGG_SNARKS - num_chunks],
-        ]
-        .concat();
-        let batch_data = BatchData::<{ MAX_AGG_SNARKS }>::new(chunks.len(), &chunks_with_padding);
-        let batch_bytes = batch_data.get_batch_data_bytes();
-        let blob_bytes = eip4844::get_blob_bytes(&batch_bytes);
-        log::info!("blob_bytes len {}", blob_bytes.len());
-        blob_bytes
-    }
-
-    // TODO: chunk_infos can be extracted from chunk_proofs.
-    // Still needed?
-    fn make_batch_task_detail(
-        chunk_traces: Vec<Vec<BlockTrace>>,
-        chunk_proofs: Vec<ChunkProof>,
-        last_batcher_header: Option<BatchHeader<{ MAX_AGG_SNARKS }>>,
-    ) -> BatchTaskDetail {
-        // dummy parent batch hash
-        let dummy_parent_batch_hash = H256([
-            0xab, 0xac, 0xad, 0xae, 0xaf, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0,
-        ]);
-        let chunk_infos: Vec<_> = chunk_proofs.iter().map(|p| p.chunk_info.clone()).collect();
-
-        let l1_message_popped = chunk_traces
-            .iter()
-            .flatten()
-            .map(|chunk| chunk.num_l1_txs())
-            .sum();
-        let last_block_timestamp = chunk_traces.last().map_or(0, |block_traces| {
-            block_traces
-                .last()
-                .map_or(0, |block_trace| block_trace.header.timestamp.as_u64())
-        });
-
-        let blob_bytes = get_blob_from_chunks(&chunk_infos);
-        let batch_header = BatchHeader::construct_from_chunks(
-            last_batcher_header.map_or(4, |header| header.version),
-            last_batcher_header.map_or(123, |header| header.batch_index + 1),
-            l1_message_popped,
-            last_batcher_header.map_or(l1_message_popped, |header| {
-                header.total_l1_message_popped + l1_message_popped
-            }),
-            last_batcher_header.map_or(dummy_parent_batch_hash, |header| header.batch_hash()),
-            last_block_timestamp,
-            &chunk_infos,
-            &blob_bytes,
-        );
-        BatchTaskDetail {
-            chunk_infos,
-            batch_proving_task: BatchProvingTask {
-                chunk_proofs,
-                batch_header,
-                blob_bytes,
-            },
-        }
-    }
-
-    fn check_vk(proof_type: TaskType, vk: Vec<u8>, info: &str) {
-        log::info!("check_vk, {:?}", proof_type);
-        let vk_from_file = read_vk(proof_type).unwrap();
+    fn check_vk(task_type: TaskType, vk: Vec<u8>, info: &str) {
+        log::info!("check_vk, {:?}", task_type);
+        let vk_from_file = read_vk(task_type).unwrap();
         assert_eq!(vk_from_file, encode_vk(vk), "{info}")
     }
 
-    fn read_vk(proof_type: TaskType) -> Result<String> {
-        log::info!("read_vk, {:?}", proof_type);
-        let vk_file = match proof_type {
+    fn read_vk(task_type: TaskType) -> Result<String> {
+        log::info!("read_vk, {:?}", task_type);
+        let vk_file = match task_type {
             TaskType::Chunk => CHUNK_VK_PATH.clone(),
             TaskType::Batch => BATCH_VK_PATH.clone(),
-            TaskType::Bundle => todo!(),
+            TaskType::Bundle => unreachable!(),
             TaskType::Undefined => unreachable!(),
         };
 

prover/src/zk_circuits_handler/darwin.rs

@@ -1,4 +1,4 @@
-use super::{common::*, CircuitsHandler};
+use super::CircuitsHandler;
 use crate::{
     geth_client::GethClient,
     types::{ProverType, TaskType},
@@ -11,11 +11,7 @@ use crate::types::{CommonHash, Task};
 use std::{cell::RefCell, cmp::Ordering, env, rc::Rc};
 
 use prover_darwin::{
-    aggregator::Prover as BatchProver,
-    check_chunk_hashes,
-    common::Prover as CommonProver,
-    config::{AGG_DEGREES, ZKEVM_DEGREES},
-    zkevm::Prover as ChunkProver,
+    aggregator::Prover as BatchProver, check_chunk_hashes, zkevm::Prover as ChunkProver,
     BatchProof, BatchProvingTask, BlockTrace, BundleProof, BundleProvingTask, ChunkInfo,
     ChunkProof, ChunkProvingTask,
 };
@@ -43,65 +39,32 @@ fn get_block_number(block_trace: &BlockTrace) -> Option<u64> {
 
 #[derive(Default)]
 pub struct DarwinHandler {
-    chunk_prover: Option<RefCell<ChunkProver<'static>>>,
-    batch_prover: Option<RefCell<BatchProver<'static>>>,
+    chunk_prover: Option<RefCell<ChunkProver>>,
+    batch_prover: Option<RefCell<BatchProver>>,
 
     geth_client: Option<Rc<RefCell<GethClient>>>,
 }
 
 impl DarwinHandler {
-    pub fn new_multi(
-        prover_types: Vec<ProverType>,
-        params_dir: &str,
-        assets_dir: &str,
-        geth_client: Option<Rc<RefCell<GethClient>>>,
-    ) -> Result<Self> {
-        let class_name = std::intrinsics::type_name::<Self>();
-        let prover_types_set = prover_types
-            .into_iter()
-            .collect::<std::collections::HashSet<ProverType>>();
-        let mut handler = Self {
-            batch_prover: None,
-            chunk_prover: None,
-            geth_client,
-        };
-        let degrees: Vec<u32> = get_degrees(&prover_types_set, |prover_type| match prover_type {
-            ProverType::Chunk => ZKEVM_DEGREES.clone(),
-            ProverType::Batch => AGG_DEGREES.clone(),
-        });
-        let params_map = get_params_map_instance(|| {
-            log::info!(
-                "calling get_params_map from {}, prover_types: {:?}, degrees: {:?}",
-                class_name,
-                prover_types_set,
-                degrees
-            );
-            CommonProver::load_params_map(params_dir, &degrees)
-        });
-        for prover_type in prover_types_set {
-            match prover_type {
-                ProverType::Chunk => {
-                    handler.chunk_prover = Some(RefCell::new(ChunkProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )));
-                }
-                ProverType::Batch => {
-                    handler.batch_prover = Some(RefCell::new(BatchProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )))
-                }
-            }
-        }
-        Ok(handler)
-    }
-
     pub fn new(
         prover_type: ProverType,
         params_dir: &str,
         assets_dir: &str,
         geth_client: Option<Rc<RefCell<GethClient>>>,
     ) -> Result<Self> {
-        Self::new_multi(vec![prover_type], params_dir, assets_dir, geth_client)
+        match prover_type {
+            ProverType::Chunk => Ok(Self {
+                chunk_prover: Some(RefCell::new(ChunkProver::from_dirs(params_dir, assets_dir))),
+                batch_prover: None,
+                geth_client,
+            }),
+
+            ProverType::Batch => Ok(Self {
+                batch_prover: Some(RefCell::new(BatchProver::from_dirs(params_dir, assets_dir))),
+                chunk_prover: None,
+                geth_client,
+            }),
+        }
     }
 
     fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
@@ -290,7 +253,7 @@ mod tests {
 
     static DEFAULT_WORK_DIR: &str = "/assets";
     static WORK_DIR: LazyLock<String> = LazyLock::new(|| {
-        std::env::var("DARWIN_TEST_DIR")
+        std::env::var("CURIE_TEST_DIR")
             .unwrap_or(String::from(DEFAULT_WORK_DIR))
             .trim_end_matches('/')
             .to_string()
@@ -302,9 +265,9 @@ mod tests {
     static BATCH_DIR_PATH: LazyLock<String> =
         LazyLock::new(|| format!("{}/traces/batch_24", *WORK_DIR));
     static BATCH_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_batch.vkey", *WORK_DIR));
+        LazyLock::new(|| format!("{}/test_assets/agg_vk.vkey", *WORK_DIR));
     static CHUNK_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_chunk.vkey", *WORK_DIR));
+        LazyLock::new(|| format!("{}/test_assets/chunk_vk.vkey", *WORK_DIR));
 
     #[test]
     fn it_works() {
@@ -314,14 +277,9 @@ mod tests {
 
     #[test]
     fn test_circuits() -> Result<()> {
-        let bi_handler = DarwinHandler::new_multi(
-            vec![ProverType::Chunk, ProverType::Batch],
-            &PARAMS_PATH,
-            &ASSETS_PATH,
-            None,
-        )?;
+        let chunk_handler =
+            DarwinHandler::new(ProverType::Chunk, &PARAMS_PATH, &ASSETS_PATH, None)?;
 
-        let chunk_handler = bi_handler;
         let chunk_vk = chunk_handler.get_vk(TaskType::Chunk).unwrap();
 
         check_vk(TaskType::Chunk, chunk_vk, "chunk vk must be available");
@@ -344,7 +302,8 @@ mod tests {
             chunk_proofs.push(chunk_proof);
         }
 
-        let batch_handler = chunk_handler;
+        let batch_handler =
+            DarwinHandler::new(ProverType::Batch, &PARAMS_PATH, &ASSETS_PATH, None)?;
         let batch_vk = batch_handler.get_vk(TaskType::Batch).unwrap();
         check_vk(TaskType::Batch, batch_vk, "batch vk must be available");
         let batch_task_detail = make_batch_task_detail(chunk_infos, chunk_proofs);

rollup/conf/config.json

@@ -19,17 +19,9 @@
         "min_gas_price": 0,
         "gas_price_diff": 50000,
         "l1_base_fee_weight": 0.132,
-        "l1_blob_base_fee_weight":  0.145,
-        "check_committed_batches_window_minutes": 5,
-        "l1_base_fee_default": 15000000000,
-        "l1_blob_base_fee_default": 1
+        "l1_blob_base_fee_weight":  0.145
       },
-      "gas_oracle_sender_signer_config": {
-        "signer_type": "PrivateKey",
-        "private_key_signer_config": {
-          "private_key": "1313131313131313131313131313131313131313131313131313131313131313"
-        }
-      }
+      "gas_oracle_sender_private_key": "1313131313131313131313131313131313131313131313131313131313131313"
     }
   },
   "l2_config": {
@@ -49,8 +41,7 @@
         "max_blob_gas_price": 10000000000000,
         "tx_type": "DynamicFeeTx",
         "check_pending_time": 1,
-        "min_gas_tip": 100000000,
-        "max_pending_blob_txs": 3
+        "min_gas_tip": 100000000
       },
       "gas_oracle_config": {
         "min_gas_price": 0,
@@ -65,24 +56,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/go.mod

@@ -9,12 +9,10 @@ require (
 	github.com/gin-gonic/gin v1.9.1
 	github.com/go-resty/resty/v2 v2.7.0
 	github.com/holiman/uint256 v1.2.4
-	github.com/mitchellh/mapstructure v1.5.0
 	github.com/prometheus/client_golang v1.16.0
-	github.com/scroll-tech/da-codec v0.1.1-0.20240819100936-c6af3bbe7068
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240821075135-bdd1b005d40f
+	github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
 	github.com/smartystreets/goconvey v1.8.0
-	github.com/spf13/viper v1.19.0
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
 	gorm.io/gorm v1.25.5
@@ -31,12 +29,12 @@ require (
 	github.com/chenzhuoyu/iasm v0.9.0 // indirect
 	github.com/consensys/bavard v0.1.13 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/deckarep/golang-set v1.8.0 // indirect
 	github.com/edsrzf/mmap-go v1.0.0 // indirect
 	github.com/ethereum/c-kzg-4844 v1.0.2 // indirect
 	github.com/fjl/memsize v0.0.2 // indirect
-	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
 	github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
@@ -55,7 +53,6 @@ require (
 	github.com/gorilla/websocket v1.5.0 // indirect
 	github.com/hashicorp/go-bexpr v0.1.10 // indirect
 	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect
-	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
 	github.com/huin/goupnp v1.3.0 // indirect
 	github.com/iden3/go-iden3-crypto v0.0.16 // indirect
@@ -66,11 +63,11 @@ require (
 	github.com/jtolds/gls v4.20.0+incompatible // indirect
 	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
 	github.com/leodido/go-urn v1.2.4 // indirect
-	github.com/magiconair/properties v1.8.7 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.15 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/mitchellh/pointerstructure v1.2.0 // indirect
 	github.com/mmcloughlin/addchain v0.4.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
@@ -78,9 +75,9 @@ require (
 	github.com/olekukonko/tablewriter v0.0.5 // indirect
 	github.com/onsi/ginkgo v1.16.5 // indirect
 	github.com/onsi/gomega v1.27.1 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.1.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/prometheus/client_model v0.4.0 // indirect
 	github.com/prometheus/common v0.42.0 // indirect
 	github.com/prometheus/procfs v0.12.0 // indirect
@@ -89,17 +86,10 @@ require (
 	github.com/rjeczalik/notify v0.9.1 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/sagikazarmark/locafero v0.4.0 // indirect
-	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
 	github.com/smartystreets/assertions v1.13.1 // indirect
-	github.com/sourcegraph/conc v0.3.0 // indirect
-	github.com/spf13/afero v1.11.0 // indirect
-	github.com/spf13/cast v1.6.0 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/status-im/keycard-go v0.2.0 // indirect
-	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/supranational/blst v0.3.12 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
 	github.com/tklauser/go-sysconf v0.3.14 // indirect
@@ -109,18 +99,14 @@ require (
 	github.com/ugorji/go/codec v1.2.11 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	go.uber.org/atomic v1.9.0 // indirect
-	go.uber.org/multierr v1.9.0 // indirect
 	golang.org/x/arch v0.5.0 // indirect
 	golang.org/x/crypto v0.24.0 // indirect
-	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
-	golang.org/x/net v0.23.0 // indirect
+	golang.org/x/net v0.21.0 // indirect
 	golang.org/x/sync v0.7.0 // indirect
 	golang.org/x/sys v0.21.0 // indirect
 	golang.org/x/text v0.16.0 // indirect
-	golang.org/x/time v0.5.0 // indirect
-	google.golang.org/protobuf v1.33.0 // indirect
-	gopkg.in/ini.v1 v1.67.0 // indirect
+	golang.org/x/time v0.3.0 // indirect
+	google.golang.org/protobuf v1.31.0 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 	gopkg.in/urfave/cli.v1 v1.20.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

rollup/go.sum

@@ -47,9 +47,8 @@ github.com/crate-crypto/go-kzg-4844 v1.0.0 h1:TsSgHwrkTKecKJ4kadtHi4b3xHW5dCFUDF
 github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
-github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4=
 github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
@@ -59,12 +58,10 @@ github.com/ethereum/c-kzg-4844 v1.0.2 h1:8tV84BCEiPeOkiVgW9mpYBeBUir2bkCNVqxPwwV
 github.com/ethereum/c-kzg-4844 v1.0.2/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
 github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA=
 github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
-github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
-github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
-github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
+github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
 github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
 github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
@@ -131,8 +128,6 @@ github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpx
 github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0=
 github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs=
 github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
-github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
-github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
 github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA=
 github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU=
@@ -168,8 +163,6 @@ github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7
 github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8=
 github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
 github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
-github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
-github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
@@ -211,14 +204,13 @@ github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7J
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.27.1 h1:rfztXRbg6nv/5f+Raen9RcGoSecHIFgBBLQK3Wdj754=
 github.com/onsi/gomega v1.27.1/go.mod h1:aHX5xOykVYzWOV4WqQy0sy8BQptgukenXpCXfadcIAw=
-github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
-github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4=
+github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
-github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
 github.com/prometheus/client_golang v1.16.0 h1:yk/hx9hDbrGHovbci4BY+pRMfSuuat626eFsHb7tmT8=
 github.com/prometheus/client_golang v1.16.0/go.mod h1:Zsulrv/L9oM40tJ7T815tM89lFEugiJ9HzIqaAx4LKc=
@@ -244,14 +236,10 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=
-github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
-github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
-github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
-github.com/scroll-tech/da-codec v0.1.1-0.20240819100936-c6af3bbe7068 h1:KyTp4aedcpjr/rbntrmlhUxjrDYu1Q02QDLaF5vqpxs=
-github.com/scroll-tech/da-codec v0.1.1-0.20240819100936-c6af3bbe7068/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240821075135-bdd1b005d40f h1:0XhY20/Sh2UCroZqD4orK7eDElQD2XK4GLrTbPmUBpw=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240821075135-bdd1b005d40f/go.mod h1:jLTGZ5iL5T7g1BEWrQXVIR+wutJFDTVs/mCfjAlrhrA=
+github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb h1:uOKdmDT0LsuS3gfynEjR4zA3Ooh6p2Z3O+IMRj2r8LA=
+github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
@@ -262,23 +250,12 @@ github.com/smartystreets/assertions v1.13.1/go.mod h1:cXr/IwVfSo/RbCSPhoAPv73p3h
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/smartystreets/goconvey v1.8.0 h1:Oi49ha/2MURE0WexF052Z0m+BNSGirfjg5RL+JXWq3w=
 github.com/smartystreets/goconvey v1.8.0/go.mod h1:EdX8jtrTIj26jmjCOVNMVSIYAtgexqXKHOXW2Dx9JLg=
-github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
-github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
-github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
-github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0=
-github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI=
-github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg=
 github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA=
 github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
@@ -290,8 +267,6 @@ github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
-github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 github.com/supranational/blst v0.3.12 h1:Vfas2U2CFHhniv2QkUm2OVa1+pGTdqtpqm9NnhUUbZ8=
 github.com/supranational/blst v0.3.12/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
@@ -313,10 +288,6 @@ github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsr
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
-go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
-go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI=
-go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/arch v0.5.0 h1:jpGode6huXQxcskEIpOCvrU+tzo81b6+oFLUYXWtH/Y=
 golang.org/x/arch v0.5.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
@@ -326,8 +297,6 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
 golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@@ -337,8 +306,8 @@ golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/
 golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20211029224645-99673261e6eb/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs=
-golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -363,6 +332,7 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -375,8 +345,8 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
-golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
+golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
@@ -393,15 +363,13 @@ google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzi
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
-google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
-gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU=
 gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=

rollup/internal/config/config.go

@@ -1,15 +1,11 @@
 package config
 
 import (
-	"fmt"
-	"reflect"
-	"scroll-tech/common/database"
-	"strings"
+	"encoding/json"
+	"os"
+	"path/filepath"
 
-	"github.com/mitchellh/mapstructure"
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/rpc"
-	"github.com/spf13/viper"
+	"scroll-tech/common/database"
 )
 
 // Config load configuration items.
@@ -21,66 +17,14 @@ type Config struct {
 
 // NewConfig returns a new instance of Config.
 func NewConfig(file string) (*Config, error) {
-	v := viper.New()
-	v.SetConfigFile(file)
-	v.SetConfigType("json")
-
-	v.SetEnvPrefix("SCROLL_ROLLUP")
-	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
-
-	v.AutomaticEnv()
-
-	if err := v.ReadInConfig(); err != nil {
-		return nil, err
-	}
-
-	cfg := &Config{}
-
-	decoderConfig := &mapstructure.DecoderConfig{
-		TagName: "json",
-		Result:  cfg,
-		DecodeHook: mapstructure.ComposeDecodeHookFunc(
-			func(from reflect.Type, to reflect.Type, data interface{}) (interface{}, error) {
-				if to == reflect.TypeOf(rpc.BlockNumber(0)) {
-					var bn rpc.BlockNumber
-					err := bn.UnmarshalJSON([]byte(fmt.Sprintf("%v", data)))
-					if err != nil {
-						return nil, fmt.Errorf("invalid block number, data: %v, error: %v", data, err)
-					}
-					return bn, nil
-				}
-
-				if to == reflect.TypeOf(common.Address{}) {
-					s, ok := data.(string)
-					if !ok {
-						return nil, fmt.Errorf("invalid address, data: %v", data)
-					}
-					return common.HexToAddress(s), nil
-				}
-
-				if to == reflect.TypeOf(common.Hash{}) {
-					s, ok := data.(string)
-					if !ok {
-						return nil, fmt.Errorf("invalid hash, data: %v", data)
-					}
-					return common.HexToHash(s), nil
-				}
-
-				return data, nil
-			},
-		),
-	}
-
-	decoder, err := mapstructure.NewDecoder(decoderConfig)
+	buf, err := os.ReadFile(filepath.Clean(file))
 	if err != nil {
 		return nil, err
 	}
 
-	if err := decoder.Decode(v.AllSettings()); err != nil {
-		return nil, err
-	}
-
-	if err := v.Unmarshal(cfg, viper.DecodeHook(decoderConfig.DecodeHook)); err != nil {
+	cfg := &Config{}
+	err = json.Unmarshal(buf, cfg)
+	if err != nil {
 		return nil, err
 	}
 

rollup/internal/config/config_test.go

@@ -55,31 +55,4 @@ func TestConfig(t *testing.T) {
 		_, err = NewConfig(tmpFile.Name())
 		assert.Error(t, err)
 	})
-
-	t.Run("Override config value", func(t *testing.T) {
-		cfg, err := NewConfig("../../conf/config.json")
-		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")
-
-		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.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)
-	})
 }

rollup/internal/config/relayer.go

@@ -1,7 +1,12 @@
 package config
 
 import (
+	"crypto/ecdsa"
+	"encoding/json"
+	"fmt"
+
 	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/rpc"
 )
 
@@ -27,8 +32,6 @@ type SenderConfig struct {
 	MaxBlobGasPrice uint64 `json:"max_blob_gas_price"`
 	// The transaction type to use: LegacyTx, DynamicFeeTx, BlobTx
 	TxType string `json:"tx_type"`
-	// The maximum number of pending blob-carrying transactions
-	MaxPendingBlobTxs int64 `json:"max_pending_blob_txs"`
 }
 
 // ChainMonitor this config is used to get batch status from chain_monitor API.
@@ -54,11 +57,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 *ecdsa.PrivateKey `json:"-"`
+	CommitSenderPrivateKey    *ecdsa.PrivateKey `json:"-"`
+	FinalizeSenderPrivateKey  *ecdsa.PrivateKey `json:"-"`
 
 	// Indicates if bypass features specific to testing environments are enabled.
 	EnableTestEnvBypassFeatures bool `json:"enable_test_env_bypass_features"`
@@ -68,48 +70,91 @@ 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.
 	L1BaseFeeWeight float64 `json:"l1_base_fee_weight"`
 	// The weight for L1 blob base fee.
 	L1BlobBaseFeeWeight float64 `json:"l1_blob_base_fee_weight"`
-	// CheckCommittedBatchesWindowMinutes the time frame to check if we committed batches to decide to update gas oracle or not in minutes
-	CheckCommittedBatchesWindowMinutes int    `json:"check_committed_batches_window_minutes"`
-	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"`
+// relayerConfigAlias RelayerConfig alias name
+type relayerConfigAlias RelayerConfig
+
+func convertAndCheck(key string, uniqueAddressesSet map[string]struct{}) (*ecdsa.PrivateKey, error) {
+	if key == "" {
+		return nil, nil
+	}
+
+	privKey, err := crypto.ToECDSA(common.FromHex(key))
+	if err != nil {
+		return nil, err
+	}
+
+	addr := crypto.PubkeyToAddress(privKey.PublicKey).Hex()
+	if _, exists := uniqueAddressesSet[addr]; exists {
+		return nil, fmt.Errorf("detected duplicated address for private key: %s", addr)
+	}
+	uniqueAddressesSet[addr] = struct{}{}
+
+	return privKey, nil
 }
 
-// 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
+// UnmarshalJSON unmarshal relayer_config struct.
+func (r *RelayerConfig) UnmarshalJSON(input []byte) error {
+	var privateKeysConfig struct {
+		relayerConfigAlias
+		GasOracleSenderPrivateKey string `json:"gas_oracle_sender_private_key"`
+		CommitSenderPrivateKey    string `json:"commit_sender_private_key"`
+		FinalizeSenderPrivateKey  string `json:"finalize_sender_private_key"`
+	}
+	var err error
+	if err = json.Unmarshal(input, &privateKeysConfig); err != nil {
+		return fmt.Errorf("failed to unmarshal private keys config: %w", err)
+	}
+
+	*r = RelayerConfig(privateKeysConfig.relayerConfigAlias)
+
+	uniqueAddressesSet := make(map[string]struct{})
+
+	r.GasOracleSenderPrivateKey, err = convertAndCheck(privateKeysConfig.GasOracleSenderPrivateKey, uniqueAddressesSet)
+	if err != nil {
+		return fmt.Errorf("error converting and checking gas oracle sender private key: %w", err)
+	}
+
+	r.CommitSenderPrivateKey, err = convertAndCheck(privateKeysConfig.CommitSenderPrivateKey, uniqueAddressesSet)
+	if err != nil {
+		return fmt.Errorf("error converting and checking commit sender private key: %w", err)
+	}
+
+	r.FinalizeSenderPrivateKey, err = convertAndCheck(privateKeysConfig.FinalizeSenderPrivateKey, uniqueAddressesSet)
+	if err != nil {
+		return fmt.Errorf("error converting and checking finalize sender private key: %w", err)
+	}
+
+	return nil
 }
 
-// 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
+// MarshalJSON marshal RelayerConfig config, transfer private keys.
+func (r *RelayerConfig) MarshalJSON() ([]byte, error) {
+	privateKeysConfig := struct {
+		relayerConfigAlias
+		// 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"`
+	}{}
+
+	privateKeysConfig.relayerConfigAlias = relayerConfigAlias(*r)
+	privateKeysConfig.GasOracleSenderPrivateKey = common.Bytes2Hex(crypto.FromECDSA(r.GasOracleSenderPrivateKey))
+	privateKeysConfig.CommitSenderPrivateKey = common.Bytes2Hex(crypto.FromECDSA(r.CommitSenderPrivateKey))
+	privateKeysConfig.FinalizeSenderPrivateKey = common.Bytes2Hex(crypto.FromECDSA(r.FinalizeSenderPrivateKey))
+
+	return json.Marshal(&privateKeysConfig)
 }

rollup/internal/controller/relayer/l1_relayer.go

@@ -6,22 +6,20 @@ import (
 	"fmt"
 	"math"
 	"math/big"
-	"time"
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
+	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
 	"scroll-tech/common/types"
-	"scroll-tech/common/utils"
 
 	bridgeAbi "scroll-tech/rollup/abi"
 	"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.
@@ -45,7 +43,6 @@ type Layer1Relayer struct {
 
 	l1BlockOrm *orm.L1Block
 	l2BlockOrm *orm.L2Block
-	batchOrm   *orm.Batch
 
 	metrics *l1RelayerMetrics
 }
@@ -57,9 +54,10 @@ func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfi
 
 	switch serviceType {
 	case ServiceTypeL1GasOracle:
-		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderSignerConfig, "l1_relayer", "gas_oracle_sender", types.SenderTypeL1GasOracle, db, reg)
+		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderPrivateKey, "l1_relayer", "gas_oracle_sender", types.SenderTypeL1GasOracle, db, reg)
 		if err != nil {
-			return nil, fmt.Errorf("new gas oracle sender failed, err: %w", err)
+			addr := crypto.PubkeyToAddress(cfg.GasOracleSenderPrivateKey.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.
@@ -86,7 +84,6 @@ func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfi
 		ctx:        ctx,
 		l1BlockOrm: orm.NewL1Block(db),
 		l2BlockOrm: orm.NewL2Block(db),
-		batchOrm:   orm.NewBatch(db),
 
 		gasOracleSender: gasOracleSender,
 		l1GasOracleABI:  bridgeAbi.L1GasPriceOracleABI,
@@ -152,50 +149,7 @@ 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
-			// Also, set fees to some default value, because we have already updated fees to some high values, probably
-			var reachTimeout bool
-			if reachTimeout, err = r.commitBatchReachTimeout(); reachTimeout && err == nil {
-				if r.lastBaseFee == r.cfg.GasOracleConfig.L1BaseFeeDefault && r.lastBlobBaseFee == r.cfg.GasOracleConfig.L1BlobBaseFeeDefault {
-					return
-				}
-				baseFee = r.cfg.GasOracleConfig.L1BaseFeeDefault
-				blobBaseFee = r.cfg.GasOracleConfig.L1BlobBaseFeeDefault
-			} 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))
@@ -306,19 +260,3 @@ func (r *Layer1Relayer) shouldUpdateGasOracle(baseFee uint64, blobBaseFee uint64
 
 	return false
 }
-
-func (r *Layer1Relayer) commitBatchReachTimeout() (bool, error) {
-	fields := map[string]interface{}{
-		"rollup_status IN ?": []types.RollupStatus{types.RollupCommitted, types.RollupFinalizing, types.RollupFinalized},
-	}
-	orderByList := []string{"index DESC"}
-	limit := 1
-	batches, err := r.batchOrm.GetBatches(r.ctx, fields, orderByList, limit)
-	if err != nil {
-		log.Warn("failed to fetch latest committed, finalizing or finalized batch", "err", err)
-		return false, err
-	}
-	// len(batches) == 0 probably shouldn't ever happen, but need to check this
-	// Also, we should check if it's a genesis batch. If so, skip the timeout check.
-	return len(batches) == 0 || (batches[0].Index != 0 && utils.NowUTC().Sub(*batches[0].CommittedAt) > time.Duration(r.cfg.GasOracleConfig.CheckCommittedBatchesWindowMinutes)*time.Minute), nil
-}

rollup/internal/controller/relayer/l2_relayer.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"math"
 	"math/big"
 	"sort"
 	"strings"
@@ -17,7 +16,6 @@ import (
 	"github.com/scroll-tech/da-codec/encoding/codecv1"
 	"github.com/scroll-tech/da-codec/encoding/codecv2"
 	"github.com/scroll-tech/da-codec/encoding/codecv3"
-	"github.com/scroll-tech/da-codec/encoding/codecv4"
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
 	"github.com/scroll-tech/go-ethereum/common"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
@@ -76,33 +74,15 @@ 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) {
-
 	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, cfg.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(cfg.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 +91,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, cfg.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(cfg.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, cfg.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(cfg.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.
@@ -218,7 +200,7 @@ func (r *Layer2Relayer) initializeGenesis() error {
 
 	err = r.db.Transaction(func(dbTX *gorm.DB) error {
 		var dbChunk *orm.Chunk
-		dbChunk, err = r.chunkOrm.InsertChunk(r.ctx, chunk, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.ChunkMetrics{}, dbTX)
+		dbChunk, err = r.chunkOrm.InsertChunk(r.ctx, chunk, encoding.CodecV0, rutils.ChunkMetrics{}, dbTX)
 		if err != nil {
 			return fmt.Errorf("failed to insert chunk: %v", err)
 		}
@@ -235,7 +217,7 @@ func (r *Layer2Relayer) initializeGenesis() error {
 		}
 
 		var dbBatch *orm.Batch
-		dbBatch, err = r.batchOrm.InsertBatch(r.ctx, batch, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.BatchMetrics{}, dbTX)
+		dbBatch, err = r.batchOrm.InsertBatch(r.ctx, batch, encoding.CodecV0, rutils.BatchMetrics{}, dbTX)
 		if err != nil {
 			return fmt.Errorf("failed to insert batch: %v", err)
 		}
@@ -325,32 +307,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
@@ -422,34 +378,28 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 
 		var calldata []byte
 		var blob *kzg4844.Blob
-		if encoding.CodecVersion(dbBatch.CodecVersion) == encoding.CodecV0 {
+		if !r.chainCfg.IsBernoulli(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) { // codecv0
 			calldata, err = r.constructCommitBatchPayloadCodecV0(dbBatch, dbParentBatch, dbChunks, chunks)
 			if err != nil {
 				log.Error("failed to construct commitBatch payload codecv0", "index", dbBatch.Index, "err", err)
 				return
 			}
-		} else if encoding.CodecVersion(dbBatch.CodecVersion) == encoding.CodecV1 {
+		} else if !r.chainCfg.IsCurie(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) { // codecv1
 			calldata, blob, err = r.constructCommitBatchPayloadCodecV1(dbBatch, dbParentBatch, dbChunks, chunks)
 			if err != nil {
 				log.Error("failed to construct commitBatch payload codecv1", "index", dbBatch.Index, "err", err)
 				return
 			}
-		} else if encoding.CodecVersion(dbBatch.CodecVersion) == encoding.CodecV2 {
+		} else if !r.chainCfg.IsDarwin(dbChunks[0].StartBlockTime) { // codecv2
 			calldata, blob, err = r.constructCommitBatchPayloadCodecV2(dbBatch, dbParentBatch, dbChunks, chunks)
 			if err != nil {
 				log.Error("failed to construct commitBatch payload codecv2", "index", dbBatch.Index, "err", err)
 				return
 			}
-		} else if encoding.CodecVersion(dbBatch.CodecVersion) == encoding.CodecV3 {
+		} else { // codecv3
 			calldata, blob, err = r.constructCommitBatchPayloadCodecV3(dbBatch, dbParentBatch, dbChunks, chunks)
 			if err != nil {
-				log.Error("failed to construct commitBatchWithBlobProof payload codecv3", "index", dbBatch.Index, "err", err)
-				return
-			}
-		} else if encoding.CodecVersion(dbBatch.CodecVersion) == encoding.CodecV4 {
-			calldata, blob, err = r.constructCommitBatchPayloadCodecV4(dbBatch, dbParentBatch, dbChunks, chunks)
-			if err != nil {
-				log.Error("failed to construct commitBatchWithBlobProof payload codecv4", "index", dbBatch.Index, "err", err)
+				log.Error("failed to construct commitBatch payload codecv3", "index", dbBatch.Index, "err", err)
 				return
 			}
 		}
@@ -464,15 +414,6 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 
 		txHash, err := r.commitSender.SendTransaction(dbBatch.Hash, &r.cfg.RollupContractAddress, calldata, blob, fallbackGasLimit)
 		if err != nil {
-			if errors.Is(err, sender.ErrTooManyPendingBlobTxs) {
-				r.metrics.rollupL2RelayerProcessPendingBatchErrTooManyPendingBlobTxsTotal.Inc()
-				log.Debug(
-					"Skipped sending commitBatch tx to L1: too many pending blob txs",
-					"maxPending", r.cfg.SenderConfig.MaxPendingBlobTxs,
-					"err", err,
-				)
-				return
-			}
 			log.Error(
 				"Failed to send commitBatch tx to layer1",
 				"index", dbBatch.Index,
@@ -489,18 +430,6 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 			log.Error("UpdateCommitTxHashAndRollupStatus failed", "hash", dbBatch.Hash, "index", dbBatch.Index, "err", err)
 			return
 		}
-
-		var maxBlockHeight uint64
-		var totalGasUsed uint64
-		for _, dbChunk := range dbChunks {
-			if dbChunk.EndBlockNumber > maxBlockHeight {
-				maxBlockHeight = dbChunk.EndBlockNumber
-			}
-			totalGasUsed += dbChunk.TotalL2TxGas
-		}
-		r.metrics.rollupL2RelayerCommitBlockHeight.Set(float64(maxBlockHeight))
-		r.metrics.rollupL2RelayerCommitThroughput.Add(float64(totalGasUsed))
-
 		r.metrics.rollupL2RelayerProcessPendingBatchSuccessTotal.Inc()
 		log.Info("Sent the commitBatch tx to layer1", "batch index", dbBatch.Index, "batch hash", dbBatch.Hash, "tx hash", txHash.String())
 	}
@@ -542,6 +471,7 @@ func (r *Layer2Relayer) ProcessCommittedBatches() {
 		}
 
 	case types.ProvingTaskVerified:
+		log.Info("Start to roll up zk proof", "hash", batch.Hash)
 		r.metrics.rollupL2RelayerProcessCommittedBatchesFinalizedTotal.Inc()
 		if err := r.finalizeBatch(batch, true); err != nil {
 			log.Error("Failed to finalize batch with proof", "index", batch.Index, "hash", batch.Hash, "err", err)
@@ -592,7 +522,7 @@ func (r *Layer2Relayer) ProcessPendingBundles() {
 		}
 
 	case types.ProvingTaskVerified:
-		log.Info("Start to roll up zk proof", "bundle hash", bundle.Hash)
+		log.Info("Start to roll up zk proof", "hash", bundle.Hash)
 		r.metrics.rollupL2RelayerProcessPendingBundlesFinalizedTotal.Inc()
 		if err := r.finalizeBundle(bundle, true); err != nil {
 			log.Error("Failed to finalize bundle with proof", "index", bundle.Index, "start batch index", bundle.StartBatchIndex, "end batch index", bundle.EndBatchIndex, "err", err)
@@ -659,15 +589,11 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 
 	var calldata []byte
 	if !r.chainCfg.IsBernoulli(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) { // codecv0
-		log.Info("Start to roll up zk proof", "batch hash", dbBatch.Hash)
-
 		calldata, err = r.constructFinalizeBatchPayloadCodecV0(dbBatch, dbParentBatch, aggProof)
 		if err != nil {
 			return fmt.Errorf("failed to construct finalizeBatch payload codecv0, index: %v, err: %w", dbBatch.Index, err)
 		}
 	} else if !r.chainCfg.IsCurie(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) { // codecv1
-		log.Info("Start to roll up zk proof", "batch hash", dbBatch.Hash)
-
 		chunks := make([]*encoding.Chunk, len(dbChunks))
 		for i, c := range dbChunks {
 			blocks, dbErr := r.l2BlockOrm.GetL2BlocksInRange(r.ctx, c.StartBlockNumber, c.EndBlockNumber)
@@ -682,8 +608,6 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 			return fmt.Errorf("failed to construct finalizeBatch payload codecv1, index: %v, err: %w", dbBatch.Index, err)
 		}
 	} else if !r.chainCfg.IsDarwin(dbChunks[0].StartBlockTime) { // codecv2
-		log.Info("Start to roll up zk proof", "batch hash", dbBatch.Hash)
-
 		chunks := make([]*encoding.Chunk, len(dbChunks))
 		for i, c := range dbChunks {
 			blocks, dbErr := r.l2BlockOrm.GetL2BlocksInRange(r.ctx, c.StartBlockNumber, c.EndBlockNumber)
@@ -786,7 +710,7 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 		}
 	}
 
-	calldata, err := r.constructFinalizeBundlePayloadCodecV3AndV4(dbBatch, aggProof)
+	calldata, err := r.constructFinalizeBundlePayloadCodecV3(dbBatch, aggProof)
 	if err != nil {
 		return fmt.Errorf("failed to construct finalizeBundle payload codecv3, index: %v, err: %w", dbBatch.Index, err)
 	}
@@ -1115,45 +1039,6 @@ func (r *Layer2Relayer) constructCommitBatchPayloadCodecV3(dbBatch *orm.Batch, d
 	return calldata, daBatch.Blob(), nil
 }
 
-func (r *Layer2Relayer) constructCommitBatchPayloadCodecV4(dbBatch *orm.Batch, dbParentBatch *orm.Batch, dbChunks []*orm.Chunk, chunks []*encoding.Chunk) ([]byte, *kzg4844.Blob, error) {
-	batch := &encoding.Batch{
-		Index:                      dbBatch.Index,
-		TotalL1MessagePoppedBefore: dbChunks[0].TotalL1MessagesPoppedBefore,
-		ParentBatchHash:            common.HexToHash(dbParentBatch.Hash),
-		Chunks:                     chunks,
-	}
-
-	daBatch, createErr := codecv4.NewDABatch(batch, dbBatch.EnableCompress)
-	if createErr != nil {
-		return nil, nil, fmt.Errorf("failed to create DA batch: %w", createErr)
-	}
-
-	encodedChunks := make([][]byte, len(dbChunks))
-	for i, c := range dbChunks {
-		daChunk, createErr := codecv4.NewDAChunk(chunks[i], c.TotalL1MessagesPoppedBefore)
-		if createErr != nil {
-			return nil, nil, fmt.Errorf("failed to create DA chunk: %w", createErr)
-		}
-		encodedChunks[i] = daChunk.Encode()
-	}
-
-	blobDataProof, err := daBatch.BlobDataProofForPointEvaluation()
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to get blob data proof for point evaluation: %w", err)
-	}
-
-	skippedL1MessageBitmap, _, err := encoding.ConstructSkippedBitmap(batch.Index, batch.Chunks, batch.TotalL1MessagePoppedBefore)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to construct skipped L1 message bitmap: %w", err)
-	}
-
-	calldata, packErr := r.l1RollupABI.Pack("commitBatchWithBlobProof", daBatch.Version, dbParentBatch.BatchHeader, encodedChunks, skippedL1MessageBitmap, blobDataProof)
-	if packErr != nil {
-		return nil, nil, fmt.Errorf("failed to pack commitBatchWithBlobProof: %w", packErr)
-	}
-	return calldata, daBatch.Blob(), nil
-}
-
 func (r *Layer2Relayer) constructFinalizeBatchPayloadCodecV0(dbBatch *orm.Batch, dbParentBatch *orm.Batch, aggProof *message.BatchProof) ([]byte, error) {
 	if aggProof != nil { // finalizeBatch with proof.
 		calldata, packErr := r.l1RollupABI.Pack(
@@ -1282,7 +1167,7 @@ func (r *Layer2Relayer) constructFinalizeBatchPayloadCodecV2(dbBatch *orm.Batch,
 	return calldata, nil
 }
 
-func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV3AndV4(dbBatch *orm.Batch, aggProof *message.BundleProof) ([]byte, error) {
+func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV3(dbBatch *orm.Batch, aggProof *message.BundleProof) ([]byte, error) {
 	if aggProof != nil { // finalizeBundle with proof.
 		calldata, packErr := r.l1RollupABI.Pack(
 			"finalizeBundleWithProof",
@@ -1325,21 +1210,3 @@ func (r *Layer2Relayer) StopSenders() {
 		r.finalizeSender.Stop()
 	}
 }
-
-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)
-	}
-}

rollup/internal/controller/relayer/l2_relayer_metrics.go

@@ -8,30 +8,26 @@ import (
 )
 
 type l2RelayerMetrics struct {
-	rollupL2RelayerProcessPendingBatchTotal                         prometheus.Counter
-	rollupL2RelayerProcessPendingBatchSuccessTotal                  prometheus.Counter
-	rollupL2RelayerProcessPendingBatchErrTooManyPendingBlobTxsTotal prometheus.Counter
-	rollupL2RelayerGasPriceOraclerRunTotal                          prometheus.Counter
-	rollupL2RelayerLastGasPrice                                     prometheus.Gauge
-	rollupL2RelayerProcessCommittedBatchesTotal                     prometheus.Counter
-	rollupL2RelayerProcessCommittedBatchesFinalizedTotal            prometheus.Counter
-	rollupL2RelayerProcessCommittedBatchesFinalizedSuccessTotal     prometheus.Counter
-	rollupL2BatchesCommittedConfirmedTotal                          prometheus.Counter
-	rollupL2BatchesCommittedConfirmedFailedTotal                    prometheus.Counter
-	rollupL2BatchesFinalizedConfirmedTotal                          prometheus.Counter
-	rollupL2BatchesFinalizedConfirmedFailedTotal                    prometheus.Counter
-	rollupL2UpdateGasOracleConfirmedTotal                           prometheus.Counter
-	rollupL2UpdateGasOracleConfirmedFailedTotal                     prometheus.Counter
-	rollupL2ChainMonitorLatestFailedCall                            prometheus.Counter
-	rollupL2ChainMonitorLatestFailedBatchStatus                     prometheus.Counter
-	rollupL2RelayerProcessPendingBundlesTotal                       prometheus.Counter
-	rollupL2RelayerProcessPendingBundlesFinalizedTotal              prometheus.Counter
-	rollupL2RelayerProcessPendingBundlesFinalizedSuccessTotal       prometheus.Counter
-	rollupL2BundlesFinalizedConfirmedTotal                          prometheus.Counter
-	rollupL2BundlesFinalizedConfirmedFailedTotal                    prometheus.Counter
-
-	rollupL2RelayerCommitBlockHeight prometheus.Gauge
-	rollupL2RelayerCommitThroughput  prometheus.Counter
+	rollupL2RelayerProcessPendingBatchTotal                     prometheus.Counter
+	rollupL2RelayerProcessPendingBatchSuccessTotal              prometheus.Counter
+	rollupL2RelayerGasPriceOraclerRunTotal                      prometheus.Counter
+	rollupL2RelayerLastGasPrice                                 prometheus.Gauge
+	rollupL2RelayerProcessCommittedBatchesTotal                 prometheus.Counter
+	rollupL2RelayerProcessCommittedBatchesFinalizedTotal        prometheus.Counter
+	rollupL2RelayerProcessCommittedBatchesFinalizedSuccessTotal prometheus.Counter
+	rollupL2BatchesCommittedConfirmedTotal                      prometheus.Counter
+	rollupL2BatchesCommittedConfirmedFailedTotal                prometheus.Counter
+	rollupL2BatchesFinalizedConfirmedTotal                      prometheus.Counter
+	rollupL2BatchesFinalizedConfirmedFailedTotal                prometheus.Counter
+	rollupL2UpdateGasOracleConfirmedTotal                       prometheus.Counter
+	rollupL2UpdateGasOracleConfirmedFailedTotal                 prometheus.Counter
+	rollupL2ChainMonitorLatestFailedCall                        prometheus.Counter
+	rollupL2ChainMonitorLatestFailedBatchStatus                 prometheus.Counter
+	rollupL2RelayerProcessPendingBundlesTotal                   prometheus.Counter
+	rollupL2RelayerProcessPendingBundlesFinalizedTotal          prometheus.Counter
+	rollupL2RelayerProcessPendingBundlesFinalizedSuccessTotal   prometheus.Counter
+	rollupL2BundlesFinalizedConfirmedTotal                      prometheus.Counter
+	rollupL2BundlesFinalizedConfirmedFailedTotal                prometheus.Counter
 }
 
 var (
@@ -50,10 +46,6 @@ func initL2RelayerMetrics(reg prometheus.Registerer) *l2RelayerMetrics {
 				Name: "rollup_layer2_process_pending_batch_success_total",
 				Help: "The total number of layer2 process pending success batch",
 			}),
-			rollupL2RelayerProcessPendingBatchErrTooManyPendingBlobTxsTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_layer2_process_pending_batch_err_too_many_pending_blob_txs_total",
-				Help: "The total number of layer2 process pending batch failed on too many pending blob txs",
-			}),
 			rollupL2RelayerGasPriceOraclerRunTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 				Name: "rollup_layer2_gas_price_oracler_total",
 				Help: "The total number of layer2 gas price oracler run total",
@@ -126,14 +118,6 @@ func initL2RelayerMetrics(reg prometheus.Registerer) *l2RelayerMetrics {
 				Name: "rollup_layer2_bundles_finalized_confirmed_failed_total",
 				Help: "Total number of failed confirmations for finalized bundles on layer2.",
 			}),
-			rollupL2RelayerCommitBlockHeight: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-				Name: "rollup_l2_relayer_commit_block_height",
-				Help: "The latest block height committed by the L2 relayer",
-			}),
-			rollupL2RelayerCommitThroughput: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_l2_relayer_commit_throughput",
-				Help: "The cumulative gas used in blocks committed by the L2 relayer",
-			}),
 		}
 	})
 	return l2RelayerMetric

rollup/internal/controller/relayer/l2_relayer_test.go

@@ -79,9 +79,9 @@ func testL2RelayerProcessPendingBatches(t *testing.T) {
 		err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
 		assert.NoError(t, err)
 		chunkOrm := orm.NewChunk(db)
-		_, err = chunkOrm.InsertChunk(context.Background(), chunk1, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk1, codecVersion, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
-		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
 
 		batch := &encoding.Batch{
@@ -92,7 +92,7 @@ func testL2RelayerProcessPendingBatches(t *testing.T) {
 		}
 
 		batchOrm := orm.NewBatch(db)
-		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: codecVersion}, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion, rutils.BatchMetrics{})
 		assert.NoError(t, err)
 
 		relayer.ProcessPendingBatches()
@@ -128,9 +128,9 @@ func testL2RelayerProcessCommittedBatches(t *testing.T) {
 		err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
 		assert.NoError(t, err)
 		chunkOrm := orm.NewChunk(db)
-		_, err = chunkOrm.InsertChunk(context.Background(), chunk1, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk1, codecVersion, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
-		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
 
 		batch := &encoding.Batch{
@@ -141,7 +141,7 @@ func testL2RelayerProcessCommittedBatches(t *testing.T) {
 		}
 
 		batchOrm := orm.NewBatch(db)
-		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: codecVersion}, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion, rutils.BatchMetrics{})
 		assert.NoError(t, err)
 
 		err = batchOrm.UpdateRollupStatus(context.Background(), dbBatch.Hash, types.RollupCommitted)
@@ -197,7 +197,7 @@ func testL2RelayerProcessPendingBundles(t *testing.T) {
 		}
 
 		batchOrm := orm.NewBatch(db)
-		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: codecVersion}, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion, rutils.BatchMetrics{})
 		assert.NoError(t, err)
 
 		bundleOrm := orm.NewBundle(db)
@@ -259,9 +259,9 @@ func testL2RelayerFinalizeTimeoutBatches(t *testing.T) {
 		err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
 		assert.NoError(t, err)
 		chunkOrm := orm.NewChunk(db)
-		chunkDB1, err := chunkOrm.InsertChunk(context.Background(), chunk1, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
+		chunkDB1, err := chunkOrm.InsertChunk(context.Background(), chunk1, codecVersion, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
-		chunkDB2, err := chunkOrm.InsertChunk(context.Background(), chunk2, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
+		chunkDB2, err := chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
 
 		batch := &encoding.Batch{
@@ -272,7 +272,7 @@ func testL2RelayerFinalizeTimeoutBatches(t *testing.T) {
 		}
 
 		batchOrm := orm.NewBatch(db)
-		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: codecVersion}, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion, rutils.BatchMetrics{})
 		assert.NoError(t, err)
 
 		err = batchOrm.UpdateRollupStatus(context.Background(), dbBatch.Hash, types.RollupCommitted)
@@ -326,9 +326,9 @@ func testL2RelayerFinalizeTimeoutBundles(t *testing.T) {
 		err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
 		assert.NoError(t, err)
 		chunkOrm := orm.NewChunk(db)
-		chunkDB1, err := chunkOrm.InsertChunk(context.Background(), chunk1, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
+		chunkDB1, err := chunkOrm.InsertChunk(context.Background(), chunk1, codecVersion, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
-		chunkDB2, err := chunkOrm.InsertChunk(context.Background(), chunk2, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
+		chunkDB2, err := chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
 
 		batch := &encoding.Batch{
@@ -339,7 +339,7 @@ func testL2RelayerFinalizeTimeoutBundles(t *testing.T) {
 		}
 
 		batchOrm := orm.NewBatch(db)
-		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: codecVersion}, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion, rutils.BatchMetrics{})
 		assert.NoError(t, err)
 
 		err = batchOrm.UpdateRollupStatus(context.Background(), dbBatch.Hash, types.RollupCommitted)
@@ -411,7 +411,7 @@ func testL2RelayerCommitConfirm(t *testing.T) {
 			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
 		}
 
-		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, rutils.BatchMetrics{})
 		assert.NoError(t, err)
 		batchHashes[i] = dbBatch.Hash
 	}
@@ -467,7 +467,7 @@ func testL2RelayerFinalizeBatchConfirm(t *testing.T) {
 			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
 		}
 
-		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, rutils.BatchMetrics{})
 		assert.NoError(t, err)
 		batchHashes[i] = dbBatch.Hash
 	}
@@ -525,7 +525,7 @@ func testL2RelayerFinalizeBundleConfirm(t *testing.T) {
 			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
 		}
 
-		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, rutils.BatchMetrics{})
 		assert.NoError(t, err)
 		batchHashes[i] = dbBatch.Hash
 
@@ -580,7 +580,7 @@ func testL2RelayerGasOracleConfirm(t *testing.T) {
 	}
 
 	batchOrm := orm.NewBatch(db)
-	dbBatch1, err := batchOrm.InsertBatch(context.Background(), batch1, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.BatchMetrics{})
+	dbBatch1, err := batchOrm.InsertBatch(context.Background(), batch1, encoding.CodecV0, rutils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	batch2 := &encoding.Batch{
@@ -590,7 +590,7 @@ func testL2RelayerGasOracleConfirm(t *testing.T) {
 		Chunks:                     []*encoding.Chunk{chunk2},
 	}
 
-	dbBatch2, err := batchOrm.InsertBatch(context.Background(), batch2, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.BatchMetrics{})
+	dbBatch2, err := batchOrm.InsertBatch(context.Background(), batch2, encoding.CodecV0, rutils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	// Create and set up the Layer2 Relayer.
@@ -742,9 +742,9 @@ func testGetBatchStatusByIndex(t *testing.T) {
 	err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
 	assert.NoError(t, err)
 	chunkOrm := orm.NewChunk(db)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk1, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.ChunkMetrics{})
+	_, err = chunkOrm.InsertChunk(context.Background(), chunk1, encoding.CodecV0, rutils.ChunkMetrics{})
 	assert.NoError(t, err)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk2, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.ChunkMetrics{})
+	_, err = chunkOrm.InsertChunk(context.Background(), chunk2, encoding.CodecV0, rutils.ChunkMetrics{})
 	assert.NoError(t, err)
 
 	batch := &encoding.Batch{
@@ -755,7 +755,7 @@ func testGetBatchStatusByIndex(t *testing.T) {
 	}
 
 	batchOrm := orm.NewBatch(db)
-	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.BatchMetrics{})
+	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, rutils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	status, err := relayer.getBatchStatusByIndex(dbBatch)

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"
@@ -37,11 +39,6 @@ const (
 	DynamicFeeTxType = "DynamicFeeTx"
 )
 
-var (
-	// ErrTooManyPendingBlobTxs
-	ErrTooManyPendingBlobTxs = errors.New("the limit of pending blob-carrying transactions has been exceeded")
-)
-
 // Confirmation struct used to indicate transaction confirmation details
 type Confirmation struct {
 	ContextID    string
@@ -65,15 +62,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 +83,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 +98,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 +117,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 +141,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
@@ -181,23 +180,6 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 	)
 
 	if blob != nil {
-		// check that number of pending blob-carrying txs is not too big
-		if s.senderType == types.SenderTypeCommitBatch {
-			var numPendingTransactions int64
-			// We should count here only blob-carrying txs, but due to check that blob != nil, we know that we already switched to blobs.
-			// Now all txs with SenderTypeCommitBatch will be blob-carrying, but some of previous pending txs could still be non-blob.
-			// But this can happen only once at the moment of switching from non-blob to blob (pre-Bernoulli and post-Bernoulli) and it doesn't break anything.
-			// So don't need to add check that tx carries blob
-			numPendingTransactions, err = s.pendingTransactionOrm.GetCountPendingTransactionsBySenderType(s.ctx, s.senderType)
-			if err != nil {
-				log.Error("failed to count pending transactions", "err: %w", err)
-				return common.Hash{}, fmt.Errorf("failed to count pending transactions, err: %w", err)
-			}
-			if numPendingTransactions >= s.config.MaxPendingBlobTxs {
-				return common.Hash{}, ErrTooManyPendingBlobTxs
-			}
-
-		}
 		sidecar, err = makeSidecar(blob)
 		if err != nil {
 			log.Error("failed to make sidecar for blob transaction", "error", err)
@@ -213,18 +195,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 +214,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 +246,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 +267,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 +303,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 +327,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 +451,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 +493,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.
@@ -537,22 +518,6 @@ func (s *Sender) checkPendingTransaction() {
 			}
 		} else if txnToCheck.Status == types.TxStatusPending && // Only try resubmitting a new transaction based on gas price of the last transaction (status pending) with same ContextID.
 			s.config.EscalateBlocks+txnToCheck.SubmitBlockNumber <= blockNumber {
-
-			// blockNumber is the block number with "latest" tag, so we need to check the current nonce of the sender address to ensure that the previous transaction has been confirmed.
-			// otherwise it's not very necessary to bump the gas price. Also worth noting is that, during bumping gas prices, the sender would consider the new basefee and blobbasefee of L1.
-			currentNonce, err := s.client.NonceAt(s.ctx, common.HexToAddress(txnToCheck.SenderAddress), new(big.Int).SetUint64(blockNumber))
-			if err != nil {
-				log.Error("failed to get current nonce from node", "address", txnToCheck.SenderAddress, "blockNumber", blockNumber, "err", err)
-				return
-			}
-
-			// early return if the previous transaction has not been confirmed yet.
-			// currentNonce is already the confirmed nonce + 1.
-			if tx.Nonce() > currentNonce {
-				log.Debug("previous transaction not yet confirmed, skip bumping gas price", "address", txnToCheck.SenderAddress, "currentNonce", currentNonce, "txNonce", tx.Nonce())
-				continue
-			}
-
 			// It's possible that the pending transaction was marked as failed earlier in this loop (e.g., if one of its replacements has already been confirmed).
 			// Therefore, we fetch the current transaction status again for accuracy before proceeding.
 			status, err := s.pendingTransactionOrm.GetTxStatusByTxHash(s.ctx, tx.Hash())
@@ -569,7 +534,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 +542,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 +585,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

@@ -6,7 +6,6 @@ import (
 	"crypto/rand"
 	"errors"
 	"fmt"
-	"math"
 	"math/big"
 	"os"
 	"testing"
@@ -38,9 +37,7 @@ import (
 )
 
 var (
-	privateKeyString     string
 	privateKey           *ecdsa.PrivateKey
-	signerConfig         *config.SignerConfig
 	cfg                  *config.Config
 	testApps             *testcontainers.TestcontainerApps
 	txTypes              = []string{"LegacyTx", "DynamicFeeTx", "DynamicFeeTx"}
@@ -55,9 +52,6 @@ func TestMain(m *testing.M) {
 		if testApps != nil {
 			testApps.Free()
 		}
-		if testAppsSignerTest != nil {
-			testAppsSignerTest.Free()
-		}
 	}()
 	m.Run()
 }
@@ -70,14 +64,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
 
@@ -133,6 +120,7 @@ func setupEnv(t *testing.T) {
 
 func TestSender(t *testing.T) {
 	setupEnv(t)
+
 	t.Run("test new sender", testNewSender)
 	t.Run("test send and retrieve transaction", testSendAndRetrieveTransaction)
 	t.Run("test fallback gas limit", testFallbackGasLimit)
@@ -142,13 +130,11 @@ func TestSender(t *testing.T) {
 	t.Run("test resubmit under priced transaction", testResubmitUnderpricedTransaction)
 	t.Run("test resubmit dynamic fee transaction with rising base fee", testResubmitDynamicFeeTransactionWithRisingBaseFee)
 	t.Run("test resubmit blob transaction with rising base fee and blob base fee", testResubmitBlobTransactionWithRisingBaseFeeAndBlobBaseFee)
-	t.Run("test resubmit nonce gapped transaction", testResubmitNonceGappedTransaction)
 	t.Run("test check pending transaction tx confirmed", testCheckPendingTransactionTxConfirmed)
 	t.Run("test check pending transaction resubmit tx confirmed", testCheckPendingTransactionResubmitTxConfirmed)
 	t.Run("test check pending transaction replaced tx confirmed", testCheckPendingTransactionReplacedTxConfirmed)
 	t.Run("test check pending transaction multiple times with only one transaction pending", testCheckPendingTransactionTxMultipleTimesWithOnlyOneTxPending)
 	t.Run("test blob transaction with blobhash op contract call", testBlobTransactionWithBlobhashOpContractCall)
-	t.Run("test test send blob-carrying tx over limit", testSendBlobCarryingTxOverLimit)
 }
 
 func testNewSender(t *testing.T) {
@@ -160,7 +146,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 +154,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 +168,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 +204,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 +260,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 +300,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 +341,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 +390,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 +427,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 +436,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 +469,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 +481,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,
@@ -531,67 +517,6 @@ func testResubmitBlobTransactionWithRisingBaseFeeAndBlobBaseFee(t *testing.T) {
 	s.Stop()
 }
 
-func testResubmitNonceGappedTransaction(t *testing.T) {
-	for i, txType := range txTypes {
-		sqlDB, err := db.DB()
-		assert.NoError(t, err)
-		assert.NoError(t, migrate.ResetDB(sqlDB))
-
-		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
-
-		// Bump gas price, gas tip cap and gas fee cap just touch the minimum threshold of 10% (default config of geth).
-		cfgCopy.EscalateMultipleNum = 110
-		cfgCopy.EscalateMultipleDen = 100
-		cfgCopy.TxType = txType
-
-		// resubmit immediately if not nonce gapped
-		cfgCopy.Confirmations = rpc.LatestBlockNumber
-		cfgCopy.EscalateBlocks = 0
-
-		// stop background check pending transaction
-		cfgCopy.CheckPendingTime = math.MaxUint32
-
-		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
-		assert.NoError(t, err)
-
-		patchGuard1 := gomonkey.ApplyMethodFunc(s.client, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
-			return nil
-		})
-
-		// simulating not confirmed transaction
-		patchGuard2 := gomonkey.ApplyMethodFunc(s.client, "TransactionReceipt", func(_ context.Context, hash common.Hash) (*gethTypes.Receipt, error) {
-			return nil, errors.New("simulated transaction receipt error")
-		})
-
-		_, err = s.SendTransaction("test-1", &common.Address{}, nil, txBlob[i], 0)
-		assert.NoError(t, err)
-
-		_, err = s.SendTransaction("test-2", &common.Address{}, nil, txBlob[i], 0)
-		assert.NoError(t, err)
-
-		s.checkPendingTransaction()
-
-		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 10)
-		assert.NoError(t, err)
-		assert.Len(t, txs, 3)
-
-		assert.Equal(t, txs[0].Nonce, txs[1].Nonce)
-		assert.Equal(t, txs[0].Nonce+1, txs[2].Nonce)
-
-		// the first 2 transactions have the same nonce, with one replaced and another pending
-		assert.Equal(t, types.TxStatusReplaced, txs[0].Status)
-		assert.Equal(t, types.TxStatusPending, txs[1].Status)
-
-		// the third transaction has nonce + 1, which will not be replaced due to the nonce gap,
-		// thus the status should be pending
-		assert.Equal(t, types.TxStatusPending, txs[2].Status)
-
-		s.Stop()
-		patchGuard1.Reset()
-		patchGuard2.Reset()
-	}
-}
-
 func testCheckPendingTransactionTxConfirmed(t *testing.T) {
 	for _, txType := range txTypes {
 		sqlDB, err := db.DB()
@@ -600,7 +525,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 +567,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 +627,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 +697,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 +774,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()
 
@@ -893,22 +818,3 @@ func randFieldElement() [32]byte {
 
 	return gokzg4844.SerializeScalar(r)
 }
-
-func testSendBlobCarryingTxOverLimit(t *testing.T) {
-	cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
-	cfgCopy.TxType = "DynamicFeeTx"
-
-	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)
-	assert.NoError(t, err)
-
-	for i := 0; i < int(cfgCopy.MaxPendingBlobTxs); i++ {
-		_, err = s.SendTransaction("0", &common.Address{}, nil, randBlob(), 0)
-		assert.NoError(t, err)
-	}
-	_, err = s.SendTransaction("0", &common.Address{}, nil, randBlob(), 0)
-	assert.ErrorIs(t, err, ErrTooManyPendingBlobTxs)
-	s.Stop()
-}

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/batch_proposer.go

@@ -2,6 +2,7 @@ package watcher
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"time"
 
@@ -53,9 +54,6 @@ type BatchProposer struct {
 
 	// total number of times that batch proposer stops early due to compressed data compatibility breach
 	compressedDataCompatibilityBreachTotal prometheus.Counter
-
-	batchProposeBlockHeight prometheus.Gauge
-	batchProposeThroughput  prometheus.Counter
 }
 
 // NewBatchProposer creates a new BatchProposer instance.
@@ -137,14 +135,6 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, chai
 			Name: "rollup_propose_batch_estimate_blob_size_time",
 			Help: "Time taken to estimate blob size for the chunk.",
 		}),
-		batchProposeBlockHeight: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-			Name: "rollup_batch_propose_block_height",
-			Help: "The block height of the latest proposed batch",
-		}),
-		batchProposeThroughput: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-			Name: "rollup_batch_propose_throughput",
-			Help: "The total gas used in proposed batches",
-		}),
 	}
 
 	return p
@@ -162,10 +152,6 @@ func (p *BatchProposer) TryProposeBatch() {
 
 func (p *BatchProposer) updateDBBatchInfo(batch *encoding.Batch, codecVersion encoding.CodecVersion, metrics *utils.BatchMetrics) error {
 	compatibilityBreachOccurred := false
-	codecConfig := utils.CodecConfig{
-		Version:        codecVersion,
-		EnableCompress: true, // codecv4 is the only version that supports conditional compression, default to enable compression
-	}
 
 	for {
 		compatible, err := utils.CheckBatchCompressedDataCompatibility(batch, codecVersion)
@@ -178,15 +164,13 @@ func (p *BatchProposer) updateDBBatchInfo(batch *encoding.Batch, codecVersion en
 			break
 		}
 
-		compatibilityBreachOccurred = true
-
 		if len(batch.Chunks) == 1 {
-			log.Warn("Disable compression: cannot truncate batch with only 1 chunk for compatibility", "start block number", batch.Chunks[0].Blocks[0].Header.Number.Uint64(),
+			log.Error("Cannot truncate batch with only 1 chunk for compatibility", "start block number", batch.Chunks[0].Blocks[0].Header.Number.Uint64(),
 				"end block number", batch.Chunks[0].Blocks[len(batch.Chunks[0].Blocks)-1].Header.Number.Uint64())
-			codecConfig.EnableCompress = false
-			break
+			return errors.New("cannot truncate batch with only 1 chunk for compatibility")
 		}
 
+		compatibilityBreachOccurred = true
 		batch.Chunks = batch.Chunks[:len(batch.Chunks)-1]
 
 		log.Info("Batch not compatible with compressed data, removing last chunk", "batch index", batch.Index, "truncated chunk length", len(batch.Chunks))
@@ -197,7 +181,7 @@ func (p *BatchProposer) updateDBBatchInfo(batch *encoding.Batch, codecVersion en
 
 		// recalculate batch metrics after truncation
 		var calcErr error
-		metrics, calcErr = utils.CalculateBatchMetrics(batch, codecConfig)
+		metrics, calcErr = utils.CalculateBatchMetrics(batch, codecVersion)
 		if calcErr != nil {
 			return fmt.Errorf("failed to calculate batch metrics, batch index: %v, error: %w", batch.Index, calcErr)
 		}
@@ -206,23 +190,11 @@ func (p *BatchProposer) updateDBBatchInfo(batch *encoding.Batch, codecVersion en
 		p.recordAllBatchMetrics(metrics)
 	}
 
-	if len(batch.Chunks) > 0 && len(batch.Chunks[len(batch.Chunks)-1].Blocks) > 0 {
-		lastChunk := batch.Chunks[len(batch.Chunks)-1]
-		lastBlock := lastChunk.Blocks[len(lastChunk.Blocks)-1]
-		p.batchProposeBlockHeight.Set(float64(lastBlock.Header.Number.Uint64()))
-	}
-
-	var totalGasUsed uint64
-	for _, chunk := range batch.Chunks {
-		totalGasUsed += chunk.L2GasUsed()
-	}
-	p.batchProposeThroughput.Add(float64(totalGasUsed))
-
 	p.proposeBatchUpdateInfoTotal.Inc()
 	err := p.db.Transaction(func(dbTX *gorm.DB) error {
-		dbBatch, dbErr := p.batchOrm.InsertBatch(p.ctx, batch, codecConfig, *metrics, dbTX)
+		dbBatch, dbErr := p.batchOrm.InsertBatch(p.ctx, batch, codecVersion, *metrics, dbTX)
 		if dbErr != nil {
-			log.Warn("BatchProposer.updateBatchInfoInDB insert batch failure", "index", batch.Index, "parent hash", batch.ParentBatchHash.Hex(), "codec version", codecVersion, "enable compress", codecConfig.EnableCompress, "error", dbErr)
+			log.Warn("BatchProposer.updateBatchInfoInDB insert batch failure", "index", batch.Index, "parent hash", batch.ParentBatchHash.Hex(), "error", dbErr)
 			return dbErr
 		}
 		if dbErr = p.chunkOrm.UpdateBatchHashInRange(p.ctx, dbBatch.StartChunkIndex, dbBatch.EndChunkIndex, dbBatch.Hash, dbTX); dbErr != nil {
@@ -283,10 +255,7 @@ func (p *BatchProposer) proposeBatch() error {
 		return err
 	}
 
-	codecConfig := utils.CodecConfig{
-		Version:        forks.GetCodecVersion(p.chainCfg, firstUnbatchedChunk.StartBlockNumber, firstUnbatchedChunk.StartBlockTime),
-		EnableCompress: true, // codecv4 is the only version that supports conditional compression, default to enable compression
-	}
+	codecVersion := forks.GetCodecVersion(p.chainCfg, firstUnbatchedChunk.StartBlockNumber, firstUnbatchedChunk.StartBlockTime)
 
 	var batch encoding.Batch
 	batch.Index = dbParentBatch.Index + 1
@@ -295,7 +264,7 @@ func (p *BatchProposer) proposeBatch() error {
 
 	for i, chunk := range daChunks {
 		batch.Chunks = append(batch.Chunks, chunk)
-		metrics, calcErr := utils.CalculateBatchMetrics(&batch, codecConfig)
+		metrics, calcErr := utils.CalculateBatchMetrics(&batch, codecVersion)
 		if calcErr != nil {
 			return fmt.Errorf("failed to calculate batch metrics: %w", calcErr)
 		}
@@ -324,17 +293,17 @@ func (p *BatchProposer) proposeBatch() error {
 
 			batch.Chunks = batch.Chunks[:len(batch.Chunks)-1]
 
-			metrics, err := utils.CalculateBatchMetrics(&batch, codecConfig)
+			metrics, err := utils.CalculateBatchMetrics(&batch, codecVersion)
 			if err != nil {
 				return fmt.Errorf("failed to calculate batch metrics: %w", err)
 			}
 
 			p.recordAllBatchMetrics(metrics)
-			return p.updateDBBatchInfo(&batch, codecConfig.Version, metrics)
+			return p.updateDBBatchInfo(&batch, codecVersion, metrics)
 		}
 	}
 
-	metrics, calcErr := utils.CalculateBatchMetrics(&batch, codecConfig)
+	metrics, calcErr := utils.CalculateBatchMetrics(&batch, codecVersion)
 	if calcErr != nil {
 		return fmt.Errorf("failed to calculate batch metrics: %w", calcErr)
 	}
@@ -348,7 +317,7 @@ func (p *BatchProposer) proposeBatch() error {
 
 		p.batchFirstBlockTimeoutReached.Inc()
 		p.recordAllBatchMetrics(metrics)
-		return p.updateDBBatchInfo(&batch, codecConfig.Version, metrics)
+		return p.updateDBBatchInfo(&batch, codecVersion, metrics)
 	}
 
 	log.Debug("pending chunks do not reach one of the constraints or contain a timeout block")

rollup/internal/controller/watcher/batch_proposer_test.go

@@ -92,7 +92,7 @@ func testBatchProposerCodecv0Limits(t *testing.T) {
 				Blocks: []*encoding.Block{block},
 			}
 			chunkOrm := orm.NewChunk(db)
-			_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 			assert.NoError(t, err)
 			batch := &encoding.Batch{
 				Index:                      0,
@@ -101,7 +101,7 @@ func testBatchProposerCodecv0Limits(t *testing.T) {
 				Chunks:                     []*encoding.Chunk{chunk},
 			}
 			batchOrm := orm.NewBatch(db)
-			_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+			_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 			assert.NoError(t, err)
 
 			l2BlockOrm := orm.NewL2Block(db)
@@ -229,7 +229,7 @@ func testBatchProposerCodecv1Limits(t *testing.T) {
 				Blocks: []*encoding.Block{block},
 			}
 			chunkOrm := orm.NewChunk(db)
-			_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 			assert.NoError(t, err)
 			batch := &encoding.Batch{
 				Index:                      0,
@@ -238,7 +238,7 @@ func testBatchProposerCodecv1Limits(t *testing.T) {
 				Chunks:                     []*encoding.Chunk{chunk},
 			}
 			batchOrm := orm.NewBatch(db)
-			_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+			_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 			assert.NoError(t, err)
 
 			l2BlockOrm := orm.NewL2Block(db)
@@ -370,7 +370,7 @@ func testBatchProposerCodecv2Limits(t *testing.T) {
 				Blocks: []*encoding.Block{block},
 			}
 			chunkOrm := orm.NewChunk(db)
-			_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 			assert.NoError(t, err)
 			batch := &encoding.Batch{
 				Index:                      0,
@@ -379,7 +379,7 @@ func testBatchProposerCodecv2Limits(t *testing.T) {
 				Chunks:                     []*encoding.Chunk{chunk},
 			}
 			batchOrm := orm.NewBatch(db)
-			_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+			_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 			assert.NoError(t, err)
 
 			l2BlockOrm := orm.NewL2Block(db)
@@ -515,7 +515,7 @@ func testBatchProposerCodecv3Limits(t *testing.T) {
 				Blocks: []*encoding.Block{block},
 			}
 			chunkOrm := orm.NewChunk(db)
-			_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 			assert.NoError(t, err)
 			batch := &encoding.Batch{
 				Index:                      0,
@@ -524,7 +524,7 @@ func testBatchProposerCodecv3Limits(t *testing.T) {
 				Chunks:                     []*encoding.Chunk{chunk},
 			}
 			batchOrm := orm.NewBatch(db)
-			_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+			_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 			assert.NoError(t, err)
 
 			l2BlockOrm := orm.NewL2Block(db)
@@ -605,7 +605,7 @@ func testBatchCommitGasAndCalldataSizeCodecv0Estimation(t *testing.T) {
 		Blocks: []*encoding.Block{block},
 	}
 	chunkOrm := orm.NewChunk(db)
-	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 	assert.NoError(t, err)
 	batch := &encoding.Batch{
 		Index:                      0,
@@ -614,7 +614,7 @@ func testBatchCommitGasAndCalldataSizeCodecv0Estimation(t *testing.T) {
 		Chunks:                     []*encoding.Chunk{chunk},
 	}
 	batchOrm := orm.NewBatch(db)
-	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	l2BlockOrm := orm.NewL2Block(db)
@@ -684,7 +684,7 @@ func testBatchCommitGasAndCalldataSizeCodecv1Estimation(t *testing.T) {
 		Blocks: []*encoding.Block{block},
 	}
 	chunkOrm := orm.NewChunk(db)
-	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 	assert.NoError(t, err)
 	batch := &encoding.Batch{
 		Index:                      0,
@@ -693,7 +693,7 @@ func testBatchCommitGasAndCalldataSizeCodecv1Estimation(t *testing.T) {
 		Chunks:                     []*encoding.Chunk{chunk},
 	}
 	batchOrm := orm.NewBatch(db)
-	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	l2BlockOrm := orm.NewL2Block(db)
@@ -763,7 +763,7 @@ func testBatchCommitGasAndCalldataSizeCodecv2Estimation(t *testing.T) {
 		Blocks: []*encoding.Block{block},
 	}
 	chunkOrm := orm.NewChunk(db)
-	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 	assert.NoError(t, err)
 	batch := &encoding.Batch{
 		Index:                      0,
@@ -772,7 +772,7 @@ func testBatchCommitGasAndCalldataSizeCodecv2Estimation(t *testing.T) {
 		Chunks:                     []*encoding.Chunk{chunk},
 	}
 	batchOrm := orm.NewBatch(db)
-	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	l2BlockOrm := orm.NewL2Block(db)
@@ -844,7 +844,7 @@ func testBatchCommitGasAndCalldataSizeCodecv3Estimation(t *testing.T) {
 		Blocks: []*encoding.Block{block},
 	}
 	chunkOrm := orm.NewChunk(db)
-	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 	assert.NoError(t, err)
 	batch := &encoding.Batch{
 		Index:                      0,
@@ -853,7 +853,7 @@ func testBatchCommitGasAndCalldataSizeCodecv3Estimation(t *testing.T) {
 		Chunks:                     []*encoding.Chunk{chunk},
 	}
 	batchOrm := orm.NewBatch(db)
-	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	l2BlockOrm := orm.NewL2Block(db)
@@ -926,7 +926,7 @@ func testBatchProposerBlobSizeLimit(t *testing.T) {
 			Blocks: []*encoding.Block{block},
 		}
 		chunkOrm := orm.NewChunk(db)
-		_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+		_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 		assert.NoError(t, err)
 		batch := &encoding.Batch{
 			Index:                      0,
@@ -935,7 +935,7 @@ func testBatchProposerBlobSizeLimit(t *testing.T) {
 			Chunks:                     []*encoding.Chunk{chunk},
 		}
 		batchOrm := orm.NewBatch(db)
-		_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+		_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 		assert.NoError(t, err)
 
 		var chainConfig *params.ChainConfig
@@ -1029,7 +1029,7 @@ func testBatchProposerMaxChunkNumPerBatchLimit(t *testing.T) {
 			Blocks: []*encoding.Block{block},
 		}
 		chunkOrm := orm.NewChunk(db)
-		_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+		_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 		assert.NoError(t, err)
 		batch := &encoding.Batch{
 			Index:                      0,
@@ -1038,7 +1038,7 @@ func testBatchProposerMaxChunkNumPerBatchLimit(t *testing.T) {
 			Chunks:                     []*encoding.Chunk{chunk},
 		}
 		batchOrm := orm.NewBatch(db)
-		_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+		_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 		assert.NoError(t, err)
 
 		var expectedChunkNum uint64
@@ -1117,7 +1117,7 @@ func testBatchProposerRespectHardforks(t *testing.T) {
 		Blocks: []*encoding.Block{block},
 	}
 	chunkOrm := orm.NewChunk(db)
-	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
 	assert.NoError(t, err)
 	batch := &encoding.Batch{
 		Index:                      0,
@@ -1126,7 +1126,7 @@ func testBatchProposerRespectHardforks(t *testing.T) {
 		Chunks:                     []*encoding.Chunk{chunk},
 	}
 	batchOrm := orm.NewBatch(db)
-	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{