fix(rollup-relayer): wrong registration of metric (#1521)

Co-authored-by: colinlyguo <colinlyguo@users.noreply.github.com>

Makefile

@@ -1,6 +1,6 @@
 .PHONY: fmt dev_docker build_test_docker run_test_docker clean update
 
-L2GETH_TAG=scroll-v5.5.1
+L2GETH_TAG=scroll-v5.6.3
 
 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 ./common/testcontainers/docker/l1geth/
-	docker build -t scroll_l2geth ./common/testcontainers/docker/l2geth/
+	docker build -t scroll_l1geth --platform linux/amd64 ./common/testcontainers/docker/l1geth/
+	docker build -t scroll_l2geth --platform linux/amd64 ./common/testcontainers/docker/l2geth/
 
 clean: ## Empty out the bin folder
 	@rm -rf build/bin

bridge-history-api/conf/config.json

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

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

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 
 	"scroll-tech/common/database"
+	"scroll-tech/common/utils"
 )
 
 // FetcherConfig is the configuration of Layer1 or Layer2 fetcher.
@@ -30,6 +31,8 @@ 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
@@ -64,5 +67,11 @@ 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,6 +168,14 @@ 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,11 +51,8 @@ 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),
@@ -69,11 +66,8 @@ 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),
@@ -105,6 +99,26 @@ 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{
@@ -210,7 +224,7 @@ func (f *L1FetcherLogic) l1FetcherLogs(ctx context.Context, from, to uint64) ([]
 		Topics:    make([][]common.Hash, 1),
 	}
 
-	query.Topics[0] = make([]common.Hash, 15)
+	query.Topics[0] = make([]common.Hash, 16)
 	query.Topics[0][0] = backendabi.L1DepositETHSig
 	query.Topics[0][1] = backendabi.L1DepositERC20Sig
 	query.Topics[0][2] = backendabi.L1DepositERC721Sig
@@ -226,6 +240,7 @@ 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,7 +54,6 @@ 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),
@@ -68,7 +67,6 @@ 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),
@@ -100,6 +98,11 @@ 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,6 @@ RUN --mount=target=. \
 FROM ubuntu:20.04
 
 ENV CGO_LDFLAGS="-Wl,--no-as-needed -ldl"
-
 COPY --from=builder /bin/bridgehistoryapi-api /bin/
 WORKDIR /app
 ENTRYPOINT ["bridgehistoryapi-api"]

build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile

@@ -17,7 +17,8 @@ RUN --mount=target=. \
 FROM ubuntu:20.04
 
 ENV CGO_LDFLAGS="-Wl,--no-as-needed -ldl"
-
+RUN apt update && apt install ca-certificates -y
+RUN update-ca-certificates
 COPY --from=builder /bin/bridgehistoryapi-fetcher /bin/
 WORKDIR /app
 ENTRYPOINT ["bridgehistoryapi-fetcher"]

common/forks/forks.go

@@ -16,8 +16,10 @@ func GetHardforkName(config *params.ChainConfig, blockHeight, blockTimestamp uin
 		return "bernoulli"
 	} else if !config.IsDarwin(blockTimestamp) {
 		return "curie"
-	} else {
+	} else if !config.IsDarwinV2(blockTimestamp) {
 		return "darwin"
+	} else {
+		return "darwinV2"
 	}
 }
 
@@ -30,8 +32,10 @@ func GetCodecVersion(config *params.ChainConfig, blockHeight, blockTimestamp uin
 		return encoding.CodecV1
 	} else if !config.IsDarwin(blockTimestamp) {
 		return encoding.CodecV2
-	} else {
+	} else if !config.IsDarwinV2(blockTimestamp) {
 		return encoding.CodecV3
+	} else {
+		return encoding.CodecV4
 	}
 }
 
@@ -44,6 +48,8 @@ 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,6 +6,8 @@ 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
@@ -13,32 +15,16 @@ 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
-    go test -tags="gpu ffi" -timeout 0 -c core/prover_test.go
+    make tests_binary
     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 test_zkp_test/*
+rm -rf $PROVER_OUTPUT_DIR/*
 #rm -rf prover.log verifier.log
-#$REPO/prover/core.test -test.v 2>&1 | tee prover.log
+$REPO/prover/prover.test --exact zk_circuits_handler::darwin_v2::tests::test_circuits 2>&1 | tee prover.log
 $REPO/coordinator/verifier.test -test.v 2>&1 | tee verifier.log

common/libzkp/impl/Cargo.lock

@@ -28,44 +28,10 @@ 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.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "ark-std 0.3.0",
  "bitstream-io",
@@ -96,6 +62,40 @@ 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.72"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b13c32d80ecc7ab747b80c3784bce54ee8a7a0cc4fbda9bf4cda2cf6fe90854"
+checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
 
 [[package]]
 name = "arc-swap"
@@ -568,37 +568,10 @@ 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.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core",
@@ -620,6 +593,31 @@ 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"
@@ -1184,8 +1182,8 @@ dependencies = [
 
 [[package]]
 name = "eth-types"
-version = "0.11.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "base64 0.13.1",
  "ethers-core",
@@ -1202,7 +1200,6 @@ dependencies = [
  "revm-primitives",
  "serde",
  "serde_json",
- "serde_stacker",
  "serde_with",
  "sha3 0.10.8",
  "strum 0.25.0",
@@ -1213,8 +1210,8 @@ dependencies = [
 
 [[package]]
 name = "eth-types"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+version = "0.13.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
 dependencies = [
  "base64 0.13.1",
  "ethers-core",
@@ -1369,11 +1366,11 @@ dependencies = [
 
 [[package]]
 name = "external-tracer"
-version = "0.11.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
- "eth-types 0.11.0",
- "geth-utils 0.11.0",
+ "eth-types 0.12.0",
+ "geth-utils 0.12.0",
  "log",
  "serde",
  "serde_json",
@@ -1382,11 +1379,11 @@ dependencies = [
 
 [[package]]
 name = "external-tracer"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+version = "0.13.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
 dependencies = [
- "eth-types 0.12.0",
- "geth-utils 0.12.0",
+ "eth-types 0.13.0",
+ "geth-utils 0.13.0",
  "log",
  "serde",
  "serde_json",
@@ -1564,10 +1561,10 @@ dependencies = [
 
 [[package]]
 name = "gadgets"
-version = "0.11.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
- "eth-types 0.11.0",
+ "eth-types 0.12.0",
  "halo2_proofs",
  "poseidon-base",
  "sha3 0.10.8",
@@ -1576,10 +1573,10 @@ dependencies = [
 
 [[package]]
 name = "gadgets"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+version = "0.13.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
 dependencies = [
- "eth-types 0.12.0",
+ "eth-types 0.13.0",
  "halo2_proofs",
  "poseidon-base",
  "sha3 0.10.8",
@@ -1599,8 +1596,8 @@ dependencies = [
 
 [[package]]
 name = "geth-utils"
-version = "0.11.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "env_logger 0.10.0",
  "gobuild",
@@ -1609,8 +1606,8 @@ dependencies = [
 
 [[package]]
 name = "geth-utils"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+version = "0.13.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
 dependencies = [
  "env_logger 0.10.0",
  "gobuild",
@@ -2356,25 +2353,10 @@ 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.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core",
@@ -2387,23 +2369,24 @@ dependencies = [
 ]
 
 [[package]]
-name = "mpt-zktrie"
-version = "0.11.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.4#38a68e22d3d8449bd39a50c22da55b9e741de453"
+name = "mock"
+version = "0.13.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
 dependencies = [
- "eth-types 0.11.0",
- "halo2curves",
- "hex",
+ "eth-types 0.13.0",
+ "ethers-core",
+ "ethers-signers",
+ "external-tracer 0.13.0",
+ "itertools 0.11.0",
  "log",
- "num-bigint",
- "poseidon-base",
- "zktrie",
+ "rand",
+ "rand_chacha",
 ]
 
 [[package]]
 name = "mpt-zktrie"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "eth-types 0.12.0",
  "halo2curves",
@@ -2411,7 +2394,21 @@ dependencies = [
  "log",
  "num-bigint",
  "poseidon-base",
- "zktrie",
+ "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)",
 ]
 
 [[package]]
@@ -2872,44 +2869,10 @@ 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.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "aggregator 0.12.0",
  "anyhow",
@@ -2940,6 +2903,40 @@ 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"
@@ -4543,52 +4540,10 @@ 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.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "array-init",
  "bus-mapping 0.12.0",
@@ -4627,18 +4582,61 @@ 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",
@@ -4651,7 +4649,16 @@ version = "0.3.0"
 source = "git+https://github.com/scroll-tech/zktrie.git?branch=main#23181f209e94137f74337b150179aeb80c72e7c8"
 dependencies = [
  "gobuild",
- "zktrie_rust",
+ "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)",
 ]
 
 [[package]]
@@ -4668,6 +4675,20 @@ 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.0", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
+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"] }
 
 base64 = "0.13.0"
 env_logger = "0.9.0"
@@ -37,6 +37,7 @@ 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

@@ -1,69 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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,4 +1,63 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,48 @@
+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,11 +1,10 @@
 // BatchVerifier is used to:
 // - Verify a batch proof
 // - Verify a bundle proof
-void init_batch_verifier(char* params_dir, char* assets_dir);
+void init(char* config);
 
 char verify_batch_proof(char* proof, char* fork_name);
 
-char verify_bundle_proof(char* proof);
+char verify_bundle_proof(char* proof, char* fork_name);
 
-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/types/message/message.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/scroll-tech/da-codec/encoding/codecv3"
 	"github.com/scroll-tech/go-ethereum/common"
 )
 
@@ -52,9 +51,10 @@ type ChunkTaskDetail struct {
 
 // BatchTaskDetail is a type containing BatchTask detail.
 type BatchTaskDetail struct {
-	ChunkInfos  []*ChunkInfo     `json:"chunk_infos"`
-	ChunkProofs []*ChunkProof    `json:"chunk_proofs"`
-	BatchHeader *codecv3.DABatch `json:"batch_header"`
+	ChunkInfos  []*ChunkInfo  `json:"chunk_infos"`
+	ChunkProofs []*ChunkProof `json:"chunk_proofs"`
+	BatchHeader interface{}   `json:"batch_header"`
+	BlobBytes   []byte        `json:"blob_bytes"`
 }
 
 // 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,10 +9,14 @@ 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.
@@ -78,3 +82,89 @@ 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.40"
+var tag = "v4.4.63"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

coordinator/cmd/api/app/mock_app.go

@@ -88,13 +88,25 @@ 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},
+		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",
+			},
+		},
 		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,14 +6,20 @@
     "batch_collection_time_sec": 180,
     "chunk_collection_time_sec": 180,
     "verifier": {
-      "fork_name": "bernoulli",
       "mock_mode": true,
-      "params_path": "",
-      "assets_path_lo": "",
-      "assets_path_hi": ""
-    },
-    "max_verifier_workers": 4,
-    "min_prover_version": "v1.0.0"
+      "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"
+      }
+    }
   },
   "db": {
     "driver_name": "postgres",

coordinator/go.mod

@@ -6,7 +6,10 @@ 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
@@ -42,12 +45,6 @@ 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-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/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/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,6 +6,7 @@ import (
 	"path/filepath"
 
 	"scroll-tech/common/database"
+	"scroll-tech/common/utils"
 )
 
 // ProverManager loads sequencer configuration items.
@@ -23,10 +24,6 @@ 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.
@@ -50,13 +47,19 @@ 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 {
-	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
+	MockMode           bool           `json:"mock_mode"`
+	LowVersionCircuit  *CircuitConfig `json:"low_version_circuit"`
+	HighVersionCircuit *CircuitConfig `json:"high_version_circuit"`
 }
 
 // NewConfig returns a new instance of Config.
@@ -72,5 +75,11 @@ 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

@@ -6,7 +6,6 @@ import (
 
 	jwt "github.com/appleboy/gin-jwt/v2"
 	"github.com/gin-gonic/gin"
-	"github.com/scroll-tech/go-ethereum/log"
 	"gorm.io/gorm"
 
 	"scroll-tech/coordinator/internal/config"
@@ -45,33 +44,34 @@ 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)
 	}
-	return login, nil
+
+	returnData := types.LoginParameterWithHardForkName{
+		HardForkName:   hardForkNames,
+		LoginParameter: login,
+	}
+
+	return returnData, nil
 }
 
 // PayloadFunc returns jwt.MapClaims with {public key, prover name}.
 func (a *AuthController) PayloadFunc(data interface{}) jwt.MapClaims {
-	v, ok := data.(types.LoginParameter)
+	v, ok := data.(types.LoginParameterWithHardForkName)
 	if !ok {
 		return jwt.MapClaims{}
 	}
 
-	publicKey := v.PublicKey
-	if publicKey == "" {
-		var err error
-		publicKey, err = v.RecoverPublicKeyFromSignature()
-		if err != nil {
-			// do not handle error here since already called v.Verify() beforehands so there should be no error
-			// add log just in case some error happens
-			log.Error("impossible path: failed to recover public key from signature", "error", err.Error())
-		}
-	}
-
 	return jwt.MapClaims{
-		types.PublicKey:     publicKey,
+		types.HardForkName:  v.HardForkName,
+		types.PublicKey:     v.PublicKey,
 		types.ProverName:    v.Message.ProverName,
 		types.ProverVersion: v.Message.ProverVersion,
 	}
@@ -91,5 +91,10 @@ 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)
+	log.Info("verifier created", "chunkVerifier", vf.ChunkVKMap, "batchVerifier", vf.BatchVKMap, "bundleVerifier", vf.BundleVkMap)
 
 	Auth = NewAuthController(db, cfg, vf)
 	GetTask = NewGetTaskController(cfg, chainCfg, db, reg)

coordinator/internal/controller/api/get_task.go

@@ -108,10 +108,6 @@ 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,6 +3,7 @@ package auth
 import (
 	"errors"
 	"fmt"
+	"strings"
 
 	"github.com/gin-gonic/gin"
 	"github.com/scroll-tech/go-ethereum/log"
@@ -23,31 +24,35 @@ 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 {
-	l := &LoginLogic{
-		cfg:          cfg,
-		chunkVks:     make(map[string]struct{}),
-		batchVKs:     make(map[string]struct{}),
-		bundleVks:    make(map[string]struct{}),
-		challengeOrm: orm.NewChallenge(db),
+	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")
 	}
 
-	for _, vk := range vf.ChunkVKMap {
-		l.chunkVks[vk] = struct{}{}
-	}
+	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
 
-	for _, vk := range vf.BatchVKMap {
-		l.batchVKs[vk] = struct{}{}
-	}
+	proverVersionHardForkMap[cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion] = []string{cfg.ProverManager.Verifier.LowVersionCircuit.ForkName}
 
-	for _, vk := range vf.BundleVkMap {
-		l.bundleVks[vk] = struct{}{}
+	return &LoginLogic{
+		cfg:                      cfg,
+		chunkVks:                 vf.ChunkVKMap,
+		batchVKs:                 vf.BatchVKMap,
+		bundleVks:                vf.BundleVkMap,
+		challengeOrm:             orm.NewChallenge(db),
+		proverVersionHardForkMap: proverVersionHardForkMap,
 	}
-
-	return l
 }
 
 // InsertChallengeString insert and check the challenge string is existed
@@ -56,16 +61,16 @@ func (l *LoginLogic) InsertChallengeString(ctx *gin.Context, challenge string) e
 }
 
 func (l *LoginLogic) Check(login *types.LoginParameter) error {
-	if login.PublicKey != "" {
-		verify, err := login.Verify()
-		if err != nil || !verify {
-			return errors.New("auth message verify failure")
-		}
+	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 !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.MinProverVersion) {
+	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion) {
 		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s",
-			l.cfg.ProverManager.MinProverVersion, login.Message.ProverVersion)
+			l.cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, login.Message.ProverVersion)
 	}
 
 	if len(login.Message.ProverTypes) > 0 {
@@ -84,13 +89,14 @@ func (l *LoginLogic) Check(login *types.LoginParameter) error {
 					vks[vk] = struct{}{}
 				}
 			default:
-				log.Error("invalid prover_type", "value", proverType)
+				log.Error("invalid prover_type", "value", proverType, "prover name", login.Message.ProverName, "prover_version", login.Message.ProverVersion)
 			}
 		}
 
 		for _, vk := range login.Message.VKs {
 			if _, ok := vks[vk]; !ok {
-				log.Error("vk inconsistency", "prover vk", vk)
+				log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
+					"prover_version", login.Message.ProverVersion, "message", login.Message)
 				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)
@@ -102,3 +108,18 @@ 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,7 +9,9 @@ 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"
@@ -29,9 +31,8 @@ import (
 type BatchProverTask struct {
 	BaseProverTask
 
-	batchAttemptsExceedTotal prometheus.Counter
-	batchTaskGetTaskTotal    *prometheus.CounterVec
-	batchTaskGetTaskProver   *prometheus.CounterVec
+	batchTaskGetTaskTotal  *prometheus.CounterVec
+	batchTaskGetTaskProver *prometheus.CounterVec
 }
 
 // NewBatchProverTask new a batch collector
@@ -47,10 +48,6 @@ 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.",
@@ -123,6 +120,15 @@ 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,
@@ -208,17 +214,9 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		chunkInfos = append(chunkInfos, &chunkInfo)
 	}
 
-	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
+	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)
 	}
 
 	chunkProofsBytes, err := json.Marshal(taskDetail)
@@ -241,3 +239,34 @@ 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,9 +27,8 @@ import (
 type BundleProverTask struct {
 	BaseProverTask
 
-	bundleAttemptsExceedTotal prometheus.Counter
-	bundleTaskGetTaskTotal    *prometheus.CounterVec
-	bundleTaskGetTaskProver   *prometheus.CounterVec
+	bundleTaskGetTaskTotal  *prometheus.CounterVec
+	bundleTaskGetTaskProver *prometheus.CounterVec
 }
 
 // NewBundleProverTask new a bundle collector
@@ -46,10 +45,6 @@ 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.",
@@ -122,6 +117,15 @@ 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,9 +27,8 @@ import (
 type ChunkProverTask struct {
 	BaseProverTask
 
-	chunkAttemptsExceedTotal prometheus.Counter
-	chunkTaskGetTaskTotal    *prometheus.CounterVec
-	chunkTaskGetTaskProver   *prometheus.CounterVec
+	chunkTaskGetTaskTotal  *prometheus.CounterVec
+	chunkTaskGetTaskProver *prometheus.CounterVec
 }
 
 // NewChunkProverTask new a chunk prover task
@@ -44,10 +43,6 @@ 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.",
@@ -70,7 +65,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)
+		tmpChunkTask, getTaskError = cp.chunkOrm.GetAssignedChunk(ctx.Copy(), maxActiveAttempts, maxTotalAttempts, getTaskParameter.ProverHeight)
 		if getTaskError != nil {
 			log.Error("failed to get assigned chunk proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 			return nil, ErrCoordinatorInternalFailure
@@ -79,7 +74,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)
+			tmpChunkTask, getTaskError = cp.chunkOrm.GetUnassignedChunk(ctx.Copy(), maxActiveAttempts, maxTotalAttempts, getTaskParameter.ProverHeight)
 			if getTaskError != nil {
 				log.Error("failed to get unassigned chunk proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 				return nil, ErrCoordinatorInternalFailure
@@ -120,6 +115,15 @@ 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,6 +3,7 @@ package provertask
 import (
 	"errors"
 	"fmt"
+	"strings"
 	"sync"
 
 	"github.com/gin-gonic/gin"
@@ -49,11 +50,13 @@ 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 {
@@ -73,6 +76,15 @@ 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)
+		success, verifyErr = m.verifier.VerifyBundleProof(&bundleProof, hardForkName)
 	}
 
 	if verifyErr != nil || !success {

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

@@ -1,11 +0,0 @@
-#!/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]string{cfg.ForkName: "mock_vk"}
-	chunkVKMap := map[string]string{cfg.ForkName: "mock_vk"}
+	batchVKMap := map[string]struct{}{"mock_vk": {}}
+	chunkVKMap := map[string]struct{}{"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) (bool, error) {
+func (v *Verifier) VerifyBundleProof(proof *message.BundleProof, forkName string) (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]string
-	BatchVKMap  map[string]string
-	BundleVkMap map[string]string
+	ChunkVKMap  map[string]struct{}
+	BatchVKMap  map[string]struct{}
+	BundleVkMap map[string]struct{}
 }

coordinator/internal/logic/verifier/verifier.go

@@ -11,11 +11,9 @@ package verifier
 import "C" //nolint:typecheck
 
 import (
-	"embed"
 	"encoding/base64"
 	"encoding/json"
 	"io"
-	"io/fs"
 	"os"
 	"path"
 	"unsafe"
@@ -27,52 +25,87 @@ 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]string{cfg.ForkName: "mock_vk"}
-		batchVKMap := map[string]string{cfg.ForkName: "mock_vk"}
-		bundleVKMap := map[string]string{cfg.ForkName: "mock_vk"}
+		chunkVKMap := map[string]struct{}{"mock_vk": {}}
+		batchVKMap := map[string]struct{}{"mock_vk": {}}
+		bundleVKMap := map[string]struct{}{"mock_vk": {}}
 		return &Verifier{cfg: cfg, ChunkVKMap: chunkVKMap, BatchVKMap: batchVKMap, BundleVkMap: bundleVKMap}, nil
 	}
-	paramsPathStr := C.CString(cfg.ParamsPath)
-	assetsPathLoStr := C.CString(cfg.AssetsPathLo)
-	assetsPathHiStr := C.CString(cfg.AssetsPathHi)
+	verifierConfig := newRustVerifierConfig(cfg)
+	configBytes, err := json.Marshal(verifierConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	configStr := C.CString(string(configBytes))
 	defer func() {
-		C.free(unsafe.Pointer(paramsPathStr))
-		C.free(unsafe.Pointer(assetsPathLoStr))
-		C.free(unsafe.Pointer(assetsPathHiStr))
+		C.free(unsafe.Pointer(configStr))
 	}()
 
-	C.init_batch_verifier(paramsPathStr, assetsPathHiStr)
-	C.init_chunk_verifier(paramsPathStr, assetsPathLoStr, assetsPathHiStr)
+	C.init(configStr)
 
 	v := &Verifier{
 		cfg:         cfg,
-		ChunkVKMap:  make(map[string]string),
-		BatchVKMap:  make(map[string]string),
-		BundleVkMap: make(map[string]string),
+		ChunkVKMap:  make(map[string]struct{}),
+		BatchVKMap:  make(map[string]struct{}),
+		BundleVkMap: make(map[string]struct{}),
 	}
 
-	bundleVK, err := v.readVK(path.Join(cfg.AssetsPathHi, "vk_bundle.vkey"))
+	bundleVK, err := v.readVK(path.Join(cfg.HighVersionCircuit.AssetsPath, "vk_bundle.vkey"))
 	if err != nil {
 		return nil, err
 	}
-	batchVK, err := v.readVK(path.Join(cfg.AssetsPathHi, "vk_batch.vkey"))
+	batchVK, err := v.readVK(path.Join(cfg.HighVersionCircuit.AssetsPath, "vk_batch.vkey"))
 	if err != nil {
 		return nil, err
 	}
-	chunkVK, err := v.readVK(path.Join(cfg.AssetsPathHi, "vk_chunk.vkey"))
+	chunkVK, err := v.readVK(path.Join(cfg.HighVersionCircuit.AssetsPath, "vk_chunk.vkey"))
 	if err != nil {
 		return nil, err
 	}
-	v.BundleVkMap[cfg.ForkName] = bundleVK
-	v.BatchVKMap[cfg.ForkName] = batchVK
-	v.ChunkVKMap[cfg.ForkName] = chunkVK
+	v.BundleVkMap[bundleVK] = struct{}{}
+	v.BatchVKMap[batchVK] = struct{}{}
+	v.ChunkVKMap[chunkVK] = struct{}{}
 
-	if err := v.loadEmbedVK(); err != nil {
+	if err := v.loadLowVersionVKs(cfg); err != nil {
 		return nil, err
 	}
+
+	v.loadCurieVersionVKs()
 	return v, nil
 }
 
@@ -131,7 +164,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) (bool, error) {
+func (v *Verifier) VerifyBundleProof(proof *message.BundleProof, forkName string) (bool, error) {
 	if v.cfg.MockMode {
 		log.Info("Mock mode, verifier disabled")
 		if string(proof.Proof) == InvalidTestProof {
@@ -146,12 +179,14 @@ func (v *Verifier) VerifyBundleProof(proof *message.BundleProof) (bool, error) {
 	}
 
 	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)
+	verified := C.verify_bundle_proof(proofStr, forkNameStr)
 	return verified != 0, nil
 }
 
@@ -167,23 +202,27 @@ func (v *Verifier) readVK(filePat string) (string, error) {
 	return base64.StdEncoding.EncodeToString(byt), nil
 }
 
-//go:embed legacy_vk/*
-var legacyVKFS embed.FS
-
-func (v *Verifier) loadEmbedVK() error {
-	batchVKBytes, err := fs.ReadFile(legacyVKFS, "legacy_vk/agg_vk.vkey")
+// 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"))
 	if err != nil {
-		log.Error("load embed batch vk failure", "err", err)
 		return err
 	}
-
-	chunkVkBytes, err := fs.ReadFile(legacyVKFS, "legacy_vk/chunk_vk.vkey")
+	batchVK, err := v.readVK(path.Join(cfg.LowVersionCircuit.AssetsPath, "vk_batch.vkey"))
 	if err != nil {
-		log.Error("load embed chunk vk failure", "err", err)
 		return err
 	}
-
-	v.BatchVKMap["curie"] = base64.StdEncoding.EncodeToString(batchVKBytes)
-	v.ChunkVKMap["curie"] = base64.StdEncoding.EncodeToString(chunkVkBytes)
+	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{}{}
 	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", "/assets/test_assets_lo", "assets dir")
-	assetsPathHi    = flag.String("assets", "/assets/test_assets_hi", "assets dir")
+	assetsPathLo    = flag.String("assets_lo", "/assets/test_assets_lo", "assets dir")
+	assetsPathHi    = flag.String("assets", "/assets/test_assets", "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,29 +29,38 @@ func TestFFI(t *testing.T) {
 	as := assert.New(t)
 
 	cfg := &config.VerifierConfig{
-		MockMode:     false,
-		ParamsPath:   *paramsPath,
-		AssetsPathLo: *assetsPathLo,
-		AssetsPathHi: *assetsPathHi,
+		MockMode: false,
+		LowVersionCircuit: &config.CircuitConfig{
+			ParamsPath:       *paramsPath,
+			AssetsPath:       *assetsPathLo,
+			ForkName:         "darwin",
+			MinProverVersion: "",
+		},
+		HighVersionCircuit: &config.CircuitConfig{
+			ParamsPath:       *paramsPath,
+			AssetsPath:       *assetsPathHi,
+			ForkName:         "darwinV2",
+			MinProverVersion: "",
+		},
 	}
 
 	v, err := NewVerifier(cfg)
 	as.NoError(err)
 
 	chunkProof1 := readChunkProof(*chunkProofPath1, as)
-	chunkOk1, err := v.VerifyChunkProof(chunkProof1)
+	chunkOk1, err := v.VerifyChunkProof(chunkProof1, "darwinV2")
 	as.NoError(err)
 	as.True(chunkOk1)
 	t.Log("Verified chunk proof 1")
 
 	chunkProof2 := readChunkProof(*chunkProofPath2, as)
-	chunkOk2, err := v.VerifyChunkProof(chunkProof2)
+	chunkOk2, err := v.VerifyChunkProof(chunkProof2, "darwinV2")
 	as.NoError(err)
 	as.True(chunkOk2)
 	t.Log("Verified chunk proof 2")
 
 	batchProof := readBatchProof(*batchProofPath, as)
-	batchOk, err := v.VerifyBatchProof(batchProof, "curie")
+	batchOk, err := v.VerifyBatchProof(batchProof, "darwinV2")
 	as.NoError(err)
 	as.True(batchOk)
 	t.Log("Verified batch proof")

coordinator/internal/orm/batch.go

@@ -31,6 +31,9 @@ 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"`
@@ -225,6 +228,19 @@ 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) (*Chunk, error) {
+func (o *Chunk) GetUnassignedChunk(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8, height uint64) (*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 chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
-		int(types.ProvingTaskUnassigned), maxTotalAttempts, maxActiveAttempts)
+	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)
 	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) (*Chunk, error) {
+func (o *Chunk) GetAssignedChunk(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8, height uint64) (*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 chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
-		int(types.ProvingTaskAssigned), maxTotalAttempts, maxActiveAttempts)
+	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)
 	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,6 +87,55 @@ 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,25 +116,6 @@ 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,6 +18,8 @@ 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
@@ -35,6 +37,12 @@ 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"`
@@ -77,22 +85,6 @@ func (a *LoginParameter) Verify() (bool, error) {
 	return isValid, nil
 }
 
-// RecoverPublicKeyFromSignature get public key from signature.
-// This method is for pre-darwin's compatible.
-func (a *LoginParameter) RecoverPublicKeyFromSignature() (string, error) {
-	hash, err := a.Message.Hash()
-	if err != nil {
-		return "", err
-	}
-	sig := common.FromHex(a.Signature)
-	// recover public key
-	pk, err := crypto.SigToPub(hash, sig)
-	if err != nil {
-		return "", err
-	}
-	return common.Bytes2Hex(crypto.CompressPubkey(pk)), nil
-}
-
 // Hash returns the hash of the auth message, which should be the message used
 // to construct the Signature.
 func (i *Message) Hash() ([]byte, error) {

coordinator/internal/types/auth_test.go

@@ -60,11 +60,10 @@ func TestGenerateSignature(t *testing.T) {
 	authMsg := LoginParameter{
 		Message: Message{
 			ProverName:    "test",
-			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="},
+			ProverVersion: "v4.4.45-37af5ef5-38a68e2-1c5093c",
+			Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MjQ4Mzg0ODUsIm9yaWdfaWF0IjoxNzI0ODM0ODg1LCJyYW5kb20iOiJ6QmdNZGstNGc4UzNUNTFrVEFsYk1RTXg2TGJ4SUs4czY3ejM2SlNuSFlJPSJ9.x9PvihhNx2w4_OX5uCrv8QJCNYVQkIi-K2k8XFXYmik",
+			ProverTypes:   []ProverType{ProverTypeChunk},
+			VKs:           []string{"mock_vk"},
 		},
 		PublicKey: publicKeyHex,
 	}

coordinator/internal/types/get_task.go

@@ -3,7 +3,6 @@ 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,12 +33,6 @@ import (
 	"scroll-tech/coordinator/internal/route"
 )
 
-const (
-	forkNumberTwo    = 2
-	forkNumberOne    = 1
-	minProverVersion = "v2.0.0"
-)
-
 var (
 	conf *config.Config
 
@@ -72,7 +66,7 @@ func randomURL() string {
 	return fmt.Sprintf("localhost:%d", 10000+2000+id.Int64())
 }
 
-func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL string, nameForkMap map[string]int64) (*cron.Collector, *http.Server) {
+func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL string, forks []string) (*cron.Collector, *http.Server) {
 	var err error
 	db, err = testApps.GetGormDBClient()
 
@@ -90,13 +84,23 @@ 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,
@@ -105,20 +109,12 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 	}
 
 	var chainConf params.ChainConfig
-	for forkName, forkNumber := range nameForkMap {
+	for _, forkName := range forks {
 		switch forkName {
-		case "shanghai":
-			chainConf.ShanghaiBlock = big.NewInt(forkNumber)
 		case "bernoulli":
-			chainConf.BernoulliBlock = big.NewInt(forkNumber)
-		case "london":
-			chainConf.LondonBlock = big.NewInt(forkNumber)
-		case "istanbul":
-			chainConf.IstanbulBlock = big.NewInt(forkNumber)
+			chainConf.BernoulliBlock = big.NewInt(100)
 		case "homestead":
-			chainConf.HomesteadBlock = big.NewInt(forkNumber)
-		case "eip155":
-			chainConf.EIP155Block = big.NewInt(forkNumber)
+			chainConf.HomesteadBlock = big.NewInt(0)
 		}
 	}
 
@@ -201,7 +197,7 @@ func TestApis(t *testing.T) {
 func testHandshake(t *testing.T) {
 	// Setup coordinator and http server.
 	coordinatorURL := randomURL()
-	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL, map[string]int64{"homestead": forkNumberOne})
+	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL, []string{"homestead"})
 	defer func() {
 		proofCollector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -214,7 +210,7 @@ func testHandshake(t *testing.T) {
 func testFailedHandshake(t *testing.T) {
 	// Setup coordinator and http server.
 	coordinatorURL := randomURL()
-	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL, map[string]int64{"homestead": forkNumberOne})
+	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL, []string{"homestead"})
 	defer func() {
 		proofCollector.Stop()
 	}()
@@ -232,7 +228,7 @@ func testFailedHandshake(t *testing.T) {
 
 func testGetTaskBlocked(t *testing.T) {
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"homestead": forkNumberOne})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"homestead"})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -276,7 +272,7 @@ func testGetTaskBlocked(t *testing.T) {
 
 func testOutdatedProverVersion(t *testing.T) {
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"homestead": forkNumberOne})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"homestead"})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -288,12 +284,14 @@ 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", 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",
+		conf.ProverManager.Verifier.LowVersionCircuit.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", 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",
+		conf.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, batchProver.proverVersion)
 	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch)
 	assert.Equal(t, types.ErrJWTCommonErr, code)
 	assert.Equal(t, expectedErr, errors.New(errMsg))
@@ -301,7 +299,7 @@ func testOutdatedProverVersion(t *testing.T) {
 
 func testValidProof(t *testing.T) {
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"istanbul": forkNumberTwo})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"homestead"})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -384,7 +382,7 @@ func testValidProof(t *testing.T) {
 func testInvalidProof(t *testing.T) {
 	// Setup coordinator and ws server.
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"istanbul": forkNumberTwo})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"darwinV2"})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -472,7 +470,7 @@ func testInvalidProof(t *testing.T) {
 func testProofGeneratedFailed(t *testing.T) {
 	// Setup coordinator and ws server.
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"istanbul": forkNumberTwo})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"darwinV2"})
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -573,7 +571,7 @@ func testProofGeneratedFailed(t *testing.T) {
 func testTimeoutProof(t *testing.T) {
 	// Setup coordinator and ws server.
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 1, coordinatorURL, map[string]int64{"istanbul": forkNumberTwo})
+	collector, httpHandler := setupCoordinator(t, 1, coordinatorURL, []string{"darwinV2"})
 	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_type": int(proofType)}).
+		SetBody(map[string]interface{}{"prover_height": 100, "task_types": []int{int(proofType)}}).
 		SetResult(&result).
 		Post("http://" + r.coordinatorURL + "/coordinator/v1/get_task")
 	assert.NoError(t, err)

database/config.go

@@ -4,6 +4,8 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
+
+	"scroll-tech/common/utils"
 )
 
 // DBConfig db config
@@ -29,5 +31,11 @@ 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(22), cur)
+	assert.Equal(t, int64(24), cur)
 }
 
 func testMigrate(t *testing.T) {
 	assert.NoError(t, Migrate(pgDB))
 	cur, err := Current(pgDB)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(22), cur)
+	assert.Equal(t, int64(24), cur)
 }
 
 func testRollback(t *testing.T) {
 	version, err := Current(pgDB)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(22), version)
+	assert.Equal(t, int64(24), version)
 
 	assert.NoError(t, Rollback(pgDB, nil))
 

database/migrate/migrations/00023_add_codec_version_to_chunk_and_enable_encoding_to_chunk_and_batch.sql

@@ -0,0 +1,23 @@
+-- +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

@@ -0,0 +1,15 @@
+-- +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,44 +28,10 @@ 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.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "ark-std 0.3.0",
  "bitstream-io",
@@ -96,6 +62,40 @@ 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,37 +632,10 @@ 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.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -684,6 +657,31 @@ 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"
@@ -1311,8 +1309,8 @@ dependencies = [
 
 [[package]]
 name = "eth-types"
-version = "0.11.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "base64 0.13.1",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -1329,7 +1327,6 @@ dependencies = [
  "revm-primitives",
  "serde",
  "serde_json",
- "serde_stacker",
  "serde_with",
  "sha3 0.10.8",
  "strum 0.25.0",
@@ -1340,8 +1337,8 @@ dependencies = [
 
 [[package]]
 name = "eth-types"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+version = "0.13.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
 dependencies = [
  "base64 0.13.1",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -1560,11 +1557,11 @@ dependencies = [
 
 [[package]]
 name = "external-tracer"
-version = "0.11.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
- "eth-types 0.11.0",
- "geth-utils 0.11.0",
+ "eth-types 0.12.0",
+ "geth-utils 0.12.0",
  "log",
  "serde",
  "serde_json",
@@ -1573,11 +1570,11 @@ dependencies = [
 
 [[package]]
 name = "external-tracer"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+version = "0.13.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
 dependencies = [
- "eth-types 0.12.0",
- "geth-utils 0.12.0",
+ "eth-types 0.13.0",
+ "geth-utils 0.13.0",
  "log",
  "serde",
  "serde_json",
@@ -1790,10 +1787,10 @@ dependencies = [
 
 [[package]]
 name = "gadgets"
-version = "0.11.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
- "eth-types 0.11.0",
+ "eth-types 0.12.0",
  "halo2_proofs",
  "poseidon-base",
  "sha3 0.10.8",
@@ -1802,10 +1799,10 @@ dependencies = [
 
 [[package]]
 name = "gadgets"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+version = "0.13.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
 dependencies = [
- "eth-types 0.12.0",
+ "eth-types 0.13.0",
  "halo2_proofs",
  "poseidon-base",
  "sha3 0.10.8",
@@ -1825,8 +1822,8 @@ dependencies = [
 
 [[package]]
 name = "geth-utils"
-version = "0.11.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
+version = "0.12.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "env_logger 0.10.2",
  "gobuild",
@@ -1835,8 +1832,8 @@ dependencies = [
 
 [[package]]
 name = "geth-utils"
-version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+version = "0.13.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
 dependencies = [
  "env_logger 0.10.2",
  "gobuild",
@@ -2673,25 +2670,10 @@ 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.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -2704,23 +2686,24 @@ dependencies = [
 ]
 
 [[package]]
-name = "mpt-zktrie"
-version = "0.11.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.11.5#6ea8fb3fad4d8a8bfe873e18e2f881ad1c807ded"
+name = "mock"
+version = "0.13.0"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.13.1#4009e5593f13ba73f64f556011ee5ef47bc4ebf3"
 dependencies = [
- "eth-types 0.11.0",
- "halo2curves",
- "hex",
+ "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",
  "log",
- "num-bigint",
- "poseidon-base",
- "zktrie",
+ "rand",
+ "rand_chacha",
 ]
 
 [[package]]
 name = "mpt-zktrie"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "eth-types 0.12.0",
  "halo2curves",
@@ -2728,7 +2711,21 @@ dependencies = [
  "log",
  "num-bigint",
  "poseidon-base",
- "zktrie",
+ "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)",
 ]
 
 [[package]]
@@ -3294,8 +3291,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",
@@ -3309,44 +3306,10 @@ 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.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "aggregator 0.12.0",
  "anyhow",
@@ -3377,6 +3340,40 @@ 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"
@@ -5338,52 +5335,10 @@ 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.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.2#6f7b46a3b1ccf9dc448735e8455e1ac6f9e30643"
 dependencies = [
  "array-init",
  "bus-mapping 0.12.0",
@@ -5422,13 +5377,64 @@ 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",
+ "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)",
 ]
 
 [[package]]
@@ -5445,6 +5451,20 @@ 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_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"] }
+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"] }
 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",
-    "proof_type": 2,
+    "prover_type": 2,
     "low_version_circuit": {
         "hard_fork_name": "bernoulli",
         "params_path": "params",

prover/src/coordinator_client.rs

@@ -14,6 +14,8 @@ 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,4 +1,6 @@
-use super::types::*;
+use crate::{coordinator_client::ProofStatusNotOKError, types::ProofStatus};
+
+use super::{errors::*, types::*};
 use anyhow::{bail, Result};
 use core::time::Duration;
 use reqwest::{header::CONTENT_TYPE, Url};
@@ -76,7 +78,23 @@ impl Api {
         token: &String,
     ) -> Result<Response<SubmitProofResponseData>> {
         let method = "/coordinator/v1/submit_proof";
-        self.post_with_token(method, req, token).await
+        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)
     }
 
     async fn post_with_token<Req, Resp>(

prover/src/coordinator_client/errors.rs

@@ -1,4 +1,5 @@
 use serde::{Deserialize, Deserializer};
+use std::fmt;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ErrorCode {
@@ -51,3 +52,14 @@ 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,4 +1,5 @@
 #![feature(lazy_cell)]
+#![feature(core_intrinsics)]
 
 mod config;
 mod coordinator_client;
@@ -37,7 +38,7 @@ struct Args {
     log_file: Option<String>,
 }
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn start() -> Result<()> {
     let args = Args::parse();
 
     if args.version {
@@ -76,3 +77,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     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::{prover::Prover, task_cache::TaskCache};
+use super::{coordinator_client::ProofStatusNotOKError, prover::Prover, task_cache::TaskCache};
 use anyhow::{Context, Result};
 use std::rc::Rc;
 
@@ -16,7 +16,11 @@ impl<'a> TaskProcessor<'a> {
         loop {
             log::info!("start a new round.");
             if let Err(err) = self.prove_and_submit() {
-                log::error!("encounter error: {:#}", err);
+                if err.is::<ProofStatusNotOKError>() {
+                    log::info!("proof status not ok, downgrade level to info.");
+                } else {
+                    log::error!("encounter error: {:#}", err);
+                }
             } else {
                 log::info!("prove & submit succeed.");
             }
@@ -54,11 +58,18 @@ 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) => self.prover.submit_error(
-                    &task_wrapper.task,
-                    super::types::ProofFailureType::NoPanic,
-                    error,
-                ),
+                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,
+                    )
+                }
             };
             return result;
         }

prover/src/types.rs

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

prover/src/zk_circuits_handler.rs

@@ -1,5 +1,6 @@
-mod curie;
+mod common;
 mod darwin;
+mod darwin_v2;
 
 use super::geth_client::GethClient;
 use crate::{
@@ -8,8 +9,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;
@@ -38,7 +39,7 @@ pub struct CircuitsHandlerProvider<'a> {
     geth_client: Option<Rc<RefCell<GethClient>>>,
     circuits_handler_builder_map: HashMap<HardForkName, CircuitsHandlerBuilder>,
 
-    current_hard_fork_name: Option<HardForkName>,
+    current_fork_name: Option<HardForkName>,
     current_circuit: Option<Rc<Box<dyn CircuitsHandler>>>,
 }
 
@@ -60,7 +61,7 @@ impl<'a> CircuitsHandlerProvider<'a> {
                 &config.low_version_circuit.hard_fork_name
             );
             AssetsDirEnvConfig::enable_first();
-            CurieHandler::new(
+            DarwinHandler::new(
                 prover_type,
                 &config.low_version_circuit.params_path,
                 &config.low_version_circuit.assets_path,
@@ -83,7 +84,7 @@ impl<'a> CircuitsHandlerProvider<'a> {
                 &config.high_version_circuit.hard_fork_name
             );
             AssetsDirEnvConfig::enable_second();
-            DarwinHandler::new(
+            DarwinV2Handler::new(
                 prover_type,
                 &config.high_version_circuit.params_path,
                 &config.high_version_circuit.assets_path,
@@ -102,7 +103,7 @@ impl<'a> CircuitsHandlerProvider<'a> {
             config,
             geth_client,
             circuits_handler_builder_map: m,
-            current_hard_fork_name: None,
+            current_fork_name: None,
             current_circuit: None,
         };
 
@@ -113,13 +114,12 @@ impl<'a> CircuitsHandlerProvider<'a> {
         &mut self,
         hard_fork_name: &String,
     ) -> Result<Rc<Box<dyn CircuitsHandler>>> {
-        match &self.current_hard_fork_name {
-            Some(name) if name == hard_fork_name => {
+        match &self.current_fork_name {
+            Some(fork_name) if fork_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,12 +131,11 @@ 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_hard_fork_name = Some(hard_fork_name.clone());
+                    self.current_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

@@ -0,0 +1,33 @@
+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/darwin.rs

@@ -1,4 +1,4 @@
-use super::CircuitsHandler;
+use super::{common::*, CircuitsHandler};
 use crate::{
     geth_client::GethClient,
     types::{ProverType, TaskType},
@@ -11,7 +11,11 @@ use crate::types::{CommonHash, Task};
 use std::{cell::RefCell, cmp::Ordering, env, rc::Rc};
 
 use prover_darwin::{
-    aggregator::Prover as BatchProver, check_chunk_hashes, zkevm::Prover as ChunkProver,
+    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,
 };
@@ -39,32 +43,65 @@ fn get_block_number(block_trace: &BlockTrace) -> Option<u64> {
 
 #[derive(Default)]
 pub struct DarwinHandler {
-    chunk_prover: Option<RefCell<ChunkProver>>,
-    batch_prover: Option<RefCell<BatchProver>>,
+    chunk_prover: Option<RefCell<ChunkProver<'static>>>,
+    batch_prover: Option<RefCell<BatchProver<'static>>>,
 
     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> {
-        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,
-            }),
-        }
+        Self::new_multi(vec![prover_type], params_dir, assets_dir, geth_client)
     }
 
     fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
@@ -253,7 +290,7 @@ mod tests {
 
     static DEFAULT_WORK_DIR: &str = "/assets";
     static WORK_DIR: LazyLock<String> = LazyLock::new(|| {
-        std::env::var("CURIE_TEST_DIR")
+        std::env::var("DARWIN_TEST_DIR")
             .unwrap_or(String::from(DEFAULT_WORK_DIR))
             .trim_end_matches('/')
             .to_string()
@@ -265,9 +302,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/agg_vk.vkey", *WORK_DIR));
+        LazyLock::new(|| format!("{}/test_assets/vk_batch.vkey", *WORK_DIR));
     static CHUNK_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/chunk_vk.vkey", *WORK_DIR));
+        LazyLock::new(|| format!("{}/test_assets/vk_chunk.vkey", *WORK_DIR));
 
     #[test]
     fn it_works() {
@@ -277,9 +314,14 @@ mod tests {
 
     #[test]
     fn test_circuits() -> Result<()> {
-        let chunk_handler =
-            DarwinHandler::new(ProverType::Chunk, &PARAMS_PATH, &ASSETS_PATH, None)?;
+        let bi_handler = DarwinHandler::new_multi(
+            vec![ProverType::Chunk, ProverType::Batch],
+            &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");
@@ -302,8 +344,7 @@ mod tests {
             chunk_proofs.push(chunk_proof);
         }
 
-        let batch_handler =
-            DarwinHandler::new(ProverType::Batch, &PARAMS_PATH, &ASSETS_PATH, None)?;
+        let batch_handler = chunk_handler;
         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);

prover/src/zk_circuits_handler/darwin_v2.rs

@@ -1,4 +1,4 @@
-use super::CircuitsHandler;
+use super::{common::*, CircuitsHandler};
 use crate::{
     geth_client::GethClient,
     types::{ProverType, TaskType},
@@ -10,21 +10,29 @@ use serde::Deserialize;
 use crate::types::{CommonHash, Task};
 use std::{cell::RefCell, cmp::Ordering, env, rc::Rc};
 
-use prover_curie::{
-    aggregator::Prover as BatchProver, check_chunk_hashes, zkevm::Prover as ChunkProver,
-    BatchProof, BatchProvingTask, BlockTrace, ChunkInfo, ChunkProof, ChunkProvingTask,
+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,
 };
 
 // Only used for debugging.
 static OUTPUT_DIR: Lazy<Option<String>> = Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
 
-#[derive(Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct BatchTaskDetail {
     pub chunk_infos: Vec<ChunkInfo>,
-    pub chunk_proofs: Vec<ChunkProof>,
+    #[serde(flatten)]
+    pub batch_proving_task: BatchProvingTask,
 }
 
-#[derive(Deserialize)]
+type BundleTaskDetail = BundleProvingTask;
+
+#[derive(Debug, Clone, Deserialize)]
 pub struct ChunkTaskDetail {
     pub block_hashes: Vec<CommonHash>,
 }
@@ -34,33 +42,66 @@ fn get_block_number(block_trace: &BlockTrace) -> Option<u64> {
 }
 
 #[derive(Default)]
-pub struct CurieHandler {
-    chunk_prover: Option<RefCell<ChunkProver>>,
-    batch_prover: Option<RefCell<BatchProver>>,
+pub struct DarwinV2Handler {
+    chunk_prover: Option<RefCell<ChunkProver<'static>>>,
+    batch_prover: Option<RefCell<BatchProver<'static>>>,
 
     geth_client: Option<Rc<RefCell<GethClient>>>,
 }
 
-impl CurieHandler {
+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)
+    }
+
     pub fn new(
         prover_type: ProverType,
         params_dir: &str,
         assets_dir: &str,
         geth_client: Option<Rc<RefCell<GethClient>>>,
     ) -> Result<Self> {
-        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,
-            }),
-        }
+        Self::new_multi(vec![prover_type], params_dir, assets_dir, geth_client)
     }
 
     fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
@@ -83,11 +124,15 @@ impl CurieHandler {
         Ok(serde_json::to_string(&chunk_proof)?)
     }
 
-    fn gen_batch_proof_raw(
-        &self,
-        chunk_hashes_proofs: Vec<(ChunkInfo, ChunkProof)>,
-    ) -> Result<BatchProof> {
+    fn gen_batch_proof_raw(&self, batch_task_detail: BatchTaskDetail) -> 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();
 
@@ -97,11 +142,11 @@ impl CurieHandler {
                 bail!("non-match chunk protocol")
             }
             check_chunk_hashes("", &chunk_hashes_proofs).context("failed to check chunk info")?;
-            let batch = BatchProvingTask { chunk_proofs };
-            let batch_proof =
-                prover
-                    .borrow_mut()
-                    .gen_agg_evm_proof(batch, None, self.get_output_dir())?;
+            let batch_proof = prover.borrow_mut().gen_batch_proof(
+                batch_task_detail.batch_proving_task,
+                None,
+                self.get_output_dir(),
+            )?;
 
             return Ok(batch_proof);
         }
@@ -110,12 +155,32 @@ impl CurieHandler {
 
     fn gen_batch_proof(&self, task: &crate::types::Task) -> Result<String> {
         log::info!("[circuit] gen_batch_proof for task {}", task.id);
-        let chunk_hashes_proofs: Vec<(ChunkInfo, ChunkProof)> =
-            self.gen_chunk_hashes_proofs(task)?;
-        let batch_proof = self.gen_batch_proof_raw(chunk_hashes_proofs)?;
+
+        let batch_task_detail: BatchTaskDetail = serde_json::from_str(&task.task_data)?;
+        let batch_proof = self.gen_batch_proof_raw(batch_task_detail)?;
         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()
     }
@@ -125,17 +190,6 @@ impl CurieHandler {
         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");
@@ -190,7 +244,7 @@ impl CurieHandler {
     }
 }
 
-impl CircuitsHandler for CurieHandler {
+impl CircuitsHandler for DarwinV2Handler {
     fn get_vk(&self, task_type: TaskType) -> Option<Vec<u8>> {
         match task_type {
             TaskType::Chunk => self
@@ -200,8 +254,11 @@ impl CircuitsHandler for CurieHandler {
             TaskType::Batch => self
                 .batch_prover
                 .as_ref()
-                .and_then(|prover| prover.borrow().get_vk()),
-            TaskType::Bundle => None,
+                .and_then(|prover| prover.borrow().get_batch_vk()),
+            TaskType::Bundle => self
+                .batch_prover
+                .as_ref()
+                .and_then(|prover| prover.borrow().get_bundle_vk()),
             _ => unreachable!(),
         }
     }
@@ -210,6 +267,7 @@ impl CircuitsHandler for CurieHandler {
         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!(),
         }
     }
@@ -221,7 +279,11 @@ impl CircuitsHandler for CurieHandler {
 mod tests {
     use super::*;
     use crate::zk_circuits_handler::utils::encode_vk;
-    use prover_curie::utils::chunk_trace_to_witness_block;
+    use ethers_core::types::H256;
+    use prover_darwin_v2::{
+        aggregator::eip4844, utils::chunk_trace_to_witness_block, BatchData, BatchHeader,
+        MAX_AGG_SNARKS,
+    };
     use std::{path::PathBuf, sync::LazyLock};
 
     #[ctor::ctor]
@@ -232,7 +294,7 @@ mod tests {
 
     static DEFAULT_WORK_DIR: &str = "/assets";
     static WORK_DIR: LazyLock<String> = LazyLock::new(|| {
-        std::env::var("CURIE_TEST_DIR")
+        std::env::var("DARWIN_V2_TEST_DIR")
             .unwrap_or(String::from(DEFAULT_WORK_DIR))
             .trim_end_matches('/')
             .to_string()
@@ -244,9 +306,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/agg_vk.vkey", *WORK_DIR));
+        LazyLock::new(|| format!("{}/test_assets/vk_batch.vkey", *WORK_DIR));
     static CHUNK_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/chunk_vk.vkey", *WORK_DIR));
+        LazyLock::new(|| format!("{}/test_assets/vk_chunk.vkey", *WORK_DIR));
 
     #[test]
     fn it_works() {
@@ -256,20 +318,27 @@ mod tests {
 
     #[test]
     fn test_circuits() -> Result<()> {
-        let chunk_handler = CurieHandler::new(ProverType::Chunk, &PARAMS_PATH, &ASSETS_PATH, None)?;
+        let bi_handler = DarwinV2Handler::new_multi(
+            vec![ProverType::Chunk, ProverType::Batch],
+            &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);
 
@@ -280,30 +349,96 @@ mod tests {
             chunk_proofs.push(chunk_proof);
         }
 
-        let batch_handler = CurieHandler::new(ProverType::Batch, &PARAMS_PATH, &ASSETS_PATH, None)?;
+        let batch_handler = chunk_handler;
         let batch_vk = batch_handler.get_vk(TaskType::Batch).unwrap();
         check_vk(TaskType::Batch, batch_vk, "batch vk must be available");
-        let chunk_hashes_proofs = chunk_infos.into_iter().zip(chunk_proofs).collect();
+        let batch_task_detail = make_batch_task_detail(chunk_traces, chunk_proofs, None);
         log::info!("start to prove batch");
-        let batch_proof = batch_handler.gen_batch_proof_raw(chunk_hashes_proofs)?;
+        let batch_proof = batch_handler.gen_batch_proof_raw(batch_task_detail)?;
         let proof_data = serde_json::to_string(&batch_proof)?;
         dump_proof("batch_proof".to_string(), proof_data)?;
 
         Ok(())
     }
 
-    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();
+    // 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();
         assert_eq!(vk_from_file, encode_vk(vk), "{info}")
     }
 
-    fn read_vk(task_type: TaskType) -> Result<String> {
-        log::info!("read_vk, {:?}", task_type);
-        let vk_file = match task_type {
+    fn read_vk(proof_type: TaskType) -> Result<String> {
+        log::info!("read_vk, {:?}", proof_type);
+        let vk_file = match proof_type {
             TaskType::Chunk => CHUNK_VK_PATH.clone(),
             TaskType::Batch => BATCH_VK_PATH.clone(),
-            TaskType::Bundle => unreachable!(),
+            TaskType::Bundle => todo!(),
             TaskType::Undefined => unreachable!(),
         };
 

rollup/conf/config.json

@@ -19,7 +19,10 @@
         "min_gas_price": 0,
         "gas_price_diff": 50000,
         "l1_base_fee_weight": 0.132,
-        "l1_blob_base_fee_weight":  0.145
+        "l1_blob_base_fee_weight":  0.145,
+        "check_committed_batches_window_minutes": 5,
+        "l1_base_fee_default": 15000000000,
+        "l1_blob_base_fee_default": 1
       },
       "gas_oracle_sender_private_key": "1313131313131313131313131313131313131313131313131313131313131313"
     }

rollup/go.mod

@@ -9,10 +9,12 @@ 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.0.0-20240730031611-1b736159d5cb
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
+	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/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
@@ -29,12 +31,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.1 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // 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.6.0 // indirect
+	github.com/fsnotify/fsnotify v1.7.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
@@ -53,6 +55,7 @@ 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
@@ -63,11 +66,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
@@ -75,9 +78,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.1.0 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // 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
@@ -86,10 +89,17 @@ 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
@@ -99,14 +109,18 @@ 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/net v0.21.0 // indirect
+	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
+	golang.org/x/net v0.23.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.3.0 // indirect
-	google.golang.org/protobuf v1.31.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
 	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,8 +47,9 @@ 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=
@@ -58,10 +59,12 @@ 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.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
-github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
+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/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=
@@ -128,6 +131,8 @@ 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=
@@ -163,6 +168,8 @@ 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=
@@ -204,13 +211,14 @@ 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.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4=
-github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
+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/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=
@@ -236,10 +244,14 @@ 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/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/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/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=
@@ -250,12 +262,23 @@ 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=
@@ -267,6 +290,8 @@ 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=
@@ -288,6 +313,10 @@ 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=
@@ -297,6 +326,8 @@ 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=
@@ -306,8 +337,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.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
-golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs=
+golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
 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=
@@ -332,7 +363,6 @@ 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=
@@ -345,8 +375,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.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
-golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+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/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=
@@ -363,13 +393,15 @@ 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.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
-google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 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,11 +1,15 @@
 package config
 
 import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-
+	"fmt"
+	"reflect"
 	"scroll-tech/common/database"
+	"strings"
+
+	"github.com/mitchellh/mapstructure"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/rpc"
+	"github.com/spf13/viper"
 )
 
 // Config load configuration items.
@@ -17,16 +21,68 @@ type Config struct {
 
 // NewConfig returns a new instance of Config.
 func NewConfig(file string) (*Config, error) {
-	buf, err := os.ReadFile(filepath.Clean(file))
-	if err != nil {
+	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{}
-	err = json.Unmarshal(buf, cfg)
+
+	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)
 	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 {
+		return nil, err
+	}
+
 	return cfg, nil
 }

rollup/internal/config/config_test.go

@@ -55,4 +55,30 @@ 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_PRIVATE_KEY", "1616161616161616161616161616161616161616161616161616161616161616")
+		os.Setenv("SCROLL_ROLLUP_L2_CONFIG_RELAYER_CONFIG_GAS_ORACLE_SENDER_PRIVATE_KEY", "1717171717171717171717171717171717171717171717171717171717171717")
+		os.Setenv("SCROLL_ROLLUP_L2_CONFIG_RELAYER_CONFIG_COMMIT_SENDER_PRIVATE_KEY", "1818181818181818181818181818181818181818181818181818181818181818")
+		os.Setenv("SCROLL_ROLLUP_L2_CONFIG_RELAYER_CONFIG_FINALIZE_SENDER_PRIVATE_KEY", "1919191919191919191919191919191919191919191919191919191919191919")
+
+		cfg2, err := NewConfig("../../conf/config.json")
+		assert.NoError(t, err)
+
+		assert.NotEqual(t, cfg.DBConfig.DSN, cfg2.DBConfig.DSN)
+		assert.NotEqual(t, cfg.L1Config.RelayerConfig.GasOracleSenderPrivateKey, cfg2.L1Config.RelayerConfig.GasOracleSenderPrivateKey)
+		assert.NotEqual(t, cfg.L2Config.RelayerConfig.GasOracleSenderPrivateKey, cfg2.L2Config.RelayerConfig.GasOracleSenderPrivateKey)
+		assert.NotEqual(t, cfg.L2Config.RelayerConfig.CommitSenderPrivateKey, cfg2.L2Config.RelayerConfig.CommitSenderPrivateKey)
+		assert.NotEqual(t, cfg.L2Config.RelayerConfig.FinalizeSenderPrivateKey, cfg2.L2Config.RelayerConfig.FinalizeSenderPrivateKey)
+
+		assert.Equal(t, cfg2.DBConfig.DSN, "postgres://test:test@postgresql:5432/scroll?sslmode=disable")
+		assert.Equal(t, "1616161616161616161616161616161616161616161616161616161616161616", cfg2.L1Config.RelayerConfig.GasOracleSenderPrivateKey)
+		assert.Equal(t, "1717171717171717171717171717171717171717171717171717171717171717", cfg2.L2Config.RelayerConfig.GasOracleSenderPrivateKey)
+		assert.Equal(t, "1818181818181818181818181818181818181818181818181818181818181818", cfg2.L2Config.RelayerConfig.CommitSenderPrivateKey)
+		assert.Equal(t, "1919191919191919191919191919191919191919191919191919191919191919", cfg2.L2Config.RelayerConfig.FinalizeSenderPrivateKey)
+	})
 }

rollup/internal/config/relayer.go

@@ -1,12 +1,7 @@
 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"
 )
 
@@ -60,9 +55,9 @@ type RelayerConfig struct {
 	// L1CommitGasLimitMultiplier multiplier for fallback gas limit in commitBatch txs
 	L1CommitGasLimitMultiplier float64 `json:"l1_commit_gas_limit_multiplier,omitempty"`
 	// The private key of the relayer
-	GasOracleSenderPrivateKey *ecdsa.PrivateKey `json:"-"`
-	CommitSenderPrivateKey    *ecdsa.PrivateKey `json:"-"`
-	FinalizeSenderPrivateKey  *ecdsa.PrivateKey `json:"-"`
+	GasOracleSenderPrivateKey string `json:"gas_oracle_sender_private_key"`
+	CommitSenderPrivateKey    string `json:"commit_sender_private_key"`
+	FinalizeSenderPrivateKey  string `json:"finalize_sender_private_key"`
 
 	// Indicates if bypass features specific to testing environments are enabled.
 	EnableTestEnvBypassFeatures bool `json:"enable_test_env_bypass_features"`
@@ -84,79 +79,8 @@ type GasOracleConfig struct {
 	L1BaseFeeWeight float64 `json:"l1_base_fee_weight"`
 	// The weight for L1 blob base fee.
 	L1BlobBaseFeeWeight float64 `json:"l1_blob_base_fee_weight"`
-}
-
-// 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
-}
-
-// 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
-}
-
-// 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)
+	// 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"`
 }

rollup/internal/controller/relayer/l1_relayer.go

@@ -6,15 +6,18 @@ 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/common"
 	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
 	"scroll-tech/common/types"
+	"scroll-tech/common/utils"
 
 	bridgeAbi "scroll-tech/rollup/abi"
 	"scroll-tech/rollup/internal/config"
@@ -43,6 +46,7 @@ type Layer1Relayer struct {
 
 	l1BlockOrm *orm.L1Block
 	l2BlockOrm *orm.L2Block
+	batchOrm   *orm.Batch
 
 	metrics *l1RelayerMetrics
 }
@@ -50,13 +54,17 @@ type Layer1Relayer struct {
 // NewLayer1Relayer will return a new instance of Layer1RelayerClient
 func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfig, chainCfg *params.ChainConfig, serviceType ServiceType, reg prometheus.Registerer) (*Layer1Relayer, error) {
 	var gasOracleSender *sender.Sender
-	var err error
 
 	switch serviceType {
 	case ServiceTypeL1GasOracle:
-		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderPrivateKey, "l1_relayer", "gas_oracle_sender", types.SenderTypeL1GasOracle, db, reg)
+		pKey, err := crypto.ToECDSA(common.FromHex(cfg.GasOracleSenderPrivateKey))
 		if err != nil {
-			addr := crypto.PubkeyToAddress(cfg.GasOracleSenderPrivateKey.PublicKey)
+			return nil, fmt.Errorf("new gas oracle sender failed, err: %v", err)
+		}
+
+		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, pKey, "l1_relayer", "gas_oracle_sender", types.SenderTypeL1GasOracle, db, reg)
+		if err != nil {
+			addr := crypto.PubkeyToAddress(pKey.PublicKey)
 			return nil, fmt.Errorf("new gas oracle sender failed for address %s, err: %v", addr.Hex(), err)
 		}
 
@@ -84,6 +92,7 @@ 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,
@@ -150,6 +159,19 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 		}
 
 		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
+			}
 			var data []byte
 			if isCurie {
 				data, err = r.l1GasOracleABI.Pack("setL1BaseFeeAndBlobBaseFee", new(big.Int).SetUint64(baseFee), new(big.Int).SetUint64(blobBaseFee))
@@ -260,3 +282,19 @@ 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

@@ -2,6 +2,7 @@ package relayer
 
 import (
 	"context"
+	"crypto/ecdsa"
 	"errors"
 	"fmt"
 	"math/big"
@@ -16,6 +17,7 @@ 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"
@@ -74,14 +76,17 @@ 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
+	gasOracleSenderPrivateKey, commitSenderPrivateKey, finalizeSenderPrivateKey, err := parsePrivateKeys(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse private keys provided by config, err: %v", err)
+	}
 
+	var gasOracleSender, commitSender, finalizeSender *sender.Sender
 	switch serviceType {
 	case ServiceTypeL2GasOracle:
-		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderPrivateKey, "l2_relayer", "gas_oracle_sender", types.SenderTypeL2GasOracle, db, reg)
+		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, gasOracleSenderPrivateKey, "l2_relayer", "gas_oracle_sender", types.SenderTypeL2GasOracle, db, reg)
 		if err != nil {
-			addr := crypto.PubkeyToAddress(cfg.GasOracleSenderPrivateKey.PublicKey)
+			addr := crypto.PubkeyToAddress(gasOracleSenderPrivateKey.PublicKey)
 			return nil, fmt.Errorf("new gas oracle sender failed for address %s, err: %w", addr.Hex(), err)
 		}
 
@@ -91,15 +96,15 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		}
 
 	case ServiceTypeL2RollupRelayer:
-		commitSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.CommitSenderPrivateKey, "l2_relayer", "commit_sender", types.SenderTypeCommitBatch, db, reg)
+		commitSender, err = sender.NewSender(ctx, cfg.SenderConfig, commitSenderPrivateKey, "l2_relayer", "commit_sender", types.SenderTypeCommitBatch, db, reg)
 		if err != nil {
-			addr := crypto.PubkeyToAddress(cfg.CommitSenderPrivateKey.PublicKey)
+			addr := crypto.PubkeyToAddress(commitSenderPrivateKey.PublicKey)
 			return nil, fmt.Errorf("new commit sender failed for address %s, err: %w", addr.Hex(), err)
 		}
 
-		finalizeSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.FinalizeSenderPrivateKey, "l2_relayer", "finalize_sender", types.SenderTypeFinalizeBatch, db, reg)
+		finalizeSender, err = sender.NewSender(ctx, cfg.SenderConfig, finalizeSenderPrivateKey, "l2_relayer", "finalize_sender", types.SenderTypeFinalizeBatch, db, reg)
 		if err != nil {
-			addr := crypto.PubkeyToAddress(cfg.FinalizeSenderPrivateKey.PublicKey)
+			addr := crypto.PubkeyToAddress(finalizeSenderPrivateKey.PublicKey)
 			return nil, fmt.Errorf("new finalize sender failed for address %s, err: %w", addr.Hex(), err)
 		}
 
@@ -200,7 +205,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, encoding.CodecV0, rutils.ChunkMetrics{}, dbTX)
+		dbChunk, err = r.chunkOrm.InsertChunk(r.ctx, chunk, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.ChunkMetrics{}, dbTX)
 		if err != nil {
 			return fmt.Errorf("failed to insert chunk: %v", err)
 		}
@@ -217,7 +222,7 @@ func (r *Layer2Relayer) initializeGenesis() error {
 		}
 
 		var dbBatch *orm.Batch
-		dbBatch, err = r.batchOrm.InsertBatch(r.ctx, batch, encoding.CodecV0, rutils.BatchMetrics{}, dbTX)
+		dbBatch, err = r.batchOrm.InsertBatch(r.ctx, batch, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.BatchMetrics{}, dbTX)
 		if err != nil {
 			return fmt.Errorf("failed to insert batch: %v", err)
 		}
@@ -378,28 +383,34 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 
 		var calldata []byte
 		var blob *kzg4844.Blob
-		if !r.chainCfg.IsBernoulli(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) { // codecv0
+		if encoding.CodecVersion(dbBatch.CodecVersion) == encoding.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 !r.chainCfg.IsCurie(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) { // codecv1
+		} else if encoding.CodecVersion(dbBatch.CodecVersion) == encoding.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 !r.chainCfg.IsDarwin(dbChunks[0].StartBlockTime) { // codecv2
+		} else if encoding.CodecVersion(dbBatch.CodecVersion) == encoding.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 { // codecv3
+		} else if encoding.CodecVersion(dbBatch.CodecVersion) == encoding.CodecV3 {
 			calldata, blob, err = r.constructCommitBatchPayloadCodecV3(dbBatch, dbParentBatch, dbChunks, chunks)
 			if err != nil {
-				log.Error("failed to construct commitBatch payload codecv3", "index", dbBatch.Index, "err", err)
+				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)
 				return
 			}
 		}
@@ -439,6 +450,18 @@ 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())
 	}
@@ -480,7 +503,6 @@ 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)
@@ -531,7 +553,7 @@ func (r *Layer2Relayer) ProcessPendingBundles() {
 		}
 
 	case types.ProvingTaskVerified:
-		log.Info("Start to roll up zk proof", "hash", bundle.Hash)
+		log.Info("Start to roll up zk proof", "bundle 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)
@@ -598,11 +620,15 @@ 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)
@@ -617,6 +643,8 @@ 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)
@@ -719,7 +747,7 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 		}
 	}
 
-	calldata, err := r.constructFinalizeBundlePayloadCodecV3(dbBatch, aggProof)
+	calldata, err := r.constructFinalizeBundlePayloadCodecV3AndV4(dbBatch, aggProof)
 	if err != nil {
 		return fmt.Errorf("failed to construct finalizeBundle payload codecv3, index: %v, err: %w", dbBatch.Index, err)
 	}
@@ -1048,6 +1076,45 @@ 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(
@@ -1176,7 +1243,7 @@ func (r *Layer2Relayer) constructFinalizeBatchPayloadCodecV2(dbBatch *orm.Batch,
 	return calldata, nil
 }
 
-func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV3(dbBatch *orm.Batch, aggProof *message.BundleProof) ([]byte, error) {
+func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV3AndV4(dbBatch *orm.Batch, aggProof *message.BundleProof) ([]byte, error) {
 	if aggProof != nil { // finalizeBundle with proof.
 		calldata, packErr := r.l1RollupABI.Pack(
 			"finalizeBundleWithProof",
@@ -1219,3 +1286,36 @@ func (r *Layer2Relayer) StopSenders() {
 		r.finalizeSender.Stop()
 	}
 }
+
+func parsePrivateKeys(cfg *config.RelayerConfig) (*ecdsa.PrivateKey, *ecdsa.PrivateKey, *ecdsa.PrivateKey, error) {
+	parseKey := func(hexKey string) (*ecdsa.PrivateKey, error) {
+		return crypto.ToECDSA(common.FromHex(hexKey))
+	}
+
+	gasOracleKey, err := parseKey(cfg.GasOracleSenderPrivateKey)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("parse gas oracle sender private key failed: %w", err)
+	}
+
+	commitKey, err := parseKey(cfg.CommitSenderPrivateKey)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("parse commit sender private key failed: %w", err)
+	}
+
+	finalizeKey, err := parseKey(cfg.FinalizeSenderPrivateKey)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("parse finalize sender private key failed: %w", err)
+	}
+
+	// Check if all three private keys are different
+	addrGasOracle := crypto.PubkeyToAddress(gasOracleKey.PublicKey)
+	addrCommit := crypto.PubkeyToAddress(commitKey.PublicKey)
+	addrFinalize := crypto.PubkeyToAddress(finalizeKey.PublicKey)
+
+	if addrGasOracle == addrCommit || addrGasOracle == addrFinalize || addrCommit == addrFinalize {
+		return nil, nil, nil, fmt.Errorf("gas oracle, commit, and finalize sender addresses must be different. Got: Gas Oracle=%s, Commit=%s, Finalize=%s",
+			addrGasOracle.Hex(), addrCommit.Hex(), addrFinalize.Hex())
+	}
+
+	return gasOracleKey, commitKey, finalizeKey, nil
+}

rollup/internal/controller/relayer/l2_relayer_metrics.go

@@ -29,6 +29,9 @@ type l2RelayerMetrics struct {
 	rollupL2RelayerProcessPendingBundlesFinalizedSuccessTotal       prometheus.Counter
 	rollupL2BundlesFinalizedConfirmedTotal                          prometheus.Counter
 	rollupL2BundlesFinalizedConfirmedFailedTotal                    prometheus.Counter
+
+	rollupL2RelayerCommitBlockHeight prometheus.Gauge
+	rollupL2RelayerCommitThroughput  prometheus.Counter
 }
 
 var (
@@ -123,6 +126,14 @@ 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, codecVersion, rutils.ChunkMetrics{})
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk1, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
-		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, rutils.CodecConfig{Version: 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, codecVersion, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: 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, codecVersion, rutils.ChunkMetrics{})
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk1, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
-		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, rutils.CodecConfig{Version: 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, codecVersion, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: 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, codecVersion, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: 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, codecVersion, rutils.ChunkMetrics{})
+		chunkDB1, err := chunkOrm.InsertChunk(context.Background(), chunk1, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
-		chunkDB2, err := chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
+		chunkDB2, err := chunkOrm.InsertChunk(context.Background(), chunk2, rutils.CodecConfig{Version: 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, codecVersion, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: 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, codecVersion, rutils.ChunkMetrics{})
+		chunkDB1, err := chunkOrm.InsertChunk(context.Background(), chunk1, rutils.CodecConfig{Version: codecVersion}, rutils.ChunkMetrics{})
 		assert.NoError(t, err)
-		chunkDB2, err := chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
+		chunkDB2, err := chunkOrm.InsertChunk(context.Background(), chunk2, rutils.CodecConfig{Version: 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, codecVersion, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: 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, encoding.CodecV0, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: 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, encoding.CodecV0, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: 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, encoding.CodecV0, rutils.BatchMetrics{})
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: 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, encoding.CodecV0, rutils.BatchMetrics{})
+	dbBatch1, err := batchOrm.InsertBatch(context.Background(), batch1, rutils.CodecConfig{Version: 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, encoding.CodecV0, rutils.BatchMetrics{})
+	dbBatch2, err := batchOrm.InsertBatch(context.Background(), batch2, rutils.CodecConfig{Version: 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, encoding.CodecV0, rutils.ChunkMetrics{})
+	_, err = chunkOrm.InsertChunk(context.Background(), chunk1, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.ChunkMetrics{})
 	assert.NoError(t, err)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk2, encoding.CodecV0, rutils.ChunkMetrics{})
+	_, err = chunkOrm.InsertChunk(context.Background(), chunk2, rutils.CodecConfig{Version: 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, encoding.CodecV0, rutils.BatchMetrics{})
+	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, rutils.CodecConfig{Version: encoding.CodecV0}, rutils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	status, err := relayer.getBatchStatusByIndex(dbBatch)

rollup/internal/controller/watcher/batch_proposer.go

@@ -2,7 +2,6 @@ package watcher
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"time"
 
@@ -54,6 +53,9 @@ 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.
@@ -135,6 +137,14 @@ 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
@@ -152,6 +162,10 @@ 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)
@@ -164,13 +178,15 @@ func (p *BatchProposer) updateDBBatchInfo(batch *encoding.Batch, codecVersion en
 			break
 		}
 
+		compatibilityBreachOccurred = true
+
 		if len(batch.Chunks) == 1 {
-			log.Error("Cannot truncate batch with only 1 chunk for compatibility", "start block number", batch.Chunks[0].Blocks[0].Header.Number.Uint64(),
+			log.Warn("Disable compression: 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())
-			return errors.New("cannot truncate batch with only 1 chunk for compatibility")
+			codecConfig.EnableCompress = false
+			break
 		}
 
-		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))
@@ -181,7 +197,7 @@ func (p *BatchProposer) updateDBBatchInfo(batch *encoding.Batch, codecVersion en
 
 		// recalculate batch metrics after truncation
 		var calcErr error
-		metrics, calcErr = utils.CalculateBatchMetrics(batch, codecVersion)
+		metrics, calcErr = utils.CalculateBatchMetrics(batch, codecConfig)
 		if calcErr != nil {
 			return fmt.Errorf("failed to calculate batch metrics, batch index: %v, error: %w", batch.Index, calcErr)
 		}
@@ -190,11 +206,23 @@ 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, codecVersion, *metrics, dbTX)
+		dbBatch, dbErr := p.batchOrm.InsertBatch(p.ctx, batch, codecConfig, *metrics, dbTX)
 		if dbErr != nil {
-			log.Warn("BatchProposer.updateBatchInfoInDB insert batch failure", "index", batch.Index, "parent hash", batch.ParentBatchHash.Hex(), "error", dbErr)
+			log.Warn("BatchProposer.updateBatchInfoInDB insert batch failure", "index", batch.Index, "parent hash", batch.ParentBatchHash.Hex(), "codec version", codecVersion, "enable compress", codecConfig.EnableCompress, "error", dbErr)
 			return dbErr
 		}
 		if dbErr = p.chunkOrm.UpdateBatchHashInRange(p.ctx, dbBatch.StartChunkIndex, dbBatch.EndChunkIndex, dbBatch.Hash, dbTX); dbErr != nil {
@@ -255,7 +283,10 @@ func (p *BatchProposer) proposeBatch() error {
 		return err
 	}
 
-	codecVersion := forks.GetCodecVersion(p.chainCfg, firstUnbatchedChunk.StartBlockNumber, firstUnbatchedChunk.StartBlockTime)
+	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
+	}
 
 	var batch encoding.Batch
 	batch.Index = dbParentBatch.Index + 1
@@ -264,7 +295,7 @@ func (p *BatchProposer) proposeBatch() error {
 
 	for i, chunk := range daChunks {
 		batch.Chunks = append(batch.Chunks, chunk)
-		metrics, calcErr := utils.CalculateBatchMetrics(&batch, codecVersion)
+		metrics, calcErr := utils.CalculateBatchMetrics(&batch, codecConfig)
 		if calcErr != nil {
 			return fmt.Errorf("failed to calculate batch metrics: %w", calcErr)
 		}
@@ -293,17 +324,17 @@ func (p *BatchProposer) proposeBatch() error {
 
 			batch.Chunks = batch.Chunks[:len(batch.Chunks)-1]
 
-			metrics, err := utils.CalculateBatchMetrics(&batch, codecVersion)
+			metrics, err := utils.CalculateBatchMetrics(&batch, codecConfig)
 			if err != nil {
 				return fmt.Errorf("failed to calculate batch metrics: %w", err)
 			}
 
 			p.recordAllBatchMetrics(metrics)
-			return p.updateDBBatchInfo(&batch, codecVersion, metrics)
+			return p.updateDBBatchInfo(&batch, codecConfig.Version, metrics)
 		}
 	}
 
-	metrics, calcErr := utils.CalculateBatchMetrics(&batch, codecVersion)
+	metrics, calcErr := utils.CalculateBatchMetrics(&batch, codecConfig)
 	if calcErr != nil {
 		return fmt.Errorf("failed to calculate batch metrics: %w", calcErr)
 	}
@@ -317,7 +348,7 @@ func (p *BatchProposer) proposeBatch() error {
 
 		p.batchFirstBlockTimeoutReached.Inc()
 		p.recordAllBatchMetrics(metrics)
-		return p.updateDBBatchInfo(&batch, codecVersion, metrics)
+		return p.updateDBBatchInfo(&batch, codecConfig.Version, 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, encoding.CodecV0, utils.ChunkMetrics{})
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+			_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.ChunkMetrics{})
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+			_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.ChunkMetrics{})
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+			_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.ChunkMetrics{})
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+			_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.ChunkMetrics{})
+		_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+		_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.ChunkMetrics{})
+		_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+		_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: 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, encoding.CodecV0, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{

rollup/internal/controller/watcher/bundle_proposer.go

@@ -147,7 +147,7 @@ func (p *BundleProposer) proposeBundle() error {
 		return err
 	}
 	hardforkName := forks.GetHardforkName(p.chainCfg, firstChunk.StartBlockNumber, firstChunk.StartBlockTime)
-	codecVersion := forks.GetCodecVersion(p.chainCfg, firstChunk.StartBlockNumber, firstChunk.StartBlockTime)
+	codecVersion := encoding.CodecVersion(batches[0].CodecVersion)
 	for i := 1; i < len(batches); i++ {
 		chunk, err := p.chunkOrm.GetChunkByIndex(p.ctx, batches[i].StartChunkIndex)
 		if err != nil {

rollup/internal/controller/watcher/bundle_proposer_test.go

@@ -72,7 +72,7 @@ func testBundleProposerLimits(t *testing.T) {
 				Blocks: []*encoding.Block{block},
 			}
 			chunkOrm := orm.NewChunk(db)
-			_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
 			assert.NoError(t, err)
 			batch := &encoding.Batch{
 				Index:                      0,
@@ -81,7 +81,7 @@ func testBundleProposerLimits(t *testing.T) {
 				Chunks:                     []*encoding.Chunk{chunk},
 			}
 			batchOrm := orm.NewBatch(db)
-			_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
+			_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
 			assert.NoError(t, err)
 
 			l2BlockOrm := orm.NewL2Block(db)
@@ -156,7 +156,7 @@ func testBundleProposerRespectHardforks(t *testing.T) {
 		Blocks: []*encoding.Block{block},
 	}
 	chunkOrm := orm.NewChunk(db)
-	_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, utils.CodecConfig{Version: encoding.CodecV0}, utils.ChunkMetrics{})
 	assert.NoError(t, err)
 	batch := &encoding.Batch{
 		Index:                      0,
@@ -165,7 +165,7 @@ func testBundleProposerRespectHardforks(t *testing.T) {
 		Chunks:                     []*encoding.Chunk{chunk},
 	}
 	batchOrm := orm.NewBatch(db)
-	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{

rollup/internal/controller/watcher/chunk_proposer.go

@@ -2,7 +2,6 @@ package watcher
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"time"
 
@@ -57,6 +56,9 @@ type ChunkProposer struct {
 
 	// total number of times that chunk proposer stops early due to compressed data compatibility breach
 	compressedDataCompatibilityBreachTotal prometheus.Counter
+
+	chunkProposeBlockHeight prometheus.Gauge
+	chunkProposeThroughput  prometheus.Counter
 }
 
 // NewChunkProposer creates a new ChunkProposer instance.
@@ -151,6 +153,14 @@ func NewChunkProposer(ctx context.Context, cfg *config.ChunkProposerConfig, chai
 			Name: "rollup_propose_chunk_estimate_blob_size_time",
 			Help: "Time taken to estimate blob size for the chunk.",
 		}),
+		chunkProposeBlockHeight: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_chunk_propose_block_height",
+			Help: "The block height of the latest proposed chunk",
+		}),
+		chunkProposeThroughput: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+			Name: "rollup_chunk_propose_throughput",
+			Help: "The total gas used in proposed chunks",
+		}),
 	}
 
 	return p
@@ -172,6 +182,10 @@ func (p *ChunkProposer) updateDBChunkInfo(chunk *encoding.Chunk, codecVersion en
 	}
 
 	compatibilityBreachOccurred := false
+	codecConfig := utils.CodecConfig{
+		Version:        codecVersion,
+		EnableCompress: true,
+	}
 
 	for {
 		compatible, err := utils.CheckChunkCompressedDataCompatibility(chunk, codecVersion)
@@ -184,12 +198,14 @@ func (p *ChunkProposer) updateDBChunkInfo(chunk *encoding.Chunk, codecVersion en
 			break
 		}
 
+		compatibilityBreachOccurred = true
+
 		if len(chunk.Blocks) == 1 {
-			log.Error("Cannot truncate chunk with only 1 block for compatibility", "block number", chunk.Blocks[0].Header.Number)
-			return errors.New("cannot truncate chunk with only 1 block for compatibility")
+			log.Warn("Disable compression: cannot truncate chunk with only 1 block for compatibility", "block number", chunk.Blocks[0].Header.Number)
+			codecConfig.EnableCompress = false
+			break
 		}
 
-		compatibilityBreachOccurred = true
 		chunk.Blocks = chunk.Blocks[:len(chunk.Blocks)-1]
 
 		log.Info("Chunk not compatible with compressed data, removing last block", "start block number", chunk.Blocks[0].Header.Number, "truncated block length", len(chunk.Blocks))
@@ -200,7 +216,7 @@ func (p *ChunkProposer) updateDBChunkInfo(chunk *encoding.Chunk, codecVersion en
 
 		// recalculate chunk metrics after truncation
 		var calcErr error
-		metrics, calcErr = utils.CalculateChunkMetrics(chunk, codecVersion)
+		metrics, calcErr = utils.CalculateChunkMetrics(chunk, codecConfig)
 		if calcErr != nil {
 			return fmt.Errorf("failed to calculate chunk metrics, start block number: %v, error: %w", chunk.Blocks[0].Header.Number, calcErr)
 		}
@@ -209,11 +225,16 @@ func (p *ChunkProposer) updateDBChunkInfo(chunk *encoding.Chunk, codecVersion en
 		p.recordAllChunkMetrics(metrics)
 	}
 
+	if len(chunk.Blocks) > 0 {
+		p.chunkProposeBlockHeight.Set(float64(chunk.Blocks[len(chunk.Blocks)-1].Header.Number.Uint64()))
+	}
+	p.chunkProposeThroughput.Add(float64(chunk.L2GasUsed()))
+
 	p.proposeChunkUpdateInfoTotal.Inc()
 	err := p.db.Transaction(func(dbTX *gorm.DB) error {
-		dbChunk, err := p.chunkOrm.InsertChunk(p.ctx, chunk, codecVersion, *metrics, dbTX)
+		dbChunk, err := p.chunkOrm.InsertChunk(p.ctx, chunk, codecConfig, *metrics, dbTX)
 		if err != nil {
-			log.Warn("ChunkProposer.InsertChunk failed", "err", err)
+			log.Warn("ChunkProposer.InsertChunk failed", "codec version", codecVersion, "enable compress", codecConfig.EnableCompress, "err", err)
 			return err
 		}
 		if err := p.l2BlockOrm.UpdateChunkHashInRange(p.ctx, dbChunk.StartBlockNumber, dbChunk.EndBlockNumber, dbChunk.Hash, dbTX); err != nil {
@@ -261,24 +282,27 @@ func (p *ChunkProposer) proposeChunk() error {
 		}
 	}
 
-	codecVersion := forks.GetCodecVersion(p.chainCfg, blocks[0].Header.Number.Uint64(), blocks[0].Header.Time)
+	codecConfig := utils.CodecConfig{
+		Version:        forks.GetCodecVersion(p.chainCfg, blocks[0].Header.Number.Uint64(), blocks[0].Header.Time),
+		EnableCompress: true, // codecv4 is the only version that supports conditional compression, default to enable compression
+	}
 
 	// Including Curie block in a sole chunk.
 	if p.chainCfg.CurieBlock != nil && blocks[0].Header.Number.Cmp(p.chainCfg.CurieBlock) == 0 {
 		chunk := encoding.Chunk{Blocks: blocks[:1]}
-		metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecVersion)
+		metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecConfig)
 		if calcErr != nil {
 			return fmt.Errorf("failed to calculate chunk metrics: %w", calcErr)
 		}
 		p.recordTimerChunkMetrics(metrics)
-		return p.updateDBChunkInfo(&chunk, codecVersion, metrics)
+		return p.updateDBChunkInfo(&chunk, codecConfig.Version, metrics)
 	}
 
 	var chunk encoding.Chunk
 	for i, block := range blocks {
 		chunk.Blocks = append(chunk.Blocks, block)
 
-		metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecVersion)
+		metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecConfig)
 		if calcErr != nil {
 			return fmt.Errorf("failed to calculate chunk metrics: %w", calcErr)
 		}
@@ -315,17 +339,17 @@ func (p *ChunkProposer) proposeChunk() error {
 
 			chunk.Blocks = chunk.Blocks[:len(chunk.Blocks)-1]
 
-			metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecVersion)
+			metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecConfig)
 			if calcErr != nil {
 				return fmt.Errorf("failed to calculate chunk metrics: %w", calcErr)
 			}
 
 			p.recordAllChunkMetrics(metrics)
-			return p.updateDBChunkInfo(&chunk, codecVersion, metrics)
+			return p.updateDBChunkInfo(&chunk, codecConfig.Version, metrics)
 		}
 	}
 
-	metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecVersion)
+	metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecConfig)
 	if calcErr != nil {
 		return fmt.Errorf("failed to calculate chunk metrics: %w", calcErr)
 	}
@@ -340,7 +364,7 @@ func (p *ChunkProposer) proposeChunk() error {
 
 		p.chunkFirstBlockTimeoutReached.Inc()
 		p.recordAllChunkMetrics(metrics)
-		return p.updateDBChunkInfo(&chunk, codecVersion, metrics)
+		return p.updateDBChunkInfo(&chunk, codecConfig.Version, metrics)
 	}
 
 	log.Debug("pending blocks do not reach one of the constraints or contain a timeout block")

rollup/internal/controller/watcher/l2_watcher.go

@@ -127,6 +127,7 @@ func (w *L2WatcherClient) getAndStoreBlocks(ctx context.Context, from, to uint64
 			return fmt.Errorf("failed to GetBlockByNumberOrHash: %v. number: %v", err, number)
 		}
 		if block.RowConsumption == nil {
+			w.metrics.fetchNilRowConsumptionBlockTotal.Inc()
 			return fmt.Errorf("fetched block does not contain RowConsumption. number: %v", number)
 		}
 
@@ -151,6 +152,7 @@ func (w *L2WatcherClient) getAndStoreBlocks(ctx context.Context, from, to uint64
 				return fmt.Errorf("failed to estimate block L1 commit calldata size: %v", err)
 			}
 			w.metrics.rollupL2BlockL1CommitCalldataSize.Set(float64(blockL1CommitCalldataSize))
+			w.metrics.rollupL2WatcherSyncThroughput.Add(float64(block.Header.GasUsed))
 		}
 		if err := w.l2BlockOrm.InsertL2Blocks(w.ctx, blocks); err != nil {
 			return fmt.Errorf("failed to batch insert BlockTraces: %v", err)

rollup/internal/controller/watcher/l2_watcher_metrics.go

@@ -12,6 +12,9 @@ type l2WatcherMetrics struct {
 	fetchRunningMissingBlocksHeight   prometheus.Gauge
 	rollupL2BlocksFetchedGap          prometheus.Gauge
 	rollupL2BlockL1CommitCalldataSize prometheus.Gauge
+	fetchNilRowConsumptionBlockTotal  prometheus.Counter
+
+	rollupL2WatcherSyncThroughput prometheus.Counter
 }
 
 var (
@@ -38,6 +41,14 @@ func initL2WatcherMetrics(reg prometheus.Registerer) *l2WatcherMetrics {
 				Name: "rollup_l2_block_l1_commit_calldata_size",
 				Help: "The l1 commitBatch calldata size of the l2 block",
 			}),
+			fetchNilRowConsumptionBlockTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_l2_watcher_fetch_nil_row_consumption_block_total",
+				Help: "The total number of occurrences where a fetched block has nil RowConsumption",
+			}),
+			rollupL2WatcherSyncThroughput: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_l2_watcher_sync_throughput",
+				Help: "The cumulative gas used in blocks that L2 watcher sync",
+			}),
 		}
 	})
 	return l2WatcherMetric

rollup/internal/orm/batch.go

@@ -35,6 +35,8 @@ type Batch struct {
 	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"`
@@ -248,7 +250,7 @@ func (o *Batch) GetBatchByIndex(ctx context.Context, index uint64) (*Batch, erro
 }
 
 // InsertBatch inserts a new batch into the database.
-func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, codecVersion encoding.CodecVersion, metrics rutils.BatchMetrics, dbTX ...*gorm.DB) (*Batch, error) {
+func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, codecConfig rutils.CodecConfig, metrics rutils.BatchMetrics, dbTX ...*gorm.DB) (*Batch, error) {
 	if batch == nil {
 		return nil, errors.New("invalid args: batch is nil")
 	}
@@ -269,7 +271,7 @@ func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, codecVer
 		startChunkIndex = parentBatch.EndChunkIndex + 1
 	}
 
-	batchMeta, err := rutils.GetBatchMetadata(batch, codecVersion)
+	batchMeta, err := rutils.GetBatchMetadata(batch, codecConfig)
 	if err != nil {
 		log.Error("failed to get batch metadata", "index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
 			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
@@ -288,7 +290,9 @@ func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, codecVer
 		WithdrawRoot:              batch.WithdrawRoot().Hex(),
 		ParentBatchHash:           batch.ParentBatchHash.Hex(),
 		BatchHeader:               batchMeta.BatchBytes,
-		CodecVersion:              int16(codecVersion),
+		CodecVersion:              int16(codecConfig.Version),
+		EnableCompress:            codecConfig.EnableCompress,
+		BlobBytes:                 batchMeta.BlobBytes,
 		ChunkProofsStatus:         int16(types.ChunkProofsStatusPending),
 		ProvingStatus:             int16(types.ProvingTaskUnassigned),
 		RollupStatus:              int16(types.RollupPending),

rollup/internal/orm/chunk.go

@@ -13,6 +13,7 @@ import (
 	"scroll-tech/common/types"
 
 	"scroll-tech/rollup/internal/utils"
+	rutils "scroll-tech/rollup/internal/utils"
 )
 
 // Chunk represents a chunk of blocks in the database.
@@ -33,6 +34,8 @@ type Chunk struct {
 	StateRoot                    string `json:"state_root" gorm:"column:state_root"`
 	ParentChunkStateRoot         string `json:"parent_chunk_state_root" gorm:"column:parent_chunk_state_root"`
 	WithdrawRoot                 string `json:"withdraw_root" gorm:"column:withdraw_root"`
+	CodecVersion                 int16  `json:"codec_version" gorm:"column:codec_version"`
+	EnableCompress               bool   `json:"enable_compress" gorm:"column:enable_compress"` // use for debug
 
 	// proof
 	ProvingStatus    int16      `json:"proving_status" gorm:"column:proving_status;default:1"`
@@ -175,7 +178,7 @@ func (o *Chunk) GetChunksByBatchHash(ctx context.Context, batchHash string) ([]*
 }
 
 // InsertChunk inserts a new chunk into the database.
-func (o *Chunk) InsertChunk(ctx context.Context, chunk *encoding.Chunk, codecVersion encoding.CodecVersion, metrics utils.ChunkMetrics, dbTX ...*gorm.DB) (*Chunk, error) {
+func (o *Chunk) InsertChunk(ctx context.Context, chunk *encoding.Chunk, codecConfig rutils.CodecConfig, metrics utils.ChunkMetrics, dbTX ...*gorm.DB) (*Chunk, error) {
 	if chunk == nil || len(chunk.Blocks) == 0 {
 		return nil, errors.New("invalid args")
 	}
@@ -200,7 +203,7 @@ func (o *Chunk) InsertChunk(ctx context.Context, chunk *encoding.Chunk, codecVer
 		parentChunkStateRoot = parentChunk.StateRoot
 	}
 
-	chunkHash, err := utils.GetChunkHash(chunk, totalL1MessagePoppedBefore, codecVersion)
+	chunkHash, err := utils.GetChunkHash(chunk, totalL1MessagePoppedBefore, codecConfig.Version)
 	if err != nil {
 		log.Error("failed to get chunk hash", "err", err)
 		return nil, fmt.Errorf("Chunk.InsertChunk error: %w", err)
@@ -225,6 +228,8 @@ func (o *Chunk) InsertChunk(ctx context.Context, chunk *encoding.Chunk, codecVer
 		StateRoot:                    chunk.Blocks[numBlocks-1].Header.Root.Hex(),
 		ParentChunkStateRoot:         parentChunkStateRoot,
 		WithdrawRoot:                 chunk.Blocks[numBlocks-1].WithdrawRoot.Hex(),
+		CodecVersion:                 int16(codecConfig.Version),
+		EnableCompress:               codecConfig.EnableCompress,
 		ProvingStatus:                int16(types.ProvingTaskUnassigned),
 		CrcMax:                       metrics.CrcMax,
 		BlobSize:                     metrics.L1CommitBlobSize,

rollup/internal/orm/orm_test.go

@@ -221,11 +221,11 @@ func TestChunkOrm(t *testing.T) {
 			assert.NoError(t, err)
 		}
 
-		dbChunk1, err := chunkOrm.InsertChunk(context.Background(), chunk1, codecVersion, utils.ChunkMetrics{})
+		dbChunk1, err := chunkOrm.InsertChunk(context.Background(), chunk1, utils.CodecConfig{Version: codecVersion}, utils.ChunkMetrics{})
 		assert.NoError(t, err)
 		assert.Equal(t, dbChunk1.Hash, chunkHash1.Hex())
 
-		dbChunk2, err := chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, utils.ChunkMetrics{})
+		dbChunk2, err := chunkOrm.InsertChunk(context.Background(), chunk2, utils.CodecConfig{Version: codecVersion}, utils.ChunkMetrics{})
 		assert.NoError(t, err)
 		assert.Equal(t, dbChunk2.Hash, chunkHash2.Hex())
 
@@ -275,7 +275,7 @@ func TestBatchOrm(t *testing.T) {
 			Index:  0,
 			Chunks: []*encoding.Chunk{chunk1},
 		}
-		batch1, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion, utils.BatchMetrics{})
+		batch1, err := batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: codecVersion}, utils.BatchMetrics{})
 		assert.NoError(t, err)
 		hash1 := batch1.Hash
 
@@ -306,7 +306,7 @@ func TestBatchOrm(t *testing.T) {
 			Index:  1,
 			Chunks: []*encoding.Chunk{chunk2},
 		}
-		batch2, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion, utils.BatchMetrics{})
+		batch2, err := batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: codecVersion}, utils.BatchMetrics{})
 		assert.NoError(t, err)
 		hash2 := batch2.Hash
 
@@ -432,7 +432,7 @@ func TestBundleOrm(t *testing.T) {
 		Index:  0,
 		Chunks: []*encoding.Chunk{chunk1},
 	}
-	dbBatch1, err := batchOrm.InsertBatch(context.Background(), batch1, encoding.CodecV3, utils.BatchMetrics{})
+	dbBatch1, err := batchOrm.InsertBatch(context.Background(), batch1, utils.CodecConfig{Version: encoding.CodecV3}, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	chunk2 := &encoding.Chunk{Blocks: []*encoding.Block{block2}}
@@ -440,7 +440,7 @@ func TestBundleOrm(t *testing.T) {
 		Index:  1,
 		Chunks: []*encoding.Chunk{chunk2},
 	}
-	dbBatch2, err := batchOrm.InsertBatch(context.Background(), batch2, encoding.CodecV3, utils.BatchMetrics{})
+	dbBatch2, err := batchOrm.InsertBatch(context.Background(), batch2, utils.CodecConfig{Version: encoding.CodecV3}, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	var bundle1 *Bundle

rollup/internal/utils/utils.go

@@ -9,9 +9,16 @@ 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/common"
 )
 
+// CodecConfig holds the configuration for codec-related operations
+type CodecConfig struct {
+	Version        encoding.CodecVersion
+	EnableCompress bool
+}
+
 // ChunkMetrics indicates the metrics for proposing a chunk.
 type ChunkMetrics struct {
 	// common metrics
@@ -36,7 +43,7 @@ type ChunkMetrics struct {
 }
 
 // CalculateChunkMetrics calculates chunk metrics.
-func CalculateChunkMetrics(chunk *encoding.Chunk, codecVersion encoding.CodecVersion) (*ChunkMetrics, error) {
+func CalculateChunkMetrics(chunk *encoding.Chunk, codecConfig CodecConfig) (*ChunkMetrics, error) {
 	var err error
 	metrics := &ChunkMetrics{
 		TxNum:               chunk.NumTransactions(),
@@ -47,7 +54,7 @@ func CalculateChunkMetrics(chunk *encoding.Chunk, codecVersion encoding.CodecVer
 	if err != nil {
 		return nil, fmt.Errorf("failed to get crc max: %w", err)
 	}
-	switch codecVersion {
+	switch codecConfig.Version {
 	case encoding.CodecV0:
 		start := time.Now()
 		metrics.L1CommitGas, err = codecv0.EstimateChunkL1CommitGas(chunk)
@@ -111,8 +118,24 @@ func CalculateChunkMetrics(chunk *encoding.Chunk, codecVersion encoding.CodecVer
 			return nil, fmt.Errorf("failed to estimate codecv3 chunk L1 commit batch size and blob size: %w", err)
 		}
 		return metrics, nil
+	case encoding.CodecV4:
+		start := time.Now()
+		metrics.L1CommitGas = codecv4.EstimateChunkL1CommitGas(chunk)
+		metrics.EstimateGasTime = time.Since(start)
+
+		start = time.Now()
+		metrics.L1CommitCalldataSize = codecv4.EstimateChunkL1CommitCalldataSize(chunk)
+		metrics.EstimateCalldataSizeTime = time.Since(start)
+
+		start = time.Now()
+		metrics.L1CommitUncompressedBatchBytesSize, metrics.L1CommitBlobSize, err = codecv4.EstimateChunkL1CommitBatchSizeAndBlobSize(chunk, codecConfig.EnableCompress)
+		metrics.EstimateBlobSizeTime = time.Since(start)
+		if err != nil {
+			return nil, fmt.Errorf("failed to estimate codecv4 chunk L1 commit batch size and blob size: %w", err)
+		}
+		return metrics, nil
 	default:
-		return nil, fmt.Errorf("unsupported codec version: %v", codecVersion)
+		return nil, fmt.Errorf("unsupported codec version: %v", codecConfig.Version)
 	}
 }
 
@@ -125,6 +148,8 @@ func CheckChunkCompressedDataCompatibility(chunk *encoding.Chunk, codecVersion e
 		return codecv2.CheckChunkCompressedDataCompatibility(chunk)
 	case encoding.CodecV3:
 		return codecv3.CheckChunkCompressedDataCompatibility(chunk)
+	case encoding.CodecV4:
+		return codecv4.CheckChunkCompressedDataCompatibility(chunk)
 	default:
 		return false, fmt.Errorf("unsupported codec version: %v", codecVersion)
 	}
@@ -139,6 +164,8 @@ func CheckBatchCompressedDataCompatibility(batch *encoding.Batch, codecVersion e
 		return codecv2.CheckBatchCompressedDataCompatibility(batch)
 	case encoding.CodecV3:
 		return codecv3.CheckBatchCompressedDataCompatibility(batch)
+	case encoding.CodecV4:
+		return codecv4.CheckBatchCompressedDataCompatibility(batch)
 	default:
 		return false, fmt.Errorf("unsupported codec version: %v", codecVersion)
 	}
@@ -166,13 +193,13 @@ type BatchMetrics struct {
 }
 
 // CalculateBatchMetrics calculates batch metrics.
-func CalculateBatchMetrics(batch *encoding.Batch, codecVersion encoding.CodecVersion) (*BatchMetrics, error) {
+func CalculateBatchMetrics(batch *encoding.Batch, codecConfig CodecConfig) (*BatchMetrics, error) {
 	var err error
 	metrics := &BatchMetrics{
 		NumChunks:           uint64(len(batch.Chunks)),
 		FirstBlockTimestamp: batch.Chunks[0].Blocks[0].Header.Time,
 	}
-	switch codecVersion {
+	switch codecConfig.Version {
 	case encoding.CodecV0:
 		start := time.Now()
 		metrics.L1CommitGas, err = codecv0.EstimateBatchL1CommitGas(batch)
@@ -235,8 +262,24 @@ func CalculateBatchMetrics(batch *encoding.Batch, codecVersion encoding.CodecVer
 			return nil, fmt.Errorf("failed to estimate codecv3 batch L1 commit batch size and blob size: %w", err)
 		}
 		return metrics, nil
+	case encoding.CodecV4:
+		start := time.Now()
+		metrics.L1CommitGas = codecv4.EstimateBatchL1CommitGas(batch)
+		metrics.EstimateGasTime = time.Since(start)
+
+		start = time.Now()
+		metrics.L1CommitCalldataSize = codecv4.EstimateBatchL1CommitCalldataSize(batch)
+		metrics.EstimateCalldataSizeTime = time.Since(start)
+
+		start = time.Now()
+		metrics.L1CommitUncompressedBatchBytesSize, metrics.L1CommitBlobSize, err = codecv4.EstimateBatchL1CommitBatchSizeAndBlobSize(batch, codecConfig.EnableCompress)
+		metrics.EstimateBlobSizeTime = time.Since(start)
+		if err != nil {
+			return nil, fmt.Errorf("failed to estimate codecv4 batch L1 commit batch size and blob size: %w", err)
+		}
+		return metrics, nil
 	default:
-		return nil, fmt.Errorf("unsupported codec version: %v", codecVersion)
+		return nil, fmt.Errorf("unsupported codec version: %v", codecConfig.Version)
 	}
 }
 
@@ -283,6 +326,16 @@ func GetChunkHash(chunk *encoding.Chunk, totalL1MessagePoppedBefore uint64, code
 			return common.Hash{}, fmt.Errorf("failed to get codecv3 DA chunk hash: %w", err)
 		}
 		return chunkHash, nil
+	case encoding.CodecV4:
+		daChunk, err := codecv4.NewDAChunk(chunk, totalL1MessagePoppedBefore)
+		if err != nil {
+			return common.Hash{}, fmt.Errorf("failed to create codecv4 DA chunk: %w", err)
+		}
+		chunkHash, err := daChunk.Hash()
+		if err != nil {
+			return common.Hash{}, fmt.Errorf("failed to get codecv4 DA chunk hash: %w", err)
+		}
+		return chunkHash, nil
 	default:
 		return common.Hash{}, fmt.Errorf("unsupported codec version: %v", codecVersion)
 	}
@@ -296,17 +349,21 @@ type BatchMetadata struct {
 	BatchBytes         []byte
 	StartChunkHash     common.Hash
 	EndChunkHash       common.Hash
+	BlobBytes          []byte
 }
 
 // GetBatchMetadata retrieves the metadata of a batch.
-func GetBatchMetadata(batch *encoding.Batch, codecVersion encoding.CodecVersion) (*BatchMetadata, error) {
+// TODO: refactor this function to reduce cyclomatic complexity
+//
+//gocyclo:ignore
+func GetBatchMetadata(batch *encoding.Batch, codecConfig CodecConfig) (*BatchMetadata, error) {
 	numChunks := len(batch.Chunks)
 	totalL1MessagePoppedBeforeEndDAChunk := batch.TotalL1MessagePoppedBefore
 	for i := 0; i < numChunks-1; i++ {
 		totalL1MessagePoppedBeforeEndDAChunk += batch.Chunks[i].NumL1Messages(totalL1MessagePoppedBeforeEndDAChunk)
 	}
 
-	switch codecVersion {
+	switch codecConfig.Version {
 	case encoding.CodecV0:
 		daBatch, err := codecv0.NewDABatch(batch)
 		if err != nil {
@@ -432,6 +489,7 @@ func GetBatchMetadata(batch *encoding.Batch, codecVersion encoding.CodecVersion)
 			BatchDataHash:      daBatch.DataHash,
 			BatchBlobDataProof: blobDataProof,
 			BatchBytes:         daBatch.Encode(),
+			BlobBytes:          daBatch.BlobBytes(),
 		}
 
 		startDAChunk, err := codecv3.NewDAChunk(batch.Chunks[0], batch.TotalL1MessagePoppedBefore)
@@ -454,7 +512,46 @@ func GetBatchMetadata(batch *encoding.Batch, codecVersion encoding.CodecVersion)
 			return nil, fmt.Errorf("failed to get codecv3 end DA chunk hash: %w", err)
 		}
 		return batchMeta, nil
+	case encoding.CodecV4:
+		daBatch, err := codecv4.NewDABatch(batch, codecConfig.EnableCompress)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create codecv4 DA batch: %w", err)
+		}
+
+		blobDataProof, err := daBatch.BlobDataProofForPointEvaluation()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get codecv4 blob data proof for point evaluation: %w", err)
+		}
+
+		batchMeta := &BatchMetadata{
+			BatchHash:          daBatch.Hash(),
+			BatchDataHash:      daBatch.DataHash,
+			BatchBlobDataProof: blobDataProof,
+			BatchBytes:         daBatch.Encode(),
+			BlobBytes:          daBatch.BlobBytes(),
+		}
+
+		startDAChunk, err := codecv4.NewDAChunk(batch.Chunks[0], batch.TotalL1MessagePoppedBefore)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create codecv4 start DA chunk: %w", err)
+		}
+
+		batchMeta.StartChunkHash, err = startDAChunk.Hash()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get codecv4 start DA chunk hash: %w", err)
+		}
+
+		endDAChunk, err := codecv4.NewDAChunk(batch.Chunks[numChunks-1], totalL1MessagePoppedBeforeEndDAChunk)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create codecv4 end DA chunk: %w", err)
+		}
+
+		batchMeta.EndChunkHash, err = endDAChunk.Hash()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get codecv4 end DA chunk hash: %w", err)
+		}
+		return batchMeta, nil
 	default:
-		return nil, fmt.Errorf("unsupported codec version: %v", codecVersion)
+		return nil, fmt.Errorf("unsupported codec version: %v", codecConfig.Version)
 	}
 }

rollup/tests/bridge_test.go

@@ -105,10 +105,14 @@ func setupEnv(t *testing.T) {
 	l2Cfg.Confirmations = 0
 	l2Cfg.RelayerConfig.SenderConfig.Confirmations = 0
 
-	l1Auth, err = bind.NewKeyedTransactorWithChainID(l2Cfg.RelayerConfig.CommitSenderPrivateKey, l1GethChainID)
+	pKey, err := crypto.ToECDSA(common.FromHex(l2Cfg.RelayerConfig.CommitSenderPrivateKey))
+	assert.NoError(t, err)
+	l1Auth, err = bind.NewKeyedTransactorWithChainID(pKey, l1GethChainID)
 	assert.NoError(t, err)
 
-	l2Auth, err = bind.NewKeyedTransactorWithChainID(l1Cfg.RelayerConfig.GasOracleSenderPrivateKey, l2GethChainID)
+	pKey, err = crypto.ToECDSA(common.FromHex(l2Cfg.RelayerConfig.GasOracleSenderPrivateKey))
+	assert.NoError(t, err)
+	l2Auth, err = bind.NewKeyedTransactorWithChainID(pKey, l2GethChainID)
 	assert.NoError(t, err)
 
 	port, err := rand.Int(rand.Reader, big.NewInt(10000))
@@ -210,5 +214,6 @@ func TestFunction(t *testing.T) {
 	// l1/l2 gas oracle
 	t.Run("TestImportL1GasPrice", testImportL1GasPrice)
 	t.Run("TestImportL1GasPriceAfterCurie", testImportL1GasPriceAfterCurie)
+	t.Run("TestImportDefaultL1GasPriceDueToL1GasPriceSpike", testImportDefaultL1GasPriceDueToL1GasPriceSpike)
 	t.Run("TestImportL2GasPrice", testImportL2GasPrice)
 }

rollup/tests/gas_oracle_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"math/big"
 	"testing"
+	"time"
 
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
@@ -56,6 +57,34 @@ func testImportL1GasPrice(t *testing.T) {
 	assert.Empty(t, blocks[0].OracleTxHash)
 	assert.Equal(t, types.GasOracleStatus(blocks[0].GasOracleStatus), types.GasOraclePending)
 
+	// add fake batch to pass check for commit batch timeout
+	chunk := &encoding.Chunk{
+		Blocks: []*encoding.Block{
+			{
+				Header: &gethTypes.Header{
+					Number:     big.NewInt(1),
+					ParentHash: common.Hash{},
+					Difficulty: big.NewInt(0),
+					BaseFee:    big.NewInt(0),
+				},
+				Transactions:   nil,
+				WithdrawRoot:   common.Hash{},
+				RowConsumption: &gethTypes.RowConsumption{},
+			},
+		},
+	}
+	batch := &encoding.Batch{
+		Index:                      0,
+		TotalL1MessagePoppedBefore: 0,
+		ParentBatchHash:            common.Hash{},
+		Chunks:                     []*encoding.Chunk{chunk},
+	}
+	batchOrm := orm.NewBatch(db)
+	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+	assert.NoError(t, err)
+	err = batchOrm.UpdateCommitTxHashAndRollupStatus(context.Background(), dbBatch.Hash, common.Hash{}.String(), types.RollupCommitted)
+	assert.NoError(t, err)
+
 	// relay gas price
 	l1Relayer.ProcessGasPriceOracle()
 	blocks, err = l1BlockOrm.GetL1Blocks(context.Background(), map[string]interface{}{"number": latestBlockHeight})
@@ -101,6 +130,34 @@ func testImportL1GasPriceAfterCurie(t *testing.T) {
 	assert.Empty(t, blocks[0].OracleTxHash)
 	assert.Equal(t, types.GasOracleStatus(blocks[0].GasOracleStatus), types.GasOraclePending)
 
+	// add fake batch to pass check for commit batch timeout
+	chunk := &encoding.Chunk{
+		Blocks: []*encoding.Block{
+			{
+				Header: &gethTypes.Header{
+					Number:     big.NewInt(1),
+					ParentHash: common.Hash{},
+					Difficulty: big.NewInt(0),
+					BaseFee:    big.NewInt(0),
+				},
+				Transactions:   nil,
+				WithdrawRoot:   common.Hash{},
+				RowConsumption: &gethTypes.RowConsumption{},
+			},
+		},
+	}
+	batch := &encoding.Batch{
+		Index:                      0,
+		TotalL1MessagePoppedBefore: 0,
+		ParentBatchHash:            common.Hash{},
+		Chunks:                     []*encoding.Chunk{chunk},
+	}
+	batchOrm := orm.NewBatch(db)
+	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+	assert.NoError(t, err)
+	err = batchOrm.UpdateCommitTxHashAndRollupStatus(context.Background(), dbBatch.Hash, common.Hash{}.String(), types.RollupCommitted)
+	assert.NoError(t, err)
+
 	// relay gas price
 	l1Relayer.ProcessGasPriceOracle()
 	blocks, err = l1BlockOrm.GetL1Blocks(context.Background(), map[string]interface{}{"number": latestBlockHeight})
@@ -110,6 +167,114 @@ func testImportL1GasPriceAfterCurie(t *testing.T) {
 	assert.Equal(t, types.GasOracleStatus(blocks[0].GasOracleStatus), types.GasOracleImporting)
 }
 
+func testImportDefaultL1GasPriceDueToL1GasPriceSpike(t *testing.T) {
+	db := setupDB(t)
+	defer database.CloseDB(db)
+
+	prepareContracts(t)
+
+	l1Cfg := rollupApp.Config.L1Config
+	l1CfgCopy := *l1Cfg
+	// set CheckCommittedBatchesWindowMinutes to zero to not pass check for commit batch timeout
+	l1CfgCopy.RelayerConfig.GasOracleConfig.CheckCommittedBatchesWindowMinutes = 0
+	// Create L1Relayer
+	l1Relayer, err := relayer.NewLayer1Relayer(context.Background(), db, l1CfgCopy.RelayerConfig, &params.ChainConfig{BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0)}, relayer.ServiceTypeL1GasOracle, nil)
+	assert.NoError(t, err)
+	defer l1Relayer.StopSenders()
+
+	// Create L1Watcher
+	startHeight, err := l1Client.BlockNumber(context.Background())
+	assert.NoError(t, err)
+	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1Client, startHeight-2, db, nil)
+
+	// fetch new blocks
+	number, err := l1Client.BlockNumber(context.Background())
+	assert.Greater(t, number-1, startHeight-2)
+	assert.NoError(t, err)
+	err = l1Watcher.FetchBlockHeader(number - 1)
+	assert.NoError(t, err)
+
+	l1BlockOrm := orm.NewL1Block(db)
+	// check db status
+	latestBlockHeight, err := l1BlockOrm.GetLatestL1BlockHeight(context.Background())
+	assert.NoError(t, err)
+	assert.Equal(t, number-1, latestBlockHeight)
+	blocks, err := l1BlockOrm.GetL1Blocks(context.Background(), map[string]interface{}{"number": latestBlockHeight})
+	assert.NoError(t, err)
+	assert.Equal(t, len(blocks), 1)
+	assert.Empty(t, blocks[0].OracleTxHash)
+	assert.Equal(t, types.GasOracleStatus(blocks[0].GasOracleStatus), types.GasOraclePending)
+
+	// add fake batch
+	chunk := &encoding.Chunk{
+		Blocks: []*encoding.Block{
+			{
+				Header: &gethTypes.Header{
+					Number:     big.NewInt(1),
+					ParentHash: common.Hash{},
+					Difficulty: big.NewInt(0),
+					BaseFee:    big.NewInt(0),
+				},
+				Transactions:   nil,
+				WithdrawRoot:   common.Hash{},
+				RowConsumption: &gethTypes.RowConsumption{},
+			},
+		},
+	}
+	batch0 := &encoding.Batch{
+		Index:                      0,
+		TotalL1MessagePoppedBefore: 0,
+		ParentBatchHash:            common.Hash{},
+		Chunks:                     []*encoding.Chunk{chunk},
+	}
+	batch := &encoding.Batch{
+		Index:                      1,
+		TotalL1MessagePoppedBefore: 0,
+		ParentBatchHash:            common.Hash{},
+		Chunks:                     []*encoding.Chunk{chunk},
+	}
+	batchOrm := orm.NewBatch(db)
+	_, err = batchOrm.InsertBatch(context.Background(), batch0, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+	assert.NoError(t, err)
+	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
+	assert.NoError(t, err)
+	err = batchOrm.UpdateCommitTxHashAndRollupStatus(context.Background(), dbBatch.Hash, common.Hash{}.String(), types.RollupCommitted)
+	assert.NoError(t, err)
+	time.Sleep(1 * time.Second)
+
+	// relay gas price
+	// gas price will be relayed to some default value because we didn't commit batches for a l1CfgCopy.RelayerConfig.GasOracleConfig.CheckCommittedBatchesWindowMinutes = 0 minutes
+	l1Relayer.ProcessGasPriceOracle()
+	blocks, err = l1BlockOrm.GetL1Blocks(context.Background(), map[string]interface{}{"number": latestBlockHeight})
+	assert.NoError(t, err)
+	assert.Equal(t, len(blocks), 1)
+	assert.NotEmpty(t, blocks[0].OracleTxHash)
+	assert.Equal(t, types.GasOracleStatus(blocks[0].GasOracleStatus), types.GasOracleImporting)
+
+	// fetch new blocks
+	err = l1Watcher.FetchBlockHeader(number)
+	assert.NoError(t, err)
+
+	// check db status
+	latestBlockHeight, err = l1BlockOrm.GetLatestL1BlockHeight(context.Background())
+	assert.NoError(t, err)
+	assert.Equal(t, number, latestBlockHeight)
+	blocks, err = l1BlockOrm.GetL1Blocks(context.Background(), map[string]interface{}{"number": latestBlockHeight})
+	assert.NoError(t, err)
+	assert.Equal(t, len(blocks), 1)
+	assert.Empty(t, blocks[0].OracleTxHash)
+	assert.Equal(t, types.GasOracleStatus(blocks[0].GasOracleStatus), types.GasOraclePending)
+
+	// relay gas price
+	// gas price should not be relayed one more time because previously we already set it do default value
+	l1Relayer.ProcessGasPriceOracle()
+	blocks, err = l1BlockOrm.GetL1Blocks(context.Background(), map[string]interface{}{"number": latestBlockHeight})
+	assert.NoError(t, err)
+	assert.Equal(t, len(blocks), 1)
+	assert.Empty(t, blocks[0].OracleTxHash)
+	assert.Equal(t, types.GasOracleStatus(blocks[0].GasOracleStatus), types.GasOraclePending)
+}
+
 func testImportL2GasPrice(t *testing.T) {
 	db := setupDB(t)
 	defer database.CloseDB(db)
@@ -144,7 +309,7 @@ func testImportL2GasPrice(t *testing.T) {
 	}
 
 	batchOrm := orm.NewBatch(db)
-	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
+	_, err = batchOrm.InsertBatch(context.Background(), batch, utils.CodecConfig{Version: encoding.CodecV0}, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
 	// check db status

tests/integration-test/contracts_test.go

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