enable isCurie on deployment

Co-authored-by: colin <102356659+colinlyguo@users.noreply.github.com>
Co-authored-by: colinlyguo <colinlyguo@users.noreply.github.com>
Co-authored-by: amoylan2 <amoylan2@users.noreply.github.com>

.github/workflows/docker-coordinator-api-arm64.yml

@@ -0,0 +1,41 @@
+name: Docker-coordinator-api-arm64
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "tag of this image (suffix -arm64 is added automatically)"
+        required: true
+        type: string
+
+jobs:
+  build-and-push-arm64-image:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        arch:
+          - aarch64
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Set up QEMU
+        run: |
+          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+          docker buildx create --name multiarch --driver docker-container --use
+      - name: Set up Docker Buildx
+        id: 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: Build docker image
+        uses: docker/build-push-action@v2
+        with:
+          platforms: linux/arm64
+          context: .
+          file: ./build/dockerfiles/coordinator-api.Dockerfile
+          push: true
+          tags: scrolltech/coordinator-api:${{inputs.tag}}-arm64

.github/workflows/docker.yml

@@ -46,7 +46,7 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/event_watcher.Dockerfile
-          platforms: linux/amd64
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
@@ -91,7 +91,7 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/gas_oracle.Dockerfile
-          platforms: linux/amd64
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
@@ -136,7 +136,7 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/rollup_relayer.Dockerfile
-          platforms: linux/amd64
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
@@ -279,6 +279,51 @@ jobs:
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
             ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
 
+  bridgehistoryapi-db-cli:
+    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: bridgehistoryapi-db-cli
+        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: bridgehistoryapi-db-cli
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/bridgehistoryapi-db-cli.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
+
   coordinator-api:
     runs-on: ubuntu-latest
     steps:
@@ -316,7 +361,6 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/coordinator-api.Dockerfile
-          platforms: linux/amd64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}

.github/workflows/intermediate-docker.yml

@@ -4,32 +4,65 @@ on:
   workflow_dispatch:
     inputs:
       GO_VERSION:
-        description: 'Go version'
+        description: "Go version"
         required: true
-        type: string
-        default: '1.21'
+        type: choice
+        options:
+          - "1.20"
+          - "1.21"
+          - "1.22"
+          - "1.23"
+        default: "1.21"
       RUST_VERSION:
-        description: 'Rust toolchain version'
+        description: "Rust toolchain version"
         required: true
-        type: string
-        default: 'nightly-2023-12-03'
+        type: choice
+        options:
+          - nightly-2023-12-03
+          - nightly-2022-12-10
+        default: "nightly-2023-12-03"
       PYTHON_VERSION:
-        description: 'Python version'
+        description: "Python version"
         required: false
-        type: string
-        default: '3.10'
+        type: choice
+        options:
+          - "3.10"
+        default: "3.10"
       CUDA_VERSION:
-        description: 'Cuda version'
+        description: "Cuda version"
         required: false
-        type: string
-        default: '11.7.1'
+        type: choice
+        options:
+          - "11.7.1"
+          - "12.2.2"
+        default: "11.7.1"
+      CARGO_CHEF_TAG:
+        description: "Cargo chef version"
+        required: true
+        default: "0.1.41"
+        type: choice
+        options:
+          - 0.1.41
+      BASE_IMAGE:
+        description: "which intermediate image you want to update"
+        required: true
+        default: "go-alpine-builder"
+        type: choice
+        options:
+          - cuda-go-rust-builder
+          - go-rust-builder
+          - go-alpine-builder
+          - rust-builder
+          - rust-alpine-builder
+          - go-rust-alpine-builder
+          - py-runner
 
 defaults:
   run:
-    working-directory: 'build/dockerfiles/intermediate'
+    working-directory: "build/dockerfiles/intermediate"
 
 jobs:
-  build-and-publish-cuda-go-rust-builder:
+  build-and-publish-intermediate:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
@@ -43,177 +76,37 @@ jobs:
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: set tag env
+        run: |
+          if [ ${{github.event.inputs.BASE_IMAGE}} == "cuda-go-rust-builder" ]; then
+            echo "TAG=cuda-${{ github.event.inputs.CUDA_VERSION }}-go-${{ github.event.inputs.GO_VERSION }}-rust-${{ github.event.inputs.RUST_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "go-rust-builder" ]; then
+            echo "TAG=go-${{ github.event.inputs.GO_VERSION }}-rust-${{ github.event.inputs.RUST_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "go-alpine-builder" ]; then
+            echo "TAG=${{ github.event.inputs.GO_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "rust-builder" ]; then
+            echo "TAG=${{ github.event.inputs.RUST_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "rust-alpine-builder" ]; then
+            echo "TAG=${{ github.event.inputs.RUST_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "go-rust-alpine-builder" ]; then
+            echo "TAG=go-${{ github.event.inputs.GO_VERSION }}-rust-${{ github.event.inputs.RUST_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "py-runner" ]; then
+            echo "TAG=${{ github.event.inputs.PYTHON_VERSION }}" >> $GITHUB_ENV
+          else
+            echo "no BASE_IMAGE match"
+          fi
       - name: Build image
         id: build
         uses: docker/build-push-action@v5
         with:
           context: .
           push: true
-          file: build/dockerfiles/intermediate/cuda-go-rust-builder.Dockerfile
-          tags: scrolltech/cuda-go-rust-builder:cuda-${{ github.event.inputs.CUDA_VERSION }}-go-${{ github.event.inputs.GO_VERSION }}-rust-${{ github.event.inputs.RUST_VERSION }}
-          build-args: |
-            CUDA_VERSION: ${{ github.event.inputs.CUDA_VERSION }}
-            GO_VERSION: ${{ github.event.inputs.GO_VERSION }}
-            RUST_VERSION: ${{ github.event.inputs.RUST_VERSION }}
-
-  build-and-publish-go-rust-builder:
-    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: Build image
-        id: build
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          file: build/dockerfiles/intermediate/go-rust-builder.Dockerfile
+          file: build/dockerfiles/intermediate/${{ github.event.inputs.BASE_IMAGE }}.Dockerfile
           platforms: linux/amd64,linux/arm64
-          tags: scrolltech/go-rust-builder:go-${{ github.event.inputs.GO_VERSION }}-rust-${{ github.event.inputs.RUST_VERSION }}
+          tags: scrolltech/${{ github.event.inputs.BASE_IMAGE }}:${{ env.TAG }}
           build-args: |
-            GO_VERSION: ${{ github.event.inputs.GO_VERSION }}
-            RUST_VERSION: ${{ github.event.inputs.RUST_VERSION }}
-
-  build-and-publish-go-alpine-builder:
-    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: Build image
-        id: build
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          file: build/dockerfiles/intermediate/go-alpine-builder.Dockerfile
-          platforms: linux/amd64,linux/arm64
-          tags: scrolltech/go-alpine-builder:${{ github.event.inputs.GO_VERSION }}
-          build-args: |
-            GO_VERSION: ${{ github.event.inputs.GO_VERSION }}
-            RUST_VERSION: ${{ github.event.inputs.RUST_VERSION }}
-
-  build-and-publish-rust-builder:
-    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: Build image
-        id: build
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          file: build/dockerfiles/intermediate/rust-builder.Dockerfile
-          platforms: linux/amd64,linux/arm64
-          tags: scrolltech/rust-builder:${{ github.event.inputs.RUST_VERSION }}
-          build-args: |
-            RUST_VERSION: ${{ github.event.inputs.RUST_VERSION }}
-
-  build-and-publish-rust-alpine-builder:
-    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: Build image
-        id: build
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          file: build/dockerfiles/intermediate/rust-alpine-builder.Dockerfile
-          platforms: linux/amd64,linux/arm64
-          tags: scrolltech/rust-alpine-builder:${{ github.event.inputs.RUST_VERSION }}
-          build-args: |
-            RUST_VERSION: ${{ github.event.inputs.RUST_VERSION }}
-
-  build-and-publish-go-rust-alpine-builder:
-    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: Build image
-        id: build
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          file: build/dockerfiles/intermediate/go-rust-alpine-builder.Dockerfile
-          platforms: linux/amd64,linux/arm64
-          tags: scrolltech/go-rust-alpine-builder:go-${{ github.event.inputs.GO_VERSION }}-rust-${{ github.event.inputs.RUST_VERSION }}
-          build-args: |
-            GO_VERSION: ${{ github.event.inputs.GO_VERSION }}
-            RUST_VERSION: ${{ github.event.inputs.RUST_VERSION }}
-
-  build-and-publish-py-runner:
-    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: Build image
-        id: build
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          file: build/dockerfiles/intermediate/py-runner.Dockerfile
-          platforms: linux/amd64,linux/arm64
-          tags: scrolltech/py-runner:${{ github.event.inputs.PYTHON_VERSION }}
-          build-args: |
-            CUDA_VERSION: ${{ github.event.inputs.CUDA_VERSION }}
-            GO_VERSION: ${{ github.event.inputs.GO_VERSION }}
-            RUST_VERSION: ${{ github.event.inputs.RUST_VERSION }}
-
+            CUDA_VERSION=${{ github.event.inputs.CUDA_VERSION }}
+            GO_VERSION=${{ github.event.inputs.GO_VERSION }}
+            RUST_VERSION=${{ github.event.inputs.RUST_VERSION }}
+            PYTHON_VERSION=${{ github.event.inputs.PYTHON_VERSION }}
+            CARGO_CHEF_TAG=${{ github.event.inputs.CARGO_CHEF_TAG }}

.github/workflows/prover.yml

@@ -25,78 +25,75 @@ defaults:
     working-directory: 'prover'
 
 jobs:
-  test:
-    if: github.event.pull_request.draft == false
+  skip_check:
     runs-on: ubuntu-latest
+    outputs:
+      should_skip: ${{ steps.skip_check.outputs.should_skip }}
     steps:
-    - name: Install Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.21.x
-    - name: Checkout code
-      uses: actions/checkout@v4
-    - name: Test
-      run: |
-        go test -tags="mock_prover" -v -coverprofile=coverage.txt ./...
-    - name: Upload coverage reports to Codecov
-      uses: codecov/codecov-action@v3
-      env:
-        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-      with:
-        flags: prover
+      - id: skip_check
+        uses: fkirc/skip-duplicate-actions@v5
+        with:
+          cancel_others: 'true'
+          concurrent_skipping: 'same_content_newer'
+          paths_ignore: '["**/README.md"]'
+
+  fmt:
+    needs: [skip_check]
+    if: |
+      github.event.pull_request.draft == false &&
+      (github.event.action == 'ready_for_review' || needs.skip_check.outputs.should_skip != 'true')
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: nightly-2023-12-03
+          components: rustfmt
+      - name: Cargo cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: "prover -> target"
+      - name: Cargo check
+        run: cargo check --all-features
+      - name: Cargo fmt
+        run: cargo fmt --all -- --check
+  
+  clippy:
+    needs: [skip_check, fmt]
+    if: |
+      github.event.pull_request.draft == false &&
+      (github.event.action == 'ready_for_review' || needs.skip_check.outputs.should_skip != 'true')
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: nightly-2023-12-03
+          components: clippy
+      - name: Cargo cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: "prover -> target"
+      - name: Run clippy
+        run: cargo clippy --all-features --all-targets -- -D warnings
+
   compile:
-    if: github.event_name == 'push' # will only be triggered when pushing to main & staging & develop & alpha
+    needs: [skip_check, clippy]
+    if: |
+      github.event.pull_request.draft == false &&
+      (github.event.action == 'ready_for_review' || needs.skip_check.outputs.should_skip != 'true')
     runs-on: ubuntu-latest
     steps:
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: nightly-2023-12-03
-        override: true
-        components: rustfmt, clippy
-    - name: Install Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.21.x
-    - name: Checkout code
-      uses: actions/checkout@v4
-    - name: Cache cargo
-      uses: Swatinem/rust-cache@v2
-      with:
-        workspaces: "common/libzkp/impl -> target"
-    - name: Test
-      run: |
-        make prover
-  check:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    steps:
-    - name: Install Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.21.x
-    - name: Checkout code
-      uses: actions/checkout@v4
-    - name: Lint
-      run: |
-        rm -rf $HOME/.cache/golangci-lint
-        make lint
-  goimports-lint:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    steps:
-    - name: Install Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.21.x
-    - name: Checkout code
-      uses: actions/checkout@v4
-    - name: Install goimports
-      run: go install golang.org/x/tools/cmd/goimports
-    - run: goimports -local scroll-tech/prover/ -w .
-    - run: go mod tidy
-    # If there are any diffs from goimports or go mod tidy, fail.
-    - name: Verify no changes from goimports and go mod tidy
-      run: |
-        if [ -n "$(git status --porcelain)" ]; then
-          exit 1
-        fi
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: nightly-2023-12-03
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: "prover -> target"
+      - name: Test
+        run: |
+          make prover

.github/workflows/rollup.yml

@@ -105,7 +105,7 @@ jobs:
     - name: Test rollup packages
       working-directory: 'rollup'
       run: |
-        ./run_test.sh
+        make test
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v3
       env:

.gitignore

@@ -4,6 +4,8 @@ assets/seed
 
 # Built binaries
 build/bin
+verifier.test
+core.test
 
 coverage.txt
 *.integration.txt
@@ -20,3 +22,5 @@ coverage.txt
 # misc
 sftp-config.json
 *~
+
+target

Makefile

@@ -12,7 +12,6 @@ update:
 	cd $(PWD)/common/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG}&& go mod tidy
 	cd $(PWD)/coordinator/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
 	cd $(PWD)/database/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
-	cd $(PWD)/prover/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG}&& go mod tidy
 	cd $(PWD)/rollup/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
 	cd $(PWD)/tests/integration-test/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
 
@@ -21,7 +20,6 @@ lint: ## The code's format and security checks.
 	make -C common lint
 	make -C coordinator lint
 	make -C database lint
-	make -C prover lint
 	make -C bridge-history-api lint
 
 fmt: ## format the code
@@ -30,7 +28,6 @@ fmt: ## format the code
 	cd $(PWD)/common/ && go mod tidy
 	cd $(PWD)/coordinator/ && go mod tidy
 	cd $(PWD)/database/ && go mod tidy
-	cd $(PWD)/prover/ && go mod tidy
 	cd $(PWD)/rollup/ && go mod tidy
 	cd $(PWD)/tests/integration-test/ && go mod tidy
 
@@ -38,7 +35,6 @@ fmt: ## format the code
 	goimports -local $(PWD)/common/ -w .
 	goimports -local $(PWD)/coordinator/ -w .
 	goimports -local $(PWD)/database/ -w .
-	goimports -local $(PWD)/prover/ -w .
 	goimports -local $(PWD)/rollup/ -w .
 	goimports -local $(PWD)/tests/integration-test/ -w .
 

README.md

@@ -46,18 +46,7 @@ make dev_docker
 Run the tests using the following commands:
 
 ```bash
-export LIBSCROLL_ZSTD_VERSION=v0.1.0-rc0-ubuntu20.04
-export SCROLL_LIB_PATH=/scroll/lib
-
-sudo mkdir -p $SCROLL_LIB_PATH
-
-sudo wget -O $SCROLL_LIB_PATH/libscroll_zstd.so https://github.com/scroll-tech/da-codec/releases/download/$LIBSCROLL_ZSTD_VERSION/libscroll_zstd.so
-
-export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$SCROLL_LIB_PATH
-export CGO_LDFLAGS="-L$SCROLL_LIB_PATH -Wl,-rpath,$SCROLL_LIB_PATH"
-
 go test -v -race -covermode=atomic scroll-tech/rollup/...
-
 go test -tags="mock_verifier" -v -race -covermode=atomic scroll-tech/coordinator/...
 go test -v -race -covermode=atomic scroll-tech/database/...
 go test -v -race -covermode=atomic scroll-tech/common/...

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

@@ -147,7 +147,7 @@ func (b *EventUpdateLogic) updateL2WithdrawMessageInfos(ctx context.Context, bat
 	}
 
 	if withdrawTrie.NextMessageNonce != l2WithdrawMessages[0].MessageNonce {
-		log.Error("nonce mismatch", "expected next message nonce", withdrawTrie.NextMessageNonce, "actuall next message nonce", l2WithdrawMessages[0].MessageNonce)
+		log.Error("nonce mismatch", "expected next message nonce", withdrawTrie.NextMessageNonce, "actual next message nonce", l2WithdrawMessages[0].MessageNonce)
 		return fmt.Errorf("nonce mismatch")
 	}
 

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

@@ -13,7 +13,6 @@ RUN cargo chef cook --release --recipe-path recipe.json
 
 COPY ./common/libzkp/impl .
 RUN cargo build --release
-RUN find ./ | grep libzktrie.so | xargs -I{} cp {} /app/target/release/
 
 
 # Download Go dependencies
@@ -35,7 +34,6 @@ FROM base as builder
 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/
-COPY --from=zkp-builder /app/target/release/libzktrie.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

build/dockerfiles/event_watcher.Dockerfile

@@ -1,6 +1,3 @@
-ARG LIBSCROLL_ZSTD_VERSION=v0.1.0-rc0-ubuntu20.04
-ARG SCROLL_LIB_PATH=/scroll/lib
-
 # Download Go dependencies
 FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
 
@@ -18,36 +15,14 @@ RUN go mod download -x
 # Build event_watcher
 FROM base as builder
 
-ARG LIBSCROLL_ZSTD_VERSION
-ARG SCROLL_LIB_PATH
-
-RUN mkdir -p $SCROLL_LIB_PATH
-
-RUN apt-get -qq update && apt-get -qq install -y wget
-
-RUN wget -O $SCROLL_LIB_PATH/libscroll_zstd.so https://github.com/scroll-tech/da-codec/releases/download/$LIBSCROLL_ZSTD_VERSION/libscroll_zstd.so
-
-ENV LD_LIBRARY_PATH=$SCROLL_LIB_PATH
-ENV CGO_LDFLAGS="-L$SCROLL_LIB_PATH -Wl,-rpath,$SCROLL_LIB_PATH"
-
 RUN --mount=target=. \
     --mount=type=cache,target=/root/.cache/go-build \
-    cd /src/rollup/cmd/event_watcher/ && go build -v -p 4 -o /bin/event_watcher
+    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
 
-ARG LIBSCROLL_ZSTD_VERSION
-ARG SCROLL_LIB_PATH
-
-RUN mkdir -p $SCROLL_LIB_PATH
-
-RUN apt-get -qq update && apt-get -qq install -y wget
-
-RUN wget -O $SCROLL_LIB_PATH/libscroll_zstd.so https://github.com/scroll-tech/da-codec/releases/download/$LIBSCROLL_ZSTD_VERSION/libscroll_zstd.so
-
-ENV LD_LIBRARY_PATH=$SCROLL_LIB_PATH
-ENV CGO_LDFLAGS="-L$SCROLL_LIB_PATH -Wl,-rpath,$SCROLL_LIB_PATH"
+ENV CGO_LDFLAGS="-ldl"
 
 COPY --from=builder /bin/event_watcher /bin/
 WORKDIR /app

build/dockerfiles/gas_oracle.Dockerfile

@@ -1,6 +1,3 @@
-ARG LIBSCROLL_ZSTD_VERSION=v0.1.0-rc0-ubuntu20.04
-ARG SCROLL_LIB_PATH=/scroll/lib
-
 # Download Go dependencies
 FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
 
@@ -18,36 +15,14 @@ RUN go mod download -x
 # Build gas_oracle
 FROM base as builder
 
-ARG LIBSCROLL_ZSTD_VERSION
-ARG SCROLL_LIB_PATH
-
-RUN mkdir -p $SCROLL_LIB_PATH
-
-RUN apt-get -qq update && apt-get -qq install -y wget
-
-RUN wget -O $SCROLL_LIB_PATH/libscroll_zstd.so https://github.com/scroll-tech/da-codec/releases/download/$LIBSCROLL_ZSTD_VERSION/libscroll_zstd.so
-
-ENV LD_LIBRARY_PATH=$SCROLL_LIB_PATH
-ENV CGO_LDFLAGS="-L$SCROLL_LIB_PATH -Wl,-rpath,$SCROLL_LIB_PATH"
-
 RUN --mount=target=. \
     --mount=type=cache,target=/root/.cache/go-build \
-    cd /src/rollup/cmd/gas_oracle/ && go build -v -p 4 -o /bin/gas_oracle
+    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
 FROM ubuntu:20.04
 
-ARG LIBSCROLL_ZSTD_VERSION
-ARG SCROLL_LIB_PATH
-
-RUN mkdir -p $SCROLL_LIB_PATH
-
-RUN apt-get -qq update && apt-get -qq install -y wget
-
-RUN wget -O $SCROLL_LIB_PATH/libscroll_zstd.so https://github.com/scroll-tech/da-codec/releases/download/$LIBSCROLL_ZSTD_VERSION/libscroll_zstd.so
-
-ENV LD_LIBRARY_PATH=$SCROLL_LIB_PATH
-ENV CGO_LDFLAGS="-L$SCROLL_LIB_PATH -Wl,-rpath,$SCROLL_LIB_PATH"
+ENV CGO_LDFLAGS="-ldl"
 
 COPY --from=builder /bin/gas_oracle /bin/
 WORKDIR /app

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

@@ -29,7 +29,14 @@ RUN cargo install cargo-chef --locked --version ${CARGO_CHEF_TAG} \
 # Install Go
 ARG GO_VERSION
 RUN rm -rf /usr/local/go
-RUN wget https://go.dev/dl/go${GO_VERSION}.1.linux-amd64.tar.gz
-RUN tar -C /usr/local -xzf go${GO_VERSION}.1.linux-amd64.tar.gz
-RUN rm go${GO_VERSION}.1.linux-amd64.tar.gz
+RUN if [ "$(uname -m)" = "x86_64" ]; then \
+    echo amd64 >/tmp/arch; \
+    elif [ "$(uname -m)" = "aarch64" ]; then \
+    echo arm64 >/tmp/arch; \
+    else \
+    echo "Unsupported architecture"; exit 1; \
+    fi
+RUN wget https://go.dev/dl/go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz
+RUN tar -C /usr/local -xzf go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz
+RUN rm go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz && rm /tmp/arch
 ENV PATH="/usr/local/go/bin:${PATH}"

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

@@ -25,7 +25,14 @@ RUN cargo install cargo-chef --locked --version ${CARGO_CHEF_TAG} \
 # Install Go
 ARG GO_VERSION
 RUN rm -rf /usr/local/go
-RUN wget https://go.dev/dl/go${GO_VERSION}.1.linux-amd64.tar.gz
-RUN tar -C /usr/local -xzf go${GO_VERSION}.1.linux-amd64.tar.gz
-RUN rm go${GO_VERSION}.1.linux-amd64.tar.gz
+RUN if [ "$(uname -m)" = "x86_64" ]; then \
+    echo amd64 >/tmp/arch; \
+    elif [ "$(uname -m)" = "aarch64" ]; then \
+    echo arm64 >/tmp/arch; \
+    else \
+    echo "Unsupported architecture"; exit 1; \
+    fi
+RUN wget https://go.dev/dl/go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz
+RUN tar -C /usr/local -xzf go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz
+RUN rm go${GO_VERSION}.1.linux-$(cat /tmp/arch).tar.gz && rm /tmp/arch
 ENV PATH="/usr/local/go/bin:${PATH}"

build/dockerfiles/rollup_relayer.Dockerfile

@@ -1,6 +1,3 @@
-ARG LIBSCROLL_ZSTD_VERSION=v0.1.0-rc0-ubuntu20.04
-ARG SCROLL_LIB_PATH=/scroll/lib
-
 # Download Go dependencies
 FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
 
@@ -18,36 +15,14 @@ RUN go mod download -x
 # Build rollup_relayer
 FROM base as builder
 
-ARG LIBSCROLL_ZSTD_VERSION
-ARG SCROLL_LIB_PATH
-
-RUN mkdir -p $SCROLL_LIB_PATH
-
-RUN apt-get -qq update && apt-get -qq install -y wget
-
-RUN wget -O $SCROLL_LIB_PATH/libscroll_zstd.so https://github.com/scroll-tech/da-codec/releases/download/$LIBSCROLL_ZSTD_VERSION/libscroll_zstd.so
-
-ENV LD_LIBRARY_PATH=$SCROLL_LIB_PATH
-ENV CGO_LDFLAGS="-L$SCROLL_LIB_PATH -Wl,-rpath,$SCROLL_LIB_PATH"
-
 RUN --mount=target=. \
     --mount=type=cache,target=/root/.cache/go-build \
-    cd /src/rollup/cmd/rollup_relayer/ && go build -v -p 4 -o /bin/rollup_relayer
+    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
 FROM ubuntu:20.04
 
-ARG LIBSCROLL_ZSTD_VERSION
-ARG SCROLL_LIB_PATH
-
-RUN mkdir -p $SCROLL_LIB_PATH
-
-RUN apt-get -qq update && apt-get -qq install -y wget
-
-RUN wget -O $SCROLL_LIB_PATH/libscroll_zstd.so https://github.com/scroll-tech/da-codec/releases/download/$LIBSCROLL_ZSTD_VERSION/libscroll_zstd.so
-
-ENV LD_LIBRARY_PATH=$SCROLL_LIB_PATH
-ENV CGO_LDFLAGS="-L$SCROLL_LIB_PATH -Wl,-rpath,$SCROLL_LIB_PATH"
+ENV CGO_LDFLAGS="-ldl"
 
 COPY --from=builder /bin/rollup_relayer /bin/
 WORKDIR /app

common/libzkp/.gitignore

@@ -0,0 +1,4 @@
+outputs
+libzkp.so
+test_zkp_test/
+*log

common/libzkp/e2e-test.sh

@@ -0,0 +1,44 @@
+set -xeu
+set -o pipefail
+
+export CHAIN_ID=534352
+export RUST_BACKTRACE=full
+export RUST_LOG=debug
+export RUST_MIN_STACK=100000000
+export PROVER_OUTPUT_DIR=test_zkp_test
+#export LD_LIBRARY_PATH=/:/usr/local/cuda/lib64
+
+mkdir -p $PROVER_OUTPUT_DIR
+
+REPO=$(realpath ../..)
+
+function build_test_bins() {
+    cd impl
+    cargo build --release
+    ln -f -s $(realpath target/release/libzkp.so) $REPO/prover/core/lib
+    ln -f -s $(realpath target/release/libzkp.so) $REPO/coordinator/internal/logic/verifier/lib
+    cd $REPO/prover
+    go test -tags="gpu ffi" -timeout 0 -c core/prover_test.go
+    cd $REPO/coordinator
+    go test -tags="gpu ffi" -timeout 0 -c ./internal/logic/verifier
+    cd $REPO/common/libzkp
+}
+
+function build_test_bins_old() {
+    cd $REPO
+    cd prover
+    make libzkp
+    go test -tags="gpu ffi" -timeout 0 -c core/prover_test.go
+    cd ..
+    cd coordinator
+    make libzkp
+    go test -tags="gpu ffi" -timeout 0 -c ./internal/logic/verifier
+    cd ..
+    cd common/libzkp
+}
+
+build_test_bins
+#rm -rf test_zkp_test/*
+#rm -rf prover.log verifier.log
+#$REPO/prover/core.test -test.v 2>&1 | tee prover.log
+$REPO/coordinator/verifier.test -test.v 2>&1 | tee verifier.log

common/libzkp/impl/Cargo.toml

@@ -25,7 +25,7 @@ bls12_381 = { git = "https://github.com/scroll-tech/bls12_381", branch = "feat/i
 [dependencies]
 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", tag = "v0.10.3", default-features = false, features = ["parallel_syn", "scroll", "shanghai"] }
+prover = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.11.4", default-features = false, features = ["parallel_syn", "scroll"] }
 
 base64 = "0.13.0"
 env_logger = "0.9.0"

common/libzkp/impl/Makefile

@@ -1,5 +1,8 @@
 .PHONY: help fmt clippy test test-ci test-all
 
+build:
+	@cargo build --release
+
 fmt:
 	@cargo fmt --all -- --check
 

common/libzkp/impl/src/batch.rs

@@ -8,9 +8,10 @@ use crate::{
 use libc::c_char;
 use prover::{
     aggregator::{Prover, Verifier},
+    check_chunk_hashes,
     consts::AGG_VK_FILENAME,
     utils::{chunk_trace_to_witness_block, init_env_and_log},
-    BatchProof, BlockTrace, ChunkHash, ChunkProof,
+    BatchProof, BatchProvingTask, BlockTrace, ChunkInfo, ChunkProof,
 };
 use snark_verifier_sdk::verify_evm_calldata;
 use std::{cell::OnceCell, env, ptr::null};
@@ -79,7 +80,7 @@ pub unsafe extern "C" fn check_chunk_proofs(chunk_proofs: *const c_char) -> *con
 
         let prover_ref = PROVER.get().expect("failed to get reference to PROVER.");
 
-        let valid = prover_ref.check_chunk_proofs(&chunk_proofs);
+        let valid = prover_ref.check_protocol_of_chunks(&chunk_proofs);
         Ok(valid)
     })
     .unwrap_or_else(|e| Err(format!("unwind error: {e:?}")));
@@ -108,7 +109,7 @@ pub unsafe extern "C" fn gen_batch_proof(
         let chunk_hashes = c_char_to_vec(chunk_hashes);
         let chunk_proofs = c_char_to_vec(chunk_proofs);
 
-        let chunk_hashes = serde_json::from_slice::<Vec<ChunkHash>>(&chunk_hashes)
+        let chunk_hashes = serde_json::from_slice::<Vec<ChunkInfo>>(&chunk_hashes)
             .map_err(|e| format!("failed to deserialize chunk hashes: {e:?}"))?;
         let chunk_proofs = serde_json::from_slice::<Vec<ChunkProof>>(&chunk_proofs)
             .map_err(|e| format!("failed to deserialize chunk proofs: {e:?}"))?;
@@ -118,15 +119,19 @@ pub unsafe extern "C" fn gen_batch_proof(
                 chunk_hashes.len(), chunk_proofs.len()));
         }
 
-        let chunk_hashes_proofs = chunk_hashes
+        let chunk_hashes_proofs: Vec<(_,_)> = chunk_hashes
             .into_iter()
-            .zip(chunk_proofs)
+            .zip(chunk_proofs.clone())
             .collect();
+        check_chunk_hashes("", &chunk_hashes_proofs).map_err(|e| format!("failed to check chunk info: {e:?}"))?;
 
+        let batch = BatchProvingTask {
+            chunk_proofs
+        };
         let proof = PROVER
             .get_mut()
             .expect("failed to get mutable reference to PROVER.")
-            .gen_agg_evm_proof(chunk_hashes_proofs, None, OUTPUT_DIR.as_deref())
+            .gen_agg_evm_proof(batch, None, OUTPUT_DIR.as_deref())
             .map_err(|e| format!("failed to generate proof: {e:?}"))?;
 
         serde_json::to_vec(&proof).map_err(|e| format!("failed to serialize the proof: {e:?}"))
@@ -157,19 +162,18 @@ pub unsafe extern "C" fn verify_batch_proof(
     let proof = serde_json::from_slice::<BatchProof>(proof.as_slice()).unwrap();
     let fork_name_str = c_char_to_str(fork_name);
     let fork_id = match fork_name_str {
-        "" => 0,
-        "shanghai" => 0,
-        "bernoulli" => 1,
+        "bernoulli" => 2,
+        "curie" => 3,
         _ => {
-            log::warn!("unexpected fork_name {fork_name_str}, treated as bernoulli");
-            1
+            log::warn!("unexpected fork_name {fork_name_str}, treated as curie");
+            3
         }
     };
     let verified = panic_catch(|| {
-        if fork_id == 0 {
-            // before upgrade#2(EIP4844)
+        if fork_id == 2 {
+            // before upgrade#3(DA Compression)
             verify_evm_calldata(
-                include_bytes!("evm_verifier_fork_1.bin").to_vec(),
+                include_bytes!("plonk_verifier_0.10.3.bin").to_vec(),
                 proof.calldata(),
             )
         } else {
@@ -187,7 +191,7 @@ pub unsafe extern "C" fn block_traces_to_chunk_info(block_traces: *const c_char)
     let block_traces = serde_json::from_slice::<Vec<BlockTrace>>(&block_traces).unwrap();
 
     let witness_block = chunk_trace_to_witness_block(block_traces).unwrap();
-    let chunk_info = ChunkHash::from_witness_block(&witness_block, false);
+    let chunk_info = ChunkInfo::from_witness_block(&witness_block, false);
 
     let chunk_info_bytes = serde_json::to_vec(&chunk_info).unwrap();
     vec_to_c_char(chunk_info_bytes)

common/libzkp/impl/src/chunk.rs

@@ -10,7 +10,7 @@ use prover::{
     consts::CHUNK_VK_FILENAME,
     utils::init_env_and_log,
     zkevm::{Prover, Verifier},
-    BlockTrace, ChunkProof,
+    BlockTrace, ChunkProof, ChunkProvingTask,
 };
 use std::{cell::OnceCell, env, ptr::null};
 
@@ -71,11 +71,12 @@ pub unsafe extern "C" fn gen_chunk_proof(block_traces: *const c_char) -> *const
         let block_traces = c_char_to_vec(block_traces);
         let block_traces = serde_json::from_slice::<Vec<BlockTrace>>(&block_traces)
             .map_err(|e| format!("failed to deserialize block traces: {e:?}"))?;
+        let chunk = ChunkProvingTask::from(block_traces);
 
         let proof = PROVER
             .get_mut()
             .expect("failed to get mutable reference to PROVER.")
-            .gen_chunk_proof(block_traces, None, None, OUTPUT_DIR.as_deref())
+            .gen_chunk_proof(chunk, None, None, OUTPUT_DIR.as_deref())
             .map_err(|e| format!("failed to generate proof: {e:?}"))?;
 
         serde_json::to_vec(&proof).map_err(|e| format!("failed to serialize the proof: {e:?}"))

common/testcontainers/testcontainers.go

@@ -154,11 +154,10 @@ func (t *TestcontainerApps) GetL2GethEndPoint() (string, error) {
 
 // GetGormDBClient returns a gorm.DB by connecting to the running postgres container
 func (t *TestcontainerApps) GetGormDBClient() (*gorm.DB, error) {
-	// endpoint, err := t.GetDBEndPoint()
-	// if err != nil {
-	// 	return nil, err
-	// }
-	endpoint := "postgres://lmr:@localhost:5432/unittest?sslmode=disable"
+	endpoint, err := t.GetDBEndPoint()
+	if err != nil {
+		return nil, err
+	}
 	dbCfg := &database.Config{
 		DSN:        endpoint,
 		DriverName: "postgres",

common/types/message/message.go

@@ -183,6 +183,12 @@ type ChunkInfo struct {
 	TxBytes       []byte      `json:"tx_bytes"`
 }
 
+// SubCircuitRowUsage tracing info added in v0.11.0rc8
+type SubCircuitRowUsage struct {
+	Name      string `json:"name"`
+	RowNumber uint64 `json:"row_number"`
+}
+
 // ChunkProof includes the proof info that are required for chunk verification and rollup.
 type ChunkProof struct {
 	StorageTrace []byte `json:"storage_trace,omitempty"`
@@ -191,8 +197,9 @@ type ChunkProof struct {
 	Instances    []byte `json:"instances"`
 	Vk           []byte `json:"vk"`
 	// cross-reference between cooridinator computation and prover compution
-	ChunkInfo  *ChunkInfo `json:"chunk_info,omitempty"`
-	GitVersion string     `json:"git_version,omitempty"`
+	ChunkInfo  *ChunkInfo           `json:"chunk_info,omitempty"`
+	GitVersion string               `json:"git_version,omitempty"`
+	RowUsages  []SubCircuitRowUsage `json:"row_usages,omitempty"`
 }
 
 // BatchProof includes the proof info that are required for batch verification and rollup.

common/types/message/message_test.go

@@ -108,7 +108,7 @@ func TestProofDetailHash(t *testing.T) {
 	}
 	hash, err := proofDetail.Hash()
 	assert.NoError(t, err)
-	expectedHash := "d3b57cb84b0da8043373eeb3612806fb7248d6d1b6e089846ccf3ccce2d9f31c"
+	expectedHash := "01128ea9006601146ba80dbda959c96ebaefca463e78570e473a57d821db5ec1"
 	assert.Equal(t, expectedHash, hex.EncodeToString(hash))
 }
 

common/version/version.go

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

contracts/docker/Dockerfile.deploy

@@ -0,0 +1,47 @@
+# Use the latest node Debian slim base image
+# This makes installing yarn dep much easier
+FROM node:20-bookworm-slim
+
+# Switch to bash shell
+SHELL ["/bin/bash", "-c"]
+
+WORKDIR /root
+
+# Install dependencies
+RUN apt update
+RUN apt install --yes curl bash coreutils git jq
+
+# Download and run the Foundry installation script
+RUN curl -L https://foundry.paradigm.xyz | bash
+
+# Set the environment variables to ensure Foundry tools are in the PATH
+ENV PATH="/root/.foundry/bin:${PATH}"
+
+# Run foundryup to update Foundry
+RUN foundryup -v nightly-56dbd20c7179570c53b6c17ff34daa7273a4ddae
+
+# copy dependencies
+COPY ./lib /contracts/lib
+COPY ./node_modules/@openzeppelin /contracts/node_modules/@openzeppelin
+
+# copy configurations
+COPY foundry.toml /contracts/foundry.toml
+COPY remappings.txt /contracts/remappings.txt
+
+# copy source code
+COPY ./src /contracts/src
+COPY ./scripts /contracts/scripts
+
+# compile contracts
+ENV FOUNDRY_EVM_VERSION="cancun"
+ENV FOUNDRY_BYTECODE_HASH="none"
+
+WORKDIR /contracts
+RUN forge build
+
+# copy script configs
+COPY ./docker/templates/config-contracts.toml /contracts/docker/templates/config-contracts.toml
+
+COPY ./docker/scripts/deploy.sh /contracts/docker/scripts/deploy.sh
+
+ENTRYPOINT ["/bin/bash", "/contracts/docker/scripts/deploy.sh"]

contracts/docker/Dockerfile.gen-configs

@@ -0,0 +1,53 @@
+# Use the latest node Debian slim base image
+# This makes installing yarn dep much easier
+FROM node:20-bookworm-slim
+
+# Switch to bash shell
+SHELL ["/bin/bash", "-c"]
+
+WORKDIR /root
+
+# Install dependencies
+RUN apt update
+RUN apt install --yes curl bash coreutils git jq
+
+# Download and run the Foundry installation script
+RUN curl -L https://foundry.paradigm.xyz | bash
+
+# Set the environment variables to ensure Foundry tools are in the PATH
+ENV PATH="/root/.foundry/bin:${PATH}"
+
+# Run foundryup to update Foundry
+RUN foundryup -v nightly-56dbd20c7179570c53b6c17ff34daa7273a4ddae
+
+# copy dependencies
+COPY ./lib /contracts/lib
+COPY ./node_modules/@openzeppelin /contracts/node_modules/@openzeppelin
+
+# copy configurations
+COPY foundry.toml /contracts/foundry.toml
+COPY remappings.txt /contracts/remappings.txt
+
+# copy source code
+COPY ./src /contracts/src
+COPY ./scripts /contracts/scripts
+
+# compile contracts
+ENV FOUNDRY_EVM_VERSION="cancun"
+ENV FOUNDRY_BYTECODE_HASH="none"
+
+WORKDIR /contracts
+RUN forge build
+
+# copy script configs
+COPY ./docker/templates/balance-checker-config.json /contracts/docker/templates/balance-checker-config.json
+COPY ./docker/templates/bridge-history-config.json /contracts/docker/templates/bridge-history-config.json
+COPY ./docker/templates/chain-monitor-config.json /contracts/docker/templates/chain-monitor-config.json
+COPY ./docker/templates/config-contracts.toml /contracts/docker/templates/config-contracts.toml
+COPY ./docker/templates/coordinator-config.json /contracts/docker/templates/coordinator-config.json
+COPY ./docker/templates/genesis.json /contracts/docker/templates/genesis.json
+COPY ./docker/templates/rollup-config.json /contracts/docker/templates/rollup-config.json
+
+COPY ./docker/scripts/gen-configs.sh /contracts/docker/scripts/gen-configs.sh
+
+ENTRYPOINT ["/bin/bash", "/contracts/docker/scripts/gen-configs.sh"]

contracts/docker/config-example.toml

@@ -0,0 +1,75 @@
+[general]
+
+L1_RPC_ENDPOINT = "http://l1geth:8545"
+L2_RPC_ENDPOINT = "http://l2geth:8545"
+
+CHAIN_ID_L1 = 111111
+CHAIN_ID_L2 = 222222
+
+MAX_TX_IN_CHUNK = 100
+MAX_BLOCK_IN_CHUNK = 100
+MAX_L1_MESSAGE_GAS_LIMIT = 10000
+
+L1_CONTRACT_DEPLOYMENT_BLOCK = 0
+
+TEST_ENV_MOCK_FINALIZE_ENABLED = true
+TEST_ENV_MOCK_FINALIZE_TIMEOUT_SEC = 3600
+
+
+[accounts]
+
+# note: for now we simply use Anvil's dev accounts
+
+DEPLOYER_PRIVATE_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+OWNER_PRIVATE_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+
+L1_COMMIT_SENDER_PRIVATE_KEY = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d"
+L1_FINALIZE_SENDER_PRIVATE_KEY = "0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a"
+L1_GAS_ORACLE_SENDER_PRIVATE_KEY = "0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6"
+L2_GAS_ORACLE_SENDER_PRIVATE_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+
+DEPLOYER_ADDR = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+OWNER_ADDR = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+
+L1_COMMIT_SENDER_ADDR = "0x70997970C51812dc3A010C7d01b50e0d17dc79C8"
+L1_FINALIZE_SENDER_ADDR = "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC"
+L1_GAS_ORACLE_SENDER_ADDR = "0x90F79bf6EB2c4f870365E785982E1f101E93b906"
+L2_GAS_ORACLE_SENDER_ADDR = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+
+L2GETH_SIGNER_0_ADDRESS = "0x756EA06BDEe36de11F22DCca45a31d8a178eF3c6"
+
+[db]
+
+SCROLL_DB_CONNECTION_STRING = "postgres://postgres:scroll2022@db:5432/scroll?sslmode=disable"
+CHAIN_MONITOR_DB_CONNECTION_STRING = "postgres://postgres:scroll2022@db:5432/chain_monitor?sslmode=disable"
+BRIDGE_HISTORY_DB_CONNECTION_STRING = "postgres://postgres:scroll2022@db:5432/bridge_history?sslmode=disable"
+
+
+[genesis]
+
+L2_MAX_ETH_SUPPLY = "226156424291633194186662080095093570025917938800079226639565593765455331328"
+L2_DEPLOYER_INITIAL_BALANCE = 1000000000000000000
+
+
+[contracts]
+
+DEPLOYMENT_SALT = ""
+
+# contracts deployed outside this script
+L1_FEE_VAULT_ADDR = "0x0000000000000000000000000000000000000001"
+L1_PLONK_VERIFIER_ADDR = "0x0000000000000000000000000000000000000001"
+
+[contracts.overrides]
+
+# L1_WETH = "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"
+
+L2_MESSAGE_QUEUE = "0x5300000000000000000000000000000000000000"
+L1_GAS_PRICE_ORACLE = "0x5300000000000000000000000000000000000002"
+L2_WHITELIST = "0x5300000000000000000000000000000000000003"
+L2_WETH = "0x5300000000000000000000000000000000000004"
+L2_TX_FEE_VAULT = "0x5300000000000000000000000000000000000005"
+
+
+[coordinator]
+
+COORDINATOR_JWT_SECRET_KEY = "e788b62d39254928a821ac1c76b274a8c835aa1e20ecfb6f50eb10e87847de44"

contracts/docker/scripts/build.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+
+latest_commit=$(git log -1 --pretty=format:%h)
+tag=${latest_commit:0:8}
+echo "Using Docker image tag: $tag"
+echo ""
+
+docker build -f docker/Dockerfile.gen-configs -t scrolltech/scroll-stack-contracts:gen-configs-$tag-amd64 --platform linux/amd64 .
+echo
+echo "built scrolltech/scroll-stack-contracts:gen-configs-$tag-amd64"
+echo
+
+docker build -f docker/Dockerfile.gen-configs -t scrolltech/scroll-stack-contracts:gen-configs-$tag-arm64 --platform linux/arm64 .
+echo
+echo "built scrolltech/scroll-stack-contracts:gen-configs-$tag-arm64"
+echo
+
+docker build -f docker/Dockerfile.deploy -t scrolltech/scroll-stack-contracts:deploy-$tag-amd64 --platform linux/amd64 .
+echo
+echo "built scrolltech/scroll-stack-contracts:deploy-$tag-amd64"
+echo
+
+docker build -f docker/Dockerfile.deploy -t scrolltech/scroll-stack-contracts:deploy-$tag-arm64 --platform linux/arm64 .
+echo
+echo "built scrolltech/scroll-stack-contracts:deploy-$tag-arm64"
+echo

contracts/docker/scripts/deploy.sh

@@ -0,0 +1,46 @@
+#!/bin/sh
+
+export FOUNDRY_EVM_VERSION="cancun"
+export FOUNDRY_BYTECODE_HASH="none"
+
+if [ "${L1_RPC_ENDPOINT}" = "" ]; then
+    echo "L1_RPC_ENDPOINT is not set"
+    L1_RPC_ENDPOINT="http://host.docker.internal:8543"
+fi
+
+if [ "$L2_RPC_ENDPOINT" = "" ]; then
+    echo "L2_RPC_ENDPOINT is not set"
+    L2_RPC_ENDPOINT="http://host.docker.internal:8545"
+fi
+
+if [ "${L1_RPC_ENDPOINT}" = "" ]; then
+    echo "L1_RPC_ENDPOINT is not set"
+    L1_RPC_ENDPOINT="http://host.docker.internal:8543"
+fi
+
+if [ "${BATCH_SIZE}" = "" ]; then
+    BATCH_SIZE="100"
+fi
+
+echo "using L1_RPC_ENDPOINT = $L1_RPC_ENDPOINT"
+echo "using L2_RPC_ENDPOINT = $L2_RPC_ENDPOINT"
+
+# simulate L1
+echo ""
+echo "simulating on L1"
+forge script scripts/foundry/DeployScroll.s.sol:DeployScroll --rpc-url "$L1_RPC_ENDPOINT" --sig "run(string,string)" "L1" "verify-config" || exit 1
+
+# simulate L2
+echo ""
+echo "simulating on L2"
+forge script scripts/foundry/DeployScroll.s.sol:DeployScroll --rpc-url "$L2_RPC_ENDPOINT" --sig "run(string,string)" "L2" "verify-config" --legacy || exit 1
+
+# deploy L1
+echo ""
+echo "deploying on L1"
+forge script scripts/foundry/DeployScroll.s.sol:DeployScroll --rpc-url "$L1_RPC_ENDPOINT" --batch-size "$BATCH_SIZE" --sig "run(string,string)" "L1" "verify-config" --broadcast || exit 1
+
+# deploy L2
+echo ""
+echo "deploying on L2"
+forge script scripts/foundry/DeployScroll.s.sol:DeployScroll --rpc-url "$L2_RPC_ENDPOINT"  --batch-size "$BATCH_SIZE" --sig "run(string,string)" "L2" "verify-config" --broadcast --legacy || exit 1

contracts/docker/scripts/gen-configs.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+echo ""
+echo "generating config-contracts.toml"
+forge script scripts/foundry/DeployScroll.s.sol:DeployScroll --sig "run(string,string)" "none" "write-config" || exit 1
+
+echo ""
+echo "generating genesis.json"
+forge script scripts/foundry/DeployScroll.s.sol:GenerateGenesis || exit 1
+
+echo ""
+echo "generating rollup-config.json"
+forge script scripts/foundry/DeployScroll.s.sol:GenerateRollupConfig || exit 1
+
+echo ""
+echo "generating coordinator-config.json"
+forge script scripts/foundry/DeployScroll.s.sol:GenerateCoordinatorConfig || exit 1
+
+echo ""
+echo "generating chain-monitor-config.json"
+forge script scripts/foundry/DeployScroll.s.sol:GenerateChainMonitorConfig || exit 1
+
+echo ""
+echo "generating bridge-history-config.json"
+forge script scripts/foundry/DeployScroll.s.sol:GenerateBridgeHistoryConfig || exit 1
+
+echo ""
+echo "generating balance-checker-config.json"
+forge script scripts/foundry/DeployScroll.s.sol:GenerateBalanceCheckerConfig || exit 1
+
+echo ""
+echo "generating .env.frontend"
+forge script scripts/foundry/DeployScroll.s.sol:GenerateFrontendConfig || exit 1

contracts/docker/scripts/push.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+
+latest_commit=$(git log -1 --pretty=format:%h)
+tag=${latest_commit:0:8}
+echo "Using Docker image tag: $tag"
+echo ""
+
+docker push scrolltech/scroll-stack-contracts:gen-configs-$tag-amd64
+docker push scrolltech/scroll-stack-contracts:gen-configs-$tag-arm64
+
+docker manifest create scrolltech/scroll-stack-contracts:gen-configs-$tag \
+    --amend scrolltech/scroll-stack-contracts:gen-configs-$tag-amd64 \
+    --amend scrolltech/scroll-stack-contracts:gen-configs-$tag-arm64
+
+docker manifest push scrolltech/scroll-stack-contracts:gen-configs-$tag
+
+docker push scrolltech/scroll-stack-contracts:deploy-$tag-amd64
+docker push scrolltech/scroll-stack-contracts:deploy-$tag-arm64
+
+docker manifest create scrolltech/scroll-stack-contracts:deploy-$tag \
+    --amend scrolltech/scroll-stack-contracts:deploy-$tag-amd64 \
+    --amend scrolltech/scroll-stack-contracts:deploy-$tag-arm64
+
+docker manifest push scrolltech/scroll-stack-contracts:deploy-$tag

contracts/docker/templates/balance-checker-config.json

@@ -0,0 +1,42 @@
+{
+  "addresses": [
+    {
+      "rpc_url": "${SCROLL_L1_RPC}",
+      "min_balance_ether": "10",
+      "address": "${L1_COMMIT_SENDER_ADDRESS}",
+      "name": "L1_COMMIT_SENDER"
+    },
+    {
+      "rpc_url": "${SCROLL_L1_RPC}",
+      "min_balance_ether": "10",
+      "address": "${L1_FINALIZE_SENDER_ADDRESS}",
+      "name": "L1_FINALIZE_SENDER"
+    },
+    {
+      "rpc_url": "${SCROLL_L1_RPC}",
+      "min_balance_ether": "1.1",
+      "address": "${L1_GAS_ORACLE_SENDER_ADDRESS}",
+      "name": "L1_GAS_ORACLE_SENDER"
+    },
+    {
+      "rpc_url": "${SCROLL_L1_RPC}",
+      "min_balance_ether": "0",
+      "address": "${L1_SCROLL_FEE_VAULT_ADDRESS}",
+      "name": "L1_SCROLL_FEE_VAULT"
+    },
+    {
+      "rpc_url": "${SCROLL_L2_RPC}",
+      "min_balance_ether": "1.1",
+      "address": "${L2_GAS_ORACLE_SENDER_ADDRESS}",
+      "name": "L2_GAS_ORACLE_SENDER"
+    },
+    {
+      "rpc_url": "${SCROLL_L2_RPC}",
+      "min_balance_ether": "0",
+      "address": "${L2_TX_FEE_VAULT_ADDR}",
+      "name": "L2_TX_FEE_VAULT"
+    }
+  ],
+  "JOB_INTERVAL_SECS": 60,
+  "BIND_PORT": 8080
+}

contracts/docker/templates/bridge-history-config.json

@@ -0,0 +1,56 @@
+{
+  "L1": {
+    "confirmation": 0,
+    "endpoint": null,
+    "startHeight": 0,
+    "blockTime": 12,
+    "fetchLimit": 16,
+    "MessageQueueAddr": null,
+    "MessengerAddr": null,
+    "ScrollChainAddr": null,
+    "GatewayRouterAddr": null,
+    "ETHGatewayAddr": null,
+    "WETHGatewayAddr": null,
+    "StandardERC20GatewayAddr": null,
+    "CustomERC20GatewayAddr": null,
+    "ERC721GatewayAddr": null,
+    "ERC1155GatewayAddr": null,
+    "USDCGatewayAddr": "0x0000000000000000000000000000000000000000",
+    "LIDOGatewayAddr": "0x0000000000000000000000000000000000000000",
+    "DAIGatewayAddr": "0x0000000000000000000000000000000000000000",
+    "PufferGatewayAddr": "0x0000000000000000000000000000000000000000"
+  },
+  "L2": {
+    "confirmation": 0,
+    "endpoint": null,
+    "blockTime": 3,
+    "fetchLimit": 64,
+    "MessageQueueAddr": null,
+    "MessengerAddr": null,
+    "GatewayRouterAddr": null,
+    "ETHGatewayAddr": null,
+    "WETHGatewayAddr": null,
+    "StandardERC20GatewayAddr": null,
+    "CustomERC20GatewayAddr": null,
+    "ERC721GatewayAddr": null,
+    "ERC1155GatewayAddr": null,
+    "USDCGatewayAddr": "0x0000000000000000000000000000000000000000",
+    "LIDOGatewayAddr": "0x0000000000000000000000000000000000000000",
+    "DAIGatewayAddr": "0x0000000000000000000000000000000000000000",
+    "PufferGatewayAddr": "0x0000000000000000000000000000000000000000"
+  },
+  "db": {
+    "dsn": null,
+    "driverName": "postgres",
+    "maxOpenNum": 200,
+    "maxIdleNum": 20
+  },
+  "redis": {
+    "address": "localhost:6379",
+    "username": "default",
+    "password": "",
+    "local": true,
+    "minIdleConns": 10,
+    "readTimeoutMs": 500
+  }
+}

contracts/docker/templates/chain-monitor-config.json

@@ -0,0 +1,56 @@
+{
+  "l1_config": {
+    "l1_url": null,
+    "confirm": "0x20",
+    "start_number": null,
+    "l1_contracts": {
+        "l1_gateways": {
+          "eth_gateway": null,
+          "weth_gateway": null,
+          "standard_erc20_gateway": null,
+          "custom_erc20_gateway": null,
+          "erc721_gateway": null,
+          "erc1155_gateway": null,
+          "dai_gateway": "0x0000000000000000000000000000000000000000",
+          "usdc_gateway": "0x0000000000000000000000000000000000000000",
+          "lido_gateway": "0x0000000000000000000000000000000000000000",
+          "puffer_gateway": "0x0000000000000000000000000000000000000000"
+        },
+        "scroll_messenger": null,
+        "message_queue": null,
+        "scroll_chain": null
+    },
+    "start_messenger_balance": null
+  },
+  "l2_config": {
+    "l2_url": null,
+    "confirm": "0x80",
+    "l2_contracts": {
+        "l2_gateways": {
+          "eth_gateway": null,
+          "weth_gateway": null,
+          "standard_erc20_gateway": null,
+          "custom_erc20_gateway": null,
+          "erc721_gateway": null,
+          "erc1155_gateway": null,
+          "dai_gateway": "0x0000000000000000000000000000000000000000",
+          "usdc_gateway": "0x0000000000000000000000000000000000000000",
+          "lido_gateway": "0x0000000000000000000000000000000000000000",
+          "puffer_gateway": "0x0000000000000000000000000000000000000000"
+        },
+        "scroll_messenger": null,
+        "message_queue": null
+    }
+  },
+  "slack_webhook_config": {
+    "webhook_url": "http://localhost:1234",
+    "worker_count": 5,
+    "worker_buffer_size": 1000
+  },
+  "db_config": {
+    "driver_name": "postgres",
+    "dsn": null,
+    "maxOpenNum": 100,
+    "maxIdleNum": 20
+  }
+}

contracts/docker/templates/config-contracts.toml

@@ -0,0 +1,55 @@
+L1_WETH_ADDR = ""
+L1_PROXY_ADMIN_ADDR = ""
+L1_PROXY_IMPLEMENTATION_PLACEHOLDER_ADDR = ""
+L1_WHITELIST_ADDR = ""
+L2_GAS_PRICE_ORACLE_IMPLEMENTATION_ADDR = ""
+L2_GAS_PRICE_ORACLE_PROXY_ADDR = ""
+L1_SCROLL_CHAIN_PROXY_ADDR = ""
+L1_SCROLL_MESSENGER_PROXY_ADDR = ""
+L1_ENFORCED_TX_GATEWAY_IMPLEMENTATION_ADDR = ""
+L1_ENFORCED_TX_GATEWAY_PROXY_ADDR = ""
+L1_ZKEVM_VERIFIER_V1_ADDR = ""
+L1_MULTIPLE_VERSION_ROLLUP_VERIFIER_ADDR = ""
+L1_MESSAGE_QUEUE_IMPLEMENTATION_ADDR = ""
+L1_MESSAGE_QUEUE_PROXY_ADDR = ""
+L1_SCROLL_CHAIN_IMPLEMENTATION_ADDR = ""
+L1_GATEWAY_ROUTER_IMPLEMENTATION_ADDR = ""
+L1_GATEWAY_ROUTER_PROXY_ADDR = ""
+L1_ETH_GATEWAY_PROXY_ADDR = ""
+L1_WETH_GATEWAY_PROXY_ADDR = ""
+L1_STANDARD_ERC20_GATEWAY_PROXY_ADDR = ""
+L1_CUSTOM_ERC20_GATEWAY_PROXY_ADDR = ""
+L1_ERC721_GATEWAY_PROXY_ADDR = ""
+L1_ERC1155_GATEWAY_PROXY_ADDR = ""
+L2_MESSAGE_QUEUE_ADDR = ""
+L1_GAS_PRICE_ORACLE_ADDR = ""
+L2_WHITELIST_ADDR = ""
+L2_WETH_ADDR = ""
+L2_TX_FEE_VAULT_ADDR = ""
+L2_PROXY_ADMIN_ADDR = ""
+L2_PROXY_IMPLEMENTATION_PLACEHOLDER_ADDR = ""
+L2_SCROLL_MESSENGER_PROXY_ADDR = ""
+L2_ETH_GATEWAY_PROXY_ADDR = ""
+L2_WETH_GATEWAY_PROXY_ADDR = ""
+L2_STANDARD_ERC20_GATEWAY_PROXY_ADDR = ""
+L2_CUSTOM_ERC20_GATEWAY_PROXY_ADDR = ""
+L2_ERC721_GATEWAY_PROXY_ADDR = ""
+L2_ERC1155_GATEWAY_PROXY_ADDR = ""
+L2_SCROLL_STANDARD_ERC20_ADDR = ""
+L2_SCROLL_STANDARD_ERC20_FACTORY_ADDR = ""
+L1_SCROLL_MESSENGER_IMPLEMENTATION_ADDR = ""
+L1_STANDARD_ERC20_GATEWAY_IMPLEMENTATION_ADDR = ""
+L1_ETH_GATEWAY_IMPLEMENTATION_ADDR = ""
+L1_WETH_GATEWAY_IMPLEMENTATION_ADDR = ""
+L1_CUSTOM_ERC20_GATEWAY_IMPLEMENTATION_ADDR = ""
+L1_ERC721_GATEWAY_IMPLEMENTATION_ADDR = ""
+L1_ERC1155_GATEWAY_IMPLEMENTATION_ADDR = ""
+L2_SCROLL_MESSENGER_IMPLEMENTATION_ADDR = ""
+L2_GATEWAY_ROUTER_IMPLEMENTATION_ADDR = ""
+L2_GATEWAY_ROUTER_PROXY_ADDR = ""
+L2_STANDARD_ERC20_GATEWAY_IMPLEMENTATION_ADDR = ""
+L2_ETH_GATEWAY_IMPLEMENTATION_ADDR = ""
+L2_WETH_GATEWAY_IMPLEMENTATION_ADDR = ""
+L2_CUSTOM_ERC20_GATEWAY_IMPLEMENTATION_ADDR = ""
+L2_ERC721_GATEWAY_IMPLEMENTATION_ADDR = ""
+L2_ERC1155_GATEWAY_IMPLEMENTATION_ADDR = ""

contracts/docker/templates/coordinator-config.json

@@ -0,0 +1,30 @@
+{
+  "prover_manager": {
+    "provers_per_session": 1,
+    "session_attempts": 100,
+    "chunk_collection_time_sec": 3600,
+    "batch_collection_time_sec": 600,
+    "verifier": {
+      "fork_name": "bernoulli",
+      "mock_mode": false,
+      "params_path": "/verifier/params",
+      "assets_path": "/verifier/assets"
+    },
+    "max_verifier_workers": 4,
+    "min_prover_version": "v4.3.41"
+  },
+  "db": {
+    "driver_name": "postgres",
+    "dsn": null,
+    "maxOpenNum": 200,
+    "maxIdleNum": 20
+  },
+  "l2": {
+    "chain_id": null
+  },
+  "auth": {
+    "secret": null,
+    "challenge_expire_duration_sec": 10,
+    "login_expire_duration_sec": 3600
+  }
+}

contracts/docker/templates/genesis.json

@@ -0,0 +1,48 @@
+{
+  "config": {
+    "chainId": null,
+    "homesteadBlock": 0,
+    "eip150Block": 0,
+    "eip150Hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "eip155Block": 0,
+    "eip158Block": 0,
+    "byzantiumBlock": 0,
+    "constantinopleBlock": 0,
+    "petersburgBlock": 0,
+    "istanbulBlock": 0,
+    "berlinBlock": 0,
+    "londonBlock": 0,
+    "archimedesBlock": 0,
+    "shanghaiBlock": 0,
+    "bernoulliBlock": 0,
+    "curieBlock": 0,
+    "clique": {
+      "period": 3,
+      "epoch": 30000
+    },
+    "scroll": {
+      "useZktrie": true,
+      "maxTxPerBlock": null,
+      "maxTxPayloadBytesPerBlock": 122880,
+      "feeVaultAddress": null,
+      "l1Config": {
+        "l1ChainId": null,
+        "l1MessageQueueAddress": null,
+        "scrollChainAddress": null,
+        "numL1MessagesPerBlock": "10"
+      }
+    }
+  },
+  "nonce": "0x0",
+  "timestamp": null,
+  "extraData": null,
+  "gasLimit": "10000000",
+  "difficulty": "0x1",
+  "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "coinbase": "0x0000000000000000000000000000000000000000",
+  "alloc": {},
+  "number": "0x0",
+  "gasUsed": "0x0",
+  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "baseFeePerGas": null
+}

contracts/docker/templates/rollup-config.json

@@ -0,0 +1,87 @@
+{
+  "l1_config": {
+    "confirmations": "0x0",
+    "endpoint": null,
+    "l1_message_queue_address": null,
+    "scroll_chain_address": null,
+    "start_height": 0,
+    "relayer_config": {
+      "gas_price_oracle_contract_address": null,
+      "sender_config": {
+        "endpoint": null,
+        "escalate_blocks": 100,
+        "escalate_multiple_num": 11,
+        "escalate_multiple_den": 10,
+        "max_gas_price": 10000000000000,
+        "tx_type": "LegacyTx",
+        "check_pending_time": 3,
+        "confirmations": "0x0"
+      },
+      "gas_oracle_config": {
+        "min_gas_price": 0,
+        "gas_price_diff": 50000,
+        "l1_base_fee_weight": 0.086,
+        "l1_blob_base_fee_weight": 0.030
+      },
+      "gas_oracle_sender_private_key": null
+    }
+  },
+  "l2_config": {
+    "confirmations": "0x0",
+    "endpoint": null,
+    "l2_message_queue_address": null,
+    "relayer_config": {
+      "rollup_contract_address": null,
+      "gas_price_oracle_contract_address": null,
+      "sender_config": {
+        "endpoint": null,
+        "escalate_blocks": 4,
+        "escalate_multiple_num": 12,
+        "escalate_multiple_den": 10,
+        "max_gas_price": 200000000000,
+        "max_blob_gas_price": 200000000000,
+        "tx_type": "DynamicFeeTx",
+        "check_pending_time": 10,
+        "confirmations": "0x0"
+      },
+      "gas_oracle_config": {
+        "min_gas_price": 0,
+        "gas_price_diff": 50000
+      },
+      "chain_monitor": {
+        "enabled": true,
+        "timeout": 3,
+        "try_times": 5,
+        "base_url": "http://chain-monitorv2:8080"
+      },
+      "enable_test_env_bypass_features": null,
+      "finalize_batch_without_proof_timeout_sec": null,
+      "gas_oracle_sender_private_key": null,
+      "commit_sender_private_key": null,
+      "finalize_sender_private_key": null,
+      "l1_commit_gas_limit_multiplier": 1.2
+    },
+    "chunk_proposer_config": {
+      "max_block_num_per_chunk": null,
+      "max_tx_num_per_chunk": null,
+      "max_l1_commit_gas_per_chunk": 5000000,
+      "max_l1_commit_calldata_size_per_chunk": 110000,
+      "chunk_timeout_sec": 2700,
+      "max_row_consumption_per_chunk": 1000000,
+      "gas_cost_increase_multiplier": 1.2
+    },
+    "batch_proposer_config": {
+      "max_chunk_num_per_batch": 15,
+      "max_l1_commit_gas_per_batch": 5000000,
+      "max_l1_commit_calldata_size_per_batch": 110000,
+      "batch_timeout_sec": 2700,
+      "gas_cost_increase_multiplier": 1.2
+    }
+  },
+  "db_config": {
+    "driver_name": "postgres",
+    "dsn": null,
+    "maxOpenNum": 50,
+    "maxIdleNum": 20
+  }
+}

contracts/docs/apis/L2GatewayRouter.md

@@ -38,7 +38,7 @@ Mapping from L2 ERC20 token address to corresponding L2ERC20Gateway.
 function defaultERC20Gateway() external view returns (address)
 ```
 
-The addess of default L2 ERC20 gateway, normally the L2StandardERC20Gateway contract.
+The address of default L2 ERC20 gateway, normally the L2StandardERC20Gateway contract.
 
 
 

contracts/docs/apis/ScrollChain.md

@@ -945,7 +945,7 @@ error ErrorRevertFinalizedBatch()
 
 
 
-*Thrown when reverting a finialized batch.*
+*Thrown when reverting a finalized batch.*
 
 
 ### ErrorRevertNotStartFromEnd
@@ -956,7 +956,7 @@ error ErrorRevertNotStartFromEnd()
 
 
 
-*Thrown when the reverted batches are not in the ending of commited batch chain.*
+*Thrown when the reverted batches are not in the ending of committed batch chain.*
 
 
 ### ErrorRevertZeroBatches

contracts/foundry.toml

@@ -7,15 +7,13 @@ libs = []                                                     # a list of librar
 remappings = []                                               # a list of remappings
 libraries = []                                                # a list of deployed libraries to link against
 cache = true                                                  # whether to cache builds or not
-force = true                                                  # whether to ignore the cache (clean build)
-# evm_version = 'london'                                        # the evm version (by hardfork name)
+force = false                                                  # whether to ignore the cache (clean build)
+evm_version = 'cancun'                                        # the evm version (by hardfork name)
 solc_version = '0.8.24'                                      # override for the solc version (setting this ignores `auto_detect_solc`)
 optimizer = true                                              # enable or disable the solc optimizer
 optimizer_runs = 200                                          # the number of optimizer runs
 verbosity = 2                                                 # the verbosity of tests
-ignored_error_codes = []                                      # a list of ignored solc error codes
 fuzz_runs = 256                                               # the number of fuzz runs for tests
-ffi = false                                                   # whether to enable ffi or not
 sender = '0x00a329c0648769a73afac7f9381e08fb43dbea72'         # the address of `msg.sender` in tests
 tx_origin = '0x00a329c0648769a73afac7f9381e08fb43dbea72'      # the address of `tx.origin` in tests
 initial_balance = '0xffffffffffffffffffffffff'                # the initial balance of the test contract
@@ -27,4 +25,15 @@ block_coinbase = '0x0000000000000000000000000000000000000000' # the address of `
 block_timestamp = 0                                           # the value of `block.timestamp` in tests
 block_difficulty = 0                                          # the value of `block.difficulty` in tests
 
+# remove bytecode hash for reliable deterministic addresses
+bytecode_hash = 'none'
+
+# file system permissions
+ffi = true
+
+fs_permissions = [
+  { access='read', path='./docker' },
+  { access='read-write', path='./volume' },
+]
+
 gas_reports = ["L2GasPriceOracle"]

contracts/scripts/foundry/DeployL1BridgeContracts.s.sol

@@ -96,7 +96,7 @@ contract DeployL1BridgeContracts is Script {
         address[] memory _verifiers = new address[](1);
         _versions[0] = 0;
         _verifiers[0] = address(zkEvmVerifierV1);
-        rollupVerifier = new MultipleVersionRollupVerifier(L1_SCROLL_CHAIN_PROXY_ADDR, _versions, _verifiers);
+        rollupVerifier = new MultipleVersionRollupVerifier(_versions, _verifiers);
 
         logAddress("L1_MULTIPLE_VERSION_ROLLUP_VERIFIER_ADDR", address(rollupVerifier));
     }

contracts/src/L1/L1ScrollMessenger.sol

@@ -44,7 +44,7 @@ contract L1ScrollMessenger is ScrollMessengerBase, IL1ScrollMessenger {
     struct ReplayState {
         // The number of replayed times.
         uint128 times;
-        // The queue index of lastest replayed one. If it is zero, it means the message has not been replayed.
+        // The queue index of latest replayed one. If it is zero, it means the message has not been replayed.
         uint128 lastIndex;
     }
 

contracts/src/L1/gateways/L1ERC20Gateway.sol

@@ -167,7 +167,7 @@ abstract contract L1ERC20Gateway is IL1ERC20Gateway, IMessageDropCallback, Scrol
     /// @dev Internal function to do all the deposit operations.
     ///
     /// @param _token The token to deposit.
-    /// @param _to The recipient address to recieve the token in L2.
+    /// @param _to The recipient address to receive the token in L2.
     /// @param _amount The amount of token to deposit.
     /// @param _data Optional data to forward to recipient's account.
     /// @param _gasLimit Gas limit required to complete the deposit on L2.

contracts/src/L1/gateways/L1GatewayRouter.sol

@@ -25,7 +25,7 @@ contract L1GatewayRouter is OwnableUpgradeable, IL1GatewayRouter {
     /// @notice The address of L1ETHGateway.
     address public ethGateway;
 
-    /// @notice The addess of default ERC20 gateway, normally the L1StandardERC20Gateway contract.
+    /// @notice The address of default ERC20 gateway, normally the L1StandardERC20Gateway contract.
     address public defaultERC20Gateway;
 
     /// @notice Mapping from ERC20 token address to corresponding L1ERC20Gateway.

contracts/src/L1/gateways/L1StandardERC20Gateway.sol

@@ -97,7 +97,7 @@ contract L1StandardERC20Gateway is L1ERC20Gateway {
 
     /// @inheritdoc IL1ERC20Gateway
     function getL2ERC20Address(address _l1Token) public view override returns (address) {
-        // In StandardERC20Gateway, all corresponding l2 tokens are depoyed by Create2 with salt,
+        // In StandardERC20Gateway, all corresponding l2 tokens are deployed by Create2 with salt,
         // we can calculate the l2 address directly.
         bytes32 _salt = keccak256(abi.encodePacked(counterpart, keccak256(abi.encodePacked(_l1Token))));
 

contracts/src/L1/rollup/MultipleVersionRollupVerifier.sol

@@ -4,7 +4,6 @@ pragma solidity =0.8.24;
 
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 
-import {IScrollChain} from "./IScrollChain.sol";
 import {IRollupVerifier} from "../../libraries/verifier/IRollupVerifier.sol";
 import {IZkEvmVerifier} from "../../libraries/verifier/IZkEvmVerifier.sol";
 
@@ -28,19 +27,9 @@ contract MultipleVersionRollupVerifier is IRollupVerifier, Ownable {
     /// @dev Thrown when the given address is `address(0)`.
     error ErrorZeroAddress();
 
-    /// @dev Thrown when the given start batch index is finalized.
-    error ErrorStartBatchIndexFinalized();
-
     /// @dev Thrown when the given start batch index is smaller than `latestVerifier.startBatchIndex`.
     error ErrorStartBatchIndexTooSmall();
 
-    /*************
-     * Constants *
-     *************/
-
-    /// @notice The address of ScrollChain contract.
-    address public immutable scrollChain;
-
     /***********
      * Structs *
      ***********/
@@ -67,14 +56,7 @@ contract MultipleVersionRollupVerifier is IRollupVerifier, Ownable {
      * Constructor *
      ***************/
 
-    constructor(
-        address _scrollChain,
-        uint256[] memory _versions,
-        address[] memory _verifiers
-    ) {
-        if (_scrollChain == address(0)) revert ErrorZeroAddress();
-        scrollChain = _scrollChain;
-
+    constructor(uint256[] memory _versions, address[] memory _verifiers) {
         for (uint256 i = 0; i < _versions.length; i++) {
             if (_verifiers[i] == address(0)) revert ErrorZeroAddress();
             latestVerifier[_versions[i]].verifier = _verifiers[i];
@@ -157,8 +139,11 @@ contract MultipleVersionRollupVerifier is IRollupVerifier, Ownable {
         uint64 _startBatchIndex,
         address _verifier
     ) external onlyOwner {
-        if (_startBatchIndex <= IScrollChain(scrollChain).lastFinalizedBatchIndex())
-            revert ErrorStartBatchIndexFinalized();
+        // We are using version to decide the verifier to use and also this function is
+        // controlled by 7 days TimeLock. It is hard to predict `lastFinalizedBatchIndex` after 7 days.
+        // So we decide to remove this check to make verifier updating more easier.
+        // if (_startBatchIndex <= IScrollChain(scrollChain).lastFinalizedBatchIndex())
+        //    revert ErrorStartBatchIndexFinalized();
 
         Verifier memory _latestVerifier = latestVerifier[_version];
         if (_startBatchIndex < _latestVerifier.startBatchIndex) revert ErrorStartBatchIndexTooSmall();

contracts/src/L1/rollup/ScrollChain.sol

@@ -89,10 +89,10 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
     /// @dev Thrown when the number of batches to revert is zero.
     error ErrorRevertZeroBatches();
 
-    /// @dev Thrown when the reverted batches are not in the ending of commited batch chain.
+    /// @dev Thrown when the reverted batches are not in the ending of committed batch chain.
     error ErrorRevertNotStartFromEnd();
 
-    /// @dev Thrown when reverting a finialized batch.
+    /// @dev Thrown when reverting a finalized batch.
     error ErrorRevertFinalizedBatch();
 
     /// @dev Thrown when the given state root is zero.
@@ -112,11 +112,11 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
      *************/
 
     /// @dev Address of the point evaluation precompile used for EIP-4844 blob verification.
-    address private constant POINT_EVALUATION_PRECOMPILE_ADDR = address(0x0A);
+    address internal constant POINT_EVALUATION_PRECOMPILE_ADDR = address(0x0A);
 
     /// @dev BLS Modulus value defined in EIP-4844 and the magic value returned from a successful call to the
     /// point evaluation precompile
-    uint256 private constant BLS_MODULUS =
+    uint256 internal constant BLS_MODULUS =
         52435875175126190479447740508185965837690552500527637822603658699938581184513;
 
     /// @notice The chain id of the corresponding layer 2 chain.
@@ -580,7 +580,7 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
     /// @param _chunks The list of chunks to commit.
     /// @param _skippedL1MessageBitmap The bitmap indicates whether each L1 message is skipped or not.
     /// @return _batchDataHash The computed data hash for the list of chunks.
-    /// @return _totalL1MessagesPoppedInBatch The total number of L1 messages poped in this batch, including skipped one.
+    /// @return _totalL1MessagesPoppedInBatch The total number of L1 messages popped in this batch, including skipped one.
     function _commitChunksV0(
         uint256 _totalL1MessagesPoppedOverall,
         bytes[] memory _chunks,
@@ -627,7 +627,7 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
     /// @param _skippedL1MessageBitmap The bitmap indicates whether each L1 message is skipped or not.
     /// @return _blobVersionedHash The blob versioned hash for the blob carried in this transaction.
     /// @return _batchDataHash The computed data hash for the list of chunks.
-    /// @return _totalL1MessagesPoppedInBatch The total number of L1 messages poped in this batch, including skipped one.
+    /// @return _totalL1MessagesPoppedInBatch The total number of L1 messages popped in this batch, including skipped one.
     function _commitChunksV1(
         uint256 _totalL1MessagesPoppedOverall,
         bytes[] memory _chunks,
@@ -950,7 +950,7 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
 
     /// @dev Internal function to pop finalized l1 messages.
     /// @param bitmapPtr The memory offset of `skippedL1MessageBitmap`.
-    /// @param totalL1MessagePopped The total number of L1 messages poped in all batches including current batch.
+    /// @param totalL1MessagePopped The total number of L1 messages popped in all batches including current batch.
     /// @param l1MessagePopped The number of L1 messages popped in current batch.
     function _popL1Messages(
         uint256 bitmapPtr,

contracts/src/L2/gateways/L2GatewayRouter.sol

@@ -21,7 +21,7 @@ contract L2GatewayRouter is OwnableUpgradeable, IL2GatewayRouter {
     /// @notice The address of L2ETHGateway.
     address public ethGateway;
 
-    /// @notice The addess of default L2 ERC20 gateway, normally the L2StandardERC20Gateway contract.
+    /// @notice The address of default L2 ERC20 gateway, normally the L2StandardERC20Gateway contract.
     address public defaultERC20Gateway;
 
     /// @notice Mapping from L2 ERC20 token address to corresponding L2ERC20Gateway.

contracts/src/L2/predeploys/L1BlockContainer.sol

@@ -242,7 +242,7 @@ contract L1BlockContainer is OwnableBase, IL1BlockContainer {
             let _computedBlockHash := keccak256(memPtr, headerPayloadLength)
             require(eq(_blockHash, _computedBlockHash), "Block hash mismatch")
 
-            // load 16 vaules
+            // load 16 values
             for {
                 let i := 0
             } lt(i, 16) {

contracts/src/L2/predeploys/L1GasPriceOracle.sol

@@ -60,7 +60,7 @@ contract L1GasPriceOracle is OwnableBase, IL1GasPriceOracle {
     /// commit_scalar = commit_gas_per_tx * fluctuation_multiplier * 1e9
     /// ```
     /// So, the value should not exceed 10^9 * 1e9 normally.
-    uint256 private constant MAX_COMMIT_SCALAR = 10 ** 9 * PRECISION;
+    uint256 private constant MAX_COMMIT_SCALAR = 10**9 * PRECISION;
 
     /// @dev The maximum possible l1 blob fee scalar after Curie.
     /// We derive the blob scalar by
@@ -68,7 +68,7 @@ contract L1GasPriceOracle is OwnableBase, IL1GasPriceOracle {
     /// blob_scalar = fluctuation_multiplier / compression_ratio / blob_util_ratio * 1e9
     /// ```
     /// So, the value should not exceed 10^9 * 1e9 normally.
-    uint256 private constant MAX_BLOB_SCALAR = 10 ** 9 * PRECISION;
+    uint256 private constant MAX_BLOB_SCALAR = 10**9 * PRECISION;
 
     /*************
      * Variables *
@@ -113,6 +113,9 @@ contract L1GasPriceOracle is OwnableBase, IL1GasPriceOracle {
 
     constructor(address _owner) {
         _transferOwnership(_owner);
+
+        // by default we enable Curie from genesis
+        isCurie = true;
     }
 
     /*************************
@@ -150,10 +153,11 @@ contract L1GasPriceOracle is OwnableBase, IL1GasPriceOracle {
     }
 
     /// @inheritdoc IL1GasPriceOracle
-    function setL1BaseFeeAndBlobBaseFee(
-        uint256 _l1BaseFee,
-        uint256 _l1BlobBaseFee
-    ) external override onlyWhitelistedSender {
+    function setL1BaseFeeAndBlobBaseFee(uint256 _l1BaseFee, uint256 _l1BlobBaseFee)
+        external
+        override
+        onlyWhitelistedSender
+    {
         l1BaseFee = _l1BaseFee;
         l1BlobBaseFee = _l1BlobBaseFee;
 

contracts/src/libraries/token/ScrollStandardERC20Factory.sol

@@ -23,7 +23,7 @@ contract ScrollStandardERC20Factory is Ownable, IScrollStandardERC20Factory {
 
     /// @inheritdoc IScrollStandardERC20Factory
     function computeL2TokenAddress(address _gateway, address _l1Token) external view returns (address) {
-        // In StandardERC20Gateway, all corresponding l2 tokens are depoyed by Create2 with salt,
+        // In StandardERC20Gateway, all corresponding l2 tokens are deployed by Create2 with salt,
         // we can calculate the l2 address directly.
         bytes32 _salt = _getSalt(_gateway, _l1Token);
 

contracts/src/libraries/verifier/PatriciaMerkleTrieVerifier.sol

@@ -369,7 +369,7 @@ library PatriciaMerkleTrieVerifier {
 
                     // first item is considered the root node.
                     // Otherwise verifies that the hash of the current node
-                    // is the same as the previous choosen one.
+                    // is the same as the previous chosen one.
                     switch i
                     case 1 {
                         rootHash := hash
@@ -425,7 +425,7 @@ library PatriciaMerkleTrieVerifier {
                     }
                 }
 
-                // lastly, derive the path of the choosen one (TM)
+                // lastly, derive the path of the chosen one (TM)
                 path := derivePath(key, depth)
             }
 

contracts/src/libraries/verifier/ZkTrieVerifier.sol

@@ -113,7 +113,7 @@ library ZkTrieVerifier {
 
                     // first item is considered the root node.
                     // Otherwise verifies that the hash of the current node
-                    // is the same as the previous choosen one.
+                    // is the same as the previous chosen one.
                     switch depth
                     case 1 {
                         rootHash := hash
@@ -262,7 +262,7 @@ library ZkTrieVerifier {
             ptr, storageValue := verifyStorageProof(poseidon, storageKey, storageRootHash, ptr)
 
             // the one and only boundary check
-            // in case an attacker crafted a malicous payload
+            // in case an attacker crafted a malicious payload
             // and succeeds in the prior verification steps
             // then this should catch any bogus accesses
             if iszero(eq(ptr, add(proof.offset, proof.length))) {

contracts/src/mocks/ScrollChainMockFinalize.sol

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity =0.8.24;
+
+import {ScrollChain} from "../L1/rollup/ScrollChain.sol";
+
+import {BatchHeaderV0Codec} from "../libraries/codec/BatchHeaderV0Codec.sol";
+import {BatchHeaderV1Codec} from "../libraries/codec/BatchHeaderV1Codec.sol";
+
+contract ScrollChainMockFinalize is ScrollChain {
+    /***************
+     * Constructor *
+     ***************/
+
+    /// @notice Constructor for `ScrollChain` implementation contract.
+    ///
+    /// @param _chainId The chain id of L2.
+    /// @param _messageQueue The address of `L1MessageQueue` contract.
+    /// @param _verifier The address of zkevm verifier contract.
+    constructor(
+        uint64 _chainId,
+        address _messageQueue,
+        address _verifier
+    ) ScrollChain(_chainId, _messageQueue, _verifier) {}
+
+    /*****************************
+     * Public Mutating Functions *
+     *****************************/
+
+    function finalizeBatch(
+        bytes calldata _batchHeader,
+        bytes32 _prevStateRoot,
+        bytes32 _postStateRoot,
+        bytes32 _withdrawRoot
+    ) external OnlyProver whenNotPaused {
+        require(_prevStateRoot != bytes32(0), "previous state root is zero");
+        require(_postStateRoot != bytes32(0), "new state root is zero");
+
+        // compute batch hash and verify
+        (uint256 memPtr, bytes32 _batchHash, uint256 _batchIndex, ) = _loadBatchHeader(_batchHeader);
+
+        // verify previous state root.
+        require(finalizedStateRoots[_batchIndex - 1] == _prevStateRoot, "incorrect previous state root");
+
+        // avoid duplicated verification
+        require(finalizedStateRoots[_batchIndex] == bytes32(0), "batch already verified");
+
+        // check and update lastFinalizedBatchIndex
+        unchecked {
+            require(lastFinalizedBatchIndex + 1 == _batchIndex, "incorrect batch index");
+            lastFinalizedBatchIndex = _batchIndex;
+        }
+
+        // record state root and withdraw root
+        finalizedStateRoots[_batchIndex] = _postStateRoot;
+        withdrawRoots[_batchIndex] = _withdrawRoot;
+
+        // Pop finalized and non-skipped message from L1MessageQueue.
+        _popL1Messages(
+            BatchHeaderV0Codec.getSkippedBitmapPtr(memPtr),
+            BatchHeaderV0Codec.getTotalL1MessagePopped(memPtr),
+            BatchHeaderV0Codec.getL1MessagePopped(memPtr)
+        );
+
+        emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot);
+    }
+
+    function finalizeBatch4844(
+        bytes calldata _batchHeader,
+        bytes32 _prevStateRoot,
+        bytes32 _postStateRoot,
+        bytes32 _withdrawRoot,
+        bytes calldata _blobDataProof
+    ) external OnlyProver whenNotPaused {
+        if (_prevStateRoot == bytes32(0)) revert ErrorPreviousStateRootIsZero();
+        if (_postStateRoot == bytes32(0)) revert ErrorStateRootIsZero();
+
+        // compute batch hash and verify
+        (uint256 memPtr, bytes32 _batchHash, uint256 _batchIndex, ) = _loadBatchHeader(_batchHeader);
+        bytes32 _blobVersionedHash = BatchHeaderV1Codec.getBlobVersionedHash(memPtr);
+
+        // Calls the point evaluation precompile and verifies the output
+        {
+            (bool success, bytes memory data) = POINT_EVALUATION_PRECOMPILE_ADDR.staticcall(
+                abi.encodePacked(_blobVersionedHash, _blobDataProof)
+            );
+            // We verify that the point evaluation precompile call was successful by testing the latter 32 bytes of the
+            // response is equal to BLS_MODULUS as defined in https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
+            if (!success) revert ErrorCallPointEvaluationPrecompileFailed();
+            (, uint256 result) = abi.decode(data, (uint256, uint256));
+            if (result != BLS_MODULUS) revert ErrorUnexpectedPointEvaluationPrecompileOutput();
+        }
+
+        // verify previous state root.
+        if (finalizedStateRoots[_batchIndex - 1] != _prevStateRoot) revert ErrorIncorrectPreviousStateRoot();
+
+        // avoid duplicated verification
+        if (finalizedStateRoots[_batchIndex] != bytes32(0)) revert ErrorBatchIsAlreadyVerified();
+
+        // check and update lastFinalizedBatchIndex
+        unchecked {
+            if (lastFinalizedBatchIndex + 1 != _batchIndex) revert ErrorIncorrectBatchIndex();
+            lastFinalizedBatchIndex = _batchIndex;
+        }
+
+        // record state root and withdraw root
+        finalizedStateRoots[_batchIndex] = _postStateRoot;
+        withdrawRoots[_batchIndex] = _withdrawRoot;
+
+        // Pop finalized and non-skipped message from L1MessageQueue.
+        _popL1Messages(
+            BatchHeaderV1Codec.getSkippedBitmapPtr(memPtr),
+            BatchHeaderV1Codec.getTotalL1MessagePopped(memPtr),
+            BatchHeaderV1Codec.getL1MessagePopped(memPtr)
+        );
+
+        emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot);
+    }
+}

contracts/src/test/L1GasPriceOracle.t.sol

@@ -11,8 +11,8 @@ contract L1GasPriceOracleTest is DSTestPlus {
     uint256 private constant PRECISION = 1e9;
     uint256 private constant MAX_OVERHEAD = 30000000 / 16;
     uint256 private constant MAX_SCALAR = 1000 * PRECISION;
-    uint256 private constant MAX_COMMIT_SCALAR = 10 ** 9 * PRECISION;
-    uint256 private constant MAX_BLOB_SCALAR = 10 ** 9 * PRECISION;
+    uint256 private constant MAX_COMMIT_SCALAR = 10**9 * PRECISION;
+    uint256 private constant MAX_BLOB_SCALAR = 10**9 * PRECISION;
 
     L1GasPriceOracle private oracle;
     Whitelist private whitelist;

contracts/src/test/MultipleVersionRollupVerifier.t.sol

@@ -18,19 +18,17 @@ contract MultipleVersionRollupVerifierTest is DSTestPlus {
     MockZkEvmVerifier private v0;
     MockZkEvmVerifier private v1;
     MockZkEvmVerifier private v2;
-    MockScrollChain private chain;
 
     function setUp() external {
         v0 = new MockZkEvmVerifier();
         v1 = new MockZkEvmVerifier();
         v2 = new MockZkEvmVerifier();
 
-        chain = new MockScrollChain(address(1), address(1));
         uint256[] memory _versions = new uint256[](1);
         address[] memory _verifiers = new address[](1);
         _versions[0] = 0;
         _verifiers[0] = address(v0);
-        verifier = new MultipleVersionRollupVerifier(address(chain), _versions, _verifiers);
+        verifier = new MultipleVersionRollupVerifier(_versions, _verifiers);
     }
 
     function testUpdateVerifierVersion0(address _newVerifier) external {
@@ -42,10 +40,6 @@ contract MultipleVersionRollupVerifierTest is DSTestPlus {
         verifier.updateVerifier(0, 0, address(0));
         hevm.stopPrank();
 
-        // start batch index finalized, revert
-        hevm.expectRevert(MultipleVersionRollupVerifier.ErrorStartBatchIndexFinalized.selector);
-        verifier.updateVerifier(0, 0, address(1));
-
         // zero verifier address, revert
         hevm.expectRevert(MultipleVersionRollupVerifier.ErrorZeroAddress.selector);
         verifier.updateVerifier(0, 1, address(0));
@@ -93,10 +87,6 @@ contract MultipleVersionRollupVerifierTest is DSTestPlus {
         verifier.updateVerifier(version, 0, address(0));
         hevm.stopPrank();
 
-        // start batch index finalized, revert
-        hevm.expectRevert(MultipleVersionRollupVerifier.ErrorStartBatchIndexFinalized.selector);
-        verifier.updateVerifier(version, 0, address(1));
-
         // zero verifier address, revert
         hevm.expectRevert(MultipleVersionRollupVerifier.ErrorZeroAddress.selector);
         verifier.updateVerifier(version, 1, address(0));

coordinator/Makefile

@@ -19,7 +19,6 @@ test:
 libzkp:
 	cd ../common/libzkp/impl && cargo clean && cargo build --release && cp ./target/release/libzkp.so ../interface/
 	rm -rf ./internal/logic/verifier/lib && cp -r ../common/libzkp/interface ./internal/logic/verifier/lib
-	find ../common | grep libzktrie.so | xargs -I{} cp {} ./internal/logic/verifier/lib
 
 coordinator_api: libzkp ## Builds the Coordinator api instance.
 	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_api ./cmd/api

coordinator/internal/controller/api/get_task.go

@@ -18,7 +18,6 @@ import (
 	"scroll-tech/coordinator/internal/logic/provertask"
 	"scroll-tech/coordinator/internal/logic/verifier"
 	coordinatorType "scroll-tech/coordinator/internal/types"
-	itypes "scroll-tech/coordinator/internal/types"
 )
 
 // GetTaskController the get prover task api controller
@@ -71,10 +70,6 @@ func (ptc *GetTaskController) incGetTaskAccessCounter(ctx *gin.Context) error {
 
 // GetTasks get assigned chunk/batch task
 func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
-	ctx.Set(itypes.PublicKey, "fake_public_key2")
-	ctx.Set(itypes.ProverName, "test")
-	ctx.Set(itypes.ProverVersion, "v4.4.9-000000-000000-000000")
-
 	var getTaskParameter coordinatorType.GetTaskParameter
 	if err := ctx.ShouldBind(&getTaskParameter); err != nil {
 		nerr := fmt.Errorf("prover task parameter invalid, err:%w", err)

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -82,7 +82,7 @@ func (r *chunkIndexRange) merge(o chunkIndexRange) *chunkIndexRange {
 }
 
 func (r *chunkIndexRange) contains(start, end uint64) bool {
-	return r.start <= start && r.end >= end+1
+	return r.start <= start && r.end > end
 }
 
 type getHardForkNameByBatchFunc func(*orm.Batch) (string, error)
@@ -137,7 +137,7 @@ func (bp *BatchProverTask) doAssignTaskWithinChunkRange(ctx *gin.Context, taskCt
 		return nil, nil
 	}
 
-	log.Info("start batch proof generation session", "id", batchTask.Hash, "public key", taskCtx.PublicKey, "prover name", taskCtx.ProverName)
+	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
@@ -146,7 +146,7 @@ func (bp *BatchProverTask) doAssignTaskWithinChunkRange(ctx *gin.Context, taskCt
 	if getHardForkName != nil {
 		hardForkName, err = getHardForkName(batchTask)
 		if err != nil {
-			log.Error("failed to get version by chunk", "error", err.Error())
+			log.Error("failed to get hard fork name by batch", "task_id", batchTask.Hash, "error", err.Error())
 			return nil, ErrCoordinatorInternalFailure
 		}
 	}
@@ -166,14 +166,14 @@ func (bp *BatchProverTask) doAssignTaskWithinChunkRange(ctx *gin.Context, taskCt
 	// Store session info.
 	if err = bp.proverTaskOrm.InsertProverTask(ctx.Copy(), &proverTask); err != nil {
 		bp.recoverActiveAttempts(ctx, batchTask)
-		log.Error("insert batch prover task info fail", "taskID", batchTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
+		log.Error("insert batch prover task info fail", "task_id", batchTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
 		return nil, ErrCoordinatorInternalFailure
 	}
 
 	taskMsg, err := bp.formatProverTask(ctx.Copy(), &proverTask)
 	if err != nil {
 		bp.recoverActiveAttempts(ctx, batchTask)
-		log.Error("format prover task failure", "hash", batchTask.Hash, "err", err)
+		log.Error("format prover task failure", "task_id", batchTask.Hash, "err", err)
 		return nil, ErrCoordinatorInternalFailure
 	}
 
@@ -222,7 +222,6 @@ func (bp *BatchProverTask) getChunkRangeByName(ctx *gin.Context, hardForkName st
 			endChunkIndex = toChunk.Index
 		}
 	}
-	fmt.Printf("%s index range %+v\n", hardForkName, &chunkIndexRange{startChunkIndex, endChunkIndex})
 	return &chunkIndexRange{startChunkIndex, endChunkIndex}, nil
 }
 
@@ -243,21 +242,28 @@ func (bp *BatchProverTask) assignWithTwoCircuits(ctx *gin.Context, taskCtx *prov
 		chunkRanges   [2]*chunkIndexRange
 		err           error
 	)
+	var chunkRange *chunkIndexRange
 	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
+		if chunkRanges[i] != nil {
+			if chunkRange == nil {
+				chunkRange = chunkRanges[i]
+			} else {
+				chunkRange = chunkRange.merge(*chunkRanges[i])
+			}
 		}
 	}
-	chunkRange := chunkRanges[0].merge(*chunkRanges[1])
+	if chunkRange == nil {
+		return nil, nil
+	}
 	var hardForkName string
 	getHardForkName := func(batch *orm.Batch) (string, error) {
 		for i := 0; i < 2; i++ {
-			if chunkRanges[i].contains(batch.StartChunkIndex, batch.EndChunkIndex) {
+			if chunkRanges[i] != nil && chunkRanges[i].contains(batch.StartChunkIndex, batch.EndChunkIndex) {
 				hardForkName = hardForkNames[i]
 				break
 			}

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -118,16 +118,16 @@ func (cp *ChunkProverTask) doAssignTaskWithinBlockRange(ctx *gin.Context, taskCt
 		return nil, nil
 	}
 
-	log.Info("start chunk generation session", "id", chunkTask.Hash, "public key", taskCtx.PublicKey, "prover name", taskCtx.ProverName)
+	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
 	)
-	var err error
 	if getHardForkName != nil {
 		hardForkName, err = getHardForkName(chunkTask)
 		if err != nil {
-			log.Error("failed to get version by chunk", "error", err.Error())
+			log.Error("failed to get hard fork name by chunk", "task_id", chunkTask.Hash, "error", err.Error())
 			return nil, ErrCoordinatorInternalFailure
 		}
 	}
@@ -146,14 +146,14 @@ func (cp *ChunkProverTask) doAssignTaskWithinBlockRange(ctx *gin.Context, taskCt
 
 	if err = cp.proverTaskOrm.InsertProverTask(ctx.Copy(), &proverTask); err != nil {
 		cp.recoverActiveAttempts(ctx, chunkTask)
-		log.Error("insert chunk prover task fail", "taskID", chunkTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
+		log.Error("insert chunk prover task fail", "task_id", chunkTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
 		return nil, ErrCoordinatorInternalFailure
 	}
 
 	taskMsg, err := cp.formatProverTask(ctx.Copy(), &proverTask)
 	if err != nil {
 		cp.recoverActiveAttempts(ctx, chunkTask)
-		log.Error("format prover task failure", "hash", chunkTask.Hash, "err", err)
+		log.Error("format prover task failure", "task_id", chunkTask.Hash, "err", err)
 		return nil, ErrCoordinatorInternalFailure
 	}
 
@@ -229,7 +229,7 @@ func (r *blockRange) merge(o blockRange) (*blockRange, error) {
 }
 
 func (r *blockRange) contains(start, end uint64) bool {
-	return r.from <= start && r.to >= end+1
+	return r.from <= start && r.to > end
 }
 
 func (cp *ChunkProverTask) getBlockRangeByName(hardForkName string) (*blockRange, error) {
@@ -251,7 +251,6 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	}
 
 	if len(getTaskParameter.VKs) > 0 {
-
 		return cp.assignWithTwoCircuits(ctx, taskCtx, getTaskParameter)
 	}
 	return cp.assignWithSingleCircuit(ctx, taskCtx, getTaskParameter)

coordinator/internal/logic/provertask/prover_task.go

@@ -32,7 +32,9 @@ type ProverTask interface {
 func reverseMap(input map[string]string) map[string]string {
 	output := make(map[string]string, len(input))
 	for k, v := range input {
-		output[v] = k
+		if k != "" {
+			output[v] = k
+		}
 	}
 	return output
 }
@@ -94,13 +96,7 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context, getTaskParameter *coor
 		if len(getTaskParameter.VKs) != 2 {
 			return nil, fmt.Errorf("parameter vks length must be 2")
 		}
-		// min prover version supporting multi circuits, maybe put it to config file?
-		var minMultiCircuitsProverVersion = "v4.4.7"
-		if !version.CheckScrollRepoVersion(ptc.ProverVersion, minMultiCircuitsProverVersion) {
-			return nil, fmt.Errorf("incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", minMultiCircuitsProverVersion, ptc.ProverVersion)
-		}
 		for _, vk := range getTaskParameter.VKs {
-			fmt.Printf("%+v\n", b.reverseVkMap)
 			if _, exists := b.reverseVkMap[vk]; !exists {
 				return nil, fmt.Errorf("incompatible vk. vk %s is invalid", vk)
 			}
@@ -131,10 +127,10 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context, getTaskParameter *coor
 
 	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", publicKey, err, proverName)
+		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)
 	}
 	if isBlocked {
-		return nil, fmt.Errorf("public key %s is blocked from fetching tasks. ProverName: %s, ProverVersion: %s", publicKey, proverName, ptc.ProverVersion)
+		return nil, fmt.Errorf("public key %s is blocked from fetching tasks. ProverName: %s, ProverVersion: %s", publicKey, proverName, proverVersion)
 	}
 
 	isAssigned, err := b.proverTaskOrm.IsProverAssigned(ctx.Copy(), publicKey.(string))
@@ -143,7 +139,7 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context, getTaskParameter *coor
 	}
 
 	if isAssigned {
-		return nil, fmt.Errorf("prover with publicKey %s is already assigned a task. ProverName: %s", publicKey, proverName)
+		return nil, fmt.Errorf("prover with publicKey %s is already assigned a task. ProverName: %s, ProverVersion: %s", publicKey, proverName, proverVersion)
 	}
 	return &ptc, nil
 }

coordinator/internal/logic/verifier/mock.go

@@ -12,17 +12,17 @@ import (
 func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 	batchVKMap := map[string]string{
 		"shanghai":  "",
-		"bernoulli": "bernoulli",
-		"london":    "london",
-		"istanbul":  "istanbul",
+		"bernoulli": "",
+		"london":    "",
+		"istanbul":  "",
 		"homestead": "",
 		"eip155":    "",
 	}
 	chunkVKMap := map[string]string{
 		"shanghai":  "",
-		"bernoulli": "bernoulli",
-		"london":    "london",
-		"istanbul":  "istanbul",
+		"bernoulli": "",
+		"london":    "",
+		"istanbul":  "",
 		"homestead": "",
 		"eip155":    "",
 	}

coordinator/internal/logic/verifier/verifier.go

@@ -3,8 +3,8 @@
 package verifier
 
 /*
-#cgo LDFLAGS: -lzkp -lm -ldl -lzktrie -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
-#cgo gpu LDFLAGS: -lzkp -lm -ldl -lgmp -lstdc++ -lprocps -lzktrie -L/usr/local/cuda/lib64/ -lcudart -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
+#cgo LDFLAGS: -lzkp -lm -ldl -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
+#cgo gpu LDFLAGS: -lzkp -lm -ldl -lgmp -lstdc++ -lprocps -L/usr/local/cuda/lib64/ -lcudart -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
 #include <stdlib.h>
 #include "./lib/libzkp.h"
 */
@@ -166,7 +166,5 @@ func (v *Verifier) loadEmbedVK() error {
 
 	v.BatchVKMap["bernoulli"] = base64.StdEncoding.EncodeToString(batchVKBytes)
 	v.ChunkVKMap["bernoulli"] = base64.StdEncoding.EncodeToString(chunkVkBytes)
-	v.BatchVKMap[""] = base64.StdEncoding.EncodeToString(batchVKBytes)
-	v.ChunkVKMap[""] = base64.StdEncoding.EncodeToString(chunkVkBytes)
 	return nil
 }

coordinator/internal/logic/verifier/verifier_test.go

@@ -49,7 +49,7 @@ func TestFFI(t *testing.T) {
 	t.Log("Verified chunk proof 2")
 
 	batchProof := readBatchProof(*batchProofPath, as)
-	batchOk, err := v.VerifyBatchProof(batchProof, "bernoulli")
+	batchOk, err := v.VerifyBatchProof(batchProof, "curie")
 	as.NoError(err)
 	as.True(batchOk)
 	t.Log("Verified batch proof")

coordinator/internal/orm/batch.go

@@ -309,7 +309,7 @@ func (o *Batch) UpdateProvingStatusFailed(ctx context.Context, hash string, maxA
 	db = db.Model(&Batch{})
 	db = db.Where("hash", hash)
 	db = db.Where("total_attempts >= ?", maxAttempts)
-	db = db.Where("proving_status != ?", int(types.ProverProofValid))
+	db = db.Where("proving_status != ?", int(types.ProvingTaskVerified))
 	if err := db.Update("proving_status", int(types.ProvingTaskFailed)).Error; err != nil {
 		return fmt.Errorf("Batch.UpdateProvingStatus error: %w, batch hash: %v, status: %v", err, hash, types.ProvingTaskFailed.String())
 	}

coordinator/internal/orm/chunk.go

@@ -332,7 +332,7 @@ func (o *Chunk) UpdateProvingStatusFailed(ctx context.Context, hash string, maxA
 	db = db.Model(&Chunk{})
 	db = db.Where("hash", hash)
 	db = db.Where("total_attempts >= ?", maxAttempts)
-	db = db.Where("proving_status != ?", int(types.ProverProofValid))
+	db = db.Where("proving_status != ?", int(types.ProvingTaskVerified))
 	if err := db.Update("proving_status", int(types.ProvingTaskFailed)).Error; err != nil {
 		return fmt.Errorf("Batch.UpdateProvingStatus error: %w, batch hash: %v, status: %v", err, hash, types.ProvingTaskFailed.String())
 	}

coordinator/internal/route/route.go

@@ -32,7 +32,7 @@ func v1(router *gin.RouterGroup, conf *config.Config) {
 	r.POST("/login", challengeMiddleware.MiddlewareFunc(), loginMiddleware.LoginHandler)
 
 	// need jwt token api
-	// r.Use(loginMiddleware.MiddlewareFunc())
+	r.Use(loginMiddleware.MiddlewareFunc())
 	{
 		r.POST("/get_task", api.GetTask.GetTasks)
 		r.POST("/submit_proof", api.SubmitProof.SubmitProof)

coordinator/internal/types/get_task.go

@@ -4,8 +4,8 @@ package types
 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"`
-	VKs          []string `form:"vks" json:"vks"`
+	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
 }
 
 // GetTaskSchema the schema data return to prover for get prover task

coordinator/test/api_test.go

@@ -18,7 +18,6 @@ import (
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/params"
 	"github.com/stretchr/testify/assert"
-	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 
 	"scroll-tech/common/testcontainers"
@@ -27,7 +26,6 @@ import (
 	"scroll-tech/common/version"
 	"scroll-tech/database/migrate"
 
-	cutils "scroll-tech/common/utils"
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/controller/api"
 	"scroll-tech/coordinator/internal/controller/cron"
@@ -82,25 +80,6 @@ func randomURL() string {
 	return fmt.Sprintf("localhost:%d", 10000+2000+id.Int64())
 }
 
-func useLocalDB(dsn string) *gorm.DB {
-	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
-		// Logger: &tmpGormLogger,
-		NowFunc: func() time.Time {
-			// why set time to UTC.
-			// if now set this, the inserted data time will use local timezone. like 2023-07-18 18:24:00 CST+8
-			// but when inserted, store to postgres is 2023-07-18 18:24:00 UTC+0 the timezone is incorrect.
-			// As mysql dsn user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local, we cant set
-			// the timezone by loc=Local. but postgres's dsn don't have loc option to set timezone, so just need set the gorm option like that.
-			return cutils.NowUTC()
-		},
-	})
-	if err != nil {
-		fmt.Println("failed to init db", err.Error())
-		panic(err.Error())
-	}
-	return db
-}
-
 func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL string, nameForkMap map[string]int64) (*cron.Collector, *http.Server) {
 	var err error
 	db, err = testApps.GetGormDBClient()
@@ -221,14 +200,14 @@ func TestApis(t *testing.T) {
 	// Set up the test environment.
 	setEnv(t)
 
-	// t.Run("TestHandshake", testHandshake)
-	// t.Run("TestFailedHandshake", testFailedHandshake)
-	// t.Run("TestGetTaskBlocked", testGetTaskBlocked)
-	// t.Run("TestOutdatedProverVersion", testOutdatedProverVersion)
-	// t.Run("TestValidProof", testValidProof)
-	// t.Run("TestInvalidProof", testInvalidProof)
-	// t.Run("TestProofGeneratedFailed", testProofGeneratedFailed)
-	// t.Run("TestTimeoutProof", testTimeoutProof)
+	t.Run("TestHandshake", testHandshake)
+	t.Run("TestFailedHandshake", testFailedHandshake)
+	t.Run("TestGetTaskBlocked", testGetTaskBlocked)
+	t.Run("TestOutdatedProverVersion", testOutdatedProverVersion)
+	t.Run("TestValidProof", testValidProof)
+	t.Run("TestInvalidProof", testInvalidProof)
+	t.Run("TestProofGeneratedFailed", testProofGeneratedFailed)
+	t.Run("TestTimeoutProof", testTimeoutProof)
 	t.Run("TestHardFork", testHardForkAssignTask)
 }
 
@@ -498,106 +477,6 @@ func testHardForkAssignTask(t *testing.T) {
 		},
 	}
 
-	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)
-
-			fmt.Println("data inserted")
-			time.Sleep(50 * time.Second)
-
-			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 testHardForkAssignTaskMultiCircuits(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"},
-		},
-	}
-
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			coordinatorURL := randomURL()

coordinator/test/mock_coordinator/mock_coordinator.go

@@ -1,112 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"math/big"
-	"net/http"
-	"scroll-tech/common/database"
-	"scroll-tech/common/version"
-	"scroll-tech/coordinator/internal/config"
-	"scroll-tech/coordinator/internal/controller/api"
-	"scroll-tech/coordinator/internal/controller/cron"
-	"scroll-tech/coordinator/internal/route"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"github.com/scroll-tech/go-ethereum/params"
-	"gorm.io/gorm"
-)
-
-// GetGormDBClient returns a gorm.DB by connecting to the running postgres container
-func GetGormDBClient() (*gorm.DB, error) {
-	// endpoint, err := t.GetDBEndPoint()
-	// if err != nil {
-	// 	return nil, err
-	// }
-	endpoint := "postgres://lmr:@localhost:5432/unittest?sslmode=disable"
-	dbCfg := &database.Config{
-		DSN:        endpoint,
-		DriverName: "postgres",
-		MaxOpenNum: 200,
-		MaxIdleNum: 20,
-	}
-	return database.InitDB(dbCfg)
-}
-
-func setupCoordinator(proversPerSession uint8, coordinatorURL string, nameForkMap map[string]int64) (*cron.Collector, *http.Server) {
-	db, err := GetGormDBClient()
-	if err != nil {
-		panic(err.Error())
-	}
-
-	tokenTimeout := 6
-	conf := &config.Config{
-		L2: &config.L2{
-			ChainID: 111,
-		},
-		ProverManager: &config.ProverManager{
-			ProversPerSession: proversPerSession,
-			Verifier: &config.VerifierConfig{
-				MockMode: true,
-			},
-			BatchCollectionTimeSec: 10,
-			ChunkCollectionTimeSec: 10,
-			MaxVerifierWorkers:     10,
-			SessionAttempts:        5,
-			MinProverVersion:       version.Version,
-		},
-		Auth: &config.Auth{
-			ChallengeExpireDurationSec: tokenTimeout,
-			LoginExpireDurationSec:     tokenTimeout,
-		},
-	}
-
-	var chainConf params.ChainConfig
-	for forkName, forkNumber := range nameForkMap {
-		switch forkName {
-		case "shanghai":
-			chainConf.ShanghaiBlock = big.NewInt(forkNumber)
-		case "bernoulli":
-			chainConf.BernoulliBlock = big.NewInt(forkNumber)
-		case "london":
-			chainConf.LondonBlock = big.NewInt(forkNumber)
-		case "istanbul":
-			chainConf.IstanbulBlock = big.NewInt(forkNumber)
-		case "homestead":
-			chainConf.HomesteadBlock = big.NewInt(forkNumber)
-		case "eip155":
-			chainConf.EIP155Block = big.NewInt(forkNumber)
-		}
-	}
-
-	proofCollector := cron.NewCollector(context.Background(), db, conf, nil)
-
-	router := gin.New()
-	api.InitController(conf, &chainConf, db, nil)
-	route.Route(router, conf, nil)
-	srv := &http.Server{
-		Addr:    coordinatorURL,
-		Handler: router,
-	}
-	go func() {
-		runErr := srv.ListenAndServe()
-		if runErr != nil && !errors.Is(runErr, http.ErrServerClosed) {
-			panic(runErr.Error())
-		}
-	}()
-	time.Sleep(time.Second * 2)
-
-	return proofCollector, srv
-}
-
-func main() {
-	coordinatorURL := ":9091"
-	nameForkMap := map[string]int64{"london": 2,
-		"istanbul":  3,
-		"bernoulli": 4}
-	setupCoordinator(1, coordinatorURL, nameForkMap)
-
-	var c = make(chan struct{}, 1)
-	_ = <-c
-}

go.work

@@ -5,7 +5,6 @@ use (
 	./common
 	./coordinator
 	./database
-	./prover
 	./rollup
 	./tests/integration-test
 )

go.work.sum

@@ -378,8 +378,6 @@ github.com/sclevine/agouti v3.0.0+incompatible h1:8IBJS6PWz3uTlMP3YBIR5f+KAldcGu
 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/da-codec v0.0.0-20240527110002-d7bcb621a61a h1:5uWQHo/+cXexQGeSrywtXM2z29zRFctmux2vXs3JLrM=
-github.com/scroll-tech/da-codec v0.0.0-20240527110002-d7bcb621a61a/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=
@@ -451,6 +449,7 @@ github.com/zclconf/go-cty v1.14.1/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgr
 github.com/zeebo/errs v1.2.2/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4=
 github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
 github.com/ziutek/mymysql v1.5.4/go.mod h1:LMSpPZ6DbqWFxNCHW77HeMg9I646SAhApZ/wKdgO/C0=
+go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw=
 go.etcd.io/etcd/api/v3 v3.5.5/go.mod h1:KFtNaxGDw4Yx/BA4iPPwevUTAuqcsPxzyX8PHydchN8=
 go.etcd.io/etcd/client/pkg/v3 v3.5.5/go.mod h1:ggrwbk069qxpKPq8/FKkQ3Xq9y39kbFR4LnKszpRXeQ=
 go.etcd.io/etcd/client/v2 v2.305.5/go.mod h1:zQjKllfqfBVyVStbt4FaosoX2iYd8fV/GRy/PbowgP4=

prover/.gitignore

@@ -1,14 +0,0 @@
-.idea
-stack/test_stack
-mock/stack
-build/bin/
-
-# ignore db file
-bbolt_db
-
-core/lib
-
-params/
-seed
-
-keystore

prover/Cargo.toml

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

prover/Makefile

@@ -1,49 +1,52 @@
-.PHONY: lint docker clean prover mock-prover
+.PHONY: prover lint tests_binary
 
 ifeq (4.3,$(firstword $(sort $(MAKE_VERSION) 4.3)))
-    ZKEVM_VERSION=$(shell grep -m 1 "zkevm-circuits" ../common/libzkp/impl/Cargo.lock | cut -d "#" -f2 | cut -c-7)
-    HALO2_VERSION=$(shell grep -m 1 "halo2.git" ../common/libzkp/impl/Cargo.lock | cut -d "#" -f2 | cut -c-7)
+    HALO2_VERSION=$(shell grep -m 1 "halo2.git" ./Cargo.lock | cut -d "#" -f2 | cut -c-7)
 else
-    ZKEVM_VERSION=$(shell grep -m 1 "zkevm-circuits" ../common/libzkp/impl/Cargo.lock | cut -d "\#" -f2 | cut -c-7)
-    HALO2_VERSION=$(shell grep -m 1 "halo2.git" ../common/libzkp/impl/Cargo.lock | cut -d "\#" -f2 | cut -c-7)
+    HALO2_VERSION=$(shell grep -m 1 "halo2.git" ./Cargo.lock | cut -d "\#" -f2 | cut -c-7)
 endif
 
+ZKEVM_VERSION=$(shell ./print_high_zkevm_version.sh)
+ifeq (${ZKEVM_VERSION},)
+    $(error ZKEVM_VERSION not set)
+else
+    $(info ZKEVM_VERSION is ${ZKEVM_VERSION})
+endif
+
+ZKEVM_COMMIT=$(shell echo ${ZKEVM_VERSION} | cut -d " " -f2)
+$(info ZKEVM_COMMIT is ${ZKEVM_COMMIT})
+
 HALO2_GPU_VERSION=$(shell ./print_halo2gpu_version.sh | sed -n '2p')
 
-ifeq (${HALO2_GPU_VERSION},)
-	# use halo2_proofs with CPU
-    ZK_VERSION=${ZKEVM_VERSION}-${HALO2_VERSION}
+GIT_REV=$(shell git rev-parse --short HEAD)
+GO_TAG=$(shell grep "var tag = " ../common/version/version.go | cut -d "\"" -f2)
+
+ifeq (${GO_TAG},)
+    $(error GO_TAG not set)
 else
-	# use halo2_gpu
-    ZK_VERSION=${ZKEVM_VERSION}-${HALO2_GPU_VERSION}
+    $(info GO_TAG is ${GO_TAG})
 endif
 
-libzkp:
-	cd ../common/libzkp/impl && cargo clean && cargo build --release && cp ./target/release/libzkp.so ../interface/
-	rm -rf ./core/lib && cp -r ../common/libzkp/interface ./core/lib
-	find ../common | grep libzktrie.so | xargs -I{} cp {} ./core/lib/
+ifeq (${HALO2_GPU_VERSION},)
+	# use halo2_proofs with CPU
+    ZK_VERSION=${ZKEVM_COMMIT}-${HALO2_VERSION}
+else
+	# use halo2_gpu
+    ZK_VERSION=${ZKEVM_COMMIT}-${HALO2_GPU_VERSION}
+endif
 
-prover: libzkp ## Build the Prover instance.
-	GOBIN=$(PWD)/build/bin go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/prover ./cmd
+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
 
-mock-prover: ## Build the mocked Prover instance.
-	GOBIN=$(PWD)/build/bin go build -tags="mock_prover mock_verifier" -o $(PWD)/build/bin/prover ./cmd
+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
 
-gpu-prover: libzkp ## Build the GPU Prover instance.
-	GOBIN=$(PWD)/build/bin go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -tags gpu -o $(PWD)/build/bin/prover ./cmd
-
-test-prover: libzkp
-	go test -tags ffi -timeout 0 -v ./prover
-
-test-gpu-prover: libzkp
-	go test -tags="gpu ffi" -timeout 0 -v ./prover
-
-lastest-zk-version:
-	curl -sL https://api.github.com/repos/scroll-tech/zkevm-circuits/commits | jq -r ".[0].sha"
-
-lint: ## Lint the files - used for CI
-	cp -r ../common/libzkp/interface ./core/lib
-	GOBIN=$(PWD)/build/bin go run ../build/lint.go
-
-clean: ## Empty out the bin folder
-	@rm -rf build/bin
+lint:
+	cargo check --all-features
+	cargo clippy --all-features --all-targets -- -D warnings
+	cargo fmt --all

prover/README.md

@@ -1,58 +0,0 @@
-# Prover
-
-This directory contains the Scroll Prover module.
-
-
-## Build
-```bash
-make clean
-make prover
-```
-The built prover binary is in the build/bin directory.
-
-
-## Test
-
-Make sure to lint before testing (or committing):
-
-```bash
-make lint
-```
-
-For current unit tests, run:
-
-```bash
-make prover
-export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:./prover/lib
-export CHAIN_ID=534353 # for Scroll Alpha
-go test -v ./...
-```
-
-When you need to mock prover results and run other prover tests (using [`core/mock.go`](core/mock.go) instead of [`core/prover.go`](core/prover.go)), run:
-
-```bash
-go test -tags="mock_prover" -v -race -covermode=atomic scroll-tech/prover/...
-```
-
-
-## Configure
-
-The prover behavior can be configured using [`config.json`](config.json). Check the code comments of `Config` and `ProverCoreConfig` in [`config/config.go`](config/config.go) for more details.
-
-
-## Start
-
-1. Set environment variables:
-
-```bash
-export CHAIN_ID=534353 # change to correct chain ID
-export RUST_MIN_STACK=100000000
-export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:./prover/lib
-```
-
-2. Start the module using settings from config.json:
-
-```bash
-./build/bin/prover
-```
-

prover/client/client.go

@@ -1,209 +0,0 @@
-package client
-
-import (
-	"context"
-	"crypto/ecdsa"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/go-resty/resty/v2"
-	"github.com/scroll-tech/go-ethereum/log"
-
-	"scroll-tech/prover/config"
-
-	"scroll-tech/common/types"
-	"scroll-tech/common/types/message"
-	"scroll-tech/common/version"
-)
-
-// CoordinatorClient is a client used for interacting with the Coordinator service.
-type CoordinatorClient struct {
-	client *resty.Client
-
-	proverName   string
-	hardForkName string
-	priv         *ecdsa.PrivateKey
-
-	mu sync.Mutex
-}
-
-// NewCoordinatorClient constructs a new CoordinatorClient.
-func NewCoordinatorClient(cfg *config.CoordinatorConfig, proverName string, hardForkName string, priv *ecdsa.PrivateKey) (*CoordinatorClient, error) {
-	client := resty.New().
-		SetTimeout(time.Duration(cfg.ConnectionTimeoutSec) * time.Second).
-		SetRetryCount(cfg.RetryCount).
-		SetRetryWaitTime(time.Duration(cfg.RetryWaitTimeSec) * time.Second).
-		SetBaseURL(cfg.BaseURL).
-		AddRetryAfterErrorCondition().
-		AddRetryCondition(func(response *resty.Response, err error) bool {
-			if err != nil {
-				log.Warn("Encountered an error while sending the request. Retrying...", "error", err)
-				return true
-			}
-			return response.IsError()
-		})
-
-	log.Info("successfully initialized prover client",
-		"base url", cfg.BaseURL,
-		"connection timeout (second)", cfg.ConnectionTimeoutSec,
-		"retry count", cfg.RetryCount,
-		"retry wait time (second)", cfg.RetryWaitTimeSec)
-
-	return &CoordinatorClient{
-		client:       client,
-		proverName:   proverName,
-		hardForkName: hardForkName,
-		priv:         priv,
-	}, nil
-}
-
-// Login completes the entire login process in one function call.
-func (c *CoordinatorClient) Login(ctx context.Context) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	var challengeResult ChallengeResponse
-
-	// Get random string
-	challengeResp, err := c.client.R().
-		SetHeader("Content-Type", "application/json").
-		SetResult(&challengeResult).
-		Get("/coordinator/v1/challenge")
-
-	if err != nil {
-		return fmt.Errorf("get random string failed: %w", err)
-	}
-
-	if challengeResp.StatusCode() != 200 {
-		return fmt.Errorf("failed to get random string, status code: %v", challengeResp.StatusCode())
-	}
-
-	// Prepare and sign the login request
-	authMsg := &message.AuthMsg{
-		Identity: &message.Identity{
-			ProverVersion: version.Version,
-			ProverName:    c.proverName,
-			Challenge:     challengeResult.Data.Token,
-			HardForkName:  c.hardForkName,
-		},
-	}
-
-	err = authMsg.SignWithKey(c.priv)
-	if err != nil {
-		return fmt.Errorf("signature failed: %w", err)
-	}
-
-	// Login to coordinator
-	loginReq := &LoginRequest{
-		Message: struct {
-			Challenge     string `json:"challenge"`
-			ProverName    string `json:"prover_name"`
-			ProverVersion string `json:"prover_version"`
-			HardForkName  string `json:"hard_fork_name"`
-		}{
-			Challenge:     authMsg.Identity.Challenge,
-			ProverName:    authMsg.Identity.ProverName,
-			ProverVersion: authMsg.Identity.ProverVersion,
-			HardForkName:  authMsg.Identity.HardForkName,
-		},
-		Signature: authMsg.Signature,
-	}
-
-	// store JWT token for login requests
-	c.client.SetAuthToken(challengeResult.Data.Token)
-
-	var loginResult LoginResponse
-	loginResp, err := c.client.R().
-		SetHeader("Content-Type", "application/json").
-		SetBody(loginReq).
-		SetResult(&loginResult).
-		Post("/coordinator/v1/login")
-
-	if err != nil {
-		return fmt.Errorf("login failed: %w", err)
-	}
-
-	if loginResp.StatusCode() != 200 {
-		return fmt.Errorf("failed to login, status code: %v", loginResp.StatusCode())
-	}
-
-	if loginResult.ErrCode != types.Success {
-		return fmt.Errorf("failed to login, error code: %v, error message: %v", loginResult.ErrCode, loginResult.ErrMsg)
-	}
-
-	// store JWT token for future requests
-	c.client.SetAuthToken(loginResult.Data.Token)
-
-	return nil
-}
-
-// GetTask sends a request to the coordinator to get prover task.
-func (c *CoordinatorClient) GetTask(ctx context.Context, req *GetTaskRequest) (*GetTaskResponse, error) {
-	var result GetTaskResponse
-
-	resp, err := c.client.R().
-		SetHeader("Content-Type", "application/json").
-		SetBody(req).
-		SetResult(&result).
-		Post("/coordinator/v1/get_task")
-
-	if err != nil {
-		return nil, fmt.Errorf("request for GetTask failed: %w", err)
-	}
-
-	if resp.StatusCode() != 200 {
-		return nil, fmt.Errorf("failed to get task, status code: %v", resp.StatusCode())
-	}
-
-	if result.ErrCode == types.ErrJWTTokenExpired {
-		log.Info("JWT expired, attempting to re-login")
-		if err := c.Login(ctx); err != nil {
-			return nil, fmt.Errorf("JWT expired, re-login failed: %w", err)
-		}
-		log.Info("re-login success")
-		return c.GetTask(ctx, req)
-	}
-	if result.ErrCode != types.Success {
-		return nil, fmt.Errorf("error code: %v, error message: %v", result.ErrCode, result.ErrMsg)
-	}
-
-	return &result, nil
-}
-
-// SubmitProof sends a request to the coordinator to submit proof.
-func (c *CoordinatorClient) SubmitProof(ctx context.Context, req *SubmitProofRequest) error {
-	var result SubmitProofResponse
-
-	resp, err := c.client.R().
-		SetHeader("Content-Type", "application/json").
-		SetBody(req).
-		SetResult(&result).
-		Post("/coordinator/v1/submit_proof")
-
-	if err != nil {
-		log.Error("submit proof request failed", "error", err)
-		return fmt.Errorf("submit proof request failed: %w", ErrCoordinatorConnect)
-	}
-
-	if resp.StatusCode() != 200 {
-		log.Error("failed to submit proof", "status code", resp.StatusCode())
-		return fmt.Errorf("failed to submit proof, status code not 200: %w", ErrCoordinatorConnect)
-	}
-
-	if result.ErrCode == types.ErrJWTTokenExpired {
-		log.Info("JWT expired, attempting to re-login")
-		if err := c.Login(ctx); err != nil {
-			log.Error("JWT expired, re-login failed", "error", err)
-			return fmt.Errorf("JWT expired, re-login failed: %w", ErrCoordinatorConnect)
-		}
-		log.Info("re-login success")
-		return c.SubmitProof(ctx, req)
-	}
-
-	if result.ErrCode != types.Success {
-		return fmt.Errorf("error code: %v, error message: %v", result.ErrCode, result.ErrMsg)
-	}
-
-	return nil
-}

prover/client/types.go

@@ -1,77 +0,0 @@
-package client
-
-import (
-	"errors"
-
-	"scroll-tech/common/types/message"
-)
-
-// ErrCoordinatorConnect connect to coordinator error
-var ErrCoordinatorConnect = errors.New("connect coordinator error")
-
-// ChallengeResponse defines the response structure for random API
-type ChallengeResponse struct {
-	ErrCode int    `json:"errcode"`
-	ErrMsg  string `json:"errmsg"`
-	Data    *struct {
-		Time  string `json:"time"`
-		Token string `json:"token"`
-	} `json:"data,omitempty"`
-}
-
-// LoginRequest defines the request structure for login API
-type LoginRequest struct {
-	Message struct {
-		Challenge     string `json:"challenge"`
-		ProverName    string `json:"prover_name"`
-		ProverVersion string `json:"prover_version"`
-		HardForkName  string `json:"hard_fork_name"`
-	} `json:"message"`
-	Signature string `json:"signature"`
-}
-
-// LoginResponse defines the response structure for login API
-type LoginResponse struct {
-	ErrCode int    `json:"errcode"`
-	ErrMsg  string `json:"errmsg"`
-	Data    *struct {
-		Time  string `json:"time"`
-		Token string `json:"token"`
-	} `json:"data"`
-}
-
-// GetTaskRequest defines the request structure for GetTask API
-type GetTaskRequest struct {
-	TaskType     message.ProofType `json:"task_type"`
-	ProverHeight uint64            `json:"prover_height,omitempty"`
-	VK           string            `json:"vk"`
-}
-
-// GetTaskResponse defines the response structure for GetTask API
-type GetTaskResponse struct {
-	ErrCode int    `json:"errcode"`
-	ErrMsg  string `json:"errmsg"`
-	Data    *struct {
-		UUID     string `json:"uuid"`
-		TaskID   string `json:"task_id"`
-		TaskType int    `json:"task_type"`
-		TaskData string `json:"task_data"`
-	} `json:"data"`
-}
-
-// SubmitProofRequest defines the request structure for the SubmitProof API.
-type SubmitProofRequest struct {
-	UUID        string `json:"uuid"`
-	TaskID      string `json:"task_id"`
-	TaskType    int    `json:"task_type"`
-	Status      int    `json:"status"`
-	Proof       string `json:"proof"`
-	FailureType int    `json:"failure_type,omitempty"`
-	FailureMsg  string `json:"failure_msg,omitempty"`
-}
-
-// SubmitProofResponse defines the response structure for the SubmitProof API.
-type SubmitProofResponse struct {
-	ErrCode int    `json:"errcode"`
-	ErrMsg  string `json:"errmsg"`
-}

prover/cmd/app/app.go

@@ -1,77 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/signal"
-
-	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/urfave/cli/v2"
-
-	"scroll-tech/prover"
-
-	"scroll-tech/common/utils"
-	"scroll-tech/common/version"
-
-	"scroll-tech/prover/config"
-)
-
-var app *cli.App
-
-func init() {
-	app = cli.NewApp()
-	app.Action = action
-	app.Name = "prover"
-	app.Usage = "The Scroll L2 Prover"
-	app.Version = version.Version
-	app.Flags = append(app.Flags, utils.CommonFlags...)
-	app.Before = func(ctx *cli.Context) error {
-		return utils.LogSetup(ctx)
-	}
-
-	// Register `prover-test` app for integration-test.
-	utils.RegisterSimulation(app, utils.ChunkProverApp)
-	utils.RegisterSimulation(app, utils.BatchProverApp)
-}
-
-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)
-	}
-
-	// Create prover
-	r, err := prover.NewProver(context.Background(), cfg)
-	if err != nil {
-		return err
-	}
-	// Start prover.
-	r.Start()
-
-	defer r.Stop()
-	log.Info(
-		"prover start successfully",
-		"name", cfg.ProverName, "type", cfg.Core.ProofType,
-		"publickey", r.PublicKey(), "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 the prover cmd func.
-func Run() {
-	if err := app.Run(os.Args); err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}

prover/cmd/app/app_test.go

@@ -1,29 +0,0 @@
-package app
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"scroll-tech/common/cmd"
-	"scroll-tech/common/utils"
-	"scroll-tech/common/version"
-)
-
-func TestRunChunkProver(t *testing.T) {
-	prover := cmd.NewCmd(string(utils.ChunkProverApp), "--version")
-	defer prover.WaitExit()
-
-	// wait result
-	prover.ExpectWithTimeout(t, true, time.Second*3, fmt.Sprintf("prover version %s", version.Version))
-	prover.RunApp(nil)
-}
-
-func TestRunBatchProver(t *testing.T) {
-	prover := cmd.NewCmd(string(utils.BatchProverApp), "--version")
-	defer prover.WaitExit()
-
-	// wait result
-	prover.ExpectWithTimeout(t, true, time.Second*3, fmt.Sprintf("prover version %s", version.Version))
-	prover.RunApp(nil)
-}

prover/cmd/app/mock_app.go

@@ -1,128 +0,0 @@
-package app
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/scroll-tech/go-ethereum/rpc"
-
-	"scroll-tech/common/cmd"
-	"scroll-tech/common/testcontainers"
-	"scroll-tech/common/types/message"
-	"scroll-tech/common/utils"
-
-	"scroll-tech/prover/config"
-)
-
-var (
-	proverIndex int
-)
-
-func getIndex() int {
-	defer func() { proverIndex++ }()
-	return proverIndex
-}
-
-// ProverApp prover-test client manager.
-type ProverApp struct {
-	Config *config.Config
-
-	testApps *testcontainers.TestcontainerApps
-
-	originFile string
-	proverFile string
-	bboltDB    string
-
-	index int
-	name  string
-	args  []string
-	*cmd.Cmd
-}
-
-// NewProverApp return a new proverApp manager.
-func NewProverApp(testApps *testcontainers.TestcontainerApps, mockName utils.MockAppName, file string, httpURL string) *ProverApp {
-	var proofType message.ProofType
-	switch mockName {
-	case utils.ChunkProverApp:
-		proofType = message.ProofTypeChunk
-	case utils.BatchProverApp:
-		proofType = message.ProofTypeBatch
-	default:
-		return nil
-	}
-	name := string(mockName)
-	proverFile := fmt.Sprintf("/tmp/%d_%s-config.json", testApps.Timestamp, name)
-	proverApp := &ProverApp{
-		testApps:   testApps,
-		originFile: file,
-		proverFile: proverFile,
-		bboltDB:    fmt.Sprintf("/tmp/%d_%s_bbolt_db", testApps.Timestamp, name),
-		index:      getIndex(),
-		name:       name,
-		args:       []string{"--log.debug", "--config", proverFile},
-	}
-	proverApp.Cmd = cmd.NewCmd(proverApp.name, proverApp.args...)
-	if err := proverApp.MockConfig(true, httpURL, proofType); err != nil {
-		panic(err)
-	}
-	return proverApp
-}
-
-// RunApp run prover-test child process by multi parameters.
-func (r *ProverApp) RunApp(t *testing.T) {
-	r.Cmd.RunApp(func() bool { return r.Cmd.WaitResult(t, time.Second*40, "prover start successfully") })
-}
-
-// Free stop and release prover-test.
-func (r *ProverApp) Free() {
-	if !utils.IsNil(r.Cmd) {
-		r.Cmd.WaitExit()
-	}
-	_ = os.Remove(r.proverFile)
-	_ = os.Remove(r.Config.KeystorePath)
-	_ = os.Remove(r.bboltDB)
-}
-
-// MockConfig creates a new prover config.
-func (r *ProverApp) MockConfig(store bool, httpURL string, proofType message.ProofType) error {
-	cfg, err := config.NewConfig(r.originFile)
-	if err != nil {
-		return err
-	}
-	cfg.ProverName = fmt.Sprintf("%s_%d", r.name, r.index)
-	cfg.KeystorePath = fmt.Sprintf("/tmp/%d_%s.json", r.testApps.Timestamp, cfg.ProverName)
-
-	endpoint, err := r.testApps.GetL2GethEndPoint()
-	if err != nil {
-		return err
-	}
-	cfg.L2Geth.Endpoint = endpoint
-	cfg.L2Geth.Confirmations = rpc.LatestBlockNumber
-	// Reuse l1geth's keystore file
-	cfg.KeystorePassword = "scrolltest"
-	cfg.DBPath = r.bboltDB
-	// Create keystore file.
-	_, err = utils.LoadOrCreateKey(cfg.KeystorePath, cfg.KeystorePassword)
-	if err != nil {
-		return err
-	}
-	cfg.Coordinator.BaseURL = httpURL
-	cfg.Coordinator.RetryCount = 10
-	cfg.Coordinator.RetryWaitTimeSec = 10
-	cfg.Coordinator.ConnectionTimeoutSec = 30
-	cfg.Core.ProofType = proofType
-	r.Config = cfg
-
-	if !store {
-		return nil
-	}
-
-	data, err := json.Marshal(r.Config)
-	if err != nil {
-		return err
-	}
-	return os.WriteFile(r.proverFile, data, 0600)
-}

prover/cmd/main.go

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

prover/config.json

@@ -1,13 +1,18 @@
 {
     "prover_name": "prover-1",
-    "hard_fork_name": "homestead",
     "keystore_path": "keystore.json",
     "keystore_password": "prover-pwd",
     "db_path": "unique-db-path-for-prover-1",
-    "core": {
+    "proof_type": 2,
+    "low_version_circuit": {
+        "hard_fork_name": "bernoulli",
         "params_path": "params",
-        "assets_path": "assets",
-        "proof_type": 2
+        "assets_path": "assets"
+    },
+    "high_version_circuit": {
+        "hard_fork_name": "curie",
+        "params_path": "params",
+        "assets_path": "assets"
     },
     "coordinator": {
         "base_url": "http://localhost:8555",
@@ -16,7 +21,6 @@
         "connection_timeout_sec": 30
     },
     "l2geth": {
-        "endpoint": "http://localhost:9999",
-        "confirmations": "0x1"
+        "endpoint": "http://localhost:9999"
     }
 }

prover/config/config.go

@@ -1,66 +0,0 @@
-package config
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-
-	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/scroll-tech/go-ethereum/rpc"
-
-	"scroll-tech/common/types/message"
-)
-
-// Config loads prover configuration items.
-type Config struct {
-	ProverName       string             `json:"prover_name"`
-	HardForkName     string             `json:"hard_fork_name"`
-	KeystorePath     string             `json:"keystore_path"`
-	KeystorePassword string             `json:"keystore_password"`
-	Core             *ProverCoreConfig  `json:"core"`
-	DBPath           string             `json:"db_path"`
-	Coordinator      *CoordinatorConfig `json:"coordinator"`
-	L2Geth           *L2GethConfig      `json:"l2geth,omitempty"` // only for chunk_prover
-}
-
-// ProverCoreConfig load zk prover config.
-type ProverCoreConfig struct {
-	ParamsPath string            `json:"params_path"`
-	AssetsPath string            `json:"assets_path"`
-	ProofType  message.ProofType `json:"proof_type,omitempty"` // 1: chunk prover (default type), 2: batch prover
-	DumpDir    string            `json:"dump_dir,omitempty"`
-}
-
-// CoordinatorConfig represents the configuration for the Coordinator client.
-type CoordinatorConfig struct {
-	BaseURL              string `json:"base_url"`
-	RetryCount           int    `json:"retry_count"`
-	RetryWaitTimeSec     int    `json:"retry_wait_time_sec"`
-	ConnectionTimeoutSec int    `json:"connection_timeout_sec"`
-}
-
-// L2GethConfig represents the configuration for the l2geth client.
-type L2GethConfig struct {
-	Endpoint      string          `json:"endpoint"`
-	Confirmations rpc.BlockNumber `json:"confirmations"`
-}
-
-// NewConfig returns a new instance of Config.
-func NewConfig(file string) (*Config, error) {
-	buf, err := os.ReadFile(filepath.Clean(file))
-	if err != nil {
-		return nil, err
-	}
-
-	cfg := &Config{}
-	if err = json.Unmarshal(buf, cfg); err != nil {
-		return nil, err
-	}
-	if !filepath.IsAbs(cfg.DBPath) {
-		if cfg.DBPath, err = filepath.Abs(cfg.DBPath); err != nil {
-			log.Error("Failed to get abs path", "error", err)
-			return nil, err
-		}
-	}
-	return cfg, nil
-}

prover/core/mock.go

@@ -1,45 +0,0 @@
-//go:build mock_prover
-
-package core
-
-import (
-	"math/big"
-
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/core/types"
-
-	"scroll-tech/common/types/message"
-
-	"scroll-tech/prover/config"
-)
-
-// ProverCore sends block-traces to rust-prover through socket and get back the zk-proof.
-type ProverCore struct {
-	cfg *config.ProverCoreConfig
-	VK  string
-}
-
-// NewProverCore inits a ProverCore object.
-func NewProverCore(cfg *config.ProverCoreConfig) (*ProverCore, error) {
-	return &ProverCore{cfg: cfg}, nil
-}
-
-func (p *ProverCore) ProveChunk(taskID string, traces []*types.BlockTrace) (*message.ChunkProof, error) {
-	_empty := common.BigToHash(big.NewInt(0))
-	return &message.ChunkProof{
-		StorageTrace: _empty[:],
-		Protocol:     _empty[:],
-		Proof:        _empty[:],
-		Instances:    _empty[:],
-		Vk:           _empty[:],
-	}, nil
-}
-
-func (p *ProverCore) ProveBatch(taskID string, chunkInfos []*message.ChunkInfo, chunkProofs []*message.ChunkProof) (*message.BatchProof, error) {
-	_empty := common.BigToHash(big.NewInt(0))
-	return &message.BatchProof{
-		Proof:     _empty[:],
-		Instances: _empty[:],
-		Vk:        _empty[:],
-	}, nil
-}

prover/core/prover.go

@@ -1,258 +0,0 @@
-//go:build !mock_prover
-
-package core
-
-/*
-#cgo LDFLAGS: -lzkp -lm -ldl -lzktrie -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
-#cgo gpu LDFLAGS: -lzkp -lm -ldl -lgmp -lstdc++ -lprocps -lzktrie -L/usr/local/cuda/lib64/ -lcudart -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
-#include <stdlib.h>
-#include "./lib/libzkp.h"
-*/
-import "C" //nolint:typecheck
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"unsafe"
-
-	"github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/log"
-
-	"scroll-tech/common/types/message"
-
-	"scroll-tech/prover/config"
-)
-
-// ProverCore sends block-traces to rust-prover through ffi and get back the zk-proof.
-type ProverCore struct {
-	cfg *config.ProverCoreConfig
-	VK  string
-}
-
-// NewProverCore inits a ProverCore object.
-func NewProverCore(cfg *config.ProverCoreConfig) (*ProverCore, error) {
-	paramsPathStr := C.CString(cfg.ParamsPath)
-	assetsPathStr := C.CString(cfg.AssetsPath)
-	defer func() {
-		C.free(unsafe.Pointer(paramsPathStr))
-		C.free(unsafe.Pointer(assetsPathStr))
-	}()
-
-	var vk string
-	var rawVK *C.char
-	if cfg.ProofType == message.ProofTypeBatch {
-		C.init_batch_prover(paramsPathStr, assetsPathStr)
-		rawVK = C.get_batch_vk()
-	} else if cfg.ProofType == message.ProofTypeChunk {
-		C.init_chunk_prover(paramsPathStr, assetsPathStr)
-		rawVK = C.get_chunk_vk()
-	}
-	defer C.free_c_chars(rawVK)
-
-	if rawVK != nil {
-		vk = C.GoString(rawVK)
-	}
-
-	if cfg.DumpDir != "" {
-		err := os.MkdirAll(cfg.DumpDir, os.ModePerm)
-		if err != nil {
-			return nil, err
-		}
-		log.Info("Enabled dump_proof", "dir", cfg.DumpDir)
-	}
-
-	return &ProverCore{cfg: cfg, VK: vk}, nil
-}
-
-// ProveBatch call rust ffi to generate batch proof.
-func (p *ProverCore) ProveBatch(taskID string, chunkInfos []*message.ChunkInfo, chunkProofs []*message.ChunkProof) (*message.BatchProof, error) {
-	if p.cfg.ProofType != message.ProofTypeBatch {
-		return nil, fmt.Errorf("prover is not a batch-prover (type: %v), but is trying to prove a batch", p.cfg.ProofType)
-	}
-
-	chunkInfosByt, err := json.Marshal(chunkInfos)
-	if err != nil {
-		return nil, err
-	}
-	chunkProofsByt, err := json.Marshal(chunkProofs)
-	if err != nil {
-		return nil, err
-	}
-
-	isValid, err := p.checkChunkProofs(chunkProofsByt)
-	if err != nil {
-		return nil, err
-	}
-
-	if !isValid {
-		return nil, fmt.Errorf("non-match chunk protocol, task-id: %s", taskID)
-	}
-
-	proofByt, err := p.proveBatch(chunkInfosByt, chunkProofsByt)
-	if err != nil {
-		return nil, fmt.Errorf("failed to generate batch proof: %v", err)
-	}
-
-	err = p.mayDumpProof(taskID, proofByt)
-	if err != nil {
-		log.Error("Dump batch proof failed", "task-id", taskID, "error", err)
-	}
-
-	zkProof := &message.BatchProof{}
-	return zkProof, json.Unmarshal(proofByt, zkProof)
-}
-
-// ProveChunk call rust ffi to generate chunk proof.
-func (p *ProverCore) ProveChunk(taskID string, traces []*types.BlockTrace) (*message.ChunkProof, error) {
-	if p.cfg.ProofType != message.ProofTypeChunk {
-		return nil, fmt.Errorf("prover is not a chunk-prover (type: %v), but is trying to prove a chunk", p.cfg.ProofType)
-	}
-
-	tracesByt, err := json.Marshal(traces)
-	if err != nil {
-		return nil, err
-	}
-	proofByt, err := p.proveChunk(tracesByt)
-	if err != nil {
-		return nil, err
-	}
-
-	err = p.mayDumpProof(taskID, proofByt)
-	if err != nil {
-		log.Error("Dump chunk proof failed", "task-id", taskID, "error", err)
-	}
-
-	zkProof := &message.ChunkProof{}
-	return zkProof, json.Unmarshal(proofByt, zkProof)
-}
-
-// TracesToChunkInfo convert traces to chunk info
-func (p *ProverCore) TracesToChunkInfo(traces []*types.BlockTrace) (*message.ChunkInfo, error) {
-	tracesByt, err := json.Marshal(traces)
-	if err != nil {
-		return nil, err
-	}
-	chunkInfoByt := p.tracesToChunkInfo(tracesByt)
-
-	chunkInfo := &message.ChunkInfo{}
-	return chunkInfo, json.Unmarshal(chunkInfoByt, chunkInfo)
-}
-
-// CheckChunkProofsResponse represents the result of a chunk proof checking operation.
-// Ok indicates whether the proof checking was successful.
-// Error provides additional details in case the check failed.
-type CheckChunkProofsResponse struct {
-	Ok    bool   `json:"ok"`
-	Error string `json:"error,omitempty"`
-}
-
-// ProofResult encapsulates the result from generating a proof.
-// Message holds the generated proof in byte slice format.
-// Error provides additional details in case the proof generation failed.
-type ProofResult struct {
-	Message []byte `json:"message,omitempty"`
-	Error   string `json:"error,omitempty"`
-}
-
-func (p *ProverCore) checkChunkProofs(chunkProofsByt []byte) (bool, error) {
-	chunkProofsStr := C.CString(string(chunkProofsByt))
-	defer C.free(unsafe.Pointer(chunkProofsStr))
-
-	log.Info("Start to check chunk proofs ...")
-	cResult := C.check_chunk_proofs(chunkProofsStr)
-	defer C.free_c_chars(cResult)
-	log.Info("Finish checking chunk proofs!")
-
-	var result CheckChunkProofsResponse
-	err := json.Unmarshal([]byte(C.GoString(cResult)), &result)
-	if err != nil {
-		return false, fmt.Errorf("failed to parse check chunk proofs result: %v", err)
-	}
-
-	if result.Error != "" {
-		return false, fmt.Errorf("failed to check chunk proofs: %s", result.Error)
-	}
-
-	return result.Ok, nil
-}
-
-func (p *ProverCore) proveBatch(chunkInfosByt []byte, chunkProofsByt []byte) ([]byte, error) {
-	chunkInfosStr := C.CString(string(chunkInfosByt))
-	chunkProofsStr := C.CString(string(chunkProofsByt))
-
-	defer func() {
-		C.free(unsafe.Pointer(chunkInfosStr))
-		C.free(unsafe.Pointer(chunkProofsStr))
-	}()
-
-	log.Info("Start to create batch proof ...")
-	bResult := C.gen_batch_proof(chunkInfosStr, chunkProofsStr)
-	defer C.free_c_chars(bResult)
-	log.Info("Finish creating batch proof!")
-
-	var result ProofResult
-	err := json.Unmarshal([]byte(C.GoString(bResult)), &result)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse batch proof result: %v", err)
-	}
-
-	if result.Error != "" {
-		return nil, fmt.Errorf("failed to generate batch proof: %s", result.Error)
-	}
-
-	return result.Message, nil
-}
-
-func (p *ProverCore) proveChunk(tracesByt []byte) ([]byte, error) {
-	tracesStr := C.CString(string(tracesByt))
-	defer C.free(unsafe.Pointer(tracesStr))
-
-	log.Info("Start to create chunk proof ...")
-	cProof := C.gen_chunk_proof(tracesStr)
-	defer C.free_c_chars(cProof)
-	log.Info("Finish creating chunk proof!")
-
-	var result ProofResult
-	err := json.Unmarshal([]byte(C.GoString(cProof)), &result)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse chunk proof result: %v", err)
-	}
-
-	if result.Error != "" {
-		return nil, fmt.Errorf("failed to generate chunk proof: %s", result.Error)
-	}
-
-	return result.Message, nil
-}
-
-func (p *ProverCore) mayDumpProof(id string, proofByt []byte) error {
-	if p.cfg.DumpDir == "" {
-		return nil
-	}
-	path := filepath.Join(p.cfg.DumpDir, id)
-	f, err := os.Create(path)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err = f.Close(); err != nil {
-			log.Error("failed to close proof dump file", "id", id, "error", err)
-		}
-	}()
-	log.Info("Saving proof", "task-id", id)
-	_, err = f.Write(proofByt)
-	return err
-}
-
-func (p *ProverCore) tracesToChunkInfo(tracesByt []byte) []byte {
-	tracesStr := C.CString(string(tracesByt))
-	defer C.free(unsafe.Pointer(tracesStr))
-
-	cChunkInfo := C.block_traces_to_chunk_info(tracesStr)
-	defer C.free_c_chars(cChunkInfo)
-
-	chunkInfo := C.GoString(cChunkInfo)
-	return []byte(chunkInfo)
-}

prover/core/prover_test.go

@@ -1,154 +0,0 @@
-//go:build ffi
-
-// go test -v -race -gcflags="-l" -ldflags="-s=false" -tags ffi ./...
-package core_test
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"sort"
-	"testing"
-
-	"github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/stretchr/testify/assert"
-
-	"scroll-tech/common/types/message"
-
-	"scroll-tech/prover/config"
-	"scroll-tech/prover/core"
-)
-
-var (
-	paramsPath    = flag.String("params", "/assets/test_params", "params dir")
-	assetsPath    = flag.String("assets", "/assets/test_assets", "assets dir")
-	proofDumpPath = flag.String("dump", "/assets/proof_data", "the path proofs dump to")
-	batchDirPath  = flag.String("batch-dir", "/assets/traces/batch_24", "batch directory")
-	batchVkPath   = flag.String("batch-vk", "/assets/test_assets/agg_vk.vkey", "batch vk")
-	chunkVkPath   = flag.String("chunk-vk", "/assets/test_assets/chunk_vk.vkey", "chunk vk")
-)
-
-func TestFFI(t *testing.T) {
-	as := assert.New(t)
-
-	chunkProverConfig := &config.ProverCoreConfig{
-		DumpDir:    *proofDumpPath,
-		ParamsPath: *paramsPath,
-		AssetsPath: *assetsPath,
-		ProofType:  message.ProofTypeChunk,
-	}
-	chunkProverCore, err := core.NewProverCore(chunkProverConfig)
-	as.NoError(err)
-	t.Log("Constructed chunk prover")
-
-	as.Equal(chunkProverCore.VK, readVk(*chunkVkPath, as))
-	t.Log("Chunk VK must be available when init")
-
-	// Get the list of subdirectories (chunks)
-	chunkDirs, err := os.ReadDir(*batchDirPath)
-	as.NoError(err)
-	sort.Slice(chunkDirs, func(i, j int) bool {
-		return chunkDirs[i].Name() < chunkDirs[j].Name()
-	})
-
-	chunkInfos := make([]*message.ChunkInfo, 0, len(chunkDirs))
-	chunkProofs := make([]*message.ChunkProof, 0, len(chunkDirs))
-
-	for i, dir := range chunkDirs {
-		if dir.IsDir() {
-			chunkPath := filepath.Join(*batchDirPath, dir.Name())
-
-			chunkTrace := readChunkTrace(chunkPath, as)
-			t.Logf("Loaded chunk trace %d", i+1)
-
-			chunkInfo, err := chunkProverCore.TracesToChunkInfo(chunkTrace)
-			as.NoError(err)
-			chunkInfos = append(chunkInfos, chunkInfo)
-			t.Logf("Converted to chunk info %d", i+1)
-
-			chunkProof, err := chunkProverCore.ProveChunk(fmt.Sprintf("chunk_proof%d", i+1), chunkTrace)
-			as.NoError(err)
-			chunkProofs = append(chunkProofs, chunkProof)
-			t.Logf("Generated and dumped chunk proof %d", i+1)
-		}
-	}
-
-	as.Equal(chunkProverCore.VK, readVk(*chunkVkPath, as))
-	t.Log("Chunk VKs must be equal after proving")
-
-	batchProverConfig := &config.ProverCoreConfig{
-		DumpDir:    *proofDumpPath,
-		ParamsPath: *paramsPath,
-		AssetsPath: *assetsPath,
-		ProofType:  message.ProofTypeBatch,
-	}
-	batchProverCore, err := core.NewProverCore(batchProverConfig)
-	as.NoError(err)
-
-	as.Equal(batchProverCore.VK, readVk(*batchVkPath, as))
-	t.Log("Batch VK must be available when init")
-
-	_, err = batchProverCore.ProveBatch("batch_proof", chunkInfos, chunkProofs)
-	as.NoError(err)
-	t.Log("Generated and dumped batch proof")
-
-	as.Equal(batchProverCore.VK, readVk(*batchVkPath, as))
-	t.Log("Batch VKs must be equal after proving")
-}
-func readChunkTrace(filePat string, as *assert.Assertions) []*types.BlockTrace {
-	fileInfo, err := os.Stat(filePat)
-	as.NoError(err)
-
-	var traces []*types.BlockTrace
-
-	readFile := func(path string) {
-		f, err := os.Open(path)
-		as.NoError(err)
-		defer func() {
-			as.NoError(f.Close())
-		}()
-		byt, err := io.ReadAll(f)
-		as.NoError(err)
-
-		trace := &types.BlockTrace{}
-		as.NoError(json.Unmarshal(byt, trace))
-
-		traces = append(traces, trace)
-	}
-
-	if fileInfo.IsDir() {
-		files, err := os.ReadDir(filePat)
-		as.NoError(err)
-
-		// Sort files alphabetically
-		sort.Slice(files, func(i, j int) bool {
-			return files[i].Name() < files[j].Name()
-		})
-
-		for _, file := range files {
-			if !file.IsDir() {
-				readFile(filepath.Join(filePat, file.Name()))
-			}
-		}
-	} else {
-		readFile(filePat)
-	}
-
-	return traces
-}
-
-func readVk(filePat string, as *assert.Assertions) string {
-	f, err := os.Open(filePat)
-	as.NoError(err)
-	defer func() {
-		as.NoError(f.Close())
-	}()
-	byt, err := io.ReadAll(f)
-	as.NoError(err)
-
-	return base64.StdEncoding.EncodeToString(byt)
-}

prover/go.mod

@@ -1,82 +0,0 @@
-module scroll-tech/prover
-
-go 1.21
-
-require (
-	github.com/go-resty/resty/v2 v2.7.0
-	github.com/google/uuid v1.6.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240426041101-a860446ebaea
-	github.com/stretchr/testify v1.9.0
-	github.com/urfave/cli/v2 v2.25.7
-	go.etcd.io/bbolt v1.3.7
-)
-
-require (
-	github.com/VictoriaMetrics/fastcache v1.12.1 // indirect
-	github.com/bits-and-blooms/bitset v1.12.0 // indirect
-	github.com/btcsuite/btcd v0.20.1-beta // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/consensys/bavard v0.1.13 // indirect
-	github.com/consensys/gnark-crypto v0.12.1 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
-	github.com/crate-crypto/go-kzg-4844 v1.0.0 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/deckarep/golang-set v1.8.0 // indirect
-	github.com/edsrzf/mmap-go v1.0.0 // indirect
-	github.com/ethereum/c-kzg-4844/bindings/go v0.0.0-20230126171313-363c7d7593b4 // indirect
-	github.com/fjl/memsize v0.0.2 // indirect
-	github.com/fsnotify/fsnotify v1.6.0 // indirect
-	github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect
-	github.com/go-kit/kit v0.9.0 // indirect
-	github.com/go-logfmt/logfmt v0.5.1 // indirect
-	github.com/go-ole/go-ole v1.3.0 // indirect
-	github.com/go-stack/stack v1.8.1 // indirect
-	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
-	github.com/google/go-cmp v0.6.0 // indirect
-	github.com/gorilla/websocket v1.5.0 // indirect
-	github.com/hashicorp/go-bexpr v0.1.10 // indirect
-	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect
-	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
-	github.com/holiman/uint256 v1.2.4 // indirect
-	github.com/huin/goupnp v1.3.0 // indirect
-	github.com/iden3/go-iden3-crypto v0.0.15 // indirect
-	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
-	github.com/kr/text v0.2.0 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.15 // indirect
-	github.com/mitchellh/mapstructure v1.5.0 // indirect
-	github.com/mitchellh/pointerstructure v1.2.0 // indirect
-	github.com/mmcloughlin/addchain v0.4.0 // indirect
-	github.com/olekukonko/tablewriter v0.0.5 // indirect
-	github.com/onsi/ginkgo v1.16.5 // indirect
-	github.com/onsi/gomega v1.27.1 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/tsdb v0.7.1 // indirect
-	github.com/rivo/uniseg v0.4.4 // indirect
-	github.com/rjeczalik/notify v0.9.1 // indirect
-	github.com/rogpeppe/go-internal v1.10.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.2 // indirect
-	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
-	github.com/status-im/keycard-go v0.2.0 // indirect
-	github.com/supranational/blst v0.3.11 // indirect
-	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
-	github.com/tklauser/go-sysconf v0.3.12 // indirect
-	github.com/tklauser/numcpus v0.6.1 // indirect
-	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
-	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
-	github.com/yusufpapurcu/wmi v1.2.3 // indirect
-	golang.org/x/crypto v0.19.0 // indirect
-	golang.org/x/net v0.20.0 // indirect
-	golang.org/x/sync v0.6.0 // indirect
-	golang.org/x/sys v0.17.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
-	golang.org/x/time v0.3.0 // indirect
-	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
-	gopkg.in/urfave/cli.v1 v1.20.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-	rsc.io/tmplfunc v0.0.3 // indirect
-)

prover/go.sum

@@ -1,296 +0,0 @@
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40=
-github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o=
-github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
-github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
-github.com/bits-and-blooms/bitset v1.12.0 h1:U/q1fAF7xXRhFCrhROzIfffYnu+dlS38vCZtmFVPHmA=
-github.com/bits-and-blooms/bitset v1.12.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
-github.com/btcsuite/btcd v0.20.1-beta h1:Ik4hyJqN8Jfyv3S4AGBOmyouMsYE3EdYODkMbQjwPGw=
-github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
-github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
-github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
-github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg=
-github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY=
-github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
-github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
-github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
-github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
-github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
-github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ=
-github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI=
-github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M=
-github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY=
-github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
-github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/crate-crypto/go-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=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4=
-github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo=
-github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
-github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
-github.com/ethereum/c-kzg-4844/bindings/go v0.0.0-20230126171313-363c7d7593b4 h1:B2mpK+MNqgPqk2/KNi1LbqwtZDy5F7iy0mynQiBr8VA=
-github.com/ethereum/c-kzg-4844/bindings/go v0.0.0-20230126171313-363c7d7593b4/go.mod h1:y4GA2JbAUama1S4QwYjC2hefgGLU8Ul0GMtL/ADMF1c=
-github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA=
-github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
-github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
-github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
-github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
-github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-kit/kit v0.9.0 h1:wDJmvq38kDhkVxi50ni9ykkdUr1PKgqKOoi01fa0Mdk=
-github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-logfmt/logfmt v0.5.1 h1:otpy5pqBCBZ1ng9RQ0dPu4PN7ba75Y/aA+UpowDyNVA=
-github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
-github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
-github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
-github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
-github.com/go-resty/resty/v2 v2.7.0 h1:me+K9p3uhSmXtrBZ4k9jcEAfJmuC8IivWHwaLZwPrFY=
-github.com/go-resty/resty/v2 v2.7.0/go.mod h1:9PWDzw47qPphMRFfhsyk0NnSgvluHcljSMVIq3w7q0I=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
-github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
-github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
-github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk=
-github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
-github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE=
-github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0=
-github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs=
-github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
-github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
-github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA=
-github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU=
-github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc=
-github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8=
-github.com/iden3/go-iden3-crypto v0.0.15 h1:4MJYlrot1l31Fzlo2sF56u7EVFeHHJkxGXXZCtESgK4=
-github.com/iden3/go-iden3-crypto v0.0.15/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBeOT/3UEhXsEsP3E=
-github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
-github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
-github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
-github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
-github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
-github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
-github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A=
-github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4=
-github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY=
-github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU=
-github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU=
-github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
-github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
-github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
-github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
-github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
-github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
-github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
-github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
-github.com/onsi/gomega v1.27.1 h1:rfztXRbg6nv/5f+Raen9RcGoSecHIFgBBLQK3Wdj754=
-github.com/onsi/gomega v1.27.1/go.mod h1:aHX5xOykVYzWOV4WqQy0sy8BQptgukenXpCXfadcIAw=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/tsdb v0.7.1 h1:YZcsG11NqnK4czYLrWd9mpEuAJIHVQLwdrleYfszMAA=
-github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeCE=
-github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
-github.com/rogpeppe/go-internal v1.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/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/zktrie v0.8.2 h1:UMuIfA+jdgWMLmTgTL64Emo+zzMOdcnH0+eYdDcshxQ=
-github.com/scroll-tech/zktrie v0.8.2/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
-github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
-github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA=
-github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4=
-github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
-github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
-github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
-github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU=
-github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI=
-github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk=
-github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY=
-github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
-github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
-github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs=
-github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw=
-github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
-go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ=
-go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw=
-golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
-golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20211029224645-99673261e6eb/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
-golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
-golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
-golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
-golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU=
-gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/urfave/cli.v1 v1.20.0 h1:NdAVW6RYxDif9DhDHaAortIu956m2c0v+09AZBPTbE0=
-gopkg.in/urfave/cli.v1 v1.20.0/go.mod h1:vuBzUtMdQeixQj8LVd+/98pzhxNGQoyuPBlsXHOQNO0=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU=
-rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA=

prover/print_high_zkevm_version.sh

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