fix: hardForkSanityCheck mask v4.4.56 prover

.github/workflows/common.yml

@@ -29,7 +29,7 @@ jobs:
     steps:
     - uses: actions-rs/toolchain@v1
       with:
-        toolchain: nightly-2025-08-18
+        toolchain: nightly-2024-12-06
         override: true
         components: rustfmt, clippy
     - name: Install Go
@@ -41,12 +41,12 @@ jobs:
     - name: Cache cargo
       uses: Swatinem/rust-cache@v2
       with:
-        workspaces: ". -> target"
-    # - name: Lint
-    #   working-directory: 'common'
-    #   run: |
-    #     rm -rf $HOME/.cache/golangci-lint
-    #     make lint
+        workspaces: "common/libzkp/impl -> target"
+    - name: Lint
+      working-directory: 'common'
+      run: |
+        rm -rf $HOME/.cache/golangci-lint
+        make lint
   goimports-lint:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest

.github/workflows/coordinator.yml

@@ -33,7 +33,7 @@ jobs:
     steps:
     - uses: actions-rs/toolchain@v1
       with:
-        toolchain: nightly-2025-08-18
+        toolchain: nightly-2023-12-03
         override: true
         components: rustfmt, clippy
     - name: Install Go
@@ -112,7 +112,7 @@ jobs:
     - name: Test coordinator packages
       working-directory: 'coordinator'
       run: |
-        make libzkp
+        # go test -exec "env LD_LIBRARY_PATH=${PWD}/verifier/lib" -v -race -gcflags="-l" -ldflags="-s=false" -coverpkg="scroll-tech/coordinator" -coverprofile=coverage.txt -covermode=atomic ./...
         go test -v -race -gcflags="-l" -ldflags="-s=false" -coverprofile=coverage.txt -covermode=atomic -tags mock_verifier ./...
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v3

.github/workflows/docker.yml

@@ -10,8 +10,7 @@ env:
 
 jobs:
   gas_oracle:
-    runs-on:
-        group: scroll-reth-runner-group
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -56,8 +55,7 @@ jobs:
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   rollup_relayer:
-    runs-on:
-        group: scroll-reth-runner-group
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -101,55 +99,8 @@ jobs:
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
-  blob_uploader:
-    runs-on:
-        group: scroll-reth-runner-group
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-      - name: Login to Docker Hub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v4
-        with:
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ env.AWS_REGION }}
-      - name: Login to Amazon ECR
-        id: login-ecr
-        uses: aws-actions/amazon-ecr-login@v2
-      - name: check repo and create it if not exist
-        env:
-          REPOSITORY: blob-uploader
-        run: |
-          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
-      - name: Build and push
-        uses: docker/build-push-action@v3
-        env:
-          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
-          REPOSITORY: blob-uploader
-          IMAGE_TAG: ${{ github.ref_name }}
-        with:
-          context: .
-          file: ./build/dockerfiles/blob_uploader.Dockerfile
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: |
-            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            scrolltech/${{ env.REPOSITORY }}:latest
-            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
-
   rollup-db-cli:
-    runs-on:
-        group: scroll-reth-runner-group
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -194,8 +145,7 @@ jobs:
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   bridgehistoryapi-fetcher:
-    runs-on:
-        group: scroll-reth-runner-group
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -240,8 +190,7 @@ jobs:
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   bridgehistoryapi-api:
-    runs-on:
-        group: scroll-reth-runner-group
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -286,8 +235,7 @@ jobs:
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   bridgehistoryapi-db-cli:
-    runs-on:
-        group: scroll-reth-runner-group
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -332,8 +280,7 @@ jobs:
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   coordinator-api:
-    runs-on:
-        group: scroll-reth-runner-group
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -377,8 +324,7 @@ jobs:
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
   coordinator-cron:
-    runs-on:
-        group: scroll-reth-runner-group
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4

.github/workflows/integration.yml

@@ -38,7 +38,6 @@ jobs:
         make dev_docker
         make -C rollup mock_abi
         make -C common/bytecode all
-        make -C coordinator/internal/logic/libzkp build
     - name: Run integration tests
       run: |
         go test -v -tags="mock_prover mock_verifier" -p 1 -coverprofile=coverage.txt scroll-tech/integration-test/...

.github/workflows/intermediate-docker.yml

@@ -22,9 +22,9 @@ on:
         required: true
         type: choice
         options:
-          - 1.86.0
-          - nightly-2025-08-18
-        default: "nightly-2025-08-18"
+          - nightly-2023-12-03
+          - nightly-2022-12-10
+        default: "nightly-2023-12-03"
       PYTHON_VERSION:
         description: "Python version"
         required: false
@@ -47,7 +47,6 @@ on:
         type: choice
         options:
           - 0.1.41
-          - 0.1.71
       BASE_IMAGE:
         description: "which intermediate image you want to update"
         required: true
@@ -68,8 +67,7 @@ defaults:
 
 jobs:
   build-and-publish-intermediate:
-    runs-on:
-        group: scroll-reth-runner-group
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4

.github/workflows/prover.yml

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

.gitignore

@@ -24,4 +24,3 @@ sftp-config.json
 *~
 
 target
-zkvm-prover/config.json

CONTRIBUTING.md

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

Cargo.toml

@@ -1,69 +0,0 @@
-[workspace]
-members = [
-  "crates/libzkp",
-  "crates/l2geth",
-  "crates/libzkp_c",
-  "crates/prover-bin",
-]
-
-resolver = "2"
-
-[workspace.package]
-authors = ["Scroll developers"]
-edition = "2021"
-homepage = "https://scroll.io"
-readme = "README.md"
-repository = "https://github.com/scroll-tech/scroll"
-version = "4.5.47"
-
-[workspace.dependencies]
-scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "5c361ad" }
-scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "5c361ad" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "5c361ad" }
-
-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"
-metrics-tracing-context = "0.16.0"
-
-anyhow = "1.0"
-alloy = { version = "1", default-features = false }
-alloy-primitives = { version = "1.3", default-features = false, features = ["tiny-keccak"] }
-alloy-sol-types = { version = "1.3", default-features = false }
-# 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.11.0"
-itertools = "0.14"
-tiny-keccak = "2.0"
-tracing = "0.1"
-eyre = "0.6"
-once_cell = "1.20"
-base64 = "0.22"
-
-[patch.crates-io]
-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"
-lto = "fat"
-codegen-units = 1

README.md

@@ -28,7 +28,7 @@ We welcome community contributions to this repository. Before you submit any iss
 
 ## Prerequisites
 + Go 1.21
-+ Rust (for version, see [rust-toolchain](./rust-toolchain))
++ Rust (for version, see [rust-toolchain](./common/libzkp/impl/rust-toolchain))
 + Hardhat / Foundry
 + Docker
 

bridge-history-api/go.mod

@@ -10,15 +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.1.3-0.20250826112206-b4cce5c5d178
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9
+	github.com/scroll-tech/da-codec v0.1.3-0.20250226072559-f8a8d3898f54
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950
 	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
 )
 
-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
+replace github.com/scroll-tech/go-ethereum => github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950 // It's a hotfix for the header hash incompatibility issue, pls change this with caution
 
 require (
 	dario.cat/mergo v1.0.0 // indirect

bridge-history-api/go.sum

@@ -309,10 +309,10 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.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/da-codec v0.1.3-0.20250226072559-f8a8d3898f54 h1:qVpsVu1J91opTn6HYeuzWcBRVhQmPR8g05i+PlOjlI4=
+github.com/scroll-tech/da-codec v0.1.3-0.20250226072559-f8a8d3898f54/go.mod h1:xECEHZLVzbdUn+tNbRJhRIjLGTOTmnFQuTgUTeVLX58=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950 h1:qfOaRflvH1vtnFWloB7BveKlP/VqYgMqLJ6e9TlBJ/8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=

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

@@ -38,7 +38,6 @@ type FetcherConfig struct {
 	BeaconNodeAPIEndpoint  string `json:"BeaconNodeAPIEndpoint"`
 	BlobScanAPIEndpoint    string `json:"BlobScanAPIEndpoint"`
 	BlockNativeAPIEndpoint string `json:"BlockNativeAPIEndpoint"`
-	AwsS3Endpoint          string `json:"AwsS3Endpoint"`
 }
 
 // RedisConfig redis config

bridge-history-api/internal/controller/fetcher/l1_fetcher.go

@@ -39,9 +39,6 @@ type L1MessageFetcher struct {
 // NewL1MessageFetcher creates a new L1MessageFetcher instance.
 func NewL1MessageFetcher(ctx context.Context, cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client) (*L1MessageFetcher, error) {
 	blobClient := blob_client.NewBlobClients()
-	if cfg.AwsS3Endpoint != "" {
-		blobClient.AddBlobClient(blob_client.NewAwsS3Client(cfg.AwsS3Endpoint))
-	}
 	if cfg.BeaconNodeAPIEndpoint != "" {
 		beaconNodeClient, err := blob_client.NewBeaconNodeClient(cfg.BeaconNodeAPIEndpoint)
 		if err != nil {

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

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"math/big"
-	"time"
 
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
@@ -253,11 +252,6 @@ func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.
 	// Key:   commit transaction hash
 	// Value: parent batch hashes (in order) for each processed CommitBatch event in the transaction
 	txBlobIndexMap := make(map[common.Hash][]common.Hash)
-
-	// Cache for the previous transaction to avoid duplicate fetches
-	var lastTxHash common.Hash
-	var lastTx *types.Transaction
-
 	var l1BatchEvents []*orm.BatchEvent
 	for _, vlog := range logs {
 		switch vlog.Topics[0] {
@@ -267,28 +261,11 @@ func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.
 				log.Error("Failed to unpack CommitBatch event", "err", err)
 				return nil, err
 			}
-
-			// Get transaction, reuse if it's the same as previous
-			var commitTx *types.Transaction
-			if lastTxHash == vlog.TxHash && lastTx != nil {
-				commitTx = lastTx
-			} else {
-				log.Debug("Fetching commit batch transaction", "txHash", vlog.TxHash.String())
-
-				// Create 10-second timeout context for transaction fetch
-				txCtx, txCancel := context.WithTimeout(ctx, 10*time.Second)
-				fetchedTx, isPending, err := client.TransactionByHash(txCtx, vlog.TxHash)
-				txCancel()
-
-				if err != nil || isPending {
-					log.Error("Failed to get commit batch tx or the tx is still pending", "err", err, "isPending", isPending)
-					return nil, err
-				}
-				commitTx = fetchedTx
-				lastTxHash = vlog.TxHash
-				lastTx = commitTx
+			commitTx, isPending, err := client.TransactionByHash(ctx, vlog.TxHash)
+			if err != nil || isPending {
+				log.Error("Failed to get commit batch tx or the tx is still pending", "err", err, "isPending", isPending)
+				return nil, err
 			}
-
 			version, startBlock, endBlock, err := utils.GetBatchVersionAndBlockRangeFromCalldata(commitTx.Data())
 			if err != nil {
 				log.Error("Failed to get batch range from calldata", "hash", commitTx.Hash().String(), "height", vlog.BlockNumber)
@@ -328,13 +305,7 @@ func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.
 					return nil, fmt.Errorf("batch hash mismatch for batch %d, expected: %s, got: %s", event.BatchIndex, event.BatchHash.String(), calculatedBatch.Hash().String())
 				}
 
-				log.Debug("Processing blob data", "blobVersionedHash", blobVersionedHash.String(), "batchIndex", event.BatchIndex.Uint64(), "currentIndex", currentIndex)
-
-				// Create 20-second timeout context for blob processing
-				blobCtx, blobCancel := context.WithTimeout(ctx, 20*time.Second)
-				blocks, err := e.getBatchBlockRangeFromBlob(blobCtx, codec, blobVersionedHash, blockTimestampsMap[vlog.BlockNumber])
-				blobCancel()
-
+				blocks, err := e.getBatchBlockRangeFromBlob(ctx, codec, blobVersionedHash, blockTimestampsMap[vlog.BlockNumber])
 				if err != nil {
 					return nil, fmt.Errorf("failed to process versioned blob, blobVersionedHash: %s, block number: %d, blob index: %d, err: %w",
 						blobVersionedHash.String(), vlog.BlockNumber, currentIndex, err)

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

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

build/dockerfiles/blob_uploader.Dockerfile

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

build/dockerfiles/blob_uploader.Dockerfile.dockerignore

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

build/dockerfiles/coordinator-api.Dockerfile

@@ -1,25 +1,22 @@
 # Build libzkp dependency
-FROM scrolltech/go-rust-builder:go-1.22.12-rust-nightly-2025-02-14 as chef
+FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as chef
 WORKDIR app
 
 FROM chef as planner
-COPY ./crates/ ./crates/
-COPY ./Cargo.* ./
-COPY ./rust-toolchain ./
+COPY ./common/libzkp/impl/ .
 RUN cargo chef prepare --recipe-path recipe.json
 
 FROM chef as zkp-builder
-COPY ./rust-toolchain ./
+COPY ./common/libzkp/impl/rust-toolchain ./
 COPY --from=planner /app/recipe.json recipe.json
 RUN cargo chef cook --release --recipe-path recipe.json
-COPY ./crates/ ./crates/
-COPY ./Cargo.* ./
-COPY .git .git
-RUN cargo build --release -p libzkp-c
+
+COPY ./common/libzkp/impl .
+RUN cargo build --release
 
 
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.22.12-rust-nightly-2025-02-14 as base
+FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
 WORKDIR /src
 COPY go.work* ./
 COPY ./rollup/go.* ./rollup/
@@ -34,9 +31,9 @@ RUN go mod download -x
 # Build coordinator
 FROM base as builder
 COPY . .
-COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/internal/logic/libzkp/lib/
-RUN cd ./coordinator && CGO_LDFLAGS="-Wl,--no-as-needed -ldl" make coordinator_api && mv ./build/bin/coordinator_api /bin/coordinator_api
-RUN mv coordinator/internal/logic/libzkp/lib /bin/
+RUN cp -r ./common/libzkp/interface ./coordinator/internal/logic/verifier/lib
+COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/internal/logic/verifier/lib/
+RUN cd ./coordinator && CGO_LDFLAGS="-Wl,--no-as-needed -ldl" make coordinator_api_skip_libzkp && mv ./build/bin/coordinator_api /bin/coordinator_api && mv internal/logic/verifier/lib /bin/
 
 # Pull coordinator into a second stage deploy ubuntu container
 FROM ubuntu:20.04

build/dockerfiles/coordinator-api.Dockerfile.dockerignore

@@ -4,5 +4,3 @@ docs/
 l2geth/
 rpc-gateway/
 *target/*
-
-permissionless-batches/conf/

build/dockerfiles/coordinator-cron.Dockerfile.dockerignore

@@ -4,5 +4,3 @@ docs/
 l2geth/
 rpc-gateway/
 *target/*
-
-permissionless-batches/conf/

build/dockerfiles/db_cli.Dockerfile.dockerignore

@@ -4,5 +4,3 @@ docs/
 l2geth/
 rpc-gateway/
 *target/*
-
-permissionless-batches/conf/

build/dockerfiles/gas_oracle.Dockerfile.dockerignore

@@ -1,8 +1,5 @@
 assets/
-contracts/
 docs/
 l2geth/
 rpc-gateway/
-*target/*
-
-permissionless-batches/conf/
+*target/*

build/dockerfiles/prover.Dockerfile

@@ -18,6 +18,6 @@ RUN cd /src/zkvm-prover && make prover
 
 FROM ubuntu:24.04 AS runtime
 
-COPY --from=builder /src/target/release/prover /usr/local/bin/
+COPY --from=builder /src/zkvm-prover/target/release/prover /usr/local/bin/
 
 ENTRYPOINT ["prover"]

build/dockerfiles/recovery_permissionless_batches.Dockerfile

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

build/dockerfiles/recovery_permissionless_batches.Dockerfile.dockerignore

@@ -1,8 +0,0 @@
-assets/
-contracts/
-docs/
-l2geth/
-rpc-gateway/
-*target/*
-
-permissionless-batches/conf/

build/dockerfiles/rollup_relayer.Dockerfile.dockerignore

@@ -1,8 +1,5 @@
 assets/
-contracts/
 docs/
 l2geth/
 rpc-gateway/
-*target/*
-
-permissionless-batches/conf/
+*target/*

common/.gitignore

@@ -1,3 +1,4 @@
 /build/bin
 .idea
-libzkp
+libzkp/impl/target
+libzkp/interface/*.a

common/Makefile

@@ -4,4 +4,5 @@ test:
 	go test -v -race -coverprofile=coverage.txt -covermode=atomic -p 1 $(PWD)/...
 
 lint: ## Lint the files - used for CI
-	GOBIN=$(PWD)/build/bin go run ../build/lint.go
+	GOBIN=$(PWD)/build/bin go run ../build/lint.go
+	cd libzkp/impl && cargo fmt --all -- --check && cargo clippy --release -- -D warnings

common/database/db.go

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

common/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.20250625112225-a67863c65587
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
 	github.com/stretchr/testify v1.10.0
 	github.com/testcontainers/testcontainers-go v0.30.0
 	github.com/testcontainers/testcontainers-go/modules/compose v0.30.0
@@ -184,7 +184,7 @@ require (
 	github.com/rjeczalik/notify v0.9.1 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178 // indirect
+	github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect
 	github.com/secure-systems-lab/go-securesystemslib v0.4.0 // indirect
 	github.com/serialx/hashring v0.0.0-20190422032157-8b2912629002 // indirect

common/go.sum

@@ -636,10 +636,10 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.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/da-codec v0.1.3-0.20250310095435-012aaee6b435 h1:X9fkvjrYBY79lGgKEPpUhuiJ4vWpWwzOVw4H8CU8L54=
+github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601 h1:NEsjCG6uSvLRBlsP3+x6PL1kM+Ojs3g8UGotIPgJSz8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/secure-systems-lab/go-securesystemslib v0.4.0 h1:b23VGrQhTA8cN2CbBw7/FulN9fTtqYUdS5+Oxzt+DUE=

common/libzkp/e2e-test.sh

@@ -20,7 +20,7 @@ function build_test_bins() {
     cd $REPO/coordinator
     make libzkp
     go test -tags="gpu ffi" -timeout 0 -c ./internal/logic/verifier
-    cd $REPO/coordinator/internal/logic/libzkp
+    cd $REPO/common/libzkp
 }
 
 build_test_bins

common/libzkp/impl/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "zkp"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+crate-type = ["cdylib"]
+
+[patch.crates-io]
+# patched add rkyv support & MSRV 1.77
+alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.21" }
+ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
+tiny-keccak = { git = "https://github.com/scroll-tech/tiny-keccak", branch = "scroll-patch-v2.0.2-openvm-v1.0.0-rc.1" }
+
+[dependencies]
+euclid_prover = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.2.0", package = "scroll-zkvm-prover" }
+euclid_verifier = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.2.0", package = "scroll-zkvm-verifier" }
+
+base64 = "0.13.0"
+env_logger = "0.9.0"
+libc = "0.2"
+log = "0.4"
+once_cell = "1.19"
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0.66"
+anyhow = "1.0.86"
+
+[profile.test]
+opt-level = 3
+
+[profile.release]
+opt-level = 3

common/libzkp/impl/Makefile

@@ -0,0 +1,11 @@
+.PHONY: help fmt clippy test test-ci test-all
+
+build:
+	@cargo build --release
+
+fmt:
+	@cargo fmt --all -- --check
+
+clippy:
+	@cargo check --all-features
+	@cargo clippy --release -- -D warnings

common/libzkp/impl/rust-toolchain

@@ -0,0 +1 @@
+nightly-2024-12-06

common/libzkp/impl/src/lib.rs

@@ -0,0 +1,82 @@
+mod utils;
+mod verifier;
+
+use std::path::Path;
+
+use crate::utils::{c_char_to_str, c_char_to_vec};
+use libc::c_char;
+use verifier::{TaskType, VerifierConfig};
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init(config: *const c_char) {
+    let config_str = c_char_to_str(config);
+    let verifier_config = serde_json::from_str::<VerifierConfig>(config_str).unwrap();
+    verifier::init(verifier_config);
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_chunk_proof(
+    proof: *const c_char,
+    fork_name: *const c_char,
+) -> c_char {
+    verify_proof(proof, fork_name, TaskType::Chunk)
+}
+
+fn verify_proof(proof: *const c_char, fork_name: *const c_char, task_type: TaskType) -> c_char {
+    let fork_name_str = c_char_to_str(fork_name);
+    // Skip verification for darwinV2 as we can't host darwinV2 and euclid verifiers on the same
+    // binary.
+    if fork_name_str == "darwinV2" {
+        return true as c_char;
+    }
+
+    let proof = c_char_to_vec(proof);
+    let verifier = verifier::get_verifier(fork_name_str);
+
+    if let Err(e) = verifier {
+        log::warn!("failed to get verifier, error: {:#}", e);
+        return 0 as c_char;
+    }
+    match verifier.unwrap().verify(task_type, proof) {
+        Err(e) => {
+            log::error!("{:?} verify failed, error: {:#}", task_type, e);
+            false as c_char
+        }
+        Ok(result) => result as c_char,
+    }
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_batch_proof(
+    proof: *const c_char,
+    fork_name: *const c_char,
+) -> c_char {
+    verify_proof(proof, fork_name, TaskType::Batch)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_bundle_proof(
+    proof: *const c_char,
+    fork_name: *const c_char,
+) -> c_char {
+    verify_proof(proof, fork_name, TaskType::Bundle)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn dump_vk(fork_name: *const c_char, file: *const c_char) {
+    _dump_vk(fork_name, file);
+}
+
+fn _dump_vk(fork_name: *const c_char, file: *const c_char) {
+    let fork_name_str = c_char_to_str(fork_name);
+    let verifier = verifier::get_verifier(fork_name_str);
+
+    if let Ok(verifier) = verifier {
+        verifier.as_ref().dump_vk(Path::new(c_char_to_str(file)));
+    }
+}

common/libzkp/impl/src/utils.rs

@@ -0,0 +1,27 @@
+use std::{
+    ffi::CStr,
+    os::raw::c_char,
+    panic::{catch_unwind, AssertUnwindSafe},
+};
+
+pub(crate) fn c_char_to_str(c: *const c_char) -> &'static str {
+    let cstr = unsafe { CStr::from_ptr(c) };
+    cstr.to_str().unwrap()
+}
+
+pub(crate) fn c_char_to_vec(c: *const c_char) -> Vec<u8> {
+    let cstr = unsafe { CStr::from_ptr(c) };
+    cstr.to_bytes().to_vec()
+}
+
+pub(crate) fn panic_catch<F: FnOnce() -> R, R>(f: F) -> Result<R, String> {
+    catch_unwind(AssertUnwindSafe(f)).map_err(|err| {
+        if let Some(s) = err.downcast_ref::<String>() {
+            s.to_string()
+        } else if let Some(s) = err.downcast_ref::<&str>() {
+            s.to_string()
+        } else {
+            format!("unable to get panic info {err:?}")
+        }
+    })
+}

common/libzkp/impl/src/verifier.rs

@@ -0,0 +1,88 @@
+#![allow(static_mut_refs)]
+
+mod euclid;
+mod euclidv2;
+
+use anyhow::{bail, Result};
+use euclid::EuclidVerifier;
+use euclidv2::EuclidV2Verifier;
+use serde::{Deserialize, Serialize};
+use std::{cell::OnceCell, path::Path, rc::Rc};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum TaskType {
+    Chunk,
+    Batch,
+    Bundle,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct VKDump {
+    pub chunk_vk: String,
+    pub batch_vk: String,
+    pub bundle_vk: String,
+}
+
+pub trait ProofVerifier {
+    fn verify(&self, task_type: TaskType, proof: Vec<u8>) -> Result<bool>;
+    fn dump_vk(&self, file: &Path);
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CircuitConfig {
+    pub fork_name: String,
+    pub params_path: String,
+    pub assets_path: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct VerifierConfig {
+    pub low_version_circuit: CircuitConfig,
+    pub high_version_circuit: CircuitConfig,
+}
+
+type HardForkName = String;
+
+struct VerifierPair(HardForkName, Rc<Box<dyn ProofVerifier>>);
+
+static mut VERIFIER_LOW: OnceCell<VerifierPair> = OnceCell::new();
+static mut VERIFIER_HIGH: OnceCell<VerifierPair> = OnceCell::new();
+
+pub fn init(config: VerifierConfig) {
+    let verifier = EuclidVerifier::new(&config.high_version_circuit.assets_path);
+    unsafe {
+        VERIFIER_LOW
+            .set(VerifierPair(
+                "euclid".to_string(),
+                Rc::new(Box::new(verifier)),
+            ))
+            .unwrap_unchecked();
+    }
+
+    let verifier = EuclidV2Verifier::new(&config.high_version_circuit.assets_path);
+    unsafe {
+        VERIFIER_HIGH
+            .set(VerifierPair(
+                "euclidV2".to_string(),
+                Rc::new(Box::new(verifier)),
+            ))
+            .unwrap_unchecked();
+    }
+}
+
+pub fn get_verifier(fork_name: &str) -> Result<Rc<Box<dyn ProofVerifier>>> {
+    unsafe {
+        if let Some(verifier) = VERIFIER_LOW.get() {
+            if verifier.0 == fork_name {
+                return Ok(verifier.1.clone());
+            }
+        }
+
+        if let Some(verifier) = VERIFIER_HIGH.get() {
+            if verifier.0 == fork_name {
+                return Ok(verifier.1.clone());
+            }
+        }
+    }
+    bail!("failed to get verifier, key not found, {}", fork_name)
+}

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

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

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

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

common/libzkp/interface/libzkp.h

@@ -0,0 +1,12 @@
+// BatchVerifier is used to:
+// - Verify a batch proof
+// - Verify a bundle proof
+void init(char* config);
+
+char verify_batch_proof(char* proof, char* fork_name);
+
+char verify_bundle_proof(char* proof, char* fork_name);
+
+char verify_chunk_proof(char* proof, char* fork_name);
+
+void dump_vk(char* fork_name, char* file);

common/types/db.go

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

common/types/db_test.go

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

common/types/message/message.go

@@ -10,6 +10,14 @@ import (
 	"github.com/scroll-tech/go-ethereum/common/hexutil"
 )
 
+const (
+	EuclidFork   = "euclid"
+	EuclidV2Fork = "euclidV2"
+
+	EuclidForkNameForProver   = "euclidv1"
+	EuclidV2ForkNameForProver = "euclidv2"
+)
+
 // ProofType represents the type of task.
 type ProofType uint8
 
@@ -39,7 +47,7 @@ const (
 
 // ChunkTaskDetail is a type containing ChunkTask detail for chunk task.
 type ChunkTaskDetail struct {
-	// use one of the string of "euclidv1" / "euclidv2"
+	// use one of the string of EuclidFork / EuclidV2Fork
 	ForkName         string        `json:"fork_name"`
 	BlockHashes      []common.Hash `json:"block_hashes"`
 	PrevMsgQueueHash common.Hash   `json:"prev_msg_queue_hash"`
@@ -90,23 +98,23 @@ func (e *Byte48) UnmarshalJSON(input []byte) error {
 
 // BatchTaskDetail is a type containing BatchTask detail.
 type BatchTaskDetail struct {
-	// use one of the string of "euclidv1" / "euclidv2"
-	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"`
+	// use one of the string of EuclidFork / EuclidV2Fork
+	ForkName        string       `json:"fork_name"`
+	ChunkInfos      []*ChunkInfo `json:"chunk_infos"`
+	ChunkProofs     []ChunkProof `json:"chunk_proofs"`
+	BatchHeader     interface{}  `json:"batch_header"`
+	BlobBytes       []byte       `json:"blob_bytes"`
+	KzgProof        Byte48       `json:"kzg_proof,omitempty"`
+	KzgCommitment   Byte48       `json:"kzg_commitment,omitempty"`
+	ChallengeDigest common.Hash  `json:"challenge_digest,omitempty"`
 }
 
 // BundleTaskDetail consists of all the information required to describe the task to generate a proof for a bundle of batches.
 type BundleTaskDetail struct {
-	// use one of the string of "euclidv1" / "euclidv2"
-	ForkName    string              `json:"fork_name"`
-	BatchProofs []*OpenVMBatchProof `json:"batch_proofs"`
-	BundleInfo  *OpenVMBundleInfo   `json:"bundle_info,omitempty"`
+	// use one of the string of EuclidFork / EuclidV2Fork
+	ForkName    string            `json:"fork_name"`
+	BatchProofs []BatchProof      `json:"batch_proofs"`
+	BundleInfo  *OpenVMBundleInfo `json:"bundle_info,omitempty"`
 }
 
 // ChunkInfo is for calculating pi_hash for chunk
@@ -135,18 +143,161 @@ type BlockContextV2 struct {
 	NumL1Msgs uint16      `json:"num_l1_msgs"`
 }
 
-// Metric data carried with OpenVMProof
-type OpenVMProofStat struct {
-	TotalCycle         uint64 `json:"total_cycles"`
-	ExecutionTimeMills uint64 `json:"execution_time_mills"`
-	ProvingTimeMills   uint64 `json:"proving_time_mills"`
+// SubCircuitRowUsage tracing info added in v0.11.0rc8
+type SubCircuitRowUsage struct {
+	Name      string `json:"name"`
+	RowNumber uint64 `json:"row_number"`
+}
+
+// ChunkProof
+type ChunkProof interface {
+	Proof() []byte
+}
+
+// NewChunkProof creates a new ChunkProof instance.
+func NewChunkProof(hardForkName string) ChunkProof {
+	switch hardForkName {
+	case EuclidFork, EuclidV2Fork:
+		return &OpenVMChunkProof{}
+	default:
+		return &Halo2ChunkProof{}
+	}
+}
+
+// Halo2ChunkProof includes the proof info that are required for chunk verification and rollup.
+type Halo2ChunkProof struct {
+	StorageTrace []byte `json:"storage_trace,omitempty"`
+	Protocol     []byte `json:"protocol"`
+	RawProof     []byte `json:"proof"`
+	Instances    []byte `json:"instances"`
+	Vk           []byte `json:"vk"`
+	// cross-reference between cooridinator computation and prover compution
+	ChunkInfo  *ChunkInfo           `json:"chunk_info,omitempty"`
+	GitVersion string               `json:"git_version,omitempty"`
+	RowUsages  []SubCircuitRowUsage `json:"row_usages,omitempty"`
+}
+
+// Proof returns the proof bytes of a ChunkProof
+func (ap *Halo2ChunkProof) Proof() []byte {
+	return ap.RawProof
+}
+
+// BatchProof
+type BatchProof interface {
+	SanityCheck() error
+	Proof() []byte
+}
+
+// NewBatchProof creates a new BatchProof instance.
+func NewBatchProof(hardForkName string) BatchProof {
+	switch hardForkName {
+	case EuclidFork, EuclidV2Fork:
+		return &OpenVMBatchProof{}
+	default:
+		return &Halo2BatchProof{}
+	}
+}
+
+// Halo2BatchProof includes the proof info that are required for batch verification and rollup.
+type Halo2BatchProof struct {
+	Protocol  []byte `json:"protocol"`
+	RawProof  []byte `json:"proof"`
+	Instances []byte `json:"instances"`
+	Vk        []byte `json:"vk"`
+	// cross-reference between cooridinator computation and prover compution
+	BatchHash  common.Hash `json:"batch_hash"`
+	GitVersion string      `json:"git_version,omitempty"`
+}
+
+// Proof returns the proof bytes of a BatchProof
+func (ap *Halo2BatchProof) Proof() []byte {
+	return ap.RawProof
+}
+
+// SanityCheck checks whether a BatchProof is in a legal format
+func (ap *Halo2BatchProof) SanityCheck() error {
+	if ap == nil {
+		return errors.New("agg_proof is nil")
+	}
+
+	if len(ap.RawProof) == 0 {
+		return errors.New("proof not ready")
+	}
+
+	if len(ap.RawProof)%32 != 0 {
+		return fmt.Errorf("proof buffer length must be a multiple of 32, got: %d", len(ap.RawProof))
+	}
+
+	if len(ap.Instances) == 0 {
+		return errors.New("instance not ready")
+	}
+
+	if len(ap.Vk) == 0 {
+		return errors.New("vk not ready")
+	}
+
+	return nil
+}
+
+// BundleProof
+type BundleProof interface {
+	SanityCheck() error
+	Proof() []byte
+}
+
+// NewBundleProof creates a new BundleProof instance.
+func NewBundleProof(hardForkName string) BundleProof {
+	switch hardForkName {
+	case EuclidFork, EuclidV2Fork:
+		return &OpenVMBundleProof{}
+	default:
+		return &Halo2BundleProof{}
+	}
+}
+
+// BundleProof includes the proof info that are required for verification of a bundle of batch proofs.
+type Halo2BundleProof struct {
+	RawProof  []byte `json:"proof"`
+	Instances []byte `json:"instances"`
+	Vk        []byte `json:"vk"`
+	// cross-reference between cooridinator computation and prover compution
+	GitVersion string `json:"git_version,omitempty"`
+}
+
+// Proof returns the proof bytes of a BundleProof
+func (ap *Halo2BundleProof) Proof() []byte {
+	return ap.RawProof
+}
+
+// SanityCheck checks whether a BundleProof is in a legal format
+func (ap *Halo2BundleProof) SanityCheck() error {
+	if ap == nil {
+		return errors.New("agg_proof is nil")
+	}
+
+	if len(ap.RawProof) == 0 {
+		return errors.New("proof not ready")
+	}
+
+	if len(ap.RawProof)%32 != 0 {
+		return fmt.Errorf("proof buffer length must be a multiple of 32, got: %d", len(ap.RawProof))
+	}
+
+	if len(ap.Instances) == 0 {
+		return errors.New("instance not ready")
+	}
+
+	if len(ap.Vk) == 0 {
+		return errors.New("vk not ready")
+	}
+
+	return nil
 }
 
 // Proof for flatten VM proof
 type OpenVMProof struct {
-	Proof        []byte           `json:"proofs"`
-	PublicValues []byte           `json:"public_values"`
-	Stat         *OpenVMProofStat `json:"stat,omitempty"`
+	Proof        []byte `json:"proofs"`
+	PublicValues []byte `json:"public_values"`
 }
 
 // Proof for flatten EVM proof
@@ -158,8 +309,7 @@ type OpenVMEvmProof struct {
 // OpenVMChunkProof includes the proof info that are required for chunk verification and rollup.
 type OpenVMChunkProof struct {
 	MetaData struct {
-		ChunkInfo    *ChunkInfo `json:"chunk_info"`
-		TotalGasUsed uint64     `json:"chunk_total_gas"`
+		ChunkInfo *ChunkInfo `json:"chunk_info"`
 	} `json:"metadata"`
 
 	VmProof    *OpenVMProof `json:"proof"`

common/utils/blob.go

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

common/utils/blob_test.go

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

common/utils/flags.go

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

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.5.46"
+var tag = "v4.5.2"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {
@@ -23,7 +23,7 @@ var commit = func() string {
 	return "000000"
 }()
 
-// ZkVersion is commit-id of cargo.lock/zkvm-prover and openvm, contacted by a "-"
+// ZkVersion is commit-id of common/libzkp/impl/cargo.lock/scroll-prover and halo2, contacted by a "-"
 // The default `000000-000000` is set for integration test, and will be overwritten by coordinator's & prover's actual compilations (see their Makefiles).
 var ZkVersion = "000000-000000"
 

coordinator/.gitignore

@@ -1,4 +1,3 @@
 /build/bin
 .idea
 internal/logic/verifier/lib
-internal/libzkp/lib/libzkp.so

coordinator/Makefile

@@ -1,31 +1,26 @@
-.PHONY: lint docker clean coordinator coordinator_skip_libzkp mock_coordinator libzkp
+.PHONY: lint docker clean coordinator coordinator_skip_libzkp mock_coordinator
 
 IMAGE_VERSION=latest
 REPO_ROOT_DIR=./..
-LIBZKP_PATH=./internal/logic/libzkp/lib/libzkp.so
 
 ifeq (4.3,$(firstword $(sort $(MAKE_VERSION) 4.3)))
-	ZKVM_VERSION=$(shell grep -m 1 "zkvm-prover?" ../Cargo.lock | cut -d "#" -f2 | cut -c-7)
-	OPENVM_VERSION=$(shell grep -m 1 "openvm.git" ../Cargo.lock | cut -d "#" -f2 | cut -c-7)
+	ZKEVM_VERSION=$(shell grep -m 1 "zkevm-circuits" ../common/libzkp/impl/Cargo.lock | cut -d "#" -f2 | cut -c-7)
+	HALO2_VERSION=$(shell grep -m 1 "halo2.git" ../common/libzkp/impl/Cargo.lock | cut -d "#" -f2 | cut -c-7)
 else
-	ZKVM_VERSION=$(shell grep -m 1 "zkvm-prover?" ../Cargo.lock | cut -d "\#" -f2 | cut -c-7)
-	OPENVM_VERSION=$(shell grep -m 1 "openvm.git" ../Cargo.lock | cut -d "\#" -f2 | cut -c-7)
+	ZKEVM_VERSION=$(shell grep -m 1 "zkevm-circuits" ../common/libzkp/impl/Cargo.lock | cut -d "\#" -f2 | cut -c-7)
+	HALO2_VERSION=$(shell grep -m 1 "halo2.git" ../common/libzkp/impl/Cargo.lock | cut -d "\#" -f2 | cut -c-7)
 endif
 
-ZK_VERSION=${ZKVM_VERSION}-${OPENVM_VERSION}
+ZK_VERSION=${ZKEVM_VERSION}-${HALO2_VERSION}
 
 test:
 	go test -v -race -coverprofile=coverage.txt -covermode=atomic -p 1 $(PWD)/...
 
-$(LIBZKP_PATH):
-	$(MAKE) -C ./internal/logic/libzkp build
+libzkp:
+	cd ../common/libzkp/impl && cargo clean && cargo build --release && cp ./target/release/libzkp.so ../interface/
+	rm -rf ./internal/logic/verifier/lib && cp -r ../common/libzkp/interface ./internal/logic/verifier/lib
 
-clean_libzkp:
-	$(MAKE) -C ./internal/logic/libzkp clean
-
-libzkp: clean_libzkp $(LIBZKP_PATH)
-
-coordinator_api: $(LIBZKP_PATH) ## Builds the Coordinator api instance.
+coordinator_api: libzkp ## Builds the Coordinator api instance.
 	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_api ./cmd/api
 
 coordinator_cron:
@@ -34,15 +29,8 @@ coordinator_cron:
 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
-	@echo "Copying configuration files..."
-	cp -r $(PWD)/conf $(PWD)/build/bin/
-	@echo "Setting up releases..."
-	cd $(PWD)/build && bash setup_releases.sh
-
-
-#coordinator_api_skip_libzkp:
-#	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_api ./cmd/api
+coordinator_api_skip_libzkp:
+	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_api ./cmd/api
 
 mock_coordinator_api: ## Builds the mocked Coordinator instance.
 	go build -tags="mock_prover mock_verifier" -o $(PWD)/build/bin/coordinator_api ./cmd/api
@@ -50,15 +38,15 @@ mock_coordinator_api: ## Builds the mocked Coordinator instance.
 mock_coordinator_cron: ## Builds the mocked Coordinator instance.
 	go build -tags="mock_prover mock_verifier" -o $(PWD)/build/bin/coordinator_cron ./cmd/cron
 
-test-verifier: $(LIBZKP_PATH)
+test-verifier: libzkp
 	go test -tags ffi -timeout 0 -v ./internal/logic/verifier
 
-test-gpu-verifier: $(LIBZKP_PATH)
+test-gpu-verifier: libzkp
 	go test -tags="gpu ffi" -timeout 0 -v ./internal/logic/verifier
 
 lint: ## Lint the files - used for CI
+	cp -r ../common/libzkp/interface ./internal/logic/verifier/lib
 	GOBIN=$(PWD)/build/bin go run ../build/lint.go
-	cd ../ && cargo fmt --all -- --check && cargo clippy --release -- -D warnings
 
 clean: ## Empty out the bin folder
 	@rm -rf build/bin

coordinator/build/setup_releases.sh

@@ -1,62 +0,0 @@
-#!/bin/bash
-
-# release version
-if [ -z "${SCROLL_ZKVM_VERSION}" ]; then
-  echo "SCROLL_ZKVM_VERSION not set"
-  exit 1
-fi
-
-# set ASSET_DIR by reading from config.json
-CONFIG_FILE="bin/conf/config.json"
-if [ ! -f "$CONFIG_FILE" ]; then
-  echo "Config file $CONFIG_FILE not found"
-  exit 1
-fi
-
-# get the number of verifiers in the array
-VERIFIER_COUNT=$(jq -r '.prover_manager.verifier.verifiers | length' "$CONFIG_FILE")
-
-if [ "$VERIFIER_COUNT" = "null" ] || [ "$VERIFIER_COUNT" -eq 0 ]; then
-  echo "No verifiers found in config file"
-  exit 1
-fi
-
-echo "Found $VERIFIER_COUNT verifier(s) in config"
-
-# iterate through each verifier entry
-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")
-  
-  if [ "$ASSETS_PATH" = "null" ]; then
-    echo "Warning: Could not find assets_path for verifier $i, skipping..."
-    continue
-  fi
-
-  echo "Processing verifier $i ($FORK_NAME): assets_path=$ASSETS_PATH"
-
-  # check if it's an absolute path (starts with /)
-  if [[ "$ASSETS_PATH" = /* ]]; then
-    # absolute path, use as is
-    ASSET_DIR="$ASSETS_PATH"
-  else
-    # relative path, prefix with "bin/"
-    ASSET_DIR="bin/$ASSETS_PATH"
-  fi
-
-  echo "Using ASSET_DIR: $ASSET_DIR"
-
-  # create directory if it doesn't exist
-  mkdir -p "$ASSET_DIR"
-
-  # 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/openVmVk.json -O ${ASSET_DIR}/openVmVk.json
-  
-  echo "Completed downloading assets for $FORK_NAME"
-  echo "---"
-done
-
-echo "All verifier assets downloaded successfully"

coordinator/cmd/api/app/mock_app.go

@@ -90,12 +90,20 @@ func (c *CoordinatorApp) MockConfig(store bool) error {
 	cfg.ProverManager = &coordinatorConfig.ProverManager{
 		ProversPerSession: 1,
 		Verifier: &coordinatorConfig.VerifierConfig{
-			MinProverVersion: "v4.4.89",
-			Verifiers: []coordinatorConfig.AssetConfig{{
-				AssetsPath: "",
-				ForkName:   "feynman",
+			MockMode: true,
+			LowVersionCircuit: &coordinatorConfig.CircuitConfig{
+				ParamsPath:       "",
+				AssetsPath:       "",
+				ForkName:         "darwin",
+				MinProverVersion: "v4.4.56",
 			},
-			}},
+			HighVersionCircuit: &coordinatorConfig.CircuitConfig{
+				ParamsPath:       "",
+				AssetsPath:       "",
+				ForkName:         "darwinV2",
+				MinProverVersion: "v4.4.89",
+			},
+		},
 		BatchCollectionTimeSec: 60,
 		ChunkCollectionTimeSec: 60,
 		SessionAttempts:        10,

coordinator/cmd/tool/tool.go

@@ -19,7 +19,6 @@ import (
 )
 
 var app *cli.App
-var cfg *config.Config
 
 func init() {
 	// Set up coordinator app info.
@@ -30,29 +29,16 @@ func init() {
 	app.Version = version.Version
 	app.Flags = append(app.Flags, utils.CommonFlags...)
 	app.Before = func(ctx *cli.Context) error {
-		if err := utils.LogSetup(ctx); err != nil {
-			return err
-		}
-
-		cfgFile := ctx.String(utils.ConfigFileFlag.Name)
-		var err error
-		cfg, err = config.NewConfig(cfgFile)
-		if err != nil {
-			log.Crit("failed to load config file", "config file", cfgFile, "error", err)
-		}
-		return nil
-	}
-	// sub commands
-	app.Commands = []*cli.Command{
-		{
-			Name:   "verify",
-			Usage:  "verify an proof, specified by [forkname] <type> <proof path>",
-			Action: verify,
-		},
+		return utils.LogSetup(ctx)
 	}
 }
 
 func action(ctx *cli.Context) error {
+	cfgFile := ctx.String(utils.ConfigFileFlag.Name)
+	cfg, err := config.NewConfig(cfgFile)
+	if err != nil {
+		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
+	}
 	db, err := database.InitDB(cfg.DB)
 	if err != nil {
 		log.Crit("failed to init db connection", "err", err)
@@ -76,14 +62,14 @@ func action(ctx *cli.Context) error {
 		return fmt.Errorf("failed to get batch proofs for bundle task id:%s, no batch found", taskID)
 	}
 
-	var batchProofs []*message.OpenVMBatchProof
+	var batchProofs []message.BatchProof
 	for _, batch := range batches {
-		var proof message.OpenVMBatchProof
+		proof := message.NewBatchProof("darwinV2")
 		if encodeErr := json.Unmarshal(batch.Proof, &proof); encodeErr != nil {
 			log.Error("failed to unmarshal batch proof")
 			return fmt.Errorf("failed to unmarshal proof: %w, bundle hash: %v, batch hash: %v", encodeErr, taskID, batch.Hash)
 		}
-		batchProofs = append(batchProofs, &proof)
+		batchProofs = append(batchProofs, proof)
 	}
 
 	taskDetail := message.BundleTaskDetail{

coordinator/cmd/tool/verify.go

@@ -1,109 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"scroll-tech/coordinator/internal/logic/verifier"
-
-	"scroll-tech/common/types/message"
-
-	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/urfave/cli/v2"
-)
-
-func verify(cCtx *cli.Context) error {
-	var forkName, proofType, proofPath string
-	if cCtx.Args().Len() <= 2 {
-		forkName = cfg.ProverManager.Verifier.Verifiers[0].ForkName
-		proofType = cCtx.Args().First()
-		proofPath = cCtx.Args().Get(1)
-	} else {
-		forkName = cCtx.Args().First()
-		proofType = cCtx.Args().Get(1)
-		proofPath = cCtx.Args().Get(2)
-	}
-	log.Info("verify proof", "in", proofPath, "type", proofType, "forkName", forkName)
-
-	// Load the content of the proof file
-	data, err := os.ReadFile(filepath.Clean(proofPath))
-	if err != nil {
-		return fmt.Errorf("error reading file: %w", err)
-	}
-
-	vf, err := verifier.NewVerifier(cfg.ProverManager.Verifier)
-	if err != nil {
-		return err
-	}
-
-	var ret bool
-	switch strings.ToLower(proofType) {
-	case "chunk":
-		proof := &message.OpenVMChunkProof{}
-		if err := json.Unmarshal(data, proof); err != nil {
-			return err
-		}
-		vk, ok := vf.ChunkVk[forkName]
-		if !ok {
-			return fmt.Errorf("no vk loaded for fork %s", forkName)
-		}
-		if len(proof.Vk) != 0 {
-			if !bytes.Equal(proof.Vk, vk) {
-				return fmt.Errorf("unmatch vk with expected: expected %s, get %s",
-					base64.StdEncoding.EncodeToString(vk),
-					base64.StdEncoding.EncodeToString(proof.Vk),
-				)
-			}
-		} else {
-			proof.Vk = vk
-		}
-
-		ret, err = vf.VerifyChunkProof(proof, forkName)
-	case "batch":
-		proof := &message.OpenVMBatchProof{}
-		if err := json.Unmarshal(data, proof); err != nil {
-			return err
-		}
-		vk, ok := vf.BatchVk[forkName]
-		if !ok {
-			return fmt.Errorf("no vk loaded for fork %s", forkName)
-		}
-		if len(proof.Vk) != 0 {
-			if !bytes.Equal(proof.Vk, vk) {
-				return fmt.Errorf("unmatch vk with expected: expected %s, get %s",
-					base64.StdEncoding.EncodeToString(vk),
-					base64.StdEncoding.EncodeToString(proof.Vk),
-				)
-			}
-		} else {
-			proof.Vk = vk
-		}
-
-		ret, err = vf.VerifyBatchProof(proof, forkName)
-	case "bundle":
-		proof := &message.OpenVMBundleProof{}
-		if err := json.Unmarshal(data, proof); err != nil {
-			return err
-		}
-		vk, ok := vf.BundleVk[forkName]
-		if !ok {
-			return fmt.Errorf("no vk loaded for fork %s", forkName)
-		}
-		proof.Vk = vk
-
-		ret, err = vf.VerifyBundleProof(proof, forkName)
-	default:
-		return fmt.Errorf("unsupport proof type %s", proofType)
-	}
-
-	if err != nil {
-		return err
-	}
-	log.Info("verified:", "ret", ret)
-	return nil
-}

coordinator/conf/config.json

@@ -7,17 +7,19 @@
     "batch_collection_time_sec": 180,
     "chunk_collection_time_sec": 180,
     "verifier": {
-      "min_prover_version": "v4.4.45",
-      "verifiers": [
-        {
-          "assets_path": "assets",
-          "fork_name": "euclidV2"
-        },        
-        {
-          "assets_path": "assets",
-          "fork_name": "feynman"
-        }
-      ]
+      "mock_mode": true,
+      "low_version_circuit": {
+        "params_path": "params",
+        "assets_path": "assets",
+        "fork_name": "darwin",
+        "min_prover_version": "v4.4.43"
+      },
+      "high_version_circuit": {
+        "params_path": "params",
+        "assets_path": "assets",
+        "fork_name": "darwinV2",
+        "min_prover_version": "v4.4.45"
+      }
     }
   },
   "db": {
@@ -27,10 +29,7 @@
     "maxIdleNum": 20
   },
   "l2": {
-    "chain_id": 111,
-    "l2geth": {
-      "endpoint": "not need to specified for mocking"
-    }
+    "chain_id": 111
   },
   "auth": {
     "secret": "prover secret key",

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.1.3-0.20250826112206-b4cce5c5d178
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7
+	github.com/scroll-tech/da-codec v0.1.3-0.20250401062930-9f9f53898493
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
 	github.com/shopspring/decimal v1.3.1
 	github.com/stretchr/testify v1.10.0
 	github.com/urfave/cli/v2 v2.25.7
@@ -46,7 +46,6 @@ require (
 )
 
 require (
-	github.com/VictoriaMetrics/fastcache v1.12.2 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bits-and-blooms/bitset v1.20.0 // indirect
 	github.com/btcsuite/btcd v0.20.1-beta // indirect
@@ -56,57 +55,28 @@ require (
 	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
 	github.com/crate-crypto/go-kzg-4844 v1.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	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 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
 	github.com/go-stack/stack v1.8.1 // indirect
-	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
-	github.com/gorilla/websocket v1.4.2 // indirect
-	github.com/hashicorp/go-bexpr v0.1.10 // indirect
-	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect
-	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
 	github.com/holiman/uint256 v1.3.2 // indirect
-	github.com/huin/goupnp v1.0.2 // indirect
 	github.com/iden3/go-iden3-crypto v0.0.17 // indirect
-	github.com/jackpal/go-nat-pmp v1.0.2-0.20160603034137-1fa385a6f458 // indirect
 	github.com/klauspost/compress v1.17.9 // indirect
-	github.com/mattn/go-colorable v0.1.8 // indirect
-	github.com/mattn/go-runewidth v0.0.15 // indirect
-	github.com/mitchellh/pointerstructure v1.2.0 // indirect
 	github.com/mmcloughlin/addchain v0.4.0 // indirect
-	github.com/olekukonko/tablewriter v0.0.5 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/prometheus/client_model v0.5.0 // indirect
 	github.com/prometheus/common v0.48.0 // indirect
 	github.com/prometheus/procfs v0.12.0 // indirect
-	github.com/prometheus/tsdb v0.7.1 // indirect
-	github.com/rivo/uniseg v0.4.4 // indirect
-	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/zktrie v0.8.4 // indirect
 	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.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
-	github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	go.uber.org/atomic v1.7.0 // indirect
-	go.uber.org/multierr v1.9.0 // indirect
 	golang.org/x/crypto v0.32.0 // indirect
 	golang.org/x/sync v0.11.0 // indirect
 	golang.org/x/sys v0.30.0 // indirect
-	golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba // indirect
-	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
-	gopkg.in/urfave/cli.v1 v1.20.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	rsc.io/tmplfunc v0.0.3 // indirect
 )

coordinator/go.sum

@@ -1,18 +1,12 @@
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI=
 github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI=
 github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
 github.com/agiledragon/gomonkey/v2 v2.12.0 h1:ek0dYu9K1rSV+TgkW5LvNNPRWyDZVIxGMCFI6Pz9o38=
 github.com/agiledragon/gomonkey/v2 v2.12.0/go.mod h1:ap1AmDzcVOAz1YpeJ3TCzIgstoaWLA6jbbgxfB4w2iY=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
-github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
 github.com/appleboy/gin-jwt/v2 v2.9.1 h1:l29et8iLW6omcHltsOP6LLk4s3v4g2FbFs0koxGWVZs=
 github.com/appleboy/gin-jwt/v2 v2.9.1/go.mod h1:jwcPZJ92uoC9nOUTOKWoN/f6JZOgMSKlFSHw5/FrRUk=
 github.com/appleboy/gofight/v2 v2.1.2 h1:VOy3jow4vIK8BRQJoC/I9muxyYlJ2yb9ht2hZoS3rf4=
 github.com/appleboy/gofight/v2 v2.1.2/go.mod h1:frW+U1QZEdDgixycTj4CygQ48yLTUhplt43+Wczp3rw=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bits-and-blooms/bitset v1.20.0 h1:2F+rfL86jE2d/bmw7OhqUg2Sj/1rURkBn3MdfoPyRVU=
@@ -30,9 +24,6 @@ github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1
 github.com/bytedance/sonic v1.10.0-rc/go.mod h1:ElCzW+ufi8qKqNW0FY314xriJhyJhuoJ3gFZdAHF7NM=
 github.com/bytedance/sonic v1.10.1 h1:7a1wuFXL1cMy7a3f7/VFcEtriuXQnUBhtoVfOZiaysc=
 github.com/bytedance/sonic v1.10.1/go.mod h1:iZcSUejdk5aukTND/Eu/ivjQuEL0Cu9/rf50Hi0u/g4=
-github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
-github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
@@ -54,32 +45,16 @@ github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/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 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=
-github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
 github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
-github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
-github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.8.1/go.mod h1:ji8BvRH1azfM+SYow9zQ6SZMvR8qOMZHmsCuWR9tTTk=
 github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
 github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
-github.com/go-kit/kit v0.8.0 h1:Wz+5lgoB0kkuqLEc6NVmwRknTKP6dTGbSqvhZtBI/j0=
-github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-logfmt/logfmt v0.5.1 h1:otpy5pqBCBZ1ng9RQ0dPu4PN7ba75Y/aA+UpowDyNVA=
-github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
 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=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
@@ -98,31 +73,19 @@ github.com/go-playground/validator/v10 v10.15.5 h1:LEBecTWb/1j5TNY1YYG2RcOUN3R7N
 github.com/go-playground/validator/v10 v10.15.5/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
 github.com/go-resty/resty/v2 v2.7.0 h1:me+K9p3uhSmXtrBZ4k9jcEAfJmuC8IivWHwaLZwPrFY=
 github.com/go-resty/resty/v2 v2.7.0/go.mod h1:9PWDzw47qPphMRFfhsyk0NnSgvluHcljSMVIq3w7q0I=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
 github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
 github.com/goccy/go-json v0.9.7/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/goccy/go-json v0.10.0/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
-github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/golang-jwt/jwt/v4 v4.4.3/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
 github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg=
 github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk=
 github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
@@ -130,24 +93,13 @@ github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/
 github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
-github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE=
-github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0=
-github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs=
-github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
 github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
 github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA=
 github.com/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA=
 github.com/holiman/uint256 v1.3.2/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/huin/goupnp v1.0.2 h1:RfGLP+h3mvisuWEyybxNq5Eft3NWhHLPeUN72kpKZoI=
-github.com/huin/goupnp v1.0.2/go.mod h1:0dxJBVBHqTMjIUMkESDTNgOOx/Mw5wYIfyFmdzSamkM=
-github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
 github.com/iden3/go-iden3-crypto v0.0.17 h1:NdkceRLJo/pI4UpcjVah4lN/a3yzxRUGXqxbWcYh9mY=
 github.com/iden3/go-iden3-crypto v0.0.17/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBeOT/3UEhXsEsP3E=
-github.com/jackpal/go-nat-pmp v1.0.2-0.20160603034137-1fa385a6f458 h1:6OvNmYgJyexcZ3pYbTI9jWx5tHo1Dee/tWbLMfPe2TA=
-github.com/jackpal/go-nat-pmp v1.0.2-0.20160603034137-1fa385a6f458/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
 github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
@@ -163,7 +115,6 @@ github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa02
 github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg=
 github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
@@ -178,22 +129,14 @@ github.com/leanovate/gopter v0.2.11/go.mod h1:aK3tzZP/C+p1m3SPRE4SYZFGP7jjkuSI4f
 github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
 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.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
-github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
 github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A=
-github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4=
 github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY=
 github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU=
 github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU=
@@ -202,76 +145,51 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
-github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
-github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
-github.com/onsi/ginkgo v1.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA=
-github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
-github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE=
-github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/pelletier/go-toml/v2 v2.0.1/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZOjgMj2KwnJFUo=
 github.com/pelletier/go-toml/v2 v2.0.6/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek=
 github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4=
 github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
 github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7kmXYlnfbA6JU=
 github.com/prometheus/client_golang v1.19.0/go.mod h1:ZRM9uEAypZakd+q/x7+gmsvXdURP+DABIEIjnmDdp+k=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw=
 github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI=
-github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE=
 github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
 github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
 github.com/prometheus/tsdb v0.7.1 h1:YZcsG11NqnK4czYLrWd9mpEuAJIHVQLwdrleYfszMAA=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeCE=
-github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
 github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
 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/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
-github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.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/da-codec v0.1.3-0.20250401062930-9f9f53898493 h1:Ioc01J0WEMxuwFvEPGJeBKXdf2KY4Yc3XbFky/IxLlI=
+github.com/scroll-tech/da-codec v0.1.3-0.20250401062930-9f9f53898493/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601 h1:NEsjCG6uSvLRBlsP3+x6PL1kM+Ojs3g8UGotIPgJSz8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 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/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8=
 github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
-github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
-github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4 h1:Gb2Tyox57NRNuZ2d3rmvB3pcmbu7O1RS3m8WRx7ilrg=
-github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
@@ -298,8 +216,6 @@ github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPD
 github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
-github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef h1:wHSqTBrZW24CsNJDfeh9Ex6Pm0Rcpc7qrgKBiL44vF4=
-github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef/go.mod h1:sJ5fKU0s6JVwZjjcUEX2zFOnvq0ASQ2K9Zr6cf67kNs=
 github.com/ugorji/go v1.2.7/go.mod h1:nF9osbDWLy6bDVv/Rtoh6QgnvNDpmCalQV5urGCCS6M=
 github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY=
 github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
@@ -311,16 +227,11 @@ github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsr
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
-go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
-go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI=
-go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/arch v0.5.0 h1:jpGode6huXQxcskEIpOCvrU+tzo81b6+oFLUYXWtH/Y=
 golang.org/x/arch v0.5.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 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.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
@@ -329,10 +240,7 @@ golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
 golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20211029224645-99673261e6eb/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
@@ -342,25 +250,13 @@ golang.org/x/net v0.4.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE=
 golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs=
 golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
 golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -373,56 +269,36 @@ golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
 golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
-golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba h1:O8mE0/t419eoIwhTFpKVkHiTs/Igowgfkj25AcZrtiE=
-golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
 google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU=
-gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/urfave/cli.v1 v1.20.0 h1:NdAVW6RYxDif9DhDHaAortIu956m2c0v+09AZBPTbE0=
-gopkg.in/urfave/cli.v1 v1.20.0/go.mod h1:vuBzUtMdQeixQj8LVd+/98pzhxNGQoyuPBlsXHOQNO0=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

coordinator/internal/config/config.go

@@ -28,16 +28,10 @@ type ProverManager struct {
 	BundleCollectionTimeSec int `json:"bundle_collection_time_sec"`
 }
 
-// l2geth client configuration items
-type L2Endpoint struct {
-	Url string `json:"endpoint"`
-}
-
 // L2 loads l2geth configuration items.
 type L2 struct {
 	// l2geth chain_id.
-	ChainID  uint64      `json:"chain_id"`
-	Endpoint *L2Endpoint `json:"l2geth"`
+	ChainID uint64 `json:"chain_id"`
 }
 
 // Auth provides the auth coordinator
@@ -55,19 +49,19 @@ type Config struct {
 	Auth          *Auth            `json:"auth"`
 }
 
-// AssetConfig contain assets configurated for each fork, the defaul vkfile name is "OpenVmVk.json".
-type AssetConfig struct {
+// CircuitConfig circuit items.
+type CircuitConfig struct {
+	ParamsPath       string `json:"params_path"`
 	AssetsPath       string `json:"assets_path"`
 	ForkName         string `json:"fork_name"`
-	Vkfile           string `json:"vk_file,omitempty"`
-	MinProverVersion string `json:"min_prover_version,omitempty"`
+	MinProverVersion string `json:"min_prover_version"`
 }
 
 // VerifierConfig load zk verifier config.
 type VerifierConfig struct {
-	MinProverVersion string        `json:"min_prover_version"`
-	Features         string        `json:"features,omitempty"`
-	Verifiers        []AssetConfig `json:"verifiers"`
+	MockMode           bool           `json:"mock_mode"`
+	LowVersionCircuit  *CircuitConfig `json:"low_version_circuit"`
+	HighVersionCircuit *CircuitConfig `json:"high_version_circuit"`
 }
 
 // NewConfig returns a new instance of Config.

coordinator/internal/config/config_test.go

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

coordinator/internal/controller/api/controller.go

@@ -1,15 +1,12 @@
 package api
 
 import (
-	"encoding/json"
-
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
 	"scroll-tech/coordinator/internal/config"
-	"scroll-tech/coordinator/internal/logic/libzkp"
 	"scroll-tech/coordinator/internal/logic/verifier"
 )
 
@@ -29,20 +26,9 @@ func InitController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.D
 		panic("proof receiver new verifier failure")
 	}
 
-	log.Info("verifier created", "openVmVerifier", vf.OpenVMVkMap)
-
-	// TODO: enable this when the libzkp has been updated
-	l2cfg := cfg.L2.Endpoint
-	if l2cfg == nil {
-		panic("l2geth is not specified")
-	}
-	l2cfgBytes, err := json.Marshal(l2cfg)
-	if err != nil {
-		panic(err)
-	}
-	libzkp.InitL2geth(string(l2cfgBytes))
+	log.Info("verifier created", "chunkVerifier", vf.ChunkVKMap, "batchVerifier", vf.BatchVKMap, "bundleVerifier", vf.BundleVkMap, "openVmVerifier", vf.OpenVMVkMap)
 
 	Auth = NewAuthController(db, cfg, vf)
-	GetTask = NewGetTaskController(cfg, chainCfg, db, vf, reg)
+	GetTask = NewGetTaskController(cfg, chainCfg, db, reg)
 	SubmitProof = NewSubmitProofController(cfg, chainCfg, db, vf, reg)
 }

coordinator/internal/controller/api/get_task.go

@@ -17,7 +17,6 @@ import (
 
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/logic/provertask"
-	"scroll-tech/coordinator/internal/logic/verifier"
 	coordinatorType "scroll-tech/coordinator/internal/types"
 )
 
@@ -26,15 +25,13 @@ type GetTaskController struct {
 	proverTasks map[message.ProofType]provertask.ProverTask
 
 	getTaskAccessCounter *prometheus.CounterVec
-
-	l2syncer *l2Syncer
 }
 
 // NewGetTaskController create a get prover task controller
-func NewGetTaskController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, verifier *verifier.Verifier, reg prometheus.Registerer) *GetTaskController {
-	chunkProverTask := provertask.NewChunkProverTask(cfg, chainCfg, db, verifier.ChunkVk, reg)
-	batchProverTask := provertask.NewBatchProverTask(cfg, chainCfg, db, verifier.BatchVk, reg)
-	bundleProverTask := provertask.NewBundleProverTask(cfg, chainCfg, db, verifier.BundleVk, reg)
+func NewGetTaskController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *GetTaskController {
+	chunkProverTask := provertask.NewChunkProverTask(cfg, chainCfg, db, reg)
+	batchProverTask := provertask.NewBatchProverTask(cfg, chainCfg, db, reg)
+	bundleProverTask := provertask.NewBundleProverTask(cfg, chainCfg, db, reg)
 
 	ptc := &GetTaskController{
 		proverTasks: make(map[message.ProofType]provertask.ProverTask),
@@ -47,13 +44,6 @@ func NewGetTaskController(cfg *config.Config, chainCfg *params.ChainConfig, db *
 	ptc.proverTasks[message.ProofTypeChunk] = chunkProverTask
 	ptc.proverTasks[message.ProofTypeBatch] = batchProverTask
 	ptc.proverTasks[message.ProofTypeBundle] = bundleProverTask
-
-	if syncer, err := createL2Syncer(cfg); err != nil {
-		log.Crit("can not init l2 syncer", "err", err)
-	} else {
-		ptc.l2syncer = syncer
-	}
-
 	return ptc
 }
 
@@ -88,17 +78,6 @@ func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 		return
 	}
 
-	if getTaskParameter.ProverHeight == 0 {
-		// help update the prover height with internal l2geth
-		if blk, err := ptc.l2syncer.getLatestBlockNumber(ctx); err == nil {
-			getTaskParameter.ProverHeight = blk
-		} else {
-			nerr := fmt.Errorf("inner l2geth failure, err:%w", err)
-			types.RenderFailure(ctx, types.InternalServerError, nerr)
-			return
-		}
-	}
-
 	proofType := ptc.proofType(&getTaskParameter)
 	proverTask, isExist := ptc.proverTasks[proofType]
 	if !isExist {

coordinator/internal/controller/api/l2_syncer.go

@@ -1,71 +0,0 @@
-//go:build !mock_verifier
-
-package api
-
-import (
-	"errors"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/scroll-tech/go-ethereum/log"
-
-	"scroll-tech/coordinator/internal/config"
-)
-
-type l2Syncer struct {
-	l2gethClient    *ethclient.Client
-	lastBlockNumber struct {
-		sync.RWMutex
-		data uint64
-		t    time.Time
-	}
-}
-
-func createL2Syncer(cfg *config.Config) (*l2Syncer, error) {
-
-	if cfg.L2 == nil || cfg.L2.Endpoint == nil {
-		return nil, fmt.Errorf("l2 endpoint is not set in config")
-	} else {
-		l2gethClient, err := ethclient.Dial(cfg.L2.Endpoint.Url)
-		if err != nil {
-			return nil, fmt.Errorf("dial l2geth endpoint fail, err: %s", err)
-		}
-		return &l2Syncer{
-			l2gethClient: l2gethClient,
-		}, nil
-	}
-}
-
-// getLatestBlockNumber gets the latest block number, using cache if available and not expired
-func (syncer *l2Syncer) getLatestBlockNumber(ctx *gin.Context) (uint64, error) {
-	// First check if we have a cached value that's still valid
-	syncer.lastBlockNumber.RLock()
-	if !syncer.lastBlockNumber.t.IsZero() && time.Since(syncer.lastBlockNumber.t) < time.Second*10 {
-		blockNumber := syncer.lastBlockNumber.data
-		syncer.lastBlockNumber.RUnlock()
-		return blockNumber, nil
-	}
-	syncer.lastBlockNumber.RUnlock()
-
-	// If not cached or expired, fetch from the client
-	if syncer.l2gethClient == nil {
-		return 0, errors.New("L2 geth client not initialized")
-	}
-
-	blockNumber, err := syncer.l2gethClient.BlockNumber(ctx)
-	if err != nil {
-		return 0, fmt.Errorf("failed to get latest block number: %w", err)
-	}
-
-	// Update the cache
-	syncer.lastBlockNumber.Lock()
-	syncer.lastBlockNumber.data = blockNumber
-	syncer.lastBlockNumber.t = time.Now()
-	syncer.lastBlockNumber.Unlock()
-
-	log.Debug("updated block height reference", "height", blockNumber)
-	return blockNumber, nil
-}

coordinator/internal/controller/api/mock_syncer.go

@@ -1,20 +0,0 @@
-//go:build mock_verifier
-
-package api
-
-import (
-	"scroll-tech/coordinator/internal/config"
-
-	"github.com/gin-gonic/gin"
-)
-
-type l2Syncer struct{}
-
-func createL2Syncer(_ *config.Config) (*l2Syncer, error) {
-	return &l2Syncer{}, nil
-}
-
-// getLatestBlockNumber gets the latest block number, using cache if available and not expired
-func (syncer *l2Syncer) getLatestBlockNumber(_ *gin.Context) (uint64, error) {
-	return 99999994, nil
-}

coordinator/internal/logic/auth/login.go

@@ -9,6 +9,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/log"
 	"gorm.io/gorm"
 
+	"scroll-tech/common/types/message"
 	"scroll-tech/common/version"
 
 	"scroll-tech/coordinator/internal/config"
@@ -21,22 +22,40 @@ import (
 type LoginLogic struct {
 	cfg          *config.Config
 	challengeOrm *orm.Challenge
+	chunkVks     map[string]struct{}
+	batchVKs     map[string]struct{}
+	bundleVks    map[string]struct{}
 
 	openVmVks map[string]struct{}
 
-	proverVersionHardForkMap map[string]string
+	proverVersionHardForkMap map[string][]string
 }
 
 // NewLoginLogic new a LoginLogic
 func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *LoginLogic {
-	proverVersionHardForkMap := make(map[string]string)
-
-	for _, cfg := range cfg.ProverManager.Verifier.Verifiers {
-		proverVersionHardForkMap[cfg.ForkName] = cfg.MinProverVersion
+	proverVersionHardForkMap := make(map[string][]string)
+	if version.CheckScrollRepoVersion(cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion, cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion) {
+		log.Error("config file error, low verifier min_prover_version should not more than high verifier min_prover_version",
+			"low verifier min_prover_version", cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion,
+			"high verifier min_prover_version", cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion)
+		panic("verifier config file error")
 	}
 
+	var highHardForks []string
+	highHardForks = append(highHardForks, cfg.ProverManager.Verifier.HighVersionCircuit.ForkName)
+	if cfg.ProverManager.Verifier.HighVersionCircuit.ForkName != message.EuclidFork && cfg.ProverManager.Verifier.HighVersionCircuit.ForkName != message.EuclidV2Fork {
+		highHardForks = append(highHardForks, cfg.ProverManager.Verifier.LowVersionCircuit.ForkName)
+	}
+	highHardForks = append(highHardForks, message.EuclidFork, message.EuclidV2Fork)
+	proverVersionHardForkMap[cfg.ProverManager.Verifier.HighVersionCircuit.MinProverVersion] = highHardForks
+
+	proverVersionHardForkMap[cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion] = []string{cfg.ProverManager.Verifier.LowVersionCircuit.ForkName}
+
 	return &LoginLogic{
 		cfg:                      cfg,
+		chunkVks:                 vf.ChunkVKMap,
+		batchVKs:                 vf.BatchVKMap,
+		bundleVks:                vf.BundleVkMap,
 		openVmVks:                vf.OpenVMVkMap,
 		challengeOrm:             orm.NewChallenge(db),
 		proverVersionHardForkMap: proverVersionHardForkMap,
@@ -56,25 +75,49 @@ func (l *LoginLogic) Check(login *types.LoginParameter) error {
 		return errors.New("auth message verify failure")
 	}
 
-	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.Verifier.MinProverVersion) {
-		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", l.cfg.ProverManager.Verifier.MinProverVersion, login.Message.ProverVersion)
+	// FIXME: for backward compatibility, set prover version as darwin prover version,
+	// change v4.4.56 to l.cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion after Euclid upgrade, including the log.
+	// hardcode the prover version because l.cfg.ProverManager.Verifier.LowVersionCircuit.MinProverVersion is used in another check and should be set as v4.4.89 for darwinV2 provers.
+	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, "v4.4.56") {
+		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s",
+			"v4.4.56", login.Message.ProverVersion)
 	}
 
-	vks := make(map[string]struct{})
-	for vk := range l.openVmVks {
-		vks[vk] = struct{}{}
-	}
-
-	for _, vk := range login.Message.VKs {
-		if _, ok := vks[vk]; !ok {
-			log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
-				"prover_version", login.Message.ProverVersion, "message", login.Message)
-			if !version.CheckScrollProverVersion(login.Message.ProverVersion) {
-				return fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s",
-					version.Version, login.Message.ProverVersion)
+	if len(login.Message.ProverTypes) > 0 {
+		vks := make(map[string]struct{})
+		for _, proverType := range login.Message.ProverTypes {
+			switch proverType {
+			case types.ProverTypeChunk:
+				for vk := range l.chunkVks {
+					vks[vk] = struct{}{}
+				}
+			case types.ProverTypeBatch:
+				for vk := range l.batchVKs {
+					vks[vk] = struct{}{}
+				}
+				for vk := range l.bundleVks {
+					vks[vk] = struct{}{}
+				}
+			case types.ProverTypeOpenVM:
+				for vk := range l.openVmVks {
+					vks[vk] = struct{}{}
+				}
+			default:
+				log.Error("invalid prover_type", "value", proverType, "prover name", login.Message.ProverName, "prover_version", login.Message.ProverVersion)
+			}
+		}
+
+		for _, vk := range login.Message.VKs {
+			if _, ok := vks[vk]; !ok {
+				log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
+					"prover_version", login.Message.ProverVersion, "message", login.Message)
+				if !version.CheckScrollProverVersion(login.Message.ProverVersion) {
+					return fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s",
+						version.Version, login.Message.ProverVersion)
+				}
+				// if the prover reports a same prover version
+				return errors.New("incompatible vk. please check your params files or config files")
 			}
-			// if the prover reports a same prover version
-			return errors.New("incompatible vk. please check your params files or config files")
 		}
 	}
 
@@ -99,15 +142,15 @@ func (l *LoginLogic) ProverHardForkName(login *types.LoginParameter) (string, er
 	}
 
 	proverVersion := proverVersionSplits[0]
-	var hardForkNames []string
-	for n, minVersion := range l.proverVersionHardForkMap {
-		if minVersion == "" || version.CheckScrollRepoVersion(proverVersion, minVersion) {
-			hardForkNames = append(hardForkNames, n)
-		}
-	}
-	if len(hardForkNames) == 0 {
-		return "", fmt.Errorf("invalid prover prover_version:%s", login.Message.ProverVersion)
+
+	// allowing darwin provers to login, because darwin provers can prove darwinV2 chunk tasks
+	if proverVersion == "v4.4.56" {
+		return "darwin", nil
 	}
 
-	return strings.Join(hardForkNames, ","), nil
+	if hardForkNames, ok := l.proverVersionHardForkMap[proverVersion]; ok {
+		return strings.Join(hardForkNames, ","), nil
+	}
+
+	return "", fmt.Errorf("invalid prover prover_version:%s", login.Message.ProverVersion)
 }

coordinator/internal/logic/libzkp/Makefile

@@ -1,17 +0,0 @@
-.PHONY: help fmt clippy test test-ci test-all
-
-build:
-	@cargo build --release -p libzkp-c
-	@mkdir -p lib
-	@cp -f ../../../../target/release/libzkp.so lib/
-
-fmt:
-	@cargo fmt --all -- --check
-
-clean:
-	@cargo clean --release -p libzkp -p libzkp-c -p l2geth
-	@rm -f lib/libzkp.so
-
-clippy:
-	@cargo check --release --all-features
-	@cargo clippy --release -- -D warnings

coordinator/internal/logic/libzkp/lib.go

@@ -1,149 +0,0 @@
-package libzkp
-
-/*
-#cgo LDFLAGS: -lzkp -lm -ldl -L${SRCDIR}/lib -Wl,-rpath=${SRCDIR}/lib
-#cgo gpu LDFLAGS: -lzkp -lm -ldl -lgmp -lstdc++ -lprocps -L/usr/local/cuda/lib64/ -lcudart -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
-#include <stdlib.h>
-#include "libzkp.h"
-*/
-import "C" //nolint:typecheck
-
-import (
-	"fmt"
-	"os"
-	"strings"
-	"unsafe"
-
-	"scroll-tech/common/types/message"
-)
-
-func init() {
-	C.init_tracing()
-}
-
-// Helper function to convert Go string to C string and handle cleanup
-func goToCString(s string) *C.char {
-	return C.CString(s)
-}
-
-// Helper function to free C string
-func freeCString(s *C.char) {
-	C.free(unsafe.Pointer(s))
-}
-
-// Initialize the verifier
-func InitVerifier(configJSON string) {
-	cConfig := goToCString(configJSON)
-	defer freeCString(cConfig)
-
-	C.init_verifier(cConfig)
-}
-
-// Verify a chunk proof
-func VerifyChunkProof(proofData, forkName string) bool {
-	cProof := goToCString(proofData)
-	cForkName := goToCString(strings.ToLower(forkName))
-	defer freeCString(cProof)
-	defer freeCString(cForkName)
-
-	result := C.verify_chunk_proof(cProof, cForkName)
-	return result != 0
-}
-
-// Verify a batch proof
-func VerifyBatchProof(proofData, forkName string) bool {
-	cProof := goToCString(proofData)
-	cForkName := goToCString(strings.ToLower(forkName))
-	defer freeCString(cProof)
-	defer freeCString(cForkName)
-
-	result := C.verify_batch_proof(cProof, cForkName)
-	return result != 0
-}
-
-// Verify a bundle proof
-func VerifyBundleProof(proofData, forkName string) bool {
-	cProof := goToCString(proofData)
-	cForkName := goToCString(strings.ToLower(forkName))
-	defer freeCString(cProof)
-	defer freeCString(cForkName)
-
-	result := C.verify_bundle_proof(cProof, cForkName)
-	return result != 0
-}
-
-// TaskType enum values matching the Rust enum
-const (
-	TaskTypeChunk  = 0
-	TaskTypeBatch  = 1
-	TaskTypeBundle = 2
-)
-
-func fromMessageTaskType(taskType int) int {
-	switch message.ProofType(taskType) {
-	case message.ProofTypeChunk:
-		return TaskTypeChunk
-	case message.ProofTypeBatch:
-		return TaskTypeBatch
-	case message.ProofTypeBundle:
-		return TaskTypeBundle
-	default:
-		panic(fmt.Sprintf("unsupported proof type: %d", taskType))
-	}
-}
-
-// Generate a universal task
-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
-func GenerateWrappedProof(proofJSON, metadata string, vkData []byte) string {
-	cProofJSON := goToCString(proofJSON)
-	cMetadata := goToCString(metadata)
-	defer freeCString(cProofJSON)
-	defer freeCString(cMetadata)
-
-	// Create a C array from Go slice
-	var cVkData *C.char
-	if len(vkData) > 0 {
-		cVkData = (*C.char)(unsafe.Pointer(&vkData[0]))
-	}
-
-	resultPtr := C.gen_wrapped_proof(cProofJSON, cMetadata, cVkData, C.size_t(len(vkData)))
-	if resultPtr == nil {
-		return ""
-	}
-
-	// Convert result to Go string and free C memory
-	result := C.GoString(resultPtr)
-	C.release_string(resultPtr)
-
-	return result
-}
-
-// Dumps a verification key to a file
-func DumpVk(forkName, filePath string) error {
-	cForkName := goToCString(strings.ToLower(forkName))
-	cFilePath := goToCString(filePath)
-	defer freeCString(cForkName)
-	defer freeCString(cFilePath)
-
-	// Call the C function to dump the verification key
-	C.dump_vk(cForkName, cFilePath)
-
-	// Check if the file was created successfully
-	// Note: The C function doesn't return an error code, so we check if the file exists
-	if _, err := os.Stat(filePath); os.IsNotExist(err) {
-		return fmt.Errorf("failed to dump verification key: file %s was not created", filePath)
-	}
-
-	return 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

@@ -1,60 +0,0 @@
-// Verifier is used to:
-// - Verify a batch proof
-// - Verify a bundle proof
-// - Verify a chunk proof
-
-#ifndef LIBZKP_H
-#define LIBZKP_H
-
-#include <stddef.h> // For size_t
-
-// Init log tracing
-void init_tracing();
-
-// Initialize the verifier with configuration
-void init_verifier(char* config);
-
-// Initialize the l2geth with configuration
-void init_l2geth(char* config);
-
-// Verify proofs - returns non-zero for success, zero for failure
-char verify_batch_proof(char* proof, char* fork_name);
-char verify_bundle_proof(char* proof, char* fork_name);
-char verify_chunk_proof(char* proof, char* fork_name);
-
-// Dump verification key to file
-void dump_vk(char* fork_name, char* file);
-
-// The result struct to hold data from handling a proving task
-typedef struct {
-    char ok;
-    char* universal_task;
-    char* metadata;
-    char expected_pi_hash[32];
-} HandlingResult;
-
-// Generate a universal task based on task type and input JSON
-// Returns a struct containing task data, metadata, and expected proof hash
-HandlingResult gen_universal_task(
-    int task_type,
-    char* task,
-    char* fork_name,
-    const unsigned char* expected_vk,
-    size_t expected_vk_len
-);
-
-// Release memory allocated for a HandlingResult returned by gen_universal_task
-void release_task_result(HandlingResult result);
-
-// Generate a wrapped proof from the universal prover output and metadata
-// Returns a JSON string containing the wrapped proof, or NULL on error
-// The caller must call release_string on the returned pointer when done
-char* gen_wrapped_proof(char* proof_json, char* metadata, char* vk, size_t vk_len);
-
-// Release memory allocated for a string returned by gen_wrapped_proof
-void release_string(char* string_ptr);
-
-void set_dynamic_feature(const char* feats);
-
-
-#endif /* LIBZKP_H */

coordinator/internal/logic/libzkp/mock_universal_task.go

@@ -1,45 +0,0 @@
-//go:build mock_verifier
-
-package libzkp
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"scroll-tech/common/types/message"
-
-	"github.com/scroll-tech/go-ethereum/common"
-)
-
-func InitL2geth(configJSON string) {
-}
-
-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{}
-	switch taskType {
-	case TaskTypeChunk:
-		metadata = struct {
-			ChunkInfo *message.ChunkInfo `json:"chunk_info"`
-		}{ChunkInfo: &message.ChunkInfo{}}
-	case TaskTypeBatch:
-		metadata = struct {
-			BatchInfo *message.OpenVMBatchInfo `json:"batch_info"`
-			BatchHash common.Hash              `json:"batch_hash"`
-		}{BatchInfo: &message.OpenVMBatchInfo{}}
-	case TaskTypeBundle:
-		metadata = struct {
-			BundleInfo   *message.OpenVMBundleInfo `json:"bundle_info"`
-			BundlePIHash common.Hash               `json:"bundle_pi_hash"`
-		}{BundleInfo: &message.OpenVMBundleInfo{}}
-	}
-
-	encodeData, err := json.Marshal(metadata)
-	if err != nil {
-		fmt.Println("mock encoding json fail:", err)
-		return false, "", "", nil
-	}
-
-	return true, "UniversalTask data is not parsed", string(encodeData), []byte{0}
-}

coordinator/internal/logic/libzkp/universal_task.go

@@ -1,51 +0,0 @@
-//go:build !mock_verifier
-
-package libzkp
-
-/*
-#include <stdlib.h>
-#include "libzkp.h"
-*/
-import "C" //nolint:typecheck
-import "unsafe"
-
-// Initialize the handler for universal task
-func InitL2geth(configJSON string) {
-	cConfig := goToCString(configJSON)
-	defer freeCString(cConfig)
-
-	C.init_l2geth(cConfig)
-}
-
-func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte) (bool, string, string, []byte) {
-	cTask := goToCString(taskJSON)
-	cForkName := goToCString(forkName)
-	defer freeCString(cTask)
-	defer freeCString(cForkName)
-
-	// Create a C array from Go slice
-	var cVk *C.uchar
-	if len(expectedVk) > 0 {
-		cVk = (*C.uchar)(unsafe.Pointer(&expectedVk[0]))
-	}
-
-	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
-	if result.ok == 0 {
-		return false, "", "", nil
-	}
-
-	// Convert C strings to Go strings
-	universalTask := C.GoString(result.universal_task)
-	metadata := C.GoString(result.metadata)
-
-	// Convert C array to Go slice
-	piHash := make([]byte, 32)
-	for i := 0; i < 32; i++ {
-		piHash[i] = byte(result.expected_pi_hash[i])
-	}
-
-	return true, universalTask, metadata, piHash
-}

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -36,13 +36,12 @@ type BatchProverTask struct {
 }
 
 // NewBatchProverTask new a batch collector
-func NewBatchProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, expectedVk map[string][]byte, reg prometheus.Registerer) *BatchProverTask {
+func NewBatchProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *BatchProverTask {
 	bp := &BatchProverTask{
 		BaseProverTask: BaseProverTask{
 			db:                 db,
 			cfg:                cfg,
 			chainCfg:           chainCfg,
-			expectedVk:         expectedVk,
 			blockOrm:           orm.NewL2Block(db),
 			chunkOrm:           orm.NewChunk(db),
 			batchOrm:           orm.NewBatch(db),
@@ -84,37 +83,10 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpBatchTask *orm.Batch
-
-		if taskCtx.hasAssignedTask != nil {
-			if taskCtx.hasAssignedTask.TaskType != int16(message.ProofTypeBatch) {
-				return nil, fmt.Errorf("prover with publicKey %s is already assigned a task. ProverName: %s, ProverVersion: %s", taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
-			}
-
-			tmpBatchTask, getTaskError = bp.batchOrm.GetBatchByHash(ctx.Copy(), taskCtx.hasAssignedTask.TaskID)
-			if getTaskError != nil {
-				log.Error("failed to get batch has assigned to prover", "taskID", taskCtx.hasAssignedTask.TaskID, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			} else if tmpBatchTask == nil {
-				// if the assigned batch dropped, there would be too much issue to assign another
-				return nil, fmt.Errorf("prover with publicKey %s is already assigned a dropped batch. ProverName: %s, ProverVersion: %s",
-					taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
-			}
-		} else if getTaskParameter.TaskID != "" {
-			tmpBatchTask, getTaskError = bp.batchOrm.GetBatchByHash(ctx.Copy(), getTaskParameter.TaskID)
-			if getTaskError != nil {
-				log.Error("failed to get expected batch", "taskID", getTaskParameter.TaskID, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			} else if tmpBatchTask == nil {
-				return nil, fmt.Errorf("Expected task (%s) is already dropped", getTaskParameter.TaskID)
-			}
-		}
-
-		if tmpBatchTask == nil {
-			tmpBatchTask, getTaskError = bp.batchOrm.GetAssignedBatch(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
-			if getTaskError != nil {
-				log.Error("failed to get assigned batch proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			}
+		tmpBatchTask, getTaskError = bp.batchOrm.GetAssignedBatch(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
+		if getTaskError != nil {
+			log.Error("failed to get assigned batch proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
+			return nil, ErrCoordinatorInternalFailure
 		}
 
 		// Why here need get again? In order to support a task can assign to multiple prover, need also assign `ProvingTaskAssigned`
@@ -142,32 +114,29 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 			return nil, nil
 		}
 
-		// we are simply pick the chunk which has been assigned, so don't bother to update attempts or check failed before
-		if taskCtx.hasAssignedTask == nil {
-			// Don't dispatch the same failing job to the same prover
-			proverTasks, getFailedTaskError := bp.proverTaskOrm.GetFailedProverTasksByHash(ctx.Copy(), message.ProofTypeBatch, tmpBatchTask.Hash, 2)
-			if getFailedTaskError != nil {
-				log.Error("failed to get prover tasks", "proof type", message.ProofTypeBatch.String(), "task ID", tmpBatchTask.Hash, "error", getFailedTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			}
-			for i := 0; i < len(proverTasks); i++ {
-				if proverTasks[i].ProverPublicKey == taskCtx.PublicKey ||
-					taskCtx.ProverProviderType == uint8(coordinatorType.ProverProviderTypeExternal) && cutils.IsExternalProverNameMatch(proverTasks[i].ProverName, taskCtx.ProverName) {
-					log.Debug("get empty batch, the prover already failed this task", "height", getTaskParameter.ProverHeight, "task ID", tmpBatchTask.Hash, "prover name", taskCtx.ProverName, "prover public key", taskCtx.PublicKey)
-					return nil, nil
-				}
+		// Don't dispatch the same failing job to the same prover
+		proverTasks, getFailedTaskError := bp.proverTaskOrm.GetFailedProverTasksByHash(ctx.Copy(), message.ProofTypeBatch, tmpBatchTask.Hash, 2)
+		if getFailedTaskError != nil {
+			log.Error("failed to get prover tasks", "proof type", message.ProofTypeBatch.String(), "task ID", tmpBatchTask.Hash, "error", getFailedTaskError)
+			return nil, ErrCoordinatorInternalFailure
+		}
+		for i := 0; i < len(proverTasks); i++ {
+			if proverTasks[i].ProverPublicKey == taskCtx.PublicKey ||
+				taskCtx.ProverProviderType == uint8(coordinatorType.ProverProviderTypeExternal) && cutils.IsExternalProverNameMatch(proverTasks[i].ProverName, taskCtx.ProverName) {
+				log.Debug("get empty batch, the prover already failed this task", "height", getTaskParameter.ProverHeight, "task ID", tmpBatchTask.Hash, "prover name", taskCtx.ProverName, "prover public key", taskCtx.PublicKey)
+				return nil, nil
 			}
+		}
 
-			rowsAffected, updateAttemptsErr := bp.batchOrm.UpdateBatchAttempts(ctx.Copy(), tmpBatchTask.Index, tmpBatchTask.ActiveAttempts, tmpBatchTask.TotalAttempts)
-			if updateAttemptsErr != nil {
-				log.Error("failed to update batch attempts", "height", getTaskParameter.ProverHeight, "err", updateAttemptsErr)
-				return nil, ErrCoordinatorInternalFailure
-			}
+		rowsAffected, updateAttemptsErr := bp.batchOrm.UpdateBatchAttempts(ctx.Copy(), tmpBatchTask.Index, tmpBatchTask.ActiveAttempts, tmpBatchTask.TotalAttempts)
+		if updateAttemptsErr != nil {
+			log.Error("failed to update batch attempts", "height", getTaskParameter.ProverHeight, "err", updateAttemptsErr)
+			return nil, ErrCoordinatorInternalFailure
+		}
 
-			if rowsAffected == 0 {
-				time.Sleep(100 * time.Millisecond)
-				continue
-			}
+		if rowsAffected == 0 {
+			time.Sleep(100 * time.Millisecond)
+			continue
 		}
 
 		batchTask = tmpBatchTask
@@ -180,51 +149,31 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	}
 
 	log.Info("start batch proof generation session", "task_id", batchTask.Hash, "public key", taskCtx.PublicKey, "prover name", taskCtx.ProverName)
-	var proverTask *orm.ProverTask
-	if taskCtx.hasAssignedTask == nil {
-		proverTask = &orm.ProverTask{
-			TaskID:          batchTask.Hash,
-			ProverPublicKey: taskCtx.PublicKey,
-			TaskType:        int16(message.ProofTypeBatch),
-			ProverName:      taskCtx.ProverName,
-			ProverVersion:   taskCtx.ProverVersion,
-			ProvingStatus:   int16(types.ProverAssigned),
-			FailureType:     int16(types.ProverTaskFailureTypeUndefined),
-			// here why need use UTC time. see scroll/common/database/db.go
-			AssignedAt: utils.NowUTC(),
-		}
-	} else {
-		proverTask = taskCtx.hasAssignedTask
+	proverTask := orm.ProverTask{
+		TaskID:          batchTask.Hash,
+		ProverPublicKey: taskCtx.PublicKey,
+		TaskType:        int16(message.ProofTypeBatch),
+		ProverName:      taskCtx.ProverName,
+		ProverVersion:   taskCtx.ProverVersion,
+		ProvingStatus:   int16(types.ProverAssigned),
+		FailureType:     int16(types.ProverTaskFailureTypeUndefined),
+		// here why need use UTC time. see scroll/common/database/db.go
+		AssignedAt: utils.NowUTC(),
 	}
 
-	taskMsg, err := bp.formatProverTask(ctx.Copy(), proverTask, batchTask, hardForkName)
+	// Store session info.
+	if err = bp.proverTaskOrm.InsertProverTask(ctx.Copy(), &proverTask); err != nil {
+		bp.recoverActiveAttempts(ctx, batchTask)
+		log.Error("insert batch prover task info fail", "task_id", batchTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
+		return nil, ErrCoordinatorInternalFailure
+	}
+
+	taskMsg, err := bp.formatProverTask(ctx.Copy(), &proverTask, batchTask, hardForkName)
 	if err != nil {
 		bp.recoverActiveAttempts(ctx, batchTask)
 		log.Error("format prover task failure", "task_id", batchTask.Hash, "err", err)
 		return nil, ErrCoordinatorInternalFailure
 	}
-	if getTaskParameter.Universal {
-		var metadata []byte
-
-		taskMsg, metadata, err = bp.applyUniversal(taskMsg)
-		if err != nil {
-			bp.recoverActiveAttempts(ctx, batchTask)
-			log.Error("Generate universal prover task failure", "task_id", batchTask.Hash, "type", "batch", "err", err)
-			return nil, ErrCoordinatorInternalFailure
-		}
-		proverTask.Metadata = metadata
-	}
-
-	// Store session info.
-	if taskCtx.hasAssignedTask == nil {
-		if err = bp.proverTaskOrm.InsertProverTask(ctx.Copy(), proverTask); err != nil {
-			bp.recoverActiveAttempts(ctx, batchTask)
-			log.Error("insert batch prover task info fail", "task_id", batchTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
-			return nil, ErrCoordinatorInternalFailure
-		}
-	}
-	// notice uuid is set as a side effect of InsertProverTask
-	taskMsg.UUID = proverTask.UUID.String()
 
 	bp.batchTaskGetTaskTotal.WithLabelValues(hardForkName).Inc()
 	bp.batchTaskGetTaskProver.With(prometheus.Labels{
@@ -248,27 +197,34 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		return nil, fmt.Errorf("no chunk found for batch task id:%s", task.TaskID)
 	}
 
-	var chunkProofs []*message.OpenVMChunkProof
+	var chunkProofs []message.ChunkProof
 	var chunkInfos []*message.ChunkInfo
 	for _, chunk := range chunks {
-		var proof message.OpenVMChunkProof
+		proof := message.NewChunkProof(hardForkName)
 		if encodeErr := json.Unmarshal(chunk.Proof, &proof); encodeErr != nil {
 			return nil, fmt.Errorf("Chunk.GetProofsByBatchHash unmarshal proof error: %w, batch hash: %v, chunk hash: %v", encodeErr, task.TaskID, chunk.Hash)
 		}
-		chunkProofs = append(chunkProofs, &proof)
+		chunkProofs = append(chunkProofs, proof)
 
 		chunkInfo := message.ChunkInfo{
-			ChainID:            bp.cfg.L2.ChainID,
-			PrevStateRoot:      common.HexToHash(chunk.ParentChunkStateRoot),
-			PostStateRoot:      common.HexToHash(chunk.StateRoot),
-			WithdrawRoot:       common.HexToHash(chunk.WithdrawRoot),
-			DataHash:           common.HexToHash(chunk.Hash),
-			PrevMsgQueueHash:   common.HexToHash(chunk.PrevL1MessageQueueHash),
-			PostMsgQueueHash:   common.HexToHash(chunk.PostL1MessageQueueHash),
-			IsPadding:          false,
-			InitialBlockNumber: proof.MetaData.ChunkInfo.InitialBlockNumber,
-			BlockCtxs:          proof.MetaData.ChunkInfo.BlockCtxs,
-			TxDataLength:       proof.MetaData.ChunkInfo.TxDataLength,
+			ChainID:          bp.cfg.L2.ChainID,
+			PrevStateRoot:    common.HexToHash(chunk.ParentChunkStateRoot),
+			PostStateRoot:    common.HexToHash(chunk.StateRoot),
+			WithdrawRoot:     common.HexToHash(chunk.WithdrawRoot),
+			DataHash:         common.HexToHash(chunk.Hash),
+			PrevMsgQueueHash: common.HexToHash(chunk.PrevL1MessageQueueHash),
+			PostMsgQueueHash: common.HexToHash(chunk.PostL1MessageQueueHash),
+			IsPadding:        false,
+		}
+		if halo2Proof, ok := proof.(*message.Halo2ChunkProof); ok {
+			if halo2Proof.ChunkInfo != nil {
+				chunkInfo.TxBytes = halo2Proof.ChunkInfo.TxBytes
+			}
+		}
+		if openvmProof, ok := proof.(*message.OpenVMChunkProof); ok {
+			chunkInfo.InitialBlockNumber = openvmProof.MetaData.ChunkInfo.InitialBlockNumber
+			chunkInfo.BlockCtxs = openvmProof.MetaData.ChunkInfo.BlockCtxs
+			chunkInfo.TxDataLength = openvmProof.MetaData.ChunkInfo.TxDataLength
 		}
 		chunkInfos = append(chunkInfos, &chunkInfo)
 	}
@@ -284,6 +240,7 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 	}
 
 	taskMsg := &coordinatorType.GetTaskSchema{
+		UUID:         task.UUID.String(),
 		TaskID:       task.TaskID,
 		TaskType:     int(message.ProofTypeBatch),
 		TaskData:     string(chunkProofsBytes),
@@ -301,16 +258,21 @@ func (bp *BatchProverTask) recoverActiveAttempts(ctx *gin.Context, batchTask *or
 	}
 }
 
-func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*message.ChunkInfo, chunkProofs []*message.OpenVMChunkProof, hardForkName string) (*message.BatchTaskDetail, error) {
+func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*message.ChunkInfo, chunkProofs []message.ChunkProof, hardForkName string) (*message.BatchTaskDetail, error) {
 	taskDetail := &message.BatchTaskDetail{
 		ChunkInfos:  chunkInfos,
 		ChunkProofs: chunkProofs,
-		ForkName:    hardForkName,
+	}
+
+	if hardForkName == message.EuclidV2Fork {
+		taskDetail.ForkName = message.EuclidV2ForkNameForProver
+	} else if hardForkName == message.EuclidFork {
+		taskDetail.ForkName = message.EuclidForkNameForProver
 	}
 
 	dbBatchCodecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
 	switch dbBatchCodecVersion {
-	case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6, encoding.CodecV7, encoding.CodecV8:
+	case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6, encoding.CodecV7:
 	default:
 		return taskDetail, nil
 	}

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -33,13 +33,12 @@ type BundleProverTask struct {
 }
 
 // NewBundleProverTask new a bundle collector
-func NewBundleProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, expectedVk map[string][]byte, reg prometheus.Registerer) *BundleProverTask {
+func NewBundleProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *BundleProverTask {
 	bp := &BundleProverTask{
 		BaseProverTask: BaseProverTask{
 			db:                 db,
 			chainCfg:           chainCfg,
 			cfg:                cfg,
-			expectedVk:         expectedVk,
 			blockOrm:           orm.NewL2Block(db),
 			chunkOrm:           orm.NewChunk(db),
 			batchOrm:           orm.NewBatch(db),
@@ -82,37 +81,10 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpBundleTask *orm.Bundle
-
-		if taskCtx.hasAssignedTask != nil {
-			if taskCtx.hasAssignedTask.TaskType != int16(message.ProofTypeBundle) {
-				return nil, fmt.Errorf("prover with publicKey %s is already assigned a task. ProverName: %s, ProverVersion: %s", taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
-			}
-
-			tmpBundleTask, getTaskError = bp.bundleOrm.GetBundleByHash(ctx.Copy(), taskCtx.hasAssignedTask.TaskID)
-			if getTaskError != nil {
-				log.Error("failed to get bundle has assigned to prover", "taskID", taskCtx.hasAssignedTask.TaskID, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			} else if tmpBundleTask == nil {
-				// if the assigned chunk dropped, there would be too much issue to assign another
-				return nil, fmt.Errorf("prover with publicKey %s is already assigned a dropped bundle. ProverName: %s, ProverVersion: %s",
-					taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
-			}
-		} else if getTaskParameter.TaskID != "" {
-			tmpBundleTask, getTaskError = bp.bundleOrm.GetBundleByHash(ctx.Copy(), getTaskParameter.TaskID)
-			if getTaskError != nil {
-				log.Error("failed to get expected bundle", "taskID", getTaskParameter.TaskID, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			} else if tmpBundleTask == nil {
-				return nil, fmt.Errorf("Expected task (%s) is already dropped", getTaskParameter.TaskID)
-			}
-		}
-
-		if tmpBundleTask == nil {
-			tmpBundleTask, getTaskError = bp.bundleOrm.GetAssignedBundle(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
-			if getTaskError != nil {
-				log.Error("failed to get assigned bundle proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			}
+		tmpBundleTask, getTaskError = bp.bundleOrm.GetAssignedBundle(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
+		if getTaskError != nil {
+			log.Error("failed to get assigned bundle proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
+			return nil, ErrCoordinatorInternalFailure
 		}
 
 		// Why here need get again? In order to support a task can assign to multiple prover, need also assign `ProvingTaskAssigned`
@@ -140,33 +112,31 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 			return nil, nil
 		}
 
-		// we are simply pick the chunk which has been assigned, so don't bother to update attempts or check failed before
-		if taskCtx.hasAssignedTask == nil {
-			// Don't dispatch the same failing job to the same prover
-			proverTasks, getTaskError := bp.proverTaskOrm.GetFailedProverTasksByHash(ctx.Copy(), message.ProofTypeBundle, tmpBundleTask.Hash, 2)
-			if getTaskError != nil {
-				log.Error("failed to get prover tasks", "proof type", message.ProofTypeBundle.String(), "task ID", tmpBundleTask.Hash, "error", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			}
-			for i := 0; i < len(proverTasks); i++ {
-				if proverTasks[i].ProverPublicKey == taskCtx.PublicKey ||
-					taskCtx.ProverProviderType == uint8(coordinatorType.ProverProviderTypeExternal) && cutils.IsExternalProverNameMatch(proverTasks[i].ProverName, taskCtx.ProverName) {
-					log.Debug("get empty bundle, the prover already failed this task", "height", getTaskParameter.ProverHeight, "task ID", tmpBundleTask.Hash, "prover name", taskCtx.ProverName, "prover public key", taskCtx.PublicKey)
-					return nil, nil
-				}
-			}
-
-			rowsAffected, updateAttemptsErr := bp.bundleOrm.UpdateBundleAttempts(ctx.Copy(), tmpBundleTask.Hash, tmpBundleTask.ActiveAttempts, tmpBundleTask.TotalAttempts)
-			if updateAttemptsErr != nil {
-				log.Error("failed to update bundle attempts", "height", getTaskParameter.ProverHeight, "err", updateAttemptsErr)
-				return nil, ErrCoordinatorInternalFailure
-			}
-
-			if rowsAffected == 0 {
-				time.Sleep(100 * time.Millisecond)
-				continue
+		// Don't dispatch the same failing job to the same prover
+		proverTasks, getTaskError := bp.proverTaskOrm.GetFailedProverTasksByHash(ctx.Copy(), message.ProofTypeBundle, tmpBundleTask.Hash, 2)
+		if getTaskError != nil {
+			log.Error("failed to get prover tasks", "proof type", message.ProofTypeBundle.String(), "task ID", tmpBundleTask.Hash, "error", getTaskError)
+			return nil, ErrCoordinatorInternalFailure
+		}
+		for i := 0; i < len(proverTasks); i++ {
+			if proverTasks[i].ProverPublicKey == taskCtx.PublicKey ||
+				taskCtx.ProverProviderType == uint8(coordinatorType.ProverProviderTypeExternal) && cutils.IsExternalProverNameMatch(proverTasks[i].ProverName, taskCtx.ProverName) {
+				log.Debug("get empty bundle, the prover already failed this task", "height", getTaskParameter.ProverHeight, "task ID", tmpBundleTask.Hash, "prover name", taskCtx.ProverName, "prover public key", taskCtx.PublicKey)
+				return nil, nil
 			}
 		}
+
+		rowsAffected, updateAttemptsErr := bp.bundleOrm.UpdateBundleAttempts(ctx.Copy(), tmpBundleTask.Hash, tmpBundleTask.ActiveAttempts, tmpBundleTask.TotalAttempts)
+		if updateAttemptsErr != nil {
+			log.Error("failed to update bundle attempts", "height", getTaskParameter.ProverHeight, "err", updateAttemptsErr)
+			return nil, ErrCoordinatorInternalFailure
+		}
+
+		if rowsAffected == 0 {
+			time.Sleep(100 * time.Millisecond)
+			continue
+		}
+
 		bundleTask = tmpBundleTask
 		break
 	}
@@ -177,52 +147,31 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 	}
 
 	log.Info("start bundle proof generation session", "task index", bundleTask.Index, "public key", taskCtx.PublicKey, "prover name", taskCtx.ProverName)
-	var proverTask *orm.ProverTask
-	if taskCtx.hasAssignedTask == nil {
-		proverTask = &orm.ProverTask{
-			TaskID:          bundleTask.Hash,
-			ProverPublicKey: taskCtx.PublicKey,
-			TaskType:        int16(message.ProofTypeBundle),
-			ProverName:      taskCtx.ProverName,
-			ProverVersion:   taskCtx.ProverVersion,
-			ProvingStatus:   int16(types.ProverAssigned),
-			FailureType:     int16(types.ProverTaskFailureTypeUndefined),
-			// here why need use UTC time. see scroll/common/database/db.go
-			AssignedAt: utils.NowUTC(),
-		}
-	} else {
-		proverTask = taskCtx.hasAssignedTask
+	proverTask := orm.ProverTask{
+		TaskID:          bundleTask.Hash,
+		ProverPublicKey: taskCtx.PublicKey,
+		TaskType:        int16(message.ProofTypeBundle),
+		ProverName:      taskCtx.ProverName,
+		ProverVersion:   taskCtx.ProverVersion,
+		ProvingStatus:   int16(types.ProverAssigned),
+		FailureType:     int16(types.ProverTaskFailureTypeUndefined),
+		// here why need use UTC time. see scroll/common/database/db.go
+		AssignedAt: utils.NowUTC(),
 	}
 
-	taskMsg, err := bp.formatProverTask(ctx.Copy(), proverTask, hardForkName)
+	// Store session info.
+	if err = bp.proverTaskOrm.InsertProverTask(ctx.Copy(), &proverTask); err != nil {
+		bp.recoverActiveAttempts(ctx, bundleTask)
+		log.Error("insert bundle prover task info fail", "task_id", bundleTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
+		return nil, ErrCoordinatorInternalFailure
+	}
+
+	taskMsg, err := bp.formatProverTask(ctx.Copy(), &proverTask, hardForkName)
 	if err != nil {
 		bp.recoverActiveAttempts(ctx, bundleTask)
 		log.Error("format bundle prover task failure", "task_id", bundleTask.Hash, "err", err)
 		return nil, ErrCoordinatorInternalFailure
 	}
-	if getTaskParameter.Universal {
-		var metadata []byte
-		taskMsg, metadata, err = bp.applyUniversal(taskMsg)
-		if err != nil {
-			bp.recoverActiveAttempts(ctx, bundleTask)
-			log.Error("Generate universal prover task failure", "task_id", bundleTask.Hash, "type", "bundle", "err", err)
-			return nil, ErrCoordinatorInternalFailure
-		}
-		// bundle proof require snark
-		taskMsg.UseSnark = true
-		proverTask.Metadata = metadata
-	}
-
-	// Store session info.
-	if taskCtx.hasAssignedTask == nil {
-		if err = bp.proverTaskOrm.InsertProverTask(ctx.Copy(), proverTask); err != nil {
-			bp.recoverActiveAttempts(ctx, bundleTask)
-			log.Error("insert bundle prover task info fail", "task_id", bundleTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
-			return nil, ErrCoordinatorInternalFailure
-		}
-	}
-	// notice uuid is set as a side effect of InsertProverTask
-	taskMsg.UUID = proverTask.UUID.String()
 
 	bp.bundleTaskGetTaskTotal.WithLabelValues(hardForkName).Inc()
 	bp.bundleTaskGetTaskProver.With(prometheus.Labels{
@@ -246,39 +195,42 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 		return nil, fmt.Errorf("failed to get batch proofs for bundle task id:%s, no batch found", task.TaskID)
 	}
 
-	var prevStateRoot common.Hash
-	// this would be common in test cases: the first batch has empty parent
-	if batches[0].Index > 1 {
-		parentBatch, err := bp.batchOrm.GetBatchByHash(ctx, batches[0].ParentBatchHash)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get parent batch for batch task id:%s err:%w", task.TaskID, err)
-		}
-		prevStateRoot = common.HexToHash(parentBatch.StateRoot)
+	parentBatch, err := bp.batchOrm.GetBatchByHash(ctx, batches[0].ParentBatchHash)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get parent batch for batch task id:%s err:%w", task.TaskID, err)
 	}
 
-	var batchProofs []*message.OpenVMBatchProof
+	var batchProofs []message.BatchProof
 	for _, batch := range batches {
-		var proof message.OpenVMBatchProof
+		proof := message.NewBatchProof(hardForkName)
 		if encodeErr := json.Unmarshal(batch.Proof, &proof); encodeErr != nil {
 			return nil, fmt.Errorf("failed to unmarshal proof: %w, bundle hash: %v, batch hash: %v", encodeErr, task.TaskID, batch.Hash)
 		}
-		batchProofs = append(batchProofs, &proof)
+		batchProofs = append(batchProofs, proof)
 	}
 
 	taskDetail := message.BundleTaskDetail{
 		BatchProofs: batchProofs,
-		ForkName:    hardForkName,
+	}
+
+	if hardForkName == message.EuclidV2Fork {
+		taskDetail.ForkName = message.EuclidV2ForkNameForProver
+	} else if hardForkName == message.EuclidFork {
+		taskDetail.ForkName = message.EuclidForkNameForProver
 	}
 
 	taskDetail.BundleInfo = &message.OpenVMBundleInfo{
 		ChainID:       bp.cfg.L2.ChainID,
-		PrevStateRoot: prevStateRoot,
+		PrevStateRoot: common.HexToHash(parentBatch.StateRoot),
 		PostStateRoot: common.HexToHash(batches[len(batches)-1].StateRoot),
 		WithdrawRoot:  common.HexToHash(batches[len(batches)-1].WithdrawRoot),
 		NumBatches:    uint32(len(batches)),
 		PrevBatchHash: common.HexToHash(batches[0].ParentBatchHash),
 		BatchHash:     common.HexToHash(batches[len(batches)-1].Hash),
-		MsgQueueHash:  common.HexToHash(batches[len(batches)-1].PostL1MessageQueueHash),
+	}
+
+	if hardForkName == message.EuclidV2Fork {
+		taskDetail.BundleInfo.MsgQueueHash = common.HexToHash(batches[len(batches)-1].PostL1MessageQueueHash)
 	}
 
 	batchProofsBytes, err := json.Marshal(taskDetail)
@@ -287,6 +239,7 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 	}
 
 	taskMsg := &coordinatorType.GetTaskSchema{
+		UUID:         task.UUID.String(),
 		TaskID:       task.TaskID,
 		TaskType:     int(message.ProofTypeBundle),
 		TaskData:     string(batchProofsBytes),

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -33,13 +33,12 @@ type ChunkProverTask struct {
 }
 
 // NewChunkProverTask new a chunk prover task
-func NewChunkProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, expectedVk map[string][]byte, reg prometheus.Registerer) *ChunkProverTask {
+func NewChunkProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *ChunkProverTask {
 	cp := &ChunkProverTask{
 		BaseProverTask: BaseProverTask{
 			db:                 db,
 			cfg:                cfg,
 			chainCfg:           chainCfg,
-			expectedVk:         expectedVk,
 			chunkOrm:           orm.NewChunk(db),
 			blockOrm:           orm.NewL2Block(db),
 			proverTaskOrm:      orm.NewProverTask(db),
@@ -80,39 +79,12 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpChunkTask *orm.Chunk
-
-		if taskCtx.hasAssignedTask != nil {
-			if taskCtx.hasAssignedTask.TaskType != int16(message.ProofTypeChunk) {
-				return nil, fmt.Errorf("prover with publicKey %s is already assigned a task. ProverName: %s, ProverVersion: %s", taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
-			}
-
-			log.Debug("retrieved assigned task chunk", "taskID", taskCtx.hasAssignedTask.TaskID, "prover", taskCtx.ProverName)
-			tmpChunkTask, getTaskError = cp.chunkOrm.GetChunkByHash(ctx.Copy(), taskCtx.hasAssignedTask.TaskID)
-			if getTaskError != nil {
-				log.Error("failed to get chunk has assigned to prover", "taskID", taskCtx.hasAssignedTask.TaskID, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			} else if tmpChunkTask == nil {
-				// if the assigned chunk dropped, there would be too much issue to assign another
-				return nil, fmt.Errorf("prover with publicKey %s is already assigned a dropped chunk. ProverName: %s, ProverVersion: %s",
-					taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
-			}
-		} else if getTaskParameter.TaskID != "" {
-			tmpChunkTask, getTaskError = cp.chunkOrm.GetChunkByHash(ctx.Copy(), getTaskParameter.TaskID)
-			if getTaskError != nil {
-				log.Error("failed to get expected chunk", "taskID", getTaskParameter.TaskID, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			} else if tmpChunkTask == nil {
-				return nil, fmt.Errorf("Expected task (%s) is already dropped", getTaskParameter.TaskID)
-			}
+		tmpChunkTask, getTaskError = cp.chunkOrm.GetAssignedChunk(ctx.Copy(), maxActiveAttempts, maxTotalAttempts, getTaskParameter.ProverHeight)
+		if getTaskError != nil {
+			log.Error("failed to get assigned chunk proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
+			return nil, ErrCoordinatorInternalFailure
 		}
 
-		if tmpChunkTask == nil {
-			tmpChunkTask, getTaskError = cp.chunkOrm.GetAssignedChunk(ctx.Copy(), maxActiveAttempts, maxTotalAttempts, getTaskParameter.ProverHeight)
-			if getTaskError != nil {
-				log.Error("failed to get assigned chunk proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			}
-		}
 		// Why here need get again? In order to support a task can assign to multiple prover, need also assign `ProvingTaskAssigned`
 		// chunk to prover. But use `proving_status in (1, 2)` will not use the postgres index. So need split the sql.
 		if tmpChunkTask == nil {
@@ -138,33 +110,31 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 			return nil, nil
 		}
 
-		// we are simply pick the chunk which has been assigned, so don't bother to update attempts or check failed before
-		if taskCtx.hasAssignedTask == nil {
-			// Don't dispatch the same failing job to the same prover
-			proverTasks, getFailedTaskError := cp.proverTaskOrm.GetFailedProverTasksByHash(ctx.Copy(), message.ProofTypeChunk, tmpChunkTask.Hash, 2)
-			if getFailedTaskError != nil {
-				log.Error("failed to get prover tasks", "proof type", message.ProofTypeChunk.String(), "task ID", tmpChunkTask.Hash, "error", getFailedTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			}
-			for i := 0; i < len(proverTasks); i++ {
-				if proverTasks[i].ProverPublicKey == taskCtx.PublicKey ||
-					taskCtx.ProverProviderType == uint8(coordinatorType.ProverProviderTypeExternal) && cutils.IsExternalProverNameMatch(proverTasks[i].ProverName, taskCtx.ProverName) {
-					log.Debug("get empty chunk, the prover already failed this task", "height", getTaskParameter.ProverHeight, "task ID", tmpChunkTask.Hash, "prover name", taskCtx.ProverName, "prover public key", taskCtx.PublicKey)
-					return nil, nil
-				}
-			}
-
-			rowsAffected, updateAttemptsErr := cp.chunkOrm.UpdateChunkAttempts(ctx.Copy(), tmpChunkTask.Index, tmpChunkTask.ActiveAttempts, tmpChunkTask.TotalAttempts)
-			if updateAttemptsErr != nil {
-				log.Error("failed to update chunk attempts", "height", getTaskParameter.ProverHeight, "err", updateAttemptsErr)
-				return nil, ErrCoordinatorInternalFailure
-			}
-
-			if rowsAffected == 0 {
-				time.Sleep(100 * time.Millisecond)
-				continue
+		// Don't dispatch the same failing job to the same prover
+		proverTasks, getFailedTaskError := cp.proverTaskOrm.GetFailedProverTasksByHash(ctx.Copy(), message.ProofTypeChunk, tmpChunkTask.Hash, 2)
+		if getFailedTaskError != nil {
+			log.Error("failed to get prover tasks", "proof type", message.ProofTypeChunk.String(), "task ID", tmpChunkTask.Hash, "error", getFailedTaskError)
+			return nil, ErrCoordinatorInternalFailure
+		}
+		for i := 0; i < len(proverTasks); i++ {
+			if proverTasks[i].ProverPublicKey == taskCtx.PublicKey ||
+				taskCtx.ProverProviderType == uint8(coordinatorType.ProverProviderTypeExternal) && cutils.IsExternalProverNameMatch(proverTasks[i].ProverName, taskCtx.ProverName) {
+				log.Debug("get empty chunk, the prover already failed this task", "height", getTaskParameter.ProverHeight, "task ID", tmpChunkTask.Hash, "prover name", taskCtx.ProverName, "prover public key", taskCtx.PublicKey)
+				return nil, nil
 			}
 		}
+
+		rowsAffected, updateAttemptsErr := cp.chunkOrm.UpdateChunkAttempts(ctx.Copy(), tmpChunkTask.Index, tmpChunkTask.ActiveAttempts, tmpChunkTask.TotalAttempts)
+		if updateAttemptsErr != nil {
+			log.Error("failed to update chunk attempts", "height", getTaskParameter.ProverHeight, "err", updateAttemptsErr)
+			return nil, ErrCoordinatorInternalFailure
+		}
+
+		if rowsAffected == 0 {
+			time.Sleep(100 * time.Millisecond)
+			continue
+		}
+
 		chunkTask = tmpChunkTask
 		break
 	}
@@ -175,51 +145,31 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	}
 
 	log.Info("start chunk generation session", "task_id", chunkTask.Hash, "public key", taskCtx.PublicKey, "prover name", taskCtx.ProverName)
-	var proverTask *orm.ProverTask
-	if taskCtx.hasAssignedTask == nil {
-		proverTask = &orm.ProverTask{
-			TaskID:          chunkTask.Hash,
-			ProverPublicKey: taskCtx.PublicKey,
-			TaskType:        int16(message.ProofTypeChunk),
-			ProverName:      taskCtx.ProverName,
-			ProverVersion:   taskCtx.ProverVersion,
-			ProvingStatus:   int16(types.ProverAssigned),
-			FailureType:     int16(types.ProverTaskFailureTypeUndefined),
-			// here why need use UTC time. see scroll/common/database/db.go
-			AssignedAt: utils.NowUTC(),
-		}
-	} else {
-		proverTask = taskCtx.hasAssignedTask
+	proverTask := orm.ProverTask{
+		TaskID:          chunkTask.Hash,
+		ProverPublicKey: taskCtx.PublicKey,
+		TaskType:        int16(message.ProofTypeChunk),
+		ProverName:      taskCtx.ProverName,
+		ProverVersion:   taskCtx.ProverVersion,
+		ProvingStatus:   int16(types.ProverAssigned),
+		FailureType:     int16(types.ProverTaskFailureTypeUndefined),
+		// here why need use UTC time. see scroll/common/database/db.go
+		AssignedAt: utils.NowUTC(),
 	}
 
-	taskMsg, err := cp.formatProverTask(ctx.Copy(), proverTask, chunkTask, hardForkName)
+	if err = cp.proverTaskOrm.InsertProverTask(ctx.Copy(), &proverTask); err != nil {
+		cp.recoverActiveAttempts(ctx, chunkTask)
+		log.Error("insert chunk prover task fail", "task_id", chunkTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
+		return nil, ErrCoordinatorInternalFailure
+	}
+
+	taskMsg, err := cp.formatProverTask(ctx.Copy(), &proverTask, chunkTask, hardForkName)
 	if err != nil {
 		cp.recoverActiveAttempts(ctx, chunkTask)
 		log.Error("format prover task failure", "task_id", chunkTask.Hash, "err", err)
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	if getTaskParameter.Universal {
-		var metadata []byte
-		taskMsg, metadata, err = cp.applyUniversal(taskMsg)
-		if err != nil {
-			cp.recoverActiveAttempts(ctx, chunkTask)
-			log.Error("Generate universal prover task failure", "task_id", chunkTask.Hash, "type", "chunk", "err", err)
-			return nil, ErrCoordinatorInternalFailure
-		}
-		proverTask.Metadata = metadata
-	}
-
-	if taskCtx.hasAssignedTask == nil {
-		if err = cp.proverTaskOrm.InsertProverTask(ctx.Copy(), proverTask); err != nil {
-			cp.recoverActiveAttempts(ctx, chunkTask)
-			log.Error("insert chunk prover task fail", "task_id", chunkTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
-			return nil, ErrCoordinatorInternalFailure
-		}
-	}
-	// notice uuid is set as a side effect of InsertProverTask
-	taskMsg.UUID = proverTask.UUID.String()
-
 	cp.chunkTaskGetTaskTotal.WithLabelValues(hardForkName).Inc()
 	cp.chunkTaskGetTaskProver.With(prometheus.Labels{
 		coordinatorType.LabelProverName:      proverTask.ProverName,
@@ -234,14 +184,19 @@ func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 	// Get block hashes.
 	blockHashes, dbErr := cp.blockOrm.GetL2BlockHashesByChunkHash(ctx, task.TaskID)
 	if dbErr != nil || len(blockHashes) == 0 {
-		return nil, fmt.Errorf("failed to fetch block hashes of a chunk, chunk hash:%s err:%v", task.TaskID, dbErr)
+		return nil, fmt.Errorf("failed to fetch block hashes of a chunk, chunk hash:%s err:%w", task.TaskID, dbErr)
 	}
 
 	var taskDetailBytes []byte
 	taskDetail := message.ChunkTaskDetail{
 		BlockHashes:      blockHashes,
 		PrevMsgQueueHash: common.HexToHash(chunk.PrevL1MessageQueueHash),
-		ForkName:         hardForkName,
+	}
+
+	if hardForkName == message.EuclidV2Fork {
+		taskDetail.ForkName = message.EuclidV2ForkNameForProver
+	} else if hardForkName == message.EuclidFork {
+		taskDetail.ForkName = message.EuclidForkNameForProver
 	}
 
 	var err error
@@ -251,6 +206,7 @@ func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 	}
 
 	proverTaskSchema := &coordinatorType.GetTaskSchema{
+		UUID:         task.UUID.String(),
 		TaskID:       task.TaskID,
 		TaskType:     int(message.ProofTypeChunk),
 		TaskData:     string(taskDetailBytes),

coordinator/internal/logic/provertask/prover_task.go

@@ -16,7 +16,6 @@ import (
 	"scroll-tech/common/types/message"
 
 	"scroll-tech/coordinator/internal/config"
-	"scroll-tech/coordinator/internal/logic/libzkp"
 	"scroll-tech/coordinator/internal/orm"
 	coordinatorType "scroll-tech/coordinator/internal/types"
 )
@@ -38,10 +37,9 @@ type ProverTask interface {
 
 // BaseProverTask a base prover task which contain series functions
 type BaseProverTask struct {
-	cfg        *config.Config
-	chainCfg   *params.ChainConfig
-	db         *gorm.DB
-	expectedVk map[string][]byte
+	cfg      *config.Config
+	chainCfg *params.ChainConfig
+	db       *gorm.DB
 
 	batchOrm           *orm.Batch
 	chunkOrm           *orm.Chunk
@@ -58,11 +56,10 @@ type proverTaskContext struct {
 	ProverProviderType uint8
 	HardForkNames      map[string]struct{}
 
-	taskType        message.ProofType
-	chunkTask       *orm.Chunk
-	batchTask       *orm.Batch
-	bundleTask      *orm.Bundle
-	hasAssignedTask *orm.ProverTask
+	taskType   message.ProofType
+	chunkTask  *orm.Chunk
+	batchTask  *orm.Batch
+	bundleTask *orm.Bundle
 }
 
 // hardForkName get the chunk/batch/bundle hard fork name
@@ -124,6 +121,11 @@ func (b *BaseProverTask) hardForkSanityCheck(ctx *gin.Context, taskCtx *proverTa
 		return "", getHardForkErr
 	}
 
+	// for backward compatibility, darwin chunk prover can still prove darwinV2 chunk tasks
+	if taskCtx.taskType == message.ProofTypeChunk && hardForkName == "darwinV2" && strings.HasPrefix(taskCtx.ProverVersion, "v4.4.56") {
+		return hardForkName, nil
+	}
+
 	if _, ok := taskCtx.HardForkNames[hardForkName]; !ok {
 		return "", fmt.Errorf("to be assigned prover task's hard-fork name is not the same as prover, proverName: %s, proverVersion: %s, proverSupportHardForkNames: %s, taskHardForkName: %v", taskCtx.ProverName, taskCtx.ProverVersion, taskCtx.HardForkNames, hardForkName)
 	}
@@ -177,30 +179,17 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context) (*proverTaskContext, e
 		return nil, fmt.Errorf("public key %s is blocked from fetching tasks. ProverName: %s, ProverVersion: %s", publicKey, proverName, proverVersion)
 	}
 
-	assigned, err := b.proverTaskOrm.IsProverAssigned(ctx.Copy(), publicKey.(string))
+	isAssigned, err := b.proverTaskOrm.IsProverAssigned(ctx.Copy(), publicKey.(string))
 	if err != nil {
 		return nil, fmt.Errorf("failed to check if prover %s is assigned a task, err: %w", publicKey.(string), err)
 	}
 
-	ptc.hasAssignedTask = assigned
+	if isAssigned {
+		return nil, fmt.Errorf("prover with publicKey %s is already assigned a task. ProverName: %s, ProverVersion: %s", publicKey, proverName, proverVersion)
+	}
 	return &ptc, nil
 }
 
-func (b *BaseProverTask) applyUniversal(schema *coordinatorType.GetTaskSchema) (*coordinatorType.GetTaskSchema, []byte, error) {
-	expectedVk, ok := b.expectedVk[schema.HardForkName]
-	if !ok {
-		return nil, nil, fmt.Errorf("no expectedVk found from hardfork %s", schema.HardForkName)
-	}
-
-	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")
-	}
-
-	schema.TaskData = uTaskData
-	return schema, []byte(metadata), 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

@@ -19,8 +19,6 @@ import (
 	"scroll-tech/common/types/message"
 
 	"scroll-tech/coordinator/internal/config"
-	"scroll-tech/coordinator/internal/logic/libzkp"
-	"scroll-tech/coordinator/internal/logic/provertask"
 	"scroll-tech/coordinator/internal/logic/verifier"
 	"scroll-tech/coordinator/internal/orm"
 	coordinatorType "scroll-tech/coordinator/internal/types"
@@ -71,18 +69,10 @@ type ProofReceiverLogic struct {
 	validateFailureProverTaskStatusNotOk  prometheus.Counter
 	validateFailureProverTaskTimeout      prometheus.Counter
 	validateFailureProverTaskHaveVerifier prometheus.Counter
-	proverSpeed                           *prometheus.GaugeVec
-	provingTime                           prometheus.Gauge
-	evmCyclePerGas                        prometheus.Gauge
-
-	ChunkTask  provertask.ProverTask
-	BundleTask provertask.ProverTask
-	BatchTask  provertask.ProverTask
 }
 
 // NewSubmitProofReceiverLogic create a proof receiver logic
 func NewSubmitProofReceiverLogic(cfg *config.ProverManager, chainCfg *params.ChainConfig, db *gorm.DB, vf *verifier.Verifier, reg prometheus.Registerer) *ProofReceiverLogic {
-
 	return &ProofReceiverLogic{
 		chunkOrm:      orm.NewChunk(db),
 		batchOrm:      orm.NewBatch(db),
@@ -137,18 +127,6 @@ func NewSubmitProofReceiverLogic(cfg *config.ProverManager, chainCfg *params.Cha
 			Name: "coordinator_validate_failure_submit_have_been_verifier",
 			Help: "Total number of submit proof validate failure proof have been verifier.",
 		}),
-		evmCyclePerGas: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-			Name: "evm_circuit_cycle_per_gas",
-			Help: "VM cycles cost for a gas unit cost in evm execution",
-		}),
-		provingTime: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-			Name: "chunk_proving_time",
-			Help: "Wall clock time for chunk proving in second",
-		}),
-		proverSpeed: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
-			Name: "prover_speed",
-			Help: "Cycle against running time of prover (in mhz)",
-		}, []string{"type", "phase"}),
 	}
 }
 
@@ -190,66 +168,22 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 	if getHardForkErr != nil {
 		return ErrGetHardForkNameFailed
 	}
-	if proofParameter.Universal {
-		if len(proverTask.Metadata) == 0 {
-			return errors.New("can not re-wrapping proof: no metadata has been recorded in advance")
-		}
-		var expected_vk []byte
-		switch message.ProofType(proofParameter.TaskType) {
-		case message.ProofTypeChunk:
-			expected_vk = m.verifier.ChunkVk[hardForkName]
-		case message.ProofTypeBatch:
-			expected_vk = m.verifier.BatchVk[hardForkName]
-		case message.ProofTypeBundle:
-			expected_vk = m.verifier.BundleVk[hardForkName]
-		}
-		if len(expected_vk) == 0 {
-			return errors.New("no vk specified match current hard fork, check your config")
-		}
-
-		proofParameter.Proof = libzkp.GenerateWrappedProof(proofParameter.Proof, string(proverTask.Metadata), expected_vk)
-		if proofParameter.Proof == "" {
-			return errors.New("can not re-wrapping proof, see coordinator log for reason")
-		}
-	}
 
 	switch message.ProofType(proofParameter.TaskType) {
 	case message.ProofTypeChunk:
-		chunkProof := &message.OpenVMChunkProof{}
+		chunkProof := message.NewChunkProof(hardForkName)
 		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &chunkProof); unmarshalErr != nil {
 			return unmarshalErr
 		}
 		success, verifyErr = m.verifier.VerifyChunkProof(chunkProof, hardForkName)
-		if stat := chunkProof.VmProof.Stat; stat != nil {
-			if g, _ := m.proverSpeed.GetMetricWithLabelValues("chunk", "exec"); g != nil && stat.ExecutionTimeMills > 0 {
-				g.Set(float64(stat.TotalCycle) / float64(stat.ExecutionTimeMills*1000))
-			}
-			if g, _ := m.proverSpeed.GetMetricWithLabelValues("chunk", "proving"); g != nil && stat.ProvingTimeMills > 0 {
-				g.Set(float64(stat.TotalCycle) / float64(stat.ProvingTimeMills*1000))
-			}
-			if chunkProof.MetaData.TotalGasUsed > 0 {
-				cycle_per_gas := float64(stat.TotalCycle) / float64(chunkProof.MetaData.TotalGasUsed)
-				m.evmCyclePerGas.Set(cycle_per_gas)
-			}
-			m.provingTime.Set(float64(stat.ProvingTimeMills) / 1000)
-		}
-
 	case message.ProofTypeBatch:
-		batchProof := &message.OpenVMBatchProof{}
+		batchProof := message.NewBatchProof(hardForkName)
 		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &batchProof); unmarshalErr != nil {
 			return unmarshalErr
 		}
 		success, verifyErr = m.verifier.VerifyBatchProof(batchProof, hardForkName)
-		if stat := batchProof.VmProof.Stat; stat != nil {
-			if g, _ := m.proverSpeed.GetMetricWithLabelValues("batch", "exec"); g != nil && stat.ExecutionTimeMills > 0 {
-				g.Set(float64(stat.TotalCycle) / float64(stat.ExecutionTimeMills*1000))
-			}
-			if g, _ := m.proverSpeed.GetMetricWithLabelValues("batch", "proving"); g != nil && stat.ProvingTimeMills > 0 {
-				g.Set(float64(stat.TotalCycle) / float64(stat.ProvingTimeMills*1000))
-			}
-		}
 	case message.ProofTypeBundle:
-		bundleProof := &message.OpenVMBundleProof{}
+		bundleProof := message.NewBundleProof(hardForkName)
 		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &bundleProof); unmarshalErr != nil {
 			return unmarshalErr
 		}

coordinator/internal/logic/verifier/mock.go

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

coordinator/internal/logic/verifier/types.go

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

coordinator/internal/logic/verifier/verifier.go

@@ -2,55 +2,59 @@
 
 package verifier
 
+/*
+#cgo LDFLAGS: -lzkp -lm -ldl -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
+#cgo gpu LDFLAGS: -lzkp -lm -ldl -lgmp -lstdc++ -lprocps -L/usr/local/cuda/lib64/ -lcudart -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
+#include <stdlib.h>
+#include "./lib/libzkp.h"
+*/
+import "C" //nolint:typecheck
+
 import (
 	"encoding/base64"
-	"encoding/hex"
 	"encoding/json"
-	"fmt"
 	"io"
 	"os"
 	"path"
-	"path/filepath"
-	"strings"
+	"unsafe"
 
 	"github.com/scroll-tech/go-ethereum/log"
 
 	"scroll-tech/common/types/message"
 
 	"scroll-tech/coordinator/internal/config"
-	"scroll-tech/coordinator/internal/logic/libzkp"
 )
 
-// This struct maps to `CircuitConfig` in libzkp/src/verifier.rs
+// This struct maps to `CircuitConfig` in common/libzkp/impl/src/verifier.rs
 // Define a brand new struct here is to eliminate side effects in case fields
 // in `*config.CircuitConfig` being changed
 type rustCircuitConfig struct {
 	ForkName   string `json:"fork_name"`
+	ParamsPath string `json:"params_path"`
 	AssetsPath string `json:"assets_path"`
 }
 
-func newRustCircuitConfig(cfg config.AssetConfig) *rustCircuitConfig {
+func newRustCircuitConfig(cfg *config.CircuitConfig) *rustCircuitConfig {
 	return &rustCircuitConfig{
 		ForkName:   cfg.ForkName,
+		ParamsPath: cfg.ParamsPath,
 		AssetsPath: cfg.AssetsPath,
 	}
 }
 
-// This struct maps to `VerifierConfig` in coordinator/internal/logic/libzkp/src/verifier.rs
+// This struct maps to `VerifierConfig` in common/libzkp/impl/src/verifier.rs
 // Define a brand new struct here is to eliminate side effects in case fields
 // in `*config.VerifierConfig` being changed
 type rustVerifierConfig struct {
-	Circuits []*rustCircuitConfig `json:"circuits"`
+	LowVersionCircuit  *rustCircuitConfig `json:"low_version_circuit"`
+	HighVersionCircuit *rustCircuitConfig `json:"high_version_circuit"`
 }
 
 func newRustVerifierConfig(cfg *config.VerifierConfig) *rustVerifierConfig {
-
-	out := &rustVerifierConfig{}
-
-	for _, cfg := range cfg.Verifiers {
-		out.Circuits = append(out.Circuits, newRustCircuitConfig(cfg))
+	return &rustVerifierConfig{
+		LowVersionCircuit:  newRustCircuitConfig(cfg.LowVersionCircuit),
+		HighVersionCircuit: newRustCircuitConfig(cfg.HighVersionCircuit),
 	}
-	return out
 }
 
 type rustVkDump struct {
@@ -61,104 +65,192 @@ type rustVkDump struct {
 
 // NewVerifier Sets up a rust ffi to call verify.
 func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
+	if cfg.MockMode {
+		chunkVKMap := map[string]struct{}{"mock_vk": {}}
+		batchVKMap := map[string]struct{}{"mock_vk": {}}
+		bundleVKMap := map[string]struct{}{"mock_vk": {}}
+		openVMVkMap := map[string]struct{}{"mock_vk": {}}
+		return &Verifier{
+			cfg:         cfg,
+			ChunkVKMap:  chunkVKMap,
+			BatchVKMap:  batchVKMap,
+			BundleVkMap: bundleVKMap,
+			OpenVMVkMap: openVMVkMap,
+		}, nil
+	}
 	verifierConfig := newRustVerifierConfig(cfg)
 	configBytes, err := json.Marshal(verifierConfig)
 	if err != nil {
 		return nil, err
 	}
 
-	if cfg.Features != "" {
-		libzkp.SetDynamicFeature(cfg.Features)
-	}
-	libzkp.InitVerifier(string(configBytes))
+	configStr := C.CString(string(configBytes))
+	defer func() {
+		C.free(unsafe.Pointer(configStr))
+	}()
+
+	C.init(configStr)
 
 	v := &Verifier{
 		cfg:         cfg,
+		ChunkVKMap:  make(map[string]struct{}),
+		BatchVKMap:  make(map[string]struct{}),
+		BundleVkMap: make(map[string]struct{}),
 		OpenVMVkMap: make(map[string]struct{}),
-		ChunkVk:     make(map[string][]byte),
-		BatchVk:     make(map[string][]byte),
-		BundleVk:    make(map[string][]byte),
 	}
 
-	for _, cfg := range cfg.Verifiers {
-		if err := v.loadOpenVMVks(cfg); err != nil {
-			return nil, err
-		}
+	if err := v.loadLowVersionVKs(cfg); err != nil {
+		return nil, err
 	}
 
+	if err := v.loadOpenVMVks(message.EuclidFork); err != nil {
+		return nil, err
+	}
+
+	if err := v.loadOpenVMVks(message.EuclidV2Fork); err != nil {
+		return nil, err
+	}
+
+	v.loadDarwinVKs()
+
 	return v, nil
 }
 
-// VerifyBatchProof Verify a ZkProof by marshaling it and sending it to the Verifier.
-func (v *Verifier) VerifyBatchProof(proof *message.OpenVMBatchProof, forkName string) (bool, error) {
+// VerifyBatchProof Verify a ZkProof by marshaling it and sending it to the Halo2 Verifier.
+func (v *Verifier) VerifyBatchProof(proof message.BatchProof, forkName string) (bool, error) {
+	if v.cfg.MockMode {
+		log.Info("Mock mode, batch verifier disabled")
+		if string(proof.Proof()) == InvalidTestProof {
+			return false, nil
+		}
+		return true, nil
+
+	}
 	buf, err := json.Marshal(proof)
 	if err != nil {
 		return false, err
 	}
 
 	log.Info("Start to verify batch proof", "forkName", forkName)
-	return libzkp.VerifyBatchProof(string(buf), forkName), nil
+	proofStr := C.CString(string(buf))
+	forkNameStr := C.CString(forkName)
+	defer func() {
+		C.free(unsafe.Pointer(proofStr))
+		C.free(unsafe.Pointer(forkNameStr))
+	}()
+
+	verified := C.verify_batch_proof(proofStr, forkNameStr)
+	return verified != 0, nil
 }
 
-// VerifyChunkProof Verify a ZkProof by marshaling it and sending it to the Verifier.
-func (v *Verifier) VerifyChunkProof(proof *message.OpenVMChunkProof, forkName string) (bool, error) {
+// VerifyChunkProof Verify a ZkProof by marshaling it and sending it to the Halo2 Verifier.
+func (v *Verifier) VerifyChunkProof(proof message.ChunkProof, forkName string) (bool, error) {
+	if v.cfg.MockMode {
+		log.Info("Mock mode, verifier disabled")
+		if string(proof.Proof()) == InvalidTestProof {
+			return false, nil
+		}
+		return true, nil
+
+	}
 	buf, err := json.Marshal(proof)
 	if err != nil {
 		return false, err
 	}
 
 	log.Info("Start to verify chunk proof", "forkName", forkName)
+	proofStr := C.CString(string(buf))
+	forkNameStr := C.CString(forkName)
+	defer func() {
+		C.free(unsafe.Pointer(proofStr))
+		C.free(unsafe.Pointer(forkNameStr))
+	}()
 
-	return libzkp.VerifyChunkProof(string(buf), forkName), nil
+	verified := C.verify_chunk_proof(proofStr, forkNameStr)
+	return verified != 0, nil
 }
 
 // VerifyBundleProof Verify a ZkProof for a bundle of batches, by marshaling it and verifying it via the EVM verifier.
-func (v *Verifier) VerifyBundleProof(proof *message.OpenVMBundleProof, forkName string) (bool, error) {
+func (v *Verifier) VerifyBundleProof(proof message.BundleProof, forkName string) (bool, error) {
+	if v.cfg.MockMode {
+		log.Info("Mock mode, verifier disabled")
+		if string(proof.Proof()) == InvalidTestProof {
+			return false, nil
+		}
+		return true, nil
+
+	}
 	buf, err := json.Marshal(proof)
 	if err != nil {
 		return false, err
 	}
 
+	proofStr := C.CString(string(buf))
+	forkNameStr := C.CString(forkName)
+	defer func() {
+		C.free(unsafe.Pointer(proofStr))
+		C.free(unsafe.Pointer(forkNameStr))
+	}()
+
 	log.Info("Start to verify bundle proof ...")
-	return libzkp.VerifyBundleProof(string(buf), forkName), nil
+	verified := C.verify_bundle_proof(proofStr, forkNameStr)
+	return verified != 0, nil
 }
 
-/*
-add vk of imcompatilbe circuit app here to avoid we had used them unexpectedly
-25/07/15: 0.5.0rc0 is no longer compatible since a breaking change
-*/
-const blocked_vks = `
-	rSJNNBpsxBdKlstbIIU/aYc7bHau98Qb2yjZMc5PmDhmGOolp5kYRbvF/VcWcO5HN5ujGs6S00W8pZcCoNQRLQ==,
-	2Lo7Cebm6SFtcsYXipkcMxIBmVY7UpoMXik/Msm7t2nyvi9EaNGsSnDnaCurscYEF+IcdjPUtVtY9EcD7IKwWg==,
-	D6YFHwTLZF/U2zpYJPQ3LwJZRm85yA5Vq2iFBqd3Mk4iwOUpS8sbOp3vg2+NDxhhKphgYpuUlykpdsoRhEt+cw==,
-`
-
-// tries to decode s as hex, and if that fails, as base64.
-func decodeVkString(s string) ([]byte, error) {
-	// Try hex decoding first
-	if b, err := hex.DecodeString(s); err == nil {
-		return b, nil
-	}
-	// Fallback to base64 decoding
-	b, err := base64.StdEncoding.DecodeString(s)
+func (v *Verifier) readVK(filePat string) (string, error) {
+	f, err := os.Open(filePat)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
-	if len(b) == 0 {
-		return nil, fmt.Errorf("decode vk string %s fail (empty bytes)", s)
+	byt, err := io.ReadAll(f)
+	if err != nil {
+		return "", err
 	}
-	return b, nil
+	return base64.StdEncoding.EncodeToString(byt), nil
 }
 
-func (v *Verifier) loadOpenVMVks(cfg config.AssetConfig) error {
-
-	vkFileName := cfg.Vkfile
-	if vkFileName == "" {
-		vkFileName = "openVmVk.json"
+// load low version vks, current is darwin
+func (v *Verifier) loadLowVersionVKs(cfg *config.VerifierConfig) error {
+	bundleVK, err := v.readVK(path.Join(cfg.LowVersionCircuit.AssetsPath, "vk_bundle.vkey"))
+	if err != nil {
+		return err
 	}
-	vkFile := path.Join(cfg.AssetsPath, vkFileName)
+	batchVK, err := v.readVK(path.Join(cfg.LowVersionCircuit.AssetsPath, "vk_batch.vkey"))
+	if err != nil {
+		return err
+	}
+	chunkVK, err := v.readVK(path.Join(cfg.LowVersionCircuit.AssetsPath, "vk_chunk.vkey"))
+	if err != nil {
+		return err
+	}
+	v.BundleVkMap[bundleVK] = struct{}{}
+	v.BatchVKMap[batchVK] = struct{}{}
+	v.ChunkVKMap[chunkVK] = struct{}{}
+	return nil
+}
 
-	f, err := os.Open(filepath.Clean(vkFile))
+func (v *Verifier) loadDarwinVKs() {
+	v.BundleVkMap["AAAAGgAAAARX2S0K1wF333B1waOsnG/vcASJmWG9YM6SNWCBy1ywD5dsp1rEy7PSqiIFikkkOPqKokLW2mZSwCbtKdkfLQcvTxARUwHSe4iZe27PRJ5WWaLqtRV1+x6+pSVKtcPtaV4kE7v2YJRf0582hxiAF0IBaOoREdpyNfA2a9cvhWb2TMaPrUYP9EDQ7CUiW1FQzxbjGc95ua2htscnpU7d9S5stHWzKb7okkCG7bTIL9aG6qTQo2YXW7n3H3Ir47oVJB7IKrUzKGvI5Wmanh2zpZOJ9Qm4/wY24cT7cJz+Ux6wAg=="] = struct{}{}
+	v.BatchVKMap["AAAAGgAAAARX2S0K1wF333B1waOsnG/vcASJmWG9YM6SNWCBy1ywD1DEjW4Kell67H07wazT5DdzrSh4+amh+cmosQHp9p9snFypyoBGt3UHtoJGQBZlywZWDS9ht5pnaEoGBdaKcQk+lFb+WxTiId0KOAa0mafTZTQw8yToy57Jple64qzlRu1dux30tZZGuerLN1CKzg5Xl2iOpMK+l87jCINwVp5cUtF/XrvhBbU7onKh3KBiy99iUqVyA3Y6iiIZhGKWBSuSA4bNgDYIoVkqjHpdL35aEShoRO6pNXt7rDzxFoPzH0JuPI54nE4OhVrzZXwtkAEosxVa/fszcE092FH+HhhtxZBYe/KEzwdISU9TOPdId3UF/UMYC0MiYOlqffVTgAg="] = struct{}{}
+	v.ChunkVKMap["AAAAGQAAAATyWEABRbJ6hQQ5/zLX1gTasr7349minA9rSgMS6gDeHwZKqikRiO3md+pXjjxMHnKQtmXYgMXhJSvlmZ+Ws+cheuly2X1RuNQzcZuRImaKPR9LJsVZYsXfJbuqdKX8p0Gj8G83wMJOmTzNVUyUol0w0lTU+CEiTpHOnxBsTF3EWaW3s1u4ycOgWt1c9M6s7WmaBZLYgAWYCunO5CLCLApNGbCASeck/LuSoedEri5u6HccCKU2khG6zl6W07jvYSbDVLJktbjRiHv+/HQix+K14j8boo8Z/unhpwXCsPxkQA=="] = struct{}{}
+}
+
+func (v *Verifier) loadOpenVMVks(forkName string) error {
+	tempFile := path.Join(os.TempDir(), "openVmVk.json")
+	defer func() {
+		if err := os.Remove(tempFile); err != nil {
+			log.Error("failed to remove temp file", "err", err)
+		}
+	}()
+
+	forkNameCStr := C.CString(forkName)
+	defer C.free(unsafe.Pointer(forkNameCStr))
+	tempFileCStr := C.CString(tempFile)
+	defer C.free(unsafe.Pointer(tempFileCStr))
+
+	C.dump_vk(forkNameCStr, tempFileCStr)
+
+	f, err := os.Open(tempFile)
 	if err != nil {
 		return err
 	}
@@ -171,36 +263,8 @@ func (v *Verifier) loadOpenVMVks(cfg config.AssetConfig) error {
 	if err := json.Unmarshal(byt, &dump); err != nil {
 		return err
 	}
-	if strings.Contains(blocked_vks, dump.Chunk) {
-		return fmt.Errorf("loaded blocked chunk vk %s", dump.Chunk)
-	}
-	if strings.Contains(blocked_vks, dump.Batch) {
-		return fmt.Errorf("loaded blocked batch vk %s", dump.Batch)
-	}
-	if strings.Contains(blocked_vks, dump.Bundle) {
-		return fmt.Errorf("loaded blocked bundle vk %s", dump.Bundle)
-	}
-
 	v.OpenVMVkMap[dump.Chunk] = struct{}{}
 	v.OpenVMVkMap[dump.Batch] = struct{}{}
 	v.OpenVMVkMap[dump.Bundle] = struct{}{}
-	log.Info("Load vks", "from", cfg.AssetsPath, "chunk", dump.Chunk, "batch", dump.Batch, "bundle", dump.Bundle)
-
-	decodedBytes, err := decodeVkString(dump.Chunk)
-	if err != nil {
-		return err
-	}
-	v.ChunkVk[cfg.ForkName] = decodedBytes
-	decodedBytes, err = decodeVkString(dump.Batch)
-	if err != nil {
-		return err
-	}
-	v.BatchVk[cfg.ForkName] = decodedBytes
-	decodedBytes, err = decodeVkString(dump.Bundle)
-	if err != nil {
-		return err
-	}
-	v.BundleVk[cfg.ForkName] = decodedBytes
-
 	return nil
 }

coordinator/internal/logic/verifier/verifier_test.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"scroll-tech/common/types/message"
+	"scroll-tech/common/types"
 
 	"scroll-tech/coordinator/internal/config"
 )
@@ -29,54 +29,62 @@ func TestFFI(t *testing.T) {
 	as := assert.New(t)
 
 	cfg := &config.VerifierConfig{
-		MinProverVersion: "",
-		Verifiers: []config.AssetConfig{{
-			AssetsPath: *assetsPathHi,
-			ForkName:   "euclidV2",
-		}},
+		MockMode: false,
+		LowVersionCircuit: &config.CircuitConfig{
+			ParamsPath:       *paramsPath,
+			AssetsPath:       *assetsPathLo,
+			ForkName:         "darwin",
+			MinProverVersion: "",
+		},
+		HighVersionCircuit: &config.CircuitConfig{
+			ParamsPath:       *paramsPath,
+			AssetsPath:       *assetsPathHi,
+			ForkName:         "darwinV2",
+			MinProverVersion: "",
+		},
 	}
 
 	v, err := NewVerifier(cfg)
 	as.NoError(err)
 
 	chunkProof1 := readChunkProof(*chunkProofPath1, as)
-	chunkOk1, err := v.VerifyChunkProof(chunkProof1, "euclidV2")
+	chunkOk1, err := v.VerifyChunkProof(chunkProof1, "darwinV2")
 	as.NoError(err)
 	as.True(chunkOk1)
 	t.Log("Verified chunk proof 1")
 
 	chunkProof2 := readChunkProof(*chunkProofPath2, as)
-	chunkOk2, err := v.VerifyChunkProof(chunkProof2, "euclidV2")
+	chunkOk2, err := v.VerifyChunkProof(chunkProof2, "darwinV2")
 	as.NoError(err)
 	as.True(chunkOk2)
 	t.Log("Verified chunk proof 2")
 
 	batchProof := readBatchProof(*batchProofPath, as)
-	batchOk, err := v.VerifyBatchProof(batchProof, "euclidV2")
+	batchOk, err := v.VerifyBatchProof(batchProof, "darwinV2")
 	as.NoError(err)
 	as.True(batchOk)
 	t.Log("Verified batch proof")
 }
 
-func readBatchProof(filePat string, as *assert.Assertions) *message.OpenVMBatchProof {
+func readBatchProof(filePat string, as *assert.Assertions) types.BatchProof {
 	f, err := os.Open(filePat)
 	as.NoError(err)
 	byt, err := io.ReadAll(f)
 	as.NoError(err)
 
-	proof := &message.OpenVMBatchProof{}
+	proof := &types.Halo2BatchProof{}
 	as.NoError(json.Unmarshal(byt, proof))
 
 	return proof
 }
 
-func readChunkProof(filePat string, as *assert.Assertions) *message.OpenVMChunkProof {
+func readChunkProof(filePat string, as *assert.Assertions) types.ChunkProof {
 	f, err := os.Open(filePat)
 	as.NoError(err)
 	byt, err := io.ReadAll(f)
 	as.NoError(err)
 
-	proof := &message.OpenVMChunkProof{}
+	proof := &types.Halo2ChunkProof{}
 	as.NoError(json.Unmarshal(byt, proof))
 
 	return proof

coordinator/internal/orm/prover_task.go

@@ -37,7 +37,6 @@ type ProverTask struct {
 	FailureType   int16           `json:"failure_type" gorm:"column:failure_type;default:0"`
 	Reward        decimal.Decimal `json:"reward" gorm:"column:reward;default:0;type:decimal(78)"`
 	Proof         []byte          `json:"proof" gorm:"column:proof;default:NULL"`
-	Metadata      []byte          `json:"metadata" gorm:"column:metadata;default:NULL"`
 	AssignedAt    time.Time       `json:"assigned_at" gorm:"assigned_at"`
 
 	// metadata
@@ -57,17 +56,17 @@ func (*ProverTask) TableName() string {
 }
 
 // IsProverAssigned checks if a prover with the given public key has been assigned a task.
-func (o *ProverTask) IsProverAssigned(ctx context.Context, publicKey string) (*ProverTask, error) {
+func (o *ProverTask) IsProverAssigned(ctx context.Context, publicKey string) (bool, error) {
 	db := o.db.WithContext(ctx)
 	var task ProverTask
 	err := db.Where("prover_public_key = ? AND proving_status = ?", publicKey, types.ProverAssigned).First(&task).Error
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, nil
+			return false, nil
 		}
-		return nil, err
+		return false, err
 	}
-	return &task, nil
+	return true, nil
 }
 
 // GetProverTasks get prover tasks
@@ -269,24 +268,6 @@ func (o *ProverTask) UpdateProverTaskProvingStatusAndFailureType(ctx context.Con
 	return nil
 }
 
-// UpdateProverTaskAssignedTime updates the assigned_at time of a specific ProverTask record.
-func (o *ProverTask) UpdateProverTaskAssignedTime(ctx context.Context, uuid uuid.UUID, t time.Time, dbTX ...*gorm.DB) error {
-	db := o.db
-	if len(dbTX) > 0 && dbTX[0] != nil {
-		db = dbTX[0]
-	}
-	db = db.WithContext(ctx)
-	db = db.Model(&ProverTask{})
-	db = db.Where("uuid = ?", uuid)
-
-	updates := make(map[string]interface{})
-	updates["assigned_at"] = t
-	if err := db.Updates(updates).Error; err != nil {
-		return fmt.Errorf("ProverTask.UpdateProverTaskAssignedTime error: %w, uuid:%s, status: %v", err, uuid, t)
-	}
-	return nil
-}
-
 // UpdateProverTaskFailureType update the prover task failure type
 func (o *ProverTask) UpdateProverTaskFailureType(ctx context.Context, uuid uuid.UUID, failureType types.ProverTaskFailureType, dbTX ...*gorm.DB) error {
 	db := o.db

coordinator/internal/types/auth_test.go

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

coordinator/internal/types/get_task.go

@@ -4,8 +4,6 @@ package types
 type GetTaskParameter struct {
 	ProverHeight uint64 `form:"prover_height" json:"prover_height"`
 	TaskTypes    []int  `form:"task_types" json:"task_types"`
-	TaskID       string `form:"task_id,omitempty" json:"task_id,omitempty"`
-	Universal    bool   `form:"universal,omitempty" json:"universal,omitempty"`
 }
 
 // GetTaskSchema the schema data return to prover for get prover task
@@ -13,7 +11,6 @@ type GetTaskSchema struct {
 	UUID         string `json:"uuid"`
 	TaskID       string `json:"task_id"`
 	TaskType     int    `json:"task_type"`
-	UseSnark     bool   `json:"use_snark,omitempty"`
 	TaskData     string `json:"task_data"`
 	HardForkName string `json:"hard_fork_name"`
 }

coordinator/internal/types/prover.go

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

coordinator/internal/types/submit_proof.go

@@ -7,7 +7,6 @@ type SubmitProofParameter struct {
 	TaskType    int    `form:"task_type" json:"task_type" binding:"required"`
 	Status      int    `form:"status" json:"status"`
 	Proof       string `form:"proof" json:"proof"`
-	Universal   bool   `form:"universal,omitempty" json:"universal,omitempty"`
 	FailureType int    `form:"failure_type" json:"failure_type"`
 	FailureMsg  string `form:"failure_msg" json:"failure_msg"`
 }

coordinator/test/api_test.go

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

coordinator/test/mock_prover.go

@@ -161,7 +161,7 @@ func (r *mockProver) getProverTask(t *testing.T, proofType message.ProofType) (*
 	resp, err := client.R().
 		SetHeader("Content-Type", "application/json").
 		SetHeader("Authorization", fmt.Sprintf("Bearer %s", token)).
-		SetBody(map[string]interface{}{"universal": true, "prover_height": 100, "task_types": []int{int(proofType)}}).
+		SetBody(map[string]interface{}{"prover_height": 100, "task_types": []int{int(proofType)}}).
 		SetResult(&result).
 		Post("http://" + r.coordinatorURL + "/coordinator/v1/get_task")
 	assert.NoError(t, err)
@@ -191,7 +191,7 @@ func (r *mockProver) tryGetProverTask(t *testing.T, proofType message.ProofType)
 	resp, err := client.R().
 		SetHeader("Content-Type", "application/json").
 		SetHeader("Authorization", fmt.Sprintf("Bearer %s", token)).
-		SetBody(map[string]interface{}{"prover_height": 100, "task_type": int(proofType), "universal": true}).
+		SetBody(map[string]interface{}{"prover_height": 100, "task_type": int(proofType)}).
 		SetResult(&result).
 		Post("http://" + r.coordinatorURL + "/coordinator/v1/get_task")
 	assert.NoError(t, err)
@@ -207,33 +207,32 @@ func (r *mockProver) submitProof(t *testing.T, proverTaskSchema *types.GetTaskSc
 	}
 
 	var proof []byte
-	if proofStatus != verifiedFailed {
-		switch message.ProofType(proverTaskSchema.TaskType) {
-		case message.ProofTypeChunk:
-			fallthrough
-		case message.ProofTypeBatch:
-			encodeData, err := json.Marshal(&message.OpenVMProof{})
+	switch proverTaskSchema.TaskType {
+	case int(message.ProofTypeChunk):
+		encodeData, err := json.Marshal(message.Halo2ChunkProof{})
+		assert.NoError(t, err)
+		assert.NotEmpty(t, encodeData)
+		proof = encodeData
+	case int(message.ProofTypeBatch):
+		encodeData, err := json.Marshal(message.Halo2BatchProof{})
+		assert.NoError(t, err)
+		assert.NotEmpty(t, encodeData)
+		proof = encodeData
+	}
+
+	if proofStatus == verifiedFailed {
+		switch proverTaskSchema.TaskType {
+		case int(message.ProofTypeChunk):
+			chunkProof := message.Halo2ChunkProof{}
+			chunkProof.RawProof = []byte(verifier.InvalidTestProof)
+			encodeData, err := json.Marshal(&chunkProof)
 			assert.NoError(t, err)
 			assert.NotEmpty(t, encodeData)
 			proof = encodeData
-		case message.ProofTypeBundle:
-			encodeData, err := json.Marshal(&message.OpenVMEvmProof{})
-			assert.NoError(t, err)
-			assert.NotEmpty(t, encodeData)
-			proof = encodeData
-		}
-	} else {
-		// in "verifiedFailed" status, we purpose the mockprover submit proof but not valid
-		switch message.ProofType(proverTaskSchema.TaskType) {
-		case message.ProofTypeChunk:
-			fallthrough
-		case message.ProofTypeBatch:
-			encodeData, err := json.Marshal(&message.OpenVMProof{Proof: []byte(verifier.InvalidTestProof)})
-			assert.NoError(t, err)
-			assert.NotEmpty(t, encodeData)
-			proof = encodeData
-		case message.ProofTypeBundle:
-			encodeData, err := json.Marshal(&message.OpenVMEvmProof{Proof: []byte(verifier.InvalidTestProof)})
+		case int(message.ProofTypeBatch):
+			batchProof := message.Halo2BatchProof{}
+			batchProof.RawProof = []byte(verifier.InvalidTestProof)
+			encodeData, err := json.Marshal(&batchProof)
 			assert.NoError(t, err)
 			assert.NotEmpty(t, encodeData)
 			proof = encodeData
@@ -241,12 +240,11 @@ func (r *mockProver) submitProof(t *testing.T, proverTaskSchema *types.GetTaskSc
 	}
 
 	submitProof := types.SubmitProofParameter{
-		UUID:      proverTaskSchema.UUID,
-		TaskID:    proverTaskSchema.TaskID,
-		TaskType:  proverTaskSchema.TaskType,
-		Status:    int(proofMsgStatus),
-		Proof:     string(proof),
-		Universal: true,
+		UUID:     proverTaskSchema.UUID,
+		TaskID:   proverTaskSchema.TaskID,
+		TaskType: proverTaskSchema.TaskType,
+		Status:   int(proofMsgStatus),
+		Proof:    string(proof),
 	}
 
 	token, authErrCode, errMsg := r.connectToCoordinator(t, []types.ProverType{types.MakeProverType(message.ProofType(proverTaskSchema.TaskType))})

crates/l2geth/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "l2geth"
-version.workspace = true
-edition.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[dependencies]
-tokio = {version = "1", features = ["rt-multi-thread"]}
-async-trait = "0.1"
-url = ">=2.5.3"
-
-libzkp = { path = "../libzkp" }
-alloy = { workspace = true, features = ["provider-http", "transport-http", "reqwest", "reqwest-rustls-tls", "json-rpc"] }
-sbv-primitives = { workspace = true, features = ["scroll"] }
-sbv-utils = { workspace = true, features = ["scroll"] }
-sbv-core = { workspace = true, features = ["scroll"] }
-
-eyre.workspace = true
-
-base64.workspace = true
-serde.workspace = true
-serde_derive.workspace = true
-serde_json = { workspace = true, features = ["raw_value"]}
-tracing.workspace = true
-
-
-

crates/l2geth/src/lib.rs

@@ -1,19 +0,0 @@
-pub mod rpc_client;
-pub use rpc_client::RpcConfig;
-
-use std::sync::{Arc, OnceLock};
-
-static GLOBAL_L2GETH_CLI: OnceLock<Arc<rpc_client::RpcClientCore>> = OnceLock::new();
-
-pub fn init(config: &str) -> eyre::Result<()> {
-    let cfg: RpcConfig = serde_json::from_str(config)?;
-    GLOBAL_L2GETH_CLI.get_or_init(|| Arc::new(rpc_client::RpcClientCore::create(&cfg).unwrap()));
-    Ok(())
-}
-
-pub fn get_client() -> impl libzkp::tasks::ChunkInterpreter {
-    GLOBAL_L2GETH_CLI
-        .get()
-        .expect("must has been inited")
-        .get_client()
-}

crates/l2geth/src/rpc_client.rs

@@ -1,221 +0,0 @@
-use alloy::{
-    providers::{Provider, ProviderBuilder},
-    rpc::client::ClientBuilder,
-    transports::layers::RetryBackoffLayer,
-};
-use eyre::Result;
-use libzkp::tasks::ChunkInterpreter;
-use sbv_primitives::types::Network;
-use serde::{Deserialize, Serialize};
-
-fn default_max_retry() -> u32 {
-    10
-}
-fn default_backoff() -> u64 {
-    100
-}
-fn default_cups() -> u64 {
-    100
-}
-fn default_workers() -> usize {
-    4
-}
-fn default_max_concurrency() -> usize {
-    10
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct RpcConfig {
-    #[serde(alias = "endpoint")]
-    pub rpc_url: String,
-    // The threads used in rt, default 4
-    #[serde(default = "default_workers")]
-    pub workers: usize,
-    // The blocking threads to handle rpc tasks, default 10
-    #[serde(default = "default_max_concurrency")]
-    pub max_concurrency: usize,
-    // Retry parameters
-    #[serde(default = "default_max_retry")]
-    pub max_retry: u32,
-    // backoff duration in milliseconds, default 100ms
-    #[serde(default = "default_backoff")]
-    pub backoff: u64,
-    // compute units per second: default 100
-    #[serde(default = "default_cups")]
-    pub cups: u64,
-}
-
-/// An rpc client prover which carrying async runtime,
-/// so it can be run in block mode (i.e. inside dynamic library without a global entry)
-pub struct RpcClientCore {
-    /// rpc prover
-    client: alloy::rpc::client::RpcClient,
-    rt: tokio::runtime::Runtime,
-}
-
-#[derive(Clone, Copy)]
-pub struct RpcClient<'a, T: Provider<Network>> {
-    provider: T,
-    handle: &'a tokio::runtime::Handle,
-}
-
-impl RpcClientCore {
-    pub fn create(config: &RpcConfig) -> Result<Self> {
-        let rpc = url::Url::parse(&config.rpc_url)?;
-        tracing::info!("Using RPC: {}", rpc);
-        // note we MUST use multi rt since we have no a main thread for driving
-        // for each call in our method we can acquire a handle of the rt to resolve one or more
-        // async tasks
-        let rt = tokio::runtime::Builder::new_multi_thread()
-            .worker_threads(config.workers)
-            .max_blocking_threads(config.max_concurrency)
-            .enable_all()
-            .build()?;
-
-        let retry_layer = RetryBackoffLayer::new(config.max_retry, config.backoff, config.cups);
-        let client = ClientBuilder::default().layer(retry_layer).http(rpc);
-
-        Ok(Self { client, rt })
-    }
-
-    pub fn get_client(&self) -> RpcClient<'_, impl Provider<Network>> {
-        RpcClient {
-            provider: ProviderBuilder::<_, _, Network>::default()
-                .connect_client(self.client.clone()),
-            handle: self.rt.handle(),
-        }
-    }
-}
-
-impl<T: Provider<Network>> ChunkInterpreter for RpcClient<'_, T> {
-    fn try_fetch_block_witness(
-        &self,
-        block_hash: sbv_primitives::B256,
-        prev_witness: Option<&sbv_core::BlockWitness>,
-    ) -> Result<sbv_core::BlockWitness> {
-        async fn fetch_witness_async(
-            provider: impl Provider<Network>,
-            block_hash: sbv_primitives::B256,
-            prev_witness: Option<&sbv_core::BlockWitness>,
-        ) -> Result<sbv_core::BlockWitness> {
-            use sbv_utils::rpc::ProviderExt;
-
-            let (chain_id, block_num, prev_state_root) = if let Some(w) = prev_witness {
-                (w.chain_id, w.header.number + 1, w.header.state_root)
-            } else {
-                let chain_id = provider.get_chain_id().await?;
-                let block = provider
-                    .get_block_by_hash(block_hash)
-                    .full()
-                    .await?
-                    .ok_or_else(|| eyre::eyre!("Block {block_hash} not found"))?;
-
-                let parent_block = provider
-                    .get_block_by_hash(block.header.parent_hash)
-                    .await?
-                    .ok_or_else(|| {
-                        eyre::eyre!(
-                            "parent block for block {} should exist",
-                            block.header.number
-                        )
-                    })?;
-
-                (
-                    chain_id,
-                    block.header.number,
-                    parent_block.header.state_root,
-                )
-            };
-
-            let req = provider
-                .dump_block_witness(block_num)
-                .with_chain_id(chain_id)
-                .with_prev_state_root(prev_state_root);
-
-            let witness = req
-                .send()
-                .await
-                .transpose()
-                .ok_or_else(|| eyre::eyre!("Block witness {block_num} not available"))??;
-
-            Ok(witness)
-        }
-
-        tracing::debug!("fetch witness for {block_hash}");
-        self.handle.block_on(fetch_witness_async(
-            &self.provider,
-            block_hash,
-            prev_witness,
-        ))
-    }
-
-    fn try_fetch_storage_node(
-        &self,
-        node_hash: sbv_primitives::B256,
-    ) -> Result<sbv_primitives::Bytes> {
-        async fn fetch_storage_node_async(
-            provider: impl Provider<Network>,
-            node_hash: sbv_primitives::B256,
-        ) -> Result<sbv_primitives::Bytes> {
-            let ret = provider
-                .client()
-                .request::<_, sbv_primitives::Bytes>("debug_dbGet", (node_hash,))
-                .await?;
-            Ok(ret)
-        }
-
-        tracing::debug!("fetch storage node for {node_hash}");
-        self.handle
-            .block_on(fetch_storage_node_async(&self.provider, node_hash))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use alloy::primitives::hex;
-    use sbv_primitives::B256;
-    use std::env;
-
-    fn create_config_from_env() -> RpcConfig {
-        let endpoint =
-            env::var("L2GETH_ENDPOINT").expect("L2GETH_ENDPOINT environment variable must be set");
-
-        let config_json = format!(r#"{{"endpoint": "{}"}}"#, endpoint);
-        serde_json::from_str(&config_json).expect("Failed to parse RPC config")
-    }
-
-    #[test]
-    #[ignore = "Requires L2GETH_ENDPOINT environment variable"]
-    fn test_try_fetch_block_witness() {
-        let config = create_config_from_env();
-        let client_core = RpcClientCore::create(&config).expect("Failed to create RPC client");
-        let client = client_core.get_client();
-
-        // latest - 1 block in 2025.9.11
-        let block_hash = B256::from(
-            hex::const_decode_to_array(
-                b"0x093fb6bf2e556a659b35428ac447cd9f0635382fc40ffad417b5910824f9e932",
-            )
-            .unwrap(),
-        );
-
-        // This is expected to fail since we're using a dummy hash, but it tests the code path
-        let wit1 = client
-            .try_fetch_block_witness(block_hash, None)
-            .expect("should success");
-
-        // block selected in 2025.9.11
-        let block_hash = B256::from(
-            hex::const_decode_to_array(
-                b"0x77cc84dd7a4dedf6fe5fb9b443aeb5a4fb0623ad088a365d3232b7b23fc848e5",
-            )
-            .unwrap(),
-        );
-        let wit2 = client
-            .try_fetch_block_witness(block_hash, Some(&wit1))
-            .expect("should success");
-
-        println!("{}", serde_json::to_string_pretty(&wit2).unwrap());
-    }
-}

crates/libzkp/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "libzkp"
-version.workspace = true
-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
-scroll-zkvm-verifier.workspace = true
-
-alloy-primitives.workspace = true #depress the effect of "native-keccak"
-sbv-primitives = {workspace = true, features = ["scroll-compress-ratio", "scroll"]}
-sbv-core = { workspace = true, features = ["scroll"] }
-base64.workspace = true
-serde.workspace = true
-serde_derive.workspace = true
-serde_json = { workspace = true, features = ["raw_value"]}
-tracing.workspace = true
-eyre.workspace = true
-
-git-version = "0.3.5"
-bincode = { version = "2", features = ["serde"] }
-serde_stacker = "0.1"
-regex = "1.11"
-c-kzg = { version = "2.0", features = ["serde"] }
-

crates/libzkp/src/lib.rs

@@ -1,164 +0,0 @@
-pub mod proofs;
-pub mod tasks;
-pub mod verifier;
-pub use verifier::{TaskType, VerifierConfig};
-mod utils;
-
-use sbv_primitives::B256;
-use scroll_zkvm_types::utils::vec_as_base64;
-use serde::{Deserialize, Serialize};
-use serde_json::value::RawValue;
-use std::path::Path;
-use tasks::chunk_interpreter::{ChunkInterpreter, TryFromWithInterpreter};
-
-/// 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 }
-}
-
-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;
-                }
-            }
-            s => tracing::warn!("unrecognized dynamic feature: {s}"),
-        }
-    }
-}
-
-/// Turn the coordinator's chunk task into a json string for formal chunk proving
-/// task (with full witnesses)
-pub fn checkout_chunk_task(
-    task_json: &str,
-    interpreter: impl ChunkInterpreter,
-) -> eyre::Result<String> {
-    let chunk_task = serde_json::from_str::<tasks::ChunkTask>(task_json)?;
-    let ret = serde_json::to_string(&tasks::ChunkProvingTask::try_from_with_interpret(
-        chunk_task,
-        interpreter,
-    )?)?;
-    Ok(ret)
-}
-
-/// Generate required staff for proving tasks
-/// return (pi_hash, metadata, task)
-pub fn gen_universal_task(
-    task_type: i32,
-    task_json: &str,
-    fork_name_str: &str,
-    expected_vk: &[u8],
-) -> eyre::Result<(B256, String, String)> {
-    use proofs::*;
-    use tasks::*;
-
-    /// Wrapper for metadata
-    #[derive(Clone, Debug, Serialize, Deserialize)]
-    #[serde(untagged)]
-    enum AnyMetaData {
-        Chunk(ChunkProofMetadata),
-        Batch(BatchProofMetadata),
-        Bundle(BundleProofMetadata),
-    }
-
-    let (pi_hash, metadata, mut u_task) = match task_type {
-        x if x == TaskType::Chunk as i32 => {
-            let mut task = serde_json::from_str::<ChunkProvingTask>(task_json)?;
-            // normailze fork name field in task
-            task.fork_name = task.fork_name.to_lowercase();
-            // 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);
-            }
-            let (pi_hash, metadata, u_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();
-            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);
-            }
-            let (pi_hash, metadata, u_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();
-            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);
-            }
-            let (pi_hash, metadata, u_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)
-        }
-        _ => return Err(eyre::eyre!("unrecognized task type {task_type}")),
-    };
-
-    u_task.vk = Vec::from(expected_vk);
-
-    Ok((
-        pi_hash,
-        serde_json::to_string(&metadata)?,
-        serde_json::to_string(&u_task)?,
-    ))
-}
-
-/// helper to rearrange the proof return by universal prover into corresponding wrapped proof
-pub fn gen_wrapped_proof(proof_json: &str, metadata: &str, vk: &[u8]) -> eyre::Result<String> {
-    #[derive(Serialize)]
-    struct RearrangeWrappedProofJson<'a> {
-        #[serde(borrow)]
-        pub metadata: &'a RawValue,
-        #[serde(borrow)]
-        pub proof: &'a RawValue,
-        #[serde(with = "vec_as_base64", default)]
-        pub vk: Vec<u8>,
-        pub git_version: String,
-    }
-
-    let re_arrange = RearrangeWrappedProofJson {
-        metadata: serde_json::from_str(metadata)?,
-        proof: serde_json::from_str(proof_json)?,
-        vk: vk.to_vec(),
-        git_version: utils::short_git_version(),
-    };
-
-    let ret = serde_json::to_string(&re_arrange)?;
-    Ok(ret)
-}
-
-/// init verifier
-pub fn verifier_init(config: &str) -> eyre::Result<()> {
-    let cfg: VerifierConfig = serde_json::from_str(config)?;
-    verifier::init(cfg);
-    Ok(())
-}
-
-/// verify proof
-pub fn verify_proof(proof: Vec<u8>, fork_name: &str, task_type: TaskType) -> eyre::Result<bool> {
-    let verifier = verifier::get_verifier(fork_name)?;
-
-    let ret = verifier.lock().unwrap().verify(task_type, &proof)?;
-    Ok(ret)
-}
-
-/// dump vk
-pub fn dump_vk(fork_name: &str, file: &str) -> eyre::Result<()> {
-    let verifier = verifier::get_verifier(fork_name)?;
-
-    verifier.lock().unwrap().dump_vk(Path::new(file));
-
-    Ok(())
-}

crates/libzkp/src/proofs.rs

@@ -1,343 +0,0 @@
-use std::path::Path;
-
-use crate::utils::short_git_version;
-use eyre::Result;
-use sbv_primitives::B256;
-use scroll_zkvm_types::{
-    batch::BatchInfo,
-    bundle::BundleInfo,
-    chunk::ChunkInfo,
-    proof::{EvmProof, OpenVmEvmProof, ProofEnum, StarkProof},
-    public_inputs::{ForkName, MultiVersionPublicInputs},
-    types_agg::AggregationInput,
-    utils::{serialize_vk, vec_as_base64},
-};
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
-
-/// A wrapper around the actual inner proof.
-#[derive(Clone, Serialize, Deserialize)]
-pub struct WrappedProof<Metadata> {
-    /// Generic metadata carried by a proof.
-    pub metadata: Metadata,
-    /// The inner proof, either a [`RootProof`] or [`EvmProof`] depending on the
-    /// [`crate::ProverType`].
-    pub proof: ProofEnum,
-    /// Represents the verifying key in serialized form. The purpose of including the verifying key
-    /// along with the proof is to allow a verifier-only mode to identify the source of proof
-    /// generation.
-    ///
-    /// For [`RootProof`] the verifying key is denoted by the digest of the VM's program.
-    ///
-    /// For [`EvmProof`] its the raw bytes of the halo2 circuit's `VerifyingKey`.
-    ///
-    /// We encode the vk in base64 format during JSON serialization.
-    #[serde(with = "vec_as_base64", default)]
-    pub vk: Vec<u8>,
-    /// Represents the git ref for `zkvm-prover` that was used to construct the proof.
-    ///
-    /// This is useful for debugging.
-    pub git_version: String,
-}
-
-pub trait AsRootProof {
-    fn as_root_proof(&self) -> &StarkProof;
-}
-
-pub trait AsEvmProof {
-    fn as_evm_proof(&self) -> &EvmProof;
-}
-
-pub trait IntoEvmProof {
-    fn into_evm_proof(self) -> OpenVmEvmProof;
-}
-
-/// Alias for convenience.
-pub type ChunkProof = WrappedProof<ChunkProofMetadata>;
-
-/// Alias for convenience.
-pub type BatchProof = WrappedProof<BatchProofMetadata>;
-
-/// Alias for convenience.
-pub type BundleProof = WrappedProof<BundleProofMetadata>;
-
-impl AsRootProof for ChunkProof {
-    fn as_root_proof(&self) -> &StarkProof {
-        self.proof
-            .as_stark_proof()
-            .expect("batch proof use root proof")
-    }
-}
-
-impl AsRootProof for BatchProof {
-    fn as_root_proof(&self) -> &StarkProof {
-        self.proof
-            .as_stark_proof()
-            .expect("batch proof use root proof")
-    }
-}
-
-impl AsEvmProof for BundleProof {
-    fn as_evm_proof(&self) -> &EvmProof {
-        self.proof
-            .as_evm_proof()
-            .expect("bundle proof use evm proof")
-    }
-}
-
-impl IntoEvmProof for BundleProof {
-    fn into_evm_proof(self) -> OpenVmEvmProof {
-        self.proof
-            .as_evm_proof()
-            .expect("bundle proof use evm proof")
-            .clone()
-            .into()
-    }
-}
-
-/// Trait to enable operations in metadata
-pub trait ProofMetadata: Serialize + DeserializeOwned + std::fmt::Debug {
-    type PublicInputs: MultiVersionPublicInputs;
-
-    fn pi_hash_info(&self) -> &Self::PublicInputs;
-
-    fn new_proof<P: Into<ProofEnum>>(self, proof: P, vk: Option<&[u8]>) -> WrappedProof<Self> {
-        WrappedProof {
-            metadata: self,
-            proof: proof.into(),
-            vk: vk.map(Vec::from).unwrap_or_default(),
-            git_version: short_git_version(),
-        }
-    }
-}
-
-pub trait PersistableProof: Sized {
-    /// Read and deserialize the proof.
-    fn from_json<P: AsRef<Path>>(path_proof: P) -> Result<Self>;
-    /// Serialize the proof and dumping at the given path.
-    fn dump<P: AsRef<Path>>(&self, path_proof: P) -> Result<()>;
-}
-
-/// Metadata attached to [`ChunkProof`].
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct ChunkProofMetadata {
-    /// The chunk information describing the list of blocks contained within the chunk.
-    pub chunk_info: ChunkInfo,
-    /// Additional data for stat
-    pub chunk_total_gas: u64,
-}
-
-impl ProofMetadata for ChunkProofMetadata {
-    type PublicInputs = ChunkInfo;
-
-    fn pi_hash_info(&self) -> &Self::PublicInputs {
-        &self.chunk_info
-    }
-}
-
-/// Metadata attached to [`BatchProof`].
-#[derive(Clone, Debug, Serialize, Deserialize)]
-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 {
-    type PublicInputs = BatchInfo;
-
-    fn pi_hash_info(&self) -> &Self::PublicInputs {
-        &self.batch_info
-    }
-}
-
-/// Metadata attached to [`BundleProof`].
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct BundleProofMetadata {
-    /// The bundle information describing the list of batches to be finalised on-chain.
-    pub bundle_info: BundleInfo,
-    /// The public-input digest for the bundle.
-    pub bundle_pi_hash: B256,
-}
-
-impl ProofMetadata for BundleProofMetadata {
-    type PublicInputs = BundleInfo;
-
-    fn pi_hash_info(&self) -> &Self::PublicInputs {
-        &self.bundle_info
-    }
-}
-
-impl<Metadata> From<&WrappedProof<Metadata>> for AggregationInput {
-    fn from(value: &WrappedProof<Metadata>) -> Self {
-        Self {
-            public_values: value.proof.public_values(),
-            commitment: serialize_vk::deserialize(&value.vk),
-        }
-    }
-}
-
-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, fork_name: ForkName) -> bool {
-        let proof_pi = self.proof.public_values();
-
-        let expected_pi = self
-            .metadata
-            .pi_hash_info()
-            .pi_hash_by_fork(fork_name)
-            .0
-            .as_ref()
-            .iter()
-            .map(|&v| v as u32)
-            .collect::<Vec<_>>();
-
-        let ret = expected_pi == proof_pi;
-        if !ret {
-            tracing::warn!("pi mismatch: expected={expected_pi:?}, found={proof_pi:?}");
-        }
-        ret
-    }
-}
-
-impl<Metadata: ProofMetadata> PersistableProof for WrappedProof<Metadata> {
-    fn from_json<P: AsRef<Path>>(path_proof: P) -> Result<Self> {
-        crate::utils::read_json_deep(path_proof)
-    }
-
-    fn dump<P: AsRef<Path>>(&self, path_proof: P) -> Result<()> {
-        crate::utils::write_json(path_proof, &self)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use base64::{prelude::BASE64_STANDARD, Engine};
-    use sbv_primitives::B256;
-    use scroll_zkvm_types::{bundle::BundleInfo, proof::EvmProof, public_inputs::ForkName};
-
-    use super::*;
-
-    #[test]
-    fn test_roundtrip() -> eyre::Result<()> {
-        macro_rules! assert_roundtrip {
-            ($fd:expr, $proof:ident) => {
-                let proof_str_expected =
-                    std::fs::read_to_string(std::path::Path::new("./testdata").join($fd))?;
-                let proof = serde_json::from_str::<$proof>(&proof_str_expected)?;
-                let proof_str_got = serde_json::to_string(&proof)?;
-                assert_eq!(proof_str_got, proof_str_expected);
-            };
-        }
-
-        assert_roundtrip!("chunk-proof.json", ChunkProof);
-        assert_roundtrip!("batch-proof.json", BatchProof);
-        assert_roundtrip!("bundle-proof.json", BundleProof);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_dummy_proof() -> eyre::Result<()> {
-        // 1. Metadata
-        let metadata = {
-            let bundle_info = BundleInfo {
-                chain_id: 12345,
-                num_batches: 12,
-                prev_state_root: B256::repeat_byte(1),
-                prev_batch_hash: B256::repeat_byte(2),
-                post_state_root: B256::repeat_byte(3),
-                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(ForkName::EuclidV1);
-            BundleProofMetadata {
-                bundle_info,
-                bundle_pi_hash,
-            }
-        };
-
-        // 2. Proof
-        let (proof, proof_base64) = {
-            let proof = std::iter::empty()
-                .chain(std::iter::repeat_n(1, 1))
-                .chain(std::iter::repeat_n(2, 2))
-                .chain(std::iter::repeat_n(3, 3))
-                .chain(std::iter::repeat_n(4, 4))
-                .chain(std::iter::repeat_n(5, 5))
-                .chain(std::iter::repeat_n(6, 6))
-                .chain(std::iter::repeat_n(7, 7))
-                .chain(std::iter::repeat_n(8, 8))
-                .chain(std::iter::repeat_n(9, 9))
-                .collect::<Vec<u8>>();
-            let proof_base64 = BASE64_STANDARD.encode(&proof);
-            (proof, proof_base64)
-        };
-
-        // 3. Instances
-        let (instances, instances_base64) = {
-            // LE: [0x56, 0x34, 0x12, 0x00, 0x00, ..., 0x00]
-            // LE: [0x32, 0x54, 0x76, 0x98, 0x00, ..., 0x00]
-            let instances = std::iter::empty()
-                .chain(std::iter::repeat_n(0x00, 29))
-                .chain(std::iter::once(0x12))
-                .chain(std::iter::once(0x34))
-                .chain(std::iter::once(0x56))
-                .chain(std::iter::repeat_n(0x00, 28))
-                .chain(std::iter::once(0x98))
-                .chain(std::iter::once(0x76))
-                .chain(std::iter::once(0x54))
-                .chain(std::iter::once(0x32))
-                .collect::<Vec<u8>>();
-            let instances_base64 = BASE64_STANDARD.encode(&instances);
-            (instances, instances_base64)
-        };
-
-        // 4. VK
-        let (vk, vk_base64) = {
-            let vk = std::iter::empty()
-                .chain(std::iter::repeat_n(1, 9))
-                .chain(std::iter::repeat_n(2, 8))
-                .chain(std::iter::repeat_n(3, 7))
-                .chain(std::iter::repeat_n(4, 6))
-                .chain(std::iter::repeat_n(5, 5))
-                .chain(std::iter::repeat_n(6, 4))
-                .chain(std::iter::repeat_n(7, 3))
-                .chain(std::iter::repeat_n(8, 2))
-                .chain(std::iter::repeat_n(9, 1))
-                .collect::<Vec<u8>>();
-            let vk_base64 = BASE64_STANDARD.encode(&vk);
-            (vk, vk_base64)
-        };
-
-        let evm_proof = EvmProof { instances, proof };
-        let bundle_proof = metadata.new_proof(evm_proof, Some(vk.as_slice()));
-        let bundle_proof_json = serde_json::to_value(&bundle_proof)?;
-
-        assert_eq!(
-            bundle_proof_json.get("proof").unwrap(),
-            &serde_json::json!({
-                "proof": proof_base64,
-                "instances": instances_base64,
-            }),
-        );
-        assert_eq!(
-            bundle_proof_json.get("vk").unwrap(),
-            &serde_json::Value::String(vk_base64),
-        );
-
-        let bundle_proof_de = serde_json::from_value::<BundleProof>(bundle_proof_json)?;
-
-        assert_eq!(
-            bundle_proof_de.proof.as_evm_proof(),
-            bundle_proof.proof.as_evm_proof()
-        );
-        assert_eq!(bundle_proof_de.vk, bundle_proof.vk);
-
-        Ok(())
-    }
-}

crates/libzkp/src/tasks.rs

@@ -1,98 +0,0 @@
-pub mod batch;
-pub mod bundle;
-pub mod chunk;
-pub mod chunk_interpreter;
-
-pub use batch::BatchProvingTask;
-pub use bundle::BundleProvingTask;
-pub use chunk::{ChunkProvingTask, ChunkTask};
-pub use chunk_interpreter::ChunkInterpreter;
-pub use scroll_zkvm_types::task::ProvingTask;
-
-use crate::{
-    proofs::{self, BatchProofMetadata, BundleProofMetadata, ChunkProofMetadata},
-    utils::panic_catch,
-};
-use sbv_primitives::B256;
-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>(
-    proofs: &[proofs::WrappedProof<Metadata>],
-    fork_name: ForkName,
-) -> eyre::Result<()>
-where
-    Metadata: proofs::ProofMetadata,
-{
-    panic_catch(|| {
-        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!("Chunk data validation failed: {}", e))?;
-
-    Ok(())
-}
-
-/// 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 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((
-        expected_pi_hash,
-        ChunkProofMetadata {
-            chunk_info,
-            chunk_total_gas,
-        },
-        proving_task,
-    ))
-}
-
-/// Generate required staff for batch proving
-pub fn gen_universal_batch_task(
-    task: BatchProvingTask,
-    fork_name: ForkName,
-) -> eyre::Result<(B256, BatchProofMetadata, ProvingTask)> {
-    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((
-        expected_pi_hash,
-        BatchProofMetadata {
-            batch_info,
-            batch_hash: expected_pi_hash,
-        },
-        proving_task,
-    ))
-}
-
-/// Generate required staff for bundle proving
-pub fn gen_universal_bundle_task(
-    task: BundleProvingTask,
-    fork_name: ForkName,
-) -> eyre::Result<(B256, BundleProofMetadata, ProvingTask)> {
-    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((
-        expected_pi_hash,
-        BundleProofMetadata {
-            bundle_info,
-            bundle_pi_hash: expected_pi_hash,
-        },
-        proving_task,
-    ))
-}

crates/libzkp/src/tasks/batch.rs

@@ -1,208 +0,0 @@
-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, BatchHeaderV8,
-        BatchInfo, BatchWitness, Envelope, EnvelopeV6, EnvelopeV7, EnvelopeV8, LegacyBatchWitness,
-        ReferenceHeader, N_BLOB_BYTES,
-    },
-    public_inputs::ForkName,
-    task::ProvingTask,
-    utils::{to_rkyv_bytes, RancorError},
-};
-
-mod utils;
-use utils::{base64, point_eval};
-
-/// 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)]
-pub enum BatchHeaderV {
-    V6(BatchHeaderV6),
-    V7_8(BatchHeaderV7),
-}
-
-impl BatchHeaderV {
-    pub fn batch_hash(&self) -> B256 {
-        match self {
-            BatchHeaderV::V6(h) => h.batch_hash(),
-            BatchHeaderV::V7_8(h) => h.batch_hash(),
-        }
-    }
-
-    pub fn must_v6_header(&self) -> &BatchHeaderV6 {
-        match self {
-            BatchHeaderV::V6(h) => h,
-            _ => panic!("try to pick other header type"),
-        }
-    }
-
-    pub fn must_v7_header(&self) -> &BatchHeaderV7 {
-        match self {
-            BatchHeaderV::V7_8(h) => h,
-            _ => panic!("try to pick other header type"),
-        }
-    }
-
-    pub fn must_v8_header(&self) -> &BatchHeaderV8 {
-        match self {
-            BatchHeaderV::V7_8(h) => h,
-            _ => panic!("try to pick other header type"),
-        }
-    }
-}
-
-/// Defines a proving task for batch proof generation, the format
-/// is compatible with both pre-euclidv2 and euclidv2
-#[derive(Clone, serde::Deserialize, serde::Serialize)]
-pub struct BatchProvingTask {
-    /// 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.
-    pub batch_header: BatchHeaderV,
-    /// The bytes encoding the batch data that will finally be published on-chain in the form of an
-    /// EIP-4844 blob.
-    #[serde(with = "base64")]
-    pub blob_bytes: Vec<u8>,
-    /// Challenge digest computed using the blob's bytes and versioned hash.
-    pub challenge_digest: Option<U256>,
-    /// KZG commitment for the blob.
-    pub kzg_commitment: Option<Bytes48>,
-    /// KZG proof.
-    pub kzg_proof: Option<Bytes48>,
-    /// fork version specify, for sanity check with batch_header and chunk proof
-    pub fork_name: String,
-}
-
-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)?
-        };
-
-        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(),
-        })
-    }
-}
-
-impl BatchProvingTask {
-    fn build_guest_input(&self) -> BatchWitness {
-        let fork_name = self.fork_name.to_lowercase().as_str().into();
-
-        // 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
-                    };
-
-                    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],
-                        ),
-                    }
-                }
-            };
-
-            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);
-        }
-
-        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 {
-            fork_name,
-            chunk_proofs: self.chunk_proofs.iter().map(|proof| proof.into()).collect(),
-            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,
-            version: 0,
-        }
-    }
-
-    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 witness = self.build_guest_input();
-        let metadata = BatchInfo::from(&witness);
-
-        super::check_aggregation_proofs(self.chunk_proofs.as_slice(), fork_name)?;
-
-        Ok(metadata)
-    }
-}

crates/libzkp/src/tasks/batch/utils.rs

@@ -1,75 +0,0 @@
-pub mod base64 {
-    use base64::prelude::*;
-    use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-    pub fn serialize<S: Serializer>(v: &Vec<u8>, s: S) -> Result<S::Ok, S::Error> {
-        let base64 = BASE64_STANDARD.encode(v);
-        String::serialize(&base64, s)
-    }
-
-    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D::Error> {
-        let base64 = String::deserialize(d)?;
-        BASE64_STANDARD
-            .decode(base64.as_bytes())
-            .map_err(serde::de::Error::custom)
-    }
-}
-
-pub mod point_eval {
-    use c_kzg;
-    use sbv_primitives::{types::eips::eip4844::BLS_MODULUS, B256 as H256, U256};
-    use scroll_zkvm_types::utils::sha256_rv32;
-
-    /// Given the blob-envelope, translate it to a fixed size EIP-4844 blob.
-    ///
-    /// For every 32-bytes chunk in the blob, the most-significant byte is set to 0 while the other
-    /// 31 bytes are copied from the provided blob-envelope.
-    pub fn to_blob(envelope_bytes: &[u8]) -> c_kzg::Blob {
-        let mut blob_bytes = [0u8; c_kzg::BYTES_PER_BLOB];
-
-        assert!(
-            envelope_bytes.len()
-                <= c_kzg::FIELD_ELEMENTS_PER_BLOB * (c_kzg::BYTES_PER_FIELD_ELEMENT - 1),
-            "too many bytes in blob envelope",
-        );
-
-        for (i, &byte) in envelope_bytes.iter().enumerate() {
-            blob_bytes[(i / 31) * 32 + 1 + (i % 31)] = byte;
-        }
-
-        c_kzg::Blob::new(blob_bytes)
-    }
-
-    /// Get the KZG commitment from an EIP-4844 blob.
-    pub fn blob_to_kzg_commitment(blob: &c_kzg::Blob) -> c_kzg::KzgCommitment {
-        c_kzg::ethereum_kzg_settings(0)
-            .blob_to_kzg_commitment(blob)
-            .expect("blob to kzg commitment should succeed")
-    }
-
-    /// The version for KZG as per EIP-4844.
-    const VERSIONED_HASH_VERSION_KZG: u8 = 1;
-
-    /// Get the EIP-4844 versioned hash from the KZG commitment.
-    pub fn get_versioned_hash(commitment: &c_kzg::KzgCommitment) -> H256 {
-        let mut hash: [u8; 32] = sha256_rv32(commitment.to_bytes().as_slice()).into();
-        hash[0] = VERSIONED_HASH_VERSION_KZG;
-        H256::new(hash)
-    }
-
-    /// Get x for kzg proof from challenge hash
-    pub fn get_x_from_challenge(challenge: H256) -> U256 {
-        U256::from_be_bytes(challenge.0) % BLS_MODULUS
-    }
-
-    /// Generate KZG proof and evaluation given the blob (polynomial) and a random challenge.
-    pub fn get_kzg_proof(blob: &c_kzg::Blob, challenge: H256) -> (c_kzg::KzgProof, U256) {
-        let challenge = get_x_from_challenge(challenge);
-
-        let (proof, y) = c_kzg::ethereum_kzg_settings(0)
-            .compute_kzg_proof(blob, &c_kzg::Bytes32::new(challenge.to_be_bytes()))
-            .expect("kzg proof should succeed");
-
-        (proof, U256::from_be_slice(y.as_slice()))
-    }
-}