feat: bump zkvm-prover (#1614 )

Co-authored-by: omerfirmak <omerfirmak@users.noreply.github.com>
feat: upgrade to euclid-enabled l2geth (#1612 )
2026-04-23 03:00:50 -04:00 · 2025-03-10 23:12:12 +08:00 · 2025-03-10 14:57:34 +03:00 · 2025-03-10 12:17:59 +03:00 · 2025-03-05 13:17:18 +08:00 · 2025-03-01 00:56:58 +08:00
58 changed files with 13573 additions and 5885 deletions
--- a/.github/workflows/common.yml
+++ b/.github/workflows/common.yml
@@ -29,7 +29,7 @@ jobs:
    steps:
    - uses: actions-rs/toolchain@v1
      with:
-        toolchain: nightly-2023-12-03
+        toolchain: nightly-2024-12-06
        override: true
        components: rustfmt, clippy
    - name: Install Go
--- a/14
+++ b/14
@@ -1,6 +1,6 @@
 .PHONY: fmt dev_docker build_test_docker run_test_docker clean update

-L2GETH_TAG=scroll-v5.8.4
+L2GETH_TAG=scroll-v5.8.23

 help: ## Display this help message
 	@grep -h \
@@ -8,12 +8,12 @@ help: ## Display this help message
 		awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
 update: ## Update dependencies
 	go work sync
-	cd $(PWD)/bridge-history-api/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
-	cd $(PWD)/common/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG}&& go mod tidy
-	cd $(PWD)/coordinator/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
-	cd $(PWD)/database/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
-	cd $(PWD)/rollup/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
-	cd $(PWD)/tests/integration-test/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/bridge-history-api/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/common/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG}&& go mod tidy
+	cd $(PWD)/coordinator/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/database/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/rollup/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/tests/integration-test/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy

 lint: ## The code's format and security checks
 	make -C rollup lint
--- a/bridge-history-api/go.mod
+++ b/bridge-history-api/go.mod
@@ -10,8 +10,8 @@ require (
 	github.com/go-redis/redis/v8 v8.11.5
 	github.com/pressly/goose/v3 v3.16.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38
-	github.com/stretchr/testify v1.10.0
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950 // It's a hotfix for the header hash incompatibility issue, pls change this with caution
+	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
 	golang.org/x/sync v0.11.0
 	gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde
@@ -27,8 +27,8 @@ require (
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
 	github.com/chenzhuoyu/iasm v0.9.0 // indirect
-	github.com/consensys/bavard v0.1.29 // indirect
-	github.com/consensys/gnark-crypto v0.16.0 // indirect
+	github.com/consensys/bavard v0.1.13 // indirect
+	github.com/consensys/gnark-crypto v0.13.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
 	github.com/crate-crypto/go-kzg-4844 v1.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
@@ -90,7 +90,7 @@ require (
 	github.com/rjeczalik/notify v0.9.1 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5 // indirect
+	github.com/scroll-tech/da-codec v0.1.3-0.20250226072559-f8a8d3898f54 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect
 	github.com/sethvargo/go-retry v0.2.4 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
@@ -108,7 +108,7 @@ require (
 	go.opentelemetry.io/otel/trace v1.24.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	golang.org/x/arch v0.5.0 // indirect
-	golang.org/x/crypto v0.32.0 // indirect
+	golang.org/x/crypto v0.24.0 // indirect
 	golang.org/x/net v0.25.0 // indirect
 	golang.org/x/sys v0.30.0 // indirect
 	golang.org/x/text v0.21.0 // indirect
--- a/bridge-history-api/go.sum
+++ b/bridge-history-api/go.sum
@@ -53,10 +53,10 @@ github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d h1:77cEq6EriyTZ
 github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d/go.mod h1:8EPpVsBuRksnlj1mLy4AWzRNQYxauNi62uWcE3to6eA=
 github.com/chenzhuoyu/iasm v0.9.0 h1:9fhXjVzq5hUy2gkhhgHl95zG2cEAhw9OSGs8toWWAwo=
 github.com/chenzhuoyu/iasm v0.9.0/go.mod h1:Xjy2NpN3h7aUqeqM+woSuuvxmIe6+DDsiNLIrkAmYog=
-github.com/consensys/bavard v0.1.29 h1:fobxIYksIQ+ZSrTJUuQgu+HIJwclrAPcdXqd7H2hh1k=
-github.com/consensys/bavard v0.1.29/go.mod h1:k/zVjHHC4B+PQy1Pg7fgvG3ALicQw540Crag8qx+dZs=
-github.com/consensys/gnark-crypto v0.16.0 h1:8Dl4eYmUWK9WmlP1Bj6je688gBRJCJbT8Mw4KoTAawo=
-github.com/consensys/gnark-crypto v0.16.0/go.mod h1:Ke3j06ndtPTVvo++PhGNgvm+lgpLvzbcE2MqljY7diU=
+github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ=
+github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI=
+github.com/consensys/gnark-crypto v0.13.0 h1:VPULb/v6bbYELAPTDFINEVaMTTybV5GLxDdcjnS+4oc=
+github.com/consensys/gnark-crypto v0.13.0/go.mod h1:wKqwsieaKPThcFkHe0d0zMsbHEUWFmZcG7KBCse210o=
 github.com/containerd/continuity v0.4.3 h1:6HVkalIp+2u1ZLH1J/pYX2oBVXlJZvh1X1A7bEZ9Su8=
 github.com/containerd/continuity v0.4.3/go.mod h1:F6PTNCKepoxEaXLQp3wDAjygEnImnZ/7o4JzpodfroQ=
 github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
@@ -214,8 +214,8 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/leanovate/gopter v0.2.11 h1:vRjThO1EKPb/1NsDXuDrzldR28RLkBflWYcU9CvzWu4=
-github.com/leanovate/gopter v0.2.11/go.mod h1:aK3tzZP/C+p1m3SPRE4SYZFGP7jjkuSI4f7Xvpt0S9c=
+github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
+github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8=
 github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
 github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
@@ -309,10 +309,10 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5 h1:vZ75srkZCStjDWq/kqZGLoucf7Y7qXC13nKjQVZ0zp8=
-github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5/go.mod h1:XfQhUl3msmE6dpZEbR/LIwiMxywPQcUQsch9URgXDzs=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38 h1:IKkevP42IQx8DQvtVq9WOmZDQrto59CGdEheXPf20HA=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38/go.mod h1:Ik3OBLl7cJxPC+CFyCBYNXBPek4wpdzkWehn/y5qLM8=
+github.com/scroll-tech/da-codec v0.1.3-0.20250226072559-f8a8d3898f54 h1:qVpsVu1J91opTn6HYeuzWcBRVhQmPR8g05i+PlOjlI4=
+github.com/scroll-tech/da-codec v0.1.3-0.20250226072559-f8a8d3898f54/go.mod h1:xECEHZLVzbdUn+tNbRJhRIjLGTOTmnFQuTgUTeVLX58=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950 h1:qfOaRflvH1vtnFWloB7BveKlP/VqYgMqLJ6e9TlBJ/8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 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/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=
@@ -341,8 +341,8 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/supranational/blst v0.3.13 h1:AYeSxdOMacwu7FBmpfloBz5pbFXDmJL33RuwnKtmTjk=
 github.com/supranational/blst v0.3.13/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
@@ -387,8 +387,8 @@ golang.org/x/arch v0.5.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
-golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
+golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
+golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
 golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
 golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
--- a/build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile
+++ b/build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile
@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM golang:1.21-alpine3.19 as base
+FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base

 WORKDIR /src
 COPY ./bridge-history-api/go.* ./
@@ -10,10 +10,11 @@ FROM base as builder

 RUN --mount=target=. \
    --mount=type=cache,target=/root/.cache/go-build \
-    cd /src/bridge-history-api/cmd/db_cli && go build -v -p 4 -o /bin/db_cli
+    cd /src/bridge-history-api/cmd/db_cli && CGO_LDFLAGS="-Wl,--no-as-needed -ldl" go build -v -p 4 -o /bin/db_cli

-# Pull db_cli into a second stage deploy alpine container
-FROM alpine:latest
+# Pull db_cli into a second stage deploy ubuntu container
+FROM ubuntu:20.04
+ENV CGO_LDFLAGS="-ldl"
 COPY --from=builder /bin/db_cli /bin/
 WORKDIR /app
 ENTRYPOINT ["db_cli"]
--- a/build/dockerfiles/db_cli.Dockerfile
+++ b/build/dockerfiles/db_cli.Dockerfile
@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.21 as base
+FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base

 WORKDIR /src
 COPY go.work* ./
@@ -16,10 +16,11 @@ FROM base as builder

 RUN --mount=target=. \
    --mount=type=cache,target=/root/.cache/go-build \
-    cd /src/database/cmd && go build -v -p 4 -o /bin/db_cli
+    cd /src/database/cmd && CGO_LDFLAGS="-Wl,--no-as-needed -ldl" go build -v -p 4 -o /bin/db_cli

-# Pull db_cli into a second stage deploy alpine container
-FROM alpine:latest
+# Pull db_cli into a second stage deploy ubuntu container
+FROM ubuntu:20.04
+ENV CGO_LDFLAGS="-ldl"
 COPY --from=builder /bin/db_cli /bin/
 WORKDIR /app
 ENTRYPOINT ["db_cli"]
--- a/build/dockerfiles/prover.Dockerfile
+++ b/build/dockerfiles/prover.Dockerfile
@@ -12,12 +12,12 @@ RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
 ENV PATH="/root/.cargo/bin:${PATH}"
 ENV CARGO_HOME=/root/.cargo

-COPY ./prover .
+COPY . /src

-RUN cargo build --release
+RUN cd /src/zkvm-prover && make prover

 FROM ubuntu:24.04 AS runtime

-COPY --from=builder /target/release/prover /usr/local/bin/
+COPY --from=builder /src/zkvm-prover/target/release/prover /usr/local/bin/

 ENTRYPOINT ["prover"]
--- a/common/go.mod
+++ b/common/go.mod
@@ -15,7 +15,7 @@ require (
 	github.com/modern-go/reflect2 v1.0.2
 	github.com/orcaman/concurrent-map v1.0.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
 	github.com/stretchr/testify v1.10.0
 	github.com/testcontainers/testcontainers-go v0.30.0
 	github.com/testcontainers/testcontainers-go/modules/compose v0.30.0
@@ -184,7 +184,7 @@ require (
 	github.com/rjeczalik/notify v0.9.1 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5 // indirect
+	github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect
 	github.com/secure-systems-lab/go-securesystemslib v0.4.0 // indirect
 	github.com/serialx/hashring v0.0.0-20190422032157-8b2912629002 // indirect
--- a/common/go.sum
+++ b/common/go.sum
@@ -636,10 +636,10 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5 h1:vZ75srkZCStjDWq/kqZGLoucf7Y7qXC13nKjQVZ0zp8=
-github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5/go.mod h1:XfQhUl3msmE6dpZEbR/LIwiMxywPQcUQsch9URgXDzs=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38 h1:IKkevP42IQx8DQvtVq9WOmZDQrto59CGdEheXPf20HA=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38/go.mod h1:Ik3OBLl7cJxPC+CFyCBYNXBPek4wpdzkWehn/y5qLM8=
+github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435 h1:X9fkvjrYBY79lGgKEPpUhuiJ4vWpWwzOVw4H8CU8L54=
+github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601 h1:NEsjCG6uSvLRBlsP3+x6PL1kM+Ojs3g8UGotIPgJSz8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/secure-systems-lab/go-securesystemslib v0.4.0 h1:b23VGrQhTA8cN2CbBw7/FulN9fTtqYUdS5+Oxzt+DUE=
--- a/common/libzkp/impl/Cargo.lock
+++ b/common/libzkp/impl/Cargo.lock
--- a/common/libzkp/impl/Cargo.toml
+++ b/common/libzkp/impl/Cargo.toml
@@ -10,39 +10,12 @@ crate-type = ["cdylib"]
 [patch.crates-io]
 # patched add rkyv support & MSRV 1.77
 alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.21" }
-revm = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-interpreter = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-precompile = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-primitives = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
 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" }

-[patch."https://github.com/scroll-tech/revm.git"]
-revm = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-interpreter = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-precompile = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-primitives = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-
-[patch."https://github.com/scroll-tech/reth.git"]
-reth-chainspec = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-evm = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-evm-ethereum = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-execution-types = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-primitives = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-primitives-traits = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-storage-errors = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-trie = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-trie-sparse = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-
-reth-scroll-chainspec = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-scroll-evm = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-scroll-primitives = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-
-scroll-alloy-consensus = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-
 [dependencies]
-euclid_prover = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.1.0-rc.5", package = "scroll-zkvm-prover" }
-euclid_verifier = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.1.0-rc.5", package = "scroll-zkvm-verifier" }
+euclid_prover = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.1.0-rc.6", package = "scroll-zkvm-prover" }
+euclid_verifier = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.1.0-rc.6", package = "scroll-zkvm-verifier" }

 base64 = "0.13.0"
 env_logger = "0.9.0"
--- a/common/types/message/batch-proof-sample.json
+++ b/common/types/message/batch-proof-sample.json
--- a/common/types/message/bundle-proof-sample.json
+++ b/common/types/message/bundle-proof-sample.json
--- a/common/types/message/message_test.go
+++ b/common/types/message/message_test.go
@@ -1,54 +0,0 @@
-package message
-
-import (
-	"encoding/json"
-	"os"
-	"testing"
-
-	"github.com/scroll-tech/go-ethereum/common"
-)
-
-func TestDeserializeOpenVMProof(t *testing.T) {
-	// Read the batch.json file located in the same directory.
-	data, err := os.ReadFile("batch-proof-sample.json")
-	if err != nil {
-		t.Fatalf("failed to read batch proof sample.json: %v", err)
-	}
-
-	// Decode the JSON data into an BatchTask instance.
-	batchProof := NewBatchProof("euclid")
-	if err = json.Unmarshal(data, &batchProof); err != nil {
-		t.Fatalf("failed to unmarshal JSON into Batch Proof: %v", err)
-	}
-	if err = batchProof.SanityCheck(); err != nil {
-		t.Fatalf("failed to sanity check for Batch Proof: %v", err)
-	}
-
-	ovmbatchProof := batchProof.(*OpenVMBatchProof)
-
-	if ovmbatchProof.MetaData.BatchInfo.ParentStateRoot !=
-		common.HexToHash("0xe3440bcf882852bb1a9d6ba941e53a645220fee2c531ed79fa60481be8078c12") {
-		t.Fatalf("get unexpected bundle info, parent state root is %v", ovmbatchProof.MetaData.BatchInfo.ParentStateRoot)
-	}
-
-	// Read the batch.json file located in the same directory.
-	data, err = os.ReadFile("bundle-proof-sample.json")
-	if err != nil {
-		t.Fatalf("failed to read bundle proof sample.json: %v", err)
-	}
-
-	// Decode the JSON data into an BatchTask instance.
-	bundleProof := NewBundleProof("euclid")
-	if err = json.Unmarshal(data, &bundleProof); err != nil {
-		t.Fatalf("failed to unmarshal JSON into Bundle Proof: %v", err)
-	}
-	if err = bundleProof.SanityCheck(); err != nil {
-		t.Fatalf("failed to sanity check for Bundle Proof: %v", err)
-	}
-	ovmbundleProof := bundleProof.(*OpenVMBundleProof)
-
-	if ovmbundleProof.MetaData.BundleInfo.PostStateRoot !=
-		common.HexToHash("0x9e8b9928c55ccbc933911283175842fa515e49dd3f2fe0192c4346095695d741") {
-		t.Fatalf("get unexpected bundle info, post state root is %v", ovmbundleProof.MetaData.BundleInfo.PostStateRoot)
-	}
-}
--- a/common/version/version.go
+++ b/common/version/version.go
@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )

-var tag = "v4.4.87"
+var tag = "v4.4.93"

 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {
--- a/coordinator/go.mod
+++ b/coordinator/go.mod
@@ -11,8 +11,8 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38
+	github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
 	github.com/shopspring/decimal v1.3.1
 	github.com/stretchr/testify v1.10.0
 	github.com/urfave/cli/v2 v2.25.7
--- a/coordinator/go.sum
+++ b/coordinator/go.sum
@@ -177,10 +177,10 @@ github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5 h1:vZ75srkZCStjDWq/kqZGLoucf7Y7qXC13nKjQVZ0zp8=
-github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5/go.mod h1:XfQhUl3msmE6dpZEbR/LIwiMxywPQcUQsch9URgXDzs=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38 h1:IKkevP42IQx8DQvtVq9WOmZDQrto59CGdEheXPf20HA=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38/go.mod h1:Ik3OBLl7cJxPC+CFyCBYNXBPek4wpdzkWehn/y5qLM8=
+github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435 h1:X9fkvjrYBY79lGgKEPpUhuiJ4vWpWwzOVw4H8CU8L54=
+github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601 h1:NEsjCG6uSvLRBlsP3+x6PL1kM+Ojs3g8UGotIPgJSz8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 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=
--- a/coordinator/internal/logic/provertask/prover_task.go
+++ b/coordinator/internal/logic/provertask/prover_task.go
@@ -79,7 +79,8 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context) (*proverTaskContext, e

 	ProverProviderType, ProverProviderTypeExist := ctx.Get(coordinatorType.ProverProviderTypeKey)
 	if !ProverProviderTypeExist {
-		return nil, errors.New("get prover provider type from context failed")
+		// for backward compatibility, set ProverProviderType as internal
+		ProverProviderType = float64(coordinatorType.ProverProviderTypeInternal)
 	}
 	ptc.ProverProviderType = uint8(ProverProviderType.(float64))

--- a/database/go.mod
+++ b/database/go.mod
@@ -8,7 +8,7 @@ require (
 	github.com/jmoiron/sqlx v1.3.5
 	github.com/lib/pq v1.10.9
 	github.com/pressly/goose/v3 v3.16.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
 	github.com/stretchr/testify v1.10.0
 	github.com/urfave/cli/v2 v2.25.7
 )
--- a/database/go.sum
+++ b/database/go.sum
@@ -121,8 +121,8 @@ github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38 h1:IKkevP42IQx8DQvtVq9WOmZDQrto59CGdEheXPf20HA=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38/go.mod h1:Ik3OBLl7cJxPC+CFyCBYNXBPek4wpdzkWehn/y5qLM8=
+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/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=
 github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
 github.com/sethvargo/go-retry v0.2.4 h1:T+jHEQy/zKJf5s95UkguisicE0zuF9y7+/vgz08Ocec=
--- a/go.work.sum
+++ b/go.work.sum
@@ -434,6 +434,7 @@ github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBp
 github.com/AzureAD/microsoft-authentication-library-for-go v0.6.0 h1:XMEdVDFxgulDDl0lQmAZS6j8gRQ/0pJ+ZpXH2FHVtDc=
 github.com/AzureAD/microsoft-authentication-library-for-go v0.6.0/go.mod h1:BDJ5qMFKx9DugEg3+uQSDCdbYPr5s9vBTrL9P8TpqOU=
 github.com/AzureAD/microsoft-authentication-library-for-go v1.0.0/go.mod h1:kgDmCTgBzIEPFElEF+FK0SdjAor06dRq2Go927dnQ6o=
+github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
 github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802 h1:1BDTz0u9nC3//pOCMdNH+CiXJVYJh5UQNCOBG7jbELc=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
@@ -590,10 +591,8 @@ github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk
 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=
-github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI=
 github.com/consensys/bavard v0.1.27/go.mod h1:k/zVjHHC4B+PQy1Pg7fgvG3ALicQw540Crag8qx+dZs=
 github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY=
-github.com/consensys/gnark-crypto v0.13.0/go.mod h1:wKqwsieaKPThcFkHe0d0zMsbHEUWFmZcG7KBCse210o=
 github.com/container-orchestrated-devices/container-device-interface v0.6.1 h1:mz77uJoP8im/4Zins+mPqt677ZMaflhoGaYrRAl5jvA=
 github.com/container-orchestrated-devices/container-device-interface v0.6.1/go.mod h1:40T6oW59rFrL/ksiSs7q45GzjGlbvxnA4xaK6cyq+kA=
 github.com/containerd/aufs v1.0.0 h1:2oeJiwX5HstO7shSrPZjrohJZLzK36wvpdmzDRkL/LY=
@@ -1013,7 +1012,6 @@ github.com/labstack/echo/v4 v4.9.0/go.mod h1:xkCDAdFCIf8jsFQ5NnbK7oqaF/yU1A1X20L
 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/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8=
 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=
@@ -1191,7 +1189,8 @@ github.com/scroll-tech/da-codec v0.1.1-0.20241014152913-2703f226fb0b/go.mod h1:4
 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=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250103082839-ea3ec93d8c1e/go.mod h1:Ik3OBLl7cJxPC+CFyCBYNXBPek4wpdzkWehn/y5qLM8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250206083728-ea43834c198f/go.mod h1:Ik3OBLl7cJxPC+CFyCBYNXBPek4wpdzkWehn/y5qLM8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250225152658-bcfdb48dd939/go.mod h1:AgU8JJxC7+nfs7R7ma35AU7dMAGW7wCw3dRZRefIKyQ=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/segmentio/kafka-go v0.1.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=
 github.com/segmentio/kafka-go v0.2.0 h1:HtCSf6B4gN/87yc5qTl7WsxPKQIIGXLPPM1bMCPOsoY=
@@ -1765,6 +1764,7 @@ gopkg.in/errgo.v2 v2.1.0 h1:0vLT13EuvQ0hNvakwLuFZ/jYrLp5F3kcWHXdRggjCE8=
 gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2 h1:OAj3g0cR6Dx/R07QgQe8wkA9RNjB2u4i700xBkIT4e0=
 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/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=
--- a/prover/Cargo.lock
+++ b/prover/Cargo.lock
--- a/prover/Cargo.toml
+++ b/prover/Cargo.toml
@@ -7,36 +7,15 @@ edition = "2021"


 [patch.crates-io]
-alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.21" }
-revm = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-interpreter = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-precompile = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-primitives = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-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" }
+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" }

-[patch."https://github.com/scroll-tech/revm.git"]
-revm = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-interpreter = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-precompile = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-revm-primitives = { git = "https://github.com/scroll-tech//revm", branch = "scroll-evm-executor/v55" }
-
-[patch."https://github.com/scroll-tech/reth.git"]
-reth-chainspec = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-evm = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-evm-ethereum = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-execution-types = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-primitives = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-primitives-traits = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-storage-errors = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-trie = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-trie-sparse = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-
-reth-scroll-chainspec = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-scroll-evm = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-reth-scroll-primitives = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }
-
-scroll-alloy-consensus = { git = "https://github.com/scroll-tech//reth", branch = "fix/scroll-zkvm" }

 [dependencies]
 anyhow = "1.0"
@@ -46,15 +25,13 @@ serde = { version = "1.0.198", features = ["derive"] }
 serde_json = "1.0.116"
 futures = "0.3.30"

-scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.1.0-rc.5" }
 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" }
-scroll-proving-sdk = { git = "https://github.com/scroll-tech/scroll-proving-sdk.git", rev = "eed375d", features = [
-    "openvm",
-] }
-sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/revm-v55-upgrade", features = [
-    "scroll",
-] }
+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"
@@ -71,5 +48,3 @@ sled = "0.34.7"
 http = "1.1.0"
 clap = { version = "4.5", features = ["derive"] }
 ctor = "0.2.8"
-url = "2.5.4"
-serde_bytes = "0.11.15"
--- a/prover/config.json
+++ b/prover/config.json
@@ -12,20 +12,19 @@
      "endpoint": "http://localhost:9999"
    },
    "prover": {
-      "circuit_type": 2,
-      "supported_proof_types": [
-        1,
-        2,
-        3
-      ],
+      "circuit_types": [1,2,3],
      "circuit_version": "v0.13.1"
    },
    "db_path": "unique-db-path-for-prover-1"
  },
-  "circuits": {
-    "euclid": {
-      "hard_fork_name": "euclid",
-      "workspace_path": "/home/ubuntu/prover-workdir"
-    }
+  "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"
  }
-}
+}
--- a/prover/rust-toolchain
+++ b/prover/rust-toolchain
@@ -1 +1 @@
-nightly-2024-12-06
+nightly-2023-12-03
--- a/prover/src/config.rs
+++ b/prover/src/config.rs
@@ -0,0 +1,51 @@
+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],
+            );
+        }
+    }
+}
--- a/prover/src/main.rs
+++ b/prover/src/main.rs
@@ -1,5 +1,10 @@
+#![feature(lazy_cell)]
+#![feature(core_intrinsics)]
+
+mod config;
 mod prover;
 mod types;
+mod utils;
 mod zk_circuits_handler;

 use clap::{ArgAction, Parser};
@@ -8,6 +13,8 @@ use scroll_proving_sdk::{
    prover::ProverBuilder,
    utils::{get_version, init_tracing},
 };
+use tokio::runtime;
+use utils::get_prover_type;

 #[derive(Parser, Debug)]
 #[clap(disable_version_flag = true)]
@@ -25,23 +32,45 @@ struct Args {
    log_file: Option<String>,
 }

-#[tokio::main]
-async fn main() -> anyhow::Result<()> {
-    init_tracing();
+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");

-    let args = Args::parse();
+    rt.block_on(async {
+        init_tracing();

-    if args.version {
-        println!("version is {}", get_version());
-        std::process::exit(0);
-    }
+        let args = Args::parse();

-    let cfg = LocalProverConfig::from_file(args.config_file)?;
-    let sdk_config = cfg.sdk_config.clone();
-    let local_prover = LocalProver::new(cfg);
-    let prover = ProverBuilder::new(sdk_config, local_prover).build().await?;
+        if args.version {
+            println!("version is {}", get_version());
+            std::process::exit(0);
+        }

-    prover.run().await;
+        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?;

-    Ok(())
+        prover.run().await;
+
+        Ok(())
+    })
 }
--- a/prover/src/prover.rs
+++ b/prover/src/prover.rs
@@ -1,4 +1,8 @@
-use crate::zk_circuits_handler::{euclid::EuclidHandler, CircuitsHandler};
+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::{
@@ -13,17 +17,17 @@ use scroll_proving_sdk::{
 };
 use serde::{Deserialize, Serialize};
 use std::{
-    collections::HashMap,
    fs::File,
-    sync::Arc,
+    sync::{Arc, Mutex},
    time::{SystemTime, UNIX_EPOCH},
 };
-use tokio::{runtime::Handle, sync::Mutex, task::JoinHandle};
+use tokio::{runtime::Handle, sync::RwLock, task::JoinHandle};

 #[derive(Clone, Serialize, Deserialize)]
 pub struct LocalProverConfig {
    pub sdk_config: SdkConfig,
-    pub circuits: HashMap<String, CircuitConfig>,
+    pub high_version_circuit: CircuitConfig,
+    pub low_version_circuit: CircuitConfig,
 }

 impl LocalProverConfig {
@@ -43,15 +47,16 @@ impl LocalProverConfig {
 #[derive(Clone, Serialize, Deserialize)]
 pub struct CircuitConfig {
    pub hard_fork_name: String,
-    pub workspace_path: String,
+    pub params_path: String,
+    pub assets_path: String,
 }

 pub struct LocalProver {
    config: LocalProverConfig,
-    next_task_id: u64,
-    current_task: Option<JoinHandle<Result<String>>>,
-
-    active_handler: Option<(String, Arc<dyn CircuitsHandler>)>,
+    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]
@@ -60,26 +65,32 @@ impl ProvingService for LocalProver {
        true
    }
    async fn get_vks(&self, req: GetVkRequest) -> GetVkResponse {
-        let mut vks = vec![];
-        for hard_fork_name in self.config.circuits.keys() {
-            let handler = self.new_handler(hard_fork_name);
-            for proof_type in &req.proof_types {
-                let vk = handler.get_vk(*proof_type).await;
-
-                if let Some(vk) = vk {
-                    vks.push(base64::encode(vk));
+        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(&mut self, req: ProveRequest) -> ProveResponse {
-        self.set_active_handler(&req.hard_fork_name);
-        match self
-            .do_prove(req, self.active_handler.as_ref().unwrap().1.clone())
+    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,
@@ -89,8 +100,9 @@ impl ProvingService for LocalProver {
        }
    }

-    async fn query_task(&mut self, req: QueryTaskRequest) -> QueryTaskResponse {
-        if let Some(handle) = &mut self.current_task {
+    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 {
@@ -113,6 +125,7 @@ impl ProvingService for LocalProver {
                    },
                };
            } else {
+                *self.current_task.lock().unwrap() = Some(handle);
                return QueryTaskResponse {
                    task_id: req.task_id,
                    status: TaskStatus::Proving,
@@ -131,21 +144,30 @@ impl ProvingService for LocalProver {
 }

 impl LocalProver {
-    pub fn new(config: LocalProverConfig) -> Self {
+    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,
-            next_task_id: 0,
-            current_task: None,
-            active_handler: None,
+            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(
-        &mut self,
+        &self,
        req: ProveRequest,
-        handler: Arc<dyn CircuitsHandler>,
+        handler: Arc<Box<dyn CircuitsHandler>>,
    ) -> Result<ProveResponse> {
-        self.next_task_id += 1;
+        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;

@@ -153,11 +175,12 @@ impl LocalProver {
        let handle = Handle::current();
        let task_handle =
            tokio::task::spawn_blocking(move || handle.block_on(handler.get_proof_data(req_clone)));
-        self.current_task = Some(task_handle);
+
+        *self.current_task.lock().unwrap() = Some(task_handle);

        Ok(ProveResponse {
-            task_id: self.next_task_id.to_string(),
-            proof_type: req.proof_type,
+            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,
@@ -166,24 +189,4 @@ impl LocalProver {
            ..Default::default()
        })
    }
-
-    fn set_active_handler(&mut self, hard_fork_name: &str) {
-        if let Some(handler) = &self.active_handler {
-            if handler.0 == hard_fork_name {
-                return;
-            }
-        }
-        self.active_handler = Some((hard_fork_name.to_string(), self.new_handler(hard_fork_name)));
-    }
-
-    fn new_handler(&self, hard_fork_name: &str) -> Arc<dyn CircuitsHandler> {
-        // if we got assigned a task for an unknown hard fork, there is something wrong in the
-        // coordinator
-        let config = self.config.circuits.get(hard_fork_name).unwrap();
-
-        Arc::new(match hard_fork_name {
-            "euclid" => Arc::new(Mutex::new(EuclidHandler::new(&config.workspace_path))),
-            _ => unreachable!(),
-        }) as Arc<dyn CircuitsHandler>
-    }
 }
--- a/prover/src/types.rs
+++ b/prover/src/types.rs
@@ -1,7 +1,50 @@
+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)]
--- a/prover/src/utils.rs
+++ b/prover/src/utils.rs
@@ -0,0 +1,18 @@
+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),
+    }
+}
--- a/prover/src/zk_circuits_handler.rs
+++ b/prover/src/zk_circuits_handler.rs
@@ -1,12 +1,165 @@
-pub mod euclid;
+mod common;
+mod darwin;
+mod darwin_v2;

-use anyhow::Result;
+use crate::{
+    config::AssetsDirEnvConfig, prover::LocalProverConfig, types::ProverType,
+    utils::get_circuit_types,
+};
+use anyhow::{bail, Result};
 use async_trait::async_trait;
-use scroll_proving_sdk::prover::{proving_service::ProveRequest, ProofType};
+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: Sync + Send {
-    async fn get_vk(&self, task_type: ProofType) -> Option<Vec<u8>>;
+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
+    }
+}
--- a/prover/src/zk_circuits_handler/common.rs
+++ b/prover/src/zk_circuits_handler/common.rs
@@ -0,0 +1,33 @@
+use std::{collections::BTreeMap, rc::Rc};
+
+use crate::types::ProverType;
+
+use once_cell::sync::OnceCell;
+
+use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
+
+static mut PARAMS_MAP: OnceCell<Rc<BTreeMap<u32, ParamsKZG<Bn256>>>> = OnceCell::new();
+
+pub fn get_params_map_instance<'a, F>(load_params_func: F) -> &'a BTreeMap<u32, ParamsKZG<Bn256>>
+where
+    F: FnOnce() -> BTreeMap<u32, ParamsKZG<Bn256>>,
+{
+    unsafe {
+        PARAMS_MAP.get_or_init(|| {
+            let params_map = load_params_func();
+            Rc::new(params_map)
+        })
+    }
+}
+
+pub fn get_degrees<F>(prover_types: &std::collections::HashSet<ProverType>, f: F) -> Vec<u32>
+where
+    F: FnMut(&ProverType) -> Vec<u32>,
+{
+    prover_types
+        .iter()
+        .flat_map(f)
+        .collect::<std::collections::HashSet<u32>>()
+        .into_iter()
+        .collect()
+}
--- a/prover/src/zk_circuits_handler/darwin.rs
+++ b/prover/src/zk_circuits_handler/darwin.rs
@@ -0,0 +1,401 @@
+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)?)
+    }
+}
--- a/prover/src/zk_circuits_handler/darwin_v2.rs
+++ b/prover/src/zk_circuits_handler/darwin_v2.rs
@@ -0,0 +1,459 @@
+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)?)
+    }
+}
--- a/rollup/cmd/rollup_relayer/app/app.go
+++ b/rollup/cmd/rollup_relayer/app/app.go
@@ -80,6 +80,12 @@ func action(ctx *cli.Context) error {
 	}

 	initGenesis := ctx.Bool(utils.ImportGenesisFlag.Name)
+
+	// sanity check config
+	if cfg.L2Config.BatchProposerConfig.MaxChunksPerBatch <= 0 {
+		log.Crit("cfg.L2Config.BatchProposerConfig.MaxChunksPerBatch must be greater than 0")
+	}
+
 	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, genesis.Config, initGenesis, relayer.ServiceTypeL2RollupRelayer, registry)
 	if err != nil {
 		log.Crit("failed to create l2 relayer", "config file", cfgFile, "error", err)
--- a/rollup/conf/config.json
+++ b/rollup/conf/config.json
@@ -102,7 +102,8 @@
      "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_uncompressed_batch_bytes_size": 634880,
+      "max_chunks_per_batch": 12
    },
    "bundle_proposer_config": {
      "max_batch_num_per_bundle": 20,
--- a/rollup/go.mod
+++ b/rollup/go.mod
@@ -13,8 +13,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.20250206084714-d61e2cbe7cd5
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38
+	github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/spf13/viper v1.19.0
 	github.com/stretchr/testify v1.10.0
--- a/rollup/go.sum
+++ b/rollup/go.sum
@@ -249,10 +249,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.20250206084714-d61e2cbe7cd5 h1:vsSXTjYDggo6TgHxS8KYl4IYHi+EawpzeqQ64X2W/cw=
-github.com/scroll-tech/da-codec v0.1.3-0.20250206084714-d61e2cbe7cd5/go.mod h1:RCDoKwQgZMr/GbD1rKiLA90+0faOzOD6JJm0Bq/7vQs=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38 h1:IKkevP42IQx8DQvtVq9WOmZDQrto59CGdEheXPf20HA=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38/go.mod h1:Ik3OBLl7cJxPC+CFyCBYNXBPek4wpdzkWehn/y5qLM8=
+github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435 h1:X9fkvjrYBY79lGgKEPpUhuiJ4vWpWwzOVw4H8CU8L54=
+github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601 h1:NEsjCG6uSvLRBlsP3+x6PL1kM+Ojs3g8UGotIPgJSz8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 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=
--- a/rollup/internal/config/l2.go
+++ b/rollup/internal/config/l2.go
@@ -47,6 +47,7 @@ type BatchProposerConfig struct {
 	BatchTimeoutSec                 uint64  `json:"batch_timeout_sec"`
 	GasCostIncreaseMultiplier       float64 `json:"gas_cost_increase_multiplier"`
 	MaxUncompressedBatchBytesSize   uint64  `json:"max_uncompressed_batch_bytes_size"`
+	MaxChunksPerBatch               int     `json:"max_chunks_per_batch"`
 }

 // BundleProposerConfig loads bundle_proposer configuration items.
--- a/rollup/internal/controller/relayer/l2_relayer.go
+++ b/rollup/internal/controller/relayer/l2_relayer.go
@@ -15,6 +15,7 @@ import (
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
 	"github.com/scroll-tech/go-ethereum/common"
+	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
 	"github.com/scroll-tech/go-ethereum/ethclient"
@@ -180,26 +181,79 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 }

 func (r *Layer2Relayer) initializeGenesis() error {
-	latestBatch, err := r.batchOrm.GetLatestBatch(r.ctx)
-	if err != nil {
-		return fmt.Errorf("failed to get latest batch: %v", err)
-	}
-
-	startFinalizedBatchIndex := uint64(337429)
-	if latestBatch.Index > startFinalizedBatchIndex {
-		log.Info("genesis already imported")
+	if count, err := r.batchOrm.GetBatchCount(r.ctx); err != nil {
+		return fmt.Errorf("failed to get batch count: %v", err)
+	} else if count > 0 {
+		log.Info("genesis already imported", "batch count", count)
 		return nil
 	}

-	startFinalizedBatch, err := r.batchOrm.GetBatchByIndex(r.ctx, startFinalizedBatchIndex)
+	genesis, err := r.l2Client.HeaderByNumber(r.ctx, big.NewInt(0))
 	if err != nil {
-		return fmt.Errorf("failed to get batch by index: %v, err: %w", startFinalizedBatchIndex, err)
+		return fmt.Errorf("failed to retrieve L2 genesis header: %v", err)
 	}

-	if err = r.commitGenesisBatch(startFinalizedBatch.Hash, startFinalizedBatch.BatchHeader, common.HexToHash(startFinalizedBatch.StateRoot)); err != nil {
-		return fmt.Errorf("commit genesis batch failed: %v", err)
+	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{},
+		}},
 	}
-	log.Info("import genesis transaction successfully", "batch index", startFinalizedBatchIndex, "batch hash", startFinalizedBatch.Hash)
+
+	err = r.db.Transaction(func(dbTX *gorm.DB) error {
+		if err = r.l2BlockOrm.InsertL2Blocks(r.ctx, chunk.Blocks); err != nil {
+			return fmt.Errorf("failed to insert genesis block: %v", err)
+		}
+
+		var dbChunk *orm.Chunk
+		dbChunk, err = r.chunkOrm.InsertChunk(r.ctx, chunk, encoding.CodecV0, rutils.ChunkMetrics{}, dbTX)
+		if err != nil {
+			return fmt.Errorf("failed to insert chunk: %v", err)
+		}
+
+		if err = r.chunkOrm.UpdateProvingStatus(r.ctx, dbChunk.Hash, types.ProvingTaskVerified, dbTX); err != nil {
+			return fmt.Errorf("failed to update genesis chunk proving status: %v", err)
+		}
+
+		batch := &encoding.Batch{
+			Index:                      0,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk},
+		}
+
+		var dbBatch *orm.Batch
+		dbBatch, err = r.batchOrm.InsertBatch(r.ctx, batch, encoding.CodecV0, rutils.BatchMetrics{}, dbTX)
+		if err != nil {
+			return fmt.Errorf("failed to insert batch: %v", err)
+		}
+
+		if err = r.chunkOrm.UpdateBatchHashInRange(r.ctx, 0, 0, dbBatch.Hash, dbTX); err != nil {
+			return fmt.Errorf("failed to update batch hash for chunks: %v", err)
+		}
+
+		if err = r.batchOrm.UpdateProvingStatus(r.ctx, dbBatch.Hash, types.ProvingTaskVerified, dbTX); err != nil {
+			return fmt.Errorf("failed to update genesis batch proving status: %v", err)
+		}
+
+		if err = r.batchOrm.UpdateRollupStatus(r.ctx, dbBatch.Hash, types.RollupFinalized, dbTX); err != nil {
+			return fmt.Errorf("failed to update genesis batch rollup status: %v", err)
+		}
+
+		// commit genesis batch on L1
+		// note: we do this inside the DB transaction so that we can revert all DB changes if this step fails
+		return r.commitGenesisBatch(dbBatch.Hash, dbBatch.BatchHeader, common.HexToHash(dbBatch.StateRoot))
+	})
+
+	if err != nil {
+		return fmt.Errorf("update genesis transaction failed: %v", err)
+	}
+
+	log.Info("successfully imported genesis chunk and batch")

 	return nil
 }
--- a/rollup/internal/controller/watcher/batch_proposer.go
+++ b/rollup/internal/controller/watcher/batch_proposer.go
@@ -32,6 +32,7 @@ type BatchProposer struct {
 	batchTimeoutSec                 uint64
 	gasCostIncreaseMultiplier       float64
 	maxUncompressedBatchBytesSize   uint64
+	maxChunksPerBatch               int

 	minCodecVersion encoding.CodecVersion
 	chainCfg        *params.ChainConfig
@@ -78,6 +79,7 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, minC
 		batchTimeoutSec:                 cfg.BatchTimeoutSec,
 		gasCostIncreaseMultiplier:       cfg.GasCostIncreaseMultiplier,
 		maxUncompressedBatchBytesSize:   cfg.MaxUncompressedBatchBytesSize,
+		maxChunksPerBatch:               cfg.MaxChunksPerBatch,
 		minCodecVersion:                 minCodecVersion,
 		chainCfg:                        chainCfg,

@@ -253,7 +255,8 @@ func (p *BatchProposer) proposeBatch() error {
 		return fmt.Errorf("unsupported codec version: %v, expected at least %v", codec.Version(), p.minCodecVersion)
 	}

-	maxChunksThisBatch := codec.MaxNumChunksPerBatch()
+	// 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)

 	// select at most maxChunkNumPerBatch chunks
 	dbChunks, err := p.chunkOrm.GetChunksGEIndex(p.ctx, firstUnbatchedChunkIndex, maxChunksThisBatch)
--- a/rollup/internal/controller/watcher/batch_proposer_test.go
+++ b/rollup/internal/controller/watcher/batch_proposer_test.go
@@ -140,6 +140,7 @@ func testBatchProposerLimitsCodecV4(t *testing.T) {
 				BatchTimeoutSec:                 tt.batchTimeoutSec,
 				GasCostIncreaseMultiplier:       1.2,
 				MaxUncompressedBatchBytesSize:   math.MaxUint64,
+				MaxChunksPerBatch:               math.MaxInt32,
 			}, encoding.CodecV4, &params.ChainConfig{
 				LondonBlock:    big.NewInt(0),
 				BernoulliBlock: big.NewInt(0),
@@ -228,6 +229,7 @@ func testBatchCommitGasAndCalldataSizeEstimationCodecV4(t *testing.T) {
 		BatchTimeoutSec:                 0,
 		GasCostIncreaseMultiplier:       1.2,
 		MaxUncompressedBatchBytesSize:   math.MaxUint64,
+		MaxChunksPerBatch:               math.MaxInt32,
 	}, encoding.CodecV4, &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64)}, db, nil)
 	bp.TryProposeBatch()

@@ -317,6 +319,7 @@ func testBatchProposerBlobSizeLimitCodecV4(t *testing.T) {
 			BatchTimeoutSec:                 math.MaxUint32,
 			GasCostIncreaseMultiplier:       1,
 			MaxUncompressedBatchBytesSize:   math.MaxUint64,
+			MaxChunksPerBatch:               math.MaxInt32,
 		}, encoding.CodecV4, chainConfig, db, nil)

 		for i := 0; i < 2; i++ {
@@ -406,6 +409,7 @@ func testBatchProposerMaxChunkNumPerBatchLimitCodecV4(t *testing.T) {
 			BatchTimeoutSec:                 math.MaxUint32,
 			GasCostIncreaseMultiplier:       1,
 			MaxUncompressedBatchBytesSize:   math.MaxUint64,
+			MaxChunksPerBatch:               math.MaxInt32,
 		}, encoding.CodecV4, chainConfig, db, nil)
 		bp.TryProposeBatch()

--- a/rollup/tests/rollup_test.go
+++ b/rollup/tests/rollup_test.go
@@ -99,6 +99,7 @@ func testCommitBatchAndFinalizeBundleCodecV4V5V6(t *testing.T) {
 		MaxL1CommitCalldataSizePerBatch: 1000000,
 		BatchTimeoutSec:                 300,
 		MaxUncompressedBatchBytesSize:   math.MaxUint64,
+		MaxChunksPerBatch:               math.MaxInt32,
 	}, encoding.CodecV4, chainConfig, db, nil)

 	bup := watcher.NewBundleProposer(context.Background(), &config.BundleProposerConfig{
--- a/tests/integration-test/go.mod
+++ b/tests/integration-test/go.mod
@@ -5,8 +5,8 @@ go 1.22
 toolchain go1.22.2

 require (
-	github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38
+	github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
 	github.com/stretchr/testify v1.10.0
 	gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde
 )
--- a/tests/integration-test/go.sum
+++ b/tests/integration-test/go.sum
@@ -93,10 +93,10 @@ github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeC
 github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
 github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
-github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5 h1:vZ75srkZCStjDWq/kqZGLoucf7Y7qXC13nKjQVZ0zp8=
-github.com/scroll-tech/da-codec v0.1.3-0.20241218102542-9852fa4e1be5/go.mod h1:XfQhUl3msmE6dpZEbR/LIwiMxywPQcUQsch9URgXDzs=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38 h1:IKkevP42IQx8DQvtVq9WOmZDQrto59CGdEheXPf20HA=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250205135740-4bdf6d096c38/go.mod h1:Ik3OBLl7cJxPC+CFyCBYNXBPek4wpdzkWehn/y5qLM8=
+github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435 h1:X9fkvjrYBY79lGgKEPpUhuiJ4vWpWwzOVw4H8CU8L54=
+github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601 h1:NEsjCG6uSvLRBlsP3+x6PL1kM+Ojs3g8UGotIPgJSz8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 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=
--- a/zkvm-prover/Cargo.lock
+++ b/zkvm-prover/Cargo.lock
--- a/zkvm-prover/Cargo.toml
+++ b/zkvm-prover/Cargo.toml
@@ -0,0 +1,47 @@
+[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]
+alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.21" }
+ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
+tiny-keccak = { git = "https://github.com/scroll-tech/tiny-keccak", branch = "scroll-patch-v2.0.2-openvm-v1.0.0-rc.1" }
+
+[dependencies]
+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"
+
+scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.1.0-rc.6" }
+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" }
+scroll-proving-sdk = { git = "https://github.com/scroll-tech/scroll-proving-sdk.git", rev = "af95d2a", features = [
+    "openvm",
+] }
+sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-v2", features = [
+    "scroll",
+] }
+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"
+url = "2.5.4"
+serde_bytes = "0.11.15"
--- a/zkvm-prover/Makefile
+++ b/zkvm-prover/Makefile
@@ -0,0 +1,48 @@
+.PHONY: prover lint tests_binary
+
+ifeq (4.3,$(firstword $(sort $(MAKE_VERSION) 4.3)))
+    PLONKY3_VERSION=$(shell grep -m 1 "Plonky3.git" ./Cargo.lock | cut -d "#" -f2 | cut -c-7)
+else
+    PLONKY3_VERSION=$(shell grep -m 1 "Plonky3.git" ./Cargo.lock | cut -d "\#" -f2 | cut -c-7)
+endif
+
+ZKVM_VERSION=$(shell ./print_high_zkvm_version.sh)
+ifeq (${ZKVM_VERSION},)
+    $(error ZKVM_VERSION not set)
+else
+    $(info ZKVM_VERSION is ${ZKVM_VERSION})
+endif
+
+ZKVM_COMMIT=$(shell echo ${ZKVM_VERSION} | cut -d " " -f2)
+$(info ZKVM_COMMIT is ${ZKVM_COMMIT})
+
+PLONKY3_GPU_VERSION=$(shell ./print_plonky3gpu_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 (${PLONKY3_GPU_VERSION},)
+	# use plonky3 with CPU
+    ZK_VERSION=${ZKVM_COMMIT}-${PLONKY3_VERSION}
+else
+	# use halo2_gpu
+    ZK_VERSION=${ZKVM_COMMIT}-${PLONKY3_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
--- a/zkvm-prover/config.json
+++ b/zkvm-prover/config.json
@@ -0,0 +1,31 @@
+{
+  "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_type": 2,
+      "supported_proof_types": [
+        1,
+        2,
+        3
+      ],
+      "circuit_version": "v0.13.1"
+    },
+    "db_path": "unique-db-path-for-prover-1"
+  },
+  "circuits": {
+    "euclid": {
+      "hard_fork_name": "euclid",
+      "workspace_path": "/home/ubuntu/prover-workdir"
+    }
+  }
+}
--- a/zkvm-prover/print_high_zkvm_version.sh
+++ b/zkvm-prover/print_high_zkvm_version.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+set -ue
+
+higher_zkvm_item=`grep "zkvm-prover" ./Cargo.lock | sort | uniq | awk -F "[#=]" '{print $3" "$4}' | sort -k 1 | tail -n 1`
+
+higher_version=`echo $higher_zkvm_item | awk '{print $1}'`
+
+higher_commit=`echo $higher_zkvm_item | cut -d ' ' -f2 | cut -c-7`
+
+echo "$higher_version $higher_commit"
--- a/zkvm-prover/print_plonky3gpu_version.sh
+++ b/zkvm-prover/print_plonky3gpu_version.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+
+config_file=~/.cargo/config.toml
+plonky3_gpu_path=$(grep 'path.*plonky3-gpu' "$config_file" | cut -d'"' -f2 | head -n 1)
+plonky3_gpu_path=$(dirname "$plonky3_gpu_path")
+
+if [ -z $plonky3_gpu_path ]; then
+    exit 0
+else
+    pushd $plonky3_gpu_path
+    commit_hash=$(git log --pretty=format:%h -n 1)
+    echo "${commit_hash:0:7}"
+
+    popd
+fi
--- a/zkvm-prover/rust-toolchain
+++ b/zkvm-prover/rust-toolchain
@@ -0,0 +1 @@
+nightly-2024-12-06
--- a/zkvm-prover/rustfmt.toml
+++ b/zkvm-prover/rustfmt.toml
@@ -0,0 +1,9 @@
+edition = "2021"
+
+comment_width = 100
+imports_granularity = "Crate"
+max_width = 100
+newline_style = "Unix"
+# normalize_comments = true
+reorder_imports = true
+wrap_comments = true
--- a/zkvm-prover/src/main.rs
+++ b/zkvm-prover/src/main.rs
@@ -0,0 +1,47 @@
+mod prover;
+mod types;
+mod zk_circuits_handler;
+
+use clap::{ArgAction, Parser};
+use prover::{LocalProver, LocalProverConfig};
+use scroll_proving_sdk::{
+    prover::ProverBuilder,
+    utils::{get_version, init_tracing},
+};
+
+#[derive(Parser, Debug)]
+#[clap(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>,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    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 local_prover = LocalProver::new(cfg);
+    let prover = ProverBuilder::new(sdk_config, local_prover).build().await?;
+
+    prover.run().await;
+
+    Ok(())
+}
--- a/zkvm-prover/src/prover.rs
+++ b/zkvm-prover/src/prover.rs
@@ -0,0 +1,189 @@
+use crate::zk_circuits_handler::{euclid::EuclidHandler, CircuitsHandler};
+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::{
+    collections::HashMap,
+    fs::File,
+    sync::Arc,
+    time::{SystemTime, UNIX_EPOCH},
+};
+use tokio::{runtime::Handle, sync::Mutex, task::JoinHandle};
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct LocalProverConfig {
+    pub sdk_config: SdkConfig,
+    pub circuits: HashMap<String, 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 workspace_path: String,
+}
+
+pub struct LocalProver {
+    config: LocalProverConfig,
+    next_task_id: u64,
+    current_task: Option<JoinHandle<Result<String>>>,
+
+    active_handler: Option<(String, Arc<dyn CircuitsHandler>)>,
+}
+
+#[async_trait]
+impl ProvingService for LocalProver {
+    fn is_local(&self) -> bool {
+        true
+    }
+    async fn get_vks(&self, req: GetVkRequest) -> GetVkResponse {
+        let mut vks = vec![];
+        for hard_fork_name in self.config.circuits.keys() {
+            let handler = self.new_handler(hard_fork_name);
+            for proof_type in &req.proof_types {
+                let vk = handler.get_vk(*proof_type).await;
+
+                if let Some(vk) = vk {
+                    vks.push(base64::encode(vk));
+                }
+            }
+        }
+
+        GetVkResponse { vks, error: None }
+    }
+    async fn prove(&mut self, req: ProveRequest) -> ProveResponse {
+        self.set_active_handler(&req.hard_fork_name);
+        match self
+            .do_prove(req, self.active_handler.as_ref().unwrap().1.clone())
+            .await
+        {
+            Ok(resp) => resp,
+            Err(e) => ProveResponse {
+                status: TaskStatus::Failed,
+                error: Some(format!("failed to request proof: {}", e)),
+                ..Default::default()
+            },
+        }
+    }
+
+    async fn query_task(&mut self, req: QueryTaskRequest) -> QueryTaskResponse {
+        if let Some(handle) = &mut self.current_task {
+            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 {
+                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) -> Self {
+        Self {
+            config,
+            next_task_id: 0,
+            current_task: None,
+            active_handler: None,
+        }
+    }
+
+    async fn do_prove(
+        &mut self,
+        req: ProveRequest,
+        handler: Arc<dyn CircuitsHandler>,
+    ) -> Result<ProveResponse> {
+        self.next_task_id += 1;
+        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 = Some(task_handle);
+
+        Ok(ProveResponse {
+            task_id: self.next_task_id.to_string(),
+            proof_type: req.proof_type,
+            circuit_version: req.circuit_version,
+            hard_fork_name: req.hard_fork_name,
+            status: TaskStatus::Proving,
+            created_at,
+            input: Some(req.input),
+            ..Default::default()
+        })
+    }
+
+    fn set_active_handler(&mut self, hard_fork_name: &str) {
+        if let Some(handler) = &self.active_handler {
+            if handler.0 == hard_fork_name {
+                return;
+            }
+        }
+        self.active_handler = Some((hard_fork_name.to_string(), self.new_handler(hard_fork_name)));
+    }
+
+    fn new_handler(&self, hard_fork_name: &str) -> Arc<dyn CircuitsHandler> {
+        // if we got assigned a task for an unknown hard fork, there is something wrong in the
+        // coordinator
+        let config = self.config.circuits.get(hard_fork_name).unwrap();
+
+        Arc::new(match hard_fork_name {
+            "euclid" => Arc::new(Mutex::new(EuclidHandler::new(&config.workspace_path))),
+            _ => unreachable!(),
+        }) as Arc<dyn CircuitsHandler>
+    }
+}
--- a/zkvm-prover/src/types.rs
+++ b/zkvm-prover/src/types.rs
@@ -0,0 +1,110 @@
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use scroll_proving_sdk::prover::types::CircuitType;
+
+#[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
+    }
+}
--- a/zkvm-prover/src/zk_circuits_handler.rs
+++ b/zkvm-prover/src/zk_circuits_handler.rs
@@ -0,0 +1,12 @@
+pub mod euclid;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use scroll_proving_sdk::prover::{proving_service::ProveRequest, ProofType};
+
+#[async_trait]
+pub trait CircuitsHandler: Sync + Send {
+    async fn get_vk(&self, task_type: ProofType) -> Option<Vec<u8>>;
+
+    async fn get_proof_data(&self, prove_request: ProveRequest) -> Result<String>;
+}
--- a/zkvm-prover/src/zk_circuits_handler/euclid.rs
+++ b/zkvm-prover/src/zk_circuits_handler/euclid.rs
Author	SHA1	Message	Date
Ömer Faruk Irmak	69a7339bab	feat: bump zkvm-prover (#1614 ) Co-authored-by: omerfirmak <omerfirmak@users.noreply.github.com>	2025-03-10 23:12:12 +08:00
Ömer Faruk Irmak	056ebdca1c	feat: upgrade to euclid-enabled l2geth (#1612 ) Co-authored-by: omerfirmak <omerfirmak@users.noreply.github.com> Co-authored-by: colinlyguo <colinlyguo@scroll.io>	2025-03-10 14:57:34 +03:00
Ömer Faruk Irmak	7a386ad807	feat: euclid prover and coordinator (#1597 ) Co-authored-by: noelwei <fan@scroll.io> Co-authored-by: Rohit Narurkar <rohit.narurkar@proton.me> Co-authored-by: jonastheis <4181434+jonastheis@users.noreply.github.com> Co-authored-by: colinlyguo <colinlyguo@scroll.io> Co-authored-by: colin <102356659+colinlyguo@users.noreply.github.com> Co-authored-by: Morty <70688412+yiweichi@users.noreply.github.com> Co-authored-by: omerfirmak <omerfirmak@users.noreply.github.com>	2025-03-10 12:17:59 +03:00
Morty	5fb93c4dc3	fix(coordinator): jwt backward compatibility (#1606 ) Co-authored-by: yiweichi <yiweichi@users.noreply.github.com>	2025-03-05 13:17:18 +08:00
Morty	a5e2d71ebd	fix(prover): tokio thread stack overflow (#1604 )	2025-03-01 00:56:58 +08:00
colin	6b837c01f3	fix(build): image building (#1603 ) Co-authored-by: colinlyguo <colinlyguo@users.noreply.github.com>	2025-02-26 21:14:21 +08:00
colin	5b6b145753	feat(bridge-history-api): update l2geth dependency for Pectra readiness (#1601 )	2025-02-26 15:36:29 +08:00
Morty	c07975acdf	feat(prover): integrate proving-sdk && support multiple task types (#1587 ) Co-authored-by: yiweichi <yiweichi@users.noreply.github.com> Co-authored-by: Ömer Faruk Irmak <omerfirmak@gmail.com>	2025-02-20 17:17:23 +08:00