prune gpu prover making

.github/workflows/docker.yml

@@ -51,7 +51,9 @@ jobs:
           push: true
           tags: |
             scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   rollup_relayer:
     runs-on:
@@ -95,7 +97,9 @@ jobs:
           push: true
           tags: |
             scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   blob_uploader:
     runs-on:
@@ -139,7 +143,9 @@ jobs:
           push: true
           tags: |
             scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   rollup-db-cli:
     runs-on:
@@ -183,7 +189,9 @@ jobs:
           push: true
           tags: |
             scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   bridgehistoryapi-fetcher:
     runs-on:
@@ -227,7 +235,9 @@ jobs:
           push: true
           tags: |
             scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   bridgehistoryapi-api:
     runs-on:
@@ -271,7 +281,9 @@ jobs:
           push: true
           tags: |
             scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   bridgehistoryapi-db-cli:
     runs-on:
@@ -315,7 +327,9 @@ jobs:
           push: true
           tags: |
             scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   coordinator-api:
     runs-on:
@@ -358,7 +372,9 @@ jobs:
           push: true
           tags: |
             scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   coordinator-cron:
     runs-on:
@@ -402,4 +418,6 @@ jobs:
           push: true
           tags: |
             scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest

.github/workflows/intermediate-docker.yml

@@ -39,8 +39,7 @@ on:
         options:
           - "11.7.1"
           - "12.2.2"
-          - "12.9.1"
-        default: "12.9.1"
+        default: "11.7.1"
       CARGO_CHEF_TAG:
         description: "Cargo chef version"
         required: true

Cargo.toml

@@ -14,16 +14,16 @@ edition = "2021"
 homepage = "https://scroll.io"
 readme = "README.md"
 repository = "https://github.com/scroll-tech/scroll"
-version = "4.7.1"
+version = "4.5.47"
 
 [workspace.dependencies]
-scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.7.1" }
-scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.7.1" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.7.1" }
+scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "060be4c" }
+scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "060be4c" }
+scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "060be4c" }
 
-sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", tag = "scroll-v91.2", features = ["scroll", "rkyv"] }
-sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", tag = "scroll-v91.2" }
-sbv-core = { git = "https://github.com/scroll-tech/stateless-block-verifier", tag = "scroll-v91.2", features = ["scroll"] }
+sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "master", features = ["scroll", "rkyv"] }
+sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "master" }
+sbv-core = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "master", features = ["scroll"] }
 
 metrics = "0.23.0"
 metrics-util = "0.17"
@@ -31,14 +31,14 @@ metrics-tracing-context = "0.16.0"
 
 anyhow = "1.0"
 alloy = { version = "1", default-features = false }
-alloy-primitives = { version = "1.4.1", default-features = false, features = ["tiny-keccak"] }
+alloy-primitives = { version = "1.3", default-features = false, features = ["tiny-keccak"] }
 # also use this to trigger "serde" feature for primitives
 alloy-serde = { version = "1", default-features = false }
 
 serde = { version = "1", default-features = false, features = ["derive"] }
 serde_json = { version = "1.0" }
 serde_derive = "1.0"
-serde_with = "3"
+serde_with = "3.11.0"
 itertools = "0.14"
 tiny-keccak = "2.0"
 tracing = "0.1"
@@ -46,20 +46,21 @@ eyre = "0.6"
 once_cell = "1.20"
 base64 = "0.22"
 
-
 [patch.crates-io]
-revm = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-bytecode = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-context = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-context-interface = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-database = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-database-interface = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-handler = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-inspector = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-interpreter = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-precompile = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-primitives = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
-revm-state = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm = { git = "https://github.com/scroll-tech/revm" }
+revm-bytecode = { git = "https://github.com/scroll-tech/revm" }
+revm-context = { git = "https://github.com/scroll-tech/revm" }
+revm-context-interface = { git = "https://github.com/scroll-tech/revm" }
+revm-database = { git = "https://github.com/scroll-tech/revm" }
+revm-database-interface = { git = "https://github.com/scroll-tech/revm" }
+revm-handler = { git = "https://github.com/scroll-tech/revm" }
+revm-inspector = { git = "https://github.com/scroll-tech/revm" }
+revm-interpreter = { git = "https://github.com/scroll-tech/revm" }
+revm-precompile = { git = "https://github.com/scroll-tech/revm" }
+revm-primitives = { git = "https://github.com/scroll-tech/revm" }
+revm-state = { git = "https://github.com/scroll-tech/revm" }
+
+alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "feat/rkyv" }
 
 [profile.maxperf]
 inherits = "release"

Makefile

@@ -1,6 +1,6 @@
 .PHONY: fmt dev_docker build_test_docker run_test_docker clean update
 
-L2GETH_TAG=scroll-v5.9.17
+L2GETH_TAG=scroll-v5.8.23
 
 help: ## Display this help message
 	@grep -h \

bridge-history-api/go.mod

@@ -10,18 +10,15 @@ 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/da-codec v0.10.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f
-	github.com/stretchr/testify v1.10.0
+	github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9
+	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
 )
 
-// Hotfix for header hash incompatibility issue.
-// PR: https://github.com/scroll-tech/go-ethereum/pull/1133/
-// CAUTION: Requires careful handling. When upgrading go-ethereum, ensure this fix remains up-to-date in this branch.
-replace github.com/scroll-tech/go-ethereum => github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092359-25d5bf6b817b
+replace github.com/scroll-tech/go-ethereum => github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9 // It's a hotfix for the header hash incompatibility issue, pls change this with caution
 
 require (
 	dario.cat/mergo v1.0.0 // indirect
@@ -33,10 +30,10 @@ 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.27 // 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-eth-kzg v1.4.0 // indirect
+	github.com/crate-crypto/go-kzg-4844 v1.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
@@ -44,7 +41,7 @@ require (
 	github.com/docker/docker v26.1.0+incompatible // indirect
 	github.com/docker/go-connections v0.5.0 // indirect
 	github.com/edsrzf/mmap-go v1.0.0 // indirect
-	github.com/ethereum/c-kzg-4844/v2 v2.1.5 // indirect
+	github.com/ethereum/c-kzg-4844 v1.0.3 // indirect
 	github.com/fjl/memsize v0.0.2 // indirect
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
@@ -101,7 +98,7 @@ require (
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/status-im/keycard-go v0.2.0 // indirect
-	github.com/supranational/blst v0.3.15 // indirect
+	github.com/supranational/blst v0.3.13 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
 	github.com/tklauser/go-sysconf v0.3.14 // indirect
 	github.com/tklauser/numcpus v0.9.0 // indirect
@@ -113,7 +110,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

bridge-history-api/go.sum

@@ -53,16 +53,16 @@ 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.27 h1:j6hKUrGAy/H+gpNrpLU3I26n1yc+VMGmd6ID5+gAhOs=
-github.com/consensys/bavard v0.1.27/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=
 github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/crate-crypto/go-eth-kzg v1.4.0 h1:WzDGjHk4gFg6YzV0rJOAsTK4z3Qkz5jd4RE3DAvPFkg=
-github.com/crate-crypto/go-eth-kzg v1.4.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI=
+github.com/crate-crypto/go-kzg-4844 v1.1.0 h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4=
+github.com/crate-crypto/go-kzg-4844 v1.1.0/go.mod h1:JolLjpSff1tCCJKaJx4psrlEdlXuJEC996PL3tTAFks=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -88,8 +88,8 @@ github.com/elastic/go-sysinfo v1.11.1 h1:g9mwl05njS4r69TisC+vwHWTSKywZFYYUu3so3T
 github.com/elastic/go-sysinfo v1.11.1/go.mod h1:6KQb31j0QeWBDF88jIdWSxE8cwoOB9tO4Y4osN7Q70E=
 github.com/elastic/go-windows v1.0.1 h1:AlYZOldA+UJ0/2nBuqWdo90GFCgG9xuyw9SYzGUtJm0=
 github.com/elastic/go-windows v1.0.1/go.mod h1:FoVvqWSun28vaDQPbj2Elfc0JahhPB7WQEGa3c814Ss=
-github.com/ethereum/c-kzg-4844/v2 v2.1.5 h1:aVtoLK5xwJ6c5RiqO8g8ptJ5KU+2Hdquf6G3aXiHh5s=
-github.com/ethereum/c-kzg-4844/v2 v2.1.5/go.mod h1:u59hRTTah4Co6i9fDWtiCjTrblJv0UwsqZKCc0GfgUs=
+github.com/ethereum/c-kzg-4844 v1.0.3 h1:IEnbOHwjixW2cTvKRUlAAUOeleV7nNM/umJR+qy4WDs=
+github.com/ethereum/c-kzg-4844 v1.0.3/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
 github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA=
 github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
@@ -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.10.0 h1:IPHxyTyXTWPV0Q+DZ08cod2fWkhUvrfysmj/VBpB+WU=
-github.com/scroll-tech/da-codec v0.10.0/go.mod h1:MBlIP4wCXPcUDZ/Ci2B7n/2IbVU1WBo9OTFTZ5ffE0U=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092359-25d5bf6b817b h1:pMQKnroJoS/FeL1aOWkz7/u1iBHUP8PWjZstNuzoUGE=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092359-25d5bf6b817b/go.mod h1:Aa/kD1XB+OV/7rRxMQrjcPCB4b0pKyLH0gsTrtuHi38=
+github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178 h1:4utngmJHXSOS5FoSdZhEV1xMRirpArbXvyoCZY9nYj0=
+github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9 h1:u371VK8eOU2Z/0SVf5KDI3eJc8msHSpJbav4do/8n38=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
 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,10 +341,10 @@ 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/supranational/blst v0.3.15 h1:rd9viN6tfARE5wv3KZJ9H8e1cg0jXW8syFCcsbHa76o=
-github.com/supranational/blst v0.3.15/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
+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=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
 github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU=
@@ -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=

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

@@ -361,6 +361,7 @@ func getTxHistoryInfoFromBridgeBatchDepositMessage(message *orm.BridgeBatchDepos
 func (h *HistoryLogic) getCachedTxsInfo(ctx context.Context, cacheKey string, pageNum, pageSize uint64) ([]*types.TxHistoryInfo, uint64, bool, error) {
 	start := int64((pageNum - 1) * pageSize)
 	end := start + int64(pageSize) - 1
+
 	total, err := h.redis.ZCard(ctx, cacheKey).Result()
 	if err != nil {
 		log.Error("failed to get zcard result", "error", err)
@@ -371,10 +372,6 @@ func (h *HistoryLogic) getCachedTxsInfo(ctx context.Context, cacheKey string, pa
 		return nil, 0, false, nil
 	}
 
-	if start >= total {
-		return nil, 0, false, nil
-	}
-
 	values, err := h.redis.ZRevRange(ctx, cacheKey, start, end).Result()
 	if err != nil {
 		log.Error("failed to get zrange result", "error", err)
@@ -453,6 +450,5 @@ func (h *HistoryLogic) processAndCacheTxHistoryInfo(ctx context.Context, cacheKe
 		log.Error("cache miss after write, expect hit", "cached key", cacheKey, "page", page, "page size", pageSize, "error", err)
 		return nil, 0, err
 	}
-
 	return pagedTxs, total, nil
 }

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

@@ -157,7 +157,7 @@ func (c *CrossMessage) GetL2UnclaimedWithdrawalsByAddress(ctx context.Context, s
 	db = db.Where("tx_status in (?)", []types.TxStatusType{types.TxStatusTypeSent, types.TxStatusTypeFailedRelayed, types.TxStatusTypeRelayTxReverted})
 	db = db.Where("sender = ?", sender)
 	db = db.Order("block_timestamp desc")
-	db = db.Limit(10000)
+	db = db.Limit(500)
 	if err := db.Find(&messages).Error; err != nil {
 		return nil, fmt.Errorf("failed to get L2 claimable withdrawal messages by sender address, sender: %v, error: %w", sender, err)
 	}

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.20251128092113-8629f088d78f
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587
 	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
@@ -64,7 +64,7 @@ require (
 	github.com/containerd/typeurl/v2 v2.1.1 // indirect
 	github.com/cpuguy83/dockercfg v0.3.1 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect
-	github.com/crate-crypto/go-eth-kzg v1.4.0 // indirect
+	github.com/crate-crypto/go-kzg-4844 v1.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea // indirect
 	github.com/distribution/reference v0.5.0 // indirect
@@ -79,7 +79,7 @@ require (
 	github.com/docker/go-units v0.5.0 // indirect
 	github.com/edsrzf/mmap-go v1.0.0 // indirect
 	github.com/emicklei/go-restful/v3 v3.10.1 // indirect
-	github.com/ethereum/c-kzg-4844/v2 v2.1.5 // indirect
+	github.com/ethereum/c-kzg-4844 v1.0.3 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/fjl/memsize v0.0.2 // indirect
 	github.com/fsnotify/fsevents v0.1.1 // indirect
@@ -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.10.0 // indirect
+	github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178 // 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
@@ -198,7 +198,7 @@ require (
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/spf13/viper v1.4.0 // indirect
 	github.com/status-im/keycard-go v0.2.0 // indirect
-	github.com/supranational/blst v0.3.15 // indirect
+	github.com/supranational/blst v0.3.13 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
 	github.com/theupdateframework/notary v0.7.0 // indirect
 	github.com/tilt-dev/fsnotify v1.4.8-0.20220602155310-fff9c274a375 // indirect

common/go.sum

@@ -155,8 +155,8 @@ github.com/cpuguy83/dockercfg v0.3.1 h1:/FpZ+JaygUR/lZP2NlFI2DVfrOEMAIKP5wWEJdoY
 github.com/cpuguy83/dockercfg v0.3.1/go.mod h1:sugsbF4//dDlL/i+S+rtpIWp+5h0BHJHfjj5/jFyUJc=
 github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
 github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/crate-crypto/go-eth-kzg v1.4.0 h1:WzDGjHk4gFg6YzV0rJOAsTK4z3Qkz5jd4RE3DAvPFkg=
-github.com/crate-crypto/go-eth-kzg v1.4.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI=
+github.com/crate-crypto/go-kzg-4844 v1.1.0 h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4=
+github.com/crate-crypto/go-kzg-4844 v1.1.0/go.mod h1:JolLjpSff1tCCJKaJx4psrlEdlXuJEC996PL3tTAFks=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
 github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY=
@@ -214,8 +214,8 @@ github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7
 github.com/envoyproxy/protoc-gen-validate v1.0.2 h1:QkIBuU5k+x7/QXPvPPnWXWlCdaBFApVqftFV6k087DA=
 github.com/envoyproxy/protoc-gen-validate v1.0.2/go.mod h1:GpiZQP3dDbg4JouG/NNS7QWXpgx6x8QiMKdmN72jogE=
 github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5/go.mod h1:a2zkGnVExMxdzMo3M0Hi/3sEU+cWnZpSni0O6/Yb/P0=
-github.com/ethereum/c-kzg-4844/v2 v2.1.5 h1:aVtoLK5xwJ6c5RiqO8g8ptJ5KU+2Hdquf6G3aXiHh5s=
-github.com/ethereum/c-kzg-4844/v2 v2.1.5/go.mod h1:u59hRTTah4Co6i9fDWtiCjTrblJv0UwsqZKCc0GfgUs=
+github.com/ethereum/c-kzg-4844 v1.0.3 h1:IEnbOHwjixW2cTvKRUlAAUOeleV7nNM/umJR+qy4WDs=
+github.com/ethereum/c-kzg-4844 v1.0.3/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
 github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
 github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA=
@@ -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.10.0 h1:IPHxyTyXTWPV0Q+DZ08cod2fWkhUvrfysmj/VBpB+WU=
-github.com/scroll-tech/da-codec v0.10.0/go.mod h1:MBlIP4wCXPcUDZ/Ci2B7n/2IbVU1WBo9OTFTZ5ffE0U=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f h1:j6SjP98MoWFFX9TwB1/nFYEkayqHQsrtE66Ll2C+oT0=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f/go.mod h1:Aa/kD1XB+OV/7rRxMQrjcPCB4b0pKyLH0gsTrtuHi38=
+github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178 h1:4utngmJHXSOS5FoSdZhEV1xMRirpArbXvyoCZY9nYj0=
+github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587 h1:wG1+gb+K4iLtxAHhiAreMdIjP5x9hB64duraN2+u1QU=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587/go.mod h1:YyfB2AyAtphlbIuDQgaxc2b9mo0zE4EBA1+qtXvzlmg=
 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=
@@ -707,8 +707,8 @@ github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/supranational/blst v0.3.15 h1:rd9viN6tfARE5wv3KZJ9H8e1cg0jXW8syFCcsbHa76o=
-github.com/supranational/blst v0.3.15/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
+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=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
 github.com/testcontainers/testcontainers-go v0.30.0 h1:jmn/XS22q4YRrcMwWg0pAwlClzs/abopbsBzrepyc4E=

common/testcontainers/docker-compose.yml

@@ -34,7 +34,7 @@ services:
 
   # Sets up the genesis configuration for the go-ethereum client from a JSON file.
   geth-genesis:
-    image: "ethereum/client-go:v1.14.0"
+    image: "ethereum/client-go:v1.13.14"
     command: --datadir=/data/execution init /data/execution/genesis.json
     volumes:
       - data:/data
@@ -80,7 +80,7 @@ services:
   # Runs the go-ethereum execution client with the specified, unlocked account and necessary
   # APIs to allow for proof-of-stake consensus via Prysm.
   geth:
-    image: "ethereum/client-go:v1.14.0"
+    image: "ethereum/client-go:v1.13.14"
     command:
       - --http
       - --http.api=eth,net,web3

common/testcontainers/docker/l1geth/Dockerfile

@@ -1,4 +1,4 @@
-FROM ethereum/client-go:v1.14.0
+FROM ethereum/client-go:v1.13.14
 
 COPY password /l1geth/
 COPY genesis.json /l1geth/

common/testcontainers/testcontainers.go

@@ -10,7 +10,6 @@ import (
 	"time"
 
 	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/testcontainers/testcontainers-go"
 	"github.com/testcontainers/testcontainers-go/modules/compose"
 	"github.com/testcontainers/testcontainers-go/modules/postgres"
@@ -167,13 +166,13 @@ func (t *TestcontainerApps) GetPoSL1EndPoint() (string, error) {
 	return contrainer.PortEndpoint(context.Background(), "8545/tcp", "http")
 }
 
-// GetPoSL1Client returns a raw rpc client by dialing the L1 node
-func (t *TestcontainerApps) GetPoSL1Client() (*rpc.Client, error) {
+// GetPoSL1Client returns a ethclient by dialing running PoS L1 client
+func (t *TestcontainerApps) GetPoSL1Client() (*ethclient.Client, error) {
 	endpoint, err := t.GetPoSL1EndPoint()
 	if err != nil {
 		return nil, err
 	}
-	return rpc.Dial(endpoint)
+	return ethclient.Dial(endpoint)
 }
 
 // GetDBEndPoint returns the endpoint of the running postgres container
@@ -221,20 +220,11 @@ func (t *TestcontainerApps) GetGormDBClient() (*gorm.DB, error) {
 
 // GetL2GethClient returns a ethclient by dialing running L2Geth
 func (t *TestcontainerApps) GetL2GethClient() (*ethclient.Client, error) {
-	rpcCli, err := t.GetL2Client()
-	if err != nil {
-		return nil, err
-	}
-	return ethclient.NewClient(rpcCli), nil
-}
-
-// GetL2GethClient returns a rpc client by dialing running L2Geth
-func (t *TestcontainerApps) GetL2Client() (*rpc.Client, error) {
 	endpoint, err := t.GetL2GethEndPoint()
 	if err != nil {
 		return nil, err
 	}
-	client, err := rpc.Dial(endpoint)
+	client, err := ethclient.Dial(endpoint)
 	if err != nil {
 		return nil, err
 	}

common/testcontainers/testcontainers_test.go

@@ -3,6 +3,7 @@ package testcontainers
 import (
 	"testing"
 
+	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 )
@@ -13,6 +14,7 @@ func TestNewTestcontainerApps(t *testing.T) {
 		err          error
 		endpoint     string
 		gormDBclient *gorm.DB
+		ethclient    *ethclient.Client
 	)
 
 	testApps := NewTestcontainerApps()
@@ -30,17 +32,17 @@ func TestNewTestcontainerApps(t *testing.T) {
 	endpoint, err = testApps.GetL2GethEndPoint()
 	assert.NoError(t, err)
 	assert.NotEmpty(t, endpoint)
-	l2RawClient, err := testApps.GetL2Client()
+	ethclient, err = testApps.GetL2GethClient()
 	assert.NoError(t, err)
-	assert.NotNil(t, l2RawClient)
+	assert.NotNil(t, ethclient)
 
 	assert.NoError(t, testApps.StartPoSL1Container())
 	endpoint, err = testApps.GetPoSL1EndPoint()
 	assert.NoError(t, err)
 	assert.NotEmpty(t, endpoint)
-	l1RawClient, err := testApps.GetPoSL1Client()
+	ethclient, err = testApps.GetPoSL1Client()
 	assert.NoError(t, err)
-	assert.NotNil(t, l1RawClient)
+	assert.NotNil(t, ethclient)
 
 	assert.NoError(t, testApps.StartWeb3SignerContainer(1))
 	endpoint, err = testApps.GetWeb3SignerEndpoint()

common/types/message/message.go

@@ -39,12 +39,10 @@ const (
 
 // ChunkTaskDetail is a type containing ChunkTask detail for chunk task.
 type ChunkTaskDetail struct {
-	Version uint8 `json:"version"`
 	// use one of the string of "euclidv1" / "euclidv2"
 	ForkName         string        `json:"fork_name"`
 	BlockHashes      []common.Hash `json:"block_hashes"`
 	PrevMsgQueueHash common.Hash   `json:"prev_msg_queue_hash"`
-	PostMsgQueueHash common.Hash   `json:"post_msg_queue_hash"`
 }
 
 // it is a hex encoded big with fixed length on 48 bytes
@@ -92,59 +90,40 @@ func (e *Byte48) UnmarshalJSON(input []byte) error {
 
 // BatchTaskDetail is a type containing BatchTask detail.
 type BatchTaskDetail struct {
-	Version uint8 `json:"version"`
 	// use one of the string of "euclidv1" / "euclidv2"
-	ForkName      string              `json:"fork_name"`
-	ChunkProofs   []*OpenVMChunkProof `json:"chunk_proofs"`
-	BatchHeader   interface{}         `json:"batch_header"`
-	BlobBytes     []byte              `json:"blob_bytes"`
-	KzgProof      *Byte48             `json:"kzg_proof,omitempty"`
-	KzgCommitment *Byte48             `json:"kzg_commitment,omitempty"`
-	// ChallengeDigest should be a common.Hash type if it is not nil
-	ChallengeDigest interface{} `json:"challenge_digest,omitempty"`
+	ForkName        string              `json:"fork_name"`
+	ChunkInfos      []*ChunkInfo        `json:"chunk_infos"`
+	ChunkProofs     []*OpenVMChunkProof `json:"chunk_proofs"`
+	BatchHeader     interface{}         `json:"batch_header"`
+	BlobBytes       []byte              `json:"blob_bytes"`
+	KzgProof        Byte48              `json:"kzg_proof,omitempty"`
+	KzgCommitment   Byte48              `json:"kzg_commitment,omitempty"`
+	ChallengeDigest common.Hash         `json:"challenge_digest,omitempty"`
 }
 
 // BundleTaskDetail consists of all the information required to describe the task to generate a proof for a bundle of batches.
 type BundleTaskDetail struct {
-	Version uint8 `json:"version"`
 	// use one of the string of "euclidv1" / "euclidv2"
 	ForkName    string              `json:"fork_name"`
 	BatchProofs []*OpenVMBatchProof `json:"batch_proofs"`
 	BundleInfo  *OpenVMBundleInfo   `json:"bundle_info,omitempty"`
 }
 
-type RawBytes []byte
-
-func (r RawBytes) MarshalJSON() ([]byte, error) {
-	if r == nil {
-		return []byte("null"), nil
-	}
-	// Marshal the []byte as a JSON array of numbers
-	rn := make([]uint16, len(r))
-	for i := range r {
-		rn[i] = uint16(r[i])
-	}
-	return json.Marshal(rn)
-}
-
 // ChunkInfo is for calculating pi_hash for chunk
 type ChunkInfo struct {
-	ChainID       uint64      `json:"chain_id"`
-	PrevStateRoot common.Hash `json:"prev_state_root"`
-	PostStateRoot common.Hash `json:"post_state_root"`
-	WithdrawRoot  common.Hash `json:"withdraw_root"`
-	DataHash      common.Hash `json:"data_hash"`
-	IsPadding     bool        `json:"is_padding"`
-	//	TxBytes            []byte           `json:"tx_bytes"`
+	ChainID            uint64           `json:"chain_id"`
+	PrevStateRoot      common.Hash      `json:"prev_state_root"`
+	PostStateRoot      common.Hash      `json:"post_state_root"`
+	WithdrawRoot       common.Hash      `json:"withdraw_root"`
+	DataHash           common.Hash      `json:"data_hash"`
+	IsPadding          bool             `json:"is_padding"`
+	TxBytes            []byte           `json:"tx_bytes"`
 	TxBytesHash        common.Hash      `json:"tx_data_digest"`
 	PrevMsgQueueHash   common.Hash      `json:"prev_msg_queue_hash"`
 	PostMsgQueueHash   common.Hash      `json:"post_msg_queue_hash"`
 	TxDataLength       uint64           `json:"tx_data_length"`
 	InitialBlockNumber uint64           `json:"initial_block_number"`
 	BlockCtxs          []BlockContextV2 `json:"block_ctxs"`
-	PrevBlockhash      common.Hash      `json:"prev_blockhash"`
-	PostBlockhash      common.Hash      `json:"post_blockhash"`
-	EncryptionKey      RawBytes         `json:"encryption_key"`
 }
 
 // BlockContextV2 is the block context for euclid v2
@@ -207,7 +186,6 @@ type OpenVMBatchInfo struct {
 	ChainID          uint64      `json:"chain_id"`
 	PrevMsgQueueHash common.Hash `json:"prev_msg_queue_hash"`
 	PostMsgQueueHash common.Hash `json:"post_msg_queue_hash"`
-	EncryptionKey    RawBytes    `json:"encryption_key"`
 }
 
 // BatchProof includes the proof info that are required for batch verification and rollup.
@@ -268,7 +246,6 @@ type OpenVMBundleInfo struct {
 	PrevBatchHash common.Hash `json:"prev_batch_hash"`
 	BatchHash     common.Hash `json:"batch_hash"`
 	MsgQueueHash  common.Hash `json:"msg_queue_hash"`
-	EncryptionKey RawBytes    `json:"encryption_key"`
 }
 
 // OpenVMBundleProof includes the proof info that are required for verification of a bundle of batch proofs.

common/version/version.go

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

coordinator/Makefile

@@ -35,16 +35,10 @@ coordinator_tool:
 	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_tool ./cmd/tool
 
 localsetup: coordinator_api ## Local setup: build coordinator_api, copy config, and setup releases
-	mkdir -p build/bin/conf
 	@echo "Copying configuration files..."
-	@if [ -f "$(PWD)/conf/config.template.json" ]; then \
-		SRC="$(PWD)/conf/config.template.json"; \
-	else \
-		SRC="$(CURDIR)/conf/config.json"; \
-	fi; \
-	cp -fL "$$SRC" "$(CURDIR)/build/bin/conf/config.template.json"
+	cp -r $(PWD)/conf $(PWD)/build/bin/
 	@echo "Setting up releases..."
-	cd $(CURDIR)/build && bash setup_releases.sh
+	cd $(PWD)/build && bash setup_releases.sh
 
 
 #coordinator_api_skip_libzkp:

coordinator/build/setup_releases.sh

@@ -6,11 +6,8 @@ if [ -z "${SCROLL_ZKVM_VERSION}" ]; then
   exit 1
 fi
 
-# default fork name from env or "galileo"
-SCROLL_FORK_NAME="${SCROLL_FORK_NAME:-galileov2}"
-
 # set ASSET_DIR by reading from config.json
-CONFIG_FILE="bin/conf/config.template.json"
+CONFIG_FILE="bin/conf/config.json"
 if [ ! -f "$CONFIG_FILE" ]; then
   echo "Config file $CONFIG_FILE not found"
   exit 1
@@ -31,13 +28,7 @@ for ((i=0; i<$VERIFIER_COUNT; i++)); do
   # extract assets_path for current verifier
   ASSETS_PATH=$(jq -r ".prover_manager.verifier.verifiers[$i].assets_path" "$CONFIG_FILE")
   FORK_NAME=$(jq -r ".prover_manager.verifier.verifiers[$i].fork_name" "$CONFIG_FILE")
-
-  # skip if this verifier's fork doesn't match the target fork
-  if [ "$FORK_NAME" != "$SCROLL_FORK_NAME" ]; then
-    echo "Expect $SCROLL_FORK_NAME, skip current fork ($FORK_NAME)"
-    continue
-  fi
-
+  
   if [ "$ASSETS_PATH" = "null" ]; then
     echo "Warning: Could not find assets_path for verifier $i, skipping..."
     continue
@@ -62,7 +53,6 @@ for ((i=0; i<$VERIFIER_COUNT; i++)); do
   # assets for verifier-only mode
   echo "Downloading assets for $FORK_NAME to $ASSET_DIR..."
   wget https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/$SCROLL_ZKVM_VERSION/verifier/verifier.bin -O ${ASSET_DIR}/verifier.bin
-  wget https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/$SCROLL_ZKVM_VERSION/verifier/root_verifier_vk -O ${ASSET_DIR}/root_verifier_vk
   wget https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/$SCROLL_ZKVM_VERSION/verifier/openVmVk.json -O ${ASSET_DIR}/openVmVk.json
   
   echo "Completed downloading assets for $FORK_NAME"

coordinator/cmd/api/app/mock_app.go

@@ -91,13 +91,11 @@ func (c *CoordinatorApp) MockConfig(store bool) error {
 		ProversPerSession: 1,
 		Verifier: &coordinatorConfig.VerifierConfig{
 			MinProverVersion: "v4.4.89",
-			Verifiers: []coordinatorConfig.AssetConfig{
-				{
-					AssetsPath: "",
-					ForkName:   "galileo",
-				},
+			Verifiers: []coordinatorConfig.AssetConfig{{
+				AssetsPath: "",
+				ForkName:   "feynman",
 			},
-		},
+			}},
 		BatchCollectionTimeSec: 60,
 		ChunkCollectionTimeSec: 60,
 		SessionAttempts:        10,

coordinator/cmd/tool/verify.go

@@ -36,7 +36,7 @@ func verify(cCtx *cli.Context) error {
 		return fmt.Errorf("error reading file: %w", err)
 	}
 
-	vf, err := verifier.NewVerifier(cfg.ProverManager.Verifier, cfg.L2.ValidiumMode)
+	vf, err := verifier.NewVerifier(cfg.ProverManager.Verifier)
 	if err != nil {
 		return err
 	}

coordinator/conf/config.json

@@ -10,18 +10,13 @@
       "min_prover_version": "v4.4.45",
       "verifiers": [
         {
-          "features": "legacy_witness:openvm_13",
-          "assets_path": "assets_feynman",
-          "fork_name": "feynman"
+          "assets_path": "assets",
+          "fork_name": "euclidV2"
         },        
         {
           "assets_path": "assets",
-          "fork_name": "galileo"
-        },
-        {
-          "assets_path": "assets_v2",
-          "fork_name": "galileoV2"
-        }        
+          "fork_name": "feynman"
+        }
       ]
     }
   },

coordinator/go.mod

@@ -9,8 +9,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.10.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f
+	github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7
 	github.com/shopspring/decimal v1.3.1
 	github.com/stretchr/testify v1.10.0
 	github.com/urfave/cli/v2 v2.25.7
@@ -54,11 +54,11 @@ require (
 	github.com/consensys/bavard v0.1.29 // indirect
 	github.com/consensys/gnark-crypto v0.16.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
-	github.com/crate-crypto/go-eth-kzg v1.4.0 // indirect
+	github.com/crate-crypto/go-kzg-4844 v1.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea // indirect
 	github.com/edsrzf/mmap-go v1.0.0 // indirect
-	github.com/ethereum/c-kzg-4844/v2 v2.1.5 // indirect
+	github.com/ethereum/c-kzg-4844 v1.0.3 // indirect
 	github.com/fjl/memsize v0.0.2 // indirect
 	github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
@@ -92,7 +92,7 @@ require (
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4 // indirect
-	github.com/supranational/blst v0.3.15 // indirect
+	github.com/supranational/blst v0.3.13 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
 	github.com/tklauser/go-sysconf v0.3.14 // indirect
 	github.com/tklauser/numcpus v0.9.0 // indirect

coordinator/go.sum

@@ -47,8 +47,8 @@ github.com/consensys/gnark-crypto v0.16.0 h1:8Dl4eYmUWK9WmlP1Bj6je688gBRJCJbT8Mw
 github.com/consensys/gnark-crypto v0.16.0/go.mod h1:Ke3j06ndtPTVvo++PhGNgvm+lgpLvzbcE2MqljY7diU=
 github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
 github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/crate-crypto/go-eth-kzg v1.4.0 h1:WzDGjHk4gFg6YzV0rJOAsTK4z3Qkz5jd4RE3DAvPFkg=
-github.com/crate-crypto/go-eth-kzg v1.4.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI=
+github.com/crate-crypto/go-kzg-4844 v1.1.0 h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4=
+github.com/crate-crypto/go-kzg-4844 v1.1.0/go.mod h1:JolLjpSff1tCCJKaJx4psrlEdlXuJEC996PL3tTAFks=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -59,8 +59,8 @@ github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vs
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
 github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
 github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
-github.com/ethereum/c-kzg-4844/v2 v2.1.5 h1:aVtoLK5xwJ6c5RiqO8g8ptJ5KU+2Hdquf6G3aXiHh5s=
-github.com/ethereum/c-kzg-4844/v2 v2.1.5/go.mod h1:u59hRTTah4Co6i9fDWtiCjTrblJv0UwsqZKCc0GfgUs=
+github.com/ethereum/c-kzg-4844 v1.0.3 h1:IEnbOHwjixW2cTvKRUlAAUOeleV7nNM/umJR+qy4WDs=
+github.com/ethereum/c-kzg-4844 v1.0.3/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
 github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA=
 github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
@@ -253,10 +253,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.10.0 h1:IPHxyTyXTWPV0Q+DZ08cod2fWkhUvrfysmj/VBpB+WU=
-github.com/scroll-tech/da-codec v0.10.0/go.mod h1:MBlIP4wCXPcUDZ/Ci2B7n/2IbVU1WBo9OTFTZ5ffE0U=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f h1:j6SjP98MoWFFX9TwB1/nFYEkayqHQsrtE66Ll2C+oT0=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f/go.mod h1:Aa/kD1XB+OV/7rRxMQrjcPCB4b0pKyLH0gsTrtuHi38=
+github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178 h1:4utngmJHXSOS5FoSdZhEV1xMRirpArbXvyoCZY9nYj0=
+github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7 h1:1rN1qocsQlOyk1VCpIEF1J5pfQbLAi1pnMZSLQS37jQ=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
 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=
@@ -282,8 +282,8 @@ github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/supranational/blst v0.3.15 h1:rd9viN6tfARE5wv3KZJ9H8e1cg0jXW8syFCcsbHa76o=
-github.com/supranational/blst v0.3.15/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
+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=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
 github.com/tidwall/gjson v1.14.3 h1:9jvXn7olKEHU1S9vwoMGliaT8jq1vJ7IH/n9zD9Dnlw=

coordinator/internal/config/config.go

@@ -36,9 +36,8 @@ type L2Endpoint struct {
 // L2 loads l2geth configuration items.
 type L2 struct {
 	// l2geth chain_id.
-	ChainID      uint64      `json:"chain_id"`
-	Endpoint     *L2Endpoint `json:"l2geth"`
-	ValidiumMode bool        `json:"validium_mode"`
+	ChainID  uint64      `json:"chain_id"`
+	Endpoint *L2Endpoint `json:"l2geth"`
 }
 
 // Auth provides the auth coordinator
@@ -48,33 +47,26 @@ type Auth struct {
 	LoginExpireDurationSec     int    `json:"login_expire_duration_sec"`
 }
 
-// The sequencer controlled data
-type Sequencer struct {
-	DecryptionKey string `json:"decryption_key"`
-}
-
 // Config load configuration items.
 type Config struct {
 	ProverManager *ProverManager   `json:"prover_manager"`
 	DB            *database.Config `json:"db"`
 	L2            *L2              `json:"l2"`
 	Auth          *Auth            `json:"auth"`
-	Sequencer     *Sequencer       `json:"sequencer"`
 }
 
 // AssetConfig contain assets configurated for each fork, the defaul vkfile name is "OpenVmVk.json".
 type AssetConfig struct {
 	AssetsPath       string `json:"assets_path"`
-	Version          uint8  `json:"version,omitempty"`
 	ForkName         string `json:"fork_name"`
 	Vkfile           string `json:"vk_file,omitempty"`
 	MinProverVersion string `json:"min_prover_version,omitempty"`
-	Features         string `json:"features,omitempty"`
 }
 
 // VerifierConfig load zk verifier config.
 type VerifierConfig struct {
 	MinProverVersion string        `json:"min_prover_version"`
+	Features         string        `json:"features,omitempty"`
 	Verifiers        []AssetConfig `json:"verifiers"`
 }
 

coordinator/internal/config/config_test.go

@@ -23,7 +23,7 @@ func TestConfig(t *testing.T) {
 				"min_prover_version": "v4.4.45",
 				"verifiers": [{
 					"assets_path": "assets",
-					"fork_name": "galileo"
+					"fork_name": "feynman"
 				}]
 			},
 			"max_verifier_workers": 4
@@ -35,17 +35,13 @@ func TestConfig(t *testing.T) {
 			"maxIdleNum": 20
 		},
 		"l2": {
-			"chain_id": 111,
-			"validium_mode": false
+			"chain_id": 111
 		},
  		"auth": {
 			"secret": "prover secret key",
 			"challenge_expire_duration_sec": 3600,
 			"login_expire_duration_sec": 3600
-  		},
-    	"sequencer": {
-     		"decryption_key": "sequencer decryption key"
-     	}
+  		}
 	}`
 
 	t.Run("Success Case", func(t *testing.T) {

coordinator/internal/controller/api/controller.go

@@ -24,9 +24,7 @@ var (
 
 // InitController inits Controller with database
 func InitController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) {
-	validiumMode := cfg.L2.ValidiumMode
-
-	vf, err := verifier.NewVerifier(cfg.ProverManager.Verifier, validiumMode)
+	vf, err := verifier.NewVerifier(cfg.ProverManager.Verifier)
 	if err != nil {
 		panic("proof receiver new verifier failure")
 	}

coordinator/internal/logic/libzkp/lib.go

@@ -93,8 +93,8 @@ func fromMessageTaskType(taskType int) int {
 }
 
 // Generate a universal task
-func GenerateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte, decryptionKey []byte) (bool, string, string, []byte) {
-	return generateUniversalTask(fromMessageTaskType(taskType), taskJSON, strings.ToLower(forkName), expectedVk, decryptionKey)
+func GenerateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte) (bool, string, string, []byte) {
+	return generateUniversalTask(fromMessageTaskType(taskType), taskJSON, strings.ToLower(forkName), expectedVk)
 }
 
 // Generate wrapped proof
@@ -141,19 +141,9 @@ func DumpVk(forkName, filePath string) error {
 	return nil
 }
 
-// UnivTaskCompatibilityFix calls the universal task compatibility fix function
-func UniversalTaskCompatibilityFix(taskJSON string) (string, error) {
-	cTaskJSON := goToCString(taskJSON)
-	defer freeCString(cTaskJSON)
-
-	resultPtr := C.univ_task_compatibility_fix(cTaskJSON)
-	if resultPtr == nil {
-		return "", fmt.Errorf("univ_task_compatibility_fix failed")
-	}
-
-	// Convert result to Go string and free C memory
-	result := C.GoString(resultPtr)
-	C.release_string(resultPtr)
-
-	return result, nil
+// Set dynamic feature flags that control libzkp runtime behavior
+func SetDynamicFeature(feats string) {
+	cFeats := goToCString(feats)
+	defer freeCString(cFeats)
+	C.set_dynamic_feature(cFeats)
 }

coordinator/internal/logic/libzkp/libzkp.h

@@ -40,9 +40,7 @@ HandlingResult gen_universal_task(
     char* task,
     char* fork_name,
     const unsigned char* expected_vk,
-    size_t expected_vk_len,
-    const unsigned char* decryption_key,
-    size_t decryption_key_len
+    size_t expected_vk_len
 );
 
 // Release memory allocated for a HandlingResult returned by gen_universal_task
@@ -56,7 +54,7 @@ char* gen_wrapped_proof(char* proof_json, char* metadata, char* vk, size_t vk_le
 // Release memory allocated for a string returned by gen_wrapped_proof
 void release_string(char* string_ptr);
 
-// Universal task compatibility fix function
-char* univ_task_compatibility_fix(char* task_json);
+void set_dynamic_feature(const char* feats);
+
 
 #endif /* LIBZKP_H */

coordinator/internal/logic/libzkp/mock_universal_task.go

@@ -14,7 +14,7 @@ import (
 func InitL2geth(configJSON string) {
 }
 
-func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte, decryptionKey []byte) (bool, string, string, []byte) {
+func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte) (bool, string, string, []byte) {
 
 	fmt.Printf("call mocked generate universal task %d, taskJson %s\n", taskType, taskJSON)
 	var metadata interface{}

coordinator/internal/logic/libzkp/universal_task.go

@@ -17,7 +17,7 @@ func InitL2geth(configJSON string) {
 	C.init_l2geth(cConfig)
 }
 
-func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte, decryptionKey []byte) (bool, string, string, []byte) {
+func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte) (bool, string, string, []byte) {
 	cTask := goToCString(taskJSON)
 	cForkName := goToCString(forkName)
 	defer freeCString(cTask)
@@ -29,13 +29,7 @@ func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk [
 		cVk = (*C.uchar)(unsafe.Pointer(&expectedVk[0]))
 	}
 
-	// Create a C array from Go slice
-	var cDk *C.uchar
-	if len(decryptionKey) > 0 {
-		cDk = (*C.uchar)(unsafe.Pointer(&decryptionKey[0]))
-	}
-
-	result := C.gen_universal_task(C.int(taskType), cTask, cForkName, cVk, C.size_t(len(expectedVk)), cDk, C.size_t(len(decryptionKey)))
+	result := C.gen_universal_task(C.int(taskType), cTask, cForkName, cVk, C.size_t(len(expectedVk)))
 	defer C.release_task_result(result)
 
 	// Check if the operation was successful

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -213,14 +213,6 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 			return nil, ErrCoordinatorInternalFailure
 		}
 		proverTask.Metadata = metadata
-
-		if isCompatibilityFixingVersion(taskCtx.ProverVersion) {
-			log.Info("Apply compatibility fixing for prover", "version", taskCtx.ProverVersion)
-			if err := fixCompatibility(taskMsg); err != nil {
-				log.Error("apply compatibility failure", "err", err)
-				return nil, ErrCoordinatorInternalFailure
-			}
-		}
 	}
 
 	// Store session info.
@@ -257,21 +249,36 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 	}
 
 	var chunkProofs []*message.OpenVMChunkProof
-	//	var chunkInfos []*message.ChunkInfo
+	var chunkInfos []*message.ChunkInfo
 	for _, chunk := range chunks {
 		var proof message.OpenVMChunkProof
 		if encodeErr := json.Unmarshal(chunk.Proof, &proof); encodeErr != nil {
 			return nil, fmt.Errorf("Chunk.GetProofsByBatchHash unmarshal proof error: %w, batch hash: %v, chunk hash: %v", encodeErr, task.TaskID, chunk.Hash)
 		}
 		chunkProofs = append(chunkProofs, &proof)
+
+		chunkInfo := message.ChunkInfo{
+			ChainID:            bp.cfg.L2.ChainID,
+			PrevStateRoot:      common.HexToHash(chunk.ParentChunkStateRoot),
+			PostStateRoot:      common.HexToHash(chunk.StateRoot),
+			WithdrawRoot:       common.HexToHash(chunk.WithdrawRoot),
+			DataHash:           common.HexToHash(chunk.Hash),
+			PrevMsgQueueHash:   common.HexToHash(chunk.PrevL1MessageQueueHash),
+			PostMsgQueueHash:   common.HexToHash(chunk.PostL1MessageQueueHash),
+			IsPadding:          false,
+			InitialBlockNumber: proof.MetaData.ChunkInfo.InitialBlockNumber,
+			BlockCtxs:          proof.MetaData.ChunkInfo.BlockCtxs,
+			TxDataLength:       proof.MetaData.ChunkInfo.TxDataLength,
+		}
+		chunkInfos = append(chunkInfos, &chunkInfo)
 	}
 
-	taskDetail, err := bp.getBatchTaskDetail(batch, chunkProofs, hardForkName)
+	taskDetail, err := bp.getBatchTaskDetail(batch, chunkInfos, chunkProofs, hardForkName)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get batch task detail, taskID:%s err:%w", task.TaskID, err)
 	}
 
-	taskBytesWithchunkProofs, err := json.Marshal(taskDetail)
+	chunkProofsBytes, err := json.Marshal(taskDetail)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal chunk proofs, taskID:%s err:%w", task.TaskID, err)
 	}
@@ -279,7 +286,7 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 	taskMsg := &coordinatorType.GetTaskSchema{
 		TaskID:       task.TaskID,
 		TaskType:     int(message.ProofTypeBatch),
-		TaskData:     string(taskBytesWithchunkProofs),
+		TaskData:     string(chunkProofsBytes),
 		HardForkName: hardForkName,
 	}
 
@@ -294,59 +301,38 @@ func (bp *BatchProverTask) recoverActiveAttempts(ctx *gin.Context, batchTask *or
 	}
 }
 
-func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkProofs []*message.OpenVMChunkProof, hardForkName string) (*message.BatchTaskDetail, error) {
-	// Get the version byte.
-	version, err := bp.version(hardForkName)
-	if err != nil {
-		return nil, fmt.Errorf("failed to decode version byte: %w", err)
-	}
-
+func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*message.ChunkInfo, chunkProofs []*message.OpenVMChunkProof, hardForkName string) (*message.BatchTaskDetail, error) {
 	taskDetail := &message.BatchTaskDetail{
-		Version:     version,
+		ChunkInfos:  chunkInfos,
 		ChunkProofs: chunkProofs,
 		ForkName:    hardForkName,
 	}
 
-	taskDetail.BlobBytes = dbBatch.BlobBytes
-	if !bp.validiumMode() {
-		dbBatchCodecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
-		switch dbBatchCodecVersion {
-		case 0:
-			log.Warn("the codec version is 0, if it is not under integration test we have encountered an error here")
-			return taskDetail, nil
-		case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6, encoding.CodecV7, encoding.CodecV8, encoding.CodecV9, encoding.CodecV10:
-		default:
-			return nil, fmt.Errorf("Unsupported codec version <%d>", dbBatchCodecVersion)
-		}
-
-		codec, err := encoding.CodecFromVersion(encoding.CodecVersion(dbBatch.CodecVersion))
-		if err != nil {
-			return nil, fmt.Errorf("failed to get codec from version %d, err: %w", dbBatch.CodecVersion, err)
-		}
-
-		batchHeader, decodeErr := codec.NewDABatchFromBytes(dbBatch.BatchHeader)
-		if decodeErr != nil {
-			return nil, fmt.Errorf("failed to decode batch header version %d: %w", dbBatch.CodecVersion, decodeErr)
-		}
-		taskDetail.BatchHeader = batchHeader
-
-		taskDetail.ChallengeDigest = common.HexToHash(dbBatch.ChallengeDigest)
-		// Memory layout of `BlobDataProof`: used in Codec.BlobDataProofForPointEvaluation()
-		// | z       | y       | kzg_commitment | kzg_proof |
-		// |---------|---------|----------------|-----------|
-		// | bytes32 | bytes32 | bytes48        | bytes48   |
-		taskDetail.KzgProof = &message.Byte48{Big: hexutil.Big(*new(big.Int).SetBytes(dbBatch.BlobDataProof[112:160]))}
-		taskDetail.KzgCommitment = &message.Byte48{Big: hexutil.Big(*new(big.Int).SetBytes(dbBatch.BlobDataProof[64:112]))}
-	} else {
-		log.Info("Apply validium mode for batch proving task")
-		codec := cutils.FromVersion(version)
-		batchHeader, decodeErr := codec.DABatchForTaskFromBytes(dbBatch.BatchHeader)
-		if decodeErr != nil {
-			return nil, fmt.Errorf("failed to decode batch header version %d: %w", dbBatch.CodecVersion, decodeErr)
-		}
-		batchHeader.SetHash(common.HexToHash(dbBatch.Hash))
-		taskDetail.BatchHeader = batchHeader
+	dbBatchCodecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
+	switch dbBatchCodecVersion {
+	case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6, encoding.CodecV7, encoding.CodecV8:
+	default:
+		return taskDetail, nil
 	}
 
+	codec, err := encoding.CodecFromVersion(encoding.CodecVersion(dbBatch.CodecVersion))
+	if err != nil {
+		return nil, fmt.Errorf("failed to get codec from version %d, err: %w", dbBatch.CodecVersion, err)
+	}
+
+	batchHeader, decodeErr := codec.NewDABatchFromBytes(dbBatch.BatchHeader)
+	if decodeErr != nil {
+		return nil, fmt.Errorf("failed to decode batch header version %d: %w", dbBatch.CodecVersion, decodeErr)
+	}
+	taskDetail.BatchHeader = batchHeader
+	taskDetail.BlobBytes = dbBatch.BlobBytes
+	taskDetail.ChallengeDigest = common.HexToHash(dbBatch.ChallengeDigest)
+	// Memory layout of `BlobDataProof`: used in Codec.BlobDataProofForPointEvaluation()
+	// | z       | y       | kzg_commitment | kzg_proof |
+	// |---------|---------|----------------|-----------|
+	// | bytes32 | bytes32 | bytes48        | bytes48   |
+	taskDetail.KzgProof = message.Byte48{Big: hexutil.Big(*new(big.Int).SetBytes(dbBatch.BlobDataProof[112:160]))}
+	taskDetail.KzgCommitment = message.Byte48{Big: hexutil.Big(*new(big.Int).SetBytes(dbBatch.BlobDataProof[64:112]))}
+
 	return taskDetail, nil
 }

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -211,14 +211,6 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 		// bundle proof require snark
 		taskMsg.UseSnark = true
 		proverTask.Metadata = metadata
-
-		if isCompatibilityFixingVersion(taskCtx.ProverVersion) {
-			log.Info("Apply compatibility fixing for prover", "version", taskCtx.ProverVersion)
-			if err := fixCompatibility(taskMsg); err != nil {
-				log.Error("apply compatibility failure", "err", err)
-				return nil, ErrCoordinatorInternalFailure
-			}
-		}
 	}
 
 	// Store session info.
@@ -273,14 +265,7 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 		batchProofs = append(batchProofs, &proof)
 	}
 
-	// Get the version byte.
-	version, err := bp.version(hardForkName)
-	if err != nil {
-		return nil, fmt.Errorf("failed to decode version byte: %w", err)
-	}
-
 	taskDetail := message.BundleTaskDetail{
-		Version:     version,
 		BatchProofs: batchProofs,
 		ForkName:    hardForkName,
 	}

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -237,21 +237,14 @@ func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		return nil, fmt.Errorf("failed to fetch block hashes of a chunk, chunk hash:%s err:%v", task.TaskID, dbErr)
 	}
 
-	// Get the version byte.
-	version, err := cp.version(hardForkName)
-	if err != nil {
-		return nil, fmt.Errorf("failed to decode version byte: %w", err)
-	}
-
 	var taskDetailBytes []byte
 	taskDetail := message.ChunkTaskDetail{
-		Version:          version,
 		BlockHashes:      blockHashes,
 		PrevMsgQueueHash: common.HexToHash(chunk.PrevL1MessageQueueHash),
-		PostMsgQueueHash: common.HexToHash(chunk.PostL1MessageQueueHash),
 		ForkName:         hardForkName,
 	}
 
+	var err error
 	taskDetailBytes, err = json.Marshal(taskDetail)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal block hashes hash:%s, err:%w", task.TaskID, err)

coordinator/internal/logic/provertask/prover_task.go

@@ -1,7 +1,6 @@
 package provertask
 
 import (
-	"encoding/hex"
 	"errors"
 	"fmt"
 	"strings"
@@ -15,13 +14,11 @@ import (
 	"gorm.io/gorm"
 
 	"scroll-tech/common/types/message"
-	"scroll-tech/common/version"
 
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/logic/libzkp"
 	"scroll-tech/coordinator/internal/orm"
 	coordinatorType "scroll-tech/coordinator/internal/types"
-	"scroll-tech/coordinator/internal/utils"
 )
 
 var (
@@ -68,17 +65,6 @@ type proverTaskContext struct {
 	hasAssignedTask *orm.ProverTask
 }
 
-func (b *BaseProverTask) version(hardForkName string) (uint8, error) {
-	return utils.Version(hardForkName, b.validiumMode())
-}
-
-// validiumMode induce different behavior in task generation:
-// + skip the point_evaluation part in batch task
-// + encode batch header with codec in utils instead of da-codec
-func (b *BaseProverTask) validiumMode() bool {
-	return b.cfg.L2.ValidiumMode
-}
-
 // hardForkName get the chunk/batch/bundle hard fork name
 func (b *BaseProverTask) hardForkName(ctx *gin.Context, taskCtx *proverTaskContext) (string, error) {
 	switch {
@@ -206,16 +192,7 @@ func (b *BaseProverTask) applyUniversal(schema *coordinatorType.GetTaskSchema) (
 		return nil, nil, fmt.Errorf("no expectedVk found from hardfork %s", schema.HardForkName)
 	}
 
-	var decryptionKey []byte
-	if b.cfg.L2.ValidiumMode {
-		var err error
-		decryptionKey, err = hex.DecodeString(b.cfg.Sequencer.DecryptionKey)
-		if err != nil {
-			return nil, nil, fmt.Errorf("sequencer decryption key hex-decoding failed")
-		}
-	}
-
-	ok, uTaskData, metadata, _ := libzkp.GenerateUniversalTask(schema.TaskType, schema.TaskData, schema.HardForkName, expectedVk, decryptionKey)
+	ok, uTaskData, metadata, _ := libzkp.GenerateUniversalTask(schema.TaskType, schema.TaskData, schema.HardForkName, expectedVk)
 	if !ok {
 		return nil, nil, fmt.Errorf("can not generate universal task, see coordinator log for the reason")
 	}
@@ -224,23 +201,6 @@ func (b *BaseProverTask) applyUniversal(schema *coordinatorType.GetTaskSchema) (
 	return schema, []byte(metadata), nil
 }
 
-const CompatibilityVersion = "4.5.43"
-
-func isCompatibilityFixingVersion(ver string) bool {
-	return !version.CheckScrollRepoVersion(ver, CompatibilityVersion)
-}
-
-func fixCompatibility(schema *coordinatorType.GetTaskSchema) error {
-
-	fixedTask, err := libzkp.UniversalTaskCompatibilityFix(schema.TaskData)
-	if err != nil {
-		return err
-	}
-	schema.TaskData = fixedTask
-
-	return nil
-}
-
 func newGetTaskCounterVec(factory promauto.Factory, taskType string) *prometheus.CounterVec {
 	getTaskCounterInitOnce.Do(func() {
 		getTaskCounterVec = factory.NewCounterVec(prometheus.CounterOpts{

coordinator/internal/logic/submitproof/proof_receiver.go

@@ -155,7 +155,7 @@ func NewSubmitProofReceiverLogic(cfg *config.ProverManager, chainCfg *params.Cha
 // HandleZkProof handle a ZkProof submitted from a prover.
 // For now only proving/verifying error will lead to setting status as skipped.
 // db/unmarshal errors will not because they are errors on the business logic side.
-func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coordinatorType.SubmitProofParameter) (rerr error) {
+func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coordinatorType.SubmitProofParameter) error {
 	m.proofReceivedTotal.Inc()
 	pk := ctx.GetString(coordinatorType.PublicKey)
 	if len(pk) == 0 {
@@ -172,18 +172,6 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 		return ErrValidatorFailureProverTaskEmpty
 	}
 
-	defer func() {
-		if rerr != nil && types.ProverProveStatus(proverTask.ProvingStatus) == types.ProverAssigned {
-			// trigger a last-chance closing of current task if some routine had missed it
-			log.Warn("last chance proof recover triggerred",
-				"proofID", proofParameter.TaskID,
-				"err", rerr,
-			)
-			m.proofRecover(ctx.Copy(), proverTask, types.ProverTaskFailureTypeUndefined, proofParameter)
-		}
-
-	}()
-
 	proofTime := time.Since(proverTask.CreatedAt)
 	proofTimeSec := uint64(proofTime.Seconds())
 
@@ -323,20 +311,6 @@ func (m *ProofReceiverLogic) validator(ctx context.Context, proverTask *orm.Prov
 		}
 	}()
 
-	// Internally we overide the timeout failure:
-	// if prover task FailureType is SessionInfoFailureTimeout, the submit proof is timeout, but we still accept it
-	if types.ProverProveStatus(proverTask.ProvingStatus) == types.ProverProofInvalid &&
-		types.ProverTaskFailureType(proverTask.FailureType) == types.ProverTaskFailureTypeTimeout {
-		m.validateFailureProverTaskTimeout.Inc()
-		proverTask.ProvingStatus = int16(types.ProverAssigned)
-
-		proofTime := time.Since(proverTask.CreatedAt)
-		proofTimeSec := uint64(proofTime.Seconds())
-		log.Warn("proof submit proof have timeout", "hash", proofParameter.TaskID, "taskType", proverTask.TaskType,
-			"proverName", proverTask.ProverName, "proverPublicKey", pk, "proofTime", proofTimeSec)
-
-	}
-
 	// Ensure this prover is eligible to participate in the prover task.
 	if types.ProverProveStatus(proverTask.ProvingStatus) == types.ProverProofValid ||
 		types.ProverProveStatus(proverTask.ProvingStatus) == types.ProverProofInvalid {
@@ -354,6 +328,9 @@ func (m *ProofReceiverLogic) validator(ctx context.Context, proverTask *orm.Prov
 		return ErrValidatorFailureProverTaskCannotSubmitTwice
 	}
 
+	proofTime := time.Since(proverTask.CreatedAt)
+	proofTimeSec := uint64(proofTime.Seconds())
+
 	if proofParameter.Status != int(coordinatorType.StatusOk) {
 		// Temporarily replace "panic" with "pa-nic" to prevent triggering the alert based on logs.
 		failureMsg := strings.Replace(proofParameter.FailureMsg, "panic", "pa-nic", -1)
@@ -369,6 +346,14 @@ func (m *ProofReceiverLogic) validator(ctx context.Context, proverTask *orm.Prov
 		return ErrValidatorFailureProofMsgStatusNotOk
 	}
 
+	// if prover task FailureType is SessionInfoFailureTimeout, the submit proof is timeout, need skip it
+	if types.ProverTaskFailureType(proverTask.FailureType) == types.ProverTaskFailureTypeTimeout {
+		m.validateFailureProverTaskTimeout.Inc()
+		log.Info("proof submit proof have timeout, skip this submit proof", "hash", proofParameter.TaskID, "taskType", proverTask.TaskType,
+			"proverName", proverTask.ProverName, "proverPublicKey", pk, "proofTime", proofTimeSec)
+		return ErrValidatorFailureProofTimeout
+	}
+
 	// store the proof to prover task
 	if updateTaskProofErr := m.updateProverTaskProof(ctx, proverTask, proofParameter); updateTaskProofErr != nil {
 		log.Warn("update prover task proof failure", "hash", proofParameter.TaskID, "proverPublicKey", pk,
@@ -383,7 +368,6 @@ func (m *ProofReceiverLogic) validator(ctx context.Context, proverTask *orm.Prov
 			"taskType", proverTask.TaskType, "proverName", proverTask.ProverName, "proverPublicKey", pk)
 		return ErrValidatorFailureTaskHaveVerifiedSuccess
 	}
-
 	return nil
 }
 
@@ -400,7 +384,7 @@ func (m *ProofReceiverLogic) closeProofTask(ctx context.Context, proverTask *orm
 	log.Info("proof close task update proof status", "hash", proverTask.TaskID, "proverPublicKey", proverTask.ProverPublicKey,
 		"taskType", message.ProofType(proverTask.TaskType).String(), "status", types.ProvingTaskVerified.String())
 
-	if err := m.updateProofStatus(ctx, proverTask, proofParameter, types.ProverProofValid, types.ProverTaskFailureType(proverTask.FailureType), proofTimeSec); err != nil {
+	if err := m.updateProofStatus(ctx, proverTask, proofParameter, types.ProverProofValid, types.ProverTaskFailureTypeUndefined, proofTimeSec); err != nil {
 		log.Error("failed to updated proof status ProvingTaskVerified", "hash", proverTask.TaskID, "proverPublicKey", proverTask.ProverPublicKey, "error", err)
 		return err
 	}
@@ -461,9 +445,6 @@ func (m *ProofReceiverLogic) updateProofStatus(ctx context.Context, proverTask *
 	if err != nil {
 		return err
 	}
-	// sync status and failture type into proverTask
-	proverTask.ProvingStatus = int16(status)
-	proverTask.FailureType = int16(failureType)
 
 	if status == types.ProverProofValid && message.ProofType(proofParameter.TaskType) == message.ProofTypeChunk {
 		if checkReadyErr := m.checkAreAllChunkProofsReady(ctx, proverTask.TaskID); checkReadyErr != nil {

coordinator/internal/logic/verifier/mock.go

@@ -9,7 +9,7 @@ import (
 )
 
 // NewVerifier Sets up a mock verifier.
-func NewVerifier(cfg *config.VerifierConfig, _ bool) (*Verifier, error) {
+func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 	return &Verifier{
 		cfg:         cfg,
 		OpenVMVkMap: map[string]struct{}{"mock_vk": {}},

coordinator/internal/logic/verifier/verifier.go

@@ -19,36 +19,20 @@ import (
 
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/logic/libzkp"
-	"scroll-tech/coordinator/internal/utils"
 )
 
 // This struct maps to `CircuitConfig` in libzkp/src/verifier.rs
 // Define a brand new struct here is to eliminate side effects in case fields
 // in `*config.CircuitConfig` being changed
 type rustCircuitConfig struct {
-	Version    uint   `json:"version"`
 	ForkName   string `json:"fork_name"`
 	AssetsPath string `json:"assets_path"`
-	Features   string `json:"features,omitempty"`
 }
 
-var validiumMode bool
-
 func newRustCircuitConfig(cfg config.AssetConfig) *rustCircuitConfig {
-	ver := cfg.Version
-	if ver == 0 {
-		var err error
-		ver, err = utils.Version(cfg.ForkName, validiumMode)
-		if err != nil {
-			panic(err)
-		}
-	}
-
 	return &rustCircuitConfig{
-		Version:    uint(ver),
-		AssetsPath: cfg.AssetsPath,
 		ForkName:   cfg.ForkName,
-		Features:   cfg.Features,
+		AssetsPath: cfg.AssetsPath,
 	}
 }
 
@@ -76,14 +60,16 @@ type rustVkDump struct {
 }
 
 // NewVerifier Sets up a rust ffi to call verify.
-func NewVerifier(cfg *config.VerifierConfig, useValidiumMode bool) (*Verifier, error) {
-	validiumMode = useValidiumMode
+func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 	verifierConfig := newRustVerifierConfig(cfg)
 	configBytes, err := json.Marshal(verifierConfig)
 	if err != nil {
 		return nil, err
 	}
 
+	if cfg.Features != "" {
+		libzkp.SetDynamicFeature(cfg.Features)
+	}
 	libzkp.InitVerifier(string(configBytes))
 
 	v := &Verifier{

coordinator/internal/utils/codec_validium.go

@@ -1,91 +0,0 @@
-package utils
-
-import (
-	"encoding/binary"
-	"fmt"
-
-	"github.com/scroll-tech/go-ethereum/common"
-)
-
-type CodecVersion uint8
-
-const (
-	daBatchValidiumEncodedLength = 137
-)
-
-type DABatch interface {
-	SetHash(common.Hash)
-}
-
-type daBatchValidiumV1 struct {
-	Version         CodecVersion `json:"version"`
-	BatchIndex      uint64       `json:"batch_index"`
-	ParentBatchHash common.Hash  `json:"parent_batch_hash"`
-	PostStateRoot   common.Hash  `json:"post_state_root"`
-	WithDrawRoot    common.Hash  `json:"withdraw_root"`
-	Commitment      common.Hash  `json:"commitment"`
-}
-
-type daBatchValidium struct {
-	V1        *daBatchValidiumV1 `json:"V1,omitempty"`
-	BatchHash common.Hash        `json:"batch_hash"`
-}
-
-func (da *daBatchValidium) SetHash(h common.Hash) {
-	da.BatchHash = h
-}
-
-func FromVersion(v uint8) CodecVersion {
-	return CodecVersion(v & STFVersionMask)
-}
-
-func (c CodecVersion) DABatchForTaskFromBytes(b []byte) (DABatch, error) {
-	switch c {
-	case 1:
-		if v1, err := decodeDABatchV1(b); err == nil {
-			return &daBatchValidium{
-				V1: v1,
-			}, nil
-		} else {
-			return nil, err
-		}
-	default:
-		return nil, fmt.Errorf("unknown codec type %d", c)
-	}
-}
-
-func decodeDABatchV1(data []byte) (*daBatchValidiumV1, error) {
-	if len(data) != daBatchValidiumEncodedLength {
-		return nil, fmt.Errorf("invalid data length for DABatchV7, expected %d bytes but got %d", daBatchValidiumEncodedLength, len(data))
-	}
-
-	const (
-		versionSize = 1
-		indexSize   = 8
-		hashSize    = 32
-	)
-
-	// Offsets (same as encodeBatchHeaderValidium)
-	versionOffset := 0
-	indexOffset := versionOffset + versionSize
-	parentHashOffset := indexOffset + indexSize
-	stateRootOffset := parentHashOffset + hashSize
-	withdrawRootOffset := stateRootOffset + hashSize
-	commitmentOffset := withdrawRootOffset + hashSize
-
-	version := CodecVersion(data[versionOffset])
-	batchIndex := binary.BigEndian.Uint64(data[indexOffset : indexOffset+indexSize])
-	parentBatchHash := common.BytesToHash(data[parentHashOffset : parentHashOffset+hashSize])
-	postStateRoot := common.BytesToHash(data[stateRootOffset : stateRootOffset+hashSize])
-	withdrawRoot := common.BytesToHash(data[withdrawRootOffset : withdrawRootOffset+hashSize])
-	commitment := common.BytesToHash(data[commitmentOffset : commitmentOffset+hashSize])
-
-	return &daBatchValidiumV1{
-		Version:         version,
-		BatchIndex:      batchIndex,
-		ParentBatchHash: parentBatchHash,
-		PostStateRoot:   postStateRoot,
-		WithDrawRoot:    withdrawRoot,
-		Commitment:      commitment,
-	}, nil
-}

coordinator/internal/utils/version.go

@@ -1,42 +0,0 @@
-package utils
-
-import (
-	"errors"
-	"strings"
-)
-
-const (
-	DomainOffset   = 6
-	STFVersionMask = (1 << DomainOffset) - 1
-)
-
-// version get the version for the chain instance
-//
-// TODO: This is not foolproof and does not cover all scenarios.
-func Version(hardForkName string, ValidiumMode bool) (uint8, error) {
-
-	var domain, stfVersion uint8
-
-	if ValidiumMode {
-		domain = 1
-		stfVersion = 1
-	} else {
-		domain = 0
-		switch canonicalName := strings.ToLower(hardForkName); canonicalName {
-		case "euclidv1":
-			stfVersion = 6
-		case "euclidv2":
-			stfVersion = 7
-		case "feynman":
-			stfVersion = 8
-		case "galileo":
-			stfVersion = 9
-		case "galileov2":
-			stfVersion = 10
-		default:
-			return 0, errors.New("unknown fork name " + canonicalName)
-		}
-	}
-
-	return (domain << DomainOffset) + stfVersion, nil
-}

coordinator/test/api_test.go

@@ -132,7 +132,7 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 func setEnv(t *testing.T) {
 	var err error
 
-	version.Version = "v4.5.45"
+	version.Version = "v4.4.89"
 
 	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.LogfmtFormat()))
 	glogger.Verbosity(log.LvlInfo)

crates/l2geth/src/rpc_client.rs

@@ -5,7 +5,7 @@ use alloy::{
 };
 use eyre::Result;
 use libzkp::tasks::ChunkInterpreter;
-use sbv_primitives::types::{consensus::TxL1Message, Network};
+use sbv_primitives::types::Network;
 use serde::{Deserialize, Serialize};
 
 fn default_max_retry() -> u32 {
@@ -168,40 +168,6 @@ impl<T: Provider<Network>> ChunkInterpreter for RpcClient<'_, T> {
         self.handle
             .block_on(fetch_storage_node_async(&self.provider, node_hash))
     }
-
-    fn try_fetch_l1_msgs(&self, block_number: u64) -> Result<Vec<TxL1Message>> {
-        async fn fetch_l1_msgs(
-            provider: impl Provider<Network>,
-            block_number: u64,
-        ) -> Result<Vec<TxL1Message>> {
-            let block_number_hex = format!("0x{:x}", block_number);
-
-            #[derive(Deserialize, Debug)]
-            #[serde(untagged)]
-            enum NullOrVec {
-                Null,                  // matches JSON `null`
-                Vec(Vec<TxL1Message>), // matches JSON array
-            }
-
-            Ok(
-                match provider
-                    .client()
-                    .request::<_, NullOrVec>(
-                        "scroll_getL1MessagesInBlock",
-                        (block_number_hex, "synced"),
-                    )
-                    .await?
-                {
-                    NullOrVec::Null => Vec::new(),
-                    NullOrVec::Vec(r) => r,
-                },
-            )
-        }
-
-        tracing::debug!("fetch L1 msgs for {block_number}");
-        self.handle
-            .block_on(fetch_l1_msgs(&self.provider, block_number))
-    }
 }
 
 #[cfg(test)]
@@ -252,16 +218,4 @@ mod tests {
 
         println!("{}", serde_json::to_string_pretty(&wit2).unwrap());
     }
-
-    #[test]
-    #[ignore = "Requires L2GETH_ENDPOINT environment variable"]
-    fn test_try_fetch_l1_messages() {
-        let config = create_config_from_env();
-        let client_core = RpcClientCore::create(&config).expect("Failed to create RPC client");
-        let client = client_core.get_client();
-
-        let msgs = client.try_fetch_l1_msgs(32).expect("should success");
-
-        println!("{}", serde_json::to_string_pretty(&msgs).unwrap());
-    }
 }

crates/libzkp/Cargo.toml

@@ -5,11 +5,11 @@ edition.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
-scroll-zkvm-types = { workspace = true, features = ["scroll"] }
+scroll-zkvm-types.workspace = true
 scroll-zkvm-verifier.workspace = true
 
 alloy-primitives.workspace = true #depress the effect of "native-keccak"
-sbv-primitives = {workspace = true, features = ["scroll-compress-info", "scroll"]}
+sbv-primitives = {workspace = true, features = ["scroll-compress-ratio", "scroll"]}
 sbv-core = { workspace = true, features = ["scroll"] }
 base64.workspace = true
 serde.workspace = true

crates/libzkp/src/lib.rs

@@ -1,57 +1,34 @@
 pub mod proofs;
 pub mod tasks;
-pub use tasks::ProvingTaskExt;
 pub mod verifier;
-use verifier::HardForkName;
 pub use verifier::{TaskType, VerifierConfig};
 mod utils;
 
 use sbv_primitives::B256;
-use scroll_zkvm_types::{utils::vec_as_base64, version::Version};
+use scroll_zkvm_types::utils::vec_as_base64;
 use serde::{Deserialize, Serialize};
 use serde_json::value::RawValue;
-use std::{collections::HashMap, path::Path, sync::OnceLock};
+use std::path::Path;
 use tasks::chunk_interpreter::{ChunkInterpreter, TryFromWithInterpreter};
 
-pub(crate) fn witness_use_legacy_mode(fork_name: &str) -> eyre::Result<bool> {
-    ADDITIONAL_FEATURES
-        .get()
-        .and_then(|features| features.get(fork_name))
-        .map(|cfg| cfg.legacy_witness_encoding)
-        .ok_or_else(|| {
-            eyre::eyre!(
-                "can not find features setting for unrecognized fork {}",
-                fork_name
-            )
-        })
+/// global features: use legacy encoding for witness
+static mut LEGACY_WITNESS_ENCODING: bool = false;
+pub(crate) fn witness_use_legacy_mode() -> bool {
+    unsafe { LEGACY_WITNESS_ENCODING }
 }
 
-#[derive(Debug, Default, Clone)]
-struct FeatureOptions {
-    legacy_witness_encoding: bool,
-    for_openvm_13_prover: bool,
-}
-
-static ADDITIONAL_FEATURES: OnceLock<HashMap<HardForkName, FeatureOptions>> = OnceLock::new();
-
-impl FeatureOptions {
-    pub fn new(feats: &str) -> Self {
-        let mut ret: Self = Default::default();
-
-        for feat_s in feats.split(':') {
-            match feat_s.trim().to_lowercase().as_str() {
-                "legacy_witness" => {
-                    tracing::info!("set witness encoding for legacy mode");
-                    ret.legacy_witness_encoding = true;
+pub fn set_dynamic_feature(feats: &str) {
+    for feat_s in feats.split(':') {
+        match feat_s.trim().to_lowercase().as_str() {
+            "legacy_witness" => {
+                tracing::info!("set witness encoding for legacy mode");
+                unsafe {
+                    // the function is only called while initialize step
+                    LEGACY_WITNESS_ENCODING = true;
                 }
-                "openvm_13" => {
-                    tracing::info!("set prover should use openvm 13");
-                    ret.for_openvm_13_prover = true;
-                }
-                s => tracing::warn!("unrecognized dynamic feature: {s}"),
             }
+            s => tracing::warn!("unrecognized dynamic feature: {s}"),
         }
-        ret
     }
 }
 
@@ -59,54 +36,14 @@ impl FeatureOptions {
 /// task (with full witnesses)
 pub fn checkout_chunk_task(
     task_json: &str,
-    decryption_key: Option<&[u8]>,
     interpreter: impl ChunkInterpreter,
 ) -> eyre::Result<String> {
     let chunk_task = serde_json::from_str::<tasks::ChunkTask>(task_json)?;
-    Ok(serde_json::to_string(
-        &tasks::ChunkProvingTask::try_from_with_interpret(chunk_task, decryption_key, interpreter)?,
-    )?)
-}
-
-/// Convert the universal task json into compatible form for old prover
-pub fn univ_task_compatibility_fix(task_json: &str) -> eyre::Result<String> {
-    use scroll_zkvm_types::proof::VmInternalStarkProof;
-
-    let task: tasks::ProvingTask = serde_json::from_str(task_json)?;
-    let aggregated_proofs: Vec<VmInternalStarkProof> = task
-        .aggregated_proofs
-        .into_iter()
-        .map(|proof| VmInternalStarkProof {
-            proofs: proof.proofs,
-            public_values: proof.public_values,
-        })
-        .collect();
-
-    #[derive(Serialize)]
-    struct CompatibleProvingTask {
-        /// seralized witness which should be written into stdin first
-        pub serialized_witness: Vec<Vec<u8>>,
-        /// aggregated proof carried by babybear fields, should be written into stdin
-        /// followed `serialized_witness`
-        pub aggregated_proofs: Vec<VmInternalStarkProof>,
-        /// Fork name specify
-        pub fork_name: String,
-        /// The vk of app which is expcted to prove this task
-        pub vk: Vec<u8>,
-        /// An identifier assigned by coordinator, it should be kept identify for the
-        /// same task (for example, using chunk, batch and bundle hashes)
-        pub identifier: String,
-    }
-
-    let compatible_u_task = CompatibleProvingTask {
-        serialized_witness: task.serialized_witness,
-        aggregated_proofs,
-        fork_name: task.fork_name,
-        vk: task.vk,
-        identifier: task.identifier,
-    };
-
-    Ok(serde_json::to_string(&compatible_u_task)?)
+    let ret = serde_json::to_string(&tasks::ChunkProvingTask::try_from_with_interpret(
+        chunk_task,
+        interpreter,
+    )?)?;
+    Ok(ret)
 }
 
 /// Generate required staff for proving tasks
@@ -134,56 +71,35 @@ pub fn gen_universal_task(
             let mut task = serde_json::from_str::<ChunkProvingTask>(task_json)?;
             // normailze fork name field in task
             task.fork_name = task.fork_name.to_lowercase();
-            let version = Version::from(task.version);
             // always respect the fork_name_str (which has been normalized) being passed
             // if the fork_name wrapped in task is not match, consider it a malformed task
             if fork_name_str != task.fork_name.as_str() {
                 eyre::bail!("fork name in chunk task not match the calling arg, expected {fork_name_str}, get {}", task.fork_name);
             }
-            if fork_name_str != version.fork.as_str() {
-                eyre::bail!(
-                    "given task version, expected fork={fork_name_str}, got={version_fork}",
-                    version_fork = version.fork.as_str()
-                );
-            }
             let (pi_hash, metadata, u_task) =
-                utils::panic_catch(move || gen_universal_chunk_task(task))
+                utils::panic_catch(move || gen_universal_chunk_task(task, fork_name_str.into()))
                     .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
             (pi_hash, AnyMetaData::Chunk(metadata), u_task)
         }
         x if x == TaskType::Batch as i32 => {
             let mut task = serde_json::from_str::<BatchProvingTask>(task_json)?;
             task.fork_name = task.fork_name.to_lowercase();
-            let version = Version::from(task.version);
             if fork_name_str != task.fork_name.as_str() {
                 eyre::bail!("fork name in batch task not match the calling arg, expected {fork_name_str}, get {}", task.fork_name);
             }
-            if fork_name_str != version.fork.as_str() {
-                eyre::bail!(
-                    "given task version, expected fork={fork_name_str}, got={version_fork}",
-                    version_fork = version.fork.as_str()
-                );
-            }
             let (pi_hash, metadata, u_task) =
-                utils::panic_catch(move || gen_universal_batch_task(task))
+                utils::panic_catch(move || gen_universal_batch_task(task, fork_name_str.into()))
                     .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
             (pi_hash, AnyMetaData::Batch(metadata), u_task)
         }
         x if x == TaskType::Bundle as i32 => {
             let mut task = serde_json::from_str::<BundleProvingTask>(task_json)?;
             task.fork_name = task.fork_name.to_lowercase();
-            let version = Version::from(task.version);
             if fork_name_str != task.fork_name.as_str() {
                 eyre::bail!("fork name in bundle task not match the calling arg, expected {fork_name_str}, get {}", task.fork_name);
             }
-            if fork_name_str != version.fork.as_str() {
-                eyre::bail!(
-                    "given task version, expected fork={fork_name_str}, got={version_fork}",
-                    version_fork = version.fork.as_str()
-                );
-            }
             let (pi_hash, metadata, u_task) =
-                utils::panic_catch(move || gen_universal_bundle_task(task))
+                utils::panic_catch(move || gen_universal_bundle_task(task, fork_name_str.into()))
                     .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
             (pi_hash, AnyMetaData::Bundle(metadata), u_task)
         }
@@ -191,26 +107,11 @@ pub fn gen_universal_task(
     };
 
     u_task.vk = Vec::from(expected_vk);
-    let fork_name = u_task.fork_name.clone();
-    let mut u_task_ext = ProvingTaskExt::new(u_task);
-
-    // set additional settings from global features
-    if let Some(cfg) = ADDITIONAL_FEATURES
-        .get()
-        .and_then(|features| features.get(&fork_name))
-    {
-        u_task_ext.use_openvm_13 = cfg.for_openvm_13_prover;
-    } else {
-        tracing::warn!(
-            "can not found features setting for unrecognized fork {}",
-            fork_name
-        );
-    }
 
     Ok((
         pi_hash,
         serde_json::to_string(&metadata)?,
-        serde_json::to_string(&u_task_ext)?,
+        serde_json::to_string(&u_task)?,
     ))
 }
 
@@ -241,26 +142,7 @@ pub fn gen_wrapped_proof(proof_json: &str, metadata: &str, vk: &[u8]) -> eyre::R
 /// init verifier
 pub fn verifier_init(config: &str) -> eyre::Result<()> {
     let cfg: VerifierConfig = serde_json::from_str(config)?;
-    ADDITIONAL_FEATURES
-        .set(HashMap::from_iter(cfg.circuits.iter().map(|config| {
-            tracing::info!(
-                "start setting features [{:?}] for fork {}",
-                config.features,
-                config.fork_name
-            );
-            (
-                config.fork_name.to_lowercase(),
-                config
-                    .features
-                    .as_ref()
-                    .map(|features| FeatureOptions::new(features.as_str()))
-                    .unwrap_or_default(),
-            )
-        })))
-        .map_err(|c| eyre::eyre!("Fail to init additional features: {c:?}"))?;
-
     verifier::init(cfg);
-
     Ok(())
 }
 

crates/libzkp/src/proofs.rs

@@ -8,10 +8,9 @@ use scroll_zkvm_types::{
     bundle::BundleInfo,
     chunk::ChunkInfo,
     proof::{EvmProof, OpenVmEvmProof, ProofEnum, StarkProof},
-    public_inputs::MultiVersionPublicInputs,
+    public_inputs::{ForkName, MultiVersionPublicInputs},
     types_agg::AggregationInput,
     utils::{serialize_vk, vec_as_base64},
-    version,
 };
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
@@ -140,6 +139,8 @@ impl ProofMetadata for ChunkProofMetadata {
 pub struct BatchProofMetadata {
     /// The batch information describing the list of chunks.
     pub batch_info: BatchInfo,
+    /// The [`scroll_zkvm_types::batch::BatchHeader`]'s digest.
+    pub batch_hash: B256,
 }
 
 impl ProofMetadata for BatchProofMetadata {
@@ -180,13 +181,13 @@ impl<Metadata: ProofMetadata> WrappedProof<Metadata> {
     /// Sanity checks on the wrapped proof:
     ///
     /// - pi_hash computed in host does in fact match pi_hash computed in guest
-    pub fn pi_hash_check(&self, ver: version::Version) -> bool {
+    pub fn pi_hash_check(&self, fork_name: ForkName) -> bool {
         let proof_pi = self.proof.public_values();
 
         let expected_pi = self
             .metadata
             .pi_hash_info()
-            .pi_hash_by_version(ver)
+            .pi_hash_by_fork(fork_name)
             .0
             .as_ref()
             .iter()
@@ -215,7 +216,7 @@ impl<Metadata: ProofMetadata> PersistableProof for WrappedProof<Metadata> {
 mod tests {
     use base64::{prelude::BASE64_STANDARD, Engine};
     use sbv_primitives::B256;
-    use scroll_zkvm_types::{bundle::BundleInfo, proof::EvmProof};
+    use scroll_zkvm_types::{bundle::BundleInfo, proof::EvmProof, public_inputs::ForkName};
 
     use super::*;
 
@@ -251,9 +252,8 @@ mod tests {
                 batch_hash: B256::repeat_byte(4),
                 withdraw_root: B256::repeat_byte(5),
                 msg_queue_hash: B256::repeat_byte(6),
-                encryption_key: None,
             };
-            let bundle_pi_hash = bundle_info.pi_hash_euclidv1();
+            let bundle_pi_hash = bundle_info.pi_hash(ForkName::EuclidV1);
             BundleProofMetadata {
                 bundle_info,
                 bundle_pi_hash,

crates/libzkp/src/tasks.rs

@@ -10,62 +10,47 @@ pub use chunk_interpreter::ChunkInterpreter;
 pub use scroll_zkvm_types::task::ProvingTask;
 
 use crate::{
-    proofs::{BatchProofMetadata, BundleProofMetadata, ChunkProofMetadata},
+    proofs::{self, BatchProofMetadata, BundleProofMetadata, ChunkProofMetadata},
     utils::panic_catch,
 };
 use sbv_primitives::B256;
-use scroll_zkvm_types::public_inputs::{MultiVersionPublicInputs, Version};
+use scroll_zkvm_types::public_inputs::{ForkName, MultiVersionPublicInputs};
 
 fn encode_task_to_witness<T: serde::Serialize>(task: &T) -> eyre::Result<Vec<u8>> {
     let config = bincode::config::standard();
     Ok(bincode::serde::encode_to_vec(task, config)?)
 }
 
-fn check_aggregation_proofs<Metadata: MultiVersionPublicInputs>(
-    metadata: &[Metadata],
-    version: Version,
-) -> eyre::Result<()> {
+fn check_aggregation_proofs<Metadata>(
+    proofs: &[proofs::WrappedProof<Metadata>],
+    fork_name: ForkName,
+) -> eyre::Result<()>
+where
+    Metadata: proofs::ProofMetadata,
+{
     panic_catch(|| {
-        for w in metadata.windows(2) {
-            w[1].validate(&w[0], version);
+        for w in proofs.windows(2) {
+            w[1].metadata
+                .pi_hash_info()
+                .validate(w[0].metadata.pi_hash_info(), fork_name);
         }
     })
-    .map_err(|e| eyre::eyre!("Metadata validation failed: {}", e))?;
+    .map_err(|e| eyre::eyre!("Chunk data validation failed: {}", e))?;
 
     Ok(())
 }
 
-#[derive(serde::Deserialize, serde::Serialize)]
-pub struct ProvingTaskExt {
-    #[serde(flatten)]
-    task: ProvingTask,
-    #[serde(default)]
-    pub use_openvm_13: bool,
-}
-
-impl From<ProvingTaskExt> for ProvingTask {
-    fn from(wrap_t: ProvingTaskExt) -> Self {
-        wrap_t.task
-    }
-}
-
-impl ProvingTaskExt {
-    pub fn new(task: ProvingTask) -> Self {
-        Self {
-            task,
-            use_openvm_13: false,
-        }
-    }
-}
-
 /// Generate required staff for chunk proving
 pub fn gen_universal_chunk_task(
     task: ChunkProvingTask,
+    fork_name: ForkName,
 ) -> eyre::Result<(B256, ChunkProofMetadata, ProvingTask)> {
     let chunk_total_gas = task.stats().total_gas_used;
-    let (proving_task, chunk_info, chunk_pi_hash) = task.into_proving_task_with_precheck()?;
+    let chunk_info = task.precheck_and_build_metadata()?;
+    let proving_task = task.try_into()?;
+    let expected_pi_hash = chunk_info.pi_hash_by_fork(fork_name);
     Ok((
-        chunk_pi_hash,
+        expected_pi_hash,
         ChunkProofMetadata {
             chunk_info,
             chunk_total_gas,
@@ -77,11 +62,18 @@ pub fn gen_universal_chunk_task(
 /// Generate required staff for batch proving
 pub fn gen_universal_batch_task(
     task: BatchProvingTask,
+    fork_name: ForkName,
 ) -> eyre::Result<(B256, BatchProofMetadata, ProvingTask)> {
-    let (proving_task, batch_info, batch_pi_hash) = task.into_proving_task_with_precheck()?;
+    let batch_info = task.precheck_and_build_metadata()?;
+    let proving_task = task.try_into()?;
+    let expected_pi_hash = batch_info.pi_hash_by_fork(fork_name);
+
     Ok((
-        batch_pi_hash,
-        BatchProofMetadata { batch_info },
+        expected_pi_hash,
+        BatchProofMetadata {
+            batch_info,
+            batch_hash: expected_pi_hash,
+        },
         proving_task,
     ))
 }
@@ -89,13 +81,17 @@ pub fn gen_universal_batch_task(
 /// Generate required staff for bundle proving
 pub fn gen_universal_bundle_task(
     task: BundleProvingTask,
+    fork_name: ForkName,
 ) -> eyre::Result<(B256, BundleProofMetadata, ProvingTask)> {
-    let (proving_task, bundle_info, bundle_pi_hash) = task.into_proving_task_with_precheck()?;
+    let bundle_info = task.precheck_and_build_metadata()?;
+    let proving_task = task.try_into()?;
+    let expected_pi_hash = bundle_info.pi_hash_by_fork(fork_name);
+
     Ok((
-        bundle_pi_hash,
+        expected_pi_hash,
         BundleProofMetadata {
             bundle_info,
-            bundle_pi_hash,
+            bundle_pi_hash: expected_pi_hash,
         },
         proving_task,
     ))

crates/libzkp/src/tasks/batch.rs

@@ -1,92 +1,58 @@
+use crate::proofs::ChunkProof;
 use c_kzg::Bytes48;
 use eyre::Result;
 use sbv_primitives::{B256, U256};
 use scroll_zkvm_types::{
     batch::{
-        build_point_eval_witness, BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchHeaderValidium,
-        BatchInfo, BatchWitness, Envelope, EnvelopeV6, EnvelopeV7, LegacyBatchWitness,
+        build_point_eval_witness, BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchHeaderV8,
+        BatchInfo, BatchWitness, Envelope, EnvelopeV6, EnvelopeV7, EnvelopeV8, LegacyBatchWitness,
         ReferenceHeader, N_BLOB_BYTES,
     },
-    chunk::ChunkInfo,
-    public_inputs::{ForkName, MultiVersionPublicInputs, Version},
+    public_inputs::ForkName,
     task::ProvingTask,
     utils::{to_rkyv_bytes, RancorError},
-    version::{Codec, Domain, STFVersion},
 };
 
-use crate::proofs::ChunkProof;
-
 mod utils;
 use utils::{base64, point_eval};
 
-#[derive(Clone, serde::Deserialize, serde::Serialize)]
-pub struct BatchHeaderValidiumWithHash {
-    #[serde(flatten)]
-    header: BatchHeaderValidium,
-    batch_hash: B256,
-}
-
-/// Parse header types passed from golang side and adapt to the
-/// definition in zkvm-prover's types
-/// We distinguish the header type in golang side according to the STF
-/// version, i.e. v6, v7-v10 (current), and validium
-/// And adapt it to the corresponding batch header type used in zkvm-prover's witness
-/// definition, i.e. v6, v7 (current), and validium
+/// Define variable batch header type, since BatchHeaderV6 can not
+/// be decoded as V7 we can always has correct deserialization
+/// Notice: V6 header MUST be put above V7 since untagged enum
+/// try to decode each defination in order
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 #[serde(untagged)]
-#[allow(non_camel_case_types)]
 pub enum BatchHeaderV {
-    /// Header for validium mode.
-    Validium(BatchHeaderValidiumWithHash),
-    /// Header for scroll's STF version v6.
     V6(BatchHeaderV6),
-    /// Header for scroll's STF versions v7 - v10.
-    ///
-    /// Since the codec essentially is unchanged for the above STF versions, we do not define new
-    /// variants, instead re-using the [`BatchHeaderV7`] variant.
-    V7_to_V10(BatchHeaderV7),
-}
-
-impl core::fmt::Display for BatchHeaderV {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self {
-            BatchHeaderV::V6(_) => write!(f, "V6"),
-            BatchHeaderV::V7_to_V10(_) => write!(f, "V7 - V10"),
-            BatchHeaderV::Validium(_) => write!(f, "Validium"),
-        }
-    }
+    V7_8(BatchHeaderV7),
 }
 
 impl BatchHeaderV {
     pub fn batch_hash(&self) -> B256 {
         match self {
             BatchHeaderV::V6(h) => h.batch_hash(),
-            BatchHeaderV::V7_to_V10(h) => h.batch_hash(),
-            BatchHeaderV::Validium(h) => h.header.batch_hash(),
+            BatchHeaderV::V7_8(h) => h.batch_hash(),
         }
     }
 
-    pub fn to_zkvm_batch_header_v6(&self) -> &BatchHeaderV6 {
+    pub fn must_v6_header(&self) -> &BatchHeaderV6 {
         match self {
             BatchHeaderV::V6(h) => h,
-            _ => unreachable!("A header of {} is considered to be v6", self),
+            _ => panic!("try to pick other header type"),
         }
     }
 
-    pub fn to_zkvm_batch_header_v7_to_v10(&self) -> &BatchHeaderV7 {
+    pub fn must_v7_header(&self) -> &BatchHeaderV7 {
         match self {
-            BatchHeaderV::V7_to_V10(h) => h,
-            _ => unreachable!(
-                "A header of {} is considered to be in [v7, v8, v9, v10]",
-                self
-            ),
+            BatchHeaderV::V7_8(h) => h,
+            _ => panic!("try to pick other header type"),
         }
     }
 
-    pub fn to_zkvm_batch_header_validium(&self) -> &BatchHeaderValidium {
+    pub fn must_v8_header(&self) -> &BatchHeaderV8 {
         match self {
-            BatchHeaderV::Validium(h) => &h.header,
-            _ => unreachable!("A header of {} is considered to be validium", self),
+            BatchHeaderV::V7_8(h) => h,
+            _ => panic!("try to pick other header type"),
         }
     }
 }
@@ -95,8 +61,6 @@ impl BatchHeaderV {
 /// is compatible with both pre-euclidv2 and euclidv2
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 pub struct BatchProvingTask {
-    /// The version of the chunks in the batch, as per [`Version`].
-    pub version: u8,
     /// Chunk proofs for the contiguous list of chunks within the batch.
     pub chunk_proofs: Vec<ChunkProof>,
     /// The [`BatchHeaderV6/V7`], as computed on-chain for this batch.
@@ -115,253 +79,129 @@ pub struct BatchProvingTask {
     pub fork_name: String,
 }
 
-impl BatchProvingTask {
-    pub fn into_proving_task_with_precheck(self) -> Result<(ProvingTask, BatchInfo, B256)> {
-        let (witness, metadata, batch_pi_hash) = self.precheck()?;
-        let serialized_witness = if crate::witness_use_legacy_mode(&self.fork_name)? {
+impl TryFrom<BatchProvingTask> for ProvingTask {
+    type Error = eyre::Error;
+
+    fn try_from(value: BatchProvingTask) -> Result<Self> {
+        let witness = value.build_guest_input();
+        let serialized_witness = if crate::witness_use_legacy_mode() {
             let legacy_witness = LegacyBatchWitness::from(witness);
             to_rkyv_bytes::<RancorError>(&legacy_witness)?.into_vec()
         } else {
             super::encode_task_to_witness(&witness)?
         };
 
-        let proving_task = ProvingTask {
-            identifier: self.batch_header.batch_hash().to_string(),
-            fork_name: self.fork_name,
-            aggregated_proofs: self
+        Ok(ProvingTask {
+            identifier: value.batch_header.batch_hash().to_string(),
+            fork_name: value.fork_name,
+            aggregated_proofs: value
                 .chunk_proofs
                 .into_iter()
                 .map(|w_proof| w_proof.proof.into_stark_proof().expect("expect root proof"))
                 .collect(),
             serialized_witness: vec![serialized_witness],
             vk: Vec::new(),
-        };
-
-        Ok((proving_task, metadata, batch_pi_hash))
+        })
     }
+}
 
-    fn build_guest_input(&self, version: Version) -> BatchWitness {
-        tracing::info!(
-            "Handling batch task for input, version byte {}, Version data: {:?}",
-            self.version,
-            version
-        );
-        // sanity check for if result of header type parsing match to version
-        match &self.batch_header {
-            BatchHeaderV::Validium(_) => assert!(
-                version.is_validium(),
-                "version {:?} is not match with parsed header, get validium header but version is not validium", version,
-            ),
-            BatchHeaderV::V6(_) => assert_eq!(version.fork, ForkName::EuclidV1,
-                "hardfork mismatch for da-codec@v6 header: found={:?}, expected={:?}",
-                version.fork,
-                ForkName::EuclidV1,
-            ),
-            BatchHeaderV::V7_to_V10(_) => assert!(
-                matches!(version.fork, ForkName::EuclidV2 | ForkName::Feynman | ForkName::Galileo | ForkName::GalileoV2),
-                "hardfork mismatch for da-codec@v7/8/9/10 header: found={}, expected={:?}",
-                version.fork,
-                [ForkName::EuclidV2, ForkName::Feynman, ForkName::Galileo, ForkName::GalileoV2],
-            ),
-        }
+impl BatchProvingTask {
+    fn build_guest_input(&self) -> BatchWitness {
+        let fork_name = self.fork_name.to_lowercase().as_str().into();
 
-        let point_eval_witness = if !version.is_validium() {
-            // sanity check: calculate point eval needed and compare with task input
-            let (kzg_commitment, kzg_proof, challenge_digest) = {
-                let blob = point_eval::to_blob(&self.blob_bytes);
-                let commitment = point_eval::blob_to_kzg_commitment(&blob);
-                let versioned_hash = point_eval::get_versioned_hash(&commitment);
+        // sanity check: calculate point eval needed and compare with task input
+        let (kzg_commitment, kzg_proof, challenge_digest) = {
+            let blob = point_eval::to_blob(&self.blob_bytes);
+            let commitment = point_eval::blob_to_kzg_commitment(&blob);
+            let versioned_hash = point_eval::get_versioned_hash(&commitment);
+            let challenge_digest = match &self.batch_header {
+                BatchHeaderV::V6(_) => {
+                    assert_eq!(
+                        fork_name,
+                        ForkName::EuclidV1,
+                        "hardfork mismatch for da-codec@v6 header: found={fork_name:?}, expected={:?}",
+                        ForkName::EuclidV1,
+                    );
+                    EnvelopeV6::from_slice(self.blob_bytes.as_slice())
+                        .challenge_digest(versioned_hash)
+                }
+                BatchHeaderV::V7_8(_) => {
+                    let padded_blob_bytes = {
+                        let mut padded_blob_bytes = self.blob_bytes.to_vec();
+                        padded_blob_bytes.resize(N_BLOB_BYTES, 0);
+                        padded_blob_bytes
+                    };
 
-                let padded_blob_bytes = {
-                    let mut padded_blob_bytes = self.blob_bytes.to_vec();
-                    padded_blob_bytes.resize(N_BLOB_BYTES, 0);
-                    padded_blob_bytes
-                };
-                let challenge_digest = match version.codec {
-                    Codec::V6 => {
-                        // notice v6 do not use padded blob bytes
-                        <EnvelopeV6 as Envelope>::from_slice(self.blob_bytes.as_slice())
-                            .challenge_digest(versioned_hash)
+                    match fork_name {
+                        ForkName::EuclidV2 => {
+                            <EnvelopeV7 as Envelope>::from_slice(padded_blob_bytes.as_slice())
+                                .challenge_digest(versioned_hash)
+                        }
+                        ForkName::Feynman => {
+                            <EnvelopeV8 as Envelope>::from_slice(padded_blob_bytes.as_slice())
+                                .challenge_digest(versioned_hash)
+                        }
+                        f => unreachable!(
+                            "hardfork mismatch for da-codec@v7 header: found={}, expected={:?}",
+                            f,
+                            [ForkName::EuclidV2, ForkName::Feynman],
+                        ),
                     }
-                    Codec::V7 => <EnvelopeV7 as Envelope>::from_slice(padded_blob_bytes.as_slice())
-                        .challenge_digest(versioned_hash),
-                };
-                let (proof, _) = point_eval::get_kzg_proof(&blob, challenge_digest);
-
-                (commitment.to_bytes(), proof.to_bytes(), challenge_digest)
+                }
             };
 
-            if let Some(k) = self.kzg_commitment {
-                assert_eq!(k, kzg_commitment);
-            }
+            let (proof, _) = point_eval::get_kzg_proof(&blob, challenge_digest);
 
-            if let Some(c) = self.challenge_digest {
-                assert_eq!(c, U256::from_be_bytes(challenge_digest.0));
-            }
-
-            if let Some(p) = self.kzg_proof {
-                assert_eq!(p, kzg_proof);
-            }
-
-            Some(build_point_eval_witness(
-                kzg_commitment.into_inner(),
-                kzg_proof.into_inner(),
-            ))
-        } else {
-            assert!(self.kzg_proof.is_none(), "domain=validium has no blob-da");
-            assert!(
-                self.kzg_commitment.is_none(),
-                "domain=validium has no blob-da"
-            );
-            assert!(
-                self.challenge_digest.is_none(),
-                "domain=validium has no blob-da"
-            );
-
-            match &self.batch_header {
-                BatchHeaderV::Validium(h) => assert_eq!(
-                    h.header.batch_hash(),
-                    h.batch_hash,
-                    "calculated batch hash match which from coordinator"
-                ),
-                _ => panic!("unexpected header type"),
-            }
-            None
+            (commitment.to_bytes(), proof.to_bytes(), challenge_digest)
         };
 
-        let reference_header = match (version.domain, version.stf_version) {
-            (Domain::Scroll, STFVersion::V6) => {
-                ReferenceHeader::V6(*self.batch_header.to_zkvm_batch_header_v6())
-            }
-            // The da-codec for STF versions v7, v8, v9, v10 is identical. In zkvm-prover we do not
-            // create additional variants to indicate the identical behaviour of codec. Instead we
-            // add a separate variant for the STF version.
-            //
-            // We handle the different STF versions here however build the same batch header since
-            // that type does not change. The batch header's version byte constructed in the
-            // coordinator actually defines the STF version (v7, v8 or v9, v10) and we can derive
-            // the hard-fork (e.g. feynman or galileo) and the codec from the version
-            // byte.
-            //
-            // Refer [`scroll_zkvm_types::public_inputs::Version`].
-            (
-                Domain::Scroll,
-                STFVersion::V7 | STFVersion::V8 | STFVersion::V9 | STFVersion::V10,
-            ) => ReferenceHeader::V7_V8_V9(*self.batch_header.to_zkvm_batch_header_v7_to_v10()),
-            (Domain::Validium, STFVersion::V1) => {
-                ReferenceHeader::Validium(*self.batch_header.to_zkvm_batch_header_validium())
-            }
-            (domain, stf_version) => {
-                unreachable!("unsupported domain={domain:?},stf-version={stf_version:?}")
-            }
-        };
+        if let Some(k) = self.kzg_commitment {
+            assert_eq!(k, kzg_commitment);
+        }
 
-        // patch: ensure block_hash field is ZERO for scroll domain
-        let chunk_infos = self
-            .chunk_proofs
-            .iter()
-            .map(|p| {
-                if version.domain == Domain::Scroll {
-                    ChunkInfo {
-                        prev_blockhash: B256::ZERO,
-                        post_blockhash: B256::ZERO,
-                        ..p.metadata.chunk_info.clone()
-                    }
-                } else {
-                    p.metadata.chunk_info.clone()
-                }
-            })
-            .collect();
+        if let Some(c) = self.challenge_digest {
+            assert_eq!(c, U256::from_be_bytes(challenge_digest.0));
+        }
+
+        if let Some(p) = self.kzg_proof {
+            assert_eq!(p, kzg_proof);
+        }
+
+        let point_eval_witness = Some(build_point_eval_witness(
+            kzg_commitment.into_inner(),
+            kzg_proof.into_inner(),
+        ));
+
+        let reference_header = match fork_name {
+            ForkName::EuclidV1 => ReferenceHeader::V6(*self.batch_header.must_v6_header()),
+            ForkName::EuclidV2 => ReferenceHeader::V7(*self.batch_header.must_v7_header()),
+            ForkName::Feynman => ReferenceHeader::V8(*self.batch_header.must_v8_header()),
+        };
 
         BatchWitness {
-            version: version.as_version_byte(),
-            fork_name: version.fork,
+            fork_name,
             chunk_proofs: self.chunk_proofs.iter().map(|proof| proof.into()).collect(),
-            chunk_infos,
+            chunk_infos: self
+                .chunk_proofs
+                .iter()
+                .map(|p| p.metadata.chunk_info.clone())
+                .collect(),
             blob_bytes: self.blob_bytes.clone(),
             reference_header,
             point_eval_witness,
         }
     }
 
-    pub fn precheck(&self) -> Result<(BatchWitness, BatchInfo, B256)> {
+    pub fn precheck_and_build_metadata(&self) -> Result<BatchInfo> {
+        let fork_name = ForkName::from(self.fork_name.as_str());
         // for every aggregation task, there are two steps needed to build the metadata:
         // 1. generate data for metadata from the witness
         // 2. validate every adjacent proof pair
-        let version = Version::from(self.version);
-        let witness = self.build_guest_input(version);
+        let witness = self.build_guest_input();
         let metadata = BatchInfo::from(&witness);
-        super::check_aggregation_proofs(
-            witness.chunk_infos.as_slice(),
-            Version::from(self.version),
-        )?;
-        let pi_hash = metadata.pi_hash_by_version(version);
 
-        Ok((witness, metadata, pi_hash))
-    }
-}
-
-#[test]
-fn test_deserde_batch_header_v_validium() {
-    use std::str::FromStr;
-
-    // Top-level JSON: flattened enum tag "V1" + batch_hash
-    let json = r#"{
-        "V1": {
-        "version": 1,
-        "batch_index": 42,
-        "parent_batch_hash": "0x1111111111111111111111111111111111111111111111111111111111111111",
-        "post_state_root": "0x2222222222222222222222222222222222222222222222222222222222222222",
-        "withdraw_root": "0x3333333333333333333333333333333333333333333333333333333333333333",
-        "commitment": "0x4444444444444444444444444444444444444444444444444444444444444444"
-        },
-        "batch_hash": "0x5555555555555555555555555555555555555555555555555555555555555555"
-    }"#;
-
-    let parsed: BatchHeaderV = serde_json::from_str(json).expect("deserialize BatchHeaderV");
-
-    match parsed {
-        BatchHeaderV::Validium(v) => {
-            // Check the batch_hash field
-            let expected_batch_hash = B256::from_str(
-                "0x5555555555555555555555555555555555555555555555555555555555555555",
-            )
-            .unwrap();
-            assert_eq!(v.batch_hash, expected_batch_hash);
-
-            // Check the inner header variant and fields
-            match v.header {
-                BatchHeaderValidium::V1(h) => {
-                    assert_eq!(h.version, 1);
-                    assert_eq!(h.batch_index, 42);
-
-                    let p = B256::from_str(
-                        "0x1111111111111111111111111111111111111111111111111111111111111111",
-                    )
-                    .unwrap();
-                    let s = B256::from_str(
-                        "0x2222222222222222222222222222222222222222222222222222222222222222",
-                    )
-                    .unwrap();
-                    let w = B256::from_str(
-                        "0x3333333333333333333333333333333333333333333333333333333333333333",
-                    )
-                    .unwrap();
-                    let c = B256::from_str(
-                        "0x4444444444444444444444444444444444444444444444444444444444444444",
-                    )
-                    .unwrap();
-
-                    assert_eq!(h.parent_batch_hash, p);
-                    assert_eq!(h.post_state_root, s);
-                    assert_eq!(h.withdraw_root, w);
-                    assert_eq!(h.commitment, c);
-
-                    // Sanity: computed batch hash equals the provided one (if method available)
-                    // assert_eq!(v.header.batch_hash(), expected_batch_hash);
-                }
-            }
-        }
-        _ => panic!("expected validium header variant"),
+        super::check_aggregation_proofs(self.chunk_proofs.as_slice(), fork_name)?;
+
+        Ok(metadata)
     }
 }

crates/libzkp/src/tasks/bundle.rs

@@ -1,22 +1,17 @@
+use crate::proofs::BatchProof;
 use eyre::Result;
-use sbv_primitives::B256;
 use scroll_zkvm_types::{
-    bundle::{BundleInfo, BundleWitness, LegacyBundleWitness},
-    public_inputs::{MultiVersionPublicInputs, Version},
+    bundle::{BundleInfo, BundleWitness},
+    public_inputs::ForkName,
     task::ProvingTask,
     utils::{to_rkyv_bytes, RancorError},
 };
 
-use crate::proofs::BatchProof;
-
 /// Message indicating a sanity check failure.
 const BUNDLE_SANITY_MSG: &str = "bundle must have at least one batch";
 
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 pub struct BundleProvingTask {
-    /// The version of batches in the bundle.
-    pub version: u8,
-    /// The STARK proofs of each batch in the bundle.
     pub batch_proofs: Vec<BatchProof>,
     /// for sanity check
     pub bundle_info: Option<BundleInfo>,
@@ -25,30 +20,6 @@ pub struct BundleProvingTask {
 }
 
 impl BundleProvingTask {
-    pub fn into_proving_task_with_precheck(self) -> Result<(ProvingTask, BundleInfo, B256)> {
-        let (witness, bundle_info, bundle_pi_hash) = self.precheck()?;
-        let serialized_witness = if crate::witness_use_legacy_mode(&self.fork_name)? {
-            let legacy = LegacyBundleWitness::from(witness);
-            to_rkyv_bytes::<RancorError>(&legacy)?.into_vec()
-        } else {
-            super::encode_task_to_witness(&witness)?
-        };
-
-        let proving_task = ProvingTask {
-            identifier: self.identifier(),
-            fork_name: self.fork_name,
-            aggregated_proofs: self
-                .batch_proofs
-                .into_iter()
-                .map(|w_proof| w_proof.proof.into_stark_proof().expect("expect root proof"))
-                .collect(),
-            serialized_witness: vec![serialized_witness],
-            vk: Vec::new(),
-        };
-
-        Ok((proving_task, bundle_info, bundle_pi_hash))
-    }
-
     fn identifier(&self) -> String {
         assert!(!self.batch_proofs.is_empty(), "{BUNDLE_SANITY_MSG}",);
 
@@ -57,45 +28,64 @@ impl BundleProvingTask {
                 .first()
                 .expect(BUNDLE_SANITY_MSG)
                 .metadata
-                .batch_info
                 .batch_hash,
             self.batch_proofs
                 .last()
                 .expect(BUNDLE_SANITY_MSG)
                 .metadata
-                .batch_info
                 .batch_hash,
         );
 
         format!("{first}-{last}")
     }
 
-    fn build_guest_input(&self, version: Version) -> BundleWitness {
+    fn build_guest_input(&self) -> BundleWitness {
         BundleWitness {
-            version: version.as_version_byte(),
             batch_proofs: self.batch_proofs.iter().map(|proof| proof.into()).collect(),
             batch_infos: self
                 .batch_proofs
                 .iter()
                 .map(|wrapped_proof| wrapped_proof.metadata.batch_info.clone())
                 .collect(),
-            fork_name: version.fork,
+            fork_name: self.fork_name.to_lowercase().as_str().into(),
         }
     }
 
-    fn precheck(&self) -> Result<(BundleWitness, BundleInfo, B256)> {
+    pub fn precheck_and_build_metadata(&self) -> Result<BundleInfo> {
+        let fork_name = ForkName::from(self.fork_name.as_str());
         // for every aggregation task, there are two steps needed to build the metadata:
         // 1. generate data for metadata from the witness
         // 2. validate every adjacent proof pair
-        let version = Version::from(self.version);
-        let witness = self.build_guest_input(version);
+        let witness = self.build_guest_input();
         let metadata = BundleInfo::from(&witness);
-        super::check_aggregation_proofs(
-            witness.batch_infos.as_slice(),
-            Version::from(self.version),
-        )?;
-        let pi_hash = metadata.pi_hash_by_version(version);
 
-        Ok((witness, metadata, pi_hash))
+        super::check_aggregation_proofs(self.batch_proofs.as_slice(), fork_name)?;
+
+        Ok(metadata)
+    }
+}
+
+impl TryFrom<BundleProvingTask> for ProvingTask {
+    type Error = eyre::Error;
+
+    fn try_from(value: BundleProvingTask) -> Result<Self> {
+        let witness = value.build_guest_input();
+        let serialized_witness = if crate::witness_use_legacy_mode() {
+            to_rkyv_bytes::<RancorError>(&witness)?.into_vec()
+        } else {
+            super::encode_task_to_witness(&witness)?
+        };
+
+        Ok(ProvingTask {
+            identifier: value.identifier(),
+            fork_name: value.fork_name,
+            aggregated_proofs: value
+                .batch_proofs
+                .into_iter()
+                .map(|w_proof| w_proof.proof.into_stark_proof().expect("expect root proof"))
+                .collect(),
+            serialized_witness: vec![serialized_witness],
+            vk: Vec::new(),
+        })
     }
 }

crates/libzkp/src/tasks/chunk.rs

@@ -1,26 +1,20 @@
+use super::chunk_interpreter::*;
 use eyre::Result;
 use sbv_core::BlockWitness;
-use sbv_primitives::{types::consensus::BlockHeader, B256};
+use sbv_primitives::B256;
 use scroll_zkvm_types::{
-    chunk::{execute, ChunkInfo, ChunkWitness, LegacyChunkWitness, ValidiumInputs},
-    public_inputs::{MultiVersionPublicInputs, Version},
+    chunk::{execute, ChunkInfo, ChunkWitness, LegacyChunkWitness},
     task::ProvingTask,
     utils::{to_rkyv_bytes, RancorError},
 };
 
-use super::chunk_interpreter::*;
-
 /// The type aligned with coordinator's defination
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ChunkTask {
-    /// The version for the chunk, as per [`Version`].
-    pub version: u8,
     /// block hashes for a series of block
     pub block_hashes: Vec<B256>,
     /// The on-chain L1 msg queue hash before applying L1 msg txs from the chunk.
     pub prev_msg_queue_hash: B256,
-    /// The on-chain L1 msg queue hash after applying L1 msg txs from the chunk (for validate)
-    pub post_msg_queue_hash: B256,
     /// Fork name specify
     pub fork_name: String,
 }
@@ -28,7 +22,6 @@ pub struct ChunkTask {
 impl TryFromWithInterpreter<ChunkTask> for ChunkProvingTask {
     fn try_from_with_interpret(
         value: ChunkTask,
-        decryption_key: Option<&[u8]>,
         interpreter: impl ChunkInterpreter,
     ) -> Result<Self> {
         let mut block_witnesses = Vec::new();
@@ -38,28 +31,10 @@ impl TryFromWithInterpreter<ChunkTask> for ChunkProvingTask {
             block_witnesses.push(witness);
         }
 
-        let validium_txs = if Version::from(value.version).is_validium() {
-            let mut validium_txs = Vec::new();
-            for block_number in block_witnesses.iter().map(|w| w.header.number()) {
-                validium_txs.push(interpreter.try_fetch_l1_msgs(block_number)?);
-            }
-            validium_txs
-        } else {
-            vec![]
-        };
-
-        let validium_inputs = decryption_key.map(|secret_key| ValidiumInputs {
-            validium_txs,
-            secret_key: secret_key.into(),
-        });
-
         Ok(Self {
-            version: value.version,
             block_witnesses,
             prev_msg_queue_hash: value.prev_msg_queue_hash,
-            post_msg_queue_hash: value.post_msg_queue_hash,
             fork_name: value.fork_name,
-            validium_inputs,
         })
     }
 }
@@ -73,18 +48,12 @@ const CHUNK_SANITY_MSG: &str = "chunk must have at least one block";
 /// - {first_block_number}-{last_block_number}
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
 pub struct ChunkProvingTask {
-    /// The version for the chunk, as per [Version][scroll_zkvm_types::version::Version].
-    pub version: u8,
     /// Witnesses for every block in the chunk.
     pub block_witnesses: Vec<BlockWitness>,
     /// The on-chain L1 msg queue hash before applying L1 msg txs from the chunk.
     pub prev_msg_queue_hash: B256,
-    /// The on-chain L1 msg queue hash after applying L1 msg txs from the chunk (for validate)
-    pub post_msg_queue_hash: B256,
     /// Fork name specify
     pub fork_name: String,
-    /// Optional inputs in case of domain=validium.
-    pub validium_inputs: Option<ValidiumInputs>,
 }
 
 #[derive(Clone, Debug)]
@@ -94,6 +63,28 @@ pub struct ChunkDetails {
     pub total_gas_used: u64,
 }
 
+impl TryFrom<ChunkProvingTask> for ProvingTask {
+    type Error = eyre::Error;
+
+    fn try_from(value: ChunkProvingTask) -> Result<Self> {
+        let witness = value.build_guest_input();
+        let serialized_witness = if crate::witness_use_legacy_mode() {
+            let legacy_witness = LegacyChunkWitness::from(witness);
+            to_rkyv_bytes::<RancorError>(&legacy_witness)?.into_vec()
+        } else {
+            super::encode_task_to_witness(&witness)?
+        };
+
+        Ok(ProvingTask {
+            identifier: value.identifier(),
+            fork_name: value.fork_name,
+            aggregated_proofs: Vec::new(),
+            serialized_witness: vec![serialized_witness],
+            vk: Vec::new(),
+        })
+    }
+}
+
 impl ChunkProvingTask {
     pub fn stats(&self) -> ChunkDetails {
         let num_blocks = self.block_witnesses.len();
@@ -115,26 +106,6 @@ impl ChunkProvingTask {
         }
     }
 
-    pub fn into_proving_task_with_precheck(self) -> Result<(ProvingTask, ChunkInfo, B256)> {
-        let (witness, chunk_info, chunk_pi_hash) = self.precheck()?;
-        let serialized_witness = if crate::witness_use_legacy_mode(&self.fork_name)? {
-            let legacy_witness = LegacyChunkWitness::from(witness);
-            to_rkyv_bytes::<RancorError>(&legacy_witness)?.into_vec()
-        } else {
-            super::encode_task_to_witness(&witness)?
-        };
-
-        let proving_task = ProvingTask {
-            identifier: self.identifier(),
-            fork_name: self.fork_name,
-            aggregated_proofs: Vec::new(),
-            serialized_witness: vec![serialized_witness],
-            vk: Vec::new(),
-        };
-
-        Ok((proving_task, chunk_info, chunk_pi_hash))
-    }
-
     fn identifier(&self) -> String {
         assert!(!self.block_witnesses.is_empty(), "{CHUNK_SANITY_MSG}",);
 
@@ -154,37 +125,23 @@ impl ChunkProvingTask {
         format!("{first}-{last}")
     }
 
-    fn build_guest_input(&self, version: Version) -> ChunkWitness {
-        if version.is_validium() {
-            assert!(self.validium_inputs.is_some());
-            ChunkWitness::new(
-                version.as_version_byte(),
-                &self.block_witnesses,
-                self.prev_msg_queue_hash,
-                version.fork,
-                self.validium_inputs.clone(),
-            )
-        } else {
-            ChunkWitness::new_scroll(
-                version.as_version_byte(),
-                &self.block_witnesses,
-                self.prev_msg_queue_hash,
-                version.fork,
-            )
-        }
+    fn build_guest_input(&self) -> ChunkWitness {
+        ChunkWitness::new(
+            &self.block_witnesses,
+            self.prev_msg_queue_hash,
+            self.fork_name.to_lowercase().as_str().into(),
+        )
     }
 
     fn insert_state(&mut self, node: sbv_primitives::Bytes) {
         self.block_witnesses[0].states.push(node);
     }
 
-    fn precheck(&self) -> Result<(ChunkWitness, ChunkInfo, B256)> {
-        let version = Version::from(self.version);
-        let witness = self.build_guest_input(version);
-        let chunk_info = ChunkInfo::try_from(witness.clone()).map_err(|e| eyre::eyre!("{e}"))?;
-        assert_eq!(chunk_info.post_msg_queue_hash, self.post_msg_queue_hash);
-        let chunk_pi_hash = chunk_info.pi_hash_by_version(version);
-        Ok((witness, chunk_info, chunk_pi_hash))
+    pub fn precheck_and_build_metadata(&self) -> Result<ChunkInfo> {
+        let witness = self.build_guest_input();
+
+        let ret = ChunkInfo::try_from(witness).map_err(|e| eyre::eyre!("{e}"))?;
+        Ok(ret)
     }
 
     /// this method check the validate of current task (there may be missing storage node)
@@ -212,7 +169,7 @@ impl ChunkProvingTask {
         let err_parse_re = regex::Regex::new(pattern)?;
         let mut attempts = 0;
         loop {
-            let witness = self.build_guest_input(Version::euclid_v2());
+            let witness = self.build_guest_input();
 
             match execute(witness) {
                 Ok(_) => return Ok(()),

crates/libzkp/src/tasks/chunk_interpreter.rs

@@ -1,6 +1,6 @@
 use eyre::Result;
 use sbv_core::BlockWitness;
-use sbv_primitives::{types::consensus::TxL1Message, Bytes, B256};
+use sbv_primitives::{Bytes, B256};
 
 /// An interpreter which is cirtical in translating chunk data
 /// since we need to grep block witness and storage node data
@@ -13,22 +13,13 @@ pub trait ChunkInterpreter {
     ) -> Result<BlockWitness> {
         Err(eyre::eyre!("no implement"))
     }
-
     fn try_fetch_storage_node(&self, _node_hash: B256) -> Result<Bytes> {
         Err(eyre::eyre!("no implement"))
     }
-
-    fn try_fetch_l1_msgs(&self, _block_number: u64) -> Result<Vec<TxL1Message>> {
-        Err(eyre::eyre!("no implement"))
-    }
 }
 
 pub trait TryFromWithInterpreter<T>: Sized {
-    fn try_from_with_interpret(
-        value: T,
-        decryption_key: Option<&[u8]>,
-        intepreter: impl ChunkInterpreter,
-    ) -> Result<Self>;
+    fn try_from_with_interpret(value: T, intepreter: impl ChunkInterpreter) -> Result<Self>;
 }
 
 pub struct DummyInterpreter {}

crates/libzkp/src/verifier.rs

@@ -41,11 +41,8 @@ pub trait ProofVerifier {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct CircuitConfig {
-    pub version: u8,
     pub fork_name: String,
     pub assets_path: String,
-    #[serde(default)]
-    pub features: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -53,7 +50,7 @@ pub struct VerifierConfig {
     pub circuits: Vec<CircuitConfig>,
 }
 
-pub(crate) type HardForkName = String;
+type HardForkName = String;
 
 type VerifierType = Arc<Mutex<dyn ProofVerifier + Send>>;
 static VERIFIERS: OnceLock<HashMap<HardForkName, VerifierType>> = OnceLock::new();
@@ -64,18 +61,14 @@ pub fn init(config: VerifierConfig) {
     for cfg in &config.circuits {
         let canonical_fork_name = cfg.fork_name.to_lowercase();
 
-        let verifier = Verifier::new(&cfg.assets_path, cfg.version);
+        let verifier = Verifier::new(&cfg.assets_path, canonical_fork_name.as_str().into());
         let ret = verifiers.insert(canonical_fork_name, Arc::new(Mutex::new(verifier)));
         assert!(
             ret.is_none(),
             "DO NOT init the same fork {} twice",
             cfg.fork_name
         );
-        tracing::info!(
-            "load verifier config for fork {} (ver {})",
-            cfg.fork_name,
-            cfg.version
-        );
+        tracing::info!("load verifier config for fork {}", cfg.fork_name);
     }
 
     let ret = VERIFIERS.set(verifiers).is_ok();

crates/libzkp/src/verifier/universal.rs

@@ -6,22 +6,22 @@ use crate::{
     proofs::{AsRootProof, BatchProof, BundleProof, ChunkProof, IntoEvmProof},
     utils::panic_catch,
 };
-use scroll_zkvm_types::version::Version;
+use scroll_zkvm_types::public_inputs::ForkName;
 use scroll_zkvm_verifier::verifier::UniversalVerifier;
 use std::path::Path;
 
 pub struct Verifier {
     verifier: UniversalVerifier,
-    version: Version,
+    fork: ForkName,
 }
 
 impl Verifier {
-    pub fn new(assets_dir: &str, ver_n: u8) -> Self {
+    pub fn new(assets_dir: &str, fork: ForkName) -> Self {
         let verifier_bin = Path::new(assets_dir);
 
         Self {
             verifier: UniversalVerifier::setup(verifier_bin).expect("Setting up chunk verifier"),
-            version: Version::from(ver_n),
+            fork,
         }
     }
 }
@@ -31,21 +31,21 @@ impl ProofVerifier for Verifier {
         panic_catch(|| match task_type {
             TaskType::Chunk => {
                 let proof = serde_json::from_slice::<ChunkProof>(proof).unwrap();
-                assert!(proof.pi_hash_check(self.version));
+                assert!(proof.pi_hash_check(self.fork));
                 self.verifier
                     .verify_stark_proof(proof.as_root_proof(), &proof.vk)
                     .unwrap()
             }
             TaskType::Batch => {
                 let proof = serde_json::from_slice::<BatchProof>(proof).unwrap();
-                assert!(proof.pi_hash_check(self.version));
+                assert!(proof.pi_hash_check(self.fork));
                 self.verifier
                     .verify_stark_proof(proof.as_root_proof(), &proof.vk)
                     .unwrap()
             }
             TaskType::Bundle => {
                 let proof = serde_json::from_slice::<BundleProof>(proof).unwrap();
-                assert!(proof.pi_hash_check(self.version));
+                assert!(proof.pi_hash_check(self.fork));
                 let vk = proof.vk.clone();
                 let evm_proof = proof.into_evm_proof();
                 self.verifier.verify_evm_proof(&evm_proof, &vk).unwrap()

crates/libzkp_c/src/lib.rs

@@ -152,28 +152,11 @@ pub unsafe extern "C" fn gen_universal_task(
     fork_name: *const c_char,
     expected_vk: *const u8,
     expected_vk_len: usize,
-    decryption_key: *const u8,
-    decryption_key_len: usize,
 ) -> HandlingResult {
     let task_json = if task_type == TaskType::Chunk as i32 {
         let pre_task_str = c_char_to_str(task);
         let cli = l2geth::get_client();
-        let decryption_key = if decryption_key_len > 0 {
-            if decryption_key_len != 32 {
-                tracing::error!(
-                    "gen_universal_task received {}-byte decryption key; expected 32",
-                    decryption_key_len
-                );
-                return failed_handling_result();
-            }
-            Some(std::slice::from_raw_parts(
-                decryption_key,
-                decryption_key_len,
-            ))
-        } else {
-            None
-        };
-        match libzkp::checkout_chunk_task(pre_task_str, decryption_key, cli) {
+        match libzkp::checkout_chunk_task(pre_task_str, cli) {
             Ok(str) => str,
             Err(e) => {
                 tracing::error!("gen_universal_task failed at pre interpret step, error: {e}");
@@ -255,19 +238,6 @@ pub unsafe extern "C" fn gen_wrapped_proof(
     }
 }
 
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn univ_task_compatibility_fix(task_json: *const c_char) -> *mut c_char {
-    let task_json_str = c_char_to_str(task_json);
-    match libzkp::univ_task_compatibility_fix(task_json_str) {
-        Ok(result) => CString::new(result).unwrap().into_raw(),
-        Err(e) => {
-            tracing::error!("univ_task_compability_fix failed, error: {:#}", e);
-            std::ptr::null_mut()
-        }
-    }
-}
-
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn release_string(ptr: *mut c_char) {
@@ -275,3 +245,10 @@ pub unsafe extern "C" fn release_string(ptr: *mut c_char) {
         let _ = CString::from_raw(ptr);
     }
 }
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn set_dynamic_feature(feats: *const c_char) {
+    let feats_str = c_char_to_str(feats);
+    libzkp::set_dynamic_feature(feats_str);
+}

crates/prover-bin/Cargo.toml

@@ -8,8 +8,7 @@ edition.workspace = true
 [dependencies]
 scroll-zkvm-types.workspace = true
 scroll-zkvm-prover.workspace = true
-libzkp = { path = "../libzkp"}
-scroll-proving-sdk = { git = "https://github.com/scroll-tech/scroll-proving-sdk.git", rev = "05648db" }
+scroll-proving-sdk = { git = "https://github.com/scroll-tech/scroll-proving-sdk.git", rev = "4c36ab2" }
 serde.workspace = true
 serde_json.workspace = true
 once_cell.workspace =true

crates/prover-bin/assets_url_preset.json

@@ -2,9 +2,6 @@
     "feynman": {
         "b68fdc3f28a5ce006280980df70cd3447e56913e5bca6054603ba85f0794c23a6618ea25a7991845bbc5fd571670ee47379ba31ace92d345bca59702a0d4112d": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.5.2/chunk/",
         "9a3f66370f11e3303f1a1248921025104e83253efea43a70d221cf4e15fc145bf2be2f4468d1ac4a70e7682babb1c60417e21c7633d4b55b58f44703ec82b05a": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.5.2/batch/",
-        "1f8627277e1c1f6e1cc70c03e6fde06929e5ea27ca5b1d56e23b235dfeda282e22c0e5294bcb1b3a9def836f8d0f18612a9860629b9497292976ca11844b7e73": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.5.2/bundle/",
-        "7eb91f1885cc7a63cc848928f043fa56bf747161a74cd933d88c0456b90643346618ea25a7991845bbc5fd571670ee47379ba31ace92d345bca59702a0d4112d": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.6.0-rc.1/chunk/",
-        "dc653e7416628c612fa4d80b4724002bad4fde3653aef7316b80df0c19740a1bf2be2f4468d1ac4a70e7682babb1c60417e21c7633d4b55b58f44703ec82b05a": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.6.0-rc.1/batch/",
-        "14de1c74b663ed3c99acb03e90a5753b5923233c5c590864ad7746570297d16722c0e5294bcb1b3a9def836f8d0f18612a9860629b9497292976ca11844b7e73": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.6.0-rc.1/bundle/"
+        "1f8627277e1c1f6e1cc70c03e6fde06929e5ea27ca5b1d56e23b235dfeda282e22c0e5294bcb1b3a9def836f8d0f18612a9860629b9497292976ca11844b7e73": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.5.2/bundle/"
     }
 }

crates/prover-bin/src/prover.rs

@@ -12,7 +12,6 @@ use scroll_proving_sdk::{
         ProvingService,
     },
 };
-use scroll_zkvm_types::ProvingTask;
 use serde::{Deserialize, Serialize};
 use std::{
     collections::HashMap,
@@ -144,6 +143,7 @@ impl LocalProverConfig {
 
 #[derive(Clone, Serialize, Deserialize)]
 pub struct CircuitConfig {
+    pub hard_fork_name: String,
     /// The path to save assets for a specified hard fork phase
     pub workspace_path: String,
     #[serde(flatten)]
@@ -273,8 +273,6 @@ impl LocalProver {
         let created_at = duration.as_secs() as f64 + duration.subsec_nanos() as f64 * 1e-9;
 
         let prover_task = UniversalHandler::get_task_from_input(&req.input)?;
-        let is_openvm_13 = prover_task.use_openvm_13;
-        let prover_task: ProvingTask = prover_task.into();
         let vk = hex::encode(&prover_task.vk);
         let handler = if let Some(handler) = self.handlers.get(&vk) {
             handler.clone()
@@ -302,7 +300,7 @@ impl LocalProver {
                 .await?;
             let circuits_handler = Arc::new(Mutex::new(UniversalHandler::new(
                 &asset_path,
-                is_openvm_13,
+                req.proof_type,
             )?));
             self.handlers.insert(vk, circuits_handler.clone());
             circuits_handler

crates/prover-bin/src/zk_circuits_handler/universal.rs

@@ -3,7 +3,7 @@ use std::path::Path;
 use super::CircuitsHandler;
 use async_trait::async_trait;
 use eyre::Result;
-use libzkp::ProvingTaskExt;
+use scroll_proving_sdk::prover::ProofType;
 use scroll_zkvm_prover::{Prover, ProverConfig};
 use scroll_zkvm_types::ProvingTask;
 use tokio::sync::Mutex;
@@ -16,15 +16,14 @@ pub struct UniversalHandler {
 unsafe impl Send for UniversalHandler {}
 
 impl UniversalHandler {
-    pub fn new(workspace_path: impl AsRef<Path>, is_openvm_v13: bool) -> Result<Self> {
+    pub fn new(workspace_path: impl AsRef<Path>, _proof_type: ProofType) -> Result<Self> {
         let path_app_exe = workspace_path.as_ref().join("app.vmexe");
         let path_app_config = workspace_path.as_ref().join("openvm.toml");
-        let segment_len = Some((1 << 21) - 100);
+        let segment_len = Some((1 << 22) - 100);
         let config = ProverConfig {
             path_app_config,
             path_app_exe,
             segment_len,
-            is_openvm_v13,
         };
 
         let prover = Prover::setup(config, None)?;
@@ -37,7 +36,7 @@ impl UniversalHandler {
         &mut self.prover
     }
 
-    pub fn get_task_from_input(input: &str) -> Result<ProvingTaskExt> {
+    pub fn get_task_from_input(input: &str) -> Result<ProvingTask> {
         Ok(serde_json::from_str(input)?)
     }
 }

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.20251128092113-8629f088d78f
+	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
 )
@@ -34,9 +34,11 @@ require (
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	go.opentelemetry.io/otel/trace v1.24.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
 	golang.org/x/sync v0.11.0 // indirect
 	golang.org/x/sys v0.30.0 // indirect
-	golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect
+	golang.org/x/text v0.21.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20231127180814-3a041ad873d4 // indirect
 	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect

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.20251128092113-8629f088d78f h1:j6SjP98MoWFFX9TwB1/nFYEkayqHQsrtE66Ll2C+oT0=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f/go.mod h1:Aa/kD1XB+OV/7rRxMQrjcPCB4b0pKyLH0gsTrtuHi38=
+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=

go.work.sum

@@ -731,9 +731,8 @@ github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:
 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=
@@ -793,7 +792,6 @@ github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS3
 github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
 github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0=
 github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
-github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
 github.com/deepmap/oapi-codegen v1.6.0 h1:w/d1ntwh91XI0b/8ja7+u5SvA4IFfM0UNNLmiDR1gg0=
@@ -1201,7 +1199,6 @@ github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0
 github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
 github.com/labstack/gommon v0.3.1/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
 github.com/labstack/gommon v0.4.0/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
-github.com/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=
@@ -1412,15 +1409,11 @@ github.com/scroll-tech/da-codec v0.1.3-0.20250609113414-f33adf0904bd/go.mod h1:g
 github.com/scroll-tech/da-codec v0.1.3-0.20250609154559-8935de62c148 h1:cyK1ifU2fRoMl8YWR9LOsZK4RvJnlG3RODgakj5I8VY=
 github.com/scroll-tech/da-codec v0.1.3-0.20250609154559-8935de62c148/go.mod h1:gz5x3CsLy5htNTbv4PWRPBU9nSAujfx1U2XtFcXoFuk=
 github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
-github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
-github.com/scroll-tech/ecies-go/v2 v2.0.10-beta.1/go.mod h1:A+pHaITd+ogBm4Rk35xebF9OPiyMYlFlgqBOiY5PSjg=
 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.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/scroll-tech/go-ethereum v1.10.14-0.20251128092359-25d5bf6b817b h1:pMQKnroJoS/FeL1aOWkz7/u1iBHUP8PWjZstNuzoUGE=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092359-25d5bf6b817b/go.mod h1:Aa/kD1XB+OV/7rRxMQrjcPCB4b0pKyLH0gsTrtuHi38=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 h1:nn5Wsu0esKSJiIVhscUtVbo7ada43DJhG55ua/hjS5I=
 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=
@@ -1618,7 +1611,6 @@ golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOM
 golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
-golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
 golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -1640,7 +1632,6 @@ golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTk
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3 h1:XQyxROzUlZH+WIQwySDgnISgOivlhjIEwaQaJEJrrN0=
 golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f h1:J5lckAjkw6qYlOZNj90mLYNTEKDvWeuc1yieZ8qUzUE=
 golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
@@ -1790,7 +1781,6 @@ golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2 h1:IRJeR9r1pYWsHKTRe/IInb7lYvbBVIqOgsX/u0mbOWY=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
@@ -1799,7 +1789,6 @@ golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
 golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
 golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
-golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=

rollup/cmd/gas_oracle/app/app.go

@@ -66,26 +66,17 @@ func action(ctx *cli.Context) error {
 	registry := prometheus.DefaultRegisterer
 	observability.Server(ctx, db)
 
-	// Init L1 connection
-	l1RpcClient, err := rpc.Dial(cfg.L1Config.Endpoint)
+	l1client, err := ethclient.Dial(cfg.L1Config.Endpoint)
 	if err != nil {
-		log.Crit("failed to dial raw RPC client to L1 endpoint", "endpoint", cfg.L1Config.Endpoint, "error", err)
-	}
-	l1client := ethclient.NewClient(l1RpcClient)
-
-	// sanity check config
-	if cfg.L1Config.RelayerConfig.GasOracleConfig.L1BaseFeeLimit == 0 || cfg.L1Config.RelayerConfig.GasOracleConfig.L1BlobBaseFeeLimit == 0 {
-		log.Crit("gas-oracle `l1_base_fee_limit` and `l1_blob_base_fee_limit` configs must be set")
+		log.Crit("failed to connect l1 geth", "config file", cfgFile, "error", err)
 	}
 
-	// Init watcher and relayer
-	l1watcher := watcher.NewL1WatcherClient(ctx.Context, l1RpcClient, cfg.L1Config.StartHeight, db, registry)
+	l1watcher := watcher.NewL1WatcherClient(ctx.Context, l1client, cfg.L1Config.StartHeight, db, registry)
 
 	l1relayer, err := relayer.NewLayer1Relayer(ctx.Context, db, cfg.L1Config.RelayerConfig, relayer.ServiceTypeL1GasOracle, registry)
 	if err != nil {
 		log.Crit("failed to create new l1 relayer", "config file", cfgFile, "error", err)
 	}
-
 	// Start l1 watcher process
 	go utils.LoopWithContext(subCtx, 10*time.Second, func(ctx context.Context) {
 		// Fetch the latest block number to decrease the delay when fetching gas prices

rollup/cmd/permissionless_batches/app/app.go

@@ -10,8 +10,8 @@ import (
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/urfave/cli/v2"
 
+	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/scroll-tech/go-ethereum/rpc"
 
 	"scroll-tech/common/database"
 	"scroll-tech/common/observability"
@@ -91,13 +91,12 @@ func action(ctx *cli.Context) error {
 	bundleProposer := watcher.NewBundleProposer(subCtx, cfg.L2Config.BundleProposerConfig, minCodecVersion, genesis.Config, db, registry)
 
 	// Init l2geth connection
-	l2client, err := rpc.Dial(cfg.L2Config.Endpoint)
+	l2client, err := ethclient.Dial(cfg.L2Config.Endpoint)
 	if err != nil {
 		return fmt.Errorf("failed to connect to L2geth at RPC=%s: %w", cfg.L2Config.Endpoint, err)
 	}
 
-	l2Watcher := watcher.NewL2WatcherClient(subCtx, l2client, cfg.L2Config.Confirmations, cfg.L2Config.L2MessageQueueAddress,
-		cfg.L2Config.WithdrawTrieRootSlot, genesis.Config, db, cfg.L2Config.RelayerConfig.ValidiumMode, registry)
+	l2Watcher := watcher.NewL2WatcherClient(subCtx, l2client, cfg.L2Config.Confirmations, cfg.L2Config.L2MessageQueueAddress, cfg.L2Config.WithdrawTrieRootSlot, genesis.Config, db, registry)
 
 	recovery := permissionless_batches.NewRecovery(subCtx, cfg, genesis, db, chunkProposer, batchProposer, bundleProposer, l2Watcher)
 

rollup/cmd/rollup_relayer/app/app.go

@@ -12,7 +12,6 @@ import (
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/rollup/l1"
-	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/urfave/cli/v2"
 
 	"scroll-tech/common/database"
@@ -70,11 +69,10 @@ func action(ctx *cli.Context) error {
 	observability.Server(ctx, db)
 
 	// Init l2geth connection
-	l2client, err := rpc.Dial(cfg.L2Config.Endpoint)
+	l2client, err := ethclient.Dial(cfg.L2Config.Endpoint)
 	if err != nil {
 		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
 	}
-	l2ethClient := ethclient.NewClient(l2client)
 
 	genesisPath := ctx.String(utils.Genesis.Name)
 	genesis, err := utils.ReadGenesis(genesisPath)
@@ -98,11 +96,8 @@ func action(ctx *cli.Context) error {
 	if cfg.L2Config.ChunkProposerConfig.MaxL2GasPerChunk <= 0 {
 		log.Crit("cfg.L2Config.ChunkProposerConfig.MaxL2GasPerChunk must be greater than 0")
 	}
-	if cfg.L2Config.RelayerConfig.SenderConfig.FusakaTimestamp == 0 {
-		log.Crit("cfg.L2Config.RelayerConfig.SenderConfig.FusakaTimestamp must be set")
-	}
 
-	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2ethClient, db, cfg.L2Config.RelayerConfig, genesis.Config, relayer.ServiceTypeL2RollupRelayer, registry)
+	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, genesis.Config, relayer.ServiceTypeL2RollupRelayer, registry)
 	if err != nil {
 		log.Crit("failed to create l2 relayer", "config file", cfgFile, "error", err)
 	}
@@ -116,7 +111,7 @@ func action(ctx *cli.Context) error {
 	batchProposer := watcher.NewBatchProposer(subCtx, cfg.L2Config.BatchProposerConfig, minCodecVersion, genesis.Config, db, cfg.L2Config.RelayerConfig.ValidiumMode, registry)
 	bundleProposer := watcher.NewBundleProposer(subCtx, cfg.L2Config.BundleProposerConfig, minCodecVersion, genesis.Config, db, registry)
 
-	l2watcher := watcher.NewL2WatcherClient(subCtx, l2client, cfg.L2Config.Confirmations, cfg.L2Config.L2MessageQueueAddress, cfg.L2Config.WithdrawTrieRootSlot, genesis.Config, db, cfg.L2Config.RelayerConfig.ValidiumMode, registry)
+	l2watcher := watcher.NewL2WatcherClient(subCtx, l2client, cfg.L2Config.Confirmations, cfg.L2Config.L2MessageQueueAddress, cfg.L2Config.WithdrawTrieRootSlot, genesis.Config, db, registry)
 
 	if cfg.RecoveryConfig != nil && cfg.RecoveryConfig.Enable {
 		log.Info("Starting rollup-relayer in recovery mode", "version", version.Version)
@@ -146,7 +141,7 @@ func action(ctx *cli.Context) error {
 
 	// Watcher loop to fetch missing blocks
 	go utils.LoopWithContext(subCtx, 2*time.Second, func(ctx context.Context) {
-		number, loopErr := rutils.GetLatestConfirmedBlockNumber(ctx, l2ethClient, cfg.L2Config.Confirmations)
+		number, loopErr := rutils.GetLatestConfirmedBlockNumber(ctx, l2client, cfg.L2Config.Confirmations)
 		if loopErr != nil {
 			log.Error("failed to get block number", "err", loopErr)
 			return

rollup/conf/config.json

@@ -21,9 +21,7 @@
         "check_committed_batches_window_minutes": 5,
         "l1_base_fee_default": 15000000000,
         "l1_blob_base_fee_default": 1,
-        "l1_blob_base_fee_threshold": 0,
-        "l1_base_fee_limit": 20000000000,
-        "l1_blob_base_fee_limit": 20000000000
+        "l1_blob_base_fee_threshold": 0
       },
       "gas_oracle_sender_signer_config": {
         "signer_type": "PrivateKey",
@@ -51,15 +49,13 @@
         "tx_type": "DynamicFeeTx",
         "check_pending_time": 1,
         "min_gas_tip": 100000000,
-        "max_pending_blob_txs": 3,
-        "fusaka_timestamp": 9999999999999
+        "max_pending_blob_txs": 3
       },
       "batch_submission": {
         "min_batches": 1,
         "max_batches": 6,
         "timeout": 7200,
-        "backlog_max": 75,
-        "blob_fee_tolerance": 500000000
+        "backlog_max": 75
       },
       "gas_oracle_config": {
         "min_gas_price": 0,

rollup/go.mod

@@ -15,8 +15,8 @@ require (
 	github.com/holiman/uint256 v1.3.2
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/prometheus/client_golang v1.16.0
-	github.com/scroll-tech/da-codec v0.10.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f
+	github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/spf13/viper v1.19.0
 	github.com/stretchr/testify v1.10.0
@@ -49,11 +49,10 @@ require (
 	github.com/chenzhuoyu/iasm v0.9.0 // indirect
 	github.com/consensys/bavard v0.1.29 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
-	github.com/crate-crypto/go-eth-kzg v1.4.0 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/deckarep/golang-set v1.8.0 // indirect
+	github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea // indirect
 	github.com/edsrzf/mmap-go v1.0.0 // indirect
-	github.com/ethereum/c-kzg-4844/v2 v2.1.5 // indirect
+	github.com/ethereum/c-kzg-4844 v1.0.3 // indirect
 	github.com/fjl/memsize v0.0.2 // indirect
 	github.com/fsnotify/fsnotify v1.7.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
@@ -119,7 +118,7 @@ require (
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/status-im/keycard-go v0.2.0 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
-	github.com/supranational/blst v0.3.15 // indirect
+	github.com/supranational/blst v0.3.13 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
 	github.com/tklauser/go-sysconf v0.3.14 // indirect
 	github.com/tklauser/numcpus v0.9.0 // indirect

rollup/go.sum

@@ -79,8 +79,6 @@ github.com/consensys/gnark-crypto v0.16.0 h1:8Dl4eYmUWK9WmlP1Bj6je688gBRJCJbT8Mw
 github.com/consensys/gnark-crypto v0.16.0/go.mod h1:Ke3j06ndtPTVvo++PhGNgvm+lgpLvzbcE2MqljY7diU=
 github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
 github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/crate-crypto/go-eth-kzg v1.4.0 h1:WzDGjHk4gFg6YzV0rJOAsTK4z3Qkz5jd4RE3DAvPFkg=
-github.com/crate-crypto/go-eth-kzg v1.4.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI=
 github.com/crate-crypto/go-kzg-4844 v1.1.0 h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4=
 github.com/crate-crypto/go-kzg-4844 v1.1.0/go.mod h1:JolLjpSff1tCCJKaJx4psrlEdlXuJEC996PL3tTAFks=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -88,13 +86,13 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4=
-github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo=
+github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea h1:j4317fAZh7X6GqbFowYdYdI0L9bwxL07jyPZIdepyZ0=
+github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
 github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
 github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
-github.com/ethereum/c-kzg-4844/v2 v2.1.5 h1:aVtoLK5xwJ6c5RiqO8g8ptJ5KU+2Hdquf6G3aXiHh5s=
-github.com/ethereum/c-kzg-4844/v2 v2.1.5/go.mod h1:u59hRTTah4Co6i9fDWtiCjTrblJv0UwsqZKCc0GfgUs=
+github.com/ethereum/c-kzg-4844 v1.0.3 h1:IEnbOHwjixW2cTvKRUlAAUOeleV7nNM/umJR+qy4WDs=
+github.com/ethereum/c-kzg-4844 v1.0.3/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
 github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA=
 github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
@@ -287,10 +285,10 @@ github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6ke
 github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
 github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
 github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
-github.com/scroll-tech/da-codec v0.10.0 h1:IPHxyTyXTWPV0Q+DZ08cod2fWkhUvrfysmj/VBpB+WU=
-github.com/scroll-tech/da-codec v0.10.0/go.mod h1:MBlIP4wCXPcUDZ/Ci2B7n/2IbVU1WBo9OTFTZ5ffE0U=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f h1:j6SjP98MoWFFX9TwB1/nFYEkayqHQsrtE66Ll2C+oT0=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f/go.mod h1:Aa/kD1XB+OV/7rRxMQrjcPCB4b0pKyLH0gsTrtuHi38=
+github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178 h1:4utngmJHXSOS5FoSdZhEV1xMRirpArbXvyoCZY9nYj0=
+github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7 h1:1rN1qocsQlOyk1VCpIEF1J5pfQbLAi1pnMZSLQS37jQ=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
 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=
@@ -332,8 +330,8 @@ github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOf
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
-github.com/supranational/blst v0.3.15 h1:rd9viN6tfARE5wv3KZJ9H8e1cg0jXW8syFCcsbHa76o=
-github.com/supranational/blst v0.3.15/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
+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=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
 github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU=

rollup/internal/config/relayer.go

@@ -7,14 +7,8 @@ import (
 
 // SenderConfig The config for transaction sender
 type SenderConfig struct {
-	// The RPC endpoint of the ethereum or scroll public node (for backward compatibility).
-	// If WriteEndpoints is specified, this endpoint will be used only for reading.
-	// If WriteEndpoints is empty, this endpoint will be used for both reading and writing.
+	// The RPC endpoint of the ethereum or scroll public node.
 	Endpoint string `json:"endpoint"`
-	// The RPC endpoints to send transactions to (optional).
-	// If specified, transactions will be sent to all these endpoints in parallel.
-	// If empty, transactions will be sent to the Endpoint.
-	WriteEndpoints []string `json:"write_endpoints,omitempty"`
 	// The time to trigger check pending txs in sender.
 	CheckPendingTime uint64 `json:"check_pending_time"`
 	// The number of blocks to wait to escalate increase gas price of the transaction.
@@ -35,8 +29,6 @@ type SenderConfig struct {
 	TxType string `json:"tx_type"`
 	// The maximum number of pending blob-carrying transactions
 	MaxPendingBlobTxs int64 `json:"max_pending_blob_txs"`
-	// The timestamp of the Ethereum Fusaka upgrade in seconds since epoch.
-	FusakaTimestamp uint64 `json:"fusaka_timestamp"`
 }
 
 type BatchSubmission struct {
@@ -48,10 +40,6 @@ type BatchSubmission struct {
 	TimeoutSec int64 `json:"timeout"`
 	// The maximum number of pending batches to keep in the backlog.
 	BacklogMax int64 `json:"backlog_max"`
-	// BlobFeeTolerance is the absolute tolerance (in wei) added to the target blob fee.
-	// If the current fee is below target + tolerance, we proceed with submission.
-	// This prevents skipping submission when the price difference is negligible.
-	BlobFeeTolerance uint64 `json:"blob_fee_tolerance"`
 }
 
 // ChainMonitor this config is used to get batch status from chain_monitor API.
@@ -113,10 +101,6 @@ type GasOracleConfig struct {
 	L1BaseFeeDefault                   uint64 `json:"l1_base_fee_default"`
 	L1BlobBaseFeeDefault               uint64 `json:"l1_blob_base_fee_default"`
 
-	// Upper limit values for gas oracle updates
-	L1BaseFeeLimit     uint64 `json:"l1_base_fee_limit"`
-	L1BlobBaseFeeLimit uint64 `json:"l1_blob_base_fee_limit"`
-
 	// L1BlobBaseFeeThreshold the threshold of L1 blob base fee to enter the default gas price mode
 	L1BlobBaseFeeThreshold uint64 `json:"l1_blob_base_fee_threshold"`
 }

rollup/internal/controller/blob_uploader/blob_uploader.go

@@ -167,7 +167,7 @@ func (b *BlobUploader) constructBlobCodec(dbBatch *orm.Batch) (*kzg4844.Blob, er
 			Chunks:                     chunks,
 		}
 
-	case encoding.CodecV7, encoding.CodecV8, encoding.CodecV9, encoding.CodecV10:
+	case encoding.CodecV7, encoding.CodecV8:
 		encodingBatch = &encoding.Batch{
 			Index:                  dbBatch.Index,
 			ParentBatchHash:        common.HexToHash(dbBatch.ParentBatchHash),
@@ -242,12 +242,10 @@ func (b *BlobUploader) GetFirstUnuploadedBatchByPlatform(ctx context.Context, st
 		break
 	}
 
-	// disable this check to upload blobs before it's committed. This is to
-	// alleviate the case nodes try to fetch the blob from s3 before its uploaded.
-	// if len(batch.CommitTxHash) == 0 {
-	// 	log.Debug("got batch not committed for blob uploading", "batch_index", batchIndex, "platform", platform.String())
-	// 	return nil, nil
-	// }
+	if len(batch.CommitTxHash) == 0 {
+		log.Debug("got batch not committed for blob uploading", "batch_index", batchIndex, "platform", platform.String())
+		return nil, nil
+	}
 
 	return batch, nil
 }

rollup/internal/controller/relayer/l1_relayer.go

@@ -173,18 +173,6 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 			} else if err != nil {
 				return
 			}
-			// Cap base fee update at the configured upper limit
-			if limit := r.cfg.GasOracleConfig.L1BaseFeeLimit; baseFee > limit {
-				log.Error("L1 base fee exceed max limit, set to max limit", "baseFee", baseFee, "maxLimit", limit)
-				r.metrics.rollupL1RelayerGasPriceOracleFeeOverLimitTotal.Inc()
-				baseFee = limit
-			}
-			// Cap blob base fee update at the configured upper limit
-			if limit := r.cfg.GasOracleConfig.L1BlobBaseFeeLimit; blobBaseFee > limit {
-				log.Error("L1 blob base fee exceed max limit, set to max limit", "blobBaseFee", blobBaseFee, "maxLimit", limit)
-				r.metrics.rollupL1RelayerGasPriceOracleFeeOverLimitTotal.Inc()
-				blobBaseFee = limit
-			}
 			data, err := r.l1GasOracleABI.Pack("setL1BaseFeeAndBlobBaseFee", new(big.Int).SetUint64(baseFee), new(big.Int).SetUint64(blobBaseFee))
 			if err != nil {
 				log.Error("Failed to pack setL1BaseFeeAndBlobBaseFee", "block.Hash", block.Hash, "block.Height", block.Number, "block.BaseFee", baseFee, "block.BlobBaseFee", blobBaseFee, "err", err)

rollup/internal/controller/relayer/l1_relayer_metrics.go

@@ -8,12 +8,11 @@ import (
 )
 
 type l1RelayerMetrics struct {
-	rollupL1RelayerGasPriceOraclerRunTotal         prometheus.Counter
-	rollupL1RelayerLatestBaseFee                   prometheus.Gauge
-	rollupL1RelayerLatestBlobBaseFee               prometheus.Gauge
-	rollupL1UpdateGasOracleConfirmedTotal          prometheus.Counter
-	rollupL1UpdateGasOracleConfirmedFailedTotal    prometheus.Counter
-	rollupL1RelayerGasPriceOracleFeeOverLimitTotal prometheus.Counter
+	rollupL1RelayerGasPriceOraclerRunTotal      prometheus.Counter
+	rollupL1RelayerLatestBaseFee                prometheus.Gauge
+	rollupL1RelayerLatestBlobBaseFee            prometheus.Gauge
+	rollupL1UpdateGasOracleConfirmedTotal       prometheus.Counter
+	rollupL1UpdateGasOracleConfirmedFailedTotal prometheus.Counter
 }
 
 var (
@@ -44,10 +43,6 @@ func initL1RelayerMetrics(reg prometheus.Registerer) *l1RelayerMetrics {
 				Name: "rollup_layer1_update_gas_oracle_confirmed_failed_total",
 				Help: "The total number of updating layer1 gas oracle confirmed failed",
 			}),
-			rollupL1RelayerGasPriceOracleFeeOverLimitTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_layer1_gas_price_oracle_fee_over_limit_total",
-				Help: "The total number of times when a gas price oracle fee update went over the configured limit",
-			}),
 		}
 	})
 	return l1RelayerMetric

rollup/internal/controller/relayer/l2_relayer.go

@@ -345,16 +345,8 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 // - backlogCount > r.cfg.BatchSubmission.BacklogMax -> forceSubmit
 // - we have at least minBatches AND price hits a desired target price
 func (r *Layer2Relayer) ProcessPendingBatches() {
-	// First, get the backlog count to determine batch submission strategy
-	backlogCount, err := r.batchOrm.GetFailedAndPendingBatchesCount(r.ctx)
-	if err != nil {
-		log.Error("Failed to fetch pending L2 batches count", "err", err)
-		return
-	}
-	r.metrics.rollupL2RelayerBacklogCounts.Set(float64(backlogCount))
-
-	// Get effective batch limits based on validium mode and backlog size.
-	minBatches, maxBatches := r.getEffectiveBatchLimits(backlogCount)
+	// Get effective batch limits based on whether validium mode is enabled.
+	minBatches, maxBatches := r.getEffectiveBatchLimits()
 
 	// get pending batches from database in ascending order by their index.
 	dbBatches, err := r.batchOrm.GetFailedAndPendingBatches(r.ctx, maxBatches)
@@ -368,6 +360,15 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		return
 	}
 
+	// if backlog outgrow max size, force‐submit enough oldest batches
+	backlogCount, err := r.batchOrm.GetFailedAndPendingBatchesCount(r.ctx)
+	r.metrics.rollupL2RelayerBacklogCounts.Set(float64(backlogCount))
+
+	if err != nil {
+		log.Error("Failed to fetch pending L2 batches", "err", err)
+		return
+	}
+
 	var forceSubmit bool
 
 	startChunk, err := r.chunkOrm.GetChunkByIndex(r.ctx, dbBatches[0].StartChunkIndex)
@@ -452,7 +453,6 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		// The next call of ProcessPendingBatches will then start with the batch with the different codec version.
 		batchesToSubmitLen := len(batchesToSubmit)
 		if batchesToSubmitLen > 0 && batchesToSubmit[batchesToSubmitLen-1].Batch.CodecVersion != dbBatch.CodecVersion {
-			forceSubmit = true
 			break
 		}
 
@@ -489,7 +489,7 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 
 	codecVersion := encoding.CodecVersion(firstBatch.CodecVersion)
 	switch codecVersion {
-	case encoding.CodecV7, encoding.CodecV8, encoding.CodecV9, encoding.CodecV10:
+	case encoding.CodecV7, encoding.CodecV8:
 		if r.cfg.ValidiumMode {
 			if len(batchesToSubmit) != 1 {
 				log.Error("validium mode only supports committing one batch at a time", "codecVersion", codecVersion, "start index", firstBatch.Index, "end index", lastBatch.Index, "batches count", len(batchesToSubmit))
@@ -563,22 +563,12 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 	log.Info("Sent the commitBatches tx to layer1", "batches count", len(batchesToSubmit), "start index", firstBatch.Index, "start hash", firstBatch.Hash, "end index", lastBatch.Index, "end hash", lastBatch.Hash, "tx hash", txHash.String())
 }
 
-// getEffectiveBatchLimits returns the effective min and max batch limits based on whether validium mode is enabled
-// and the current backlog size.
-// When backlogCount >= backlog_max: submit min_batches for fast inclusion at slightly higher price.
-// When backlogCount < backlog_max: submit max_batches for better cost amortization.
-func (r *Layer2Relayer) getEffectiveBatchLimits(backlogCount int64) (int, int) {
+// getEffectiveBatchLimits returns the effective min and max batch limits based on whether validium mode is enabled.
+func (r *Layer2Relayer) getEffectiveBatchLimits() (int, int) {
 	if r.cfg.ValidiumMode {
 		return 1, 1 // minBatches=1, maxBatches=1
 	}
-
-	// If backlog is at or above max, prioritize fast inclusion by submitting min_batches
-	if backlogCount >= r.cfg.BatchSubmission.BacklogMax {
-		return r.cfg.BatchSubmission.MinBatches, r.cfg.BatchSubmission.MinBatches
-	}
-
-	// Otherwise, prioritize cost efficiency by trying to submit max_batches
-	return r.cfg.BatchSubmission.MaxBatches, r.cfg.BatchSubmission.MaxBatches
+	return r.cfg.BatchSubmission.MinBatches, r.cfg.BatchSubmission.MaxBatches
 }
 
 func (r *Layer2Relayer) contextIDFromBatches(codecVersion encoding.CodecVersion, batches []*dbBatchWithChunks) string {
@@ -748,7 +738,7 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 
 	var calldata []byte
 	switch encoding.CodecVersion(bundle.CodecVersion) {
-	case encoding.CodecV7, encoding.CodecV8, encoding.CodecV9, encoding.CodecV10:
+	case encoding.CodecV7, encoding.CodecV8:
 		if r.cfg.ValidiumMode {
 			calldata, err = r.constructFinalizeBundlePayloadValidium(dbBatch, endChunk, aggProof)
 			if err != nil {
@@ -1050,15 +1040,7 @@ func (r *Layer2Relayer) constructCommitBatchPayloadValidium(batch *dbBatchWithCh
 	lastChunk := batch.Chunks[len(batch.Chunks)-1]
 	commitment := common.HexToHash(lastChunk.EndBlockHash)
 
-	var version uint8
-	if encoding.CodecVersion(batch.Batch.CodecVersion) == encoding.CodecV8 || encoding.CodecVersion(batch.Batch.CodecVersion) == encoding.CodecV9 || encoding.CodecVersion(batch.Batch.CodecVersion) == encoding.CodecV10 {
-		// Validium version line starts with v1,
-		// but rollup-relayer behavior follows v8.
-		version = 1
-	} else {
-		return nil, 0, 0, fmt.Errorf("unexpected codec version %d for validium mode", batch.Batch.CodecVersion)
-	}
-
+	version := encoding.CodecVersion(batch.Batch.CodecVersion)
 	calldata, err := r.validiumABI.Pack("commitBatch", version, common.HexToHash(batch.Batch.ParentBatchHash), common.HexToHash(batch.Batch.StateRoot), common.HexToHash(batch.Batch.WithdrawRoot), commitment[:])
 	if err != nil {
 		return nil, 0, 0, fmt.Errorf("failed to pack commitBatch: %w", err)
@@ -1255,20 +1237,16 @@ func (r *Layer2Relayer) skipSubmitByFee(oldest time.Time, metrics *l2RelayerMetr
 	target := calculateTargetPrice(windowSec, r.batchStrategy, oldest, hist)
 	current := hist[len(hist)-1]
 
-	// apply absolute tolerance offset to target
-	tolerance := new(big.Int).SetUint64(r.cfg.BatchSubmission.BlobFeeTolerance)
-	threshold := new(big.Int).Add(target, tolerance)
-
 	currentFloat, _ := current.Float64()
 	targetFloat, _ := target.Float64()
 	metrics.rollupL2RelayerCurrentBlobPrice.Set(currentFloat)
 	metrics.rollupL2RelayerTargetBlobPrice.Set(targetFloat)
 
-	// if current fee > threshold (target + tolerance) and still inside the timeout window, skip
-	if current.Cmp(threshold) > 0 && time.Since(oldest) < time.Duration(windowSec)*time.Second {
+	// if current fee > target and still inside the timeout window, skip
+	if current.Cmp(target) > 0 && time.Since(oldest) < time.Duration(windowSec)*time.Second {
 		return true, fmt.Errorf(
-			"blob-fee above threshold & window not yet passed; current=%s target=%s threshold=%s tolerance=%s age=%s",
-			current.String(), target.String(), threshold.String(), tolerance.String(), time.Since(oldest),
+			"blob-fee above target & window not yet passed; current=%s target=%s age=%s",
+			current.String(), target.String(), time.Since(oldest),
 		)
 	}
 

rollup/internal/controller/relayer/relayer_test.go

@@ -56,7 +56,6 @@ func setupEnv(t *testing.T) {
 
 	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint, err = testApps.GetPoSL1EndPoint()
 	assert.NoError(t, err)
-	cfg.L2Config.RelayerConfig.SenderConfig.WriteEndpoints = []string{cfg.L2Config.RelayerConfig.SenderConfig.Endpoint, cfg.L2Config.RelayerConfig.SenderConfig.Endpoint}
 	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint, err = testApps.GetL2GethEndPoint()
 	assert.NoError(t, err)
 

rollup/internal/controller/sender/estimategas.go

@@ -2,7 +2,6 @@ package sender
 
 import (
 	"errors"
-	"fmt"
 	"math/big"
 
 	"github.com/scroll-tech/go-ethereum"
@@ -53,7 +52,7 @@ func (s *Sender) estimateDynamicGas(to *common.Address, data []byte, baseFee uin
 	if err != nil {
 		log.Error("estimateDynamicGas estimateGasLimit failure",
 			"from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "to address", to.String(),
-			"error", err)
+			"fallback gas limit", "error", err)
 		return nil, err
 	}
 
@@ -119,7 +118,7 @@ func (s *Sender) estimateGasLimit(to *common.Address, data []byte, sidecar *type
 
 	gasLimitWithoutAccessList, err := s.client.EstimateGas(s.ctx, msg)
 	if err != nil {
-		log.Error("estimateGasLimit EstimateGas failure without access list", "error", err, "msg", fmt.Sprintf("%+v", msg))
+		log.Error("estimateGasLimit EstimateGas failure without access list", "error", err)
 		return 0, nil, err
 	}
 

rollup/internal/controller/sender/sender.go

@@ -7,13 +7,12 @@ import (
 	"fmt"
 	"math/big"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/holiman/uint256"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/common/hexutil"
+	"github.com/scroll-tech/go-ethereum/consensus/misc"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
 	"github.com/scroll-tech/go-ethereum/ethclient"
@@ -67,10 +66,8 @@ type FeeData struct {
 // Sender Transaction sender to send transaction to l1/l2
 type Sender struct {
 	config            *config.SenderConfig
-	rpcClient         *rpc.Client         // Raw RPC client
-	gethClient        *gethclient.Client  // Client to use for CreateAccessList
-	client            *ethclient.Client   // The client to retrieve on chain data (read-only)
-	writeClients      []*ethclient.Client // The clients to send transactions to (write operations)
+	gethClient        *gethclient.Client
+	client            *ethclient.Client // The client to retrieve on chain data or send transaction.
 	transactionSigner *TransactionSigner
 	chainID           *big.Int // The chain id of the endpoint
 	ctx               context.Context
@@ -93,10 +90,9 @@ func NewSender(ctx context.Context, config *config.SenderConfig, signerConfig *c
 		return nil, fmt.Errorf("invalid params, EscalateMultipleNum; %v, EscalateMultipleDen: %v", config.EscalateMultipleNum, config.EscalateMultipleDen)
 	}
 
-	// Initialize read client
 	rpcClient, err := rpc.Dial(config.Endpoint)
 	if err != nil {
-		return nil, fmt.Errorf("failed to dial read client, err: %w", err)
+		return nil, fmt.Errorf("failed to dial eth client, err: %w", err)
 	}
 
 	client := ethclient.NewClient(rpcClient)
@@ -109,43 +105,12 @@ func NewSender(ctx context.Context, config *config.SenderConfig, signerConfig *c
 		return nil, fmt.Errorf("failed to create transaction signer, err: %w", err)
 	}
 
-	// Initialize write clients
-	var writeClients []*ethclient.Client
-	if len(config.WriteEndpoints) > 0 {
-		// Use specified write endpoints
-		for i, endpoint := range config.WriteEndpoints {
-			writeRpcClient, err := rpc.Dial(endpoint)
-			if err != nil {
-				return nil, fmt.Errorf("failed to dial write client %d (endpoint: %s), err: %w", i, endpoint, err)
-			}
-			writeClient := ethclient.NewClient(writeRpcClient)
-
-			// Verify the write client is connected to the same chain
-			writeChainID, err := writeClient.ChainID(ctx)
-			if err != nil {
-				return nil, fmt.Errorf("failed to get chain ID from write client %d (endpoint: %s), err: %w", i, endpoint, err)
-			}
-			if writeChainID.Cmp(chainID) != 0 {
-				return nil, fmt.Errorf("write client %d (endpoint: %s) has different chain ID %s, expected %s", i, endpoint, writeChainID.String(), chainID.String())
-			}
-
-			writeClients = append(writeClients, writeClient)
-		}
-		log.Info("initialized sender with multiple write clients", "service", service, "name", name, "readEndpoint", config.Endpoint, "writeEndpoints", config.WriteEndpoints)
-	} else {
-		// Use read client for writing (backward compatibility)
-		writeClients = append(writeClients, client)
-		log.Info("initialized sender with single client", "service", service, "name", name, "endpoint", config.Endpoint)
-	}
-
 	// Create sender instance first and then initialize nonce
 	sender := &Sender{
 		ctx:                   ctx,
 		config:                config,
-		rpcClient:             rpcClient,
 		gethClient:            gethclient.New(rpcClient),
 		client:                client,
-		writeClients:          writeClients,
 		chainID:               chainID,
 		transactionSigner:     transactionSigner,
 		db:                    db,
@@ -204,82 +169,6 @@ func (s *Sender) getFeeData(target *common.Address, data []byte, sidecar *gethTy
 	}
 }
 
-// sendTransactionToMultipleClients sends a transaction to all write clients in parallel
-// and returns success if at least one client succeeds
-func (s *Sender) sendTransactionToMultipleClients(signedTx *gethTypes.Transaction) error {
-	ctx, cancel := context.WithTimeout(s.ctx, 15*time.Second)
-	defer cancel()
-
-	if len(s.writeClients) == 1 {
-		// Single client - use direct approach
-		return s.writeClients[0].SendTransaction(ctx, signedTx)
-	}
-
-	// Multiple clients - send in parallel
-	type result struct {
-		endpoint string
-		err      error
-	}
-
-	resultChan := make(chan result, len(s.writeClients))
-	var wg sync.WaitGroup
-
-	// Send transaction to all write clients in parallel
-	for i, client := range s.writeClients {
-		wg.Add(1)
-		// Determine endpoint URL for this client
-		endpoint := s.config.WriteEndpoints[i]
-
-		go func(ep string, writeClient *ethclient.Client) {
-			defer wg.Done()
-			err := writeClient.SendTransaction(ctx, signedTx)
-			resultChan <- result{endpoint: ep, err: err}
-		}(endpoint, client)
-	}
-
-	// Wait for all goroutines to finish
-	go func() {
-		wg.Wait()
-		close(resultChan)
-	}()
-
-	// Collect results
-	var errs []error
-	for res := range resultChan {
-		if res.err != nil {
-			errs = append(errs, fmt.Errorf("%s: %w", res.endpoint, res.err))
-			log.Warn("failed to send transaction to write client",
-				"endpoint", res.endpoint,
-				"txHash", signedTx.Hash().Hex(),
-				"nonce", signedTx.Nonce(),
-				"from", s.transactionSigner.GetAddr().String(),
-				"error", res.err)
-		} else {
-			log.Info("successfully sent transaction to write client",
-				"endpoint", res.endpoint,
-				"txHash", signedTx.Hash().Hex(),
-				"nonce", signedTx.Nonce(),
-				"from", s.transactionSigner.GetAddr().String())
-		}
-	}
-
-	// Check if at least one client succeeded
-	if len(errs) < len(s.writeClients) {
-		successCount := len(s.writeClients) - len(errs)
-		if len(errs) > 0 {
-			log.Info("transaction partially succeeded",
-				"txHash", signedTx.Hash().Hex(),
-				"successCount", successCount,
-				"totalClients", len(s.writeClients),
-				"failures", errors.Join(errs...))
-		}
-		return nil
-	}
-
-	// All clients failed
-	return fmt.Errorf("failed to send transaction to all %d write clients: %w", len(s.writeClients), errors.Join(errs...))
-}
-
 // SendTransaction send a signed L2tL1 transaction.
 func (s *Sender) SendTransaction(contextID string, target *common.Address, data []byte, blobs []*kzg4844.Blob) (common.Hash, uint64, error) {
 	s.metrics.sendTransactionTotal.WithLabelValues(s.service, s.name).Inc()
@@ -289,12 +178,6 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 		err     error
 	)
 
-	blockNumber, blockTimestamp, baseFee, blobBaseFee, err := s.getBlockNumberAndTimestampAndBaseFeeAndBlobFee(s.ctx)
-	if err != nil {
-		log.Error("failed to get block number and base fee", "error", err)
-		return common.Hash{}, 0, fmt.Errorf("failed to get block number and base fee, err: %w", err)
-	}
-
 	if blobs != nil {
 		// check that number of pending blob-carrying txs is not too big
 		if s.senderType == types.SenderTypeCommitBatch {
@@ -311,24 +194,21 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 			if numPendingTransactions >= s.config.MaxPendingBlobTxs {
 				return common.Hash{}, 0, ErrTooManyPendingBlobTxs
 			}
-		}
 
-		if blockTimestamp < s.config.FusakaTimestamp && (s.config.FusakaTimestamp-blockTimestamp) < 180 {
-			return common.Hash{}, 0, fmt.Errorf("pausing blob txs before Fusaka upgrade, eta %d seconds", s.config.FusakaTimestamp-blockTimestamp)
 		}
-
-		version := gethTypes.BlobSidecarVersion0
-		if blockTimestamp >= s.config.FusakaTimestamp {
-			version = gethTypes.BlobSidecarVersion1
-		}
-
-		sidecar, err = makeSidecar(version, blobs)
+		sidecar, err = makeSidecar(blobs)
 		if err != nil {
 			log.Error("failed to make sidecar for blob transaction", "error", err)
 			return common.Hash{}, 0, fmt.Errorf("failed to make sidecar for blob transaction, err: %w", err)
 		}
 	}
 
+	blockNumber, baseFee, blobBaseFee, err := s.getBlockNumberAndBaseFeeAndBlobFee(s.ctx)
+	if err != nil {
+		log.Error("failed to get block number and base fee", "error", err)
+		return common.Hash{}, 0, fmt.Errorf("failed to get block number and base fee, err: %w", err)
+	}
+
 	if feeData, err = s.getFeeData(target, data, sidecar, baseFee, blobBaseFee); err != nil {
 		s.metrics.sendTransactionFailureGetFee.WithLabelValues(s.service, s.name).Inc()
 		log.Error("failed to get fee data", "from", s.transactionSigner.GetAddr().String(), "nonce", s.transactionSigner.GetNonce(), "err", err)
@@ -350,7 +230,7 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 		return common.Hash{}, 0, fmt.Errorf("failed to insert transaction, err: %w", err)
 	}
 
-	if err := s.sendTransactionToMultipleClients(signedTx); err != nil {
+	if err := s.client.SendTransaction(s.ctx, signedTx); err != nil {
 		// Delete the transaction from the pending transaction table if it fails to send.
 		if updateErr := s.pendingTransactionOrm.DeleteTransactionByTxHash(s.ctx, signedTx.Hash()); updateErr != nil {
 			log.Error("failed to delete transaction", "tx hash", signedTx.Hash().String(), "from", s.transactionSigner.GetAddr().String(), "nonce", signedTx.Nonce(), "err", updateErr)
@@ -635,10 +515,6 @@ func (s *Sender) createReplacingTransaction(tx *gethTypes.Transaction, baseFee,
 
 	nonce := tx.Nonce()
 	s.metrics.resubmitTransactionTotal.WithLabelValues(s.service, s.name).Inc()
-
-	// Note: This might fail during the Fusaka upgrade, if we originally sent a V0 blob tx.
-	// Normally we would need to convert it to V1 before resubmitting. However, this case is
-	// unlikely and geth would still accept the V0 version, so we omit the conversion.
 	signedTx, err := s.createTx(&feeData, tx.To(), tx.Data(), tx.BlobTxSidecar(), nonce)
 	if err != nil {
 		log.Error("failed to create signed tx (resubmit case)", "from", s.transactionSigner.GetAddr().String(), "nonce", nonce, "err", err)
@@ -652,7 +528,7 @@ func (s *Sender) createReplacingTransaction(tx *gethTypes.Transaction, baseFee,
 func (s *Sender) checkPendingTransaction() {
 	s.metrics.senderCheckPendingTransactionTotal.WithLabelValues(s.service, s.name).Inc()
 
-	blockNumber, _, baseFee, blobBaseFee, err := s.getBlockNumberAndTimestampAndBaseFeeAndBlobFee(s.ctx)
+	blockNumber, baseFee, blobBaseFee, err := s.getBlockNumberAndBaseFeeAndBlobFee(s.ctx)
 	if err != nil {
 		log.Error("failed to get block number and base fee", "error", err)
 		return
@@ -769,7 +645,7 @@ func (s *Sender) checkPendingTransaction() {
 				return
 			}
 
-			if err := s.sendTransactionToMultipleClients(newSignedTx); err != nil {
+			if err := s.client.SendTransaction(s.ctx, newSignedTx); err != nil {
 				if strings.Contains(err.Error(), "nonce too low") {
 					// When we receive a 'nonce too low' error but cannot find the transaction receipt, it indicates another transaction with this nonce has already been processed, so this transaction will never be mined and should be marked as failed.
 					log.Warn("nonce too low detected, marking all non-confirmed transactions with same nonce as failed", "nonce", originalTx.Nonce(), "address", s.transactionSigner.GetAddr().Hex(), "txHash", originalTx.Hash().Hex(), "newTxHash", newSignedTx.Hash().Hex(), "err", err)
@@ -830,10 +706,10 @@ func (s *Sender) getSenderMeta() *orm.SenderMeta {
 	}
 }
 
-func (s *Sender) getBlockNumberAndTimestampAndBaseFeeAndBlobFee(ctx context.Context) (uint64, uint64, uint64, uint64, error) {
+func (s *Sender) getBlockNumberAndBaseFeeAndBlobFee(ctx context.Context) (uint64, uint64, uint64, error) {
 	header, err := s.client.HeaderByNumber(ctx, big.NewInt(rpc.PendingBlockNumber.Int64()))
 	if err != nil {
-		return 0, 0, 0, 0, fmt.Errorf("failed to get header by number, err: %w", err)
+		return 0, 0, 0, fmt.Errorf("failed to get header by number, err: %w", err)
 	}
 
 	var baseFee uint64
@@ -843,24 +719,13 @@ func (s *Sender) getBlockNumberAndTimestampAndBaseFeeAndBlobFee(ctx context.Cont
 
 	var blobBaseFee uint64
 	if excess := header.ExcessBlobGas; excess != nil {
-		// Leave it up to the L1 node to compute the correct blob base fee.
-		// Previously we would compute it locally using `CalcBlobFee`, but
-		// that approach requires syncing any future L1 configuration changes.
-		// Note: The fetched blob base fee might not correspond to the block
-		// that we fetched in the previous step, but this is acceptable.
-		var blobBaseFeeHex hexutil.Big
-		if err := s.rpcClient.CallContext(ctx, &blobBaseFeeHex, "eth_blobBaseFee"); err != nil {
-			return 0, 0, 0, 0, fmt.Errorf("failed to call eth_blobBaseFee, err: %w", err)
-		}
-		// A correct L1 node could not return a value that overflows uint64
-		blobBaseFee = blobBaseFeeHex.ToInt().Uint64()
+		blobBaseFee = misc.CalcBlobFee(*excess).Uint64()
 	}
-
 	// header.Number.Uint64() returns the pendingBlockNumber, so we minus 1 to get the latestBlockNumber.
-	return header.Number.Uint64() - 1, header.Time, baseFee, blobBaseFee, nil
+	return header.Number.Uint64() - 1, baseFee, blobBaseFee, nil
 }
 
-func makeSidecar(version byte, blobsInput []*kzg4844.Blob) (*gethTypes.BlobTxSidecar, error) {
+func makeSidecar(blobsInput []*kzg4844.Blob) (*gethTypes.BlobTxSidecar, error) {
 	if len(blobsInput) == 0 {
 		return nil, errors.New("blobsInput is empty")
 	}
@@ -877,33 +742,23 @@ func makeSidecar(version byte, blobsInput []*kzg4844.Blob) (*gethTypes.BlobTxSid
 	var proofs []kzg4844.Proof
 
 	for i := range blobs {
-		// Calculate commitment
 		c, err := kzg4844.BlobToCommitment(&blobs[i])
 		if err != nil {
 			return nil, fmt.Errorf("failed to get blob commitment, err: %w", err)
 		}
-		commitments = append(commitments, c)
 
-		// Calculate proof
-		switch version {
-		case gethTypes.BlobSidecarVersion0:
-			p, err := kzg4844.ComputeBlobProof(&blobs[i], c)
-			if err != nil {
-				return nil, fmt.Errorf("failed to compute v0 blob proof, err: %w", err)
-			}
-			proofs = append(proofs, p)
-
-		case gethTypes.BlobSidecarVersion1:
-			ps, err := kzg4844.ComputeCellProofs(&blobs[i])
-			if err != nil {
-				return nil, fmt.Errorf("failed to compute v1 blob cell proofs, err: %w", err)
-			}
-			proofs = append(proofs, ps...)
-
-		default:
-			return nil, fmt.Errorf("unsupported blob sidecar version: %d", version)
+		p, err := kzg4844.ComputeBlobProof(&blobs[i], c)
+		if err != nil {
+			return nil, fmt.Errorf("failed to compute blob proof, err: %w", err)
 		}
+
+		commitments = append(commitments, c)
+		proofs = append(proofs, p)
 	}
 
-	return gethTypes.NewBlobTxSidecar(version, blobs, commitments, proofs), nil
+	return &gethTypes.BlobTxSidecar{
+		Blobs:       blobs,
+		Commitments: commitments,
+		Proofs:      proofs,
+	}, nil
 }

rollup/internal/controller/sender/sender_test.go

@@ -21,7 +21,6 @@ import (
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
-	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/stretchr/testify/assert"
@@ -95,9 +94,8 @@ func setupEnv(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(sqlDB))
 
-	l1RawClient, err := testApps.GetPoSL1Client()
+	l1Client, err := testApps.GetPoSL1Client()
 	assert.NoError(t, err)
-	l1Client := ethclient.NewClient(l1RawClient)
 
 	chainID, err := l1Client.ChainID(context.Background())
 	assert.NoError(t, err)
@@ -293,7 +291,7 @@ func testAccessListTransactionGasLimit(t *testing.T) {
 
 		var sidecar *gethTypes.BlobTxSidecar
 		if txBlob[i] != nil {
-			sidecar, err = makeSidecar(gethTypes.BlobSidecarVersion0, []*kzg4844.Blob{txBlob[i]})
+			sidecar, err = makeSidecar([]*kzg4844.Blob{txBlob[i]})
 			assert.NoError(t, err)
 		}
 
@@ -334,7 +332,7 @@ func testResubmitNonZeroGasPriceTransaction(t *testing.T) {
 		}
 		var sidecar *gethTypes.BlobTxSidecar
 		if txBlob[i] != nil {
-			sidecar, err = makeSidecar(gethTypes.BlobSidecarVersion0, []*kzg4844.Blob{txBlob[i]})
+			sidecar, err = makeSidecar([]*kzg4844.Blob{txBlob[i]})
 			assert.NoError(t, err)
 		}
 		tx, err := s.createTx(feeData, &common.Address{}, nil, sidecar, s.transactionSigner.GetNonce())
@@ -469,7 +467,7 @@ func testResubmitBlobTransactionWithRisingBaseFeeAndBlobBaseFee(t *testing.T) {
 	})
 	defer patchGuard.Reset()
 
-	sidecar, err := makeSidecar(gethTypes.BlobSidecarVersion0, randBlobs(1))
+	sidecar, err := makeSidecar(randBlobs(1))
 	assert.NoError(t, err)
 	tx := gethTypes.NewTx(&gethTypes.BlobTx{
 		ChainID:    uint256.MustFromBig(s.chainID),
@@ -801,7 +799,7 @@ func testBlobTransactionWithBlobhashOpContractCall(t *testing.T) {
 	assert.NoError(t, migrate.ResetDB(sqlDB))
 
 	blobs := randBlobs(1)
-	sideCar, err := makeSidecar(gethTypes.BlobSidecarVersion0, blobs)
+	sideCar, err := makeSidecar(blobs)
 	assert.NoError(t, err)
 	versionedHash := sideCar.BlobHashes()[0]
 	blsModulo, ok := new(big.Int).SetString("52435875175126190479447740508185965837690552500527637822603658699938581184513", 10)

rollup/internal/controller/watcher/chunk_proposer.go

@@ -245,13 +245,11 @@ func (p *ChunkProposer) ProposeChunk() error {
 	// Ensure all blocks in the same chunk use the same hardfork name
 	// If a different hardfork name is found, truncate the blocks slice at that point
 	hardforkName := encoding.GetHardforkName(p.chainCfg, blocks[0].Header.Number.Uint64(), blocks[0].Header.Time)
-	hardforkBoundary := false
 	for i := 1; i < len(blocks); i++ {
 		currentHardfork := encoding.GetHardforkName(p.chainCfg, blocks[i].Header.Number.Uint64(), blocks[i].Header.Time)
 		if currentHardfork != hardforkName {
-			// Truncate blocks at hardfork boundary
 			blocks = blocks[:i]
-			hardforkBoundary = true
+			// Truncate blocks at hardfork boundary
 			break
 		}
 	}
@@ -323,19 +321,6 @@ func (p *ChunkProposer) ProposeChunk() error {
 		return fmt.Errorf("failed to calculate chunk metrics: %w", calcErr)
 	}
 
-	// No breaking condition met, but hardfork boundary reached
-	if hardforkBoundary {
-		log.Info("hardfork boundary reached, proposing chunk",
-			"block count", len(chunk.Blocks),
-			"codec version", codecVersion,
-			"start block number", chunk.Blocks[0].Header.Number,
-			"end block number", chunk.Blocks[len(chunk.Blocks)-1].Header.Number)
-
-		p.recordAllChunkMetrics(metrics)
-		return p.updateDBChunkInfo(&chunk, codecVersion, metrics)
-	}
-
-	// No breaking condition met, check for timeout
 	currentTimeSec := uint64(time.Now().Unix())
 	if metrics.FirstBlockTimestamp+p.cfg.ChunkTimeoutSec < currentTimeSec {
 		log.Info("first block timeout reached",

rollup/internal/controller/watcher/chunk_proposer_test.go

@@ -19,8 +19,6 @@ import (
 	"scroll-tech/rollup/internal/utils"
 )
 
-func newUint64(val uint64) *uint64 { return &val }
-
 func testChunkProposerLimitsCodecV7(t *testing.T) {
 	tests := []struct {
 		name                       string
@@ -28,7 +26,6 @@ func testChunkProposerLimitsCodecV7(t *testing.T) {
 		chunkTimeoutSec            uint64
 		expectedChunksLen          int
 		expectedBlocksInFirstChunk int // only be checked when expectedChunksLen > 0
-		GalileoTime                *uint64
 	}{
 		{
 			name:              "NoLimitReached",
@@ -65,14 +62,6 @@ func testChunkProposerLimitsCodecV7(t *testing.T) {
 			expectedChunksLen:          1,
 			expectedBlocksInFirstChunk: 1,
 		},
-		{
-			name:                       "SingleBlockByForkBoundary",
-			maxL2Gas:                   20_000_000,
-			chunkTimeoutSec:            1000000000000,
-			expectedChunksLen:          1,
-			expectedBlocksInFirstChunk: 1,
-			GalileoTime:                newUint64(1669364525), // timestamp of `block2`
-		},
 	}
 
 	for _, tt := range tests {
@@ -89,26 +78,11 @@ func testChunkProposerLimitsCodecV7(t *testing.T) {
 			_, err = chunkOrm.InsertChunk(context.Background(), &encoding.Chunk{Blocks: []*encoding.Block{{Header: &gethTypes.Header{Number: big.NewInt(0)}}}}, encoding.CodecV0, utils.ChunkMetrics{})
 			assert.NoError(t, err)
 
-			// Initialize the chunk proposer.
-			chainConfig := &params.ChainConfig{
-				LondonBlock:    big.NewInt(0),
-				BernoulliBlock: big.NewInt(0),
-				CurieBlock:     big.NewInt(0),
-				DarwinTime:     new(uint64),
-				DarwinV2Time:   new(uint64),
-				EuclidTime:     new(uint64),
-				EuclidV2Time:   new(uint64),
-				FeynmanTime:    new(uint64),
-				GalileoTime:    tt.GalileoTime,
-			}
-
 			cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
 				MaxL2GasPerChunk:              tt.maxL2Gas,
 				ChunkTimeoutSec:               tt.chunkTimeoutSec,
 				MaxUncompressedBatchBytesSize: math.MaxUint64,
-			}, encoding.CodecV7, chainConfig, db, nil)
-
-			// Run one round of chunk proposing.
+			}, encoding.CodecV7, &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}, db, nil)
 			cp.TryProposeChunk()
 
 			chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 1, 0)

rollup/internal/controller/watcher/l1_watcher.go

@@ -3,15 +3,13 @@ package watcher
 import (
 	"context"
 	"errors"
-	"fmt"
 	"math/big"
 
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/scroll-tech/go-ethereum/common/hexutil"
+	"github.com/scroll-tech/go-ethereum/consensus/misc"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/scroll-tech/go-ethereum/rpc"
 	"gorm.io/gorm"
 
 	"scroll-tech/common/types"
@@ -22,8 +20,7 @@ import (
 // L1WatcherClient will listen for smart contract events from Eth L1.
 type L1WatcherClient struct {
 	ctx        context.Context
-	rpcClient  *rpc.Client       // Raw RPC client
-	client     *ethclient.Client // Go SDK RPC client
+	client     *ethclient.Client
 	l1BlockOrm *orm.L1Block
 
 	// The height of the block that the watcher has retrieved header rlp
@@ -33,7 +30,7 @@ type L1WatcherClient struct {
 }
 
 // NewL1WatcherClient returns a new instance of L1WatcherClient.
-func NewL1WatcherClient(ctx context.Context, rpcClient *rpc.Client, startHeight uint64, db *gorm.DB, reg prometheus.Registerer) *L1WatcherClient {
+func NewL1WatcherClient(ctx context.Context, client *ethclient.Client, startHeight uint64, db *gorm.DB, reg prometheus.Registerer) *L1WatcherClient {
 	l1BlockOrm := orm.NewL1Block(db)
 	savedL1BlockHeight, err := l1BlockOrm.GetLatestL1BlockHeight(ctx)
 	if err != nil {
@@ -46,8 +43,7 @@ func NewL1WatcherClient(ctx context.Context, rpcClient *rpc.Client, startHeight
 
 	return &L1WatcherClient{
 		ctx:        ctx,
-		rpcClient:  rpcClient,
-		client:     ethclient.NewClient(rpcClient),
+		client:     client,
 		l1BlockOrm: l1BlockOrm,
 
 		processedBlockHeight: savedL1BlockHeight,
@@ -84,17 +80,7 @@ func (w *L1WatcherClient) FetchBlockHeader(blockHeight uint64) error {
 
 	var blobBaseFee uint64
 	if excess := block.ExcessBlobGas; excess != nil {
-		// Leave it up to the L1 node to compute the correct blob base fee.
-		// Previously we would compute it locally using `CalcBlobFee`, but
-		// that approach requires syncing any future L1 configuration changes.
-		// Note: The fetched blob base fee might not correspond to the block
-		// that we fetched in the previous step, but this is acceptable.
-		var blobBaseFeeHex hexutil.Big
-		if err := w.rpcClient.CallContext(w.ctx, &blobBaseFeeHex, "eth_blobBaseFee"); err != nil {
-			return fmt.Errorf("failed to call eth_blobBaseFee, err: %w", err)
-		}
-		// A correct L1 node could not return a value that overflows uint64
-		blobBaseFee = blobBaseFeeHex.ToInt().Uint64()
+		blobBaseFee = misc.CalcBlobFee(*excess).Uint64()
 	}
 
 	l1Block := orm.L1Block{

rollup/internal/controller/watcher/l1_watcher_test.go

@@ -21,10 +21,10 @@ import (
 
 func setupL1Watcher(t *testing.T) (*L1WatcherClient, *gorm.DB) {
 	db := setupDB(t)
-	l1RawClient, err := testApps.GetPoSL1Client()
+	client, err := testApps.GetPoSL1Client()
 	assert.NoError(t, err)
 	l1Cfg := cfg.L1Config
-	watcher := NewL1WatcherClient(context.Background(), l1RawClient, l1Cfg.StartHeight, db, nil)
+	watcher := NewL1WatcherClient(context.Background(), client, l1Cfg.StartHeight, db, nil)
 	return watcher, db
 }
 

rollup/internal/controller/watcher/l2_watcher.go

@@ -8,7 +8,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/event"
 	"github.com/scroll-tech/go-ethereum/log"
@@ -25,7 +24,6 @@ type L2WatcherClient struct {
 	event.Feed
 
 	*ethclient.Client
-	rpcCli *rpc.Client
 
 	l2BlockOrm *orm.L2Block
 
@@ -34,19 +32,16 @@ type L2WatcherClient struct {
 	messageQueueAddress  common.Address
 	withdrawTrieRootSlot common.Hash
 
-	validiumMode bool
-
 	metrics *l2WatcherMetrics
 
 	chainCfg *params.ChainConfig
 }
 
 // NewL2WatcherClient take a l2geth instance to generate a l2watcherclient instance
-func NewL2WatcherClient(ctx context.Context, client *rpc.Client, confirmations rpc.BlockNumber, messageQueueAddress common.Address, withdrawTrieRootSlot common.Hash, chainCfg *params.ChainConfig, db *gorm.DB, validiumMode bool, reg prometheus.Registerer) *L2WatcherClient {
+func NewL2WatcherClient(ctx context.Context, client *ethclient.Client, confirmations rpc.BlockNumber, messageQueueAddress common.Address, withdrawTrieRootSlot common.Hash, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *L2WatcherClient {
 	return &L2WatcherClient{
 		ctx:    ctx,
-		Client: ethclient.NewClient(client),
-		rpcCli: client,
+		Client: client,
 
 		l2BlockOrm: orm.NewL2Block(db),
 
@@ -55,8 +50,6 @@ func NewL2WatcherClient(ctx context.Context, client *rpc.Client, confirmations r
 		messageQueueAddress:  messageQueueAddress,
 		withdrawTrieRootSlot: withdrawTrieRootSlot,
 
-		validiumMode: validiumMode,
-
 		metrics: initL2WatcherMetrics(reg),
 
 		chainCfg: chainCfg,
@@ -102,51 +95,21 @@ func (w *L2WatcherClient) GetAndStoreBlocks(ctx context.Context, from, to uint64
 			return fmt.Errorf("failed to BlockByNumber: %v. number: %v", err, number)
 		}
 
-		blockTxs := block.Transactions()
-
 		var count int
-		for _, tx := range blockTxs {
+		for _, tx := range block.Transactions() {
 			if tx.IsL1MessageTx() {
 				count++
 			}
 		}
 		log.Info("retrieved block", "height", block.Header().Number, "hash", block.Header().Hash().String(), "L1 message count", count)
 
-		// use original (encrypted) L1 message txs in validium mode
-		if w.validiumMode {
-			var txs []*types.Transaction
-
-			if count > 0 {
-				log.Info("Fetching encrypted messages in validium mode")
-				err = w.rpcCli.CallContext(ctx, &txs, "scroll_getL1MessagesInBlock", block.Hash(), "synced")
-				if err != nil {
-					return fmt.Errorf("failed to get L1 messages: %v, block hash: %v", err, block.Hash().Hex())
-				}
-			}
-
-			// sanity check
-			if len(txs) != count {
-				return fmt.Errorf("L1 message count mismatch: expected %d, got %d", count, len(txs))
-			}
-
-			for ii := 0; ii < count; ii++ {
-				// sanity check
-				if blockTxs[ii].AsL1MessageTx().QueueIndex != txs[ii].AsL1MessageTx().QueueIndex {
-					return fmt.Errorf("L1 message queue index mismatch at index %d: expected %d, got %d", ii, blockTxs[ii].AsL1MessageTx().QueueIndex, txs[ii].AsL1MessageTx().QueueIndex)
-				}
-
-				log.Info("Replacing L1 message tx in validium mode", "index", ii, "queueIndex", txs[ii].AsL1MessageTx().QueueIndex, "decryptedTxHash", blockTxs[ii].Hash().Hex(), "originalTxHash", txs[ii].Hash().Hex())
-				blockTxs[ii] = txs[ii]
-			}
-		}
-
 		withdrawRoot, err3 := w.StorageAt(ctx, w.messageQueueAddress, w.withdrawTrieRootSlot, big.NewInt(int64(number)))
 		if err3 != nil {
 			return fmt.Errorf("failed to get withdrawRoot: %v. number: %v", err3, number)
 		}
 		blocks = append(blocks, &encoding.Block{
 			Header:       block.Header(),
-			Transactions: encoding.TxsToTxsData(blockTxs),
+			Transactions: encoding.TxsToTxsData(block.Transactions()),
 			WithdrawRoot: common.BytesToHash(withdrawRoot),
 		})
 	}

rollup/internal/controller/watcher/l2_watcher_test.go

@@ -2,13 +2,12 @@ package watcher
 
 import (
 	"context"
-	"os"
 	"testing"
 
 	"gorm.io/gorm"
 
 	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/stretchr/testify/assert"
 
@@ -21,7 +20,7 @@ import (
 func setupL2Watcher(t *testing.T) (*L2WatcherClient, *gorm.DB) {
 	db := setupDB(t)
 	l2cfg := cfg.L2Config
-	watcher := NewL2WatcherClient(context.Background(), l2Rpc, l2cfg.Confirmations, l2cfg.L2MessageQueueAddress, l2cfg.WithdrawTrieRootSlot, nil, db, false, nil)
+	watcher := NewL2WatcherClient(context.Background(), l2Cli, l2cfg.Confirmations, l2cfg.L2MessageQueueAddress, l2cfg.WithdrawTrieRootSlot, nil, db, nil)
 	return watcher, db
 }
 
@@ -35,7 +34,7 @@ func testFetchRunningMissingBlocks(t *testing.T) {
 		if err != nil {
 			return false
 		}
-		wc := prepareWatcherClient(l2Rpc, db)
+		wc := prepareWatcherClient(l2Cli, db)
 		wc.TryFetchRunningMissingBlocks(latestHeight)
 		fetchedHeight, err := l2BlockOrm.GetL2BlocksLatestHeight(context.Background())
 		return err == nil && fetchedHeight == latestHeight
@@ -43,32 +42,7 @@ func testFetchRunningMissingBlocks(t *testing.T) {
 	assert.True(t, ok)
 }
 
-func prepareWatcherClient(l2Cli *rpc.Client, db *gorm.DB) *L2WatcherClient {
+func prepareWatcherClient(l2Cli *ethclient.Client, db *gorm.DB) *L2WatcherClient {
 	confirmations := rpc.LatestBlockNumber
-	return NewL2WatcherClient(context.Background(), l2Cli, confirmations, common.Address{}, common.Hash{}, nil, db, false, nil)
-}
-
-// New test for raw RPC GetBlockByHash from an endpoint URL in env.
-func TestRawRPCGetBlockByHash(t *testing.T) {
-	url := os.Getenv("RPC_ENDPOINT_URL")
-	if url == "" {
-		t.Log("warn: RPC_ENDPOINT_URL not set, skipping raw RPC test")
-		t.Skip("missing RPC_ENDPOINT_URL")
-	}
-
-	ctx := context.Background()
-	cli, err := rpc.DialContext(ctx, url)
-	if err != nil {
-		t.Fatalf("failed to dial RPC endpoint %s: %v", url, err)
-	}
-	defer cli.Close()
-
-	var txs []*types.Transaction
-	blkHash := common.HexToHash("0xc80cf12883341827d71c08f734ba9a9d6da7e59eb16921d26e6706887e552c74")
-	err = cli.CallContext(ctx, &txs, "scroll_getL1MessagesInBlock", blkHash, "synced")
-	if err != nil {
-		t.Logf("scroll_getL1MessagesInBlock failed: err=%v", err)
-		t.Fail()
-	}
-	t.Log(txs, txs[0].Hash())
+	return NewL2WatcherClient(context.Background(), l2Cli, confirmations, common.Address{}, common.Hash{}, nil, db, nil)
 }

rollup/internal/controller/watcher/watcher_test.go

@@ -8,7 +8,6 @@ import (
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 
@@ -28,7 +27,6 @@ var (
 
 	// l2geth client
 	l2Cli *ethclient.Client
-	l2Rpc *rpc.Client
 
 	// block trace
 	block1 *encoding.Block
@@ -64,9 +62,8 @@ func setupEnv(t *testing.T) (err error) {
 	}
 
 	// Create l2geth client.
-	l2Rpc, err = testApps.GetL2Client()
+	l2Cli, err = testApps.GetL2GethClient()
 	assert.NoError(t, err)
-	l2Cli = ethclient.NewClient(l2Rpc)
 
 	block1 = readBlockFromJSON(t, "../../../testdata/blockTrace_02.json")
 	block2 = readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")

rollup/internal/utils/utils.go

@@ -8,7 +8,6 @@ import (
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/crypto"
-	"github.com/scroll-tech/go-ethereum/log"
 )
 
 // ChunkMetrics indicates the metrics for proposing a chunk.
@@ -139,26 +138,6 @@ func encodeBatchHeaderValidium(b *encoding.Batch, codecVersion encoding.CodecVer
 	// TODO: This is a temporary solution, we might use a larger commitment in the future
 	lastBlock := b.Blocks[len(b.Blocks)-1]
 	commitment := lastBlock.Header.Hash()
-	stateRoot := b.StateRoot()
-
-	// Temporary workaround for the wrong genesis state root configuration issue.
-	if lastBlock.Header.Number.Uint64() == 0 {
-		if commitment == common.HexToHash("0x76a8e1359fe1a51ec3917ca98dec95ba005f1a73bcdbc2c7f87c7683e828fbb1") && stateRoot == common.HexToHash("0x08d535cc60f40af5dd3b31e0998d7567c2d568b224bed2ba26070aeb078d1339") {
-			// cloak-xen/sepolia
-			stateRoot = common.HexToHash("0x0711f02d6f85b0597c4705298e01ee27159fdd8bd8bdeda670ae8b9073091246")
-		} else if commitment == common.HexToHash("0x8005a02271085eaded2565f3e252013cd9d3cd0a4775d89f9ba4224289671276") && stateRoot == common.HexToHash("0x08d535cc60f40af5dd3b31e0998d7567c2d568b224bed2ba26070aeb078d1339") {
-			// cloak-xen/mainnet
-			stateRoot = common.HexToHash("0x8da1aaf41660ddf7870ab5ff4f6a3ab4b2e652568d341ede87ada56aad5fb097")
-		} else if commitment == common.HexToHash("0xa7e50dfc812039410c2009c74cdcb0c0797aa5485dec062985eaa43b17d333ea") && stateRoot == common.HexToHash("0x08d535cc60f40af5dd3b31e0998d7567c2d568b224bed2ba26070aeb078d1339") {
-			// cloak-etherfi/sepolia
-			stateRoot = common.HexToHash("0x7b44ea23770dda8810801779eb6847d56be0399e35de7c56465ccf8b7578ddf6")
-		} else if commitment == common.HexToHash("0xeccf4fab24f8b5dd3b72667c6bf5e28b17ccffdea01e3e5c08f393edaa9e7657") && stateRoot == common.HexToHash("0x08d535cc60f40af5dd3b31e0998d7567c2d568b224bed2ba26070aeb078d1339") {
-			// cloak-shiga/sepolia
-			stateRoot = common.HexToHash("0x05973227854ac82c22f164ed3d4510b7df516a0eecdfd9bed5f2446efc9994b9")
-		}
-
-		log.Warn("Using genesis state root", "stateRoot", stateRoot.Hex())
-	}
 
 	// Batch header field sizes
 	const (
@@ -185,22 +164,10 @@ func encodeBatchHeaderValidium(b *encoding.Batch, codecVersion encoding.CodecVer
 		commitmentOffset   = withdrawRootOffset + withdrawRootSize
 	)
 
-	var version uint8
-	if codecVersion == encoding.CodecV8 || codecVersion == encoding.CodecV9 || codecVersion == encoding.CodecV10 {
-		// Validium version line starts with v1,
-		// but rollup-relayer behavior follows v8.
-		version = 1
-	} else if codecVersion == encoding.CodecV0 {
-		// Special case for genesis batch
-		version = 0
-	} else {
-		return nil, common.Hash{}, fmt.Errorf("unexpected codec version %d for batch %v in validium mode", codecVersion, b.Index)
-	}
-
-	batchBytes[versionOffset] = version                                                                                    // version
+	batchBytes[versionOffset] = uint8(codecVersion)                                                                        // version
 	binary.BigEndian.PutUint64(batchBytes[indexOffset:indexOffset+indexSize], b.Index)                                     // batch index
 	copy(batchBytes[parentHashOffset:parentHashOffset+parentHashSize], b.ParentBatchHash[0:parentHashSize])                // parentBatchHash
-	copy(batchBytes[stateRootOffset:stateRootOffset+stateRootSize], stateRoot.Bytes()[0:stateRootSize])                    // postStateRoot
+	copy(batchBytes[stateRootOffset:stateRootOffset+stateRootSize], b.StateRoot().Bytes()[0:stateRootSize])                // postStateRoot
 	copy(batchBytes[withdrawRootOffset:withdrawRootOffset+withdrawRootSize], b.WithdrawRoot().Bytes()[0:withdrawRootSize]) // postWithdrawRoot
 	copy(batchBytes[commitmentOffset:commitmentOffset+commitmentSize], commitment[0:commitmentSize])                       // data commitment
 

rollup/tests/bridge_test.go

@@ -19,7 +19,6 @@ import (
 	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 
@@ -38,9 +37,8 @@ var (
 	rollupApp *bcmd.MockApp
 
 	// clients
-	l1RawClient *rpc.Client
-	l1Client    *ethclient.Client
-	l2Client    *ethclient.Client
+	l1Client *ethclient.Client
+	l2Client *ethclient.Client
 
 	l1Auth *bind.TransactOpts
 	l2Auth *bind.TransactOpts
@@ -93,9 +91,8 @@ func setupEnv(t *testing.T) {
 	assert.NoError(t, testApps.StartPoSL1Container())
 	rollupApp = bcmd.NewRollupApp(testApps, "../conf/config.json")
 
-	l1RawClient, err = testApps.GetPoSL1Client()
+	l1Client, err = testApps.GetPoSL1Client()
 	assert.NoError(t, err)
-	l1Client = ethclient.NewClient(l1RawClient)
 	l2Client, err = testApps.GetL2GethClient()
 	assert.NoError(t, err)
 	l1GethChainID, err = l1Client.ChainID(context.Background())

rollup/tests/gas_oracle_test.go

@@ -36,7 +36,7 @@ func testImportL1GasPrice(t *testing.T) {
 	// Create L1Watcher
 	startHeight, err := l1Client.BlockNumber(context.Background())
 	assert.NoError(t, err)
-	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1RawClient, startHeight-1, db, nil)
+	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1Client, startHeight-1, db, nil)
 
 	// fetch new blocks
 	number, err := l1Client.BlockNumber(context.Background())
@@ -110,7 +110,7 @@ func testImportDefaultL1GasPriceDueToL1GasPriceSpike(t *testing.T) {
 	// Create L1Watcher
 	startHeight, err := l1Client.BlockNumber(context.Background())
 	assert.NoError(t, err)
-	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1RawClient, startHeight-2, db, nil)
+	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1Client, startHeight-2, db, nil)
 
 	// fetch new blocks
 	number, err := l1Client.BlockNumber(context.Background())

rollup/tests/integration_tool/block_fetching.go

@@ -1,84 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"math/big"
-
-	"github.com/scroll-tech/da-codec/encoding"
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/scroll-tech/go-ethereum/rpc"
-)
-
-func fetchAndStoreBlocks(ctx context.Context, from, to uint64) ([]*encoding.Block, error) {
-	validiumMode := cfg.ValidiumMode
-	cfg := cfg.FetchConfig
-	client, err := rpc.Dial(cfg.Endpoint)
-	if err != nil {
-		return nil, fmt.Errorf("failed to connect l2 geth, endpoint %s, err %v", cfg.Endpoint, err)
-	}
-	defer client.Close()
-
-	ethCli := ethclient.NewClient(client)
-	var blocks []*encoding.Block
-	for number := from; number <= to; number++ {
-		log.Debug("retrieving block", "height", number)
-		block, err := ethCli.BlockByNumber(ctx, new(big.Int).SetUint64(number))
-		if err != nil {
-			return nil, fmt.Errorf("failed to BlockByNumber: %v. number: %v", err, number)
-		}
-
-		blockTxs := block.Transactions()
-
-		var count int
-		for _, tx := range blockTxs {
-			if tx.IsL1MessageTx() {
-				count++
-			}
-		}
-		log.Info("retrieved block", "height", block.Header().Number, "hash", block.Header().Hash().String(), "L1 message count", count)
-
-		// use original (encrypted) L1 message txs in validium mode
-		if validiumMode {
-			var txs []*types.Transaction
-
-			if count > 0 {
-				log.Info("Fetching encrypted messages in validium mode")
-				err = client.CallContext(ctx, &txs, "scroll_getL1MessagesInBlock", block.Hash(), "synced")
-				if err != nil {
-					return nil, fmt.Errorf("failed to get L1 messages: %v, block hash: %v", err, block.Hash().Hex())
-				}
-			}
-
-			// sanity check
-			if len(txs) != count {
-				return nil, fmt.Errorf("L1 message count mismatch: expected %d, got %d", count, len(txs))
-			}
-
-			for ii := 0; ii < count; ii++ {
-				// sanity check
-				if blockTxs[ii].AsL1MessageTx().QueueIndex != txs[ii].AsL1MessageTx().QueueIndex {
-					return nil, fmt.Errorf("L1 message queue index mismatch at index %d: expected %d, got %d", ii, blockTxs[ii].AsL1MessageTx().QueueIndex, txs[ii].AsL1MessageTx().QueueIndex)
-				}
-
-				log.Info("Replacing L1 message tx in validium mode", "index", ii, "queueIndex", txs[ii].AsL1MessageTx().QueueIndex, "decryptedTxHash", blockTxs[ii].Hash().Hex(), "originalTxHash", txs[ii].Hash().Hex())
-				blockTxs[ii] = txs[ii]
-			}
-		}
-
-		withdrawRoot, err3 := ethCli.StorageAt(ctx, cfg.L2MessageQueueAddress, cfg.WithdrawTrieRootSlot, big.NewInt(int64(number)))
-		if err3 != nil {
-			return nil, fmt.Errorf("failed to get withdrawRoot: %v. number: %v", err3, number)
-		}
-		blocks = append(blocks, &encoding.Block{
-			Header:       block.Header(),
-			Transactions: encoding.TxsToTxsData(blockTxs),
-			WithdrawRoot: common.BytesToHash(withdrawRoot),
-		})
-	}
-
-	return blocks, nil
-}

rollup/tests/integration_tool/imports.go

@@ -10,11 +10,9 @@ import (
 
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/log"
 
 	"scroll-tech/common/database"
-	ctypes "scroll-tech/common/types"
 
 	"scroll-tech/rollup/internal/orm"
 	"scroll-tech/rollup/internal/utils"
@@ -42,21 +40,12 @@ func randomPickKfromN(n, k int, rng *rand.Rand) []int {
 	return ret
 }
 
-func importData(ctx context.Context, beginBlk, endBlk uint64, blocks []*encoding.Block, chkNum, batchNum, bundleNum int, seed int64) (*importRecord, error) {
+func importData(ctx context.Context, beginBlk, endBlk uint64, chkNum, batchNum, bundleNum int, seed int64) (*importRecord, error) {
 
 	db, err := database.InitDB(cfg.DBConfig)
 	if err != nil {
 		return nil, err
 	}
-
-	if len(blocks) > 0 {
-		log.Info("import block")
-		blockOrm := orm.NewL2Block(db)
-		if err := blockOrm.InsertL2Blocks(ctx, blocks); err != nil {
-			return nil, err
-		}
-	}
-
 	ret := &importRecord{}
 	// Create a new random source with the provided seed
 	source := rand.NewSource(seed)
@@ -73,9 +62,6 @@ func importData(ctx context.Context, beginBlk, endBlk uint64, blocks []*encoding
 	log.Info("separated chunk", "border", chkSep)
 	head := beginBlk
 	lastMsgHash := common.Hash{}
-	if err := initLeadingChunk(ctx, db, beginBlk, endBlk, lastMsgHash); err != nil {
-		return nil, err
-	}
 
 	ormChks := make([]*orm.Chunk, 0, chkNum)
 	encChks := make([]*encoding.Chunk, 0, chkNum)
@@ -132,73 +118,6 @@ func importData(ctx context.Context, beginBlk, endBlk uint64, blocks []*encoding
 	return ret, nil
 }
 
-func initLeadingChunk(ctx context.Context, db *gorm.DB, beginBlk, endBlk uint64, prevMsgQueueHash common.Hash) error {
-	blockOrm := orm.NewL2Block(db)
-	if beginBlk <= 1 {
-		log.Info("start from genesis, no need to insert leading chunk")
-		return nil
-	}
-
-	var l1MsgPoppedBefore uint64
-	blks, err := blockOrm.GetL2BlocksGEHeight(ctx, beginBlk, int(endBlk-beginBlk+1))
-	if err != nil {
-		return err
-	}
-	for i, block := range blks {
-		for _, tx := range block.Transactions {
-			if tx.Type == types.L1MessageTxType {
-				l1MsgPoppedBefore = tx.Nonce
-				log.Info("search first l1 nonce", "index", l1MsgPoppedBefore, "blk", beginBlk+uint64(i))
-				break
-			}
-		}
-		if l1MsgPoppedBefore != 0 {
-			break
-		}
-	}
-
-	if l1MsgPoppedBefore == 0 {
-		log.Info("no l1 message in target blks, no need for leading chunk")
-		return nil
-	}
-
-	prevBlks, err := blockOrm.GetL2BlocksGEHeight(ctx, beginBlk-1, 1)
-	if err != nil {
-		log.Error("get prev block fail, we also need at least 1 block before selected range", "need block", beginBlk-1, "err", err)
-		return err
-	}
-
-	// we use InsertTestChunkForProposerTool to insert leading chunk, which do not calculate l1 message
-	// so we simply exclude l1 in this hacked chunk
-	prevBlk := prevBlks[0]
-	var trimLen int
-	for _, tx := range prevBlk.Transactions {
-		if tx.Type != types.L1MessageTxType {
-			prevBlk.Transactions[trimLen] = tx
-			trimLen++
-		}
-	}
-	prevBlk.Transactions = prevBlk.Transactions[:trimLen]
-
-	postHash, err := encoding.MessageQueueV2ApplyL1MessagesFromBlocks(prevMsgQueueHash, prevBlks)
-	if err != nil {
-		return err
-	}
-	chunkOrm := orm.NewChunk(db)
-
-	log.Info("Insert leading chunk with prev block", "msgPoppedBefore", l1MsgPoppedBefore)
-	leadingChunk, err := chunkOrm.InsertTestChunkForProposerTool(ctx, &encoding.Chunk{
-		Blocks:                 prevBlks,
-		PrevL1MessageQueueHash: prevMsgQueueHash,
-		PostL1MessageQueueHash: postHash,
-	}, codecCfg, l1MsgPoppedBefore)
-	if err != nil {
-		return err
-	}
-
-	return chunkOrm.UpdateProvingStatus(ctx, leadingChunk.Hash, ctypes.ProvingTaskProvedDEPRECATED)
-}
-
 func importChunk(ctx context.Context, db *gorm.DB, beginBlk, endBlk uint64, prevMsgQueueHash common.Hash) (*orm.Chunk, *encoding.Chunk, error) {
 	nblk := int(endBlk-beginBlk) + 1
 	blockOrm := orm.NewL2Block(db)
@@ -264,13 +183,9 @@ func importBatch(ctx context.Context, db *gorm.DB, chks []*orm.Chunk, encChks []
 		ParentBatchHash:            parentHash,
 		Chunks:                     encChks,
 		Blocks:                     blks,
-		PrevL1MessageQueueHash:     encChks[0].PrevL1MessageQueueHash,
-		PostL1MessageQueueHash:     encChks[len(encChks)-1].PostL1MessageQueueHash,
 	}
 
-	dbBatch, err := batchOrm.InsertBatch(ctx, batch, codecCfg, utils.BatchMetrics{
-		ValidiumMode: cfg.ValidiumMode,
-	})
+	dbBatch, err := batchOrm.InsertBatch(ctx, batch, codecCfg, utils.BatchMetrics{})
 	if err != nil {
 		return nil, err
 	}

rollup/tests/integration_tool/main.go

@@ -10,7 +10,6 @@ import (
 	"strings"
 
 	"github.com/scroll-tech/da-codec/encoding"
-	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/urfave/cli/v2"
 
@@ -21,7 +20,7 @@ import (
 
 var app *cli.App
 var cfg *config
-var codecCfg encoding.CodecVersion = encoding.CodecV9
+var codecCfg encoding.CodecVersion = encoding.CodecV8
 
 var outputNumFlag = cli.StringFlag{
 	Name:  "counts",
@@ -41,6 +40,12 @@ var seedFlag = cli.Int64Flag{
 	Value: 0,
 }
 
+var codecFlag = cli.IntFlag{
+	Name:  "codec",
+	Usage: "codec version, valid from 6, default(auto) is 0",
+	Value: 0,
+}
+
 func parseThreeIntegers(value string) (int, int, int, error) {
 	// Split the input string by comma
 	parts := strings.Split(value, ",")
@@ -79,21 +84,9 @@ func parseThreeIntegers(value string) (int, int, int, error) {
 	return values[0], values[1], values[2], nil
 }
 
-type fetchConfig struct {
-	// node url.
-	Endpoint string `json:"endpoint"`
-	// The L2MessageQueue contract address deployed on layer 2 chain.
-	L2MessageQueueAddress common.Address `json:"l2_message_queue_address"`
-	// The WithdrawTrieRootSlot in L2MessageQueue contract.
-	WithdrawTrieRootSlot common.Hash `json:"withdraw_trie_root_slot,omitempty"`
-}
-
 // load a comptabile type of config for rollup
 type config struct {
-	DBConfig     *database.Config `json:"db_config"`
-	FetchConfig  *fetchConfig     `json:"fetch_config,omitempty"`
-	ValidiumMode bool             `json:"validium_mode"`
-	CodecVersion int              `json:"codec_version"`
+	DBConfig *database.Config `json:"db_config"`
 }
 
 func init() {
@@ -103,7 +96,7 @@ func init() {
 	app.Name = "integration-test-tool"
 	app.Usage = "The Scroll L2 Integration Test Tool"
 	app.Version = version.Version
-	app.Flags = append(app.Flags, &seedFlag, &outputNumFlag, &outputPathFlag)
+	app.Flags = append(app.Flags, &codecFlag, &seedFlag, &outputNumFlag, &outputPathFlag)
 	app.Flags = append(app.Flags, utils.CommonFlags...)
 	app.Before = func(ctx *cli.Context) error {
 		if err := utils.LogSetup(ctx); err != nil {
@@ -126,13 +119,13 @@ func newConfig(file string) (*config, error) {
 		return nil, err
 	}
 
-	loadCfg := &config{}
-	err = json.Unmarshal(buf, loadCfg)
+	cfg := &config{}
+	err = json.Unmarshal(buf, cfg)
 	if err != nil {
 		return nil, err
 	}
 
-	return loadCfg, nil
+	return cfg, nil
 }
 
 func action(ctx *cli.Context) error {
@@ -141,20 +134,17 @@ func action(ctx *cli.Context) error {
 		return fmt.Errorf("specify begin and end block number")
 	}
 
-	if cfg.CodecVersion != 0 {
-		switch cfg.CodecVersion {
+	codecFl := ctx.Int(codecFlag.Name)
+	if codecFl != 0 {
+		switch codecFl {
 		case 6:
 			codecCfg = encoding.CodecV6
 		case 7:
 			codecCfg = encoding.CodecV7
 		case 8:
 			codecCfg = encoding.CodecV8
-		case 9:
-			codecCfg = encoding.CodecV9
-		case 10:
-			codecCfg = encoding.CodecV10
 		default:
-			return fmt.Errorf("invalid codec version %d", cfg.CodecVersion)
+			return fmt.Errorf("invalid codec version %d", codecFl)
 		}
 		log.Info("set codec", "version", codecCfg)
 	}
@@ -168,14 +158,6 @@ func action(ctx *cli.Context) error {
 		return fmt.Errorf("invalid begin block number: %w", err)
 	}
 
-	var import_blocks []*encoding.Block
-	if cfg.FetchConfig != nil {
-		import_blocks, err = fetchAndStoreBlocks(ctx.Context, beginBlk, endBlk)
-		if err != nil {
-			return err
-		}
-	}
-
 	chkNum, batchNum, bundleNum, err := parseThreeIntegers(ctx.String(outputNumFlag.Name))
 	if err != nil {
 		return err
@@ -189,7 +171,7 @@ func action(ctx *cli.Context) error {
 
 	outputPath := ctx.String(outputPathFlag.Name)
 	log.Info("output", "Seed", seed, "file", outputPath)
-	ret, err := importData(ctx.Context, beginBlk, endBlk, import_blocks, chkNum, batchNum, bundleNum, seed)
+	ret, err := importData(ctx.Context, beginBlk, endBlk, chkNum, batchNum, bundleNum, seed)
 	if err != nil {
 		return err
 	}

tests/integration-test/go.mod

@@ -5,8 +5,8 @@ go 1.22
 toolchain go1.22.2
 
 require (
-	github.com/scroll-tech/da-codec v0.10.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f
+	github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587
 	github.com/stretchr/testify v1.10.0
 	gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde
 )
@@ -16,10 +16,10 @@ require (
 	github.com/btcsuite/btcd v0.20.1-beta // indirect
 	github.com/consensys/bavard v0.1.29 // indirect
 	github.com/consensys/gnark-crypto v0.16.0 // indirect
-	github.com/crate-crypto/go-eth-kzg v1.4.0 // indirect
+	github.com/crate-crypto/go-kzg-4844 v1.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea // indirect
-	github.com/ethereum/c-kzg-4844/v2 v2.1.5 // indirect
+	github.com/ethereum/c-kzg-4844 v1.0.3 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
@@ -34,7 +34,7 @@ require (
 	github.com/rjeczalik/notify v0.9.1 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
-	github.com/supranational/blst v0.3.15 // indirect
+	github.com/supranational/blst v0.3.13 // indirect
 	github.com/tklauser/go-sysconf v0.3.14 // indirect
 	github.com/tklauser/numcpus v0.9.0 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect

tests/integration-test/go.sum

@@ -22,8 +22,8 @@ github.com/consensys/bavard v0.1.29 h1:fobxIYksIQ+ZSrTJUuQgu+HIJwclrAPcdXqd7H2hh
 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/crate-crypto/go-eth-kzg v1.4.0 h1:WzDGjHk4gFg6YzV0rJOAsTK4z3Qkz5jd4RE3DAvPFkg=
-github.com/crate-crypto/go-eth-kzg v1.4.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI=
+github.com/crate-crypto/go-kzg-4844 v1.1.0 h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4=
+github.com/crate-crypto/go-kzg-4844 v1.1.0/go.mod h1:JolLjpSff1tCCJKaJx4psrlEdlXuJEC996PL3tTAFks=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -31,8 +31,8 @@ github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea h1:j4317fAZh7X
 github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ=
 github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
 github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
-github.com/ethereum/c-kzg-4844/v2 v2.1.5 h1:aVtoLK5xwJ6c5RiqO8g8ptJ5KU+2Hdquf6G3aXiHh5s=
-github.com/ethereum/c-kzg-4844/v2 v2.1.5/go.mod h1:u59hRTTah4Co6i9fDWtiCjTrblJv0UwsqZKCc0GfgUs=
+github.com/ethereum/c-kzg-4844 v1.0.3 h1:IEnbOHwjixW2cTvKRUlAAUOeleV7nNM/umJR+qy4WDs=
+github.com/ethereum/c-kzg-4844 v1.0.3/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
@@ -93,18 +93,18 @@ 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.10.0 h1:IPHxyTyXTWPV0Q+DZ08cod2fWkhUvrfysmj/VBpB+WU=
-github.com/scroll-tech/da-codec v0.10.0/go.mod h1:MBlIP4wCXPcUDZ/Ci2B7n/2IbVU1WBo9OTFTZ5ffE0U=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f h1:j6SjP98MoWFFX9TwB1/nFYEkayqHQsrtE66Ll2C+oT0=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20251128092113-8629f088d78f/go.mod h1:Aa/kD1XB+OV/7rRxMQrjcPCB4b0pKyLH0gsTrtuHi38=
+github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178 h1:4utngmJHXSOS5FoSdZhEV1xMRirpArbXvyoCZY9nYj0=
+github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587 h1:wG1+gb+K4iLtxAHhiAreMdIjP5x9hB64duraN2+u1QU=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587/go.mod h1:YyfB2AyAtphlbIuDQgaxc2b9mo0zE4EBA1+qtXvzlmg=
 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=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
 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/supranational/blst v0.3.15 h1:rd9viN6tfARE5wv3KZJ9H8e1cg0jXW8syFCcsbHa76o=
-github.com/supranational/blst v0.3.15/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
+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=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
 github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU=

tests/prover-e2e/.gitignore

@@ -1,3 +1,2 @@
 build/*
-testset.json
-conf
+testset.json

tests/prover-e2e/Makefile

@@ -1,38 +1,20 @@
 .PHONY: clean setup_db test_tool all check_vars
 
-include conf/.make.env
 GOOSE_CMD?=goose
-ifndef BEGIN_BLOCK
-$(error BEGIN_BLOCK is not set. Define it in .make.env or pass BEGIN_BLOCK=<start_block>)
-endif
-ifndef END_BLOCK
-$(error END_BLOCK is not set. Define it in .make.env or pass END_BLOCK=<end_block>)
-endif
 
-BLOCK_PRE_MIGRATIONS := $(wildcard conf/*.sql)
-.OPTIONAL: $(BLOCK_PRE_MIGRATIONS)
 
 all: setup_db test_tool import_data
 
 clean:
 	docker compose down
 
-conf:
-	@echo "Please link sepolia or cloak-xen as conf"
-	exit 1
-
-check_vars: | conf
+check_vars:
 	@if [ -z "$(BEGIN_BLOCK)" ] || [ -z "$(END_BLOCK)" ]; then \
         echo "Error: BEGIN_BLOCK and END_BLOCK must be defined"; \
         echo "Usage: make import_data BEGIN_BLOCK=<start_block> END_BLOCK=<end_block>"; \
         exit 1; \
     fi
 
-migration_blocks: $(BLOCK_PRE_MIGRATIONS)
-ifneq ($(strip $(BLOCK_PRE_MIGRATIONS)),)
-	GOOSE_MIGRATION_DIR=conf ${GOOSE_CMD} up-to 100
-endif
-
 setup_db: clean
 	docker compose up --detach
 	@echo "Waiting for PostgreSQL to be ready..."
@@ -50,21 +32,15 @@ setup_db: clean
         fi; \
     done	
 	${GOOSE_CMD} up
-
-reset_db:
-	${GOOSE_CMD} down-to 0
-	${GOOSE_CMD} up
+	GOOSE_MIGRATION_DIR=./ ${GOOSE_CMD} up-to 100
 
 test_tool:
 	go build -o $(PWD)/build/bin/e2e_tool ../../rollup/tests/integration_tool
 
 build/bin/e2e_tool: test_tool
 
-import_data: build/bin/e2e_tool check_vars migration_blocks
-	build/bin/e2e_tool --config conf/config.json ${BEGIN_BLOCK} ${END_BLOCK}
+import_data_euclid: build/bin/e2e_tool check_vars
+	build/bin/e2e_tool --config ./config.json --codec 7 ${BEGIN_BLOCK} ${END_BLOCK}
 
-reimport_data: reset_db import_data
-
-coordinator_setup:
-	SCROLL_FORK_NAME=${SCROLL_FORK_NAME} $(MAKE) -C ../../coordinator localsetup
-	cp -f conf/genesis.json ../../coordinator/build/bin/conf
+import_data: build/bin/e2e_tool check_vars
+	build/bin/e2e_tool --config ./config.json --codec 8 ${BEGIN_BLOCK} ${END_BLOCK}    

tests/prover-e2e/README.md

@@ -1,16 +1,12 @@
 ## A new e2e test tool to setup a local environment for testing coordinator and prover.
 
-It contains data from some blocks in a specified testnet, and helps to generate a series of chunks/batches/bundles from these blocks, filling the DB for the coordinator, so an e2e test (from chunk to bundle) can be run completely local
-
-Prepare:
-link the staff dir as "conf" from one of the dir with staff set, currently we have following staff sets:
-+ sepolia: with blocks from scroll sepolia
-+ cloak-xen: with blocks from xen sepolia, which is a cloak network
+It contains data from some blocks in scroll sepolia, and helps to generate a series of chunks/batches/bundles from these blocks, filling the DB for the coordinator, so an e2e test (from chunk to bundle) can be run completely local
 
 Steps:
 1. run `make all` under `tests/prover-e2e`, it would launch a postgreSql db in local docker container, which is ready to be used by coordinator (include some chunks/batches/bundles waiting to be proven)
-2. setup assets by run `make coordinator_setup`
-3. in `coordinator/build/bin/conf`, update necessary items in `config.template.json` and rename it as `config.json`
-4. build and launch `coordinator_api` service locally
-5. setup the `config.json` for zkvm prover to connect with the locally launched coordinator api
-6. in `zkvm-prover`, launch `make test_e2e_run`, which would specific prover run locally, connect to the local coordinator api service according to the `config.json`, and prove all tasks being injected to db in step 1.
+2. download circuit assets with `download-release.sh` script in `zkvm-prover`
+3. generate the verifier stuff corresponding to the downloaded assets by `make gen_verifier_stuff` in `zkvm-prover`
+4. setup `config.json` and `genesis.json` for coordinator, copy the generated verifier stuff in step 3 to the directory which coordinator would load them
+5. build and launch `coordinator_api` service locally
+6. setup the `config.json` for zkvm prover to connect with the locally launched coordinator api
+7. in `zkvm-prover`, launch `make test_e2e_run`, which would specific prover run locally, connect to the local coordinator api service according to the `config.json`, and prove all tasks being injected to db in step 1.

tests/prover-e2e/cloak-xen/.make.env

@@ -1,3 +0,0 @@
-BEGIN_BLOCK?=35
-END_BLOCK?=49
-SCROLL_FORK_NAME=feynman

tests/prover-e2e/cloak-xen/config.template.json

@@ -1,40 +0,0 @@
-{
-  "prover_manager": {
-    "provers_per_session": 1,
-    "session_attempts": 5,
-    "external_prover_threshold": 32,
-    "bundle_collection_time_sec": 180,
-    "batch_collection_time_sec": 180,
-    "chunk_collection_time_sec": 180,
-    "verifier": {
-      "min_prover_version": "v4.4.45",
-      "verifiers": [
-        {
-          "assets_path": "assets",
-          "fork_name": "feynman"
-        }
-      ]
-    }
-  },
-  "db": {
-    "driver_name": "postgres",
-    "dsn": "postgres://dev:dev@localhost/scroll?sslmode=disable",
-    "maxOpenNum": 200,
-    "maxIdleNum": 20
-  },
-  "l2": {
-    "validium_mode": true,
-    "chain_id": 5343513301,
-    "l2geth": {
-      "endpoint": "http://cloak-xen-sequencer.sepolia.scroll.tech:8545/"
-    }
-  },
-  "auth": {
-    "secret": "prover secret key",
-    "challenge_expire_duration_sec": 3600,
-    "login_expire_duration_sec": 3600
-  },
-  "sequencer": {
-    "decryption_key": "<decryption key>"
-  }
-}

tests/prover-e2e/config.json

@@ -4,7 +4,5 @@
     "dsn": "postgres://dev:dev@localhost:5432/scroll?sslmode=disable",
     "maxOpenNum": 5,
     "maxIdleNum": 1
-  },
-  "validium_mode": true,
-  "codec_version": 8
+  }
 }

tests/prover-e2e/prepare/dump_block_records.sql

@@ -1,12 +1,7 @@
 -- Create a file with INSERT statements for the specific records
-\o 00100_import_blocks.sql
+\o block_export.sql
 \t on
 \a
--- Write header comment
-SELECT '-- +goose Up';
-SELECT '-- +goose StatementBegin';
-SELECT '';
-
 SELECT 'INSERT INTO l2_block (number, hash, parent_hash, header, withdraw_root,
        state_root, tx_num, gas_used, block_timestamp, row_consumption,
        chunk_hash, transactions
@@ -25,17 +20,8 @@ SELECT 'INSERT INTO l2_block (number, hash, parent_hash, header, withdraw_root,
        quote_literal(transactions) ||
        ');'
 FROM l2_block 
-WHERE number >= 15206780 and number <= 15206809
+WHERE number >= 10973700 and number <= 10973730
 ORDER BY number ASC;
-
--- Write footer
-SELECT '';
-SELECT '-- +goose StatementEnd';
-SELECT '-- +goose Down';
-SELECT '-- +goose StatementBegin';
-SELECT 'DELETE FROM l2_block;';
-SELECT '-- +goose StatementEnd';
-
 \t off
 \a
 \o