chore: bump version

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

.github/workflows/common.yml

@@ -42,11 +42,11 @@ 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: 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

@@ -99,6 +99,51 @@ jobs:
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
+  blob_uploader:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: blob-uploader
+        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: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: blob-uploader
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/blob_uploader.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
   rollup-db-cli:
     runs-on: ubuntu-latest
     steps:
@@ -307,6 +352,48 @@ 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
+        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
       - name: Build and push
         uses: docker/build-push-action@v3
         env:

.github/workflows/intermediate-docker.yml

@@ -24,6 +24,7 @@ on:
         options:
           - nightly-2023-12-03
           - nightly-2022-12-10
+          - 1.86.0
         default: "nightly-2023-12-03"
       PYTHON_VERSION:
         description: "Python version"
@@ -47,6 +48,7 @@ on:
         type: choice
         options:
           - 0.1.41
+          - 0.1.71
       BASE_IMAGE:
         description: "which intermediate image you want to update"
         required: true

.github/workflows/prover.yml

@@ -1,99 +0,0 @@
-name: Prover
-
-on:
-  push:
-    branches:
-      - main
-      - staging
-      - develop
-      - alpha
-    paths:
-      - 'prover/**'
-      - '.github/workflows/prover.yml'
-  pull_request:
-    types:
-      - opened
-      - reopened
-      - synchronize
-      - ready_for_review
-    paths:
-      - 'prover/**'
-      - '.github/workflows/prover.yml'
-
-defaults:
-  run:
-    working-directory: 'prover'
-
-jobs:
-  skip_check:
-    runs-on: ubuntu-latest
-    outputs:
-      should_skip: ${{ steps.skip_check.outputs.should_skip }}
-    steps:
-      - id: skip_check
-        uses: fkirc/skip-duplicate-actions@v5
-        with:
-          cancel_others: 'true'
-          concurrent_skipping: 'same_content_newer'
-          paths_ignore: '["**/README.md"]'
-
-  fmt:
-    needs: [skip_check]
-    if: |
-      github.event.pull_request.draft == false &&
-      (github.event.action == 'ready_for_review' || needs.skip_check.outputs.should_skip != 'true')
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: nightly-2023-12-03
-          components: rustfmt
-      - name: Cargo cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: "prover -> target"
-      - name: Cargo check
-        run: cargo check --all-features
-      - name: Cargo fmt
-        run: cargo fmt --all -- --check
-  
-  clippy:
-    needs: [skip_check, fmt]
-    if: |
-      github.event.pull_request.draft == false &&
-      (github.event.action == 'ready_for_review' || needs.skip_check.outputs.should_skip != 'true')
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: nightly-2023-12-03
-          components: clippy
-      - name: Cargo cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: "prover -> target"
-      - name: Run clippy
-        run: cargo clippy --all-features --all-targets -- -D warnings
-
-  compile:
-    needs: [skip_check, clippy]
-    if: |
-      github.event.pull_request.draft == false &&
-      (github.event.action == 'ready_for_review' || needs.skip_check.outputs.should_skip != 'true')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: nightly-2023-12-03
-      - name: Cache cargo
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: "prover -> target"
-      - name: Test
-        run: |
-          make prover

CONTRIBUTING.md

@@ -11,7 +11,7 @@ Please note that this project is released with a [Contributor Code of Conduct][c
 
 ## Contribute to Scroll
 
-Did you know there are many ways of contributing to Scroll? If you are looking to contribute to by adding Scroll to existing Dev Tools or by doing integrations please go to the [Contribute to Scroll](https://github.com/scroll-tech/contribute-to-scroll) repo instead. If you are looking to contribute to Scroll's Halo2 zkEVM circuits please refer to the [zkEVM circuits](https://github.com/scroll-tech/zkevm-circuits) repo. This repository covers the Scroll infrastructure and smart contracts, if you want to contribute to these areas continue reading this document.
+Did you know there are many ways of contributing to Scroll? If you are looking to contribute to by adding Scroll to existing Dev Tools or by doing integrations please go to the [Contribute to Scroll](https://github.com/scroll-tech/contribute-to-scroll) repo instead. This repository covers the Scroll infrastructure and smart contracts, if you want to contribute to these areas continue reading this document.
 
 ## Issues and PRs
 

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 = ?", types.TxStatusTypeSent)
+	db = db.Where("tx_status in (?)", []types.TxStatusType{types.TxStatusTypeSent, types.TxStatusTypeFailedRelayed, types.TxStatusTypeRelayTxReverted})
 	db = db.Where("sender = ?", sender)
 	db = db.Order("block_timestamp desc")
 	db = db.Limit(500)

build/dockerfiles/blob_uploader.Dockerfile

@@ -0,0 +1,30 @@
+# Download Go dependencies
+FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as base
+
+WORKDIR /src
+COPY go.work* ./
+COPY ./rollup/go.* ./rollup/
+COPY ./common/go.* ./common/
+COPY ./coordinator/go.* ./coordinator/
+COPY ./database/go.* ./database/
+COPY ./tests/integration-test/go.* ./tests/integration-test/
+COPY ./bridge-history-api/go.* ./bridge-history-api/
+RUN go mod download -x
+
+# Build blob_uploader
+FROM base as builder
+
+RUN --mount=target=. \
+    --mount=type=cache,target=/root/.cache/go-build \
+    cd /src/rollup/cmd/blob_uploader/ && CGO_LDFLAGS="-ldl" go build -v -p 4 -o /bin/blob_uploader
+
+# Pull blob_uploader into a second stage deploy ubuntu container
+FROM ubuntu:20.04
+
+RUN apt update && apt install vim netcat-openbsd net-tools curl ca-certificates -y
+
+ENV CGO_LDFLAGS="-ldl"
+
+COPY --from=builder /bin/blob_uploader /bin/
+WORKDIR /app
+ENTRYPOINT ["blob_uploader"]

build/dockerfiles/blob_uploader.Dockerfile.dockerignore

@@ -0,0 +1,5 @@
+assets/
+docs/
+l2geth/
+rpc-gateway/
+*target/*

build/dockerfiles/coordinator-api.Dockerfile

@@ -1,5 +1,5 @@
 # Build libzkp dependency
-FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as chef
+FROM scrolltech/cuda-go-rust-builder:cuda-11.7.1-go-1.21-rust-nightly-2023-12-03 as chef
 WORKDIR app
 
 FROM chef as planner
@@ -9,6 +9,12 @@ 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
+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
 RUN cargo chef cook --release --recipe-path recipe.json
 
 COPY ./common/libzkp/impl .
@@ -16,7 +22,7 @@ RUN cargo build --release
 
 
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
+FROM scrolltech/cuda-go-rust-builder:cuda-11.7.1-go-1.21-rust-nightly-2023-12-03 as base
 WORKDIR /src
 COPY go.work* ./
 COPY ./rollup/go.* ./rollup/
@@ -36,7 +42,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 ubuntu:20.04
+FROM nvidia/cuda:11.7.1-runtime-ubuntu22.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

@@ -0,0 +1,17 @@
+#!/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_gpu.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+set -uex
+
+DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" > /dev/null 2>&1 && pwd)
+
+# clone openvm-gpu if not exists
+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

build/dockerfiles/coordinator-api/clone_openvm_stark_gpu.sh

@@ -0,0 +1,10 @@
+#!/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

@@ -0,0 +1,10 @@
+#!/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

@@ -0,0 +1,92 @@
+# openvm
+# same order and features as zkvm-prover/Cargo.toml.gpu
+[patch."ssh://git@github.com/scroll-tech/openvm-gpu.git"]
+openvm = { path = "/openvm-gpu/crates/toolchain/openvm", default-features = false }
+openvm-algebra-complex-macros = { path = "/openvm-gpu/extensions/algebra/complex-macros", default-features = false }
+openvm-algebra-guest = { path = "/openvm-gpu/extensions/algebra/guest", default-features = false }
+openvm-bigint-guest = { path = "/openvm-gpu/extensions/bigint/guest", default-features = false }
+openvm-build = { path = "/openvm-gpu/crates/toolchain/build", default-features = false }
+openvm-circuit = { path = "/openvm-gpu/crates/vm", default-features = false }
+openvm-custom-insn = { path = "/openvm-gpu/crates/toolchain/custom_insn", default-features = false }
+openvm-continuations = { path = "/openvm-gpu/crates/continuations", default-features = false }
+openvm-ecc-guest = { path = "/openvm-gpu/extensions/ecc/guest", default-features = false }
+openvm-instructions ={ path = "/openvm-gpu/crates/toolchain/instructions", default-features = false }
+openvm-keccak256-guest = { path = "/openvm-gpu/extensions/keccak256/guest", default-features = false }
+openvm-native-circuit = { path = "/openvm-gpu/extensions/native/circuit", default-features = false }
+openvm-native-compiler = { path = "/openvm-gpu/extensions/native/compiler", default-features = false }
+openvm-native-recursion = { path = "/openvm-gpu/extensions/native/recursion", default-features = false }
+openvm-native-transpiler = { path = "/openvm-gpu/extensions/native/transpiler", default-features = false }
+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-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/gitconfig

@@ -0,0 +1,2 @@
+[url "https://github.com/"]
+	insteadOf = ssh://git@github.com/

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.Debug("gorm", "line", utils.FileWithLineNum(), "cost", elapsed, "sql", sql, "rowsAffected", rowsAffected, "err", err)
+	g.gethLogger.Trace("gorm", "line", utils.FileWithLineNum(), "cost", elapsed, "sql", sql, "rowsAffected", rowsAffected, "err", err)
 }
 
 // InitDB init the db handler

common/libzkp/impl/Cargo.toml

@@ -14,8 +14,8 @@ 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.2.0", package = "scroll-zkvm-prover" }
-euclid_verifier = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.2.0", package = "scroll-zkvm-verifier" }
+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" }
 
 base64 = "0.13.0"
 env_logger = "0.9.0"
@@ -32,3 +32,35 @@ 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/lib.rs

@@ -26,12 +26,6 @@ pub unsafe extern "C" fn verify_chunk_proof(
 
 fn verify_proof(proof: *const c_char, fork_name: *const c_char, task_type: TaskType) -> c_char {
     let fork_name_str = c_char_to_str(fork_name);
-    // Skip verification for darwinV2 as we can't host darwinV2 and euclid verifiers on the same
-    // binary.
-    if fork_name_str == "darwinV2" {
-        return true as c_char;
-    }
-
     let proof = c_char_to_vec(proof);
     let verifier = verifier::get_verifier(fork_name_str);
 

common/libzkp/impl/src/verifier.rs

@@ -1,10 +1,7 @@
 #![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};
@@ -31,39 +28,25 @@ 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(
-                "euclidV2".to_string(),
+                config.high_version_circuit.fork_name,
                 Rc::new(Box::new(verifier)),
             ))
             .unwrap_unchecked();
@@ -72,12 +55,6 @@ 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

@@ -1,65 +0,0 @@
-use super::{ProofVerifier, TaskType, VKDump};
-
-use anyhow::Result;
-
-use crate::utils::panic_catch;
-use euclid_prover::{BatchProof, BundleProof, ChunkProof};
-use euclid_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) {
-        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()),
-        };
-        serde_json::to_writer(f, &dump).expect("Failed to dump VK");
-    }
-}

common/types/db.go

@@ -276,8 +276,8 @@ const (
 	SenderTypeFinalizeBatch
 	// SenderTypeL1GasOracle indicates a sender from L2 responsible for updating L1 gas prices.
 	SenderTypeL1GasOracle
-	// SenderTypeL2GasOracle indicates a sender from L1 responsible for updating L2 gas prices.
-	SenderTypeL2GasOracle
+	// SenderTypeL2GasOracleDeprecated indicates a sender from L1 responsible for updating L2 gas prices, which is deprecated.
+	SenderTypeL2GasOracleDeprecated
 )
 
 // String returns a string representation of the SenderType.
@@ -289,8 +289,8 @@ func (t SenderType) String() string {
 		return "SenderTypeFinalizeBatch"
 	case SenderTypeL1GasOracle:
 		return "SenderTypeL1GasOracle"
-	case SenderTypeL2GasOracle:
-		return "SenderTypeL2GasOracle"
+	case SenderTypeL2GasOracleDeprecated:
+		return "SenderTypeL2GasOracleDeprecated"
 	default:
 		return fmt.Sprintf("Unknown SenderType (%d)", int32(t))
 	}
@@ -326,3 +326,53 @@ func (s TxStatus) String() string {
 		return fmt.Sprintf("Unknown TxStatus (%d)", int32(s))
 	}
 }
+
+// BlobUploadStatus represents the status of a blob upload
+type BlobUploadStatus int
+
+const (
+	// BlobUploadStatusUndefined indicates an undefined status
+	BlobUploadStatusUndefined BlobUploadStatus = iota
+	// BlobUploadStatusPending indicates a pending upload status
+	BlobUploadStatusPending
+	// BlobUploadStatusUploaded indicates a successful upload status
+	BlobUploadStatusUploaded
+	// BlobUploadStatusFailed indicates a failed upload status
+	BlobUploadStatusFailed
+)
+
+func (s BlobUploadStatus) String() string {
+	switch s {
+	case BlobUploadStatusPending:
+		return "BlobUploadStatusPending"
+	case BlobUploadStatusUploaded:
+		return "BlobUploadStatusUploaded"
+	case BlobUploadStatusFailed:
+		return "BlobUploadStatusFailed"
+	default:
+		return fmt.Sprintf("Unknown BlobUploadStatus (%d)", int32(s))
+	}
+}
+
+// BlobStoragePlatform represents the platform a blob upload to
+type BlobStoragePlatform int
+
+const (
+	// BlobStoragePlatformUndefined indicates an undefined platform
+	BlobStoragePlatformUndefined BlobStoragePlatform = iota
+	// BlobStoragePlatformS3 represents AWS S3
+	BlobStoragePlatformS3
+	// BlobStoragePlatformArweave represents storage blockchain Arweave
+	BlobStoragePlatformArweave
+)
+
+func (s BlobStoragePlatform) String() string {
+	switch s {
+	case BlobStoragePlatformS3:
+		return "BlobStoragePlatformS3"
+	case BlobStoragePlatformArweave:
+		return "BlobStoragePlatformArweave"
+	default:
+		return fmt.Sprintf("Unknown BlobStoragePlatform (%d)", int32(s))
+	}
+}

common/types/db_test.go

@@ -173,9 +173,9 @@ func TestSenderType(t *testing.T) {
 			"SenderTypeL1GasOracle",
 		},
 		{
-			"SenderTypeL2GasOracle",
-			SenderTypeL2GasOracle,
-			"SenderTypeL2GasOracle",
+			"SenderTypeL2GasOracleDeprecated",
+			SenderTypeL2GasOracleDeprecated,
+			"SenderTypeL2GasOracleDeprecated",
 		},
 		{
 			"Invalid Value",

common/types/message/message.go

@@ -11,10 +11,8 @@ import (
 )
 
 const (
-	EuclidFork   = "euclid"
 	EuclidV2Fork = "euclidV2"
 
-	EuclidForkNameForProver   = "euclidv1"
 	EuclidV2ForkNameForProver = "euclidv2"
 )
 
@@ -47,7 +45,7 @@ const (
 
 // ChunkTaskDetail is a type containing ChunkTask detail for chunk task.
 type ChunkTaskDetail struct {
-	// use one of the string of EuclidFork / EuclidV2Fork
+	// use one of the string of "euclidv1" / "euclidv2"
 	ForkName         string        `json:"fork_name"`
 	BlockHashes      []common.Hash `json:"block_hashes"`
 	PrevMsgQueueHash common.Hash   `json:"prev_msg_queue_hash"`
@@ -98,23 +96,23 @@ func (e *Byte48) UnmarshalJSON(input []byte) error {
 
 // BatchTaskDetail is a type containing BatchTask detail.
 type BatchTaskDetail struct {
-	// use one of the string of EuclidFork / EuclidV2Fork
-	ForkName        string       `json:"fork_name"`
-	ChunkInfos      []*ChunkInfo `json:"chunk_infos"`
-	ChunkProofs     []ChunkProof `json:"chunk_proofs"`
-	BatchHeader     interface{}  `json:"batch_header"`
-	BlobBytes       []byte       `json:"blob_bytes"`
-	KzgProof        Byte48       `json:"kzg_proof,omitempty"`
-	KzgCommitment   Byte48       `json:"kzg_commitment,omitempty"`
-	ChallengeDigest common.Hash  `json:"challenge_digest,omitempty"`
+	// use one of the string of "euclidv1" / "euclidv2"
+	ForkName        string              `json:"fork_name"`
+	ChunkInfos      []*ChunkInfo        `json:"chunk_infos"`
+	ChunkProofs     []*OpenVMChunkProof `json:"chunk_proofs"`
+	BatchHeader     interface{}         `json:"batch_header"`
+	BlobBytes       []byte              `json:"blob_bytes"`
+	KzgProof        Byte48              `json:"kzg_proof,omitempty"`
+	KzgCommitment   Byte48              `json:"kzg_commitment,omitempty"`
+	ChallengeDigest common.Hash         `json:"challenge_digest,omitempty"`
 }
 
 // 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 EuclidFork / EuclidV2Fork
-	ForkName    string            `json:"fork_name"`
-	BatchProofs []BatchProof      `json:"batch_proofs"`
-	BundleInfo  *OpenVMBundleInfo `json:"bundle_info,omitempty"`
+	// use one of the string of "euclidv1" / "euclidv2"
+	ForkName    string              `json:"fork_name"`
+	BatchProofs []*OpenVMBatchProof `json:"batch_proofs"`
+	BundleInfo  *OpenVMBundleInfo   `json:"bundle_info,omitempty"`
 }
 
 // ChunkInfo is for calculating pi_hash for chunk
@@ -143,157 +141,6 @@ type BlockContextV2 struct {
 	NumL1Msgs uint16      `json:"num_l1_msgs"`
 }
 
-// SubCircuitRowUsage tracing info added in v0.11.0rc8
-type SubCircuitRowUsage struct {
-	Name      string `json:"name"`
-	RowNumber uint64 `json:"row_number"`
-}
-
-// ChunkProof
-type ChunkProof interface {
-	Proof() []byte
-}
-
-// NewChunkProof creates a new ChunkProof instance.
-func NewChunkProof(hardForkName string) ChunkProof {
-	switch hardForkName {
-	case EuclidFork, EuclidV2Fork:
-		return &OpenVMChunkProof{}
-	default:
-		return &Halo2ChunkProof{}
-	}
-}
-
-// Halo2ChunkProof includes the proof info that are required for chunk verification and rollup.
-type Halo2ChunkProof struct {
-	StorageTrace []byte `json:"storage_trace,omitempty"`
-	Protocol     []byte `json:"protocol"`
-	RawProof     []byte `json:"proof"`
-	Instances    []byte `json:"instances"`
-	Vk           []byte `json:"vk"`
-	// cross-reference between cooridinator computation and prover compution
-	ChunkInfo  *ChunkInfo           `json:"chunk_info,omitempty"`
-	GitVersion string               `json:"git_version,omitempty"`
-	RowUsages  []SubCircuitRowUsage `json:"row_usages,omitempty"`
-}
-
-// Proof returns the proof bytes of a ChunkProof
-func (ap *Halo2ChunkProof) Proof() []byte {
-	return ap.RawProof
-}
-
-// BatchProof
-type BatchProof interface {
-	SanityCheck() error
-	Proof() []byte
-}
-
-// NewBatchProof creates a new BatchProof instance.
-func NewBatchProof(hardForkName string) BatchProof {
-	switch hardForkName {
-	case EuclidFork, EuclidV2Fork:
-		return &OpenVMBatchProof{}
-	default:
-		return &Halo2BatchProof{}
-	}
-}
-
-// Halo2BatchProof includes the proof info that are required for batch verification and rollup.
-type Halo2BatchProof struct {
-	Protocol  []byte `json:"protocol"`
-	RawProof  []byte `json:"proof"`
-	Instances []byte `json:"instances"`
-	Vk        []byte `json:"vk"`
-	// cross-reference between cooridinator computation and prover compution
-	BatchHash  common.Hash `json:"batch_hash"`
-	GitVersion string      `json:"git_version,omitempty"`
-}
-
-// Proof returns the proof bytes of a BatchProof
-func (ap *Halo2BatchProof) Proof() []byte {
-	return ap.RawProof
-}
-
-// SanityCheck checks whether a BatchProof is in a legal format
-func (ap *Halo2BatchProof) SanityCheck() error {
-	if ap == nil {
-		return errors.New("agg_proof is nil")
-	}
-
-	if len(ap.RawProof) == 0 {
-		return errors.New("proof not ready")
-	}
-
-	if len(ap.RawProof)%32 != 0 {
-		return fmt.Errorf("proof buffer length must be a multiple of 32, got: %d", len(ap.RawProof))
-	}
-
-	if len(ap.Instances) == 0 {
-		return errors.New("instance not ready")
-	}
-
-	if len(ap.Vk) == 0 {
-		return errors.New("vk not ready")
-	}
-
-	return nil
-}
-
-// BundleProof
-type BundleProof interface {
-	SanityCheck() error
-	Proof() []byte
-}
-
-// NewBundleProof creates a new BundleProof instance.
-func NewBundleProof(hardForkName string) BundleProof {
-	switch hardForkName {
-	case EuclidFork, EuclidV2Fork:
-		return &OpenVMBundleProof{}
-	default:
-		return &Halo2BundleProof{}
-	}
-}
-
-// BundleProof includes the proof info that are required for verification of a bundle of batch proofs.
-type Halo2BundleProof struct {
-	RawProof  []byte `json:"proof"`
-	Instances []byte `json:"instances"`
-	Vk        []byte `json:"vk"`
-	// cross-reference between cooridinator computation and prover compution
-	GitVersion string `json:"git_version,omitempty"`
-}
-
-// Proof returns the proof bytes of a BundleProof
-func (ap *Halo2BundleProof) Proof() []byte {
-	return ap.RawProof
-}
-
-// SanityCheck checks whether a BundleProof is in a legal format
-func (ap *Halo2BundleProof) SanityCheck() error {
-	if ap == nil {
-		return errors.New("agg_proof is nil")
-	}
-
-	if len(ap.RawProof) == 0 {
-		return errors.New("proof not ready")
-	}
-
-	if len(ap.RawProof)%32 != 0 {
-		return fmt.Errorf("proof buffer length must be a multiple of 32, got: %d", len(ap.RawProof))
-	}
-
-	if len(ap.Instances) == 0 {
-		return errors.New("instance not ready")
-	}
-
-	if len(ap.Vk) == 0 {
-		return errors.New("vk not ready")
-	}
-
-	return nil
-}
-
 // Proof for flatten VM proof
 type OpenVMProof struct {
 	Proof        []byte `json:"proofs"`

common/utils/blob.go

@@ -0,0 +1,23 @@
+package utils
+
+import (
+	"crypto/sha256"
+	"fmt"
+
+	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
+)
+
+// CalculateVersionedBlobHash calculate the kzg4844 versioned blob hash from a blob
+func CalculateVersionedBlobHash(blob kzg4844.Blob) ([32]byte, error) {
+	// calculate kzg4844 commitment from blob
+	commit, err := kzg4844.BlobToCommitment(&blob)
+	if err != nil {
+		return [32]byte{}, fmt.Errorf("failed to get blob commitment, err: %w", err)
+	}
+
+	// calculate kzg4844 versioned blob hash from blob commitment
+	hasher := sha256.New()
+	vh := kzg4844.CalcBlobHashV1(hasher, &commit)
+
+	return vh, nil
+}

common/utils/blob_test.go

@@ -0,0 +1,51 @@
+package utils
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"os"
+	"testing"
+
+	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
+)
+
+type BlobData struct {
+	VersionedBlobHash string `json:"versionedBlobHash"`
+	BlobData          string `json:"blobData"`
+}
+
+// TestCalculateVersionedBlobHash tests the CalculateVersionedBlobHash function
+func TestCalculateVersionedBlobHash(t *testing.T) {
+	// Read the test data
+	data, err := os.ReadFile("../testdata/blobdata.json")
+	if err != nil {
+		t.Fatalf("Failed to read blobdata.json: %v", err)
+	}
+
+	var blobData BlobData
+	if err := json.Unmarshal(data, &blobData); err != nil {
+		t.Fatalf("Failed to parse blobdata.json: %v", err)
+	}
+
+	blobBytes, err := hex.DecodeString(blobData.BlobData)
+	if err != nil {
+		t.Fatalf("Failed to decode blob data: %v", err)
+	}
+
+	// Convert []byte to kzg4844.Blob
+	var blob kzg4844.Blob
+	copy(blob[:], blobBytes)
+
+	// Calculate the hash
+	calculatedHashBytes, err := CalculateVersionedBlobHash(blob)
+	if err != nil {
+		t.Fatalf("Failed to calculate versioned blob hash: %v", err)
+	}
+
+	calculatedHash := hex.EncodeToString(calculatedHashBytes[:])
+
+	if calculatedHash != blobData.VersionedBlobHash {
+		t.Fatalf("Hash mismatch: got %s, want %s", calculatedHash, blobData.VersionedBlobHash)
+	}
+
+}

common/utils/flags.go

@@ -20,9 +20,12 @@ var (
 	}
 	// RollupRelayerFlags contains flags only used in rollup-relayer
 	RollupRelayerFlags = []cli.Flag{
-		&ImportGenesisFlag,
 		&MinCodecVersionFlag,
 	}
+	// ProposerToolFlags contains flags only used in proposer tool
+	ProposerToolFlags = []cli.Flag{
+		&StartL2BlockFlag,
+	}
 	// ConfigFileFlag load json type config file.
 	ConfigFileFlag = cli.StringFlag{
 		Name:  "config",
@@ -73,12 +76,6 @@ var (
 		Category: "METRICS",
 		Value:    6060,
 	}
-	// ImportGenesisFlag import genesis batch during startup
-	ImportGenesisFlag = cli.BoolFlag{
-		Name:  "import-genesis",
-		Usage: "Import genesis batch into L1 contract during startup",
-		Value: false,
-	}
 	// ServicePortFlag is the port the service will listen on
 	ServicePortFlag = cli.IntFlag{
 		Name:  "service.port",
@@ -97,4 +94,10 @@ var (
 		Usage:    "Minimum required codec version for the chunk/batch/bundle proposers",
 		Required: true,
 	}
+	// StartL2BlockFlag indicates the start L2 block number for proposer tool
+	StartL2BlockFlag = cli.Uint64Flag{
+		Name:  "start-l2-block",
+		Usage: "Start L2 block number for proposer tool",
+		Value: 0,
+	}
 )

common/version/version.go

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

coordinator/cmd/api/app/mock_app.go

@@ -90,18 +90,10 @@ func (c *CoordinatorApp) MockConfig(store bool) error {
 	cfg.ProverManager = &coordinatorConfig.ProverManager{
 		ProversPerSession: 1,
 		Verifier: &coordinatorConfig.VerifierConfig{
-			MockMode: true,
-			LowVersionCircuit: &coordinatorConfig.CircuitConfig{
-				ParamsPath:       "",
-				AssetsPath:       "",
-				ForkName:         "darwin",
-				MinProverVersion: "v4.2.0",
-			},
 			HighVersionCircuit: &coordinatorConfig.CircuitConfig{
-				ParamsPath:       "",
 				AssetsPath:       "",
-				ForkName:         "darwinV2",
-				MinProverVersion: "v4.3.0",
+				ForkName:         "euclidV2",
+				MinProverVersion: "v4.4.89",
 			},
 		},
 		BatchCollectionTimeSec: 60,

coordinator/cmd/tool/tool.go

@@ -62,14 +62,14 @@ func action(ctx *cli.Context) error {
 		return fmt.Errorf("failed to get batch proofs for bundle task id:%s, no batch found", taskID)
 	}
 
-	var batchProofs []message.BatchProof
+	var batchProofs []*message.OpenVMBatchProof
 	for _, batch := range batches {
-		proof := message.NewBatchProof("darwinV2")
+		var proof message.OpenVMBatchProof
 		if encodeErr := json.Unmarshal(batch.Proof, &proof); encodeErr != nil {
 			log.Error("failed to unmarshal batch proof")
 			return fmt.Errorf("failed to unmarshal proof: %w, bundle hash: %v, batch hash: %v", encodeErr, taskID, batch.Hash)
 		}
-		batchProofs = append(batchProofs, proof)
+		batchProofs = append(batchProofs, &proof)
 	}
 
 	taskDetail := message.BundleTaskDetail{

coordinator/conf/config.json

@@ -7,17 +7,9 @@
     "batch_collection_time_sec": 180,
     "chunk_collection_time_sec": 180,
     "verifier": {
-      "mock_mode": true,
-      "low_version_circuit": {
-        "params_path": "params",
-        "assets_path": "assets",
-        "fork_name": "darwin",
-        "min_prover_version": "v4.4.43"
-      },
       "high_version_circuit": {
-        "params_path": "params",
         "assets_path": "assets",
-        "fork_name": "darwinV2",
+        "fork_name": "euclidV2",
         "min_prover_version": "v4.4.45"
       }
     }

coordinator/internal/config/config.go

@@ -51,7 +51,6 @@ type Config struct {
 
 // CircuitConfig circuit items.
 type CircuitConfig struct {
-	ParamsPath       string `json:"params_path"`
 	AssetsPath       string `json:"assets_path"`
 	ForkName         string `json:"fork_name"`
 	MinProverVersion string `json:"min_prover_version"`
@@ -59,8 +58,6 @@ type CircuitConfig struct {
 
 // VerifierConfig load zk verifier config.
 type VerifierConfig struct {
-	MockMode           bool           `json:"mock_mode"`
-	LowVersionCircuit  *CircuitConfig `json:"low_version_circuit"`
 	HighVersionCircuit *CircuitConfig `json:"high_version_circuit"`
 }
 

coordinator/internal/config/config_test.go

@@ -15,15 +15,18 @@ func TestConfig(t *testing.T) {
 		"prover_manager": {
 			"provers_per_session": 1,
 			"session_attempts": 5,
+			"external_prover_threshold": 32,
+			"bundle_collection_time_sec": 180,
 			"batch_collection_time_sec": 180,
 			"chunk_collection_time_sec": 180,
 			"verifier": {
-				"mock_mode": true,
-				"params_path": "",
-				"agg_vk_path": ""
+				"high_version_circuit": {
+					"assets_path": "assets",
+					"fork_name": "euclidV2",
+					"min_prover_version": "v4.4.45"
+				}
 			},
-			"max_verifier_workers": 4,
-			"min_prover_version": "v1.0.0"
+			"max_verifier_workers": 4
 		},
 		"db": {
 			"driver_name": "postgres",

coordinator/internal/controller/api/controller.go

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

coordinator/internal/logic/auth/login.go

@@ -9,7 +9,6 @@ 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"
@@ -22,9 +21,6 @@ import (
 type LoginLogic struct {
 	cfg          *config.Config
 	challengeOrm *orm.Challenge
-	chunkVks     map[string]struct{}
-	batchVKs     map[string]struct{}
-	bundleVks    map[string]struct{}
 
 	openVmVks map[string]struct{}
 
@@ -34,28 +30,13 @@ type LoginLogic struct {
 // NewLoginLogic new a LoginLogic
 func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *LoginLogic {
 	proverVersionHardForkMap := make(map[string][]string)
-	if version.CheckScrollRepoVersion(cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion) {
-		log.Error("config file error, low verifier min_prover_version should not more than high verifier min_prover_version",
-			"low verifier min_prover_version", cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion,
-			"high verifier min_prover_version", cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion)
-		panic("verifier config file error")
-	}
 
 	var highHardForks []string
 	highHardForks = append(highHardForks, cfg.ProverManager.Verifier.HighVersionCircuit.ForkName)
-	if cfg.ProverManager.Verifier.HighVersionCircuit.ForkName != message.EuclidFork && cfg.ProverManager.Verifier.HighVersionCircuit.ForkName != message.EuclidV2Fork {
-		highHardForks = append(highHardForks, cfg.ProverManager.Verifier.LowVersionCircuit.ForkName)
-	}
-	highHardForks = append(highHardForks, message.EuclidFork, message.EuclidV2Fork)
 	proverVersionHardForkMap[cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion] = highHardForks
 
-	proverVersionHardForkMap[cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion] = []string{cfg.ProverManager.Verifier.LowVersionCircuit.ForkName}
-
 	return &LoginLogic{
 		cfg:                      cfg,
-		chunkVks:                 vf.ChunkVKMap,
-		batchVKs:                 vf.BatchVKMap,
-		bundleVks:                vf.BundleVkMap,
 		openVmVks:                vf.OpenVMVkMap,
 		challengeOrm:             orm.NewChallenge(db),
 		proverVersionHardForkMap: proverVersionHardForkMap,
@@ -75,46 +56,25 @@ func (l *LoginLogic) Check(login *types.LoginParameter) error {
 		return errors.New("auth message verify failure")
 	}
 
-	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion) {
-		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s",
-			l.cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, login.Message.ProverVersion)
+	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion) {
+		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", l.cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion, login.Message.ProverVersion)
 	}
 
-	if len(login.Message.ProverTypes) > 0 {
-		vks := make(map[string]struct{})
-		for _, proverType := range login.Message.ProverTypes {
-			switch proverType {
-			case types.ProverTypeChunk:
-				for vk := range l.chunkVks {
-					vks[vk] = struct{}{}
-				}
-			case types.ProverTypeBatch:
-				for vk := range l.batchVKs {
-					vks[vk] = struct{}{}
-				}
-				for vk := range l.bundleVks {
-					vks[vk] = struct{}{}
-				}
-			case types.ProverTypeOpenVM:
-				for vk := range l.openVmVks {
-					vks[vk] = struct{}{}
-				}
-			default:
-				log.Error("invalid prover_type", "value", proverType, "prover name", login.Message.ProverName, "prover_version", login.Message.ProverVersion)
-			}
-		}
+	vks := make(map[string]struct{})
+	for vk := range l.openVmVks {
+		vks[vk] = struct{}{}
+	}
 
-		for _, vk := range login.Message.VKs {
-			if _, ok := vks[vk]; !ok {
-				log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
-					"prover_version", login.Message.ProverVersion, "message", login.Message)
-				if !version.CheckScrollProverVersion(login.Message.ProverVersion) {
-					return fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s",
-						version.Version, login.Message.ProverVersion)
-				}
-				// if the prover reports a same prover version
-				return errors.New("incompatible vk. please check your params files or config files")
+	for _, vk := range login.Message.VKs {
+		if _, ok := vks[vk]; !ok {
+			log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
+				"prover_version", login.Message.ProverVersion, "message", login.Message)
+			if !version.CheckScrollProverVersion(login.Message.ProverVersion) {
+				return fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s",
+					version.Version, login.Message.ProverVersion)
 			}
+			// if the prover reports a same prover version
+			return errors.New("incompatible vk. please check your params files or config files")
 		}
 	}
 

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -197,34 +197,27 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		return nil, fmt.Errorf("no chunk found for batch task id:%s", task.TaskID)
 	}
 
-	var chunkProofs []message.ChunkProof
+	var chunkProofs []*message.OpenVMChunkProof
 	var chunkInfos []*message.ChunkInfo
 	for _, chunk := range chunks {
-		proof := message.NewChunkProof(hardForkName)
+		var proof message.OpenVMChunkProof
 		if encodeErr := json.Unmarshal(chunk.Proof, &proof); encodeErr != nil {
 			return nil, fmt.Errorf("Chunk.GetProofsByBatchHash unmarshal proof error: %w, batch hash: %v, chunk hash: %v", encodeErr, task.TaskID, chunk.Hash)
 		}
-		chunkProofs = append(chunkProofs, proof)
+		chunkProofs = append(chunkProofs, &proof)
 
 		chunkInfo := message.ChunkInfo{
-			ChainID:          bp.cfg.L2.ChainID,
-			PrevStateRoot:    common.HexToHash(chunk.ParentChunkStateRoot),
-			PostStateRoot:    common.HexToHash(chunk.StateRoot),
-			WithdrawRoot:     common.HexToHash(chunk.WithdrawRoot),
-			DataHash:         common.HexToHash(chunk.Hash),
-			PrevMsgQueueHash: common.HexToHash(chunk.PrevL1MessageQueueHash),
-			PostMsgQueueHash: common.HexToHash(chunk.PostL1MessageQueueHash),
-			IsPadding:        false,
-		}
-		if halo2Proof, ok := proof.(*message.Halo2ChunkProof); ok {
-			if halo2Proof.ChunkInfo != nil {
-				chunkInfo.TxBytes = halo2Proof.ChunkInfo.TxBytes
-			}
-		}
-		if openvmProof, ok := proof.(*message.OpenVMChunkProof); ok {
-			chunkInfo.InitialBlockNumber = openvmProof.MetaData.ChunkInfo.InitialBlockNumber
-			chunkInfo.BlockCtxs = openvmProof.MetaData.ChunkInfo.BlockCtxs
-			chunkInfo.TxDataLength = openvmProof.MetaData.ChunkInfo.TxDataLength
+			ChainID:            bp.cfg.L2.ChainID,
+			PrevStateRoot:      common.HexToHash(chunk.ParentChunkStateRoot),
+			PostStateRoot:      common.HexToHash(chunk.StateRoot),
+			WithdrawRoot:       common.HexToHash(chunk.WithdrawRoot),
+			DataHash:           common.HexToHash(chunk.Hash),
+			PrevMsgQueueHash:   common.HexToHash(chunk.PrevL1MessageQueueHash),
+			PostMsgQueueHash:   common.HexToHash(chunk.PostL1MessageQueueHash),
+			IsPadding:          false,
+			InitialBlockNumber: proof.MetaData.ChunkInfo.InitialBlockNumber,
+			BlockCtxs:          proof.MetaData.ChunkInfo.BlockCtxs,
+			TxDataLength:       proof.MetaData.ChunkInfo.TxDataLength,
 		}
 		chunkInfos = append(chunkInfos, &chunkInfo)
 	}
@@ -258,7 +251,7 @@ func (bp *BatchProverTask) recoverActiveAttempts(ctx *gin.Context, batchTask *or
 	}
 }
 
-func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*message.ChunkInfo, chunkProofs []message.ChunkProof, hardForkName string) (*message.BatchTaskDetail, error) {
+func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*message.ChunkInfo, chunkProofs []*message.OpenVMChunkProof, hardForkName string) (*message.BatchTaskDetail, error) {
 	taskDetail := &message.BatchTaskDetail{
 		ChunkInfos:  chunkInfos,
 		ChunkProofs: chunkProofs,
@@ -266,8 +259,9 @@ func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*
 
 	if hardForkName == message.EuclidV2Fork {
 		taskDetail.ForkName = message.EuclidV2ForkNameForProver
-	} else if hardForkName == message.EuclidFork {
-		taskDetail.ForkName = message.EuclidForkNameForProver
+	} else {
+		log.Error("unsupported hard fork name", "hard_fork_name", hardForkName)
+		return nil, fmt.Errorf("unsupported hard fork name: %s", hardForkName)
 	}
 
 	dbBatchCodecVersion := encoding.CodecVersion(dbBatch.CodecVersion)

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -200,13 +200,13 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 		return nil, fmt.Errorf("failed to get parent batch for batch task id:%s err:%w", task.TaskID, err)
 	}
 
-	var batchProofs []message.BatchProof
+	var batchProofs []*message.OpenVMBatchProof
 	for _, batch := range batches {
-		proof := message.NewBatchProof(hardForkName)
+		var proof message.OpenVMBatchProof
 		if encodeErr := json.Unmarshal(batch.Proof, &proof); encodeErr != nil {
 			return nil, fmt.Errorf("failed to unmarshal proof: %w, bundle hash: %v, batch hash: %v", encodeErr, task.TaskID, batch.Hash)
 		}
-		batchProofs = append(batchProofs, proof)
+		batchProofs = append(batchProofs, &proof)
 	}
 
 	taskDetail := message.BundleTaskDetail{
@@ -215,8 +215,9 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 
 	if hardForkName == message.EuclidV2Fork {
 		taskDetail.ForkName = message.EuclidV2ForkNameForProver
-	} else if hardForkName == message.EuclidFork {
-		taskDetail.ForkName = message.EuclidForkNameForProver
+	} else {
+		log.Error("unsupported hard fork name", "hard_fork_name", hardForkName)
+		return nil, fmt.Errorf("unsupported hard fork name: %s", hardForkName)
 	}
 
 	taskDetail.BundleInfo = &message.OpenVMBundleInfo{
@@ -227,10 +228,7 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 		NumBatches:    uint32(len(batches)),
 		PrevBatchHash: common.HexToHash(batches[0].ParentBatchHash),
 		BatchHash:     common.HexToHash(batches[len(batches)-1].Hash),
-	}
-
-	if hardForkName == message.EuclidV2Fork {
-		taskDetail.BundleInfo.MsgQueueHash = common.HexToHash(batches[len(batches)-1].PostL1MessageQueueHash)
+		MsgQueueHash:  common.HexToHash(batches[len(batches)-1].PostL1MessageQueueHash),
 	}
 
 	batchProofsBytes, err := json.Marshal(taskDetail)

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -195,8 +195,9 @@ func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 
 	if hardForkName == message.EuclidV2Fork {
 		taskDetail.ForkName = message.EuclidV2ForkNameForProver
-	} else if hardForkName == message.EuclidFork {
-		taskDetail.ForkName = message.EuclidForkNameForProver
+	} else {
+		log.Error("unsupported hard fork name", "hard_fork_name", hardForkName)
+		return nil, fmt.Errorf("unsupported hard fork name: %s", hardForkName)
 	}
 
 	var err error

coordinator/internal/logic/submitproof/proof_receiver.go

@@ -171,19 +171,19 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 
 	switch message.ProofType(proofParameter.TaskType) {
 	case message.ProofTypeChunk:
-		chunkProof := message.NewChunkProof(hardForkName)
+		chunkProof := &message.OpenVMChunkProof{}
 		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &chunkProof); unmarshalErr != nil {
 			return unmarshalErr
 		}
 		success, verifyErr = m.verifier.VerifyChunkProof(chunkProof, hardForkName)
 	case message.ProofTypeBatch:
-		batchProof := message.NewBatchProof(hardForkName)
+		batchProof := &message.OpenVMBatchProof{}
 		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &batchProof); unmarshalErr != nil {
 			return unmarshalErr
 		}
 		success, verifyErr = m.verifier.VerifyBatchProof(batchProof, hardForkName)
 	case message.ProofTypeBundle:
-		bundleProof := message.NewBundleProof(hardForkName)
+		bundleProof := &message.OpenVMBundleProof{}
 		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &bundleProof); unmarshalErr != nil {
 			return unmarshalErr
 		}

coordinator/internal/logic/verifier/mock.go

@@ -10,31 +10,26 @@ import (
 
 // NewVerifier Sets up a mock verifier.
 func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
-	batchVKMap := map[string]struct{}{"mock_vk": {}}
-	chunkVKMap := map[string]struct{}{"mock_vk": {}}
-	return &Verifier{cfg: cfg, ChunkVKMap: chunkVKMap, BatchVKMap: batchVKMap}, nil
+	return &Verifier{cfg: cfg, OpenVMVkMap: map[string]struct{}{"mock_vk": {}}}, nil
 }
 
 // VerifyChunkProof return a mock verification result for a ChunkProof.
-func (v *Verifier) VerifyChunkProof(proof message.ChunkProof, forkName string) (bool, error) {
-	if string(proof.Proof()) == InvalidTestProof {
+func (v *Verifier) VerifyChunkProof(proof *message.OpenVMChunkProof, forkName string) (bool, error) {
+	if proof.VmProof != nil && string(proof.VmProof.Proof) == InvalidTestProof {
 		return false, nil
 	}
 	return true, nil
 }
 
 // VerifyBatchProof return a mock verification result for a BatchProof.
-func (v *Verifier) VerifyBatchProof(proof message.BatchProof, forkName string) (bool, error) {
-	if string(proof.Proof()) == InvalidTestProof {
+func (v *Verifier) VerifyBatchProof(proof *message.OpenVMBatchProof, forkName string) (bool, error) {
+	if proof.VmProof != nil && string(proof.VmProof.Proof) == InvalidTestProof {
 		return false, nil
 	}
 	return true, nil
 }
 
 // VerifyBundleProof return a mock verification result for a BundleProof.
-func (v *Verifier) VerifyBundleProof(proof message.BundleProof, forkName string) (bool, error) {
-	if string(proof.Proof()) == InvalidTestProof {
-		return false, nil
-	}
+func (v *Verifier) VerifyBundleProof(proof *message.OpenVMBundleProof, forkName string) (bool, error) {
 	return true, nil
 }

coordinator/internal/logic/verifier/types.go

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

coordinator/internal/logic/verifier/verifier.go

@@ -30,14 +30,12 @@ import (
 // in `*config.CircuitConfig` being changed
 type rustCircuitConfig struct {
 	ForkName   string `json:"fork_name"`
-	ParamsPath string `json:"params_path"`
 	AssetsPath string `json:"assets_path"`
 }
 
 func newRustCircuitConfig(cfg *config.CircuitConfig) *rustCircuitConfig {
 	return &rustCircuitConfig{
 		ForkName:   cfg.ForkName,
-		ParamsPath: cfg.ParamsPath,
 		AssetsPath: cfg.AssetsPath,
 	}
 }
@@ -46,13 +44,11 @@ func newRustCircuitConfig(cfg *config.CircuitConfig) *rustCircuitConfig {
 // Define a brand new struct here is to eliminate side effects in case fields
 // in `*config.VerifierConfig` being changed
 type rustVerifierConfig struct {
-	LowVersionCircuit  *rustCircuitConfig `json:"low_version_circuit"`
 	HighVersionCircuit *rustCircuitConfig `json:"high_version_circuit"`
 }
 
 func newRustVerifierConfig(cfg *config.VerifierConfig) *rustVerifierConfig {
 	return &rustVerifierConfig{
-		LowVersionCircuit:  newRustCircuitConfig(cfg.LowVersionCircuit),
 		HighVersionCircuit: newRustCircuitConfig(cfg.HighVersionCircuit),
 	}
 }
@@ -65,19 +61,6 @@ type rustVkDump struct {
 
 // NewVerifier Sets up a rust ffi to call verify.
 func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
-	if cfg.MockMode {
-		chunkVKMap := map[string]struct{}{"mock_vk": {}}
-		batchVKMap := map[string]struct{}{"mock_vk": {}}
-		bundleVKMap := map[string]struct{}{"mock_vk": {}}
-		openVMVkMap := map[string]struct{}{"mock_vk": {}}
-		return &Verifier{
-			cfg:         cfg,
-			ChunkVKMap:  chunkVKMap,
-			BatchVKMap:  batchVKMap,
-			BundleVkMap: bundleVKMap,
-			OpenVMVkMap: openVMVkMap,
-		}, nil
-	}
 	verifierConfig := newRustVerifierConfig(cfg)
 	configBytes, err := json.Marshal(verifierConfig)
 	if err != nil {
@@ -93,39 +76,18 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 
 	v := &Verifier{
 		cfg:         cfg,
-		ChunkVKMap:  make(map[string]struct{}),
-		BatchVKMap:  make(map[string]struct{}),
-		BundleVkMap: make(map[string]struct{}),
 		OpenVMVkMap: make(map[string]struct{}),
 	}
 
-	if err := v.loadLowVersionVKs(cfg); err != nil {
-		return nil, err
-	}
-
-	if err := v.loadOpenVMVks(message.EuclidFork); err != nil {
-		return nil, err
-	}
-
 	if err := v.loadOpenVMVks(message.EuclidV2Fork); err != nil {
 		return nil, err
 	}
 
-	v.loadDarwinVKs()
-
 	return v, nil
 }
 
-// VerifyBatchProof Verify a ZkProof by marshaling it and sending it to the Halo2 Verifier.
-func (v *Verifier) VerifyBatchProof(proof message.BatchProof, forkName string) (bool, error) {
-	if v.cfg.MockMode {
-		log.Info("Mock mode, batch verifier disabled")
-		if string(proof.Proof()) == InvalidTestProof {
-			return false, nil
-		}
-		return true, nil
-
-	}
+// VerifyBatchProof Verify a ZkProof by marshaling it and sending it to the Verifier.
+func (v *Verifier) VerifyBatchProof(proof *message.OpenVMBatchProof, forkName string) (bool, error) {
 	buf, err := json.Marshal(proof)
 	if err != nil {
 		return false, err
@@ -143,16 +105,8 @@ func (v *Verifier) VerifyBatchProof(proof message.BatchProof, forkName string) (
 	return verified != 0, nil
 }
 
-// VerifyChunkProof Verify a ZkProof by marshaling it and sending it to the Halo2 Verifier.
-func (v *Verifier) VerifyChunkProof(proof message.ChunkProof, forkName string) (bool, error) {
-	if v.cfg.MockMode {
-		log.Info("Mock mode, verifier disabled")
-		if string(proof.Proof()) == InvalidTestProof {
-			return false, nil
-		}
-		return true, nil
-
-	}
+// VerifyChunkProof Verify a ZkProof by marshaling it and sending it to the Verifier.
+func (v *Verifier) VerifyChunkProof(proof *message.OpenVMChunkProof, forkName string) (bool, error) {
 	buf, err := json.Marshal(proof)
 	if err != nil {
 		return false, err
@@ -171,15 +125,7 @@ func (v *Verifier) VerifyChunkProof(proof message.ChunkProof, forkName string) (
 }
 
 // VerifyBundleProof Verify a ZkProof for a bundle of batches, by marshaling it and verifying it via the EVM verifier.
-func (v *Verifier) VerifyBundleProof(proof message.BundleProof, forkName string) (bool, error) {
-	if v.cfg.MockMode {
-		log.Info("Mock mode, verifier disabled")
-		if string(proof.Proof()) == InvalidTestProof {
-			return false, nil
-		}
-		return true, nil
-
-	}
+func (v *Verifier) VerifyBundleProof(proof *message.OpenVMBundleProof, forkName string) (bool, error) {
 	buf, err := json.Marshal(proof)
 	if err != nil {
 		return false, err
@@ -209,32 +155,6 @@ func (v *Verifier) readVK(filePat string) (string, error) {
 	return base64.StdEncoding.EncodeToString(byt), nil
 }
 
-// load low version vks, current is darwin
-func (v *Verifier) loadLowVersionVKs(cfg *config.VerifierConfig) error {
-	bundleVK, err := v.readVK(path.Join(cfg.LowVersionCircuit.AssetsPath, "vk_bundle.vkey"))
-	if err != nil {
-		return err
-	}
-	batchVK, err := v.readVK(path.Join(cfg.LowVersionCircuit.AssetsPath, "vk_batch.vkey"))
-	if err != nil {
-		return err
-	}
-	chunkVK, err := v.readVK(path.Join(cfg.LowVersionCircuit.AssetsPath, "vk_chunk.vkey"))
-	if err != nil {
-		return err
-	}
-	v.BundleVkMap[bundleVK] = struct{}{}
-	v.BatchVKMap[batchVK] = struct{}{}
-	v.ChunkVKMap[chunkVK] = struct{}{}
-	return nil
-}
-
-func (v *Verifier) loadDarwinVKs() {
-	v.BundleVkMap["AAAAGgAAAARX2S0K1wF333B1waOsnG/vcASJmWG9YM6SNWCBy1ywD5dsp1rEy7PSqiIFikkkOPqKokLW2mZSwCbtKdkfLQcvTxARUwHSe4iZe27PRJ5WWaLqtRV1+x6+pSVKtcPtaV4kE7v2YJRf0582hxiAF0IBaOoREdpyNfA2a9cvhWb2TMaPrUYP9EDQ7CUiW1FQzxbjGc95ua2htscnpU7d9S5stHWzKb7okkCG7bTIL9aG6qTQo2YXW7n3H3Ir47oVJB7IKrUzKGvI5Wmanh2zpZOJ9Qm4/wY24cT7cJz+Ux6wAg=="] = struct{}{}
-	v.BatchVKMap["AAAAGgAAAARX2S0K1wF333B1waOsnG/vcASJmWG9YM6SNWCBy1ywD1DEjW4Kell67H07wazT5DdzrSh4+amh+cmosQHp9p9snFypyoBGt3UHtoJGQBZlywZWDS9ht5pnaEoGBdaKcQk+lFb+WxTiId0KOAa0mafTZTQw8yToy57Jple64qzlRu1dux30tZZGuerLN1CKzg5Xl2iOpMK+l87jCINwVp5cUtF/XrvhBbU7onKh3KBiy99iUqVyA3Y6iiIZhGKWBSuSA4bNgDYIoVkqjHpdL35aEShoRO6pNXt7rDzxFoPzH0JuPI54nE4OhVrzZXwtkAEosxVa/fszcE092FH+HhhtxZBYe/KEzwdISU9TOPdId3UF/UMYC0MiYOlqffVTgAg="] = struct{}{}
-	v.ChunkVKMap["AAAAGQAAAATyWEABRbJ6hQQ5/zLX1gTasr7349minA9rSgMS6gDeHwZKqikRiO3md+pXjjxMHnKQtmXYgMXhJSvlmZ+Ws+cheuly2X1RuNQzcZuRImaKPR9LJsVZYsXfJbuqdKX8p0Gj8G83wMJOmTzNVUyUol0w0lTU+CEiTpHOnxBsTF3EWaW3s1u4ycOgWt1c9M6s7WmaBZLYgAWYCunO5CLCLApNGbCASeck/LuSoedEri5u6HccCKU2khG6zl6W07jvYSbDVLJktbjRiHv+/HQix+K14j8boo8Z/unhpwXCsPxkQA=="] = struct{}{}
-}
-
 func (v *Verifier) loadOpenVMVks(forkName string) error {
 	tempFile := path.Join(os.TempDir(), "openVmVk.json")
 	defer func() {

coordinator/internal/logic/verifier/verifier_test.go

@@ -29,17 +29,9 @@ func TestFFI(t *testing.T) {
 	as := assert.New(t)
 
 	cfg := &config.VerifierConfig{
-		MockMode: false,
-		LowVersionCircuit: &config.CircuitConfig{
-			ParamsPath:       *paramsPath,
-			AssetsPath:       *assetsPathLo,
-			ForkName:         "darwin",
-			MinProverVersion: "",
-		},
 		HighVersionCircuit: &config.CircuitConfig{
-			ParamsPath:       *paramsPath,
 			AssetsPath:       *assetsPathHi,
-			ForkName:         "darwinV2",
+			ForkName:         "euclidV2",
 			MinProverVersion: "",
 		},
 	}
@@ -48,43 +40,43 @@ func TestFFI(t *testing.T) {
 	as.NoError(err)
 
 	chunkProof1 := readChunkProof(*chunkProofPath1, as)
-	chunkOk1, err := v.VerifyChunkProof(chunkProof1, "darwinV2")
+	chunkOk1, err := v.VerifyChunkProof(chunkProof1, "euclidV2")
 	as.NoError(err)
 	as.True(chunkOk1)
 	t.Log("Verified chunk proof 1")
 
 	chunkProof2 := readChunkProof(*chunkProofPath2, as)
-	chunkOk2, err := v.VerifyChunkProof(chunkProof2, "darwinV2")
+	chunkOk2, err := v.VerifyChunkProof(chunkProof2, "euclidV2")
 	as.NoError(err)
 	as.True(chunkOk2)
 	t.Log("Verified chunk proof 2")
 
 	batchProof := readBatchProof(*batchProofPath, as)
-	batchOk, err := v.VerifyBatchProof(batchProof, "darwinV2")
+	batchOk, err := v.VerifyBatchProof(batchProof, "euclidV2")
 	as.NoError(err)
 	as.True(batchOk)
 	t.Log("Verified batch proof")
 }
 
-func readBatchProof(filePat string, as *assert.Assertions) types.BatchProof {
+func readBatchProof(filePat string, as *assert.Assertions) *types.OpenVMBatchProof {
 	f, err := os.Open(filePat)
 	as.NoError(err)
 	byt, err := io.ReadAll(f)
 	as.NoError(err)
 
-	proof := &types.Halo2BatchProof{}
+	proof := &types.OpenVMBatchProof{}
 	as.NoError(json.Unmarshal(byt, proof))
 
 	return proof
 }
 
-func readChunkProof(filePat string, as *assert.Assertions) types.ChunkProof {
+func readChunkProof(filePat string, as *assert.Assertions) *types.OpenVMChunkProof {
 	f, err := os.Open(filePat)
 	as.NoError(err)
 	byt, err := io.ReadAll(f)
 	as.NoError(err)
 
-	proof := &types.Halo2ChunkProof{}
+	proof := &types.OpenVMChunkProof{}
 	as.NoError(json.Unmarshal(byt, proof))
 
 	return proof

coordinator/internal/types/auth_test.go

@@ -22,7 +22,7 @@ func TestAuthMessageSignAndVerify(t *testing.T) {
 				ProverVersion:      "v0.0.1",
 				Challenge:          "abcdef",
 				ProverProviderType: ProverProviderTypeInternal,
-				ProverTypes:        []ProverType{ProverTypeBatch},
+				ProverTypes:        []ProverType{ProverTypeOpenVM},
 				VKs:                []string{"vk1", "vk2"},
 			},
 			PublicKey: publicKeyHex,
@@ -64,7 +64,7 @@ func TestGenerateSignature(t *testing.T) {
 			ProverVersion:      "v4.4.45-37af5ef5-38a68e2-1c5093c",
 			Challenge:          "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MjQ4Mzg0ODUsIm9yaWdfaWF0IjoxNzI0ODM0ODg1LCJyYW5kb20iOiJ6QmdNZGstNGc4UzNUNTFrVEFsYk1RTXg2TGJ4SUs4czY3ejM2SlNuSFlJPSJ9.x9PvihhNx2w4_OX5uCrv8QJCNYVQkIi-K2k8XFXYmik",
 			ProverProviderType: ProverProviderTypeInternal,
-			ProverTypes:        []ProverType{ProverTypeChunk},
+			ProverTypes:        []ProverType{ProverTypeOpenVM},
 			VKs:                []string{"mock_vk"},
 		},
 		PublicKey: publicKeyHex,

coordinator/internal/types/prover.go

@@ -21,10 +21,10 @@ type ProverType uint8
 
 func (r ProverType) String() string {
 	switch r {
-	case ProverTypeChunk:
-		return "prover type chunk"
-	case ProverTypeBatch:
-		return "prover type batch"
+	case ProverTypeChunkDeprecated:
+		return "prover type chunk (deprecated)"
+	case ProverTypeBatchDeprecated:
+		return "prover type batch (deprecated)"
 	case ProverTypeOpenVM:
 		return "prover type openvm"
 	default:
@@ -35,10 +35,10 @@ func (r ProverType) String() string {
 const (
 	// ProverTypeUndefined is an unknown prover type
 	ProverTypeUndefined ProverType = iota
-	// ProverTypeChunk signals it's a chunk prover, which can prove chunk_tasks
-	ProverTypeChunk
-	// ProverTypeBatch signals it's a batch prover, which can prove batch_tasks and bundle_tasks
-	ProverTypeBatch
+	// ProverTypeChunk signals it's a chunk prover, which can prove chunk_tasks, which is deprecated
+	ProverTypeChunkDeprecated
+	// ProverTypeBatch signals it's a batch prover, which can prove batch_tasks and bundle_tasks, which is deprecated
+	ProverTypeBatchDeprecated
 	// ProverTypeOpenVM
 	ProverTypeOpenVM
 )
@@ -47,9 +47,9 @@ const (
 func MakeProverType(proofType message.ProofType) ProverType {
 	switch proofType {
 	case message.ProofTypeChunk:
-		return ProverTypeChunk
+		return ProverTypeChunkDeprecated
 	case message.ProofTypeBatch, message.ProofTypeBundle:
-		return ProverTypeBatch
+		return ProverTypeBatchDeprecated
 	default:
 		return ProverTypeUndefined
 	}

coordinator/test/api_test.go

@@ -67,7 +67,7 @@ func randomURL() string {
 	return fmt.Sprintf("localhost:%d", 10000+2000+id.Int64())
 }
 
-func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL string, forks []string) (*cron.Collector, *http.Server) {
+func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL string) (*cron.Collector, *http.Server) {
 	var err error
 	db, err = testApps.GetGormDBClient()
 
@@ -84,18 +84,10 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 		ProverManager: &config.ProverManager{
 			ProversPerSession: proversPerSession,
 			Verifier: &config.VerifierConfig{
-				MockMode: true,
-				LowVersionCircuit: &config.CircuitConfig{
-					ParamsPath:       "",
-					AssetsPath:       "",
-					ForkName:         "homestead",
-					MinProverVersion: "v4.2.0",
-				},
 				HighVersionCircuit: &config.CircuitConfig{
-					ParamsPath:       "",
 					AssetsPath:       "",
-					ForkName:         "bernoulli",
-					MinProverVersion: "v4.3.0",
+					ForkName:         "euclidV2",
+					MinProverVersion: "v4.4.89",
 				},
 			},
 			BatchCollectionTimeSec:  10,
@@ -109,20 +101,17 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 		},
 	}
 
-	var chainConf params.ChainConfig
-	for _, forkName := range forks {
-		switch forkName {
-		case "bernoulli":
-			chainConf.BernoulliBlock = big.NewInt(100)
-		case "homestead":
-			chainConf.HomesteadBlock = big.NewInt(0)
-		}
-	}
-
 	proofCollector := cron.NewCollector(context.Background(), db, conf, nil)
 
 	router := gin.New()
-	api.InitController(conf, &chainConf, db, nil)
+	api.InitController(conf, &params.ChainConfig{
+		BernoulliBlock: big.NewInt(0),
+		CurieBlock:     big.NewInt(0),
+		DarwinTime:     new(uint64),
+		DarwinV2Time:   new(uint64),
+		EuclidTime:     new(uint64),
+		EuclidV2Time:   new(uint64),
+	}, db, nil)
 	route.Route(router, conf, nil)
 	srv := &http.Server{
 		Addr:    coordinatorURL,
@@ -142,7 +131,7 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 func setEnv(t *testing.T) {
 	var err error
 
-	version.Version = "v4.2.0"
+	version.Version = "v4.4.89"
 
 	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.LogfmtFormat()))
 	glogger.Verbosity(log.LvlInfo)
@@ -198,7 +187,7 @@ func TestApis(t *testing.T) {
 func testHandshake(t *testing.T) {
 	// Setup coordinator and http server.
 	coordinatorURL := randomURL()
-	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL, []string{"homestead"})
+	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL)
 	defer func() {
 		proofCollector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -211,7 +200,7 @@ func testHandshake(t *testing.T) {
 func testFailedHandshake(t *testing.T) {
 	// Setup coordinator and http server.
 	coordinatorURL := randomURL()
-	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL, []string{"homestead"})
+	proofCollector, httpHandler := setupCoordinator(t, 1, coordinatorURL)
 	defer func() {
 		proofCollector.Stop()
 	}()
@@ -229,7 +218,7 @@ func testFailedHandshake(t *testing.T) {
 
 func testGetTaskBlocked(t *testing.T) {
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"homestead"})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL)
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -273,7 +262,7 @@ func testGetTaskBlocked(t *testing.T) {
 
 func testOutdatedProverVersion(t *testing.T) {
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"homestead"})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL)
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -285,14 +274,12 @@ func testOutdatedProverVersion(t *testing.T) {
 	batchProver := newMockProver(t, "prover_batch_test", coordinatorURL, message.ProofTypeBatch, "v1.999.999")
 	assert.True(t, chunkProver.healthCheckSuccess(t))
 
-	expectedErr := fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s",
-		conf.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, chunkProver.proverVersion)
+	expectedErr := fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: v4.4.89, actual version: %s", chunkProver.proverVersion)
 	code, errMsg := chunkProver.tryGetProverTask(t, message.ProofTypeChunk)
 	assert.Equal(t, types.ErrJWTCommonErr, code)
 	assert.Equal(t, expectedErr, errors.New(errMsg))
 
-	expectedErr = fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s",
-		conf.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, batchProver.proverVersion)
+	expectedErr = fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: v4.4.89, actual version: %s", batchProver.proverVersion)
 	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch)
 	assert.Equal(t, types.ErrJWTCommonErr, code)
 	assert.Equal(t, expectedErr, errors.New(errMsg))
@@ -300,7 +287,7 @@ func testOutdatedProverVersion(t *testing.T) {
 
 func testValidProof(t *testing.T) {
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"homestead"})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL)
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -383,7 +370,7 @@ func testValidProof(t *testing.T) {
 func testInvalidProof(t *testing.T) {
 	// Setup coordinator and ws server.
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"darwinV2"})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL)
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -471,7 +458,7 @@ func testInvalidProof(t *testing.T) {
 func testProofGeneratedFailed(t *testing.T) {
 	// Setup coordinator and ws server.
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, []string{"darwinV2"})
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL)
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -572,7 +559,7 @@ func testProofGeneratedFailed(t *testing.T) {
 func testTimeoutProof(t *testing.T) {
 	// Setup coordinator and ws server.
 	coordinatorURL := randomURL()
-	collector, httpHandler := setupCoordinator(t, 1, coordinatorURL, []string{"darwinV2"})
+	collector, httpHandler := setupCoordinator(t, 1, coordinatorURL)
 	defer func() {
 		collector.Stop()
 		assert.NoError(t, httpHandler.Shutdown(context.Background()))
@@ -595,7 +582,9 @@ func testTimeoutProof(t *testing.T) {
 	assert.NoError(t, err)
 	err = chunkOrm.UpdateBatchHashInRange(context.Background(), 0, 100, batch.Hash)
 	assert.NoError(t, err)
-	encodeData, err := json.Marshal(message.Halo2ChunkProof{})
+	encodeData, err := json.Marshal(message.OpenVMChunkProof{VmProof: &message.OpenVMProof{}, MetaData: struct {
+		ChunkInfo *message.ChunkInfo `json:"chunk_info"`
+	}{ChunkInfo: &message.ChunkInfo{}}})
 	assert.NoError(t, err)
 	assert.NotEmpty(t, encodeData)
 	err = chunkOrm.UpdateProofAndProvingStatusByHash(context.Background(), dbChunk.Hash, encodeData, types.ProvingTaskUnassigned, 1)

coordinator/test/mock_prover.go

@@ -207,14 +207,16 @@ func (r *mockProver) submitProof(t *testing.T, proverTaskSchema *types.GetTaskSc
 	}
 
 	var proof []byte
-	switch proverTaskSchema.TaskType {
-	case int(message.ProofTypeChunk):
-		encodeData, err := json.Marshal(message.Halo2ChunkProof{})
+	switch message.ProofType(proverTaskSchema.TaskType) {
+	case message.ProofTypeChunk:
+		encodeData, err := json.Marshal(message.OpenVMChunkProof{VmProof: &message.OpenVMProof{}, MetaData: struct {
+			ChunkInfo *message.ChunkInfo `json:"chunk_info"`
+		}{ChunkInfo: &message.ChunkInfo{}}})
 		assert.NoError(t, err)
 		assert.NotEmpty(t, encodeData)
 		proof = encodeData
-	case int(message.ProofTypeBatch):
-		encodeData, err := json.Marshal(message.Halo2BatchProof{})
+	case message.ProofTypeBatch:
+		encodeData, err := json.Marshal(message.OpenVMBatchProof{VmProof: &message.OpenVMProof{}})
 		assert.NoError(t, err)
 		assert.NotEmpty(t, encodeData)
 		proof = encodeData
@@ -223,16 +225,14 @@ func (r *mockProver) submitProof(t *testing.T, proverTaskSchema *types.GetTaskSc
 	if proofStatus == verifiedFailed {
 		switch proverTaskSchema.TaskType {
 		case int(message.ProofTypeChunk):
-			chunkProof := message.Halo2ChunkProof{}
-			chunkProof.RawProof = []byte(verifier.InvalidTestProof)
-			encodeData, err := json.Marshal(&chunkProof)
+			encodeData, err := json.Marshal(message.OpenVMChunkProof{VmProof: &message.OpenVMProof{Proof: []byte(verifier.InvalidTestProof)}, MetaData: struct {
+				ChunkInfo *message.ChunkInfo `json:"chunk_info"`
+			}{ChunkInfo: &message.ChunkInfo{}}})
 			assert.NoError(t, err)
 			assert.NotEmpty(t, encodeData)
 			proof = encodeData
 		case int(message.ProofTypeBatch):
-			batchProof := message.Halo2BatchProof{}
-			batchProof.RawProof = []byte(verifier.InvalidTestProof)
-			encodeData, err := json.Marshal(&batchProof)
+			encodeData, err := json.Marshal(&message.OpenVMBatchProof{VmProof: &message.OpenVMProof{Proof: []byte(verifier.InvalidTestProof)}})
 			assert.NoError(t, err)
 			assert.NotEmpty(t, encodeData)
 			proof = encodeData

database/migrate/migrate_test.go

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

database/migrate/migrations/00027_ blob_upload.sql

@@ -0,0 +1,32 @@
+-- +goose Up
+-- +goose StatementBegin
+
+CREATE TABLE blob_upload (
+    batch_index     BIGINT          NOT NULL,
+    batch_hash      VARCHAR         NOT NULL,
+
+    platform        SMALLINT        NOT NULL,
+    status          SMALLINT        NOT NULL,
+
+-- metadata
+    created_at              TIMESTAMP(0)    NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at              TIMESTAMP(0)    NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at              TIMESTAMP(0)    DEFAULT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS batch_index_batch_hash_platform_uindex
+ON blob_upload(batch_index, batch_hash, platform) WHERE deleted_at IS NULL;
+
+COMMENT ON COLUMN blob_upload.status IS 'undefined, pending, uploaded, failed';
+
+CREATE INDEX IF NOT EXISTS idx_blob_upload_status_platform ON blob_upload(status, platform) WHERE deleted_at IS NULL;
+
+CREATE INDEX IF NOT EXISTS idx_blob_upload_batch_index_batch_hash_status_platform 
+ON blob_upload(batch_index, batch_hash, status, platform) WHERE deleted_at IS NULL;
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE blob_upload;
+-- +goose StatementEnd

go.work

@@ -1,6 +1,4 @@
-go 1.22
-
-toolchain go1.22.2
+go 1.22.4
 
 use (
 	./bridge-history-api

go.work.sum

@@ -555,12 +555,16 @@ github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802 h1:1BDTz0u9nC3//pOC
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53/go.mod h1:+3IMCy2vIlbG1XG/0ggNQv0SvxCAIpPM5b1nCz56Xno=
 github.com/CloudyKit/jet/v6 v6.1.0/go.mod h1:d3ypHeIRNo2+XyqnGA8s+aphtcVpjP5hPwP/Lzo7Ro4=
+github.com/CloudyKit/jet/v6 v6.2.0/go.mod h1:d3ypHeIRNo2+XyqnGA8s+aphtcVpjP5hPwP/Lzo7Ro4=
 github.com/DATA-DOG/go-sqlmock v1.3.3 h1:CWUqKXe0s8A2z6qCgkP4Kru7wC11YoAnoupUKFDnH08=
 github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
 github.com/DataDog/datadog-go v3.2.0+incompatible h1:qSG2N4FghB1He/r2mFrWKCaL7dXCilEuNEeAn20fdD4=
 github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
+github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo=
 github.com/HdrHistogram/hdrhistogram-go v1.1.2/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo=
+github.com/Joker/jade v1.1.3/go.mod h1:T+2WLyt7VH6Lp0TRxQrUYEs64nRc83wkMQrfeIQKduM=
 github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
 github.com/NYTimes/gziphandler v1.1.1 h1:ZUDjpQae29j0ryrS0u/B8HZfJBtBQHjqw2rQ2cqUQ3I=
 github.com/NYTimes/gziphandler v1.1.1/go.mod h1:n/CVRwUEOgIxrgPvAQhUUr9oeUtvrhMomdKFjzJNB0c=
 github.com/OneOfOne/xxhash v1.2.8 h1:31czK/TI9sNkxIKfaUfGlU47BAxQ0ztGgd9vPyqimf8=
@@ -572,6 +576,7 @@ github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdko
 github.com/Shopify/goreferrer v0.0.0-20220729165902-8cddb4f5de06/go.mod h1:7erjKLwalezA0k99cWs5L11HWOAPNjdUZ6RxH1BXbbM=
 github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 h1:fLjPD/aNc3UIOA6tDi6QXUemppXK3P9BI7mr2hd6gx8=
 github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
+github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8=
 github.com/aclements/go-moremath v0.0.0-20210112150236-f10218a38794/go.mod h1:7e+I0LQFUI9AXWxOfsQROs9xPhoJtbsyWcjJqDd4KPY=
 github.com/aead/siphash v1.0.1 h1:FwHfE/T45KPKYuuSAKyyvE+oPWcaQ+CUmFW0bPlM+kg=
 github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
@@ -654,6 +659,7 @@ github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kB
 github.com/bitly/go-hostpool v0.1.0 h1:XKmsF6k5el6xHG3WPJ8U0Ku/ye7njX7W81Ng7O2ioR0=
 github.com/bitly/go-simplejson v0.5.0 h1:6IH+V8/tVMab511d5bn4M7EwGXZf9Hj6i2xSwkNEM+Y=
 github.com/bits-and-blooms/bitset v1.7.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
+github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
 github.com/bits-and-blooms/bitset v1.12.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
 github.com/bits-and-blooms/bitset v1.14.2/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
 github.com/bketelsen/crypt v0.0.4 h1:w/jqZtC9YD4DS/Vp9GhWfWcCpuAL58oTnLoI8vE9YHU=
@@ -665,11 +671,9 @@ github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40 h1:y4B3+GPxKlrigF1ha
 github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40/go.mod h1:8rLXio+WjiTceGBHIoTvn60HIbs7Hm7bcHjyrSqYB9c=
 github.com/boltdb/bolt v1.3.1 h1:JQmyP4ZBrce+ZQu0dY660FMfatumYDLun9hBCUVIkF4=
 github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
-github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k=
 github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
-github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
 github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f h1:bAs4lUbRJpnnkd9VhRV3jjAVU7DJVjMaK+IsvSeZvFo=
 github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d h1:yJzD/yFppdVCf6ApMkVy8cUxV0XrxdP9rVf6D87/Mng=
 github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd h1:R/opQEbFEy9JGkIguV40SvRY1uliPX8ifOvi6ICsFCw=
@@ -684,6 +688,7 @@ github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91
 github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/chzyer/logex v1.1.10 h1:Swpa1K6QvQznwJRcfTfQJmTE72DqScAa40E+fbHEXEE=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/logex v1.2.0/go.mod h1:9+9sk7u7pGNWYMkh0hdiL++6OeibzJccyQU4p4MedaY=
@@ -714,7 +719,14 @@ github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XP
 github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20231128003011-0fa0005c9caa h1:jQCWAUqqlij9Pgj2i/PB79y4KOPYVyFYdROxgaCwdTQ=
 github.com/cncf/xds/go v0.0.0-20231128003011-0fa0005c9caa/go.mod h1:x/1Gn8zydmfq8dk6e9PdstVsDgu9RuyIIJqAaF//0IM=
+github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU=
+github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8=
+github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M=
+github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs=
+github.com/cockroachdb/pebble v1.1.1/go.mod h1:4exszw1r40423ZsmkG/09AFEG83I0uDgfujJdbL6kYU=
+github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg=
 github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ=
+github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ=
 github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM=
 github.com/compose-spec/compose-go v1.20.0 h1:h4ZKOst1EF/DwZp7dWkb+wbTVE4nEyT9Lc89to84Ol4=
 github.com/compose-spec/compose-go v1.20.0/go.mod h1:+MdqXV4RA7wdFsahh/Kb8U0pAJqkg7mr4PM9tFKU8RM=
@@ -764,6 +776,7 @@ github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:ma
 github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/crate-crypto/go-ipa v0.0.0-20230601170251-1830d0757c80/go.mod h1:gzbVz57IDJgQ9rLQwfSk696JGWof8ftznEL9GoAv3NI=
+github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs=
 github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c h1:/ovYnF02fwL0kvspmy9AuyKg1JhdTRUgPw4nUxd9oZM=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
@@ -775,9 +788,9 @@ github.com/dchest/blake512 v1.0.0 h1:oDFEQFIqFSeuA34xLtXZ/rWxCXdSjirjzPhey5EUvmA
 github.com/dchest/blake512 v1.0.0/go.mod h1:FV1x7xPPLWukZlpDpWQ88rF/SFwZ5qbskrzhLMB92JI=
 github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4=
 github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo=
+github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
 github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0=
 github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
-github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
 github.com/deepmap/oapi-codegen v1.6.0 h1:w/d1ntwh91XI0b/8ja7+u5SvA4IFfM0UNNLmiDR1gg0=
 github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M=
@@ -799,11 +812,13 @@ github.com/docker/cli-docs-tool v0.6.0/go.mod h1:zMjqTFCU361PRh8apiXzeAZ1Q/xupbI
 github.com/docker/docker v1.4.2-0.20180625184442-8e610b2b55bf/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/docker v24.0.5+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815 h1:bWDMxwH3px2JBh6AyO7hdCn/PkvCZXii8TGj7sbtEbQ=
+github.com/donovanhide/eventsource v0.0.0-20210830082556-c59027999da0/go.mod h1:56wL82FO0bfMU5RvfXoIwSOP2ggqqxT+tAfNEIyxuHw=
 github.com/dop251/goja v0.0.0-20211011172007-d99e4b8cbf48 h1:iZOop7pqsg+56twTopWgwCGxdB5SI2yDO8Ti7eTRliQ=
 github.com/dop251/goja v0.0.0-20211011172007-d99e4b8cbf48/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=
 github.com/dop251/goja v0.0.0-20211022113120-dc8c55024d06/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=
 github.com/dop251/goja v0.0.0-20220405120441-9037c2b61cbf h1:Yt+4K30SdjOkRoRRm3vYNQgR+/ZIy0RmeUDZo7Y8zeQ=
 github.com/dop251/goja v0.0.0-20220405120441-9037c2b61cbf/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=
+github.com/dop251/goja v0.0.0-20230605162241-28ee0ee714f3/go.mod h1:QMWlm50DNe14hD7t24KEqZuUdC9sOTy8W6XbCU1mlw4=
 github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127/go.mod h1:QMWlm50DNe14hD7t24KEqZuUdC9sOTy8W6XbCU1mlw4=
 github.com/dop251/goja_nodejs v0.0.0-20210225215109-d91c329300e7 h1:tYwu/z8Y0NkkzGEh3z21mSWggMg4LwLRFucLS7TjARg=
 github.com/dop251/goja_nodejs v0.0.0-20210225215109-d91c329300e7/go.mod h1:hn7BA7c8pLvoGndExHudxTDKZ84Pyvv+90pbBjbTz0Y=
@@ -822,10 +837,12 @@ github.com/envoyproxy/go-control-plane v0.12.0/go.mod h1:ZBTaoJ23lqITozF0M6G4/Ir
 github.com/envoyproxy/protoc-gen-validate v1.0.4 h1:gVPz/FMfvh57HdSJQyvBtF00j8JU4zdyUgIUNhlgg0A=
 github.com/envoyproxy/protoc-gen-validate v1.0.4/go.mod h1:qys6tmnRsYrQqIhm2bvKZH4Blx/1gTIZ2UKVY1M+Yew=
 github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5 h1:Yzb9+7DPaBjB8zlTR87/ElzFsnQfuHnVUVqpZZIcV5Y=
+github.com/ethereum/c-kzg-4844 v1.0.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
 github.com/ethereum/c-kzg-4844/bindings/go v0.0.0-20230126171313-363c7d7593b4 h1:B2mpK+MNqgPqk2/KNi1LbqwtZDy5F7iy0mynQiBr8VA=
 github.com/ethereum/c-kzg-4844/bindings/go v0.0.0-20230126171313-363c7d7593b4/go.mod h1:y4GA2JbAUama1S4QwYjC2hefgGLU8Ul0GMtL/ADMF1c=
 github.com/ethereum/go-ethereum v1.10.26 h1:i/7d9RBBwiXCEuyduBQzJw/mKmnvzsN14jqBmytw72s=
 github.com/ethereum/go-ethereum v1.10.26/go.mod h1:EYFyF19u3ezGLD4RqOkLq+ZCXzYbLoNDdZlMt7kyKFg=
+github.com/ethereum/go-verkle v0.1.1-0.20240306133620-7d920df305f0/go.mod h1:D9AJLVXSyZQXJQVk8oh1EwjISE+sJTn2duYIZC0dy3w=
 github.com/evanphx/json-patch v4.12.0+incompatible h1:4onqiflcdA9EOZ4RxV643DvftH5pOlLGNtQ5lPWQu84=
 github.com/evanphx/json-patch v4.12.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
@@ -834,7 +851,9 @@ github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL
 github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
 github.com/fatih/color v1.14.1 h1:qfhVLaG5s+nCROl1zJsZRxFeYrHLqWroPOQ8BWiNb4w=
 github.com/fatih/color v1.14.1/go.mod h1:2oHN61fhTpgcxD3TSWCgKDiH1+x4OiDVVGH8WlgGZGg=
+github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
+github.com/ferranbt/fastssz v0.1.2/go.mod h1:X5UPrE2u1UJjxHA8X54u04SBwdAQjG2sFtWs39YxyWs=
 github.com/fjl/gencodec v0.0.0-20220412091415-8bb9e558978c h1:CndMRAH4JIwxbW8KYq6Q+cGWcGHz0FjGR3QqcInWcW0=
 github.com/fjl/gencodec v0.0.0-20220412091415-8bb9e558978c/go.mod h1:AzA8Lj6YtixmJWL+wkKoBGsLWy9gFrAzi4g+5bCKwpY=
 github.com/fjl/gencodec v0.0.0-20230517082657-f9840df7b83e/go.mod h1:AzA8Lj6YtixmJWL+wkKoBGsLWy9gFrAzi4g+5bCKwpY=
@@ -854,6 +873,7 @@ github.com/getkin/kin-openapi v0.61.0 h1:6awGqF5nG5zkVpMsAih1QH4VgzS8phTxECUWIFo
 github.com/getkin/kin-openapi v0.61.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
 github.com/getsentry/sentry-go v0.11.0 h1:qro8uttJGvNAMr5CLcFI9CHR0aDzXl0Vs3Pmw/oTPg8=
 github.com/getsentry/sentry-go v0.11.0/go.mod h1:KBQIxiZAetw62Cj8Ri964vAEWVdgfaUCn30Q3bCvANo=
+github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY=
 github.com/ghemawat/stream v0.0.0-20171120220530-696b145b53b9/go.mod h1:106OIgooyS7OzLDOpUGgm9fA3bQENb/cFSyyBmMoJDs=
 github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
 github.com/glycerine/go-unsnap-stream v0.0.0-20180323001048-9f0cb55181dd h1:r04MMPyLHj/QwZuMJ5+7tJcBr1AQjpiAK/rZWRrQT7o=
@@ -862,6 +882,7 @@ github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31 h1:gclg6gY70GLy
 github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
 github.com/go-chi/chi/v5 v5.0.0 h1:DBPx88FjZJH3FsICfDAfIfnb7XxKIYVGG6lOPlhENAg=
 github.com/go-chi/chi/v5 v5.0.0/go.mod h1:BBug9lr0cqtdAhsu6R4AAdvufI0/XBzAQSsUqJpoZOs=
+github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1 h1:QbL/5oDUmRBzO9/Z7Seo6zf912W/a6Sr4Eu0G/3Jho0=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72 h1:b+9H1GAsx5RsjvDFLoS5zkNBzIQMuVKUYQDmxU3N5XE=
@@ -873,6 +894,7 @@ github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
 github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
 github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab/go.mod h1:/P9AEU963A2AYjv4d1V5eVL1CQbEJq6aCNHDDjibzu8=
+github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
 github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
 github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
@@ -913,6 +935,7 @@ github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+Licev
 github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219 h1:utua3L2IbQJmauC5IXdEA547bcoU5dozgQAfc8Onsg4=
@@ -1053,7 +1076,10 @@ github.com/hashicorp/memberlist v0.5.0/go.mod h1:yvyXLpo0QaGE59Y7hDTsTzDD25JYBZ4
 github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
 github.com/hashicorp/serf v0.10.1 h1:Z1H2J60yRKvfDYAOZLd2MU0ND4AH/WDz7xYHDWQsIPY=
 github.com/hashicorp/serf v0.10.1/go.mod h1:yL2t6BqATOLGc5HF7qbFkTfXoPIY0WZdWHfEvMqbG+4=
+github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc=
+github.com/holiman/uint256 v1.2.0/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw=
 github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
+github.com/holiman/uint256 v1.3.0/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/huin/goupnp v1.0.2/go.mod h1:0dxJBVBHqTMjIUMkESDTNgOOx/Mw5wYIfyFmdzSamkM=
 github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150 h1:vlNjIqmUZ9CMAWsbURYl3a6wZbw7q5RHVvlXTNS/Bs8=
@@ -1123,13 +1149,16 @@ github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5 h1:PJr+ZMXIecYc
 github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
 github.com/jwilder/encoding v0.0.0-20170811194829-b4e1701a28ef h1:2jNeR4YUziVtswNP9sEFAI913cVrzH85T+8Q6LpYbT0=
 github.com/jwilder/encoding v0.0.0-20170811194829-b4e1701a28ef/go.mod h1:Ct9fl0F6iIOGgxJ5npU/IUOhOhqlVrGjyIZc8/MagT0=
+github.com/karalabe/hid v1.0.1-0.20240306101548-573246063e52/go.mod h1:qk1sX/IBgppQNcGCRoj90u6EGC056EBoIc1oEjCWla8=
 github.com/karalabe/usb v0.0.0-20211005121534-4c5740d64559 h1:0VWDXPNE0brOek1Q8bLfzKkvOzwbQE/snjGojlCr8CY=
 github.com/karalabe/usb v0.0.0-20211005121534-4c5740d64559/go.mod h1:Od972xHfMJowv7NGVDiWVxk2zxnWgjLlJzE+F4F7AGU=
 github.com/karalabe/usb v0.0.2 h1:M6QQBNxF+CQ8OFvxrT90BA0qBOXymndZnk5q235mFc4=
 github.com/karalabe/usb v0.0.2/go.mod h1:Od972xHfMJowv7NGVDiWVxk2zxnWgjLlJzE+F4F7AGU=
 github.com/kataras/blocks v0.0.7/go.mod h1:UJIU97CluDo0f+zEjbnbkeMRlvYORtmc1304EeyXf4I=
 github.com/kataras/golog v0.1.7/go.mod h1:jOSQ+C5fUqsNSwurB/oAHq1IFSb0KI3l6GMa7xB6dZA=
+github.com/kataras/golog v0.1.8/go.mod h1:rGPAin4hYROfk1qT9wZP6VY2rsb4zzc37QpdPjdkqVw=
 github.com/kataras/iris/v12 v12.2.0-beta5/go.mod h1:q26aoWJ0Knx/00iPKg5iizDK7oQQSPjbD8np0XDh6dc=
+github.com/kataras/iris/v12 v12.2.0/go.mod h1:BLzBpEunc41GbE68OUaQlqX4jzi791mx5HU04uPb90Y=
 github.com/kataras/pio v0.0.11/go.mod h1:38hH6SWH6m4DKSYmRhlrCJ5WItwWgCVrTNU62XZyUvI=
 github.com/kataras/sitemap v0.0.6/go.mod h1:dW4dOCNs896OR1HmG+dMLdT7JjDk7mYBzoIRwuj5jA4=
 github.com/kataras/tunnel v0.0.4/go.mod h1:9FkU4LaeifdMWqZu7o20ojmW4B7hdhv2CMLwfnHGpYw=
@@ -1143,9 +1172,11 @@ github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23 h1:FOOIBWrEkLgmlgGfM
 github.com/klauspost/asmfmt v1.3.2 h1:4Ri7ox3EwapiOjCki+hw14RyKk201CN4rzyCJRFLpK4=
 github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE=
 github.com/klauspost/compress v1.4.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/klauspost/cpuid v0.0.0-20170728055534-ae7887de9fa5 h1:2U0HzY8BJ8hVwDKIzp7y4voR9CX/nvcfymLmg2UiOio=
 github.com/klauspost/cpuid v0.0.0-20170728055534-ae7887de9fa5/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/crc32 v0.0.0-20161016154125-cb6bfca970f6 h1:KAZ1BW2TCmT6PRihDPpocIy1QTtsAsrx6TneU/4+CMg=
 github.com/klauspost/crc32 v0.0.0-20161016154125-cb6bfca970f6/go.mod h1:+ZoRqAPRLkC4NPOvfYeR5KNOrY6TD+/sAC3HXPZgDYg=
 github.com/klauspost/pgzip v1.0.2-0.20170402124221-0bf5dcad4ada h1:3L+neHp83cTjegPdCiOxVOJtRIy7/8RldvMTsyPYH10=
@@ -1164,9 +1195,11 @@ github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+
 github.com/labstack/echo/v4 v4.2.1 h1:LF5Iq7t/jrtUuSutNuiEWtB5eiHfZ5gSe2pcu5exjQw=
 github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg=
 github.com/labstack/echo/v4 v4.9.0/go.mod h1:xkCDAdFCIf8jsFQ5NnbK7oqaF/yU1A1X20Ltm0OvSks=
+github.com/labstack/echo/v4 v4.10.0/go.mod h1:S/T/5fy/GigaXnHTkh0ZGe4LpkkQysvRjFMSUTkDRNQ=
 github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0=
 github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
 github.com/labstack/gommon v0.3.1/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
+github.com/labstack/gommon v0.4.0/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
 github.com/lestrrat-go/backoff/v2 v2.0.8 h1:oNb5E5isby2kiro9AgdHLv5N5tint1AnDVVf2E2un5A=
 github.com/lestrrat-go/backoff/v2 v2.0.8/go.mod h1:rHP/q/r9aT27n24JQLa7JhSQZCKBBOiM/uP402WwN8Y=
 github.com/lestrrat-go/blackmagic v1.0.0 h1:XzdxDbuQTz0RZZEmdU7cnQxUtFUzgCSPq8RCz4BxIi4=
@@ -1186,6 +1219,7 @@ github.com/lyft/protoc-gen-star/v2 v2.0.3 h1:/3+/2sWyXeMLzKd1bX+ixWKgEMsULrIivpD
 github.com/lyft/protoc-gen-star/v2 v2.0.3/go.mod h1:amey7yeodaJhXSbf/TlLvWiqQfLOSpEk//mLlc+axEk=
 github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=
 github.com/mailgun/raymond/v2 v2.0.46/go.mod h1:lsgvL50kgt1ylcFJYZiULi5fjPBkkhNfj4KA0W54Z18=
+github.com/mailgun/raymond/v2 v2.0.48/go.mod h1:lsgvL50kgt1ylcFJYZiULi5fjPBkkhNfj4KA0W54Z18=
 github.com/matryer/moq v0.0.0-20190312154309-6cfb0558e1bd h1:HvFwW+cm9bCbZ/+vuGNq7CRWXql8c0y8nGeYpqmpvmk=
 github.com/matryer/moq v0.0.0-20190312154309-6cfb0558e1bd/go.mod h1:9ELz6aaclSIGnZBoaSLZ3NAl1VTufbOrXBPvtcy6WiQ=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
@@ -1207,12 +1241,15 @@ github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOA
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/mattn/go-tty v0.0.0-20180907095812-13ff1204f104 h1:d8RFOZ2IiFtFWBcKEHAFYJcPTf0wY5q0exFNJZVWa1U=
 github.com/mattn/go-tty v0.0.0-20180907095812-13ff1204f104/go.mod h1:XPvLUNfbS4fJH25nqRHfWLMa1ONC8Amw+mIA639KxkE=
+github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
 github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 h1:jWpvCLoY8Z/e3VKvlsiIGKtc+UG6U5vzxaoagmhXfyg=
 github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0/go.mod h1:QUyp042oQthUoa9bqDv0ER0wrtXnBruoNd7aNjkbP+k=
 github.com/microcosm-cc/bluemonday v1.0.21/go.mod h1:ytNkv4RrDrLJ2pqlsSI46O6IVXmZOBBD4SaJyDwwTkM=
+github.com/microcosm-cc/bluemonday v1.0.23/go.mod h1:mN70sk7UkkF8TUr2IGBpNN0jAgStuPzlK76QuruE/z4=
 github.com/microsoft/go-mssqldb v1.6.0 h1:mM3gYdVwEPFrlg/Dvr2DNVEgYFG7L42l+dGc67NNNpc=
 github.com/microsoft/go-mssqldb v1.6.0/go.mod h1:00mDtPbeQCRGC1HwOOR5K/gr30P1NcEG0vx6Kbv2aJU=
 github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
@@ -1265,6 +1302,7 @@ github.com/nats-io/nkeys v0.4.7 h1:RwNJbbIdYCoClSDNY7QVKZlyb/wfT6ugvFCiKy6vDvI=
 github.com/nats-io/nkeys v0.4.7/go.mod h1:kqXRgRDPlGy7nGaEDMuYzmiJCIAAWDK0IMBtDmGD0nc=
 github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32/go.mod h1:9wM+0iRr9ahx58uYLpLIr5fm8diHn0JbqRycJi6w0Ms=
 github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86 h1:D6paGObi5Wud7xg83MaEFyjxQB1W5bz5d0IFppr+ymk=
 github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo=
 github.com/neelance/sourcemap v0.0.0-20200213170602-2833bce08e4c h1:bY6ktFuJkt+ZXkX0RChQch2FtHpWQLVS8Qo1YasiIVk=
@@ -1296,6 +1334,7 @@ github.com/philhofer/fwd v1.0.0 h1:UbZqGr5Y38ApvM/V/jEljVxwocdweyH+vmYvRPBnbqQ=
 github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
 github.com/pierrec/lz4 v2.0.5+incompatible h1:2xWsjqPFWcplujydGg4WmhC/6fZqK42wMM8aXeqhl0I=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
+github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
 github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4 h1:Qj1ukM4GlMWXNdMBuXcXfz/Kw9s1qm0CLY32QxuSImI=
 github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4/go.mod h1:N6UoU20jOqggOuDwUaBQpluzLNDqif3kq9z2wpdYEfQ=
 github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI=
@@ -1316,15 +1355,24 @@ github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P
 github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
 github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.12.0/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
 github.com/prometheus/client_golang v1.18.0/go.mod h1:T+GXkCk5wSJyOqMIzVgvvjFDlkOQntgjkJWKrN5txjA=
 github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w=
 github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
 github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
+github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/protolambda/bls12-381-util v0.0.0-20220416220906-d8552aa452c7/go.mod h1:IToEjHuttnUzwZI5KBSM/LOOW3qLbbrHOEfp3SbECGY=
+github.com/protolambda/bls12-381-util v0.1.0/go.mod h1:cdkysJTRpeFeuUVx/TXGDQNMTiRAalk1vQw3TYTHcE4=
+github.com/protolambda/messagediff v1.4.0/go.mod h1:LboJp0EwIbJsePYpzh5Op/9G1/4mIztMRYzzwR0dR2M=
+github.com/protolambda/zrnt v0.32.2/go.mod h1:A0fezkp9Tt3GBLATSPIbuY4ywYESyAuc/FFmPKg8Lqs=
+github.com/protolambda/ztyp v0.2.2/go.mod h1:9bYgKGqg3wJqT9ac1gI2hnVb0STQq7p/1lapqrqY1dU=
+github.com/prysmaticlabs/gohashtree v0.0.1-alpha.0.20220714111606-acbb2962fb48/go.mod h1:4pWaT30XoEx1j8KNJf3TV+E3mQkaufn7mf+jRNb/Fuk=
 github.com/rcrowley/go-metrics v0.0.0-20200313005456-10cdbea86bc0 h1:MkV+77GLUNo5oJ0jf870itWm3D0Sjh7+Za9gazKc5LQ=
 github.com/rcrowley/go-metrics v0.0.0-20200313005456-10cdbea86bc0/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
 github.com/retailnext/hllpp v1.0.1-0.20180308014038-101a6d2f8b52 h1:RnWNS9Hlm8BIkjr6wx8li5abe0fr73jljLycdfemTp0=
@@ -1357,8 +1405,6 @@ 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.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=
@@ -1371,6 +1417,7 @@ github.com/segmentio/kafka-go v0.2.0 h1:HtCSf6B4gN/87yc5qTl7WsxPKQIIGXLPPM1bMCPO
 github.com/segmentio/kafka-go v0.2.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=
 github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
 github.com/shurcooL/go v0.0.0-20200502201357-93f07166e636 h1:aSISeOcal5irEhJd1M+IrApc0PdcN7e7Aj4yuEnOrfQ=
 github.com/shurcooL/go v0.0.0-20200502201357-93f07166e636/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=
 github.com/shurcooL/httpfs v0.0.0-20190707220628-8d4bc4ba7749 h1:bUGsEnyNbVPw06Bs80sCeARAlK8lhwqGyi6UT8ymuGk=
@@ -1438,6 +1485,7 @@ github.com/valyala/fasthttp v1.40.0/go.mod h1:t/G+3rLek+CyY9bnIE+YlMRddxVAAGjhxn
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
 github.com/valyala/fasttemplate v1.2.1 h1:TVEnxayobAdVkhQfrfes2IzOB6o+z4roRkPF52WA1u4=
 github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
 github.com/vektah/gqlparser/v2 v2.4.5 h1:C02NsyEsL4TXJB7ndonqTfuQOL4XPIu0aAWugdmTgmc=
 github.com/vektah/gqlparser/v2 v2.4.5/go.mod h1:flJWIR04IMQPGz+BXLrORkrARBxv/rtyIAFvd/MceW0=
 github.com/veraison/go-cose v1.0.0-rc.1 h1:4qA7dbFJGvt7gcqv5MCIyCQvN+NpHFPkW7do3EeDLb8=
@@ -1550,6 +1598,7 @@ golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
+golang.org/x/crypto v0.2.0/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
 golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
 golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
 golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
@@ -1557,6 +1606,7 @@ golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq
 golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
 golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
 golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
 golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -1571,6 +1621,7 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/exp v0.0.0-20220426173459-3bcf042a4bf5/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
 golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b h1:+qEpEAPhDZ1o0x3tHzZTQDArnOixOzGD9HUJfcg0mb4=
@@ -1599,6 +1650,7 @@ golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -1638,6 +1690,7 @@ golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
 golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -1659,7 +1712,6 @@ golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
@@ -1719,6 +1771,7 @@ golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
@@ -1751,6 +1804,7 @@ golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxb
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.2.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -1801,8 +1855,10 @@ golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.7.0/go.mod h1:4pg6aUX35JBAogB10C9AtvVL+qowtN4pT3CGSQex14s=
+golang.org/x/tools v0.11.0/go.mod h1:anzJrxPjNtfgiYQYirP2CPGzGLxrH2u2QBhn6Bf3qY8=
 golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
 golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps=
+golang.org/x/tools v0.20.0/go.mod h1:WvitBU7JJf6A4jOdg4S1tviW9bhUxkgeCui/0JHctQg=
 golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 h1:H2TDz8ibqkAF6YGhCdN3jS9O0/s90v0rJh3X/OLHEUk=
 golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
 golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU=
@@ -1954,6 +2010,8 @@ gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2 h1:OAj3g0cR6Dx/R07QgQe8wkA9RNj
 gopkg.in/ini.v1 v1.62.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8=
 gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
 gopkg.in/olebedev/go-duktape.v3 v3.0.0-20200619000410-60c24ae608a6 h1:a6cXbcDDUkSBlpnkWV1bJ+vv3mOgQEltEJ2rPxroVu0=
 gopkg.in/olebedev/go-duktape.v3 v3.0.0-20200619000410-60c24ae608a6/go.mod h1:uAJfkITjFhyEEuUfm7bsmCZRbW5WRq8s9EY8HZ6hCns=
 gopkg.in/resty.v1 v1.12.0 h1:CuXP0Pjfw9rOuY6EP+UvtNvt5DSqHpIxILZKT/quCZI=

prover/Cargo.toml

@@ -1,50 +0,0 @@
-[package]
-name = "prover"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-
-[patch.crates-io]
-ethers-signers  = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
-halo2curves = { git = "https://github.com/scroll-tech/halo2curves", branch = "v0.1.0" }
-[patch."https://github.com/privacy-scaling-explorations/halo2.git"]
-halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1"  }
-[patch."https://github.com/privacy-scaling-explorations/poseidon.git"]
-poseidon = { git = "https://github.com/scroll-tech/poseidon.git", branch = "main" }
-[patch."https://github.com/privacy-scaling-explorations/bls12_381"]
-bls12_381 = { git = "https://github.com/scroll-tech/bls12_381", branch = "feat/impl_scalar_field" }
-
-
-[dependencies]
-anyhow = "1.0"
-log = "0.4"
-env_logger = "0.11.3"
-serde = { version = "1.0.198", features = ["derive"] }
-serde_json = "1.0.116"
-futures = "0.3.30"
-
-ethers-core = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
-ethers-providers = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
-halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1" }
-snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", branch = "develop", default-features = false, features = ["loader_halo2", "loader_evm", "halo2-pse"] }
-prover_darwin = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.2", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
-prover_darwin_v2 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.13.1", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
-scroll-proving-sdk = { git = "https://github.com/scroll-tech/scroll-proving-sdk.git", rev = "160db6c"}
-base64 = "0.13.1"
-reqwest = { version = "0.12.4", features = ["gzip"] }
-reqwest-middleware = "0.3"
-reqwest-retry = "0.5"
-once_cell = "1.19.0"
-hex = "0.4.3"
-tiny-keccak = { version = "2.0.0", features = ["sha3", "keccak"] }
-rand = "0.8.5"
-eth-keystore = "0.5.0"
-rlp = "0.5.2"
-tokio = "1.37.0"
-async-trait = "0.1"
-sled = "0.34.7"
-http = "1.1.0"
-clap = { version = "4.5", features = ["derive"] }
-ctor = "0.2.8"

prover/Makefile

@@ -1,48 +0,0 @@
-.PHONY: prover lint tests_binary
-
-ifeq (4.3,$(firstword $(sort $(MAKE_VERSION) 4.3)))
-    HALO2_VERSION=$(shell grep -m 1 "halo2.git" ./Cargo.lock | cut -d "#" -f2 | cut -c-7)
-else
-    HALO2_VERSION=$(shell grep -m 1 "halo2.git" ./Cargo.lock | cut -d "\#" -f2 | cut -c-7)
-endif
-
-ZKEVM_VERSION=$(shell ./print_high_zkevm_version.sh)
-ifeq (${ZKEVM_VERSION},)
-    $(error ZKEVM_VERSION not set)
-else
-    $(info ZKEVM_VERSION is ${ZKEVM_VERSION})
-endif
-
-ZKEVM_COMMIT=$(shell echo ${ZKEVM_VERSION} | cut -d " " -f2)
-$(info ZKEVM_COMMIT is ${ZKEVM_COMMIT})
-
-HALO2_GPU_VERSION=$(shell ./print_halo2gpu_version.sh | sed -n '2p')
-
-GIT_REV=$(shell git rev-parse --short HEAD)
-GO_TAG=$(shell grep "var tag = " ../common/version/version.go | cut -d "\"" -f2)
-
-ifeq (${GO_TAG},)
-    $(error GO_TAG not set)
-else
-    $(info GO_TAG is ${GO_TAG})
-endif
-
-ifeq (${HALO2_GPU_VERSION},)
-	# use halo2_proofs with CPU
-    ZK_VERSION=${ZKEVM_COMMIT}-${HALO2_VERSION}
-else
-	# use halo2_gpu
-    ZK_VERSION=${ZKEVM_COMMIT}-${HALO2_GPU_VERSION}
-endif
-
-prover:
-	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo build --release
-
-tests_binary:
-	cargo clean && cargo test --release --no-run
-	ls target/release/deps/prover* | grep -v "\.d" | xargs -I{} ln -sf {} ./prover.test
-
-lint:
-	cargo check --all-features
-	cargo clippy --all-features --all-targets -- -D warnings
-	cargo fmt --all

prover/config.json

@@ -1,30 +0,0 @@
-{
-  "sdk_config": {
-    "prover_name_prefix": "prover-1",
-    "keys_dir": "keys",
-    "coordinator": {
-      "base_url": "http://localhost:8555",
-      "retry_count": 10,
-      "retry_wait_time_sec": 10,
-      "connection_timeout_sec": 30
-    },
-    "l2geth": {
-      "endpoint": "http://localhost:9999"
-    },
-    "prover": {
-      "circuit_types": [1,2,3],
-      "circuit_version": "v0.13.1"
-    },
-    "db_path": "unique-db-path-for-prover-1"
-  },
-  "low_version_circuit": {
-    "hard_fork_name": "darwin",
-    "params_path": "params",
-    "assets_path": "assets"
-  },
-  "high_version_circuit": {
-    "hard_fork_name": "darwinV2",
-    "params_path": "params",
-    "assets_path": "assets"
-  }
-}

prover/print_halo2gpu_version.sh

@@ -1,21 +0,0 @@
-#!/bin/bash
-
-config_file="$HOME/.cargo/config"
-
-if [ ! -e "$config_file" ]; then
-    exit 0
-fi
-
-if [[ $(head -n 1 "$config_file") == "#"* ]]; then
-  exit 0
-fi
-
-halo2gpu_path=$(grep -Po '(?<=paths = \[")([^"]*)' $config_file)
-
-pushd $halo2gpu_path
-
-commit_hash=$(git log --pretty=format:%h -n 1)
-echo "${commit_hash:0:7}"
-
-popd
-

prover/print_high_zkevm_version.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-set -ue
-
-higher_zkevm_item=`grep "zkevm-circuits.git" ./Cargo.lock | sort | uniq | awk -F "[#=]" '{print $3" "$4}' | sort -k 1 | tail -n 1`
-
-higher_version=`echo $higher_zkevm_item | awk '{print $1}'`
-
-higher_commit=`echo $higher_zkevm_item | cut -d ' ' -f2 | cut -c-7`
-
-echo "$higher_version $higher_commit"

prover/rust-toolchain

@@ -1 +0,0 @@
-nightly-2023-12-03

prover/rustfmt.toml

@@ -1,9 +0,0 @@
-edition = "2021"
-
-comment_width = 100
-imports_granularity = "Crate"
-max_width = 100
-newline_style = "Unix"
-# normalize_comments = true
-reorder_imports = true
-wrap_comments = true

prover/src/config.rs

@@ -1,51 +0,0 @@
-use anyhow::{bail, Result};
-
-static SCROLL_PROVER_ASSETS_DIR_ENV_NAME: &str = "SCROLL_PROVER_ASSETS_DIR";
-static mut SCROLL_PROVER_ASSETS_DIRS: Vec<String> = vec![];
-
-#[derive(Debug)]
-pub struct AssetsDirEnvConfig {}
-
-impl AssetsDirEnvConfig {
-    pub fn init() -> Result<()> {
-        let value = std::env::var(SCROLL_PROVER_ASSETS_DIR_ENV_NAME)?;
-        let dirs: Vec<&str> = value.split(',').collect();
-        if dirs.len() != 2 {
-            bail!("env variable SCROLL_PROVER_ASSETS_DIR value must be 2 parts seperated by comma.")
-        }
-        unsafe {
-            SCROLL_PROVER_ASSETS_DIRS = dirs.into_iter().map(|s| s.to_string()).collect();
-            log::info!(
-                "init SCROLL_PROVER_ASSETS_DIRS: {:?}",
-                SCROLL_PROVER_ASSETS_DIRS
-            );
-        }
-        Ok(())
-    }
-
-    pub fn enable_first() {
-        unsafe {
-            log::info!(
-                "set env {SCROLL_PROVER_ASSETS_DIR_ENV_NAME} to {}",
-                &SCROLL_PROVER_ASSETS_DIRS[0]
-            );
-            std::env::set_var(
-                SCROLL_PROVER_ASSETS_DIR_ENV_NAME,
-                &SCROLL_PROVER_ASSETS_DIRS[0],
-            );
-        }
-    }
-
-    pub fn enable_second() {
-        unsafe {
-            log::info!(
-                "set env {SCROLL_PROVER_ASSETS_DIR_ENV_NAME} to {}",
-                &SCROLL_PROVER_ASSETS_DIRS[1]
-            );
-            std::env::set_var(
-                SCROLL_PROVER_ASSETS_DIR_ENV_NAME,
-                &SCROLL_PROVER_ASSETS_DIRS[1],
-            );
-        }
-    }
-}

prover/src/main.rs

@@ -1,76 +0,0 @@
-#![feature(lazy_cell)]
-#![feature(core_intrinsics)]
-
-mod config;
-mod prover;
-mod types;
-mod utils;
-mod zk_circuits_handler;
-
-use clap::{ArgAction, Parser};
-use prover::{LocalProver, LocalProverConfig};
-use scroll_proving_sdk::{
-    prover::ProverBuilder,
-    utils::{get_version, init_tracing},
-};
-use tokio::runtime;
-use utils::get_prover_type;
-
-#[derive(Parser, Debug)]
-#[command(disable_version_flag = true)]
-struct Args {
-    /// Path of config file
-    #[arg(long = "config", default_value = "conf/config.json")]
-    config_file: String,
-
-    /// Version of this prover
-    #[arg(short, long, action = ArgAction::SetTrue)]
-    version: bool,
-
-    /// Path of log file
-    #[arg(long = "log.file")]
-    log_file: Option<String>,
-}
-
-fn main() -> anyhow::Result<()> {
-    let rt = runtime::Builder::new_multi_thread()
-        .thread_stack_size(16 * 1024 * 1024) // Set stack size to 16MB
-        .enable_all()
-        .build()
-        .expect("Failed to create Tokio runtime");
-
-    rt.block_on(async {
-        init_tracing();
-
-        let args = Args::parse();
-
-        if args.version {
-            println!("version is {}", get_version());
-            std::process::exit(0);
-        }
-
-        let cfg = LocalProverConfig::from_file(args.config_file)?;
-        let sdk_config = cfg.sdk_config.clone();
-        let mut prover_types = vec![];
-        sdk_config
-            .prover
-            .circuit_types
-            .iter()
-            .for_each(|circuit_type| {
-                if let Some(pt) = get_prover_type(*circuit_type) {
-                    if !prover_types.contains(&pt) {
-                        prover_types.push(pt);
-                    }
-                }
-            });
-        let local_prover = LocalProver::new(cfg, prover_types);
-        let prover = ProverBuilder::new(sdk_config)
-            .with_proving_service(Box::new(local_prover))
-            .build()
-            .await?;
-
-        prover.run().await;
-
-        Ok(())
-    })
-}

prover/src/prover.rs

@@ -1,192 +0,0 @@
-use crate::{
-    types::ProverType,
-    utils::get_prover_type,
-    zk_circuits_handler::{CircuitsHandler, CircuitsHandlerProvider},
-};
-use anyhow::{anyhow, Result};
-use async_trait::async_trait;
-use scroll_proving_sdk::{
-    config::Config as SdkConfig,
-    prover::{
-        proving_service::{
-            GetVkRequest, GetVkResponse, ProveRequest, ProveResponse, QueryTaskRequest,
-            QueryTaskResponse, TaskStatus,
-        },
-        ProvingService,
-    },
-};
-use serde::{Deserialize, Serialize};
-use std::{
-    fs::File,
-    sync::{Arc, Mutex},
-    time::{SystemTime, UNIX_EPOCH},
-};
-use tokio::{runtime::Handle, sync::RwLock, task::JoinHandle};
-
-#[derive(Clone, Serialize, Deserialize)]
-pub struct LocalProverConfig {
-    pub sdk_config: SdkConfig,
-    pub high_version_circuit: CircuitConfig,
-    pub low_version_circuit: CircuitConfig,
-}
-
-impl LocalProverConfig {
-    pub fn from_reader<R>(reader: R) -> Result<Self>
-    where
-        R: std::io::Read,
-    {
-        serde_json::from_reader(reader).map_err(|e| anyhow!(e))
-    }
-
-    pub fn from_file(file_name: String) -> Result<Self> {
-        let file = File::open(file_name)?;
-        Self::from_reader(&file)
-    }
-}
-
-#[derive(Clone, Serialize, Deserialize)]
-pub struct CircuitConfig {
-    pub hard_fork_name: String,
-    pub params_path: String,
-    pub assets_path: String,
-}
-
-pub struct LocalProver {
-    config: LocalProverConfig,
-    prover_types: Vec<ProverType>,
-    circuits_handler_provider: RwLock<CircuitsHandlerProvider>,
-    next_task_id: Arc<Mutex<u64>>,
-    current_task: Arc<Mutex<Option<JoinHandle<Result<String>>>>>,
-}
-
-#[async_trait]
-impl ProvingService for LocalProver {
-    fn is_local(&self) -> bool {
-        true
-    }
-    async fn get_vks(&self, req: GetVkRequest) -> GetVkResponse {
-        let mut prover_types = vec![];
-        req.circuit_types.iter().for_each(|circuit_type| {
-            if let Some(pt) = get_prover_type(*circuit_type) {
-                if !prover_types.contains(&pt) {
-                    prover_types.push(pt);
-                }
-            }
-        });
-
-        let vks = self
-            .circuits_handler_provider
-            .read()
-            .await
-            .init_vks(&self.config, prover_types)
-            .await;
-        GetVkResponse { vks, error: None }
-    }
-    async fn prove(&self, req: ProveRequest) -> ProveResponse {
-        let handler = self
-            .circuits_handler_provider
-            .write()
-            .await
-            .get_circuits_handler(&req.hard_fork_name, self.prover_types.clone())
-            .expect("failed to get circuit handler");
-
-        match self.do_prove(req, handler).await {
-            Ok(resp) => resp,
-            Err(e) => ProveResponse {
-                status: TaskStatus::Failed,
-                error: Some(format!("failed to request proof: {}", e)),
-                ..Default::default()
-            },
-        }
-    }
-
-    async fn query_task(&self, req: QueryTaskRequest) -> QueryTaskResponse {
-        let handle = self.current_task.lock().unwrap().take();
-        if let Some(handle) = handle {
-            if handle.is_finished() {
-                return match handle.await {
-                    Ok(Ok(proof)) => QueryTaskResponse {
-                        task_id: req.task_id,
-                        status: TaskStatus::Success,
-                        proof: Some(proof),
-                        ..Default::default()
-                    },
-                    Ok(Err(e)) => QueryTaskResponse {
-                        task_id: req.task_id,
-                        status: TaskStatus::Failed,
-                        error: Some(format!("proving task failed: {}", e)),
-                        ..Default::default()
-                    },
-                    Err(e) => QueryTaskResponse {
-                        task_id: req.task_id,
-                        status: TaskStatus::Failed,
-                        error: Some(format!("proving task panicked: {}", e)),
-                        ..Default::default()
-                    },
-                };
-            } else {
-                *self.current_task.lock().unwrap() = Some(handle);
-                return QueryTaskResponse {
-                    task_id: req.task_id,
-                    status: TaskStatus::Proving,
-                    ..Default::default()
-                };
-            }
-        }
-        // If no handle is found
-        QueryTaskResponse {
-            task_id: req.task_id,
-            status: TaskStatus::Failed,
-            error: Some("no proving task is running".to_string()),
-            ..Default::default()
-        }
-    }
-}
-
-impl LocalProver {
-    pub fn new(config: LocalProverConfig, prover_types: Vec<ProverType>) -> Self {
-        let circuits_handler_provider = CircuitsHandlerProvider::new(config.clone())
-            .expect("failed to create circuits handler provider");
-
-        Self {
-            config,
-            prover_types,
-            circuits_handler_provider: RwLock::new(circuits_handler_provider),
-            next_task_id: Arc::new(Mutex::new(0)),
-            current_task: Arc::new(Mutex::new(None)),
-        }
-    }
-
-    async fn do_prove(
-        &self,
-        req: ProveRequest,
-        handler: Arc<Box<dyn CircuitsHandler>>,
-    ) -> Result<ProveResponse> {
-        let task_id = {
-            let mut next_task_id = self.next_task_id.lock().unwrap();
-            *next_task_id += 1;
-            *next_task_id
-        };
-
-        let duration = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-        let created_at = duration.as_secs() as f64 + duration.subsec_nanos() as f64 * 1e-9;
-
-        let req_clone = req.clone();
-        let handle = Handle::current();
-        let task_handle =
-            tokio::task::spawn_blocking(move || handle.block_on(handler.get_proof_data(req_clone)));
-
-        *self.current_task.lock().unwrap() = Some(task_handle);
-
-        Ok(ProveResponse {
-            task_id: task_id.to_string(),
-            circuit_type: req.circuit_type,
-            circuit_version: req.circuit_version,
-            hard_fork_name: req.hard_fork_name,
-            status: TaskStatus::Proving,
-            created_at,
-            input: Some(req.input),
-            ..Default::default()
-        })
-    }
-}

prover/src/types.rs

@@ -1,153 +0,0 @@
-use ethers_core::types::H256;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-use scroll_proving_sdk::prover::types::CircuitType;
-
-pub type CommonHash = H256;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum ProverType {
-    Chunk,
-    Batch,
-}
-
-impl ProverType {
-    fn from_u8(v: u8) -> Self {
-        match v {
-            1 => ProverType::Chunk,
-            2 => ProverType::Batch,
-            _ => {
-                panic!("invalid prover_type")
-            }
-        }
-    }
-}
-
-impl Serialize for ProverType {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            ProverType::Chunk => serializer.serialize_u8(1),
-            ProverType::Batch => serializer.serialize_u8(2),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for ProverType {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let v: u8 = u8::deserialize(deserializer)?;
-        Ok(ProverType::from_u8(v))
-    }
-}
-
-#[derive(Serialize, Deserialize, Default)]
-pub struct Task {
-    #[serde(rename = "type", default)]
-    pub task_type: CircuitType,
-    pub task_data: String,
-    #[serde(default)]
-    pub hard_fork_name: String,
-}
-
-#[derive(Serialize, Deserialize, Default)]
-pub struct ProofDetail {
-    pub id: String,
-    #[serde(rename = "type", default)]
-    pub proof_type: CircuitType,
-    pub proof_data: String,
-    pub error: String,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum ProofFailureType {
-    Undefined,
-    Panic,
-    NoPanic,
-}
-
-impl ProofFailureType {
-    fn from_u8(v: u8) -> Self {
-        match v {
-            1 => ProofFailureType::Panic,
-            2 => ProofFailureType::NoPanic,
-            _ => ProofFailureType::Undefined,
-        }
-    }
-}
-
-impl Serialize for ProofFailureType {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            ProofFailureType::Undefined => serializer.serialize_u8(0),
-            ProofFailureType::Panic => serializer.serialize_u8(1),
-            ProofFailureType::NoPanic => serializer.serialize_u8(2),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for ProofFailureType {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let v: u8 = u8::deserialize(deserializer)?;
-        Ok(ProofFailureType::from_u8(v))
-    }
-}
-
-impl Default for ProofFailureType {
-    fn default() -> Self {
-        Self::Undefined
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum ProofStatus {
-    Ok,
-    Error,
-}
-
-impl ProofStatus {
-    fn from_u8(v: u8) -> Self {
-        match v {
-            0 => ProofStatus::Ok,
-            _ => ProofStatus::Error,
-        }
-    }
-}
-
-impl Serialize for ProofStatus {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            ProofStatus::Ok => serializer.serialize_u8(0),
-            ProofStatus::Error => serializer.serialize_u8(1),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for ProofStatus {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let v: u8 = u8::deserialize(deserializer)?;
-        Ok(ProofStatus::from_u8(v))
-    }
-}
-
-impl Default for ProofStatus {
-    fn default() -> Self {
-        Self::Ok
-    }
-}

prover/src/utils.rs

@@ -1,18 +0,0 @@
-use crate::types::ProverType;
-use scroll_proving_sdk::prover::types::CircuitType;
-
-pub fn get_circuit_types(prover_type: ProverType) -> Vec<CircuitType> {
-    match prover_type {
-        ProverType::Chunk => vec![CircuitType::Chunk],
-        ProverType::Batch => vec![CircuitType::Batch, CircuitType::Bundle],
-    }
-}
-
-pub fn get_prover_type(task_type: CircuitType) -> Option<ProverType> {
-    match task_type {
-        CircuitType::Undefined => None,
-        CircuitType::Chunk => Some(ProverType::Chunk),
-        CircuitType::Batch => Some(ProverType::Batch),
-        CircuitType::Bundle => Some(ProverType::Batch),
-    }
-}

prover/src/zk_circuits_handler.rs

@@ -1,165 +0,0 @@
-mod common;
-mod darwin;
-mod darwin_v2;
-
-use crate::{
-    config::AssetsDirEnvConfig, prover::LocalProverConfig, types::ProverType,
-    utils::get_circuit_types,
-};
-use anyhow::{bail, Result};
-use async_trait::async_trait;
-use darwin::DarwinHandler;
-use darwin_v2::DarwinV2Handler;
-use scroll_proving_sdk::prover::{proving_service::ProveRequest, CircuitType};
-use std::{collections::HashMap, sync::Arc};
-
-type HardForkName = String;
-
-pub mod utils {
-    pub fn encode_vk(vk: Vec<u8>) -> String {
-        base64::encode(vk)
-    }
-}
-
-#[async_trait]
-pub trait CircuitsHandler: Send + Sync {
-    async fn get_vk(&self, task_type: CircuitType) -> Option<Vec<u8>>;
-
-    async fn get_proof_data(&self, prove_request: ProveRequest) -> Result<String>;
-}
-
-type CircuitsHandlerBuilder = fn(
-    prover_types: Vec<ProverType>,
-    config: &LocalProverConfig,
-) -> Result<Box<dyn CircuitsHandler>>;
-
-pub struct CircuitsHandlerProvider {
-    config: LocalProverConfig,
-    circuits_handler_builder_map: HashMap<HardForkName, CircuitsHandlerBuilder>,
-    current_fork_name: Option<HardForkName>,
-    current_circuit: Option<Arc<Box<dyn CircuitsHandler>>>,
-}
-
-impl CircuitsHandlerProvider {
-    pub fn new(config: LocalProverConfig) -> Result<Self> {
-        let mut m: HashMap<HardForkName, CircuitsHandlerBuilder> = HashMap::new();
-
-        if let Err(e) = AssetsDirEnvConfig::init() {
-            panic!("AssetsDirEnvConfig init failed: {:#}", e);
-        }
-
-        fn handler_builder(
-            prover_types: Vec<ProverType>,
-            config: &LocalProverConfig,
-        ) -> Result<Box<dyn CircuitsHandler>> {
-            log::info!(
-                "now init zk circuits handler, hard_fork_name: {}",
-                &config.low_version_circuit.hard_fork_name
-            );
-            AssetsDirEnvConfig::enable_first();
-            DarwinHandler::new(
-                prover_types,
-                &config.low_version_circuit.params_path,
-                &config.low_version_circuit.assets_path,
-            )
-            .map(|handler| Box::new(handler) as Box<dyn CircuitsHandler>)
-        }
-        m.insert(
-            config.low_version_circuit.hard_fork_name.clone(),
-            handler_builder,
-        );
-
-        fn next_handler_builder(
-            prover_types: Vec<ProverType>,
-            config: &LocalProverConfig,
-        ) -> Result<Box<dyn CircuitsHandler>> {
-            log::info!(
-                "now init zk circuits handler, hard_fork_name: {}",
-                &config.high_version_circuit.hard_fork_name
-            );
-            AssetsDirEnvConfig::enable_second();
-            DarwinV2Handler::new(
-                prover_types,
-                &config.high_version_circuit.params_path,
-                &config.high_version_circuit.assets_path,
-            )
-            .map(|handler| Box::new(handler) as Box<dyn CircuitsHandler>)
-        }
-
-        m.insert(
-            config.high_version_circuit.hard_fork_name.clone(),
-            next_handler_builder,
-        );
-
-        let provider = CircuitsHandlerProvider {
-            config,
-            circuits_handler_builder_map: m,
-            current_fork_name: None,
-            current_circuit: None,
-        };
-
-        Ok(provider)
-    }
-
-    pub fn get_circuits_handler(
-        &mut self,
-        hard_fork_name: &String,
-        prover_types: Vec<ProverType>,
-    ) -> Result<Arc<Box<dyn CircuitsHandler>>> {
-        match &self.current_fork_name {
-            Some(fork_name) if fork_name == hard_fork_name => {
-                log::info!("get circuits handler from cache");
-                if let Some(handler) = &self.current_circuit {
-                    Ok(handler.clone())
-                } else {
-                    bail!("missing cached handler, there must be something wrong.")
-                }
-            }
-            _ => {
-                log::info!(
-                    "failed to get circuits handler from cache, create a new one: {hard_fork_name}"
-                );
-                if let Some(builder) = self.circuits_handler_builder_map.get(hard_fork_name) {
-                    log::info!("building circuits handler for {hard_fork_name}");
-                    let handler = builder(prover_types, &self.config)
-                        .expect("failed to build circuits handler");
-                    self.current_fork_name = Some(hard_fork_name.clone());
-                    let arc_handler = Arc::new(handler);
-                    self.current_circuit = Some(arc_handler.clone());
-                    Ok(arc_handler)
-                } else {
-                    bail!("missing builder, there must be something wrong.")
-                }
-            }
-        }
-    }
-
-    pub async fn init_vks(
-        &self,
-        config: &LocalProverConfig,
-        prover_types: Vec<ProverType>,
-    ) -> Vec<String> {
-        let mut vks = Vec::new();
-        for (hard_fork_name, build) in self.circuits_handler_builder_map.iter() {
-            let handler =
-                build(prover_types.clone(), config).expect("failed to build circuits handler");
-
-            for prover_type in prover_types.iter() {
-                for task_type in get_circuit_types(*prover_type).into_iter() {
-                    let vk = handler
-                        .get_vk(task_type)
-                        .await
-                        .map_or("".to_string(), utils::encode_vk);
-                    log::info!(
-                        "vk for {hard_fork_name}, is {vk}, task_type: {:?}",
-                        task_type
-                    );
-                    if !vk.is_empty() {
-                        vks.push(vk)
-                    }
-                }
-            }
-        }
-        vks
-    }
-}

prover/src/zk_circuits_handler/common.rs

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

prover/src/zk_circuits_handler/darwin.rs

@@ -1,401 +0,0 @@
-use super::{common::*, CircuitsHandler};
-use crate::types::ProverType;
-use anyhow::{bail, Context, Ok, Result};
-use async_trait::async_trait;
-use once_cell::sync::Lazy;
-use scroll_proving_sdk::prover::{proving_service::ProveRequest, CircuitType};
-use serde::Deserialize;
-use tokio::sync::RwLock;
-
-use crate::types::CommonHash;
-use std::env;
-
-use prover_darwin::{
-    aggregator::Prover as BatchProver,
-    check_chunk_hashes,
-    common::Prover as CommonProver,
-    config::{AGG_DEGREES, ZKEVM_DEGREES},
-    zkevm::Prover as ChunkProver,
-    BatchProof, BatchProvingTask, BlockTrace, BundleProof, BundleProvingTask, ChunkInfo,
-    ChunkProof, ChunkProvingTask,
-};
-
-// Only used for debugging.
-static OUTPUT_DIR: Lazy<Option<String>> = Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct BatchTaskDetail {
-    pub chunk_infos: Vec<ChunkInfo>,
-    #[serde(flatten)]
-    pub batch_proving_task: BatchProvingTask,
-}
-
-type BundleTaskDetail = BundleProvingTask;
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct ChunkTaskDetail {
-    pub block_hashes: Vec<CommonHash>,
-}
-
-#[derive(Default)]
-pub struct DarwinHandler {
-    chunk_prover: Option<RwLock<ChunkProver<'static>>>,
-    batch_prover: Option<RwLock<BatchProver<'static>>>,
-}
-
-impl DarwinHandler {
-    pub fn new_multi(
-        prover_types: Vec<ProverType>,
-        params_dir: &str,
-        assets_dir: &str,
-    ) -> Result<Self> {
-        let class_name = std::intrinsics::type_name::<Self>();
-        let prover_types_set = prover_types
-            .into_iter()
-            .collect::<std::collections::HashSet<ProverType>>();
-        let mut handler = Self {
-            batch_prover: None,
-            chunk_prover: None,
-        };
-        let degrees: Vec<u32> = get_degrees(&prover_types_set, |prover_type| match prover_type {
-            ProverType::Chunk => ZKEVM_DEGREES.clone(),
-            ProverType::Batch => AGG_DEGREES.clone(),
-        });
-        let params_map = get_params_map_instance(|| {
-            log::info!(
-                "calling get_params_map from {}, prover_types: {:?}, degrees: {:?}",
-                class_name,
-                prover_types_set,
-                degrees
-            );
-            CommonProver::load_params_map(params_dir, &degrees)
-        });
-        for prover_type in prover_types_set {
-            match prover_type {
-                ProverType::Chunk => {
-                    handler.chunk_prover = Some(RwLock::new(ChunkProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )));
-                }
-                ProverType::Batch => {
-                    handler.batch_prover = Some(RwLock::new(BatchProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )))
-                }
-            }
-        }
-        Ok(handler)
-    }
-
-    pub fn new(prover_types: Vec<ProverType>, params_dir: &str, assets_dir: &str) -> Result<Self> {
-        Self::new_multi(prover_types, params_dir, assets_dir)
-    }
-
-    async fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
-        if let Some(prover) = self.chunk_prover.as_ref() {
-            let chunk = ChunkProvingTask::from(chunk_trace);
-
-            let chunk_proof =
-                prover
-                    .write()
-                    .await
-                    .gen_chunk_proof(chunk, None, None, self.get_output_dir())?;
-
-            return Ok(chunk_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    async fn gen_chunk_proof(&self, prove_request: ProveRequest) -> Result<String> {
-        let chunk_traces: Vec<BlockTrace> = serde_json::from_str(&prove_request.input)?;
-        let chunk_proof = self.gen_chunk_proof_raw(chunk_traces).await?;
-        Ok(serde_json::to_string(&chunk_proof)?)
-    }
-
-    async fn gen_batch_proof_raw(&self, batch_task_detail: BatchTaskDetail) -> Result<BatchProof> {
-        if let Some(prover) = self.batch_prover.as_ref() {
-            let chunk_hashes_proofs: Vec<(ChunkInfo, ChunkProof)> = batch_task_detail
-                .chunk_infos
-                .clone()
-                .into_iter()
-                .zip(batch_task_detail.batch_proving_task.chunk_proofs.clone())
-                .collect();
-
-            let chunk_proofs: Vec<ChunkProof> =
-                chunk_hashes_proofs.iter().map(|t| t.1.clone()).collect();
-
-            let is_valid = prover.read().await.check_protocol_of_chunks(&chunk_proofs);
-
-            if !is_valid {
-                bail!("non-match chunk protocol")
-            }
-            check_chunk_hashes("", &chunk_hashes_proofs).context("failed to check chunk info")?;
-            let batch_proof = prover.write().await.gen_batch_proof(
-                batch_task_detail.batch_proving_task,
-                None,
-                self.get_output_dir(),
-            )?;
-
-            return Ok(batch_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    async fn gen_batch_proof(&self, prove_request: ProveRequest) -> Result<String> {
-        let batch_task_detail: BatchTaskDetail = serde_json::from_str(&prove_request.input)?;
-        let batch_proof = self.gen_batch_proof_raw(batch_task_detail).await?;
-        Ok(serde_json::to_string(&batch_proof)?)
-    }
-
-    async fn gen_bundle_proof_raw(
-        &self,
-        bundle_task_detail: BundleTaskDetail,
-    ) -> Result<BundleProof> {
-        if let Some(prover) = self.batch_prover.as_ref() {
-            let bundle_proof = prover.write().await.gen_bundle_proof(
-                bundle_task_detail,
-                None,
-                self.get_output_dir(),
-            )?;
-
-            return Ok(bundle_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    async fn gen_bundle_proof(&self, prove_request: ProveRequest) -> Result<String> {
-        let bundle_task_detail: BundleTaskDetail = serde_json::from_str(&prove_request.input)?;
-        let bundle_proof = self.gen_bundle_proof_raw(bundle_task_detail).await?;
-        Ok(serde_json::to_string(&bundle_proof)?)
-    }
-
-    fn get_output_dir(&self) -> Option<&str> {
-        OUTPUT_DIR.as_deref()
-    }
-}
-
-#[async_trait]
-impl CircuitsHandler for DarwinHandler {
-    async fn get_vk(&self, task_type: CircuitType) -> Option<Vec<u8>> {
-        match task_type {
-            CircuitType::Chunk => self.chunk_prover.as_ref().unwrap().read().await.get_vk(),
-            CircuitType::Batch => self
-                .batch_prover
-                .as_ref()
-                .unwrap()
-                .read()
-                .await
-                .get_batch_vk(),
-            CircuitType::Bundle => self
-                .batch_prover
-                .as_ref()
-                .unwrap()
-                .read()
-                .await
-                .get_bundle_vk(),
-            _ => unreachable!(),
-        }
-    }
-
-    async fn get_proof_data(&self, prove_request: ProveRequest) -> Result<String> {
-        match prove_request.circuit_type {
-            CircuitType::Chunk => self.gen_chunk_proof(prove_request).await,
-            CircuitType::Batch => self.gen_batch_proof(prove_request).await,
-            CircuitType::Bundle => self.gen_bundle_proof(prove_request).await,
-            _ => unreachable!(),
-        }
-    }
-}
-
-// =================================== tests module ========================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::zk_circuits_handler::utils::encode_vk;
-    use prover_darwin::utils::chunk_trace_to_witness_block;
-    use scroll_proving_sdk::utils::init_tracing;
-    use std::{path::PathBuf, sync::LazyLock};
-
-    #[ctor::ctor]
-    fn init() {
-        init_tracing();
-        log::info!("logger initialized");
-    }
-
-    static DEFAULT_WORK_DIR: &str = "/assets";
-    static WORK_DIR: LazyLock<String> = LazyLock::new(|| {
-        std::env::var("DARWIN_TEST_DIR")
-            .unwrap_or(String::from(DEFAULT_WORK_DIR))
-            .trim_end_matches('/')
-            .to_string()
-    });
-    static PARAMS_PATH: LazyLock<String> = LazyLock::new(|| format!("{}/test_params", *WORK_DIR));
-    static ASSETS_PATH: LazyLock<String> = LazyLock::new(|| format!("{}/test_assets", *WORK_DIR));
-    static PROOF_DUMP_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/proof_data", *WORK_DIR));
-    static BATCH_DIR_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/traces/batch_24", *WORK_DIR));
-    static BATCH_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_batch.vkey", *WORK_DIR));
-    static CHUNK_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_chunk.vkey", *WORK_DIR));
-
-    #[test]
-    fn it_works() {
-        let result = true;
-        assert!(result);
-    }
-
-    #[tokio::test]
-    async fn test_circuits() -> Result<()> {
-        let bi_handler = DarwinHandler::new_multi(
-            vec![ProverType::Chunk, ProverType::Batch],
-            &PARAMS_PATH,
-            &ASSETS_PATH,
-        )?;
-
-        let chunk_handler = bi_handler;
-        let chunk_vk = chunk_handler.get_vk(CircuitType::Chunk).await.unwrap();
-
-        check_vk(CircuitType::Chunk, chunk_vk, "chunk vk must be available");
-        let chunk_dir_paths = get_chunk_dir_paths()?;
-        log::info!("chunk_dir_paths, {:?}", chunk_dir_paths);
-        let mut chunk_infos = vec![];
-        let mut chunk_proofs = vec![];
-        for (id, chunk_path) in chunk_dir_paths.into_iter().enumerate() {
-            let chunk_id = format!("chunk_proof{}", id + 1);
-            log::info!("start to process {chunk_id}");
-            let chunk_trace = read_chunk_trace(chunk_path)?;
-
-            let chunk_info = traces_to_chunk_info(chunk_trace.clone())?;
-            chunk_infos.push(chunk_info);
-
-            log::info!("start to prove {chunk_id}");
-            let chunk_proof = chunk_handler.gen_chunk_proof_raw(chunk_trace).await?;
-            let proof_data = serde_json::to_string(&chunk_proof)?;
-            dump_proof(chunk_id, proof_data)?;
-            chunk_proofs.push(chunk_proof);
-        }
-
-        let batch_handler = chunk_handler;
-        let batch_vk = batch_handler.get_vk(CircuitType::Batch).await.unwrap();
-        check_vk(CircuitType::Batch, batch_vk, "batch vk must be available");
-        let batch_task_detail = make_batch_task_detail(chunk_infos, chunk_proofs);
-        log::info!("start to prove batch");
-        let batch_proof = batch_handler.gen_batch_proof_raw(batch_task_detail).await?;
-        let proof_data = serde_json::to_string(&batch_proof)?;
-        dump_proof("batch_proof".to_string(), proof_data)?;
-
-        Ok(())
-    }
-
-    fn make_batch_task_detail(_: Vec<ChunkInfo>, _: Vec<ChunkProof>) -> BatchTaskDetail {
-        todo!();
-        // BatchTaskDetail {
-        //     chunk_infos,
-        //     batch_proving_task: BatchProvingTask {
-        //         parent_batch_hash: todo!(),
-        //         parent_state_root: todo!(),
-        //         batch_header: todo!(),
-        //         chunk_proofs,
-        //     },
-        // }
-    }
-
-    fn check_vk(proof_type: CircuitType, vk: Vec<u8>, info: &str) {
-        log::info!("check_vk, {:?}", proof_type);
-        let vk_from_file = read_vk(proof_type).unwrap();
-        assert_eq!(vk_from_file, encode_vk(vk), "{info}")
-    }
-
-    fn read_vk(proof_type: CircuitType) -> Result<String> {
-        log::info!("read_vk, {:?}", proof_type);
-        let vk_file = match proof_type {
-            CircuitType::Chunk => CHUNK_VK_PATH.clone(),
-            CircuitType::Batch => BATCH_VK_PATH.clone(),
-            CircuitType::Bundle => todo!(),
-            CircuitType::Undefined => unreachable!(),
-        };
-
-        let data = std::fs::read(vk_file)?;
-        Ok(encode_vk(data))
-    }
-
-    fn read_chunk_trace(path: PathBuf) -> Result<Vec<BlockTrace>> {
-        log::info!("read_chunk_trace, {:?}", path);
-        let mut chunk_trace: Vec<BlockTrace> = vec![];
-
-        fn read_block_trace(file: &PathBuf) -> Result<BlockTrace> {
-            let f = std::fs::File::open(file)?;
-            Ok(serde_json::from_reader(&f)?)
-        }
-
-        if path.is_dir() {
-            let entries = std::fs::read_dir(&path)?;
-            let mut files: Vec<String> = entries
-                .into_iter()
-                .filter_map(|e| {
-                    if e.is_err() {
-                        return None;
-                    }
-                    let entry = e.unwrap();
-                    if entry.path().is_dir() {
-                        return None;
-                    }
-                    if let Result::Ok(file_name) = entry.file_name().into_string() {
-                        Some(file_name)
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            files.sort();
-
-            log::info!("files in chunk {:?} is {:?}", path, files);
-            for file in files {
-                let block_trace = read_block_trace(&path.join(file))?;
-                chunk_trace.push(block_trace);
-            }
-        } else {
-            let block_trace = read_block_trace(&path)?;
-            chunk_trace.push(block_trace);
-        }
-        Ok(chunk_trace)
-    }
-
-    fn get_chunk_dir_paths() -> Result<Vec<PathBuf>> {
-        let batch_path = PathBuf::from(BATCH_DIR_PATH.clone());
-        let entries = std::fs::read_dir(&batch_path)?;
-        let mut files: Vec<String> = entries
-            .filter_map(|e| {
-                if e.is_err() {
-                    return None;
-                }
-                let entry = e.unwrap();
-                if entry.path().is_dir() {
-                    if let Result::Ok(file_name) = entry.file_name().into_string() {
-                        Some(file_name)
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                }
-            })
-            .collect();
-        files.sort();
-        log::info!("files in batch {:?} is {:?}", batch_path, files);
-        Ok(files.into_iter().map(|f| batch_path.join(f)).collect())
-    }
-
-    fn traces_to_chunk_info(chunk_trace: Vec<BlockTrace>) -> Result<ChunkInfo> {
-        let witness_block = chunk_trace_to_witness_block(chunk_trace)?;
-        Ok(ChunkInfo::from_witness_block(&witness_block, false))
-    }
-
-    fn dump_proof(id: String, proof_data: String) -> Result<()> {
-        let dump_path = PathBuf::from(PROOF_DUMP_PATH.clone());
-        Ok(std::fs::write(dump_path.join(id), proof_data)?)
-    }
-}

prover/src/zk_circuits_handler/darwin_v2.rs

@@ -1,459 +0,0 @@
-use super::{common::*, CircuitsHandler};
-use crate::types::ProverType;
-use anyhow::{bail, Context, Ok, Result};
-use async_trait::async_trait;
-use once_cell::sync::Lazy;
-use scroll_proving_sdk::prover::{proving_service::ProveRequest, CircuitType};
-use serde::Deserialize;
-use tokio::sync::RwLock;
-
-use crate::types::CommonHash;
-use std::env;
-
-use prover_darwin_v2::{
-    aggregator::Prover as BatchProver,
-    check_chunk_hashes,
-    common::Prover as CommonProver,
-    config::{AGG_DEGREES, ZKEVM_DEGREES},
-    zkevm::Prover as ChunkProver,
-    BatchProof, BatchProvingTask, BlockTrace, BundleProof, BundleProvingTask, ChunkInfo,
-    ChunkProof, ChunkProvingTask,
-};
-
-// Only used for debugging.
-static OUTPUT_DIR: Lazy<Option<String>> = Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct BatchTaskDetail {
-    pub chunk_infos: Vec<ChunkInfo>,
-    #[serde(flatten)]
-    pub batch_proving_task: BatchProvingTask,
-}
-
-type BundleTaskDetail = BundleProvingTask;
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct ChunkTaskDetail {
-    pub block_hashes: Vec<CommonHash>,
-}
-
-#[derive(Default)]
-pub struct DarwinV2Handler {
-    chunk_prover: Option<RwLock<ChunkProver<'static>>>,
-    batch_prover: Option<RwLock<BatchProver<'static>>>,
-}
-
-impl DarwinV2Handler {
-    pub fn new_multi(
-        prover_types: Vec<ProverType>,
-        params_dir: &str,
-        assets_dir: &str,
-    ) -> Result<Self> {
-        let class_name = std::intrinsics::type_name::<Self>();
-        let prover_types_set = prover_types
-            .into_iter()
-            .collect::<std::collections::HashSet<ProverType>>();
-        let mut handler = Self {
-            batch_prover: None,
-            chunk_prover: None,
-        };
-        let degrees: Vec<u32> = get_degrees(&prover_types_set, |prover_type| match prover_type {
-            ProverType::Chunk => ZKEVM_DEGREES.clone(),
-            ProverType::Batch => AGG_DEGREES.clone(),
-        });
-        let params_map = get_params_map_instance(|| {
-            log::info!(
-                "calling get_params_map from {}, prover_types: {:?}, degrees: {:?}",
-                class_name,
-                prover_types_set,
-                degrees
-            );
-            CommonProver::load_params_map(params_dir, &degrees)
-        });
-        for prover_type in prover_types_set {
-            match prover_type {
-                ProverType::Chunk => {
-                    handler.chunk_prover = Some(RwLock::new(ChunkProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )));
-                }
-                ProverType::Batch => {
-                    handler.batch_prover = Some(RwLock::new(BatchProver::from_params_and_assets(
-                        params_map, assets_dir,
-                    )))
-                }
-            }
-        }
-        Ok(handler)
-    }
-
-    pub fn new(prover_types: Vec<ProverType>, params_dir: &str, assets_dir: &str) -> Result<Self> {
-        Self::new_multi(prover_types, params_dir, assets_dir)
-    }
-
-    async fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
-        if let Some(prover) = self.chunk_prover.as_ref() {
-            let chunk = ChunkProvingTask::from(chunk_trace);
-
-            let chunk_proof =
-                prover
-                    .write()
-                    .await
-                    .gen_chunk_proof(chunk, None, None, self.get_output_dir())?;
-
-            return Ok(chunk_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    async fn gen_chunk_proof(&self, prove_request: ProveRequest) -> Result<String> {
-        let chunk_traces: Vec<BlockTrace> = serde_json::from_str(&prove_request.input)?;
-        let chunk_proof = self.gen_chunk_proof_raw(chunk_traces).await?;
-        Ok(serde_json::to_string(&chunk_proof)?)
-    }
-
-    async fn gen_batch_proof_raw(&self, batch_task_detail: BatchTaskDetail) -> Result<BatchProof> {
-        if let Some(prover) = self.batch_prover.as_ref() {
-            let chunk_hashes_proofs: Vec<(ChunkInfo, ChunkProof)> = batch_task_detail
-                .chunk_infos
-                .clone()
-                .into_iter()
-                .zip(batch_task_detail.batch_proving_task.chunk_proofs.clone())
-                .collect();
-
-            let chunk_proofs: Vec<ChunkProof> =
-                chunk_hashes_proofs.iter().map(|t| t.1.clone()).collect();
-
-            let is_valid = prover.write().await.check_protocol_of_chunks(&chunk_proofs);
-
-            if !is_valid {
-                bail!("non-match chunk protocol")
-            }
-            check_chunk_hashes("", &chunk_hashes_proofs).context("failed to check chunk info")?;
-            let batch_proof = prover.write().await.gen_batch_proof(
-                batch_task_detail.batch_proving_task,
-                None,
-                self.get_output_dir(),
-            )?;
-
-            return Ok(batch_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    async fn gen_batch_proof(&self, prove_request: ProveRequest) -> Result<String> {
-        let batch_task_detail: BatchTaskDetail = serde_json::from_str(&prove_request.input)?;
-        let batch_proof = self.gen_batch_proof_raw(batch_task_detail).await?;
-        Ok(serde_json::to_string(&batch_proof)?)
-    }
-
-    async fn gen_bundle_proof_raw(
-        &self,
-        bundle_task_detail: BundleTaskDetail,
-    ) -> Result<BundleProof> {
-        if let Some(prover) = self.batch_prover.as_ref() {
-            let bundle_proof = prover.write().await.gen_bundle_proof(
-                bundle_task_detail,
-                None,
-                self.get_output_dir(),
-            )?;
-
-            return Ok(bundle_proof);
-        }
-        unreachable!("please check errors in proof_type logic")
-    }
-
-    async fn gen_bundle_proof(&self, prove_request: ProveRequest) -> Result<String> {
-        let bundle_task_detail: BundleTaskDetail = serde_json::from_str(&prove_request.input)?;
-        let bundle_proof = self.gen_bundle_proof_raw(bundle_task_detail).await?;
-        Ok(serde_json::to_string(&bundle_proof)?)
-    }
-
-    fn get_output_dir(&self) -> Option<&str> {
-        OUTPUT_DIR.as_deref()
-    }
-}
-
-#[async_trait]
-impl CircuitsHandler for DarwinV2Handler {
-    async fn get_vk(&self, task_type: CircuitType) -> Option<Vec<u8>> {
-        match task_type {
-            CircuitType::Chunk => self.chunk_prover.as_ref().unwrap().read().await.get_vk(),
-            CircuitType::Batch => self
-                .batch_prover
-                .as_ref()
-                .unwrap()
-                .read()
-                .await
-                .get_batch_vk(),
-            CircuitType::Bundle => self
-                .batch_prover
-                .as_ref()
-                .unwrap()
-                .read()
-                .await
-                .get_bundle_vk(),
-            _ => unreachable!(),
-        }
-    }
-
-    async fn get_proof_data(&self, prove_request: ProveRequest) -> Result<String> {
-        match prove_request.circuit_type {
-            CircuitType::Chunk => self.gen_chunk_proof(prove_request).await,
-            CircuitType::Batch => self.gen_batch_proof(prove_request).await,
-            CircuitType::Bundle => self.gen_bundle_proof(prove_request).await,
-            _ => unreachable!(),
-        }
-    }
-}
-
-// =================================== tests module ========================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::zk_circuits_handler::utils::encode_vk;
-    use ethers_core::types::H256;
-    use prover_darwin_v2::{
-        aggregator::eip4844, utils::chunk_trace_to_witness_block, BatchData, BatchHeader,
-        MAX_AGG_SNARKS,
-    };
-    use scroll_proving_sdk::utils::init_tracing;
-    use std::{path::PathBuf, sync::LazyLock};
-
-    #[ctor::ctor]
-    fn init() {
-        init_tracing();
-        log::info!("logger initialized");
-    }
-
-    static DEFAULT_WORK_DIR: &str = "/assets";
-    static WORK_DIR: LazyLock<String> = LazyLock::new(|| {
-        std::env::var("DARWIN_V2_TEST_DIR")
-            .unwrap_or(String::from(DEFAULT_WORK_DIR))
-            .trim_end_matches('/')
-            .to_string()
-    });
-    static PARAMS_PATH: LazyLock<String> = LazyLock::new(|| format!("{}/test_params", *WORK_DIR));
-    static ASSETS_PATH: LazyLock<String> = LazyLock::new(|| format!("{}/test_assets", *WORK_DIR));
-    static PROOF_DUMP_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/proof_data", *WORK_DIR));
-    static BATCH_DIR_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/traces/batch_24", *WORK_DIR));
-    static BATCH_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_batch.vkey", *WORK_DIR));
-    static CHUNK_VK_PATH: LazyLock<String> =
-        LazyLock::new(|| format!("{}/test_assets/vk_chunk.vkey", *WORK_DIR));
-
-    #[test]
-    fn it_works() {
-        let result = true;
-        assert!(result);
-    }
-
-    #[tokio::test]
-    async fn test_circuits() -> Result<()> {
-        let bi_handler = DarwinV2Handler::new_multi(
-            vec![ProverType::Chunk, ProverType::Batch],
-            &PARAMS_PATH,
-            &ASSETS_PATH,
-        )?;
-
-        let chunk_handler = bi_handler;
-        let chunk_vk = chunk_handler.get_vk(CircuitType::Chunk).await.unwrap();
-
-        check_vk(CircuitType::Chunk, chunk_vk, "chunk vk must be available");
-        let chunk_dir_paths = get_chunk_dir_paths()?;
-        log::info!("chunk_dir_paths, {:?}", chunk_dir_paths);
-        let mut chunk_traces = vec![];
-        let mut chunk_infos = vec![];
-        let mut chunk_proofs = vec![];
-        for (id, chunk_path) in chunk_dir_paths.into_iter().enumerate() {
-            let chunk_id = format!("chunk_proof{}", id + 1);
-            log::info!("start to process {chunk_id}");
-            let chunk_trace = read_chunk_trace(chunk_path)?;
-            chunk_traces.push(chunk_trace.clone());
-            let chunk_info = traces_to_chunk_info(chunk_trace.clone())?;
-            chunk_infos.push(chunk_info);
-
-            log::info!("start to prove {chunk_id}");
-            let chunk_proof = chunk_handler.gen_chunk_proof_raw(chunk_trace).await?;
-            let proof_data = serde_json::to_string(&chunk_proof)?;
-            dump_proof(chunk_id, proof_data)?;
-            chunk_proofs.push(chunk_proof);
-        }
-
-        let batch_handler = chunk_handler;
-        let batch_vk = batch_handler.get_vk(CircuitType::Batch).await.unwrap();
-        check_vk(CircuitType::Batch, batch_vk, "batch vk must be available");
-        let batch_task_detail = make_batch_task_detail(chunk_traces, chunk_proofs, None);
-        log::info!("start to prove batch");
-        let batch_proof = batch_handler.gen_batch_proof_raw(batch_task_detail).await?;
-        let proof_data = serde_json::to_string(&batch_proof)?;
-        dump_proof("batch_proof".to_string(), proof_data)?;
-
-        Ok(())
-    }
-
-    // copied from https://github.com/scroll-tech/scroll-prover/blob/main/integration/src/prove.rs
-    fn get_blob_from_chunks(chunks: &[ChunkInfo]) -> Vec<u8> {
-        let num_chunks = chunks.len();
-
-        let padded_chunk =
-            ChunkInfo::mock_padded_chunk_info_for_testing(chunks.last().as_ref().unwrap());
-        let chunks_with_padding = [
-            chunks.to_vec(),
-            vec![padded_chunk; MAX_AGG_SNARKS - num_chunks],
-        ]
-        .concat();
-        let batch_data = BatchData::<{ MAX_AGG_SNARKS }>::new(chunks.len(), &chunks_with_padding);
-        let batch_bytes = batch_data.get_batch_data_bytes();
-        let blob_bytes = eip4844::get_blob_bytes(&batch_bytes);
-        log::info!("blob_bytes len {}", blob_bytes.len());
-        blob_bytes
-    }
-
-    // TODO: chunk_infos can be extracted from chunk_proofs.
-    // Still needed?
-    fn make_batch_task_detail(
-        chunk_traces: Vec<Vec<BlockTrace>>,
-        chunk_proofs: Vec<ChunkProof>,
-        last_batcher_header: Option<BatchHeader<{ MAX_AGG_SNARKS }>>,
-    ) -> BatchTaskDetail {
-        // dummy parent batch hash
-        let dummy_parent_batch_hash = H256([
-            0xab, 0xac, 0xad, 0xae, 0xaf, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0,
-        ]);
-        let chunk_infos: Vec<_> = chunk_proofs.iter().map(|p| p.chunk_info.clone()).collect();
-
-        let l1_message_popped = chunk_traces
-            .iter()
-            .flatten()
-            .map(|chunk| chunk.num_l1_txs())
-            .sum();
-        let last_block_timestamp = chunk_traces.last().map_or(0, |block_traces| {
-            block_traces
-                .last()
-                .map_or(0, |block_trace| block_trace.header.timestamp.as_u64())
-        });
-
-        let blob_bytes = get_blob_from_chunks(&chunk_infos);
-        let batch_header = BatchHeader::construct_from_chunks(
-            last_batcher_header.map_or(4, |header| header.version),
-            last_batcher_header.map_or(123, |header| header.batch_index + 1),
-            l1_message_popped,
-            last_batcher_header.map_or(l1_message_popped, |header| {
-                header.total_l1_message_popped + l1_message_popped
-            }),
-            last_batcher_header.map_or(dummy_parent_batch_hash, |header| header.batch_hash()),
-            last_block_timestamp,
-            &chunk_infos,
-            &blob_bytes,
-        );
-        BatchTaskDetail {
-            chunk_infos,
-            batch_proving_task: BatchProvingTask {
-                chunk_proofs,
-                batch_header,
-                blob_bytes,
-            },
-        }
-    }
-
-    fn check_vk(proof_type: CircuitType, vk: Vec<u8>, info: &str) {
-        log::info!("check_vk, {:?}", proof_type);
-        let vk_from_file = read_vk(proof_type).unwrap();
-        assert_eq!(vk_from_file, encode_vk(vk), "{info}")
-    }
-
-    fn read_vk(proof_type: CircuitType) -> Result<String> {
-        log::info!("read_vk, {:?}", proof_type);
-        let vk_file = match proof_type {
-            CircuitType::Chunk => CHUNK_VK_PATH.clone(),
-            CircuitType::Batch => BATCH_VK_PATH.clone(),
-            CircuitType::Bundle => todo!(),
-            CircuitType::Undefined => unreachable!(),
-        };
-
-        let data = std::fs::read(vk_file)?;
-        Ok(encode_vk(data))
-    }
-
-    fn read_chunk_trace(path: PathBuf) -> Result<Vec<BlockTrace>> {
-        log::info!("read_chunk_trace, {:?}", path);
-        let mut chunk_trace: Vec<BlockTrace> = vec![];
-
-        fn read_block_trace(file: &PathBuf) -> Result<BlockTrace> {
-            let f = std::fs::File::open(file)?;
-            Ok(serde_json::from_reader(&f)?)
-        }
-
-        if path.is_dir() {
-            let entries = std::fs::read_dir(&path)?;
-            let mut files: Vec<String> = entries
-                .into_iter()
-                .filter_map(|e| {
-                    if e.is_err() {
-                        return None;
-                    }
-                    let entry = e.unwrap();
-                    if entry.path().is_dir() {
-                        return None;
-                    }
-                    if let Result::Ok(file_name) = entry.file_name().into_string() {
-                        Some(file_name)
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            files.sort();
-
-            log::info!("files in chunk {:?} is {:?}", path, files);
-            for file in files {
-                let block_trace = read_block_trace(&path.join(file))?;
-                chunk_trace.push(block_trace);
-            }
-        } else {
-            let block_trace = read_block_trace(&path)?;
-            chunk_trace.push(block_trace);
-        }
-        Ok(chunk_trace)
-    }
-
-    fn get_chunk_dir_paths() -> Result<Vec<PathBuf>> {
-        let batch_path = PathBuf::from(BATCH_DIR_PATH.clone());
-        let entries = std::fs::read_dir(&batch_path)?;
-        let mut files: Vec<String> = entries
-            .filter_map(|e| {
-                if e.is_err() {
-                    return None;
-                }
-                let entry = e.unwrap();
-                if entry.path().is_dir() {
-                    if let Result::Ok(file_name) = entry.file_name().into_string() {
-                        Some(file_name)
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                }
-            })
-            .collect();
-        files.sort();
-        log::info!("files in batch {:?} is {:?}", batch_path, files);
-        Ok(files.into_iter().map(|f| batch_path.join(f)).collect())
-    }
-
-    fn traces_to_chunk_info(chunk_trace: Vec<BlockTrace>) -> Result<ChunkInfo> {
-        let witness_block = chunk_trace_to_witness_block(chunk_trace)?;
-        Ok(ChunkInfo::from_witness_block(&witness_block, false))
-    }
-
-    fn dump_proof(id: String, proof_data: String) -> Result<()> {
-        let dump_path = PathBuf::from(PROOF_DUMP_PATH.clone());
-        Ok(std::fs::write(dump_path.join(id), proof_data)?)
-    }
-}

rollup/Makefile

@@ -11,6 +11,7 @@ mock_abi:
 rollup_bins: ## Builds the Rollup bins.
 	go build -o $(PWD)/build/bin/gas_oracle ./cmd/gas_oracle/
 	go build -o $(PWD)/build/bin/rollup_relayer ./cmd/rollup_relayer/
+	go build -o $(PWD)/build/bin/blob_uploader ./cmd/blob_uploader/
 
 gas_oracle: ## Builds the gas_oracle bin
 	go build -o $(PWD)/build/bin/gas_oracle ./cmd/gas_oracle/
@@ -18,6 +19,9 @@ gas_oracle: ## Builds the gas_oracle bin
 rollup_relayer: ## Builds the rollup_relayer bin
 	go build -o $(PWD)/build/bin/rollup_relayer ./cmd/rollup_relayer/
 
+blob_uploader: ## Builds the blob_uploader bin
+	go build -o $(PWD)/build/bin/blob_uploader ./cmd/blob_uploader/
+
 test:
 	go test -v -race -coverprofile=coverage.txt -covermode=atomic -p 1 $(PWD)/...
 

rollup/README.md

@@ -33,3 +33,45 @@ make rollup_bins
 ./build/bin/gas_oracle --config ./conf/config.json
 ./build/bin/rollup_relayer --config ./conf/config.json
 ```
+
+## Proposer Tool
+
+The Proposer Tool replays historical blocks with custom configurations (e.g., future hardfork configs, custom chunk/batch/bundle proposer configs) to generate chunks/batches/bundles, helping test parameter changes before protocol upgrade.
+
+You can:
+
+1. Enable different hardforks in the genesis configuration.
+2. Set custom chunk-proposer, batch-proposer, and bundle-proposer parameters.
+3. Analyze resulting metrics (blob size, block count, transaction count, gas usage).
+
+## How to run the proposer tool?
+
+### Set the configs
+
+1. Set genesis config to enable desired hardforks in [`proposer-tool-genesis.json`](./proposer-tool-genesis.json).
+2. Set proposer config in [`proposer-tool-config.json`](./proposer-tool-config.json) for data analysis.
+3. Set `start-l2-block` in the launch command of proposer-tool in [`docker-compose-proposer-tool.yml`](./docker-compose-proposer-tool.yml) to the block number you want to start from. The default is `0`, which means starting from the genesis block.
+
+### Start the proposer tool using docker-compose
+
+Prerequisite: an RPC URL to an archive L2 node. The default url in [`proposer-tool-config.json`](./proposer-tool-config.json) is `https://rpc.scroll.io`.
+
+```
+cd rollup
+DOCKER_BUILDKIT=1 docker-compose -f docker-compose-proposer-tool.yml up -d
+```
+
+> Note: The port 5432 of database is mapped to the host machine. You can use `psql` or any db clients to connect to the database.
+
+> The DSN for the database is `postgres://postgres:postgres@db:5432/scroll?sslmode=disable`.
+
+
+### Reset env
+```
+docker-compose -f docker-compose-proposer-tool.yml down -v
+```
+
+If you need to rebuild the images, removing the old images is necessary. You can do this by running the following command:
+```
+docker images | grep rollup | awk '{print $3}' | xargs docker rmi -f
+```

rollup/abi/bridge_abi_test.go

@@ -10,33 +10,6 @@ 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)
@@ -49,58 +22,6 @@ 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/blob_uploader/app/app.go

@@ -0,0 +1,94 @@
+package app
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/urfave/cli/v2"
+
+	"scroll-tech/common/database"
+	"scroll-tech/common/observability"
+	"scroll-tech/common/utils"
+	"scroll-tech/common/version"
+
+	"scroll-tech/rollup/internal/config"
+	"scroll-tech/rollup/internal/controller/blob_uploader"
+)
+
+var app *cli.App
+
+func init() {
+	// Set up blob-uploader app info.
+	app = cli.NewApp()
+	app.Action = action
+	app.Name = "blob-uploader"
+	app.Usage = "The Scroll Blob Uploader"
+	app.Version = version.Version
+	app.Flags = append(app.Flags, utils.CommonFlags...)
+	app.Commands = []*cli.Command{}
+	app.Before = func(ctx *cli.Context) error {
+		return utils.LogSetup(ctx)
+	}
+}
+
+func action(ctx *cli.Context) error {
+	// Load config file.
+	cfgFile := ctx.String(utils.ConfigFileFlag.Name)
+	cfg, err := config.NewConfig(cfgFile)
+	if err != nil {
+		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
+	}
+
+	subCtx, cancel := context.WithCancel(ctx.Context)
+	// Init db connection
+	db, err := database.InitDB(cfg.DBConfig)
+	if err != nil {
+		log.Crit("failed to init db connection", "err", err)
+	}
+	defer func() {
+		cancel()
+		if err = database.CloseDB(db); err != nil {
+			log.Crit("failed to close db connection", "error", err)
+		}
+	}()
+
+	registry := prometheus.DefaultRegisterer
+	observability.Server(ctx, db)
+
+	// sanity check config
+	if cfg.L2Config.BlobUploaderConfig == nil {
+		log.Crit("cfg.L2Config.BlobUploaderConfig must not be nil")
+	}
+
+	blobUploader, err := blob_uploader.NewBlobUploader(ctx.Context, db, cfg.L2Config.BlobUploaderConfig, registry)
+	if err != nil {
+		log.Crit("failed to create l2 relayer", "config file", cfgFile, "error", err)
+	}
+
+	go utils.Loop(subCtx, 2*time.Second, blobUploader.UploadBlobToS3)
+
+	// Finish start all blob-uploader functions.
+	log.Info("Start blob-uploader successfully", "version", version.Version)
+
+	// Catch CTRL-C to ensure a graceful shutdown.
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, os.Interrupt)
+
+	// Wait until the interrupt signal is received from an OS signal.
+	<-interrupt
+
+	return nil
+}
+
+// Run blob uploader cmd instance.
+func Run() {
+	if err := app.Run(os.Args); err != nil {
+		_, _ = fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

rollup/cmd/blob_uploader/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "scroll-tech/rollup/cmd/blob_uploader/app"
+
+func main() {
+	app.Run()
+}

rollup/cmd/gas_oracle/app/app.go

@@ -10,7 +10,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/scroll-tech/go-ethereum/params"
 	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/urfave/cli/v2"
 
@@ -72,22 +71,12 @@ func action(ctx *cli.Context) error {
 		log.Crit("failed to connect l1 geth", "config file", cfgFile, "error", err)
 	}
 
-	// Init l2geth connection
-	l2client, err := ethclient.Dial(cfg.L2Config.Endpoint)
-	if err != nil {
-		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
-	}
-
 	l1watcher := watcher.NewL1WatcherClient(ctx.Context, l1client, cfg.L1Config.StartHeight, db, registry)
 
 	l1relayer, err := relayer.NewLayer1Relayer(ctx.Context, db, cfg.L1Config.RelayerConfig, relayer.ServiceTypeL1GasOracle, registry)
 	if err != nil {
 		log.Crit("failed to create new l1 relayer", "config file", cfgFile, "error", err)
 	}
-	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, false /* initGenesis */, relayer.ServiceTypeL2GasOracle, registry)
-	if err != nil {
-		log.Crit("failed to create new l2 relayer", "config file", cfgFile, "error", err)
-	}
 	// Start l1 watcher process
 	go utils.LoopWithContext(subCtx, 10*time.Second, func(ctx context.Context) {
 		// Fetch the latest block number to decrease the delay when fetching gas prices
@@ -106,7 +95,6 @@ func action(ctx *cli.Context) error {
 
 	// Start l1relayer process
 	go utils.Loop(subCtx, 10*time.Second, l1relayer.ProcessGasPriceOracle)
-	go utils.Loop(subCtx, 2*time.Second, l2relayer.ProcessGasPriceOracle)
 
 	// Finish start all message relayer functions
 	log.Info("Start gas-oracle successfully", "version", version.Version)

rollup/cmd/proposer_tool/app/app.go

@@ -0,0 +1,96 @@
+package app
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+
+	"github.com/scroll-tech/da-codec/encoding"
+	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/urfave/cli/v2"
+
+	"scroll-tech/common/utils"
+	"scroll-tech/common/version"
+
+	"scroll-tech/rollup/internal/config"
+	"scroll-tech/rollup/internal/controller/watcher"
+)
+
+var app *cli.App
+
+func init() {
+	// Set up proposer-tool app info.
+	app = cli.NewApp()
+	app.Action = action
+	app.Name = "proposer-tool"
+	app.Usage = "The Scroll Proposer Tool"
+	app.Version = version.Version
+	app.Flags = append(app.Flags, utils.CommonFlags...)
+	app.Flags = append(app.Flags, utils.RollupRelayerFlags...)
+	app.Flags = append(app.Flags, utils.ProposerToolFlags...)
+	app.Commands = []*cli.Command{}
+	app.Before = func(ctx *cli.Context) error {
+		return utils.LogSetup(ctx)
+	}
+}
+
+func action(ctx *cli.Context) error {
+	// Load config file.
+	cfgFile := ctx.String(utils.ConfigFileFlag.Name)
+	cfg, err := config.NewConfigForReplay(cfgFile)
+	if err != nil {
+		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
+	}
+
+	subCtx, cancel := context.WithCancel(ctx.Context)
+
+	startL2BlockHeight := ctx.Uint64(utils.StartL2BlockFlag.Name)
+
+	genesisPath := ctx.String(utils.Genesis.Name)
+	genesis, err := utils.ReadGenesis(genesisPath)
+	if err != nil {
+		log.Crit("failed to read genesis", "genesis file", genesisPath, "error", err)
+	}
+
+	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 {
+		log.Crit("cfg.L2Config.BatchProposerConfig.MaxChunksPerBatch must be greater than 0")
+	}
+	if cfg.L2Config.ChunkProposerConfig.MaxL2GasPerChunk <= 0 {
+		log.Crit("cfg.L2Config.ChunkProposerConfig.MaxL2GasPerChunk must be greater than 0")
+	}
+
+	proposerTool, err := watcher.NewProposerTool(subCtx, cancel, cfg, startL2BlockHeight, minCodecVersion, genesis.Config)
+	if err != nil {
+		log.Crit("failed to create proposer tool", "startL2BlockHeight", startL2BlockHeight, "minCodecVersion", minCodecVersion, "error", err)
+	}
+	proposerTool.Start()
+
+	log.Info("Start proposer-tool successfully", "version", version.Version)
+
+	// Catch CTRL-C to ensure a graceful shutdown.
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, os.Interrupt)
+
+	// Wait until the interrupt signal is received from an OS signal.
+	<-interrupt
+
+	cancel()
+	proposerTool.Stop()
+
+	return nil
+}
+
+// Run proposer tool cmd instance.
+func Run() {
+	if err := app.Run(os.Args); err != nil {
+		_, _ = fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

rollup/cmd/proposer_tool/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "scroll-tech/rollup/cmd/proposer_tool/app"
+
+func main() {
+	app.Run()
+}

rollup/cmd/rollup_relayer/app/app.go

@@ -79,8 +79,6 @@ func action(ctx *cli.Context) error {
 		log.Crit("failed to read genesis", "genesis file", genesisPath, "error", err)
 	}
 
-	initGenesis := ctx.Bool(utils.ImportGenesisFlag.Name)
-
 	// sanity check config
 	if cfg.L2Config.RelayerConfig.BatchSubmission == nil {
 		log.Crit("cfg.L2Config.RelayerConfig.BatchSubmission must not be nil")
@@ -98,12 +96,16 @@ func action(ctx *cli.Context) error {
 		log.Crit("cfg.L2Config.ChunkProposerConfig.MaxL2GasPerChunk must be greater than 0")
 	}
 
-	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, genesis.Config, initGenesis, relayer.ServiceTypeL2RollupRelayer, registry)
+	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, genesis.Config, relayer.ServiceTypeL2RollupRelayer, registry)
 	if err != nil {
 		log.Crit("failed to create l2 relayer", "config file", cfgFile, "error", err)
 	}
 
 	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,7 +54,8 @@
       "batch_submission": {
         "min_batches": 1,
         "max_batches": 6,
-        "timeout": 300
+        "timeout": 7200,
+        "backlog_max": 75
       },
       "gas_oracle_config": {
         "min_gas_price": 0,
@@ -87,33 +88,31 @@
         "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,
-      "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
+      "chunk_timeout_sec": 300
     },
     "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,
-      "gas_cost_increase_multiplier": 1.2,
-      "max_uncompressed_batch_bytes_size": 634880,
-      "max_chunks_per_batch": 12
+      "max_chunks_per_batch": 45
     },
     "bundle_proposer_config": {
       "max_batch_num_per_bundle": 20,
       "bundle_timeout_sec": 36000
+    },
+    "blob_uploader_config": {
+      "start_batch": 0,
+      "aws_s3_config": {
+        "bucket": "blob-data",
+        "region": "us-west-2",
+        "access_key": "ACCESSKEY",
+        "secret_key": "SECRETKEY"
+      }
     }
   },
   "db_config": {

rollup/docker-compose-proposer-tool.yml

@@ -0,0 +1,40 @@
+version: '3'
+
+services:
+  db:
+    image: postgres:14
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=scroll
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  proposer-tool:
+    build:
+      context: ..
+      dockerfile: ./rollup/proposer_tool.Dockerfile
+    depends_on:
+      db:
+        condition: service_healthy
+    command: [
+      "--config", "/app/conf/proposer-tool-config.json",
+      "--genesis", "/app/conf/proposer-tool-genesis.json",
+      "--min-codec-version", "7",
+      "--start-l2-block", "10000",
+      "--log.debug", "--verbosity", "3"
+    ]
+    volumes:
+      - ./proposer-tool-config.json:/app/conf/proposer-tool-config.json
+      - ./proposer-tool-genesis.json:/app/conf/proposer-tool-genesis.json
+    restart: unless-stopped
+
+volumes:
+  postgres_data:

rollup/go.mod

@@ -4,6 +4,10 @@ go 1.22
 
 require (
 	github.com/agiledragon/gomonkey/v2 v2.12.0
+	github.com/aws/aws-sdk-go-v2 v1.36.3
+	github.com/aws/aws-sdk-go-v2/config v1.29.14
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.67
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.80.0
 	github.com/consensys/gnark-crypto v0.16.0
 	github.com/crate-crypto/go-kzg-4844 v1.1.0
 	github.com/gin-gonic/gin v1.9.1
@@ -11,8 +15,8 @@ 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.20250401062930-9f9f53898493
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
+	github.com/scroll-tech/da-codec v0.1.3-0.20250519114140-bfa7133d4ad1
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250610090337-00c5c2bd3e65
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/spf13/viper v1.19.0
 	github.com/stretchr/testify v1.10.0
@@ -22,6 +26,20 @@ require (
 
 require (
 	github.com/VictoriaMetrics/fastcache v1.12.2 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.10 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.34 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.7.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.15 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.15 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.25.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.33.19 // indirect
+	github.com/aws/smithy-go v1.22.2 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bits-and-blooms/bitset v1.20.0 // indirect
 	github.com/btcsuite/btcd v0.20.1-beta // indirect

rollup/go.sum

@@ -8,6 +8,42 @@ github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuy
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
+github.com/aws/aws-sdk-go-v2 v1.36.3 h1:mJoei2CxPutQVxaATCzDUjcZEjVRdpsiiXi2o38yqWM=
+github.com/aws/aws-sdk-go-v2 v1.36.3/go.mod h1:LLXuLpgzEbD766Z5ECcRmi8AzSwfZItDtmABVkRLGzg=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.10 h1:zAybnyUQXIZ5mok5Jqwlf58/TFE7uvd3IAsa1aF9cXs=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.10/go.mod h1:qqvMj6gHLR/EXWZw4ZbqlPbQUyenf4h82UQUlKc+l14=
+github.com/aws/aws-sdk-go-v2/config v1.29.14 h1:f+eEi/2cKCg9pqKBoAIwRGzVb70MRKqWX4dg1BDcSJM=
+github.com/aws/aws-sdk-go-v2/config v1.29.14/go.mod h1:wVPHWcIFv3WO89w0rE10gzf17ZYy+UVS1Geq8Iei34g=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.67 h1:9KxtdcIA/5xPNQyZRgUSpYOE6j9Bc4+D7nZua0KGYOM=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.67/go.mod h1:p3C44m+cfnbv763s52gCqrjaqyPikj9Sg47kUVaNZQQ=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30 h1:x793wxmUWVDhshP8WW2mlnXuFrO4cOd3HLBroh1paFw=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30/go.mod h1:Jpne2tDnYiFascUEs2AWHJL9Yp7A5ZVy3TNyxaAjD6M=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 h1:ZK5jHhnrioRkUNOc+hOgQKlUL5JeC3S6JgLxtQ+Rm0Q=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34/go.mod h1:p4VfIceZokChbA9FzMbRGz5OV+lekcVtHlPKEO0gSZY=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 h1:SZwFm17ZUNNg5Np0ioo/gq8Mn6u9w19Mri8DnJ15Jf0=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34/go.mod h1:dFZsC0BLo346mvKQLWmoJxT+Sjp+qcVR1tRVHQGOH9Q=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 h1:bIqFDwgGXXN1Kpp99pDOdKMTTb5d2KyU5X/BZxjOkRo=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3/go.mod h1:H5O/EsxDWyU+LP/V8i5sm8cxoZgc2fdNR9bxlOFrQTo=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.34 h1:ZNTqv4nIdE/DiBfUUfXcLZ/Spcuz+RjeziUtNJackkM=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.34/go.mod h1:zf7Vcd1ViW7cPqYWEHLHJkS50X0JS2IKz9Cgaj6ugrs=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.3 h1:eAh2A4b5IzM/lum78bZ590jy36+d/aFLgKF/4Vd1xPE=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.3/go.mod h1:0yKJC/kb8sAnmlYa6Zs3QVYqaC8ug2AbnNChv5Ox3uA=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.7.2 h1:BCG7DCXEXpNCcpwCxg1oi9pkJWH2+eZzTn9MY56MbVw=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.7.2/go.mod h1:iu6FSzgt+M2/x3Dk8zhycdIcHjEFb36IS8HVUVFoMg0=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.15 h1:dM9/92u2F1JbDaGooxTq18wmmFzbJRfXfVfy96/1CXM=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.15/go.mod h1:SwFBy2vjtA0vZbjjaFtfN045boopadnoVPhu4Fv66vY=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.15 h1:moLQUoVq91LiqT1nbvzDukyqAlCv89ZmwaHw/ZFlFZg=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.15/go.mod h1:ZH34PJUc8ApjBIfgQCFvkWcUDBtl/WTD+uiYHjd8igA=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.80.0 h1:fV4XIU5sn/x8gjRouoJpDVHj+ExJaUk4prYF+eb6qTs=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.80.0/go.mod h1:qbn305Je/IofWBJ4bJz/Q7pDEtnnoInw/dGt71v6rHE=
+github.com/aws/aws-sdk-go-v2/service/sso v1.25.3 h1:1Gw+9ajCV1jogloEv1RRnvfRFia2cL6c9cuKV2Ps+G8=
+github.com/aws/aws-sdk-go-v2/service/sso v1.25.3/go.mod h1:qs4a9T5EMLl/Cajiw2TcbNt2UNo/Hqlyp+GiuG4CFDI=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.1 h1:hXmVKytPfTy5axZ+fYbR5d0cFmC3JvwLm5kM83luako=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.1/go.mod h1:MlYRNmYu/fGPoxBQVvBYr9nyr948aY/WLUvwBMBJubs=
+github.com/aws/aws-sdk-go-v2/service/sts v1.33.19 h1:1XuUZ8mYJw9B6lzAkXhqHlJd/XvaX32evhproijJEZY=
+github.com/aws/aws-sdk-go-v2/service/sts v1.33.19/go.mod h1:cQnB8CUnxbMU82JvlqjKR2HBOm3fe9pWorWBza6MBJ4=
+github.com/aws/smithy-go v1.22.2 h1:6D9hW43xKFrRx/tXXfAlIZc4JI+yQe6snnWcQyxSyLQ=
+github.com/aws/smithy-go v1.22.2/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
@@ -249,10 +285,10 @@ 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.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/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/go-ethereum v1.10.14-0.20250610090337-00c5c2bd3e65 h1:idsnkl5rwVr7eNUB0HxdkKI0L3zbTm8XSGwMTB5ndws=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250610090337-00c5c2bd3e65/go.mod h1:756YMENiSfx/5pCwKq3+uSTWjXuHTbiCB+TirJjsQT8=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=

rollup/internal/config/config.go

@@ -1,7 +1,10 @@
 package config
 
 import (
+	"encoding/json"
 	"fmt"
+	"os"
+	"path/filepath"
 	"reflect"
 	"strings"
 
@@ -20,6 +23,11 @@ type Config struct {
 	DBConfig *database.Config `json:"db_config"`
 }
 
+type ConfigForReplay struct {
+	Config
+	DBConfigForReplay *database.Config `json:"db_config_for_replay"`
+}
+
 // NewConfig returns a new instance of Config.
 func NewConfig(file string) (*Config, error) {
 	v := viper.New()
@@ -87,3 +95,19 @@ func NewConfig(file string) (*Config, error) {
 
 	return cfg, nil
 }
+
+// NewConfigForReplay returns a new instance of ConfigForReplay.
+func NewConfigForReplay(file string) (*ConfigForReplay, error) {
+	buf, err := os.ReadFile(filepath.Clean(file))
+	if err != nil {
+		return nil, err
+	}
+
+	cfg := &ConfigForReplay{}
+	err = json.Unmarshal(buf, cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	return cfg, nil
+}

rollup/internal/config/l2.go

@@ -24,31 +24,23 @@ type L2Config struct {
 	BatchProposerConfig *BatchProposerConfig `json:"batch_proposer_config"`
 	// The bundle_proposer config
 	BundleProposerConfig *BundleProposerConfig `json:"bundle_proposer_config"`
+	// The blob_uploader config
+	BlobUploaderConfig *BlobUploaderConfig `json:"blob_uploader_config"`
 }
 
 // ChunkProposerConfig loads chunk_proposer configuration items.
 type ChunkProposerConfig struct {
-	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"`
+	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"`
 }
 
 // BatchProposerConfig loads batch_proposer configuration items.
 type BatchProposerConfig struct {
-	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"`
+	ProposeIntervalMilliseconds uint64 `json:"propose_interval_milliseconds"`
+	BatchTimeoutSec             uint64 `json:"batch_timeout_sec"`
+	MaxChunksPerBatch           int    `json:"max_chunks_per_batch"`
 }
 
 // BundleProposerConfig loads bundle_proposer configuration items.
@@ -56,3 +48,17 @@ type BundleProposerConfig struct {
 	MaxBatchNumPerBundle uint64 `json:"max_batch_num_per_bundle"`
 	BundleTimeoutSec     uint64 `json:"bundle_timeout_sec"`
 }
+
+// BlobUploaderConfig loads blob_uploader configuration items.
+type BlobUploaderConfig struct {
+	StartBatch  uint64       `json:"start_batch"`
+	AWSS3Config *AWSS3Config `json:"aws_s3_config"`
+}
+
+// AWSS3Config loads s3_uploader configuration items.
+type AWSS3Config struct {
+	Bucket    string `json:"bucket"`
+	Region    string `json:"region"`
+	AccessKey string `json:"access_key"`
+	SecretKey string `json:"secret_key"`
+}

rollup/internal/config/relayer.go

@@ -38,6 +38,8 @@ 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.
@@ -63,8 +65,6 @@ 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,8 +73,6 @@ 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/blob_uploader/arweave_sender.go

@@ -0,0 +1 @@
+package blob_uploader

rollup/internal/controller/blob_uploader/blob_uploader.go

@@ -0,0 +1,251 @@
+package blob_uploader
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/scroll-tech/da-codec/encoding"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
+	"github.com/scroll-tech/go-ethereum/log"
+	"gorm.io/gorm"
+
+	"scroll-tech/common/types"
+	"scroll-tech/common/utils"
+
+	"scroll-tech/rollup/internal/config"
+	"scroll-tech/rollup/internal/orm"
+)
+
+// BlobUploader is responsible for uploading blobs to blob storage services.
+type BlobUploader struct {
+	ctx context.Context
+
+	cfg *config.BlobUploaderConfig
+
+	s3Uploader *S3Uploader
+
+	blobUploadOrm *orm.BlobUpload
+	batchOrm      *orm.Batch
+	chunkOrm      *orm.Chunk
+	l2BlockOrm    *orm.L2Block
+
+	metrics *blobUploaderMetrics
+}
+
+// NewBlobUploader will return a new instance of BlobUploader
+func NewBlobUploader(ctx context.Context, db *gorm.DB, cfg *config.BlobUploaderConfig, reg prometheus.Registerer) (*BlobUploader, error) {
+	var s3Uploader *S3Uploader
+	var err error
+	if cfg.AWSS3Config != nil {
+		s3Uploader, err = NewS3Uploader(cfg.AWSS3Config)
+		if err != nil {
+			return nil, fmt.Errorf("new blob uploader failed, err: %w", err)
+		}
+	}
+
+	blobUploader := &BlobUploader{
+		ctx:           ctx,
+		cfg:           cfg,
+		s3Uploader:    s3Uploader,
+		batchOrm:      orm.NewBatch(db),
+		chunkOrm:      orm.NewChunk(db),
+		l2BlockOrm:    orm.NewL2Block(db),
+		blobUploadOrm: orm.NewBlobUpload(db),
+	}
+
+	blobUploader.metrics = initBlobUploaderMetrics(reg)
+
+	return blobUploader, nil
+}
+
+func (b *BlobUploader) UploadBlobToS3() {
+	// skip upload if s3 uploader is not configured
+	if b.s3Uploader == nil {
+		return
+	}
+
+	// get un-uploaded batches from database in ascending order by their index.
+	dbBatch, err := b.GetFirstUnuploadedBatchByPlatform(b.ctx, b.cfg.StartBatch, types.BlobStoragePlatformS3)
+	if err != nil {
+		log.Error("Failed to fetch unuploaded batch", "err", err)
+		return
+	}
+
+	// nothing to do if we don't have any pending batches
+	if dbBatch == nil {
+		log.Debug("no pending batches to upload")
+		return
+	}
+
+	// construct blob
+	codecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
+	blob, err := b.constructBlobCodec(dbBatch)
+	if err != nil {
+		log.Error("failed to construct constructBlobCodec payload ", "codecVersion", codecVersion, "batch index", dbBatch.Index, "err", err)
+		b.metrics.rollupBlobUploaderUploadToS3FailedTotal.Inc()
+		if updateErr := b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, dbBatch.Index, dbBatch.Hash, types.BlobStoragePlatformS3, types.BlobUploadStatusFailed); updateErr != nil {
+			log.Error("failed to update blob upload status to failed", "batch index", dbBatch.Index, "err", updateErr)
+		}
+		return
+	}
+
+	// calculate versioned blob hash
+	versionedBlobHash, err := utils.CalculateVersionedBlobHash(*blob)
+	if err != nil {
+		log.Error("failed to calculate versioned blob hash", "batch index", dbBatch.Index, "err", err)
+		b.metrics.rollupBlobUploaderUploadToS3FailedTotal.Inc()
+		// update status to failed
+		if updateErr := b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, dbBatch.Index, dbBatch.Hash, types.BlobStoragePlatformS3, types.BlobUploadStatusFailed); updateErr != nil {
+			log.Error("failed to update blob upload status to failed", "batch index", dbBatch.Index, "err", updateErr)
+		}
+		return
+	}
+
+	// upload blob data to s3 bucket
+	key := common.BytesToHash(versionedBlobHash[:]).Hex()
+	err = b.s3Uploader.UploadData(b.ctx, blob[:], key)
+	if err != nil {
+		log.Error("failed to upload blob data to AWS S3", "batch index", dbBatch.Index, "versioned blob hash", key, "err", err)
+		b.metrics.rollupBlobUploaderUploadToS3FailedTotal.Inc()
+		// update status to failed
+		if updateErr := b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, dbBatch.Index, dbBatch.Hash, types.BlobStoragePlatformS3, types.BlobUploadStatusFailed); updateErr != nil {
+			log.Error("failed to update blob upload status to failed", "batch index", dbBatch.Index, "err", updateErr)
+		}
+		return
+	}
+
+	// update status to uploaded
+	if err = b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, dbBatch.Index, dbBatch.Hash, types.BlobStoragePlatformS3, types.BlobUploadStatusUploaded); err != nil {
+		log.Error("failed to update blob upload status to uploaded", "batch index", dbBatch.Index, "err", err)
+		b.metrics.rollupBlobUploaderUploadToS3FailedTotal.Inc()
+		return
+	}
+
+	b.metrics.rollupBlobUploaderUploadToS3SuccessTotal.Inc()
+	log.Info("Successfully uploaded blob to S3", "batch index", dbBatch.Index, "versioned blob hash", key)
+}
+
+func (b *BlobUploader) constructBlobCodec(dbBatch *orm.Batch) (*kzg4844.Blob, error) {
+	var dbChunks []*orm.Chunk
+
+	dbChunks, err := b.chunkOrm.GetChunksInRange(b.ctx, dbBatch.StartChunkIndex, dbBatch.EndChunkIndex)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get chunks in range: %v", err)
+	}
+
+	// check codec version
+	for _, dbChunk := range dbChunks {
+		if dbBatch.CodecVersion != dbChunk.CodecVersion {
+			return nil, fmt.Errorf("batch codec version is different from chunk codec version, batch index: %d, chunk index: %d, batch codec version: %d, chunk codec version: %d", dbBatch.Index, dbChunk.Index, dbBatch.CodecVersion, dbChunk.CodecVersion)
+		}
+	}
+
+	chunks := make([]*encoding.Chunk, len(dbChunks))
+	var allBlocks []*encoding.Block // collect blocks for CodecV7
+	for i, c := range dbChunks {
+		blocks, getErr := b.l2BlockOrm.GetL2BlocksInRange(b.ctx, c.StartBlockNumber, c.EndBlockNumber)
+		if getErr != nil {
+			return nil, fmt.Errorf("failed to get blocks in range for batch %d: %w", dbBatch.Index, getErr)
+		}
+		chunks[i] = &encoding.Chunk{Blocks: blocks}
+		allBlocks = append(allBlocks, blocks...)
+	}
+
+	var encodingBatch *encoding.Batch
+	codecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
+	switch codecVersion {
+	case encoding.CodecV0:
+		return nil, fmt.Errorf("codec version 0 doesn't support blob, batch index: %d", dbBatch.Index)
+	case encoding.CodecV1, encoding.CodecV2, encoding.CodecV3, encoding.CodecV4, encoding.CodecV5, encoding.CodecV6:
+		encodingBatch = &encoding.Batch{
+			Index:                      dbBatch.Index,
+			TotalL1MessagePoppedBefore: dbChunks[0].TotalL1MessagesPoppedBefore,
+			ParentBatchHash:            common.HexToHash(dbBatch.ParentBatchHash),
+			Chunks:                     chunks,
+		}
+
+	case encoding.CodecV7:
+		encodingBatch = &encoding.Batch{
+			Index:                  dbBatch.Index,
+			ParentBatchHash:        common.HexToHash(dbBatch.ParentBatchHash),
+			Chunks:                 chunks,
+			PrevL1MessageQueueHash: common.HexToHash(dbBatch.PrevL1MessageQueueHash),
+			PostL1MessageQueueHash: common.HexToHash(dbBatch.PostL1MessageQueueHash),
+			Blocks:                 allBlocks,
+		}
+	default:
+		return nil, fmt.Errorf("unsupported codec version, batch index: %d, batch codec version: %d", dbBatch.Index, codecVersion)
+	}
+
+	codec, err := encoding.CodecFromVersion(codecVersion)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get codec from version %d, err: %w", dbBatch.CodecVersion, err)
+	}
+
+	daBatch, err := codec.NewDABatch(encodingBatch)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create DA batch: %w", err)
+	}
+
+	if daBatch.Blob() == nil {
+		return nil, fmt.Errorf("codec version doesn't support blob, batch index: %d, batch codec version: %d", dbBatch.Index, dbBatch.CodecVersion)
+	}
+
+	return daBatch.Blob(), nil
+}
+
+// GetFirstUnuploadedBatchByPlatform retrieves the first batch that either hasn't been uploaded to corresponding blob storage service
+// The batch must have a commit_tx_hash (committed).
+func (b *BlobUploader) GetFirstUnuploadedBatchByPlatform(ctx context.Context, startBatch uint64, platform types.BlobStoragePlatform) (*orm.Batch, error) {
+	batchIndex, err := b.blobUploadOrm.GetNextBatchIndexToUploadByPlatform(ctx, startBatch, platform)
+	if err != nil {
+		return nil, err
+	}
+
+	var batch *orm.Batch
+	for {
+		var err error
+		batch, err = b.batchOrm.GetBatchByIndex(ctx, batchIndex)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				log.Debug("got batch not proposed for blob uploading", "batch_index", batchIndex, "platform", platform.String())
+				return nil, nil
+			}
+			return nil, err
+		}
+
+		// to check if the parent batch uploaded
+		// if no, there is a batch revert happened, we need to fallback to upload previous batch
+		// skip the check if the parent batch is genesis batch
+		if batchIndex <= 1 || batchIndex == startBatch {
+			break
+		}
+		fields := map[string]interface{}{
+			"batch_index = ?": batchIndex - 1,
+			"batch_hash = ?":  batch.ParentBatchHash,
+			"platform = ?":    platform,
+			"status = ?":      types.BlobUploadStatusUploaded,
+		}
+		blobUpload, err := b.blobUploadOrm.GetBlobUploads(ctx, fields, nil, 1)
+		if err != nil {
+			return nil, err
+		}
+
+		if len(blobUpload) == 0 {
+			batchIndex--
+			continue
+		}
+
+		break
+	}
+
+	if len(batch.CommitTxHash) == 0 {
+		log.Debug("got batch not committed for blob uploading", "batch_index", batchIndex, "platform", platform.String())
+		return nil, nil
+	}
+
+	return batch, nil
+}

rollup/internal/controller/blob_uploader/blob_uploader_metrics.go

@@ -0,0 +1,34 @@
+package blob_uploader
+
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+type blobUploaderMetrics struct {
+	rollupBlobUploaderUploadToS3SuccessTotal prometheus.Counter
+	rollupBlobUploaderUploadToS3FailedTotal  prometheus.Counter
+}
+
+var (
+	initBlobUploaderMetricsOnce sync.Once
+	blobUploaderMetric          *blobUploaderMetrics
+)
+
+func initBlobUploaderMetrics(reg prometheus.Registerer) *blobUploaderMetrics {
+	initBlobUploaderMetricsOnce.Do(func() {
+		blobUploaderMetric = &blobUploaderMetrics{
+			rollupBlobUploaderUploadToS3SuccessTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_blob_uploader_upload_to_s3_success_total",
+				Help: "The total number of upload blob to S3 runs success total",
+			}),
+			rollupBlobUploaderUploadToS3FailedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_blob_uploader_upload_to_s3_failed_total",
+				Help: "The total number of upload blob to S3 runs failed total",
+			}),
+		}
+	})
+	return blobUploaderMetric
+}

rollup/internal/controller/blob_uploader/s3_sender.go

@@ -0,0 +1,66 @@
+package blob_uploader
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"time"
+
+	"scroll-tech/rollup/internal/config"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	awsconfig "github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+)
+
+// S3 Uploader is responsible for uploading data to AWS S3.
+type S3Uploader struct {
+	client  *s3.Client
+	bucket  string
+	region  string
+	timeout time.Duration
+}
+
+func NewS3Uploader(cfg *config.AWSS3Config) (*S3Uploader, error) {
+	// load AWS config
+	var opts []func(*awsconfig.LoadOptions) error
+	opts = append(opts, awsconfig.WithRegion(cfg.Region))
+
+	// if AccessKey && SecretKey provided, use it
+	if cfg.AccessKey != "" && cfg.SecretKey != "" {
+		opts = append(opts, awsconfig.WithCredentialsProvider(
+			credentials.NewStaticCredentialsProvider(
+				cfg.AccessKey,
+				cfg.SecretKey,
+				"",
+			)),
+		)
+	}
+
+	awsCfg, err := awsconfig.LoadDefaultConfig(context.Background(), opts...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load default config: %w", err)
+	}
+
+	return &S3Uploader{
+		client:  s3.NewFromConfig(awsCfg),
+		bucket:  cfg.Bucket,
+		region:  cfg.Region,
+		timeout: 30 * time.Second,
+	}, nil
+}
+
+// UploadData uploads data to s3 bucket
+func (u *S3Uploader) UploadData(ctx context.Context, data []byte, objectKey string) error {
+	uploadCtx, cancel := context.WithTimeout(ctx, u.timeout)
+	defer cancel()
+
+	_, err := u.client.PutObject(uploadCtx, &s3.PutObjectInput{
+		Bucket:      aws.String(u.bucket),
+		Key:         aws.String(objectKey),
+		Body:        bytes.NewReader(data),
+		ContentType: aws.String("application/octet-stream"),
+	})
+	return err
+}

rollup/internal/controller/relayer/common.go

@@ -1,20 +1,11 @@
 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
 
@@ -25,6 +16,6 @@ const (
 	ServiceTypeL2RollupRelayer
 	// ServiceTypeL1GasOracle indicates the service is a Layer 1 gas oracle.
 	ServiceTypeL1GasOracle
-	// ServiceTypeL2GasOracle indicates the service is a Layer 2 gas oracle.
-	ServiceTypeL2GasOracle
+	// ServiceTypeL2GasOracleDeprecated indicates the service is a Layer 2 gas oracle, which is deprecated.
+	ServiceTypeL2GasOracleDeprecated
 )

rollup/internal/controller/relayer/l1_relayer.go

@@ -167,6 +167,7 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 				if r.lastBaseFee == r.cfg.GasOracleConfig.L1BaseFeeDefault && r.lastBlobBaseFee == r.cfg.GasOracleConfig.L1BlobBaseFeeDefault {
 					return
 				}
+				log.Warn("The committing batch has been stuck for a long time, it's likely that the L1 gas fee spiked, set fees to default values", "currentBaseFee", baseFee, "currentBlobBaseFee", blobBaseFee, "threshold (min)", r.cfg.GasOracleConfig.L1BlobBaseFeeThreshold, "defaultBaseFee", r.cfg.GasOracleConfig.L1BaseFeeDefault, "defaultBlobBaseFee", r.cfg.GasOracleConfig.L1BlobBaseFeeDefault)
 				baseFee = r.cfg.GasOracleConfig.L1BaseFeeDefault
 				blobBaseFee = r.cfg.GasOracleConfig.L1BlobBaseFeeDefault
 			} else if err != nil {
@@ -178,13 +179,13 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 				return
 			}
 
-			hash, err := r.gasOracleSender.SendTransaction(block.Hash, &r.cfg.GasPriceOracleContractAddress, data, nil, 0)
+			txHash, _, err := r.gasOracleSender.SendTransaction(block.Hash, &r.cfg.GasPriceOracleContractAddress, data, nil)
 			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, hash.String())
+			err = r.l1BlockOrm.UpdateL1GasOracleStatusAndOracleTxHash(r.ctx, block.Hash, types.GasOracleImporting, txHash.String())
 			if err != nil {
 				log.Error("UpdateGasOracleStatusAndOracleTxHash failed", "block.Hash", block.Hash, "block.Height", block.Number, "err", err)
 				return
@@ -194,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", hash.String(), "baseFee", baseFee, "blobBaseFee", blobBaseFee)
+			log.Info("Update l1 base fee", "txHash", txHash.String(), "baseFee", baseFee, "blobBaseFee", blobBaseFee)
 		}
 	}
 }
@@ -250,7 +251,11 @@ func (r *Layer1Relayer) shouldUpdateGasOracle(baseFee uint64, blobBaseFee uint64
 		return true
 	}
 
-	expectedBaseFeeDelta := r.lastBaseFee*r.gasPriceDiff/gasPriceDiffPrecision + 1
+	expectedBaseFeeDelta := r.lastBaseFee * r.gasPriceDiff / gasPriceDiffPrecision
+	// Allowing a minimum of 0 wei if the gas price diff config is 0, this will be used to let the gas oracle send transactions continuously.
+	if r.gasPriceDiff > 0 {
+		expectedBaseFeeDelta += 1
+	}
 	if baseFee >= r.minGasPrice && math.Abs(float64(baseFee)-float64(r.lastBaseFee)) >= float64(expectedBaseFeeDelta) {
 		return true
 	}
@@ -278,5 +283,7 @@ func (r *Layer1Relayer) commitBatchReachTimeout() (bool, error) {
 	}
 	// len(batches) == 0 probably shouldn't ever happen, but need to check this
 	// Also, we should check if it's a genesis batch. If so, skip the timeout check.
-	return len(batches) == 0 || (batches[0].Index != 0 && utils.NowUTC().Sub(*batches[0].CommittedAt) > time.Duration(r.cfg.GasOracleConfig.CheckCommittedBatchesWindowMinutes)*time.Minute), nil
+	// If finalizing/finalized status is updated before committed status, skip the timeout check of this round.
+	// Because batches[0].CommittedAt is nil in this case, this will only continue for a short time window.
+	return len(batches) == 0 || (batches[0].Index != 0 && batches[0].CommittedAt != nil && utils.NowUTC().Sub(*batches[0].CommittedAt) > time.Duration(r.cfg.GasOracleConfig.CheckCommittedBatchesWindowMinutes)*time.Minute), nil
 }

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, uint64) (hash common.Hash, err error) {
+		patchGuard.ApplyMethodFunc(l1Relayer.gasOracleSender, "SendTransaction", func(string, *common.Address, []byte, *kzg4844.Blob) (hash common.Hash, err error) {
 			return common.Hash{}, targetErr
 		})
 		l1Relayer.ProcessGasPriceOracle()
 	})
 
-	patchGuard.ApplyMethodFunc(l1Relayer.gasOracleSender, "SendTransaction", func(string, *common.Address, []byte, *kzg4844.Blob, uint64) (hash common.Hash, err error) {
+	patchGuard.ApplyMethodFunc(l1Relayer.gasOracleSender, "SendTransaction", func(string, *common.Address, []byte, *kzg4844.Blob) (hash common.Hash, err error) {
 		return common.Hash{}, nil
 	})
 

rollup/internal/controller/relayer/l2_relayer.go

@@ -15,7 +15,6 @@ 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"
@@ -34,6 +33,32 @@ 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.
@@ -47,6 +72,7 @@ type Layer2Relayer struct {
 	batchOrm   *orm.Batch
 	chunkOrm   *orm.Chunk
 	l2BlockOrm *orm.L2Block
+	l1BlockOrm *orm.L1Block
 
 	cfg *config.RelayerConfig
 
@@ -54,12 +80,7 @@ type Layer2Relayer struct {
 	finalizeSender *sender.Sender
 	l1RollupABI    *abi.ABI
 
-	gasOracleSender *sender.Sender
-	l2GasOracleABI  *abi.ABI
-
-	lastGasPrice uint64
-	minGasPrice  uint64
-	gasPriceDiff uint64
+	l2GasOracleABI *abi.ABI
 
 	// Used to get batch status from chain_monitor api.
 	chainMonitorClient *resty.Client
@@ -67,25 +88,38 @@ 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
-func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.DB, cfg *config.RelayerConfig, chainCfg *params.ChainConfig, initGenesis bool, serviceType ServiceType, reg prometheus.Registerer) (*Layer2Relayer, error) {
-	var gasOracleSender, commitSender, finalizeSender *sender.Sender
-	var err error
+func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.DB, cfg *config.RelayerConfig, chainCfg *params.ChainConfig, serviceType ServiceType, reg prometheus.Registerer) (*Layer2Relayer, error) {
+	var commitSender, finalizeSender *sender.Sender
 
 	switch serviceType {
-	case ServiceTypeL2GasOracle:
-		gasOracleSender, err = sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderSignerConfig, "l2_relayer", "gas_oracle_sender", types.SenderTypeL2GasOracle, db, reg)
-		if err != nil {
-			return nil, fmt.Errorf("new gas oracle sender failed, err: %w", err)
-		}
-
-		// Ensure test features aren't enabled on the ethereum mainnet.
-		if gasOracleSender.GetChainID().Cmp(big.NewInt(1)) == 0 && cfg.EnableTestEnvBypassFeatures {
-			return nil, errors.New("cannot enable test env features in mainnet")
-		}
-
 	case ServiceTypeL2RollupRelayer:
 		commitSenderAddr, err := addrFromSignerConfig(cfg.CommitSenderSignerConfig)
 		if err != nil {
@@ -118,14 +152,9 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		return nil, fmt.Errorf("invalid service type for l2_relayer: %v", serviceType)
 	}
 
-	var minGasPrice uint64
-	var gasPriceDiff uint64
-	if cfg.GasOracleConfig != nil {
-		minGasPrice = cfg.GasOracleConfig.MinGasPrice
-		gasPriceDiff = cfg.GasOracleConfig.GasPriceDiff
-	} else {
-		minGasPrice = 0
-		gasPriceDiff = defaultGasPriceDiff
+	strategy, ok := bestParams[uint64(cfg.BatchSubmission.TimeoutSec)]
+	if !ok {
+		return nil, fmt.Errorf("invalid timeout for batch submission: %v", cfg.BatchSubmission.TimeoutSec)
 	}
 
 	layer2Relayer := &Layer2Relayer{
@@ -134,6 +163,7 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 
 		bundleOrm:  orm.NewBundle(db),
 		batchOrm:   orm.NewBatch(db),
+		l1BlockOrm: orm.NewL1Block(db),
 		l2BlockOrm: orm.NewL2Block(db),
 		chunkOrm:   orm.NewChunk(db),
 
@@ -143,14 +173,10 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		finalizeSender: finalizeSender,
 		l1RollupABI:    bridgeAbi.ScrollChainABI,
 
-		gasOracleSender: gasOracleSender,
-		l2GasOracleABI:  bridgeAbi.L2GasPriceOracleABI,
-
-		minGasPrice:  minGasPrice,
-		gasPriceDiff: gasPriceDiff,
-
-		cfg:      cfg,
-		chainCfg: chainCfg,
+		l2GasOracleABI: bridgeAbi.L2GasPriceOracleABI,
+		batchStrategy:  strategy,
+		cfg:            cfg,
+		chainCfg:       chainCfg,
 	}
 
 	// chain_monitor client
@@ -161,16 +187,12 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 	}
 
 	// Initialize genesis before we do anything else
-	if initGenesis {
-		if err := layer2Relayer.initializeGenesis(); err != nil {
-			return nil, fmt.Errorf("failed to initialize and commit genesis batch, err: %v", err)
-		}
+	if err := layer2Relayer.initializeGenesis(); err != nil {
+		return nil, fmt.Errorf("failed to initialize and commit genesis batch, err: %v", err)
 	}
 	layer2Relayer.metrics = initL2RelayerMetrics(reg)
 
 	switch serviceType {
-	case ServiceTypeL2GasOracle:
-		go layer2Relayer.handleL2GasOracleConfirmLoop(ctx)
 	case ServiceTypeL2RollupRelayer:
 		go layer2Relayer.handleL2RollupRelayerConfirmLoop(ctx)
 	default:
@@ -195,17 +217,10 @@ func (r *Layer2Relayer) initializeGenesis() error {
 
 	log.Info("retrieved L2 genesis header", "hash", genesis.Hash().String())
 
-	chunk := &encoding.Chunk{
-		Blocks: []*encoding.Block{{
-			Header:         genesis,
-			Transactions:   nil,
-			WithdrawRoot:   common.Hash{},
-			RowConsumption: &gethTypes.RowConsumption{},
-		}},
-	}
+	chunk := &encoding.Chunk{Blocks: []*encoding.Block{{Header: genesis}}}
 
 	err = r.db.Transaction(func(dbTX *gorm.DB) error {
-		if err = r.l2BlockOrm.InsertL2Blocks(r.ctx, chunk.Blocks); err != nil {
+		if err = r.l2BlockOrm.InsertL2Blocks(r.ctx, chunk.Blocks, dbTX); err != nil {
 			return fmt.Errorf("failed to insert genesis block: %v", err)
 		}
 
@@ -266,11 +281,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, 0)
+	txHash, _, err := r.commitSender.SendTransaction(batchHash, &r.cfg.RollupContractAddress, calldata, nil)
 	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.String(), "batchHash", batchHash)
+	log.Info("importGenesisBatch transaction sent", "contract", r.cfg.RollupContractAddress, "txHash", txHash, "batchHash", batchHash)
 
 	// wait for confirmation
 	// we assume that no other transactions are sent before initializeGenesis completes
@@ -301,81 +316,11 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 	}
 }
 
-// ProcessGasPriceOracle imports gas price to layer1
-func (r *Layer2Relayer) ProcessGasPriceOracle() {
-	r.metrics.rollupL2RelayerGasPriceOraclerRunTotal.Inc()
-	batch, err := r.batchOrm.GetLatestBatch(r.ctx)
-	if err != nil {
-		log.Error("Failed to GetLatestBatch", "err", err)
-		return
-	}
-
-	if types.GasOracleStatus(batch.OracleStatus) == types.GasOraclePending {
-		suggestGasPrice, err := r.l2Client.SuggestGasPrice(r.ctx)
-		if err != nil {
-			log.Error("Failed to fetch SuggestGasPrice from l2geth", "err", err)
-			return
-		}
-		suggestGasPriceUint64 := uint64(suggestGasPrice.Int64())
-
-		// include the token exchange rate in the fee data if alternative gas token enabled
-		if r.cfg.GasOracleConfig.AlternativeGasTokenConfig != nil && r.cfg.GasOracleConfig.AlternativeGasTokenConfig.Enabled {
-			// The exchange rate represent the number of native token on L1 required to exchange for 1 native token on L2.
-			var exchangeRate float64
-			switch r.cfg.GasOracleConfig.AlternativeGasTokenConfig.Mode {
-			case "Fixed":
-				exchangeRate = r.cfg.GasOracleConfig.AlternativeGasTokenConfig.FixedExchangeRate
-			case "BinanceApi":
-				exchangeRate, err = rutils.GetExchangeRateFromBinanceApi(r.cfg.GasOracleConfig.AlternativeGasTokenConfig.TokenSymbolPair, 5)
-				if err != nil {
-					log.Error("Failed to get gas token exchange rate from Binance api", "tokenSymbolPair", r.cfg.GasOracleConfig.AlternativeGasTokenConfig.TokenSymbolPair, "err", err)
-					return
-				}
-			default:
-				log.Error("Invalid alternative gas token mode", "mode", r.cfg.GasOracleConfig.AlternativeGasTokenConfig.Mode)
-				return
-			}
-			if exchangeRate == 0 {
-				log.Error("Invalid exchange rate", "exchangeRate", exchangeRate)
-				return
-			}
-			suggestGasPriceUint64 = uint64(math.Ceil(float64(suggestGasPriceUint64) * exchangeRate))
-			suggestGasPrice = new(big.Int).SetUint64(suggestGasPriceUint64)
-		}
-
-		expectedDelta := r.lastGasPrice * r.gasPriceDiff / gasPriceDiffPrecision
-		if r.lastGasPrice > 0 && expectedDelta == 0 {
-			expectedDelta = 1
-		}
-
-		// last is undefined or (suggestGasPriceUint64 >= minGasPrice && exceed diff)
-		if r.lastGasPrice == 0 || (suggestGasPriceUint64 >= r.minGasPrice &&
-			(math.Abs(float64(suggestGasPriceUint64)-float64(r.lastGasPrice)) >= float64(expectedDelta))) {
-			data, err := r.l2GasOracleABI.Pack("setL2BaseFee", suggestGasPrice)
-			if err != nil {
-				log.Error("Failed to pack setL2BaseFee", "batch.Hash", batch.Hash, "GasPrice", suggestGasPrice.Uint64(), "err", err)
-				return
-			}
-
-			hash, err := r.gasOracleSender.SendTransaction(batch.Hash, &r.cfg.GasPriceOracleContractAddress, data, nil, 0)
-			if err != nil {
-				log.Error("Failed to send setL2BaseFee tx to layer2 ", "batch.Hash", batch.Hash, "err", err)
-				return
-			}
-
-			err = r.batchOrm.UpdateL2GasOracleStatusAndOracleTxHash(r.ctx, batch.Hash, types.GasOracleImporting, hash.String())
-			if err != nil {
-				log.Error("UpdateGasOracleStatusAndOracleTxHash failed", "batch.Hash", batch.Hash, "err", err)
-				return
-			}
-			r.lastGasPrice = suggestGasPriceUint64
-			r.metrics.rollupL2RelayerLastGasPrice.Set(float64(r.lastGasPrice))
-			log.Info("Update l2 gas price", "txHash", hash.String(), "GasPrice", suggestGasPrice)
-		}
-	}
-}
-
 // 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)
@@ -384,15 +329,56 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		return
 	}
 
-	var batchesToSubmit []*dbBatchWithChunksAndParent
+	// 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 forceSubmit bool
-	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)
+
+	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)
 			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
 
@@ -446,11 +432,6 @@ 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,
@@ -471,7 +452,7 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 	}
 
 	if forceSubmit {
-		log.Info("Forcing submission of batches due to timeout", "batch index", batchesToSubmit[0].Batch.Index, "created at", batchesToSubmit[0].Batch.CreatedAt)
+		log.Info("Forcing submission of batches due to timeout", "batch index", batchesToSubmit[0].Batch.Index, "first block created at", oldestBlockTimestamp)
 	}
 
 	// We have at least 1 batch to commit
@@ -496,7 +477,7 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		return
 	}
 
-	txHash, err := r.commitSender.SendTransaction(r.contextIDFromBatches(batchesToSubmit), &r.cfg.RollupContractAddress, calldata, blobs, 0)
+	txHash, blobBaseFee, err := r.commitSender.SendTransaction(r.contextIDFromBatches(batchesToSubmit), &r.cfg.RollupContractAddress, calldata, blobs)
 	if err != nil {
 		if errors.Is(err, sender.ErrTooManyPendingBlobTxs) {
 			r.metrics.rollupL2RelayerProcessPendingBatchErrTooManyPendingBlobTxsTotal.Inc()
@@ -536,6 +517,8 @@ 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())
 }
@@ -564,117 +547,6 @@ 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()
@@ -709,33 +581,6 @@ 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
@@ -834,11 +679,9 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 		return fmt.Errorf("failed to get end chunk of batch: %w", err)
 	}
 
-	hardForkName := encoding.GetHardforkName(r.chainCfg, firstChunk.StartBlockNumber, firstChunk.StartBlockTime)
-
-	var aggProof message.BundleProof
+	var aggProof *message.OpenVMBundleProof
 	if withProof {
-		aggProof, err = r.bundleOrm.GetVerifiedProofByHash(r.ctx, bundle.Hash, hardForkName)
+		aggProof, err = r.bundleOrm.GetVerifiedProofByHash(r.ctx, bundle.Hash)
 		if err != nil {
 			return fmt.Errorf("failed to get verified proof by bundle index: %d, err: %w", bundle.Index, err)
 		}
@@ -850,11 +693,6 @@ 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 {
@@ -864,7 +702,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, 0)
+	txHash, _, err := r.finalizeSender.SendTransaction("finalizeBundle-"+bundle.Hash, &r.cfg.RollupContractAddress, calldata, nil)
 	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,
@@ -1040,22 +878,6 @@ func (r *Layer2Relayer) handleConfirmation(cfm *sender.Confirmation) {
 		if err != nil {
 			log.Warn("UpdateFinalizeTxHashAndRollupStatus failed", "confirmation", cfm, "err", err)
 		}
-	case types.SenderTypeL2GasOracle:
-		batchHash := cfm.ContextID
-		var status types.GasOracleStatus
-		if cfm.IsSuccessful {
-			status = types.GasOracleImported
-			r.metrics.rollupL2UpdateGasOracleConfirmedTotal.Inc()
-		} else {
-			status = types.GasOracleImportedFailed
-			r.metrics.rollupL2UpdateGasOracleConfirmedFailedTotal.Inc()
-			log.Warn("UpdateGasOracleTxType transaction confirmed but failed in layer1", "confirmation", cfm)
-		}
-
-		err := r.batchOrm.UpdateL2GasOracleStatusAndOracleTxHash(r.ctx, batchHash, status, cfm.TxHash.String())
-		if err != nil {
-			log.Warn("UpdateL2GasOracleStatusAndOracleTxHash failed", "confirmation", cfm, "err", err)
-		}
 	default:
 		log.Warn("Unknown transaction type", "confirmation", cfm)
 	}
@@ -1063,17 +885,6 @@ func (r *Layer2Relayer) handleConfirmation(cfm *sender.Confirmation) {
 	log.Info("Transaction confirmed in layer1", "confirmation", cfm)
 }
 
-func (r *Layer2Relayer) handleL2GasOracleConfirmLoop(ctx context.Context) {
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case cfm := <-r.gasOracleSender.ConfirmChan():
-			r.handleConfirmation(cfm)
-		}
-	}
-}
-
 func (r *Layer2Relayer) handleL2RollupRelayerConfirmLoop(ctx context.Context) {
 	for {
 		select {
@@ -1087,48 +898,6 @@ 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
@@ -1186,35 +955,7 @@ func (r *Layer2Relayer) constructCommitBatchPayloadCodecV7(batchesToSubmit []*db
 	return calldata, blobs, maxBlockHeight, totalGasUsed, nil
 }
 
-func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV4(dbBatch *orm.Batch, aggProof message.BundleProof) ([]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.BundleProof) ([]byte, error) {
+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(
 			"finalizeBundlePostEuclidV2",
@@ -1248,10 +989,6 @@ func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV7(dbBatch *orm.Batch
 // StopSenders stops the senders of the rollup-relayer to prevent querying the removed pending_transaction table in unit tests.
 // for unit test
 func (r *Layer2Relayer) StopSenders() {
-	if r.gasOracleSender != nil {
-		r.gasOracleSender.Stop()
-	}
-
 	if r.commitSender != nil {
 		r.commitSender.Stop()
 	}
@@ -1261,6 +998,141 @@ 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

@@ -12,14 +12,10 @@ type l2RelayerMetrics struct {
 	rollupL2RelayerProcessPendingBatchTotal                         prometheus.Counter
 	rollupL2RelayerProcessPendingBatchSuccessTotal                  prometheus.Counter
 	rollupL2RelayerProcessPendingBatchErrTooManyPendingBlobTxsTotal prometheus.Counter
-	rollupL2RelayerGasPriceOraclerRunTotal                          prometheus.Counter
-	rollupL2RelayerLastGasPrice                                     prometheus.Gauge
 	rollupL2BatchesCommittedConfirmedTotal                          prometheus.Counter
 	rollupL2BatchesCommittedConfirmedFailedTotal                    prometheus.Counter
 	rollupL2BatchesFinalizedConfirmedTotal                          prometheus.Counter
 	rollupL2BatchesFinalizedConfirmedFailedTotal                    prometheus.Counter
-	rollupL2UpdateGasOracleConfirmedTotal                           prometheus.Counter
-	rollupL2UpdateGasOracleConfirmedFailedTotal                     prometheus.Counter
 	rollupL2ChainMonitorLatestFailedCall                            prometheus.Counter
 	rollupL2ChainMonitorLatestFailedBatchStatus                     prometheus.Counter
 	rollupL2RelayerProcessPendingBundlesTotal                       prometheus.Counter
@@ -30,6 +26,12 @@ 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 (
@@ -56,14 +58,6 @@ func initL2RelayerMetrics(reg prometheus.Registerer) *l2RelayerMetrics {
 				Name: "rollup_layer2_process_pending_batch_err_too_many_pending_blob_txs_total",
 				Help: "The total number of layer2 process pending batch failed on too many pending blob txs",
 			}),
-			rollupL2RelayerGasPriceOraclerRunTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_layer2_gas_price_oracler_total",
-				Help: "The total number of layer2 gas price oracler run total",
-			}),
-			rollupL2RelayerLastGasPrice: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-				Name: "rollup_layer2_gas_price_latest_gas_price",
-				Help: "The latest gas price of rollup relayer l2",
-			}),
 			rollupL2BatchesCommittedConfirmedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 				Name: "rollup_layer2_process_committed_batches_confirmed_total",
 				Help: "The total number of layer2 process committed batches confirmed total",
@@ -80,14 +74,6 @@ func initL2RelayerMetrics(reg prometheus.Registerer) *l2RelayerMetrics {
 				Name: "rollup_layer2_process_finalized_batches_confirmed_failed_total",
 				Help: "The total number of layer2 process finalized batches confirmed failed total",
 			}),
-			rollupL2UpdateGasOracleConfirmedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_layer2_update_layer1_gas_oracle_confirmed_total",
-				Help: "The total number of updating layer2 gas oracle confirmed",
-			}),
-			rollupL2UpdateGasOracleConfirmedFailedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_layer2_update_layer1_gas_oracle_confirmed_failed_total",
-				Help: "The total number of updating layer2 gas oracle confirmed failed",
-			}),
 			rollupL2ChainMonitorLatestFailedCall: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 				Name: "rollup_layer2_chain_monitor_latest_failed_batch_call",
 				Help: "The total number of failed call chain_monitor api",
@@ -124,6 +110,26 @@ 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

@@ -2,7 +2,6 @@ package relayer
 
 import (
 	"context"
-	"errors"
 	"math/big"
 	"net/http"
 	"strings"
@@ -14,9 +13,7 @@ import (
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
 	"github.com/scroll-tech/go-ethereum/params"
-	"github.com/smartystreets/goconvey/convey"
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 
@@ -44,209 +41,193 @@ func setupL2RelayerDB(t *testing.T) *gorm.DB {
 func testCreateNewRelayer(t *testing.T) {
 	db := setupL2RelayerDB(t)
 	defer database.CloseDB(db)
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, true, ServiceTypeL2RollupRelayer, nil)
+	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, ServiceTypeL2RollupRelayer, nil)
 	assert.NoError(t, err)
 	assert.NotNil(t, relayer)
 	defer relayer.StopSenders()
 }
 
 func testL2RelayerProcessPendingBatches(t *testing.T) {
-	codecVersions := []encoding.CodecVersion{encoding.CodecV4}
-	for _, codecVersion := range codecVersions {
-		db := setupL2RelayerDB(t)
-		defer database.CloseDB(db)
+	db := setupL2RelayerDB(t)
+	defer database.CloseDB(db)
 
-		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")
-		}
+	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, true, 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, codecVersion, rutils.ChunkMetrics{})
-		assert.NoError(t, err)
-		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion, 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, encoding.CodecV7, rutils.ChunkMetrics{})
+	assert.NoError(t, err)
+	_, err = chunkOrm.InsertChunk(context.Background(), chunk2, encoding.CodecV7, rutils.ChunkMetrics{})
+	assert.NoError(t, err)
 
-		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()
+	batch := &encoding.Batch{
+		Index:                      1,
+		TotalL1MessagePoppedBefore: 0,
+		ParentBatchHash:            common.Hash{},
+		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		Blocks:                     []*encoding.Block{block1, block2},
 	}
+
+	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) {
-	codecVersions := []encoding.CodecVersion{encoding.CodecV4}
-	for _, codecVersion := range codecVersions {
-		db := setupL2RelayerDB(t)
-		defer database.CloseDB(db)
+	db := setupL2RelayerDB(t)
+	defer database.CloseDB(db)
 
-		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, true, ServiceTypeL2RollupRelayer, nil)
-		assert.NoError(t, err)
+	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)
 
-		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))
-
-		proof := &message.Halo2BundleProof{
-			RawProof:  []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
-			Instances: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
-			Vk:        []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
-		}
-		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()
+	batch := &encoding.Batch{
+		Index:                      1,
+		TotalL1MessagePoppedBefore: 0,
+		ParentBatchHash:            common.Hash{},
+		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		Blocks:                     []*encoding.Block{block1, block2},
 	}
+
+	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) {
-	codecVersions := []encoding.CodecVersion{encoding.CodecV4}
-	for _, codecVersion := range codecVersions {
-		db := setupL2RelayerDB(t)
-		defer database.CloseDB(db)
+	db := setupL2RelayerDB(t)
+	defer database.CloseDB(db)
 
-		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, true, ServiceTypeL2RollupRelayer, nil)
-		assert.NoError(t, err)
+	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)
 
-		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)
+	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)
 
-		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()
+	batch := &encoding.Batch{
+		Index:                      1,
+		TotalL1MessagePoppedBefore: 0,
+		ParentBatchHash:            common.Hash{},
+		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		Blocks:                     []*encoding.Block{block1, block2},
 	}
+
+	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) {
@@ -257,7 +238,7 @@ func testL2RelayerCommitConfirm(t *testing.T) {
 	l2Cfg := cfg.L2Config
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, true, ServiceTypeL2RollupRelayer, nil)
+	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, ServiceTypeL2RollupRelayer, nil)
 	assert.NoError(t, err)
 	defer l2Relayer.StopSenders()
 
@@ -271,6 +252,7 @@ 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{})
@@ -313,7 +295,7 @@ func testL2RelayerFinalizeBundleConfirm(t *testing.T) {
 	l2Cfg := cfg.L2Config
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, true, ServiceTypeL2RollupRelayer, nil)
+	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, ServiceTypeL2RollupRelayer, nil)
 	assert.NoError(t, err)
 	defer l2Relayer.StopSenders()
 
@@ -329,13 +311,14 @@ 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.CodecV4)
+		bundle, err := bundleOrm.InsertBundle(context.Background(), []*orm.Batch{dbBatch}, encoding.CodecV7)
 		assert.NoError(t, err)
 		bundleHashes[i] = bundle.Hash
 
@@ -374,149 +357,6 @@ func testL2RelayerFinalizeBundleConfirm(t *testing.T) {
 	}, 5*time.Second, 100*time.Millisecond, "Bundle or Batch status did not update as expected")
 }
 
-func testL2RelayerGasOracleConfirm(t *testing.T) {
-	db := setupL2RelayerDB(t)
-	defer database.CloseDB(db)
-
-	batch1 := &encoding.Batch{
-		Index:                      0,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{chunk1},
-	}
-
-	batchOrm := orm.NewBatch(db)
-	dbBatch1, err := batchOrm.InsertBatch(context.Background(), batch1, encoding.CodecV0, rutils.BatchMetrics{})
-	assert.NoError(t, err)
-
-	batch2 := &encoding.Batch{
-		Index:                      batch1.Index + 1,
-		TotalL1MessagePoppedBefore: batch1.TotalL1MessagePoppedBefore,
-		ParentBatchHash:            common.HexToHash(dbBatch1.Hash),
-		Chunks:                     []*encoding.Chunk{chunk2},
-	}
-
-	dbBatch2, err := batchOrm.InsertBatch(context.Background(), batch2, encoding.CodecV0, rutils.BatchMetrics{})
-	assert.NoError(t, err)
-
-	// Create and set up the Layer2 Relayer.
-	l2Cfg := cfg.L2Config
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, false, ServiceTypeL2GasOracle, nil)
-	assert.NoError(t, err)
-	defer l2Relayer.StopSenders()
-
-	// Simulate message confirmations.
-	type BatchConfirmation struct {
-		batchHash    string
-		isSuccessful bool
-	}
-
-	confirmations := []BatchConfirmation{
-		{batchHash: dbBatch1.Hash, isSuccessful: true},
-		{batchHash: dbBatch2.Hash, isSuccessful: false},
-	}
-
-	for _, confirmation := range confirmations {
-		l2Relayer.gasOracleSender.SendConfirmation(&sender.Confirmation{
-			ContextID:    confirmation.batchHash,
-			IsSuccessful: confirmation.isSuccessful,
-			SenderType:   types.SenderTypeL2GasOracle,
-		})
-	}
-	// Check the database for the updated status using TryTimes.
-	ok := utils.TryTimes(5, func() bool {
-		expectedStatuses := []types.GasOracleStatus{types.GasOracleImported, types.GasOracleImportedFailed}
-		for i, confirmation := range confirmations {
-			gasOracle, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{"hash": confirmation.batchHash}, nil, 0)
-			if err != nil || len(gasOracle) != 1 || types.GasOracleStatus(gasOracle[0].OracleStatus) != expectedStatuses[i] {
-				return false
-			}
-		}
-		return true
-	})
-	assert.True(t, ok)
-}
-
-func testLayer2RelayerProcessGasPriceOracle(t *testing.T) {
-	db := setupL2RelayerDB(t)
-	defer database.CloseDB(db)
-
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, false, ServiceTypeL2GasOracle, nil)
-	assert.NoError(t, err)
-	assert.NotNil(t, relayer)
-	defer relayer.StopSenders()
-
-	var batchOrm *orm.Batch
-	convey.Convey("Failed to GetLatestBatch", t, func() {
-		targetErr := errors.New("GetLatestBatch error")
-		patchGuard := gomonkey.ApplyMethodFunc(batchOrm, "GetLatestBatch", func(context.Context) (*orm.Batch, error) {
-			return nil, targetErr
-		})
-		defer patchGuard.Reset()
-		relayer.ProcessGasPriceOracle()
-	})
-
-	patchGuard := gomonkey.ApplyMethodFunc(batchOrm, "GetLatestBatch", func(context.Context) (*orm.Batch, error) {
-		batch := orm.Batch{
-			OracleStatus: int16(types.GasOraclePending),
-			Hash:         "0x0000000000000000000000000000000000000000",
-		}
-		return &batch, nil
-	})
-	defer patchGuard.Reset()
-
-	convey.Convey("Failed to fetch SuggestGasPrice from l2geth", t, func() {
-		targetErr := errors.New("SuggestGasPrice error")
-		patchGuard.ApplyMethodFunc(relayer.l2Client, "SuggestGasPrice", func(ctx context.Context) (*big.Int, error) {
-			return nil, targetErr
-		})
-		relayer.ProcessGasPriceOracle()
-	})
-
-	patchGuard.ApplyMethodFunc(relayer.l2Client, "SuggestGasPrice", func(ctx context.Context) (*big.Int, error) {
-		return big.NewInt(100), nil
-	})
-
-	convey.Convey("Failed to pack setL2BaseFee", t, func() {
-		targetErr := errors.New("setL2BaseFee error")
-		patchGuard.ApplyMethodFunc(relayer.l2GasOracleABI, "Pack", func(name string, args ...interface{}) ([]byte, error) {
-			return nil, targetErr
-		})
-		relayer.ProcessGasPriceOracle()
-	})
-
-	patchGuard.ApplyMethodFunc(relayer.l2GasOracleABI, "Pack", func(name string, args ...interface{}) ([]byte, error) {
-		return nil, nil
-	})
-
-	convey.Convey("Failed to send setL2BaseFee tx to layer2", t, func() {
-		targetErr := errors.New("failed to send setL2BaseFee tx to layer2 error")
-		patchGuard.ApplyMethodFunc(relayer.gasOracleSender, "SendTransaction", func(ContextID string, target *common.Address, data []byte, blob *kzg4844.Blob, fallbackGasLimit uint64) (hash common.Hash, err error) {
-			return common.Hash{}, targetErr
-		})
-		relayer.ProcessGasPriceOracle()
-	})
-
-	patchGuard.ApplyMethodFunc(relayer.gasOracleSender, "SendTransaction", func(ContextID string, target *common.Address, data []byte, blob *kzg4844.Blob, fallbackGasLimit uint64) (hash common.Hash, err error) {
-		return common.HexToHash("0x56789abcdef1234"), nil
-	})
-
-	convey.Convey("UpdateGasOracleStatusAndOracleTxHash failed", t, func() {
-		targetErr := errors.New("UpdateL2GasOracleStatusAndOracleTxHash error")
-		patchGuard.ApplyMethodFunc(batchOrm, "UpdateL2GasOracleStatusAndOracleTxHash", func(ctx context.Context, hash string, status types.GasOracleStatus, txHash string) error {
-			return targetErr
-		})
-		relayer.ProcessGasPriceOracle()
-	})
-
-	patchGuard.ApplyMethodFunc(batchOrm, "UpdateL2GasOracleStatusAndOracleTxHash", func(ctx context.Context, hash string, status types.GasOracleStatus, txHash string) error {
-		return nil
-	})
-	relayer.ProcessGasPriceOracle()
-}
-
 func mockChainMonitorServer(baseURL string) (*http.Server, error) {
 	router := gin.New()
 	r := router.Group("/v1")
@@ -539,7 +379,7 @@ func testGetBatchStatusByIndex(t *testing.T) {
 	defer database.CloseDB(db)
 
 	cfg.L2Config.RelayerConfig.ChainMonitor.Enabled = true
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, true, ServiceTypeL2RollupRelayer, nil)
+	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, ServiceTypeL2RollupRelayer, nil)
 	assert.NoError(t, err)
 	assert.NotNil(t, relayer)
 	defer relayer.StopSenders()
@@ -558,6 +398,7 @@ 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/relayer/relayer_test.go

@@ -128,8 +128,6 @@ func TestFunctions(t *testing.T) {
 	t.Run("TestL2RelayerFinalizeTimeoutBundles", testL2RelayerFinalizeTimeoutBundles)
 	t.Run("TestL2RelayerCommitConfirm", testL2RelayerCommitConfirm)
 	t.Run("TestL2RelayerFinalizeBundleConfirm", testL2RelayerFinalizeBundleConfirm)
-	t.Run("TestL2RelayerGasOracleConfirm", testL2RelayerGasOracleConfirm)
-	t.Run("TestLayer2RelayerProcessGasPriceOracle", testLayer2RelayerProcessGasPriceOracle)
 
 	// test getBatchStatusByIndex
 	t.Run("TestGetBatchStatusByIndex", testGetBatchStatusByIndex)

rollup/internal/controller/sender/estimategas.go

@@ -7,11 +7,10 @@ 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, fallbackGasLimit uint64) (*FeeData, error) {
+func (s *Sender) estimateLegacyGas(to *common.Address, data []byte) (*FeeData, error) {
 	gasPrice, err := s.client.SuggestGasPrice(s.ctx)
 	if err != nil {
 		log.Error("estimateLegacyGas SuggestGasPrice failure", "error", err)
@@ -26,21 +25,17 @@ func (s *Sender) estimateLegacyGas(to *common.Address, data []byte, fallbackGasL
 	gasLimit, _, err := s.estimateGasLimit(to, data, nil, gasPrice, nil, nil, nil)
 	if err != nil {
 		log.Error("estimateLegacyGas estimateGasLimit failure", "gas price", gasPrice, "from", s.transactionSigner.GetAddr().String(),
-			"nonce", s.transactionSigner.GetNonce(), "to address", to.String(), "fallback gas limit", fallbackGasLimit, "error", err)
-		if fallbackGasLimit == 0 {
-			return nil, err
-		}
-		gasLimit = fallbackGasLimit
-	} else {
-		gasLimit = gasLimit * 12 / 10 // 20% extra gas to avoid out of gas error
+			"nonce", s.transactionSigner.GetNonce(), "to address", to.String(), "error", err)
+		return nil, err
 	}
+
 	return &FeeData{
 		gasPrice: gasPrice,
-		gasLimit: gasLimit,
+		gasLimit: gasLimit * 12 / 10, // 20% extra gas to avoid out of gas error
 	}, nil
 }
 
-func (s *Sender) estimateDynamicGas(to *common.Address, data []byte, baseFee uint64, fallbackGasLimit uint64) (*FeeData, error) {
+func (s *Sender) estimateDynamicGas(to *common.Address, data []byte, baseFee uint64) (*FeeData, error) {
 	gasTipCap, err := s.client.SuggestGasTipCap(s.ctx)
 	if err != nil {
 		log.Error("estimateDynamicGas SuggestGasTipCap failure", "error", err)
@@ -57,16 +52,12 @@ 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", 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
+			"fallback gas limit", "error", err)
+		return nil, err
 	}
+
 	feeData := &FeeData{
-		gasLimit:  gasLimit,
+		gasLimit:  gasLimit * 12 / 10, // 20% extra gas to avoid out of gas error,
 		gasTipCap: gasTipCap,
 		gasFeeCap: gasFeeCap,
 	}
@@ -76,7 +67,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 *gethTypes.BlobTxSidecar, baseFee, blobBaseFee uint64, fallbackGasLimit uint64) (*FeeData, error) {
+func (s *Sender) estimateBlobGas(to *common.Address, data []byte, sidecar *types.BlobTxSidecar, baseFee, blobBaseFee uint64) (*FeeData, error) {
 	gasTipCap, err := s.client.SuggestGasTipCap(s.ctx)
 	if err != nil {
 		log.Error("estimateBlobGas SuggestGasTipCap failure", "error", err)
@@ -93,17 +84,12 @@ func (s *Sender) estimateBlobGas(to *common.Address, data []byte, sidecar *gethT
 	gasLimit, accessList, err := s.estimateGasLimit(to, data, sidecar, nil, gasTipCap, gasFeeCap, blobGasFeeCap)
 	if err != nil {
 		log.Error("estimateBlobGas estimateGasLimit failure",
-			"from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "to address", to.String(),
-			"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
+			"from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "to address", to.String(), "error", err)
+		return nil, err
 	}
+
 	feeData := &FeeData{
-		gasLimit:      gasLimit,
+		gasLimit:      gasLimit * 12 / 10, // 20% extra gas to avoid out of gas error
 		gasTipCap:     gasTipCap,
 		gasFeeCap:     gasFeeCap,
 		blobGasFeeCap: blobGasFeeCap,
@@ -115,7 +101,7 @@ func (s *Sender) estimateBlobGas(to *common.Address, data []byte, sidecar *gethT
 	return feeData, nil
 }
 
-func (s *Sender) estimateGasLimit(to *common.Address, data []byte, sidecar *gethTypes.BlobTxSidecar, gasPrice, gasTipCap, gasFeeCap, blobGasFeeCap *big.Int) (uint64, *types.AccessList, error) {
+func (s *Sender) estimateGasLimit(to *common.Address, data []byte, sidecar *types.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, fallbackGasLimit uint64) (*FeeData, error) {
+func (s *Sender) getFeeData(target *common.Address, data []byte, sidecar *gethTypes.BlobTxSidecar, baseFee, blobBaseFee uint64) (*FeeData, error) {
 	switch s.config.TxType {
 	case LegacyTxType:
-		return s.estimateLegacyGas(target, data, fallbackGasLimit)
+		return s.estimateLegacyGas(target, data)
 	case DynamicFeeTxType:
 		if sidecar == nil {
-			return s.estimateDynamicGas(target, data, baseFee, fallbackGasLimit)
+			return s.estimateDynamicGas(target, data, baseFee)
 		}
-		return s.estimateBlobGas(target, data, sidecar, baseFee, blobBaseFee, fallbackGasLimit)
+		return s.estimateBlobGas(target, data, sidecar, baseFee, blobBaseFee)
 	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, fallbackGasLimit uint64) (common.Hash, error) {
+func (s *Sender) SendTransaction(contextID string, target *common.Address, data []byte, blobs []*kzg4844.Blob) (common.Hash, uint64, 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{}, fmt.Errorf("failed to count pending transactions, err: %w", err)
+				return common.Hash{}, 0, fmt.Errorf("failed to count pending transactions, err: %w", err)
 			}
 			if numPendingTransactions >= s.config.MaxPendingBlobTxs {
-				return common.Hash{}, ErrTooManyPendingBlobTxs
+				return common.Hash{}, 0, ErrTooManyPendingBlobTxs
 			}
 
 		}
 		sidecar, err = makeSidecar(blobs)
 		if err != nil {
 			log.Error("failed to make sidecar for blob transaction", "error", err)
-			return common.Hash{}, fmt.Errorf("failed to make sidecar for blob transaction, err: %w", err)
+			return common.Hash{}, 0, 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{}, fmt.Errorf("failed to get block number and base fee, err: %w", err)
+		return common.Hash{}, 0, fmt.Errorf("failed to get block number and base fee, err: %w", err)
 	}
 
-	if feeData, err = s.getFeeData(target, data, sidecar, baseFee, blobBaseFee, fallbackGasLimit); err != nil {
+	if feeData, err = s.getFeeData(target, data, sidecar, baseFee, blobBaseFee); err != nil {
 		s.metrics.sendTransactionFailureGetFee.WithLabelValues(s.service, s.name).Inc()
-		log.Error("failed to get fee data", "from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "fallback gas limit", fallbackGasLimit, "err", err)
-		return common.Hash{}, 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(), "err", err)
+		return common.Hash{}, 0, 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{}, fmt.Errorf("failed to create signed transaction, err: %w", err)
+		return common.Hash{}, 0, 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{}, fmt.Errorf("failed to insert transaction, err: %w", err)
+		return common.Hash{}, 0, 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{}, fmt.Errorf("failed to delete transaction, err: %w", updateErr)
+			return common.Hash{}, 0, 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{}, fmt.Errorf("failed to send transaction, err: %w", err)
+		return common.Hash{}, 0, fmt.Errorf("failed to send transaction, err: %w", err)
 	}
 
 	s.transactionSigner.SetNonce(signedTx.Nonce() + 1)
 
-	return signedTx.Hash(), nil
+	return signedTx.Hash(), blobBaseFee, 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,7 +21,6 @@ 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"
@@ -34,7 +33,6 @@ import (
 
 	bridgeAbi "scroll-tech/rollup/abi"
 	"scroll-tech/rollup/internal/config"
-	"scroll-tech/rollup/internal/orm"
 	"scroll-tech/rollup/mock_bridge"
 )
 
@@ -136,7 +134,6 @@ 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)
@@ -190,7 +187,7 @@ func testSendAndRetrieveTransaction(t *testing.T) {
 		if txBlob[i] != nil {
 			blobs = []*kzg4844.Blob{txBlob[i]}
 		}
-		hash, err := s.SendTransaction("0", &common.Address{}, nil, blobs, 0)
+		hash, _, err := s.SendTransaction("0", &common.Address{}, nil, blobs)
 		assert.NoError(t, err)
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
 		assert.NoError(t, err)
@@ -214,63 +211,6 @@ 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 {
@@ -605,10 +545,10 @@ func testResubmitNonceGappedTransaction(t *testing.T) {
 		if txBlob[i] != nil {
 			blobs = []*kzg4844.Blob{txBlob[i]}
 		}
-		_, err = s.SendTransaction("test-1", &common.Address{}, nil, blobs, 0)
+		_, _, err = s.SendTransaction("test-1", &common.Address{}, nil, blobs)
 		assert.NoError(t, err)
 
-		_, err = s.SendTransaction("test-2", &common.Address{}, nil, blobs, 0)
+		_, _, err = s.SendTransaction("test-2", &common.Address{}, nil, blobs)
 		assert.NoError(t, err)
 
 		s.checkPendingTransaction()
@@ -649,7 +589,7 @@ func testCheckPendingTransactionTxConfirmed(t *testing.T) {
 			return nil
 		})
 
-		_, err = s.SendTransaction("test", &common.Address{}, nil, randBlobs(1), 0)
+		_, _, err = s.SendTransaction("test", &common.Address{}, nil, randBlobs(1))
 		assert.NoError(t, err)
 
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
@@ -691,7 +631,7 @@ func testCheckPendingTransactionResubmitTxConfirmed(t *testing.T) {
 			return nil
 		})
 
-		originTxHash, err := s.SendTransaction("test", &common.Address{}, nil, randBlobs(1), 0)
+		originTxHash, _, err := s.SendTransaction("test", &common.Address{}, nil, randBlobs(1))
 		assert.NoError(t, err)
 
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
@@ -751,7 +691,7 @@ func testCheckPendingTransactionReplacedTxConfirmed(t *testing.T) {
 			return nil
 		})
 
-		txHash, err := s.SendTransaction("test", &common.Address{}, nil, randBlobs(1), 0)
+		txHash, _, err := s.SendTransaction("test", &common.Address{}, nil, randBlobs(1))
 		assert.NoError(t, err)
 
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
@@ -821,7 +761,7 @@ func testCheckPendingTransactionTxMultipleTimesWithOnlyOneTxPending(t *testing.T
 			return nil
 		})
 
-		_, err = s.SendTransaction("test", &common.Address{}, nil, randBlobs(1), 0)
+		_, _, err = s.SendTransaction("test", &common.Address{}, nil, randBlobs(1))
 		assert.NoError(t, err)
 
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
@@ -895,7 +835,7 @@ func testBlobTransactionWithBlobhashOpContractCall(t *testing.T) {
 	assert.NoError(t, err)
 	defer s.Stop()
 
-	_, err = s.SendTransaction("0", &testContractsAddress, data, blobs, 0)
+	_, _, err = s.SendTransaction("0", &testContractsAddress, data, blobs)
 	assert.NoError(t, err)
 
 	var txHash common.Hash
@@ -953,10 +893,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), 0)
+		_, _, err = s.SendTransaction("0", &common.Address{}, nil, randBlobs(1))
 		assert.NoError(t, err)
 	}
-	_, err = s.SendTransaction("0", &common.Address{}, nil, randBlobs(1), 0)
+	_, _, err = s.SendTransaction("0", &common.Address{}, nil, randBlobs(1))
 	assert.ErrorIs(t, err, ErrTooManyPendingBlobTxs)
 	s.Stop()
 }

rollup/internal/controller/watcher/batch_proposer.go

@@ -13,6 +13,8 @@ import (
 	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
+	"scroll-tech/common/types"
+
 	"scroll-tech/rollup/internal/config"
 	"scroll-tech/rollup/internal/orm"
 	"scroll-tech/rollup/internal/utils"
@@ -27,13 +29,9 @@ type BatchProposer struct {
 	chunkOrm   *orm.Chunk
 	l2BlockOrm *orm.L2Block
 
-	maxL1CommitGasPerBatch          uint64
-	maxL1CommitCalldataSizePerBatch uint64
-	batchTimeoutSec                 uint64
-	gasCostIncreaseMultiplier       float64
-	maxUncompressedBatchBytesSize   uint64
-	maxChunksPerBatch               int
+	cfg *config.BatchProposerConfig
 
+	replayMode      bool
 	minCodecVersion encoding.CodecVersion
 	chainCfg        *params.ChainConfig
 
@@ -41,14 +39,10 @@ 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
@@ -60,28 +54,18 @@ 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",
-		"maxL1CommitGasPerBatch", cfg.MaxL1CommitGasPerBatch,
-		"maxL1CommitCalldataSizePerBatch", cfg.MaxL1CommitCalldataSizePerBatch,
-		"batchTimeoutSec", cfg.BatchTimeoutSec,
-		"gasCostIncreaseMultiplier", cfg.GasCostIncreaseMultiplier,
-		"maxBlobSize", maxBlobSize,
-		"maxUncompressedBatchBytesSize", cfg.MaxUncompressedBatchBytesSize)
+	log.Info("new batch proposer", "batchTimeoutSec", cfg.BatchTimeoutSec, "maxBlobSize", maxBlobSize)
 
 	p := &BatchProposer{
-		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,
-		minCodecVersion:                 minCodecVersion,
-		chainCfg:                        chainCfg,
+		ctx:             ctx,
+		db:              db,
+		batchOrm:        orm.NewBatch(db),
+		chunkOrm:        orm.NewChunk(db),
+		l2BlockOrm:      orm.NewL2Block(db),
+		cfg:             cfg,
+		replayMode:      false,
+		minCodecVersion: minCodecVersion,
+		chainCfg:        chainCfg,
 
 		batchProposerCircleTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 			Name: "rollup_propose_batch_circle_total",
@@ -103,14 +87,6 @@ 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",
@@ -127,14 +103,6 @@ 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.",
@@ -152,6 +120,14 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, minC
 	return p
 }
 
+// SetReplayDB sets the replay database for the BatchProposer.
+// This is used for the proposer tool only, to change the l2_block data source.
+// This function is not thread-safe and should be called after initializing the BatchProposer and before starting to propose chunks.
+func (p *BatchProposer) SetReplayDB(replayDB *gorm.DB) {
+	p.l2BlockOrm = orm.NewL2Block(replayDB)
+	p.replayMode = true
+}
+
 // TryProposeBatch tries to propose a new batches.
 func (p *BatchProposer) TryProposeBatch() {
 	p.batchProposerCircleTotal.Inc()
@@ -185,6 +161,7 @@ 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))
 	}
@@ -226,6 +203,15 @@ func (p *BatchProposer) updateDBBatchInfo(batch *encoding.Batch, codecVersion en
 			log.Warn("BatchProposer.UpdateBatchHashInRange update the chunk's batch hash failure", "hash", dbBatch.Hash, "error", dbErr)
 			return dbErr
 		}
+		if p.replayMode {
+			// If replayMode is true, meaning the batch was proposed by the proposer tool,
+			// set batch status to types.RollupCommitted and assign a unique commit tx hash to enable new bundle proposals.
+			if dbErr = p.batchOrm.UpdateCommitTxHashAndRollupStatus(p.ctx, dbBatch.Hash, dbBatch.Hash, types.RollupCommitted, dbTX); dbErr != nil {
+				log.Warn("BatchProposer.UpdateCommitTxHashAndRollupStatus update the batch's commit tx hash failure", "hash", dbBatch.Hash, "error", dbErr)
+				return dbErr
+			}
+		}
+
 		return nil
 	})
 	if err != nil {
@@ -256,7 +242,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.maxChunksPerBatch)
+	maxChunksThisBatch := min(codec.MaxNumChunksPerBatch(), p.cfg.MaxChunksPerBatch)
 
 	// select at most maxChunkNumPerBatch chunks
 	dbChunks, err := p.chunkOrm.GetChunksGEIndex(p.ctx, firstUnbatchedChunkIndex, maxChunksThisBatch)
@@ -298,9 +284,7 @@ func (p *BatchProposer) proposeBatch() error {
 
 	for i, chunk := range daChunks {
 		batch.Chunks = append(batch.Chunks, chunk)
-		if codec.Version() >= encoding.CodecV7 {
-			batch.Blocks = append(batch.Blocks, chunk.Blocks...)
-		}
+		batch.Blocks = append(batch.Blocks, chunk.Blocks...)
 		batch.PostL1MessageQueueHash = common.HexToHash(dbChunks[i].PostL1MessageQueueHash)
 
 		metrics, calcErr := utils.CalculateBatchMetrics(&batch, codec.Version())
@@ -310,33 +294,21 @@ func (p *BatchProposer) proposeBatch() error {
 
 		p.recordTimerBatchMetrics(metrics)
 
-		totalOverEstimateL1CommitGas := uint64(p.gasCostIncreaseMultiplier * float64(metrics.L1CommitGas))
-		if metrics.L1CommitCalldataSize > p.maxL1CommitCalldataSizePerBatch || totalOverEstimateL1CommitGas > p.maxL1CommitGasPerBatch ||
-			metrics.L1CommitBlobSize > maxBlobSize || metrics.L1CommitUncompressedBatchBytesSize > p.maxUncompressedBatchBytesSize {
+		if metrics.L1CommitBlobSize > maxBlobSize {
 			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, maxL1CommitCalldataSize: %v, maxL1CommitGas: %v, maxBlobSize: %v, maxUncompressedBatchBytesSize: %v",
-					dbChunks[0].StartBlockNumber, dbChunks[0].EndBlockNumber, metrics, maxChunksThisBatch, p.maxL1CommitCalldataSizePerBatch, p.maxL1CommitGasPerBatch, maxBlobSize, p.maxUncompressedBatchBytesSize)
+				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)
 			}
 
 			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,
-				"L1CommitUncompressedBatchBytesSize", metrics.L1CommitUncompressedBatchBytesSize,
-				"maxUncompressedBatchBytesSize", p.maxUncompressedBatchBytesSize)
+				"maxBlobSize", maxBlobSize)
 
 			lastChunk := batch.Chunks[len(batch.Chunks)-1]
 			batch.Chunks = batch.Chunks[:len(batch.Chunks)-1]
 			batch.PostL1MessageQueueHash = common.HexToHash(dbChunks[i-1].PostL1MessageQueueHash)
-
-			if codec.Version() >= encoding.CodecV7 {
-				batch.Blocks = batch.Blocks[:len(batch.Blocks)-len(lastChunk.Blocks)]
-			}
+			batch.Blocks = batch.Blocks[:len(batch.Blocks)-len(lastChunk.Blocks)]
 
 			metrics, err = utils.CalculateBatchMetrics(&batch, codec.Version())
 			if err != nil {
@@ -353,7 +325,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.batchTimeoutSec < currentTimeSec || metrics.NumChunks == uint64(maxChunksThisBatch) {
+	if metrics.FirstBlockTimestamp+p.cfg.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,
@@ -389,17 +361,11 @@ 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))
 }