chore: bump version

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

.github/workflows/common.yml

@@ -42,11 +42,11 @@ jobs:
       uses: Swatinem/rust-cache@v2
       with:
         workspaces: "common/libzkp/impl -> target"
-    - name: Lint
-      working-directory: 'common'
-      run: |
-        rm -rf $HOME/.cache/golangci-lint
-        make lint
+    # - name: Lint
+    #   working-directory: 'common'
+    #   run: |
+    #     rm -rf $HOME/.cache/golangci-lint
+    #     make lint
   goimports-lint:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest

.github/workflows/docker.yml

@@ -99,6 +99,51 @@ jobs:
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
+  blob_uploader:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: blob-uploader
+        run: |
+          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: blob-uploader
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/blob_uploader.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
   rollup-db-cli:
     runs-on: ubuntu-latest
     steps:
@@ -307,6 +352,48 @@ jobs:
           REPOSITORY: coordinator-api
         run: |
           aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Setup SSH for repositories and clone them
+        run: |
+          mkdir -p ~/.ssh
+          chmod 700 ~/.ssh
+
+          # Setup for plonky3-gpu
+          echo "${{ secrets.PLONKY3_GPU_SSH_PRIVATE_KEY }}" > ~/.ssh/plonky3_gpu_key
+          chmod 600 ~/.ssh/plonky3_gpu_key
+          eval "$(ssh-agent -s)" > /dev/null
+          ssh-add ~/.ssh/plonky3_gpu_key 2>/dev/null
+          ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts 2>/dev/null
+          echo "Loaded plonky3-gpu key"
+
+          # Clone plonky3-gpu repository
+          ./build/dockerfiles/coordinator-api/clone_plonky3_gpu.sh
+
+          # Setup for openvm-stark-gpu
+          echo "${{ secrets.OPENVM_STARK_GPU_SSH_PRIVATE_KEY }}" > ~/.ssh/openvm_stark_gpu_key
+          chmod 600 ~/.ssh/openvm_stark_gpu_key
+          eval "$(ssh-agent -s)" > /dev/null
+          ssh-add ~/.ssh/openvm_stark_gpu_key 2>/dev/null
+          echo "Loaded openvm-stark-gpu key"
+
+          # Clone openvm-stark-gpu repository
+          ./build/dockerfiles/coordinator-api/clone_openvm_stark_gpu.sh
+
+          # Setup for openvm-gpu
+          echo "${{ secrets.OPENVM_GPU_SSH_PRIVATE_KEY }}" > ~/.ssh/openvm_gpu_key
+          chmod 600 ~/.ssh/openvm_gpu_key
+          eval "$(ssh-agent -s)" > /dev/null
+          ssh-add ~/.ssh/openvm_gpu_key 2>/dev/null
+          echo "Loaded openvm-gpu key"
+
+          # Clone openvm-gpu repository
+          ./build/dockerfiles/coordinator-api/clone_openvm_gpu.sh
+
+          # Show number of loaded keys
+          echo "Number of loaded keys: $(ssh-add -l | wc -l)"
+
+      - name: Checkout specific commits
+        run: |
+          ./build/dockerfiles/coordinator-api/checkout_all.sh
       - name: Build and push
         uses: docker/build-push-action@v3
         env:

.github/workflows/intermediate-docker.yml

@@ -9,9 +9,13 @@ on:
         type: choice
         options:
           - "1.20"
+          - "1.20.14"
           - "1.21"
+          - "1.21.13"
           - "1.22"
+          - "1.22.12"
           - "1.23"
+          - "1.23.7"
         default: "1.21"
       RUST_VERSION:
         description: "Rust toolchain version"
@@ -20,6 +24,7 @@ on:
         options:
           - nightly-2023-12-03
           - nightly-2022-12-10
+          - 1.86.0
         default: "nightly-2023-12-03"
       PYTHON_VERSION:
         description: "Python version"
@@ -43,6 +48,7 @@ on:
         type: choice
         options:
           - 0.1.41
+          - 0.1.71
       BASE_IMAGE:
         description: "which intermediate image you want to update"
         required: true

.github/workflows/prover.yml

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

CONTRIBUTING.md

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

Makefile

@@ -31,12 +31,12 @@ fmt: ## Format the code
 	cd $(PWD)/rollup/ && go mod tidy
 	cd $(PWD)/tests/integration-test/ && go mod tidy
 
-	goimports -local $(PWD)/bridge-history-api/ -w .
-	goimports -local $(PWD)/common/ -w .
-	goimports -local $(PWD)/coordinator/ -w .
-	goimports -local $(PWD)/database/ -w .
-	goimports -local $(PWD)/rollup/ -w .
-	goimports -local $(PWD)/tests/integration-test/ -w .
+	goimports -local scroll-tech/bridge-history-api/ -w .
+	goimports -local scroll-tech/common/ -w .
+	goimports -local scroll-tech/coordinator/ -w .
+	goimports -local scroll-tech/database/ -w .
+	goimports -local scroll-tech/rollup/ -w .
+	goimports -local scroll-tech/tests/integration-test/ -w .
 
 dev_docker: ## Build docker images for development/testing usages
 	docker pull postgres

bridge-history-api/Makefile

@@ -37,6 +37,6 @@ reset-env:
 	go build -o $(PWD)/build/bin/bridgehistoryapi-db-cli ./cmd/db_cli && $(PWD)/build/bin/bridgehistoryapi-db-cli reset
 
 bridgehistoryapi-docker:
-	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-fetcher:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile
-	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-api:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-api.Dockerfile
-	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-db-cli:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile
+	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-fetcher:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile --platform=linux/amd64
+	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-api:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-api.Dockerfile --platform=linux/amd64
+	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-db-cli:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile --platform=linux/amd64

bridge-history-api/abi/backend_abi_test.go

@@ -0,0 +1,13 @@
+package backendabi
+
+import (
+	"testing"
+
+	"github.com/scroll-tech/go-ethereum/crypto"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEventSignatures(t *testing.T) {
+	assert.Equal(t, crypto.Keccak256Hash([]byte("RevertBatch(uint256,bytes32)")), L1RevertBatchV0EventSig)
+	assert.Equal(t, crypto.Keccak256Hash([]byte("RevertBatch(uint256,uint256)")), L1RevertBatchV7EventSig)
+}

bridge-history-api/cmd/fetcher/app/app.go

@@ -68,7 +68,10 @@ func action(ctx *cli.Context) error {
 
 	observability.Server(ctx, db)
 
-	l1MessageFetcher := fetcher.NewL1MessageFetcher(subCtx, cfg.L1, db, l1Client)
+	l1MessageFetcher, err := fetcher.NewL1MessageFetcher(subCtx, cfg.L1, db, l1Client)
+	if err != nil {
+		log.Crit("failed to create L1MessageFetcher", "err", err)
+	}
 	go l1MessageFetcher.Start()
 
 	l2MessageFetcher := fetcher.NewL2MessageFetcher(subCtx, cfg.L2, db, l2Client)

bridge-history-api/conf/config.json

@@ -19,9 +19,11 @@
 		"ScrollChainAddr": "0xa13BAF47339d63B743e7Da8741db5456DAc1E556",
 		"GatewayRouterAddr": "0xF8B1378579659D8F7EE5f3C929c2f3E332E41Fd6",
 		"MessageQueueAddr": "0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B",
+		"MessageQueueV2Addr": "0x0000000000000000000000000000000000000000",
 		"BatchBridgeGatewayAddr": "0x5Bcfd99c34cf7E06fc756f6f5aE7400504852bc4",
 		"GasTokenGatewayAddr": "0x0000000000000000000000000000000000000000",
-		"WrappedTokenGatewayAddr": "0x0000000000000000000000000000000000000000"
+		"WrappedTokenGatewayAddr": "0x0000000000000000000000000000000000000000",
+		"BlobScanAPIEndpoint": "https://api.blobscan.com/blobs/"
 	},
 	"L2": {
 		"confirmation": 0,

bridge-history-api/go.mod

@@ -10,13 +10,16 @@ require (
 	github.com/go-redis/redis/v8 v8.11.5
 	github.com/pressly/goose/v3 v3.16.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950 // It's a hotfix for the header hash incompatibility issue, pls change this with caution
+	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.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
 	github.com/VictoriaMetrics/fastcache v1.12.2 // indirect
@@ -90,7 +93,6 @@ 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.20250226072559-f8a8d3898f54 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect
 	github.com/sethvargo/go-retry v0.2.4 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect

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

@@ -30,9 +30,14 @@ type FetcherConfig struct {
 	ScrollChainAddr          string `json:"ScrollChainAddr"`
 	GatewayRouterAddr        string `json:"GatewayRouterAddr"`
 	MessageQueueAddr         string `json:"MessageQueueAddr"`
+	MessageQueueV2Addr       string `json:"MessageQueueV2Addr"`
 	BatchBridgeGatewayAddr   string `json:"BatchBridgeGatewayAddr"`
 	GasTokenGatewayAddr      string `json:"GasTokenGatewayAddr"`
 	WrappedTokenGatewayAddr  string `json:"WrappedTokenGatewayAddr"`
+
+	BeaconNodeAPIEndpoint  string `json:"BeaconNodeAPIEndpoint"`
+	BlobScanAPIEndpoint    string `json:"BlobScanAPIEndpoint"`
+	BlockNativeAPIEndpoint string `json:"BlockNativeAPIEndpoint"`
 }
 
 // RedisConfig redis config

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

@@ -2,6 +2,7 @@ package fetcher
 
 import (
 	"context"
+	"fmt"
 	"math/big"
 	"time"
 
@@ -10,6 +11,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/rollup/da_syncer/blob_client"
 	"gorm.io/gorm"
 
 	"scroll-tech/bridge-history-api/internal/config"
@@ -35,13 +37,32 @@ type L1MessageFetcher struct {
 }
 
 // NewL1MessageFetcher creates a new L1MessageFetcher instance.
-func NewL1MessageFetcher(ctx context.Context, cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client) *L1MessageFetcher {
+func NewL1MessageFetcher(ctx context.Context, cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client) (*L1MessageFetcher, error) {
+	blobClient := blob_client.NewBlobClients()
+	if cfg.BeaconNodeAPIEndpoint != "" {
+		beaconNodeClient, err := blob_client.NewBeaconNodeClient(cfg.BeaconNodeAPIEndpoint)
+		if err != nil {
+			log.Warn("failed to create BeaconNodeClient", "err", err)
+		} else {
+			blobClient.AddBlobClient(beaconNodeClient)
+		}
+	}
+	if cfg.BlobScanAPIEndpoint != "" {
+		blobClient.AddBlobClient(blob_client.NewBlobScanClient(cfg.BlobScanAPIEndpoint))
+	}
+	if cfg.BlockNativeAPIEndpoint != "" {
+		blobClient.AddBlobClient(blob_client.NewBlockNativeClient(cfg.BlockNativeAPIEndpoint))
+	}
+	if blobClient.Size() == 0 {
+		return nil, fmt.Errorf("no blob client is configured")
+	}
+
 	c := &L1MessageFetcher{
 		ctx:              ctx,
 		cfg:              cfg,
 		client:           client,
 		eventUpdateLogic: logic.NewEventUpdateLogic(db, true),
-		l1FetcherLogic:   logic.NewL1FetcherLogic(cfg, db, client),
+		l1FetcherLogic:   logic.NewL1FetcherLogic(cfg, db, client, blobClient),
 	}
 
 	reg := prometheus.DefaultRegisterer
@@ -58,7 +79,7 @@ func NewL1MessageFetcher(ctx context.Context, cfg *config.FetcherConfig, db *gor
 		Help: "Latest blockchain height the L1 message fetcher has synced with.",
 	})
 
-	return c
+	return c, nil
 }
 
 // Start starts the L1 message fetching process.

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

@@ -2,13 +2,16 @@ package logic
 
 import (
 	"context"
+	"fmt"
 	"math/big"
 
+	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/rollup/da_syncer/blob_client"
 
 	backendabi "scroll-tech/bridge-history-api/abi"
 	"scroll-tech/bridge-history-api/internal/config"
@@ -19,15 +22,17 @@ import (
 
 // L1EventParser the l1 event parser
 type L1EventParser struct {
-	cfg    *config.FetcherConfig
-	client *ethclient.Client
+	cfg        *config.FetcherConfig
+	client     *ethclient.Client
+	blobClient blob_client.BlobClient
 }
 
 // NewL1EventParser creates l1 event parser
-func NewL1EventParser(cfg *config.FetcherConfig, client *ethclient.Client) *L1EventParser {
+func NewL1EventParser(cfg *config.FetcherConfig, client *ethclient.Client, blobClient blob_client.BlobClient) *L1EventParser {
 	return &L1EventParser{
-		cfg:    cfg,
-		client: client,
+		cfg:        cfg,
+		client:     client,
+		blobClient: blobClient,
 	}
 }
 
@@ -232,7 +237,21 @@ func (e *L1EventParser) ParseL1SingleCrossChainEventLogs(ctx context.Context, lo
 }
 
 // ParseL1BatchEventLogs parses L1 watched batch events.
-func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.Log, client *ethclient.Client) ([]*orm.BatchEvent, error) {
+func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.Log, client *ethclient.Client, blockTimestampsMap map[uint64]uint64) ([]*orm.BatchEvent, error) {
+	// Since multiple CommitBatch events per transaction is introduced >= CodecV7,
+	// with one transaction carrying multiple blobs,
+	// each CommitBatch event corresponds to a blob containing block range data.
+	// To correctly process these events, we need to:
+	// 1. Parsing the associated blob data to extract the block range for each event
+	// 2. Tracking the parent batch hash for each processed CommitBatch event, to:
+	//   - Validate the batch hash, since parent batch hash is needed to calculate the batch hash
+	//   - Derive the index of the current batch by the number of parent batch hashes tracked
+	// In commitBatches and commitAndFinalizeBatch, the parent batch hash is passed in calldata,
+	// so that we can use it to get the first batch's parent batch hash, and derive the rest.
+	// The index map serves this purpose with:
+	// 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)
 	var l1BatchEvents []*orm.BatchEvent
 	for _, vlog := range logs {
 		switch vlog.Topics[0] {
@@ -247,11 +266,59 @@ func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.
 				log.Error("Failed to get commit batch tx or the tx is still pending", "err", err, "isPending", isPending)
 				return nil, err
 			}
-			startBlock, endBlock, err := utils.GetBatchRangeFromCalldata(commitTx.Data())
+			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)
 				return nil, err
 			}
+			if version >= 7 { // It's a batch with version >= 7.
+				codec, err := encoding.CodecFromVersion(encoding.CodecVersion(version))
+				if err != nil {
+					return nil, fmt.Errorf("unsupported codec version: %v, err: %w", version, err)
+				}
+
+				// we append the batch hash to the slice for the current commit transaction after processing the batch.
+				// that means the current index of the batch within the transaction is len(txBlobIndexMap[vlog.TxHash]).
+				currentIndex := len(txBlobIndexMap[vlog.TxHash])
+				if currentIndex >= len(commitTx.BlobHashes()) {
+					return nil, fmt.Errorf("commit transaction %s has %d blobs, but trying to access index %d (batch index %d)",
+						vlog.TxHash.String(), len(commitTx.BlobHashes()), currentIndex, event.BatchIndex.Uint64())
+				}
+				blobVersionedHash := commitTx.BlobHashes()[currentIndex]
+
+				// validate the batch hash
+				var parentBatchHash common.Hash
+				if currentIndex == 0 {
+					parentBatchHash, err = utils.GetParentBatchHashFromCalldata(commitTx.Data())
+					if err != nil {
+						return nil, fmt.Errorf("failed to get parent batch header from calldata, tx hash: %s, err: %w", vlog.TxHash.String(), err)
+					}
+				} else {
+					// here we need to subtract 1 from the current index to get the parent batch hash.
+					parentBatchHash = txBlobIndexMap[vlog.TxHash][currentIndex-1]
+				}
+				calculatedBatch, err := codec.NewDABatchFromParams(event.BatchIndex.Uint64(), blobVersionedHash, parentBatchHash)
+				if err != nil {
+					return nil, fmt.Errorf("failed to create new DA batch from params, batch index: %d, err: %w", event.BatchIndex.Uint64(), err)
+				}
+				if calculatedBatch.Hash() != event.BatchHash {
+					return nil, fmt.Errorf("batch hash mismatch for batch %d, expected: %s, got: %s", event.BatchIndex, event.BatchHash.String(), calculatedBatch.Hash().String())
+				}
+
+				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)
+				}
+				if len(blocks) == 0 {
+					return nil, fmt.Errorf("no blocks found in the blob, blobVersionedHash: %s, block number: %d, blob index: %d",
+						blobVersionedHash.String(), vlog.BlockNumber, currentIndex)
+				}
+				startBlock = blocks[0].Number()
+				endBlock = blocks[len(blocks)-1].Number()
+
+				txBlobIndexMap[vlog.TxHash] = append(txBlobIndexMap[vlog.TxHash], event.BatchHash)
+			}
 			l1BatchEvents = append(l1BatchEvents, &orm.BatchEvent{
 				BatchStatus:      int(btypes.BatchStatusTypeCommitted),
 				BatchIndex:       event.BatchIndex.Uint64(),
@@ -260,8 +327,8 @@ func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.
 				EndBlockNumber:   endBlock,
 				L1BlockNumber:    vlog.BlockNumber,
 			})
-		case backendabi.L1RevertBatchEventSig:
-			event := backendabi.L1RevertBatchEvent{}
+		case backendabi.L1RevertBatchV0EventSig:
+			event := backendabi.L1RevertBatchV0Event{}
 			if err := utils.UnpackLog(backendabi.IScrollChainABI, &event, "RevertBatch", vlog); err != nil {
 				log.Error("Failed to unpack RevertBatch event", "err", err)
 				return nil, err
@@ -272,6 +339,19 @@ func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.
 				BatchHash:     event.BatchHash.String(),
 				L1BlockNumber: vlog.BlockNumber,
 			})
+		case backendabi.L1RevertBatchV7EventSig:
+			event := backendabi.L1RevertBatchV7Event{}
+			if err := utils.UnpackLog(backendabi.IScrollChainABI, &event, "RevertBatch0", vlog); err != nil {
+				log.Error("Failed to unpack RevertBatch event", "err", err)
+				return nil, err
+			}
+			for i := event.StartBatchIndex.Uint64(); i <= event.FinishBatchIndex.Uint64(); i++ {
+				l1BatchEvents = append(l1BatchEvents, &orm.BatchEvent{
+					BatchStatus:   int(btypes.BatchStatusTypeReverted),
+					BatchIndex:    i,
+					L1BlockNumber: vlog.BlockNumber,
+				})
+			}
 		case backendabi.L1FinalizeBatchEventSig:
 			event := backendabi.L1FinalizeBatchEvent{}
 			if err := utils.UnpackLog(backendabi.IScrollChainABI, &event, "FinalizeBatch", vlog); err != nil {
@@ -389,3 +469,27 @@ func getRealFromAddress(ctx context.Context, eventSender common.Address, eventMe
 	}
 	return sender.String(), nil
 }
+
+func (e *L1EventParser) getBatchBlockRangeFromBlob(ctx context.Context, codec encoding.Codec, blobVersionedHash common.Hash, l1BlockTime uint64) ([]encoding.DABlock, error) {
+	blob, err := e.blobClient.GetBlobByVersionedHashAndBlockTime(ctx, blobVersionedHash, l1BlockTime)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get blob %s: %w", blobVersionedHash.Hex(), err)
+	}
+	if blob == nil {
+		return nil, fmt.Errorf("blob %s not found", blobVersionedHash.Hex())
+	}
+
+	blobPayload, err := codec.DecodeBlob(blob)
+	if err != nil {
+		return nil, fmt.Errorf("blob %s decode error: %w", blobVersionedHash.Hex(), err)
+	}
+
+	blocks := blobPayload.Blocks()
+	if len(blocks) == 0 {
+		return nil, fmt.Errorf("empty blocks in blob %s", blobVersionedHash.Hex())
+	}
+
+	log.Debug("Successfully processed blob", "blobVersionedHash", blobVersionedHash.Hex(), "blocksCount", len(blocks))
+
+	return blocks, nil
+}

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

@@ -11,6 +11,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/rollup/da_syncer/blob_client"
 	"gorm.io/gorm"
 
 	backendabi "scroll-tech/bridge-history-api/abi"
@@ -49,7 +50,7 @@ type L1FetcherLogic struct {
 }
 
 // NewL1FetcherLogic creates L1 fetcher logic
-func NewL1FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client) *L1FetcherLogic {
+func NewL1FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client, blobClient blob_client.BlobClient) *L1FetcherLogic {
 	addressList := []common.Address{
 		common.HexToAddress(cfg.StandardERC20GatewayAddr),
 		common.HexToAddress(cfg.CustomERC20GatewayAddr),
@@ -119,6 +120,10 @@ func NewL1FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient
 		gatewayList = append(gatewayList, common.HexToAddress(cfg.WrappedTokenGatewayAddr))
 	}
 
+	if common.HexToAddress(cfg.MessageQueueV2Addr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.MessageQueueV2Addr))
+	}
+
 	log.Info("L1 Fetcher configured with the following address list", "addresses", addressList, "gateways", gatewayList)
 
 	f := &L1FetcherLogic{
@@ -129,7 +134,7 @@ func NewL1FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient
 		client:          client,
 		addressList:     addressList,
 		gatewayList:     gatewayList,
-		parser:          NewL1EventParser(cfg, client),
+		parser:          NewL1EventParser(cfg, client, blobClient),
 	}
 
 	reg := prometheus.DefaultRegisterer
@@ -168,14 +173,10 @@ func (f *L1FetcherLogic) getBlocksAndDetectReorg(ctx context.Context, from, to u
 	return false, 0, lastBlockHash, blocks, nil
 }
 
-func (f *L1FetcherLogic) getRevertedTxs(ctx context.Context, from, to uint64, blocks []*types.Block) (map[uint64]uint64, []*orm.CrossMessage, error) {
+func (f *L1FetcherLogic) getRevertedTxs(ctx context.Context, from, to uint64, blocks []*types.Block) ([]*orm.CrossMessage, error) {
 	var l1RevertedTxs []*orm.CrossMessage
-	blockTimestampsMap := make(map[uint64]uint64)
-
 	for i := from; i <= to; i++ {
 		block := blocks[i-from]
-		blockTimestampsMap[block.NumberU64()] = block.Time()
-
 		for _, tx := range block.Transactions() {
 			// Gateways: L1 deposit.
 			// Messenger: L1 deposit retry (replayMessage), L1 deposit refund (dropMessage), L2 withdrawal's claim (relayMessageWithProof).
@@ -187,7 +188,7 @@ func (f *L1FetcherLogic) getRevertedTxs(ctx context.Context, from, to uint64, bl
 			receipt, receiptErr := f.client.TransactionReceipt(ctx, tx.Hash())
 			if receiptErr != nil {
 				log.Error("Failed to get transaction receipt", "txHash", tx.Hash().String(), "err", receiptErr)
-				return nil, nil, receiptErr
+				return nil, receiptErr
 			}
 
 			// Check if the transaction is failed
@@ -199,7 +200,7 @@ func (f *L1FetcherLogic) getRevertedTxs(ctx context.Context, from, to uint64, bl
 			sender, senderErr := signer.Sender(tx)
 			if senderErr != nil {
 				log.Error("get sender failed", "chain id", tx.ChainId().Uint64(), "tx hash", tx.Hash().String(), "err", senderErr)
-				return nil, nil, senderErr
+				return nil, senderErr
 			}
 
 			l1RevertedTxs = append(l1RevertedTxs, &orm.CrossMessage{
@@ -213,7 +214,7 @@ func (f *L1FetcherLogic) getRevertedTxs(ctx context.Context, from, to uint64, bl
 			})
 		}
 	}
-	return blockTimestampsMap, l1RevertedTxs, nil
+	return l1RevertedTxs, nil
 }
 
 func (f *L1FetcherLogic) l1FetcherLogs(ctx context.Context, from, to uint64) ([]types.Log, error) {
@@ -224,7 +225,7 @@ func (f *L1FetcherLogic) l1FetcherLogs(ctx context.Context, from, to uint64) ([]
 		Topics:    make([][]common.Hash, 1),
 	}
 
-	query.Topics[0] = make([]common.Hash, 16)
+	query.Topics[0] = make([]common.Hash, 17)
 	query.Topics[0][0] = backendabi.L1DepositETHSig
 	query.Topics[0][1] = backendabi.L1DepositERC20Sig
 	query.Topics[0][2] = backendabi.L1DepositERC721Sig
@@ -233,14 +234,15 @@ func (f *L1FetcherLogic) l1FetcherLogs(ctx context.Context, from, to uint64) ([]
 	query.Topics[0][5] = backendabi.L1RelayedMessageEventSig
 	query.Topics[0][6] = backendabi.L1FailedRelayedMessageEventSig
 	query.Topics[0][7] = backendabi.L1CommitBatchEventSig
-	query.Topics[0][8] = backendabi.L1RevertBatchEventSig
-	query.Topics[0][9] = backendabi.L1FinalizeBatchEventSig
-	query.Topics[0][10] = backendabi.L1QueueTransactionEventSig
-	query.Topics[0][11] = backendabi.L1DequeueTransactionEventSig
-	query.Topics[0][12] = backendabi.L1DropTransactionEventSig
-	query.Topics[0][13] = backendabi.L1ResetDequeuedTransactionEventSig
-	query.Topics[0][14] = backendabi.L1BridgeBatchDepositSig
-	query.Topics[0][15] = backendabi.L1DepositWrappedTokenSig
+	query.Topics[0][8] = backendabi.L1RevertBatchV0EventSig
+	query.Topics[0][9] = backendabi.L1RevertBatchV7EventSig
+	query.Topics[0][10] = backendabi.L1FinalizeBatchEventSig
+	query.Topics[0][11] = backendabi.L1QueueTransactionEventSig
+	query.Topics[0][12] = backendabi.L1DequeueTransactionEventSig
+	query.Topics[0][13] = backendabi.L1DropTransactionEventSig
+	query.Topics[0][14] = backendabi.L1ResetDequeuedTransactionEventSig
+	query.Topics[0][15] = backendabi.L1BridgeBatchDepositSig
+	query.Topics[0][16] = backendabi.L1DepositWrappedTokenSig
 
 	eventLogs, err := f.client.FilterLogs(ctx, query)
 	if err != nil {
@@ -264,12 +266,18 @@ func (f *L1FetcherLogic) L1Fetcher(ctx context.Context, from, to uint64, lastBlo
 		return isReorg, reorgHeight, blockHash, nil, nil
 	}
 
-	blockTimestampsMap, l1RevertedTxs, err := f.getRevertedTxs(ctx, from, to, blocks)
+	l1RevertedTxs, err := f.getRevertedTxs(ctx, from, to, blocks)
 	if err != nil {
 		log.Error("L1Fetcher getRevertedTxs failed", "from", from, "to", to, "error", err)
 		return false, 0, common.Hash{}, nil, err
 	}
 
+	// Map block number to block timestamp to avoid fetching block header multiple times to get block timestamp.
+	blockTimestampsMap := make(map[uint64]uint64)
+	for _, block := range blocks {
+		blockTimestampsMap[block.NumberU64()] = block.Time()
+	}
+
 	eventLogs, err := f.l1FetcherLogs(ctx, from, to)
 	if err != nil {
 		log.Error("L1Fetcher l1FetcherLogs failed", "from", from, "to", to, "error", err)
@@ -282,7 +290,7 @@ func (f *L1FetcherLogic) L1Fetcher(ctx context.Context, from, to uint64, lastBlo
 		return false, 0, common.Hash{}, nil, err
 	}
 
-	l1BatchEvents, err := f.parser.ParseL1BatchEventLogs(ctx, eventLogs, f.client)
+	l1BatchEvents, err := f.parser.ParseL1BatchEventLogs(ctx, eventLogs, f.client, blockTimestampsMap)
 	if err != nil {
 		log.Error("failed to parse L1 batch event logs", "from", from, "to", to, "err", err)
 		return false, 0, common.Hash{}, nil, err

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

@@ -117,7 +117,7 @@ func (c *BatchEvent) InsertOrUpdateBatchEvents(ctx context.Context, l1BatchEvent
 			}
 		case btypes.BatchStatusTypeReverted:
 			db = db.Where("batch_index = ?", l1BatchEvent.BatchIndex)
-			db = db.Where("batch_hash = ?", l1BatchEvent.BatchHash)
+			db = db.Where("batch_status != ?", btypes.BatchStatusTypeFinalized)
 			updateFields["batch_status"] = btypes.BatchStatusTypeReverted
 			if err := db.Updates(updateFields).Error; err != nil {
 				return fmt.Errorf("failed to update batch event, error: %w", 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 = ?", types.TxStatusTypeSent)
+	db = db.Where("tx_status in (?)", []types.TxStatusType{types.TxStatusTypeSent, types.TxStatusTypeFailedRelayed, types.TxStatusTypeRelayTxReverted})
 	db = db.Where("sender = ?", sender)
 	db = db.Order("block_timestamp desc")
 	db = db.Limit(500)

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

@@ -66,25 +66,26 @@ func ComputeMessageHash(
 	return common.BytesToHash(crypto.Keccak256(data))
 }
 
-// GetBatchRangeFromCalldata find the block range from calldata, both inclusive.
-func GetBatchRangeFromCalldata(txData []byte) (uint64, uint64, error) {
+// GetBatchVersionAndBlockRangeFromCalldata find the block range from calldata, both inclusive.
+func GetBatchVersionAndBlockRangeFromCalldata(txData []byte) (uint8, uint64, uint64, error) {
 	const methodIDLength = 4
 	if len(txData) < methodIDLength {
-		return 0, 0, fmt.Errorf("transaction data is too short, length of tx data: %v, minimum length required: %v", len(txData), methodIDLength)
+		return 0, 0, 0, fmt.Errorf("transaction data is too short, length of tx data: %v, minimum length required: %v", len(txData), methodIDLength)
 	}
 	method, err := backendabi.IScrollChainABI.MethodById(txData[:methodIDLength])
 	if err != nil {
-		return 0, 0, fmt.Errorf("failed to get method by ID, ID: %v, err: %w", txData[:methodIDLength], err)
+		return 0, 0, 0, fmt.Errorf("failed to get method by ID, ID: %v, err: %w", txData[:methodIDLength], err)
 	}
 	values, err := method.Inputs.Unpack(txData[methodIDLength:])
 	if err != nil {
-		return 0, 0, fmt.Errorf("failed to unpack transaction data using ABI, tx data: %v, err: %w", txData, err)
+		return 0, 0, 0, fmt.Errorf("failed to unpack transaction data using ABI, tx data: %v, err: %w", txData, err)
 	}
 
 	var chunks [][]byte
+	var version uint8
 
 	if method.Name == "importGenesisBatch" {
-		return 0, 0, nil
+		return 0, 0, 0, nil
 	} else if method.Name == "commitBatch" {
 		type commitBatchArgs struct {
 			Version                uint8
@@ -95,11 +96,11 @@ func GetBatchRangeFromCalldata(txData []byte) (uint64, uint64, error) {
 
 		var args commitBatchArgs
 		if err = method.Inputs.Copy(&args, values); err != nil {
-			return 0, 0, fmt.Errorf("failed to decode calldata into commitBatch args, values: %+v, err: %w", values, err)
+			return 0, 0, 0, fmt.Errorf("failed to decode calldata into commitBatch args, values: %+v, err: %w", values, err)
 		}
 
 		chunks = args.Chunks
-
+		version = args.Version
 	} else if method.Name == "commitBatchWithBlobProof" {
 		type commitBatchWithBlobProofArgs struct {
 			Version                uint8
@@ -111,10 +112,22 @@ func GetBatchRangeFromCalldata(txData []byte) (uint64, uint64, error) {
 
 		var args commitBatchWithBlobProofArgs
 		if err = method.Inputs.Copy(&args, values); err != nil {
-			return 0, 0, fmt.Errorf("failed to decode calldata into commitBatchWithBlobProofArgs args, values: %+v, err: %w", values, err)
+			return 0, 0, 0, fmt.Errorf("failed to decode calldata into commitBatchWithBlobProofArgs args, values: %+v, err: %w", values, err)
 		}
 
 		chunks = args.Chunks
+		version = args.Version
+	} else if method.Name == "commitBatches" || method.Name == "commitAndFinalizeBatch" {
+		if len(values) < 3 {
+			return 0, 0, 0, fmt.Errorf("insufficient arguments for %s, expected 3, got %d", method.Name, len(values))
+		}
+
+		var ok bool
+		version, ok = values[0].(uint8)
+		if !ok {
+			return 0, 0, 0, fmt.Errorf("invalid version type: %T", values[0])
+		}
+		return version, 0, 0, nil
 	}
 
 	var startBlock uint64
@@ -124,7 +137,7 @@ func GetBatchRangeFromCalldata(txData []byte) (uint64, uint64, error) {
 	// |   1 byte   | 60 bytes | ... | 60 bytes |
 	// | num blocks |  block 1 | ... |  block n |
 	if len(chunks) == 0 {
-		return 0, 0, errors.New("invalid chunks")
+		return 0, 0, 0, errors.New("invalid chunks")
 	}
 	chunk := chunks[0]
 	block := chunk[1:61] // first block in chunk
@@ -135,7 +148,36 @@ func GetBatchRangeFromCalldata(txData []byte) (uint64, uint64, error) {
 	block = chunk[1+lastBlockIndex*60 : 1+lastBlockIndex*60+60] // last block in chunk
 	finishBlock = binary.BigEndian.Uint64(block[0:8])
 
-	return startBlock, finishBlock, err
+	return version, startBlock, finishBlock, err
+}
+
+// GetParentBatchHashFromCalldata gets the parent batch hash from calldata.
+// It only supports commitBatches and commitAndFinalizeBatch, which only accept batches >= v7.
+func GetParentBatchHashFromCalldata(txData []byte) (common.Hash, error) {
+	const methodIDLength = 4
+	if len(txData) < methodIDLength {
+		return common.Hash{}, fmt.Errorf("transaction data is too short, length of tx data: %v, minimum length required: %v", len(txData), methodIDLength)
+	}
+	method, err := backendabi.IScrollChainABI.MethodById(txData[:methodIDLength])
+	if err != nil {
+		return common.Hash{}, fmt.Errorf("failed to get method by ID, ID: %v, err: %w", txData[:methodIDLength], err)
+	}
+	values, err := method.Inputs.Unpack(txData[methodIDLength:])
+	if err != nil {
+		return common.Hash{}, fmt.Errorf("failed to unpack transaction data using ABI, tx data: %v, err: %w", txData, err)
+	}
+
+	if method.Name == "commitBatches" || method.Name == "commitAndFinalizeBatch" {
+		if len(values) < 3 {
+			return common.Hash{}, fmt.Errorf("insufficient arguments for %s, expected 3, got %d", method.Name, len(values))
+		}
+		parentBatchHash, ok := values[1].([32]byte)
+		if !ok {
+			return common.Hash{}, fmt.Errorf("invalid parentBatchHash type: %T", values[1])
+		}
+		return common.BytesToHash(parentBatchHash[:]), nil
+	}
+	return common.Hash{}, fmt.Errorf("method %s does not support parent batch header", method.Name)
 }
 
 // GetBlocksInRange gets a batch of blocks for a block range [start, end] inclusive.

build/.golangci.yml

@@ -91,7 +91,7 @@ linters-settings:
     #local-prefixes: github.com/org/project
   gocyclo:
     # minimal code complexity to report, 30 by default (but we recommend 10-20)
-    min-complexity: 30
+    min-complexity: 40
   maligned:
     # print struct with more effective memory layout or not, false by default
     suggest-new: true
@@ -254,6 +254,9 @@ issues:
     - linters:
         - wsl
       text: "expressions should not be cuddled with declarations or returns"
+    - linters:
+        - govet
+      text: 'shadow: declaration of "(err|ctx)" shadows declaration at'
 
   # Independently from option `exclude` we use default exclude patterns,
   # it can be disabled by this option. To list all

build/dockerfiles/blob_uploader.Dockerfile

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

build/dockerfiles/blob_uploader.Dockerfile.dockerignore

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

build/dockerfiles/bridgehistoryapi-api.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
+FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as base
 
 WORKDIR /src
 COPY go.mod* ./

build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
+FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as base
 
 WORKDIR /src
 COPY ./bridge-history-api/go.* ./

build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
+FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as base
 
 WORKDIR /src
 COPY go.mod* ./

build/dockerfiles/coordinator-api.Dockerfile

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

build/dockerfiles/coordinator-api/checkout_all.sh

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

build/dockerfiles/coordinator-api/clone_openvm_gpu.sh

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

build/dockerfiles/coordinator-api/clone_openvm_stark_gpu.sh

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

build/dockerfiles/coordinator-api/clone_plonky3_gpu.sh

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

build/dockerfiles/coordinator-api/config.toml

@@ -0,0 +1,92 @@
+# openvm
+# same order and features as zkvm-prover/Cargo.toml.gpu
+[patch."ssh://git@github.com/scroll-tech/openvm-gpu.git"]
+openvm = { path = "/openvm-gpu/crates/toolchain/openvm", default-features = false }
+openvm-algebra-complex-macros = { path = "/openvm-gpu/extensions/algebra/complex-macros", default-features = false }
+openvm-algebra-guest = { path = "/openvm-gpu/extensions/algebra/guest", default-features = false }
+openvm-bigint-guest = { path = "/openvm-gpu/extensions/bigint/guest", default-features = false }
+openvm-build = { path = "/openvm-gpu/crates/toolchain/build", default-features = false }
+openvm-circuit = { path = "/openvm-gpu/crates/vm", default-features = false }
+openvm-custom-insn = { path = "/openvm-gpu/crates/toolchain/custom_insn", default-features = false }
+openvm-continuations = { path = "/openvm-gpu/crates/continuations", default-features = false }
+openvm-ecc-guest = { path = "/openvm-gpu/extensions/ecc/guest", default-features = false }
+openvm-instructions ={ path = "/openvm-gpu/crates/toolchain/instructions", default-features = false }
+openvm-keccak256-guest = { path = "/openvm-gpu/extensions/keccak256/guest", default-features = false }
+openvm-native-circuit = { path = "/openvm-gpu/extensions/native/circuit", default-features = false }
+openvm-native-compiler = { path = "/openvm-gpu/extensions/native/compiler", default-features = false }
+openvm-native-recursion = { path = "/openvm-gpu/extensions/native/recursion", default-features = false }
+openvm-native-transpiler = { path = "/openvm-gpu/extensions/native/transpiler", default-features = false }
+openvm-pairing-guest = { path = "/openvm-gpu/extensions/pairing/guest", default-features = false }
+openvm-rv32im-guest = { path = "/openvm-gpu/extensions/rv32im/guest", default-features = false }
+openvm-rv32im-transpiler = { path = "/openvm-gpu/extensions/rv32im/transpiler", default-features = false }
+openvm-sdk = { path = "/openvm-gpu/crates/sdk", default-features = false, features = ["parallel", "bench-metrics", "evm-prove"] }
+openvm-sha256-guest = { path = "/openvm-gpu/extensions/sha256/guest", default-features = false }
+openvm-transpiler = { path = "/openvm-gpu/crates/toolchain/transpiler", default-features = false }
+
+# stark-backend
+[patch."https://github.com/openvm-org/stark-backend.git"]
+openvm-stark-backend = { path = "/openvm-stark-gpu/crates/stark-backend", features = ["gpu"] }
+openvm-stark-sdk = { path = "/openvm-stark-gpu/crates/stark-sdk", features = ["gpu"] }
+
+[patch."ssh://git@github.com/scroll-tech/openvm-stark-gpu.git"]
+openvm-stark-backend = { path = "/openvm-stark-gpu/crates/stark-backend", features = ["gpu"] }
+openvm-stark-sdk = { path = "/openvm-stark-gpu/crates/stark-sdk", features = ["gpu"] }
+
+# plonky3
+[patch."https://github.com/Plonky3/Plonky3.git"]
+p3-air = { path = "/plonky3-gpu/air" }
+p3-field = { path = "/plonky3-gpu/field" }
+p3-commit = { path = "/plonky3-gpu/commit" }
+p3-matrix = { path = "/plonky3-gpu/matrix" }
+p3-baby-bear = { path = "/plonky3-gpu/baby-bear" }
+p3-koala-bear = { path = "/plonky3-gpu/koala-bear" }
+p3-util = { path = "/plonky3-gpu/util" }
+p3-challenger = { path = "/plonky3-gpu/challenger" }
+p3-dft = { path = "/plonky3-gpu/dft" }
+p3-fri = { path = "/plonky3-gpu/fri" }
+p3-goldilocks = { path = "/plonky3-gpu/goldilocks" }
+p3-keccak = { path = "/plonky3-gpu/keccak" }
+p3-keccak-air = { path = "/plonky3-gpu/keccak-air" }
+p3-blake3 = { path = "/plonky3-gpu/blake3" }
+p3-mds = { path = "/plonky3-gpu/mds" }
+p3-monty-31 = { path = "/plonky3-gpu/monty-31" }
+p3-merkle-tree = { path = "/plonky3-gpu/merkle-tree" }
+p3-poseidon = { path = "/plonky3-gpu/poseidon" }
+p3-poseidon2 = { path = "/plonky3-gpu/poseidon2" }
+p3-poseidon2-air = { path = "/plonky3-gpu/poseidon2-air" }
+p3-symmetric = { path = "/plonky3-gpu/symmetric" }
+p3-uni-stark = { path = "/plonky3-gpu/uni-stark" }
+p3-maybe-rayon = { path = "/plonky3-gpu/maybe-rayon" }
+p3-bn254-fr = { path = "/plonky3-gpu/bn254-fr" }
+
+# gpu crates
+[patch."ssh://git@github.com/scroll-tech/plonky3-gpu.git"]
+p3-gpu-base = { path = "/plonky3-gpu/gpu-base" }
+p3-gpu-build = { path = "/plonky3-gpu/gpu-build" }
+p3-gpu-field = { path = "/plonky3-gpu/gpu-field" }
+p3-gpu-backend = { path = "/plonky3-gpu/gpu-backend" }
+p3-gpu-module = { path = "/plonky3-gpu/gpu-module" }
+p3-air = { path = "/plonky3-gpu/air" }
+p3-field = { path = "/plonky3-gpu/field" }
+p3-commit = { path = "/plonky3-gpu/commit" }
+p3-matrix = { path = "/plonky3-gpu/matrix" }
+p3-baby-bear = { path = "/plonky3-gpu/baby-bear" }
+p3-koala-bear = { path = "/plonky3-gpu/koala-bear" }
+p3-util = { path = "/plonky3-gpu/util" }
+p3-challenger = { path = "/plonky3-gpu/challenger" }
+p3-dft = { path = "/plonky3-gpu/dft" }
+p3-fri = { path = "/plonky3-gpu/fri" }
+p3-goldilocks = { path = "/plonky3-gpu/goldilocks" }
+p3-keccak = { path = "/plonky3-gpu/keccak" }
+p3-keccak-air = { path = "/plonky3-gpu/keccak-air" }
+p3-blake3 = { path = "/plonky3-gpu/blake3" }
+p3-mds = { path = "/plonky3-gpu/mds" }
+p3-monty-31 = { path = "/plonky3-gpu/monty-31" }
+p3-merkle-tree = { path = "/plonky3-gpu/merkle-tree" }
+p3-poseidon = { path = "/plonky3-gpu/poseidon" }
+p3-poseidon2 = { path = "/plonky3-gpu/poseidon2" }
+p3-poseidon2-air = { path = "/plonky3-gpu/poseidon2-air" }
+p3-symmetric = { path = "/plonky3-gpu/symmetric" }
+p3-uni-stark = { path = "/plonky3-gpu/uni-stark" }
+p3-maybe-rayon = { path = "/plonky3-gpu/maybe-rayon" }
+p3-bn254-fr = { path = "/plonky3-gpu/bn254-fr" }

build/dockerfiles/coordinator-api/gitconfig

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

build/dockerfiles/coordinator-cron.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
+FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as base
 
 WORKDIR /src
 COPY go.work* ./

build/dockerfiles/db_cli.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
+FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as base
 
 WORKDIR /src
 COPY go.work* ./

build/dockerfiles/gas_oracle.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
+FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as base
 
 WORKDIR /src
 COPY go.work* ./

build/dockerfiles/intermediate/cuda-go-rust-builder.Dockerfile

@@ -1,5 +1,5 @@
 ARG CUDA_VERSION=11.7.1
-ARG GO_VERSION=1.21
+ARG GO_VERSION=1.22.12
 ARG RUST_VERSION=nightly-2023-12-03
 ARG CARGO_CHEF_TAG=0.1.41
 
@@ -36,7 +36,7 @@ RUN if [ "$(uname -m)" = "x86_64" ]; then \
     else \
     echo "Unsupported architecture"; exit 1; \
     fi
-RUN wget https://go.dev/dl/go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz
-RUN tar -C /usr/local -xzf go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz
-RUN rm go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz && rm /tmp/arch
+RUN wget https://go.dev/dl/go${GO_VERSION}.linux-$(cat /tmp/arch).tar.gz
+RUN tar -C /usr/local -xzf go${GO_VERSION}.linux-$(cat /tmp/arch).tar.gz
+RUN rm go${GO_VERSION}.linux-$(cat /tmp/arch).tar.gz && rm /tmp/arch
 ENV PATH="/usr/local/go/bin:${PATH}"

build/dockerfiles/intermediate/go-rust-builder.Dockerfile

@@ -1,4 +1,4 @@
-ARG GO_VERSION=1.21
+ARG GO_VERSION=1.22.12
 ARG RUST_VERSION=nightly-2023-12-03
 ARG CARGO_CHEF_TAG=0.1.41
 
@@ -32,7 +32,7 @@ RUN if [ "$(uname -m)" = "x86_64" ]; then \
     else \
     echo "Unsupported architecture"; exit 1; \
     fi
-RUN wget https://go.dev/dl/go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz
-RUN tar -C /usr/local -xzf go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz
-RUN rm go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz && rm /tmp/arch
+RUN wget https://go.dev/dl/go${GO_VERSION}.linux-$(cat /tmp/arch).tar.gz
+RUN tar -C /usr/local -xzf go${GO_VERSION}.linux-$(cat /tmp/arch).tar.gz
+RUN rm go${GO_VERSION}.linux-$(cat /tmp/arch).tar.gz && rm /tmp/arch
 ENV PATH="/usr/local/go/bin:${PATH}"

build/dockerfiles/rollup_relayer.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
+FROM scrolltech/go-rust-builder:go-1.22-rust-nightly-2023-12-03 as base
 
 WORKDIR /src
 COPY go.work* ./

common/database/db.go

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

common/libzkp/impl/Cargo.toml

@@ -14,8 +14,8 @@ ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
 tiny-keccak = { git = "https://github.com/scroll-tech/tiny-keccak", branch = "scroll-patch-v2.0.2-openvm-v1.0.0-rc.1" }
 
 [dependencies]
-euclid_prover = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.1.0-rc.6", package = "scroll-zkvm-prover" }
-euclid_verifier = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.1.0-rc.6", package = "scroll-zkvm-verifier" }
+euclid_prover = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.4.2", package = "scroll-zkvm-prover" }
+euclid_verifier = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.4.2", package = "scroll-zkvm-verifier" }
 
 base64 = "0.13.0"
 env_logger = "0.9.0"
@@ -32,3 +32,35 @@ opt-level = 3
 
 [profile.release]
 opt-level = 3
+
+[patch."https://github.com/openvm-org/stark-backend.git"]
+openvm-stark-backend = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "main", features = ["gpu"] }
+openvm-stark-sdk = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "main", features = ["gpu"] }
+
+[patch."https://github.com/Plonky3/Plonky3.git"]
+p3-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-field = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-commit = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-matrix = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-baby-bear = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", features = [
+    "nightly-features",
+], tag = "v0.2.0" }
+p3-koala-bear = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-util = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-challenger = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-dft = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-fri = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-goldilocks = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-keccak = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-keccak-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-blake3 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-mds = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-merkle-tree = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-monty-31 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-poseidon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-poseidon2 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-poseidon2-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-symmetric = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-uni-stark = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-maybe-rayon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" } # the "parallel" feature is NOT on by default to allow single-threaded benchmarking
+p3-bn254-fr = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }

common/libzkp/impl/src/lib.rs

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

common/libzkp/impl/src/verifier.rs

@@ -1,9 +1,8 @@
 #![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};
 
@@ -29,27 +28,23 @@ pub trait ProofVerifier {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct CircuitConfig {
     pub fork_name: String,
-    pub params_path: String,
     pub assets_path: String,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct VerifierConfig {
-    pub low_version_circuit: CircuitConfig,
     pub high_version_circuit: CircuitConfig,
 }
 
 type HardForkName = String;
 
 struct VerifierPair(HardForkName, Rc<Box<dyn ProofVerifier>>);
-
-static mut VERIFIER_LOW: OnceCell<VerifierPair> = OnceCell::new();
 static mut VERIFIER_HIGH: OnceCell<VerifierPair> = OnceCell::new();
 
 pub fn init(config: VerifierConfig) {
-    let verifier = EuclidVerifier::new(&config.high_version_circuit.assets_path);
+    let verifier = EuclidV2Verifier::new(&config.high_version_circuit.assets_path);
     unsafe {
-        VERIFIER_LOW
+        VERIFIER_HIGH
             .set(VerifierPair(
                 config.high_version_circuit.fork_name,
                 Rc::new(Box::new(verifier)),
@@ -60,12 +55,6 @@ pub fn init(config: VerifierConfig) {
 
 pub fn get_verifier(fork_name: &str) -> Result<Rc<Box<dyn ProofVerifier>>> {
     unsafe {
-        if let Some(verifier) = VERIFIER_LOW.get() {
-            if verifier.0 == fork_name {
-                return Ok(verifier.1.clone());
-            }
-        }
-
         if let Some(verifier) = VERIFIER_HIGH.get() {
             if verifier.0 == fork_name {
                 return Ok(verifier.1.clone());

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

@@ -4,16 +4,16 @@ use anyhow::Result;
 
 use crate::utils::panic_catch;
 use euclid_prover::{BatchProof, BundleProof, ChunkProof};
-use euclid_verifier::verifier::{BatchVerifier, BundleVerifier, ChunkVerifier};
+use euclid_verifier::verifier::{BatchVerifier, BundleVerifierEuclidV2, ChunkVerifier};
 use std::{fs::File, path::Path};
 
-pub struct EuclidVerifier {
+pub struct EuclidV2Verifier {
     chunk_verifier: ChunkVerifier,
     batch_verifier: BatchVerifier,
-    bundle_verifier: BundleVerifier,
+    bundle_verifier: BundleVerifierEuclidV2,
 }
 
-impl EuclidVerifier {
+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");
@@ -24,13 +24,13 @@ impl EuclidVerifier {
                 .expect("Setting up chunk verifier"),
             batch_verifier: BatchVerifier::setup(&config, &exe, &verifier_bin)
                 .expect("Setting up batch verifier"),
-            bundle_verifier: BundleVerifier::setup(&config, &exe, &verifier_bin)
+            bundle_verifier: BundleVerifierEuclidV2::setup(&config, &exe, &verifier_bin)
                 .expect("Setting up bundle verifier"),
         }
     }
 }
 
-impl ProofVerifier for EuclidVerifier {
+impl ProofVerifier for EuclidV2Verifier {
     fn verify(&self, task_type: super::TaskType, proof: Vec<u8>) -> Result<bool> {
         panic_catch(|| match task_type {
             TaskType::Chunk => {

common/types/db.go

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

common/types/db_test.go

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

common/types/message/message.go

@@ -4,12 +4,16 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"math/big"
 
 	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/common/hexutil"
 )
 
 const (
-	euclidFork = "euclid"
+	EuclidV2Fork = "euclidV2"
+
+	EuclidV2ForkNameForProver = "euclidv2"
 )
 
 // ProofType represents the type of task.
@@ -39,185 +43,102 @@ const (
 	ProofTypeBundle
 )
 
-// ChunkTaskDetail is a type containing ChunkTask detail.
+// ChunkTaskDetail is a type containing ChunkTask detail for chunk task.
 type ChunkTaskDetail struct {
-	BlockHashes []common.Hash `json:"block_hashes"`
+	// use one of the string of "euclidv1" / "euclidv2"
+	ForkName         string        `json:"fork_name"`
+	BlockHashes      []common.Hash `json:"block_hashes"`
+	PrevMsgQueueHash common.Hash   `json:"prev_msg_queue_hash"`
+}
+
+// it is a hex encoded big with fixed length on 48 bytes
+type Byte48 struct {
+	hexutil.Big
+}
+
+func (e Byte48) MarshalText() ([]byte, error) {
+	i := e.ToInt()
+	// overrite encode big
+	if sign := i.Sign(); sign < 0 {
+		// sanity check
+		return nil, errors.New("Byte48 must be positive integer")
+	} else {
+		s := i.Text(16)
+		if len(s) > 96 {
+			return nil, errors.New("integer Exceed 384bit")
+		}
+		return []byte(fmt.Sprintf("0x%0*s", 96, s)), nil
+	}
+}
+
+func isString(input []byte) bool {
+	return len(input) >= 2 && input[0] == '"' && input[len(input)-1] == '"'
+}
+
+// hexutil.Big has limition of 256bit so we have to override it ...
+func (e *Byte48) UnmarshalJSON(input []byte) error {
+	if !isString(input) {
+		return errors.New("not hex string")
+	}
+
+	b, err := hexutil.Decode(string(input[1 : len(input)-1]))
+	if err != nil {
+		return err
+	}
+	if len(b) != 48 {
+		return fmt.Errorf("not a 48 bytes hex string: %d", len(b))
+	}
+	var dec big.Int
+	dec.SetBytes(b)
+	*e = Byte48{(hexutil.Big)(dec)}
+	return nil
 }
 
 // BatchTaskDetail is a type containing BatchTask detail.
 type BatchTaskDetail struct {
-	ChunkInfos  []*ChunkInfo `json:"chunk_infos"`
-	ChunkProofs []ChunkProof `json:"chunk_proofs"`
-	BatchHeader interface{}  `json:"batch_header"`
-	BlobBytes   []byte       `json:"blob_bytes"`
+	// use one of the string of "euclidv1" / "euclidv2"
+	ForkName        string              `json:"fork_name"`
+	ChunkInfos      []*ChunkInfo        `json:"chunk_infos"`
+	ChunkProofs     []*OpenVMChunkProof `json:"chunk_proofs"`
+	BatchHeader     interface{}         `json:"batch_header"`
+	BlobBytes       []byte              `json:"blob_bytes"`
+	KzgProof        Byte48              `json:"kzg_proof,omitempty"`
+	KzgCommitment   Byte48              `json:"kzg_commitment,omitempty"`
+	ChallengeDigest common.Hash         `json:"challenge_digest,omitempty"`
 }
 
 // BundleTaskDetail consists of all the information required to describe the task to generate a proof for a bundle of batches.
 type BundleTaskDetail struct {
-	BatchProofs []BatchProof `json:"batch_proofs"`
+	// use one of the string of "euclidv1" / "euclidv2"
+	ForkName    string              `json:"fork_name"`
+	BatchProofs []*OpenVMBatchProof `json:"batch_proofs"`
+	BundleInfo  *OpenVMBundleInfo   `json:"bundle_info,omitempty"`
 }
 
 // ChunkInfo is for calculating pi_hash for chunk
 type ChunkInfo struct {
-	ChainID       uint64      `json:"chain_id"`
-	PrevStateRoot common.Hash `json:"prev_state_root"`
-	PostStateRoot common.Hash `json:"post_state_root"`
-	WithdrawRoot  common.Hash `json:"withdraw_root"`
-	DataHash      common.Hash `json:"data_hash"`
-	IsPadding     bool        `json:"is_padding"`
-	TxBytes       []byte      `json:"tx_bytes"`
-	TxBytesHash   common.Hash `json:"tx_data_digest"`
+	ChainID            uint64           `json:"chain_id"`
+	PrevStateRoot      common.Hash      `json:"prev_state_root"`
+	PostStateRoot      common.Hash      `json:"post_state_root"`
+	WithdrawRoot       common.Hash      `json:"withdraw_root"`
+	DataHash           common.Hash      `json:"data_hash"`
+	IsPadding          bool             `json:"is_padding"`
+	TxBytes            []byte           `json:"tx_bytes"`
+	TxBytesHash        common.Hash      `json:"tx_data_digest"`
+	PrevMsgQueueHash   common.Hash      `json:"prev_msg_queue_hash"`
+	PostMsgQueueHash   common.Hash      `json:"post_msg_queue_hash"`
+	TxDataLength       uint64           `json:"tx_data_length"`
+	InitialBlockNumber uint64           `json:"initial_block_number"`
+	BlockCtxs          []BlockContextV2 `json:"block_ctxs"`
 }
 
-// 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:
-		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:
-		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:
-		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
+// BlockContextV2 is the block context for euclid v2
+type BlockContextV2 struct {
+	Timestamp uint64      `json:"timestamp"`
+	BaseFee   hexutil.Big `json:"base_fee"`
+	GasLimit  uint64      `json:"gas_limit"`
+	NumTxs    uint16      `json:"num_txs"`
+	NumL1Msgs uint16      `json:"num_l1_msgs"`
 }
 
 // Proof for flatten VM proof
@@ -254,12 +175,14 @@ func (p *OpenVMChunkProof) Proof() []byte {
 
 // OpenVMBatchInfo is for calculating pi_hash for batch header
 type OpenVMBatchInfo struct {
-	ParentBatchHash common.Hash `json:"parent_batch_hash"`
-	ParentStateRoot common.Hash `json:"parent_state_root"`
-	StateRoot       common.Hash `json:"state_root"`
-	WithdrawRoot    common.Hash `json:"withdraw_root"`
-	BatchHash       common.Hash `json:"batch_hash"`
-	ChainID         uint64      `json:"chain_id"`
+	ParentBatchHash  common.Hash `json:"parent_batch_hash"`
+	ParentStateRoot  common.Hash `json:"parent_state_root"`
+	StateRoot        common.Hash `json:"state_root"`
+	WithdrawRoot     common.Hash `json:"withdraw_root"`
+	BatchHash        common.Hash `json:"batch_hash"`
+	ChainID          uint64      `json:"chain_id"`
+	PrevMsgQueueHash common.Hash `json:"prev_msg_queue_hash"`
+	PostMsgQueueHash common.Hash `json:"post_msg_queue_hash"`
 }
 
 // BatchProof includes the proof info that are required for batch verification and rollup.
@@ -319,6 +242,7 @@ type OpenVMBundleInfo struct {
 	NumBatches    uint32      `json:"num_batches"`
 	PrevBatchHash common.Hash `json:"prev_batch_hash"`
 	BatchHash     common.Hash `json:"batch_hash"`
+	MsgQueueHash  common.Hash `json:"msg_queue_hash"`
 }
 
 // OpenVMBundleProof includes the proof info that are required for verification of a bundle of batch proofs.

common/types/message/message_test.go

@@ -0,0 +1,22 @@
+package message
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestBytes48(t *testing.T) {
+	ti := &Byte48{}
+	ti.UnmarshalText([]byte("0x1"))
+	if s, err := ti.MarshalText(); err == nil {
+		if len(s) != 98 {
+			panic(fmt.Sprintf("wrong str: %s", s))
+		}
+	}
+	ti.UnmarshalText([]byte("0x0"))
+	if s, err := ti.MarshalText(); err == nil {
+		if len(s) != 98 {
+			panic(fmt.Sprintf("wrong str: %s", s))
+		}
+	}
+}

common/utils/blob.go

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

common/utils/blob_test.go

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

common/utils/flags.go

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

common/version/version.go

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

coordinator/cmd/api/app/mock_app.go

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

coordinator/cmd/tool/tool.go

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

coordinator/conf/config.json

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

coordinator/go.mod

@@ -2,8 +2,6 @@ module scroll-tech/coordinator
 
 go 1.22
 
-toolchain go1.22.2
-
 require (
 	github.com/appleboy/gin-jwt/v2 v2.9.1
 	github.com/gin-gonic/gin v1.9.1
@@ -11,7 +9,7 @@ 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.20250310095435-012aaee6b435
+	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

coordinator/go.sum

@@ -177,8 +177,8 @@ github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/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/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=

coordinator/internal/config/config.go

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

coordinator/internal/config/config_test.go

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

coordinator/internal/controller/api/auth.go

@@ -46,7 +46,7 @@ func (a *AuthController) Login(c *gin.Context) (interface{}, error) {
 
 	hardForkNames, err := a.loginLogic.ProverHardForkName(&login)
 	if err != nil {
-		return "", fmt.Errorf("prover hard name failure:%w", err)
+		return "", fmt.Errorf("prover hard fork name failure:%w", err)
 	}
 
 	// check the challenge is used, if used, return failure

coordinator/internal/controller/api/controller.go

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

coordinator/internal/logic/auth/login.go

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

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"math/big"
 	"time"
 
 	"github.com/gin-gonic/gin"
@@ -11,6 +12,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/common/hexutil"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
@@ -77,6 +79,7 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	}
 
 	var batchTask *orm.Batch
+	var hardForkName string
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpBatchTask *orm.Batch
@@ -101,16 +104,26 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 			return nil, nil
 		}
 
+		taskCtx.taskType = message.ProofTypeBatch
+		taskCtx.batchTask = tmpBatchTask
+
+		var checkErr error
+		hardForkName, checkErr = bp.hardForkSanityCheck(ctx, taskCtx)
+		if checkErr != nil {
+			log.Debug("hard fork sanity check failed", "height", getTaskParameter.ProverHeight, "err", checkErr)
+			return nil, nil
+		}
+
 		// Don't dispatch the same failing job to the same prover
-		proverTasks, getTaskError := bp.proverTaskOrm.GetFailedProverTasksByHash(ctx.Copy(), message.ProofTypeBatch, tmpBatchTask.Hash, 2)
-		if getTaskError != nil {
-			log.Error("failed to get prover tasks", "proof type", message.ProofTypeBatch.String(), "task ID", tmpBatchTask.Hash, "error", getTaskError)
+		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)
+				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
 			}
 		}
@@ -136,23 +149,6 @@ 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)
-
-	hardForkName, getHardForkErr := bp.hardForkName(ctx, batchTask)
-	if getHardForkErr != nil {
-		bp.recoverActiveAttempts(ctx, batchTask)
-		log.Error("retrieve hard fork name by batch failed", "task_id", batchTask.Hash, "err", getHardForkErr)
-		return nil, ErrCoordinatorInternalFailure
-	}
-
-	if _, ok := taskCtx.HardForkNames[hardForkName]; !ok {
-		bp.recoverActiveAttempts(ctx, batchTask)
-		log.Error("incompatible prover version",
-			"requisite hard fork name", hardForkName,
-			"prover hard fork name", taskCtx.HardForkNames,
-			"task_id", batchTask.Hash)
-		return nil, ErrCoordinatorInternalFailure
-	}
-
 	proverTask := orm.ProverTask{
 		TaskID:          batchTask.Hash,
 		ProverPublicKey: taskCtx.PublicKey,
@@ -189,20 +185,6 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	return taskMsg, nil
 }
 
-func (bp *BatchProverTask) hardForkName(ctx *gin.Context, batchTask *orm.Batch) (string, error) {
-	startChunk, getChunkErr := bp.chunkOrm.GetChunkByHash(ctx, batchTask.StartChunkHash)
-	if getChunkErr != nil {
-		return "", getChunkErr
-	}
-
-	l2Block, getBlockErr := bp.blockOrm.GetL2BlockByNumber(ctx.Copy(), startChunk.StartBlockNumber)
-	if getBlockErr != nil {
-		return "", getBlockErr
-	}
-	hardForkName := encoding.GetHardforkName(bp.chainCfg, l2Block.Number, l2Block.BlockTimestamp)
-	return hardForkName, nil
-}
-
 func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.ProverTask, batch *orm.Batch, hardForkName string) (*coordinatorType.GetTaskSchema, error) {
 	// get chunk from db
 	chunks, err := bp.chunkOrm.GetChunksByBatchHash(ctx, task.TaskID)
@@ -215,32 +197,32 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		return nil, fmt.Errorf("no chunk found for batch task id:%s", task.TaskID)
 	}
 
-	var chunkProofs []message.ChunkProof
+	var chunkProofs []*message.OpenVMChunkProof
 	var chunkInfos []*message.ChunkInfo
 	for _, chunk := range chunks {
-		proof := message.NewChunkProof(hardForkName)
+		var proof message.OpenVMChunkProof
 		if encodeErr := json.Unmarshal(chunk.Proof, &proof); encodeErr != nil {
 			return nil, fmt.Errorf("Chunk.GetProofsByBatchHash unmarshal proof error: %w, batch hash: %v, chunk hash: %v", encodeErr, task.TaskID, chunk.Hash)
 		}
-		chunkProofs = append(chunkProofs, proof)
+		chunkProofs = append(chunkProofs, &proof)
 
 		chunkInfo := message.ChunkInfo{
-			ChainID:       bp.cfg.L2.ChainID,
-			PrevStateRoot: common.HexToHash(chunk.ParentChunkStateRoot),
-			PostStateRoot: common.HexToHash(chunk.StateRoot),
-			WithdrawRoot:  common.HexToHash(chunk.WithdrawRoot),
-			DataHash:      common.HexToHash(chunk.Hash),
-			IsPadding:     false,
-		}
-		if haloProot, ok := proof.(*message.Halo2ChunkProof); ok {
-			if haloProot.ChunkInfo != nil {
-				chunkInfo.TxBytes = haloProot.ChunkInfo.TxBytes
-			}
+			ChainID:            bp.cfg.L2.ChainID,
+			PrevStateRoot:      common.HexToHash(chunk.ParentChunkStateRoot),
+			PostStateRoot:      common.HexToHash(chunk.StateRoot),
+			WithdrawRoot:       common.HexToHash(chunk.WithdrawRoot),
+			DataHash:           common.HexToHash(chunk.Hash),
+			PrevMsgQueueHash:   common.HexToHash(chunk.PrevL1MessageQueueHash),
+			PostMsgQueueHash:   common.HexToHash(chunk.PostL1MessageQueueHash),
+			IsPadding:          false,
+			InitialBlockNumber: proof.MetaData.ChunkInfo.InitialBlockNumber,
+			BlockCtxs:          proof.MetaData.ChunkInfo.BlockCtxs,
+			TxDataLength:       proof.MetaData.ChunkInfo.TxDataLength,
 		}
 		chunkInfos = append(chunkInfos, &chunkInfo)
 	}
 
-	taskDetail, err := bp.getBatchTaskDetail(batch, chunkInfos, chunkProofs)
+	taskDetail, err := bp.getBatchTaskDetail(batch, chunkInfos, chunkProofs, hardForkName)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get batch task detail, taskID:%s err:%w", task.TaskID, err)
 	}
@@ -257,6 +239,9 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		TaskData:     string(chunkProofsBytes),
 		HardForkName: hardForkName,
 	}
+
+	log.Debug("TaskData", "task_id", task.TaskID, "task_type", message.ProofTypeBatch.String(), "hard_fork_name", hardForkName, "task_data", taskMsg.TaskData)
+
 	return taskMsg, nil
 }
 
@@ -266,15 +251,22 @@ func (bp *BatchProverTask) recoverActiveAttempts(ctx *gin.Context, batchTask *or
 	}
 }
 
-func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*message.ChunkInfo, chunkProofs []message.ChunkProof) (*message.BatchTaskDetail, error) {
+func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*message.ChunkInfo, chunkProofs []*message.OpenVMChunkProof, hardForkName string) (*message.BatchTaskDetail, error) {
 	taskDetail := &message.BatchTaskDetail{
 		ChunkInfos:  chunkInfos,
 		ChunkProofs: chunkProofs,
 	}
 
+	if hardForkName == message.EuclidV2Fork {
+		taskDetail.ForkName = message.EuclidV2ForkNameForProver
+	} else {
+		log.Error("unsupported hard fork name", "hard_fork_name", hardForkName)
+		return nil, fmt.Errorf("unsupported hard fork name: %s", hardForkName)
+	}
+
 	dbBatchCodecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
 	switch dbBatchCodecVersion {
-	case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6:
+	case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6, encoding.CodecV7:
 	default:
 		return taskDetail, nil
 	}
@@ -290,6 +282,13 @@ func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*
 	}
 	taskDetail.BatchHeader = batchHeader
 	taskDetail.BlobBytes = dbBatch.BlobBytes
+	taskDetail.ChallengeDigest = common.HexToHash(dbBatch.ChallengeDigest)
+	// Memory layout of `BlobDataProof`: used in Codec.BlobDataProofForPointEvaluation()
+	// | z       | y       | kzg_commitment | kzg_proof |
+	// |---------|---------|----------------|-----------|
+	// | bytes32 | bytes32 | bytes48        | bytes48   |
+	taskDetail.KzgProof = message.Byte48{Big: hexutil.Big(*new(big.Int).SetBytes(dbBatch.BlobDataProof[112:160]))}
+	taskDetail.KzgCommitment = message.Byte48{Big: hexutil.Big(*new(big.Int).SetBytes(dbBatch.BlobDataProof[64:112]))}
 
 	return taskDetail, nil
 }

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -9,19 +9,19 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/scroll-tech/da-codec/encoding"
+	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
-	"scroll-tech/common/types"
-	"scroll-tech/common/types/message"
-	"scroll-tech/common/utils"
-
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/orm"
 	coordinatorType "scroll-tech/coordinator/internal/types"
 	cutils "scroll-tech/coordinator/internal/utils"
+
+	"scroll-tech/common/types"
+	"scroll-tech/common/types/message"
+	"scroll-tech/common/utils"
 )
 
 // BundleProverTask is prover task implement for bundle proof
@@ -77,6 +77,7 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 	}
 
 	var bundleTask *orm.Bundle
+	var hardForkName string
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpBundleTask *orm.Bundle
@@ -101,6 +102,16 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 			return nil, nil
 		}
 
+		taskCtx.taskType = message.ProofTypeBundle
+		taskCtx.bundleTask = tmpBundleTask
+
+		var checkErr error
+		hardForkName, checkErr = bp.hardForkSanityCheck(ctx, taskCtx)
+		if checkErr != nil {
+			log.Debug("hard fork sanity check failed", "height", getTaskParameter.ProverHeight, "err", checkErr)
+			return nil, 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 {
@@ -110,7 +121,7 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 		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)
+				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
 			}
 		}
@@ -136,23 +147,6 @@ 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)
-
-	hardForkName, getHardForkErr := bp.hardForkName(ctx, bundleTask)
-	if getHardForkErr != nil {
-		bp.recoverActiveAttempts(ctx, bundleTask)
-		log.Error("retrieve hard fork name by bundle failed", "task_id", bundleTask.Hash, "err", getHardForkErr)
-		return nil, ErrCoordinatorInternalFailure
-	}
-
-	if _, ok := taskCtx.HardForkNames[hardForkName]; !ok {
-		bp.recoverActiveAttempts(ctx, bundleTask)
-		log.Error("incompatible prover version",
-			"requisite hard fork name", hardForkName,
-			"prover hard fork name", taskCtx.HardForkNames,
-			"task_id", bundleTask.Hash)
-		return nil, ErrCoordinatorInternalFailure
-	}
-
 	proverTask := orm.ProverTask{
 		TaskID:          bundleTask.Hash,
 		ProverPublicKey: taskCtx.PublicKey,
@@ -189,26 +183,6 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 	return taskMsg, nil
 }
 
-func (bp *BundleProverTask) hardForkName(ctx *gin.Context, bundleTask *orm.Bundle) (string, error) {
-	startBatch, getBatchErr := bp.batchOrm.GetBatchByHash(ctx, bundleTask.StartBatchHash)
-	if getBatchErr != nil {
-		return "", getBatchErr
-	}
-
-	startChunk, getChunkErr := bp.chunkOrm.GetChunkByHash(ctx, startBatch.StartChunkHash)
-	if getChunkErr != nil {
-		return "", getChunkErr
-	}
-
-	l2Block, getBlockErr := bp.blockOrm.GetL2BlockByNumber(ctx.Copy(), startChunk.StartBlockNumber)
-	if getBlockErr != nil {
-		return "", getBlockErr
-	}
-
-	hardForkName := encoding.GetHardforkName(bp.chainCfg, l2Block.Number, l2Block.BlockTimestamp)
-	return hardForkName, nil
-}
-
 func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.ProverTask, hardForkName string) (*coordinatorType.GetTaskSchema, error) {
 	// get bundle from db
 	batches, err := bp.batchOrm.GetBatchesByBundleHash(ctx, task.TaskID)
@@ -221,19 +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 batchProofs []message.BatchProof
+	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
 	for _, batch := range batches {
-		proof := message.NewBatchProof(hardForkName)
+		var proof message.OpenVMBatchProof
 		if encodeErr := json.Unmarshal(batch.Proof, &proof); encodeErr != nil {
 			return nil, fmt.Errorf("failed to unmarshal proof: %w, bundle hash: %v, batch hash: %v", encodeErr, task.TaskID, batch.Hash)
 		}
-		batchProofs = append(batchProofs, proof)
+		batchProofs = append(batchProofs, &proof)
 	}
 
 	taskDetail := message.BundleTaskDetail{
 		BatchProofs: batchProofs,
 	}
 
+	if hardForkName == message.EuclidV2Fork {
+		taskDetail.ForkName = message.EuclidV2ForkNameForProver
+	} else {
+		log.Error("unsupported hard fork name", "hard_fork_name", hardForkName)
+		return nil, fmt.Errorf("unsupported hard fork name: %s", hardForkName)
+	}
+
+	taskDetail.BundleInfo = &message.OpenVMBundleInfo{
+		ChainID:       bp.cfg.L2.ChainID,
+		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),
+	}
+
 	batchProofsBytes, err := json.Marshal(taskDetail)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal batch proofs, taskID:%s err:%w", task.TaskID, err)
@@ -246,6 +243,9 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 		TaskData:     string(batchProofsBytes),
 		HardForkName: hardForkName,
 	}
+
+	log.Debug("TaskData", "task_id", task.TaskID, "task_type", message.ProofTypeBundle.String(), "hard_fork_name", hardForkName, "task_data", taskMsg.TaskData)
+
 	return taskMsg, nil
 }
 

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -9,7 +9,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/scroll-tech/da-codec/encoding"
+	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
@@ -75,6 +75,7 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	}
 
 	var chunkTask *orm.Chunk
+	var hardForkName string
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpChunkTask *orm.Chunk
@@ -99,16 +100,26 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 			return nil, nil
 		}
 
+		taskCtx.taskType = message.ProofTypeChunk
+		taskCtx.chunkTask = tmpChunkTask
+
+		var checkErr error
+		hardForkName, checkErr = cp.hardForkSanityCheck(ctx, taskCtx)
+		if checkErr != nil {
+			log.Debug("hard fork sanity check failed", "height", getTaskParameter.ProverHeight, "err", checkErr)
+			return nil, nil
+		}
+
 		// Don't dispatch the same failing job to the same prover
-		proverTasks, getTaskError := cp.proverTaskOrm.GetFailedProverTasksByHash(ctx.Copy(), message.ProofTypeChunk, tmpChunkTask.Hash, 2)
-		if getTaskError != nil {
-			log.Error("failed to get prover tasks", "proof type", message.ProofTypeChunk.String(), "task ID", tmpChunkTask.Hash, "error", getTaskError)
+		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)
+				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
 			}
 		}
@@ -134,23 +145,6 @@ 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)
-
-	hardForkName, getHardForkErr := cp.hardForkName(ctx, chunkTask)
-	if getHardForkErr != nil {
-		cp.recoverActiveAttempts(ctx, chunkTask)
-		log.Error("retrieve hard fork name by chunk failed", "task_id", chunkTask.Hash, "err", getHardForkErr)
-		return nil, ErrCoordinatorInternalFailure
-	}
-
-	if _, ok := taskCtx.HardForkNames[hardForkName]; !ok {
-		cp.recoverActiveAttempts(ctx, chunkTask)
-		log.Error("incompatible prover version",
-			"requisite hard fork name", hardForkName,
-			"prover hard fork name", taskCtx.HardForkNames,
-			"task_id", chunkTask.Hash)
-		return nil, ErrCoordinatorInternalFailure
-	}
-
 	proverTask := orm.ProverTask{
 		TaskID:          chunkTask.Hash,
 		ProverPublicKey: taskCtx.PublicKey,
@@ -169,7 +163,7 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	taskMsg, err := cp.formatProverTask(ctx.Copy(), &proverTask, hardForkName)
+	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)
@@ -186,26 +180,28 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	return taskMsg, nil
 }
 
-func (cp *ChunkProverTask) hardForkName(ctx *gin.Context, chunkTask *orm.Chunk) (string, error) {
-	l2Block, getBlockErr := cp.blockOrm.GetL2BlockByNumber(ctx.Copy(), chunkTask.StartBlockNumber)
-	if getBlockErr != nil {
-		return "", getBlockErr
-	}
-	hardForkName := encoding.GetHardforkName(cp.chainCfg, l2Block.Number, l2Block.BlockTimestamp)
-	return hardForkName, nil
-}
-
-func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.ProverTask, hardForkName string) (*coordinatorType.GetTaskSchema, error) {
+func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.ProverTask, chunk *orm.Chunk, hardForkName string) (*coordinatorType.GetTaskSchema, error) {
 	// 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:%w", task.TaskID, dbErr)
 	}
 
+	var taskDetailBytes []byte
 	taskDetail := message.ChunkTaskDetail{
-		BlockHashes: blockHashes,
+		BlockHashes:      blockHashes,
+		PrevMsgQueueHash: common.HexToHash(chunk.PrevL1MessageQueueHash),
 	}
-	blockHashesBytes, err := json.Marshal(taskDetail)
+
+	if hardForkName == message.EuclidV2Fork {
+		taskDetail.ForkName = message.EuclidV2ForkNameForProver
+	} else {
+		log.Error("unsupported hard fork name", "hard_fork_name", hardForkName)
+		return nil, fmt.Errorf("unsupported hard fork name: %s", hardForkName)
+	}
+
+	var err error
+	taskDetailBytes, err = json.Marshal(taskDetail)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal block hashes hash:%s, err:%w", task.TaskID, err)
 	}
@@ -214,10 +210,12 @@ func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		UUID:         task.UUID.String(),
 		TaskID:       task.TaskID,
 		TaskType:     int(message.ProofTypeChunk),
-		TaskData:     string(blockHashesBytes),
+		TaskData:     string(taskDetailBytes),
 		HardForkName: hardForkName,
 	}
 
+	log.Debug("TaskData", "task_id", task.TaskID, "task_type", message.ProofTypeChunk.String(), "hard_fork_name", hardForkName, "task_data", proverTaskSchema.TaskData)
+
 	return proverTaskSchema, nil
 }
 

coordinator/internal/logic/provertask/prover_task.go

@@ -9,9 +9,12 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
+	"scroll-tech/common/types/message"
+
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/orm"
 	coordinatorType "scroll-tech/coordinator/internal/types"
@@ -52,6 +55,76 @@ type proverTaskContext struct {
 	ProverVersion      string
 	ProverProviderType uint8
 	HardForkNames      map[string]struct{}
+
+	taskType   message.ProofType
+	chunkTask  *orm.Chunk
+	batchTask  *orm.Batch
+	bundleTask *orm.Bundle
+}
+
+// hardForkName get the chunk/batch/bundle hard fork name
+func (b *BaseProverTask) hardForkName(ctx *gin.Context, taskCtx *proverTaskContext) (string, error) {
+	switch {
+	case taskCtx.taskType == message.ProofTypeChunk:
+		if taskCtx.chunkTask == nil {
+			return "", errors.New("chunk task is nil")
+		}
+		l2Block, getBlockErr := b.blockOrm.GetL2BlockByNumber(ctx.Copy(), taskCtx.chunkTask.StartBlockNumber)
+		if getBlockErr != nil {
+			return "", getBlockErr
+		}
+		hardForkName := encoding.GetHardforkName(b.chainCfg, l2Block.Number, l2Block.BlockTimestamp)
+		return hardForkName, nil
+
+	case taskCtx.taskType == message.ProofTypeBatch:
+		if taskCtx.batchTask == nil {
+			return "", errors.New("batch task is nil")
+		}
+		startChunk, getChunkErr := b.chunkOrm.GetChunkByHash(ctx, taskCtx.batchTask.StartChunkHash)
+		if getChunkErr != nil {
+			return "", getChunkErr
+		}
+		l2Block, getBlockErr := b.blockOrm.GetL2BlockByNumber(ctx.Copy(), startChunk.StartBlockNumber)
+		if getBlockErr != nil {
+			return "", getBlockErr
+		}
+		hardForkName := encoding.GetHardforkName(b.chainCfg, l2Block.Number, l2Block.BlockTimestamp)
+		return hardForkName, nil
+
+	case taskCtx.taskType == message.ProofTypeBundle:
+		if taskCtx.bundleTask == nil {
+			return "", errors.New("bundle task is nil")
+		}
+		startBatch, getBatchErr := b.batchOrm.GetBatchByHash(ctx, taskCtx.bundleTask.StartBatchHash)
+		if getBatchErr != nil {
+			return "", getBatchErr
+		}
+		startChunk, getChunkErr := b.chunkOrm.GetChunkByHash(ctx, startBatch.StartChunkHash)
+		if getChunkErr != nil {
+			return "", getChunkErr
+		}
+		l2Block, getBlockErr := b.blockOrm.GetL2BlockByNumber(ctx.Copy(), startChunk.StartBlockNumber)
+		if getBlockErr != nil {
+			return "", getBlockErr
+		}
+		hardForkName := encoding.GetHardforkName(b.chainCfg, l2Block.Number, l2Block.BlockTimestamp)
+		return hardForkName, nil
+	default:
+		return "", errors.New("illegal task type")
+	}
+}
+
+// hardForkSanityCheck check the task's hard fork name is the same as prover
+func (b *BaseProverTask) hardForkSanityCheck(ctx *gin.Context, taskCtx *proverTaskContext) (string, error) {
+	hardForkName, getHardForkErr := b.hardForkName(ctx, taskCtx)
+	if getHardForkErr != nil {
+		return "", getHardForkErr
+	}
+
+	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)
+	}
+	return hardForkName, nil
 }
 
 // checkParameter check the prover task parameter illegal

coordinator/internal/logic/submitproof/proof_receiver.go

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

coordinator/internal/logic/verifier/mock.go

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

coordinator/internal/logic/verifier/types.go

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

coordinator/internal/logic/verifier/verifier.go

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

coordinator/internal/logic/verifier/verifier_test.go

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

coordinator/internal/orm/batch.go

@@ -19,20 +19,23 @@ type Batch struct {
 	db *gorm.DB `gorm:"column:-"`
 
 	// batch
-	Index           uint64 `json:"index" gorm:"column:index"`
-	Hash            string `json:"hash" gorm:"column:hash"`
-	DataHash        string `json:"data_hash" gorm:"column:data_hash"`
-	StartChunkIndex uint64 `json:"start_chunk_index" gorm:"column:start_chunk_index"`
-	StartChunkHash  string `json:"start_chunk_hash" gorm:"column:start_chunk_hash"`
-	EndChunkIndex   uint64 `json:"end_chunk_index" gorm:"column:end_chunk_index"`
-	EndChunkHash    string `json:"end_chunk_hash" gorm:"column:end_chunk_hash"`
-	StateRoot       string `json:"state_root" gorm:"column:state_root"`
-	WithdrawRoot    string `json:"withdraw_root" gorm:"column:withdraw_root"`
-	ParentBatchHash string `json:"parent_batch_hash" gorm:"column:parent_batch_hash"`
-	BatchHeader     []byte `json:"batch_header" gorm:"column:batch_header"`
-	CodecVersion    int16  `json:"codec_version" gorm:"column:codec_version"`
-	EnableCompress  bool   `json:"enable_compress" gorm:"column:enable_compress"`
-	BlobBytes       []byte `json:"blob_bytes" gorm:"column:blob_bytes"`
+	Index                  uint64 `json:"index" gorm:"column:index"`
+	Hash                   string `json:"hash" gorm:"column:hash"`
+	DataHash               string `json:"data_hash" gorm:"column:data_hash"`
+	StartChunkIndex        uint64 `json:"start_chunk_index" gorm:"column:start_chunk_index"`
+	StartChunkHash         string `json:"start_chunk_hash" gorm:"column:start_chunk_hash"`
+	EndChunkIndex          uint64 `json:"end_chunk_index" gorm:"column:end_chunk_index"`
+	EndChunkHash           string `json:"end_chunk_hash" gorm:"column:end_chunk_hash"`
+	StateRoot              string `json:"state_root" gorm:"column:state_root"`
+	WithdrawRoot           string `json:"withdraw_root" gorm:"column:withdraw_root"`
+	ParentBatchHash        string `json:"parent_batch_hash" gorm:"column:parent_batch_hash"`
+	BatchHeader            []byte `json:"batch_header" gorm:"column:batch_header"`
+	CodecVersion           int16  `json:"codec_version" gorm:"column:codec_version"`
+	PrevL1MessageQueueHash string `json:"prev_l1_message_queue_hash" gorm:"column:prev_l1_message_queue_hash"`
+	PostL1MessageQueueHash string `json:"post_l1_message_queue_hash" gorm:"column:post_l1_message_queue_hash"`
+	EnableCompress         bool   `json:"enable_compress" gorm:"column:enable_compress"`
+	BlobBytes              []byte `json:"blob_bytes" gorm:"column:blob_bytes"`
+	ChallengeDigest        string `json:"challenge_digest" gorm:"column:challenge_digest"`
 
 	// proof
 	ChunkProofsStatus int16      `json:"chunk_proofs_status" gorm:"column:chunk_proofs_status;default:1"`

coordinator/internal/orm/chunk.go

@@ -28,6 +28,8 @@ type Chunk struct {
 	StartBlockTime               uint64 `json:"start_block_time" gorm:"column:start_block_time"`
 	TotalL1MessagesPoppedBefore  uint64 `json:"total_l1_messages_popped_before" gorm:"column:total_l1_messages_popped_before"`
 	TotalL1MessagesPoppedInChunk uint64 `json:"total_l1_messages_popped_in_chunk" gorm:"column:total_l1_messages_popped_in_chunk"`
+	PrevL1MessageQueueHash       string `json:"prev_l1_message_queue_hash" gorm:"column:prev_l1_message_queue_hash"`
+	PostL1MessageQueueHash       string `json:"post_l1_message_queue_hash" gorm:"column:post_l1_message_queue_hash"`
 	ParentChunkHash              string `json:"parent_chunk_hash" gorm:"column:parent_chunk_hash"`
 	StateRoot                    string `json:"state_root" gorm:"column:state_root"`
 	ParentChunkStateRoot         string `json:"parent_chunk_state_root" gorm:"column:parent_chunk_state_root"`

coordinator/internal/orm/orm_test.go

@@ -9,11 +9,12 @@ import (
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 
+	"scroll-tech/database/migrate"
+
 	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/message"
 	"scroll-tech/common/utils"
-	"scroll-tech/database/migrate"
 )
 
 var (

coordinator/internal/types/auth_test.go

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

coordinator/internal/types/prover.go

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

coordinator/test/api_test.go

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

coordinator/test/mock_prover.go

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

database/migrate/migrate_test.go

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

database/migrate/migrations/00025_add_l1_message_queue_hash.sql

@@ -0,0 +1,26 @@
+-- +goose Up
+-- +goose StatementBegin
+
+ALTER TABLE chunk
+ADD COLUMN prev_l1_message_queue_hash VARCHAR DEFAULT '',
+ADD COLUMN post_l1_message_queue_hash VARCHAR DEFAULT '';
+
+ALTER TABLE batch
+ADD COLUMN prev_l1_message_queue_hash VARCHAR DEFAULT '',
+ADD COLUMN post_l1_message_queue_hash VARCHAR DEFAULT '';
+
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+
+ALTER TABLE IF EXISTS chunk
+DROP COLUMN IF EXISTS prev_l1_message_queue_hash,
+DROP COLUMN IF EXISTS post_l1_message_queue_hash;
+
+ALTER TABLE IF EXISTS batch
+DROP COLUMN IF EXISTS prev_l1_message_queue_hash,
+DROP COLUMN IF EXISTS post_l1_message_queue_hash;
+
+-- +goose StatementEnd

database/migrate/migrations/00026_add_challenge_digest.sql

@@ -0,0 +1,15 @@
+-- +goose Up
+-- +goose StatementBegin
+
+ALTER TABLE batch
+ADD COLUMN challenge_digest VARCHAR DEFAULT '';
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+
+ALTER TABLE IF EXISTS batch
+DROP COLUMN IF EXISTS challenge_digest;
+
+-- +goose StatementEnd

database/migrate/migrations/00027_ blob_upload.sql

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

go.work

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

prover/Cargo.toml

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

prover/Makefile

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

prover/config.json

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

prover/print_halo2gpu_version.sh

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

prover/print_high_zkevm_version.sh

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

prover/rust-toolchain

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

prover/rustfmt.toml

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

prover/src/config.rs

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

prover/src/main.rs

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

prover/src/prover.rs

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

prover/src/types.rs

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

prover/src/utils.rs

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

prover/src/zk_circuits_handler.rs

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