fix lint issue

Signed-off-by: noelwei <fan@scroll.io>

.dockerignore

@@ -0,0 +1,16 @@
+.github
+
+.gitignore
+
+.dockerignore
+
+Dockerfile
+Dockerfile.backup
+
+.output
+
+docs
+
+openvm-clippy
+
+target

.github/workflows/common.yml

@@ -42,11 +42,15 @@ jobs:
       uses: Swatinem/rust-cache@v2
       with:
         workspaces: "common/libzkp/impl -> target"
-    # - name: Lint
-    #   working-directory: 'common'
-    #   run: |
-    #     rm -rf $HOME/.cache/golangci-lint
-    #     make lint
+    - name: Setup SSH for private repos
+      uses: webfactory/ssh-agent@v0.9.0
+      with:
+        ssh-private-key: ${{ secrets.OPENVM_GPU_SSH_PRIVATE_KEY }}
+    - name: Lint
+      working-directory: 'common'
+      run: |
+        rm -rf $HOME/.cache/golangci-lint
+        make lint
   goimports-lint:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest

.github/workflows/docker.yml

@@ -307,48 +307,13 @@ jobs:
           REPOSITORY: coordinator-api
         run: |
           aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
-      - name: Setup SSH for repositories and clone them
+      - name: Setup SSH for private repos
+        uses: webfactory/ssh-agent@v0.9.0
+        with:
+          ssh-private-key: ${{ secrets.OPENVM_GPU_SSH_PRIVATE_KEY }}
+      - name: Run custom script
         run: |
-          mkdir -p ~/.ssh
-          chmod 700 ~/.ssh
-
-          # Setup for plonky3-gpu
-          echo "${{ secrets.PLONKY3_GPU_SSH_PRIVATE_KEY }}" > ~/.ssh/plonky3_gpu_key
-          chmod 600 ~/.ssh/plonky3_gpu_key
-          eval "$(ssh-agent -s)" > /dev/null
-          ssh-add ~/.ssh/plonky3_gpu_key 2>/dev/null
-          ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts 2>/dev/null
-          echo "Loaded plonky3-gpu key"
-
-          # Clone plonky3-gpu repository
-          ./build/dockerfiles/coordinator-api/clone_plonky3_gpu.sh
-
-          # Setup for openvm-stark-gpu
-          echo "${{ secrets.OPENVM_STARK_GPU_SSH_PRIVATE_KEY }}" > ~/.ssh/openvm_stark_gpu_key
-          chmod 600 ~/.ssh/openvm_stark_gpu_key
-          eval "$(ssh-agent -s)" > /dev/null
-          ssh-add ~/.ssh/openvm_stark_gpu_key 2>/dev/null
-          echo "Loaded openvm-stark-gpu key"
-
-          # Clone openvm-stark-gpu repository
-          ./build/dockerfiles/coordinator-api/clone_openvm_stark_gpu.sh
-
-          # Setup for openvm-gpu
-          echo "${{ secrets.OPENVM_GPU_SSH_PRIVATE_KEY }}" > ~/.ssh/openvm_gpu_key
-          chmod 600 ~/.ssh/openvm_gpu_key
-          eval "$(ssh-agent -s)" > /dev/null
-          ssh-add ~/.ssh/openvm_gpu_key 2>/dev/null
-          echo "Loaded openvm-gpu key"
-
-          # Clone openvm-gpu repository
-          ./build/dockerfiles/coordinator-api/clone_openvm_gpu.sh
-
-          # Show number of loaded keys
-          echo "Number of loaded keys: $(ssh-add -l | wc -l)"
-
-      - name: Checkout specific commits
-        run: |
-          ./build/dockerfiles/coordinator-api/checkout_all.sh
+          ./build/dockerfiles/coordinator-api/init-openvm.sh
       - name: Build and push
         uses: docker/build-push-action@v3
         env:

Cargo.toml

@@ -0,0 +1,93 @@
+[workspace]
+members = [
+  "common/types-rs",
+  "common/types-rs/base",
+  "common/types-rs/aggregation",
+  "common/types-rs/chunk",
+  "common/types-rs/batch",
+  "common/types-rs/bundle",
+  "common/libzkp/impl",
+  "zkvm-prover/prover",
+  "zkvm-prover/verifier",
+  "zkvm-prover/integration",
+  "zkvm-prover/bin",
+]
+exclude = [
+  "prover"
+]
+
+resolver = "2"
+
+[workspace.package]
+authors = ["Scroll developers"]
+edition = "2021"
+homepage = "https://scroll.io"
+readme = "README.md"
+repository = "https://github.com/scroll-tech/scroll"
+version = "4.5.8"
+
+[workspace.dependencies]
+scroll-zkvm-prover-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", package = "scroll-zkvm-prover"}
+
+openvm = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-build = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-transpiler = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-custom-insn = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-rv32im-guest = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-circuit = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-native-circuit = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-native-compiler = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-native-recursion = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-native-transpiler = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-continuations = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-sdk = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false, features = ["parallel", "bench-metrics", "evm-prove"] }
+openvm-stark-sdk = { git = "https://github.com/openvm-org/stark-backend.git", tag = "v1.0.1" }
+
+sbv-core = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade", features = ["scroll"] }
+sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade", features = ["scroll"] }
+sbv-kv = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade" }
+sbv-trie = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade" }
+sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade" }
+
+metrics = "0.23.0"
+metrics-util = "0.17"
+metrics-tracing-context = "0.16.0"
+
+alloy = { version = "0.11", default-features = false }
+alloy-primitives = { version = "0.8", default-features = false }
+# also use this to trigger "serde" feature for primitives
+alloy-serde = { version = "0.8", default-features = false }
+
+rkyv = "0.8"
+serde = { version = "1", default-features = false, features = ["derive"] }
+serde_json = { version = "1.0" }
+serde_with = "3.11.0"
+itertools = "0.14"
+tiny-keccak = "2.0"
+tracing = "0.1"
+eyre = "0.6"
+bincode_v1 = { version = "1.3", package = "bincode"}
+snark-verifier-sdk = { version = "0.2.0", default-features = false, features = [
+    "loader_halo2",
+    "halo2-axiom",
+    "display",
+] }
+once_cell = "1.20"
+base64 = "0.22"
+
+#TODO: upgrade
+vm-zstd = { git = "https://github.com/scroll-tech/rust-zstd-decompressor.git", tag = "v0.1.1" }
+
+scroll-zkvm-circuit-input-types = { path = "common/types-rs"}
+scroll-zkvm-verifier = { path = "zkvm-prover/verifier"}
+scroll-zkvm-prover = { path = "zkvm-prover/prover"}
+
+[patch.crates-io]
+alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.18-euclid-upgrade" }
+ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
+tiny-keccak = { git = "https://github.com/scroll-tech/tiny-keccak", branch = "scroll-patch-v2.0.2-euclid-upgrade" }
+
+[profile.maxperf]
+inherits = "release"
+lto = "fat"
+codegen-units = 1

bridge-history-api/internal/orm/cross_message.go

@@ -154,7 +154,7 @@ func (c *CrossMessage) GetL2UnclaimedWithdrawalsByAddress(ctx context.Context, s
 	db := c.db.WithContext(ctx)
 	db = db.Model(&CrossMessage{})
 	db = db.Where("message_type = ?", btypes.MessageTypeL2SentMessage)
-	db = db.Where("tx_status in (?)", []types.TxStatusType{types.TxStatusTypeSent, types.TxStatusTypeFailedRelayed, types.TxStatusTypeRelayTxReverted})
+	db = db.Where("tx_status = ?", types.TxStatusTypeSent)
 	db = db.Where("sender = ?", sender)
 	db = db.Order("block_timestamp desc")
 	db = db.Limit(500)

build/.cargo/config.toml

@@ -0,0 +1,6 @@
+[patch."https://github.com/scroll-tech/scroll.git"]
+scroll-zkvm-circuit-input-types-base = { path = "../common/types-rs/base"}
+scroll-zkvm-circuit-input-types-aggregation = { path = "../common/types-rs/aggregation"}
+scroll-zkvm-circuit-input-types-chunk = { path = "../common/types-rs/chunk"}
+scroll-zkvm-circuit-input-types-batch = { path = "../common/types-rs/batch"}
+scroll-zkvm-circuit-input-types-bundle = { path = "../common/types-rs/bundle"}

build/dockerfiles/coordinator-api.Dockerfile

@@ -1,5 +1,5 @@
 # Build libzkp dependency
-FROM scrolltech/cuda-go-rust-builder:cuda-11.7.1-go-1.21-rust-nightly-2023-12-03 as chef
+FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as chef
 WORKDIR app
 
 FROM chef as planner
@@ -9,9 +9,7 @@ RUN cargo chef prepare --recipe-path recipe.json
 FROM chef as zkp-builder
 COPY ./common/libzkp/impl/rust-toolchain ./
 COPY --from=planner /app/recipe.json recipe.json
-# run scripts to get openvm-gpu
-COPY ./build/dockerfiles/coordinator-api/plonky3-gpu /plonky3-gpu
-COPY ./build/dockerfiles/coordinator-api/openvm-stark-gpu /openvm-stark-gpu
+# run ./build/dockerfiles/coordinator-api/init-openvm.sh to get openvm-gpu
 COPY ./build/dockerfiles/coordinator-api/openvm-gpu /openvm-gpu
 COPY ./build/dockerfiles/coordinator-api/gitconfig /root/.gitconfig
 COPY ./build/dockerfiles/coordinator-api/config.toml /root/.cargo/config.toml
@@ -22,7 +20,7 @@ RUN cargo build --release
 
 
 # Download Go dependencies
-FROM scrolltech/cuda-go-rust-builder:cuda-11.7.1-go-1.21-rust-nightly-2023-12-03 as base
+FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
 WORKDIR /src
 COPY go.work* ./
 COPY ./rollup/go.* ./rollup/
@@ -42,7 +40,7 @@ COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/internal/log
 RUN cd ./coordinator && CGO_LDFLAGS="-Wl,--no-as-needed -ldl" make coordinator_api_skip_libzkp && mv ./build/bin/coordinator_api /bin/coordinator_api && mv internal/logic/verifier/lib /bin/
 
 # Pull coordinator into a second stage deploy ubuntu container
-FROM nvidia/cuda:11.7.1-runtime-ubuntu22.04
+FROM ubuntu:20.04
 ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/src/coordinator/internal/logic/verifier/lib
 ENV CGO_LDFLAGS="-Wl,--no-as-needed -ldl"
 # ENV CHAIN_ID=534353

build/dockerfiles/coordinator-api/checkout_all.sh

@@ -1,17 +0,0 @@
-#!/bin/bash
-set -uex
-
-PLONKY3_GPU_COMMIT=261b322        # v0.2.0
-OPENVM_STARK_GPU_COMMIT=3082234   # PR#48
-OPENVM_GPU_COMMIT=8094b4f         # branch: patch-v1.2.0
-
-DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" > /dev/null 2>&1 && pwd)
-
-# checkout plonky3-gpu
-cd $DIR/plonky3-gpu && git checkout ${PLONKY3_GPU_COMMIT}
-
-# checkout openvm-stark-gpu
-cd $DIR/openvm-stark-gpu && git checkout ${OPENVM_STARK_GPU_COMMIT}
-
-# checkout openvm-gpu
-cd $DIR/openvm-gpu && git checkout ${OPENVM_GPU_COMMIT}

build/dockerfiles/coordinator-api/clone_openvm_stark_gpu.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-set -uex
-
-DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" > /dev/null 2>&1 && pwd)
-
-# clone openvm-stark-gpu if not exists
-if [ ! -d $DIR/openvm-stark-gpu ]; then
-    git clone git@github.com:scroll-tech/openvm-stark-gpu.git $DIR/openvm-stark-gpu
-fi
-cd $DIR/openvm-stark-gpu && git fetch --all --force

build/dockerfiles/coordinator-api/clone_plonky3_gpu.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-set -uex
-
-DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" > /dev/null 2>&1 && pwd)
-
-# clone plonky3-gpu if not exists
-if [ ! -d $DIR/plonky3-gpu ]; then
-    git clone git@github.com:scroll-tech/plonky3-gpu.git $DIR/plonky3-gpu
-fi
-cd $DIR/plonky3-gpu && git fetch --all --force

build/dockerfiles/coordinator-api/config.toml

@@ -19,74 +19,6 @@ openvm-native-transpiler = { path = "/openvm-gpu/extensions/native/transpiler",
 openvm-pairing-guest = { path = "/openvm-gpu/extensions/pairing/guest", default-features = false }
 openvm-rv32im-guest = { path = "/openvm-gpu/extensions/rv32im/guest", default-features = false }
 openvm-rv32im-transpiler = { path = "/openvm-gpu/extensions/rv32im/transpiler", default-features = false }
-openvm-sdk = { path = "/openvm-gpu/crates/sdk", default-features = false, features = ["parallel", "bench-metrics", "evm-prove"] }
+openvm-sdk = { path = "/openvm-gpu/crates/sdk", default-features = false, features = ["parallel", "bench-metrics"] }
 openvm-sha256-guest = { path = "/openvm-gpu/extensions/sha256/guest", default-features = false }
 openvm-transpiler = { path = "/openvm-gpu/crates/toolchain/transpiler", default-features = false }
-
-# stark-backend
-[patch."https://github.com/openvm-org/stark-backend.git"]
-openvm-stark-backend = { path = "/openvm-stark-gpu/crates/stark-backend", features = ["gpu"] }
-openvm-stark-sdk = { path = "/openvm-stark-gpu/crates/stark-sdk", features = ["gpu"] }
-
-[patch."ssh://git@github.com/scroll-tech/openvm-stark-gpu.git"]
-openvm-stark-backend = { path = "/openvm-stark-gpu/crates/stark-backend", features = ["gpu"] }
-openvm-stark-sdk = { path = "/openvm-stark-gpu/crates/stark-sdk", features = ["gpu"] }
-
-# plonky3
-[patch."https://github.com/Plonky3/Plonky3.git"]
-p3-air = { path = "/plonky3-gpu/air" }
-p3-field = { path = "/plonky3-gpu/field" }
-p3-commit = { path = "/plonky3-gpu/commit" }
-p3-matrix = { path = "/plonky3-gpu/matrix" }
-p3-baby-bear = { path = "/plonky3-gpu/baby-bear" }
-p3-koala-bear = { path = "/plonky3-gpu/koala-bear" }
-p3-util = { path = "/plonky3-gpu/util" }
-p3-challenger = { path = "/plonky3-gpu/challenger" }
-p3-dft = { path = "/plonky3-gpu/dft" }
-p3-fri = { path = "/plonky3-gpu/fri" }
-p3-goldilocks = { path = "/plonky3-gpu/goldilocks" }
-p3-keccak = { path = "/plonky3-gpu/keccak" }
-p3-keccak-air = { path = "/plonky3-gpu/keccak-air" }
-p3-blake3 = { path = "/plonky3-gpu/blake3" }
-p3-mds = { path = "/plonky3-gpu/mds" }
-p3-monty-31 = { path = "/plonky3-gpu/monty-31" }
-p3-merkle-tree = { path = "/plonky3-gpu/merkle-tree" }
-p3-poseidon = { path = "/plonky3-gpu/poseidon" }
-p3-poseidon2 = { path = "/plonky3-gpu/poseidon2" }
-p3-poseidon2-air = { path = "/plonky3-gpu/poseidon2-air" }
-p3-symmetric = { path = "/plonky3-gpu/symmetric" }
-p3-uni-stark = { path = "/plonky3-gpu/uni-stark" }
-p3-maybe-rayon = { path = "/plonky3-gpu/maybe-rayon" }
-p3-bn254-fr = { path = "/plonky3-gpu/bn254-fr" }
-
-# gpu crates
-[patch."ssh://git@github.com/scroll-tech/plonky3-gpu.git"]
-p3-gpu-base = { path = "/plonky3-gpu/gpu-base" }
-p3-gpu-build = { path = "/plonky3-gpu/gpu-build" }
-p3-gpu-field = { path = "/plonky3-gpu/gpu-field" }
-p3-gpu-backend = { path = "/plonky3-gpu/gpu-backend" }
-p3-gpu-module = { path = "/plonky3-gpu/gpu-module" }
-p3-air = { path = "/plonky3-gpu/air" }
-p3-field = { path = "/plonky3-gpu/field" }
-p3-commit = { path = "/plonky3-gpu/commit" }
-p3-matrix = { path = "/plonky3-gpu/matrix" }
-p3-baby-bear = { path = "/plonky3-gpu/baby-bear" }
-p3-koala-bear = { path = "/plonky3-gpu/koala-bear" }
-p3-util = { path = "/plonky3-gpu/util" }
-p3-challenger = { path = "/plonky3-gpu/challenger" }
-p3-dft = { path = "/plonky3-gpu/dft" }
-p3-fri = { path = "/plonky3-gpu/fri" }
-p3-goldilocks = { path = "/plonky3-gpu/goldilocks" }
-p3-keccak = { path = "/plonky3-gpu/keccak" }
-p3-keccak-air = { path = "/plonky3-gpu/keccak-air" }
-p3-blake3 = { path = "/plonky3-gpu/blake3" }
-p3-mds = { path = "/plonky3-gpu/mds" }
-p3-monty-31 = { path = "/plonky3-gpu/monty-31" }
-p3-merkle-tree = { path = "/plonky3-gpu/merkle-tree" }
-p3-poseidon = { path = "/plonky3-gpu/poseidon" }
-p3-poseidon2 = { path = "/plonky3-gpu/poseidon2" }
-p3-poseidon2-air = { path = "/plonky3-gpu/poseidon2-air" }
-p3-symmetric = { path = "/plonky3-gpu/symmetric" }
-p3-uni-stark = { path = "/plonky3-gpu/uni-stark" }
-p3-maybe-rayon = { path = "/plonky3-gpu/maybe-rayon" }
-p3-bn254-fr = { path = "/plonky3-gpu/bn254-fr" }

build/dockerfiles/coordinator-api/init-openvm.sh

@@ -1,10 +1,12 @@
 #!/bin/bash
 set -uex
 
+OPENVM_GPU_COMMIT=dfa10b4
+
 DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" > /dev/null 2>&1 && pwd)
 
-# clone openvm-gpu if not exists
+# checkout openvm-gpu
 if [ ! -d $DIR/openvm-gpu ]; then
     git clone git@github.com:scroll-tech/openvm-gpu.git $DIR/openvm-gpu
 fi
-cd $DIR/openvm-gpu && git fetch --all --force
+cd $DIR/openvm-gpu && git fetch && git checkout ${OPENVM_GPU_COMMIT}

common/database/db.go

@@ -41,7 +41,7 @@ func (g *gormLogger) Error(_ context.Context, msg string, data ...interface{}) {
 func (g *gormLogger) Trace(_ context.Context, begin time.Time, fc func() (string, int64), err error) {
 	elapsed := time.Since(begin)
 	sql, rowsAffected := fc()
-	g.gethLogger.Trace("gorm", "line", utils.FileWithLineNum(), "cost", elapsed, "sql", sql, "rowsAffected", rowsAffected, "err", err)
+	g.gethLogger.Debug("gorm", "line", utils.FileWithLineNum(), "cost", elapsed, "sql", sql, "rowsAffected", rowsAffected, "err", err)
 }
 
 // InitDB init the db handler

common/libzkp/impl/Cargo.toml

@@ -7,60 +7,22 @@ edition = "2021"
 [lib]
 crate-type = ["cdylib"]
 
-[patch.crates-io]
-# patched add rkyv support & MSRV 1.77
-alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.21" }
-ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
-tiny-keccak = { git = "https://github.com/scroll-tech/tiny-keccak", branch = "scroll-patch-v2.0.2-openvm-v1.0.0-rc.1" }
-
 [dependencies]
-euclid_prover = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.4.2", package = "scroll-zkvm-prover" }
-euclid_verifier = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.4.2", package = "scroll-zkvm-verifier" }
+scroll-zkvm-prover.workspace = true
+scroll-zkvm-verifier.workspace = true
 
-base64 = "0.13.0"
-env_logger = "0.9.0"
+env_logger = "0.11.0"
 libc = "0.2"
 log = "0.4"
-once_cell = "1.19"
-serde = "1.0"
+base64.workspace = true
+once_cell.workspace = true
+serde.workspace = true
 serde_derive = "1.0"
-serde_json = "1.0.66"
-anyhow = "1.0.86"
+serde_json.workspace = true
+anyhow = "1"
 
 [profile.test]
 opt-level = 3
 
 [profile.release]
 opt-level = 3
-
-[patch."https://github.com/openvm-org/stark-backend.git"]
-openvm-stark-backend = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "main", features = ["gpu"] }
-openvm-stark-sdk = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "main", features = ["gpu"] }
-
-[patch."https://github.com/Plonky3/Plonky3.git"]
-p3-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-field = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-commit = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-matrix = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-baby-bear = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", features = [
-    "nightly-features",
-], tag = "v0.2.0" }
-p3-koala-bear = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-util = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-challenger = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-dft = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-fri = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-goldilocks = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-keccak = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-keccak-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-blake3 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-mds = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-merkle-tree = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-monty-31 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-poseidon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-poseidon2 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-poseidon2-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-symmetric = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-uni-stark = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
-p3-maybe-rayon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" } # the "parallel" feature is NOT on by default to allow single-threaded benchmarking
-p3-bn254-fr = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }

common/libzkp/impl/src/verifier.rs

@@ -1,7 +1,10 @@
 #![allow(static_mut_refs)]
 
+mod euclid;
 mod euclidv2;
+
 use anyhow::{bail, Result};
+use euclid::EuclidVerifier;
 use euclidv2::EuclidV2Verifier;
 use serde::{Deserialize, Serialize};
 use std::{cell::OnceCell, path::Path, rc::Rc};
@@ -28,25 +31,39 @@ pub trait ProofVerifier {
 #[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_LOW: OnceCell<VerifierPair> = OnceCell::new();
 static mut VERIFIER_HIGH: OnceCell<VerifierPair> = OnceCell::new();
 
 pub fn init(config: VerifierConfig) {
+    let verifier = EuclidVerifier::new(&config.high_version_circuit.assets_path);
+    unsafe {
+        VERIFIER_LOW
+            .set(VerifierPair(
+                "euclid".to_string(),
+                Rc::new(Box::new(verifier)),
+            ))
+            .unwrap_unchecked();
+    }
+
     let verifier = EuclidV2Verifier::new(&config.high_version_circuit.assets_path);
     unsafe {
         VERIFIER_HIGH
             .set(VerifierPair(
-                config.high_version_circuit.fork_name,
+                "euclidV2".to_string(),
                 Rc::new(Box::new(verifier)),
             ))
             .unwrap_unchecked();
@@ -55,6 +72,12 @@ pub fn init(config: VerifierConfig) {
 
 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());

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

@@ -0,0 +1,66 @@
+use super::{ProofVerifier, TaskType, VKDump};
+
+use anyhow::Result;
+
+use crate::utils::panic_catch;
+use scroll_zkvm_prover::{BatchProof, BundleProof, ChunkProof};
+use scroll_zkvm_verifier::verifier::{BatchVerifier, BundleVerifierEuclidV1, ChunkVerifier};
+use std::{fs::File, path::Path};
+
+pub struct EuclidVerifier {
+    chunk_verifier: ChunkVerifier,
+    batch_verifier: BatchVerifier,
+    bundle_verifier: BundleVerifierEuclidV1,
+}
+
+impl EuclidVerifier {
+    pub fn new(assets_dir: &str) -> Self {
+        let verifier_bin = Path::new(assets_dir).join("verifier.bin");
+        let config = Path::new(assets_dir).join("root-verifier-vm-config");
+        let exe = Path::new(assets_dir).join("root-verifier-committed-exe");
+
+        Self {
+            chunk_verifier: ChunkVerifier::setup(&config, &exe, &verifier_bin)
+                .expect("Setting up chunk verifier"),
+            batch_verifier: BatchVerifier::setup(&config, &exe, &verifier_bin)
+                .expect("Setting up batch verifier"),
+            bundle_verifier: BundleVerifierEuclidV1::setup(&config, &exe, &verifier_bin)
+                .expect("Setting up bundle verifier"),
+        }
+    }
+}
+
+impl ProofVerifier for EuclidVerifier {
+    fn verify(&self, task_type: super::TaskType, proof: Vec<u8>) -> Result<bool> {
+        panic_catch(|| match task_type {
+            TaskType::Chunk => {
+                let proof = serde_json::from_slice::<ChunkProof>(proof.as_slice()).unwrap();
+                self.chunk_verifier
+                    .verify_proof(proof.proof.as_root_proof().unwrap())
+            }
+            TaskType::Batch => {
+                let proof = serde_json::from_slice::<BatchProof>(proof.as_slice()).unwrap();
+                self.batch_verifier
+                    .verify_proof(proof.proof.as_root_proof().unwrap())
+            }
+            TaskType::Bundle => {
+                let proof = serde_json::from_slice::<BundleProof>(proof.as_slice()).unwrap();
+                self.bundle_verifier
+                    .verify_proof_evm(&proof.proof.as_evm_proof().unwrap())
+            }
+        })
+        .map_err(|err_str: String| anyhow::anyhow!(err_str))
+    }
+
+    fn dump_vk(&self, file: &Path) {
+        use base64::{prelude::BASE64_STANDARD, Engine};
+        let f = File::create(file).expect("Failed to open file to dump VK");
+
+        let dump = VKDump {
+            chunk_vk: BASE64_STANDARD.encode(self.chunk_verifier.get_app_vk()),
+            batch_vk: BASE64_STANDARD.encode(self.batch_verifier.get_app_vk()),
+            bundle_vk: BASE64_STANDARD.encode(self.bundle_verifier.get_app_vk()),
+        };
+        serde_json::to_writer(f, &dump).expect("Failed to dump VK");
+    }
+}

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

@@ -3,8 +3,8 @@ use super::{ProofVerifier, TaskType, VKDump};
 use anyhow::Result;
 
 use crate::utils::panic_catch;
-use euclid_prover::{BatchProof, BundleProof, ChunkProof};
-use euclid_verifier::verifier::{BatchVerifier, BundleVerifierEuclidV2, ChunkVerifier};
+use scroll_zkvm_prover::{BatchProof, BundleProof, ChunkProof};
+use scroll_zkvm_verifier::verifier::{BatchVerifier, BundleVerifierEuclidV2, ChunkVerifier};
 use std::{fs::File, path::Path};
 
 pub struct EuclidV2Verifier {
@@ -53,12 +53,13 @@ impl ProofVerifier for EuclidV2Verifier {
     }
 
     fn dump_vk(&self, file: &Path) {
+        use base64::{prelude::BASE64_STANDARD, Engine};
         let f = File::create(file).expect("Failed to open file to dump VK");
 
         let dump = VKDump {
-            chunk_vk: base64::encode(self.chunk_verifier.get_app_vk()),
-            batch_vk: base64::encode(self.batch_verifier.get_app_vk()),
-            bundle_vk: base64::encode(self.bundle_verifier.get_app_vk()),
+            chunk_vk: BASE64_STANDARD.encode(self.chunk_verifier.get_app_vk()),
+            batch_vk: BASE64_STANDARD.encode(self.batch_verifier.get_app_vk()),
+            bundle_vk: BASE64_STANDARD.encode(self.bundle_verifier.get_app_vk()),
         };
         serde_json::to_writer(f, &dump).expect("Failed to dump VK");
     }

common/types-rs/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "scroll-zkvm-circuit-input-types"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+readme.workspace = true
+repository.workspace = true
+version = "0.2.0"
+
+[dependencies]
+types-base = { path = "base", package = "scroll-zkvm-circuit-input-types-base"}
+types-agg = { path = "aggregation", package = "scroll-zkvm-circuit-input-types-aggregation"}
+types-chunk = { path = "chunk", package = "scroll-zkvm-circuit-input-types-chunk"}
+types-batch = { path = "batch", package = "scroll-zkvm-circuit-input-types-batch"}
+types-bundle = { path = "bundle", package = "scroll-zkvm-circuit-input-types-bundle"}
+
+

common/types-rs/README.md

@@ -0,0 +1,24 @@
+# Input Types for circuits
+
+A series of separated crates for the input types accepted by circuits as input.
+
+This crate help decoupling circuits with other crates and keep their dependencies neat and controllable. Avoiding to involve crates which is not compatible with the tootlchain of openvm from indirect dependency.
+
+### Code structure
+```
+types-rs
+│
+├── base
+│
+├── circuit
+│
+├── aggregation
+│
+<following are layer-oriented crates>
+│
+├── chunk
+│
+├── batch
+│
+└── bundle
+```

common/types-rs/aggregation/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "scroll-zkvm-circuit-input-types-aggregation"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+readme.workspace = true
+repository.workspace = true
+version = "0.2.0"
+
+[dependencies]
+alloy-primitives = { workspace = true, default-features = false, features = ["std", "map-hashbrown", "map-fxhash", "rkyv"] }
+rkyv.workspace = true
+serde.workspace = true
+

common/types-rs/aggregation/src/lib.rs

@@ -0,0 +1,81 @@
+/// Represents an openvm program commitments and public values.
+#[derive(
+    Clone,
+    Debug,
+    rkyv::Archive,
+    rkyv::Deserialize,
+    rkyv::Serialize,
+    serde::Deserialize,
+    serde::Serialize,
+)]
+#[rkyv(derive(Debug))]
+pub struct AggregationInput {
+    /// Public values.
+    pub public_values: Vec<u32>,
+    /// Represent the commitment needed to verify a root proof
+    pub commitment: ProgramCommitment,
+}
+
+/// Represent the commitment needed to verify a [`RootProof`].
+#[derive(
+    Clone,
+    Debug,
+    Default,
+    rkyv::Archive,
+    rkyv::Deserialize,
+    rkyv::Serialize,
+    serde::Deserialize,
+    serde::Serialize,
+)]
+#[rkyv(derive(Debug))]
+pub struct ProgramCommitment {
+    /// The commitment to the child program exe.
+    pub exe: [u32; 8],
+    /// The commitment to the child program leaf.
+    pub leaf: [u32; 8],
+}
+
+impl ProgramCommitment {
+    pub fn deserialize(commitment_bytes: &[u8]) -> Self {
+        // TODO: temporary skip deserialize if no vk is provided
+        if commitment_bytes.is_empty() {
+            return Default::default();
+        }
+
+        let archived_data =
+            rkyv::access::<ArchivedProgramCommitment, rkyv::rancor::BoxedError>(commitment_bytes)
+                .unwrap();
+
+        Self {
+            exe: archived_data.exe.map(|u32_le| u32_le.to_native()),
+            leaf: archived_data.leaf.map(|u32_le| u32_le.to_native()),
+        }
+    }
+
+    pub fn serialize(&self) -> Vec<u8> {
+        rkyv::to_bytes::<rkyv::rancor::BoxedError>(self)
+            .map(|v| v.to_vec())
+            .unwrap()
+    }
+}
+
+impl From<&ArchivedProgramCommitment> for ProgramCommitment {
+    fn from(archived: &ArchivedProgramCommitment) -> Self {
+        Self {
+            exe: archived.exe.map(|u32_le| u32_le.to_native()),
+            leaf: archived.leaf.map(|u32_le| u32_le.to_native()),
+        }
+    }
+}
+
+/// Number of public-input values, i.e. [u32; N].
+///
+/// Note that the actual value for each u32 is a byte.
+pub const NUM_PUBLIC_VALUES: usize = 32;
+
+/// Witness for an [`AggregationCircuit`][AggCircuit] that also carries proofs that are being
+/// aggregated.
+pub trait ProofCarryingWitness {
+    /// Get the root proofs from the witness.
+    fn get_proofs(&self) -> Vec<AggregationInput>;
+}

common/types-rs/base/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "scroll-zkvm-circuit-input-types-base"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+readme.workspace = true
+repository.workspace = true
+version = "0.2.0"
+
+[dependencies]
+alloy-primitives = { workspace = true, default-features = false, features = ["std", "map-hashbrown", "map-fxhash", "rkyv"] }
+alloy-serde.workspace = true
+rkyv.workspace = true
+serde.workspace = true
+itertools.workspace = true
+tiny-keccak = { workspace = true }
+sha3 = "0.10.8"
+sha2 = "0.10.8"
+
+[features]
+default = []

common/types-rs/base/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod public_inputs;
+pub mod utils;

common/types-rs/base/src/public_inputs.rs

@@ -0,0 +1,81 @@
+use alloy_primitives::B256;
+pub mod batch;
+pub mod bundle;
+pub mod chunk;
+
+/// Defines behaviour to be implemented by types representing the public-input values of a circuit.
+pub trait PublicInputs {
+    /// Keccak-256 digest of the public inputs. The public-input hash are revealed as public values
+    /// via [`openvm::io::reveal`].
+    fn pi_hash(&self) -> B256;
+
+    /// Validation logic between public inputs of two contiguous instances.
+    fn validate(&self, prev_pi: &Self);
+}
+
+#[derive(
+    Default,
+    Debug,
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    rkyv::Archive,
+    rkyv::Deserialize,
+    rkyv::Serialize,
+    serde::Deserialize,
+    serde::Serialize,
+)]
+#[rkyv(derive(Debug))]
+pub enum ForkName {
+    #[default]
+    EuclidV1,
+    EuclidV2,
+}
+
+impl From<&ArchivedForkName> for ForkName {
+    fn from(archived: &ArchivedForkName) -> Self {
+        match archived {
+            ArchivedForkName::EuclidV1 => ForkName::EuclidV1,
+            ArchivedForkName::EuclidV2 => ForkName::EuclidV2,
+        }
+    }
+}
+
+impl From<Option<&str>> for ForkName {
+    fn from(value: Option<&str>) -> Self {
+        match value {
+            None => Default::default(),
+            Some("euclidv1") => ForkName::EuclidV1,
+            Some("euclidv2") => ForkName::EuclidV2,
+            Some(s) => unreachable!("hardfork not accepted: {s}"),
+        }
+    }
+}
+
+impl From<&str> for ForkName {
+    fn from(value: &str) -> Self {
+        match value {
+            "euclidv1" => ForkName::EuclidV1,
+            "euclidv2" => ForkName::EuclidV2,
+            s => unreachable!("hardfork not accepted: {s}"),
+        }
+    }
+}
+
+/// helper trait to extend PublicInputs
+pub trait MultiVersionPublicInputs {
+    fn pi_hash_by_fork(&self, fork_name: ForkName) -> B256;
+    fn validate(&self, prev_pi: &Self, fork_name: ForkName);
+}
+
+impl<T: MultiVersionPublicInputs> PublicInputs for (T, ForkName) {
+    fn pi_hash(&self) -> B256 {
+        self.0.pi_hash_by_fork(self.1)
+    }
+
+    fn validate(&self, prev_pi: &Self) {
+        assert_eq!(self.1, prev_pi.1);
+        self.0.validate(&prev_pi.0, self.1)
+    }
+}

common/types-rs/base/src/public_inputs/batch.rs

@@ -0,0 +1,144 @@
+use alloy_primitives::B256;
+
+use crate::{
+    public_inputs::{ForkName, MultiVersionPublicInputs},
+    utils::keccak256,
+};
+
+/// Represents public-input values for a batch.
+#[derive(
+    Clone,
+    Debug,
+    rkyv::Archive,
+    rkyv::Deserialize,
+    rkyv::Serialize,
+    serde::Deserialize,
+    serde::Serialize,
+)]
+#[rkyv(derive(Debug))]
+pub struct BatchInfo {
+    /// The state root before applying the batch.
+    #[rkyv()]
+    pub parent_state_root: B256,
+    /// The batch hash of the parent batch.
+    #[rkyv()]
+    pub parent_batch_hash: B256,
+    /// The state root after applying txs in the batch.
+    #[rkyv()]
+    pub state_root: B256,
+    /// The batch header hash of the batch.
+    #[rkyv()]
+    pub batch_hash: B256,
+    /// The EIP-155 chain ID of all txs in the batch.
+    #[rkyv()]
+    pub chain_id: u64,
+    /// The withdraw root of the last block in the last chunk in the batch.
+    #[rkyv()]
+    pub withdraw_root: B256,
+    /// The L1 msg queue hash at the end of the previous batch.
+    #[rkyv()]
+    pub prev_msg_queue_hash: B256,
+    /// The L1 msg queue hash at the end of the current batch.
+    #[rkyv()]
+    pub post_msg_queue_hash: B256,
+}
+
+impl From<&ArchivedBatchInfo> for BatchInfo {
+    fn from(archived: &ArchivedBatchInfo) -> Self {
+        Self {
+            parent_state_root: archived.parent_state_root.into(),
+            parent_batch_hash: archived.parent_batch_hash.into(),
+            state_root: archived.state_root.into(),
+            batch_hash: archived.batch_hash.into(),
+            chain_id: archived.chain_id.into(),
+            withdraw_root: archived.withdraw_root.into(),
+            prev_msg_queue_hash: archived.prev_msg_queue_hash.into(),
+            post_msg_queue_hash: archived.post_msg_queue_hash.into(),
+        }
+    }
+}
+
+impl BatchInfo {
+    /// Public input hash for a batch (euclidv1 or da-codec@v6) is defined as
+    ///
+    /// keccak(
+    ///     parent state root ||
+    ///     parent batch hash ||
+    ///     state root ||
+    ///     batch hash ||
+    ///     chain id ||
+    ///     withdraw root ||
+    /// )
+    fn pi_hash_euclidv1(&self) -> B256 {
+        keccak256(
+            std::iter::empty()
+                .chain(self.parent_state_root.as_slice())
+                .chain(self.parent_batch_hash.as_slice())
+                .chain(self.state_root.as_slice())
+                .chain(self.batch_hash.as_slice())
+                .chain(self.chain_id.to_be_bytes().as_slice())
+                .chain(self.withdraw_root.as_slice())
+                .cloned()
+                .collect::<Vec<u8>>(),
+        )
+    }
+
+    /// Public input hash for a batch (euclidv2 or da-codec@v7) is defined as
+    ///
+    /// keccak(
+    ///     parent state root ||
+    ///     parent batch hash ||
+    ///     state root ||
+    ///     batch hash ||
+    ///     chain id ||
+    ///     withdraw root ||
+    ///     prev msg queue hash ||
+    ///     post msg queue hash
+    /// )    
+    fn pi_hash_euclidv2(&self) -> B256 {
+        keccak256(
+            std::iter::empty()
+                .chain(self.parent_state_root.as_slice())
+                .chain(self.parent_batch_hash.as_slice())
+                .chain(self.state_root.as_slice())
+                .chain(self.batch_hash.as_slice())
+                .chain(self.chain_id.to_be_bytes().as_slice())
+                .chain(self.withdraw_root.as_slice())
+                .chain(self.prev_msg_queue_hash.as_slice())
+                .chain(self.post_msg_queue_hash.as_slice())
+                .cloned()
+                .collect::<Vec<u8>>(),
+        )
+    }
+}
+
+pub type VersionedBatchInfo = (BatchInfo, ForkName);
+
+impl MultiVersionPublicInputs for BatchInfo {
+    fn pi_hash_by_fork(&self, fork_name: ForkName) -> B256 {
+        match fork_name {
+            ForkName::EuclidV1 => self.pi_hash_euclidv1(),
+            ForkName::EuclidV2 => self.pi_hash_euclidv2(),
+        }
+    }
+
+    /// Validate public inputs between 2 contiguous batches.
+    ///
+    /// - chain id MUST match
+    /// - state roots MUST be chained
+    /// - batch hashes MUST be chained
+    /// - L1 msg queue hashes MUST be chained
+    fn validate(&self, prev_pi: &Self, fork_name: ForkName) {
+        assert_eq!(self.chain_id, prev_pi.chain_id);
+        assert_eq!(self.parent_state_root, prev_pi.state_root);
+        assert_eq!(self.parent_batch_hash, prev_pi.batch_hash);
+        assert_eq!(self.prev_msg_queue_hash, prev_pi.post_msg_queue_hash);
+
+        if fork_name == ForkName::EuclidV1 {
+            assert_eq!(self.prev_msg_queue_hash, B256::ZERO);
+            assert_eq!(prev_pi.prev_msg_queue_hash, B256::ZERO);
+            assert_eq!(self.post_msg_queue_hash, B256::ZERO);
+            assert_eq!(prev_pi.post_msg_queue_hash, B256::ZERO);
+        }
+    }
+}

common/types-rs/base/src/public_inputs/bundle.rs

@@ -0,0 +1,149 @@
+use alloy_primitives::B256;
+
+use crate::{
+    public_inputs::{ForkName, MultiVersionPublicInputs, PublicInputs},
+    utils::keccak256,
+};
+
+/// Represents fields required to compute the public-inputs digest of a bundle.
+#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
+pub struct BundleInfo {
+    /// The EIP-155 chain ID of all txs in the bundle.
+    pub chain_id: u64,
+    /// The L1 msg queue hash at the end of the last batch in the bundle.
+    /// Not a phase 1 field so we make it omitable
+    #[serde(default)]
+    pub msg_queue_hash: B256,
+    /// The number of batches bundled together in the bundle.
+    pub num_batches: u32,
+    /// The last finalized on-chain state root.
+    pub prev_state_root: B256,
+    /// The last finalized on-chain batch hash.
+    pub prev_batch_hash: B256,
+    /// The state root after applying every batch in the bundle.
+    ///
+    /// Upon verification of the EVM-verifiable bundle proof, this state root will be finalized
+    /// on-chain.
+    pub post_state_root: B256,
+    /// The batch hash of the last batch in the bundle.
+    ///
+    /// Upon verification of the EVM-verifiable bundle proof, this batch hash will be finalized
+    /// on-chain.
+    pub batch_hash: B256,
+    /// The withdrawals root at the last block in the last chunk in the last batch in the bundle.
+    pub withdraw_root: B256,
+}
+
+impl BundleInfo {
+    /// Public input hash for a bundle (euclidv1 or da-codec@v6) is defined as
+    ///
+    /// keccak(
+    ///     chain id ||
+    ///     num batches ||
+    ///     prev state root ||
+    ///     prev batch hash ||
+    ///     post state root ||
+    ///     batch hash ||
+    ///     withdraw root
+    /// )
+    pub fn pi_hash_euclidv1(&self) -> B256 {
+        keccak256(
+            std::iter::empty()
+                .chain(self.chain_id.to_be_bytes().as_slice())
+                .chain(self.num_batches.to_be_bytes().as_slice())
+                .chain(self.prev_state_root.as_slice())
+                .chain(self.prev_batch_hash.as_slice())
+                .chain(self.post_state_root.as_slice())
+                .chain(self.batch_hash.as_slice())
+                .chain(self.withdraw_root.as_slice())
+                .cloned()
+                .collect::<Vec<u8>>(),
+        )
+    }
+
+    /// Public input hash for a bundle (euclidv2 or da-codec@v7) is defined as
+    ///
+    /// keccak(
+    ///     chain id ||
+    ///     msg_queue_hash ||
+    ///     num batches ||
+    ///     prev state root ||
+    ///     prev batch hash ||
+    ///     post state root ||
+    ///     batch hash ||
+    ///     withdraw root
+    /// )   
+    pub fn pi_hash_euclidv2(&self) -> B256 {
+        keccak256(
+            std::iter::empty()
+                .chain(self.chain_id.to_be_bytes().as_slice())
+                .chain(self.msg_queue_hash.as_slice())
+                .chain(self.num_batches.to_be_bytes().as_slice())
+                .chain(self.prev_state_root.as_slice())
+                .chain(self.prev_batch_hash.as_slice())
+                .chain(self.post_state_root.as_slice())
+                .chain(self.batch_hash.as_slice())
+                .chain(self.withdraw_root.as_slice())
+                .cloned()
+                .collect::<Vec<u8>>(),
+        )
+    }
+
+    pub fn pi_hash(&self, fork_name: ForkName) -> B256 {
+        match fork_name {
+            ForkName::EuclidV1 => self.pi_hash_euclidv1(),
+            ForkName::EuclidV2 => self.pi_hash_euclidv2(),
+        }
+    }
+}
+
+impl MultiVersionPublicInputs for BundleInfo {
+    fn pi_hash_by_fork(&self, fork_name: ForkName) -> B256 {
+        match fork_name {
+            ForkName::EuclidV1 => self.pi_hash_euclidv1(),
+            ForkName::EuclidV2 => self.pi_hash_euclidv2(),
+        }
+    }
+
+    fn validate(&self, _prev_pi: &Self, _fork_name: ForkName) {
+        unreachable!("bundle is the last layer and is not aggregated by any other circuit");
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct BundleInfoV1(pub BundleInfo);
+
+#[derive(Clone, Debug)]
+pub struct BundleInfoV2(pub BundleInfo);
+
+impl From<BundleInfo> for BundleInfoV1 {
+    fn from(value: BundleInfo) -> Self {
+        Self(value)
+    }
+}
+
+impl From<BundleInfo> for BundleInfoV2 {
+    fn from(value: BundleInfo) -> Self {
+        Self(value)
+    }
+}
+
+impl PublicInputs for BundleInfoV1 {
+    fn pi_hash(&self) -> B256 {
+        self.0.pi_hash_euclidv1()
+    }
+
+    fn validate(&self, _prev_pi: &Self) {
+        unreachable!("bundle is the last layer and is not aggregated by any other circuit");
+    }
+}
+
+impl PublicInputs for BundleInfoV2 {
+    fn pi_hash(&self) -> B256 {
+        self.0.pi_hash_euclidv2()
+    }
+
+    fn validate(&self, _prev_pi: &Self) {
+        unreachable!("bundle is the last layer and is not aggregated by any other circuit");
+    }
+}

common/types-rs/base/src/public_inputs/chunk.rs

@@ -0,0 +1,248 @@
+use alloy_primitives::{B256, U256};
+
+use crate::{
+    public_inputs::{ForkName, MultiVersionPublicInputs},
+    utils::keccak256,
+};
+
+/// Number of bytes used to serialise [`BlockContextV2`].
+pub const SIZE_BLOCK_CTX: usize = 52;
+
+/// Represents the version 2 of block context.
+///
+/// The difference between v2 and v1 is that the block number field has been removed since v2.
+#[derive(
+    Debug,
+    Clone,
+    PartialEq,
+    rkyv::Archive,
+    rkyv::Deserialize,
+    rkyv::Serialize,
+    serde::Deserialize,
+    serde::Serialize,
+)]
+#[rkyv(derive(Debug))]
+pub struct BlockContextV2 {
+    /// The timestamp of the block.
+    pub timestamp: u64,
+    /// The base fee of the block.
+    pub base_fee: U256,
+    /// The gas limit of the block.
+    pub gas_limit: u64,
+    /// The number of transactions in the block, including both L1 msg txs as well as L2 txs.
+    pub num_txs: u16,
+    /// The number of L1 msg txs in the block.
+    pub num_l1_msgs: u16,
+}
+
+impl From<&ArchivedBlockContextV2> for BlockContextV2 {
+    fn from(archived: &ArchivedBlockContextV2) -> Self {
+        Self {
+            timestamp: archived.timestamp.into(),
+            base_fee: archived.base_fee.into(),
+            gas_limit: archived.gas_limit.into(),
+            num_txs: archived.num_txs.into(),
+            num_l1_msgs: archived.num_l1_msgs.into(),
+        }
+    }
+}
+
+impl From<&[u8]> for BlockContextV2 {
+    fn from(bytes: &[u8]) -> Self {
+        assert_eq!(bytes.len(), SIZE_BLOCK_CTX);
+
+        let timestamp = u64::from_be_bytes(bytes[0..8].try_into().expect("should not fail"));
+        let base_fee = U256::from_be_slice(&bytes[8..40]);
+        let gas_limit = u64::from_be_bytes(bytes[40..48].try_into().expect("should not fail"));
+        let num_txs = u16::from_be_bytes(bytes[48..50].try_into().expect("should not fail"));
+        let num_l1_msgs = u16::from_be_bytes(bytes[50..52].try_into().expect("should not fail"));
+
+        Self {
+            timestamp,
+            base_fee,
+            gas_limit,
+            num_txs,
+            num_l1_msgs,
+        }
+    }
+}
+
+impl BlockContextV2 {
+    /// Serialize the block context in packed form.
+    pub fn to_bytes(&self) -> Vec<u8> {
+        std::iter::empty()
+            .chain(self.timestamp.to_be_bytes())
+            .chain(self.base_fee.to_be_bytes::<32>())
+            .chain(self.gas_limit.to_be_bytes())
+            .chain(self.num_txs.to_be_bytes())
+            .chain(self.num_l1_msgs.to_be_bytes())
+            .collect()
+    }
+}
+
+/// Represents header-like information for the chunk.
+#[derive(
+    Debug,
+    Clone,
+    rkyv::Archive,
+    rkyv::Deserialize,
+    rkyv::Serialize,
+    serde::Deserialize,
+    serde::Serialize,
+)]
+#[rkyv(derive(Debug))]
+pub struct ChunkInfo {
+    /// The EIP-155 chain ID for all txs in the chunk.
+    #[rkyv()]
+    pub chain_id: u64,
+    /// The state root before applying the chunk.
+    #[rkyv()]
+    pub prev_state_root: B256,
+    /// The state root after applying the chunk.
+    #[rkyv()]
+    pub post_state_root: B256,
+    /// The withdrawals root after applying the chunk.
+    #[rkyv()]
+    pub withdraw_root: B256,
+    /// Digest of L1 message txs force included in the chunk.
+    /// It is a legacy field and can be omitted in new defination
+    #[rkyv()]
+    #[serde(default)]
+    pub data_hash: B256,
+    /// Digest of L2 tx data flattened over all L2 txs in the chunk.
+    #[rkyv()]
+    pub tx_data_digest: B256,
+    /// The L1 msg queue hash at the end of the previous chunk.
+    #[rkyv()]
+    pub prev_msg_queue_hash: B256,
+    /// The L1 msg queue hash at the end of the current chunk.
+    #[rkyv()]
+    pub post_msg_queue_hash: B256,
+    /// The length of rlp encoded L2 tx bytes flattened over all L2 txs in the chunk.
+    #[rkyv()]
+    pub tx_data_length: u64,
+    /// The block number of the first block in the chunk.
+    #[rkyv()]
+    pub initial_block_number: u64,
+    /// The block contexts of the blocks in the chunk.
+    #[rkyv()]
+    pub block_ctxs: Vec<BlockContextV2>,
+}
+
+impl ChunkInfo {
+    /// Public input hash for a given chunk (euclidv1 or da-codec@v6) is defined as
+    ///
+    /// keccak(
+    ///     chain id ||
+    ///     prev state root ||
+    ///     post state root ||
+    ///     withdraw root ||
+    ///     chunk data hash ||
+    ///     tx data hash
+    /// )
+    pub fn pi_hash_euclidv1(&self) -> B256 {
+        keccak256(
+            std::iter::empty()
+                .chain(&self.chain_id.to_be_bytes())
+                .chain(self.prev_state_root.as_slice())
+                .chain(self.post_state_root.as_slice())
+                .chain(self.withdraw_root.as_slice())
+                .chain(self.data_hash.as_slice())
+                .chain(self.tx_data_digest.as_slice())
+                .cloned()
+                .collect::<Vec<u8>>(),
+        )
+    }
+
+    /// Public input hash for a given chunk (euclidv2 or da-codec@v7) is defined as
+    ///
+    /// keccak(
+    ///     chain id ||
+    ///     prev state root ||
+    ///     post state root ||
+    ///     withdraw root ||
+    ///     tx data digest ||
+    ///     prev msg queue hash ||
+    ///     post msg queue hash ||
+    ///     initial block number ||
+    ///     block_ctx for block_ctx in block_ctxs
+    /// )
+    pub fn pi_hash_euclidv2(&self) -> B256 {
+        keccak256(
+            std::iter::empty()
+                .chain(&self.chain_id.to_be_bytes())
+                .chain(self.prev_state_root.as_slice())
+                .chain(self.post_state_root.as_slice())
+                .chain(self.withdraw_root.as_slice())
+                .chain(self.tx_data_digest.as_slice())
+                .chain(self.prev_msg_queue_hash.as_slice())
+                .chain(self.post_msg_queue_hash.as_slice())
+                .chain(&self.initial_block_number.to_be_bytes())
+                .chain(
+                    self.block_ctxs
+                        .iter()
+                        .flat_map(|block_ctx| block_ctx.to_bytes())
+                        .collect::<Vec<u8>>()
+                        .as_slice(),
+                )
+                .cloned()
+                .collect::<Vec<u8>>(),
+        )
+    }
+}
+
+impl From<&ArchivedChunkInfo> for ChunkInfo {
+    fn from(archived: &ArchivedChunkInfo) -> Self {
+        Self {
+            chain_id: archived.chain_id.into(),
+            prev_state_root: archived.prev_state_root.into(),
+            post_state_root: archived.post_state_root.into(),
+            withdraw_root: archived.withdraw_root.into(),
+            data_hash: archived.data_hash.into(),
+            tx_data_digest: archived.tx_data_digest.into(),
+            prev_msg_queue_hash: archived.prev_msg_queue_hash.into(),
+            post_msg_queue_hash: archived.post_msg_queue_hash.into(),
+            tx_data_length: archived.tx_data_length.into(),
+            initial_block_number: archived.initial_block_number.into(),
+            block_ctxs: archived
+                .block_ctxs
+                .iter()
+                .map(BlockContextV2::from)
+                .collect(),
+        }
+    }
+}
+
+pub type VersionedChunkInfo = (ChunkInfo, ForkName);
+
+impl MultiVersionPublicInputs for ChunkInfo {
+    /// Compute the public input hash for the chunk.
+    fn pi_hash_by_fork(&self, fork_name: ForkName) -> B256 {
+        match fork_name {
+            ForkName::EuclidV1 => {
+                assert_ne!(self.data_hash, B256::ZERO, "v6 must has valid data hash");
+                self.pi_hash_euclidv1()
+            }
+            ForkName::EuclidV2 => self.pi_hash_euclidv2(),
+        }
+    }
+
+    /// Validate public inputs between 2 contiguous chunks.
+    ///
+    /// - chain id MUST match
+    /// - state roots MUST be chained
+    /// - L1 msg queue hash MUST be chained
+    fn validate(&self, prev_pi: &Self, fork_name: ForkName) {
+        assert_eq!(self.chain_id, prev_pi.chain_id);
+        assert_eq!(self.prev_state_root, prev_pi.post_state_root);
+        assert_eq!(self.prev_msg_queue_hash, prev_pi.post_msg_queue_hash);
+
+        // message queue hash is used only after euclidv2 (da-codec@v7)
+        if fork_name == ForkName::EuclidV1 {
+            assert_eq!(self.prev_msg_queue_hash, B256::ZERO);
+            assert_eq!(prev_pi.prev_msg_queue_hash, B256::ZERO);
+            assert_eq!(self.post_msg_queue_hash, B256::ZERO);
+            assert_eq!(prev_pi.post_msg_queue_hash, B256::ZERO);
+        }
+    }
+}

common/types-rs/base/src/utils/hash.rs

@@ -0,0 +1,35 @@
+use alloy_primitives::B256;
+use tiny_keccak::{Hasher, Keccak};
+
+/// From the utility of ether-rs
+///
+/// Computes the Keccak-256 hash of input bytes.
+///
+/// Note that strings are interpreted as UTF-8 bytes,
+pub fn keccak256<T: AsRef<[u8]>>(bytes: T) -> B256 {
+    let mut output = [0u8; 32];
+
+    let mut hasher = Keccak::v256();
+    hasher.update(bytes.as_ref());
+    hasher.finalize(&mut output);
+
+    B256::from(output)
+}
+
+pub fn keccak256_rv32<T: AsRef<[u8]>>(bytes: T) -> B256 {
+    use sha3::{Digest, Keccak256};
+    let mut output = [0u8; 32];
+    let mut hasher = Keccak256::new();
+    hasher.update(bytes.as_ref());
+    output.copy_from_slice(hasher.finalize().as_ref());
+    B256::from(output)
+}
+
+pub fn sha256_rv32<T: AsRef<[u8]>>(bytes: T) -> B256 {
+    use sha2::{Digest, Sha256};
+    let mut output = [0u8; 32];
+    let mut hasher = Sha256::new();
+    hasher.update(bytes.as_ref());
+    output.copy_from_slice(hasher.finalize().as_ref());
+    B256::from(output)
+}

common/types-rs/base/src/utils/mod.rs

@@ -0,0 +1,2 @@
+mod hash;
+pub use hash::{keccak256, keccak256_rv32, sha256_rv32};

common/types-rs/batch/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "scroll-zkvm-circuit-input-types-batch"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+readme.workspace = true
+repository.workspace = true
+version = "0.2.0"
+
+[dependencies]
+alloy-primitives = { workspace = true, default-features = false, features = ["std", "map-hashbrown", "map-fxhash", "rkyv"] }
+rkyv.workspace = true
+serde.workspace = true
+itertools.workspace = true
+vm-zstd = { workspace = true }
+
+types-base = { path = "../base", package = "scroll-zkvm-circuit-input-types-base"}
+types-agg = { path = "../aggregation", package = "scroll-zkvm-circuit-input-types-aggregation"}
+
+[features]
+default = []

common/types-rs/batch/src/header/mod.rs

@@ -0,0 +1,30 @@
+use alloy_primitives::B256;
+
+pub mod v6;
+
+pub mod v7;
+
+pub trait BatchHeader {
+    /// The DA-codec version for the batch header.
+    fn version(&self) -> u8;
+
+    /// The incremental index of the batch.
+    fn index(&self) -> u64;
+
+    /// The batch header digest of the parent batch.
+    fn parent_batch_hash(&self) -> B256;
+
+    /// The batch header digest.
+    fn batch_hash(&self) -> B256;
+}
+
+/// Reference header indicate the version of batch header base on which batch hash
+/// should be calculated.
+#[derive(Clone, Debug, rkyv::Archive, rkyv::Deserialize, rkyv::Serialize)]
+#[rkyv(derive(Debug))]
+pub enum ReferenceHeader {
+    /// Represents DA-codec v6.
+    V6(v6::BatchHeaderV6),
+    /// Represents DA-codec v7.
+    V7(v7::BatchHeaderV7),
+}

common/types-rs/batch/src/header/v6.rs

@@ -0,0 +1,151 @@
+use super::BatchHeader;
+use alloy_primitives::B256;
+use types_base::utils::keccak256;
+
+/// Represents the header summarising the batch of chunks as per DA-codec v6.
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    rkyv::Archive,
+    rkyv::Deserialize,
+    rkyv::Serialize,
+    serde::Deserialize,
+    serde::Serialize,
+)]
+#[rkyv(derive(Debug))]
+pub struct BatchHeaderV6 {
+    /// The DA-codec version for the batch.
+    #[rkyv()]
+    pub version: u8,
+    /// The index of the batch
+    #[rkyv()]
+    pub batch_index: u64,
+    /// Number of L1 messages popped in the batch
+    #[rkyv()]
+    pub l1_message_popped: u64,
+    /// Number of total L1 messages popped after the batch
+    #[rkyv()]
+    pub total_l1_message_popped: u64,
+    /// The parent batch hash
+    #[rkyv()]
+    pub parent_batch_hash: B256,
+    /// The timestamp of the last block in this batch
+    #[rkyv()]
+    pub last_block_timestamp: u64,
+    /// The data hash of the batch
+    #[rkyv()]
+    pub data_hash: B256,
+    /// The versioned hash of the blob with this batch's data
+    #[rkyv()]
+    pub blob_versioned_hash: B256,
+    /// The blob data proof: z (32), y (32)
+    #[rkyv()]
+    pub blob_data_proof: [B256; 2],
+}
+
+impl BatchHeader for BatchHeaderV6 {
+    fn version(&self) -> u8 {
+        self.version
+    }
+
+    fn index(&self) -> u64 {
+        self.batch_index
+    }
+
+    fn parent_batch_hash(&self) -> B256 {
+        self.parent_batch_hash
+    }
+
+    /// Batch hash as per DA-codec v6:
+    ///
+    /// keccak(
+    ///     version ||
+    ///     batch index ||
+    ///     l1 message popped ||
+    ///     total l1 message popped ||
+    ///     batch data hash ||
+    ///     versioned hash ||
+    ///     parent batch hash ||
+    ///     last block timestamp ||
+    ///     z ||
+    ///     y
+    /// )
+    fn batch_hash(&self) -> B256 {
+        keccak256(
+            std::iter::empty()
+                .chain(vec![self.version].as_slice())
+                .chain(self.batch_index.to_be_bytes().as_slice())
+                .chain(self.l1_message_popped.to_be_bytes().as_slice())
+                .chain(self.total_l1_message_popped.to_be_bytes().as_slice())
+                .chain(self.data_hash.as_slice())
+                .chain(self.blob_versioned_hash.as_slice())
+                .chain(self.parent_batch_hash.as_slice())
+                .chain(self.last_block_timestamp.to_be_bytes().as_slice())
+                .chain(self.blob_data_proof[0].as_slice())
+                .chain(self.blob_data_proof[1].as_slice())
+                .cloned()
+                .collect::<Vec<u8>>(),
+        )
+    }
+}
+
+impl BatchHeader for ArchivedBatchHeaderV6 {
+    fn version(&self) -> u8 {
+        self.version
+    }
+
+    fn index(&self) -> u64 {
+        self.batch_index.into()
+    }
+
+    fn parent_batch_hash(&self) -> B256 {
+        self.parent_batch_hash.into()
+    }
+
+    fn batch_hash(&self) -> B256 {
+        let batch_index: u64 = self.batch_index.into();
+        let l1_message_popped: u64 = self.l1_message_popped.into();
+        let total_l1_message_popped: u64 = self.total_l1_message_popped.into();
+        let data_hash: B256 = self.data_hash.into();
+        let blob_versioned_hash: B256 = self.blob_versioned_hash.into();
+        let parent_batch_hash: B256 = self.parent_batch_hash.into();
+        let last_block_timestamp: u64 = self.last_block_timestamp.into();
+        let blob_data_proof: [B256; 2] = self.blob_data_proof.map(|h| h.into());
+        keccak256(
+            std::iter::empty()
+                .chain(vec![self.version].as_slice())
+                .chain(batch_index.to_be_bytes().as_slice())
+                .chain(l1_message_popped.to_be_bytes().as_slice())
+                .chain(total_l1_message_popped.to_be_bytes().as_slice())
+                .chain(data_hash.as_slice())
+                .chain(blob_versioned_hash.as_slice())
+                .chain(parent_batch_hash.as_slice())
+                .chain(last_block_timestamp.to_be_bytes().as_slice())
+                .chain(blob_data_proof[0].as_slice())
+                .chain(blob_data_proof[1].as_slice())
+                .cloned()
+                .collect::<Vec<u8>>(),
+        )
+    }
+}
+
+impl From<&ArchivedBatchHeaderV6> for BatchHeaderV6 {
+    fn from(archived: &ArchivedBatchHeaderV6) -> Self {
+        Self {
+            version: archived.version,
+            batch_index: archived.batch_index.into(),
+            l1_message_popped: archived.l1_message_popped.into(),
+            total_l1_message_popped: archived.total_l1_message_popped.into(),
+            parent_batch_hash: archived.parent_batch_hash.into(),
+            last_block_timestamp: archived.last_block_timestamp.into(),
+            data_hash: archived.data_hash.into(),
+            blob_versioned_hash: archived.blob_versioned_hash.into(),
+            blob_data_proof: [
+                archived.blob_data_proof[0].into(),
+                archived.blob_data_proof[1].into(),
+            ],
+        }
+    }
+}

common/types-rs/batch/src/header/v7.rs

@@ -0,0 +1,106 @@
+use alloy_primitives::B256;
+
+use super::BatchHeader;
+use types_base::utils::keccak256;
+
+/// Represents the header summarising the batch of chunks as per DA-codec v7.
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    rkyv::Archive,
+    rkyv::Deserialize,
+    rkyv::Serialize,
+    serde::Deserialize,
+    serde::Serialize,
+)]
+#[rkyv(derive(Debug))]
+pub struct BatchHeaderV7 {
+    /// The DA-codec version for the batch.
+    #[rkyv()]
+    pub version: u8,
+    /// The index of the batch
+    #[rkyv()]
+    pub batch_index: u64,
+    /// The parent batch hash
+    #[rkyv()]
+    pub parent_batch_hash: B256,
+    /// The versioned hash of the blob with this batch's data
+    #[rkyv()]
+    pub blob_versioned_hash: B256,
+}
+
+impl BatchHeader for BatchHeaderV7 {
+    fn version(&self) -> u8 {
+        self.version
+    }
+
+    fn index(&self) -> u64 {
+        self.batch_index
+    }
+
+    fn parent_batch_hash(&self) -> B256 {
+        self.parent_batch_hash
+    }
+
+    /// Batch hash as per DA-codec v7:
+    ///
+    /// keccak(
+    ///     version ||
+    ///     batch index ||
+    ///     versioned hash ||
+    ///     parent batch hash
+    /// )
+    fn batch_hash(&self) -> B256 {
+        keccak256(
+            std::iter::empty()
+                .chain(vec![self.version].as_slice())
+                .chain(self.batch_index.to_be_bytes().as_slice())
+                .chain(self.blob_versioned_hash.as_slice())
+                .chain(self.parent_batch_hash.as_slice())
+                .cloned()
+                .collect::<Vec<u8>>(),
+        )
+    }
+}
+
+impl BatchHeader for ArchivedBatchHeaderV7 {
+    fn version(&self) -> u8 {
+        self.version
+    }
+
+    fn index(&self) -> u64 {
+        self.batch_index.into()
+    }
+
+    fn parent_batch_hash(&self) -> B256 {
+        self.parent_batch_hash.into()
+    }
+
+    fn batch_hash(&self) -> B256 {
+        let batch_index: u64 = self.batch_index.into();
+        let blob_versioned_hash: B256 = self.blob_versioned_hash.into();
+        let parent_batch_hash: B256 = self.parent_batch_hash.into();
+        keccak256(
+            std::iter::empty()
+                .chain(vec![self.version].as_slice())
+                .chain(batch_index.to_be_bytes().as_slice())
+                .chain(blob_versioned_hash.as_slice())
+                .chain(parent_batch_hash.as_slice())
+                .cloned()
+                .collect::<Vec<u8>>(),
+        )
+    }
+}
+
+impl From<&ArchivedBatchHeaderV7> for BatchHeaderV7 {
+    fn from(archived: &ArchivedBatchHeaderV7) -> Self {
+        Self {
+            version: archived.version,
+            batch_index: archived.batch_index.into(),
+            parent_batch_hash: archived.parent_batch_hash.into(),
+            blob_versioned_hash: archived.blob_versioned_hash.into(),
+        }
+    }
+}

common/types-rs/batch/src/lib.rs

@@ -0,0 +1,17 @@
+mod header;
+pub use header::{
+    ArchivedReferenceHeader, BatchHeader, ReferenceHeader,
+    v6::{ArchivedBatchHeaderV6, BatchHeaderV6},
+    v7::{ArchivedBatchHeaderV7, BatchHeaderV7},
+};
+
+mod payload;
+pub use payload::{
+    v6::{EnvelopeV6, PayloadV6},
+    v7::{EnvelopeV7, PayloadV7},
+};
+
+pub use payload::{BLOB_WIDTH, N_BLOB_BYTES, N_DATA_BYTES_PER_COEFFICIENT};
+
+mod witness;
+pub use witness::{ArchivedBatchWitness, BatchWitness, Bytes48, PointEvalWitness};

common/types-rs/batch/src/payload/mod.rs

@@ -0,0 +1,15 @@
+pub mod v6;
+pub mod v7;
+
+/// The number data bytes we pack each BLS12-381 scalar into. The most-significant byte is 0.
+pub const N_DATA_BYTES_PER_COEFFICIENT: usize = 31;
+
+/// The number of BLS12-381 scalar fields that effectively represent an EIP-4844 blob.
+pub const BLOB_WIDTH: usize = 4096;
+
+/// The effective (reduced) number of bytes we can use within a blob.
+///
+/// EIP-4844 requires that each 32-bytes chunk of bytes represent a BLS12-381 scalar field element
+/// in its canonical form. As a result, we set the most-significant byte in each such chunk to 0.
+/// This allows us to use only up to 31 bytes in each such chunk, hence the reduced capacity.
+pub const N_BLOB_BYTES: usize = BLOB_WIDTH * N_DATA_BYTES_PER_COEFFICIENT;

common/types-rs/batch/src/payload/v6.rs

@@ -0,0 +1,212 @@
+use alloy_primitives::B256;
+use itertools::Itertools;
+
+use crate::BatchHeaderV6;
+use types_base::{public_inputs::chunk::ChunkInfo, utils::keccak256};
+
+/// The default max chunks for v6 payload
+pub const N_MAX_CHUNKS: usize = 45;
+
+/// The number of bytes to encode number of chunks in a batch.
+const N_BYTES_NUM_CHUNKS: usize = 2;
+
+/// The number of rows to encode chunk size (u32).
+const N_BYTES_CHUNK_SIZE: usize = 4;
+
+impl From<&[u8]> for EnvelopeV6 {
+    fn from(blob_bytes: &[u8]) -> Self {
+        let is_encoded = blob_bytes[0] & 1 == 1;
+        Self {
+            is_encoded,
+            envelope_bytes: if blob_bytes[0] & 1 == 1 {
+                vm_zstd::process(&blob_bytes[1..]).unwrap().decoded_data
+            } else {
+                Vec::from(&blob_bytes[1..])
+            },
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct EnvelopeV6 {
+    /// The original envelope bytes supplied.
+    ///
+    /// Caching just for re-use later in challenge digest computation.
+    pub envelope_bytes: Vec<u8>,
+    /// If the enveloped bytes is encoded (compressed) in envelop
+    pub is_encoded: bool,
+}
+
+impl EnvelopeV6 {
+    /// Parse payload bytes and obtain challenge digest
+    pub fn challenge_digest(&self, versioned_hash: B256) -> B256 {
+        let payload = Payload::from(self);
+        payload.get_challenge_digest(versioned_hash)
+    }
+}
+
+impl From<&EnvelopeV6> for Payload {
+    fn from(envelope: &EnvelopeV6) -> Self {
+        Self::from_payload(&envelope.envelope_bytes)
+    }
+}
+
+/// Payload that describes a batch.
+#[derive(Clone, Debug, Default)]
+pub struct Payload {
+    /// Metadata that encodes the sizes of every chunk in the batch.
+    pub metadata_digest: B256,
+    /// The Keccak digests of transaction bytes for every chunk in the batch.
+    ///
+    /// The `chunk_data_digest` is a part of the chunk-circuit's public input and hence used to
+    /// verify that the transaction bytes included in the chunk-circuit indeed match the
+    /// transaction bytes made available in the batch.
+    pub chunk_data_digests: Vec<B256>,
+}
+
+pub type PayloadV6 = Payload;
+
+impl Payload {
+    /// For raw payload data (read from decompressed enveloped data), which is raw batch bytes
+    /// with metadata, this function segments the byte stream into chunk segments.
+    ///
+    /// This method is used INSIDE OF zkvm since we can not generate (compress) batch data within
+    /// the vm program
+    ///
+    /// The structure of batch bytes is as follows:
+    ///
+    /// | Byte Index                                                   | Size                          | Hint                                |
+    /// |--------------------------------------------------------------|-------------------------------|-------------------------------------|
+    /// | 0                                                            | N_BYTES_NUM_CHUNKS            | Number of chunks                    |
+    /// | N_BYTES_NUM_CHUNKS                                           | N_BYTES_CHUNK_SIZE            | Size of chunks[0]                   |
+    /// | N_BYTES_NUM_CHUNKS + N_BYTES_CHUNK_SIZE                      | N_BYTES_CHUNK_SIZE            | Size of chunks[1]                   |
+    /// | N_BYTES_NUM_CHUNKS + (i * N_BYTES_CHUNK_SIZE)                | N_BYTES_CHUNK_SIZE            | Size of chunks[i]                   |
+    /// | N_BYTES_NUM_CHUNKS + ((N_MAX_CHUNKS-1) * N_BYTES_CHUNK_SIZE) | N_BYTES_CHUNK_SIZE            | Size of chunks[N_MAX_CHUNKS-1]      |
+    /// | N_BYTES_NUM_CHUNKS + (N_MAX_CHUNKS * N_BYTES_CHUNK_SIZE)     | Size of chunks[0]             | L2 tx bytes of chunks[0]            |
+    /// | "" + Size_of_chunks[0]                                       | Size of chunks[1]             | L2 tx bytes of chunks[1]            |
+    /// | "" + Size_of_chunks[i-1]                                     | Size of chunks[i]             | L2 tx bytes of chunks[i]            |
+    /// | "" + Size_of_chunks[Num_chunks-1]                            | Size of chunks[Num_chunks-1]  | L2 tx bytes of chunks[Num_chunks-1] |
+    pub fn from_payload(batch_bytes_with_metadata: &[u8]) -> Self {
+        // Get the metadata bytes and metadata digest.
+        let n_bytes_metadata = Self::n_bytes_metadata();
+        let metadata_bytes = &batch_bytes_with_metadata[..n_bytes_metadata];
+        let metadata_digest = keccak256(metadata_bytes);
+
+        // The remaining bytes represent the chunk data (L2 tx bytes) segmented as chunks.
+        let batch_bytes = &batch_bytes_with_metadata[n_bytes_metadata..];
+
+        // The number of chunks in the batch.
+        let valid_chunks = metadata_bytes[..N_BYTES_NUM_CHUNKS]
+            .iter()
+            .fold(0usize, |acc, &d| acc * 256usize + d as usize);
+
+        // The size of each chunk in the batch.
+        let chunk_sizes = metadata_bytes[N_BYTES_NUM_CHUNKS..]
+            .iter()
+            .chunks(N_BYTES_CHUNK_SIZE)
+            .into_iter()
+            .map(|bytes| bytes.fold(0usize, |acc, &d| acc * 256usize + d as usize))
+            .collect::<Vec<usize>>();
+
+        // For every unused chunk, the chunk size should be set to 0.
+        for &unused_chunk_size in chunk_sizes.iter().skip(valid_chunks) {
+            assert_eq!(unused_chunk_size, 0, "unused chunk has size 0");
+        }
+
+        // Segment the batch bytes based on the chunk sizes.
+        let (segmented_batch_data, remaining_bytes) =
+            chunk_sizes.into_iter().take(valid_chunks).fold(
+                (Vec::new(), batch_bytes),
+                |(mut datas, rest_bytes), size| {
+                    datas.push(Vec::from(&rest_bytes[..size]));
+                    (datas, &rest_bytes[size..])
+                },
+            );
+
+        // After segmenting the batch data into chunks, no bytes should be left.
+        assert!(
+            remaining_bytes.is_empty(),
+            "chunk segmentation len must add up to the correct value"
+        );
+
+        // Compute the chunk data digests based on the segmented data.
+        let chunk_data_digests = segmented_batch_data
+            .iter()
+            .map(|bytes| B256::from(keccak256(bytes)))
+            .collect();
+
+        Self {
+            metadata_digest,
+            chunk_data_digests,
+        }
+    }
+
+    /// Compute the challenge digest from blob bytes. which is the combination of
+    /// digest for bytes in each chunk
+    pub fn get_challenge_digest(&self, versioned_hash: B256) -> B256 {
+        keccak256(self.get_challenge_digest_preimage(versioned_hash))
+    }
+
+    /// The number of bytes in payload Data to represent the "payload metadata" section: a u16 to
+    /// represent the size of chunks and max_chunks * u32 to represent chunk sizes
+    const fn n_bytes_metadata() -> usize {
+        N_BYTES_NUM_CHUNKS + (N_MAX_CHUNKS * N_BYTES_CHUNK_SIZE)
+    }
+
+    /// Validate the payload contents.
+    pub fn validate<'a>(
+        &self,
+        header: &BatchHeaderV6,
+        chunk_infos: &'a [ChunkInfo],
+    ) -> (&'a ChunkInfo, &'a ChunkInfo) {
+        // There should be at least 1 chunk info.
+        assert!(!chunk_infos.is_empty(), "at least 1 chunk info");
+
+        // Get the first and last chunks' info, to construct the batch info.
+        let (first_chunk, last_chunk) = (
+            chunk_infos.first().expect("at least one chunk in batch"),
+            chunk_infos.last().expect("at least one chunk in batch"),
+        );
+
+        for (&chunk_data_digest, chunk_info) in self.chunk_data_digests.iter().zip_eq(chunk_infos) {
+            assert_eq!(chunk_data_digest, chunk_info.tx_data_digest)
+        }
+
+        // Validate the l1-msg identifier data_hash for the batch.
+        let batch_data_hash_preimage = chunk_infos
+            .iter()
+            .flat_map(|chunk_info| chunk_info.data_hash.0)
+            .collect::<Vec<_>>();
+        let batch_data_hash = keccak256(batch_data_hash_preimage);
+        assert_eq!(batch_data_hash, header.data_hash);
+
+        (first_chunk, last_chunk)
+    }
+
+    /// Get the preimage for the challenge digest.
+    pub(crate) fn get_challenge_digest_preimage(&self, versioned_hash: B256) -> Vec<u8> {
+        // preimage =
+        //     metadata_digest ||
+        //     chunk[0].chunk_data_digest || ...
+        //     chunk[N_SNARKS-1].chunk_data_digest ||
+        //     blob_versioned_hash
+        //
+        // where chunk_data_digest for a padded chunk is set equal to the "last valid chunk"'s
+        // chunk_data_digest.
+        let mut preimage = self.metadata_digest.to_vec();
+        let last_digest = self
+            .chunk_data_digests
+            .last()
+            .expect("at least we have one");
+        for chunk_digest in self
+            .chunk_data_digests
+            .iter()
+            .chain(std::iter::repeat(last_digest))
+            .take(N_MAX_CHUNKS)
+        {
+            preimage.extend_from_slice(chunk_digest.as_slice());
+        }
+        preimage.extend_from_slice(versioned_hash.as_slice());
+        preimage
+    }
+}

common/types-rs/batch/src/payload/v7.rs

@@ -0,0 +1,256 @@
+use alloy_primitives::B256;
+
+use crate::BatchHeaderV7;
+use types_base::{
+    public_inputs::chunk::{BlockContextV2, ChunkInfo, SIZE_BLOCK_CTX},
+    utils::keccak256,
+};
+
+use super::N_BLOB_BYTES;
+
+/// da-codec@v7
+const DA_CODEC_VERSION: u8 = 7;
+
+/// Represents the data contained within an EIP-4844 blob that is published on-chain.
+///
+/// The bytes following some metadata represent zstd-encoded [`PayloadV7`] if the envelope is
+/// indicated as `is_encoded == true`.
+#[derive(Debug, Clone)]
+pub struct EnvelopeV7 {
+    /// The original envelope bytes supplied.
+    ///
+    /// Caching just for re-use later in challenge digest computation.
+    pub envelope_bytes: Vec<u8>,
+    /// The version from da-codec, i.e. v7 in this case.
+    pub version: u8,
+    /// A single byte boolean flag (value is 0 or 1) to denote whether or not the following blob
+    /// bytes represent a batch in its zstd-encoded or raw form.
+    pub is_encoded: u8,
+    /// The unpadded bytes that possibly encode the [`PayloadV7`].
+    pub unpadded_bytes: Vec<u8>,
+}
+
+impl From<&[u8]> for EnvelopeV7 {
+    fn from(blob_bytes: &[u8]) -> Self {
+        // The number of bytes is as expected.
+        assert_eq!(blob_bytes.len(), N_BLOB_BYTES);
+
+        // The version of the blob encoding was as expected, i.e. da-codec@v7.
+        let version = blob_bytes[0];
+        assert_eq!(version, DA_CODEC_VERSION);
+
+        // Calculate the unpadded size of the encoded payload.
+        //
+        // It should be at most the maximum number of bytes allowed.
+        let unpadded_size = (blob_bytes[1] as usize) * 256 * 256
+            + (blob_bytes[2] as usize) * 256
+            + blob_bytes[3] as usize;
+        assert!(unpadded_size <= N_BLOB_BYTES - 5);
+
+        // Whether the envelope represents encoded payload or raw payload.
+        //
+        // Is a boolean.
+        let is_encoded = blob_bytes[4];
+        assert!(is_encoded <= 1);
+
+        // The padded bytes are all 0s.
+        for &padded_byte in blob_bytes.iter().skip(5 + unpadded_size) {
+            assert_eq!(padded_byte, 0);
+        }
+
+        Self {
+            version,
+            is_encoded,
+            unpadded_bytes: blob_bytes[5..(5 + unpadded_size)].to_vec(),
+            envelope_bytes: blob_bytes.to_vec(),
+        }
+    }
+}
+
+impl EnvelopeV7 {
+    /// The verification of the EIP-4844 blob is done via point-evaluation precompile
+    /// implemented in-circuit.
+    ///
+    /// We require a random challenge point for this, and using Fiat-Shamir we compute it with
+    /// every byte in the blob along with the blob's versioned hash, i.e. an identifier for its KZG
+    /// commitment.
+    ///
+    /// keccak256(
+    ///     keccak256(envelope) ||
+    ///     versioned hash
+    /// )
+    pub fn challenge_digest(&self, versioned_hash: B256) -> B256 {
+        keccak256(
+            std::iter::empty()
+                .chain(keccak256(&self.envelope_bytes))
+                .chain(versioned_hash.0)
+                .collect::<Vec<u8>>(),
+        )
+    }
+}
+
+/// Represents the batch data, eventually encoded into an [`EnvelopeV7`].
+///
+/// | Field                  | # Bytes | Type           | Index         |
+/// |------------------------|---------|----------------|---------------|
+/// | prevL1MessageQueueHash | 32      | bytes32        | 0             |
+/// | postL1MessageQueueHash | 32      | bytes32        | 32            |
+/// | initialL2BlockNumber   | 8       | u64            | 64            |
+/// | numBlocks              | 2       | u16            | 72            |
+/// | blockCtxs[0]           | 52      | BlockContextV2 | 74            |
+/// | ... blockCtxs[i] ...   | 52      | BlockContextV2 | 74 + 52*i     |
+/// | blockCtxs[n-1]         | 52      | BlockContextV2 | 74 + 52*(n-1) |
+/// | l2TxsData              | dynamic | bytes          | 74 + 52*n     |
+#[derive(Debug, Clone)]
+pub struct PayloadV7 {
+    /// The version from da-codec, i.e. v7 in this case.
+    ///
+    /// Note: This is not really a part of payload, simply coopied from the envelope for
+    /// convenience.
+    pub version: u8,
+    /// Message queue hash at the end of the previous batch.
+    pub prev_msg_queue_hash: B256,
+    /// Message queue hash at the end of the current batch.
+    pub post_msg_queue_hash: B256,
+    /// The block number of the first block in the batch.
+    pub initial_block_number: u64,
+    /// The number of blocks in the batch.
+    pub num_blocks: u16,
+    /// The block contexts of each block in the batch.
+    pub block_contexts: Vec<BlockContextV2>,
+    /// The L2 tx data flattened over every tx in every block in the batch.
+    pub tx_data: Vec<u8>,
+}
+
+const INDEX_PREV_MSG_QUEUE_HASH: usize = 0;
+const INDEX_POST_MSG_QUEUE_HASH: usize = INDEX_PREV_MSG_QUEUE_HASH + 32;
+const INDEX_L2_BLOCK_NUM: usize = INDEX_POST_MSG_QUEUE_HASH + 32;
+const INDEX_NUM_BLOCKS: usize = INDEX_L2_BLOCK_NUM + 8;
+const INDEX_BLOCK_CTX: usize = INDEX_NUM_BLOCKS + 2;
+
+impl From<&EnvelopeV7> for PayloadV7 {
+    fn from(envelope: &EnvelopeV7) -> Self {
+        // Conditionally decode depending on the flag set in the envelope.
+        let payload_bytes = if envelope.is_encoded & 1 == 1 {
+            vm_zstd::process(&envelope.unpadded_bytes)
+                .expect("zstd decode should succeed")
+                .decoded_data
+        } else {
+            envelope.unpadded_bytes.to_vec()
+        };
+
+        // Sanity check on the payload size.
+        assert!(payload_bytes.len() >= INDEX_BLOCK_CTX);
+        let num_blocks = u16::from_be_bytes(
+            payload_bytes[INDEX_NUM_BLOCKS..INDEX_BLOCK_CTX]
+                .try_into()
+                .expect("should not fail"),
+        );
+        assert!(payload_bytes.len() >= INDEX_BLOCK_CTX + ((num_blocks as usize) * SIZE_BLOCK_CTX));
+
+        // Deserialize the other fields.
+        let prev_msg_queue_hash =
+            B256::from_slice(&payload_bytes[INDEX_PREV_MSG_QUEUE_HASH..INDEX_POST_MSG_QUEUE_HASH]);
+        let post_msg_queue_hash =
+            B256::from_slice(&payload_bytes[INDEX_POST_MSG_QUEUE_HASH..INDEX_L2_BLOCK_NUM]);
+        let initial_block_number = u64::from_be_bytes(
+            payload_bytes[INDEX_L2_BLOCK_NUM..INDEX_NUM_BLOCKS]
+                .try_into()
+                .expect("should not fail"),
+        );
+
+        // Deserialize block contexts depending on the number of blocks in the batch.
+        let mut block_contexts = Vec::with_capacity(num_blocks as usize);
+        for i in 0..num_blocks {
+            let start = (i as usize) * SIZE_BLOCK_CTX + INDEX_BLOCK_CTX;
+            block_contexts.push(BlockContextV2::from(
+                &payload_bytes[start..(start + SIZE_BLOCK_CTX)],
+            ));
+        }
+
+        // All remaining bytes are flattened L2 txs.
+        let tx_data =
+            payload_bytes[INDEX_BLOCK_CTX + ((num_blocks as usize) * SIZE_BLOCK_CTX)..].to_vec();
+
+        Self {
+            version: envelope.version,
+            prev_msg_queue_hash,
+            post_msg_queue_hash,
+            initial_block_number,
+            num_blocks,
+            block_contexts,
+            tx_data,
+        }
+    }
+}
+
+impl PayloadV7 {
+    /// Validate the payload contents.
+    pub fn validate<'a>(
+        &self,
+        header: &BatchHeaderV7,
+        chunk_infos: &'a [ChunkInfo],
+    ) -> (&'a ChunkInfo, &'a ChunkInfo) {
+        // Get the first and last chunks' info, to construct the batch info.
+        let (first_chunk, last_chunk) = (
+            chunk_infos.first().expect("at least one chunk in batch"),
+            chunk_infos.last().expect("at least one chunk in batch"),
+        );
+
+        // version from payload is what's present in the on-chain batch header
+        assert_eq!(self.version, header.version);
+
+        // number of blocks in the batch
+        assert_eq!(
+            usize::from(self.num_blocks),
+            chunk_infos
+                .iter()
+                .flat_map(|chunk_info| &chunk_info.block_ctxs)
+                .count()
+        );
+        assert_eq!(usize::from(self.num_blocks), self.block_contexts.len());
+
+        // the block number of the first block in the batch
+        assert_eq!(self.initial_block_number, first_chunk.initial_block_number);
+
+        // prev message queue hash
+        assert_eq!(self.prev_msg_queue_hash, first_chunk.prev_msg_queue_hash);
+
+        // post message queue hash
+        assert_eq!(self.post_msg_queue_hash, last_chunk.post_msg_queue_hash);
+
+        // for each chunk, the tx_data_digest, i.e. keccak digest of the rlp-encoded L2 tx bytes
+        // flattened over every tx in the chunk, should be re-computed and matched against the
+        // public input of the chunk-circuit.
+        //
+        // first check that the total size of rlp-encoded tx data flattened over all txs in the
+        // chunk is in fact the size available from the payload.
+        assert_eq!(
+            u64::try_from(self.tx_data.len()).expect("len(tx-data) is u64"),
+            chunk_infos
+                .iter()
+                .map(|chunk_info| chunk_info.tx_data_length)
+                .sum::<u64>(),
+        );
+        let mut index: usize = 0;
+        for chunk_info in chunk_infos.iter() {
+            let chunk_size = chunk_info.tx_data_length as usize;
+            let chunk_tx_data_digest =
+                keccak256(&self.tx_data.as_slice()[index..(index + chunk_size)]);
+            assert_eq!(chunk_tx_data_digest, chunk_info.tx_data_digest);
+            index += chunk_size;
+        }
+
+        // for each block in the batch, check that the block context matches what's provided as
+        // witness.
+        for (block_ctx, witness_block_ctx) in self.block_contexts.iter().zip(
+            chunk_infos
+                .iter()
+                .flat_map(|chunk_info| &chunk_info.block_ctxs),
+        ) {
+            assert_eq!(block_ctx, witness_block_ctx);
+        }
+
+        (first_chunk, last_chunk)
+    }
+}

common/types-rs/batch/src/witness.rs

@@ -0,0 +1,57 @@
+use crate::header::ReferenceHeader;
+use types_agg::{AggregationInput, ProgramCommitment, ProofCarryingWitness};
+use types_base::public_inputs::{ForkName, chunk::ChunkInfo};
+
+/// Simply rewrap byte48 to avoid unnecessary dep
+pub type Bytes48 = [u8; 48];
+
+/// Witness required by applying point evaluation
+#[derive(Clone, Debug, rkyv::Archive, rkyv::Deserialize, rkyv::Serialize)]
+#[rkyv(derive(Debug))]
+pub struct PointEvalWitness {
+    /// kzg commitment
+    #[rkyv()]
+    pub kzg_commitment: Bytes48,
+    /// kzg proof
+    #[rkyv()]
+    pub kzg_proof: Bytes48,
+}
+
+/// Witness to the batch circuit.
+#[derive(Clone, Debug, rkyv::Archive, rkyv::Deserialize, rkyv::Serialize)]
+#[rkyv(derive(Debug))]
+pub struct BatchWitness {
+    /// Flattened root proofs from all chunks in the batch.
+    #[rkyv()]
+    pub chunk_proofs: Vec<AggregationInput>,
+    /// Chunk infos.
+    #[rkyv()]
+    pub chunk_infos: Vec<ChunkInfo>,
+    /// Blob bytes.
+    #[rkyv()]
+    pub blob_bytes: Vec<u8>,
+    /// Witness for point evaluation
+    pub point_eval_witness: PointEvalWitness,
+    /// Header for reference.
+    #[rkyv()]
+    pub reference_header: ReferenceHeader,
+    /// The code version specify the chain spec
+    #[rkyv()]
+    pub fork_name: ForkName,
+}
+
+impl ProofCarryingWitness for ArchivedBatchWitness {
+    fn get_proofs(&self) -> Vec<AggregationInput> {
+        self.chunk_proofs
+            .iter()
+            .map(|archived| AggregationInput {
+                public_values: archived
+                    .public_values
+                    .iter()
+                    .map(|u32_le| u32_le.to_native())
+                    .collect(),
+                commitment: ProgramCommitment::from(&archived.commitment),
+            })
+            .collect()
+    }
+}

common/types-rs/bundle/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "scroll-zkvm-circuit-input-types-bundle"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+readme.workspace = true
+repository.workspace = true
+version = "0.2.0"
+
+[dependencies]
+alloy-primitives = { workspace = true, default-features = false, features = ["std", "map-hashbrown", "map-fxhash", "rkyv"] }
+rkyv.workspace = true
+serde.workspace = true
+itertools.workspace = true
+vm-zstd = { workspace = true }
+
+types-base = { path = "../base", package = "scroll-zkvm-circuit-input-types-base"}
+types-agg = { path = "../aggregation", package = "scroll-zkvm-circuit-input-types-aggregation"}
+
+[features]
+default = []

common/types-rs/bundle/src/lib.rs

@@ -0,0 +1,2 @@
+mod witness;
+pub use witness::{ArchivedBundleWitness, BundleWitness};

common/types-rs/bundle/src/witness.rs

@@ -0,0 +1,30 @@
+use types_agg::{AggregationInput, ProgramCommitment, ProofCarryingWitness};
+use types_base::public_inputs::batch::BatchInfo;
+
+/// The witness for the bundle circuit.
+#[derive(Clone, Debug, rkyv::Archive, rkyv::Deserialize, rkyv::Serialize)]
+#[rkyv(derive(Debug))]
+pub struct BundleWitness {
+    /// Batch proofs being aggregated in the bundle.
+    #[rkyv()]
+    pub batch_proofs: Vec<AggregationInput>,
+    /// Public-input values for the corresponding batch proofs.
+    #[rkyv()]
+    pub batch_infos: Vec<BatchInfo>,
+}
+
+impl ProofCarryingWitness for ArchivedBundleWitness {
+    fn get_proofs(&self) -> Vec<AggregationInput> {
+        self.batch_proofs
+            .iter()
+            .map(|archived| AggregationInput {
+                public_values: archived
+                    .public_values
+                    .iter()
+                    .map(|u32_le| u32_le.to_native())
+                    .collect(),
+                commitment: ProgramCommitment::from(&archived.commitment),
+            })
+            .collect()
+    }
+}

common/types-rs/chunk/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "scroll-zkvm-circuit-input-types-chunk"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+readme.workspace = true
+repository.workspace = true
+version = "0.2.0"
+
+[dependencies]
+alloy-primitives = { workspace = true, default-features = false, features = ["std", "map-hashbrown", "map-fxhash", "rkyv"] }
+rkyv.workspace = true
+sbv-trie = { workspace = true }
+sbv-core = { workspace = true }
+sbv-primitives = { workspace = true }
+sbv-kv = { workspace = true }
+serde.workspace = true
+itertools.workspace = true
+
+openvm = { workspace = true, features = ["std"] }
+openvm-rv32im-guest = {  workspace = true }
+openvm-custom-insn = { workspace = true }
+
+types-base = { path = "../base", package = "scroll-zkvm-circuit-input-types-base"}
+
+[features]
+default = []
+openvm = ["sbv-trie/openvm", "sbv-core/openvm", "sbv-primitives/openvm"]

common/types-rs/chunk/src/execute.rs

@@ -0,0 +1,167 @@
+use sbv_core::{EvmDatabase, EvmExecutor};
+use sbv_primitives::{
+    BlockWitness,
+    chainspec::{
+        BaseFeeParams, BaseFeeParamsKind, Chain, MAINNET,
+        reth_chainspec::ChainSpec,
+        scroll::{ScrollChainConfig, ScrollChainSpec},
+    },
+    ext::{BlockWitnessChunkExt, TxBytesHashExt},
+    hardforks::SCROLL_DEV_HARDFORKS,
+    types::{
+        consensus::BlockHeader,
+        reth::{Block, BlockWitnessRethExt, RecoveredBlock},
+        scroll::ChunkInfoBuilder,
+    },
+};
+
+use crate::{ArchivedChunkWitness, make_providers, manually_drop_on_zkvm};
+use types_base::public_inputs::{
+    ForkName,
+    chunk::{BlockContextV2, ChunkInfo},
+};
+
+fn block_ctxv2_from_block(value: &RecoveredBlock<Block>) -> BlockContextV2 {
+    use alloy_primitives::U256;
+    BlockContextV2 {
+        timestamp: value.timestamp,
+        gas_limit: value.gas_limit,
+        base_fee: U256::from(value.base_fee_per_gas().expect("base_fee_expected")),
+        num_txs: u16::try_from(value.body().transactions.len()).expect("num txs u16"),
+        num_l1_msgs: u16::try_from(
+            value
+                .body()
+                .transactions
+                .iter()
+                .filter(|tx| tx.is_l1_message())
+                .count(),
+        )
+        .expect("num l1 msgs u16"),
+    }
+}
+
+type Witness = ArchivedChunkWitness;
+
+pub fn execute(witness: &Witness) -> Result<ChunkInfo, String> {
+    if witness.blocks.is_empty() {
+        return Err("At least one witness must be provided in chunk mode".into());
+    }
+    if !witness.blocks.has_same_chain_id() {
+        return Err("All witnesses must have the same chain id in chunk mode".into());
+    }
+    if !witness.blocks.has_seq_block_number() {
+        return Err("All witnesses must have sequential block numbers in chunk mode".into());
+    }
+    // Get the blocks to build the basic chunk-info.
+    let blocks = manually_drop_on_zkvm!(
+        witness
+            .blocks
+            .iter()
+            .map(|w| w.build_reth_block())
+            .collect::<Result<Vec<RecoveredBlock<Block>>, _>>()
+            .map_err(|e| e.to_string())?
+    );
+    let pre_state_root = witness.blocks[0].pre_state_root;
+
+    let fork_name = ForkName::from(&witness.fork_name);
+    let chain = Chain::from_id(witness.blocks[0].chain_id());
+
+    // SCROLL_DEV_HARDFORKS will enable all forks
+    let mut hardforks = (*SCROLL_DEV_HARDFORKS).clone();
+    if fork_name == ForkName::EuclidV1 {
+        // disable EuclidV2 fork for legacy chunk
+        use sbv_primitives::{chainspec::ForkCondition, hardforks::ScrollHardfork};
+        hardforks.insert(ScrollHardfork::EuclidV2, ForkCondition::Never);
+    }
+
+    let inner = ChainSpec {
+        chain,
+        genesis_hash: Default::default(),
+        genesis: Default::default(),
+        genesis_header: Default::default(),
+        paris_block_and_final_difficulty: Default::default(),
+        hardforks,
+        deposit_contract: Default::default(),
+        base_fee_params: BaseFeeParamsKind::Constant(BaseFeeParams::ethereum()),
+        prune_delete_limit: 20000,
+        blob_params: Default::default(),
+    };
+    let config = ScrollChainConfig::mainnet();
+    let chain_spec: ScrollChainSpec = ScrollChainSpec { inner, config };
+
+    let (code_db, nodes_provider, block_hashes) = make_providers(&witness.blocks);
+    let nodes_provider = manually_drop_on_zkvm!(nodes_provider);
+
+    let prev_state_root = witness.blocks[0].pre_state_root();
+    let mut db = manually_drop_on_zkvm!(
+        EvmDatabase::new_from_root(code_db, prev_state_root, &nodes_provider, block_hashes)
+            .map_err(|e| format!("failed to create EvmDatabase: {}", e))?
+    );
+    for block in blocks.iter() {
+        let output = manually_drop_on_zkvm!(
+            EvmExecutor::new(std::sync::Arc::new(chain_spec.clone()), &db, block)
+                .execute()
+                .map_err(|e| format!("failed to execute block: {}", e))?
+        );
+        db.update(&nodes_provider, output.state.state.iter())
+            .map_err(|e| format!("failed to update db: {}", e))?;
+    }
+
+    let post_state_root = db.commit_changes();
+
+    let withdraw_root = db
+        .withdraw_root()
+        .map_err(|e| format!("failed to get withdraw root: {}", e))?;
+
+    let mut rlp_buffer = manually_drop_on_zkvm!(Vec::with_capacity(2048));
+    let (tx_data_length, tx_data_digest) = blocks
+        .iter()
+        .flat_map(|b| b.body().transactions.iter())
+        .tx_bytes_hash_in(rlp_buffer.as_mut());
+    let _ = tx_data_length;
+
+    let sbv_chunk_info = {
+        #[allow(unused_mut)]
+        let mut builder = ChunkInfoBuilder::new(&chain_spec, pre_state_root.into(), &blocks);
+        if fork_name == ForkName::EuclidV2 {
+            builder.set_prev_msg_queue_hash(witness.prev_msg_queue_hash.into());
+        }
+        builder.build(withdraw_root)
+    };
+    if post_state_root != sbv_chunk_info.post_state_root() {
+        return Err(format!(
+            "state root mismatch: expected={}, found={}",
+            sbv_chunk_info.post_state_root(),
+            post_state_root
+        ));
+    }
+
+    let chunk_info = ChunkInfo {
+        chain_id: sbv_chunk_info.chain_id(),
+        prev_state_root: sbv_chunk_info.prev_state_root(),
+        post_state_root: sbv_chunk_info.post_state_root(),
+        data_hash: sbv_chunk_info
+            .clone()
+            .into_legacy()
+            .map(|x| x.data_hash)
+            .unwrap_or_default(),
+        withdraw_root,
+        tx_data_digest,
+        tx_data_length: u64::try_from(tx_data_length).expect("tx_data_length: u64"),
+        initial_block_number: blocks[0].header().number,
+        prev_msg_queue_hash: witness.prev_msg_queue_hash.into(),
+        post_msg_queue_hash: sbv_chunk_info
+            .into_euclid_v2()
+            .map(|x| x.post_msg_queue_hash)
+            .unwrap_or_default(),
+        block_ctxs: blocks.iter().map(block_ctxv2_from_block).collect(),
+    };
+
+    openvm::io::println(format!("withdraw_root = {:?}", withdraw_root));
+    openvm::io::println(format!("tx_bytes_hash = {:?}", tx_data_digest));
+
+    // We should never touch that lazy lock... Or else we introduce 40M useless cycles.
+    assert!(std::sync::LazyLock::get(&MAINNET).is_none());
+
+    Ok(chunk_info)
+}

common/types-rs/chunk/src/lib.rs

@@ -0,0 +1,11 @@
+#![feature(lazy_get)]
+
+mod utils;
+
+mod witness;
+
+pub use utils::make_providers;
+pub use witness::{ArchivedChunkWitness, ChunkWitness};
+
+mod execute;
+pub use execute::execute;

common/types-rs/chunk/src/public_inputs.rs

@@ -0,0 +1,27 @@
+use alloy_primitives::{B256, U256};
+use sbv_primitives::types::{
+    consensus::BlockHeader,
+    reth::{Block, RecoveredBlock},
+};
+
+use types_base::public_inputs::chunk::BlockContextV2;
+
+impl From<&RecoveredBlock<Block>> for BlockContextV2 {
+    fn from(value: &RecoveredBlock<Block>) -> Self {
+        Self {
+            timestamp: value.timestamp,
+            gas_limit: value.gas_limit,
+            base_fee: U256::from(value.base_fee_per_gas().expect("base_fee_expected")),
+            num_txs: u16::try_from(value.body().transactions.len()).expect("num txs u16"),
+            num_l1_msgs: u16::try_from(
+                value
+                    .body()
+                    .transactions
+                    .iter()
+                    .filter(|tx| tx.is_l1_message())
+                    .count(),
+            )
+            .expect("num l1 msgs u16"),
+        }
+    }
+}

common/types-rs/chunk/src/utils.rs

@@ -0,0 +1,48 @@
+use sbv_kv::nohash::NoHashMap;
+use sbv_primitives::{B256, BlockWitness, Bytes, ext::BlockWitnessExt};
+use sbv_trie::{BlockWitnessTrieExt, TrieNode};
+
+type CodeDb = NoHashMap<B256, Bytes>;
+
+type NodesProvider = NoHashMap<B256, TrieNode>;
+
+type BlockHashProvider = sbv_kv::null::NullProvider;
+
+pub fn make_providers<W: BlockWitness>(
+    witnesses: &[W],
+) -> (CodeDb, NodesProvider, BlockHashProvider) {
+    let code_db = {
+        // build code db
+        let num_codes = witnesses.iter().map(|w| w.codes_iter().len()).sum();
+        let mut code_db =
+            NoHashMap::<B256, Bytes>::with_capacity_and_hasher(num_codes, Default::default());
+        witnesses.import_codes(&mut code_db);
+        code_db
+    };
+    let nodes_provider = {
+        let num_states = witnesses.iter().map(|w| w.states_iter().len()).sum();
+        let mut nodes_provider =
+            NoHashMap::<B256, TrieNode>::with_capacity_and_hasher(num_states, Default::default());
+        witnesses.import_nodes(&mut nodes_provider).unwrap();
+        nodes_provider
+    };
+    let block_hashes = sbv_kv::null::NullProvider;
+
+    (code_db, nodes_provider, block_hashes)
+}
+
+#[macro_export]
+#[cfg(not(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64")))]
+macro_rules! manually_drop_on_zkvm {
+    ($e:expr) => {
+        std::mem::ManuallyDrop::new($e)
+    };
+}
+
+#[macro_export]
+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
+macro_rules! manually_drop_on_zkvm {
+    ($e:expr) => {
+        $e
+    };
+}

common/types-rs/chunk/src/witness.rs

@@ -0,0 +1,71 @@
+use alloy_primitives::B256;
+use sbv_primitives::types::BlockWitness;
+use std::collections::HashSet;
+
+use types_base::public_inputs::ForkName;
+
+/// The witness type accepted by the chunk-circuit.
+#[derive(
+    Clone,
+    Debug,
+    serde::Deserialize,
+    serde::Serialize,
+    rkyv::Archive,
+    rkyv::Deserialize,
+    rkyv::Serialize,
+)]
+#[rkyv(derive(Debug))]
+pub struct ChunkWitness {
+    /// The block witness for each block in the chunk.
+    pub blocks: Vec<BlockWitness>,
+    /// The on-chain rolling L1 message queue hash before enqueueing any L1 msg tx from the chunk.
+    pub prev_msg_queue_hash: B256,
+    /// The code version specify the chain spec
+    pub fork_name: ForkName,
+}
+
+impl ChunkWitness {
+    pub fn new(blocks: &[BlockWitness], prev_msg_queue_hash: B256, fork_name: ForkName) -> Self {
+        let num_codes = blocks.iter().map(|w| w.codes.len()).sum();
+        let num_states = blocks.iter().map(|w| w.states.len()).sum();
+        let mut codes = HashSet::with_capacity(num_codes);
+        let mut states = HashSet::with_capacity(num_states);
+
+        let blocks = blocks
+            .iter()
+            .map(|block| BlockWitness {
+                chain_id: block.chain_id,
+                header: block.header.clone(),
+                pre_state_root: block.pre_state_root,
+                transaction: block.transaction.clone(),
+                withdrawals: block.withdrawals.clone(),
+                states: block
+                    .states
+                    .iter()
+                    .filter(|s| states.insert(*s))
+                    .cloned()
+                    .collect(),
+                codes: block
+                    .codes
+                    .iter()
+                    .filter(|c| codes.insert(*c))
+                    .cloned()
+                    .collect(),
+            })
+            .collect();
+
+        Self {
+            blocks,
+            prev_msg_queue_hash,
+            fork_name,
+        }
+    }
+
+    pub fn new_v1(blocks: &[BlockWitness]) -> Self {
+        Self::new(blocks, Default::default(), ForkName::EuclidV1)
+    }
+
+    pub fn new_v2(blocks: &[BlockWitness], prev_msg_queue_hash: B256) -> Self {
+        Self::new(blocks, prev_msg_queue_hash, ForkName::EuclidV2)
+    }
+}

common/types-rs/src/lib.rs

@@ -0,0 +1,21 @@
+// re-export for a compatible interface with old circuit/types for prover
+
+pub mod bundle {
+    pub use types_base::public_inputs::bundle::{BundleInfo, BundleInfoV1, BundleInfoV2};
+    pub use types_bundle::*;
+}
+
+pub mod batch {
+    pub use types_base::public_inputs::batch::{ArchivedBatchInfo, BatchInfo, VersionedBatchInfo};
+    pub use types_batch::*;
+}
+
+pub mod chunk {
+    pub use types_base::public_inputs::chunk::{
+        ArchivedChunkInfo, BlockContextV2, ChunkInfo, SIZE_BLOCK_CTX, VersionedChunkInfo,
+    };
+    pub use types_chunk::*;
+}
+
+pub use types_agg;
+pub use types_base::{public_inputs, utils};

common/types/message/bundle-proof-sample.json

@@ -0,0 +1 @@
+{"metadata":{"bundle_info":{"chain_id":333333,"msg_queue_hash":"0x0101010101010101010101010101010101010101010101010101010101010101","num_batches":2,"prev_state_root":"0x5302a56cbbec7d14d48d592b805d4ec3c7011439dfaa90d44deee02a9326d203","prev_batch_hash":"0xabacadaeaf000000000000000000000000000000000000000000000000000000","post_state_root":"0xaf6696afb2e11052490051f0f9f6444be6e9f5bb82beb3c3dae846cfa59ed6e0","batch_hash":"0xf0ee5d6b9cd739eb1ff816a58486af8b08d42a8c50d6e5998e7a3947c7aae2a9","withdraw_root":"0x0000000000000000000000000000000000000000000000000000000000000000"},"bundle_pi_hash":"0x2028510c403837c6ed77660fd92814ba61d7b746e7268cc8dfc14d163d45e6bd"},"proof":{"proof":"CfpNiL6UpegsK3VcoAj9ey5daMbZDFiF1XpCKvrOeN0MPPLNCDrllJL/gN0E3qmq20kGLYpBQ8aZ3sgUrxpSyA+9GKK8NhZoIM75adOnV8AYCLXpmxfS81MxIai/+ghxDIUvJQJVgWKJPsMQp4lO/Qltc4eCNWeoR2jHua/VzSASQXDDQ5ozD6i448TVkjKiyEcHwFFMMuOebFUzDc85hA4AJGM1T9bPl5VVQkEpijdNF+1lzUfi27U0XRQbYz8aE8hiCLxR8Z2bHg65dvfa+TsaDI8oAlz33Q1yIadZBtceKsH53P5u6vwWp0dQvw8DGNv8G5zvsayHPNCvy4xz8hRT3E4G0Ome8voqqOxrc/A8u2fE6LoXKswvU6Uquv+LHwGMbTugRvQ0BBXlLQ29Hvj18rDzS6ll0OnEcRiaaEkGOZy7Kq1PGiF7ZxMZsJYCbhyPgg4TKpesYDUJygEN0iGNX90dmyzGLTTgJATMYBGD2U+XP/T+UOMbxFTl3TFNHWlCPhEAu5LBwZ0pD3XV1xNW1iUqwTSfg7Qz1SOUYkot10Q8EAKeXk3hluHK+nSQhOMfWC4tnvfQdMqepfymwwArzA/9GMA/Two7yuzgCz7vHb+56YKPZiDrh4cqSvpVI92hCF8GWHaTqWDR0fikx2Y7GLX8YBM3Rx8reQE+LYYGEJHJzD4cIc0MKiuet605ZPSAaKpb8JM2EgrCAfw+QAhBiwXQ3HOQkrt17tzqNJH7IeHF761v43D9w+IeqvetKEgYXEH3fHmN00dLV2Uws8C4956qze+SG81ScnZzbrIeiO9lnmUXSFzrL40K+3NqCZcFnfLhVidyEJepzJi50yOK5BUJdMFdNtvHtprICqLKyb7aRg39qoZ7RqyJTg5nAjQQBGelvRu/AN6zdyxja73Jo5gEovdIiMybi/IhfMwKGWgiRaOGxyHx9KZ/ZA/w7r3rce6vuDsUhk5hsgVj4wUW3BqoZ8iRIH8X6AjK1xli+S/HfgAkfmUVwNNBOcgYEcrqEbswsfYKOcoFn71DISLK0jmB44LTNyGxoWBMpIAOf/gGhQSNk0ojd4n4UXxShsqmJ57Kudw/mGimMm+Crhr5asxeiFH0eJNBgUEXDuveqE1d20UTRJ1UJ/hZGomsDLebTojSTtsMLWTtx/4Mqg+g3Odte1WKN6CgxF4kGRcW2tE3D1jiBys5FTHMAhmka3mUBwlciT7syDWBDlYVuSmwppCghdBMQfQL4s3Uh0vRG28LkU+UXcwYXwh3UK6cA1bBnKfAa9k7P5BuMxVh8p6he6EZr0kGNjKGPSxuVxgczO/C32GP+HVVsWlIMNmgB4GeMHIN3yJampOrLZIMlQuP9d9kOicvRia1ge5sFtT+Vmthnp1F7sR3P+ADB/WxKSxVbiLaVBo+zm/rZbyM9vU0CVLD69lzPC6xKcFkxewlWJU6o7rOz1qzh47fT+8qUcVYfpCSEtT/U8eX2JFnXCb0PPXWivofI28tnsuS8GjwUiOyzCoxxuIEOyz1HNRXBcO2dSKR2qM41zUs0btA2JkA3hTVW8YWn8czHxrZyooooaumzbUPQBOqO3fewnLLyQ9etBcjZJ8Xm/B1EBk9cRPWDjgx5Hq8C0soA+EsoNoaSQJu67HuFTRd/OWvKSliCoj1XVcqBobnJWmTU7kAgi73pMaq/G4ot2rRFSL9MbkJgHCyxBkrl9nkCVUJC5GphsrDS5P5/bmRS3iTNdxiXAzdwOIQqJpEO54oN+3CHZuZuUOgCcWTI3uxWq/gBDJrBTsv8EUqtNQJve0qwIh2PUuJl5DIqF0CvswN649gywc=","instances":"AAAAAAAAAAAAAAAAAAAAAAAAAAAApvhdIlw19IwSvukAAAAAAAAAAAAAAAAAAAAAAAAAAAAl72fyrHk3TaguHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAALh9HvEG69AvDlAAAAAAAAAAAAAAAAAAAAAAAAAAAAkGY9R6S+t36FIrAAAAAAAAAAAAAAAAAAAAAAAAAAAACoNqt7QwZoXUpj/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdaREhypq22OmnAAAAAAAAAAAAAAAAAAAAAAAAAAAAOXf2Vj0jGD1q4xQAAAAAAAAAAAAAAAAAAAAAAAAAAADZYAdKTg7m4hBHGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAll4nXKE0us1IMAAAAAAAAAAAAAAAAAAAAAAAAAAAAFfnJ8YXlwczTsyEAAAAAAAAAAAAAAAAAAAAAAAAAAAArXqULkWYvNST9PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAArqteSdJMySnbMAC5TUWus+SXtvRWUNmCSMiMb4aZvb4hpJ5yXqjtih6gAIn9WQUOx/Z/rbbdComU0hCSwKwrewQgB3KolXKensAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL0="},"vk":"AhYAAAAABAAAAD2PumVP6pqldS0PKWW8Q4IvnE/rvtm5/2fXvG196sYhKtVFtg+WFGYJrU+eMUKZVjPurMpM8kbYiXvE18bnsU4Nu8s47Xabxy0EViND1dzsu5HicdAWl0xG5C+VpO2faJdK4nGwtD4WHtbdqWY72nSY5aKSDxAYO85vLy+9cJZlQsMNQlhTi/2q9PYQpC4D3Uf8E+yZ7gvLhd6cFdErlg4Oq/nthQkfxPAarVYLUFNGW80SgIloMDhutrky34D+Csw8T9j5UXpHz3K/2yuVSXK6OvMG4/058TXG09qKgXYP","git_version":"9f48bc4"}

common/types/message/message.go

@@ -11,6 +11,7 @@ import (
 )
 
 const (
+	EuclidFork   = "euclid"
 	EuclidV2Fork = "euclidV2"
 
 	EuclidV2ForkNameForProver = "euclidv2"
@@ -45,7 +46,7 @@ const (
 
 // ChunkTaskDetail is a type containing ChunkTask detail for chunk task.
 type ChunkTaskDetail struct {
-	// use one of the string of "euclidv1" / "euclidv2"
+	// use one of the string of EuclidFork / EuclidV2Fork
 	ForkName         string        `json:"fork_name"`
 	BlockHashes      []common.Hash `json:"block_hashes"`
 	PrevMsgQueueHash common.Hash   `json:"prev_msg_queue_hash"`
@@ -96,7 +97,7 @@ func (e *Byte48) UnmarshalJSON(input []byte) error {
 
 // BatchTaskDetail is a type containing BatchTask detail.
 type BatchTaskDetail struct {
-	// use one of the string of "euclidv1" / "euclidv2"
+	// use one of the string of EuclidFork / EuclidV2Fork
 	ForkName        string              `json:"fork_name"`
 	ChunkInfos      []*ChunkInfo        `json:"chunk_infos"`
 	ChunkProofs     []*OpenVMChunkProof `json:"chunk_proofs"`
@@ -109,7 +110,7 @@ type BatchTaskDetail struct {
 
 // BundleTaskDetail consists of all the information required to describe the task to generate a proof for a bundle of batches.
 type BundleTaskDetail struct {
-	// use one of the string of "euclidv1" / "euclidv2"
+	// use one of the string of EuclidFork / EuclidV2Fork
 	ForkName    string              `json:"fork_name"`
 	BatchProofs []*OpenVMBatchProof `json:"batch_proofs"`
 	BundleInfo  *OpenVMBundleInfo   `json:"bundle_info,omitempty"`

common/version/version.go

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

coordinator/internal/logic/auth/login.go

@@ -9,6 +9,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/log"
 	"gorm.io/gorm"
 
+	"scroll-tech/common/types/message"
 	"scroll-tech/common/version"
 
 	"scroll-tech/coordinator/internal/config"
@@ -33,6 +34,7 @@ func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *Logi
 
 	var highHardForks []string
 	highHardForks = append(highHardForks, cfg.ProverManager.Verifier.HighVersionCircuit.ForkName)
+	highHardForks = append(highHardForks, message.EuclidFork, message.EuclidV2Fork)
 	proverVersionHardForkMap[cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion] = highHardForks
 
 	return &LoginLogic{

coordinator/internal/logic/verifier/verifier.go

@@ -79,6 +79,10 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 		OpenVMVkMap: make(map[string]struct{}),
 	}
 
+	if err := v.loadOpenVMVks(message.EuclidFork); err != nil {
+		return nil, err
+	}
+
 	if err := v.loadOpenVMVks(message.EuclidV2Fork); err != nil {
 		return nil, err
 	}

go.work.sum

@@ -1357,7 +1357,8 @@ github.com/scroll-tech/da-codec v0.1.1-0.20241014152913-2703f226fb0b h1:5H6V6yba
 github.com/scroll-tech/da-codec v0.1.1-0.20241014152913-2703f226fb0b/go.mod h1:48uxaqVgpD8ulH8p+nrBtfeLHZ9tX82bVVdPNkW3rPE=
 github.com/scroll-tech/da-codec v0.1.3-0.20250227072756-a1482833595f h1:YYbhuUwjowqI4oyXtECRofck7Fyj18e1tcRjuQlZpJE=
 github.com/scroll-tech/da-codec v0.1.3-0.20250227072756-a1482833595f/go.mod h1:xECEHZLVzbdUn+tNbRJhRIjLGTOTmnFQuTgUTeVLX58=
-github.com/scroll-tech/da-codec v0.1.3-0.20250519114140-bfa7133d4ad1/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/da-codec v0.1.3-0.20250401062930-9f9f53898493 h1:Ioc01J0WEMxuwFvEPGJeBKXdf2KY4Yc3XbFky/IxLlI=
+github.com/scroll-tech/da-codec v0.1.3-0.20250401062930-9f9f53898493/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240607130425-e2becce6a1a4/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240821074444-b3fa00861e5e/go.mod h1:swB5NSp8pKNDuYsTxfR08bHS6L56i119PBx8fxvV8Cs=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20241010064814-3d88e870ae22/go.mod h1:r9FwtxCtybMkTbWYCyBuevT9TW3zHmOTHqD082Uh+Oo=

rollup/abi/bridge_abi_test.go

@@ -10,6 +10,33 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func TestPackCommitBatch(t *testing.T) {
+	scrollChainABI, err := ScrollChainMetaData.GetAbi()
+	assert.NoError(t, err)
+
+	version := uint8(1)
+	var parentBatchHeader []byte
+	var chunks [][]byte
+	var skippedL1MessageBitmap []byte
+
+	_, err = scrollChainABI.Pack("commitBatch", version, parentBatchHeader, chunks, skippedL1MessageBitmap)
+	assert.NoError(t, err)
+}
+
+func TestPackCommitBatchWithBlobProof(t *testing.T) {
+	scrollChainABI, err := ScrollChainMetaData.GetAbi()
+	assert.NoError(t, err)
+
+	version := uint8(1)
+	var parentBatchHeader []byte
+	var chunks [][]byte
+	var skippedL1MessageBitmap []byte
+	var blobDataProof []byte
+
+	_, err = scrollChainABI.Pack("commitBatchWithBlobProof", version, parentBatchHeader, chunks, skippedL1MessageBitmap, blobDataProof)
+	assert.NoError(t, err)
+}
+
 func TestPackCommitBatches(t *testing.T) {
 	scrollChainABI, err := ScrollChainMetaData.GetAbi()
 	assert.NoError(t, err)
@@ -22,6 +49,58 @@ func TestPackCommitBatches(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+func TestPackFinalizeBatchWithProof(t *testing.T) {
+	l1RollupABI, err := ScrollChainMetaData.GetAbi()
+	assert.NoError(t, err)
+
+	var batchHeader []byte
+	var prevStateRoot common.Hash
+	var postStateRoot common.Hash
+	var withdrawRoot common.Hash
+	var aggrProof []byte
+
+	_, err = l1RollupABI.Pack("finalizeBatchWithProof", batchHeader, prevStateRoot, postStateRoot, withdrawRoot, aggrProof)
+	assert.NoError(t, err)
+}
+
+func TestPackFinalizeBatchWithProof4844(t *testing.T) {
+	l1RollupABI, err := ScrollChainMetaData.GetAbi()
+	assert.NoError(t, err)
+
+	var batchHeader []byte
+	var prevStateRoot common.Hash
+	var postStateRoot common.Hash
+	var withdrawRoot common.Hash
+	var blobDataProof []byte
+	var aggrProof []byte
+
+	_, err = l1RollupABI.Pack("finalizeBatchWithProof4844", batchHeader, prevStateRoot, postStateRoot, withdrawRoot, blobDataProof, aggrProof)
+	assert.NoError(t, err)
+}
+
+func TestPackFinalizeBundleWithProof(t *testing.T) {
+	l1RollupABI, err := ScrollChainMetaData.GetAbi()
+	assert.NoError(t, err)
+
+	var batchHeader []byte
+	var postStateRoot common.Hash
+	var withdrawRoot common.Hash
+	var aggrProof []byte
+
+	_, err = l1RollupABI.Pack("finalizeBundleWithProof", batchHeader, postStateRoot, withdrawRoot, aggrProof)
+	assert.NoError(t, err)
+}
+
+func TestPackFinalizeEuclidInitialBatch(t *testing.T) {
+	l1RollupABI, err := ScrollChainMetaData.GetAbi()
+	assert.NoError(t, err)
+
+	var postStateRoot common.Hash
+
+	_, err = l1RollupABI.Pack("finalizeEuclidInitialBatch", postStateRoot)
+	assert.NoError(t, err)
+}
+
 func TestPackFinalizeBundlePostEuclidV2(t *testing.T) {
 	l1RollupABI, err := ScrollChainMetaData.GetAbi()
 	assert.NoError(t, err)

rollup/cmd/proposer_tool/app/app.go

@@ -54,9 +54,6 @@ func action(ctx *cli.Context) error {
 	}
 
 	minCodecVersion := encoding.CodecVersion(ctx.Uint(utils.MinCodecVersionFlag.Name))
-	if minCodecVersion < encoding.CodecV7 {
-		log.Crit("min codec version must be greater than or equal to CodecV7", "minCodecVersion", minCodecVersion)
-	}
 
 	// sanity check config
 	if cfg.L2Config.BatchProposerConfig.MaxChunksPerBatch <= 0 {

rollup/cmd/rollup_relayer/app/app.go

@@ -102,10 +102,6 @@ func action(ctx *cli.Context) error {
 	}
 
 	minCodecVersion := encoding.CodecVersion(ctx.Uint(utils.MinCodecVersionFlag.Name))
-	if minCodecVersion < encoding.CodecV7 {
-		log.Crit("min codec version must be greater than or equal to CodecV7", "minCodecVersion", minCodecVersion)
-	}
-
 	chunkProposer := watcher.NewChunkProposer(subCtx, cfg.L2Config.ChunkProposerConfig, minCodecVersion, genesis.Config, db, registry)
 	batchProposer := watcher.NewBatchProposer(subCtx, cfg.L2Config.BatchProposerConfig, minCodecVersion, genesis.Config, db, registry)
 	bundleProposer := watcher.NewBundleProposer(subCtx, cfg.L2Config.BundleProposerConfig, minCodecVersion, genesis.Config, db, registry)

rollup/conf/config.json

@@ -54,8 +54,7 @@
       "batch_submission": {
         "min_batches": 1,
         "max_batches": 6,
-        "timeout": 7200,
-        "backlog_max": 75
+        "timeout": 300
       },
       "gas_oracle_config": {
         "min_gas_price": 0,
@@ -88,18 +87,29 @@
         "private_key_signer_config": {
           "private_key": "1515151515151515151515151515151515151515151515151515151515151515"
         }
-      }
+      },
+      "l1_commit_gas_limit_multiplier": 1.2
     },
     "chunk_proposer_config": {
       "propose_interval_milliseconds": 100,
       "max_block_num_per_chunk": 100,
+      "max_tx_num_per_chunk": 100,
       "max_l2_gas_per_chunk": 20000000,
-      "chunk_timeout_sec": 300
+      "max_l1_commit_gas_per_chunk": 11234567,
+      "max_l1_commit_calldata_size_per_chunk": 112345,
+      "chunk_timeout_sec": 300,
+      "max_row_consumption_per_chunk": 1048319,
+      "gas_cost_increase_multiplier": 1.2,
+      "max_uncompressed_batch_bytes_size": 634880
     },
     "batch_proposer_config": {
       "propose_interval_milliseconds": 1000,
+      "max_l1_commit_gas_per_batch": 11234567,
+      "max_l1_commit_calldata_size_per_batch": 112345,
       "batch_timeout_sec": 300,
-      "max_chunks_per_batch": 45
+      "gas_cost_increase_multiplier": 1.2,
+      "max_uncompressed_batch_bytes_size": 634880,
+      "max_chunks_per_batch": 12
     },
     "bundle_proposer_config": {
       "max_batch_num_per_bundle": 20,

rollup/docker-compose-proposer-tool.yml

@@ -27,7 +27,7 @@ services:
     command: [
       "--config", "/app/conf/proposer-tool-config.json",
       "--genesis", "/app/conf/proposer-tool-genesis.json",
-      "--min-codec-version", "7",
+      "--min-codec-version", "4",
       "--start-l2-block", "10000",
       "--log.debug", "--verbosity", "3"
     ]

rollup/go.mod

@@ -11,7 +11,7 @@ require (
 	github.com/holiman/uint256 v1.3.2
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/prometheus/client_golang v1.16.0
-	github.com/scroll-tech/da-codec v0.1.3-0.20250519114140-bfa7133d4ad1
+	github.com/scroll-tech/da-codec v0.1.3-0.20250401062930-9f9f53898493
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/spf13/viper v1.19.0

rollup/go.sum

@@ -249,8 +249,8 @@ github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6ke
 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.3-0.20250519114140-bfa7133d4ad1 h1:6aKqJSal+QVdB5HMWMs0JTbAIZ6/iAHJx9qizz0w9dU=
-github.com/scroll-tech/da-codec v0.1.3-0.20250519114140-bfa7133d4ad1/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/da-codec v0.1.3-0.20250401062930-9f9f53898493 h1:Ioc01J0WEMxuwFvEPGJeBKXdf2KY4Yc3XbFky/IxLlI=
+github.com/scroll-tech/da-codec v0.1.3-0.20250401062930-9f9f53898493/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601 h1:NEsjCG6uSvLRBlsP3+x6PL1kM+Ojs3g8UGotIPgJSz8=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=

rollup/internal/config/l2.go

@@ -28,17 +28,27 @@ type L2Config struct {
 
 // ChunkProposerConfig loads chunk_proposer configuration items.
 type ChunkProposerConfig struct {
-	ProposeIntervalMilliseconds uint64 `json:"propose_interval_milliseconds"`
-	MaxBlockNumPerChunk         uint64 `json:"max_block_num_per_chunk"`
-	MaxL2GasPerChunk            uint64 `json:"max_l2_gas_per_chunk"`
-	ChunkTimeoutSec             uint64 `json:"chunk_timeout_sec"`
+	ProposeIntervalMilliseconds     uint64  `json:"propose_interval_milliseconds"`
+	MaxBlockNumPerChunk             uint64  `json:"max_block_num_per_chunk"`
+	MaxTxNumPerChunk                uint64  `json:"max_tx_num_per_chunk"`
+	MaxL2GasPerChunk                uint64  `json:"max_l2_gas_per_chunk"`
+	MaxL1CommitGasPerChunk          uint64  `json:"max_l1_commit_gas_per_chunk"`
+	MaxL1CommitCalldataSizePerChunk uint64  `json:"max_l1_commit_calldata_size_per_chunk"`
+	ChunkTimeoutSec                 uint64  `json:"chunk_timeout_sec"`
+	MaxRowConsumptionPerChunk       uint64  `json:"max_row_consumption_per_chunk"`
+	GasCostIncreaseMultiplier       float64 `json:"gas_cost_increase_multiplier"`
+	MaxUncompressedBatchBytesSize   uint64  `json:"max_uncompressed_batch_bytes_size"`
 }
 
 // BatchProposerConfig loads batch_proposer configuration items.
 type BatchProposerConfig struct {
-	ProposeIntervalMilliseconds uint64 `json:"propose_interval_milliseconds"`
-	BatchTimeoutSec             uint64 `json:"batch_timeout_sec"`
-	MaxChunksPerBatch           int    `json:"max_chunks_per_batch"`
+	ProposeIntervalMilliseconds     uint64  `json:"propose_interval_milliseconds"`
+	MaxL1CommitGasPerBatch          uint64  `json:"max_l1_commit_gas_per_batch"`
+	MaxL1CommitCalldataSizePerBatch uint64  `json:"max_l1_commit_calldata_size_per_batch"`
+	BatchTimeoutSec                 uint64  `json:"batch_timeout_sec"`
+	GasCostIncreaseMultiplier       float64 `json:"gas_cost_increase_multiplier"`
+	MaxUncompressedBatchBytesSize   uint64  `json:"max_uncompressed_batch_bytes_size"`
+	MaxChunksPerBatch               int     `json:"max_chunks_per_batch"`
 }
 
 // BundleProposerConfig loads bundle_proposer configuration items.

rollup/internal/config/relayer.go

@@ -38,8 +38,6 @@ type BatchSubmission struct {
 	MaxBatches int `json:"max_batches"`
 	// The time in seconds after which a batch is considered stale and should be submitted ignoring the min batch count.
 	TimeoutSec int64 `json:"timeout"`
-	// The maximum number of pending batches to keep in the backlog.
-	BacklogMax int64 `json:"backlog_max"`
 }
 
 // ChainMonitor this config is used to get batch status from chain_monitor API.
@@ -65,6 +63,8 @@ type RelayerConfig struct {
 	GasOracleConfig *GasOracleConfig `json:"gas_oracle_config"`
 	// ChainMonitor config of monitoring service
 	ChainMonitor *ChainMonitor `json:"chain_monitor"`
+	// L1CommitGasLimitMultiplier multiplier for fallback gas limit in commitBatch txs
+	L1CommitGasLimitMultiplier float64 `json:"l1_commit_gas_limit_multiplier,omitempty"`
 
 	// Configs of transaction signers (GasOracle, Commit, Finalize)
 	GasOracleSenderSignerConfig *SignerConfig `json:"gas_oracle_sender_signer_config"`
@@ -73,6 +73,8 @@ type RelayerConfig struct {
 
 	// Indicates if bypass features specific to testing environments are enabled.
 	EnableTestEnvBypassFeatures bool `json:"enable_test_env_bypass_features"`
+	// Sets rollup-relayer to stop fake finalizing at the fork boundary
+	TestEnvBypassOnlyUntilForkBoundary bool `json:"test_env_bypass_only_until_fork_boundary"`
 	// The timeout in seconds for finalizing a batch without proof, only used when EnableTestEnvBypassFeatures is true.
 	FinalizeBatchWithoutProofTimeoutSec uint64 `json:"finalize_batch_without_proof_timeout_sec"`
 	// The timeout in seconds for finalizing a bundle without proof, only used when EnableTestEnvBypassFeatures is true.

rollup/internal/controller/relayer/common.go

@@ -1,11 +1,20 @@
 package relayer
 
+import "errors"
+
 const (
 	gasPriceDiffPrecision = 1000000
 
 	defaultGasPriceDiff = 50000 // 5%
 )
 
+var (
+	// ErrExecutionRevertedMessageExpired error of Message expired
+	ErrExecutionRevertedMessageExpired = errors.New("execution reverted: Message expired")
+	// ErrExecutionRevertedAlreadySuccessExecuted error of Message was already successfully executed
+	ErrExecutionRevertedAlreadySuccessExecuted = errors.New("execution reverted: Message was already successfully executed")
+)
+
 // ServiceType defines the various types of services within the relayer.
 type ServiceType int
 

rollup/internal/controller/relayer/l1_relayer.go

@@ -179,13 +179,13 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 				return
 			}
 
-			txHash, _, err := r.gasOracleSender.SendTransaction(block.Hash, &r.cfg.GasPriceOracleContractAddress, data, nil)
+			hash, err := r.gasOracleSender.SendTransaction(block.Hash, &r.cfg.GasPriceOracleContractAddress, data, nil, 0)
 			if err != nil {
 				log.Error("Failed to send gas oracle update tx to layer2", "block.Hash", block.Hash, "block.Height", block.Number, "block.BaseFee", baseFee, "block.BlobBaseFee", blobBaseFee, "err", err)
 				return
 			}
 
-			err = r.l1BlockOrm.UpdateL1GasOracleStatusAndOracleTxHash(r.ctx, block.Hash, types.GasOracleImporting, txHash.String())
+			err = r.l1BlockOrm.UpdateL1GasOracleStatusAndOracleTxHash(r.ctx, block.Hash, types.GasOracleImporting, hash.String())
 			if err != nil {
 				log.Error("UpdateGasOracleStatusAndOracleTxHash failed", "block.Hash", block.Hash, "block.Height", block.Number, "err", err)
 				return
@@ -195,7 +195,7 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 			r.lastBlobBaseFee = blobBaseFee
 			r.metrics.rollupL1RelayerLatestBaseFee.Set(float64(r.lastBaseFee))
 			r.metrics.rollupL1RelayerLatestBlobBaseFee.Set(float64(r.lastBlobBaseFee))
-			log.Info("Update l1 base fee", "txHash", txHash.String(), "baseFee", baseFee, "blobBaseFee", blobBaseFee)
+			log.Info("Update l1 base fee", "txHash", hash.String(), "baseFee", baseFee, "blobBaseFee", blobBaseFee)
 		}
 	}
 }

rollup/internal/controller/relayer/l1_relayer_test.go

@@ -146,13 +146,13 @@ func testL1RelayerProcessGasPriceOracle(t *testing.T) {
 
 	convey.Convey("send transaction failure", t, func() {
 		targetErr := errors.New("send transaction failure")
-		patchGuard.ApplyMethodFunc(l1Relayer.gasOracleSender, "SendTransaction", func(string, *common.Address, []byte, *kzg4844.Blob) (hash common.Hash, err error) {
+		patchGuard.ApplyMethodFunc(l1Relayer.gasOracleSender, "SendTransaction", func(string, *common.Address, []byte, *kzg4844.Blob, uint64) (hash common.Hash, err error) {
 			return common.Hash{}, targetErr
 		})
 		l1Relayer.ProcessGasPriceOracle()
 	})
 
-	patchGuard.ApplyMethodFunc(l1Relayer.gasOracleSender, "SendTransaction", func(string, *common.Address, []byte, *kzg4844.Blob) (hash common.Hash, err error) {
+	patchGuard.ApplyMethodFunc(l1Relayer.gasOracleSender, "SendTransaction", func(string, *common.Address, []byte, *kzg4844.Blob, uint64) (hash common.Hash, err error) {
 		return common.Hash{}, nil
 	})
 

rollup/internal/controller/relayer/l2_relayer.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"math"
 	"math/big"
 	"sort"
 	"strings"
@@ -15,6 +14,7 @@ import (
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
 	"github.com/scroll-tech/go-ethereum/common"
+	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
 	"github.com/scroll-tech/go-ethereum/ethclient"
@@ -33,32 +33,6 @@ import (
 	rutils "scroll-tech/rollup/internal/utils"
 )
 
-// RelaxType enumerates the relaxation functions we support when
-// turning a baseline fee into a “target” fee.
-type RelaxType int
-
-const (
-	// NoRelaxation means “don’t touch the baseline” (i.e. fallback/default).
-	NoRelaxation RelaxType = iota
-	Exponential
-	Sigmoid
-)
-
-const secondsPerBlock = 12
-
-// BaselineType enumerates the baseline types we support when
-// turning a baseline fee into a “target” fee.
-type BaselineType int
-
-const (
-	// PctMin means “take the minimum of the last N blocks’ fees, then
-	// take the PCT of that”.
-	PctMin BaselineType = iota
-	// EWMA means “take the exponentially‐weighted moving average of
-	// the last N blocks’ fees”.
-	EWMA
-)
-
 // Layer2Relayer is responsible for:
 // i. committing and finalizing L2 blocks on L1.
 // ii. updating L2 gas price oracle contract on L1.
@@ -72,7 +46,6 @@ type Layer2Relayer struct {
 	batchOrm   *orm.Batch
 	chunkOrm   *orm.Chunk
 	l2BlockOrm *orm.L2Block
-	l1BlockOrm *orm.L1Block
 
 	cfg *config.RelayerConfig
 
@@ -88,31 +61,6 @@ type Layer2Relayer struct {
 	metrics *l2RelayerMetrics
 
 	chainCfg *params.ChainConfig
-
-	lastFetchedBlock uint64     // highest block number ever pulled
-	feeHistory       []*big.Int // sliding window of blob fees
-	batchStrategy    StrategyParams
-}
-
-// StrategyParams holds the per‐window fee‐submission rules.
-type StrategyParams struct {
-	BaselineType  BaselineType // "pct_min" or "ewma"
-	BaselineParam float64      // percentile (0–1) or α for EWMA
-	Gamma         float64      // relaxation γ
-	Beta          float64      // relaxation β
-	RelaxType     RelaxType    // Exponential or Sigmoid
-}
-
-// bestParams maps your 2h/5h/12h windows to their best rules.
-// Timeouts are in seconds, 2, 5 and 12 hours (and same + 20 mins to account for
-// time to create batch currently roughly, as time is measured from block creation)
-var bestParams = map[uint64]StrategyParams{
-	7200:  {BaselineType: PctMin, BaselineParam: 0.10, Gamma: 0.4, Beta: 8, RelaxType: Exponential},
-	8400:  {BaselineType: PctMin, BaselineParam: 0.10, Gamma: 0.4, Beta: 8, RelaxType: Exponential},
-	18000: {BaselineType: PctMin, BaselineParam: 0.30, Gamma: 0.6, Beta: 20, RelaxType: Sigmoid},
-	19200: {BaselineType: PctMin, BaselineParam: 0.30, Gamma: 0.6, Beta: 20, RelaxType: Sigmoid},
-	42800: {BaselineType: PctMin, BaselineParam: 0.50, Gamma: 0.5, Beta: 20, RelaxType: Sigmoid},
-	44400: {BaselineType: PctMin, BaselineParam: 0.50, Gamma: 0.5, Beta: 20, RelaxType: Sigmoid},
 }
 
 // NewLayer2Relayer will return a new instance of Layer2RelayerClient
@@ -152,18 +100,12 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		return nil, fmt.Errorf("invalid service type for l2_relayer: %v", serviceType)
 	}
 
-	strategy, ok := bestParams[uint64(cfg.BatchSubmission.TimeoutSec)]
-	if !ok {
-		return nil, fmt.Errorf("invalid timeout for batch submission: %v", cfg.BatchSubmission.TimeoutSec)
-	}
-
 	layer2Relayer := &Layer2Relayer{
 		ctx: ctx,
 		db:  db,
 
 		bundleOrm:  orm.NewBundle(db),
 		batchOrm:   orm.NewBatch(db),
-		l1BlockOrm: orm.NewL1Block(db),
 		l2BlockOrm: orm.NewL2Block(db),
 		chunkOrm:   orm.NewChunk(db),
 
@@ -174,9 +116,9 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		l1RollupABI:    bridgeAbi.ScrollChainABI,
 
 		l2GasOracleABI: bridgeAbi.L2GasPriceOracleABI,
-		batchStrategy:  strategy,
-		cfg:            cfg,
-		chainCfg:       chainCfg,
+
+		cfg:      cfg,
+		chainCfg: chainCfg,
 	}
 
 	// chain_monitor client
@@ -217,7 +159,14 @@ func (r *Layer2Relayer) initializeGenesis() error {
 
 	log.Info("retrieved L2 genesis header", "hash", genesis.Hash().String())
 
-	chunk := &encoding.Chunk{Blocks: []*encoding.Block{{Header: genesis}}}
+	chunk := &encoding.Chunk{
+		Blocks: []*encoding.Block{{
+			Header:         genesis,
+			Transactions:   nil,
+			WithdrawRoot:   common.Hash{},
+			RowConsumption: &gethTypes.RowConsumption{},
+		}},
+	}
 
 	err = r.db.Transaction(func(dbTX *gorm.DB) error {
 		if err = r.l2BlockOrm.InsertL2Blocks(r.ctx, chunk.Blocks); err != nil {
@@ -281,11 +230,11 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 	}
 
 	// submit genesis batch to L1 rollup contract
-	txHash, _, err := r.commitSender.SendTransaction(batchHash, &r.cfg.RollupContractAddress, calldata, nil)
+	txHash, err := r.commitSender.SendTransaction(batchHash, &r.cfg.RollupContractAddress, calldata, nil, 0)
 	if err != nil {
 		return fmt.Errorf("failed to send import genesis batch tx to L1, error: %v", err)
 	}
-	log.Info("importGenesisBatch transaction sent", "contract", r.cfg.RollupContractAddress, "txHash", txHash, "batchHash", batchHash)
+	log.Info("importGenesisBatch transaction sent", "contract", r.cfg.RollupContractAddress, "txHash", txHash.String(), "batchHash", batchHash)
 
 	// wait for confirmation
 	// we assume that no other transactions are sent before initializeGenesis completes
@@ -317,10 +266,6 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 }
 
 // ProcessPendingBatches processes the pending batches by sending commitBatch transactions to layer 1.
-// Pending batchess are submitted if one of the following conditions is met:
-// - the first batch is too old -> forceSubmit
-// - backlogCount > r.cfg.BatchSubmission.BacklogMax -> forceSubmit
-// - we have at least minBatches AND price hits a desired target price
 func (r *Layer2Relayer) ProcessPendingBatches() {
 	// get pending batches from database in ascending order by their index.
 	dbBatches, err := r.batchOrm.GetFailedAndPendingBatches(r.ctx, r.cfg.BatchSubmission.MaxBatches)
@@ -329,56 +274,15 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		return
 	}
 
-	// nothing to do if we don't have any pending batches
-	if len(dbBatches) == 0 {
-		return
-	}
-
-	// if backlog outgrow max size, force‐submit enough oldest batches
-	backlogCount, err := r.batchOrm.GetFailedAndPendingBatchesCount(r.ctx)
-	r.metrics.rollupL2RelayerBacklogCounts.Set(float64(backlogCount))
-
-	if err != nil {
-		log.Error("Failed to fetch pending L2 batches", "err", err)
-		return
-	}
-
+	var batchesToSubmit []*dbBatchWithChunksAndParent
 	var forceSubmit bool
-
-	startChunk, err := r.chunkOrm.GetChunkByIndex(r.ctx, dbBatches[0].StartChunkIndex)
-	if err != nil {
-		log.Error("failed to get first chunk", "err", err, "batch index", dbBatches[0].Index, "chunk index", dbBatches[0].StartChunkIndex)
-		return
-	}
-	oldestBlockTimestamp := time.Unix(int64(startChunk.StartBlockTime), 0)
-
-	// if the batch with the oldest index is too old, we force submit all batches that we have so far in the next step
-	if r.cfg.BatchSubmission.TimeoutSec > 0 && time.Since(oldestBlockTimestamp) > time.Duration(r.cfg.BatchSubmission.TimeoutSec)*time.Second {
-		forceSubmit = true
-	}
-
-	// force submit if backlog is too big
-	if backlogCount > r.cfg.BatchSubmission.BacklogMax {
-		forceSubmit = true
-	}
-
-	if !forceSubmit {
-		// check if we should skip submitting the batch based on the fee target
-		skip, err := r.skipSubmitByFee(oldestBlockTimestamp, r.metrics)
-		// return if not hitting target price
-		if skip {
-			log.Debug("Skipping batch submission", "first batch index", dbBatches[0].Index, "backlog count", backlogCount, "reason", err)
-			log.Debug("first batch index", dbBatches[0].Index)
-			log.Debug("backlog count", backlogCount)
+	for i, dbBatch := range dbBatches {
+		if i == 0 && encoding.CodecVersion(dbBatch.CodecVersion) < encoding.CodecV7 {
+			// if the first batch is not >= V7 then we need to submit batches one by one
+			r.processPendingBatchesV4(dbBatches)
 			return
 		}
-		if err != nil {
-			log.Warn("Failed to check if we should skip batch submission, fallback to immediate submission", "err", err)
-		}
-	}
 
-	var batchesToSubmit []*dbBatchWithChunksAndParent
-	for i, dbBatch := range dbBatches {
 		var dbChunks []*orm.Chunk
 		var dbParentBatch *orm.Batch
 
@@ -432,6 +336,11 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 			break
 		}
 
+		// if one of the batches is too old, we force submit all batches that we have so far in the next step
+		if r.cfg.BatchSubmission.TimeoutSec > 0 && !forceSubmit && time.Since(dbBatch.CreatedAt) > time.Duration(r.cfg.BatchSubmission.TimeoutSec)*time.Second {
+			forceSubmit = true
+		}
+
 		if batchesToSubmitLen < r.cfg.BatchSubmission.MaxBatches {
 			batchesToSubmit = append(batchesToSubmit, &dbBatchWithChunksAndParent{
 				Batch:       dbBatch,
@@ -452,7 +361,7 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 	}
 
 	if forceSubmit {
-		log.Info("Forcing submission of batches due to timeout", "batch index", batchesToSubmit[0].Batch.Index, "first block created at", oldestBlockTimestamp)
+		log.Info("Forcing submission of batches due to timeout", "batch index", batchesToSubmit[0].Batch.Index, "created at", batchesToSubmit[0].Batch.CreatedAt)
 	}
 
 	// We have at least 1 batch to commit
@@ -477,7 +386,7 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		return
 	}
 
-	txHash, blobBaseFee, err := r.commitSender.SendTransaction(r.contextIDFromBatches(batchesToSubmit), &r.cfg.RollupContractAddress, calldata, blobs)
+	txHash, err := r.commitSender.SendTransaction(r.contextIDFromBatches(batchesToSubmit), &r.cfg.RollupContractAddress, calldata, blobs, 0)
 	if err != nil {
 		if errors.Is(err, sender.ErrTooManyPendingBlobTxs) {
 			r.metrics.rollupL2RelayerProcessPendingBatchErrTooManyPendingBlobTxsTotal.Inc()
@@ -517,8 +426,6 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 	r.metrics.rollupL2RelayerCommitThroughput.Add(float64(totalGasUsed))
 	r.metrics.rollupL2RelayerProcessPendingBatchSuccessTotal.Add(float64(len(batchesToSubmit)))
 	r.metrics.rollupL2RelayerProcessBatchesPerTxCount.Set(float64(len(batchesToSubmit)))
-	r.metrics.rollupL2RelayerCommitLatency.Set(time.Since(oldestBlockTimestamp).Seconds())
-	r.metrics.rollupL2RelayerCommitPrice.Set(float64(blobBaseFee))
 
 	log.Info("Sent the commitBatches tx to layer1", "batches count", len(batchesToSubmit), "start index", firstBatch.Index, "start hash", firstBatch.Hash, "end index", lastBatch.Index, "end hash", lastBatch.Hash, "tx hash", txHash.String())
 }
@@ -547,6 +454,117 @@ type dbBatchWithChunksAndParent struct {
 	ParentBatch *orm.Batch
 }
 
+func (r *Layer2Relayer) processPendingBatchesV4(dbBatches []*orm.Batch) {
+	for _, dbBatch := range dbBatches {
+		r.metrics.rollupL2RelayerProcessPendingBatchTotal.Inc()
+
+		dbChunks, err := r.chunkOrm.GetChunksInRange(r.ctx, dbBatch.StartChunkIndex, dbBatch.EndChunkIndex)
+		if err != nil {
+			log.Error("failed to get chunks in range", "err", err)
+			return
+		}
+
+		// check codec version
+		for _, dbChunk := range dbChunks {
+			if dbBatch.CodecVersion != dbChunk.CodecVersion {
+				log.Error("batch codec version is different from chunk codec version", "batch index", dbBatch.Index, "chunk index", dbChunk.Index, "batch codec version", dbBatch.CodecVersion, "chunk codec version", dbChunk.CodecVersion)
+				return
+			}
+		}
+
+		chunks := make([]*encoding.Chunk, len(dbChunks))
+		for i, c := range dbChunks {
+			blocks, getErr := r.l2BlockOrm.GetL2BlocksInRange(r.ctx, c.StartBlockNumber, c.EndBlockNumber)
+			if getErr != nil {
+				log.Error("failed to get blocks in range", "err", getErr)
+				return
+			}
+			chunks[i] = &encoding.Chunk{Blocks: blocks}
+		}
+
+		if dbBatch.Index == 0 {
+			log.Error("invalid args: batch index is 0, should only happen in committing genesis batch")
+			return
+		}
+
+		dbParentBatch, getErr := r.batchOrm.GetBatchByIndex(r.ctx, dbBatch.Index-1)
+		if getErr != nil {
+			log.Error("failed to get parent batch header", "err", getErr)
+			return
+		}
+
+		if dbParentBatch.CodecVersion > dbBatch.CodecVersion {
+			log.Error("parent batch codec version is greater than current batch codec version", "index", dbBatch.Index, "hash", dbBatch.Hash, "parent codec version", dbParentBatch.CodecVersion, "current codec version", dbBatch.CodecVersion)
+			return
+		}
+
+		var calldata []byte
+		var blob *kzg4844.Blob
+		codecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
+		switch codecVersion {
+		case encoding.CodecV4, encoding.CodecV5, encoding.CodecV6:
+			calldata, blob, err = r.constructCommitBatchPayloadCodecV4(dbBatch, dbParentBatch, dbChunks, chunks)
+			if err != nil {
+				log.Error("failed to construct commitBatchWithBlobProof payload for V4", "codecVersion", codecVersion, "index", dbBatch.Index, "err", err)
+				return
+			}
+		default:
+			log.Error("unsupported codec version in processPendingBatchesV4", "codecVersion", codecVersion)
+			return
+		}
+
+		// fallbackGasLimit is non-zero only in sending non-blob transactions.
+		fallbackGasLimit := uint64(float64(dbBatch.TotalL1CommitGas) * r.cfg.L1CommitGasLimitMultiplier)
+		if types.RollupStatus(dbBatch.RollupStatus) == types.RollupCommitFailed {
+			// use eth_estimateGas if this batch has been committed and failed at least once.
+			fallbackGasLimit = 0
+			log.Warn("Batch commit previously failed, using eth_estimateGas for the re-submission", "hash", dbBatch.Hash)
+		}
+
+		txHash, err := r.commitSender.SendTransaction(dbBatch.Hash, &r.cfg.RollupContractAddress, calldata, []*kzg4844.Blob{blob}, fallbackGasLimit)
+		if err != nil {
+			if errors.Is(err, sender.ErrTooManyPendingBlobTxs) {
+				r.metrics.rollupL2RelayerProcessPendingBatchErrTooManyPendingBlobTxsTotal.Inc()
+				log.Debug(
+					"Skipped sending commitBatch tx to L1: too many pending blob txs",
+					"maxPending", r.cfg.SenderConfig.MaxPendingBlobTxs,
+					"err", err,
+				)
+				return
+			}
+			log.Error(
+				"Failed to send commitBatch tx to layer1",
+				"index", dbBatch.Index,
+				"hash", dbBatch.Hash,
+				"RollupContractAddress", r.cfg.RollupContractAddress,
+				"err", err,
+				"calldata", common.Bytes2Hex(calldata),
+			)
+			return
+		}
+
+		err = r.batchOrm.UpdateCommitTxHashAndRollupStatus(r.ctx, dbBatch.Hash, txHash.String(), types.RollupCommitting)
+		if err != nil {
+			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())
+	}
+}
+
 // ProcessPendingBundles submits proof to layer 1 rollup contract
 func (r *Layer2Relayer) ProcessPendingBundles() {
 	r.metrics.rollupL2RelayerProcessPendingBundlesTotal.Inc()
@@ -581,6 +599,33 @@ func (r *Layer2Relayer) ProcessPendingBundles() {
 				return
 			}
 
+			lastFinalizedChunk, err := r.chunkOrm.GetChunkByIndex(r.ctx, lastBatch.EndChunkIndex)
+			if err != nil {
+				log.Error("failed to get last finalized chunk", "chunk index", lastBatch.EndChunkIndex)
+				return
+			}
+
+			firstUnfinalizedBatch, err := r.batchOrm.GetBatchByIndex(r.ctx, bundle.StartBatchIndex)
+			if err != nil {
+				log.Error("failed to get first unfinalized batch", "batch index", bundle.StartBatchIndex)
+				return
+			}
+
+			firstUnfinalizedChunk, err := r.chunkOrm.GetChunkByIndex(r.ctx, firstUnfinalizedBatch.StartChunkIndex)
+			if err != nil {
+				log.Error("failed to get firsr unfinalized chunk", "chunk index", firstUnfinalizedBatch.StartChunkIndex)
+				return
+			}
+
+			if r.cfg.TestEnvBypassOnlyUntilForkBoundary {
+				lastFork := encoding.GetHardforkName(r.chainCfg, lastFinalizedChunk.StartBlockNumber, lastFinalizedChunk.StartBlockTime)
+				nextFork := encoding.GetHardforkName(r.chainCfg, firstUnfinalizedChunk.StartBlockNumber, firstUnfinalizedChunk.StartBlockTime)
+				if lastFork != nextFork {
+					log.Info("not fake finalizing past the fork boundary", "last fork", lastFork, "next fork", nextFork)
+					return
+				}
+			}
+
 			if err := r.finalizeBundle(bundle, false); err != nil {
 				log.Error("failed to finalize timeout bundle without proof", "bundle index", bundle.Index, "start batch index", bundle.StartBatchIndex, "end batch index", bundle.EndBatchIndex, "err", err)
 				return
@@ -693,6 +738,11 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 
 	var calldata []byte
 	switch encoding.CodecVersion(bundle.CodecVersion) {
+	case encoding.CodecV4, encoding.CodecV5, encoding.CodecV6:
+		calldata, err = r.constructFinalizeBundlePayloadCodecV4(dbBatch, aggProof)
+		if err != nil {
+			return fmt.Errorf("failed to construct finalizeBundle payload codecv4, bundle index: %v, last batch index: %v, err: %w", bundle.Index, dbBatch.Index, err)
+		}
 	case encoding.CodecV7:
 		calldata, err = r.constructFinalizeBundlePayloadCodecV7(dbBatch, endChunk, aggProof)
 		if err != nil {
@@ -702,7 +752,7 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 		return fmt.Errorf("unsupported codec version in finalizeBundle, bundle index: %v, version: %d", bundle.Index, bundle.CodecVersion)
 	}
 
-	txHash, _, err := r.finalizeSender.SendTransaction("finalizeBundle-"+bundle.Hash, &r.cfg.RollupContractAddress, calldata, nil)
+	txHash, err := r.finalizeSender.SendTransaction("finalizeBundle-"+bundle.Hash, &r.cfg.RollupContractAddress, calldata, nil, 0)
 	if err != nil {
 		log.Error("finalizeBundle in layer1 failed", "with proof", withProof, "index", bundle.Index,
 			"start batch index", bundle.StartBatchIndex, "end batch index", bundle.EndBatchIndex,
@@ -898,6 +948,48 @@ func (r *Layer2Relayer) handleL2RollupRelayerConfirmLoop(ctx context.Context) {
 	}
 }
 
+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,
+	}
+
+	codec, err := encoding.CodecFromVersion(encoding.CodecVersion(dbBatch.CodecVersion))
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get codec from version %d, err: %w", dbBatch.CodecVersion, err)
+	}
+
+	daBatch, createErr := codec.NewDABatch(batch)
+	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 := codec.NewDAChunk(chunks[i], c.TotalL1MessagesPoppedBefore)
+		if createErr != nil {
+			return nil, nil, fmt.Errorf("failed to create DA chunk: %w", createErr)
+		}
+		encodedChunks[i], err = daChunk.Encode()
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to encode DA chunk: %w", err)
+		}
+	}
+
+	blobDataProof, err := daBatch.BlobDataProofForPointEvaluation()
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get blob data proof for point evaluation: %w", err)
+	}
+
+	calldata, packErr := r.l1RollupABI.Pack("commitBatchWithBlobProof", daBatch.Version(), dbParentBatch.BatchHeader, encodedChunks, daBatch.SkippedL1MessageBitmap(), blobDataProof)
+	if packErr != nil {
+		return nil, nil, fmt.Errorf("failed to pack commitBatchWithBlobProof: %w", packErr)
+	}
+	return calldata, daBatch.Blob(), nil
+}
+
 func (r *Layer2Relayer) constructCommitBatchPayloadCodecV7(batchesToSubmit []*dbBatchWithChunksAndParent, firstBatch, lastBatch *orm.Batch) ([]byte, []*kzg4844.Blob, uint64, uint64, error) {
 	var maxBlockHeight uint64
 	var totalGasUsed uint64
@@ -955,6 +1047,34 @@ func (r *Layer2Relayer) constructCommitBatchPayloadCodecV7(batchesToSubmit []*db
 	return calldata, blobs, maxBlockHeight, totalGasUsed, nil
 }
 
+func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV4(dbBatch *orm.Batch, aggProof *message.OpenVMBundleProof) ([]byte, error) {
+	if aggProof != nil { // finalizeBundle with proof.
+		calldata, packErr := r.l1RollupABI.Pack(
+			"finalizeBundleWithProof",
+			dbBatch.BatchHeader,
+			common.HexToHash(dbBatch.StateRoot),
+			common.HexToHash(dbBatch.WithdrawRoot),
+			aggProof.Proof(),
+		)
+		if packErr != nil {
+			return nil, fmt.Errorf("failed to pack finalizeBundleWithProof: %w", packErr)
+		}
+		return calldata, nil
+	}
+
+	// finalizeBundle without proof.
+	calldata, packErr := r.l1RollupABI.Pack(
+		"finalizeBundle",
+		dbBatch.BatchHeader,
+		common.HexToHash(dbBatch.StateRoot),
+		common.HexToHash(dbBatch.WithdrawRoot),
+	)
+	if packErr != nil {
+		return nil, fmt.Errorf("failed to pack finalizeBundle: %w", packErr)
+	}
+	return calldata, nil
+}
+
 func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV7(dbBatch *orm.Batch, endChunk *orm.Chunk, aggProof *message.OpenVMBundleProof) ([]byte, error) {
 	if aggProof != nil { // finalizeBundle with proof.
 		calldata, packErr := r.l1RollupABI.Pack(
@@ -998,141 +1118,6 @@ func (r *Layer2Relayer) StopSenders() {
 	}
 }
 
-// fetchBlobFeeHistory returns the last WindowSec seconds of blob‐fee samples,
-// by reading L1Block table’s BlobBaseFee column.
-func (r *Layer2Relayer) fetchBlobFeeHistory(windowSec uint64) ([]*big.Int, error) {
-	latest, err := r.l1BlockOrm.GetLatestL1BlockHeight(r.ctx)
-	if err != nil {
-		return nil, fmt.Errorf("GetLatestL1BlockHeight: %w", err)
-	}
-	// bootstrap on first call
-	if r.lastFetchedBlock == 0 {
-		// start window
-		r.lastFetchedBlock = latest - windowSec/secondsPerBlock
-	}
-	from := r.lastFetchedBlock + 1
-	//if new blocks
-	if from <= latest {
-		raw, err := r.l1BlockOrm.GetBlobFeesInRange(r.ctx, from, latest)
-		if err != nil {
-			return nil, fmt.Errorf("GetBlobFeesInRange: %w", err)
-		}
-		// append them
-		for _, v := range raw {
-			r.feeHistory = append(r.feeHistory, new(big.Int).SetUint64(v))
-			r.lastFetchedBlock++
-		}
-	}
-
-	maxLen := int(windowSec / secondsPerBlock)
-	if len(r.feeHistory) > maxLen {
-		r.feeHistory = r.feeHistory[len(r.feeHistory)-maxLen:]
-	}
-
-	return r.feeHistory, nil
-}
-
-// calculateTargetPrice applies pct_min/ewma + relaxation to get a BigInt target
-func calculateTargetPrice(windowSec uint64, strategy StrategyParams, firstTime time.Time, history []*big.Int) *big.Int {
-	var baseline float64 // baseline in Gwei (converting to float, small loss of precision)
-	n := len(history)
-	if n == 0 {
-		return big.NewInt(0)
-	}
-	switch strategy.BaselineType {
-	case PctMin:
-		// make a copy, sort by big.Int.Cmp, then pick the percentile element
-		sorted := make([]*big.Int, n)
-		copy(sorted, history)
-		sort.Slice(sorted, func(i, j int) bool {
-			return sorted[i].Cmp(sorted[j]) < 0
-		})
-		idx := int(strategy.BaselineParam * float64(n-1))
-		if idx < 0 {
-			idx = 0
-		}
-		baseline, _ = new(big.Float).
-			Quo(new(big.Float).SetInt(sorted[idx]), big.NewFloat(1e9)).
-			Float64()
-
-	case EWMA:
-		one := big.NewFloat(1)
-		alpha := big.NewFloat(strategy.BaselineParam)
-		oneMinusAlpha := new(big.Float).Sub(one, alpha)
-
-		// start from first history point
-		ewma := new(big.Float).
-			Quo(new(big.Float).SetInt(history[0]), big.NewFloat(1e9))
-
-		for i := 1; i < n; i++ {
-			curr := new(big.Float).
-				Quo(new(big.Float).SetInt(history[i]), big.NewFloat(1e9))
-			term1 := new(big.Float).Mul(alpha, curr)
-			term2 := new(big.Float).Mul(oneMinusAlpha, ewma)
-			ewma = new(big.Float).Add(term1, term2)
-		}
-		baseline, _ = ewma.Float64()
-
-	default:
-		// fallback to last element
-		baseline, _ = new(big.Float).
-			Quo(new(big.Float).SetInt(history[n-1]), big.NewFloat(1e9)).
-			Float64()
-	} // now baseline holds our baseline in float64 Gwei
-
-	// relaxation
-	age := time.Since(firstTime).Seconds()
-	frac := age / float64(windowSec)
-	var adjusted float64
-	switch strategy.RelaxType {
-	case Exponential:
-		adjusted = baseline * (1 + strategy.Gamma*math.Exp(strategy.Beta*(frac-1)))
-	case Sigmoid:
-		adjusted = baseline * (1 + strategy.Gamma/(1+math.Exp(-strategy.Beta*(frac-0.5))))
-	default:
-		adjusted = baseline
-	}
-	// back to wei
-	f := new(big.Float).Mul(big.NewFloat(adjusted), big.NewFloat(1e9))
-	out, _ := f.Int(nil)
-	return out
-}
-
-// skipSubmitByFee returns (true, nil) when submission should be skipped right now
-// because the blob‐fee is above target and the timeout window hasn’t yet elapsed.
-// Otherwise returns (false, err)
-func (r *Layer2Relayer) skipSubmitByFee(oldest time.Time, metrics *l2RelayerMetrics) (bool, error) {
-	windowSec := uint64(r.cfg.BatchSubmission.TimeoutSec)
-
-	hist, err := r.fetchBlobFeeHistory(windowSec)
-	if err != nil || len(hist) == 0 {
-		return false, fmt.Errorf(
-			"blob-fee history unavailable or empty: %w (history_length=%d)",
-			err, len(hist),
-		)
-	}
-
-	// calculate target & get current (in wei)
-	target := calculateTargetPrice(windowSec, r.batchStrategy, oldest, hist)
-	current := hist[len(hist)-1]
-
-	currentFloat, _ := current.Float64()
-	targetFloat, _ := target.Float64()
-	metrics.rollupL2RelayerCurrentBlobPrice.Set(currentFloat)
-	metrics.rollupL2RelayerTargetBlobPrice.Set(targetFloat)
-
-	// if current fee > target and still inside the timeout window, skip
-	if current.Cmp(target) > 0 && time.Since(oldest) < time.Duration(windowSec)*time.Second {
-		return true, fmt.Errorf(
-			"blob-fee above target & window not yet passed; current=%s target=%s age=%s",
-			current.String(), target.String(), time.Since(oldest),
-		)
-	}
-
-	// otherwise proceed with submission
-	return false, nil
-}
-
 func addrFromSignerConfig(config *config.SignerConfig) (common.Address, error) {
 	switch config.SignerType {
 	case sender.PrivateKeySignerType:

rollup/internal/controller/relayer/l2_relayer_metrics.go

@@ -26,12 +26,6 @@ type l2RelayerMetrics struct {
 
 	rollupL2RelayerCommitBlockHeight prometheus.Gauge
 	rollupL2RelayerCommitThroughput  prometheus.Counter
-
-	rollupL2RelayerCurrentBlobPrice prometheus.Gauge
-	rollupL2RelayerTargetBlobPrice  prometheus.Gauge
-	rollupL2RelayerCommitLatency    prometheus.Gauge
-	rollupL2RelayerBacklogCounts    prometheus.Gauge
-	rollupL2RelayerCommitPrice      prometheus.Gauge
 }
 
 var (
@@ -110,26 +104,6 @@ func initL2RelayerMetrics(reg prometheus.Registerer) *l2RelayerMetrics {
 				Name: "rollup_l2_relayer_commit_throughput",
 				Help: "The cumulative gas used in blocks committed by the L2 relayer",
 			}),
-			rollupL2RelayerTargetBlobPrice: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-				Name: "rollup_l2_relayer_target_blob_price",
-				Help: "The target blob price for the L2 relayer's submission strategy",
-			}),
-			rollupL2RelayerCurrentBlobPrice: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-				Name: "rollup_l2_relayer_current_blob_price",
-				Help: "The current blob price",
-			}),
-			rollupL2RelayerCommitLatency: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-				Name: "rollup_l2_relayer_commit_latency",
-				Help: "The latency of the commit measured from oldest blocktime",
-			}),
-			rollupL2RelayerBacklogCounts: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-				Name: "rollup_l2_relayer_backlog_counts",
-				Help: "The number of pending batches in the backlog",
-			}),
-			rollupL2RelayerCommitPrice: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-				Name: "rollup_l2_relayer_commit_price",
-				Help: "The commit price for the L2 relayer's submission strategy",
-			}),
 		}
 	})
 	return l2RelayerMetric

rollup/internal/controller/relayer/l2_relayer_test.go

@@ -48,186 +48,203 @@ func testCreateNewRelayer(t *testing.T) {
 }
 
 func testL2RelayerProcessPendingBatches(t *testing.T) {
-	db := setupL2RelayerDB(t)
-	defer database.CloseDB(db)
+	codecVersions := []encoding.CodecVersion{encoding.CodecV4}
+	for _, codecVersion := range codecVersions {
+		db := setupL2RelayerDB(t)
+		defer database.CloseDB(db)
 
-	l2Cfg := cfg.L2Config
-	chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
+		l2Cfg := cfg.L2Config
+		var chainConfig *params.ChainConfig
+		if codecVersion == encoding.CodecV4 {
+			chainConfig = &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}
+		} else {
+			assert.Fail(t, "unsupported codec version, expected CodecV4")
+		}
 
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, chainConfig, ServiceTypeL2RollupRelayer, nil)
-	assert.NoError(t, err)
+		relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, chainConfig, ServiceTypeL2RollupRelayer, nil)
+		assert.NoError(t, err)
 
-	patchGuard := gomonkey.ApplyMethodFunc(l2Cli, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
-		return nil
-	})
+		patchGuard := gomonkey.ApplyMethodFunc(l2Cli, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
+			return nil
+		})
 
-	l2BlockOrm := orm.NewL2Block(db)
-	err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
-	assert.NoError(t, err)
-	chunkOrm := orm.NewChunk(db)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk1, encoding.CodecV7, rutils.ChunkMetrics{})
-	assert.NoError(t, err)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk2, encoding.CodecV7, rutils.ChunkMetrics{})
-	assert.NoError(t, err)
+		l2BlockOrm := orm.NewL2Block(db)
+		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{})
+		assert.NoError(t, err)
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
+		assert.NoError(t, err)
 
-	batch := &encoding.Batch{
-		Index:                      1,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
-		Blocks:                     []*encoding.Block{block1, block2},
+		batch := &encoding.Batch{
+			Index:                      1,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		}
+
+		batchOrm := orm.NewBatch(db)
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion, rutils.BatchMetrics{})
+		assert.NoError(t, err)
+
+		relayer.ProcessPendingBatches()
+
+		statuses, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{dbBatch.Hash})
+		assert.NoError(t, err)
+		assert.Equal(t, 1, len(statuses))
+		assert.Equal(t, types.RollupCommitting, statuses[0])
+		relayer.StopSenders()
+		patchGuard.Reset()
 	}
-
-	batchOrm := orm.NewBatch(db)
-	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV7, rutils.BatchMetrics{})
-	assert.NoError(t, err)
-
-	relayer.ProcessPendingBatches()
-
-	statuses, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{dbBatch.Hash})
-	assert.NoError(t, err)
-	assert.Equal(t, 1, len(statuses))
-	assert.Equal(t, types.RollupCommitting, statuses[0])
-	relayer.StopSenders()
-	patchGuard.Reset()
 }
 
 func testL2RelayerProcessPendingBundles(t *testing.T) {
-	db := setupL2RelayerDB(t)
-	defer database.CloseDB(db)
+	codecVersions := []encoding.CodecVersion{encoding.CodecV4}
+	for _, codecVersion := range codecVersions {
+		db := setupL2RelayerDB(t)
+		defer database.CloseDB(db)
 
-	l2Cfg := cfg.L2Config
-	chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, chainConfig, ServiceTypeL2RollupRelayer, nil)
-	assert.NoError(t, err)
+		l2Cfg := cfg.L2Config
+		var chainConfig *params.ChainConfig
+		if codecVersion == encoding.CodecV4 {
+			chainConfig = &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}
+		}
+		relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, chainConfig, ServiceTypeL2RollupRelayer, nil)
+		assert.NoError(t, err)
 
-	batch := &encoding.Batch{
-		Index:                      1,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
-		Blocks:                     []*encoding.Block{block1, block2},
+		batch := &encoding.Batch{
+			Index:                      1,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		}
+
+		chunkOrm := orm.NewChunk(db)
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk1, codecVersion, rutils.ChunkMetrics{})
+		assert.NoError(t, err)
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
+		assert.NoError(t, err)
+
+		batchOrm := orm.NewBatch(db)
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion, rutils.BatchMetrics{})
+		assert.NoError(t, err)
+
+		bundleOrm := orm.NewBundle(db)
+		bundle, err := bundleOrm.InsertBundle(context.Background(), []*orm.Batch{dbBatch}, codecVersion)
+		assert.NoError(t, err)
+
+		err = bundleOrm.UpdateRollupStatus(context.Background(), bundle.Hash, types.RollupPending)
+		assert.NoError(t, err)
+
+		err = bundleOrm.UpdateProvingStatus(context.Background(), dbBatch.Hash, types.ProvingTaskVerified)
+		assert.NoError(t, err)
+
+		relayer.ProcessPendingBundles()
+
+		bundles, err := bundleOrm.GetBundles(context.Background(), map[string]interface{}{"hash": bundle.Hash}, nil, 0)
+		assert.NoError(t, err)
+		assert.Equal(t, 1, len(bundles))
+		// no valid proof, rollup status remains the same
+		assert.Equal(t, types.RollupPending, types.RollupStatus(bundles[0].RollupStatus))
+
+		patchGuard := gomonkey.ApplyMethodFunc((*message.OpenVMBundleProof)(nil), "SanityCheck", func() error {
+			return nil
+		})
+		defer patchGuard.Reset()
+
+		proof := &message.OpenVMBundleProof{EvmProof: &message.OpenVMEvmProof{Instances: make([]byte, 384)}}
+		err = bundleOrm.UpdateProofAndProvingStatusByHash(context.Background(), bundle.Hash, proof, types.ProvingTaskVerified, 600)
+		assert.NoError(t, err)
+
+		relayer.ProcessPendingBundles()
+		bundles, err = bundleOrm.GetBundles(context.Background(), map[string]interface{}{"hash": bundle.Hash}, nil, 0)
+		assert.NoError(t, err)
+		assert.Equal(t, 1, len(bundles))
+		assert.Equal(t, types.RollupFinalizing, types.RollupStatus(bundles[0].RollupStatus))
+		relayer.StopSenders()
 	}
-
-	chunkOrm := orm.NewChunk(db)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk1, encoding.CodecV7, rutils.ChunkMetrics{})
-	assert.NoError(t, err)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk2, encoding.CodecV7, rutils.ChunkMetrics{})
-	assert.NoError(t, err)
-
-	batchOrm := orm.NewBatch(db)
-	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV7, rutils.BatchMetrics{})
-	assert.NoError(t, err)
-
-	bundleOrm := orm.NewBundle(db)
-	bundle, err := bundleOrm.InsertBundle(context.Background(), []*orm.Batch{dbBatch}, encoding.CodecV7)
-	assert.NoError(t, err)
-
-	err = bundleOrm.UpdateRollupStatus(context.Background(), bundle.Hash, types.RollupPending)
-	assert.NoError(t, err)
-
-	err = bundleOrm.UpdateProvingStatus(context.Background(), bundle.Hash, types.ProvingTaskVerified)
-	assert.NoError(t, err)
-
-	relayer.ProcessPendingBundles()
-
-	bundles, err := bundleOrm.GetBundles(context.Background(), map[string]interface{}{"hash": bundle.Hash}, nil, 0)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, len(bundles))
-	// no valid proof, rollup status remains the same
-	assert.Equal(t, types.RollupPending, types.RollupStatus(bundles[0].RollupStatus))
-
-	patchGuard := gomonkey.ApplyMethodFunc((*message.OpenVMBundleProof)(nil), "SanityCheck", func() error {
-		return nil
-	})
-	defer patchGuard.Reset()
-
-	proof := &message.OpenVMBundleProof{EvmProof: &message.OpenVMEvmProof{Instances: make([]byte, 384)}}
-	err = bundleOrm.UpdateProofAndProvingStatusByHash(context.Background(), bundle.Hash, proof, types.ProvingTaskVerified, 600)
-	assert.NoError(t, err)
-
-	relayer.ProcessPendingBundles()
-	bundles, err = bundleOrm.GetBundles(context.Background(), map[string]interface{}{"hash": bundle.Hash}, nil, 0)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, len(bundles))
-	assert.Equal(t, types.RollupFinalizing, types.RollupStatus(bundles[0].RollupStatus))
-	relayer.StopSenders()
 }
 
 func testL2RelayerFinalizeTimeoutBundles(t *testing.T) {
-	db := setupL2RelayerDB(t)
-	defer database.CloseDB(db)
+	codecVersions := []encoding.CodecVersion{encoding.CodecV4}
+	for _, codecVersion := range codecVersions {
+		db := setupL2RelayerDB(t)
+		defer database.CloseDB(db)
 
-	l2Cfg := cfg.L2Config
-	l2Cfg.RelayerConfig.EnableTestEnvBypassFeatures = true
-	l2Cfg.RelayerConfig.FinalizeBundleWithoutProofTimeoutSec = 0
-	chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, chainConfig, ServiceTypeL2RollupRelayer, nil)
-	assert.NoError(t, err)
+		l2Cfg := cfg.L2Config
+		l2Cfg.RelayerConfig.EnableTestEnvBypassFeatures = true
+		l2Cfg.RelayerConfig.FinalizeBundleWithoutProofTimeoutSec = 0
+		var chainConfig *params.ChainConfig
+		if codecVersion == encoding.CodecV4 {
+			chainConfig = &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}
+		}
+		relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, chainConfig, ServiceTypeL2RollupRelayer, nil)
+		assert.NoError(t, err)
 
-	l2BlockOrm := orm.NewL2Block(db)
-	err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
-	assert.NoError(t, err)
-	chunkOrm := orm.NewChunk(db)
-	chunkDB1, err := chunkOrm.InsertChunk(context.Background(), chunk1, encoding.CodecV7, rutils.ChunkMetrics{})
-	assert.NoError(t, err)
-	chunkDB2, err := chunkOrm.InsertChunk(context.Background(), chunk2, encoding.CodecV7, rutils.ChunkMetrics{})
-	assert.NoError(t, err)
+		l2BlockOrm := orm.NewL2Block(db)
+		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{})
+		assert.NoError(t, err)
+		chunkDB2, err := chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, rutils.ChunkMetrics{})
+		assert.NoError(t, err)
 
-	batch := &encoding.Batch{
-		Index:                      1,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
-		Blocks:                     []*encoding.Block{block1, block2},
+		batch := &encoding.Batch{
+			Index:                      1,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		}
+
+		batchOrm := orm.NewBatch(db)
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion, rutils.BatchMetrics{})
+		assert.NoError(t, err)
+
+		err = batchOrm.UpdateRollupStatus(context.Background(), dbBatch.Hash, types.RollupCommitted)
+		assert.NoError(t, err)
+
+		err = chunkOrm.UpdateBatchHashInRange(context.Background(), chunkDB1.Index, chunkDB2.Index, dbBatch.Hash, nil)
+		assert.NoError(t, err)
+
+		bundleOrm := orm.NewBundle(db)
+		bundle, err := bundleOrm.InsertBundle(context.Background(), []*orm.Batch{dbBatch}, codecVersion)
+		assert.NoError(t, err)
+
+		err = batchOrm.UpdateBundleHashInRange(context.Background(), dbBatch.Index, dbBatch.Index, bundle.Hash, nil)
+		assert.NoError(t, err)
+
+		assert.Eventually(t, func() bool {
+			relayer.ProcessPendingBundles()
+
+			bundleInDB, bundleErr := bundleOrm.GetBundles(context.Background(), map[string]interface{}{"hash": bundle.Hash}, nil, 0)
+			if bundleErr != nil {
+				return false
+			}
+
+			bundleStatus := len(bundleInDB) == 1 && types.RollupStatus(bundleInDB[0].RollupStatus) == types.RollupFinalizing &&
+				types.ProvingStatus(bundleInDB[0].ProvingStatus) == types.ProvingTaskVerified
+
+			batchInDB, batchErr := batchOrm.GetBatches(context.Background(), map[string]interface{}{"hash": dbBatch.Hash}, nil, 0)
+			if batchErr != nil {
+				return false
+			}
+
+			batchStatus := len(batchInDB) == 1 && types.ProvingStatus(batchInDB[0].ProvingStatus) == types.ProvingTaskVerified
+
+			chunks, chunkErr := chunkOrm.GetChunksByBatchHash(context.Background(), dbBatch.Hash)
+			if chunkErr != nil {
+				return false
+			}
+
+			chunkStatus := len(chunks) == 2 && types.ProvingStatus(chunks[0].ProvingStatus) == types.ProvingTaskVerified &&
+				types.ProvingStatus(chunks[1].ProvingStatus) == types.ProvingTaskVerified
+
+			return bundleStatus && batchStatus && chunkStatus
+		}, 5*time.Second, 100*time.Millisecond, "Bundle or Batch or Chunk status did not update as expected")
+		relayer.StopSenders()
 	}
-
-	batchOrm := orm.NewBatch(db)
-	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV7, rutils.BatchMetrics{})
-	assert.NoError(t, err)
-
-	err = batchOrm.UpdateRollupStatus(context.Background(), dbBatch.Hash, types.RollupCommitted)
-	assert.NoError(t, err)
-
-	err = chunkOrm.UpdateBatchHashInRange(context.Background(), chunkDB1.Index, chunkDB2.Index, dbBatch.Hash, nil)
-	assert.NoError(t, err)
-
-	bundleOrm := orm.NewBundle(db)
-	bundle, err := bundleOrm.InsertBundle(context.Background(), []*orm.Batch{dbBatch}, encoding.CodecV7)
-	assert.NoError(t, err)
-
-	err = batchOrm.UpdateBundleHashInRange(context.Background(), dbBatch.Index, dbBatch.Index, bundle.Hash, nil)
-	assert.NoError(t, err)
-
-	assert.Eventually(t, func() bool {
-		relayer.ProcessPendingBundles()
-
-		bundleInDB, bundleErr := bundleOrm.GetBundles(context.Background(), map[string]interface{}{"hash": bundle.Hash}, nil, 0)
-		if bundleErr != nil {
-			return false
-		}
-
-		bundleStatus := len(bundleInDB) == 1 && types.RollupStatus(bundleInDB[0].RollupStatus) == types.RollupFinalizing &&
-			types.ProvingStatus(bundleInDB[0].ProvingStatus) == types.ProvingTaskVerified
-
-		batchInDB, batchErr := batchOrm.GetBatches(context.Background(), map[string]interface{}{"hash": dbBatch.Hash}, nil, 0)
-		if batchErr != nil {
-			return false
-		}
-
-		batchStatus := len(batchInDB) == 1 && types.ProvingStatus(batchInDB[0].ProvingStatus) == types.ProvingTaskVerified
-
-		chunks, chunkErr := chunkOrm.GetChunksByBatchHash(context.Background(), dbBatch.Hash)
-		if chunkErr != nil {
-			return false
-		}
-
-		chunkStatus := len(chunks) == 2 && types.ProvingStatus(chunks[0].ProvingStatus) == types.ProvingTaskVerified &&
-			types.ProvingStatus(chunks[1].ProvingStatus) == types.ProvingTaskVerified
-
-		return bundleStatus && batchStatus && chunkStatus
-	}, 5*time.Second, 100*time.Millisecond, "Bundle or Batch or Chunk status did not update as expected")
-	relayer.StopSenders()
 }
 
 func testL2RelayerCommitConfirm(t *testing.T) {
@@ -252,7 +269,6 @@ func testL2RelayerCommitConfirm(t *testing.T) {
 			TotalL1MessagePoppedBefore: 0,
 			ParentBatchHash:            common.Hash{},
 			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
-			Blocks:                     []*encoding.Block{block1, block2},
 		}
 
 		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, rutils.BatchMetrics{})
@@ -311,14 +327,13 @@ func testL2RelayerFinalizeBundleConfirm(t *testing.T) {
 			TotalL1MessagePoppedBefore: 0,
 			ParentBatchHash:            common.Hash{},
 			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
-			Blocks:                     []*encoding.Block{block1, block2},
 		}
 
 		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, rutils.BatchMetrics{})
 		assert.NoError(t, err)
 		batchHashes[i] = dbBatch.Hash
 
-		bundle, err := bundleOrm.InsertBundle(context.Background(), []*orm.Batch{dbBatch}, encoding.CodecV7)
+		bundle, err := bundleOrm.InsertBundle(context.Background(), []*orm.Batch{dbBatch}, encoding.CodecV4)
 		assert.NoError(t, err)
 		bundleHashes[i] = bundle.Hash
 
@@ -398,7 +413,6 @@ func testGetBatchStatusByIndex(t *testing.T) {
 		TotalL1MessagePoppedBefore: 0,
 		ParentBatchHash:            common.Hash{},
 		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
-		Blocks:                     []*encoding.Block{block1, block2},
 	}
 
 	batchOrm := orm.NewBatch(db)

rollup/internal/controller/sender/estimategas.go

@@ -7,10 +7,11 @@ import (
 	"github.com/scroll-tech/go-ethereum"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/core/types"
+	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/log"
 )
 
-func (s *Sender) estimateLegacyGas(to *common.Address, data []byte) (*FeeData, error) {
+func (s *Sender) estimateLegacyGas(to *common.Address, data []byte, fallbackGasLimit uint64) (*FeeData, error) {
 	gasPrice, err := s.client.SuggestGasPrice(s.ctx)
 	if err != nil {
 		log.Error("estimateLegacyGas SuggestGasPrice failure", "error", err)
@@ -25,17 +26,21 @@ func (s *Sender) estimateLegacyGas(to *common.Address, data []byte) (*FeeData, e
 	gasLimit, _, err := s.estimateGasLimit(to, data, nil, gasPrice, nil, nil, nil)
 	if err != nil {
 		log.Error("estimateLegacyGas estimateGasLimit failure", "gas price", gasPrice, "from", s.transactionSigner.GetAddr().String(),
-			"nonce", s.transactionSigner.GetNonce(), "to address", to.String(), "error", err)
-		return nil, err
+			"nonce", s.transactionSigner.GetNonce(), "to address", to.String(), "fallback gas limit", fallbackGasLimit, "error", err)
+		if fallbackGasLimit == 0 {
+			return nil, err
+		}
+		gasLimit = fallbackGasLimit
+	} else {
+		gasLimit = gasLimit * 12 / 10 // 20% extra gas to avoid out of gas error
 	}
-
 	return &FeeData{
 		gasPrice: gasPrice,
-		gasLimit: gasLimit * 12 / 10, // 20% extra gas to avoid out of gas error
+		gasLimit: gasLimit,
 	}, nil
 }
 
-func (s *Sender) estimateDynamicGas(to *common.Address, data []byte, baseFee uint64) (*FeeData, error) {
+func (s *Sender) estimateDynamicGas(to *common.Address, data []byte, baseFee uint64, fallbackGasLimit uint64) (*FeeData, error) {
 	gasTipCap, err := s.client.SuggestGasTipCap(s.ctx)
 	if err != nil {
 		log.Error("estimateDynamicGas SuggestGasTipCap failure", "error", err)
@@ -52,12 +57,16 @@ func (s *Sender) estimateDynamicGas(to *common.Address, data []byte, baseFee uin
 	if err != nil {
 		log.Error("estimateDynamicGas estimateGasLimit failure",
 			"from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "to address", to.String(),
-			"fallback gas limit", "error", err)
-		return nil, err
+			"fallback gas limit", fallbackGasLimit, "error", err)
+		if fallbackGasLimit == 0 {
+			return nil, err
+		}
+		gasLimit = fallbackGasLimit
+	} else {
+		gasLimit = gasLimit * 12 / 10 // 20% extra gas to avoid out of gas error
 	}
-
 	feeData := &FeeData{
-		gasLimit:  gasLimit * 12 / 10, // 20% extra gas to avoid out of gas error,
+		gasLimit:  gasLimit,
 		gasTipCap: gasTipCap,
 		gasFeeCap: gasFeeCap,
 	}
@@ -67,7 +76,7 @@ func (s *Sender) estimateDynamicGas(to *common.Address, data []byte, baseFee uin
 	return feeData, nil
 }
 
-func (s *Sender) estimateBlobGas(to *common.Address, data []byte, sidecar *types.BlobTxSidecar, baseFee, blobBaseFee uint64) (*FeeData, error) {
+func (s *Sender) estimateBlobGas(to *common.Address, data []byte, sidecar *gethTypes.BlobTxSidecar, baseFee, blobBaseFee uint64, fallbackGasLimit uint64) (*FeeData, error) {
 	gasTipCap, err := s.client.SuggestGasTipCap(s.ctx)
 	if err != nil {
 		log.Error("estimateBlobGas SuggestGasTipCap failure", "error", err)
@@ -84,12 +93,17 @@ func (s *Sender) estimateBlobGas(to *common.Address, data []byte, sidecar *types
 	gasLimit, accessList, err := s.estimateGasLimit(to, data, sidecar, nil, gasTipCap, gasFeeCap, blobGasFeeCap)
 	if err != nil {
 		log.Error("estimateBlobGas estimateGasLimit failure",
-			"from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "to address", to.String(), "error", err)
-		return nil, err
+			"from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "to address", to.String(),
+			"fallback gas limit", fallbackGasLimit, "error", err)
+		if fallbackGasLimit == 0 {
+			return nil, err
+		}
+		gasLimit = fallbackGasLimit
+	} else {
+		gasLimit = gasLimit * 12 / 10 // 20% extra gas to avoid out of gas error
 	}
-
 	feeData := &FeeData{
-		gasLimit:      gasLimit * 12 / 10, // 20% extra gas to avoid out of gas error
+		gasLimit:      gasLimit,
 		gasTipCap:     gasTipCap,
 		gasFeeCap:     gasFeeCap,
 		blobGasFeeCap: blobGasFeeCap,
@@ -101,7 +115,7 @@ func (s *Sender) estimateBlobGas(to *common.Address, data []byte, sidecar *types
 	return feeData, nil
 }
 
-func (s *Sender) estimateGasLimit(to *common.Address, data []byte, sidecar *types.BlobTxSidecar, gasPrice, gasTipCap, gasFeeCap, blobGasFeeCap *big.Int) (uint64, *types.AccessList, error) {
+func (s *Sender) estimateGasLimit(to *common.Address, data []byte, sidecar *gethTypes.BlobTxSidecar, gasPrice, gasTipCap, gasFeeCap, blobGasFeeCap *big.Int) (uint64, *types.AccessList, error) {
 	msg := ethereum.CallMsg{
 		From:      s.transactionSigner.GetAddr(),
 		To:        to,

rollup/internal/controller/sender/sender.go

@@ -156,22 +156,22 @@ func (s *Sender) SendConfirmation(cfm *Confirmation) {
 	s.confirmCh <- cfm
 }
 
-func (s *Sender) getFeeData(target *common.Address, data []byte, sidecar *gethTypes.BlobTxSidecar, baseFee, blobBaseFee uint64) (*FeeData, error) {
+func (s *Sender) getFeeData(target *common.Address, data []byte, sidecar *gethTypes.BlobTxSidecar, baseFee, blobBaseFee uint64, fallbackGasLimit uint64) (*FeeData, error) {
 	switch s.config.TxType {
 	case LegacyTxType:
-		return s.estimateLegacyGas(target, data)
+		return s.estimateLegacyGas(target, data, fallbackGasLimit)
 	case DynamicFeeTxType:
 		if sidecar == nil {
-			return s.estimateDynamicGas(target, data, baseFee)
+			return s.estimateDynamicGas(target, data, baseFee, fallbackGasLimit)
 		}
-		return s.estimateBlobGas(target, data, sidecar, baseFee, blobBaseFee)
+		return s.estimateBlobGas(target, data, sidecar, baseFee, blobBaseFee, fallbackGasLimit)
 	default:
 		return nil, fmt.Errorf("unsupported transaction type: %s", s.config.TxType)
 	}
 }
 
 // SendTransaction send a signed L2tL1 transaction.
-func (s *Sender) SendTransaction(contextID string, target *common.Address, data []byte, blobs []*kzg4844.Blob) (common.Hash, uint64, error) {
+func (s *Sender) SendTransaction(contextID string, target *common.Address, data []byte, blobs []*kzg4844.Blob, fallbackGasLimit uint64) (common.Hash, error) {
 	s.metrics.sendTransactionTotal.WithLabelValues(s.service, s.name).Inc()
 	var (
 		feeData *FeeData
@@ -190,37 +190,37 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 			numPendingTransactions, err = s.pendingTransactionOrm.GetCountPendingTransactionsBySenderType(s.ctx, s.senderType)
 			if err != nil {
 				log.Error("failed to count pending transactions", "err: %w", err)
-				return common.Hash{}, 0, fmt.Errorf("failed to count pending transactions, err: %w", err)
+				return common.Hash{}, fmt.Errorf("failed to count pending transactions, err: %w", err)
 			}
 			if numPendingTransactions >= s.config.MaxPendingBlobTxs {
-				return common.Hash{}, 0, ErrTooManyPendingBlobTxs
+				return common.Hash{}, ErrTooManyPendingBlobTxs
 			}
 
 		}
 		sidecar, err = makeSidecar(blobs)
 		if err != nil {
 			log.Error("failed to make sidecar for blob transaction", "error", err)
-			return common.Hash{}, 0, fmt.Errorf("failed to make sidecar for blob transaction, err: %w", err)
+			return common.Hash{}, fmt.Errorf("failed to make sidecar for blob transaction, err: %w", err)
 		}
 	}
 
 	blockNumber, baseFee, blobBaseFee, err := s.getBlockNumberAndBaseFeeAndBlobFee(s.ctx)
 	if err != nil {
 		log.Error("failed to get block number and base fee", "error", err)
-		return common.Hash{}, 0, fmt.Errorf("failed to get block number and base fee, err: %w", err)
+		return common.Hash{}, fmt.Errorf("failed to get block number and base fee, err: %w", err)
 	}
 
-	if feeData, err = s.getFeeData(target, data, sidecar, baseFee, blobBaseFee); err != nil {
+	if feeData, err = s.getFeeData(target, data, sidecar, baseFee, blobBaseFee, fallbackGasLimit); err != nil {
 		s.metrics.sendTransactionFailureGetFee.WithLabelValues(s.service, s.name).Inc()
-		log.Error("failed to get fee data", "from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "err", err)
-		return common.Hash{}, 0, fmt.Errorf("failed to get fee data, err: %w", err)
+		log.Error("failed to get fee data", "from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "fallback gas limit", fallbackGasLimit, "err", err)
+		return common.Hash{}, fmt.Errorf("failed to get fee data, err: %w", err)
 	}
 
 	signedTx, err := s.createTx(feeData, target, data, sidecar, s.transactionSigner.GetNonce())
 	if err != nil {
 		s.metrics.sendTransactionFailureSendTx.WithLabelValues(s.service, s.name).Inc()
 		log.Error("failed to create signed tx (non-resubmit case)", "from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "err", err)
-		return common.Hash{}, 0, fmt.Errorf("failed to create signed transaction, err: %w", err)
+		return common.Hash{}, fmt.Errorf("failed to create signed transaction, err: %w", err)
 	}
 
 	// Insert the transaction into the pending transaction table.
@@ -228,14 +228,14 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 	// This case will be handled by the checkPendingTransaction function.
 	if err = s.pendingTransactionOrm.InsertPendingTransaction(s.ctx, contextID, s.getSenderMeta(), signedTx, blockNumber); err != nil {
 		log.Error("failed to insert transaction", "from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "err", err)
-		return common.Hash{}, 0, fmt.Errorf("failed to insert transaction, err: %w", err)
+		return common.Hash{}, fmt.Errorf("failed to insert transaction, err: %w", err)
 	}
 
 	if err := s.client.SendTransaction(s.ctx, signedTx); err != nil {
 		// Delete the transaction from the pending transaction table if it fails to send.
 		if updateErr := s.pendingTransactionOrm.DeleteTransactionByTxHash(s.ctx, signedTx.Hash()); updateErr != nil {
 			log.Error("failed to delete transaction", "tx hash", signedTx.Hash().String(), "from", s.transactionSigner.GetAddr().String(), "nonce", signedTx.Nonce(), "err", updateErr)
-			return common.Hash{}, 0, fmt.Errorf("failed to delete transaction, err: %w", updateErr)
+			return common.Hash{}, fmt.Errorf("failed to delete transaction, err: %w", updateErr)
 		}
 
 		log.Error("failed to send tx", "tx hash", signedTx.Hash().String(), "from", s.transactionSigner.GetAddr().String(), "nonce", signedTx.Nonce(), "err", err)
@@ -244,12 +244,12 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 		if strings.Contains(err.Error(), "nonce too low") {
 			s.resetNonce(context.Background())
 		}
-		return common.Hash{}, 0, fmt.Errorf("failed to send transaction, err: %w", err)
+		return common.Hash{}, fmt.Errorf("failed to send transaction, err: %w", err)
 	}
 
 	s.transactionSigner.SetNonce(signedTx.Nonce() + 1)
 
-	return signedTx.Hash(), blobBaseFee, nil
+	return signedTx.Hash(), nil
 }
 
 func (s *Sender) createTx(feeData *FeeData, target *common.Address, data []byte, sidecar *gethTypes.BlobTxSidecar, nonce uint64) (*gethTypes.Transaction, error) {

rollup/internal/controller/sender/sender_test.go

@@ -21,6 +21,7 @@ import (
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
+	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/stretchr/testify/assert"
@@ -33,6 +34,7 @@ import (
 
 	bridgeAbi "scroll-tech/rollup/abi"
 	"scroll-tech/rollup/internal/config"
+	"scroll-tech/rollup/internal/orm"
 	"scroll-tech/rollup/mock_bridge"
 )
 
@@ -134,6 +136,7 @@ func TestSender(t *testing.T) {
 	setupEnv(t)
 	t.Run("test new sender", testNewSender)
 	t.Run("test send and retrieve transaction", testSendAndRetrieveTransaction)
+	t.Run("test fallback gas limit", testFallbackGasLimit)
 	t.Run("test access list transaction gas limit", testAccessListTransactionGasLimit)
 	t.Run("test resubmit zero gas price transaction", testResubmitZeroGasPriceTransaction)
 	t.Run("test resubmit non-zero gas price transaction", testResubmitNonZeroGasPriceTransaction)
@@ -187,7 +190,7 @@ func testSendAndRetrieveTransaction(t *testing.T) {
 		if txBlob[i] != nil {
 			blobs = []*kzg4844.Blob{txBlob[i]}
 		}
-		hash, _, err := s.SendTransaction("0", &common.Address{}, nil, blobs)
+		hash, err := s.SendTransaction("0", &common.Address{}, nil, blobs, 0)
 		assert.NoError(t, err)
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
 		assert.NoError(t, err)
@@ -211,6 +214,63 @@ func testSendAndRetrieveTransaction(t *testing.T) {
 	}
 }
 
+func testFallbackGasLimit(t *testing.T) {
+	for i, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
+		cfgCopy.TxType = txType
+		cfgCopy.Confirmations = rpc.LatestBlockNumber
+		s, err := NewSender(context.Background(), &cfgCopy, signerConfig, "test", "test", types.SenderTypeUnknown, db, nil)
+		assert.NoError(t, err)
+
+		client, err := ethclient.Dial(cfgCopy.Endpoint)
+		assert.NoError(t, err)
+
+		var blobs []*kzg4844.Blob
+		if txBlob[i] != nil {
+			blobs = []*kzg4844.Blob{txBlob[i]}
+		}
+		// FallbackGasLimit = 0
+		txHash0, err := s.SendTransaction("0", &common.Address{}, nil, blobs, 0)
+		assert.NoError(t, err)
+		tx0, _, err := client.TransactionByHash(context.Background(), txHash0)
+		assert.NoError(t, err)
+		assert.Greater(t, tx0.Gas(), uint64(0))
+
+		assert.Eventually(t, func() bool {
+			var txs []orm.PendingTransaction
+			txs, err = s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 100)
+			assert.NoError(t, err)
+			return len(txs) == 0
+		}, 30*time.Second, time.Second)
+
+		// FallbackGasLimit = 100000
+		patchGuard := gomonkey.ApplyPrivateMethod(s, "estimateGasLimit",
+			func(contract *common.Address, data []byte, sidecar *gethTypes.BlobTxSidecar, gasPrice, gasTipCap, gasFeeCap, blobGasFeeCap *big.Int) (uint64, *gethTypes.AccessList, error) {
+				return 0, nil, errors.New("estimateGasLimit error")
+			},
+		)
+
+		txHash1, err := s.SendTransaction("1", &common.Address{}, nil, blobs, 100000)
+		assert.NoError(t, err)
+		tx1, _, err := client.TransactionByHash(context.Background(), txHash1)
+		assert.NoError(t, err)
+		assert.Equal(t, uint64(100000), tx1.Gas())
+
+		assert.Eventually(t, func() bool {
+			txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 100)
+			assert.NoError(t, err)
+			return len(txs) == 0
+		}, 30*time.Second, time.Second)
+
+		s.Stop()
+		patchGuard.Reset()
+	}
+}
+
 func testResubmitZeroGasPriceTransaction(t *testing.T) {
 	for i, txType := range txTypes {
 		if txBlob[i] != nil {
@@ -545,10 +605,10 @@ func testResubmitNonceGappedTransaction(t *testing.T) {
 		if txBlob[i] != nil {
 			blobs = []*kzg4844.Blob{txBlob[i]}
 		}
-		_, _, err = s.SendTransaction("test-1", &common.Address{}, nil, blobs)
+		_, err = s.SendTransaction("test-1", &common.Address{}, nil, blobs, 0)
 		assert.NoError(t, err)
 
-		_, _, err = s.SendTransaction("test-2", &common.Address{}, nil, blobs)
+		_, err = s.SendTransaction("test-2", &common.Address{}, nil, blobs, 0)
 		assert.NoError(t, err)
 
 		s.checkPendingTransaction()
@@ -589,7 +649,7 @@ func testCheckPendingTransactionTxConfirmed(t *testing.T) {
 			return nil
 		})
 
-		_, _, err = s.SendTransaction("test", &common.Address{}, nil, randBlobs(1))
+		_, err = s.SendTransaction("test", &common.Address{}, nil, randBlobs(1), 0)
 		assert.NoError(t, err)
 
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
@@ -631,7 +691,7 @@ func testCheckPendingTransactionResubmitTxConfirmed(t *testing.T) {
 			return nil
 		})
 
-		originTxHash, _, err := s.SendTransaction("test", &common.Address{}, nil, randBlobs(1))
+		originTxHash, err := s.SendTransaction("test", &common.Address{}, nil, randBlobs(1), 0)
 		assert.NoError(t, err)
 
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
@@ -691,7 +751,7 @@ func testCheckPendingTransactionReplacedTxConfirmed(t *testing.T) {
 			return nil
 		})
 
-		txHash, _, err := s.SendTransaction("test", &common.Address{}, nil, randBlobs(1))
+		txHash, err := s.SendTransaction("test", &common.Address{}, nil, randBlobs(1), 0)
 		assert.NoError(t, err)
 
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
@@ -761,7 +821,7 @@ func testCheckPendingTransactionTxMultipleTimesWithOnlyOneTxPending(t *testing.T
 			return nil
 		})
 
-		_, _, err = s.SendTransaction("test", &common.Address{}, nil, randBlobs(1))
+		_, err = s.SendTransaction("test", &common.Address{}, nil, randBlobs(1), 0)
 		assert.NoError(t, err)
 
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
@@ -835,7 +895,7 @@ func testBlobTransactionWithBlobhashOpContractCall(t *testing.T) {
 	assert.NoError(t, err)
 	defer s.Stop()
 
-	_, _, err = s.SendTransaction("0", &testContractsAddress, data, blobs)
+	_, err = s.SendTransaction("0", &testContractsAddress, data, blobs, 0)
 	assert.NoError(t, err)
 
 	var txHash common.Hash
@@ -893,10 +953,10 @@ func testSendBlobCarryingTxOverLimit(t *testing.T) {
 	assert.NoError(t, err)
 
 	for i := 0; i < int(cfgCopy.MaxPendingBlobTxs); i++ {
-		_, _, err = s.SendTransaction("0", &common.Address{}, nil, randBlobs(1))
+		_, err = s.SendTransaction("0", &common.Address{}, nil, randBlobs(1), 0)
 		assert.NoError(t, err)
 	}
-	_, _, err = s.SendTransaction("0", &common.Address{}, nil, randBlobs(1))
+	_, err = s.SendTransaction("0", &common.Address{}, nil, randBlobs(1), 0)
 	assert.ErrorIs(t, err, ErrTooManyPendingBlobTxs)
 	s.Stop()
 }

rollup/internal/controller/watcher/batch_proposer.go

@@ -29,7 +29,12 @@ type BatchProposer struct {
 	chunkOrm   *orm.Chunk
 	l2BlockOrm *orm.L2Block
 
-	cfg *config.BatchProposerConfig
+	maxL1CommitGasPerBatch          uint64
+	maxL1CommitCalldataSizePerBatch uint64
+	batchTimeoutSec                 uint64
+	gasCostIncreaseMultiplier       float64
+	maxUncompressedBatchBytesSize   uint64
+	maxChunksPerBatch               int
 
 	replayMode      bool
 	minCodecVersion encoding.CodecVersion
@@ -39,10 +44,14 @@ type BatchProposer struct {
 	proposeBatchFailureTotal           prometheus.Counter
 	proposeBatchUpdateInfoTotal        prometheus.Counter
 	proposeBatchUpdateInfoFailureTotal prometheus.Counter
+	totalL1CommitGas                   prometheus.Gauge
+	totalL1CommitCalldataSize          prometheus.Gauge
 	totalL1CommitBlobSize              prometheus.Gauge
 	batchChunksNum                     prometheus.Gauge
 	batchFirstBlockTimeoutReached      prometheus.Counter
 	batchChunksProposeNotEnoughTotal   prometheus.Counter
+	batchEstimateGasTime               prometheus.Gauge
+	batchEstimateCalldataSizeTime      prometheus.Gauge
 	batchEstimateBlobSizeTime          prometheus.Gauge
 
 	// total number of times that batch proposer stops early due to compressed data compatibility breach
@@ -54,18 +63,29 @@ type BatchProposer struct {
 
 // NewBatchProposer creates a new BatchProposer instance.
 func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, minCodecVersion encoding.CodecVersion, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *BatchProposer {
-	log.Info("new batch proposer", "batchTimeoutSec", cfg.BatchTimeoutSec, "maxBlobSize", maxBlobSize)
+	log.Info("new batch proposer",
+		"maxL1CommitGasPerBatch", cfg.MaxL1CommitGasPerBatch,
+		"maxL1CommitCalldataSizePerBatch", cfg.MaxL1CommitCalldataSizePerBatch,
+		"batchTimeoutSec", cfg.BatchTimeoutSec,
+		"gasCostIncreaseMultiplier", cfg.GasCostIncreaseMultiplier,
+		"maxBlobSize", maxBlobSize,
+		"maxUncompressedBatchBytesSize", cfg.MaxUncompressedBatchBytesSize)
 
 	p := &BatchProposer{
-		ctx:             ctx,
-		db:              db,
-		batchOrm:        orm.NewBatch(db),
-		chunkOrm:        orm.NewChunk(db),
-		l2BlockOrm:      orm.NewL2Block(db),
-		cfg:             cfg,
-		replayMode:      false,
-		minCodecVersion: minCodecVersion,
-		chainCfg:        chainCfg,
+		ctx:                             ctx,
+		db:                              db,
+		batchOrm:                        orm.NewBatch(db),
+		chunkOrm:                        orm.NewChunk(db),
+		l2BlockOrm:                      orm.NewL2Block(db),
+		maxL1CommitGasPerBatch:          cfg.MaxL1CommitGasPerBatch,
+		maxL1CommitCalldataSizePerBatch: cfg.MaxL1CommitCalldataSizePerBatch,
+		batchTimeoutSec:                 cfg.BatchTimeoutSec,
+		gasCostIncreaseMultiplier:       cfg.GasCostIncreaseMultiplier,
+		maxUncompressedBatchBytesSize:   cfg.MaxUncompressedBatchBytesSize,
+		maxChunksPerBatch:               cfg.MaxChunksPerBatch,
+		replayMode:                      false,
+		minCodecVersion:                 minCodecVersion,
+		chainCfg:                        chainCfg,
 
 		batchProposerCircleTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 			Name: "rollup_propose_batch_circle_total",
@@ -87,6 +107,14 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, minC
 			Name: "rollup_propose_batch_due_to_compressed_data_compatibility_breach_total",
 			Help: "Total number of propose batch due to compressed data compatibility breach.",
 		}),
+		totalL1CommitGas: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_batch_total_l1_commit_gas",
+			Help: "The total l1 commit gas",
+		}),
+		totalL1CommitCalldataSize: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_batch_total_l1_call_data_size",
+			Help: "The total l1 call data size",
+		}),
 		totalL1CommitBlobSize: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
 			Name: "rollup_propose_batch_total_l1_commit_blob_size",
 			Help: "The total l1 commit blob size",
@@ -103,6 +131,14 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, minC
 			Name: "rollup_propose_batch_chunks_propose_not_enough_total",
 			Help: "Total number of batch chunk propose not enough",
 		}),
+		batchEstimateGasTime: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_batch_estimate_gas_time",
+			Help: "Time taken to estimate gas for the chunk.",
+		}),
+		batchEstimateCalldataSizeTime: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_batch_estimate_calldata_size_time",
+			Help: "Time taken to estimate calldata size for the chunk.",
+		}),
 		batchEstimateBlobSizeTime: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
 			Name: "rollup_propose_batch_estimate_blob_size_time",
 			Help: "Time taken to estimate blob size for the chunk.",
@@ -161,7 +197,6 @@ func (p *BatchProposer) updateDBBatchInfo(batch *encoding.Batch, codecVersion en
 		}
 
 		batch.Chunks = batch.Chunks[:len(batch.Chunks)-1]
-		batch.PostL1MessageQueueHash = batch.Chunks[len(batch.Chunks)-1].PostL1MessageQueueHash
 
 		log.Info("Batch not compatible with compressed data, removing last chunk", "batch index", batch.Index, "truncated chunk length", len(batch.Chunks))
 	}
@@ -242,7 +277,7 @@ func (p *BatchProposer) proposeBatch() error {
 	}
 
 	// always take the minimum of the configured max chunks per batch and the codec's max chunks per batch
-	maxChunksThisBatch := min(codec.MaxNumChunksPerBatch(), p.cfg.MaxChunksPerBatch)
+	maxChunksThisBatch := min(codec.MaxNumChunksPerBatch(), p.maxChunksPerBatch)
 
 	// select at most maxChunkNumPerBatch chunks
 	dbChunks, err := p.chunkOrm.GetChunksGEIndex(p.ctx, firstUnbatchedChunkIndex, maxChunksThisBatch)
@@ -284,7 +319,9 @@ func (p *BatchProposer) proposeBatch() error {
 
 	for i, chunk := range daChunks {
 		batch.Chunks = append(batch.Chunks, chunk)
-		batch.Blocks = append(batch.Blocks, chunk.Blocks...)
+		if codec.Version() >= encoding.CodecV7 {
+			batch.Blocks = append(batch.Blocks, chunk.Blocks...)
+		}
 		batch.PostL1MessageQueueHash = common.HexToHash(dbChunks[i].PostL1MessageQueueHash)
 
 		metrics, calcErr := utils.CalculateBatchMetrics(&batch, codec.Version())
@@ -294,21 +331,33 @@ func (p *BatchProposer) proposeBatch() error {
 
 		p.recordTimerBatchMetrics(metrics)
 
-		if metrics.L1CommitBlobSize > maxBlobSize {
+		totalOverEstimateL1CommitGas := uint64(p.gasCostIncreaseMultiplier * float64(metrics.L1CommitGas))
+		if metrics.L1CommitCalldataSize > p.maxL1CommitCalldataSizePerBatch || totalOverEstimateL1CommitGas > p.maxL1CommitGasPerBatch ||
+			metrics.L1CommitBlobSize > maxBlobSize || metrics.L1CommitUncompressedBatchBytesSize > p.maxUncompressedBatchBytesSize {
 			if i == 0 {
 				// The first chunk exceeds hard limits, which indicates a bug in the chunk-proposer, manual fix is needed.
-				return fmt.Errorf("the first chunk exceeds limits; start block number: %v, end block number: %v, limits: %+v, maxChunkNum: %v, maxBlobSize: %v",
-					dbChunks[0].StartBlockNumber, dbChunks[0].EndBlockNumber, metrics, maxChunksThisBatch, maxBlobSize)
+				return fmt.Errorf("the first chunk exceeds limits; start block number: %v, end block number: %v, limits: %+v, maxChunkNum: %v, maxL1CommitCalldataSize: %v, maxL1CommitGas: %v, maxBlobSize: %v, maxUncompressedBatchBytesSize: %v",
+					dbChunks[0].StartBlockNumber, dbChunks[0].EndBlockNumber, metrics, maxChunksThisBatch, p.maxL1CommitCalldataSizePerBatch, p.maxL1CommitGasPerBatch, maxBlobSize, p.maxUncompressedBatchBytesSize)
 			}
 
 			log.Debug("breaking limit condition in batching",
+				"l1CommitCalldataSize", metrics.L1CommitCalldataSize,
+				"maxL1CommitCalldataSize", p.maxL1CommitCalldataSizePerBatch,
+				"l1CommitGas", metrics.L1CommitGas,
+				"overEstimateL1CommitGas", totalOverEstimateL1CommitGas,
+				"maxL1CommitGas", p.maxL1CommitGasPerBatch,
 				"l1CommitBlobSize", metrics.L1CommitBlobSize,
-				"maxBlobSize", maxBlobSize)
+				"maxBlobSize", maxBlobSize,
+				"L1CommitUncompressedBatchBytesSize", metrics.L1CommitUncompressedBatchBytesSize,
+				"maxUncompressedBatchBytesSize", p.maxUncompressedBatchBytesSize)
 
 			lastChunk := batch.Chunks[len(batch.Chunks)-1]
 			batch.Chunks = batch.Chunks[:len(batch.Chunks)-1]
 			batch.PostL1MessageQueueHash = common.HexToHash(dbChunks[i-1].PostL1MessageQueueHash)
-			batch.Blocks = batch.Blocks[:len(batch.Blocks)-len(lastChunk.Blocks)]
+
+			if codec.Version() >= encoding.CodecV7 {
+				batch.Blocks = batch.Blocks[:len(batch.Blocks)-len(lastChunk.Blocks)]
+			}
 
 			metrics, err = utils.CalculateBatchMetrics(&batch, codec.Version())
 			if err != nil {
@@ -325,7 +374,7 @@ func (p *BatchProposer) proposeBatch() error {
 		return fmt.Errorf("failed to calculate batch metrics: %w", calcErr)
 	}
 	currentTimeSec := uint64(time.Now().Unix())
-	if metrics.FirstBlockTimestamp+p.cfg.BatchTimeoutSec < currentTimeSec || metrics.NumChunks == uint64(maxChunksThisBatch) {
+	if metrics.FirstBlockTimestamp+p.batchTimeoutSec < currentTimeSec || metrics.NumChunks == uint64(maxChunksThisBatch) {
 		log.Info("reached maximum number of chunks in batch or first block timeout",
 			"chunk count", metrics.NumChunks,
 			"start block number", dbChunks[0].StartBlockNumber,
@@ -361,11 +410,17 @@ func (p *BatchProposer) getDAChunks(dbChunks []*orm.Chunk) ([]*encoding.Chunk, e
 }
 
 func (p *BatchProposer) recordAllBatchMetrics(metrics *utils.BatchMetrics) {
+	p.totalL1CommitGas.Set(float64(metrics.L1CommitGas))
+	p.totalL1CommitCalldataSize.Set(float64(metrics.L1CommitCalldataSize))
 	p.batchChunksNum.Set(float64(metrics.NumChunks))
 	p.totalL1CommitBlobSize.Set(float64(metrics.L1CommitBlobSize))
+	p.batchEstimateGasTime.Set(float64(metrics.EstimateGasTime))
+	p.batchEstimateCalldataSizeTime.Set(float64(metrics.EstimateCalldataSizeTime))
 	p.batchEstimateBlobSizeTime.Set(float64(metrics.EstimateBlobSizeTime))
 }
 
 func (p *BatchProposer) recordTimerBatchMetrics(metrics *utils.BatchMetrics) {
+	p.batchEstimateGasTime.Set(float64(metrics.EstimateGasTime))
+	p.batchEstimateCalldataSizeTime.Set(float64(metrics.EstimateCalldataSizeTime))
 	p.batchEstimateBlobSizeTime.Set(float64(metrics.EstimateBlobSizeTime))
 }

rollup/internal/controller/watcher/batch_proposer_test.go

@@ -20,24 +20,60 @@ import (
 	"scroll-tech/rollup/internal/utils"
 )
 
-func testBatchProposerLimitsCodecV7(t *testing.T) {
+func testBatchProposerLimitsCodecV4(t *testing.T) {
 	tests := []struct {
 		name                       string
+		maxL1CommitGas             uint64
+		maxL1CommitCalldataSize    uint64
 		batchTimeoutSec            uint64
 		expectedBatchesLen         int
 		expectedChunksInFirstBatch uint64 // only be checked when expectedBatchesLen > 0
 	}{
 		{
-			name:               "NoLimitReached",
-			batchTimeoutSec:    1000000000000,
-			expectedBatchesLen: 0,
+			name:                    "NoLimitReached",
+			maxL1CommitGas:          50000000000,
+			maxL1CommitCalldataSize: 1000000,
+			batchTimeoutSec:         1000000000000,
+			expectedBatchesLen:      0,
 		},
 		{
 			name:                       "Timeout",
+			maxL1CommitGas:             50000000000,
+			maxL1CommitCalldataSize:    1000000,
 			batchTimeoutSec:            0,
 			expectedBatchesLen:         1,
 			expectedChunksInFirstBatch: 2,
 		},
+		{
+			name:                    "MaxL1CommitGasPerBatchIs0",
+			maxL1CommitGas:          0,
+			maxL1CommitCalldataSize: 1000000,
+			batchTimeoutSec:         1000000000000,
+			expectedBatchesLen:      0,
+		},
+		{
+			name:                    "MaxL1CommitCalldataSizePerBatchIs0",
+			maxL1CommitGas:          50000000000,
+			maxL1CommitCalldataSize: 0,
+			batchTimeoutSec:         1000000000000,
+			expectedBatchesLen:      0,
+		},
+		{
+			name:                       "MaxL1CommitGasPerBatchIsFirstChunk",
+			maxL1CommitGas:             249179,
+			maxL1CommitCalldataSize:    1000000,
+			batchTimeoutSec:            1000000000000,
+			expectedBatchesLen:         1,
+			expectedChunksInFirstBatch: 1,
+		},
+		{
+			name:                       "MaxL1CommitCalldataSizePerBatchIsFirstChunk",
+			maxL1CommitGas:             50000000000,
+			maxL1CommitCalldataSize:    60,
+			batchTimeoutSec:            1000000000000,
+			expectedBatchesLen:         1,
+			expectedChunksInFirstBatch: 1,
+		},
 	}
 
 	for _, tt := range tests {
@@ -50,6 +86,7 @@ func testBatchProposerLimitsCodecV7(t *testing.T) {
 				Header: &gethTypes.Header{
 					Number: big.NewInt(0),
 				},
+				RowConsumption: &gethTypes.RowConsumption{},
 			}
 			chunk := &encoding.Chunk{
 				Blocks: []*encoding.Block{block},
@@ -72,32 +109,45 @@ func testBatchProposerLimitsCodecV7(t *testing.T) {
 			assert.NoError(t, err)
 
 			cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-				MaxBlockNumPerChunk: 1,
-				MaxL2GasPerChunk:    20000000,
-				ChunkTimeoutSec:     300,
-			}, encoding.CodecV7, &params.ChainConfig{
+				MaxBlockNumPerChunk:             1,
+				MaxTxNumPerChunk:                10000,
+				MaxL2GasPerChunk:                20000000,
+				MaxL1CommitGasPerChunk:          50000000000,
+				MaxL1CommitCalldataSizePerChunk: 1000000,
+				MaxRowConsumptionPerChunk:       1000000,
+				ChunkTimeoutSec:                 300,
+				GasCostIncreaseMultiplier:       1.2,
+				MaxUncompressedBatchBytesSize:   math.MaxUint64,
+			}, encoding.CodecV4, &params.ChainConfig{
 				LondonBlock:    big.NewInt(0),
 				BernoulliBlock: big.NewInt(0),
 				CurieBlock:     big.NewInt(0),
 				DarwinTime:     new(uint64),
 				DarwinV2Time:   new(uint64),
-				EuclidTime:     new(uint64),
-				EuclidV2Time:   new(uint64),
 			}, db, nil)
 			cp.TryProposeChunk() // chunk1 contains block1
 			cp.TryProposeChunk() // chunk2 contains block2
 
+			chunks, err := chunkOrm.GetChunksInRange(context.Background(), 1, 2)
+			assert.NoError(t, err)
+			assert.Equal(t, uint64(51124), chunks[0].TotalL1CommitGas)
+			assert.Equal(t, uint64(60), chunks[0].TotalL1CommitCalldataSize)
+			assert.Equal(t, uint64(51124), chunks[1].TotalL1CommitGas)
+			assert.Equal(t, uint64(60), chunks[1].TotalL1CommitCalldataSize)
+
 			bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-				MaxChunksPerBatch: math.MaxInt32,
-				BatchTimeoutSec:   tt.batchTimeoutSec,
-			}, encoding.CodecV7, &params.ChainConfig{
+				MaxL1CommitGasPerBatch:          tt.maxL1CommitGas,
+				MaxL1CommitCalldataSizePerBatch: tt.maxL1CommitCalldataSize,
+				BatchTimeoutSec:                 tt.batchTimeoutSec,
+				GasCostIncreaseMultiplier:       1.2,
+				MaxUncompressedBatchBytesSize:   math.MaxUint64,
+				MaxChunksPerBatch:               math.MaxInt32,
+			}, encoding.CodecV4, &params.ChainConfig{
 				LondonBlock:    big.NewInt(0),
 				BernoulliBlock: big.NewInt(0),
 				CurieBlock:     big.NewInt(0),
 				DarwinTime:     new(uint64),
 				DarwinV2Time:   new(uint64),
-				EuclidTime:     new(uint64),
-				EuclidV2Time:   new(uint64),
 			}, db, nil)
 			bp.TryProposeBatch()
 
@@ -123,7 +173,7 @@ func testBatchProposerLimitsCodecV7(t *testing.T) {
 	}
 }
 
-func testBatchProposerBlobSizeLimitCodecV7(t *testing.T) {
+func testBatchCommitGasAndCalldataSizeEstimationCodecV4(t *testing.T) {
 	db := setupDB(t)
 	defer database.CloseDB(db)
 
@@ -132,6 +182,7 @@ func testBatchProposerBlobSizeLimitCodecV7(t *testing.T) {
 		Header: &gethTypes.Header{
 			Number: big.NewInt(0),
 		},
+		RowConsumption: &gethTypes.RowConsumption{},
 	}
 	chunk := &encoding.Chunk{
 		Blocks: []*encoding.Block{block},
@@ -149,104 +200,230 @@ func testBatchProposerBlobSizeLimitCodecV7(t *testing.T) {
 	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
 	assert.NoError(t, err)
 
-	chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
+	l2BlockOrm := orm.NewL2Block(db)
+	err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
+	assert.NoError(t, err)
 
 	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxBlockNumPerChunk: math.MaxUint64,
-		MaxL2GasPerChunk:    math.MaxUint64,
-		ChunkTimeoutSec:     0,
-	}, encoding.CodecV7, chainConfig, db, nil)
+		MaxBlockNumPerChunk:             1,
+		MaxTxNumPerChunk:                10000,
+		MaxL2GasPerChunk:                20_000_000,
+		MaxL1CommitGasPerChunk:          50000000000,
+		MaxL1CommitCalldataSizePerChunk: 1000000,
+		MaxRowConsumptionPerChunk:       1000000,
+		ChunkTimeoutSec:                 300,
+		GasCostIncreaseMultiplier:       1.2,
+		MaxUncompressedBatchBytesSize:   math.MaxUint64,
+	}, encoding.CodecV4, &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}, db, nil)
+	cp.TryProposeChunk() // chunk1 contains block1
+	cp.TryProposeChunk() // chunk2 contains block2
 
-	blockHeight := uint64(0)
-	block = readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
-	for total := int64(0); total < 90; total++ {
-		for i := int64(0); i < 30; i++ {
-			blockHeight++
-			l2BlockOrm := orm.NewL2Block(db)
-			block.Header.Number = new(big.Int).SetUint64(blockHeight)
-			block.Header.Time = blockHeight
-			err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block})
-			assert.NoError(t, err)
-		}
-		cp.TryProposeChunk()
-	}
+	chunks, err := chunkOrm.GetChunksInRange(context.Background(), 1, 2)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(51124), chunks[0].TotalL1CommitGas)
+	assert.Equal(t, uint64(60), chunks[0].TotalL1CommitCalldataSize)
+	assert.Equal(t, uint64(51124), chunks[1].TotalL1CommitGas)
+	assert.Equal(t, uint64(60), chunks[1].TotalL1CommitCalldataSize)
 
 	bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-		MaxChunksPerBatch: math.MaxInt32,
-		BatchTimeoutSec:   math.MaxUint32,
-	}, encoding.CodecV7, chainConfig, db, nil)
-
-	for i := 0; i < 2; i++ {
-		bp.TryProposeBatch()
-	}
-
-	batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
-	batches = batches[1:]
-	assert.NoError(t, err)
-
-	var expectedNumBatches int = 1
-	var numChunksMultiplier uint64 = 64
-	assert.Len(t, batches, expectedNumBatches)
-
-	for i, batch := range batches {
-		assert.Equal(t, numChunksMultiplier*(uint64(i)+1), batch.EndChunkIndex)
-	}
-}
-
-func testBatchProposerMaxChunkNumPerBatchLimitCodecV7(t *testing.T) {
-	db := setupDB(t)
-	defer database.CloseDB(db)
-
-	// Add genesis batch.
-	block := &encoding.Block{
-		Header: &gethTypes.Header{
-			Number: big.NewInt(0),
-		},
-	}
-	chunk := &encoding.Chunk{
-		Blocks: []*encoding.Block{block},
-	}
-	chunkOrm := orm.NewChunk(db)
-	_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
-	assert.NoError(t, err)
-	batch := &encoding.Batch{
-		Index:                      0,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{chunk},
-	}
-	batchOrm := orm.NewBatch(db)
-	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
-	assert.NoError(t, err)
-
-	var expectedChunkNum uint64 = 45
-	chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
-
-	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxBlockNumPerChunk: math.MaxUint64,
-		MaxL2GasPerChunk:    math.MaxUint64,
-		ChunkTimeoutSec:     0,
-	}, encoding.CodecV7, chainConfig, db, nil)
-
-	block = readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
-	for blockHeight := uint64(1); blockHeight <= 60; blockHeight++ {
-		block.Header.Number = new(big.Int).SetUint64(blockHeight)
-		block.Header.Time = blockHeight
-		err = orm.NewL2Block(db).InsertL2Blocks(context.Background(), []*encoding.Block{block})
-		assert.NoError(t, err)
-		cp.TryProposeChunk()
-	}
-
-	bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-		MaxChunksPerBatch: 45,
-		BatchTimeoutSec:   math.MaxUint32,
-	}, encoding.CodecV7, chainConfig, db, nil)
+		MaxL1CommitGasPerBatch:          50000000000,
+		MaxL1CommitCalldataSizePerBatch: 1000000,
+		BatchTimeoutSec:                 0,
+		GasCostIncreaseMultiplier:       1.2,
+		MaxUncompressedBatchBytesSize:   math.MaxUint64,
+		MaxChunksPerBatch:               math.MaxInt32,
+	}, encoding.CodecV4, &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}, db, nil)
 	bp.TryProposeBatch()
 
 	batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
 	assert.NoError(t, err)
 	assert.Len(t, batches, 2)
-	dbBatch := batches[1]
+	batches = batches[1:]
+	assert.Equal(t, uint64(1), batches[0].StartChunkIndex)
+	assert.Equal(t, uint64(2), batches[0].EndChunkIndex)
+	assert.Equal(t, types.RollupPending, types.RollupStatus(batches[0].RollupStatus))
+	assert.Equal(t, types.ProvingTaskUnassigned, types.ProvingStatus(batches[0].ProvingStatus))
 
-	assert.Equal(t, expectedChunkNum, dbBatch.EndChunkIndex)
+	dbChunks, err := chunkOrm.GetChunksInRange(context.Background(), 1, 2)
+	assert.NoError(t, err)
+	assert.Len(t, dbChunks, 2)
+	for _, chunk := range dbChunks {
+		assert.Equal(t, batches[0].Hash, chunk.BatchHash)
+		assert.Equal(t, types.ProvingTaskUnassigned, types.ProvingStatus(chunk.ProvingStatus))
+	}
+
+	assert.Equal(t, uint64(209350), batches[0].TotalL1CommitGas)
+	assert.Equal(t, uint64(120), batches[0].TotalL1CommitCalldataSize)
+}
+
+func testBatchProposerBlobSizeLimitCodecV4(t *testing.T) {
+	codecVersions := []encoding.CodecVersion{encoding.CodecV4}
+	for _, codecVersion := range codecVersions {
+		db := setupDB(t)
+
+		// Add genesis batch.
+		block := &encoding.Block{
+			Header: &gethTypes.Header{
+				Number: big.NewInt(0),
+			},
+			RowConsumption: &gethTypes.RowConsumption{},
+		}
+		chunk := &encoding.Chunk{
+			Blocks: []*encoding.Block{block},
+		}
+		chunkOrm := orm.NewChunk(db)
+		_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
+		assert.NoError(t, err)
+		batch := &encoding.Batch{
+			Index:                      0,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk},
+		}
+		batchOrm := orm.NewBatch(db)
+		_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
+		assert.NoError(t, err)
+
+		var chainConfig *params.ChainConfig
+		if codecVersion == encoding.CodecV4 {
+			chainConfig = &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}
+		} else {
+			assert.Fail(t, "unsupported codec version, expected CodecV4")
+		}
+
+		cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+			MaxBlockNumPerChunk:             math.MaxUint64,
+			MaxTxNumPerChunk:                math.MaxUint64,
+			MaxL2GasPerChunk:                math.MaxUint64,
+			MaxL1CommitGasPerChunk:          math.MaxUint64,
+			MaxL1CommitCalldataSizePerChunk: math.MaxUint64,
+			MaxRowConsumptionPerChunk:       math.MaxUint64,
+			ChunkTimeoutSec:                 0,
+			GasCostIncreaseMultiplier:       1,
+			MaxUncompressedBatchBytesSize:   math.MaxUint64,
+		}, encoding.CodecV4, chainConfig, db, nil)
+
+		blockHeight := int64(0)
+		block = readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
+		for total := int64(0); total < 90; total++ {
+			for i := int64(0); i < 30; i++ {
+				blockHeight++
+				l2BlockOrm := orm.NewL2Block(db)
+				block.Header.Number = big.NewInt(blockHeight)
+				err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block})
+				assert.NoError(t, err)
+			}
+			cp.TryProposeChunk()
+		}
+
+		bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
+			MaxL1CommitGasPerBatch:          math.MaxUint64,
+			MaxL1CommitCalldataSizePerBatch: math.MaxUint64,
+			BatchTimeoutSec:                 math.MaxUint32,
+			GasCostIncreaseMultiplier:       1,
+			MaxUncompressedBatchBytesSize:   math.MaxUint64,
+			MaxChunksPerBatch:               math.MaxInt32,
+		}, encoding.CodecV4, chainConfig, db, nil)
+
+		for i := 0; i < 2; i++ {
+			bp.TryProposeBatch()
+		}
+
+		batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
+		batches = batches[1:]
+		assert.NoError(t, err)
+
+		var expectedNumBatches int
+		var numChunksMultiplier uint64
+		if codecVersion == encoding.CodecV4 {
+			expectedNumBatches = 2
+			numChunksMultiplier = 45
+		} else {
+			assert.Fail(t, "unsupported codec version, expected CodecV4")
+		}
+		assert.Len(t, batches, expectedNumBatches)
+
+		for i, batch := range batches {
+			assert.Equal(t, numChunksMultiplier*(uint64(i)+1), batch.EndChunkIndex)
+		}
+		database.CloseDB(db)
+	}
+}
+
+func testBatchProposerMaxChunkNumPerBatchLimitCodecV4(t *testing.T) {
+	codecVersions := []encoding.CodecVersion{encoding.CodecV4}
+	for _, codecVersion := range codecVersions {
+		db := setupDB(t)
+
+		// Add genesis batch.
+		block := &encoding.Block{
+			Header: &gethTypes.Header{
+				Number: big.NewInt(0),
+			},
+			RowConsumption: &gethTypes.RowConsumption{},
+		}
+		chunk := &encoding.Chunk{
+			Blocks: []*encoding.Block{block},
+		}
+		chunkOrm := orm.NewChunk(db)
+		_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0, utils.ChunkMetrics{})
+		assert.NoError(t, err)
+		batch := &encoding.Batch{
+			Index:                      0,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk},
+		}
+		batchOrm := orm.NewBatch(db)
+		_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0, utils.BatchMetrics{})
+		assert.NoError(t, err)
+
+		var expectedChunkNum uint64
+		var chainConfig *params.ChainConfig
+		if codecVersion == encoding.CodecV4 {
+			chainConfig = &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}
+			expectedChunkNum = 45
+		} else {
+			assert.Fail(t, "unsupported codec version, expected CodecV4")
+		}
+
+		cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+			MaxBlockNumPerChunk:             math.MaxUint64,
+			MaxTxNumPerChunk:                math.MaxUint64,
+			MaxL2GasPerChunk:                math.MaxUint64,
+			MaxL1CommitGasPerChunk:          math.MaxUint64,
+			MaxL1CommitCalldataSizePerChunk: math.MaxUint64,
+			MaxRowConsumptionPerChunk:       math.MaxUint64,
+			ChunkTimeoutSec:                 0,
+			GasCostIncreaseMultiplier:       1,
+			MaxUncompressedBatchBytesSize:   math.MaxUint64,
+		}, encoding.CodecV4, chainConfig, db, nil)
+
+		block = readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
+		for blockHeight := int64(1); blockHeight <= 60; blockHeight++ {
+			block.Header.Number = big.NewInt(blockHeight)
+			err = orm.NewL2Block(db).InsertL2Blocks(context.Background(), []*encoding.Block{block})
+			assert.NoError(t, err)
+			cp.TryProposeChunk()
+		}
+
+		bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
+			MaxL1CommitGasPerBatch:          math.MaxUint64,
+			MaxL1CommitCalldataSizePerBatch: math.MaxUint64,
+			BatchTimeoutSec:                 math.MaxUint32,
+			GasCostIncreaseMultiplier:       1,
+			MaxUncompressedBatchBytesSize:   math.MaxUint64,
+			MaxChunksPerBatch:               math.MaxInt32,
+		}, encoding.CodecV4, chainConfig, db, nil)
+		bp.TryProposeBatch()
+
+		batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
+		assert.NoError(t, err)
+		assert.Len(t, batches, 2)
+		dbBatch := batches[1]
+
+		assert.Equal(t, expectedChunkNum, dbBatch.EndChunkIndex)
+
+		database.CloseDB(db)
+	}
 }

rollup/internal/controller/watcher/bundle_proposer.go

@@ -26,7 +26,8 @@ type BundleProposer struct {
 	batchOrm  *orm.Batch
 	bundleOrm *orm.Bundle
 
-	cfg *config.BundleProposerConfig
+	maxBatchNumPerBundle uint64
+	bundleTimeoutSec     uint64
 
 	minCodecVersion encoding.CodecVersion
 	chainCfg        *params.ChainConfig
@@ -45,14 +46,15 @@ func NewBundleProposer(ctx context.Context, cfg *config.BundleProposerConfig, mi
 	log.Info("new bundle proposer", "bundleBatchesNum", cfg.MaxBatchNumPerBundle, "bundleTimeoutSec", cfg.BundleTimeoutSec)
 
 	p := &BundleProposer{
-		ctx:             ctx,
-		db:              db,
-		chunkOrm:        orm.NewChunk(db),
-		batchOrm:        orm.NewBatch(db),
-		bundleOrm:       orm.NewBundle(db),
-		cfg:             cfg,
-		minCodecVersion: minCodecVersion,
-		chainCfg:        chainCfg,
+		ctx:                  ctx,
+		db:                   db,
+		chunkOrm:             orm.NewChunk(db),
+		batchOrm:             orm.NewBatch(db),
+		bundleOrm:            orm.NewBundle(db),
+		maxBatchNumPerBundle: cfg.MaxBatchNumPerBundle,
+		bundleTimeoutSec:     cfg.BundleTimeoutSec,
+		minCodecVersion:      minCodecVersion,
+		chainCfg:             chainCfg,
 
 		bundleProposerCircleTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 			Name: "rollup_propose_bundle_circle_total",
@@ -130,7 +132,7 @@ func (p *BundleProposer) proposeBundle() error {
 	}
 
 	// select at most maxBlocksThisChunk blocks
-	maxBatchesThisBundle := p.cfg.MaxBatchNumPerBundle
+	maxBatchesThisBundle := p.maxBatchNumPerBundle
 	batches, err := p.batchOrm.GetCommittedBatchesGEIndexGECodecVersion(p.ctx, firstUnbundledBatchIndex, p.minCodecVersion, int(maxBatchesThisBundle))
 	if err != nil {
 		return err
@@ -159,6 +161,11 @@ func (p *BundleProposer) proposeBundle() error {
 		return fmt.Errorf("unsupported codec version: %v, expected at least %v", codecVersion, p.minCodecVersion)
 	}
 
+	if codecVersion == encoding.CodecV5 {
+		maxBatchesThisBundle = 1
+		batches = batches[:maxBatchesThisBundle]
+	}
+
 	for i := 1; i < len(batches); i++ {
 		// Make sure that all batches have been committed.
 		if len(batches[i].CommitTxHash) == 0 {
@@ -191,8 +198,8 @@ func (p *BundleProposer) proposeBundle() error {
 	}
 
 	currentTimeSec := uint64(time.Now().Unix())
-	if firstChunk.StartBlockTime+p.cfg.BundleTimeoutSec < currentTimeSec {
-		log.Info("first block timeout", "batch count", len(batches), "start block number", firstChunk.StartBlockNumber, "start block timestamp", firstChunk.StartBlockTime, "bundle timeout", p.cfg.BundleTimeoutSec, "current time", currentTimeSec)
+	if firstChunk.StartBlockTime+p.bundleTimeoutSec < currentTimeSec {
+		log.Info("first block timeout", "batch count", len(batches), "start block number", firstChunk.StartBlockNumber, "start block timestamp", firstChunk.StartBlockTime, "bundle timeout", p.bundleTimeoutSec, "current time", currentTimeSec)
 
 		batches, err = p.allBatchesCommittedInSameTXIncluded(batches)
 		if err != nil {

rollup/internal/controller/watcher/bundle_proposer_test.go

@@ -23,7 +23,7 @@ import (
 	"scroll-tech/rollup/internal/utils"
 )
 
-func testBundleProposerLimitsCodecV7(t *testing.T) {
+func testBundleProposerLimitsCodecV4(t *testing.T) {
 	tests := []struct {
 		name                         string
 		maxBatchNumPerBundle         uint64
@@ -69,6 +69,7 @@ func testBundleProposerLimitsCodecV7(t *testing.T) {
 				Header: &gethTypes.Header{
 					Number: big.NewInt(0),
 				},
+				RowConsumption: &gethTypes.RowConsumption{},
 			}
 			chunk := &encoding.Chunk{
 				Blocks: []*encoding.Block{block},
@@ -90,18 +91,27 @@ func testBundleProposerLimitsCodecV7(t *testing.T) {
 			err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
 			assert.NoError(t, err)
 
-			chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
+			chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}
 
 			cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-				MaxBlockNumPerChunk: 1,
-				MaxL2GasPerChunk:    math.MaxUint64,
-				ChunkTimeoutSec:     math.MaxUint32,
-			}, encoding.CodecV7, chainConfig, db, nil)
+				MaxBlockNumPerChunk:             1,
+				MaxTxNumPerChunk:                math.MaxUint64,
+				MaxL2GasPerChunk:                math.MaxUint64,
+				MaxL1CommitGasPerChunk:          math.MaxUint64,
+				MaxL1CommitCalldataSizePerChunk: math.MaxUint64,
+				MaxRowConsumptionPerChunk:       math.MaxUint64,
+				ChunkTimeoutSec:                 math.MaxUint32,
+				GasCostIncreaseMultiplier:       1,
+				MaxUncompressedBatchBytesSize:   math.MaxUint64,
+			}, encoding.CodecV4, chainConfig, db, nil)
 
 			bap := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-				MaxChunksPerBatch: math.MaxInt32,
-				BatchTimeoutSec:   0,
-			}, encoding.CodecV7, chainConfig, db, nil)
+				MaxL1CommitGasPerBatch:          math.MaxUint64,
+				MaxL1CommitCalldataSizePerBatch: math.MaxUint64,
+				BatchTimeoutSec:                 0,
+				GasCostIncreaseMultiplier:       1,
+				MaxUncompressedBatchBytesSize:   math.MaxUint64,
+			}, encoding.CodecV4, chainConfig, db, nil)
 
 			cp.TryProposeChunk()  // chunk1 contains block1
 			bap.TryProposeBatch() // batch1 contains chunk1
@@ -111,7 +121,7 @@ func testBundleProposerLimitsCodecV7(t *testing.T) {
 			bup := NewBundleProposer(context.Background(), &config.BundleProposerConfig{
 				MaxBatchNumPerBundle: tt.maxBatchNumPerBundle,
 				BundleTimeoutSec:     tt.bundleTimeoutSec,
-			}, encoding.CodecV7, chainConfig, db, nil)
+			}, encoding.CodecV4, chainConfig, db, nil)
 
 			batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
 			require.NoError(t, err)

rollup/internal/controller/watcher/chunk_proposer.go

@@ -26,7 +26,15 @@ type ChunkProposer struct {
 	chunkOrm   *orm.Chunk
 	l2BlockOrm *orm.L2Block
 
-	cfg *config.ChunkProposerConfig
+	maxBlockNumPerChunk             uint64
+	maxTxNumPerChunk                uint64
+	maxL2GasPerChunk                uint64
+	maxL1CommitGasPerChunk          uint64
+	maxL1CommitCalldataSizePerChunk uint64
+	maxRowConsumptionPerChunk       uint64
+	chunkTimeoutSec                 uint64
+	gasCostIncreaseMultiplier       float64
+	maxUncompressedBatchBytesSize   uint64
 
 	replayMode      bool
 	minCodecVersion encoding.CodecVersion
@@ -38,10 +46,15 @@ type ChunkProposer struct {
 	proposeChunkUpdateInfoFailureTotal prometheus.Counter
 	chunkTxNum                         prometheus.Gauge
 	chunkL2Gas                         prometheus.Gauge
+	chunkEstimateL1CommitGas           prometheus.Gauge
+	totalL1CommitCalldataSize          prometheus.Gauge
 	totalL1CommitBlobSize              prometheus.Gauge
+	maxTxConsumption                   prometheus.Gauge
 	chunkBlocksNum                     prometheus.Gauge
 	chunkFirstBlockTimeoutReached      prometheus.Counter
 	chunkBlocksProposeNotEnoughTotal   prometheus.Counter
+	chunkEstimateGasTime               prometheus.Gauge
+	chunkEstimateCalldataSizeTime      prometheus.Gauge
 	chunkEstimateBlobSizeTime          prometheus.Gauge
 
 	// total number of times that chunk proposer stops early due to compressed data compatibility breach
@@ -55,19 +68,33 @@ type ChunkProposer struct {
 func NewChunkProposer(ctx context.Context, cfg *config.ChunkProposerConfig, minCodecVersion encoding.CodecVersion, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *ChunkProposer {
 	log.Info("new chunk proposer",
 		"maxBlockNumPerChunk", cfg.MaxBlockNumPerChunk,
+		"maxTxNumPerChunk", cfg.MaxTxNumPerChunk,
 		"maxL2GasPerChunk", cfg.MaxL2GasPerChunk,
+		"maxL1CommitGasPerChunk", cfg.MaxL1CommitGasPerChunk,
+		"maxL1CommitCalldataSizePerChunk", cfg.MaxL1CommitCalldataSizePerChunk,
+		"maxRowConsumptionPerChunk", cfg.MaxRowConsumptionPerChunk,
 		"chunkTimeoutSec", cfg.ChunkTimeoutSec,
-		"maxBlobSize", maxBlobSize)
+		"gasCostIncreaseMultiplier", cfg.GasCostIncreaseMultiplier,
+		"maxBlobSize", maxBlobSize,
+		"maxUncompressedBatchBytesSize", cfg.MaxUncompressedBatchBytesSize)
 
 	p := &ChunkProposer{
-		ctx:             ctx,
-		db:              db,
-		chunkOrm:        orm.NewChunk(db),
-		l2BlockOrm:      orm.NewL2Block(db),
-		cfg:             cfg,
-		replayMode:      false,
-		minCodecVersion: minCodecVersion,
-		chainCfg:        chainCfg,
+		ctx:                             ctx,
+		db:                              db,
+		chunkOrm:                        orm.NewChunk(db),
+		l2BlockOrm:                      orm.NewL2Block(db),
+		maxBlockNumPerChunk:             cfg.MaxBlockNumPerChunk,
+		maxTxNumPerChunk:                cfg.MaxTxNumPerChunk,
+		maxL2GasPerChunk:                cfg.MaxL2GasPerChunk,
+		maxL1CommitGasPerChunk:          cfg.MaxL1CommitGasPerChunk,
+		maxL1CommitCalldataSizePerChunk: cfg.MaxL1CommitCalldataSizePerChunk,
+		maxRowConsumptionPerChunk:       cfg.MaxRowConsumptionPerChunk,
+		chunkTimeoutSec:                 cfg.ChunkTimeoutSec,
+		gasCostIncreaseMultiplier:       cfg.GasCostIncreaseMultiplier,
+		maxUncompressedBatchBytesSize:   cfg.MaxUncompressedBatchBytesSize,
+		replayMode:                      false,
+		minCodecVersion:                 minCodecVersion,
+		chainCfg:                        chainCfg,
 
 		chunkProposerCircleTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 			Name: "rollup_propose_chunk_circle_total",
@@ -97,11 +124,22 @@ func NewChunkProposer(ctx context.Context, cfg *config.ChunkProposerConfig, minC
 			Name: "rollup_propose_chunk_l2_gas",
 			Help: "The chunk l2 gas",
 		}),
+		chunkEstimateL1CommitGas: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_chunk_estimate_l1_commit_gas",
+			Help: "The chunk estimate l1 commit gas",
+		}),
+		totalL1CommitCalldataSize: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_chunk_total_l1_commit_call_data_size",
+			Help: "The total l1 commit call data size",
+		}),
 		totalL1CommitBlobSize: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
 			Name: "rollup_propose_chunk_total_l1_commit_blob_size",
 			Help: "The total l1 commit blob size",
 		}),
-
+		maxTxConsumption: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_chunk_max_tx_consumption",
+			Help: "The max tx consumption",
+		}),
 		chunkBlocksNum: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
 			Name: "rollup_propose_chunk_chunk_block_number",
 			Help: "The number of blocks in the chunk",
@@ -114,6 +152,14 @@ func NewChunkProposer(ctx context.Context, cfg *config.ChunkProposerConfig, minC
 			Name: "rollup_propose_chunk_blocks_propose_not_enough_total",
 			Help: "Total number of chunk block propose not enough",
 		}),
+		chunkEstimateGasTime: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_chunk_estimate_gas_time",
+			Help: "Time taken to estimate gas for the chunk.",
+		}),
+		chunkEstimateCalldataSizeTime: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_chunk_estimate_calldata_size_time",
+			Help: "Time taken to estimate calldata size for the chunk.",
+		}),
 		chunkEstimateBlobSizeTime: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
 			Name: "rollup_propose_chunk_estimate_blob_size_time",
 			Help: "Time taken to estimate blob size for the chunk.",
@@ -150,7 +196,7 @@ func (p *ChunkProposer) TryProposeChunk() {
 }
 
 func (p *ChunkProposer) updateDBChunkInfo(chunk *encoding.Chunk, codecVersion encoding.CodecVersion, metrics *utils.ChunkMetrics) error {
-	if chunk == nil || len(chunk.Blocks) == 0 {
+	if chunk == nil {
 		return nil
 	}
 
@@ -175,11 +221,6 @@ func (p *ChunkProposer) updateDBChunkInfo(chunk *encoding.Chunk, codecVersion en
 		}
 
 		chunk.Blocks = chunk.Blocks[:len(chunk.Blocks)-1]
-		chunk.PostL1MessageQueueHash, err = encoding.MessageQueueV2ApplyL1MessagesFromBlocks(chunk.PrevL1MessageQueueHash, chunk.Blocks)
-		if err != nil {
-			log.Error("Failed to calculate last L1 message queue hash for block", "block number", chunk.Blocks[0].Header.Number, "err", err)
-			return err
-		}
 
 		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))
 	}
@@ -198,7 +239,9 @@ func (p *ChunkProposer) updateDBChunkInfo(chunk *encoding.Chunk, codecVersion en
 		p.recordAllChunkMetrics(metrics)
 	}
 
-	p.chunkProposeBlockHeight.Set(float64(chunk.Blocks[len(chunk.Blocks)-1].Header.Number.Uint64()))
+	if len(chunk.Blocks) > 0 {
+		p.chunkProposeBlockHeight.Set(float64(chunk.Blocks[len(chunk.Blocks)-1].Header.Number.Uint64()))
+	}
 	p.chunkProposeThroughput.Add(float64(chunk.TotalGasUsed()))
 
 	p.proposeChunkUpdateInfoTotal.Inc()
@@ -232,7 +275,7 @@ func (p *ChunkProposer) proposeChunk() error {
 		return err
 	}
 
-	maxBlocksThisChunk := p.cfg.MaxBlockNumPerChunk
+	maxBlocksThisChunk := p.maxBlockNumPerChunk
 
 	// select at most maxBlocksThisChunk blocks
 	blocks, err := p.l2BlockOrm.GetL2BlocksGEHeight(p.ctx, unchunkedBlockHeight, int(maxBlocksThisChunk))
@@ -262,30 +305,53 @@ func (p *ChunkProposer) proposeChunk() error {
 		return fmt.Errorf("unsupported codec version: %v, expected at least %v", codecVersion, p.minCodecVersion)
 	}
 
+	// 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)
+		if calcErr != nil {
+			return fmt.Errorf("failed to calculate chunk metrics: %w", calcErr)
+		}
+		p.recordTimerChunkMetrics(metrics)
+		return p.updateDBChunkInfo(&chunk, codecVersion, metrics)
+	}
+
+	if proposed, err := p.tryProposeEuclidTransitionChunk(blocks); proposed || err != nil {
+		return err
+	}
+
 	var chunk encoding.Chunk
-	parentChunk, err := p.chunkOrm.GetLatestChunk(p.ctx)
-	if err != nil || parentChunk == nil {
-		return fmt.Errorf("failed to get parent chunk: %w", err)
+	// From CodecV7 / EuclidV2 onwards we need to provide the PrevL1MessageQueueHash and PostL1MessageQueueHash.
+	// PrevL1MessageQueueHash of the first chunk in the fork needs to be the empty hash.
+	if codecVersion >= encoding.CodecV7 {
+		parentChunk, err := p.chunkOrm.GetLatestChunk(p.ctx)
+		if err != nil || parentChunk == nil {
+			return fmt.Errorf("failed to get parent chunk: %w", err)
+		}
+
+		chunk.PrevL1MessageQueueHash = common.HexToHash(parentChunk.PostL1MessageQueueHash)
+
+		// previous chunk is not CodecV7, this means this is the first chunk of the fork.
+		if encoding.CodecVersion(parentChunk.CodecVersion) < codecVersion {
+			chunk.PrevL1MessageQueueHash = common.Hash{}
+		}
+
+		chunk.PostL1MessageQueueHash = chunk.PrevL1MessageQueueHash
 	}
 
-	chunk.PrevL1MessageQueueHash = common.HexToHash(parentChunk.PostL1MessageQueueHash)
-
-	// previous chunk is not CodecV7, this means this is the first chunk of the fork.
-	if encoding.CodecVersion(parentChunk.CodecVersion) < codecVersion {
-		chunk.PrevL1MessageQueueHash = common.Hash{}
-	}
-
-	chunk.PostL1MessageQueueHash = chunk.PrevL1MessageQueueHash
-
 	var previousPostL1MessageQueueHash common.Hash
 	chunk.Blocks = make([]*encoding.Block, 0, len(blocks))
 	for i, block := range blocks {
 		chunk.Blocks = append(chunk.Blocks, block)
 
-		previousPostL1MessageQueueHash = chunk.PostL1MessageQueueHash
-		chunk.PostL1MessageQueueHash, err = encoding.MessageQueueV2ApplyL1MessagesFromBlocks(previousPostL1MessageQueueHash, []*encoding.Block{block})
-		if err != nil {
-			return fmt.Errorf("failed to calculate last L1 message queue hash for block %d: %w", block.Header.Number.Uint64(), err)
+		// Compute rolling PostL1MessageQueueHash for the chunk. Each block's L1 messages are applied to the previous
+		// hash starting from the PrevL1MessageQueueHash for the chunk.
+		if codecVersion >= encoding.CodecV7 {
+			previousPostL1MessageQueueHash = chunk.PostL1MessageQueueHash
+			chunk.PostL1MessageQueueHash, err = encoding.MessageQueueV2ApplyL1MessagesFromBlocks(previousPostL1MessageQueueHash, []*encoding.Block{block})
+			if err != nil {
+				return fmt.Errorf("failed to calculate last L1 message queue hash for block %d: %w", block.Header.Number.Uint64(), err)
+			}
 		}
 
 		metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecVersion)
@@ -295,17 +361,36 @@ func (p *ChunkProposer) proposeChunk() error {
 
 		p.recordTimerChunkMetrics(metrics)
 
-		if metrics.L2Gas > p.cfg.MaxL2GasPerChunk || metrics.L1CommitBlobSize > maxBlobSize {
+		overEstimatedL1CommitGas := uint64(p.gasCostIncreaseMultiplier * float64(metrics.L1CommitGas))
+		if metrics.TxNum > p.maxTxNumPerChunk ||
+			metrics.L2Gas > p.maxL2GasPerChunk ||
+			metrics.L1CommitCalldataSize > p.maxL1CommitCalldataSizePerChunk ||
+			overEstimatedL1CommitGas > p.maxL1CommitGasPerChunk ||
+			metrics.CrcMax > p.maxRowConsumptionPerChunk ||
+			metrics.L1CommitBlobSize > maxBlobSize ||
+			metrics.L1CommitUncompressedBatchBytesSize > p.maxUncompressedBatchBytesSize {
 			if i == 0 {
 				// The first block exceeds hard limits, which indicates a bug in the sequencer, manual fix is needed.
-				return fmt.Errorf("the first block exceeds limits; block number: %v, limits: %+v, maxBlobSize: %v", block.Header.Number, metrics, maxBlobSize)
+				return fmt.Errorf("the first block exceeds limits; block number: %v, limits: %+v, maxTxNum: %v, maxL1CommitCalldataSize: %v, maxL1CommitGas: %v, maxRowConsumption: %v, maxBlobSize: %v, maxUncompressedBatchBytesSize: %v",
+					block.Header.Number, metrics, p.maxTxNumPerChunk, p.maxL1CommitCalldataSizePerChunk, p.maxL1CommitGasPerChunk, p.maxRowConsumptionPerChunk, maxBlobSize, p.maxUncompressedBatchBytesSize)
 			}
 
 			log.Debug("breaking limit condition in chunking",
+				"txNum", metrics.TxNum,
+				"maxTxNum", p.maxTxNumPerChunk,
 				"l2Gas", metrics.L2Gas,
-				"maxL2Gas", p.cfg.MaxL2GasPerChunk,
+				"maxL2Gas", p.maxL2GasPerChunk,
+				"l1CommitCalldataSize", metrics.L1CommitCalldataSize,
+				"maxL1CommitCalldataSize", p.maxL1CommitCalldataSizePerChunk,
+				"l1CommitGas", metrics.L1CommitGas,
+				"overEstimatedL1CommitGas", overEstimatedL1CommitGas,
+				"maxL1CommitGas", p.maxL1CommitGasPerChunk,
+				"rowConsumption", metrics.CrcMax,
+				"maxRowConsumption", p.maxRowConsumptionPerChunk,
 				"l1CommitBlobSize", metrics.L1CommitBlobSize,
-				"maxBlobSize", maxBlobSize)
+				"maxBlobSize", maxBlobSize,
+				"L1CommitUncompressedBatchBytesSize", metrics.L1CommitUncompressedBatchBytesSize,
+				"maxUncompressedBatchBytesSize", p.maxUncompressedBatchBytesSize)
 
 			chunk.Blocks = chunk.Blocks[:len(chunk.Blocks)-1]
 			chunk.PostL1MessageQueueHash = previousPostL1MessageQueueHash
@@ -326,7 +411,7 @@ func (p *ChunkProposer) proposeChunk() error {
 	}
 
 	currentTimeSec := uint64(time.Now().Unix())
-	if metrics.FirstBlockTimestamp+p.cfg.ChunkTimeoutSec < currentTimeSec || metrics.NumBlocks == maxBlocksThisChunk {
+	if metrics.FirstBlockTimestamp+p.chunkTimeoutSec < currentTimeSec || metrics.NumBlocks == maxBlocksThisChunk {
 		log.Info("reached maximum number of blocks in chunk or first block timeout",
 			"block count", len(chunk.Blocks),
 			"start block number", chunk.Blocks[0].Header.Number,
@@ -346,12 +431,54 @@ func (p *ChunkProposer) proposeChunk() error {
 
 func (p *ChunkProposer) recordAllChunkMetrics(metrics *utils.ChunkMetrics) {
 	p.chunkTxNum.Set(float64(metrics.TxNum))
+	p.maxTxConsumption.Set(float64(metrics.CrcMax))
 	p.chunkBlocksNum.Set(float64(metrics.NumBlocks))
 	p.chunkL2Gas.Set(float64(metrics.L2Gas))
+	p.totalL1CommitCalldataSize.Set(float64(metrics.L1CommitCalldataSize))
+	p.chunkEstimateL1CommitGas.Set(float64(metrics.L1CommitGas))
 	p.totalL1CommitBlobSize.Set(float64(metrics.L1CommitBlobSize))
+	p.chunkEstimateGasTime.Set(float64(metrics.EstimateGasTime))
+	p.chunkEstimateCalldataSizeTime.Set(float64(metrics.EstimateCalldataSizeTime))
 	p.chunkEstimateBlobSizeTime.Set(float64(metrics.EstimateBlobSizeTime))
 }
 
 func (p *ChunkProposer) recordTimerChunkMetrics(metrics *utils.ChunkMetrics) {
+	p.chunkEstimateGasTime.Set(float64(metrics.EstimateGasTime))
+	p.chunkEstimateCalldataSizeTime.Set(float64(metrics.EstimateCalldataSizeTime))
 	p.chunkEstimateBlobSizeTime.Set(float64(metrics.EstimateBlobSizeTime))
 }
+
+func (p *ChunkProposer) tryProposeEuclidTransitionChunk(blocks []*encoding.Block) (bool, error) {
+	// If we are in replay mode, there is a corner case when StartL2Block is set as 0 in this check,
+	// it needs to get genesis block, but in mainnet db there is no genesis block, so we need to bypass this check.
+	if p.replayMode {
+		return false, nil
+	}
+
+	if !p.chainCfg.IsEuclid(blocks[0].Header.Time) {
+		return false, nil
+	}
+
+	prevBlocks, err := p.l2BlockOrm.GetL2BlocksGEHeight(p.ctx, blocks[0].Header.Number.Uint64()-1, 1)
+	if err != nil || len(prevBlocks) == 0 || prevBlocks[0].Header.Hash() != blocks[0].Header.ParentHash {
+		return false, fmt.Errorf("failed to get parent block: %w", err)
+	}
+
+	if p.chainCfg.IsEuclid(prevBlocks[0].Header.Time) {
+		// Parent is still Euclid, transition happened already
+		return false, nil
+	}
+
+	// blocks[0] is Euclid, but parent is not, propose a chunk with only blocks[0]
+	chunk := encoding.Chunk{Blocks: blocks[:1]}
+	codecVersion := encoding.CodecV5
+	metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecVersion)
+	if calcErr != nil {
+		return false, fmt.Errorf("failed to calculate chunk metrics: %w", calcErr)
+	}
+	p.recordTimerChunkMetrics(metrics)
+	if err := p.updateDBChunkInfo(&chunk, codecVersion, metrics); err != nil {
+		return false, err
+	}
+	return true, nil
+}

rollup/internal/controller/watcher/chunk_proposer_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common/math"
-	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/params"
 	"github.com/stretchr/testify/assert"
 
@@ -15,44 +14,119 @@ import (
 
 	"scroll-tech/rollup/internal/config"
 	"scroll-tech/rollup/internal/orm"
-	"scroll-tech/rollup/internal/utils"
 )
 
-func testChunkProposerLimitsCodecV7(t *testing.T) {
+func testChunkProposerLimitsCodecV4(t *testing.T) {
 	tests := []struct {
 		name                       string
 		maxBlockNum                uint64
+		maxTxNum                   uint64
 		maxL2Gas                   uint64
+		maxL1CommitGas             uint64
+		maxL1CommitCalldataSize    uint64
+		maxRowConsumption          uint64
 		chunkTimeoutSec            uint64
 		expectedChunksLen          int
 		expectedBlocksInFirstChunk int // only be checked when expectedChunksLen > 0
 	}{
 		{
-			name:              "NoLimitReached",
-			maxBlockNum:       100,
-			maxL2Gas:          20_000_000,
-			chunkTimeoutSec:   1000000000000,
-			expectedChunksLen: 0,
+			name:                    "NoLimitReached",
+			maxBlockNum:             100,
+			maxTxNum:                10000,
+			maxL2Gas:                20_000_000,
+			maxL1CommitGas:          50000000000,
+			maxL1CommitCalldataSize: 1000000,
+			maxRowConsumption:       1000000,
+			chunkTimeoutSec:         1000000000000,
+			expectedChunksLen:       0,
 		},
 		{
 			name:                       "Timeout",
 			maxBlockNum:                100,
+			maxTxNum:                   10000,
 			maxL2Gas:                   20_000_000,
+			maxL1CommitGas:             50000000000,
+			maxL1CommitCalldataSize:    1000000,
+			maxRowConsumption:          1000000,
 			chunkTimeoutSec:            0,
 			expectedChunksLen:          1,
 			expectedBlocksInFirstChunk: 2,
 		},
 		{
-			name:              "MaxL2GasPerChunkIs0",
-			maxBlockNum:       10,
-			maxL2Gas:          0,
-			chunkTimeoutSec:   1000000000000,
-			expectedChunksLen: 0,
+			name:                    "MaxTxNumPerChunkIs0",
+			maxBlockNum:             10,
+			maxTxNum:                0,
+			maxL2Gas:                20_000_000,
+			maxL1CommitGas:          50000000000,
+			maxL1CommitCalldataSize: 1000000,
+			maxRowConsumption:       1000000,
+			chunkTimeoutSec:         1000000000000,
+			expectedChunksLen:       0,
+		},
+		{
+			name:                    "MaxL2GasPerChunkIs0",
+			maxBlockNum:             10,
+			maxTxNum:                10,
+			maxL2Gas:                0,
+			maxL1CommitGas:          50000000000,
+			maxL1CommitCalldataSize: 1000000,
+			maxRowConsumption:       1000000,
+			chunkTimeoutSec:         1000000000000,
+			expectedChunksLen:       0,
+		},
+		{
+			name:                    "MaxL1CommitGasPerChunkIs0",
+			maxBlockNum:             10,
+			maxTxNum:                10000,
+			maxL2Gas:                20_000_000,
+			maxL1CommitGas:          0,
+			maxL1CommitCalldataSize: 1000000,
+			maxRowConsumption:       1000000,
+			chunkTimeoutSec:         1000000000000,
+			expectedChunksLen:       0,
+		},
+		{
+			name:                    "MaxL1CommitCalldataSizePerChunkIs0",
+			maxBlockNum:             10,
+			maxTxNum:                10000,
+			maxL2Gas:                20_000_000,
+			maxL1CommitGas:          50000000000,
+			maxL1CommitCalldataSize: 0,
+			maxRowConsumption:       1000000,
+			chunkTimeoutSec:         1000000000000,
+			expectedChunksLen:       0,
+		},
+		{
+			name:                    "MaxRowConsumptionPerChunkIs0",
+			maxBlockNum:             100,
+			maxTxNum:                10000,
+			maxL2Gas:                20_000_000,
+			maxL1CommitGas:          50000000000,
+			maxL1CommitCalldataSize: 1000000,
+			maxRowConsumption:       0,
+			chunkTimeoutSec:         1000000000000,
+			expectedChunksLen:       0,
 		},
 		{
 			name:                       "MaxBlockNumPerChunkIs1",
 			maxBlockNum:                1,
+			maxTxNum:                   10000,
 			maxL2Gas:                   20_000_000,
+			maxL1CommitGas:             50000000000,
+			maxL1CommitCalldataSize:    1000000,
+			maxRowConsumption:          1000000,
+			chunkTimeoutSec:            1000000000000,
+			expectedChunksLen:          1,
+			expectedBlocksInFirstChunk: 1,
+		},
+		{
+			name:                       "MaxTxNumPerChunkIsFirstBlock",
+			maxBlockNum:                10,
+			maxTxNum:                   2,
+			maxL2Gas:                   20_000_000,
+			maxL1CommitGas:             50000000000,
+			maxL1CommitCalldataSize:    1000000,
+			maxRowConsumption:          1000000,
 			chunkTimeoutSec:            1000000000000,
 			expectedChunksLen:          1,
 			expectedBlocksInFirstChunk: 1,
@@ -62,7 +136,47 @@ func testChunkProposerLimitsCodecV7(t *testing.T) {
 			// with the first block it exceeds the maxL2GasPerChunk limit.
 			name:                       "MaxL2GasPerChunkIsSecondBlock",
 			maxBlockNum:                10,
+			maxTxNum:                   10000,
 			maxL2Gas:                   1_153_000,
+			maxL1CommitGas:             50000000000,
+			maxL1CommitCalldataSize:    1000000,
+			maxRowConsumption:          1,
+			chunkTimeoutSec:            1000000000000,
+			expectedChunksLen:          1,
+			expectedBlocksInFirstChunk: 1,
+		},
+		{
+			name:                       "MaxL1CommitGasPerChunkIsFirstBlock",
+			maxBlockNum:                10,
+			maxTxNum:                   10000,
+			maxL2Gas:                   20_000_000,
+			maxL1CommitGas:             62500,
+			maxL1CommitCalldataSize:    1000000,
+			maxRowConsumption:          1000000,
+			chunkTimeoutSec:            1000000000000,
+			expectedChunksLen:          1,
+			expectedBlocksInFirstChunk: 1,
+		},
+		{
+			name:                       "MaxL1CommitCalldataSizePerChunkIsFirstBlock",
+			maxBlockNum:                10,
+			maxTxNum:                   10000,
+			maxL2Gas:                   20_000_000,
+			maxL1CommitGas:             50000000000,
+			maxL1CommitCalldataSize:    60,
+			maxRowConsumption:          1000000,
+			chunkTimeoutSec:            1000000000000,
+			expectedChunksLen:          1,
+			expectedBlocksInFirstChunk: 1,
+		},
+		{
+			name:                       "MaxRowConsumptionPerChunkIs1",
+			maxBlockNum:                10,
+			maxTxNum:                   10000,
+			maxL2Gas:                   20_000_000,
+			maxL1CommitGas:             50000000000,
+			maxL1CommitCalldataSize:    1000000,
+			maxRowConsumption:          1,
 			chunkTimeoutSec:            1000000000000,
 			expectedChunksLen:          1,
 			expectedBlocksInFirstChunk: 1,
@@ -78,19 +192,21 @@ func testChunkProposerLimitsCodecV7(t *testing.T) {
 			err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
 			assert.NoError(t, err)
 
-			// Add genesis chunk.
-			chunkOrm := orm.NewChunk(db)
-			_, err = chunkOrm.InsertChunk(context.Background(), &encoding.Chunk{Blocks: []*encoding.Block{{Header: &gethTypes.Header{Number: big.NewInt(0)}}}}, encoding.CodecV0, utils.ChunkMetrics{})
-			assert.NoError(t, err)
-
 			cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-				MaxBlockNumPerChunk: tt.maxBlockNum,
-				MaxL2GasPerChunk:    tt.maxL2Gas,
-				ChunkTimeoutSec:     tt.chunkTimeoutSec,
-			}, encoding.CodecV7, &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}, db, nil)
+				MaxBlockNumPerChunk:             tt.maxBlockNum,
+				MaxTxNumPerChunk:                tt.maxTxNum,
+				MaxL2GasPerChunk:                tt.maxL2Gas,
+				MaxL1CommitGasPerChunk:          tt.maxL1CommitGas,
+				MaxL1CommitCalldataSizePerChunk: tt.maxL1CommitCalldataSize,
+				MaxRowConsumptionPerChunk:       tt.maxRowConsumption,
+				ChunkTimeoutSec:                 tt.chunkTimeoutSec,
+				GasCostIncreaseMultiplier:       1.2,
+				MaxUncompressedBatchBytesSize:   math.MaxUint64,
+			}, encoding.CodecV4, &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}, db, nil)
 			cp.TryProposeChunk()
 
-			chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 1, 0)
+			chunkOrm := orm.NewChunk(db)
+			chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 0, 0)
 			assert.NoError(t, err)
 			assert.Len(t, chunks, tt.expectedChunksLen)
 
@@ -108,48 +224,61 @@ func testChunkProposerLimitsCodecV7(t *testing.T) {
 	}
 }
 
-func testChunkProposerBlobSizeLimitCodecV7(t *testing.T) {
-	db := setupDB(t)
-	defer database.CloseDB(db)
-	block := readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
-	for i := uint64(0); i < 510; i++ {
-		l2BlockOrm := orm.NewL2Block(db)
-		block.Header.Number = new(big.Int).SetUint64(i + 1)
-		block.Header.Time = i + 1
-		err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block})
-		assert.NoError(t, err)
-	}
-
-	// Add genesis chunk.
-	chunkOrm := orm.NewChunk(db)
-	_, err := chunkOrm.InsertChunk(context.Background(), &encoding.Chunk{Blocks: []*encoding.Block{{Header: &gethTypes.Header{Number: big.NewInt(0)}}}}, encoding.CodecV0, utils.ChunkMetrics{})
-	assert.NoError(t, err)
-
-	chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
-
-	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxBlockNumPerChunk: 255,
-		MaxL2GasPerChunk:    math.MaxUint64,
-		ChunkTimeoutSec:     math.MaxUint32,
-	}, encoding.CodecV7, chainConfig, db, nil)
-
-	for i := 0; i < 2; i++ {
-		cp.TryProposeChunk()
-	}
-
-	chunkOrm = orm.NewChunk(db)
-	chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 1, 0)
-	assert.NoError(t, err)
-
-	var expectedNumChunks int = 2
-	var numBlocksMultiplier uint64 = 255
-	assert.Len(t, chunks, expectedNumChunks)
-
-	for i, chunk := range chunks {
-		expected := numBlocksMultiplier * (uint64(i) + 1)
-		if expected > 2000 {
-			expected = 2000
+func testChunkProposerBlobSizeLimitCodecV4(t *testing.T) {
+	codecVersions := []encoding.CodecVersion{encoding.CodecV4}
+	for _, codecVersion := range codecVersions {
+		db := setupDB(t)
+		block := readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
+		for i := int64(0); i < 510; i++ {
+			l2BlockOrm := orm.NewL2Block(db)
+			block.Header.Number = big.NewInt(i + 1)
+			err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block})
+			assert.NoError(t, err)
 		}
-		assert.Equal(t, expected, chunk.EndBlockNumber)
+
+		var chainConfig *params.ChainConfig
+		if codecVersion == encoding.CodecV4 {
+			chainConfig = &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}
+		} else {
+			assert.Fail(t, "unsupported codec version, expected CodecV4")
+		}
+
+		cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+			MaxBlockNumPerChunk:             255,
+			MaxTxNumPerChunk:                math.MaxUint64,
+			MaxL2GasPerChunk:                math.MaxUint64,
+			MaxL1CommitGasPerChunk:          math.MaxUint64,
+			MaxL1CommitCalldataSizePerChunk: math.MaxUint64,
+			MaxRowConsumptionPerChunk:       math.MaxUint64,
+			ChunkTimeoutSec:                 math.MaxUint32,
+			GasCostIncreaseMultiplier:       1,
+			MaxUncompressedBatchBytesSize:   math.MaxUint64,
+		}, encoding.CodecV4, chainConfig, db, nil)
+
+		for i := 0; i < 2; i++ {
+			cp.TryProposeChunk()
+		}
+
+		chunkOrm := orm.NewChunk(db)
+		chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 0, 0)
+		assert.NoError(t, err)
+
+		var expectedNumChunks int = 2
+		var numBlocksMultiplier uint64
+		if codecVersion == encoding.CodecV4 {
+			numBlocksMultiplier = 255
+		} else {
+			assert.Fail(t, "unsupported codec version, expected CodecV4")
+		}
+		assert.Len(t, chunks, expectedNumChunks)
+
+		for i, chunk := range chunks {
+			expected := numBlocksMultiplier * (uint64(i) + 1)
+			if expected > 2000 {
+				expected = 2000
+			}
+			assert.Equal(t, expected, chunk.EndBlockNumber)
+		}
+		database.CloseDB(db)
 	}
 }

rollup/internal/controller/watcher/l2_watcher.go

@@ -92,6 +92,10 @@ func (w *L2WatcherClient) getAndStoreBlocks(ctx context.Context, from, to uint64
 		if err != nil {
 			return fmt.Errorf("failed to GetBlockByNumberOrHash: %v. number: %v", err, number)
 		}
+		if block.RowConsumption == nil && !w.chainCfg.IsEuclid(block.Time()) {
+			w.metrics.fetchNilRowConsumptionBlockTotal.Inc()
+			return fmt.Errorf("fetched block does not contain RowConsumption. number: %v", number)
+		}
 
 		var count int
 		for _, tx := range block.Transactions() {
@@ -106,9 +110,10 @@ func (w *L2WatcherClient) getAndStoreBlocks(ctx context.Context, from, to uint64
 			return fmt.Errorf("failed to get withdrawRoot: %v. number: %v", err3, number)
 		}
 		blocks = append(blocks, &encoding.Block{
-			Header:       block.Header(),
-			Transactions: encoding.TxsToTxsData(block.Transactions()),
-			WithdrawRoot: common.BytesToHash(withdrawRoot),
+			Header:         block.Header(),
+			Transactions:   encoding.TxsToTxsData(block.Transactions()),
+			WithdrawRoot:   common.BytesToHash(withdrawRoot),
+			RowConsumption: block.RowConsumption,
 		})
 	}
 
@@ -118,6 +123,11 @@ func (w *L2WatcherClient) getAndStoreBlocks(ctx context.Context, from, to uint64
 			if codec == nil {
 				return fmt.Errorf("failed to retrieve codec for block number %v and time %v", block.Header.Number, block.Header.Time)
 			}
+			blockL1CommitCalldataSize, err := codec.EstimateBlockL1CommitCalldataSize(block)
+			if err != nil {
+				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 {

rollup/internal/controller/watcher/l2_watcher_metrics.go

@@ -8,9 +8,11 @@ import (
 )
 
 type l2WatcherMetrics struct {
-	fetchRunningMissingBlocksTotal  prometheus.Counter
-	fetchRunningMissingBlocksHeight prometheus.Gauge
-	rollupL2BlocksFetchedGap        prometheus.Gauge
+	fetchRunningMissingBlocksTotal    prometheus.Counter
+	fetchRunningMissingBlocksHeight   prometheus.Gauge
+	rollupL2BlocksFetchedGap          prometheus.Gauge
+	rollupL2BlockL1CommitCalldataSize prometheus.Gauge
+	fetchNilRowConsumptionBlockTotal  prometheus.Counter
 
 	rollupL2WatcherSyncThroughput prometheus.Counter
 }
@@ -35,6 +37,14 @@ func initL2WatcherMetrics(reg prometheus.Registerer) *l2WatcherMetrics {
 				Name: "rollup_l2_watcher_blocks_fetched_gap",
 				Help: "The gap of l2 fetch",
 			}),
+			rollupL2BlockL1CommitCalldataSize: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+				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",

rollup/internal/controller/watcher/watcher_test.go

@@ -101,16 +101,17 @@ func TestFunction(t *testing.T) {
 	t.Run("TestFetchRunningMissingBlocks", testFetchRunningMissingBlocks)
 
 	// Run chunk proposer test cases.
-	t.Run("TestChunkProposerLimitsCodecV7", testChunkProposerLimitsCodecV7)
-	t.Run("TestChunkProposerBlobSizeLimitCodecV7", testChunkProposerBlobSizeLimitCodecV7)
+	t.Run("TestChunkProposerLimitsCodecV4", testChunkProposerLimitsCodecV4)
+	t.Run("TestChunkProposerBlobSizeLimitCodecV4", testChunkProposerBlobSizeLimitCodecV4)
 
 	// Run batch proposer test cases.
-	t.Run("TestBatchProposerLimitsCodecV7", testBatchProposerLimitsCodecV7)
-	t.Run("TestBatchProposerBlobSizeLimitCodecV7", testBatchProposerBlobSizeLimitCodecV7)
-	t.Run("TestBatchProposerMaxChunkNumPerBatchLimitCodecV7", testBatchProposerMaxChunkNumPerBatchLimitCodecV7)
+	t.Run("TestBatchProposerLimitsCodecV4", testBatchProposerLimitsCodecV4)
+	t.Run("TestBatchCommitGasAndCalldataSizeEstimationCodecV4", testBatchCommitGasAndCalldataSizeEstimationCodecV4)
+	t.Run("TestBatchProposerBlobSizeLimitCodecV4", testBatchProposerBlobSizeLimitCodecV4)
+	t.Run("TestBatchProposerMaxChunkNumPerBatchLimitCodecV4", testBatchProposerMaxChunkNumPerBatchLimitCodecV4)
 
 	// Run bundle proposer test cases.
-	t.Run("TestBundleProposerLimitsCodecV7", testBundleProposerLimitsCodecV7)
+	t.Run("TestBundleProposerLimitsCodecV4", testBundleProposerLimitsCodecV4)
 }
 
 func readBlockFromJSON(t *testing.T, filename string) *encoding.Block {

rollup/internal/orm/batch.go

@@ -218,18 +218,6 @@ func (o *Batch) GetRollupStatusByHashList(ctx context.Context, hashes []string)
 	return statuses, nil
 }
 
-func (o *Batch) GetFailedAndPendingBatchesCount(ctx context.Context) (int64, error) {
-	db := o.db.WithContext(ctx)
-	db = db.Model(&Batch{})
-	db = db.Where("rollup_status = ? OR rollup_status = ?", types.RollupCommitFailed, types.RollupPending)
-
-	var count int64
-	if err := db.Count(&count).Error; err != nil {
-		return 0, fmt.Errorf("Batch.GetFailedAndPendingBatchesCount error: %w", err)
-	}
-	return count, nil
-}
-
 // GetFailedAndPendingBatches retrieves batches with failed or pending status up to the specified limit.
 // The returned batches are sorted in ascending order by their index.
 func (o *Batch) GetFailedAndPendingBatches(ctx context.Context, limit int) ([]*Batch, error) {
@@ -300,28 +288,30 @@ func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, codecVer
 	}
 
 	newBatch := Batch{
-		Index:                  batch.Index,
-		Hash:                   batchMeta.BatchHash.Hex(),
-		DataHash:               batchMeta.BatchDataHash.Hex(),
-		StartChunkHash:         batchMeta.StartChunkHash.Hex(),
-		StartChunkIndex:        startChunkIndex,
-		EndChunkHash:           batchMeta.EndChunkHash.Hex(),
-		EndChunkIndex:          startChunkIndex + numChunks - 1,
-		StateRoot:              batch.StateRoot().Hex(),
-		WithdrawRoot:           batch.WithdrawRoot().Hex(),
-		ParentBatchHash:        batch.ParentBatchHash.Hex(),
-		BatchHeader:            batchMeta.BatchBytes,
-		CodecVersion:           int16(codecVersion),
-		PrevL1MessageQueueHash: batch.PrevL1MessageQueueHash.Hex(),
-		PostL1MessageQueueHash: batch.PostL1MessageQueueHash.Hex(),
-		EnableCompress:         enableCompress,
-		BlobBytes:              batchMeta.BlobBytes,
-		ChallengeDigest:        batchMeta.ChallengeDigest.Hex(),
-		ChunkProofsStatus:      int16(types.ChunkProofsStatusPending),
-		ProvingStatus:          int16(types.ProvingTaskUnassigned),
-		RollupStatus:           int16(types.RollupPending),
-		BlobDataProof:          batchMeta.BatchBlobDataProof,
-		BlobSize:               metrics.L1CommitBlobSize,
+		Index:                     batch.Index,
+		Hash:                      batchMeta.BatchHash.Hex(),
+		DataHash:                  batchMeta.BatchDataHash.Hex(),
+		StartChunkHash:            batchMeta.StartChunkHash.Hex(),
+		StartChunkIndex:           startChunkIndex,
+		EndChunkHash:              batchMeta.EndChunkHash.Hex(),
+		EndChunkIndex:             startChunkIndex + numChunks - 1,
+		StateRoot:                 batch.StateRoot().Hex(),
+		WithdrawRoot:              batch.WithdrawRoot().Hex(),
+		ParentBatchHash:           batch.ParentBatchHash.Hex(),
+		BatchHeader:               batchMeta.BatchBytes,
+		CodecVersion:              int16(codecVersion),
+		PrevL1MessageQueueHash:    batch.PrevL1MessageQueueHash.Hex(),
+		PostL1MessageQueueHash:    batch.PostL1MessageQueueHash.Hex(),
+		EnableCompress:            enableCompress,
+		BlobBytes:                 batchMeta.BlobBytes,
+		ChallengeDigest:           batchMeta.ChallengeDigest.Hex(),
+		ChunkProofsStatus:         int16(types.ChunkProofsStatusPending),
+		ProvingStatus:             int16(types.ProvingTaskUnassigned),
+		RollupStatus:              int16(types.RollupPending),
+		TotalL1CommitGas:          metrics.L1CommitGas,
+		TotalL1CommitCalldataSize: metrics.L1CommitCalldataSize,
+		BlobDataProof:             batchMeta.BatchBlobDataProof,
+		BlobSize:                  metrics.L1CommitBlobSize,
 	}
 
 	db := o.db

rollup/internal/orm/chunk.go

@@ -50,14 +50,14 @@ type Chunk struct {
 	BatchHash string `json:"batch_hash" gorm:"column:batch_hash;default:NULL"`
 
 	// blob
-	CrcMax   uint64 `json:"crc_max" gorm:"column:crc_max"` // deprecated
+	CrcMax   uint64 `json:"crc_max" gorm:"column:crc_max"`
 	BlobSize uint64 `json:"blob_size" gorm:"column:blob_size"`
 
 	// metadata
 	TotalL2TxGas              uint64         `json:"total_l2_tx_gas" gorm:"column:total_l2_tx_gas"`
 	TotalL2TxNum              uint64         `json:"total_l2_tx_num" gorm:"column:total_l2_tx_num"`
-	TotalL1CommitCalldataSize uint64         `json:"total_l1_commit_calldata_size" gorm:"column:total_l1_commit_calldata_size"` // deprecated
-	TotalL1CommitGas          uint64         `json:"total_l1_commit_gas" gorm:"column:total_l1_commit_gas"`                     // deprecated
+	TotalL1CommitCalldataSize uint64         `json:"total_l1_commit_calldata_size" gorm:"column:total_l1_commit_calldata_size"`
+	TotalL1CommitGas          uint64         `json:"total_l1_commit_gas" gorm:"column:total_l1_commit_gas"`
 	CreatedAt                 time.Time      `json:"created_at" gorm:"column:created_at"`
 	UpdatedAt                 time.Time      `json:"updated_at" gorm:"column:updated_at"`
 	DeletedAt                 gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at;default:NULL"`
@@ -246,6 +246,8 @@ func (o *Chunk) InsertChunk(ctx context.Context, chunk *encoding.Chunk, codecVer
 		EndBlockHash:                 chunk.Blocks[numBlocks-1].Header.Hash().Hex(),
 		TotalL2TxGas:                 chunk.TotalGasUsed(),
 		TotalL2TxNum:                 chunk.NumL2Transactions(),
+		TotalL1CommitCalldataSize:    metrics.L1CommitCalldataSize,
+		TotalL1CommitGas:             metrics.L1CommitGas,
 		StartBlockTime:               chunk.Blocks[0].Header.Time,
 		TotalL1MessagesPoppedBefore:  totalL1MessagePoppedBefore,
 		TotalL1MessagesPoppedInChunk: chunk.NumL1Messages(totalL1MessagePoppedBefore),
@@ -258,6 +260,7 @@ func (o *Chunk) InsertChunk(ctx context.Context, chunk *encoding.Chunk, codecVer
 		CodecVersion:                 int16(codecVersion),
 		EnableCompress:               enableCompress,
 		ProvingStatus:                int16(types.ProvingTaskUnassigned),
+		CrcMax:                       metrics.CrcMax,
 		BlobSize:                     metrics.L1CommitBlobSize,
 	}
 

rollup/internal/orm/l1_block.go

@@ -71,20 +71,6 @@ func (o *L1Block) GetL1Blocks(ctx context.Context, fields map[string]interface{}
 	return l1Blocks, nil
 }
 
-// GetBlobFeesInRange returns all blob_base_fee values for blocks
-// with number ∈ [startBlock..endBlock], ordered by block number ascending.
-func (o *L1Block) GetBlobFeesInRange(ctx context.Context, startBlock, endBlock uint64) ([]uint64, error) {
-	var fees []uint64
-	db := o.db.WithContext(ctx).
-		Model(&L1Block{}).
-		Where("number >= ? AND number <= ?", startBlock, endBlock).
-		Order("number ASC")
-	if err := db.Pluck("blob_base_fee", &fees).Error; err != nil {
-		return nil, fmt.Errorf("L1Block.GetBlobFeesInRange error: %w", err)
-	}
-	return fees, nil
-}
-
 // InsertL1Blocks batch inserts l1 blocks.
 // If there's a block number conflict (e.g., due to reorg), soft deletes the existing block and inserts the new one.
 func (o *L1Block) InsertL1Blocks(ctx context.Context, blocks []L1Block) error {

rollup/internal/orm/l2_block.go

@@ -96,6 +96,11 @@ func (o *L2Block) GetL2BlocksGEHeight(ctx context.Context, height uint64, limit
 		}
 
 		block.WithdrawRoot = common.HexToHash(v.WithdrawRoot)
+
+		if err := json.Unmarshal([]byte(v.RowConsumption), &block.RowConsumption); err != nil {
+			return nil, fmt.Errorf("L2Block.GetL2BlocksGEHeight error: %w", err)
+		}
+
 		blocks = append(blocks, &block)
 	}
 
@@ -166,6 +171,11 @@ func (o *L2Block) GetL2BlocksInRange(ctx context.Context, startBlockNumber uint6
 		}
 
 		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)
 	}
 
@@ -188,6 +198,12 @@ func (o *L2Block) InsertL2Blocks(ctx context.Context, blocks []*encoding.Block)
 			return fmt.Errorf("L2Block.InsertL2Blocks error: %w", err)
 		}
 
+		rc, err := json.Marshal(block.RowConsumption)
+		if err != nil {
+			log.Error("failed to marshal RowConsumption", "hash", block.Header.Hash().String(), "err", err)
+			return fmt.Errorf("L2Block.InsertL2Blocks error: %w", err)
+		}
+
 		l2Block := L2Block{
 			Number:         block.Header.Number.Uint64(),
 			Hash:           block.Header.Hash().String(),
@@ -198,6 +214,7 @@ func (o *L2Block) InsertL2Blocks(ctx context.Context, blocks []*encoding.Block)
 			TxNum:          uint32(len(block.Transactions)),
 			GasUsed:        block.Header.GasUsed,
 			BlockTimestamp: block.Header.Time,
+			RowConsumption: string(rc),
 			Header:         string(header),
 		}
 		l2Blocks = append(l2Blocks, l2Block)

rollup/internal/orm/orm_test.go

@@ -71,14 +71,12 @@ func setupEnv(t *testing.T) {
 	block1 = &encoding.Block{}
 	err = json.Unmarshal(templateBlockTrace, block1)
 	assert.NoError(t, err)
-	block1.RowConsumption = nil
 
 	templateBlockTrace, err = os.ReadFile("../../../common/testdata/blockTrace_03.json")
 	assert.NoError(t, err)
 	block2 = &encoding.Block{}
 	err = json.Unmarshal(templateBlockTrace, block2)
 	assert.NoError(t, err)
-	block2.RowConsumption = nil
 }
 
 func tearDownEnv(t *testing.T) {

rollup/internal/utils/utils.go

@@ -13,12 +13,19 @@ type ChunkMetrics struct {
 	NumBlocks           uint64
 	TxNum               uint64
 	L2Gas               uint64
+	CrcMax              uint64
 	FirstBlockTimestamp uint64
 
-	L1CommitBlobSize uint64
+	L1CommitCalldataSize uint64
+	L1CommitGas          uint64
+
+	L1CommitBlobSize                   uint64
+	L1CommitUncompressedBatchBytesSize uint64
 
 	// timing metrics
-	EstimateBlobSizeTime time.Duration
+	EstimateGasTime          time.Duration
+	EstimateCalldataSizeTime time.Duration
+	EstimateBlobSizeTime     time.Duration
 }
 
 // CalculateChunkMetrics calculates chunk metrics.
@@ -35,13 +42,34 @@ func CalculateChunkMetrics(chunk *encoding.Chunk, codecVersion encoding.CodecVer
 	}
 
 	var err error
+	metrics.CrcMax, err = chunk.CrcMax()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get crc max, version: %v, err: %w", codecVersion, err)
+	}
+
 	codec, err := encoding.CodecFromVersion(codecVersion)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get codec from version: %v, err: %w", codecVersion, err)
 	}
 
+	metrics.EstimateGasTime, err = measureTime(func() error {
+		metrics.L1CommitGas, err = codec.EstimateChunkL1CommitGas(chunk)
+		return err
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to estimate chunk L1 commit gas, version: %v, err: %w", codecVersion, err)
+	}
+
+	metrics.EstimateCalldataSizeTime, err = measureTime(func() error {
+		metrics.L1CommitCalldataSize, err = codec.EstimateChunkL1CommitCalldataSize(chunk)
+		return err
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to estimate chunk L1 commit calldata size, version: %v, err: %w", codecVersion, err)
+	}
+
 	metrics.EstimateBlobSizeTime, err = measureTime(func() error {
-		_, metrics.L1CommitBlobSize, err = codec.EstimateChunkL1CommitBatchSizeAndBlobSize(chunk)
+		metrics.L1CommitUncompressedBatchBytesSize, metrics.L1CommitBlobSize, err = codec.EstimateChunkL1CommitBatchSizeAndBlobSize(chunk)
 		return err
 	})
 	if err != nil {
@@ -56,10 +84,16 @@ type BatchMetrics struct {
 	NumChunks           uint64
 	FirstBlockTimestamp uint64
 
-	L1CommitBlobSize uint64
+	L1CommitCalldataSize uint64
+	L1CommitGas          uint64
+
+	L1CommitBlobSize                   uint64
+	L1CommitUncompressedBatchBytesSize uint64
 
 	// timing metrics
-	EstimateBlobSizeTime time.Duration
+	EstimateGasTime          time.Duration
+	EstimateCalldataSizeTime time.Duration
+	EstimateBlobSizeTime     time.Duration
 }
 
 // CalculateBatchMetrics calculates batch metrics.
@@ -74,8 +108,24 @@ func CalculateBatchMetrics(batch *encoding.Batch, codecVersion encoding.CodecVer
 		return nil, fmt.Errorf("failed to get codec from version: %v, err: %w", codecVersion, err)
 	}
 
+	metrics.EstimateGasTime, err = measureTime(func() error {
+		metrics.L1CommitGas, err = codec.EstimateBatchL1CommitGas(batch)
+		return err
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to estimate batch L1 commit gas, version: %v, err: %w", codecVersion, err)
+	}
+
+	metrics.EstimateCalldataSizeTime, err = measureTime(func() error {
+		metrics.L1CommitCalldataSize, err = codec.EstimateBatchL1CommitCalldataSize(batch)
+		return err
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to estimate batch L1 commit calldata size, version: %v, err: %w", codecVersion, err)
+	}
+
 	metrics.EstimateBlobSizeTime, err = measureTime(func() error {
-		_, metrics.L1CommitBlobSize, err = codec.EstimateBatchL1CommitBatchSizeAndBlobSize(batch)
+		metrics.L1CommitUncompressedBatchBytesSize, metrics.L1CommitBlobSize, err = codec.EstimateBatchL1CommitBatchSizeAndBlobSize(batch)
 		return err
 	})
 	if err != nil {

rollup/proposer-tool-config.json

@@ -3,11 +3,21 @@
       "endpoint": "https://rpc.scroll.io",
       "chunk_proposer_config": {
         "max_block_num_per_chunk": 100,
+        "max_tx_num_per_chunk": 100,
         "max_l2_gas_per_chunk": 20000000,
-        "chunk_timeout_sec": 72000000000
+        "max_l1_commit_gas_per_chunk": 5000000,
+        "max_l1_commit_calldata_size_per_chunk": 123740,
+        "chunk_timeout_sec": 72000000000,
+        "max_row_consumption_per_chunk": 10000000000,
+        "gas_cost_increase_multiplier": 1.2,
+        "max_uncompressed_batch_bytes_size": 634693
       },
       "batch_proposer_config": {
+        "max_l1_commit_gas_per_batch": 5000000,
+        "max_l1_commit_calldata_size_per_batch": 123740,
         "batch_timeout_sec": 72000000000,
+        "gas_cost_increase_multiplier": 1.2,
+        "max_uncompressed_batch_bytes_size": 634693,
         "max_chunks_per_batch": 45
       },
       "bundle_proposer_config": {

rollup/tests/bridge_test.go

@@ -208,6 +208,7 @@ func TestFunction(t *testing.T) {
 
 	// l1 rollup and watch rollup events
 	t.Run("TestCommitAndFinalizeGenesisBatch", testCommitAndFinalizeGenesisBatch)
+	t.Run("TestCommitBatchAndFinalizeBundleCodecV4V5V6", testCommitBatchAndFinalizeBundleCodecV4V5V6)
 	t.Run("TestCommitBatchAndFinalizeBundleCodecV7", testCommitBatchAndFinalizeBundleCodecV7)
 
 	// l1 gas oracle

rollup/tests/gas_oracle_test.go

@@ -66,8 +66,9 @@ func testImportL1GasPrice(t *testing.T) {
 					Difficulty: big.NewInt(0),
 					BaseFee:    big.NewInt(0),
 				},
-				Transactions: nil,
-				WithdrawRoot: common.Hash{},
+				Transactions:   nil,
+				WithdrawRoot:   common.Hash{},
+				RowConsumption: &gethTypes.RowConsumption{},
 			},
 		},
 	}
@@ -140,8 +141,9 @@ func testImportDefaultL1GasPriceDueToL1GasPriceSpike(t *testing.T) {
 					Difficulty: big.NewInt(0),
 					BaseFee:    big.NewInt(0),
 				},
-				Transactions: nil,
-				WithdrawRoot: common.Hash{},
+				Transactions:   nil,
+				WithdrawRoot:   common.Hash{},
+				RowConsumption: &gethTypes.RowConsumption{},
 			},
 		},
 	}

rollup/tests/process_start_test.go

@@ -19,7 +19,7 @@ func testProcessStart(t *testing.T) {
 	db := setupDB(t)
 	defer database.CloseDB(db)
 	rollupApp.RunApp(t, cutils.GasOracleApp, "--genesis", "../conf/genesis.json")
-	rollupApp.RunApp(t, cutils.RollupRelayerApp, "--genesis", "../conf/genesis.json", "--min-codec-version", "7")
+	rollupApp.RunApp(t, cutils.RollupRelayerApp, "--genesis", "../conf/genesis.json", "--min-codec-version", "4")
 
 	rollupApp.WaitExit()
 }
@@ -36,7 +36,7 @@ func testProcessStartEnableMetrics(t *testing.T) {
 	port, err = rand.Int(rand.Reader, big.NewInt(10000))
 	assert.NoError(t, err)
 	svrPort = strconv.FormatInt(port.Int64()+30000, 10)
-	rollupApp.RunApp(t, cutils.RollupRelayerApp, "--metrics", "--metrics.addr", "localhost", "--metrics.port", svrPort, "--genesis", "../conf/genesis.json", "--min-codec-version", "7")
+	rollupApp.RunApp(t, cutils.RollupRelayerApp, "--metrics", "--metrics.addr", "localhost", "--metrics.port", svrPort, "--genesis", "../conf/genesis.json", "--min-codec-version", "4")
 
 	rollupApp.WaitExit()
 }

rollup/tests/rollup_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/agiledragon/gomonkey/v2"
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
@@ -18,6 +19,7 @@ import (
 
 	"scroll-tech/common/database"
 	"scroll-tech/common/types"
+	"scroll-tech/common/types/message"
 
 	"scroll-tech/rollup/internal/config"
 	"scroll-tech/rollup/internal/controller/relayer"
@@ -54,6 +56,172 @@ func testCommitAndFinalizeGenesisBatch(t *testing.T) {
 	assert.Equal(t, types.RollupFinalized, types.RollupStatus(batch.RollupStatus))
 }
 
+func testCommitBatchAndFinalizeBundleCodecV4V5V6(t *testing.T) {
+	db := setupDB(t)
+
+	prepareContracts(t)
+
+	euclidTime := uint64(3)
+	chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: &euclidTime}
+
+	// Create L2Relayer
+	l2Cfg := rollupApp.Config.L2Config
+	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig, chainConfig, relayer.ServiceTypeL2RollupRelayer, nil)
+	assert.NoError(t, err)
+
+	// add some blocks to db
+	var blocks []*encoding.Block
+	for i := int64(0); i < 10; i++ {
+		header := gethTypes.Header{
+			Number:     big.NewInt(i + 1),
+			ParentHash: common.Hash{},
+			Difficulty: big.NewInt(0),
+			BaseFee:    big.NewInt(0),
+			Root:       common.HexToHash("0x1"),
+			Time:       uint64(i),
+		}
+		blocks = append(blocks, &encoding.Block{
+			Header:         &header,
+			Transactions:   nil,
+			WithdrawRoot:   common.HexToHash("0x2"),
+			RowConsumption: &gethTypes.RowConsumption{},
+		})
+	}
+
+	cp := watcher.NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+		MaxBlockNumPerChunk:             100,
+		MaxTxNumPerChunk:                10000,
+		MaxL1CommitGasPerChunk:          50000000000,
+		MaxL1CommitCalldataSizePerChunk: 1000000,
+		MaxRowConsumptionPerChunk:       1048319,
+		ChunkTimeoutSec:                 300,
+		MaxUncompressedBatchBytesSize:   math.MaxUint64,
+	}, encoding.CodecV4, chainConfig, db, nil)
+
+	bap := watcher.NewBatchProposer(context.Background(), &config.BatchProposerConfig{
+		MaxL1CommitGasPerBatch:          50000000000,
+		MaxL1CommitCalldataSizePerBatch: 1000000,
+		BatchTimeoutSec:                 300,
+		MaxUncompressedBatchBytesSize:   math.MaxUint64,
+		MaxChunksPerBatch:               math.MaxInt32,
+	}, encoding.CodecV4, chainConfig, db, nil)
+
+	bup := watcher.NewBundleProposer(context.Background(), &config.BundleProposerConfig{
+		MaxBatchNumPerBundle: 1000000,
+		BundleTimeoutSec:     300,
+	}, encoding.CodecV4, chainConfig, db, nil)
+
+	l2BlockOrm := orm.NewL2Block(db)
+	batchOrm := orm.NewBatch(db)
+	bundleOrm := orm.NewBundle(db)
+
+	err = l2BlockOrm.InsertL2Blocks(context.Background(), blocks[:5])
+	assert.NoError(t, err)
+
+	cp.TryProposeChunk()
+	bap.TryProposeBatch()
+
+	err = l2BlockOrm.InsertL2Blocks(context.Background(), blocks[5:])
+	assert.NoError(t, err)
+
+	cp.TryProposeChunk()
+	bap.TryProposeBatch()
+
+	l2Relayer.ProcessPendingBatches()
+
+	// make sure that batches are committed before proposing bundles (as bundle proposing depends on batches being committed).
+	require.Eventually(t, func() bool {
+		batches, getErr := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, nil, 0)
+		assert.NoError(t, getErr)
+
+		assert.Len(t, batches, 3)
+		batches = batches[1:]
+		for _, batch := range batches {
+			if types.RollupCommitted != types.RollupStatus(batch.RollupStatus) {
+				return false
+			}
+		}
+
+		// make sure that batches 1 and 2 have been committed in separate transactions
+		return batches[0].CommitTxHash != batches[1].CommitTxHash
+	}, 30*time.Second, time.Second)
+
+	bup.TryProposeBundle() // The proposed bundle contains two batches when codec version is codecv3.
+
+	patchGuard1 := gomonkey.ApplyMethodFunc((*message.OpenVMBatchProof)(nil), "SanityCheck", func() error {
+		return nil
+	})
+	defer patchGuard1.Reset()
+
+	batchProof := &message.OpenVMBatchProof{}
+	batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, nil, 0)
+	assert.NoError(t, err)
+	batches = batches[1:]
+	for _, batch := range batches {
+		err = batchOrm.UpdateProofByHash(context.Background(), batch.Hash, batchProof, 100)
+		assert.NoError(t, err)
+		err = batchOrm.UpdateProvingStatus(context.Background(), batch.Hash, types.ProvingTaskVerified)
+		assert.NoError(t, err)
+	}
+
+	patchGuard2 := gomonkey.ApplyMethodFunc((*message.OpenVMBundleProof)(nil), "SanityCheck", func() error {
+		return nil
+	})
+	defer patchGuard2.Reset()
+
+	bundleProof := &message.OpenVMBundleProof{EvmProof: &message.OpenVMEvmProof{Instances: make([]byte, 384)}}
+	bundles, err := bundleOrm.GetBundles(context.Background(), map[string]interface{}{}, nil, 0)
+	assert.NoError(t, err)
+	for _, bundle := range bundles {
+		err = bundleOrm.UpdateProofAndProvingStatusByHash(context.Background(), bundle.Hash, bundleProof, types.ProvingTaskVerified, 100)
+		assert.NoError(t, err)
+	}
+
+	assert.Eventually(t, func() bool {
+		l2Relayer.ProcessPendingBundles()
+
+		batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, nil, 0)
+		assert.NoError(t, err)
+		assert.Len(t, batches, 3)
+		batches = batches[1:]
+		for _, batch := range batches {
+			if types.RollupStatus(batch.RollupStatus) != types.RollupFinalized {
+				return false
+			}
+
+			assert.NotEmpty(t, batch.FinalizeTxHash)
+			receipt, getErr := l1Client.TransactionReceipt(context.Background(), common.HexToHash(batch.FinalizeTxHash))
+			assert.NoError(t, getErr)
+			assert.Equal(t, gethTypes.ReceiptStatusSuccessful, receipt.Status)
+		}
+
+		bundles, err := bundleOrm.GetBundles(context.Background(), map[string]interface{}{}, nil, 0)
+		assert.NoError(t, err)
+		assert.Len(t, bundles, 1)
+
+		bundle := bundles[0]
+		if types.RollupStatus(bundle.RollupStatus) != types.RollupFinalized {
+			return false
+		}
+		assert.NotEmpty(t, bundle.FinalizeTxHash)
+		receipt, err := l1Client.TransactionReceipt(context.Background(), common.HexToHash(bundle.FinalizeTxHash))
+		assert.NoError(t, err)
+		assert.Equal(t, gethTypes.ReceiptStatusSuccessful, receipt.Status)
+		batches, err = batchOrm.GetBatches(context.Background(), map[string]interface{}{"bundle_hash": bundle.Hash}, nil, 0)
+		assert.NoError(t, err)
+		assert.Len(t, batches, 2)
+		for _, batch := range batches {
+			assert.Equal(t, batch.RollupStatus, bundle.RollupStatus)
+			assert.Equal(t, bundle.FinalizeTxHash, batch.FinalizeTxHash)
+		}
+
+		return true
+	}, 30*time.Second, time.Second)
+
+	l2Relayer.StopSenders()
+	database.CloseDB(db)
+}
+
 func testCommitBatchAndFinalizeBundleCodecV7(t *testing.T) {
 	db := setupDB(t)
 
@@ -110,22 +278,29 @@ func testCommitBatchAndFinalizeBundleCodecV7(t *testing.T) {
 		}
 
 		blocks = append(blocks, &encoding.Block{
-			Header:       &header,
-			Transactions: transactions,
-			WithdrawRoot: common.HexToHash("0x2"),
+			Header:         &header,
+			Transactions:   transactions,
+			WithdrawRoot:   common.HexToHash("0x2"),
+			RowConsumption: &gethTypes.RowConsumption{},
 		})
 		parentHash = header.Hash()
 	}
 
 	cp := watcher.NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxBlockNumPerChunk: 100,
-		MaxL2GasPerChunk:    math.MaxUint64,
-		ChunkTimeoutSec:     300,
+		MaxBlockNumPerChunk:             100,
+		MaxTxNumPerChunk:                10000,
+		MaxL1CommitGasPerChunk:          50000000000,
+		MaxL1CommitCalldataSizePerChunk: 1000000,
+		MaxRowConsumptionPerChunk:       1048319,
+		ChunkTimeoutSec:                 300,
+		MaxUncompressedBatchBytesSize:   math.MaxUint64,
 	}, encoding.CodecV7, chainConfig, db, nil)
 
 	bap := watcher.NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-		MaxChunksPerBatch: math.MaxInt32,
-		BatchTimeoutSec:   300,
+		MaxL1CommitGasPerBatch:          50000000000,
+		MaxL1CommitCalldataSizePerBatch: 1000000,
+		BatchTimeoutSec:                 300,
+		MaxUncompressedBatchBytesSize:   math.MaxUint64,
 	}, encoding.CodecV7, chainConfig, db, nil)
 
 	bup := watcher.NewBundleProposer(context.Background(), &config.BundleProposerConfig{

rust-toolchain

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "nightly-2025-02-14"
+targets = ["riscv32im-unknown-none-elf", "x86_64-unknown-linux-gnu"]
+components = ["llvm-tools", "rustc-dev"]

rustfmt.toml

@@ -0,0 +1,8 @@
+comment_width = 300
+edition = "2024"
+imports_granularity = "Crate"
+max_width = 100
+newline_style = "Unix"
+normalize_comments = true
+style_edition = "2024"
+wrap_comments = false