add fix

This reverts commit d94ac817ca.

.github/workflows/docker.yml

@@ -2,58 +2,11 @@ name: Docker
 
 on:
   push:
-    tags:
-      - v**
 
 env:
   AWS_REGION: us-west-2
 
 jobs:
-  event_watcher:
-    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: event-watcher
-        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: event-watcher
-          IMAGE_TAG: ${{ github.ref_name }}
-        with:
-          context: .
-          file: ./build/dockerfiles/event_watcher.Dockerfile
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: |
-            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
-            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
-            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
-
   gas_oracle:
     runs-on: ubuntu-latest
     steps:

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "scroll-contracts"]
+	path = scroll-contracts
+	url = https://github.com/scroll-tech/scroll-contracts.git

Makefile

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

README.md

@@ -52,12 +52,6 @@ go test -v -race -covermode=atomic scroll-tech/database/...
 go test -v -race -covermode=atomic scroll-tech/common/...
 ```
 
-## Testing Contracts
-
-You can find the unit tests in [`contracts/src/test/`](/contracts/src/test/), and integration tests in [`contracts/integration-test/`](/contracts/integration-test/).
-
-See [`contracts`](/contracts) for more details on the contracts.
-
 ## License
 
 Scroll Monorepo is licensed under the [MIT](./LICENSE) license.

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

@@ -96,7 +96,7 @@ func action(ctx *cli.Context) error {
 	return nil
 }
 
-// Run event watcher cmd instance.
+// Run bridge-history-backend api cmd instance.
 func Run() {
 	if err := app.Run(os.Args); err != nil {
 		_, _ = fmt.Fprintln(os.Stderr, err)

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

@@ -84,7 +84,7 @@ func action(ctx *cli.Context) error {
 	return nil
 }
 
-// Run event watcher cmd instance.
+// Run bridge-history-backend fetcher cmd instance.
 func Run() {
 	if err := app.Run(os.Args); err != nil {
 		_, _ = fmt.Fprintln(os.Stderr, err)

bridge-history-api/go.mod

@@ -8,7 +8,7 @@ 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.20240422045311-246955a4df94
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
 	golang.org/x/sync v0.7.0
@@ -65,7 +65,6 @@ require (
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/compress v1.17.4 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
-	github.com/kr/text v0.2.0 // indirect
 	github.com/leodido/go-urn v1.2.4 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
@@ -90,6 +89,7 @@ require (
 	github.com/rjeczalik/notify v0.9.1 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7 // 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/go.sum

@@ -61,7 +61,6 @@ github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0q
 github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/crate-crypto/go-kzg-4844 v1.0.0 h1:TsSgHwrkTKecKJ4kadtHi4b3xHW5dCFUDFnUp1TsawI=
 github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -309,8 +308,10 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240422045311-246955a4df94 h1:yYsneFgHlSmOyCGNMF75t0NQLkNEuIo1jE+GIAOPviw=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240422045311-246955a4df94/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
+github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7 h1:Mx3fKRszn6CMeJ7YBTdjLSfXoSDd9hkP8BwhIaaUVfQ=
+github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=

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

@@ -407,7 +407,7 @@ func (h *HistoryLogic) cacheTxsInfo(ctx context.Context, cacheKey string, txs []
 				return err
 			}
 		} else {
-			// The transactions are sorted, thus we set the score as their indices.
+			// The transactions are sorted, thus we set the score as their index.
 			for _, tx := range txs {
 				txBytes, err := json.Marshal(tx)
 				if err != nil {

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

@@ -273,7 +273,6 @@ func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.
 			l1BatchEvents = append(l1BatchEvents, &orm.BatchEvent{
 				BatchStatus:   int(btypes.BatchStatusTypeFinalized),
 				BatchIndex:    event.BatchIndex.Uint64(),
-				BatchHash:     event.BatchHash.String(),
 				L1BlockNumber: vlog.BlockNumber,
 			})
 		}

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

@@ -73,6 +73,9 @@ func (c *BatchEvent) GetFinalizedBatchesLEBlockHeight(ctx context.Context, block
 
 // InsertOrUpdateBatchEvents inserts a new batch event or updates an existing one based on the BatchStatusType.
 func (c *BatchEvent) InsertOrUpdateBatchEvents(ctx context.Context, l1BatchEvents []*BatchEvent) error {
+	var maxFinalizedBatchIndex uint64
+	var containsFinalizedEvent bool
+	var maxL1BlockNumber uint64
 	for _, l1BatchEvent := range l1BatchEvents {
 		db := c.db
 		db = db.WithContext(ctx)
@@ -89,11 +92,13 @@ func (c *BatchEvent) InsertOrUpdateBatchEvents(ctx context.Context, l1BatchEvent
 				return fmt.Errorf("failed to insert or ignore batch event, error: %w", err)
 			}
 		case btypes.BatchStatusTypeFinalized:
-			db = db.Where("batch_index = ?", l1BatchEvent.BatchIndex)
-			db = db.Where("batch_hash = ?", l1BatchEvent.BatchHash)
-			updateFields["batch_status"] = btypes.BatchStatusTypeFinalized
-			if err := db.Updates(updateFields).Error; err != nil {
-				return fmt.Errorf("failed to update batch event, error: %w", err)
+			containsFinalizedEvent = true
+			// get the maxFinalizedBatchIndex, which signals all the batch before it are all finalized
+			if l1BatchEvent.BatchIndex > maxFinalizedBatchIndex {
+				maxFinalizedBatchIndex = l1BatchEvent.BatchIndex
+			}
+			if l1BatchEvent.L1BlockNumber > maxL1BlockNumber {
+				maxL1BlockNumber = l1BatchEvent.L1BlockNumber
 			}
 		case btypes.BatchStatusTypeReverted:
 			db = db.Where("batch_index = ?", l1BatchEvent.BatchIndex)
@@ -108,6 +113,21 @@ func (c *BatchEvent) InsertOrUpdateBatchEvents(ctx context.Context, l1BatchEvent
 			}
 		}
 	}
+	if containsFinalizedEvent {
+		db := c.db
+		db = db.WithContext(ctx)
+		db = db.Model(&BatchEvent{})
+		updateFields := make(map[string]interface{})
+		// After darwin, FinalizeBatch event signals a range of batches are finalized,
+		// thus losing the batch hash info. Meanwhile, only batch_index is enough to update finalized batches.
+		db = db.Where("batch_index <= ?", maxFinalizedBatchIndex)
+		db = db.Where("batch_status != ?", btypes.BatchStatusTypeFinalized)
+		updateFields["batch_status"] = btypes.BatchStatusTypeFinalized
+		updateFields["l1_block_number"] = maxL1BlockNumber
+		if err := db.Updates(updateFields).Error; err != nil {
+			return fmt.Errorf("failed to update batch event, error: %w", err)
+		}
+	}
 	return nil
 }
 

build/dockerfiles/coordinator-api.Dockerfile

@@ -31,13 +31,15 @@ RUN go mod download -x
 
 # Build coordinator
 FROM base as builder
+RUN apt-get install libc6-dev
 COPY . .
 RUN cp -r ./common/libzkp/interface ./coordinator/internal/logic/verifier/lib
 COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/internal/logic/verifier/lib/
 RUN cd ./coordinator && 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 alpine container
+# Pull coordinator into a second stage deploy ubuntu container
 FROM ubuntu:20.04
+ENV CGO_LDFLAGS="-Wl,--no-as-needed -ldl"
 ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/src/coordinator/internal/logic/verifier/lib
 # ENV CHAIN_ID=534353
 RUN mkdir -p /src/coordinator/internal/logic/verifier/lib

build/dockerfiles/coordinator-cron.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.21 as base
+FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
 
 WORKDIR /src
 COPY go.work* ./
@@ -16,10 +16,13 @@ RUN go mod download -x
 FROM base as builder
 RUN --mount=target=. \
     --mount=type=cache,target=/root/.cache/go-build \
-    cd /src/coordinator/cmd/cron/ && go build -v -p 4 -o /bin/coordinator_cron
+    cd /src/coordinator/cmd/cron/ && CGO_LDFLAGS="-ldl" go build -v -p 4 -o /bin/coordinator_cron
+
+# Pull coordinator into a second stage deploy ubuntu container
+FROM ubuntu:20.04
+
+ENV CGO_LDFLAGS="-ldl"
 
-# Pull coordinator into a second stage deploy alpine container
-FROM alpine:latest
 COPY --from=builder /bin/coordinator_cron /bin/
 WORKDIR /app
 ENTRYPOINT ["coordinator_cron"]

build/dockerfiles/event_watcher.Dockerfile

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

build/dockerfiles/event_watcher.Dockerfile.dockerignore

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

build/dockerfiles/gas_oracle.Dockerfile

@@ -19,7 +19,7 @@ RUN --mount=target=. \
     --mount=type=cache,target=/root/.cache/go-build \
     cd /src/rollup/cmd/gas_oracle/ && CGO_LDFLAGS="-ldl" go build -v -p 4 -o /bin/gas_oracle
 
-# Pull gas_oracle into a second stage deploy alpine container
+# Pull gas_oracle into a second stage deploy ubuntu container
 FROM ubuntu:20.04
 
 ENV CGO_LDFLAGS="-ldl"

build/dockerfiles/rollup_relayer.Dockerfile

@@ -19,7 +19,7 @@ RUN --mount=target=. \
     --mount=type=cache,target=/root/.cache/go-build \
     cd /src/rollup/cmd/rollup_relayer/ && CGO_LDFLAGS="-ldl" go build -v -p 4 -o /bin/rollup_relayer
 
-# Pull rollup_relayer into a second stage deploy alpine container
+# Pull rollup_relayer into a second stage deploy ubuntu container
 FROM ubuntu:20.04
 
 ENV CGO_LDFLAGS="-ldl"

common/forks/forks.go

@@ -5,6 +5,7 @@ import (
 	"math/big"
 	"sort"
 
+	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/params"
 )
 
@@ -63,17 +64,6 @@ func CollectSortedForkHeights(config *params.ChainConfig) ([]uint64, map[uint64]
 	return forkHeights, forkHeightsMap, forkNameHeightMap
 }
 
-// BlocksUntilFork returns the number of blocks until the next fork
-// returns 0 if there is no fork scheduled for the future
-func BlocksUntilFork(blockHeight uint64, forkHeights []uint64) uint64 {
-	for _, forkHeight := range forkHeights {
-		if forkHeight > blockHeight {
-			return forkHeight - blockHeight
-		}
-	}
-	return 0
-}
-
 // BlockRange returns the block range of the hard fork
 // Need ensure the forkHeights is incremental
 func BlockRange(currentForkHeight uint64, forkHeights []uint64) (from, to uint64) {
@@ -87,3 +77,45 @@ func BlockRange(currentForkHeight uint64, forkHeights []uint64) (from, to uint64
 	}
 	return
 }
+
+// GetHardforkName returns the name of the hardfork active at the given block height and timestamp.
+// It checks the chain configuration to determine which hardfork is active.
+func GetHardforkName(config *params.ChainConfig, blockHeight, blockTimestamp uint64) string {
+	if !config.IsBernoulli(new(big.Int).SetUint64(blockHeight)) {
+		return "homestead"
+	} else if !config.IsCurie(new(big.Int).SetUint64(blockHeight)) {
+		return "bernoulli"
+	} else if !config.IsDarwin(blockTimestamp) {
+		return "curie"
+	} else {
+		return "darwin"
+	}
+}
+
+// GetCodecVersion returns the encoding codec version for the given block height and timestamp.
+// It determines the appropriate codec version based on the active hardfork.
+func GetCodecVersion(config *params.ChainConfig, blockHeight, blockTimestamp uint64) encoding.CodecVersion {
+	if !config.IsBernoulli(new(big.Int).SetUint64(blockHeight)) {
+		return encoding.CodecV0
+	} else if !config.IsCurie(new(big.Int).SetUint64(blockHeight)) {
+		return encoding.CodecV1
+	} else if !config.IsDarwin(blockTimestamp) {
+		return encoding.CodecV2
+	} else {
+		return encoding.CodecV3
+	}
+}
+
+// GetMaxChunksPerBatch returns the maximum number of chunks allowed per batch for the given block height and timestamp.
+// This value may change depending on the active hardfork.
+func GetMaxChunksPerBatch(config *params.ChainConfig, blockHeight, blockTimestamp uint64) uint64 {
+	if !config.IsBernoulli(new(big.Int).SetUint64(blockHeight)) {
+		return 15
+	} else if !config.IsCurie(new(big.Int).SetUint64(blockHeight)) {
+		return 15
+	} else if !config.IsDarwin(blockTimestamp) {
+		return 45
+	} else {
+		return 45
+	}
+}

common/forks/forks_test.go

@@ -33,46 +33,6 @@ func TestCollectSortedForkBlocks(t *testing.T) {
 	}, n)
 }
 
-func TestBlocksUntilFork(t *testing.T) {
-	tests := map[string]struct {
-		block    uint64
-		forks    []uint64
-		expected uint64
-	}{
-		"NoFork": {
-			block:    44,
-			forks:    []uint64{},
-			expected: 0,
-		},
-		"BeforeFork": {
-			block:    0,
-			forks:    []uint64{1, 5},
-			expected: 1,
-		},
-		"OnFork": {
-			block:    1,
-			forks:    []uint64{1, 5},
-			expected: 4,
-		},
-		"OnLastFork": {
-			block:    5,
-			forks:    []uint64{1, 5},
-			expected: 0,
-		},
-		"AfterFork": {
-			block:    5,
-			forks:    []uint64{1, 5},
-			expected: 0,
-		},
-	}
-
-	for name, test := range tests {
-		t.Run(name, func(t *testing.T) {
-			require.Equal(t, test.expected, BlocksUntilFork(test.block, test.forks))
-		})
-	}
-}
-
 func TestBlockRange(t *testing.T) {
 	tests := []struct {
 		name         string

common/go.mod

@@ -13,7 +13,8 @@ require (
 	github.com/modern-go/reflect2 v1.0.2
 	github.com/orcaman/concurrent-map v1.0.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240422045311-246955a4df94
+	github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
 	github.com/stretchr/testify v1.9.0
 	github.com/testcontainers/testcontainers-go v0.30.0
 	github.com/testcontainers/testcontainers-go/modules/compose v0.30.0

common/go.sum

@@ -633,8 +633,10 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240422045311-246955a4df94 h1:yYsneFgHlSmOyCGNMF75t0NQLkNEuIo1jE+GIAOPviw=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240422045311-246955a4df94/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
+github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7 h1:Mx3fKRszn6CMeJ7YBTdjLSfXoSDd9hkP8BwhIaaUVfQ=
+github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/secure-systems-lab/go-securesystemslib v0.4.0 h1:b23VGrQhTA8cN2CbBw7/FulN9fTtqYUdS5+Oxzt+DUE=

common/types/db.go

@@ -188,6 +188,31 @@ func (s ChunkProofsStatus) String() string {
 	}
 }
 
+// BatchProofsStatus describes the proving status of batches that belong to a bundle.
+type BatchProofsStatus int
+
+const (
+	// BatchProofsStatusUndefined represents an undefined batch proofs status
+	BatchProofsStatusUndefined BatchProofsStatus = iota
+
+	// BatchProofsStatusPending means that some batches that belong to this bundle have not been proven
+	BatchProofsStatusPending
+
+	// BatchProofsStatusReady means that all batches that belong to this bundle have been proven
+	BatchProofsStatusReady
+)
+
+func (s BatchProofsStatus) String() string {
+	switch s {
+	case BatchProofsStatusPending:
+		return "BatchProofsStatusPending"
+	case BatchProofsStatusReady:
+		return "BatchProofsStatusReady"
+	default:
+		return fmt.Sprintf("Undefined BatchProofsStatus (%d)", int32(s))
+	}
+}
+
 // RollupStatus block_batch rollup_status (pending, committing, committed, commit_failed, finalizing, finalized, finalize_skipped, finalize_failed)
 type RollupStatus int
 

common/types/message/auth_msg.go

@@ -1,91 +0,0 @@
-package message
-
-import (
-	"crypto/ecdsa"
-
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/common/hexutil"
-	"github.com/scroll-tech/go-ethereum/crypto"
-	"github.com/scroll-tech/go-ethereum/rlp"
-)
-
-// AuthMsg is the first message exchanged from the Prover to the Sequencer.
-// It effectively acts as a registration, and makes the Prover identification
-// known to the Sequencer.
-type AuthMsg struct {
-	// Message fields
-	Identity *Identity `json:"message"`
-	// Prover signature
-	Signature string `json:"signature"`
-}
-
-// Identity contains all the fields to be signed by the prover.
-type Identity struct {
-	// ProverName the prover name
-	ProverName string `json:"prover_name"`
-	// ProverVersion the prover version
-	ProverVersion string `json:"prover_version"`
-	// Challenge unique challenge generated by manager
-	Challenge string `json:"challenge"`
-	// HardForkName the hard fork name
-	HardForkName string `json:"hard_fork_name"`
-}
-
-// SignWithKey auth message with private key and set public key in auth message's Identity
-func (a *AuthMsg) SignWithKey(priv *ecdsa.PrivateKey) error {
-	// Hash identity content
-	hash, err := a.Identity.Hash()
-	if err != nil {
-		return err
-	}
-
-	// Sign register message
-	sig, err := crypto.Sign(hash, priv)
-	if err != nil {
-		return err
-	}
-	a.Signature = hexutil.Encode(sig)
-
-	return nil
-}
-
-// Verify verifies the message of auth.
-func (a *AuthMsg) Verify() (bool, error) {
-	hash, err := a.Identity.Hash()
-	if err != nil {
-		return false, err
-	}
-	sig := common.FromHex(a.Signature)
-
-	pk, err := crypto.SigToPub(hash, sig)
-	if err != nil {
-		return false, err
-	}
-	return crypto.VerifySignature(crypto.CompressPubkey(pk), hash, sig[:len(sig)-1]), nil
-}
-
-// PublicKey return public key from signature
-func (a *AuthMsg) PublicKey() (string, error) {
-	hash, err := a.Identity.Hash()
-	if err != nil {
-		return "", err
-	}
-	sig := common.FromHex(a.Signature)
-	// recover public key
-	pk, err := crypto.SigToPub(hash, sig)
-	if err != nil {
-		return "", err
-	}
-	return common.Bytes2Hex(crypto.CompressPubkey(pk)), nil
-}
-
-// Hash returns the hash of the auth message, which should be the message used
-// to construct the Signature.
-func (i *Identity) Hash() ([]byte, error) {
-	byt, err := rlp.EncodeToBytes(i)
-	if err != nil {
-		return nil, err
-	}
-	hash := crypto.Keccak256Hash(byt)
-	return hash[:], nil
-}

common/types/message/legacy_auth_msg.go

@@ -1,89 +0,0 @@
-package message
-
-import (
-	"crypto/ecdsa"
-
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/common/hexutil"
-	"github.com/scroll-tech/go-ethereum/crypto"
-	"github.com/scroll-tech/go-ethereum/rlp"
-)
-
-// LegacyAuthMsg is the old auth message exchanged from the Prover to the Sequencer.
-// It effectively acts as a registration, and makes the Prover identification
-// known to the Sequencer.
-type LegacyAuthMsg struct {
-	// Message fields
-	Identity *LegacyIdentity `json:"message"`
-	// Prover signature
-	Signature string `json:"signature"`
-}
-
-// LegacyIdentity contains all the fields to be signed by the prover.
-type LegacyIdentity struct {
-	// ProverName the prover name
-	ProverName string `json:"prover_name"`
-	// ProverVersion the prover version
-	ProverVersion string `json:"prover_version"`
-	// Challenge unique challenge generated by manager
-	Challenge string `json:"challenge"`
-}
-
-// SignWithKey auth message with private key and set public key in auth message's Identity
-func (a *LegacyAuthMsg) SignWithKey(priv *ecdsa.PrivateKey) error {
-	// Hash identity content
-	hash, err := a.Identity.Hash()
-	if err != nil {
-		return err
-	}
-
-	// Sign register message
-	sig, err := crypto.Sign(hash, priv)
-	if err != nil {
-		return err
-	}
-	a.Signature = hexutil.Encode(sig)
-
-	return nil
-}
-
-// Verify verifies the message of auth.
-func (a *LegacyAuthMsg) Verify() (bool, error) {
-	hash, err := a.Identity.Hash()
-	if err != nil {
-		return false, err
-	}
-	sig := common.FromHex(a.Signature)
-
-	pk, err := crypto.SigToPub(hash, sig)
-	if err != nil {
-		return false, err
-	}
-	return crypto.VerifySignature(crypto.CompressPubkey(pk), hash, sig[:len(sig)-1]), nil
-}
-
-// PublicKey return public key from signature
-func (a *LegacyAuthMsg) PublicKey() (string, error) {
-	hash, err := a.Identity.Hash()
-	if err != nil {
-		return "", err
-	}
-	sig := common.FromHex(a.Signature)
-	// recover public key
-	pk, err := crypto.SigToPub(hash, sig)
-	if err != nil {
-		return "", err
-	}
-	return common.Bytes2Hex(crypto.CompressPubkey(pk)), nil
-}
-
-// Hash returns the hash of the auth message, which should be the message used
-// to construct the Signature.
-func (i *LegacyIdentity) Hash() ([]byte, error) {
-	byt, err := rlp.EncodeToBytes(i)
-	if err != nil {
-		return nil, err
-	}
-	hash := crypto.Keccak256Hash(byt)
-	return hash[:], nil
-}

common/types/message/message.go

@@ -1,28 +1,11 @@
 package message
 
 import (
-	"crypto/ecdsa"
-	"crypto/rand"
-	"encoding/hex"
 	"errors"
 	"fmt"
 
+	"github.com/scroll-tech/da-codec/encoding/codecv3"
 	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/common/hexutil"
-	"github.com/scroll-tech/go-ethereum/crypto"
-	"github.com/scroll-tech/go-ethereum/rlp"
-)
-
-// ProofFailureType the proof failure type
-type ProofFailureType int
-
-const (
-	// ProofFailureUndefined the undefined type proof failure type
-	ProofFailureUndefined ProofFailureType = iota
-	// ProofFailurePanic proof failure for prover panic
-	ProofFailurePanic
-	// ProofFailureNoPanic proof failure for no prover panic
-	ProofFailureNoPanic
 )
 
 // RespStatus represents status code from prover to scroll
@@ -35,7 +18,7 @@ const (
 	StatusProofError
 )
 
-// ProofType represents the type of prover.
+// ProofType represents the type of task.
 type ProofType uint8
 
 func (r ProofType) String() string {
@@ -44,6 +27,8 @@ func (r ProofType) String() string {
 		return "proof type chunk"
 	case ProofTypeBatch:
 		return "proof type batch"
+	case ProofTypeBundle:
+		return "proof type bundle"
 	default:
 		return fmt.Sprintf("illegal proof type: %d", r)
 	}
@@ -52,93 +37,14 @@ func (r ProofType) String() string {
 const (
 	// ProofTypeUndefined is an unknown proof type
 	ProofTypeUndefined ProofType = iota
-	// ProofTypeChunk is default prover, it only generates zk proof from traces.
+	// ProofTypeChunk generates a proof for a ZkEvm chunk, where the inputs are the execution traces for blocks contained in the chunk. ProofTypeChunk is the default proof type.
 	ProofTypeChunk
-	// ProofTypeBatch generates zk proof from other zk proofs and aggregate them into one proof.
+	// ProofTypeBatch generates zk proof from chunk proofs
 	ProofTypeBatch
+	// ProofTypeBundle generates zk proof from batch proofs
+	ProofTypeBundle
 )
 
-// GenerateToken generates token
-func GenerateToken() (string, error) {
-	b := make([]byte, 16)
-	if _, err := rand.Read(b); err != nil {
-		return "", err
-	}
-	return hex.EncodeToString(b), nil
-}
-
-// ProofMsg is the data structure sent to the coordinator.
-type ProofMsg struct {
-	*ProofDetail `json:"zkProof"`
-	// Prover signature
-	Signature string `json:"signature"`
-
-	// Prover public key
-	publicKey string
-}
-
-// Sign signs the ProofMsg.
-func (a *ProofMsg) Sign(priv *ecdsa.PrivateKey) error {
-	hash, err := a.ProofDetail.Hash()
-	if err != nil {
-		return err
-	}
-	sig, err := crypto.Sign(hash, priv)
-	if err != nil {
-		return err
-	}
-	a.Signature = hexutil.Encode(sig)
-	return nil
-}
-
-// Verify verifies ProofMsg.Signature.
-func (a *ProofMsg) Verify() (bool, error) {
-	hash, err := a.ProofDetail.Hash()
-	if err != nil {
-		return false, err
-	}
-	sig := common.FromHex(a.Signature)
-	// recover public key
-	if a.publicKey == "" {
-		pk, err := crypto.SigToPub(hash, sig)
-		if err != nil {
-			return false, err
-		}
-		a.publicKey = common.Bytes2Hex(crypto.CompressPubkey(pk))
-	}
-
-	return crypto.VerifySignature(common.FromHex(a.publicKey), hash, sig[:len(sig)-1]), nil
-}
-
-// PublicKey return public key from signature
-func (a *ProofMsg) PublicKey() (string, error) {
-	if a.publicKey == "" {
-		hash, err := a.ProofDetail.Hash()
-		if err != nil {
-			return "", err
-		}
-		sig := common.FromHex(a.Signature)
-		// recover public key
-		pk, err := crypto.SigToPub(hash, sig)
-		if err != nil {
-			return "", err
-		}
-		a.publicKey = common.Bytes2Hex(crypto.CompressPubkey(pk))
-		return a.publicKey, nil
-	}
-
-	return a.publicKey, nil
-}
-
-// TaskMsg is a wrapper type around db ProveTask type.
-type TaskMsg struct {
-	UUID            string           `json:"uuid"`
-	ID              string           `json:"id"`
-	Type            ProofType        `json:"type,omitempty"`
-	BatchTaskDetail *BatchTaskDetail `json:"batch_task_detail,omitempty"`
-	ChunkTaskDetail *ChunkTaskDetail `json:"chunk_task_detail,omitempty"`
-}
-
 // ChunkTaskDetail is a type containing ChunkTask detail.
 type ChunkTaskDetail struct {
 	BlockHashes []common.Hash `json:"block_hashes"`
@@ -146,30 +52,22 @@ type ChunkTaskDetail struct {
 
 // BatchTaskDetail is a type containing BatchTask detail.
 type BatchTaskDetail struct {
-	ChunkInfos  []*ChunkInfo  `json:"chunk_infos"`
-	ChunkProofs []*ChunkProof `json:"chunk_proofs"`
+	ChunkInfos      []*ChunkInfo     `json:"chunk_infos"`
+	ChunkProofs     []*ChunkProof    `json:"chunk_proofs"`
+	ParentStateRoot common.Hash      `json:"parent_state_root"`
+	ParentBatchHash common.Hash      `json:"parent_batch_hash"`
+	BatchHeader     *codecv3.DABatch `json:"batch_header"`
 }
 
-// ProofDetail is the message received from provers that contains zk proof, the status of
-// the proof generation succeeded, and an error message if proof generation failed.
-type ProofDetail struct {
-	ID         string      `json:"id"`
-	Type       ProofType   `json:"type,omitempty"`
-	Status     RespStatus  `json:"status"`
-	ChunkProof *ChunkProof `json:"chunk_proof,omitempty"`
-	BatchProof *BatchProof `json:"batch_proof,omitempty"`
-	Error      string      `json:"error,omitempty"`
-}
-
-// Hash return proofMsg content hash.
-func (z *ProofDetail) Hash() ([]byte, error) {
-	byt, err := rlp.EncodeToBytes(z)
-	if err != nil {
-		return nil, err
-	}
-
-	hash := crypto.Keccak256Hash(byt)
-	return hash[:], nil
+// BundleTaskDetail consists of all the information required to describe the task to generate a proof for a bundle of batches.
+type BundleTaskDetail struct {
+	ChainID             uint64        `json:"chain_id"`
+	FinalizedBatchHash  common.Hash   `json:"finalized_batch_hash"`
+	FinalizedStateRoot  common.Hash   `json:"finalized_state_root"`
+	PendingBatchHash    common.Hash   `json:"pending_batch_hash"`
+	PendingStateRoot    common.Hash   `json:"pending_state_root"`
+	PendingWithdrawRoot common.Hash   `json:"pending_withdraw_root"`
+	BatchProofs         []*BatchProof `json:"batch_proofs"`
 }
 
 // ChunkInfo is for calculating pi_hash for chunk
@@ -204,15 +102,16 @@ type ChunkProof struct {
 
 // BatchProof includes the proof info that are required for batch verification and rollup.
 type BatchProof struct {
+	Protocol  []byte `json:"protocol"`
 	Proof     []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"`
+	BatchHash  common.Hash `json:"batch_hash"`
+	GitVersion string      `json:"git_version,omitempty"`
 }
 
-// SanityCheck checks whether an BatchProof is in a legal format
-// TODO: change to check Proof&Instance when upgrading to snark verifier v0.4
+// SanityCheck checks whether a BatchProof is in a legal format
 func (ap *BatchProof) SanityCheck() error {
 	if ap == nil {
 		return errors.New("agg_proof is nil")
@@ -221,8 +120,51 @@ func (ap *BatchProof) SanityCheck() error {
 	if len(ap.Proof) == 0 {
 		return errors.New("proof not ready")
 	}
+
 	if len(ap.Proof)%32 != 0 {
-		return fmt.Errorf("proof buffer has wrong length, expected: 32, got: %d", len(ap.Proof))
+		return fmt.Errorf("proof buffer length must be a multiple of 32, got: %d", len(ap.Proof))
+	}
+
+	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 includes the proof info that are required for verification of a bundle of batch proofs.
+type BundleProof struct {
+	Proof     []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"`
+}
+
+// SanityCheck checks whether a BundleProof is in a legal format
+func (ap *BundleProof) SanityCheck() error {
+	if ap == nil {
+		return errors.New("agg_proof is nil")
+	}
+
+	if len(ap.Proof) == 0 {
+		return errors.New("proof not ready")
+	}
+
+	if len(ap.Proof)%32 != 0 {
+		return fmt.Errorf("proof buffer length must be a multiple of 32, got: %d", len(ap.Proof))
+	}
+
+	if len(ap.Instances) == 0 {
+		return errors.New("instance not ready")
+	}
+
+	if len(ap.Vk) == 0 {
+		return errors.New("vk not ready")
 	}
 
 	return nil

common/types/message/message_test.go

@@ -1,158 +0,0 @@
-package message
-
-import (
-	"encoding/hex"
-	"testing"
-
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/crypto"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAuthMessageSignAndVerify(t *testing.T) {
-	privkey, err := crypto.GenerateKey()
-	assert.NoError(t, err)
-
-	authMsg := &AuthMsg{
-		Identity: &Identity{
-			Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2OTEwMzgxNzUsIm9yaWdfaWF0IjoxNjkxMDM0NTc1fQ.HybBMsEJFhyZqtIa2iVcHUP7CEFttf708jmTMAImAWA",
-			ProverName:    "test",
-			ProverVersion: "v1.0.0",
-		},
-	}
-	assert.NoError(t, authMsg.SignWithKey(privkey))
-
-	// Check public key.
-	pk, err := authMsg.PublicKey()
-	assert.NoError(t, err)
-	assert.Equal(t, common.Bytes2Hex(crypto.CompressPubkey(&privkey.PublicKey)), pk)
-
-	ok, err := authMsg.Verify()
-	assert.NoError(t, err)
-	assert.Equal(t, true, ok)
-
-	// Check public key is ok.
-	pub, err := authMsg.PublicKey()
-	assert.NoError(t, err)
-	pubkey := crypto.CompressPubkey(&privkey.PublicKey)
-	assert.Equal(t, pub, common.Bytes2Hex(pubkey))
-}
-
-func TestGenerateToken(t *testing.T) {
-	token, err := GenerateToken()
-	assert.NoError(t, err)
-	assert.Equal(t, 32, len(token))
-}
-
-func TestIdentityHash(t *testing.T) {
-	identity := &Identity{
-		Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2OTEwMzM0MTksIm9yaWdfaWF0IjoxNjkxMDI5ODE5fQ.EhkLZsj__rNPVC3ZDYBtvdh0nB8mmM_Hl82hObaIWOs",
-		ProverName:    "test",
-		ProverVersion: "v1.0.0",
-	}
-
-	hash, err := identity.Hash()
-	assert.NoError(t, err)
-
-	expectedHash := "9b8b00f5655411ec1d68ba1666261281c5414aedbda932e5b6a9f7f1b114fdf2"
-	assert.Equal(t, expectedHash, hex.EncodeToString(hash))
-}
-
-func TestProofMessageSignVerifyPublicKey(t *testing.T) {
-	privkey, err := crypto.GenerateKey()
-	assert.NoError(t, err)
-
-	proofMsg := &ProofMsg{
-		ProofDetail: &ProofDetail{
-			ID:     "testID",
-			Type:   ProofTypeChunk,
-			Status: StatusOk,
-			ChunkProof: &ChunkProof{
-				StorageTrace: []byte("testStorageTrace"),
-				Protocol:     []byte("testProtocol"),
-				Proof:        []byte("testProof"),
-				Instances:    []byte("testInstance"),
-				Vk:           []byte("testVk"),
-				ChunkInfo:    nil,
-			},
-			Error: "testError",
-		},
-	}
-	assert.NoError(t, proofMsg.Sign(privkey))
-
-	// Test when publicKey is not set.
-	ok, err := proofMsg.Verify()
-	assert.NoError(t, err)
-	assert.Equal(t, true, ok)
-
-	// Test when publicKey is already set.
-	ok, err = proofMsg.Verify()
-	assert.NoError(t, err)
-	assert.Equal(t, true, ok)
-}
-
-func TestProofDetailHash(t *testing.T) {
-	proofDetail := &ProofDetail{
-		ID:     "testID",
-		Type:   ProofTypeChunk,
-		Status: StatusOk,
-		ChunkProof: &ChunkProof{
-			StorageTrace: []byte("testStorageTrace"),
-			Protocol:     []byte("testProtocol"),
-			Proof:        []byte("testProof"),
-			Instances:    []byte("testInstance"),
-			Vk:           []byte("testVk"),
-			ChunkInfo:    nil,
-		},
-		Error: "testError",
-	}
-	hash, err := proofDetail.Hash()
-	assert.NoError(t, err)
-	expectedHash := "01128ea9006601146ba80dbda959c96ebaefca463e78570e473a57d821db5ec1"
-	assert.Equal(t, expectedHash, hex.EncodeToString(hash))
-}
-
-func TestProveTypeString(t *testing.T) {
-	proofTypeChunk := ProofType(1)
-	assert.Equal(t, "proof type chunk", proofTypeChunk.String())
-
-	proofTypeBatch := ProofType(2)
-	assert.Equal(t, "proof type batch", proofTypeBatch.String())
-
-	illegalProof := ProofType(3)
-	assert.Equal(t, "illegal proof type: 3", illegalProof.String())
-}
-
-func TestProofMsgPublicKey(t *testing.T) {
-	privkey, err := crypto.GenerateKey()
-	assert.NoError(t, err)
-
-	proofMsg := &ProofMsg{
-		ProofDetail: &ProofDetail{
-			ID:     "testID",
-			Type:   ProofTypeChunk,
-			Status: StatusOk,
-			ChunkProof: &ChunkProof{
-				StorageTrace: []byte("testStorageTrace"),
-				Protocol:     []byte("testProtocol"),
-				Proof:        []byte("testProof"),
-				Instances:    []byte("testInstance"),
-				Vk:           []byte("testVk"),
-				ChunkInfo:    nil,
-			},
-			Error: "testError",
-		},
-	}
-	assert.NoError(t, proofMsg.Sign(privkey))
-
-	// Test when publicKey is not set.
-	pk, err := proofMsg.PublicKey()
-	assert.NoError(t, err)
-	assert.Equal(t, common.Bytes2Hex(crypto.CompressPubkey(&privkey.PublicKey)), pk)
-
-	// Test when publicKey is already set.
-	proofMsg.publicKey = common.Bytes2Hex(crypto.CompressPubkey(&privkey.PublicKey))
-	pk, err = proofMsg.PublicKey()
-	assert.NoError(t, err)
-	assert.Equal(t, common.Bytes2Hex(crypto.CompressPubkey(&privkey.PublicKey)), pk)
-}

common/utils/simulation.go

@@ -12,12 +12,8 @@ import (
 type MockAppName string
 
 var (
-	// EventWatcherApp the name of mock event-watcher app.
-	EventWatcherApp MockAppName = "event-watcher-test"
 	// GasOracleApp the name of mock gas-oracle app.
 	GasOracleApp MockAppName = "gas-oracle-test"
-	// MessageRelayerApp the name of mock message-relayer app.
-	MessageRelayerApp MockAppName = "message-relayer-test"
 	// RollupRelayerApp the name of mock rollup-relayer app.
 	RollupRelayerApp MockAppName = "rollup-relayer-test"
 
@@ -28,11 +24,6 @@ var (
 	CoordinatorAPIApp MockAppName = "coordinator-api-test"
 	// CoordinatorCronApp the name of mock coordinator cron app.
 	CoordinatorCronApp MockAppName = "coordinator-cron-test"
-
-	// ChunkProverApp the name of mock chunk prover app.
-	ChunkProverApp MockAppName = "chunkProver-test"
-	// BatchProverApp the name of mock batch prover app.
-	BatchProverApp MockAppName = "batchProver-test"
 )
 
 // RegisterSimulation register initializer function for integration-test.

common/version/version.go

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

coordinator/Makefile

@@ -27,7 +27,7 @@ coordinator_cron:
 	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_cron ./cmd/cron
 
 coordinator_api_skip_libzkp:
-	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_api ./cmd/api
+	CGO_ENABLED=1 CGO_LDFLAGS="-ldl" go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_api ./cmd/api
 
 mock_coordinator_api: ## Builds the mocked Coordinator instance.
 	go build -tags="mock_prover mock_verifier" -o $(PWD)/build/bin/coordinator_api ./cmd/api
@@ -54,4 +54,4 @@ docker:
 
 docker_push:
 	docker push scrolltech/coordinator-api:${IMAGE_VERSION}
-	docker push scrolltech/coordinator-cron:${IMAGE_VERSION}
+	docker push scrolltech/coordinator-cron:${IMAGE_VERSION}

coordinator/conf/config.json

@@ -2,6 +2,7 @@
   "prover_manager": {
     "provers_per_session": 1,
     "session_attempts": 5,
+    "bundle_collection_time_sec": 180,
     "batch_collection_time_sec": 180,
     "chunk_collection_time_sec": 180,
     "verifier": {
@@ -24,7 +25,7 @@
   },
   "auth": {
     "secret": "prover secret key",
-    "challenge_expire_duration_sec": 10,
+    "challenge_expire_duration_sec": 3600,
     "login_expire_duration_sec": 3600
   }
 }

coordinator/go.mod

@@ -6,8 +6,11 @@ require (
 	github.com/appleboy/gin-jwt/v2 v2.9.1
 	github.com/gin-gonic/gin v1.9.1
 	github.com/go-resty/resty/v2 v2.7.0
+	github.com/google/uuid v1.6.0
 	github.com/mitchellh/mapstructure v1.5.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240426041101-a860446ebaea
+	github.com/prometheus/client_golang v1.19.0
+	github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
 	github.com/shopspring/decimal v1.3.1
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
@@ -15,43 +18,13 @@ require (
 	gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde
 )
 
-require (
-	github.com/bytedance/sonic v1.10.1 // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
-	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
-	github.com/gin-contrib/sse v0.1.0 // indirect
-	github.com/go-playground/locales v0.14.1 // indirect
-	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.15.5 // indirect
-	github.com/goccy/go-json v0.10.2 // indirect
-	github.com/golang-jwt/jwt/v4 v4.5.0 // indirect
-	github.com/jinzhu/inflection v1.0.0 // indirect
-	github.com/jinzhu/now v1.1.5 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
-	github.com/leodido/go-urn v1.2.4 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/pelletier/go-toml/v2 v2.1.0 // indirect
-	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
-	github.com/ugorji/go/codec v1.2.11 // indirect
-	golang.org/x/net v0.21.0 // indirect
-	golang.org/x/text v0.16.0 // indirect
-	google.golang.org/protobuf v1.33.0 // indirect
-)
-
-require (
-	github.com/google/uuid v1.6.0
-	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/da-codec v0.1.0
-)
-
 require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bits-and-blooms/bitset v1.13.0 // indirect
 	github.com/btcsuite/btcd v0.20.1-beta // indirect
+	github.com/bytedance/sonic v1.10.1 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
 	github.com/chenzhuoyu/iasm v0.9.0 // indirect
 	github.com/consensys/bavard v0.1.13 // indirect
 	github.com/consensys/gnark-crypto v0.12.1 // indirect
@@ -59,11 +32,27 @@ require (
 	github.com/crate-crypto/go-kzg-4844 v1.0.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/ethereum/c-kzg-4844 v1.0.2 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.15.5 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/golang-jwt/jwt/v4 v4.5.0 // indirect
 	github.com/holiman/uint256 v1.2.4 // indirect
 	github.com/iden3/go-iden3-crypto v0.0.16 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mmcloughlin/addchain v0.4.0 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.1.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/prometheus/client_model v0.5.0 // indirect
 	github.com/prometheus/common v0.48.0 // indirect
@@ -74,11 +63,16 @@ require (
 	github.com/supranational/blst v0.3.12 // indirect
 	github.com/tklauser/go-sysconf v0.3.14 // indirect
 	github.com/tklauser/numcpus v0.8.0 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	golang.org/x/crypto v0.24.0 // indirect
+	golang.org/x/net v0.21.0 // indirect
 	golang.org/x/sync v0.7.0 // indirect
 	golang.org/x/sys v0.21.0 // indirect
+	golang.org/x/text v0.16.0 // indirect
+	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	rsc.io/tmplfunc v0.0.3 // indirect
 )

coordinator/go.sum

@@ -173,10 +173,10 @@ github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjR
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 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.0 h1:osgX8MwP4jGHVlR9TpGjkzmiochCneyuB1Z/VUFGyXg=
-github.com/scroll-tech/da-codec v0.1.0/go.mod h1:1wWYii0OPwd5kw+xrz0PFgS420xNadrNF1x/ELJT+TM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240426041101-a860446ebaea h1:CH1WXWrpEpLaP3N+bFs2a1xdE0+lRm1AuJQb5YvE6Ls=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240426041101-a860446ebaea/go.mod h1:i4VBgWoaW/y0D8MmQb7hSOulyw1dKhuiSFAbznwivCA=
+github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7 h1:Mx3fKRszn6CMeJ7YBTdjLSfXoSDd9hkP8BwhIaaUVfQ=
+github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=

coordinator/internal/config/config.go

@@ -21,6 +21,8 @@ type ProverManager struct {
 	BatchCollectionTimeSec int `json:"batch_collection_time_sec"`
 	// ChunkCollectionTimeSec chunk Proof collection time (in seconds).
 	ChunkCollectionTimeSec int `json:"chunk_collection_time_sec"`
+	// BundleCollectionTimeSec bundle Proof collection time (in seconds).
+	BundleCollectionTimeSec int `json:"bundle_collection_time_sec"`
 	// Max number of workers in verifier worker pool
 	MaxVerifierWorkers int `json:"max_verifier_workers"`
 	// MinProverVersion is the minimum version of the prover that is required.

coordinator/internal/controller/api/auth.go

@@ -1,15 +1,16 @@
 package api
 
 import (
+	"errors"
 	"fmt"
 
 	jwt "github.com/appleboy/gin-jwt/v2"
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 
-	"scroll-tech/common/types/message"
-
+	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/logic/auth"
+	"scroll-tech/coordinator/internal/logic/verifier"
 	"scroll-tech/coordinator/internal/types"
 )
 
@@ -19,9 +20,9 @@ type AuthController struct {
 }
 
 // NewAuthController returns an LoginController instance
-func NewAuthController(db *gorm.DB) *AuthController {
+func NewAuthController(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *AuthController {
 	return &AuthController{
-		loginLogic: auth.NewLoginLogic(db),
+		loginLogic: auth.NewLoginLogic(db, cfg, vf),
 	}
 }
 
@@ -36,7 +37,11 @@ func (a *AuthController) Login(c *gin.Context) (interface{}, error) {
 	// if not exist, the jwt token will intercept it
 	brearToken := c.GetHeader("Authorization")
 	if brearToken != "Bearer "+login.Message.Challenge {
-		return "", fmt.Errorf("check challenge failure for the not equal challenge string")
+		return "", errors.New("check challenge failure for the not equal challenge string")
+	}
+
+	if err := a.loginLogic.Check(&login); err != nil {
+		return "", fmt.Errorf("check the login parameter failure: %w", err)
 	}
 
 	// check the challenge is used, if used, return failure
@@ -53,44 +58,10 @@ func (a *AuthController) PayloadFunc(data interface{}) jwt.MapClaims {
 		return jwt.MapClaims{}
 	}
 
-	var publicKey string
-	var err error
-	if v.Message.HardForkName != "" {
-		authMsg := message.AuthMsg{
-			Identity: &message.Identity{
-				Challenge:     v.Message.Challenge,
-				ProverName:    v.Message.ProverName,
-				ProverVersion: v.Message.ProverVersion,
-				HardForkName:  v.Message.HardForkName,
-			},
-			Signature: v.Signature,
-		}
-		publicKey, err = authMsg.PublicKey()
-	} else {
-		authMsg := message.LegacyAuthMsg{
-			Identity: &message.LegacyIdentity{
-				Challenge:     v.Message.Challenge,
-				ProverName:    v.Message.ProverName,
-				ProverVersion: v.Message.ProverVersion,
-			},
-			Signature: v.Signature,
-		}
-		publicKey, err = authMsg.PublicKey()
-	}
-
-	if err != nil {
-		return jwt.MapClaims{}
-	}
-
-	if v.Message.HardForkName == "" {
-		v.Message.HardForkName = "shanghai"
-	}
-
 	return jwt.MapClaims{
-		types.PublicKey:     publicKey,
+		types.PublicKey:     v.PublicKey,
 		types.ProverName:    v.Message.ProverName,
 		types.ProverVersion: v.Message.ProverVersion,
-		types.HardForkName:  v.Message.HardForkName,
 	}
 }
 
@@ -108,9 +79,5 @@ func (a *AuthController) IdentityHandler(c *gin.Context) interface{} {
 	if proverVersion, ok := claims[types.ProverVersion]; ok {
 		c.Set(types.ProverVersion, proverVersion)
 	}
-
-	if hardForkName, ok := claims[types.HardForkName]; ok {
-		c.Set(types.HardForkName, hardForkName)
-	}
 	return nil
 }

coordinator/internal/controller/api/controller.go

@@ -28,7 +28,7 @@ func InitController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.D
 
 	log.Info("verifier created", "chunkVerifier", vf.ChunkVKMap, "batchVerifier", vf.BatchVKMap)
 
-	Auth = NewAuthController(db)
-	GetTask = NewGetTaskController(cfg, chainCfg, db, vf, reg)
-	SubmitProof = NewSubmitProofController(cfg, db, vf, reg)
+	Auth = NewAuthController(db, cfg, vf)
+	GetTask = NewGetTaskController(cfg, chainCfg, db, reg)
+	SubmitProof = NewSubmitProofController(cfg, chainCfg, db, vf, reg)
 }

coordinator/internal/controller/api/get_task.go

@@ -16,7 +16,6 @@ import (
 
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/logic/provertask"
-	"scroll-tech/coordinator/internal/logic/verifier"
 	coordinatorType "scroll-tech/coordinator/internal/types"
 )
 
@@ -28,9 +27,10 @@ type GetTaskController struct {
 }
 
 // NewGetTaskController create a get prover task controller
-func NewGetTaskController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, vf *verifier.Verifier, reg prometheus.Registerer) *GetTaskController {
-	chunkProverTask := provertask.NewChunkProverTask(cfg, chainCfg, db, vf.ChunkVKMap, reg)
-	batchProverTask := provertask.NewBatchProverTask(cfg, chainCfg, db, vf.BatchVKMap, reg)
+func NewGetTaskController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *GetTaskController {
+	chunkProverTask := provertask.NewChunkProverTask(cfg, chainCfg, db, reg)
+	batchProverTask := provertask.NewBatchProverTask(cfg, chainCfg, db, reg)
+	bundleProverTask := provertask.NewBundleProverTask(cfg, chainCfg, db, reg)
 
 	ptc := &GetTaskController{
 		proverTasks: make(map[message.ProofType]provertask.ProverTask),
@@ -42,7 +42,7 @@ func NewGetTaskController(cfg *config.Config, chainCfg *params.ChainConfig, db *
 
 	ptc.proverTasks[message.ProofTypeChunk] = chunkProverTask
 	ptc.proverTasks[message.ProofTypeBatch] = batchProverTask
-
+	ptc.proverTasks[message.ProofTypeBundle] = bundleProverTask
 	return ptc
 }
 
@@ -106,18 +106,25 @@ func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 }
 
 func (ptc *GetTaskController) proofType(para *coordinatorType.GetTaskParameter) message.ProofType {
-	proofType := message.ProofType(para.TaskType)
-
-	proofTypes := []message.ProofType{
-		message.ProofTypeChunk,
-		message.ProofTypeBatch,
+	var proofTypes []message.ProofType
+	if para.TaskType != 0 {
+		proofTypes = append(proofTypes, message.ProofType(para.TaskType))
 	}
 
-	if proofType == message.ProofTypeUndefined {
-		rand.Shuffle(len(proofTypes), func(i, j int) {
-			proofTypes[i], proofTypes[j] = proofTypes[j], proofTypes[i]
-		})
-		proofType = proofTypes[0]
+	for _, proofType := range para.TaskTypes {
+		proofTypes = append(proofTypes, message.ProofType(proofType))
 	}
-	return proofType
+
+	if len(proofTypes) == 0 {
+		proofTypes = []message.ProofType{
+			message.ProofTypeChunk,
+			message.ProofTypeBatch,
+			message.ProofTypeBundle,
+		}
+	}
+
+	rand.Shuffle(len(proofTypes), func(i, j int) {
+		proofTypes[i], proofTypes[j] = proofTypes[j], proofTypes[i]
+	})
+	return proofTypes[0]
 }

coordinator/internal/controller/api/submit_proof.go

@@ -1,15 +1,14 @@
 package api
 
 import (
-	"encoding/json"
 	"fmt"
 
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
 	"scroll-tech/common/types"
-	"scroll-tech/common/types/message"
 
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/logic/submitproof"
@@ -23,9 +22,9 @@ type SubmitProofController struct {
 }
 
 // NewSubmitProofController create the submit proof api controller instance
-func NewSubmitProofController(cfg *config.Config, db *gorm.DB, vf *verifier.Verifier, reg prometheus.Registerer) *SubmitProofController {
+func NewSubmitProofController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, vf *verifier.Verifier, reg prometheus.Registerer) *SubmitProofController {
 	return &SubmitProofController{
-		submitProofReceiverLogic: submitproof.NewSubmitProofReceiverLogic(cfg.ProverManager, db, vf, reg),
+		submitProofReceiverLogic: submitproof.NewSubmitProofReceiverLogic(cfg.ProverManager, chainCfg, db, vf, reg),
 	}
 }
 
@@ -38,36 +37,7 @@ func (spc *SubmitProofController) SubmitProof(ctx *gin.Context) {
 		return
 	}
 
-	proofMsg := message.ProofMsg{
-		ProofDetail: &message.ProofDetail{
-			ID:     spp.TaskID,
-			Type:   message.ProofType(spp.TaskType),
-			Status: message.RespStatus(spp.Status),
-		},
-	}
-
-	if spp.Status == int(message.StatusOk) {
-		switch message.ProofType(spp.TaskType) {
-		case message.ProofTypeChunk:
-			var tmpChunkProof message.ChunkProof
-			if err := json.Unmarshal([]byte(spp.Proof), &tmpChunkProof); err != nil {
-				nerr := fmt.Errorf("unmarshal parameter chunk proof invalid, err:%w", err)
-				types.RenderFailure(ctx, types.ErrCoordinatorParameterInvalidNo, nerr)
-				return
-			}
-			proofMsg.ChunkProof = &tmpChunkProof
-		case message.ProofTypeBatch:
-			var tmpBatchProof message.BatchProof
-			if err := json.Unmarshal([]byte(spp.Proof), &tmpBatchProof); err != nil {
-				nerr := fmt.Errorf("unmarshal parameter batch proof invalid, err:%w", err)
-				types.RenderFailure(ctx, types.ErrCoordinatorParameterInvalidNo, nerr)
-				return
-			}
-			proofMsg.BatchProof = &tmpBatchProof
-		}
-	}
-
-	if err := spc.submitProofReceiverLogic.HandleZkProof(ctx, &proofMsg, spp); err != nil {
+	if err := spc.submitProofReceiverLogic.HandleZkProof(ctx, spp); err != nil {
 		nerr := fmt.Errorf("handle zk proof failure, err:%w", err)
 		types.RenderFailure(ctx, types.ErrCoordinatorHandleZkProofFailure, nerr)
 		return

coordinator/internal/controller/cron/collect_proof.go

@@ -23,38 +23,55 @@ type Collector struct {
 	db  *gorm.DB
 	ctx context.Context
 
-	stopChunkTimeoutChan       chan struct{}
-	stopBatchTimeoutChan       chan struct{}
-	stopBatchAllChunkReadyChan chan struct{}
-	stopCleanChallengeChan     chan struct{}
+	stopBundleTimeoutChan       chan struct{}
+	stopChunkTimeoutChan        chan struct{}
+	stopBatchTimeoutChan        chan struct{}
+	stopBatchAllChunkReadyChan  chan struct{}
+	stopBundleAllBatchReadyChan chan struct{}
+	stopCleanChallengeChan      chan struct{}
 
 	proverTaskOrm *orm.ProverTask
+	bundleOrm     *orm.Bundle
 	chunkOrm      *orm.Chunk
 	batchOrm      *orm.Batch
 	challenge     *orm.Challenge
 
-	timeoutBatchCheckerRunTotal     prometheus.Counter
-	batchProverTaskTimeoutTotal     prometheus.Counter
-	timeoutChunkCheckerRunTotal     prometheus.Counter
-	chunkProverTaskTimeoutTotal     prometheus.Counter
-	checkBatchAllChunkReadyRunTotal prometheus.Counter
+	timeoutBundleCheckerRunTotal     prometheus.Counter
+	bundleProverTaskTimeoutTotal     prometheus.Counter
+	timeoutBatchCheckerRunTotal      prometheus.Counter
+	batchProverTaskTimeoutTotal      prometheus.Counter
+	timeoutChunkCheckerRunTotal      prometheus.Counter
+	chunkProverTaskTimeoutTotal      prometheus.Counter
+	checkBatchAllChunkReadyRunTotal  prometheus.Counter
+	checkBundleAllBatchReadyRunTotal prometheus.Counter
 }
 
 // NewCollector create a collector to cron collect the data to send to prover
 func NewCollector(ctx context.Context, db *gorm.DB, cfg *config.Config, reg prometheus.Registerer) *Collector {
 	c := &Collector{
-		cfg:                        cfg,
-		db:                         db,
-		ctx:                        ctx,
-		stopChunkTimeoutChan:       make(chan struct{}),
-		stopBatchTimeoutChan:       make(chan struct{}),
-		stopBatchAllChunkReadyChan: make(chan struct{}),
-		stopCleanChallengeChan:     make(chan struct{}),
-		proverTaskOrm:              orm.NewProverTask(db),
-		chunkOrm:                   orm.NewChunk(db),
-		batchOrm:                   orm.NewBatch(db),
-		challenge:                  orm.NewChallenge(db),
+		cfg:                         cfg,
+		db:                          db,
+		ctx:                         ctx,
+		stopBundleTimeoutChan:       make(chan struct{}),
+		stopChunkTimeoutChan:        make(chan struct{}),
+		stopBatchTimeoutChan:        make(chan struct{}),
+		stopBatchAllChunkReadyChan:  make(chan struct{}),
+		stopBundleAllBatchReadyChan: make(chan struct{}),
+		stopCleanChallengeChan:      make(chan struct{}),
+		proverTaskOrm:               orm.NewProverTask(db),
+		chunkOrm:                    orm.NewChunk(db),
+		batchOrm:                    orm.NewBatch(db),
+		bundleOrm:                   orm.NewBundle(db),
+		challenge:                   orm.NewChallenge(db),
 
+		timeoutBundleCheckerRunTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+			Name: "coordinator_bundle_timeout_checker_run_total",
+			Help: "Total number of bundle timeout checker run.",
+		}),
+		bundleProverTaskTimeoutTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+			Name: "coordinator_bundle_prover_task_timeout_total",
+			Help: "Total number of bundle timeout prover task.",
+		}),
 		timeoutBatchCheckerRunTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 			Name: "coordinator_batch_timeout_checker_run_total",
 			Help: "Total number of batch timeout checker run.",
@@ -75,11 +92,17 @@ func NewCollector(ctx context.Context, db *gorm.DB, cfg *config.Config, reg prom
 			Name: "coordinator_check_batch_all_chunk_ready_run_total",
 			Help: "Total number of check batch all chunks ready total",
 		}),
+		checkBundleAllBatchReadyRunTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+			Name: "coordinator_check_bundle_all_batch_ready_run_total",
+			Help: "Total number of check bundle all batches ready total",
+		}),
 	}
 
+	go c.timeoutBundleProofTask()
 	go c.timeoutBatchProofTask()
 	go c.timeoutChunkProofTask()
 	go c.checkBatchAllChunkReady()
+	go c.checkBundleAllBatchReady()
 	go c.cleanupChallenge()
 
 	log.Info("Start coordinator cron successfully.")
@@ -91,10 +114,45 @@ func NewCollector(ctx context.Context, db *gorm.DB, cfg *config.Config, reg prom
 func (c *Collector) Stop() {
 	c.stopChunkTimeoutChan <- struct{}{}
 	c.stopBatchTimeoutChan <- struct{}{}
+	c.stopBundleTimeoutChan <- struct{}{}
 	c.stopBatchAllChunkReadyChan <- struct{}{}
 	c.stopCleanChallengeChan <- struct{}{}
 }
 
+// timeoutBundleProofTask cron checks the send task is timeout. if timeout reached, restore the
+// bundle task to unassigned. then the bundle collector can retry it.
+func (c *Collector) timeoutBundleProofTask() {
+	defer func() {
+		if err := recover(); err != nil {
+			nerr := fmt.Errorf("timeout bundle proof task panic error:%v", err)
+			log.Warn(nerr.Error())
+		}
+	}()
+
+	ticker := time.NewTicker(time.Second * 2)
+	for {
+		select {
+		case <-ticker.C:
+			c.timeoutBundleCheckerRunTotal.Inc()
+			timeout := time.Duration(c.cfg.ProverManager.BundleCollectionTimeSec) * time.Second
+			assignedProverTasks, err := c.proverTaskOrm.GetTimeoutAssignedProverTasks(c.ctx, 10, message.ProofTypeBundle, timeout)
+			if err != nil {
+				log.Error("get unassigned session info failure", "error", err)
+				break
+			}
+			c.check(assignedProverTasks, c.bundleProverTaskTimeoutTotal)
+		case <-c.ctx.Done():
+			if c.ctx.Err() != nil {
+				log.Error("manager context canceled with error", "error", c.ctx.Err())
+			}
+			return
+		case <-c.stopBundleTimeoutChan:
+			log.Info("the coordinator timeoutBundleProofTask run loop exit")
+			return
+		}
+	}
+}
+
 // timeoutBatchProofTask cron check the send task is timeout. if timeout reached, restore the
 // chunk/batch task to unassigned. then the batch/chunk collector can retry it.
 func (c *Collector) timeoutBatchProofTask() {
@@ -202,6 +260,16 @@ func (c *Collector) check(assignedProverTasks []orm.ProverTask, timeout promethe
 					log.Error("update proving status failed failure", "uuid", assignedProverTask.UUID, "hash", assignedProverTask.TaskID, "pubKey", assignedProverTask.ProverPublicKey, "err", err)
 					return err
 				}
+			case message.ProofTypeBundle:
+				if err := c.bundleOrm.DecreaseActiveAttemptsByHash(c.ctx, assignedProverTask.TaskID, tx); err != nil {
+					log.Error("decrease bundle active attempts failure", "uuid", assignedProverTask.UUID, "hash", assignedProverTask.TaskID, "pubKey", assignedProverTask.ProverPublicKey, "err", err)
+					return err
+				}
+
+				if err := c.bundleOrm.UpdateProvingStatusFailed(c.ctx, assignedProverTask.TaskID, c.cfg.ProverManager.SessionAttempts, tx); err != nil {
+					log.Error("update proving status failed failure", "uuid", assignedProverTask.UUID, "hash", assignedProverTask.TaskID, "pubKey", assignedProverTask.ProverPublicKey, "err", err)
+					return err
+				}
 			}
 
 			return nil
@@ -268,3 +336,60 @@ func (c *Collector) checkBatchAllChunkReady() {
 		}
 	}
 }
+
+func (c *Collector) checkBundleAllBatchReady() {
+	defer func() {
+		if err := recover(); err != nil {
+			nerr := fmt.Errorf("check batch all batches ready panic error:%v", err)
+			log.Warn(nerr.Error())
+		}
+	}()
+
+	ticker := time.NewTicker(time.Second * 10)
+	for {
+		select {
+		case <-ticker.C:
+			c.checkBundleAllBatchReadyRunTotal.Inc()
+			page := 1
+			pageSize := 50
+			for {
+				offset := (page - 1) * pageSize
+				bundles, err := c.bundleOrm.GetUnassignedAndBatchesUnreadyBundles(c.ctx, offset, pageSize)
+				if err != nil {
+					log.Warn("checkBundleAllBatchReady GetUnassignedAndBatchesUnreadyBundles", "error", err)
+					break
+				}
+
+				for _, bundle := range bundles {
+					allReady, checkErr := c.batchOrm.CheckIfBundleBatchProofsAreReady(c.ctx, bundle.Hash)
+					if checkErr != nil {
+						log.Warn("checkBatchAllChunkReady CheckIfBatchChunkProofsAreReady failure", "error", checkErr, "hash", bundle.Hash)
+						continue
+					}
+
+					if !allReady {
+						continue
+					}
+
+					if updateErr := c.bundleOrm.UpdateBatchProofsStatusByBatchHash(c.ctx, bundle.Hash, types.BatchProofsStatusReady); updateErr != nil {
+						log.Warn("checkBundleAllBatchReady UpdateBatchProofsStatusByBatchHash failure", "error", checkErr, "hash", bundle.Hash)
+					}
+				}
+
+				if len(bundles) < pageSize {
+					break
+				}
+				page++
+			}
+
+		case <-c.ctx.Done():
+			if c.ctx.Err() != nil {
+				log.Error("manager context canceled with error", "error", c.ctx.Err())
+			}
+			return
+		case <-c.stopBundleAllBatchReadyChan:
+			log.Info("the coordinator checkBundleAllBatchReady run loop exit")
+			return
+		}
+	}
+}

coordinator/internal/logic/auth/login.go

@@ -1,25 +1,104 @@
 package auth
 
 import (
+	"errors"
+	"fmt"
+
 	"github.com/gin-gonic/gin"
+	"github.com/scroll-tech/go-ethereum/log"
 	"gorm.io/gorm"
 
+	"scroll-tech/common/version"
+
+	"scroll-tech/coordinator/internal/config"
+	"scroll-tech/coordinator/internal/logic/verifier"
 	"scroll-tech/coordinator/internal/orm"
+	"scroll-tech/coordinator/internal/types"
 )
 
 // LoginLogic the auth logic
 type LoginLogic struct {
+	cfg          *config.Config
 	challengeOrm *orm.Challenge
+	chunkVks     map[string]struct{}
+	batchVKs     map[string]struct{}
+	bundleVks    map[string]struct{}
 }
 
 // NewLoginLogic new a LoginLogic
-func NewLoginLogic(db *gorm.DB) *LoginLogic {
-	return &LoginLogic{
+func NewLoginLogic(db *gorm.DB, cfg *config.Config, vf *verifier.Verifier) *LoginLogic {
+	l := &LoginLogic{
+		cfg:          cfg,
+		chunkVks:     make(map[string]struct{}),
+		batchVKs:     make(map[string]struct{}),
+		bundleVks:    make(map[string]struct{}),
 		challengeOrm: orm.NewChallenge(db),
 	}
+
+	for _, vk := range vf.ChunkVKMap {
+		l.chunkVks[vk] = struct{}{}
+	}
+
+	for _, vk := range vf.BatchVKMap {
+		l.batchVKs[vk] = struct{}{}
+	}
+
+	for _, vk := range vf.BundleVkMap {
+		l.bundleVks[vk] = struct{}{}
+	}
+
+	return l
 }
 
 // InsertChallengeString insert and check the challenge string is existed
 func (l *LoginLogic) InsertChallengeString(ctx *gin.Context, challenge string) error {
 	return l.challengeOrm.InsertChallenge(ctx.Copy(), challenge)
 }
+
+func (l *LoginLogic) Check(login *types.LoginParameter) error {
+	if login.PublicKey != "" {
+		verify, err := login.Verify()
+		if err != nil || !verify {
+			return errors.New("auth message verify failure")
+		}
+	}
+
+	if !version.CheckScrollRepoVersion(login.Message.ProverVersion, l.cfg.ProverManager.MinProverVersion) {
+		return fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s",
+			l.cfg.ProverManager.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{}{}
+				}
+			default:
+				log.Error("invalid prover_type", "value", proverType)
+			}
+		}
+
+		for _, vk := range login.Message.VKs {
+			if _, ok := vks[vk]; !ok {
+				log.Error("vk inconsistency", "prover vk", vk)
+				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 fmt.Errorf("incompatible vk. please check your params files or config files")
+			}
+		}
+	}
+	return nil
+}

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -4,12 +4,12 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"math"
 	"time"
 
 	"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/codecv3"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/params"
@@ -35,18 +35,13 @@ type BatchProverTask struct {
 }
 
 // NewBatchProverTask new a batch collector
-func NewBatchProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, vkMap map[string]string, reg prometheus.Registerer) *BatchProverTask {
-	forkHeights, _, nameForkMap := forks.CollectSortedForkHeights(chainCfg)
-	log.Info("new batch prover task", "forkHeights", forkHeights, "nameForks", nameForkMap)
-
+func NewBatchProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *BatchProverTask {
 	bp := &BatchProverTask{
 		BaseProverTask: BaseProverTask{
-			vkMap:              vkMap,
-			reverseVkMap:       reverseMap(vkMap),
 			db:                 db,
 			cfg:                cfg,
-			nameForkMap:        nameForkMap,
-			forkHeights:        forkHeights,
+			chainCfg:           chainCfg,
+			blockOrm:           orm.NewL2Block(db),
 			chunkOrm:           orm.NewChunk(db),
 			batchOrm:           orm.NewBatch(db),
 			proverTaskOrm:      orm.NewProverTask(db),
@@ -65,38 +60,20 @@ func NewBatchProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *go
 	return bp
 }
 
-type chunkIndexRange struct {
-	start uint64
-	end   uint64
-}
-
-func (r *chunkIndexRange) merge(o chunkIndexRange) *chunkIndexRange {
-	var start, end = r.start, r.end
-	if o.start < r.start {
-		start = o.start
+// Assign load and assign batch tasks
+func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error) {
+	taskCtx, err := bp.checkParameter(ctx)
+	if err != nil || taskCtx == nil {
+		return nil, fmt.Errorf("check prover task parameter failed, error:%w", err)
 	}
-	if o.end > r.end {
-		end = o.end
-	}
-	return &chunkIndexRange{start, end}
-}
 
-func (r *chunkIndexRange) contains(start, end uint64) bool {
-	return r.start <= start && r.end > end
-}
-
-type getHardForkNameByBatchFunc func(*orm.Batch) (string, error)
-
-func (bp *BatchProverTask) doAssignTaskWithinChunkRange(ctx *gin.Context, taskCtx *proverTaskContext,
-	chunkRange *chunkIndexRange, getTaskParameter *coordinatorType.GetTaskParameter, getHardForkName getHardForkNameByBatchFunc) (*coordinatorType.GetTaskSchema, error) {
-	startChunkIndex, endChunkIndex := chunkRange.start, chunkRange.end
 	maxActiveAttempts := bp.cfg.ProverManager.ProversPerSession
 	maxTotalAttempts := bp.cfg.ProverManager.SessionAttempts
 	var batchTask *orm.Batch
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpBatchTask *orm.Batch
-		tmpBatchTask, getTaskError = bp.batchOrm.GetAssignedBatch(ctx.Copy(), startChunkIndex, endChunkIndex, maxActiveAttempts, maxTotalAttempts)
+		tmpBatchTask, getTaskError = bp.batchOrm.GetAssignedBatch(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
 		if getTaskError != nil {
 			log.Error("failed to get assigned batch proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 			return nil, ErrCoordinatorInternalFailure
@@ -105,7 +82,7 @@ func (bp *BatchProverTask) doAssignTaskWithinChunkRange(ctx *gin.Context, taskCt
 		// Why here need get again? In order to support a task can assign to multiple prover, need also assign `ProvingTaskAssigned`
 		// batch to prover. But use `proving_status in (1, 2)` will not use the postgres index. So need split the sql.
 		if tmpBatchTask == nil {
-			tmpBatchTask, getTaskError = bp.batchOrm.GetUnassignedBatch(ctx.Copy(), startChunkIndex, endChunkIndex, maxActiveAttempts, maxTotalAttempts)
+			tmpBatchTask, getTaskError = bp.batchOrm.GetUnassignedBatch(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
 			if getTaskError != nil {
 				log.Error("failed to get unassigned batch proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 				return nil, ErrCoordinatorInternalFailure
@@ -138,17 +115,12 @@ func (bp *BatchProverTask) doAssignTaskWithinChunkRange(ctx *gin.Context, taskCt
 	}
 
 	log.Info("start batch proof generation session", "task_id", batchTask.Hash, "public key", taskCtx.PublicKey, "prover name", taskCtx.ProverName)
-	var (
-		proverVersion = taskCtx.ProverVersion
-		hardForkName  = taskCtx.HardForkName
-	)
-	var err error
-	if getHardForkName != nil {
-		hardForkName, err = getHardForkName(batchTask)
-		if err != nil {
-			log.Error("failed to get hard fork name by batch", "task_id", batchTask.Hash, "error", err.Error())
-			return nil, ErrCoordinatorInternalFailure
-		}
+
+	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
 	}
 
 	proverTask := orm.ProverTask{
@@ -156,10 +128,10 @@ func (bp *BatchProverTask) doAssignTaskWithinChunkRange(ctx *gin.Context, taskCt
 		ProverPublicKey: taskCtx.PublicKey,
 		TaskType:        int16(message.ProofTypeBatch),
 		ProverName:      taskCtx.ProverName,
-		ProverVersion:   proverVersion,
+		ProverVersion:   taskCtx.ProverVersion,
 		ProvingStatus:   int16(types.ProverAssigned),
 		FailureType:     int16(types.ProverTaskFailureTypeUndefined),
-		// here why need use UTC time. see scroll/common/databased/db.go
+		// here why need use UTC time. see scroll/common/database/db.go
 		AssignedAt: utils.NowUTC(),
 	}
 
@@ -170,7 +142,7 @@ func (bp *BatchProverTask) doAssignTaskWithinChunkRange(ctx *gin.Context, taskCt
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	taskMsg, err := bp.formatProverTask(ctx.Copy(), &proverTask)
+	taskMsg, err := bp.formatProverTask(ctx.Copy(), &proverTask, batchTask, hardForkName)
 	if err != nil {
 		bp.recoverActiveAttempts(ctx, batchTask)
 		log.Error("format prover task failure", "task_id", batchTask.Hash, "err", err)
@@ -187,108 +159,21 @@ func (bp *BatchProverTask) doAssignTaskWithinChunkRange(ctx *gin.Context, taskCt
 	return taskMsg, nil
 }
 
-func (bp *BatchProverTask) getChunkRangeByName(ctx *gin.Context, hardForkName string) (*chunkIndexRange, error) {
-	hardForkNumber, err := bp.getHardForkNumberByName(hardForkName)
-	if err != nil {
-		log.Error("batch assign failure because of the hard fork name don't exist", "fork name", hardForkName)
-		return nil, err
+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
 	}
 
-	// if the hard fork number set, rollup relayer must generate the chunk from hard fork number,
-	// so the hard fork chunk's start_block_number must be ForkBlockNumber
-	var startChunkIndex uint64 = 0
-	var endChunkIndex uint64 = math.MaxInt64
-	fromBlockNum, toBlockNum := forks.BlockRange(hardForkNumber, bp.forkHeights)
-	if fromBlockNum != 0 {
-		startChunk, chunkErr := bp.chunkOrm.GetChunkByStartBlockNumber(ctx.Copy(), fromBlockNum)
-		if chunkErr != nil {
-			log.Error("failed to get fork start chunk index", "forkName", hardForkName, "fromBlockNumber", fromBlockNum, "err", chunkErr)
-			return nil, ErrCoordinatorInternalFailure
-		}
-		if startChunk == nil {
-			return nil, nil
-		}
-		startChunkIndex = startChunk.Index
+	l2Block, getBlockErr := bp.blockOrm.GetL2BlockByNumber(ctx.Copy(), startChunk.StartBlockNumber)
+	if getBlockErr != nil {
+		return "", getBlockErr
 	}
-	if toBlockNum != math.MaxInt64 {
-		toChunk, chunkErr := bp.chunkOrm.GetChunkByStartBlockNumber(ctx.Copy(), toBlockNum)
-		if chunkErr != nil {
-			log.Error("failed to get fork end chunk index", "forkName", hardForkName, "toBlockNumber", toBlockNum, "err", chunkErr)
-			return nil, ErrCoordinatorInternalFailure
-		}
-		if toChunk != nil {
-			// toChunk being nil only indicates that we haven't yet reached the fork boundary
-			// don't need change the endChunkIndex of math.MaxInt64
-			endChunkIndex = toChunk.Index
-		}
-	}
-	return &chunkIndexRange{startChunkIndex, endChunkIndex}, nil
+	hardForkName := forks.GetHardforkName(bp.chainCfg, l2Block.Number, l2Block.BlockTimestamp)
+	return hardForkName, nil
 }
 
-func (bp *BatchProverTask) assignWithSingleCircuit(ctx *gin.Context, taskCtx *proverTaskContext, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error) {
-	chunkRange, err := bp.getChunkRangeByName(ctx, taskCtx.HardForkName)
-	if err != nil {
-		return nil, err
-	}
-	if chunkRange == nil {
-		return nil, nil
-	}
-	return bp.doAssignTaskWithinChunkRange(ctx, taskCtx, chunkRange, getTaskParameter, nil)
-}
-
-func (bp *BatchProverTask) assignWithTwoCircuits(ctx *gin.Context, taskCtx *proverTaskContext, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error) {
-	var (
-		hardForkNames [2]string
-		chunkRanges   [2]*chunkIndexRange
-		err           error
-	)
-	for i := 0; i < 2; i++ {
-		hardForkNames[i] = bp.reverseVkMap[getTaskParameter.VKs[i]]
-		chunkRanges[i], err = bp.getChunkRangeByName(ctx, hardForkNames[i])
-		if err != nil {
-			return nil, err
-		}
-		if chunkRanges[i] == nil {
-			return nil, nil
-		}
-	}
-	chunkRange := chunkRanges[0].merge(*chunkRanges[1])
-	var hardForkName string
-	getHardForkName := func(batch *orm.Batch) (string, error) {
-		for i := 0; i < 2; i++ {
-			if chunkRanges[i].contains(batch.StartChunkIndex, batch.EndChunkIndex) {
-				hardForkName = hardForkNames[i]
-				break
-			}
-		}
-		if hardForkName == "" {
-			log.Warn("get batch not belongs to any hard fork name", "batch id", batch.Index)
-			return "", fmt.Errorf("get batch not belongs to any hard fork name, batch id: %d", batch.Index)
-		}
-		return hardForkName, nil
-	}
-	schema, err := bp.doAssignTaskWithinChunkRange(ctx, taskCtx, chunkRange, getTaskParameter, getHardForkName)
-	if schema != nil && err == nil {
-		schema.HardForkName = hardForkName
-		return schema, nil
-	}
-	return schema, err
-}
-
-// Assign load and assign batch tasks
-func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error) {
-	taskCtx, err := bp.checkParameter(ctx, getTaskParameter)
-	if err != nil || taskCtx == nil {
-		return nil, fmt.Errorf("check prover task parameter failed, error:%w", err)
-	}
-
-	if len(getTaskParameter.VKs) > 0 {
-		return bp.assignWithTwoCircuits(ctx, taskCtx, getTaskParameter)
-	}
-	return bp.assignWithSingleCircuit(ctx, taskCtx, getTaskParameter)
-}
-
-func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.ProverTask) (*coordinatorType.GetTaskSchema, error) {
+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)
 	if err != nil {
@@ -296,6 +181,10 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		return nil, err
 	}
 
+	if len(chunks) == 0 {
+		return nil, fmt.Errorf("no chunk found for batch task id:%s", task.TaskID)
+	}
+
 	var chunkProofs []*message.ChunkProof
 	var chunkInfos []*message.ChunkInfo
 	for _, chunk := range chunks {
@@ -324,16 +213,27 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		ChunkProofs: chunkProofs,
 	}
 
+	if hardForkName == "darwin" {
+		taskDetail.ParentStateRoot = common.HexToHash(chunks[0].ParentChunkStateRoot)
+		taskDetail.ParentBatchHash = common.HexToHash(batch.ParentBatchHash)
+		batchHeader, decodeErr := codecv3.NewDABatchFromBytes(batch.BatchHeader)
+		if decodeErr != nil {
+			return nil, fmt.Errorf("failed to decode batch header, taskID:%s err:%w", task.TaskID, decodeErr)
+		}
+		taskDetail.BatchHeader = batchHeader
+	}
+
 	chunkProofsBytes, err := json.Marshal(taskDetail)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal chunk proofs, taskID:%s err:%w", task.TaskID, err)
 	}
 
 	taskMsg := &coordinatorType.GetTaskSchema{
-		UUID:     task.UUID.String(),
-		TaskID:   task.TaskID,
-		TaskType: int(message.ProofTypeBatch),
-		TaskData: string(chunkProofsBytes),
+		UUID:         task.UUID.String(),
+		TaskID:       task.TaskID,
+		TaskType:     int(message.ProofTypeBatch),
+		TaskData:     string(chunkProofsBytes),
+		HardForkName: hardForkName,
 	}
 	return taskMsg, nil
 }

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -0,0 +1,242 @@
+package provertask
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"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/forks"
+	"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"
+)
+
+// BundleProverTask is prover task implement for bundle proof
+type BundleProverTask struct {
+	BaseProverTask
+
+	bundleAttemptsExceedTotal prometheus.Counter
+	bundleTaskGetTaskTotal    *prometheus.CounterVec
+	bundleTaskGetTaskProver   *prometheus.CounterVec
+}
+
+// NewBundleProverTask new a bundle collector
+func NewBundleProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *BundleProverTask {
+	bp := &BundleProverTask{
+		BaseProverTask: BaseProverTask{
+			db:                 db,
+			chainCfg:           chainCfg,
+			cfg:                cfg,
+			blockOrm:           orm.NewL2Block(db),
+			chunkOrm:           orm.NewChunk(db),
+			batchOrm:           orm.NewBatch(db),
+			bundleOrm:          orm.NewBundle(db),
+			proverTaskOrm:      orm.NewProverTask(db),
+			proverBlockListOrm: orm.NewProverBlockList(db),
+		},
+		bundleAttemptsExceedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+			Name: "coordinator_bundle_attempts_exceed_total",
+			Help: "Total number of bundle attempts exceed.",
+		}),
+		bundleTaskGetTaskTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
+			Name: "coordinator_bundle_get_task_total",
+			Help: "Total number of bundle get task.",
+		}, []string{"fork_name"}),
+		bundleTaskGetTaskProver: newGetTaskCounterVec(promauto.With(reg), "bundle"),
+	}
+	return bp
+}
+
+// Assign load and assign batch tasks
+func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error) {
+	taskCtx, err := bp.checkParameter(ctx)
+	if err != nil || taskCtx == nil {
+		return nil, fmt.Errorf("check prover task parameter failed, error:%w", err)
+	}
+
+	maxActiveAttempts := bp.cfg.ProverManager.ProversPerSession
+	maxTotalAttempts := bp.cfg.ProverManager.SessionAttempts
+	var bundleTask *orm.Bundle
+	for i := 0; i < 5; i++ {
+		var getTaskError error
+		var tmpBundleTask *orm.Bundle
+		tmpBundleTask, getTaskError = bp.bundleOrm.GetAssignedBundle(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
+		if getTaskError != nil {
+			log.Error("failed to get assigned bundle proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
+			return nil, ErrCoordinatorInternalFailure
+		}
+
+		// Why here need get again? In order to support a task can assign to multiple prover, need also assign `ProvingTaskAssigned`
+		// bundle to prover. But use `proving_status in (1, 2)` will not use the postgres index. So need split the sql.
+		if tmpBundleTask == nil {
+			tmpBundleTask, getTaskError = bp.bundleOrm.GetUnassignedBundle(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
+			if getTaskError != nil {
+				log.Error("failed to get unassigned bundle proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
+				return nil, ErrCoordinatorInternalFailure
+			}
+		}
+
+		if tmpBundleTask == nil {
+			log.Debug("get empty bundle", "height", getTaskParameter.ProverHeight)
+			return nil, nil
+		}
+
+		rowsAffected, updateAttemptsErr := bp.bundleOrm.UpdateBundleAttempts(ctx.Copy(), tmpBundleTask.Hash, tmpBundleTask.ActiveAttempts, tmpBundleTask.TotalAttempts)
+		if updateAttemptsErr != nil {
+			log.Error("failed to update bundle attempts", "height", getTaskParameter.ProverHeight, "err", updateAttemptsErr)
+			return nil, ErrCoordinatorInternalFailure
+		}
+
+		if rowsAffected == 0 {
+			time.Sleep(100 * time.Millisecond)
+			continue
+		}
+
+		bundleTask = tmpBundleTask
+		break
+	}
+
+	if bundleTask == nil {
+		log.Debug("get empty unassigned bundle after retry 5 times", "height", getTaskParameter.ProverHeight)
+		return nil, nil
+	}
+
+	log.Info("start batch 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
+	}
+
+	proverTask := orm.ProverTask{
+		TaskID:          bundleTask.Hash,
+		ProverPublicKey: taskCtx.PublicKey,
+		TaskType:        int16(message.ProofTypeBundle),
+		ProverName:      taskCtx.ProverName,
+		ProverVersion:   taskCtx.ProverVersion,
+		ProvingStatus:   int16(types.ProverAssigned),
+		FailureType:     int16(types.ProverTaskFailureTypeUndefined),
+		// here why need use UTC time. see scroll/common/database/db.go
+		AssignedAt: utils.NowUTC(),
+	}
+
+	// Store session info.
+	if err = bp.proverTaskOrm.InsertProverTask(ctx.Copy(), &proverTask); err != nil {
+		bp.recoverActiveAttempts(ctx, bundleTask)
+		log.Error("insert bundle prover task info fail", "task_id", bundleTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
+		return nil, ErrCoordinatorInternalFailure
+	}
+
+	taskMsg, err := bp.formatProverTask(ctx.Copy(), &proverTask, hardForkName)
+	if err != nil {
+		bp.recoverActiveAttempts(ctx, bundleTask)
+		log.Error("format bundle prover task failure", "task_id", bundleTask.Hash, "err", err)
+		return nil, ErrCoordinatorInternalFailure
+	}
+
+	bp.bundleTaskGetTaskTotal.WithLabelValues(hardForkName).Inc()
+	bp.bundleTaskGetTaskProver.With(prometheus.Labels{
+		coordinatorType.LabelProverName:      proverTask.ProverName,
+		coordinatorType.LabelProverPublicKey: proverTask.ProverPublicKey,
+		coordinatorType.LabelProverVersion:   proverTask.ProverVersion,
+	}).Inc()
+
+	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 := forks.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)
+	if err != nil {
+		err = fmt.Errorf("failed to get batch proofs for batch task id:%s err:%w ", task.TaskID, err)
+		return nil, err
+	}
+
+	if len(batches) == 0 {
+		return nil, fmt.Errorf("failed to get batch proofs for bundle task id:%s, no batch found", task.TaskID)
+	}
+
+	latestFinalizedBatch, err := bp.batchOrm.GetLatestFinalizedBatch(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get latest finalized batch by bundle hash: %w, bundle hash: %v", err, task.TaskID)
+	}
+
+	if latestFinalizedBatch == nil {
+		return nil, fmt.Errorf("failed to get latest finalized batch by bundle hash: %v, no finalized batch found", task.TaskID)
+	}
+
+	var batchProofs []*message.BatchProof
+	for _, batch := range batches {
+		var proof message.BatchProof
+		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)
+	}
+
+	lastPendingBatch := batches[len(batches)-1]
+	taskDetail := message.BundleTaskDetail{
+		ChainID:             bp.cfg.L2.ChainID,
+		FinalizedBatchHash:  common.HexToHash(latestFinalizedBatch.Hash),
+		FinalizedStateRoot:  common.HexToHash(latestFinalizedBatch.StateRoot),
+		PendingBatchHash:    common.HexToHash(lastPendingBatch.Hash),
+		PendingStateRoot:    common.HexToHash(lastPendingBatch.StateRoot),
+		PendingWithdrawRoot: common.HexToHash(lastPendingBatch.WithdrawRoot),
+		BatchProofs:         batchProofs,
+	}
+
+	batchProofsBytes, err := json.Marshal(taskDetail)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal chunk proofs, taskID:%s err:%w", task.TaskID, err)
+	}
+
+	taskMsg := &coordinatorType.GetTaskSchema{
+		UUID:         task.UUID.String(),
+		TaskID:       task.TaskID,
+		TaskType:     int(message.ProofTypeBundle),
+		TaskData:     string(batchProofsBytes),
+		HardForkName: hardForkName,
+	}
+	return taskMsg, nil
+}
+
+func (bp *BundleProverTask) recoverActiveAttempts(ctx *gin.Context, bundleTask *orm.Bundle) {
+	if err := bp.chunkOrm.DecreaseActiveAttemptsByHash(ctx.Copy(), bundleTask.Hash); err != nil {
+		log.Error("failed to recover bundle active attempts", "hash", bundleTask.Hash, "error", err)
+	}
+}

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -33,17 +33,12 @@ type ChunkProverTask struct {
 }
 
 // NewChunkProverTask new a chunk prover task
-func NewChunkProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, vkMap map[string]string, reg prometheus.Registerer) *ChunkProverTask {
-	forkHeights, _, nameForkMap := forks.CollectSortedForkHeights(chainCfg)
-	log.Info("new chunk prover task", "forkHeights", forkHeights, "nameForks", nameForkMap)
+func NewChunkProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *ChunkProverTask {
 	cp := &ChunkProverTask{
 		BaseProverTask: BaseProverTask{
-			vkMap:              vkMap,
-			reverseVkMap:       reverseMap(vkMap),
 			db:                 db,
 			cfg:                cfg,
-			nameForkMap:        nameForkMap,
-			forkHeights:        forkHeights,
+			chainCfg:           chainCfg,
 			chunkOrm:           orm.NewChunk(db),
 			blockOrm:           orm.NewL2Block(db),
 			proverTaskOrm:      orm.NewProverTask(db),
@@ -62,13 +57,11 @@ func NewChunkProverTask(cfg *config.Config, chainCfg *params.ChainConfig, db *go
 	return cp
 }
 
-type getHardForkNameByChunkFunc func(*orm.Chunk) (string, error)
-
-func (cp *ChunkProverTask) doAssignTaskWithinBlockRange(ctx *gin.Context, taskCtx *proverTaskContext,
-	blockRange *blockRange, getTaskParameter *coordinatorType.GetTaskParameter, getHardForkName getHardForkNameByChunkFunc) (*coordinatorType.GetTaskSchema, error) {
-	fromBlockNum, toBlockNum := blockRange.from, blockRange.to
-	if toBlockNum > getTaskParameter.ProverHeight {
-		toBlockNum = getTaskParameter.ProverHeight + 1
+// Assign the chunk proof which need to prove
+func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error) {
+	taskCtx, err := cp.checkParameter(ctx)
+	if err != nil || taskCtx == nil {
+		return nil, fmt.Errorf("check prover task parameter failed, error:%w", err)
 	}
 
 	maxActiveAttempts := cp.cfg.ProverManager.ProversPerSession
@@ -77,7 +70,7 @@ func (cp *ChunkProverTask) doAssignTaskWithinBlockRange(ctx *gin.Context, taskCt
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpChunkTask *orm.Chunk
-		tmpChunkTask, getTaskError = cp.chunkOrm.GetAssignedChunk(ctx.Copy(), fromBlockNum, toBlockNum, maxActiveAttempts, maxTotalAttempts)
+		tmpChunkTask, getTaskError = cp.chunkOrm.GetAssignedChunk(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
 		if getTaskError != nil {
 			log.Error("failed to get assigned chunk proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 			return nil, ErrCoordinatorInternalFailure
@@ -86,7 +79,7 @@ func (cp *ChunkProverTask) doAssignTaskWithinBlockRange(ctx *gin.Context, taskCt
 		// Why here need get again? In order to support a task can assign to multiple prover, need also assign `ProvingTaskAssigned`
 		// chunk to prover. But use `proving_status in (1, 2)` will not use the postgres index. So need split the sql.
 		if tmpChunkTask == nil {
-			tmpChunkTask, getTaskError = cp.chunkOrm.GetUnassignedChunk(ctx.Copy(), fromBlockNum, toBlockNum, maxActiveAttempts, maxTotalAttempts)
+			tmpChunkTask, getTaskError = cp.chunkOrm.GetUnassignedChunk(ctx.Copy(), maxActiveAttempts, maxTotalAttempts)
 			if getTaskError != nil {
 				log.Error("failed to get unassigned chunk proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 				return nil, ErrCoordinatorInternalFailure
@@ -119,17 +112,12 @@ func (cp *ChunkProverTask) doAssignTaskWithinBlockRange(ctx *gin.Context, taskCt
 	}
 
 	log.Info("start chunk generation session", "task_id", chunkTask.Hash, "public key", taskCtx.PublicKey, "prover name", taskCtx.ProverName)
-	var (
-		proverVersion = taskCtx.ProverVersion
-		hardForkName  = taskCtx.HardForkName
-		err           error
-	)
-	if getHardForkName != nil {
-		hardForkName, err = getHardForkName(chunkTask)
-		if err != nil {
-			log.Error("failed to get hard fork name by chunk", "task_id", chunkTask.Hash, "error", err.Error())
-			return nil, ErrCoordinatorInternalFailure
-		}
+
+	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
 	}
 
 	proverTask := orm.ProverTask{
@@ -137,10 +125,10 @@ func (cp *ChunkProverTask) doAssignTaskWithinBlockRange(ctx *gin.Context, taskCt
 		ProverPublicKey: taskCtx.PublicKey,
 		TaskType:        int16(message.ProofTypeChunk),
 		ProverName:      taskCtx.ProverName,
-		ProverVersion:   proverVersion,
+		ProverVersion:   taskCtx.ProverVersion,
 		ProvingStatus:   int16(types.ProverAssigned),
 		FailureType:     int16(types.ProverTaskFailureTypeUndefined),
-		// here why need use UTC time. see scroll/common/databased/db.go
+		// here why need use UTC time. see scroll/common/database/db.go
 		AssignedAt: utils.NowUTC(),
 	}
 
@@ -150,7 +138,7 @@ func (cp *ChunkProverTask) doAssignTaskWithinBlockRange(ctx *gin.Context, taskCt
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	taskMsg, err := cp.formatProverTask(ctx.Copy(), &proverTask)
+	taskMsg, err := cp.formatProverTask(ctx.Copy(), &proverTask, hardForkName)
 	if err != nil {
 		cp.recoverActiveAttempts(ctx, chunkTask)
 		log.Error("format prover task failure", "task_id", chunkTask.Hash, "err", err)
@@ -167,96 +155,16 @@ func (cp *ChunkProverTask) doAssignTaskWithinBlockRange(ctx *gin.Context, taskCt
 	return taskMsg, nil
 }
 
-func (cp *ChunkProverTask) assignWithSingleCircuit(ctx *gin.Context, taskCtx *proverTaskContext, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error) {
-	blockRange, err := cp.getBlockRangeByName(taskCtx.HardForkName)
-	if err != nil {
-		return nil, err
+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
 	}
-	return cp.doAssignTaskWithinBlockRange(ctx, taskCtx, blockRange, getTaskParameter, nil)
+	hardForkName := forks.GetHardforkName(cp.chainCfg, l2Block.Number, l2Block.BlockTimestamp)
+	return hardForkName, nil
 }
 
-func (cp *ChunkProverTask) assignWithTwoCircuits(ctx *gin.Context, taskCtx *proverTaskContext, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error) {
-	var (
-		hardForkNames [2]string
-		blockRanges   [2]*blockRange
-		err           error
-	)
-	for i := 0; i < 2; i++ {
-		hardForkNames[i] = cp.reverseVkMap[getTaskParameter.VKs[i]]
-		blockRanges[i], err = cp.getBlockRangeByName(hardForkNames[i])
-		if err != nil {
-			return nil, err
-		}
-	}
-	blockRange, err := blockRanges[0].merge(*blockRanges[1])
-	if err != nil {
-		return nil, err
-	}
-	var hardForkName string
-	getHardForkName := func(chunk *orm.Chunk) (string, error) {
-		for i := 0; i < 2; i++ {
-			if blockRanges[i].contains(chunk.StartBlockNumber, chunk.EndBlockNumber) {
-				hardForkName = hardForkNames[i]
-				break
-			}
-		}
-		if hardForkName == "" {
-			log.Warn("get chunk not belongs to any hard fork name", "chunk id", chunk.Index)
-			return "", fmt.Errorf("get chunk not belongs to any hard fork name, chunk id: %d", chunk.Index)
-		}
-		return hardForkName, nil
-	}
-	schema, err := cp.doAssignTaskWithinBlockRange(ctx, taskCtx, blockRange, getTaskParameter, getHardForkName)
-	if schema != nil && err == nil {
-		schema.HardForkName = hardForkName
-		return schema, nil
-	}
-	return schema, err
-}
-
-type blockRange struct {
-	from uint64
-	to   uint64
-}
-
-func (r *blockRange) merge(o blockRange) (*blockRange, error) {
-	if r.from == o.to {
-		return &blockRange{o.from, r.to}, nil
-	} else if r.to == o.from {
-		return &blockRange{r.from, o.to}, nil
-	}
-	return nil, fmt.Errorf("two ranges are not adjacent")
-}
-
-func (r *blockRange) contains(start, end uint64) bool {
-	return r.from <= start && r.to > end
-}
-
-func (cp *ChunkProverTask) getBlockRangeByName(hardForkName string) (*blockRange, error) {
-	hardForkNumber, err := cp.getHardForkNumberByName(hardForkName)
-	if err != nil {
-		log.Error("chunk assign failure because of the hard fork name don't exist", "fork name", hardForkName)
-		return nil, err
-	}
-
-	fromBlockNum, toBlockNum := forks.BlockRange(hardForkNumber, cp.forkHeights)
-	return &blockRange{fromBlockNum, toBlockNum}, nil
-}
-
-// Assign the chunk proof which need to prove
-func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error) {
-	taskCtx, err := cp.checkParameter(ctx, getTaskParameter)
-	if err != nil || taskCtx == nil {
-		return nil, fmt.Errorf("check prover task parameter failed, error:%w", err)
-	}
-
-	if len(getTaskParameter.VKs) > 0 {
-		return cp.assignWithTwoCircuits(ctx, taskCtx, getTaskParameter)
-	}
-	return cp.assignWithSingleCircuit(ctx, taskCtx, getTaskParameter)
-}
-
-func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.ProverTask) (*coordinatorType.GetTaskSchema, error) {
+func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.ProverTask, hardForkName string) (*coordinatorType.GetTaskSchema, error) {
 	// Get block hashes.
 	blockHashes, dbErr := cp.blockOrm.GetL2BlockHashesByChunkHash(ctx, task.TaskID)
 	if dbErr != nil || len(blockHashes) == 0 {
@@ -272,10 +180,11 @@ func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 	}
 
 	proverTaskSchema := &coordinatorType.GetTaskSchema{
-		UUID:     task.UUID.String(),
-		TaskID:   task.TaskID,
-		TaskType: int(message.ProofTypeChunk),
-		TaskData: string(blockHashesBytes),
+		UUID:         task.UUID.String(),
+		TaskID:       task.TaskID,
+		TaskType:     int(message.ProofTypeChunk),
+		TaskData:     string(blockHashesBytes),
+		HardForkName: hardForkName,
 	}
 
 	return proverTaskSchema, nil

coordinator/internal/logic/provertask/prover_task.go

@@ -7,11 +7,9 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
-	"scroll-tech/common/version"
-
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/orm"
 	coordinatorType "scroll-tech/coordinator/internal/types"
@@ -24,35 +22,25 @@ var (
 	ErrHardForkName = fmt.Errorf("wrong hard fork name")
 )
 
+var (
+	getTaskCounterInitOnce sync.Once
+	getTaskCounterVec      *prometheus.CounterVec = nil
+)
+
 // ProverTask the interface of a collector who send data to prover
 type ProverTask interface {
 	Assign(ctx *gin.Context, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error)
 }
 
-func reverseMap(input map[string]string) map[string]string {
-	output := make(map[string]string, len(input))
-	for k, v := range input {
-		if k != "" {
-			output[v] = k
-		}
-	}
-	return output
-}
-
 // BaseProverTask a base prover task which contain series functions
 type BaseProverTask struct {
-	cfg *config.Config
-	db  *gorm.DB
-
-	// key is hardForkName, value is vk
-	vkMap map[string]string
-	// key is vk, value is hardForkName
-	reverseVkMap map[string]string
-	nameForkMap  map[string]uint64
-	forkHeights  []uint64
+	cfg      *config.Config
+	chainCfg *params.ChainConfig
+	db       *gorm.DB
 
 	batchOrm           *orm.Batch
 	chunkOrm           *orm.Chunk
+	bundleOrm          *orm.Bundle
 	blockOrm           *orm.L2Block
 	proverTaskOrm      *orm.ProverTask
 	proverBlockListOrm *orm.ProverBlockList
@@ -62,11 +50,10 @@ type proverTaskContext struct {
 	PublicKey     string
 	ProverName    string
 	ProverVersion string
-	HardForkName  string
 }
 
 // checkParameter check the prover task parameter illegal
-func (b *BaseProverTask) checkParameter(ctx *gin.Context, getTaskParameter *coordinatorType.GetTaskParameter) (*proverTaskContext, error) {
+func (b *BaseProverTask) checkParameter(ctx *gin.Context) (*proverTaskContext, error) {
 	var ptc proverTaskContext
 
 	publicKey, publicKeyExist := ctx.Get(coordinatorType.PublicKey)
@@ -87,44 +74,6 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context, getTaskParameter *coor
 	}
 	ptc.ProverVersion = proverVersion.(string)
 
-	if !version.CheckScrollRepoVersion(proverVersion.(string), b.cfg.ProverManager.MinProverVersion) {
-		return nil, fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", b.cfg.ProverManager.MinProverVersion, proverVersion.(string))
-	}
-
-	// signals that the prover is multi-circuits version
-	if len(getTaskParameter.VKs) > 0 {
-		if len(getTaskParameter.VKs) != 2 {
-			return nil, fmt.Errorf("parameter vks length must be 2")
-		}
-		for _, vk := range getTaskParameter.VKs {
-			if _, exists := b.reverseVkMap[vk]; !exists {
-				return nil, fmt.Errorf("incompatible vk. vk %s is invalid", vk)
-			}
-		}
-	} else {
-		hardForkName, hardForkNameExist := ctx.Get(coordinatorType.HardForkName)
-		if !hardForkNameExist {
-			return nil, fmt.Errorf("get hard fork name from context failed")
-		}
-		ptc.HardForkName = hardForkName.(string)
-
-		vk, vkExist := b.vkMap[ptc.HardForkName]
-		if !vkExist {
-			return nil, fmt.Errorf("can't get vk for hard fork:%s, vkMap:%v", ptc.HardForkName, b.vkMap)
-		}
-
-		// if the prover has a different vk
-		if getTaskParameter.VK != vk {
-			log.Error("vk inconsistency", "prover vk", getTaskParameter.VK, "vk", vk, "hardForkName", ptc.HardForkName)
-			// if the prover reports a different prover version
-			if !version.CheckScrollProverVersion(proverVersion.(string)) {
-				return nil, fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s", version.Version, proverVersion.(string))
-			}
-			// if the prover reports a same prover version
-			return nil, fmt.Errorf("incompatible vk. please check your params files or config files")
-		}
-	}
-
 	isBlocked, err := b.proverBlockListOrm.IsPublicKeyBlocked(ctx.Copy(), publicKey.(string))
 	if err != nil {
 		return nil, fmt.Errorf("failed to check whether the public key %s is blocked before assigning a chunk task, err: %w, proverName: %s, proverVersion: %s", publicKey, err, proverName, proverVersion)
@@ -144,26 +93,6 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context, getTaskParameter *coor
 	return &ptc, nil
 }
 
-func (b *BaseProverTask) getHardForkNumberByName(forkName string) (uint64, error) {
-	// when the first hard fork upgrade, the prover don't pass the fork_name to coordinator.
-	// so coordinator need to be compatible.
-	if forkName == "" {
-		return 0, nil
-	}
-
-	hardForkNumber, exist := b.nameForkMap[forkName]
-	if !exist {
-		return 0, ErrHardForkName
-	}
-
-	return hardForkNumber, nil
-}
-
-var (
-	getTaskCounterInitOnce sync.Once
-	getTaskCounterVec      *prometheus.CounterVec = nil
-)
-
 func newGetTaskCounterVec(factory promauto.Factory, taskType string) *prometheus.CounterVec {
 	getTaskCounterInitOnce.Do(func() {
 		getTaskCounterVec = factory.NewCounterVec(prometheus.CounterOpts{

coordinator/internal/logic/submitproof/proof_receiver.go

@@ -12,8 +12,10 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
+	"scroll-tech/common/forks"
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/message"
 
@@ -35,21 +37,26 @@ var (
 	// ErrValidatorFailureTaskHaveVerifiedSuccess have proved success and verified success
 	ErrValidatorFailureTaskHaveVerifiedSuccess = errors.New("validator failure chunk/batch have proved and verified success")
 	// ErrValidatorFailureVerifiedFailed failed to verify and the verifier returns error
-	ErrValidatorFailureVerifiedFailed = fmt.Errorf("verification failed, verifier returns error")
+	ErrValidatorFailureVerifiedFailed = errors.New("verification failed, verifier returns error")
 	// ErrValidatorSuccessInvalidProof successful verified and the proof is invalid
-	ErrValidatorSuccessInvalidProof = fmt.Errorf("verification succeeded, it's an invalid proof")
+	ErrValidatorSuccessInvalidProof = errors.New("verification succeeded, it's an invalid proof")
+	// ErrGetHardForkNameFailed failed to get hard fork name
+	ErrGetHardForkNameFailed = errors.New("failed to get hard fork name")
 	// ErrCoordinatorInternalFailure coordinator internal db failure
-	ErrCoordinatorInternalFailure = fmt.Errorf("coordinator internal error")
+	ErrCoordinatorInternalFailure = errors.New("coordinator internal error")
 )
 
 // ProofReceiverLogic the proof receiver logic
 type ProofReceiverLogic struct {
 	chunkOrm      *orm.Chunk
 	batchOrm      *orm.Batch
+	bundleOrm     *orm.Bundle
+	blockOrm      *orm.L2Block
 	proverTaskOrm *orm.ProverTask
 
-	db  *gorm.DB
-	cfg *config.ProverManager
+	db       *gorm.DB
+	cfg      *config.ProverManager
+	chainCfg *params.ChainConfig
 
 	verifier *verifier.Verifier
 
@@ -66,14 +73,17 @@ type ProofReceiverLogic struct {
 }
 
 // NewSubmitProofReceiverLogic create a proof receiver logic
-func NewSubmitProofReceiverLogic(cfg *config.ProverManager, db *gorm.DB, vf *verifier.Verifier, reg prometheus.Registerer) *ProofReceiverLogic {
+func NewSubmitProofReceiverLogic(cfg *config.ProverManager, chainCfg *params.ChainConfig, db *gorm.DB, vf *verifier.Verifier, reg prometheus.Registerer) *ProofReceiverLogic {
 	return &ProofReceiverLogic{
 		chunkOrm:      orm.NewChunk(db),
 		batchOrm:      orm.NewBatch(db),
+		bundleOrm:     orm.NewBundle(db),
+		blockOrm:      orm.NewL2Block(db),
 		proverTaskOrm: orm.NewProverTask(db),
 
-		cfg: cfg,
-		db:  db,
+		cfg:      cfg,
+		chainCfg: chainCfg,
+		db:       db,
 
 		verifier: vf,
 
@@ -124,7 +134,7 @@ func NewSubmitProofReceiverLogic(cfg *config.ProverManager, db *gorm.DB, vf *ver
 // HandleZkProof handle a ZkProof submitted from a prover.
 // For now only proving/verifying error will lead to setting status as skipped.
 // db/unmarshal errors will not because they are errors on the business logic side.
-func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofMsg *message.ProofMsg, proofParameter coordinatorType.SubmitProofParameter) error {
+func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coordinatorType.SubmitProofParameter) error {
 	m.proofReceivedTotal.Inc()
 	pk := ctx.GetString(coordinatorType.PublicKey)
 	if len(pk) == 0 {
@@ -134,37 +144,20 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofMsg *message.P
 	if len(pv) == 0 {
 		return fmt.Errorf("get ProverVersion from context failed")
 	}
-	// use hard_fork_name from parameter first
-	// if prover support multi hard_forks, the real hard_fork_name is not set to the gin context
-	hardForkName := proofParameter.HardForkName
-	if hardForkName == "" {
-		hardForkName = ctx.GetString(coordinatorType.HardForkName)
-	}
 
-	var proverTask *orm.ProverTask
-	var err error
-	if proofParameter.UUID != "" {
-		proverTask, err = m.proverTaskOrm.GetProverTaskByUUIDAndPublicKey(ctx.Copy(), proofParameter.UUID, pk)
-		if proverTask == nil || err != nil {
-			log.Error("get none prover task for the proof", "uuid", proofParameter.UUID, "key", pk, "taskID", proofMsg.ID, "error", err)
-			return ErrValidatorFailureProverTaskEmpty
-		}
-	} else {
-		// TODO When prover all have upgrade, need delete this logic
-		proverTask, err = m.proverTaskOrm.GetAssignedProverTaskByTaskIDAndProver(ctx.Copy(), proofMsg.Type, proofMsg.ID, pk, pv)
-		if proverTask == nil || err != nil {
-			log.Error("get none prover task for the proof", "key", pk, "taskID", proofMsg.ID, "error", err)
-			return ErrValidatorFailureProverTaskEmpty
-		}
+	proverTask, err := m.proverTaskOrm.GetProverTaskByUUIDAndPublicKey(ctx.Copy(), proofParameter.UUID, pk)
+	if proverTask == nil || err != nil {
+		log.Error("get none prover task for the proof", "uuid", proofParameter.UUID, "key", pk, "taskID", proofParameter.TaskID, "error", err)
+		return ErrValidatorFailureProverTaskEmpty
 	}
 
 	proofTime := time.Since(proverTask.CreatedAt)
 	proofTimeSec := uint64(proofTime.Seconds())
 
-	log.Info("handling zk proof", "proofID", proofMsg.ID, "proverName", proverTask.ProverName,
-		"proverPublicKey", pk, "proveType", proverTask.TaskType, "proofTime", proofTimeSec, "hardForkName", hardForkName)
+	log.Info("handling zk proof", "proofID", proofParameter.TaskID, "proverName", proverTask.ProverName,
+		"proverPublicKey", pk, "proveType", proverTask.TaskType, "proofTime", proofTimeSec)
 
-	if err = m.validator(ctx.Copy(), proverTask, pk, proofMsg, proofParameter, hardForkName); err != nil {
+	if err = m.validator(ctx.Copy(), proverTask, pk, proofParameter); err != nil {
 		return err
 	}
 
@@ -172,18 +165,30 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofMsg *message.P
 
 	success := true
 	var verifyErr error
+	hardForkName, getHardForkErr := m.hardForkName(ctx, proofParameter.TaskID, proofParameter.TaskType)
+	if getHardForkErr != nil {
+		return ErrGetHardForkNameFailed
+	}
 	// only verify batch proof. chunk proof verifier have been disabled after Bernoulli
-	if proofMsg.Type == message.ProofTypeBatch {
-		success, verifyErr = m.verifier.VerifyBatchProof(proofMsg.BatchProof, hardForkName)
+	if message.ProofType(proofParameter.TaskType) == message.ProofTypeBatch {
+		var batchProof message.BatchProof
+		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &batchProof); unmarshalErr != nil {
+			return unmarshalErr
+		}
+		success, verifyErr = m.verifier.VerifyBatchProof(&batchProof, hardForkName)
+	}
+
+	if message.ProofType(proofParameter.TaskType) == message.ProofTypeBundle {
+		// TODO add bundle check here
 	}
 
 	if verifyErr != nil || !success {
 		m.verifierFailureTotal.WithLabelValues(pv).Inc()
 
-		m.proofRecover(ctx.Copy(), proverTask, types.ProverTaskFailureTypeVerifiedFailed, proofMsg)
+		m.proofRecover(ctx.Copy(), proverTask, types.ProverTaskFailureTypeVerifiedFailed, proofParameter)
 
-		log.Info("proof verified by coordinator failed", "proof id", proofMsg.ID, "prover name", proverTask.ProverName,
-			"prover pk", pk, "forkName", hardForkName, "prove type", proofMsg.Type, "proof time", proofTimeSec, "error", verifyErr)
+		log.Info("proof verified by coordinator failed", "proof id", proofParameter.TaskID, "prover name", proverTask.ProverName,
+			"prover pk", pk, "prove type", proofParameter.TaskType, "proof time", proofTimeSec, "error", verifyErr)
 
 		if verifyErr != nil {
 			return ErrValidatorFailureVerifiedFailed
@@ -193,13 +198,13 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofMsg *message.P
 
 	m.proverTaskProveDuration.Observe(time.Since(proverTask.CreatedAt).Seconds())
 
-	log.Info("proof verified and valid", "proof id", proofMsg.ID, "prover name", proverTask.ProverName,
-		"prover pk", pk, "prove type", proofMsg.Type, "proof time", proofTimeSec, "forkName", hardForkName)
+	log.Info("proof verified and valid", "proof id", proofParameter.TaskID, "prover name", proverTask.ProverName,
+		"prover pk", pk, "prove type", proofParameter.TaskType, "proof time", proofTimeSec)
 
-	if err := m.closeProofTask(ctx.Copy(), proverTask, proofMsg, proofTimeSec); err != nil {
+	if err := m.closeProofTask(ctx.Copy(), proverTask, proofParameter, proofTimeSec); err != nil {
 		m.proofSubmitFailure.Inc()
 
-		m.proofRecover(ctx.Copy(), proverTask, types.ProverTaskFailureTypeServerError, proofMsg)
+		m.proofRecover(ctx.Copy(), proverTask, types.ProverTaskFailureTypeServerError, proofParameter)
 
 		return ErrCoordinatorInternalFailure
 	}
@@ -212,7 +217,6 @@ func (m *ProofReceiverLogic) checkAreAllChunkProofsReady(ctx context.Context, ch
 	if err != nil {
 		return err
 	}
-
 	allReady, err := m.chunkOrm.CheckIfBatchChunkProofsAreReady(ctx, batch.BatchHash)
 	if err != nil {
 		return err
@@ -226,7 +230,7 @@ func (m *ProofReceiverLogic) checkAreAllChunkProofsReady(ctx context.Context, ch
 	return nil
 }
 
-func (m *ProofReceiverLogic) validator(ctx context.Context, proverTask *orm.ProverTask, pk string, proofMsg *message.ProofMsg, proofParameter coordinatorType.SubmitProofParameter, forkName string) (err error) {
+func (m *ProofReceiverLogic) validator(ctx context.Context, proverTask *orm.ProverTask, pk string, proofParameter coordinatorType.SubmitProofParameter) (err error) {
 	defer func() {
 		if err != nil {
 			m.validateFailureTotal.Inc()
@@ -243,9 +247,9 @@ func (m *ProofReceiverLogic) validator(ctx context.Context, proverTask *orm.Prov
 		// (ii) set the maximum failure retry times
 		log.Warn(
 			"cannot submit valid proof for a prover task twice",
-			"taskType", proverTask.TaskType, "hash", proofMsg.ID,
+			"taskType", proverTask.TaskType, "hash", proofParameter.TaskID,
 			"proverName", proverTask.ProverName, "proverVersion", proverTask.ProverVersion,
-			"proverPublicKey", proverTask.ProverPublicKey, "forkName", forkName,
+			"proverPublicKey", proverTask.ProverPublicKey,
 		)
 		return ErrValidatorFailureProverTaskCannotSubmitTwice
 	}
@@ -253,59 +257,59 @@ func (m *ProofReceiverLogic) validator(ctx context.Context, proverTask *orm.Prov
 	proofTime := time.Since(proverTask.CreatedAt)
 	proofTimeSec := uint64(proofTime.Seconds())
 
-	if proofMsg.Status != message.StatusOk {
+	if proofParameter.Status != int(message.StatusOk) {
 		// Temporarily replace "panic" with "pa-nic" to prevent triggering the alert based on logs.
 		failureMsg := strings.Replace(proofParameter.FailureMsg, "panic", "pa-nic", -1)
 
-		m.proofRecover(ctx, proverTask, types.ProverTaskFailureTypeSubmitStatusNotOk, proofMsg)
+		m.proofRecover(ctx, proverTask, types.ProverTaskFailureTypeSubmitStatusNotOk, proofParameter)
 
 		m.validateFailureProverTaskStatusNotOk.Inc()
 
 		log.Info("proof generated by prover failed",
-			"taskType", proofMsg.Type, "hash", proofMsg.ID, "proverName", proverTask.ProverName,
+			"taskType", proofParameter.TaskType, "hash", proofParameter.TaskID, "proverName", proverTask.ProverName,
 			"proverVersion", proverTask.ProverVersion, "proverPublicKey", pk, "failureType", proofParameter.FailureType,
-			"failureMessage", failureMsg, "forkName", forkName)
+			"failureMessage", failureMsg)
 		return ErrValidatorFailureProofMsgStatusNotOk
 	}
 
 	// if prover task FailureType is SessionInfoFailureTimeout, the submit proof is timeout, need skip it
 	if types.ProverTaskFailureType(proverTask.FailureType) == types.ProverTaskFailureTypeTimeout {
 		m.validateFailureProverTaskTimeout.Inc()
-		log.Info("proof submit proof have timeout, skip this submit proof", "hash", proofMsg.ID, "taskType", proverTask.TaskType,
-			"proverName", proverTask.ProverName, "proverPublicKey", pk, "proofTime", proofTimeSec, "forkName", forkName)
+		log.Info("proof submit proof have timeout, skip this submit proof", "hash", proofParameter.TaskID, "taskType", proverTask.TaskType,
+			"proverName", proverTask.ProverName, "proverPublicKey", pk, "proofTime", proofTimeSec)
 		return ErrValidatorFailureProofTimeout
 	}
 
 	// store the proof to prover task
-	if updateTaskProofErr := m.updateProverTaskProof(ctx, proverTask, proofMsg); updateTaskProofErr != nil {
-		log.Warn("update prover task proof failure", "hash", proofMsg.ID, "proverPublicKey", pk, "forkName", forkName,
+	if updateTaskProofErr := m.updateProverTaskProof(ctx, proverTask, proofParameter); updateTaskProofErr != nil {
+		log.Warn("update prover task proof failure", "hash", proofParameter.TaskID, "proverPublicKey", pk,
 			"taskType", proverTask.TaskType, "proverName", proverTask.ProverName, "error", updateTaskProofErr)
 	}
 
 	// if the batch/chunk have proved and verifier success, need skip this submit proof
-	if m.checkIsTaskSuccess(ctx, proofMsg.ID, proofMsg.Type) {
+	if m.checkIsTaskSuccess(ctx, proofParameter.TaskID, message.ProofType(proofParameter.TaskType)) {
 		m.validateFailureProverTaskHaveVerifier.Inc()
-		log.Info("the prove task have proved and verifier success, skip this submit proof", "hash", proofMsg.ID,
-			"taskType", proverTask.TaskType, "proverName", proverTask.ProverName, "proverPublicKey", pk, "forkName", forkName)
+		log.Info("the prove task have proved and verifier success, skip this submit proof", "hash", proofParameter.TaskID,
+			"taskType", proverTask.TaskType, "proverName", proverTask.ProverName, "proverPublicKey", pk)
 		return ErrValidatorFailureTaskHaveVerifiedSuccess
 	}
 	return nil
 }
 
-func (m *ProofReceiverLogic) proofRecover(ctx context.Context, proverTask *orm.ProverTask, failureType types.ProverTaskFailureType, proofMsg *message.ProofMsg) {
+func (m *ProofReceiverLogic) proofRecover(ctx context.Context, proverTask *orm.ProverTask, failureType types.ProverTaskFailureType, proofParameter coordinatorType.SubmitProofParameter) {
 	log.Info("proof recover update proof status", "hash", proverTask.TaskID, "proverPublicKey", proverTask.ProverPublicKey,
 		"taskType", message.ProofType(proverTask.TaskType).String(), "status", types.ProvingTaskUnassigned.String())
 
-	if err := m.updateProofStatus(ctx, proverTask, proofMsg, types.ProverProofInvalid, failureType, 0); err != nil {
+	if err := m.updateProofStatus(ctx, proverTask, proofParameter, types.ProverProofInvalid, failureType, 0); err != nil {
 		log.Error("failed to updated proof status ProvingTaskUnassigned", "hash", proverTask.TaskID, "pubKey", proverTask.ProverPublicKey, "error", err)
 	}
 }
 
-func (m *ProofReceiverLogic) closeProofTask(ctx context.Context, proverTask *orm.ProverTask, proofMsg *message.ProofMsg, proofTimeSec uint64) error {
+func (m *ProofReceiverLogic) closeProofTask(ctx context.Context, proverTask *orm.ProverTask, proofParameter coordinatorType.SubmitProofParameter, proofTimeSec uint64) error {
 	log.Info("proof close task update proof status", "hash", proverTask.TaskID, "proverPublicKey", proverTask.ProverPublicKey,
 		"taskType", message.ProofType(proverTask.TaskType).String(), "status", types.ProvingTaskVerified.String())
 
-	if err := m.updateProofStatus(ctx, proverTask, proofMsg, types.ProverProofValid, types.ProverTaskFailureTypeUndefined, proofTimeSec); err != nil {
+	if err := m.updateProofStatus(ctx, proverTask, proofParameter, types.ProverProofValid, types.ProverTaskFailureTypeUndefined, proofTimeSec); err != nil {
 		log.Error("failed to updated proof status ProvingTaskVerified", "hash", proverTask.TaskID, "proverPublicKey", proverTask.ProverPublicKey, "error", err)
 		return err
 	}
@@ -314,14 +318,14 @@ func (m *ProofReceiverLogic) closeProofTask(ctx context.Context, proverTask *orm
 
 // UpdateProofStatus update the chunk/batch task and session info status
 func (m *ProofReceiverLogic) updateProofStatus(ctx context.Context, proverTask *orm.ProverTask,
-	proofMsg *message.ProofMsg, status types.ProverProveStatus, failureType types.ProverTaskFailureType, proofTimeSec uint64) error {
+	proofParameter coordinatorType.SubmitProofParameter, status types.ProverProveStatus, failureType types.ProverTaskFailureType, proofTimeSec uint64) error {
 	err := m.db.Transaction(func(tx *gorm.DB) error {
 		if updateErr := m.proverTaskOrm.UpdateProverTaskProvingStatusAndFailureType(ctx, proverTask.UUID, status, failureType, tx); updateErr != nil {
 			log.Error("failed to update prover task proving status and failure type", "uuid", proverTask.UUID, "error", updateErr)
 			return updateErr
 		}
 
-		switch proofMsg.Type {
+		switch message.ProofType(proofParameter.TaskType) {
 		case message.ProofTypeChunk:
 			if err := m.chunkOrm.DecreaseActiveAttemptsByHash(ctx, proverTask.TaskID, tx); err != nil {
 				log.Error("failed to update chunk proving_status as failed", "hash", proverTask.TaskID, "error", err)
@@ -332,21 +336,28 @@ func (m *ProofReceiverLogic) updateProofStatus(ctx context.Context, proverTask *
 				log.Error("failed to update batch proving_status as failed", "hash", proverTask.TaskID, "error", err)
 				return err
 			}
+		case message.ProofTypeBundle:
+			if err := m.bundleOrm.DecreaseActiveAttemptsByHash(ctx, proverTask.TaskID, tx); err != nil {
+				log.Error("failed to update bundle proving_status as failed", "hash", proverTask.TaskID, "error", err)
+				return err
+			}
 		}
 
 		// if the block batch has proof verified, so the failed status not update block batch proving status
-		if m.checkIsTaskSuccess(ctx, proverTask.TaskID, proofMsg.Type) {
+		if m.checkIsTaskSuccess(ctx, proverTask.TaskID, message.ProofType(proofParameter.TaskType)) {
 			log.Info("update proof status skip because this chunk/batch has been verified", "hash", proverTask.TaskID, "public key", proverTask.ProverPublicKey)
 			return nil
 		}
 
 		if status == types.ProverProofValid {
 			var storeProofErr error
-			switch proofMsg.Type {
+			switch message.ProofType(proofParameter.TaskType) {
 			case message.ProofTypeChunk:
-				storeProofErr = m.chunkOrm.UpdateProofAndProvingStatusByHash(ctx, proofMsg.ID, proofMsg.ChunkProof, types.ProvingTaskVerified, proofTimeSec, tx)
+				storeProofErr = m.chunkOrm.UpdateProofAndProvingStatusByHash(ctx, proofParameter.TaskID, []byte(proofParameter.Proof), types.ProvingTaskVerified, proofTimeSec, tx)
 			case message.ProofTypeBatch:
-				storeProofErr = m.batchOrm.UpdateProofAndProvingStatusByHash(ctx, proofMsg.ID, proofMsg.BatchProof, types.ProvingTaskVerified, proofTimeSec, tx)
+				storeProofErr = m.batchOrm.UpdateProofAndProvingStatusByHash(ctx, proofParameter.TaskID, []byte(proofParameter.Proof), types.ProvingTaskVerified, proofTimeSec, tx)
+			case message.ProofTypeBundle:
+				storeProofErr = m.bundleOrm.UpdateProofAndProvingStatusByHash(ctx, proofParameter.TaskID, []byte(proofParameter.Proof), types.ProvingTaskVerified, proofTimeSec, tx)
 			}
 			if storeProofErr != nil {
 				log.Error("failed to store chunk/batch proof and proving status", "hash", proverTask.TaskID, "public key", proverTask.ProverPublicKey, "error", storeProofErr)
@@ -360,7 +371,7 @@ func (m *ProofReceiverLogic) updateProofStatus(ctx context.Context, proverTask *
 		return err
 	}
 
-	if status == types.ProverProofValid && proofMsg.Type == message.ProofTypeChunk {
+	if status == types.ProverProofValid && message.ProofType(proofParameter.TaskType) == message.ProofTypeChunk {
 		if checkReadyErr := m.checkAreAllChunkProofsReady(ctx, proverTask.TaskID); checkReadyErr != nil {
 			log.Error("failed to check are all chunk proofs ready", "error", checkReadyErr)
 			return checkReadyErr
@@ -385,24 +396,63 @@ func (m *ProofReceiverLogic) checkIsTaskSuccess(ctx context.Context, hash string
 		if err != nil {
 			return false
 		}
+	case message.ProofTypeBundle:
+		provingStatus, err = m.bundleOrm.GetProvingStatusByHash(ctx, hash)
+		if err != nil {
+			return false
+		}
 	}
-
 	return provingStatus == types.ProvingTaskVerified
 }
 
-func (m *ProofReceiverLogic) updateProverTaskProof(ctx context.Context, proverTask *orm.ProverTask, proofMsg *message.ProofMsg) error {
-	// store the proof to prover task
-	var proofBytes []byte
-	var marshalErr error
-	switch proofMsg.Type {
+func (m *ProofReceiverLogic) updateProverTaskProof(ctx context.Context, proverTask *orm.ProverTask, proofParameter coordinatorType.SubmitProofParameter) error {
+	return m.proverTaskOrm.UpdateProverTaskProof(ctx, proverTask.UUID, []byte(proofParameter.Proof))
+}
+
+func (m *ProofReceiverLogic) hardForkName(ctx *gin.Context, hash string, proofType int) (string, error) {
+	var (
+		bundle *orm.Bundle
+		batch  *orm.Batch
+		chunk  *orm.Chunk
+		err    error
+	)
+
+	switch message.ProofType(proofType) {
 	case message.ProofTypeChunk:
-		proofBytes, marshalErr = json.Marshal(proofMsg.ChunkProof)
+		chunk, err = m.chunkOrm.GetChunkByHash(ctx, hash)
 	case message.ProofTypeBatch:
-		proofBytes, marshalErr = json.Marshal(proofMsg.BatchProof)
+		batch, err = m.batchOrm.GetBatchByHash(ctx, hash)
+	case message.ProofTypeBundle:
+		bundle, err = m.bundleOrm.GetBundleByHash(ctx, hash)
 	}
 
-	if len(proofBytes) == 0 || marshalErr != nil {
-		return fmt.Errorf("updateProverTaskProof marshal proof error:%w", marshalErr)
+	if err != nil {
+		return "", err
 	}
-	return m.proverTaskOrm.UpdateProverTaskProof(ctx, proverTask.UUID, proofBytes)
+
+	if bundle != nil {
+		batch, err = m.batchOrm.GetBatchByHash(ctx, bundle.StartBatchHash)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	if batch != nil {
+		chunk, err = m.chunkOrm.GetChunkByHash(ctx, batch.StartChunkHash)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	if chunk == nil {
+		return "", errors.New("failed to find chunk")
+	}
+
+	l2Block, getBlockErr := m.blockOrm.GetL2BlockByNumber(ctx.Copy(), chunk.StartBlockNumber)
+	if getBlockErr != nil {
+		return "", getBlockErr
+	}
+
+	hardForkName := forks.GetHardforkName(m.chainCfg, l2Block.Number, l2Block.BlockTimestamp)
+	return hardForkName, nil
 }

coordinator/internal/logic/verifier/legacy_vk/upgrade_vks.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+work_dir="$(dirname -- "${BASH_SOURCE[0]}")"
+work_dir="$(cd -- "$work_dir" && pwd)"
+echo $work_dir
+
+rm $work_dir/*.vkey
+
+version=release-v0.11.4
+wget https://circuit-release.s3.us-west-2.amazonaws.com/${version}/chunk_vk.vkey -O $work_dir/chunk_vk.vkey
+wget https://circuit-release.s3.us-west-2.amazonaws.com/${version}/agg_vk.vkey -O $work_dir/agg_vk.vkey

coordinator/internal/logic/verifier/mock.go

@@ -10,24 +10,8 @@ import (
 
 // NewVerifier Sets up a mock verifier.
 func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
-	batchVKMap := map[string]string{
-		"shanghai":  "",
-		"bernoulli": "",
-		"london":    "",
-		"istanbul":  "",
-		"homestead": "",
-		"eip155":    "",
-	}
-	chunkVKMap := map[string]string{
-		"shanghai":  "",
-		"bernoulli": "",
-		"london":    "",
-		"istanbul":  "",
-		"homestead": "",
-		"eip155":    "",
-	}
-	batchVKMap[cfg.ForkName] = ""
-	chunkVKMap[cfg.ForkName] = ""
+	batchVKMap := map[string]string{cfg.ForkName: "mock_vk"}
+	chunkVKMap := map[string]string{cfg.ForkName: "mock_vk"}
 	return &Verifier{cfg: cfg, ChunkVKMap: chunkVKMap, BatchVKMap: batchVKMap}, nil
 }
 

coordinator/internal/logic/verifier/types.go

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

coordinator/internal/logic/verifier/verifier.go

@@ -22,33 +22,16 @@ import (
 
 	"github.com/scroll-tech/go-ethereum/log"
 
-	"scroll-tech/coordinator/internal/config"
+	coordinatorType "scroll-tech/common/types/message"
 
-	"scroll-tech/common/types/message"
+	"scroll-tech/coordinator/internal/config"
 )
 
 // NewVerifier Sets up a rust ffi to call verify.
 func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 	if cfg.MockMode {
-		batchVKMap := map[string]string{
-			"shanghai":  "",
-			"bernoulli": "",
-			"london":    "",
-			"istanbul":  "",
-			"homestead": "",
-			"eip155":    "",
-		}
-		chunkVKMap := map[string]string{
-			"shanghai":  "",
-			"bernoulli": "",
-			"london":    "",
-			"istanbul":  "",
-			"homestead": "",
-			"eip155":    "",
-		}
-
-		batchVKMap[cfg.ForkName] = ""
-		chunkVKMap[cfg.ForkName] = ""
+		batchVKMap := map[string]string{cfg.ForkName: "mock_vk"}
+		chunkVKMap := map[string]string{cfg.ForkName: "mock_vk"}
 		return &Verifier{cfg: cfg, ChunkVKMap: chunkVKMap, BatchVKMap: batchVKMap}, nil
 	}
 	paramsPathStr := C.CString(cfg.ParamsPath)
@@ -67,7 +50,11 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 		BatchVKMap: make(map[string]string),
 	}
 
-	batchVK, err := v.readVK(path.Join(cfg.AssetsPath, "agg_vk.vkey"))
+	bundleVK, err := v.readVK(path.Join(cfg.AssetsPath, "bundle_vk.vkey"))
+	if err != nil {
+		return nil, err
+	}
+	batchVK, err := v.readVK(path.Join(cfg.AssetsPath, "batch_vk.vkey"))
 	if err != nil {
 		return nil, err
 	}
@@ -75,6 +62,7 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 	if err != nil {
 		return nil, err
 	}
+	v.BundleVkMap[cfg.ForkName] = bundleVK
 	v.BatchVKMap[cfg.ForkName] = batchVK
 	v.ChunkVKMap[cfg.ForkName] = chunkVK
 
@@ -85,7 +73,7 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 }
 
 // VerifyBatchProof Verify a ZkProof by marshaling it and sending it to the Halo2 Verifier.
-func (v *Verifier) VerifyBatchProof(proof *message.BatchProof, forkName string) (bool, error) {
+func (v *Verifier) VerifyBatchProof(proof *coordinatorType.BatchProof, forkName string) (bool, error) {
 	if v.cfg.MockMode {
 		log.Info("Mock mode, batch verifier disabled")
 		if string(proof.Proof) == InvalidTestProof {
@@ -112,7 +100,7 @@ func (v *Verifier) VerifyBatchProof(proof *message.BatchProof, forkName string)
 }
 
 // VerifyChunkProof Verify a ZkProof by marshaling it and sending it to the Halo2 Verifier.
-func (v *Verifier) VerifyChunkProof(proof *message.ChunkProof) (bool, error) {
+func (v *Verifier) VerifyChunkProof(proof *coordinatorType.ChunkProof) (bool, error) {
 	if v.cfg.MockMode {
 		log.Info("Mock mode, verifier disabled")
 		if string(proof.Proof) == InvalidTestProof {
@@ -164,7 +152,7 @@ func (v *Verifier) loadEmbedVK() error {
 		return err
 	}
 
-	v.BatchVKMap["bernoulli"] = base64.StdEncoding.EncodeToString(batchVKBytes)
-	v.ChunkVKMap["bernoulli"] = base64.StdEncoding.EncodeToString(chunkVkBytes)
+	v.BatchVKMap["curie"] = base64.StdEncoding.EncodeToString(batchVKBytes)
+	v.ChunkVKMap["curie"] = base64.StdEncoding.EncodeToString(chunkVkBytes)
 	return nil
 }

coordinator/internal/orm/batch.go

@@ -2,7 +2,6 @@ package orm
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"time"
@@ -13,7 +12,6 @@ import (
 	"gorm.io/gorm"
 
 	"scroll-tech/common/types"
-	"scroll-tech/common/types/message"
 	"scroll-tech/common/utils"
 )
 
@@ -59,6 +57,9 @@ type Batch struct {
 	BlobDataProof []byte `json:"blob_data_proof" gorm:"column:blob_data_proof"`
 	BlobSize      uint64 `json:"blob_size" gorm:"column:blob_size"`
 
+	// bundle
+	BundleHash string `json:"bundle_hash" gorm:"column:bundle_hash"`
+
 	// metadata
 	CreatedAt time.Time      `json:"created_at" gorm:"column:created_at"`
 	UpdatedAt time.Time      `json:"updated_at" gorm:"column:updated_at"`
@@ -76,12 +77,12 @@ func (*Batch) TableName() string {
 }
 
 // GetUnassignedBatch retrieves unassigned batch based on the specified limit.
-// The returned batch are sorted in ascending order by their index.
-func (o *Batch) GetUnassignedBatch(ctx context.Context, startChunkIndex, endChunkIndex uint64, maxActiveAttempts, maxTotalAttempts uint8) (*Batch, error) {
+// The returned batches are sorted in ascending order by their index.
+func (o *Batch) GetUnassignedBatch(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8) (*Batch, error) {
 	var batch Batch
 	db := o.db.WithContext(ctx)
-	sql := fmt.Sprintf("SELECT * FROM batch WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND chunk_proofs_status = %d AND start_chunk_index >= %d AND end_chunk_index < %d AND batch.deleted_at IS NULL ORDER BY batch.index LIMIT 1;",
-		int(types.ProvingTaskUnassigned), maxTotalAttempts, maxActiveAttempts, int(types.ChunkProofsStatusReady), startChunkIndex, endChunkIndex)
+	sql := fmt.Sprintf("SELECT * FROM batch WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND chunk_proofs_status = %d AND batch.deleted_at IS NULL ORDER BY batch.index LIMIT 1;",
+		int(types.ProvingTaskUnassigned), maxTotalAttempts, maxActiveAttempts, int(types.ChunkProofsStatusReady))
 	err := db.Raw(sql).Scan(&batch).Error
 	if err != nil {
 		return nil, fmt.Errorf("Batch.GetUnassignedBatch error: %w", err)
@@ -93,12 +94,12 @@ func (o *Batch) GetUnassignedBatch(ctx context.Context, startChunkIndex, endChun
 }
 
 // GetAssignedBatch retrieves assigned batch based on the specified limit.
-// The returned batch are sorted in ascending order by their index.
-func (o *Batch) GetAssignedBatch(ctx context.Context, startChunkIndex, endChunkIndex uint64, maxActiveAttempts, maxTotalAttempts uint8) (*Batch, error) {
+// The returned batches are sorted in ascending order by their index.
+func (o *Batch) GetAssignedBatch(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8) (*Batch, error) {
 	var batch Batch
 	db := o.db.WithContext(ctx)
-	sql := fmt.Sprintf("SELECT * FROM batch WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND chunk_proofs_status = %d AND start_chunk_index >= %d AND end_chunk_index < %d AND batch.deleted_at IS NULL ORDER BY batch.index LIMIT 1;",
-		int(types.ProvingTaskAssigned), maxTotalAttempts, maxActiveAttempts, int(types.ChunkProofsStatusReady), startChunkIndex, endChunkIndex)
+	sql := fmt.Sprintf("SELECT * FROM batch WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND chunk_proofs_status = %d AND batch.deleted_at IS NULL ORDER BY batch.index LIMIT 1;",
+		int(types.ProvingTaskAssigned), maxTotalAttempts, maxActiveAttempts, int(types.ChunkProofsStatusReady))
 	err := db.Raw(sql).Scan(&batch).Error
 	if err != nil {
 		return nil, fmt.Errorf("Batch.GetAssignedBatch error: %w", err)
@@ -184,6 +185,63 @@ func (o *Batch) GetAttemptsByHash(ctx context.Context, hash string) (int16, int1
 	return batch.ActiveAttempts, batch.TotalAttempts, nil
 }
 
+// CheckIfBundleBatchProofsAreReady checks if all proofs for all batches of a given bundleHash are collected.
+func (o *Batch) CheckIfBundleBatchProofsAreReady(ctx context.Context, bundleHash string) (bool, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&Batch{})
+	db = db.Where("bundle_hash = ? AND proving_status != ?", bundleHash, types.ProvingTaskVerified)
+
+	var count int64
+	if err := db.Count(&count).Error; err != nil {
+		return false, fmt.Errorf("Chunk.CheckIfBundleBatchProofsAreReady error: %w, bundle hash: %v", err, bundleHash)
+	}
+	return count == 0, nil
+}
+
+// GetBatchByHash retrieves the given batch.
+func (o *Batch) GetBatchByHash(ctx context.Context, hash string) (*Batch, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&Batch{})
+	db = db.Where("hash = ?", hash)
+
+	var batch Batch
+	if err := db.First(&batch).Error; err != nil {
+		return nil, fmt.Errorf("Batch.GetBatchByHash error: %w, batch hash: %v", err, hash)
+	}
+	return &batch, nil
+}
+
+// GetLatestFinalizedBatch retrieves the latest finalized batch from the database.
+func (o *Batch) GetLatestFinalizedBatch(ctx context.Context) (*Batch, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&Batch{})
+	db = db.Where("rollup_status = ?", int(types.RollupFinalized))
+	db = db.Order("index desc")
+
+	var latestFinalizedBatch Batch
+	if err := db.First(&latestFinalizedBatch).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("Batch.GetLatestBatch error: %w", err)
+	}
+	return &latestFinalizedBatch, nil
+}
+
+// GetBatchesByBundleHash retrieves the given batch.
+func (o *Batch) GetBatchesByBundleHash(ctx context.Context, bundleHash string) ([]*Batch, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&Batch{})
+	db = db.Where("bundle_hash = ?", bundleHash)
+	db = db.Order("index ASC")
+
+	var batches []*Batch
+	if err := db.First(&batches).Error; err != nil {
+		return nil, fmt.Errorf("Batch.GetBatchesByBundleHash error: %w, bundle hash: %v", err, bundleHash)
+	}
+	return batches, nil
+}
+
 // InsertBatch inserts a new batch into the database.
 func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, dbTX ...*gorm.DB) (*Batch, error) {
 	if batch == nil {
@@ -317,18 +375,14 @@ func (o *Batch) UpdateProvingStatusFailed(ctx context.Context, hash string, maxA
 }
 
 // UpdateProofAndProvingStatusByHash updates the batch proof and proving status by hash.
-func (o *Batch) UpdateProofAndProvingStatusByHash(ctx context.Context, hash string, proof *message.BatchProof, provingStatus types.ProvingStatus, proofTimeSec uint64, dbTX ...*gorm.DB) error {
+func (o *Batch) UpdateProofAndProvingStatusByHash(ctx context.Context, hash string, proof []byte, provingStatus types.ProvingStatus, proofTimeSec uint64, dbTX ...*gorm.DB) error {
 	db := o.db
 	if len(dbTX) > 0 && dbTX[0] != nil {
 		db = dbTX[0]
 	}
-	proofBytes, err := json.Marshal(proof)
-	if err != nil {
-		return err
-	}
 
 	updateFields := make(map[string]interface{})
-	updateFields["proof"] = proofBytes
+	updateFields["proof"] = proof
 	updateFields["proving_status"] = provingStatus
 	updateFields["proof_time_sec"] = proofTimeSec
 	updateFields["proved_at"] = utils.NowUTC()

coordinator/internal/orm/bundle.go

@@ -0,0 +1,229 @@
+package orm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/scroll-tech/go-ethereum/log"
+	"gorm.io/gorm"
+
+	"scroll-tech/common/types"
+	"scroll-tech/common/utils"
+)
+
+// Bundle represents a bundle of batches.
+type Bundle struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	Index           uint64 `json:"index" gorm:"column:index"`
+	Hash            string `json:"hash" gorm:"column:hash"`
+	StartBatchIndex uint64 `json:"start_batch_index" gorm:"column:start_batch_index"`
+	StartBatchHash  string `json:"start_batch_hash" gorm:"column:start_batch_hash"`
+	EndBatchIndex   uint64 `json:"end_batch_index" gorm:"column:end_batch_index"`
+	EndBatchHash    string `json:"end_batch_hash" gorm:"column:end_batch_hash"`
+
+	// proof
+	BatchProofsStatus int16      `json:"batch_proofs_status" gorm:"column:batch_proofs_status;default:1"`
+	ProvingStatus     int16      `json:"proving_status" gorm:"column:proving_status;default:1"`
+	Proof             []byte     `json:"proof" gorm:"column:proof;default:NULL"`
+	ProverAssignedAt  *time.Time `json:"prover_assigned_at" gorm:"column:prover_assigned_at;default:NULL"`
+	ProvedAt          *time.Time `json:"proved_at" gorm:"column:proved_at;default:NULL"`
+	ProofTimeSec      int32      `json:"proof_time_sec" gorm:"column:proof_time_sec;default:NULL"`
+	TotalAttempts     int16      `json:"total_attempts" gorm:"column:total_attempts;default:0"`
+	ActiveAttempts    int16      `json:"active_attempts" gorm:"column:active_attempts;default:0"`
+
+	// rollup
+	RollupStatus   int16      `json:"rollup_status" gorm:"column:rollup_status;default:1"`
+	FinalizeTxHash string     `json:"finalize_tx_hash" gorm:"column:finalize_tx_hash;default:NULL"`
+	FinalizedAt    *time.Time `json:"finalized_at" gorm:"column:finalized_at;default:NULL"`
+
+	// metadata
+	CreatedAt time.Time      `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt time.Time      `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at;default:NULL"`
+}
+
+// NewBundle creates a new Bundle database instance.
+func NewBundle(db *gorm.DB) *Bundle {
+	return &Bundle{db: db}
+}
+
+// TableName returns the table name for the Bundle model.
+func (*Bundle) TableName() string {
+	return "bundle"
+}
+
+// GetUnassignedBundle retrieves unassigned bundle based on the specified limit.
+// The returned batch sorts in ascending order by their index.
+func (o *Bundle) GetUnassignedBundle(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8) (*Bundle, error) {
+	var bundle Bundle
+	db := o.db.WithContext(ctx)
+	sql := fmt.Sprintf("SELECT * FROM bundle WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND batch_proofs_status = %d AND bundle.deleted_at IS NULL ORDER BY bundle.index LIMIT 1;",
+		int(types.ProvingTaskUnassigned), maxTotalAttempts, maxActiveAttempts, int(types.BatchProofsStatusReady))
+	err := db.Raw(sql).Scan(&bundle).Error
+	if err != nil {
+		return nil, fmt.Errorf("Batch.GetUnassignedBundle error: %w", err)
+	}
+	if bundle.StartBatchHash == "" || bundle.EndBatchHash == "" {
+		return nil, nil
+	}
+	return &bundle, nil
+}
+
+// GetAssignedBundle retrieves assigned bundle based on the specified limit.
+// The returned bundle sorts in ascending order by their index.
+func (o *Bundle) GetAssignedBundle(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8) (*Bundle, error) {
+	var bundle Bundle
+	db := o.db.WithContext(ctx)
+	sql := fmt.Sprintf("SELECT * FROM bundle WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND batch_proofs_status = %d AND bundle.deleted_at IS NULL ORDER BY bundle.index LIMIT 1;",
+		int(types.ProvingTaskAssigned), maxTotalAttempts, maxActiveAttempts, int(types.BatchProofsStatusReady))
+	err := db.Raw(sql).Scan(&bundle).Error
+	if err != nil {
+		return nil, fmt.Errorf("Bundle.GetAssignedBatch error: %w", err)
+	}
+	if bundle.StartBatchHash == "" || bundle.EndBatchHash == "" {
+		return nil, nil
+	}
+	return &bundle, nil
+}
+
+// GetProvingStatusByHash retrieves the proving status of a bundle given its hash.
+func (o *Bundle) GetProvingStatusByHash(ctx context.Context, hash string) (types.ProvingStatus, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&Bundle{})
+	db = db.Select("proving_status")
+	db = db.Where("hash = ?", hash)
+
+	var bundle Bundle
+	if err := db.Find(&bundle).Error; err != nil {
+		return types.ProvingStatusUndefined, fmt.Errorf("Bundle.GetProvingStatusByHash error: %w, batch hash: %v", err, hash)
+	}
+	return types.ProvingStatus(bundle.ProvingStatus), nil
+}
+
+// GetBundleByHash retrieves the given
+func (o *Bundle) GetBundleByHash(ctx context.Context, bundleHash string) (*Bundle, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&Bundle{})
+	db = db.Where("hash = ?", bundleHash)
+
+	var bundle Bundle
+	if err := db.First(&bundle).Error; err != nil {
+		return nil, fmt.Errorf("Bundle.GetBundleByHash error: %w, bundle hash: %v", err, bundleHash)
+	}
+	return &bundle, nil
+}
+
+// GetUnassignedAndBatchesUnreadyBundles get the bundles which is unassigned and batches are not ready
+func (o *Bundle) GetUnassignedAndBatchesUnreadyBundles(ctx context.Context, offset, limit int) ([]*Bundle, error) {
+	if offset < 0 || limit < 0 {
+		return nil, errors.New("limit and offset must not be smaller than 0")
+	}
+
+	db := o.db.WithContext(ctx)
+	db = db.Where("proving_status = ?", types.ProvingTaskUnassigned)
+	db = db.Where("batch_proofs_status = ?", types.BatchProofsStatusPending)
+	db = db.Order("index ASC")
+	db = db.Offset(offset)
+	db = db.Limit(limit)
+
+	var bundles []*Bundle
+	if err := db.Find(&bundles).Error; err != nil {
+		return nil, fmt.Errorf("Bundle.GetUnassignedAndBatchesUnreadyBundles error: %w", err)
+	}
+	return bundles, nil
+}
+
+// UpdateBatchProofsStatusByBatchHash updates the status of batch_proofs_status field for a given bundle hash.
+func (o *Bundle) UpdateBatchProofsStatusByBatchHash(ctx context.Context, bundleHash string, status types.BatchProofsStatus) error {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&Bundle{})
+	db = db.Where("hash = ?", bundleHash)
+
+	if err := db.Update("batch_proofs_status", status).Error; err != nil {
+		return fmt.Errorf("Bundle.UpdateBatchProofsStatusByBatchHash error: %w, bundle hash: %v, status: %v", err, bundleHash, status.String())
+	}
+	return nil
+}
+
+// UpdateProvingStatusFailed updates the proving status failed of a bundle.
+func (o *Bundle) UpdateProvingStatusFailed(ctx context.Context, bundleHash string, maxAttempts uint8, dbTX ...*gorm.DB) error {
+	db := o.db
+	if len(dbTX) > 0 && dbTX[0] != nil {
+		db = dbTX[0]
+	}
+	db = db.WithContext(ctx)
+	db = db.Model(&Bundle{})
+	db = db.Where("hash", bundleHash)
+	db = db.Where("total_attempts >= ?", maxAttempts)
+	db = db.Where("proving_status != ?", int(types.ProvingTaskVerified))
+	if err := db.Update("proving_status", int(types.ProvingTaskFailed)).Error; err != nil {
+		return fmt.Errorf("Bundle.UpdateProvingStatus error: %w, bundle hash: %v, status: %v", err, bundleHash, types.ProvingTaskFailed.String())
+	}
+	return nil
+}
+
+// UpdateProofAndProvingStatusByHash updates the bundle proof and proving status by hash.
+func (o *Bundle) UpdateProofAndProvingStatusByHash(ctx context.Context, hash string, proof []byte, provingStatus types.ProvingStatus, proofTimeSec uint64, dbTX ...*gorm.DB) error {
+	db := o.db
+	if len(dbTX) > 0 && dbTX[0] != nil {
+		db = dbTX[0]
+	}
+
+	updateFields := make(map[string]interface{})
+	updateFields["proof"] = proof
+	updateFields["proving_status"] = provingStatus
+	updateFields["proof_time_sec"] = proofTimeSec
+	updateFields["proved_at"] = utils.NowUTC()
+
+	db = db.WithContext(ctx)
+	db = db.Model(&Bundle{})
+	db = db.Where("hash", hash)
+
+	if err := db.Updates(updateFields).Error; err != nil {
+		return fmt.Errorf("Batch.UpdateProofByHash error: %w, batch hash: %v", err, hash)
+	}
+	return nil
+}
+
+// UpdateBundleAttempts atomically increments the attempts count for the earliest available bundle that meets the conditions.
+func (o *Bundle) UpdateBundleAttempts(ctx context.Context, hash string, curActiveAttempts, curTotalAttempts int16) (int64, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&Bundle{})
+	db = db.Where("hash = ?", hash)
+	db = db.Where("active_attempts = ?", curActiveAttempts)
+	db = db.Where("total_attempts = ?", curTotalAttempts)
+	result := db.Updates(map[string]interface{}{
+		"proving_status":  types.ProvingTaskAssigned,
+		"total_attempts":  gorm.Expr("total_attempts + 1"),
+		"active_attempts": gorm.Expr("active_attempts + 1"),
+	})
+
+	if result.Error != nil {
+		return 0, fmt.Errorf("failed to update bundle, err:%w", result.Error)
+	}
+	return result.RowsAffected, nil
+}
+
+// DecreaseActiveAttemptsByHash decrements the active_attempts of a bundle given its hash.
+func (o *Bundle) DecreaseActiveAttemptsByHash(ctx context.Context, bundleHash string, dbTX ...*gorm.DB) error {
+	db := o.db
+	if len(dbTX) > 0 && dbTX[0] != nil {
+		db = dbTX[0]
+	}
+	db = db.WithContext(ctx)
+	db = db.Model(&Bundle{})
+	db = db.Where("hash = ?", bundleHash)
+	db = db.Where("proving_status != ?", int(types.ProvingTaskVerified))
+	db = db.Where("active_attempts > ?", 0)
+	result := db.UpdateColumn("active_attempts", gorm.Expr("active_attempts - 1"))
+	if result.Error != nil {
+		return fmt.Errorf("Bundle.DecreaseActiveAttemptsByHash error: %w, bundle hash: %v", result.Error, bundleHash)
+	}
+	if result.RowsAffected == 0 {
+		log.Warn("No rows were affected in DecreaseActiveAttemptsByHash", "bundle hash", bundleHash)
+	}
+	return nil
+}

coordinator/internal/orm/chunk.go

@@ -74,11 +74,11 @@ func (*Chunk) TableName() string {
 
 // GetUnassignedChunk retrieves unassigned chunk based on the specified limit.
 // The returned chunks are sorted in ascending order by their index.
-func (o *Chunk) GetUnassignedChunk(ctx context.Context, fromBlockNum, toBlockNum uint64, maxActiveAttempts, maxTotalAttempts uint8) (*Chunk, error) {
+func (o *Chunk) GetUnassignedChunk(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8) (*Chunk, error) {
 	var chunk Chunk
 	db := o.db.WithContext(ctx)
-	sql := fmt.Sprintf("SELECT * FROM chunk WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND start_block_number >= %d AND end_block_number < %d AND chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
-		int(types.ProvingTaskUnassigned), maxTotalAttempts, maxActiveAttempts, fromBlockNum, toBlockNum)
+	sql := fmt.Sprintf("SELECT * FROM chunk WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
+		int(types.ProvingTaskUnassigned), maxTotalAttempts, maxActiveAttempts)
 	err := db.Raw(sql).Scan(&chunk).Error
 	if err != nil {
 		return nil, fmt.Errorf("Chunk.GetUnassignedChunk error: %w", err)
@@ -91,11 +91,11 @@ func (o *Chunk) GetUnassignedChunk(ctx context.Context, fromBlockNum, toBlockNum
 
 // GetAssignedChunk retrieves assigned chunk based on the specified limit.
 // The returned chunks are sorted in ascending order by their index.
-func (o *Chunk) GetAssignedChunk(ctx context.Context, fromBlockNum, toBlockNum uint64, maxActiveAttempts, maxTotalAttempts uint8) (*Chunk, error) {
+func (o *Chunk) GetAssignedChunk(ctx context.Context, maxActiveAttempts, maxTotalAttempts uint8) (*Chunk, error) {
 	var chunk Chunk
 	db := o.db.WithContext(ctx)
-	sql := fmt.Sprintf("SELECT * FROM chunk WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND start_block_number >= %d AND end_block_number < %d AND chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
-		int(types.ProvingTaskAssigned), maxTotalAttempts, maxActiveAttempts, fromBlockNum, toBlockNum)
+	sql := fmt.Sprintf("SELECT * FROM chunk WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d  AND chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
+		int(types.ProvingTaskAssigned), maxTotalAttempts, maxActiveAttempts)
 	err := db.Raw(sql).Scan(&chunk).Error
 	if err != nil {
 		return nil, fmt.Errorf("Chunk.GetAssignedChunk error: %w", err)
@@ -340,18 +340,14 @@ func (o *Chunk) UpdateProvingStatusFailed(ctx context.Context, hash string, maxA
 }
 
 // UpdateProofAndProvingStatusByHash updates the chunk proof and proving_status by hash.
-func (o *Chunk) UpdateProofAndProvingStatusByHash(ctx context.Context, hash string, proof *message.ChunkProof, status types.ProvingStatus, proofTimeSec uint64, dbTX ...*gorm.DB) error {
+func (o *Chunk) UpdateProofAndProvingStatusByHash(ctx context.Context, hash string, proof []byte, status types.ProvingStatus, proofTimeSec uint64, dbTX ...*gorm.DB) error {
 	db := o.db
 	if len(dbTX) > 0 && dbTX[0] != nil {
 		db = dbTX[0]
 	}
-	proofBytes, err := json.Marshal(proof)
-	if err != nil {
-		return err
-	}
 
 	updateFields := make(map[string]interface{})
-	updateFields["proof"] = proofBytes
+	updateFields["proof"] = proof
 	updateFields["proving_status"] = int(status)
 	updateFields["proof_time_sec"] = proofTimeSec
 	updateFields["proved_at"] = utils.NowUTC()

coordinator/internal/orm/l2_block.go

@@ -74,6 +74,19 @@ func (o *L2Block) GetL2BlockHashesByChunkHash(ctx context.Context, chunkHash str
 	return blockHashes, nil
 }
 
+// GetL2BlockByNumber retrieves the L2 block by l2 block number
+func (o *L2Block) GetL2BlockByNumber(ctx context.Context, blockNumber uint64) (*L2Block, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&L2Block{})
+	db = db.Where("number = ?", blockNumber)
+
+	var l2Block L2Block
+	if err := db.First(&l2Block).Error; err != nil {
+		return nil, fmt.Errorf("L2Block.GetL2BlockByNumber error: %w, chunk block number: %v", err, blockNumber)
+	}
+	return &l2Block, nil
+}
+
 // InsertL2Blocks inserts l2 blocks into the "l2_block" table.
 // for unit test
 func (o *L2Block) InsertL2Blocks(ctx context.Context, blocks []*encoding.Block) error {

coordinator/internal/orm/prover_task.go

@@ -11,7 +11,7 @@ import (
 	"gorm.io/gorm/clause"
 
 	"scroll-tech/common/types"
-	"scroll-tech/common/types/message"
+	coordinatorType "scroll-tech/common/types/message"
 	"scroll-tech/common/utils"
 )
 
@@ -98,7 +98,7 @@ func (o *ProverTask) GetProverTasks(ctx context.Context, fields map[string]inter
 
 // GetProverTasksByHashes retrieves the ProverTask records associated with the specified hashes.
 // The returned prover task objects are sorted in ascending order by their ids.
-func (o *ProverTask) GetProverTasksByHashes(ctx context.Context, taskType message.ProofType, hashes []string) ([]*ProverTask, error) {
+func (o *ProverTask) GetProverTasksByHashes(ctx context.Context, taskType coordinatorType.ProofType, hashes []string) ([]*ProverTask, error) {
 	if len(hashes) == 0 {
 		return nil, nil
 	}
@@ -118,7 +118,7 @@ func (o *ProverTask) GetProverTasksByHashes(ctx context.Context, taskType messag
 
 // GetAssignedProverTaskByTaskIDAndProver get prover task taskID and public key
 // TODO: when prover all upgrade need DEPRECATED this function
-func (o *ProverTask) GetAssignedProverTaskByTaskIDAndProver(ctx context.Context, taskType message.ProofType, taskID, proverPublicKey, proverVersion string) (*ProverTask, error) {
+func (o *ProverTask) GetAssignedProverTaskByTaskIDAndProver(ctx context.Context, taskType coordinatorType.ProofType, taskID, proverPublicKey, proverVersion string) (*ProverTask, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&ProverTask{})
 	db = db.Where("task_type", int(taskType))
@@ -151,7 +151,7 @@ func (o *ProverTask) GetProverTaskByUUIDAndPublicKey(ctx context.Context, uuid,
 }
 
 // GetAssignedTaskOfOtherProvers get the chunk/batch task assigned other provers
-func (o *ProverTask) GetAssignedTaskOfOtherProvers(ctx context.Context, taskType message.ProofType, taskID, proverPublicKey string) ([]ProverTask, error) {
+func (o *ProverTask) GetAssignedTaskOfOtherProvers(ctx context.Context, taskType coordinatorType.ProofType, taskID, proverPublicKey string) ([]ProverTask, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&ProverTask{})
 	db = db.Where("task_type", int(taskType))
@@ -167,7 +167,7 @@ func (o *ProverTask) GetAssignedTaskOfOtherProvers(ctx context.Context, taskType
 }
 
 // GetProvingStatusByTaskID retrieves the proving status of a prover task
-func (o *ProverTask) GetProvingStatusByTaskID(ctx context.Context, taskType message.ProofType, taskID string) (types.ProverProveStatus, error) {
+func (o *ProverTask) GetProvingStatusByTaskID(ctx context.Context, taskType coordinatorType.ProofType, taskID string) (types.ProverProveStatus, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&ProverTask{})
 	db = db.Select("proving_status")
@@ -182,7 +182,7 @@ func (o *ProverTask) GetProvingStatusByTaskID(ctx context.Context, taskType mess
 }
 
 // GetTimeoutAssignedProverTasks get the timeout and assigned proving_status prover task
-func (o *ProverTask) GetTimeoutAssignedProverTasks(ctx context.Context, limit int, taskType message.ProofType, timeout time.Duration) ([]ProverTask, error) {
+func (o *ProverTask) GetTimeoutAssignedProverTasks(ctx context.Context, limit int, taskType coordinatorType.ProofType, timeout time.Duration) ([]ProverTask, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&ProverTask{})
 	db = db.Where("proving_status", int(types.ProverAssigned))
@@ -199,7 +199,7 @@ func (o *ProverTask) GetTimeoutAssignedProverTasks(ctx context.Context, limit in
 }
 
 // TaskTimeoutMoreThanOnce get the timeout twice task. a temp design
-func (o *ProverTask) TaskTimeoutMoreThanOnce(ctx context.Context, taskType message.ProofType, taskID string) bool {
+func (o *ProverTask) TaskTimeoutMoreThanOnce(ctx context.Context, taskType coordinatorType.ProofType, taskID string) bool {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&ProverTask{})
 	db = db.Where("task_type", int(taskType))

coordinator/internal/types/auth.go

@@ -1,6 +1,15 @@
 package types
 
-import "time"
+import (
+	"crypto/ecdsa"
+	"encoding/hex"
+	"time"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/common/hexutil"
+	"github.com/scroll-tech/go-ethereum/crypto"
+	"github.com/scroll-tech/go-ethereum/rlp"
+)
 
 const (
 	// PublicKey the public key for context
@@ -9,26 +18,88 @@ const (
 	ProverName = "prover_name"
 	// ProverVersion the prover version for context
 	ProverVersion = "prover_version"
-	// HardForkName the fork name for context
-	HardForkName = "hard_fork_name"
 )
 
-// Message the login message struct
-type Message struct {
-	Challenge     string `form:"challenge" json:"challenge" binding:"required"`
-	ProverVersion string `form:"prover_version" json:"prover_version" binding:"required"`
-	ProverName    string `form:"prover_name" json:"prover_name" binding:"required"`
-	HardForkName  string `form:"hard_fork_name" json:"hard_fork_name"`
-}
-
-// LoginParameter for /login api
-type LoginParameter struct {
-	Message   Message `form:"message" json:"message" binding:"required"`
-	Signature string  `form:"signature" json:"signature" binding:"required"`
-}
-
 // LoginSchema for /login response
 type LoginSchema struct {
 	Time  time.Time `json:"time"`
 	Token string    `json:"token"`
 }
+
+// Message the login message struct
+type Message struct {
+	Challenge     string       `form:"challenge" json:"challenge" binding:"required"`
+	ProverVersion string       `form:"prover_version" json:"prover_version" binding:"required"`
+	ProverName    string       `form:"prover_name" json:"prover_name" binding:"required"`
+	ProverTypes   []ProverType `form:"prover_types" json:"prover_types"`
+	VKs           []string     `form:"vks" json:"vks"`
+}
+
+// LoginParameter for /login api
+type LoginParameter struct {
+	Message   Message `form:"message" json:"message" binding:"required"`
+	PublicKey string  `form:"public_key" json:"public_key"`
+	Signature string  `form:"signature" json:"signature" binding:"required"`
+}
+
+// SignWithKey auth message with private key and set public key in auth message's Identity
+func (a *LoginParameter) SignWithKey(priv *ecdsa.PrivateKey) error {
+	// Hash identity content
+	hash, err := a.Message.Hash()
+	if err != nil {
+		return err
+	}
+
+	// Sign register message
+	sig, err := crypto.Sign(hash, priv)
+	if err != nil {
+		return err
+	}
+
+	a.Signature = hexutil.Encode(sig)
+	return nil
+}
+
+// Verify verifies the message of auth.
+func (a *LoginParameter) Verify() (bool, error) {
+	hash, err := a.Message.Hash()
+	if err != nil {
+		return false, err
+	}
+
+	expectedPubKey, err := a.Message.DecodeAndUnmarshalPubkey(a.PublicKey)
+	if err != nil {
+		return false, err
+	}
+
+	sig := common.FromHex(a.Signature)
+	isValid := crypto.VerifySignature(crypto.CompressPubkey(expectedPubKey), hash, sig[:len(sig)-1])
+	return isValid, nil
+}
+
+// Hash returns the hash of the auth message, which should be the message used
+// to construct the Signature.
+func (i *Message) Hash() ([]byte, error) {
+	byt, err := rlp.EncodeToBytes(i)
+	if err != nil {
+		return nil, err
+	}
+	hash := crypto.Keccak256Hash(byt)
+	return hash[:], nil
+}
+
+// DecodeAndUnmarshalPubkey decodes a hex-encoded public key and unmarshal it into an ecdsa.PublicKey
+func (i *Message) DecodeAndUnmarshalPubkey(pubKeyHex string) (*ecdsa.PublicKey, error) {
+	// Decode hex string to bytes
+	byteKey, err := hex.DecodeString(pubKeyHex)
+	if err != nil {
+		return nil, err
+	}
+
+	// Unmarshal bytes to ECDSA public key
+	pubKey, err := crypto.DecompressPubkey(byteKey)
+	if err != nil {
+		return nil, err
+	}
+	return pubKey, nil
+}

coordinator/internal/types/auth_test.go

@@ -0,0 +1,77 @@
+package types
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/crypto"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAuthMessageSignAndVerify(t *testing.T) {
+	privateKey, err := crypto.GenerateKey()
+	assert.NoError(t, err)
+	publicKeyHex := common.Bytes2Hex(crypto.CompressPubkey(&privateKey.PublicKey))
+
+	var authMsg LoginParameter
+	t.Run("sign", func(t *testing.T) {
+		authMsg = LoginParameter{
+			Message: Message{
+				ProverName:    "test1",
+				ProverVersion: "v0.0.1",
+				Challenge:     "abcdef",
+				ProverTypes:   []ProverType{ProverTypeBatch},
+				VKs:           []string{"vk1", "vk2"},
+			},
+			PublicKey: publicKeyHex,
+		}
+
+		err = authMsg.SignWithKey(privateKey)
+		assert.NoError(t, err)
+	})
+
+	t.Run("valid verify", func(t *testing.T) {
+		ok, verifyErr := authMsg.Verify()
+		assert.True(t, ok)
+		assert.NoError(t, verifyErr)
+	})
+
+	t.Run("invalid verify", func(t *testing.T) {
+		authMsg.Message.Challenge = "abcdefgh"
+		ok, verifyErr := authMsg.Verify()
+		assert.False(t, ok)
+		assert.NoError(t, verifyErr)
+	})
+}
+
+// TestGenerateSignature this unit test isn't for test, just generate the signature for manually test.
+func TestGenerateSignature(t *testing.T) {
+	privateKeyHex := "8b8df68fddf7ee2724b79ccbd07799909d59b4dd4f4df3f6ecdc4fb8d56bdf4c"
+	privateKeyBytes, err := hex.DecodeString(privateKeyHex)
+	assert.Nil(t, err)
+	privateKey, err := crypto.ToECDSA(privateKeyBytes)
+	assert.NoError(t, err)
+	assert.NoError(t, err)
+	publicKeyHex := common.Bytes2Hex(crypto.CompressPubkey(&privateKey.PublicKey))
+
+	t.Log("publicKey: ", publicKeyHex)
+
+	authMsg := LoginParameter{
+		Message: Message{
+			ProverName:    "test",
+			ProverVersion: "v4.1.115-4dd11c6-000000-000000",
+			Challenge:     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MTk1NjkyNDAsIm9yaWdfaWF0IjoxNzE5NTY1NjQwLCJyYW5kb20iOiJPRExnNEZtUW1MOEwzTDRvZ3BMcnl6c09EN1ZXd0FoNmd3bVpzVURJV3M0PSJ9.3Oq7fDtFnKGbPyjc8fslzfftyzreQbi-lAr0_HFy54w",
+			ProverTypes:   []ProverType{ProverTypeChunk},
+			VKs:           []string{"mock_chunk_vk"},
+		},
+		PublicKey: publicKeyHex,
+	}
+	err = authMsg.SignWithKey(privateKey)
+	assert.NoError(t, err)
+	t.Log("signature: ", authMsg.Signature)
+
+	verify, err := authMsg.Verify()
+	assert.NoError(t, err)
+	assert.True(t, verify)
+}

coordinator/internal/types/get_task.go

@@ -2,10 +2,9 @@ package types
 
 // GetTaskParameter for ProverTasks request parameter
 type GetTaskParameter struct {
-	ProverHeight uint64   `form:"prover_height" json:"prover_height"`
-	TaskType     int      `form:"task_type" json:"task_type"`
-	VK           string   `form:"vk" json:"vk"`   // will be deprecated after all go_prover offline
-	VKs          []string `form:"vks" json:"vks"` // for rust_prover that supporting multi-circuits
+	ProverHeight uint64 `form:"prover_height" json:"prover_height"`
+	TaskType     int    `form:"task_type" json:"task_type"`
+	TaskTypes    []int  `form:"task_types" json:"task_types"`
 }
 
 // GetTaskSchema the schema data return to prover for get prover task

coordinator/internal/types/prover.go

@@ -0,0 +1,41 @@
+package types
+
+import (
+	"fmt"
+	"scroll-tech/common/types/message"
+)
+
+// ProverType represents the type of prover.
+type ProverType uint8
+
+func (r ProverType) String() string {
+	switch r {
+	case ProverTypeChunk:
+		return "prover type chunk"
+	case ProverTypeBatch:
+		return "prover type batch"
+	default:
+		return fmt.Sprintf("illegal prover type: %d", r)
+	}
+}
+
+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
+)
+
+// MakeProverType make ProverType from ProofType
+func MakeProverType(proof_type message.ProofType) ProverType {
+	switch proof_type {
+	case message.ProofTypeChunk:
+		return ProverTypeChunk
+	case message.ProofTypeBatch, message.ProofTypeBundle:
+		return ProverTypeBatch
+	default:
+		return ProverTypeUndefined
+	}
+}

coordinator/internal/types/submit_proof.go

@@ -2,13 +2,11 @@ package types
 
 // SubmitProofParameter the SubmitProof api request parameter
 type SubmitProofParameter struct {
-	// TODO when prover have upgrade, need change this field to required
-	UUID         string `form:"uuid" json:"uuid"`
-	TaskID       string `form:"task_id" json:"task_id" binding:"required"`
-	TaskType     int    `form:"task_type" json:"task_type" binding:"required"`
-	Status       int    `form:"status" json:"status"`
-	Proof        string `form:"proof" json:"proof"`
-	FailureType  int    `form:"failure_type" json:"failure_type"`
-	FailureMsg   string `form:"failure_msg" json:"failure_msg"`
-	HardForkName string `form:"hard_fork_name" json:"hard_fork_name"`
+	UUID        string `form:"uuid" json:"uuid"`
+	TaskID      string `form:"task_id" json:"task_id" binding:"required"`
+	TaskType    int    `form:"task_type" json:"task_type" binding:"required"`
+	Status      int    `form:"status" json:"status"`
+	Proof       string `form:"proof" json:"proof"`
+	FailureType int    `form:"failure_type" json:"failure_type"`
+	FailureMsg  string `form:"failure_msg" json:"failure_msg"`
 }

coordinator/test/api_test.go

@@ -34,10 +34,9 @@ import (
 )
 
 const (
-	forkNumberFour  = 4
-	forkNumberThree = 3
-	forkNumberTwo   = 2
-	forkNumberOne   = 1
+	forkNumberTwo    = 2
+	forkNumberOne    = 1
+	minProverVersion = "v2.0.0"
 )
 
 var (
@@ -52,17 +51,10 @@ var (
 	proverTaskOrm      *orm.ProverTask
 	proverBlockListOrm *orm.ProverBlockList
 
-	block1 *encoding.Block
-	block2 *encoding.Block
-
-	chunk          *encoding.Chunk
-	hardForkChunk1 *encoding.Chunk
-	hardForkChunk2 *encoding.Chunk
-
-	batch          *encoding.Batch
-	hardForkBatch1 *encoding.Batch
-	hardForkBatch2 *encoding.Batch
-
+	block1       *encoding.Block
+	block2       *encoding.Block
+	chunk        *encoding.Chunk
+	batch        *encoding.Batch
 	tokenTimeout int
 )
 
@@ -89,7 +81,7 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(sqlDB))
 
-	tokenTimeout = 6
+	tokenTimeout = 60
 	conf = &config.Config{
 		L2: &config.L2{
 			ChainID: 111,
@@ -99,11 +91,12 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 			Verifier: &config.VerifierConfig{
 				MockMode: true,
 			},
-			BatchCollectionTimeSec: 10,
-			ChunkCollectionTimeSec: 10,
-			MaxVerifierWorkers:     10,
-			SessionAttempts:        5,
-			MinProverVersion:       version.Version,
+			BatchCollectionTimeSec:  10,
+			ChunkCollectionTimeSec:  10,
+			BundleCollectionTimeSec: 10,
+			MaxVerifierWorkers:      10,
+			SessionAttempts:         5,
+			MinProverVersion:        minProverVersion,
 		},
 		Auth: &config.Auth{
 			ChallengeExpireDurationSec: tokenTimeout,
@@ -152,7 +145,7 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 func setEnv(t *testing.T) {
 	var err error
 
-	version.Version = "v4.1.98"
+	version.Version = "v4.2.0"
 
 	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.LogfmtFormat()))
 	glogger.Verbosity(log.LvlInfo)
@@ -186,14 +179,9 @@ func setEnv(t *testing.T) {
 	assert.NoError(t, err)
 
 	chunk = &encoding.Chunk{Blocks: []*encoding.Block{block1, block2}}
-	hardForkChunk1 = &encoding.Chunk{Blocks: []*encoding.Block{block1}}
-	hardForkChunk2 = &encoding.Chunk{Blocks: []*encoding.Block{block2}}
-
 	assert.NoError(t, err)
-
 	batch = &encoding.Batch{Chunks: []*encoding.Chunk{chunk}}
-	hardForkBatch1 = &encoding.Batch{Index: 1, Chunks: []*encoding.Chunk{hardForkChunk1}}
-	hardForkBatch2 = &encoding.Batch{Index: 2, Chunks: []*encoding.Chunk{hardForkChunk2}}
+
 }
 
 func TestApis(t *testing.T) {
@@ -208,7 +196,6 @@ func TestApis(t *testing.T) {
 	t.Run("TestInvalidProof", testInvalidProof)
 	t.Run("TestProofGeneratedFailed", testProofGeneratedFailed)
 	t.Run("TestTimeoutProof", testTimeoutProof)
-	t.Run("TestHardFork", testHardForkAssignTask)
 }
 
 func testHandshake(t *testing.T) {
@@ -261,12 +248,12 @@ func testGetTaskBlocked(t *testing.T) {
 	assert.NoError(t, err)
 
 	expectedErr := fmt.Errorf("return prover task err:check prover task parameter failed, error:public key %s is blocked from fetching tasks. ProverName: %s, ProverVersion: %s", chunkProver.publicKey(), chunkProver.proverName, chunkProver.proverVersion)
-	code, errMsg := chunkProver.tryGetProverTask(t, message.ProofTypeChunk, "homestead")
+	code, errMsg := chunkProver.tryGetProverTask(t, message.ProofTypeChunk)
 	assert.Equal(t, types.ErrCoordinatorGetTaskFailure, code)
 	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 
 	expectedErr = fmt.Errorf("get empty prover task")
-	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch, "homestead")
+	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch)
 	assert.Equal(t, types.ErrCoordinatorEmptyProofData, code)
 	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 
@@ -277,12 +264,12 @@ func testGetTaskBlocked(t *testing.T) {
 	assert.NoError(t, err)
 
 	expectedErr = fmt.Errorf("get empty prover task")
-	code, errMsg = chunkProver.tryGetProverTask(t, message.ProofTypeChunk, "homestead")
+	code, errMsg = chunkProver.tryGetProverTask(t, message.ProofTypeChunk)
 	assert.Equal(t, types.ErrCoordinatorEmptyProofData, code)
 	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 
 	expectedErr = fmt.Errorf("return prover task err:check prover task parameter failed, error:public key %s is blocked from fetching tasks. ProverName: %s, ProverVersion: %s", batchProver.publicKey(), batchProver.proverName, batchProver.proverVersion)
-	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch, "homestead")
+	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch)
 	assert.Equal(t, types.ErrCoordinatorGetTaskFailure, code)
 	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 }
@@ -301,249 +288,17 @@ 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("return prover task err:check prover task parameter failed, error:incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", version.Version, chunkProver.proverVersion)
-	code, errMsg := chunkProver.tryGetProverTask(t, message.ProofTypeChunk, "homestead")
-	assert.Equal(t, types.ErrCoordinatorGetTaskFailure, code)
+	expectedErr := fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", minProverVersion, chunkProver.proverVersion)
+	code, errMsg := chunkProver.tryGetProverTask(t, message.ProofTypeChunk)
+	assert.Equal(t, types.ErrJWTCommonErr, code)
 	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 
-	expectedErr = fmt.Errorf("return prover task err:check prover task parameter failed, error:incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", version.Version, batchProver.proverVersion)
-	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch, "homestead")
-	assert.Equal(t, types.ErrCoordinatorGetTaskFailure, code)
+	expectedErr = fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", minProverVersion, batchProver.proverVersion)
+	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch)
+	assert.Equal(t, types.ErrJWTCommonErr, code)
 	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 }
 
-func testHardForkAssignTask(t *testing.T) {
-	tests := []struct {
-		name                  string
-		proofType             message.ProofType
-		forkNumbers           map[string]int64
-		proverForkNames       []string
-		exceptTaskNumber      int
-		exceptGetTaskErrCodes []int
-		exceptGetTaskErrMsgs  []string
-	}{
-		{ // hard fork 4, prover 4  block [2-3]
-			name:                  "noTaskForkChunkProverVersionLargeOrEqualThanHardFork",
-			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"bernoulli": forkNumberFour},
-			exceptTaskNumber:      0,
-			proverForkNames:       []string{"bernoulli", "bernoulli"},
-			exceptGetTaskErrCodes: []int{types.ErrCoordinatorEmptyProofData, types.ErrCoordinatorEmptyProofData},
-			exceptGetTaskErrMsgs:  []string{"get empty prover task", "get empty prover task"},
-		},
-		{
-			name:                  "noTaskForkBatchProverVersionLargeOrEqualThanHardFork",
-			proofType:             message.ProofTypeBatch,
-			forkNumbers:           map[string]int64{"bernoulli": forkNumberFour},
-			exceptTaskNumber:      0,
-			proverForkNames:       []string{"bernoulli", "bernoulli"},
-			exceptGetTaskErrCodes: []int{types.ErrCoordinatorEmptyProofData, types.ErrCoordinatorEmptyProofData},
-			exceptGetTaskErrMsgs:  []string{"get empty prover task", "get empty prover task"},
-		},
-		{ // hard fork 1, prover 1 block [2-3]
-			name:                  "noTaskForkChunkProverVersionLessThanHardFork",
-			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"istanbul": forkNumberTwo, "homestead": forkNumberOne},
-			exceptTaskNumber:      0,
-			proverForkNames:       []string{"homestead", "homestead"},
-			exceptGetTaskErrCodes: []int{types.ErrCoordinatorEmptyProofData, types.ErrCoordinatorEmptyProofData},
-			exceptGetTaskErrMsgs:  []string{"get empty prover task", "get empty prover task"},
-		},
-		{
-			name:                  "noTaskForkBatchProverVersionLessThanHardFork",
-			proofType:             message.ProofTypeBatch,
-			forkNumbers:           map[string]int64{"istanbul": forkNumberTwo, "homestead": forkNumberOne},
-			exceptTaskNumber:      0,
-			proverForkNames:       []string{"homestead", "homestead"},
-			exceptGetTaskErrCodes: []int{types.ErrCoordinatorEmptyProofData, types.ErrCoordinatorEmptyProofData},
-			exceptGetTaskErrMsgs:  []string{"get empty prover task", "get empty prover task"},
-		},
-		{
-			name:                  "noTaskForkBatchProverVersionLessThanHardForkProverNumberEqual0",
-			proofType:             message.ProofTypeBatch,
-			forkNumbers:           map[string]int64{"shanghai": forkNumberOne, "london": forkNumberThree},
-			exceptTaskNumber:      0,
-			proverForkNames:       []string{"", ""},
-			exceptGetTaskErrCodes: []int{types.ErrCoordinatorEmptyProofData, types.ErrCoordinatorEmptyProofData},
-			exceptGetTaskErrMsgs:  []string{"get empty prover task", "get empty prover task"},
-		},
-		{ // hard fork 3, prover 3 block [2-3]
-			name:                  "oneTaskForkChunkProverVersionLargeOrEqualThanHardFork",
-			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"london": forkNumberThree},
-			exceptTaskNumber:      1,
-			proverForkNames:       []string{"london", "london"},
-			exceptGetTaskErrCodes: []int{types.Success, types.ErrCoordinatorEmptyProofData},
-			exceptGetTaskErrMsgs:  []string{"", "get empty prover task"},
-		},
-		{
-			name:                  "oneTaskForkBatchProverVersionLargeOrEqualThanHardFork",
-			proofType:             message.ProofTypeBatch,
-			forkNumbers:           map[string]int64{"london": forkNumberThree},
-			exceptTaskNumber:      1,
-			proverForkNames:       []string{"london", "london"},
-			exceptGetTaskErrCodes: []int{types.Success, types.ErrCoordinatorEmptyProofData},
-			exceptGetTaskErrMsgs:  []string{"", "get empty prover task"},
-		},
-		{ // hard fork 2, prover 2 block [2-3]
-			name:                  "oneTaskForkChunkProverVersionLessThanHardFork",
-			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"istanbul": forkNumberTwo, "london": forkNumberThree},
-			exceptTaskNumber:      1,
-			proverForkNames:       []string{"istanbul", "istanbul"},
-			exceptGetTaskErrCodes: []int{types.Success, types.ErrCoordinatorEmptyProofData},
-			exceptGetTaskErrMsgs:  []string{"", "get empty prover task"},
-		},
-		{
-			name:                  "oneTaskForkBatchProverVersionLessThanHardFork",
-			proofType:             message.ProofTypeBatch,
-			forkNumbers:           map[string]int64{"istanbul": forkNumberTwo, "london": forkNumberThree},
-			exceptTaskNumber:      1,
-			proverForkNames:       []string{"istanbul", "istanbul"},
-			exceptGetTaskErrCodes: []int{types.Success, types.ErrCoordinatorEmptyProofData},
-			exceptGetTaskErrMsgs:  []string{"", "get empty prover task"},
-		},
-		{ // hard fork 2, prover 2 block [2-3]
-			name:                  "twoTaskForkChunkProverVersionLargeOrEqualThanHardFork",
-			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"istanbul": forkNumberTwo},
-			exceptTaskNumber:      2,
-			proverForkNames:       []string{"istanbul", "istanbul"},
-			exceptGetTaskErrCodes: []int{types.Success, types.Success},
-			exceptGetTaskErrMsgs:  []string{"", ""},
-		},
-		{
-			name:                  "twoTaskForkBatchProverVersionLargeOrEqualThanHardFork",
-			proofType:             message.ProofTypeBatch,
-			forkNumbers:           map[string]int64{"istanbul": forkNumberTwo},
-			exceptTaskNumber:      2,
-			proverForkNames:       []string{"istanbul", "istanbul"},
-			exceptGetTaskErrCodes: []int{types.Success, types.Success},
-			exceptGetTaskErrMsgs:  []string{"", ""},
-		},
-		{ // hard fork 4, prover 3 block [2-3]
-			name:                  "twoTaskForkChunkProverVersionLessThanHardFork",
-			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"bernoulli": forkNumberFour, "istanbul": forkNumberTwo},
-			exceptTaskNumber:      2,
-			proverForkNames:       []string{"istanbul", "istanbul"},
-			exceptGetTaskErrCodes: []int{types.Success, types.Success},
-			exceptGetTaskErrMsgs:  []string{"", ""},
-		},
-		{ // hard fork 3, prover1:2 prover2:3 block [2-3]
-			name:                  "twoTaskForkChunkProverVersionMiddleHardFork",
-			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"istanbul": forkNumberTwo, "london": forkNumberThree},
-			exceptTaskNumber:      2,
-			proverForkNames:       []string{"istanbul", "london"},
-			exceptGetTaskErrCodes: []int{types.Success, types.Success},
-			exceptGetTaskErrMsgs:  []string{"", ""},
-		},
-		{
-			name:                  "twoTaskForkBatchProverVersionMiddleHardFork",
-			proofType:             message.ProofTypeBatch,
-			forkNumbers:           map[string]int64{"istanbul": forkNumberTwo, "london": forkNumberThree},
-			exceptTaskNumber:      2,
-			proverForkNames:       []string{"istanbul", "london"},
-			exceptGetTaskErrCodes: []int{types.Success, types.Success},
-			exceptGetTaskErrMsgs:  []string{"", ""},
-		},
-		{ // hard fork 3, prover1:2 prover2:3 block [2-3]
-			name:                  "twoTaskForkChunkProverVersionMiddleHardForkProverNumberEqual0",
-			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"shanghai": forkNumberTwo, "london": forkNumberThree},
-			exceptTaskNumber:      2,
-			proverForkNames:       []string{"", "london"},
-			exceptGetTaskErrCodes: []int{types.Success, types.Success},
-			exceptGetTaskErrMsgs:  []string{"", ""},
-		},
-		{
-			name:                  "twoTaskForkBatchProverVersionMiddleHardForkProverNumberEqual0",
-			proofType:             message.ProofTypeBatch,
-			forkNumbers:           map[string]int64{"shanghai": forkNumberTwo, "london": forkNumberThree},
-			exceptTaskNumber:      2,
-			proverForkNames:       []string{"", "london"},
-			exceptGetTaskErrCodes: []int{types.Success, types.Success},
-			exceptGetTaskErrMsgs:  []string{"", ""},
-		},
-		{ // hard fork 2, prover 2 block [2-3]
-			name:                  "oneTaskForkChunkProverVersionLessThanHardForkProverNumberEqual0",
-			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"shanghai": forkNumberOne, "london": forkNumberThree},
-			exceptTaskNumber:      1,
-			proverForkNames:       []string{"", ""},
-			exceptGetTaskErrCodes: []int{types.Success, types.ErrCoordinatorEmptyProofData},
-			exceptGetTaskErrMsgs:  []string{"", "get empty prover task"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			coordinatorURL := randomURL()
-			collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, tt.forkNumbers)
-			defer func() {
-				collector.Stop()
-				assert.NoError(t, httpHandler.Shutdown(context.Background()))
-			}()
-
-			chunkProof := &message.ChunkProof{
-				StorageTrace: []byte("testStorageTrace"),
-				Protocol:     []byte("testProtocol"),
-				Proof:        []byte("testProof"),
-				Instances:    []byte("testInstance"),
-				Vk:           []byte("testVk"),
-				ChunkInfo:    nil,
-			}
-
-			// the insert block number is 2 and 3
-			// chunk1 batch1 contains block number 2
-			// chunk2 batch2 contains block number 3
-			err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
-			assert.NoError(t, err)
-
-			dbHardForkChunk1, err := chunkOrm.InsertChunk(context.Background(), hardForkChunk1)
-			assert.NoError(t, err)
-			err = l2BlockOrm.UpdateChunkHashInRange(context.Background(), 0, 2, dbHardForkChunk1.Hash)
-			assert.NoError(t, err)
-			err = chunkOrm.UpdateProofAndProvingStatusByHash(context.Background(), dbHardForkChunk1.Hash, chunkProof, types.ProvingTaskUnassigned, 1)
-			assert.NoError(t, err)
-			dbHardForkBatch1, err := batchOrm.InsertBatch(context.Background(), hardForkBatch1)
-			assert.NoError(t, err)
-			err = chunkOrm.UpdateBatchHashInRange(context.Background(), 0, 0, dbHardForkBatch1.Hash)
-			assert.NoError(t, err)
-			err = batchOrm.UpdateChunkProofsStatusByBatchHash(context.Background(), dbHardForkBatch1.Hash, types.ChunkProofsStatusReady)
-			assert.NoError(t, err)
-
-			dbHardForkChunk2, err := chunkOrm.InsertChunk(context.Background(), hardForkChunk2)
-			assert.NoError(t, err)
-			err = l2BlockOrm.UpdateChunkHashInRange(context.Background(), 3, 100, dbHardForkChunk2.Hash)
-			assert.NoError(t, err)
-			err = chunkOrm.UpdateProofAndProvingStatusByHash(context.Background(), dbHardForkChunk2.Hash, chunkProof, types.ProvingTaskUnassigned, 1)
-			assert.NoError(t, err)
-			dbHardForkBatch2, err := batchOrm.InsertBatch(context.Background(), hardForkBatch2)
-			assert.NoError(t, err)
-			err = chunkOrm.UpdateBatchHashInRange(context.Background(), 1, 1, dbHardForkBatch2.Hash)
-			assert.NoError(t, err)
-			err = batchOrm.UpdateChunkProofsStatusByBatchHash(context.Background(), dbHardForkBatch2.Hash, types.ChunkProofsStatusReady)
-			assert.NoError(t, err)
-
-			getTaskNumber := 0
-			for i := 0; i < 2; i++ {
-				mockProver := newMockProver(t, fmt.Sprintf("mock_prover_%d", i), coordinatorURL, tt.proofType, version.Version)
-				proverTask, errCode, errMsg := mockProver.getProverTask(t, tt.proofType, tt.proverForkNames[i])
-				assert.Equal(t, tt.exceptGetTaskErrCodes[i], errCode)
-				assert.Equal(t, tt.exceptGetTaskErrMsgs[i], errMsg)
-				if errCode != types.Success {
-					continue
-				}
-				getTaskNumber++
-				mockProver.submitProof(t, proverTask, verifiedSuccess, types.Success, tt.proverForkNames[i])
-			}
-			assert.Equal(t, getTaskNumber, tt.exceptTaskNumber)
-		})
-	}
-}
-
 func testValidProof(t *testing.T) {
 	coordinatorURL := randomURL()
 	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL, map[string]int64{"istanbul": forkNumberTwo})
@@ -575,12 +330,12 @@ func testValidProof(t *testing.T) {
 
 		provers[i] = newMockProver(t, "prover_test"+strconv.Itoa(i), coordinatorURL, proofType, version.Version)
 
-		proofStatus := verifiedSuccess
-		proverTask, errCode, errMsg := provers[i].getProverTask(t, proofType, "istanbul")
-		assert.Equal(t, errCode, types.Success)
-		assert.Equal(t, errMsg, "")
+		exceptProofStatus := verifiedSuccess
+		proverTask, errCode, errMsg := provers[i].getProverTask(t, proofType)
+		assert.Equal(t, types.Success, errCode)
+		assert.Equal(t, "", errMsg)
 		assert.NotNil(t, proverTask)
-		provers[i].submitProof(t, proverTask, proofStatus, types.Success, "istanbul")
+		provers[i].submitProof(t, proverTask, exceptProofStatus, types.Success)
 	}
 
 	// verify proof status
@@ -641,39 +396,69 @@ func testInvalidProof(t *testing.T) {
 	assert.NoError(t, err)
 	err = l2BlockOrm.UpdateChunkHashInRange(context.Background(), 0, 100, dbChunk.Hash)
 	assert.NoError(t, err)
-	batch, err := batchOrm.InsertBatch(context.Background(), batch)
+	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch)
 	assert.NoError(t, err)
-	err = batchOrm.UpdateChunkProofsStatusByBatchHash(context.Background(), batch.Hash, types.ChunkProofsStatusReady)
+	err = chunkOrm.UpdateBatchHashInRange(context.Background(), 0, 100, dbBatch.Hash)
+	assert.NoError(t, err)
+	err = batchOrm.UpdateChunkProofsStatusByBatchHash(context.Background(), dbBatch.Hash, types.ChunkProofsStatusReady)
 	assert.NoError(t, err)
 
-	proofType := message.ProofTypeBatch
-	provingStatus := verifiedFailed
-	expectErrCode := types.ErrCoordinatorHandleZkProofFailure
-	prover := newMockProver(t, "prover_test", coordinatorURL, proofType, version.Version)
-	proverTask, errCode, errMsg := prover.getProverTask(t, proofType, "istanbul")
-	assert.NotNil(t, proverTask)
-	assert.Equal(t, errCode, types.Success)
-	assert.Equal(t, errMsg, "")
-	prover.submitProof(t, proverTask, provingStatus, expectErrCode, "istanbul")
+	// create mock provers.
+	provers := make([]*mockProver, 2)
+	for i := 0; i < len(provers); i++ {
+		var (
+			proofType     message.ProofType
+			provingStatus proofStatus
+			exceptCode    int
+		)
+
+		if i%2 == 0 {
+			proofType = message.ProofTypeChunk
+			provingStatus = verifiedSuccess
+			exceptCode = types.Success
+		} else {
+			proofType = message.ProofTypeBatch
+			provingStatus = verifiedFailed
+			exceptCode = types.ErrCoordinatorHandleZkProofFailure
+		}
+
+		provers[i] = newMockProver(t, "prover_test"+strconv.Itoa(i), coordinatorURL, proofType, version.Version)
+		proverTask, errCode, errMsg := provers[i].getProverTask(t, proofType)
+		assert.Equal(t, types.Success, errCode)
+		assert.Equal(t, "", errMsg)
+		assert.NotNil(t, proverTask)
+		provers[i].submitProof(t, proverTask, provingStatus, exceptCode)
+	}
 
 	// verify proof status
 	var (
 		tick                = time.Tick(1500 * time.Millisecond)
 		tickStop            = time.Tick(time.Minute)
+		chunkProofStatus    types.ProvingStatus
 		batchProofStatus    types.ProvingStatus
 		batchActiveAttempts int16
 		batchMaxAttempts    int16
+		chunkActiveAttempts int16
+		chunkMaxAttempts    int16
 	)
 
 	for {
 		select {
 		case <-tick:
-			batchProofStatus, err = batchOrm.GetProvingStatusByHash(context.Background(), batch.Hash)
+			chunkProofStatus, err = chunkOrm.GetProvingStatusByHash(context.Background(), dbChunk.Hash)
 			assert.NoError(t, err)
-			if batchProofStatus == types.ProvingTaskAssigned {
+			batchProofStatus, err = batchOrm.GetProvingStatusByHash(context.Background(), dbBatch.Hash)
+			assert.NoError(t, err)
+			if chunkProofStatus == types.ProvingTaskVerified && batchProofStatus == types.ProvingTaskAssigned {
 				return
 			}
-			batchActiveAttempts, batchMaxAttempts, err = batchOrm.GetAttemptsByHash(context.Background(), batch.Hash)
+
+			chunkActiveAttempts, chunkMaxAttempts, err = chunkOrm.GetAttemptsByHash(context.Background(), dbChunk.Hash)
+			assert.NoError(t, err)
+			assert.Equal(t, 1, int(chunkMaxAttempts))
+			assert.Equal(t, 0, int(chunkActiveAttempts))
+
+			batchActiveAttempts, batchMaxAttempts, err = batchOrm.GetAttemptsByHash(context.Background(), dbBatch.Hash)
 			assert.NoError(t, err)
 			assert.Equal(t, 1, int(batchMaxAttempts))
 			assert.Equal(t, 0, int(batchActiveAttempts))
@@ -699,26 +484,38 @@ func testProofGeneratedFailed(t *testing.T) {
 	assert.NoError(t, err)
 	err = l2BlockOrm.UpdateChunkHashInRange(context.Background(), 0, 100, dbChunk.Hash)
 	assert.NoError(t, err)
-	batch, err := batchOrm.InsertBatch(context.Background(), batch)
+	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch)
 	assert.NoError(t, err)
-	err = batchOrm.UpdateChunkProofsStatusByBatchHash(context.Background(), batch.Hash, types.ChunkProofsStatusReady)
+	err = chunkOrm.UpdateBatchHashInRange(context.Background(), 0, 100, dbBatch.Hash)
+	assert.NoError(t, err)
+	err = batchOrm.UpdateChunkProofsStatusByBatchHash(context.Background(), dbBatch.Hash, types.ChunkProofsStatusReady)
 	assert.NoError(t, err)
 
 	// create mock provers.
 	provers := make([]*mockProver, 2)
 	for i := 0; i < len(provers); i++ {
-		var proofType message.ProofType
+		var (
+			proofType    message.ProofType
+			exceptCode   int
+			exceptErrMsg string
+		)
 		if i%2 == 0 {
 			proofType = message.ProofTypeChunk
+			exceptCode = types.Success
+			exceptErrMsg = ""
 		} else {
 			proofType = message.ProofTypeBatch
+			exceptCode = types.ErrCoordinatorGetTaskFailure
+			exceptErrMsg = "return prover task err:coordinator internal error"
 		}
 		provers[i] = newMockProver(t, "prover_test"+strconv.Itoa(i), coordinatorURL, proofType, version.Version)
-		proverTask, errCode, errMsg := provers[i].getProverTask(t, proofType, "istanbul")
+		proverTask, errCode, errMsg := provers[i].getProverTask(t, proofType)
 		assert.NotNil(t, proverTask)
-		assert.Equal(t, errCode, types.Success)
-		assert.Equal(t, errMsg, "")
-		provers[i].submitProof(t, proverTask, generatedFailed, types.ErrCoordinatorHandleZkProofFailure, "istanbul")
+		assert.Equal(t, errCode, exceptCode)
+		assert.Equal(t, errMsg, exceptErrMsg)
+		if errCode == types.Success {
+			provers[i].submitProof(t, proverTask, generatedFailed, types.ErrCoordinatorHandleZkProofFailure)
+		}
 	}
 
 	// verify proof status
@@ -743,7 +540,7 @@ func testProofGeneratedFailed(t *testing.T) {
 		case <-tick:
 			chunkProofStatus, err = chunkOrm.GetProvingStatusByHash(context.Background(), dbChunk.Hash)
 			assert.NoError(t, err)
-			batchProofStatus, err = batchOrm.GetProvingStatusByHash(context.Background(), batch.Hash)
+			batchProofStatus, err = batchOrm.GetProvingStatusByHash(context.Background(), dbBatch.Hash)
 			assert.NoError(t, err)
 			if chunkProofStatus == types.ProvingTaskAssigned && batchProofStatus == types.ProvingTaskAssigned {
 				return
@@ -754,14 +551,14 @@ func testProofGeneratedFailed(t *testing.T) {
 			assert.Equal(t, 1, int(chunkMaxAttempts))
 			assert.Equal(t, 0, int(chunkActiveAttempts))
 
-			batchActiveAttempts, batchMaxAttempts, err = batchOrm.GetAttemptsByHash(context.Background(), batch.Hash)
+			batchActiveAttempts, batchMaxAttempts, err = batchOrm.GetAttemptsByHash(context.Background(), dbBatch.Hash)
 			assert.NoError(t, err)
 			assert.Equal(t, 1, int(batchMaxAttempts))
 			assert.Equal(t, 0, int(batchActiveAttempts))
 
 			chunkProverTaskProvingStatus, err = proverTaskOrm.GetProvingStatusByTaskID(context.Background(), message.ProofTypeChunk, dbChunk.Hash)
 			assert.NoError(t, err)
-			batchProverTaskProvingStatus, err = proverTaskOrm.GetProvingStatusByTaskID(context.Background(), message.ProofTypeBatch, batch.Hash)
+			batchProverTaskProvingStatus, err = proverTaskOrm.GetProvingStatusByTaskID(context.Background(), message.ProofTypeBatch, dbBatch.Hash)
 			assert.NoError(t, err)
 			if chunkProverTaskProvingStatus == types.ProverProofInvalid && batchProverTaskProvingStatus == types.ProverProofInvalid {
 				return
@@ -797,18 +594,25 @@ func testTimeoutProof(t *testing.T) {
 	assert.NoError(t, err)
 	batch, err := batchOrm.InsertBatch(context.Background(), batch)
 	assert.NoError(t, err)
+	err = chunkOrm.UpdateBatchHashInRange(context.Background(), 0, 100, batch.Hash)
+	assert.NoError(t, err)
+	encodeData, err := json.Marshal(message.ChunkProof{})
+	assert.NoError(t, err)
+	assert.NotEmpty(t, encodeData)
+	err = chunkOrm.UpdateProofAndProvingStatusByHash(context.Background(), dbChunk.Hash, encodeData, types.ProvingTaskUnassigned, 1)
+	assert.NoError(t, err)
 	err = batchOrm.UpdateChunkProofsStatusByBatchHash(context.Background(), batch.Hash, types.ChunkProofsStatusReady)
 	assert.NoError(t, err)
 
 	// create first chunk & batch mock prover, that will not send any proof.
 	chunkProver1 := newMockProver(t, "prover_test"+strconv.Itoa(0), coordinatorURL, message.ProofTypeChunk, version.Version)
-	proverChunkTask, errChunkCode, errChunkMsg := chunkProver1.getProverTask(t, message.ProofTypeChunk, "istanbul")
+	proverChunkTask, errChunkCode, errChunkMsg := chunkProver1.getProverTask(t, message.ProofTypeChunk)
 	assert.NotNil(t, proverChunkTask)
 	assert.Equal(t, errChunkCode, types.Success)
 	assert.Equal(t, errChunkMsg, "")
 
 	batchProver1 := newMockProver(t, "prover_test"+strconv.Itoa(1), coordinatorURL, message.ProofTypeBatch, version.Version)
-	proverBatchTask, errBatchCode, errBatchMsg := batchProver1.getProverTask(t, message.ProofTypeBatch, "istanbul")
+	proverBatchTask, errBatchCode, errBatchMsg := batchProver1.getProverTask(t, message.ProofTypeBatch)
 	assert.NotNil(t, proverBatchTask)
 	assert.Equal(t, errBatchCode, types.Success)
 	assert.Equal(t, errBatchMsg, "")
@@ -837,18 +641,18 @@ func testTimeoutProof(t *testing.T) {
 
 	// create second mock prover, that will send valid proof.
 	chunkProver2 := newMockProver(t, "prover_test"+strconv.Itoa(2), coordinatorURL, message.ProofTypeChunk, version.Version)
-	proverChunkTask2, chunkTask2ErrCode, chunkTask2ErrMsg := chunkProver2.getProverTask(t, message.ProofTypeChunk, "istanbul")
+	proverChunkTask2, chunkTask2ErrCode, chunkTask2ErrMsg := chunkProver2.getProverTask(t, message.ProofTypeChunk)
 	assert.NotNil(t, proverChunkTask2)
 	assert.Equal(t, chunkTask2ErrCode, types.Success)
 	assert.Equal(t, chunkTask2ErrMsg, "")
-	chunkProver2.submitProof(t, proverChunkTask2, verifiedSuccess, types.Success, "istanbul")
+	chunkProver2.submitProof(t, proverChunkTask2, verifiedSuccess, types.Success)
 
 	batchProver2 := newMockProver(t, "prover_test"+strconv.Itoa(3), coordinatorURL, message.ProofTypeBatch, version.Version)
-	proverBatchTask2, batchTask2ErrCode, batchTask2ErrMsg := batchProver2.getProverTask(t, message.ProofTypeBatch, "istanbul")
+	proverBatchTask2, batchTask2ErrCode, batchTask2ErrMsg := batchProver2.getProverTask(t, message.ProofTypeBatch)
 	assert.NotNil(t, proverBatchTask2)
 	assert.Equal(t, batchTask2ErrCode, types.Success)
 	assert.Equal(t, batchTask2ErrMsg, "")
-	batchProver2.submitProof(t, proverBatchTask2, verifiedSuccess, types.Success, "istanbul")
+	batchProver2.submitProof(t, proverBatchTask2, verifiedSuccess, types.Success)
 
 	// verify proof status, it should be verified now, because second prover sent valid proof
 	chunkProofStatus2, err := chunkOrm.GetProvingStatusByHash(context.Background(), dbChunk.Hash)

coordinator/test/mock_prover.go

@@ -51,9 +51,9 @@ func newMockProver(t *testing.T, proverName string, coordinatorURL string, proof
 }
 
 // connectToCoordinator sets up a websocket client to connect to the prover manager.
-func (r *mockProver) connectToCoordinator(t *testing.T, forkName string) string {
+func (r *mockProver) connectToCoordinator(t *testing.T, proverTypes []types.ProverType) (string, int, string) {
 	challengeString := r.challenge(t)
-	return r.login(t, challengeString, forkName)
+	return r.login(t, challengeString, proverTypes)
 }
 
 func (r *mockProver) challenge(t *testing.T) string {
@@ -76,43 +76,35 @@ func (r *mockProver) challenge(t *testing.T) string {
 	return loginData.Token
 }
 
-func (r *mockProver) login(t *testing.T, challengeString string, forkName string) string {
-	var body string
-	if forkName != "" {
-		authMsg := message.AuthMsg{
-			Identity: &message.Identity{
-				Challenge:     challengeString,
-				ProverName:    r.proverName,
-				ProverVersion: r.proverVersion,
-				HardForkName:  forkName,
-			},
-		}
-		assert.NoError(t, authMsg.SignWithKey(r.privKey))
-		body = fmt.Sprintf("{\"message\":{\"challenge\":\"%s\",\"prover_name\":\"%s\", \"prover_version\":\"%s\", \"hard_fork_name\":\"%s\"},\"signature\":\"%s\"}",
-			authMsg.Identity.Challenge, authMsg.Identity.ProverName, authMsg.Identity.ProverVersion, authMsg.Identity.HardForkName, authMsg.Signature)
-	} else {
-		authMsg := message.LegacyAuthMsg{
-			Identity: &message.LegacyIdentity{
-				Challenge:     challengeString,
-				ProverName:    r.proverName,
-				ProverVersion: r.proverVersion,
-			},
-		}
-		assert.NoError(t, authMsg.SignWithKey(r.privKey))
-		body = fmt.Sprintf("{\"message\":{\"challenge\":\"%s\",\"prover_name\":\"%s\", \"prover_version\":\"%s\"},\"signature\":\"%s\"}",
-			authMsg.Identity.Challenge, authMsg.Identity.ProverName, authMsg.Identity.ProverVersion, authMsg.Signature)
+func (r *mockProver) login(t *testing.T, challengeString string, proverTypes []types.ProverType) (string, int, string) {
+	authMsg := types.LoginParameter{
+		Message: types.Message{
+			Challenge:     challengeString,
+			ProverName:    r.proverName,
+			ProverVersion: r.proverVersion,
+			ProverTypes:   proverTypes,
+			VKs:           []string{"mock_vk"},
+		},
+		PublicKey: r.publicKey(),
 	}
+	assert.NoError(t, authMsg.SignWithKey(r.privKey))
+	body, err := json.Marshal(authMsg)
+	assert.NoError(t, err)
 
 	var result ctypes.Response
 	client := resty.New()
 	resp, err := client.R().
 		SetHeader("Content-Type", "application/json").
 		SetHeader("Authorization", fmt.Sprintf("Bearer %s", challengeString)).
-		SetBody([]byte(body)).
+		SetBody(body).
 		SetResult(&result).
 		Post("http://" + r.coordinatorURL + "/coordinator/v1/login")
 	assert.NoError(t, err)
 
+	if result.ErrCode != 0 {
+		return "", result.ErrCode, result.ErrMsg
+	}
+
 	type login struct {
 		Time  string `json:"time"`
 		Token string `json:"token"`
@@ -122,7 +114,7 @@ func (r *mockProver) login(t *testing.T, challengeString string, forkName string
 	assert.NoError(t, err)
 	assert.Equal(t, http.StatusOK, resp.StatusCode())
 	assert.Empty(t, result.ErrMsg)
-	return loginData.Token
+	return loginData.Token, 0, ""
 }
 
 func (r *mockProver) healthCheckSuccess(t *testing.T) bool {
@@ -149,9 +141,12 @@ func (r *mockProver) healthCheckFailure(t *testing.T) bool {
 	return true
 }
 
-func (r *mockProver) getProverTask(t *testing.T, proofType message.ProofType, forkName string) (*types.GetTaskSchema, int, string) {
+func (r *mockProver) getProverTask(t *testing.T, proofType message.ProofType) (*types.GetTaskSchema, int, string) {
 	// get task from coordinator
-	token := r.connectToCoordinator(t, forkName)
+	token, errCode, errMsg := r.connectToCoordinator(t, []types.ProverType{types.MakeProverType(proofType)})
+	if errCode != 0 {
+		return nil, errCode, errMsg
+	}
 	assert.NotEmpty(t, token)
 
 	type response struct {
@@ -176,9 +171,12 @@ func (r *mockProver) getProverTask(t *testing.T, proofType message.ProofType, fo
 // Testing expected errors returned by coordinator.
 //
 //nolint:unparam
-func (r *mockProver) tryGetProverTask(t *testing.T, proofType message.ProofType, forkName string) (int, string) {
+func (r *mockProver) tryGetProverTask(t *testing.T, proofType message.ProofType) (int, string) {
 	// get task from coordinator
-	token := r.connectToCoordinator(t, forkName)
+	token, errCode, errMsg := r.connectToCoordinator(t, []types.ProverType{types.MakeProverType(proofType)})
+	if errCode != 0 {
+		return errCode, errMsg
+	}
 	assert.NotEmpty(t, token)
 
 	type response struct {
@@ -201,50 +199,56 @@ func (r *mockProver) tryGetProverTask(t *testing.T, proofType message.ProofType,
 	return result.ErrCode, result.ErrMsg
 }
 
-func (r *mockProver) submitProof(t *testing.T, proverTaskSchema *types.GetTaskSchema, proofStatus proofStatus, errCode int, forkName string) {
+func (r *mockProver) submitProof(t *testing.T, proverTaskSchema *types.GetTaskSchema, proofStatus proofStatus, errCode int) {
 	proofMsgStatus := message.StatusOk
 	if proofStatus == generatedFailed {
 		proofMsgStatus = message.StatusProofError
 	}
 
-	proof := &message.ProofMsg{
-		ProofDetail: &message.ProofDetail{
-			ID:         proverTaskSchema.TaskID,
-			Type:       message.ProofType(proverTaskSchema.TaskType),
-			Status:     proofMsgStatus,
-			ChunkProof: &message.ChunkProof{},
-			BatchProof: &message.BatchProof{},
-		},
+	var proof []byte
+	switch proverTaskSchema.TaskType {
+	case int(message.ProofTypeChunk):
+		encodeData, err := json.Marshal(message.ChunkProof{})
+		assert.NoError(t, err)
+		assert.NotEmpty(t, encodeData)
+		proof = encodeData
+	case int(message.ProofTypeBatch):
+		encodeData, err := json.Marshal(message.BatchProof{})
+		assert.NoError(t, err)
+		assert.NotEmpty(t, encodeData)
+		proof = encodeData
 	}
 
-	if proofStatus == generatedFailed {
-		proof.Status = message.StatusProofError
-	} else if proofStatus == verifiedFailed {
-		proof.ProofDetail.ChunkProof.Proof = []byte(verifier.InvalidTestProof)
-		proof.ProofDetail.BatchProof.Proof = []byte(verifier.InvalidTestProof)
+	if proofStatus == verifiedFailed {
+		switch proverTaskSchema.TaskType {
+		case int(message.ProofTypeChunk):
+			chunkProof := message.ChunkProof{}
+			chunkProof.Proof = []byte(verifier.InvalidTestProof)
+			encodeData, err := json.Marshal(&chunkProof)
+			assert.NoError(t, err)
+			assert.NotEmpty(t, encodeData)
+			proof = encodeData
+		case int(message.ProofTypeBatch):
+			batchProof := message.BatchProof{}
+			batchProof.Proof = []byte(verifier.InvalidTestProof)
+			encodeData, err := json.Marshal(&batchProof)
+			assert.NoError(t, err)
+			assert.NotEmpty(t, encodeData)
+			proof = encodeData
+		}
 	}
 
-	assert.NoError(t, proof.Sign(r.privKey))
 	submitProof := types.SubmitProofParameter{
-		TaskID:   proof.ID,
-		TaskType: int(proof.Type),
-		Status:   int(proof.Status),
+		UUID:     proverTaskSchema.UUID,
+		TaskID:   proverTaskSchema.TaskID,
+		TaskType: proverTaskSchema.TaskType,
+		Status:   int(proofMsgStatus),
+		Proof:    string(proof),
 	}
 
-	switch proof.Type {
-	case message.ProofTypeChunk:
-		encodeData, err := json.Marshal(proof.ChunkProof)
-		assert.NoError(t, err)
-		assert.NotEmpty(t, encodeData)
-		submitProof.Proof = string(encodeData)
-	case message.ProofTypeBatch:
-		encodeData, err := json.Marshal(proof.BatchProof)
-		assert.NoError(t, err)
-		assert.NotEmpty(t, encodeData)
-		submitProof.Proof = string(encodeData)
-	}
-
-	token := r.connectToCoordinator(t, forkName)
+	token, authErrCode, errMsg := r.connectToCoordinator(t, []types.ProverType{types.MakeProverType(message.ProofType(proverTaskSchema.TaskType))})
+	assert.Equal(t, authErrCode, 0)
+	assert.Equal(t, errMsg, "")
 	assert.NotEmpty(t, token)
 
 	submitProofData, err := json.Marshal(submitProof)

database/config.json

@@ -1,5 +1,5 @@
 {
-  "dsn": "postgres://postgres:123456@localhost:5444/test?sslmode=disable",
+  "dsn": "postgres://localhost/scroll?sslmode=disable",
   "driver_name": "postgres",
   "maxOpenNum": 200,
   "maxIdleNum": 20

database/go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/jmoiron/sqlx v1.3.5
 	github.com/lib/pq v1.10.9
 	github.com/pressly/goose/v3 v3.16.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240422045311-246955a4df94
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
 )

database/go.sum

@@ -121,8 +121,8 @@ github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjR
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240422045311-246955a4df94 h1:yYsneFgHlSmOyCGNMF75t0NQLkNEuIo1jE+GIAOPviw=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240422045311-246955a4df94/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=
 github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
 github.com/sethvargo/go-retry v0.2.4 h1:T+jHEQy/zKJf5s95UkguisicE0zuF9y7+/vgz08Ocec=

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(20), cur)
+	assert.Equal(t, int64(22), cur)
 }
 
 func testMigrate(t *testing.T) {
 	assert.NoError(t, Migrate(pgDB))
 	cur, err := Current(pgDB)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(20), cur)
+	assert.Equal(t, int64(22), cur)
 }
 
 func testRollback(t *testing.T) {
 	version, err := Current(pgDB)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(20), version)
+	assert.Equal(t, int64(22), version)
 
 	assert.NoError(t, Rollback(pgDB, nil))
 

database/migrate/migrations/00021_bundle.sql

@@ -0,0 +1,54 @@
+-- +goose Up
+-- +goose StatementBegin
+
+CREATE TABLE bundle (
+    index                   BIGSERIAL       PRIMARY KEY,
+    hash                    VARCHAR         NOT NULL, -- Not part of DA hash, used for SQL query consistency and ease of use, derived using keccak256(concat(start_batch_hash_bytes, end_batch_hash_bytes)).
+    start_batch_index       BIGINT          NOT NULL,
+    end_batch_index         BIGINT          NOT NULL,
+    start_batch_hash        VARCHAR         NOT NULL,
+    end_batch_hash          VARCHAR         NOT NULL,
+    codec_version           SMALLINT        NOT NULL,
+
+-- proof
+    batch_proofs_status     SMALLINT        NOT NULL DEFAULT 1,
+    proving_status          SMALLINT        NOT NULL DEFAULT 1,
+    proof                   BYTEA           DEFAULT NULL,
+    prover_assigned_at      TIMESTAMP(0)    DEFAULT NULL,
+    proved_at               TIMESTAMP(0)    DEFAULT NULL,
+    proof_time_sec          INTEGER         DEFAULT NULL,
+    total_attempts          SMALLINT        NOT NULL DEFAULT 0,
+    active_attempts         SMALLINT        NOT NULL DEFAULT 0,
+
+-- rollup
+    rollup_status           SMALLINT        NOT NULL DEFAULT 1,
+    finalize_tx_hash        VARCHAR         DEFAULT NULL,
+    finalized_at            TIMESTAMP(0)    DEFAULT 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 INDEX idx_bundle_index_rollup_status ON bundle(index, rollup_status) WHERE deleted_at IS NULL;
+CREATE INDEX idx_bundle_hash ON bundle(hash) WHERE deleted_at IS NULL;
+CREATE INDEX idx_bundle_hash_proving_status ON bundle(hash, proving_status) WHERE deleted_at IS NULL;
+CREATE INDEX idx_bundle_index_desc ON bundle(index DESC) WHERE deleted_at IS NULL;
+CREATE INDEX idx_bundle_batch_proofs_status ON bundle(batch_proofs_status) WHERE deleted_at IS NULL;
+CREATE INDEX idx_bundle_start_batch_index ON bundle(start_batch_index) WHERE deleted_at IS NULL;
+CREATE INDEX idx_bundle_end_batch_index ON bundle(end_batch_index) WHERE deleted_at IS NULL;
+create index idx_bundle_total_attempts_active_attempts_batch_proofs_status
+    on bundle (total_attempts, active_attempts, batch_proofs_status)
+    where deleted_at IS NULL;
+
+COMMENT ON COLUMN bundle.batch_proofs_status IS 'undefined, pending, ready';
+COMMENT ON COLUMN bundle.proving_status IS 'undefined, unassigned, assigned, proved (deprecated), verified, failed';
+COMMENT ON COLUMN bundle.rollup_status IS 'undefined, pending, committing (not used for bundles), committed (not used for bundles), finalizing, finalized, commit_failed (not used for bundles), finalize_failed';
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE IF EXISTS bundle;
+-- +goose StatementEnd

database/migrate/migrations/00022_add_bundle_hash_and_codec_version_to_batch.sql

@@ -0,0 +1,23 @@
+-- +goose Up
+-- +goose StatementBegin
+
+ALTER TABLE batch
+ADD COLUMN bundle_hash VARCHAR DEFAULT '',
+ADD COLUMN codec_version SMALLINT DEFAULT 0;
+
+CREATE INDEX idx_batch_bundle_hash ON batch(bundle_hash);
+CREATE INDEX idx_batch_index_codec_version ON batch(index, codec_version);
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+
+DROP INDEX IF EXISTS idx_batch_bundle_hash;
+DROP INDEX IF EXISTS idx_batch_index_codec_version;
+
+ALTER TABLE IF EXISTS batch
+DROP COLUMN IF EXISTS bundle_hash,
+DROP COLUMN IF EXISTS codec_version;
+
+-- +goose StatementEnd

go.work.sum

@@ -9,7 +9,6 @@ cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTj
 cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
 cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
 cloud.google.com/go v0.51.0/go.mod h1:hWtGJ6gnXH+KgDv+V0zFGDvpi07n3z8ZNj3T1RW0Gcw=
-cloud.google.com/go v0.110.8/go.mod h1:Iz8AkXJf1qmxC3Oxoep8R1T36w8B92yU29PcBhHO5fk=
 cloud.google.com/go v0.110.10 h1:LXy9GEO+timppncPIAZoOj3l58LIU9k+kn48AN7IO3Y=
 cloud.google.com/go v0.110.10/go.mod h1:v1OoFqYxiBkUrruItNM3eT4lLByNjxmJSV/xDKJNnic=
 cloud.google.com/go/accessapproval v1.7.4 h1:ZvLvJ952zK8pFHINjpMBY5k7LTAp/6pBf50RDMRgBUI=
@@ -64,8 +63,6 @@ cloud.google.com/go/clouddms v1.7.3 h1:xe/wJKz55VO1+L891a1EG9lVUgfHr9Ju/I3xh1nwF
 cloud.google.com/go/clouddms v1.7.3/go.mod h1:fkN2HQQNUYInAU3NQ3vRLkV2iWs8lIdmBKOx4nrL6Hc=
 cloud.google.com/go/cloudtasks v1.12.4 h1:5xXuFfAjg0Z5Wb81j2GAbB3e0bwroCeSF+5jBn/L650=
 cloud.google.com/go/cloudtasks v1.12.4/go.mod h1:BEPu0Gtt2dU6FxZHNqqNdGqIG86qyWKBPGnsb7udGY0=
-cloud.google.com/go/compute v1.20.1/go.mod h1:4tCnrn48xsqlwSAiLf1HXMQk8CONslYbdiEZc9FEIbM=
-cloud.google.com/go/compute v1.23.1/go.mod h1:CqB3xpmPKKt3OJpW2ndFIXnA9A4xAy/F3Xp1ixncW78=
 cloud.google.com/go/compute v1.23.3 h1:6sVlXXBmbd7jNX0Ipq0trII3e4n1/MsADLK6a+aiVlk=
 cloud.google.com/go/compute v1.23.3/go.mod h1:VCgBUoMnIVIR0CscqQiPJLAG25E3ZRZMzcFZeQ+h8CI=
 cloud.google.com/go/contactcenterinsights v1.12.0 h1:wP41IUA4ucMVooj/TP53jd7vbNjWrDkAPOeulVJGT5U=
@@ -133,7 +130,6 @@ cloud.google.com/go/grafeas v0.3.0 h1:oyTL/KjiUeBs9eYLw/40cpSZglUC+0F7X4iu/8t7NW
 cloud.google.com/go/grafeas v0.3.0/go.mod h1:P7hgN24EyONOTMyeJH6DxG4zD7fwiYa5Q6GUgyFSOU8=
 cloud.google.com/go/gsuiteaddons v1.6.4 h1:uuw2Xd37yHftViSI8J2hUcCS8S7SH3ZWH09sUDLW30Q=
 cloud.google.com/go/gsuiteaddons v1.6.4/go.mod h1:rxtstw7Fx22uLOXBpsvb9DUbC+fiXs7rF4U29KHM/pE=
-cloud.google.com/go/iam v1.1.1/go.mod h1:A5avdyVL2tCppe4unb0951eI9jreack+RJ0/d+KUZOU=
 cloud.google.com/go/iam v1.1.5 h1:1jTsCu4bcsNsE4iiqNT5SHwrDRCfRmIaaaVFhRveTJI=
 cloud.google.com/go/iam v1.1.5/go.mod h1:rB6P/Ic3mykPbFio+vo7403drjlgvoWfYpJhMXEbzv8=
 cloud.google.com/go/iap v1.9.3 h1:M4vDbQ4TLXdaljXVZSwW7XtxpwXUUarY2lIs66m0aCM=
@@ -150,7 +146,6 @@ cloud.google.com/go/lifesciences v0.9.4 h1:rZEI/UxcxVKEzyoRS/kdJ1VoolNItRWjNN0Uk
 cloud.google.com/go/lifesciences v0.9.4/go.mod h1:bhm64duKhMi7s9jR9WYJYvjAFJwRqNj+Nia7hF0Z7JA=
 cloud.google.com/go/logging v1.8.1 h1:26skQWPeYhvIasWKm48+Eq7oUqdcdbwsCVwz5Ys0FvU=
 cloud.google.com/go/logging v1.8.1/go.mod h1:TJjR+SimHwuC8MZ9cjByQulAMgni+RkXeI3wwctHJEI=
-cloud.google.com/go/longrunning v0.5.2/go.mod h1:nqo6DQbNV2pXhGDbDMoN2bWz68MjZUzqv2YttZiveCs=
 cloud.google.com/go/longrunning v0.5.4 h1:w8xEcbZodnA2BbW6sVirkkoC+1gP8wS57EUUgGS0GVg=
 cloud.google.com/go/longrunning v0.5.4/go.mod h1:zqNVncI0BOP8ST6XQD1+VcvuShMmq7+xFSzOL++V0dI=
 cloud.google.com/go/managedidentities v1.6.4 h1:SF/u1IJduMqQQdJA4MDyivlIQ4SrV5qAawkr/ZEREkY=
@@ -309,7 +304,6 @@ github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 h1:d+Bc7a5rLufV
 github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
 github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 h1:fLjPD/aNc3UIOA6tDi6QXUemppXK3P9BI7mr2hd6gx8=
 github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
-github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw=
 github.com/aead/siphash v1.0.1 h1:FwHfE/T45KPKYuuSAKyyvE+oPWcaQ+CUmFW0bPlM+kg=
 github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
 github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
@@ -319,7 +313,6 @@ github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af h1:wVe6/Ea46ZMeNkQjj
 github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw=
 github.com/akavel/rsrc v0.10.2 h1:Zxm8V5eI1hW4gGaYsJQUhxpjkENuG91ki8B4zCrvEsw=
 github.com/akavel/rsrc v0.10.2/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c=
-github.com/alecthomas/kingpin/v2 v2.3.1/go.mod h1:oYL5vtsvEHZGHxU7DMp32Dvx+qL+ptGn6lWaot2vCNE=
 github.com/alecthomas/kingpin/v2 v2.4.0 h1:f48lwail6p8zpO1bC4TxtqACaGqHYA22qkHjHpqDjYY=
 github.com/alecthomas/kingpin/v2 v2.4.0/go.mod h1:0gyi0zQnjuFk8xrkNKamJoyUo382HRL7ATRpFZCw6tE=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc h1:cAKDfWh5VpdgMhJosfJnn5/FoN2SRZ4p7fJNX58YPaU=
@@ -347,27 +340,13 @@ github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6 h1:G1bPvciwNyF7IU
 github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a h1:idn718Q4B6AGu/h5Sxe66HYVdqdGu2l9Iebqhi/AEoA=
 github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=
 github.com/aws/aws-sdk-go-v2 v1.2.0/go.mod h1:zEQs02YRBw1DjK0PoJv3ygDYOFTre1ejlJWl8FwAuQo=
-github.com/aws/aws-sdk-go-v2 v1.17.6 h1:Y773UK7OBqhzi5VDXMi1zVGsoj+CVHs2eaC2bDsLwi0=
-github.com/aws/aws-sdk-go-v2 v1.17.6/go.mod h1:uzbQtefpm44goOPmdKyAlXSNcwlRgF3ePWVW6EtJvvw=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10 h1:dK82zF6kkPeCo8J1e+tGx4JdvDIQzj7ygIoLg8WMuGs=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10/go.mod h1:VeTZetY5KRJLuD/7fkQXMU6Mw7H5m/KP2J5Iy9osMno=
 github.com/aws/aws-sdk-go-v2/config v1.1.1/go.mod h1:0XsVy9lBI/BCXm+2Tuvt39YmdHwS5unDQmxZOYe8F5Y=
-github.com/aws/aws-sdk-go-v2/config v1.18.16 h1:4r7gsCu8Ekwl5iJGE/GmspA2UifqySCCkyyyPFeWs3w=
-github.com/aws/aws-sdk-go-v2/config v1.18.16/go.mod h1:XjM6lVbq7UgELp9NjXBrb1DQY/ownlWsvDhEQksemJc=
 github.com/aws/aws-sdk-go-v2/credentials v1.1.1/go.mod h1:mM2iIjwl7LULWtS6JCACyInboHirisUUdkBPoTHMOUo=
-github.com/aws/aws-sdk-go-v2/credentials v1.13.16 h1:GgToSxaENX/1zXIGNFfiVk4hxryYJ5Vt4Mh8XLAL7Lc=
-github.com/aws/aws-sdk-go-v2/credentials v1.13.16/go.mod h1:KP7aFJhfwPFgx9aoVYL2nYHjya5WBD98CWaadpgmnpY=
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.0.2/go.mod h1:3hGg3PpiEjHnrkrlasTfxFqUsZ2GCk/fMUn4CbKgSkM=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.12.24 h1:5qyqXASrX2zy5cTnoHHa4N2c3Lc94GH7gjnBP3GwKdU=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.12.24/go.mod h1:neYVaeKr5eT7BzwULuG2YbLhzWZ22lpjKdCybR7AXrQ=
 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.56 h1:kFDCPqqVvb9vYcW82L7xYfrBGpuxXQ/8A/zYVayRQK4=
 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.56/go.mod h1:FoSBuessadgy8Cqp9gQF8U5rzi1XVQhiEJ6su2/kBEE=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.30 h1:y+8n9AGDjikyXoMBTRaHHHSaFEB8267ykmvyPodJfys=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.30/go.mod h1:LUBAO3zNXQjoONBKn/kR1y0Q4cj/D02Ts0uHYjcCQLM=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.24 h1:r+Kv+SEJquhAZXaJ7G4u44cIwXV3f8K+N482NNAzJZA=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.24/go.mod h1:gAuCezX/gob6BSMbItsSlMb6WZGV7K2+fWOvk8xBSto=
-github.com/aws/aws-sdk-go-v2/internal/ini v1.3.31 h1:hf+Vhp5WtTdcSdE+yEcUz8L73sAzN0R+0jQv+Z51/mI=
-github.com/aws/aws-sdk-go-v2/internal/ini v1.3.31/go.mod h1:5zUjguZfG5qjhG9/wqmuyHRyUftl2B5Cp6NNxNC6kRA=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.22 h1:lTqBRUuy8oLhBsnnVZf14uRbIHPHCrGqg4Plc8gU/1U=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.22/go.mod h1:YsOa3tFriwWNvBPYHXM5ARiU2yqBNWPWeUiq+4i7Na0=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11 h1:y2+VQzC6Zh2ojtV2LoC0MNwHWc6qXv/j2vrQtlftkdA=
@@ -375,8 +354,6 @@ github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11/go.mod h1:
 github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.25 h1:B/hO3jfWRm7hP00UeieNlI5O2xP5WJ27tyJG5lzc7AM=
 github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.25/go.mod h1:54K1zgxK/lai3a4HosE4IKBwZsP/5YAJ6dzJfwsjJ0U=
 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.0.2/go.mod h1:45MfaXZ0cNbeuT0KQ1XJylq8A6+OpVV2E5kvY/Kq+u8=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.24 h1:c5qGfdbCHav6viBwiyDns3OXqhqAbGjfIB4uVu2ayhk=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.24/go.mod h1:HMA4FZG6fyib+NDo5bpIxX1EhYjrAOveZJY2YR0xrNE=
 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.13.24 h1:i4RH8DLv/BHY0fCrXYQDr+DGnWzaxB3Ee/esxUaSavk=
 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.13.24/go.mod h1:N8X45/o2cngvjCYi2ZnvI0P4mU4ZRJfEYC3maCSsPyw=
 github.com/aws/aws-sdk-go-v2/service/route53 v1.1.1 h1:cKr6St+CtC3/dl/rEBJvlk7A/IN5D5F02GNkGzfbtVU=
@@ -384,20 +361,11 @@ github.com/aws/aws-sdk-go-v2/service/route53 v1.1.1/go.mod h1:rLiOUrPLW/Er5kRcQ7
 github.com/aws/aws-sdk-go-v2/service/s3 v1.30.6 h1:zzTm99krKsFcF4N7pu2z17yCcAZpQYZ7jnJZPIgEMXE=
 github.com/aws/aws-sdk-go-v2/service/s3 v1.30.6/go.mod h1:PudwVKUTApfm0nYaPutOXaKdPKTlZYClGBQpVIRdcbs=
 github.com/aws/aws-sdk-go-v2/service/sso v1.1.1/go.mod h1:SuZJxklHxLAXgLTc1iFXbEWkXs7QRTQpCLGaKIprQW0=
-github.com/aws/aws-sdk-go-v2/service/sso v1.12.5 h1:bdKIX6SVF3nc3xJFw6Nf0igzS6Ff/louGq8Z6VP/3Hs=
-github.com/aws/aws-sdk-go-v2/service/sso v1.12.5/go.mod h1:vuWiaDB30M/QTC+lI3Wj6S/zb7tpUK2MSYgy3Guh2L0=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.5 h1:xLPZMyuZ4GuqRCIec/zWuIhRFPXh2UOJdLXBSi64ZWQ=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.5/go.mod h1:QjxpHmCwAg0ESGtPQnLIVp7SedTOBMYy+Slr3IfMKeI=
 github.com/aws/aws-sdk-go-v2/service/sts v1.1.1/go.mod h1:Wi0EBZwiz/K44YliU0EKxqTCJGUfYTWXrrBwkq736bM=
-github.com/aws/aws-sdk-go-v2/service/sts v1.18.6 h1:rIFn5J3yDoeuKCE9sESXqM5POTAhOP1du3bv/qTL+tE=
-github.com/aws/aws-sdk-go-v2/service/sts v1.18.6/go.mod h1:48WJ9l3dwP0GSHWGc5sFGGlCkuA82Mc2xnw+T6Q8aDw=
 github.com/aws/smithy-go v1.1.0/go.mod h1:EzMw8dbp/YJL4A5/sbhGddag+NPT7q084agLbB9LgIw=
-github.com/aws/smithy-go v1.13.5 h1:hgz0X/DX0dGqTYpGALqXJoRKRj5oQ7150i5FdTePzO8=
-github.com/aws/smithy-go v1.13.5/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA=
 github.com/bitly/go-hostpool v0.1.0 h1:XKmsF6k5el6xHG3WPJ8U0Ku/ye7njX7W81Ng7O2ioR0=
 github.com/bitly/go-simplejson v0.5.0 h1:6IH+V8/tVMab511d5bn4M7EwGXZf9Hj6i2xSwkNEM+Y=
-github.com/bits-and-blooms/bitset v1.5.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
-github.com/bits-and-blooms/bitset v1.7.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
+github.com/bits-and-blooms/bitset v1.12.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
 github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM=
 github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ=
 github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY=
@@ -421,7 +389,6 @@ github.com/c-bata/go-prompt v0.2.2/go.mod h1:VzqtzE2ksDBcdln8G7mk2RX9QyGjH+OVqOC
 github.com/census-instrumentation/opencensus-proto v0.4.1 h1:iKLQ0xPNFxR/2hzXZMrBo8f1j86j5WHzznCCQxV/b8g=
 github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw=
 github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
-github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chzyer/logex v1.1.10 h1:Swpa1K6QvQznwJRcfTfQJmTE72DqScAa40E+fbHEXEE=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e h1:fY5BOSpyZCqRo5OhCuC+XN+r/bBCmeuuJtjz+bCNIf8=
@@ -433,23 +400,14 @@ github.com/cilium/ebpf v0.9.1/go.mod h1:+OhNOIXx/Fnu1IE8bJz2dzOA+VSfyTfdNUVdlQnx
 github.com/client9/misspell v0.3.4 h1:ta993UF76GwbvJcIo3Y68y/M3WxlpEHPWIGDkJYwzJI=
 github.com/cloudflare/backoff v0.0.0-20161212185259-647f3cdfc87a h1:8d1CEOF1xldesKds5tRG3tExBsMOgWYownMHNCsev54=
 github.com/cloudflare/backoff v0.0.0-20161212185259-647f3cdfc87a/go.mod h1:rzgs2ZOiguV6/NpiDgADjRLPNyZlApIWxKpkT+X8SdY=
-github.com/cloudflare/cfssl v0.0.0-20180223231731-4e2dcbde5004 h1:lkAMpLVBDaj17e85keuznYcH5rqI438v41pKcBl4ZxQ=
 github.com/cloudflare/cloudflare-go v0.14.0 h1:gFqGlGl/5f9UGXAaKapCGUfaTCgRKKnzu2VvzMZlOFA=
 github.com/cloudflare/cloudflare-go v0.14.0/go.mod h1:EnwdgGMaFOruiPZRFSgn+TsQ3hQ7C/YWzIGLeu5c304=
 github.com/cloudflare/redoctober v0.0.0-20211013234631-6a74ccc611f6 h1:QKzett0dn5FhjcIHNKSClEilabfhWCnsdijq3ftm9Ms=
 github.com/cloudflare/redoctober v0.0.0-20211013234631-6a74ccc611f6/go.mod h1:Ikt4Wfpln1YOrak+auA8BNxgiilj0Y2y7nO+aN2eMzk=
-github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
 github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe h1:QQ3GSy+MqSHxm/d8nCtnAiZdYFd45cYZPs8vOOIYKfk=
 github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
-github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/compose-spec/compose-go v1.20.0 h1:h4ZKOst1EF/DwZp7dWkb+wbTVE4nEyT9Lc89to84Ol4=
 github.com/compose-spec/compose-go v1.20.0/go.mod h1:+MdqXV4RA7wdFsahh/Kb8U0pAJqkg7mr4PM9tFKU8RM=
-github.com/compose-spec/compose-go/v2 v2.0.0-rc.2 h1:eJ01FpliL/02KvsaPyH1bSLbM1S70yWQUojHVRbyvy4=
-github.com/compose-spec/compose-go/v2 v2.0.0-rc.2/go.mod h1:IVsvFyGVhw4FASzUtlWNVaAOhYmakXAFY9IlZ7LAuD8=
-github.com/consensys/gnark-crypto v0.10.0/go.mod h1:Iq/P3HHl0ElSjsg2E1gsMwhAyxnxoKK5nVyZKd+/KhU=
 github.com/container-orchestrated-devices/container-device-interface v0.6.1 h1:mz77uJoP8im/4Zins+mPqt677ZMaflhoGaYrRAl5jvA=
 github.com/container-orchestrated-devices/container-device-interface v0.6.1/go.mod h1:40T6oW59rFrL/ksiSs7q45GzjGlbvxnA4xaK6cyq+kA=
 github.com/containerd/aufs v1.0.0 h1:2oeJiwX5HstO7shSrPZjrohJZLzK36wvpdmzDRkL/LY=
@@ -489,17 +447,7 @@ github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e h1:Wf6HqHfScWJN9
 github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f h1:lBNOc5arjvs8E5mO2tbpBpLoyyu8B6e44T7hJy6potg=
-github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk=
-github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
-github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/crate-crypto/go-ipa v0.0.0-20220523130400-f11357ae11c7 h1:6IrxszG5G+O7zhtkWxq6+unVvnrm1fqV2Pe+T95DUzw=
-github.com/crate-crypto/go-ipa v0.0.0-20220523130400-f11357ae11c7/go.mod h1:gFnFS95y8HstDP6P9pPwzrxOOC5TRDkwbM+ao15ChAI=
-github.com/crate-crypto/go-ipa v0.0.0-20230601170251-1830d0757c80 h1:DuBDHVjgGMPki7bAyh91+3cF1Vh34sAEdH8JQgbc2R0=
-github.com/crate-crypto/go-ipa v0.0.0-20230601170251-1830d0757c80/go.mod h1:gzbVz57IDJgQ9rLQwfSk696JGWof8ftznEL9GoAv3NI=
-github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ=
-github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs=
-github.com/creack/pty v1.1.11 h1:07n33Z8lZxZ2qwegKbObQohDhXDQxiMMz1NOUGYlesw=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c h1:/ovYnF02fwL0kvspmy9AuyKg1JhdTRUgPw4nUxd9oZM=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
 github.com/danieljoos/wincred v1.2.0 h1:ozqKHaLK0W/ii4KVbbvluM91W2H3Sh0BncbUNPS7jLE=
@@ -525,15 +473,10 @@ github.com/dimchansky/utfbom v1.1.1 h1:vV6w1AhK4VMnhBno/TPVCoK9U/LP0PkLCS9tbxHdi
 github.com/dimchansky/utfbom v1.1.1/go.mod h1:SxdoEBH5qIqFocHMyGOXVAybYJdr71b1Q/j0mACtrfE=
 github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91 h1:Izz0+t1Z5nI16/II7vuEo/nHjodOg0p7+OiDpjX5t1E=
 github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
-github.com/docker/cli v25.0.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
 github.com/docker/cli-docs-tool v0.6.0 h1:Z9x10SaZgFaB6jHgz3OWooynhSa40CsWkpe5hEnG/qA=
 github.com/docker/cli-docs-tool v0.6.0/go.mod h1:zMjqTFCU361PRh8apiXzeAZ1Q/xupbIwTusYpzCXS/o=
-github.com/docker/compose/v2 v2.24.3 h1:BVc1oDV7aQgksH64pDKTvcI95G36uJ+Mz9DGGBBoZeQ=
-github.com/docker/compose/v2 v2.24.3/go.mod h1:D8Nv9+juzD7xiMyyHJ7G2J/MOYiGBmb9SvdIW5+2zKo=
 github.com/docker/docker v1.4.2-0.20180625184442-8e610b2b55bf/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
-github.com/docker/docker v25.0.3+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815 h1:bWDMxwH3px2JBh6AyO7hdCn/PkvCZXii8TGj7sbtEbQ=
-github.com/dop251/goja v0.0.0-20211011172007-d99e4b8cbf48 h1:iZOop7pqsg+56twTopWgwCGxdB5SI2yDO8Ti7eTRliQ=
 github.com/dop251/goja v0.0.0-20211011172007-d99e4b8cbf48/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=
 github.com/dop251/goja v0.0.0-20220405120441-9037c2b61cbf h1:Yt+4K30SdjOkRoRRm3vYNQgR+/ZIy0RmeUDZo7Y8zeQ=
 github.com/dop251/goja v0.0.0-20220405120441-9037c2b61cbf/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=
@@ -542,9 +485,6 @@ github.com/dop251/goja_nodejs v0.0.0-20210225215109-d91c329300e7/go.mod h1:hn7BA
 github.com/dvsekhvalnov/jose2go v0.0.0-20170216131308-f21a8cedbbae h1:UTOyRlLeWJrZx+ynml6q6qzZ1uDkJe/0Z5CMZRbEIJg=
 github.com/eclipse/paho.mqtt.golang v1.2.0 h1:1F8mhG9+aO5/xpdtFkW4SxOJB67ukuDC3t2y2qayIX0=
 github.com/eclipse/paho.mqtt.golang v1.2.0/go.mod h1:H9keYFcgq3Qr5OUJm/JZI/i6U7joQ8SYLhZwfeOo6Ts=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
 github.com/envoyproxy/go-control-plane v0.11.1 h1:wSUXTlLfiAQRWs2F+p+EKOY9rUyis1MyGqJ2DIk5HpM=
 github.com/envoyproxy/go-control-plane v0.11.1/go.mod h1:uhMcXKCQMEJHiAb0w+YGefQLaTEw+YhGluxZkrTmD0g=
 github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5 h1:Yzb9+7DPaBjB8zlTR87/ElzFsnQfuHnVUVqpZZIcV5Y=
@@ -585,7 +525,6 @@ github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72 h1:b+9H1GAsx5
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
 github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
-github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8=
 github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
 github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
 github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
@@ -597,7 +536,6 @@ github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5x
 github.com/gofrs/uuid v3.3.0+incompatible h1:8K4tyRfvU1CYPgJsveYFQMhpFd/wXNM7iK6rR7UHz84=
 github.com/gofrs/uuid v3.3.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
-github.com/golang-jwt/jwt v3.2.1+incompatible h1:73Z+4BJcrTC+KczS6WvTPvRGOp1WmfEP4Q1lOd9Z/+c=
 github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA=
 github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
 github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A=
@@ -614,7 +552,6 @@ github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
 github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219 h1:utua3L2IbQJmauC5IXdEA547bcoU5dozgQAfc8Onsg4=
 github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219/go.mod h1:/X8TswGSh1pIozq4ZwCfxS0WA5JGXguxk94ar/4c87Y=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
@@ -626,11 +563,9 @@ github.com/google/flatbuffers v1.11.0/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv
 github.com/google/flatbuffers v2.0.8+incompatible h1:ivUb1cGomAB101ZM1T0nOiWz9pSrTMoa9+EiY7igmkM=
 github.com/google/flatbuffers v2.0.8+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
 github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-containerregistry v0.14.0 h1:z58vMqHxuwvAsVwvKEkmVBz2TlgBgH5k6koEXBtlYkw=
 github.com/google/go-containerregistry v0.14.0/go.mod h1:aiJ2fp/SXvkWgmYHioXnbMdlgB8eXiiYOY55gfN91Wk=
-github.com/google/go-pkcs11 v0.2.1-0.20230907215043-c6f79328ddf9/go.mod h1:6eQoGcuNJpa7jnd5pMGdkSaQpNDYvPlXWMcjXXThLlY=
 github.com/google/gofuzz v1.1.1-0.20200604201612-c04b05f3adfa/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/martian v2.1.0+incompatible h1:/CP5g8u/VJHijgedC/Legn3BAbAaWPgecwXBIDzw5no=
 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
@@ -643,15 +578,10 @@ github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38 h1:yAJXTCF9TqKcTiHJAE
 github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/google/renameio v0.1.0 h1:GOZbcHa3HfsPKPlmyPyN2KEohoMXOhdMbHrvbpl2QaA=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/s2a-go v0.1.4/go.mod h1:Ej+mSEMGRnqRzjc7VtF+jdBwYG5fuJfiZ8ELkjEwM0A=
 github.com/google/s2a-go v0.1.7 h1:60BLSyTrOV4/haCDW4zb1guZItoSq8foHCXrAnjBo/o=
 github.com/google/s2a-go v0.1.7/go.mod h1:50CgR4k1jNlWBu4UfS4AcfhVe1r6pdZPygJ3R8F0Qdw=
 github.com/google/subcommands v1.2.0 h1:vWQspBTo2nEqTUFita5/KeEWlUL8kQObDFbub/EN9oE=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.5/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/enterprise-certificate-proxy v0.2.4/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k=
 github.com/googleapis/enterprise-certificate-proxy v0.3.2 h1:Vie5ybvEvT75RniqhfFxPRy3Bf7vr3h0cechB90XaQs=
 github.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
@@ -661,7 +591,6 @@ github.com/googleapis/gax-go/v2 v2.12.0/go.mod h1:y+aIqrI5eb1YGMVJfuV3185Ts/D7qK
 github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
 github.com/gotestyourself/gotestyourself v1.4.0 h1:CDSlSIuRL/Fsc72Ln5lMybtrCvSRDddsHsDRG/nP7Rg=
 github.com/gotestyourself/gotestyourself v1.4.0/go.mod h1:zZKM6oeNM8k+FRljX1mnzVYeS8wiGgQyvST1/GafPbY=
-github.com/graph-gophers/graphql-go v0.0.0-20201113091052-beb923fada29 h1:sezaKhEfPFg8W0Enm61B9Gs911H8iesGY5R8NDPtd1M=
 github.com/graph-gophers/graphql-go v0.0.0-20201113091052-beb923fada29/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc=
 github.com/graph-gophers/graphql-go v1.3.0 h1:Eb9x/q6MFpCLz7jBCiP/WTxjSDrYLR1QY41SORZyNJ0=
 github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc=
@@ -688,7 +617,7 @@ github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150 h1:vlNjIqmUZ9CMAWsbURY
 github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6 h1:UDMh68UUwekSh5iP2OMhRRZJiiBccgV7axzUG8vi56c=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/iden3/go-iden3-crypto v0.0.12/go.mod h1:swXIv0HFbJKobbQBtsB50G7IHr6PbTowutSew/iBEoo=
+github.com/iden3/go-iden3-crypto v0.0.15/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBeOT/3UEhXsEsP3E=
 github.com/influxdata/flux v0.65.1 h1:77BcVUCzvN5HMm8+j9PRBQ4iZcu98Dl4Y9rf+J5vhnc=
 github.com/influxdata/flux v0.65.1/go.mod h1:J754/zds0vvpfwuq7Gc2wRdVwEodfpCFM7mYlOw2LqY=
 github.com/influxdata/influxdb v1.8.3 h1:WEypI1BQFTT4teLM+1qkEcvUi0dAvopAI/ir0vAiBg8=
@@ -711,8 +640,6 @@ github.com/influxdata/usage-client v0.0.0-20160829180054-6d3895376368 h1:+TUUmaF
 github.com/influxdata/usage-client v0.0.0-20160829180054-6d3895376368/go.mod h1:Wbbw6tYNvwa5dlB6304Sd+82Z3f7PmVZHVKU637d4po=
 github.com/intel/goresctrl v0.3.0 h1:K2D3GOzihV7xSBedGxONSlaw/un1LZgWsc9IfqipN4c=
 github.com/intel/goresctrl v0.3.0/go.mod h1:fdz3mD85cmP9sHD8JUlrNWAxvwM86CrbmVXltEKd7zk=
-github.com/jackc/pgx/v5 v5.3.0/go.mod h1:t3JDKnCBlYIc0ewLF0Q7B8MXmoIaBOZj/ic7iHozM/8=
-github.com/jackc/puddle/v2 v2.2.0/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jackpal/go-nat-pmp v1.0.2-0.20160603034137-1fa385a6f458/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
 github.com/jedisct1/go-minisign v0.0.0-20190909160543-45766022959e h1:UvSe12bq+Uj2hWd8aOlwPmoZ+CITRFrdit+sDGfAg8U=
 github.com/jedisct1/go-minisign v0.0.0-20190909160543-45766022959e/go.mod h1:G1CVv03EnqU1wYL2dFwXxW2An0az9JTl/ZsqXQeBlkU=
@@ -738,7 +665,6 @@ github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5 h1:PJr+ZMXIecYc
 github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
 github.com/jwilder/encoding v0.0.0-20170811194829-b4e1701a28ef h1:2jNeR4YUziVtswNP9sEFAI913cVrzH85T+8Q6LpYbT0=
 github.com/jwilder/encoding v0.0.0-20170811194829-b4e1701a28ef/go.mod h1:Ct9fl0F6iIOGgxJ5npU/IUOhOhqlVrGjyIZc8/MagT0=
-github.com/karalabe/usb v0.0.0-20211005121534-4c5740d64559 h1:0VWDXPNE0brOek1Q8bLfzKkvOzwbQE/snjGojlCr8CY=
 github.com/karalabe/usb v0.0.0-20211005121534-4c5740d64559/go.mod h1:Od972xHfMJowv7NGVDiWVxk2zxnWgjLlJzE+F4F7AGU=
 github.com/karalabe/usb v0.0.2 h1:M6QQBNxF+CQ8OFvxrT90BA0qBOXymndZnk5q235mFc4=
 github.com/karalabe/usb v0.0.2/go.mod h1:Od972xHfMJowv7NGVDiWVxk2zxnWgjLlJzE+F4F7AGU=
@@ -850,7 +776,6 @@ github.com/package-url/packageurl-go v0.1.1-0.20220428063043-89078438f170 h1:DiL
 github.com/package-url/packageurl-go v0.1.1-0.20220428063043-89078438f170/go.mod h1:uQd4a7Rh3ZsVg5j0lNyAfyxIeGde9yrlhjF78GzeW0c=
 github.com/paulbellamy/ratecounter v0.2.0 h1:2L/RhJq+HA8gBQImDXtLPrDXK5qAj6ozWVK/zFXVJGs=
 github.com/paulbellamy/ratecounter v0.2.0/go.mod h1:Hfx1hDpSGoqxkVVpBi/IlYD7kChlfo5C6hzIHwPqfFE=
-github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
 github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI=
 github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
 github.com/peterh/liner v1.0.1-0.20180619022028-8c1271fcf47f/go.mod h1:xIteQHvHuaLYG9IFj6mSxM0fCKrs34IrEQUhOYuGPHc=
@@ -880,38 +805,12 @@ github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFR
 github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww=
 github.com/russross/blackfriday v1.6.0/go.mod h1:ti0ldHuxg49ri4ksnFxlkCfN+hvslNlmVHqNRXXJNAY=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/ryanuber/columnize v2.1.0+incompatible h1:j1Wcmh8OrK4Q7GXY+V7SVSY8nUWQxHW5TkBe7YUl+2s=
-github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
-github.com/sanity-io/litter v1.5.5/go.mod h1:9gzJgR2i4ZpjZHsKvUXIRQVk7P+yM3e+jAF7bU2UI5U=
-github.com/schollz/closestmatch v2.1.0+incompatible h1:Uel2GXEpJqOWBrlyI+oY9LTiyyjYS17cCYRqP13/SHk=
-github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g=
-github.com/sclevine/agouti v3.0.0+incompatible h1:8IBJS6PWz3uTlMP3YBIR5f+KAldcGuOeFkFbUWfBgK4=
-github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw=
-github.com/scroll-tech/da-codec v0.0.0-20240515170552-2e5286688fce h1:SN43TBs7VaJt9q737eWWqGz0OCg4v+PtUn3RbJcG1o0=
-github.com/scroll-tech/da-codec v0.0.0-20240515170552-2e5286688fce/go.mod h1:1wWYii0OPwd5kw+xrz0PFgS420xNadrNF1x/ELJT+TM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20221202061207-804e7edc23ba/go.mod h1:jurIpDQ0hqtp9//xxeWzr8X9KMP/+TYn+vz3K1wZrv0=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20221213034543-78c1f57fcfea/go.mod h1:jurIpDQ0hqtp9//xxeWzr8X9KMP/+TYn+vz3K1wZrv0=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20221221073256-5ca70bf3a257/go.mod h1:jurIpDQ0hqtp9//xxeWzr8X9KMP/+TYn+vz3K1wZrv0=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230210093343-bb26fa3e391d/go.mod h1:OH4ZTAz6RM1IL0xcQ1zM6+Iy9s2vtcYqqwcEQdfHV7g=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230220082843-ec9254b0b1c6/go.mod h1:eW+eyNdMoO0MyuczCc9xWSnW8dPJ0kOy5xsxgOKYEaA=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230306131930-03b4de32b78b/go.mod h1:f9ygxrxL7WRCTzuloV+t/UlcxMq3AL+gcNU60liiNNU=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230321020420-127af384ed04/go.mod h1:jH8c08L9K8Hieaf0r/ur2P/cpesn4dFhmLm2Mmoi8kI=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230802095950-4b2bbf6225e7/go.mod h1:DiN3p2inoXOxGffxSswDKqWjQ7bU+Mp0c9v0XQXKmaA=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230829000527-f883dcdc21fc/go.mod h1:DiN3p2inoXOxGffxSswDKqWjQ7bU+Mp0c9v0XQXKmaA=
-github.com/scroll-tech/zktrie v0.6.0/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
-github.com/scroll-tech/zktrie v0.8.2/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240607130425-e2becce6a1a4/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/segmentio/kafka-go v0.1.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=
 github.com/segmentio/kafka-go v0.2.0 h1:HtCSf6B4gN/87yc5qTl7WsxPKQIIGXLPPM1bMCPOsoY=
 github.com/segmentio/kafka-go v0.2.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=
 github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
-github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
-github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
-github.com/sergi/go-diff v1.2.0 h1:XU+rvMAioB0UC3q1MFrIQy4Vo5/4VsRDQQXHsEya6xQ=
-github.com/sergi/go-diff v1.2.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
-github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
-github.com/shirou/gopsutil/v3 v3.22.8 h1:a4s3hXogo5mE2PfdfJIonDbstO/P+9JszdfhAHSzD9Y=
-github.com/shirou/gopsutil/v3 v3.22.8/go.mod h1:s648gW4IywYzUfE/KjXxUsqrqx/T2xO5VqOXxONeRfI=
 github.com/shurcooL/go v0.0.0-20200502201357-93f07166e636 h1:aSISeOcal5irEhJd1M+IrApc0PdcN7e7Aj4yuEnOrfQ=
 github.com/shurcooL/go v0.0.0-20200502201357-93f07166e636/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=
 github.com/shurcooL/httpfs v0.0.0-20190707220628-8d4bc4ba7749 h1:bUGsEnyNbVPw06Bs80sCeARAlK8lhwqGyi6UT8ymuGk=
@@ -927,7 +826,6 @@ github.com/soheilhy/cmux v0.1.5 h1:jjzc5WVemNEDTLwv9tlmemhC73tI08BNOIGwBOo10Js=
 github.com/soheilhy/cmux v0.1.5/go.mod h1:T7TcVDs9LWfQgPlPsdngu6I6QIoyIFZDDC6sNE1GqG0=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ=
 github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
-github.com/spf13/cobra v1.5.0/go.mod h1:dWXEIy2H428czQCjInthrTRUg7yKbok+2Qi/yBIJoUM=
 github.com/spiffe/go-spiffe/v2 v2.1.1 h1:RT9kM8MZLZIsPTH+HKQEP5yaAk3yd/VBzlINaRjXs8k=
 github.com/spiffe/go-spiffe/v2 v2.1.1/go.mod h1:5qg6rpqlwIub0JAiF1UK9IMD6BpPTmvG6yfSgDBs5lg=
 github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q=
@@ -943,24 +841,8 @@ github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635 h1:kdXcSzyDtse
 github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww=
 github.com/tchap/go-patricia/v2 v2.3.1 h1:6rQp39lgIYZ+MHmdEq4xzuk1t7OdC35z/xm0BGhTkes=
 github.com/tchap/go-patricia/v2 v2.3.1/go.mod h1:VZRHKAb53DLaG+nA9EaYYiaEx6YztwDlLElMsnSHD4k=
-github.com/tdewolff/minify/v2 v2.12.4 h1:kejsHQMM17n6/gwdw53qsi6lg0TGddZADVyQOz1KMdE=
-github.com/tdewolff/minify/v2 v2.12.4/go.mod h1:h+SRvSIX3kwgwTFOpSckvSxgax3uy8kZTSF1Ojrr3bk=
-github.com/tdewolff/parse/v2 v2.6.4 h1:KCkDvNUMof10e3QExio9OPZJT8SbdKojLBumw8YZycQ=
-github.com/tdewolff/parse/v2 v2.6.4/go.mod h1:woz0cgbLwFdtbjJu8PIKxhW05KplTFQkOdX78o+Jgrs=
-github.com/tdewolff/test v1.0.7 h1:8Vs0142DmPFW/bQeHRP3MV19m1gvndjUb1sn8yy74LM=
-github.com/tdewolff/test v1.0.7/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
-github.com/testcontainers/testcontainers-go v0.28.0 h1:1HLm9qm+J5VikzFDYhOd+Zw12NtOl+8drH2E8nTY1r8=
-github.com/testcontainers/testcontainers-go v0.28.0/go.mod h1:COlDpUXbwW3owtpMkEB1zo9gwb1CoKVKlyrVPejF4AU=
-github.com/testcontainers/testcontainers-go/modules/compose v0.28.0 h1:QOCeTYZIYixg796Ik60MOaeMgpAKPbQd5pJOdTrftyg=
-github.com/testcontainers/testcontainers-go/modules/compose v0.28.0/go.mod h1:lShXm8oldlLck3ltA5u+ShSvUnZ+wiNxwpp8wAQGZ1Y=
-github.com/testcontainers/testcontainers-go/modules/postgres v0.28.0 h1:ff0s4JdYIdNAVSi/SrpN2Pdt1f+IjIw3AKjbHau8Un4=
-github.com/testcontainers/testcontainers-go/modules/postgres v0.28.0/go.mod h1:fXgcYpbyrduNdiz2qRZuYkmvqLnEqsjbQiBNYH1ystI=
-github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
 github.com/tinylib/msgp v1.0.2 h1:DfdQrzQa7Yh2es9SuLkixqxuXS2SxsdYn0KbdrOGWD8=
 github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
-github.com/tklauser/go-sysconf v0.3.5/go.mod h1:MkWzOF4RMCshBAMXuhXJs64Rte09mITnppBXY/rYEFI=
-github.com/tklauser/go-sysconf v0.3.10/go.mod h1:C8XykCvCb+Gn0oNCWPIlcb0RuglQTYaQ2hGm7jmxEFk=
-github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hMwiKKqXCQ=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20201229170055-e5319fda7802 h1:uruHq4dN7GR16kFc5fp3d1RIYzJW5onx8Ybykw2YQFA=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20201229170055-e5319fda7802/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/tonistiigi/go-actions-cache v0.0.0-20220404170428-0bdeb6e1eac7 h1:8eY6m1mjgyB8XySUR7WvebTM8D/Vs86jLJzD/Tw7zkc=
@@ -1024,19 +906,15 @@ go.etcd.io/etcd/raft/v3 v3.5.5 h1:Ibz6XyZ60OYyRopu73lLM/P+qco3YtlZMOhnXNS051I=
 go.etcd.io/etcd/raft/v3 v3.5.5/go.mod h1:76TA48q03g1y1VpTue92jZLr9lIHKUNcYdZOOGyx8rI=
 go.etcd.io/etcd/server/v3 v3.5.5 h1:jNjYm/9s+f9A9r6+SC4RvNaz6AqixpOvhrFdT0PvIj0=
 go.etcd.io/etcd/server/v3 v3.5.5/go.mod h1:rZ95vDw/jrvsbj9XpTqPrTAB9/kzchVdhRirySPkUBc=
-go.etcd.io/gofail v0.1.0/go.mod h1:VZBCXYGZhHAinaBiiqYvuDynvahNsAyLFwB3kEHKz1M=
 go.mozilla.org/pkcs7 v0.0.0-20200128120323-432b2356ecb1 h1:A/5uWzF44DlIgdm/PQFwfMkW0JX+cIcQi/SwLAmZP5M=
 go.mozilla.org/pkcs7 v0.0.0-20200128120323-432b2356ecb1/go.mod h1:SNgMg+EgDFwmvSmLRTNKC5fegJjB7v23qTQ0XLGUNHk=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.45.0 h1:x8Z78aZx8cOF0+Kkazoc7lwUNMGy0LrzEMxTm4BbTxg=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.45.0/go.mod h1:62CPTSry9QZtOaSsE3tOzhx6LzDhHnXJ6xHeMNNiM6Q=
 go.opentelemetry.io/otel/exporters/jaeger v1.17.0 h1:D7UpUy2Xc2wsi1Ras6V40q806WM07rqoCWzXu7Sqy+4=
 go.opentelemetry.io/otel/exporters/jaeger v1.17.0/go.mod h1:nPCqOnEH9rNLKqH/+rrUjiMzHJdV1BlpKcTwRTyKkKI=
 go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.10.0 h1:TaB+1rQhddO1sF71MpZOZAuSPW1klK2M8XxfrBMfK7Y=
 go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.10.0/go.mod h1:78XhIg8Ht9vR4tbLNUhXsiOnE2HOuSeKAiAcoVQEpOY=
-go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
@@ -1048,14 +926,10 @@ golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20190909091759-094676da4a83/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.0.0-20211117183948-ae814b36b871/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.0.0-20220314234659-1baeb1ce4c0b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
 golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
 golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
-golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
-golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
-golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -1066,15 +940,11 @@ golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm0
 golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
 golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
 golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20230713183714-613f0c0eb8a1 h1:MGwJjxBy0HJshjDNfLsYO8xppfqWlA5ZT9OhtUUhTNw=
-golang.org/x/exp v0.0.0-20230713183714-613f0c0eb8a1/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc=
-golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ=
 golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b h1:+qEpEAPhDZ1o0x3tHzZTQDArnOixOzGD9HUJfcg0mb4=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3 h1:XQyxROzUlZH+WIQwySDgnISgOivlhjIEwaQaJEJrrN0=
 golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
@@ -1087,20 +957,15 @@ golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKG
 golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210220033124-5f55cee0dc0d/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
 golang.org/x/net v0.16.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
 golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
 golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
@@ -1108,12 +973,9 @@ golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4Iltr
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.11.0/go.mod h1:LdF7O/8bLR/qWK9DrpXmbHLTouvRHK0SgJl0GmDBchk=
-golang.org/x/oauth2 v0.13.0/go.mod h1:/JMhi4ZRXAf4HG9LiNmxvk+45+96RUlVThiH8FzNBn0=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -1127,20 +989,16 @@ golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2 h1:IRJeR9r1pYWsHKTRe/IInb7lYvbBVIqOgsX/u0mbOWY=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
-golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
+golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
@@ -1191,7 +1049,6 @@ google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEn
 google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
 google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
 google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.128.0/go.mod h1:Y611qgqaE92On/7g65MQgxYul3c0rEB894kniWLY750=
 google.golang.org/api v0.149.0 h1:b2CqT6kG+zqJIVKRQ3ELJVLN1PwHZ6DJ3dW8yl82rgY=
 google.golang.org/api v0.149.0/go.mod h1:Mwn1B7JTXrzXtnvmzQE2BD6bYZQ8DShKZDZbeN9I7qI=
 google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
@@ -1209,28 +1066,16 @@ google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvx
 google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
 google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
 google.golang.org/genproto v0.0.0-20200108215221-bd8f9a0ef82f/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20231016165738-49dd2c1f3d0b/go.mod h1:CgAqfJo+Xmu0GwA0411Ht3OU3OntXwsGmrmjI8ioGXI=
 google.golang.org/genproto v0.0.0-20231030173426-d783a09b4405/go.mod h1:3WDQMjmJk36UQhjQ89emUzb1mdaHcPeeAh4SCBKznB4=
 google.golang.org/genproto v0.0.0-20231120223509-83a465c0220f h1:Vn+VyHU5guc9KjB5KrjI2q0wCOWEOIh0OEsleqakHJg=
 google.golang.org/genproto v0.0.0-20231120223509-83a465c0220f/go.mod h1:nWSwAFPb+qfNJXsoeO3Io7zf4tMSfN8EA8RlDA04GhY=
-google.golang.org/genproto/googleapis/api v0.0.0-20231016165738-49dd2c1f3d0b/go.mod h1:IBQ646DjkDkvUIsVq/cc03FUFQ9wbZu7yE396YcL870=
 google.golang.org/genproto/googleapis/api v0.0.0-20231106174013-bbf56f31fb17 h1:JpwMPBpFN3uKhdaekDpiNlImDdkUAyiJ6ez/uxGaUSo=
 google.golang.org/genproto/googleapis/api v0.0.0-20231106174013-bbf56f31fb17/go.mod h1:0xJLfVdJqpAPl8tDg1ujOCGzx6LFLttXT5NhllGOXY4=
-google.golang.org/genproto/googleapis/bytestream v0.0.0-20231030173426-d783a09b4405/go.mod h1:GRUCuLdzVqZte8+Dl/D4N25yLzcGqqWaYkeVOwulFqw=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20231016165738-49dd2c1f3d0b/go.mod h1:swOH3j0KzcDDgGUWr+SNpyTen5YrXjS3eyPzFYKc6lc=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20231030173426-d783a09b4405/go.mod h1:67X1fPuzjcrkymZzZV1vvkFeTn2Rvc6lYF9MYFGCcwE=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20231106174013-bbf56f31fb17/go.mod h1:oQ5rr10WTTMvP4A36n8JpR1OrO1BEiV4f78CneXZxkA=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
-google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
-google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
-google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ=
-google.golang.org/grpc v1.57.0/go.mod h1:Sd+9RMTACXwmub0zcNY2c4arhtrbBYD1AUHI/dt16Mo=
-google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/airbrake/gobrake.v2 v2.0.9 h1:7z2uVWwn7oVeeugY1DtlPAy5H+KYgB1KeKTnqjNatLo=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6 h1:jMFz6MfLP0/4fUyZle81rXUoxOBFi19VUFKVDOQfozc=
@@ -1245,13 +1090,9 @@ gopkg.in/resty.v1 v1.12.0 h1:CuXP0Pjfw9rOuY6EP+UvtNvt5DSqHpIxILZKT/quCZI=
 gopkg.in/square/go-jose.v2 v2.5.1 h1:7odma5RETjNHWJnR32wx8t+Io4djHE1PqxCFx3iiZ2w=
 gopkg.in/square/go-jose.v2 v2.5.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
 gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gorm.io/driver/postgres v1.5.0 h1:u2FXTy14l45qc3UeCJ7QaAXZmZfDDv0YrthvmRq1l0U=
-gorm.io/driver/postgres v1.5.0/go.mod h1:FUZXzO+5Uqg5zzwzv4KK49R8lvGIyscBOqYrtI1Ce9A=
-gorm.io/gorm v1.24.7-0.20230306060331-85eaf9eeda11/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
 gotest.tools v1.4.0/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc h1:/hemPrYIhOhy8zYrNj+069zDB68us2sMGsfkFJO0iZs=
 honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
 k8s.io/component-base v0.26.7 h1:uqsOyZh0Zqoaup8tmHa491D/CvgFdGUs+X2H/inNUKM=
@@ -1260,8 +1101,6 @@ k8s.io/cri-api v0.27.1 h1:KWO+U8MfI9drXB/P4oU9VchaWYOlwDglJZVHWMpTT3Q=
 k8s.io/cri-api v0.27.1/go.mod h1:+Ts/AVYbIo04S86XbTD73UPp/DkTiYxtsFeOFEu32L0=
 k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c h1:GohjlNKauSai7gN4wsJkeZ3WAJx4Sh+oT/b5IYn5suA=
 k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E=
-k8s.io/klog/v2 v2.90.1 h1:m4bYOKall2MmOiRaR1J+We67Do7vm9KiQVlT96lnHUw=
-k8s.io/klog/v2 v2.90.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0=
 k8s.io/kms v0.26.7 h1:vruEJNh2IyFnPHbCH8CpUjekHy1HFJtHd/lE2K0lU78=
 k8s.io/kms v0.26.7/go.mod h1:AYuV9ZebRhr6cb1eT9L6kZVxvgIUxmE1Fe6kPhqYvuc=
 kernel.org/pub/linux/libs/security/libcap/cap v1.2.67 h1:sPQ9qlSNR26fToTKbxe/HDWJlXvBLqGmt84LGCQkOy0=

prover/Cargo.toml

@@ -29,8 +29,8 @@ ethers-core = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "
 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 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "v0.10", default-features = false, features = ["parallel_syn", "scroll", "shanghai"] }
-prover_next = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.11.4", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
+prover_curie = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.11.4", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
+prover_darwin = { git = "https://github.com/scroll-tech/zkevm-circuits.git", branch = "feat/agg_recursion", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
 base64 = "0.13.1"
 reqwest = { version = "0.12.4", features = ["gzip"] }
 reqwest-middleware = "0.3"

prover/Makefile

@@ -37,14 +37,10 @@ endif
 
 prover:
 	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo build --release
-	rm -rf ./lib && mkdir ./lib
-	find target/ -name "libzktrie.so" | xargs -I{} cp {} ./lib
 
 tests_binary:
 	cargo clean && cargo test --release --no-run
 	ls target/release/deps/prover* | grep -v "\.d" | xargs -I{} ln -sf {} ./prover.test
-	rm -rf ./lib && mkdir ./lib
-	find target/ -name "libzktrie.so" | xargs -I{} cp {} ./lib
 
 lint:
 	cargo check --all-features

prover/src/config.rs

@@ -2,7 +2,7 @@ use anyhow::{bail, Result};
 use serde::{Deserialize, Serialize};
 use std::fs::File;
 
-use crate::types::ProofType;
+use crate::types::ProverType;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct CircuitConfig {
@@ -24,14 +24,13 @@ pub struct L2GethConfig {
     pub endpoint: String,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Deserialize)]
 pub struct Config {
     pub prover_name: String,
     pub keystore_path: String,
     pub keystore_password: String,
     pub db_path: String,
-    #[serde(default)]
-    pub proof_type: ProofType,
+    pub prover_type: ProverType,
     pub low_version_circuit: CircuitConfig,
     pub high_version_circuit: CircuitConfig,
     pub coordinator: CoordinatorConfig,

prover/src/coordinator_client.rs

@@ -21,6 +21,7 @@ pub struct CoordinatorClient<'a> {
     key_signer: Rc<KeySigner>,
     rt: Runtime,
     listener: Box<dyn Listener>,
+    vks: Vec<String>,
 }
 
 impl<'a> CoordinatorClient<'a> {
@@ -28,6 +29,7 @@ impl<'a> CoordinatorClient<'a> {
         config: &'a Config,
         key_signer: Rc<KeySigner>,
         listener: Box<dyn Listener>,
+        vks: Vec<String>,
     ) -> Result<Self> {
         let rt = tokio::runtime::Builder::new_current_thread()
             .enable_all()
@@ -46,6 +48,7 @@ impl<'a> CoordinatorClient<'a> {
             key_signer,
             rt,
             listener,
+            vks,
         };
         client.login()?;
         Ok(client)
@@ -68,12 +71,15 @@ impl<'a> CoordinatorClient<'a> {
             challenge: token.clone(),
             prover_name: self.config.prover_name.clone(),
             prover_version: crate::version::get_version(),
+            prover_types: vec![self.config.prover_type],
+            vks: self.vks.clone(),
         };
 
-        let buffer = login_message.rlp();
+        let buffer = rlp::encode(&login_message);
         let signature = self.key_signer.sign_buffer(&buffer)?;
         let login_request = LoginRequest {
             message: login_message,
+            public_key: self.key_signer.get_public_key(),
             signature,
         };
         let login_response = self.rt.block_on(api.login(&login_request, &token))?;

prover/src/coordinator_client/types.rs

@@ -1,6 +1,6 @@
 use super::errors::ErrorCode;
-use crate::types::{ProofFailureType, ProofStatus};
-use rlp::RlpStream;
+use crate::types::{ProofFailureType, ProofStatus, ProverType, TaskType};
+use rlp::{Encodable, RlpStream};
 use serde::{Deserialize, Serialize};
 
 #[derive(Deserialize)]
@@ -15,23 +15,36 @@ pub struct LoginMessage {
     pub challenge: String,
     pub prover_name: String,
     pub prover_version: String,
+    pub prover_types: Vec<ProverType>,
+    pub vks: Vec<String>,
 }
 
-impl LoginMessage {
-    pub fn rlp(&self) -> Vec<u8> {
-        let mut rlp = RlpStream::new();
-        let num_fields = 3;
-        rlp.begin_list(num_fields);
-        rlp.append(&self.prover_name);
-        rlp.append(&self.prover_version);
-        rlp.append(&self.challenge);
-        rlp.out().freeze().into()
+impl Encodable for LoginMessage {
+    fn rlp_append(&self, s: &mut RlpStream) {
+        let num_fields = 5;
+        s.begin_list(num_fields);
+        s.append(&self.challenge);
+        s.append(&self.prover_version);
+        s.append(&self.prover_name);
+        // The ProverType in go side is an type alias of uint8
+        // A uint8 slice is treated as a string when doing the rlp encoding
+        let prover_types = self
+            .prover_types
+            .iter()
+            .map(|prover_type: &ProverType| prover_type.to_u8())
+            .collect::<Vec<u8>>();
+        s.append(&prover_types);
+        s.begin_list(self.vks.len());
+        for vk in &self.vks {
+            s.append(vk);
+        }
     }
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct LoginRequest {
     pub message: LoginMessage,
+    pub public_key: String,
     pub signature: String,
 }
 
@@ -45,16 +58,15 @@ pub type ChallengeResponseData = LoginResponseData;
 
 #[derive(Default, Serialize, Deserialize)]
 pub struct GetTaskRequest {
-    pub task_type: crate::types::ProofType,
+    pub task_types: Vec<TaskType>,
     pub prover_height: Option<u64>,
-    pub vks: Vec<String>,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct GetTaskResponseData {
     pub uuid: String,
     pub task_id: String,
-    pub task_type: crate::types::ProofType,
+    pub task_type: TaskType,
     pub task_data: String,
     pub hard_fork_name: String,
 }
@@ -63,12 +75,11 @@ pub struct GetTaskResponseData {
 pub struct SubmitProofRequest {
     pub uuid: String,
     pub task_id: String,
-    pub task_type: crate::types::ProofType,
+    pub task_type: TaskType,
     pub status: ProofStatus,
     pub proof: String,
     pub failure_type: Option<ProofFailureType>,
     pub failure_msg: Option<String>,
-    pub hard_fork_name: String,
 }
 
 #[derive(Serialize, Deserialize)]

prover/src/main.rs

@@ -65,7 +65,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     log::info!(
         "prover start successfully. name: {}, type: {:?}, publickey: {}, version: {}",
         config.prover_name,
-        config.proof_type,
+        config.prover_type,
         prover.get_public_key(),
         version::get_version(),
     );

prover/src/prover.rs

@@ -8,7 +8,8 @@ use crate::{
     coordinator_client::{listener::Listener, types::*, CoordinatorClient},
     geth_client::GethClient,
     key_signer::KeySigner,
-    types::{ProofFailureType, ProofStatus, ProofType},
+    types::{ProofFailureType, ProofStatus, ProverType},
+    utils::get_task_types,
     zk_circuits_handler::{CircuitsHandler, CircuitsHandlerProvider},
 };
 
@@ -24,16 +25,11 @@ pub struct Prover<'a> {
 
 impl<'a> Prover<'a> {
     pub fn new(config: &'a Config, coordinator_listener: Box<dyn Listener>) -> Result<Self> {
-        let proof_type = config.proof_type;
+        let prover_type = config.prover_type;
         let keystore_path = &config.keystore_path;
         let keystore_password = &config.keystore_password;
 
-        let key_signer = Rc::new(KeySigner::new(keystore_path, keystore_password)?);
-        let coordinator_client =
-            CoordinatorClient::new(config, Rc::clone(&key_signer), coordinator_listener)
-                .context("failed to create coordinator_client")?;
-
-        let geth_client = if config.proof_type == ProofType::Chunk {
+        let geth_client = if config.prover_type == ProverType::Chunk {
             Some(Rc::new(RefCell::new(
                 GethClient::new(
                     &config.prover_name,
@@ -45,9 +41,16 @@ impl<'a> Prover<'a> {
             None
         };
 
-        let provider = CircuitsHandlerProvider::new(proof_type, config, geth_client.clone())
+        let provider = CircuitsHandlerProvider::new(prover_type, config, geth_client.clone())
             .context("failed to create circuits handler provider")?;
 
+        let vks = provider.init_vks(prover_type, config, geth_client.clone());
+
+        let key_signer = Rc::new(KeySigner::new(keystore_path, keystore_password)?);
+        let coordinator_client =
+            CoordinatorClient::new(config, Rc::clone(&key_signer), coordinator_listener, vks)
+                .context("failed to create coordinator_client")?;
+
         let prover = Prover {
             config,
             key_signer: Rc::clone(&key_signer),
@@ -59,10 +62,6 @@ impl<'a> Prover<'a> {
         Ok(prover)
     }
 
-    pub fn get_proof_type(&self) -> ProofType {
-        self.config.proof_type
-    }
-
     pub fn get_public_key(&self) -> String {
         self.key_signer.get_public_key()
     }
@@ -70,12 +69,12 @@ impl<'a> Prover<'a> {
     pub fn fetch_task(&self) -> Result<Task> {
         log::info!("[prover] start to fetch_task");
         let mut req = GetTaskRequest {
-            task_type: self.get_proof_type(),
+            task_types: get_task_types(self.config.prover_type),
             prover_height: None,
-            vks: self.circuits_handler_provider.borrow().get_vks(),
+            // vks: self.circuits_handler_provider.borrow().get_vks(),
         };
 
-        if self.get_proof_type() == ProofType::Chunk {
+        if self.config.prover_type == ProverType::Chunk {
             let latest_block_number = self.get_latest_block_number_value()?;
             if let Some(v) = latest_block_number {
                 if v.as_u64() == 0 {
@@ -130,7 +129,6 @@ impl<'a> Prover<'a> {
             task_type: proof_detail.proof_type,
             status: ProofStatus::Ok,
             proof: proof_detail.proof_data,
-            hard_fork_name: task.hard_fork_name.clone(),
             ..Default::default()
         };
 
@@ -151,7 +149,6 @@ impl<'a> Prover<'a> {
             status: ProofStatus::Error,
             failure_type: Some(failure_type),
             failure_msg: Some(error.to_string()),
-            hard_fork_name: task.hard_fork_name.clone(),
             ..Default::default()
         };
         self.do_submit(&request)

prover/src/types.rs

@@ -6,57 +6,107 @@ use crate::coordinator_client::types::GetTaskResponseData;
 pub type CommonHash = H256;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
-pub enum ProofType {
+pub enum TaskType {
     Undefined,
     Chunk,
     Batch,
+    Bundle,
 }
 
-impl ProofType {
+impl TaskType {
     fn from_u8(v: u8) -> Self {
         match v {
-            1 => ProofType::Chunk,
-            2 => ProofType::Batch,
-            _ => ProofType::Undefined,
+            1 => TaskType::Chunk,
+            2 => TaskType::Batch,
+            3 => TaskType::Bundle,
+            _ => TaskType::Undefined,
         }
     }
 }
 
-impl Serialize for ProofType {
+impl Serialize for TaskType {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         match *self {
-            ProofType::Undefined => serializer.serialize_i8(0),
-            ProofType::Chunk => serializer.serialize_i8(1),
-            ProofType::Batch => serializer.serialize_i8(2),
+            TaskType::Undefined => serializer.serialize_u8(0),
+            TaskType::Chunk => serializer.serialize_u8(1),
+            TaskType::Batch => serializer.serialize_u8(2),
+            TaskType::Bundle => serializer.serialize_u8(3),
         }
     }
 }
 
-impl<'de> Deserialize<'de> for ProofType {
+impl<'de> Deserialize<'de> for TaskType {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
         let v: u8 = u8::deserialize(deserializer)?;
-        Ok(ProofType::from_u8(v))
+        Ok(TaskType::from_u8(v))
     }
 }
 
-impl Default for ProofType {
+impl Default for TaskType {
     fn default() -> Self {
         Self::Undefined
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+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")
+            }
+        }
+    }
+
+    pub fn to_u8(self) -> u8 {
+        match self {
+            ProverType::Chunk => 1,
+            ProverType::Batch => 2,
+        }
+    }
+}
+
+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 {
     pub uuid: String,
     pub id: String,
     #[serde(rename = "type", default)]
-    pub task_type: ProofType,
+    pub task_type: TaskType,
     pub task_data: String,
     #[serde(default)]
     pub hard_fork_name: String,
@@ -100,7 +150,7 @@ impl From<Task> for TaskWrapper {
 pub struct ProofDetail {
     pub id: String,
     #[serde(rename = "type", default)]
-    pub proof_type: ProofType,
+    pub proof_type: TaskType,
     pub proof_data: String,
     pub error: String,
 }

prover/src/utils.rs

@@ -1,6 +1,8 @@
 use env_logger::Env;
 use std::{fs::OpenOptions, sync::Once};
 
+use crate::types::{ProverType, TaskType};
+
 static LOG_INIT: Once = Once::new();
 
 /// Initialize log
@@ -21,3 +23,10 @@ pub fn log_init(log_file: Option<String>) {
         builder.init();
     });
 }
+
+pub fn get_task_types(prover_type: ProverType) -> Vec<TaskType> {
+    match prover_type {
+        ProverType::Chunk => vec![TaskType::Chunk],
+        ProverType::Batch => vec![TaskType::Batch, TaskType::Bundle],
+    }
+}

prover/src/zk_circuits_handler.rs

@@ -1,14 +1,15 @@
-mod bernoulli;
 mod curie;
+mod darwin;
 
 use super::geth_client::GethClient;
 use crate::{
     config::{AssetsDirEnvConfig, Config},
-    types::{ProofType, Task},
+    types::{ProverType, Task, TaskType},
+    utils::get_task_types,
 };
 use anyhow::{bail, Result};
-use bernoulli::BaseCircuitsHandler;
-use curie::NextCircuitsHandler;
+use curie::CurieHandler;
+use darwin::DarwinHandler;
 use std::{cell::RefCell, collections::HashMap, rc::Rc};
 
 type HardForkName = String;
@@ -20,38 +21,37 @@ pub mod utils {
 }
 
 pub trait CircuitsHandler {
-    fn get_vk(&self, task_type: ProofType) -> Option<Vec<u8>>;
+    fn get_vk(&self, task_type: TaskType) -> Option<Vec<u8>>;
 
-    fn get_proof_data(&self, task_type: ProofType, task: &Task) -> Result<String>;
+    fn get_proof_data(&self, task_type: TaskType, task: &Task) -> Result<String>;
 }
 
 type CircuitsHandlerBuilder = fn(
-    proof_type: ProofType,
+    prover_type: ProverType,
     config: &Config,
     geth_client: Option<Rc<RefCell<GethClient>>>,
 ) -> Result<Box<dyn CircuitsHandler>>;
 
 pub struct CircuitsHandlerProvider<'a> {
-    proof_type: ProofType,
+    prover_type: ProverType,
     config: &'a Config,
     geth_client: Option<Rc<RefCell<GethClient>>>,
     circuits_handler_builder_map: HashMap<HardForkName, CircuitsHandlerBuilder>,
 
     current_hard_fork_name: Option<HardForkName>,
     current_circuit: Option<Rc<Box<dyn CircuitsHandler>>>,
-    vks: Vec<String>,
 }
 
 impl<'a> CircuitsHandlerProvider<'a> {
     pub fn new(
-        proof_type: ProofType,
+        prover_type: ProverType,
         config: &'a Config,
         geth_client: Option<Rc<RefCell<GethClient>>>,
     ) -> Result<Self> {
         let mut m: HashMap<HardForkName, CircuitsHandlerBuilder> = HashMap::new();
 
         fn handler_builder(
-            proof_type: ProofType,
+            prover_type: ProverType,
             config: &Config,
             geth_client: Option<Rc<RefCell<GethClient>>>,
         ) -> Result<Box<dyn CircuitsHandler>> {
@@ -60,8 +60,8 @@ impl<'a> CircuitsHandlerProvider<'a> {
                 &config.low_version_circuit.hard_fork_name
             );
             AssetsDirEnvConfig::enable_first();
-            BaseCircuitsHandler::new(
-                proof_type,
+            CurieHandler::new(
+                prover_type,
                 &config.low_version_circuit.params_path,
                 &config.low_version_circuit.assets_path,
                 geth_client,
@@ -74,7 +74,7 @@ impl<'a> CircuitsHandlerProvider<'a> {
         );
 
         fn next_handler_builder(
-            proof_type: ProofType,
+            prover_type: ProverType,
             config: &Config,
             geth_client: Option<Rc<RefCell<GethClient>>>,
         ) -> Result<Box<dyn CircuitsHandler>> {
@@ -83,8 +83,8 @@ impl<'a> CircuitsHandlerProvider<'a> {
                 &config.high_version_circuit.hard_fork_name
             );
             AssetsDirEnvConfig::enable_second();
-            NextCircuitsHandler::new(
-                proof_type,
+            DarwinHandler::new(
+                prover_type,
                 &config.high_version_circuit.params_path,
                 &config.high_version_circuit.assets_path,
                 geth_client,
@@ -97,16 +97,13 @@ impl<'a> CircuitsHandlerProvider<'a> {
             next_handler_builder,
         );
 
-        let vks = CircuitsHandlerProvider::init_vks(proof_type, config, &m, geth_client.clone());
-
         let provider = CircuitsHandlerProvider {
-            proof_type,
+            prover_type,
             config,
             geth_client,
             circuits_handler_builder_map: m,
             current_hard_fork_name: None,
             current_circuit: None,
-            vks,
         };
 
         Ok(provider)
@@ -132,7 +129,7 @@ impl<'a> CircuitsHandlerProvider<'a> {
                 );
                 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(self.proof_type, self.config, self.geth_client.clone())
+                    let handler = builder(self.prover_type, self.config, self.geth_client.clone())
                         .expect("failed to build circuits handler");
                     self.current_hard_fork_name = Some(hard_fork_name.clone());
                     let rc_handler = Rc::new(handler);
@@ -146,27 +143,32 @@ impl<'a> CircuitsHandlerProvider<'a> {
         }
     }
 
-    fn init_vks(
-        proof_type: ProofType,
+    pub fn init_vks(
+        &self,
+        prover_type: ProverType,
         config: &'a Config,
-        circuits_handler_builder_map: &HashMap<HardForkName, CircuitsHandlerBuilder>,
         geth_client: Option<Rc<RefCell<GethClient>>>,
     ) -> Vec<String> {
-        circuits_handler_builder_map
+        self.circuits_handler_builder_map
             .iter()
-            .map(|(hard_fork_name, build)| {
-                let handler = build(proof_type, config, geth_client.clone())
+            .flat_map(|(hard_fork_name, build)| {
+                let handler = build(prover_type, config, geth_client.clone())
                     .expect("failed to build circuits handler");
-                let vk = handler
-                    .get_vk(proof_type)
-                    .map_or("".to_string(), utils::encode_vk);
-                log::info!("vk for {hard_fork_name} is {vk}");
-                vk
+
+                get_task_types(prover_type)
+                    .into_iter()
+                    .map(|task_type| {
+                        let vk = handler
+                            .get_vk(task_type)
+                            .map_or("".to_string(), utils::encode_vk);
+                        log::info!(
+                            "vk for {hard_fork_name}, is {vk}, task_type: {:?}",
+                            task_type
+                        );
+                        vk
+                    })
+                    .collect::<Vec<String>>()
             })
             .collect::<Vec<String>>()
     }
-
-    pub fn get_vks(&self) -> Vec<String> {
-        self.vks.clone()
-    }
 }

prover/src/zk_circuits_handler/curie.rs

@@ -1,17 +1,22 @@
 use super::CircuitsHandler;
-use crate::{geth_client::GethClient, types::ProofType};
+use crate::{
+    geth_client::GethClient,
+    types::{ProverType, TaskType},
+};
 use anyhow::{bail, Context, Ok, Result};
+use once_cell::sync::Lazy;
 use serde::Deserialize;
 
 use crate::types::{CommonHash, Task};
-use std::{cell::RefCell, cmp::Ordering, rc::Rc};
+use std::{cell::RefCell, cmp::Ordering, env, rc::Rc};
 
-use prover_next::{
+use prover_curie::{
     aggregator::Prover as BatchProver, check_chunk_hashes, zkevm::Prover as ChunkProver,
     BatchProof, BatchProvingTask, BlockTrace, ChunkInfo, ChunkProof, ChunkProvingTask,
 };
 
-use super::bernoulli::OUTPUT_DIR;
+// Only used for debugging.
+static OUTPUT_DIR: Lazy<Option<String>> = Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
 
 #[derive(Deserialize)]
 pub struct BatchTaskDetail {
@@ -29,33 +34,32 @@ fn get_block_number(block_trace: &BlockTrace) -> Option<u64> {
 }
 
 #[derive(Default)]
-pub struct NextCircuitsHandler {
+pub struct CurieHandler {
     chunk_prover: Option<RefCell<ChunkProver>>,
     batch_prover: Option<RefCell<BatchProver>>,
 
     geth_client: Option<Rc<RefCell<GethClient>>>,
 }
 
-impl NextCircuitsHandler {
+impl CurieHandler {
     pub fn new(
-        proof_type: ProofType,
+        prover_type: ProverType,
         params_dir: &str,
         assets_dir: &str,
         geth_client: Option<Rc<RefCell<GethClient>>>,
     ) -> Result<Self> {
-        match proof_type {
-            ProofType::Chunk => Ok(Self {
+        match prover_type {
+            ProverType::Chunk => Ok(Self {
                 chunk_prover: Some(RefCell::new(ChunkProver::from_dirs(params_dir, assets_dir))),
                 batch_prover: None,
                 geth_client,
             }),
 
-            ProofType::Batch => Ok(Self {
+            ProverType::Batch => Ok(Self {
                 batch_prover: Some(RefCell::new(BatchProver::from_dirs(params_dir, assets_dir))),
                 chunk_prover: None,
                 geth_client,
             }),
-            _ => bail!("proof type invalid"),
         }
     }
 
@@ -186,14 +190,14 @@ impl NextCircuitsHandler {
     }
 }
 
-impl CircuitsHandler for NextCircuitsHandler {
-    fn get_vk(&self, task_type: ProofType) -> Option<Vec<u8>> {
+impl CircuitsHandler for CurieHandler {
+    fn get_vk(&self, task_type: TaskType) -> Option<Vec<u8>> {
         match task_type {
-            ProofType::Chunk => self
+            TaskType::Chunk => self
                 .chunk_prover
                 .as_ref()
                 .and_then(|prover| prover.borrow().get_vk()),
-            ProofType::Batch => self
+            TaskType::Batch => self
                 .batch_prover
                 .as_ref()
                 .and_then(|prover| prover.borrow().get_vk()),
@@ -201,10 +205,10 @@ impl CircuitsHandler for NextCircuitsHandler {
         }
     }
 
-    fn get_proof_data(&self, task_type: ProofType, task: &crate::types::Task) -> Result<String> {
+    fn get_proof_data(&self, task_type: TaskType, task: &crate::types::Task) -> Result<String> {
         match task_type {
-            ProofType::Chunk => self.gen_chunk_proof(task),
-            ProofType::Batch => self.gen_batch_proof(task),
+            TaskType::Chunk => self.gen_chunk_proof(task),
+            TaskType::Batch => self.gen_batch_proof(task),
             _ => unreachable!(),
         }
     }
@@ -216,7 +220,7 @@ impl CircuitsHandler for NextCircuitsHandler {
 mod tests {
     use super::*;
     use crate::zk_circuits_handler::utils::encode_vk;
-    use prover_next::utils::chunk_trace_to_witness_block;
+    use prover_curie::utils::chunk_trace_to_witness_block;
     use std::{path::PathBuf, sync::LazyLock};
 
     #[ctor::ctor]
@@ -251,12 +255,11 @@ mod tests {
 
     #[test]
     fn test_circuits() -> Result<()> {
-        let chunk_handler =
-            NextCircuitsHandler::new(ProofType::Chunk, &PARAMS_PATH, &ASSETS_PATH, None)?;
+        let chunk_handler = CurieHandler::new(ProverType::Chunk, &PARAMS_PATH, &ASSETS_PATH, None)?;
 
-        let chunk_vk = chunk_handler.get_vk(ProofType::Chunk).unwrap();
+        let chunk_vk = chunk_handler.get_vk(TaskType::Chunk).unwrap();
 
-        check_vk(ProofType::Chunk, chunk_vk, "chunk vk must be available");
+        check_vk(TaskType::Chunk, chunk_vk, "chunk vk must be available");
         let chunk_dir_paths = get_chunk_dir_paths()?;
         log::info!("chunk_dir_paths, {:?}", chunk_dir_paths);
         let mut chunk_infos = vec![];
@@ -276,10 +279,9 @@ mod tests {
             chunk_proofs.push(chunk_proof);
         }
 
-        let batch_handler =
-            NextCircuitsHandler::new(ProofType::Batch, &PARAMS_PATH, &ASSETS_PATH, None)?;
-        let batch_vk = batch_handler.get_vk(ProofType::Batch).unwrap();
-        check_vk(ProofType::Batch, batch_vk, "batch vk must be available");
+        let batch_handler = CurieHandler::new(ProverType::Batch, &PARAMS_PATH, &ASSETS_PATH, None)?;
+        let batch_vk = batch_handler.get_vk(TaskType::Batch).unwrap();
+        check_vk(TaskType::Batch, batch_vk, "batch vk must be available");
         let chunk_hashes_proofs = chunk_infos.into_iter().zip(chunk_proofs).collect();
         log::info!("start to prove batch");
         let batch_proof = batch_handler.gen_batch_proof_raw(chunk_hashes_proofs)?;
@@ -289,18 +291,19 @@ mod tests {
         Ok(())
     }
 
-    fn check_vk(proof_type: ProofType, vk: Vec<u8>, info: &str) {
-        log::info!("check_vk, {:?}", proof_type);
-        let vk_from_file = read_vk(proof_type).unwrap();
+    fn check_vk(task_type: TaskType, vk: Vec<u8>, info: &str) {
+        log::info!("check_vk, {:?}", task_type);
+        let vk_from_file = read_vk(task_type).unwrap();
         assert_eq!(vk_from_file, encode_vk(vk), "{info}")
     }
 
-    fn read_vk(proof_type: ProofType) -> Result<String> {
-        log::info!("read_vk, {:?}", proof_type);
-        let vk_file = match proof_type {
-            ProofType::Chunk => CHUNK_VK_PATH.clone(),
-            ProofType::Batch => BATCH_VK_PATH.clone(),
-            ProofType::Undefined => unreachable!(),
+    fn read_vk(task_type: TaskType) -> Result<String> {
+        log::info!("read_vk, {:?}", task_type);
+        let vk_file = match task_type {
+            TaskType::Chunk => CHUNK_VK_PATH.clone(),
+            TaskType::Batch => BATCH_VK_PATH.clone(),
+            TaskType::Bundle => unreachable!(),
+            TaskType::Undefined => unreachable!(),
         };
 
         let data = std::fs::read(vk_file)?;

prover/src/zk_circuits_handler/darwin.rs

@@ -1,27 +1,36 @@
 use super::CircuitsHandler;
-use crate::{geth_client::GethClient, types::ProofType};
-use anyhow::{bail, Ok, Result};
+use crate::{
+    geth_client::GethClient,
+    types::{ProverType, TaskType},
+};
+use anyhow::{bail, Context, Ok, Result};
 use once_cell::sync::Lazy;
 use serde::Deserialize;
 
 use crate::types::{CommonHash, Task};
-use prover::{
-    aggregator::Prover as BatchProver, zkevm::Prover as ChunkProver, BatchProof, BlockTrace,
-    ChunkHash, ChunkProof,
-};
 use std::{cell::RefCell, cmp::Ordering, env, rc::Rc};
 
-// Only used for debugging.
-pub(crate) static OUTPUT_DIR: Lazy<Option<String>> =
-    Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
+use prover_darwin::{
+    aggregator::{Prover as BatchProver, MAX_AGG_SNARKS},
+    check_chunk_hashes,
+    zkevm::Prover as ChunkProver,
+    BatchProof, BatchProvingTask, BlockTrace, BundleProof, BundleProvingTask, ChunkInfo,
+    ChunkProof, ChunkProvingTask,
+};
 
-#[derive(Deserialize)]
+// Only used for debugging.
+static OUTPUT_DIR: Lazy<Option<String>> = Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
+
+#[derive(Debug, Clone, Deserialize)]
 pub struct BatchTaskDetail {
-    pub chunk_infos: Vec<ChunkHash>,
-    pub chunk_proofs: Vec<ChunkProof>,
+    pub chunk_infos: Vec<ChunkInfo>,
+    #[serde(flatten)]
+    pub batch_proving_task: BatchProvingTask,
 }
 
-#[derive(Deserialize)]
+type BundleTaskDetail = BundleProvingTask;
+
+#[derive(Debug, Clone, Deserialize)]
 pub struct ChunkTaskDetail {
     pub block_hashes: Vec<CommonHash>,
 }
@@ -30,44 +39,44 @@ fn get_block_number(block_trace: &BlockTrace) -> Option<u64> {
     block_trace.header.number.map(|n| n.as_u64())
 }
 
-pub struct BaseCircuitsHandler {
+#[derive(Default)]
+pub struct DarwinHandler {
     chunk_prover: Option<RefCell<ChunkProver>>,
     batch_prover: Option<RefCell<BatchProver>>,
 
     geth_client: Option<Rc<RefCell<GethClient>>>,
 }
 
-impl BaseCircuitsHandler {
+impl DarwinHandler {
     pub fn new(
-        proof_type: ProofType,
+        prover_type: ProverType,
         params_dir: &str,
         assets_dir: &str,
         geth_client: Option<Rc<RefCell<GethClient>>>,
     ) -> Result<Self> {
-        match proof_type {
-            ProofType::Chunk => Ok(Self {
+        match prover_type {
+            ProverType::Chunk => Ok(Self {
                 chunk_prover: Some(RefCell::new(ChunkProver::from_dirs(params_dir, assets_dir))),
                 batch_prover: None,
                 geth_client,
             }),
 
-            ProofType::Batch => Ok(Self {
+            ProverType::Batch => Ok(Self {
                 batch_prover: Some(RefCell::new(BatchProver::from_dirs(params_dir, assets_dir))),
                 chunk_prover: None,
                 geth_client,
             }),
-            _ => bail!("proof type invalid"),
         }
     }
 
     fn gen_chunk_proof_raw(&self, chunk_trace: Vec<BlockTrace>) -> Result<ChunkProof> {
         if let Some(prover) = self.chunk_prover.as_ref() {
-            let chunk_proof = prover.borrow_mut().gen_chunk_proof(
-                chunk_trace,
-                None,
-                None,
-                self.get_output_dir(),
-            )?;
+            let chunk = ChunkProvingTask::from(chunk_trace);
+
+            let chunk_proof =
+                prover
+                    .borrow_mut()
+                    .gen_chunk_proof(chunk, None, None, self.get_output_dir())?;
 
             return Ok(chunk_proof);
         }
@@ -80,22 +89,26 @@ impl BaseCircuitsHandler {
         Ok(serde_json::to_string(&chunk_proof)?)
     }
 
-    fn gen_batch_proof_raw(
-        &self,
-        chunk_hashes_proofs: Vec<(ChunkHash, ChunkProof)>,
-    ) -> Result<BatchProof> {
+    fn gen_batch_proof_raw(&self, batch_task_detail: BatchTaskDetail) -> Result<BatchProof> {
         if let Some(prover) = self.batch_prover.as_ref() {
+            let chunk_hashes_proofs: Vec<(ChunkInfo, ChunkProof)> = batch_task_detail
+                .chunk_infos
+                .clone()
+                .into_iter()
+                .zip(batch_task_detail.batch_proving_task.chunk_proofs.clone())
+                .collect();
+
             let chunk_proofs: Vec<ChunkProof> =
                 chunk_hashes_proofs.iter().map(|t| t.1.clone()).collect();
 
-            let is_valid = prover.borrow_mut().check_chunk_proofs(&chunk_proofs);
+            let is_valid = prover.borrow_mut().check_protocol_of_chunks(&chunk_proofs);
 
             if !is_valid {
                 bail!("non-match chunk protocol")
             }
-
-            let batch_proof = prover.borrow_mut().gen_agg_evm_proof(
-                chunk_hashes_proofs,
+            check_chunk_hashes("", &chunk_hashes_proofs).context("failed to check chunk info")?;
+            let batch_proof = prover.borrow_mut().gen_batch_proof::<MAX_AGG_SNARKS>(
+                batch_task_detail.batch_proving_task,
                 None,
                 self.get_output_dir(),
             )?;
@@ -107,12 +120,32 @@ impl BaseCircuitsHandler {
 
     fn gen_batch_proof(&self, task: &crate::types::Task) -> Result<String> {
         log::info!("[circuit] gen_batch_proof for task {}", task.id);
-        let chunk_hashes_proofs: Vec<(ChunkHash, ChunkProof)> =
-            self.gen_chunk_hashes_proofs(task)?;
-        let batch_proof = self.gen_batch_proof_raw(chunk_hashes_proofs)?;
+
+        let batch_task_detail: BatchTaskDetail = serde_json::from_str(&task.task_data)?;
+        let batch_proof = self.gen_batch_proof_raw(batch_task_detail)?;
         Ok(serde_json::to_string(&batch_proof)?)
     }
 
+    fn gen_bundle_proof_raw(&self, bundle_task_detail: BundleTaskDetail) -> Result<BundleProof> {
+        if let Some(prover) = self.batch_prover.as_ref() {
+            let bundle_proof = prover.borrow_mut().gen_bundle_proof(
+                bundle_task_detail,
+                None,
+                self.get_output_dir(),
+            )?;
+
+            return Ok(bundle_proof);
+        }
+        unreachable!("please check errors in proof_type logic")
+    }
+
+    fn gen_bundle_proof(&self, task: &crate::types::Task) -> Result<String> {
+        log::info!("[circuit] gen_bundle_proof for task {}", task.id);
+        let bundle_task_detail: BundleTaskDetail = serde_json::from_str(&task.task_data)?;
+        let bundle_proof = self.gen_bundle_proof_raw(bundle_task_detail)?;
+        Ok(serde_json::to_string(&bundle_proof)?)
+    }
+
     fn get_output_dir(&self) -> Option<&str> {
         OUTPUT_DIR.as_deref()
     }
@@ -122,17 +155,6 @@ impl BaseCircuitsHandler {
         self.get_sorted_traces_by_hashes(&chunk_task_detail.block_hashes)
     }
 
-    fn gen_chunk_hashes_proofs(&self, task: &Task) -> Result<Vec<(ChunkHash, ChunkProof)>> {
-        let batch_task_detail: BatchTaskDetail = serde_json::from_str(&task.task_data)?;
-
-        Ok(batch_task_detail
-            .chunk_infos
-            .clone()
-            .into_iter()
-            .zip(batch_task_detail.chunk_proofs.clone())
-            .collect())
-    }
-
     fn get_sorted_traces_by_hashes(&self, block_hashes: &[CommonHash]) -> Result<Vec<BlockTrace>> {
         if block_hashes.is_empty() {
             log::error!("[prover] failed to get sorted traces: block_hashes are empty");
@@ -187,25 +209,30 @@ impl BaseCircuitsHandler {
     }
 }
 
-impl CircuitsHandler for BaseCircuitsHandler {
-    fn get_vk(&self, task_type: ProofType) -> Option<Vec<u8>> {
+impl CircuitsHandler for DarwinHandler {
+    fn get_vk(&self, task_type: TaskType) -> Option<Vec<u8>> {
         match task_type {
-            ProofType::Chunk => self
+            TaskType::Chunk => self
                 .chunk_prover
                 .as_ref()
                 .and_then(|prover| prover.borrow().get_vk()),
-            ProofType::Batch => self
+            TaskType::Batch => self
                 .batch_prover
                 .as_ref()
-                .and_then(|prover| prover.borrow().get_vk()),
+                .and_then(|prover| prover.borrow().get_batch_vk()),
+            TaskType::Bundle => self
+                .batch_prover
+                .as_ref()
+                .and_then(|prover| prover.borrow().get_bundle_vk()),
             _ => unreachable!(),
         }
     }
 
-    fn get_proof_data(&self, task_type: ProofType, task: &crate::types::Task) -> Result<String> {
+    fn get_proof_data(&self, task_type: TaskType, task: &crate::types::Task) -> Result<String> {
         match task_type {
-            ProofType::Chunk => self.gen_chunk_proof(task),
-            ProofType::Batch => self.gen_batch_proof(task),
+            TaskType::Chunk => self.gen_chunk_proof(task),
+            TaskType::Batch => self.gen_batch_proof(task),
+            TaskType::Bundle => self.gen_bundle_proof(task),
             _ => unreachable!(),
         }
     }
@@ -217,7 +244,7 @@ impl CircuitsHandler for BaseCircuitsHandler {
 mod tests {
     use super::*;
     use crate::zk_circuits_handler::utils::encode_vk;
-    use prover::utils::chunk_trace_to_witness_block;
+    use prover_darwin::utils::chunk_trace_to_witness_block;
     use std::{path::PathBuf, sync::LazyLock};
 
     #[ctor::ctor]
@@ -228,7 +255,7 @@ mod tests {
 
     static DEFAULT_WORK_DIR: &str = "/assets";
     static WORK_DIR: LazyLock<String> = LazyLock::new(|| {
-        std::env::var("BERNOULLI_TEST_DIR")
+        std::env::var("CURIE_TEST_DIR")
             .unwrap_or(String::from(DEFAULT_WORK_DIR))
             .trim_end_matches('/')
             .to_string()
@@ -253,11 +280,11 @@ mod tests {
     #[test]
     fn test_circuits() -> Result<()> {
         let chunk_handler =
-            BaseCircuitsHandler::new(ProofType::Chunk, &PARAMS_PATH, &ASSETS_PATH, None)?;
+            DarwinHandler::new(ProverType::Chunk, &PARAMS_PATH, &ASSETS_PATH, None)?;
 
-        let chunk_vk = chunk_handler.get_vk(ProofType::Chunk).unwrap();
+        let chunk_vk = chunk_handler.get_vk(TaskType::Chunk).unwrap();
 
-        check_vk(ProofType::Chunk, chunk_vk, "chunk vk must be available");
+        check_vk(TaskType::Chunk, chunk_vk, "chunk vk must be available");
         let chunk_dir_paths = get_chunk_dir_paths()?;
         log::info!("chunk_dir_paths, {:?}", chunk_dir_paths);
         let mut chunk_infos = vec![];
@@ -278,30 +305,44 @@ mod tests {
         }
 
         let batch_handler =
-            BaseCircuitsHandler::new(ProofType::Batch, &PARAMS_PATH, &ASSETS_PATH, None)?;
-        let batch_vk = batch_handler.get_vk(ProofType::Batch).unwrap();
-        check_vk(ProofType::Batch, batch_vk, "batch vk must be available");
-        let chunk_hashes_proofs = chunk_infos.into_iter().zip(chunk_proofs).collect();
+            DarwinHandler::new(ProverType::Batch, &PARAMS_PATH, &ASSETS_PATH, None)?;
+        let batch_vk = batch_handler.get_vk(TaskType::Batch).unwrap();
+        check_vk(TaskType::Batch, batch_vk, "batch vk must be available");
+        let batch_task_detail = make_batch_task_detail(chunk_infos, chunk_proofs);
         log::info!("start to prove batch");
-        let batch_proof = batch_handler.gen_batch_proof_raw(chunk_hashes_proofs)?;
+        let batch_proof = batch_handler.gen_batch_proof_raw(batch_task_detail)?;
         let proof_data = serde_json::to_string(&batch_proof)?;
         dump_proof("batch_proof".to_string(), proof_data)?;
 
         Ok(())
     }
 
-    fn check_vk(proof_type: ProofType, vk: Vec<u8>, info: &str) {
+    fn make_batch_task_detail(_: Vec<ChunkInfo>, _: Vec<ChunkProof>) -> BatchTaskDetail {
+        todo!();
+        // BatchTaskDetail {
+        //     chunk_infos,
+        //     batch_proving_task: BatchProvingTask {
+        //         parent_batch_hash: todo!(),
+        //         parent_state_root: todo!(),
+        //         batch_header: todo!(),
+        //         chunk_proofs,
+        //     },
+        // }
+    }
+
+    fn check_vk(proof_type: TaskType, vk: Vec<u8>, info: &str) {
         log::info!("check_vk, {:?}", proof_type);
         let vk_from_file = read_vk(proof_type).unwrap();
         assert_eq!(vk_from_file, encode_vk(vk), "{info}")
     }
 
-    fn read_vk(proof_type: ProofType) -> Result<String> {
+    fn read_vk(proof_type: TaskType) -> Result<String> {
         log::info!("read_vk, {:?}", proof_type);
         let vk_file = match proof_type {
-            ProofType::Chunk => CHUNK_VK_PATH.clone(),
-            ProofType::Batch => BATCH_VK_PATH.clone(),
-            ProofType::Undefined => unreachable!(),
+            TaskType::Chunk => CHUNK_VK_PATH.clone(),
+            TaskType::Batch => BATCH_VK_PATH.clone(),
+            TaskType::Bundle => todo!(),
+            TaskType::Undefined => unreachable!(),
         };
 
         let data = std::fs::read(vk_file)?;
@@ -375,9 +416,9 @@ mod tests {
         Ok(files.into_iter().map(|f| batch_path.join(f)).collect())
     }
 
-    fn traces_to_chunk_info(chunk_trace: Vec<BlockTrace>) -> Result<ChunkHash> {
+    fn traces_to_chunk_info(chunk_trace: Vec<BlockTrace>) -> Result<ChunkInfo> {
         let witness_block = chunk_trace_to_witness_block(chunk_trace)?;
-        Ok(ChunkHash::from_witness_block(&witness_block, false))
+        Ok(ChunkInfo::from_witness_block(&witness_block, false))
     }
 
     fn dump_proof(id: String, proof_data: String) -> Result<()> {

rollup/Makefile

@@ -1,20 +1,17 @@
-.PHONY: mock_abi libzstd rollup_bins event_watcher gas_oracle rollup_relayer test lint clean docker
+.PHONY: mock_abi libzstd rollup_bins gas_oracle rollup_relayer test lint clean docker
 
 IMAGE_VERSION=latest
 REPO_ROOT_DIR=./..
 
 mock_abi:
+	git submodule update --init --recursive
 	cd .. && solc --evm-version cancun --bin --abi --optimize --overwrite -o ./build/bin ./rollup/mock_bridge/MockBridge.sol
 	cd .. && go run github.com/scroll-tech/go-ethereum/cmd/abigen --bin=./build/bin/MockBridge.bin --abi=./build/bin/MockBridge.abi --pkg=mock_bridge --out=./rollup/mock_bridge/MockBridge.go
 
 rollup_bins: ## Builds the Rollup bins.
-	go build -o $(PWD)/build/bin/event_watcher ./cmd/event_watcher/
 	go build -o $(PWD)/build/bin/gas_oracle ./cmd/gas_oracle/
 	go build -o $(PWD)/build/bin/rollup_relayer ./cmd/rollup_relayer/
 
-event_watcher: ## Builds the event_watcher bin
-	go build -o $(PWD)/build/bin/event_watcher ./cmd/event_watcher/
-
 gas_oracle: ## Builds the gas_oracle bin
 	go build -o $(PWD)/build/bin/gas_oracle ./cmd/gas_oracle/
 
@@ -32,10 +29,8 @@ clean: ## Empty out the bin folder
 
 docker_push:
 	docker push scrolltech/gas-oracle:${IMAGE_VERSION}
-	docker push scrolltech/event-watcher:${IMAGE_VERSION}
 	docker push scrolltech/rollup-relayer:${IMAGE_VERSION}
 
 docker:
 	DOCKER_BUILDKIT=1 docker build -t scrolltech/gas-oracle:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/gas_oracle.Dockerfile
-	DOCKER_BUILDKIT=1 docker build -t scrolltech/event-watcher:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/event_watcher.Dockerfile
 	DOCKER_BUILDKIT=1 docker build -t scrolltech/rollup-relayer:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/rollup_relayer.Dockerfile

rollup/README.md

@@ -1,7 +1,6 @@
 # Rollup
 
 This directory contains the three essential rollup services for the Scroll chain:
-- Event Watcher (<a href="./cmd/event_watcher/">event_watcher</a>): watches the events emitted from the L1 and L2 contracts and updates the event database.
 - Gas Oracle (<a href="./cmd/gas_oracle/">gas_oracle</a>): monitors the L1 and L2 gas price and sends transactions to update the gas price oracle contracts on L1 and L2.
 - Rollup Relayer (<a href="./cmd/rollup_relayer/">rollup_relayer</a>): consists of three components: chunk and batch proposer and a relayer.
     - The chunk and batch proposer proposes new chunks and batches that sends Commit Transactions for data availability and Finalize Transactions for proof verification and state finalization.
@@ -31,7 +30,6 @@ make rollup_bins
 (Note: make sure you use different private keys for different senders in config.json.)
 
 ```bash
-./build/bin/event_watcher --config ./conf/config.json
 ./build/bin/gas_oracle --config ./conf/config.json
 ./build/bin/rollup_relayer --config ./conf/config.json
 ```

rollup/abi/bridge_abi_test.go

@@ -8,32 +8,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestEventSignature(t *testing.T) {
-	assert := assert.New(t)
-
-	assert.Equal(L1CommitBatchEventSignature, common.HexToHash("2c32d4ae151744d0bf0b9464a3e897a1d17ed2f1af71f7c9a75f12ce0d28238f"))
-	assert.Equal(L1FinalizeBatchEventSignature, common.HexToHash("26ba82f907317eedc97d0cbef23de76a43dd6edb563bdb6e9407645b950a7a2d"))
-
-	assert.Equal(L2SentMessageEventSignature, common.HexToHash("104371f3b442861a2a7b82a070afbbaab748bb13757bf47769e170e37809ec1e"))
-	assert.Equal(L2RelayedMessageEventSignature, common.HexToHash("4641df4a962071e12719d8c8c8e5ac7fc4d97b927346a3d7a335b1f7517e133c"))
-	assert.Equal(L2FailedRelayedMessageEventSignature, common.HexToHash("99d0e048484baa1b1540b1367cb128acd7ab2946d1ed91ec10e3c85e4bf51b8f"))
-
-	assert.Equal(L2AppendMessageEventSignature, common.HexToHash("faa617c2d8ce12c62637dbce76efcc18dae60574aa95709bdcedce7e76071693"))
-}
-
-func TestPackRelayL2MessageWithProof(t *testing.T) {
-	assert := assert.New(t)
-	l1MessengerABI, err := L1ScrollMessengerMetaData.GetAbi()
-	assert.NoError(err)
-
-	proof := IL1ScrollMessengerL2MessageProof{
-		BatchIndex:  big.NewInt(0),
-		MerkleProof: []byte{},
-	}
-	_, err = l1MessengerABI.Pack("relayMessageWithProof", common.Address{}, common.Address{}, big.NewInt(0), big.NewInt(0), []byte{}, proof)
-	assert.NoError(err)
-}
-
 func TestPackCommitBatch(t *testing.T) {
 	assert := assert.New(t)
 
@@ -78,16 +52,6 @@ func TestPackImportGenesisBatch(t *testing.T) {
 	assert.NoError(err)
 }
 
-func TestPackRelayL1Message(t *testing.T) {
-	assert := assert.New(t)
-
-	l2MessengerABI, err := L2ScrollMessengerMetaData.GetAbi()
-	assert.NoError(err)
-
-	_, err = l2MessengerABI.Pack("relayMessage", common.Address{}, common.Address{}, big.NewInt(0), big.NewInt(0), []byte{})
-	assert.NoError(err)
-}
-
 func TestPackSetL1BaseFee(t *testing.T) {
 	assert := assert.New(t)
 

rollup/abi/build_abi.sh

@@ -24,7 +24,7 @@ gen_name=("L1GatewayRouter" "L2GatewayRouter" "L1ScrollMessenger" "L2ScrollMesse
 for i in "${!abi_name[@]}"; do
   mkdir -p tmp
   abi="tmp/${abi_name[$i]}.json"
-  cat ../contracts/artifacts/src/${abi_name[$i]}.sol/${abi_name[$i]}.json | jq '.abi' > $abi
+  cat ../scroll-contracts/artifacts/src/${abi_name[$i]}.sol/${abi_name[$i]}.json | jq '.abi' > $abi
   pkg="${pkg_name[$i]}_abi"
   out="contracts/${pkg}/${gen_name[$i]}.go"
   echo "generating ${out} from ${abi}"

rollup/cmd/event_watcher/app/app.go

@@ -1,97 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/signal"
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/urfave/cli/v2"
-
-	"scroll-tech/common/database"
-	"scroll-tech/common/observability"
-	"scroll-tech/common/utils"
-	"scroll-tech/common/version"
-
-	"scroll-tech/rollup/internal/config"
-	"scroll-tech/rollup/internal/controller/watcher"
-)
-
-var app *cli.App
-
-func init() {
-	// Set up event-watcher app info.
-	app = cli.NewApp()
-	app.Action = action
-	app.Name = "event-watcher"
-	app.Usage = "The Scroll Event Watcher"
-	app.Version = version.Version
-	app.Flags = append(app.Flags, utils.CommonFlags...)
-	app.Commands = []*cli.Command{}
-	app.Before = func(ctx *cli.Context) error {
-		return utils.LogSetup(ctx)
-	}
-	// Register `event-watcher-test` app for integration-test.
-	utils.RegisterSimulation(app, utils.EventWatcherApp)
-}
-
-func action(ctx *cli.Context) error {
-	// Load config file.
-	cfgFile := ctx.String(utils.ConfigFileFlag.Name)
-	cfg, err := config.NewConfig(cfgFile)
-	if err != nil {
-		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
-	}
-
-	subCtx, cancel := context.WithCancel(ctx.Context)
-	// Init db connection
-	db, err := database.InitDB(cfg.DBConfig)
-	if err != nil {
-		log.Crit("failed to init db connection", "err", err)
-	}
-	defer func() {
-		cancel()
-		if err = database.CloseDB(db); err != nil {
-			log.Crit("failed to close db connection", "error", err)
-		}
-	}()
-
-	registry := prometheus.DefaultRegisterer
-	observability.Server(ctx, db)
-	l1client, err := ethclient.Dial(cfg.L1Config.Endpoint)
-	if err != nil {
-		log.Crit("failed to connect l1 geth", "config file", cfgFile, "error", err)
-	}
-
-	l1watcher := watcher.NewL1WatcherClient(ctx.Context, l1client, cfg.L1Config.StartHeight, cfg.L1Config.Confirmations,
-		cfg.L1Config.L1MessageQueueAddress, cfg.L1Config.ScrollChainContractAddress, db, registry)
-
-	go utils.Loop(subCtx, 10*time.Second, func() {
-		if loopErr := l1watcher.FetchContractEvent(); loopErr != nil {
-			log.Error("Failed to fetch bridge contract", "err", loopErr)
-		}
-	})
-
-	log.Info("Start event-watcher successfully", "version", version.Version)
-
-	// Catch CTRL-C to ensure a graceful shutdown.
-	interrupt := make(chan os.Signal, 1)
-	signal.Notify(interrupt, os.Interrupt)
-
-	// Wait until the interrupt signal is received from an OS signal.
-	<-interrupt
-
-	return nil
-}
-
-// Run event watcher cmd instance.
-func Run() {
-	if err := app.Run(os.Args); err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}

rollup/cmd/event_watcher/main.go

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

rollup/cmd/gas_oracle/app/app.go

@@ -84,7 +84,7 @@ func action(ctx *cli.Context) error {
 		log.Crit("failed to read genesis", "genesis file", genesisPath, "error", err)
 	}
 
-	l1watcher := watcher.NewL1WatcherClient(ctx.Context, l1client, cfg.L1Config.StartHeight, cfg.L1Config.Confirmations, cfg.L1Config.L1MessageQueueAddress, cfg.L1Config.ScrollChainContractAddress, db, registry)
+	l1watcher := watcher.NewL1WatcherClient(ctx.Context, l1client, cfg.L1Config.StartHeight, db, registry)
 
 	l1relayer, err := relayer.NewLayer1Relayer(ctx.Context, db, cfg.L1Config.RelayerConfig, genesis.Config, relayer.ServiceTypeL1GasOracle, registry)
 	if err != nil {

rollup/cmd/mock_app.go

@@ -45,10 +45,7 @@ func NewRollupApp(testApps *testcontainers.TestcontainerApps, file string) *Mock
 
 // RunApp run rollup-test child process by multi parameters.
 func (b *MockApp) RunApp(t *testing.T, name utils.MockAppName, args ...string) {
-	if !(name == utils.EventWatcherApp ||
-		name == utils.GasOracleApp ||
-		name == utils.MessageRelayerApp ||
-		name == utils.RollupRelayerApp) {
+	if !(name == utils.GasOracleApp || name == utils.RollupRelayerApp) {
 		t.Errorf(fmt.Sprintf("Don't support the mock app, name: %s", name))
 		return
 	}

rollup/conf/config.json

@@ -1,9 +1,6 @@
 {
   "l1_config": {
-    "confirmations": "0x6",
     "endpoint": "https://rpc.ankr.com/eth",
-    "l1_message_queue_address": "0x0000000000000000000000000000000000000000",
-    "scroll_chain_address": "0x0000000000000000000000000000000000000000",
     "start_height": 0,
     "relayer_config": {
       "gas_price_oracle_address": "0x0000000000000000000000000000000000000000",
@@ -58,6 +55,7 @@
       },
       "enable_test_env_bypass_features": true,
       "finalize_batch_without_proof_timeout_sec": 7200,
+      "finalize_bundle_without_proof_timeout_sec": 7200,
       "gas_oracle_sender_private_key": "1313131313131313131313131313131313131313131313131313131313131313",
       "commit_sender_private_key": "1414141414141414141414141414141414141414141414141414141414141414",
       "finalize_sender_private_key": "1515151515151515151515151515151515151515151515151515151515151515",
@@ -79,6 +77,10 @@
       "batch_timeout_sec": 300,
       "gas_cost_increase_multiplier": 1.2,
       "max_uncompressed_batch_bytes_size": 634880
+    },
+    "bundle_proposer_config": {
+      "max_batch_num_per_bundle": 20,
+      "bundle_timeout_sec": 36000
     }
   },
   "db_config": {

rollup/go.mod

@@ -10,8 +10,8 @@ require (
 	github.com/go-resty/resty/v2 v2.7.0
 	github.com/holiman/uint256 v1.2.4
 	github.com/prometheus/client_golang v1.16.0
-	github.com/scroll-tech/da-codec v0.1.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240426041101-a860446ebaea
+	github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
@@ -84,7 +84,6 @@ require (
 	github.com/prometheus/tsdb v0.7.1 // indirect
 	github.com/rivo/uniseg v0.4.4 // indirect
 	github.com/rjeczalik/notify v0.9.1 // indirect
-	github.com/rogpeppe/go-internal v1.12.0 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect

rollup/go.sum

@@ -230,16 +230,16 @@ github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeCE=
 github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
-github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
-github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.0 h1:osgX8MwP4jGHVlR9TpGjkzmiochCneyuB1Z/VUFGyXg=
-github.com/scroll-tech/da-codec v0.1.0/go.mod h1:1wWYii0OPwd5kw+xrz0PFgS420xNadrNF1x/ELJT+TM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240426041101-a860446ebaea h1:CH1WXWrpEpLaP3N+bFs2a1xdE0+lRm1AuJQb5YvE6Ls=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240426041101-a860446ebaea/go.mod h1:i4VBgWoaW/y0D8MmQb7hSOulyw1dKhuiSFAbznwivCA=
+github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7 h1:Mx3fKRszn6CMeJ7YBTdjLSfXoSDd9hkP8BwhIaaUVfQ=
+github.com/scroll-tech/da-codec v0.0.0-20240703091800-5b6cded48ab7/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=

rollup/internal/config/l1.go

@@ -1,22 +1,11 @@
 package config
 
-import (
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/rpc"
-)
-
 // L1Config loads l1eth configuration items.
 type L1Config struct {
-	// Confirmations block height confirmations number.
-	Confirmations rpc.BlockNumber `json:"confirmations"`
 	// l1 eth node url.
 	Endpoint string `json:"endpoint"`
 	// The start height to sync event from layer 1
 	StartHeight uint64 `json:"start_height"`
-	// The L1MessageQueue contract address deployed on layer 1 chain.
-	L1MessageQueueAddress common.Address `json:"l1_message_queue_address"`
-	// The ScrollChain contract address deployed on layer 1 chain.
-	ScrollChainContractAddress common.Address `json:"scroll_chain_address"`
 	// The relayer config
 	RelayerConfig *RelayerConfig `json:"relayer_config"`
 }

rollup/internal/config/l2.go

@@ -22,6 +22,8 @@ type L2Config struct {
 	ChunkProposerConfig *ChunkProposerConfig `json:"chunk_proposer_config"`
 	// The batch_proposer config
 	BatchProposerConfig *BatchProposerConfig `json:"batch_proposer_config"`
+	// The bundle_proposer config
+	BundleProposerConfig *BatchProposerConfig `json:"bundle_proposer_config"`
 }
 
 // ChunkProposerConfig loads chunk_proposer configuration items.
@@ -44,3 +46,9 @@ type BatchProposerConfig struct {
 	GasCostIncreaseMultiplier       float64 `json:"gas_cost_increase_multiplier"`
 	MaxUncompressedBatchBytesSize   uint64  `json:"max_uncompressed_batch_bytes_size"`
 }
+
+// BundleProposerConfig loads bundle_proposer configuration items.
+type BundleProposerConfig struct {
+	MaxBatchNumPerBundle uint64 `json:"max_batch_num_per_bundle"`
+	BundleTimeoutSec     uint64 `json:"bundle_timeout_sec"`
+}

rollup/internal/config/relayer.go

@@ -66,6 +66,8 @@ type RelayerConfig struct {
 	EnableTestEnvBypassFeatures bool `json:"enable_test_env_bypass_features"`
 	// The timeout in seconds for finalizing a batch without proof, only used when EnableTestEnvBypassFeatures is true.
 	FinalizeBatchWithoutProofTimeoutSec uint64 `json:"finalize_batch_without_proof_timeout_sec"`
+	// The timeout in seconds for finalizing a bundle without proof, only used when EnableTestEnvBypassFeatures is true.
+	FinalizeBundleWithoutProofTimeoutSec uint64 `json:"finalize_bundle_without_proof_timeout_sec"`
 }
 
 // GasOracleConfig The config for updating gas price oracle.

rollup/internal/controller/relayer/l1_relayer.go

@@ -21,12 +21,9 @@ import (
 	"scroll-tech/rollup/internal/orm"
 )
 
-// Layer1Relayer is responsible for
-//  1. fetch pending L1Message from db
-//  2. relay pending message to layer 2 node
+// Layer1Relayer is responsible for updating L1 gas price oracle contract on L2.
 //
-// Actions are triggered by new head from layer 1 geth node.
-// @todo It's better to be triggered by watcher.
+// Actions are triggered by L1 watcher.
 type Layer1Relayer struct {
 	ctx context.Context
 

rollup/internal/controller/relayer/l2_relayer.go

@@ -2,9 +2,11 @@ package relayer
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"math/big"
 	"sort"
+	"strings"
 	"time"
 
 	"github.com/go-resty/resty/v2"
@@ -13,6 +15,7 @@ import (
 	"github.com/scroll-tech/da-codec/encoding/codecv0"
 	"github.com/scroll-tech/da-codec/encoding/codecv1"
 	"github.com/scroll-tech/da-codec/encoding/codecv2"
+	"github.com/scroll-tech/da-codec/encoding/codecv3"
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
 	"github.com/scroll-tech/go-ethereum/common"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
@@ -34,13 +37,16 @@ import (
 	rutils "scroll-tech/rollup/internal/utils"
 )
 
-// Layer2Relayer is responsible for committing and finalizing L2 blocks on L1.
+// Layer2Relayer is responsible for:
+// i. committing and finalizing L2 blocks on L1.
+// ii. updating L2 gas price oracle contract on L1.
 type Layer2Relayer struct {
 	ctx context.Context
 
 	l2Client *ethclient.Client
 
 	db         *gorm.DB
+	bundleOrm  *orm.Bundle
 	batchOrm   *orm.Batch
 	chunkOrm   *orm.Chunk
 	l2BlockOrm *orm.L2Block
@@ -120,6 +126,7 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		ctx: ctx,
 		db:  db,
 
+		bundleOrm:  orm.NewBundle(db),
 		batchOrm:   orm.NewBatch(db),
 		l2BlockOrm: orm.NewL2Block(db),
 		chunkOrm:   orm.NewChunk(db),
@@ -383,12 +390,18 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 				log.Error("failed to construct commitBatch payload codecv1", "index", dbBatch.Index, "err", err)
 				return
 			}
-		} else { // codecv2
+		} else if !r.chainCfg.IsDarwin(dbChunks[0].StartBlockTime) { // codecv2
 			calldata, blob, err = r.constructCommitBatchPayloadCodecV2(dbBatch, dbParentBatch, dbChunks, chunks)
 			if err != nil {
 				log.Error("failed to construct commitBatch payload codecv2", "index", dbBatch.Index, "err", err)
 				return
 			}
+		} else { // codecv3
+			calldata, blob, err = r.constructCommitBatchPayloadCodecV3(dbBatch, dbParentBatch, dbChunks, chunks)
+			if err != nil {
+				log.Error("failed to construct commitBatch payload codecv3", "index", dbBatch.Index, "err", err)
+				return
+			}
 		}
 
 		// fallbackGasLimit is non-zero only in sending non-blob transactions.
@@ -407,14 +420,7 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 				"hash", dbBatch.Hash,
 				"RollupContractAddress", r.cfg.RollupContractAddress,
 				"err", err,
-			)
-			log.Debug(
-				"Failed to send commitBatch tx to layer1",
-				"index", dbBatch.Index,
-				"hash", dbBatch.Hash,
-				"RollupContractAddress", r.cfg.RollupContractAddress,
 				"calldata", common.Bytes2Hex(calldata),
-				"err", err,
 			)
 			return
 		}
@@ -494,8 +500,49 @@ func (r *Layer2Relayer) ProcessCommittedBatches() {
 	}
 }
 
+// ProcessPendingBundles submits proof to layer 1 rollup contract
+func (r *Layer2Relayer) ProcessPendingBundles() {
+	r.metrics.rollupL2RelayerProcessPendingBundlesTotal.Inc()
+
+	bundle, err := r.bundleOrm.GetFirstPendingBundle(r.ctx)
+	if err != nil {
+		log.Error("Failed to fetch first pending L2 bundle", "err", err)
+		return
+	}
+	status := types.ProvingStatus(bundle.ProvingStatus)
+	switch status {
+	case types.ProvingTaskUnassigned, types.ProvingTaskAssigned:
+		if r.cfg.EnableTestEnvBypassFeatures && utils.NowUTC().Sub(bundle.CreatedAt) > time.Duration(r.cfg.FinalizeBundleWithoutProofTimeoutSec)*time.Second {
+			if err := r.finalizeBundle(bundle, false); err != nil {
+				log.Error("Failed to finalize timeout bundle without proof", "index", bundle.Index, "start batch index", bundle.StartBatchIndex, "end batch index", bundle.EndBatchIndex, "err", err)
+			}
+		}
+
+	case types.ProvingTaskVerified:
+		log.Info("Start to roll up zk proof", "hash", bundle.Hash)
+		r.metrics.rollupL2RelayerProcessPendingBundlesFinalizedTotal.Inc()
+		if err := r.finalizeBundle(bundle, true); err != nil {
+			log.Error("Failed to finalize bundle with proof", "index", bundle.Index, "start batch index", bundle.StartBatchIndex, "end batch index", bundle.EndBatchIndex, "err", err)
+		}
+
+	case types.ProvingTaskFailed:
+		// We were unable to prove this bundle. There are two possibilities:
+		// (a) Prover bug. In this case, we should fix and redeploy the prover.
+		//     In the meantime, we continue to commit batches to L1 as well as
+		//     proposing and proving chunks, batches and bundles.
+		// (b) Unprovable bundle, e.g. proof overflow. In this case we need to
+		//     stop the ledger, fix the limit, revert all the violating blocks,
+		//     chunks, batches, bundles and all subsequent ones, and resume,
+		//     i.e. this case requires manual resolution.
+		log.Error("bundle proving failed", "index", bundle.Index, "hash", bundle.Hash, "prover assigned at", bundle.ProverAssignedAt, "proved at", bundle.ProvedAt, "proof time sec", bundle.ProofTimeSec)
+
+	default:
+		log.Error("encounter unreachable case in ProcessPendingBundles", "proving status", status)
+	}
+}
+
 func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error {
-	// Check batch status before send `finalizeBatch` tx.
+	// Check batch status before sending `finalizeBatch` tx.
 	if r.cfg.ChainMonitor.Enabled {
 		var batchStatus bool
 		batchStatus, err := r.getBatchStatusByIndex(dbBatch)
@@ -506,8 +553,8 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 		}
 		if !batchStatus {
 			r.metrics.rollupL2ChainMonitorLatestFailedBatchStatus.Inc()
-			log.Error("the batch status is not right, stop finalize batch and check the reason", "batch_index", dbBatch.Index)
-			return err
+			log.Error("the batch status is false, stop finalize batch and check the reason", "batch_index", dbBatch.Index)
+			return errors.New("the batch status is false")
 		}
 	}
 
@@ -541,7 +588,7 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 	if !r.chainCfg.IsBernoulli(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) { // codecv0
 		calldata, err = r.constructFinalizeBatchPayloadCodecV0(dbBatch, dbParentBatch, aggProof)
 		if err != nil {
-			return fmt.Errorf("failed to construct commitBatch payload codecv0, index: %v, err: %w", dbBatch.Index, err)
+			return fmt.Errorf("failed to construct finalizeBatch payload codecv0, index: %v, err: %w", dbBatch.Index, err)
 		}
 	} else if !r.chainCfg.IsCurie(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) { // codecv1
 		chunks := make([]*encoding.Chunk, len(dbChunks))
@@ -555,9 +602,9 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 
 		calldata, err = r.constructFinalizeBatchPayloadCodecV1(dbBatch, dbParentBatch, dbChunks, chunks, aggProof)
 		if err != nil {
-			return fmt.Errorf("failed to construct commitBatch payload codecv1, index: %v, err: %w", dbBatch.Index, err)
+			return fmt.Errorf("failed to construct finalizeBatch payload codecv1, index: %v, err: %w", dbBatch.Index, err)
 		}
-	} else { // codecv2
+	} else if !r.chainCfg.IsDarwin(dbChunks[0].StartBlockTime) { // codecv2
 		chunks := make([]*encoding.Chunk, len(dbChunks))
 		for i, c := range dbChunks {
 			blocks, dbErr := r.l2BlockOrm.GetL2BlocksInRange(r.ctx, c.StartBlockNumber, c.EndBlockNumber)
@@ -569,8 +616,11 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 
 		calldata, err = r.constructFinalizeBatchPayloadCodecV2(dbBatch, dbParentBatch, dbChunks, chunks, aggProof)
 		if err != nil {
-			return fmt.Errorf("failed to construct commitBatch payload codecv1, index: %v, err: %w", dbBatch.Index, err)
+			return fmt.Errorf("failed to construct finalizeBatch payload codecv2, index: %v, err: %w", dbBatch.Index, err)
 		}
+	} else { // codecv3
+		log.Debug("encoding is codecv3, using finalizeBundle instead", "index", dbBatch.Index)
+		return nil
 	}
 
 	txHash, err := r.finalizeSender.SendTransaction(dbBatch.Hash, &r.cfg.RollupContractAddress, calldata, nil, 0)
@@ -582,15 +632,7 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 			"hash", dbBatch.Hash,
 			"RollupContractAddress", r.cfg.RollupContractAddress,
 			"err", err,
-		)
-		log.Debug(
-			"finalizeBatch in layer1 failed",
-			"with proof", withProof,
-			"index", dbBatch.Index,
-			"hash", dbBatch.Hash,
-			"RollupContractAddress", r.cfg.RollupContractAddress,
 			"calldata", common.Bytes2Hex(calldata),
-			"err", err,
 		)
 		return err
 	}
@@ -624,6 +666,98 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 	return nil
 }
 
+func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error {
+	// Check batch status before sending `finalizeBundle` tx.
+	if r.cfg.ChainMonitor.Enabled {
+		for batchIndex := bundle.StartBatchIndex; batchIndex <= bundle.EndBatchIndex; batchIndex++ {
+			tmpBatch, getErr := r.batchOrm.GetBatchByIndex(r.ctx, batchIndex)
+			if getErr != nil {
+				log.Error("failed to get batch by index", "batch index", batchIndex, "error", getErr)
+				return getErr
+			}
+			batchStatus, getErr := r.getBatchStatusByIndex(tmpBatch)
+			if getErr != nil {
+				r.metrics.rollupL2ChainMonitorLatestFailedCall.Inc()
+				log.Error("failed to get batch status, please check chain_monitor api server", "batch_index", tmpBatch.Index, "err", getErr)
+				return getErr
+			}
+			if !batchStatus {
+				r.metrics.rollupL2ChainMonitorLatestFailedBatchStatus.Inc()
+				log.Error("the batch status is false, stop finalize batch and check the reason", "batch_index", tmpBatch.Index)
+				return errors.New("the batch status is false")
+			}
+		}
+	}
+
+	dbBatch, err := r.batchOrm.GetBatchByIndex(r.ctx, bundle.EndBatchIndex)
+	if err != nil {
+		log.Error("failed to get batch by index", "batch index", bundle.EndBatchIndex, "error", err)
+		return err
+	}
+
+	var aggProof *message.BundleProof
+	if withProof {
+		aggProof, err = r.bundleOrm.GetVerifiedProofByHash(r.ctx, bundle.Hash)
+		if err != nil {
+			return fmt.Errorf("failed to get verified proof by bundle index: %d, err: %w", bundle.Index, err)
+		}
+
+		if err = aggProof.SanityCheck(); err != nil {
+			return fmt.Errorf("failed to check agg_proof sanity, index: %d, err: %w", bundle.Index, err)
+		}
+	}
+
+	calldata, err := r.constructFinalizeBundlePayloadCodecV3(dbBatch, aggProof)
+	if err != nil {
+		return fmt.Errorf("failed to construct finalizeBundle payload codecv3, index: %v, err: %w", dbBatch.Index, err)
+	}
+
+	txHash, err := r.finalizeSender.SendTransaction("finalizeBundle-"+bundle.Hash, &r.cfg.RollupContractAddress, calldata, nil, 0)
+	if err != nil {
+		log.Error("finalizeBundle in layer1 failed", "with proof", withProof, "index", bundle.Index,
+			"start batch index", bundle.StartBatchIndex, "end batch index", bundle.EndBatchIndex,
+			"RollupContractAddress", r.cfg.RollupContractAddress, "err", err, "calldata", common.Bytes2Hex(calldata))
+		return err
+	}
+
+	log.Info("finalizeBundle in layer1", "with proof", withProof, "index", bundle.Index, "start batch index", bundle.StartBatchIndex, "end batch index", bundle.EndBatchIndex, "tx hash", txHash.String())
+
+	// Updating rollup status in database.
+	if err := r.bundleOrm.UpdateFinalizeTxHashAndRollupStatus(r.ctx, bundle.Hash, txHash.String(), types.RollupFinalizing); err != nil {
+		log.Error("UpdateFinalizeTxHashAndRollupStatus failed", "index", bundle.Index, "bundle hash", bundle.Hash, "tx hash", txHash.String(), "err", err)
+		return err
+	}
+
+	// Updating the proving status when finalizing without proof, thus the coordinator could omit this task.
+	// it isn't a necessary step, so don't put in a transaction with UpdateFinalizeTxHashAndRollupStatus
+	if !withProof {
+		txErr := r.db.Transaction(func(tx *gorm.DB) error {
+			if updateErr := r.bundleOrm.UpdateProvingStatus(r.ctx, bundle.Hash, types.ProvingTaskVerified); updateErr != nil {
+				return updateErr
+			}
+			if updateErr := r.batchOrm.UpdateProvingStatusByBundleHash(r.ctx, bundle.Hash, types.ProvingTaskVerified); updateErr != nil {
+				return updateErr
+			}
+			for batchIndex := bundle.StartBatchIndex; batchIndex <= bundle.EndBatchIndex; batchIndex++ {
+				tmpBatch, getErr := r.batchOrm.GetBatchByIndex(r.ctx, batchIndex)
+				if getErr != nil {
+					return getErr
+				}
+				if updateErr := r.chunkOrm.UpdateProvingStatusByBatchHash(r.ctx, tmpBatch.Hash, types.ProvingTaskVerified); updateErr != nil {
+					return updateErr
+				}
+			}
+			return nil
+		})
+		if txErr != nil {
+			log.Error("Updating chunk and batch proving status when finalizing without proof failure", "bundleHash", bundle.Hash, "err", txErr)
+		}
+	}
+
+	r.metrics.rollupL2RelayerProcessPendingBundlesFinalizedSuccessTotal.Inc()
+	return nil
+}
+
 // batchStatusResponse the response schema
 type batchStatusResponse struct {
 	ErrCode int    `json:"errcode"`
@@ -688,6 +822,36 @@ func (r *Layer2Relayer) handleConfirmation(cfm *sender.Confirmation) {
 			log.Warn("UpdateCommitTxHashAndRollupStatus failed", "confirmation", cfm, "err", err)
 		}
 	case types.SenderTypeFinalizeBatch:
+		if strings.HasPrefix(cfm.ContextID, "finalizeBundle-") {
+			bundleHash := strings.TrimPrefix(cfm.ContextID, "finalizeBundle-")
+			var status types.RollupStatus
+			if cfm.IsSuccessful {
+				status = types.RollupFinalized
+				r.metrics.rollupL2BundlesFinalizedConfirmedTotal.Inc()
+			} else {
+				status = types.RollupFinalizeFailed
+				r.metrics.rollupL2BundlesFinalizedConfirmedFailedTotal.Inc()
+				log.Warn("FinalizeBundleTxType transaction confirmed but failed in layer1", "confirmation", cfm)
+			}
+
+			err := r.db.Transaction(func(dbTX *gorm.DB) error {
+				if err := r.batchOrm.UpdateFinalizeTxHashAndRollupStatusByBundleHash(r.ctx, bundleHash, cfm.TxHash.String(), status); err != nil {
+					log.Warn("UpdateFinalizeTxHashAndRollupStatusByBundleHash failed", "confirmation", cfm, "err", err)
+					return err
+				}
+
+				if err := r.bundleOrm.UpdateFinalizeTxHashAndRollupStatus(r.ctx, bundleHash, cfm.TxHash.String(), status); err != nil {
+					log.Warn("UpdateFinalizeTxHashAndRollupStatus failed", "confirmation", cfm, "err", err)
+					return err
+				}
+				return nil
+			})
+			if err != nil {
+				log.Warn("failed to update rollup status of bundle and batches", "err", err)
+			}
+			return
+		}
+
 		var status types.RollupStatus
 		if cfm.IsSuccessful {
 			status = types.RollupFinalized
@@ -833,6 +997,45 @@ func (r *Layer2Relayer) constructCommitBatchPayloadCodecV2(dbBatch *orm.Batch, d
 	return calldata, daBatch.Blob(), nil
 }
 
+func (r *Layer2Relayer) constructCommitBatchPayloadCodecV3(dbBatch *orm.Batch, dbParentBatch *orm.Batch, dbChunks []*orm.Chunk, chunks []*encoding.Chunk) ([]byte, *kzg4844.Blob, error) {
+	batch := &encoding.Batch{
+		Index:                      dbBatch.Index,
+		TotalL1MessagePoppedBefore: dbChunks[0].TotalL1MessagesPoppedBefore,
+		ParentBatchHash:            common.HexToHash(dbParentBatch.Hash),
+		Chunks:                     chunks,
+	}
+
+	daBatch, createErr := codecv3.NewDABatch(batch)
+	if createErr != nil {
+		return nil, nil, fmt.Errorf("failed to create DA batch: %w", createErr)
+	}
+
+	encodedChunks := make([][]byte, len(dbChunks))
+	for i, c := range dbChunks {
+		daChunk, createErr := codecv3.NewDAChunk(chunks[i], c.TotalL1MessagesPoppedBefore)
+		if createErr != nil {
+			return nil, nil, fmt.Errorf("failed to create DA chunk: %w", createErr)
+		}
+		encodedChunks[i] = daChunk.Encode()
+	}
+
+	blobDataProof, err := daBatch.BlobDataProofForPointEvaluation()
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get blob data proof for point evaluation: %w", err)
+	}
+
+	skippedL1MessageBitmap, _, err := encoding.ConstructSkippedBitmap(batch.Index, batch.Chunks, batch.TotalL1MessagePoppedBefore)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to construct skipped L1 message bitmap: %w", err)
+	}
+
+	calldata, packErr := r.l1RollupABI.Pack("commitBatchWithBlobProof", daBatch.Version, dbParentBatch.BatchHeader, encodedChunks, skippedL1MessageBitmap, blobDataProof)
+	if packErr != nil {
+		return nil, nil, fmt.Errorf("failed to pack commitBatchWithBlobProof: %w", packErr)
+	}
+	return calldata, daBatch.Blob(), nil
+}
+
 func (r *Layer2Relayer) constructFinalizeBatchPayloadCodecV0(dbBatch *orm.Batch, dbParentBatch *orm.Batch, aggProof *message.BatchProof) ([]byte, error) {
 	if aggProof != nil { // finalizeBatch with proof.
 		calldata, packErr := r.l1RollupABI.Pack(
@@ -961,6 +1164,34 @@ func (r *Layer2Relayer) constructFinalizeBatchPayloadCodecV2(dbBatch *orm.Batch,
 	return calldata, nil
 }
 
+func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV3(dbBatch *orm.Batch, aggProof *message.BundleProof) ([]byte, error) {
+	if aggProof != nil { // finalizeBundle with proof.
+		calldata, packErr := r.l1RollupABI.Pack(
+			"finalizeBundleWithProof",
+			dbBatch.BatchHeader,
+			common.HexToHash(dbBatch.StateRoot),
+			common.HexToHash(dbBatch.WithdrawRoot),
+			aggProof.Proof,
+		)
+		if packErr != nil {
+			return nil, fmt.Errorf("failed to pack finalizeBundleWithProof: %w", packErr)
+		}
+		return calldata, nil
+	}
+
+	// finalizeBundle without proof.
+	calldata, packErr := r.l1RollupABI.Pack(
+		"finalizeBundle",
+		dbBatch.BatchHeader,
+		common.HexToHash(dbBatch.StateRoot),
+		common.HexToHash(dbBatch.WithdrawRoot),
+	)
+	if packErr != nil {
+		return nil, fmt.Errorf("failed to pack finalizeBundle: %w", packErr)
+	}
+	return calldata, nil
+}
+
 // StopSenders stops the senders of the rollup-relayer to prevent querying the removed pending_transaction table in unit tests.
 // for unit test
 func (r *Layer2Relayer) StopSenders() {

rollup/internal/controller/relayer/l2_relayer_metrics.go

@@ -23,6 +23,11 @@ type l2RelayerMetrics struct {
 	rollupL2UpdateGasOracleConfirmedFailedTotal                 prometheus.Counter
 	rollupL2ChainMonitorLatestFailedCall                        prometheus.Counter
 	rollupL2ChainMonitorLatestFailedBatchStatus                 prometheus.Counter
+	rollupL2RelayerProcessPendingBundlesTotal                   prometheus.Counter
+	rollupL2RelayerProcessPendingBundlesFinalizedTotal          prometheus.Counter
+	rollupL2RelayerProcessPendingBundlesFinalizedSuccessTotal   prometheus.Counter
+	rollupL2BundlesFinalizedConfirmedTotal                      prometheus.Counter
+	rollupL2BundlesFinalizedConfirmedFailedTotal                prometheus.Counter
 }
 
 var (
@@ -93,6 +98,26 @@ func initL2RelayerMetrics(reg prometheus.Registerer) *l2RelayerMetrics {
 				Name: "rollup_layer2_chain_monitor_latest_failed_batch_status",
 				Help: "The total number of failed batch status get from chain_monitor",
 			}),
+			rollupL2RelayerProcessPendingBundlesTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_layer2_relayer_process_pending_bundles_total",
+				Help: "Total number of times the layer2 relayer has processed pending bundles.",
+			}),
+			rollupL2RelayerProcessPendingBundlesFinalizedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_layer2_relayer_process_pending_bundles_finalized_total",
+				Help: "Total number of times the layer2 relayer has finalized proven bundle processes.",
+			}),
+			rollupL2RelayerProcessPendingBundlesFinalizedSuccessTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_layer2_relayer_process_pending_bundles_finalized_success_total",
+				Help: "Total number of times the layer2 relayer has successful finalized proven bundle processes.",
+			}),
+			rollupL2BundlesFinalizedConfirmedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_layer2_bundles_finalized_confirmed_total",
+				Help: "Total number of finalized bundles confirmed on layer2.",
+			}),
+			rollupL2BundlesFinalizedConfirmedFailedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_layer2_bundles_finalized_confirmed_failed_total",
+				Help: "Total number of failed confirmations for finalized bundles on layer2.",
+			}),
 		}
 	})
 	return l2RelayerMetric