Reapply "build(ci): make all intermediate images compatible with multi platforms (#1291)"

This reverts commit 5090b77655.

.github/workflows/common.yml

@@ -29,7 +29,7 @@ jobs:
     steps:
     - uses: actions-rs/toolchain@v1
       with:
-        toolchain: nightly-2022-12-10
+        toolchain: nightly-2023-12-03
         override: true
         components: rustfmt, clippy
     - name: Install Go

.github/workflows/coordinator.yml

@@ -33,13 +33,13 @@ jobs:
     steps:
     - uses: actions-rs/toolchain@v1
       with:
-        toolchain: nightly-2022-12-10
+        toolchain: nightly-2023-12-03
         override: true
         components: rustfmt, clippy
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.20.x
+        go-version: 1.21.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Lint
@@ -54,7 +54,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.20.x
+        go-version: 1.21.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install goimports
@@ -95,7 +95,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.20.x
+        go-version: 1.21.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc

.github/workflows/docker.yml

@@ -46,6 +46,7 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/event_watcher.Dockerfile
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
@@ -90,6 +91,7 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/gas_oracle.Dockerfile
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
@@ -134,6 +136,52 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/rollup_relayer.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
+
+  rollup-db-cli:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - 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: rollup-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: rollup-db-cli
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/db_cli.Dockerfile
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
@@ -178,6 +226,7 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
@@ -222,6 +271,7 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/bridgehistoryapi-api.Dockerfile
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
@@ -266,6 +316,7 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/coordinator-api.Dockerfile
+          platforms: linux/amd64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
@@ -310,6 +361,7 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/coordinator-cron.Dockerfile
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}

.github/workflows/intermediate-docker.yml

@@ -7,12 +7,12 @@ on:
         description: 'Go version'
         required: true
         type: string
-        default: '1.20'
+        default: '1.21'
       RUST_VERSION:
         description: 'Rust toolchain version'
         required: true
         type: string
-        default: 'nightly-2022-12-10'
+        default: 'nightly-2023-12-03'
       PYTHON_VERSION:
         description: 'Python version'
         required: false
@@ -29,31 +29,191 @@ defaults:
     working-directory: 'build/dockerfiles/intermediate'
 
 jobs:
-  build-and-push:
+  build-and-publish-cuda-go-rust-builder:
     runs-on: ubuntu-latest
     steps:
-    - name: Checkout code
+      - name: Checkout code
-      uses: actions/checkout@v2
+        uses: actions/checkout@v2
-    - name: Set up Docker Buildx
+      - name: Set up QEMU
-      uses: docker/setup-buildx-action@v2
+        uses: docker/setup-qemu-action@v2
-    - name: Login to Docker Hub
+      - name: Set up Docker Buildx
-      uses: docker/login-action@v2
+        uses: docker/setup-buildx-action@v2
-      with:
+      - name: Login to Docker Hub
-        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        uses: docker/login-action@v2
-        password: ${{ secrets.DOCKERHUB_TOKEN }}
+        with:
-    - name: Build
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
-      run: |
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
-        make all
+      - name: Build image
-      env:
+        id: build
-        GO_VERSION: ${{ inputs.GO_VERSION }}
+        uses: docker/build-push-action@v5
-        RUST_VERSION: ${{ inputs.RUST_VERSION }}
+        with:
-        PYTHON_VERSION: ${{ inputs.PYTHON_VERSION }}
+          context: .
-        CUDA_VERSION: ${{ inputs.CUDA_VERSION }}
+          push: true
-    - name: Publish
+          file: build/dockerfiles/intermediate/cuda-go-rust-builder.Dockerfile
-      run: |
+          tags: scrolltech/cuda-go-rust-builder:cuda-${{ github.event.inputs.CUDA_VERSION }}-go-${{ github.event.inputs.GO_VERSION }}-rust-${{ github.event.inputs.RUST_VERSION }}
-        make publish
+          build-args: |
-      env:
+            CUDA_VERSION: ${{ github.event.inputs.CUDA_VERSION }}
-        GO_VERSION: ${{ inputs.GO_VERSION }}
+            GO_VERSION: ${{ github.event.inputs.GO_VERSION }}
-        RUST_VERSION: ${{ inputs.RUST_VERSION }}
+            RUST_VERSION: ${{ github.event.inputs.RUST_VERSION }}
-        PYTHON_VERSION: ${{ inputs.PYTHON_VERSION }}
+
-        CUDA_VERSION: ${{ inputs.CUDA_VERSION }}
+  build-and-publish-go-rust-builder:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - 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
+          platforms: linux/amd64,linux/arm64
+          tags: scrolltech/go-rust-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-go-alpine-builder:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - 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@v2
+      - 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@v2
+      - 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@v2
+      - 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@v2
+      - 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 }}
+

.github/workflows/prover.yml

@@ -50,7 +50,7 @@ jobs:
     steps:
     - uses: actions-rs/toolchain@v1
       with:
-        toolchain: nightly-2022-12-10
+        toolchain: nightly-2023-12-03
         override: true
         components: rustfmt, clippy
     - name: Install Go

Makefile

@@ -47,11 +47,5 @@ dev_docker: ## build docker images for development/testing usages
 	docker build -t scroll_l1geth ./common/docker/l1geth/
 	docker build -t scroll_l2geth ./common/docker/l2geth/
 
-build_test_docker: ## build Docker image for local testing on M1/M2 Silicon Mac
-	docker build -t scroll_test_image -f ./build/dockerfiles/local_testing.Dockerfile $$(mktemp -d)
-
-run_test_docker: ## run Docker image for local testing on M1/M2 Silicon Mac
-	docker run -it --rm --name scroll_test_container --network=host -v /var/run/docker.sock:/var/run/docker.sock -v $(PWD):/go/src/app -e HOST_PATH=$(PWD) scroll_test_image
-
 clean: ## Empty out the bin folder
 	@rm -rf build/bin

README.md

@@ -43,8 +43,6 @@ make dev_docker
 
 ## Testing Rollup & Coordinator
 
-### For Non-Apple Silicon (M1/M2) Macs
-
 Run the tests using the following commands:
 
 ```bash
@@ -54,39 +52,6 @@ go test -v -race -covermode=atomic scroll-tech/database/...
 go test -v -race -covermode=atomic scroll-tech/common/...
 ```
 
-### For Apple Silicon (M1/M2) Macs
-
-To run tests on Apple Silicon Macs, build and execute the Docker image as outlined below:
-
-#### Build a Docker Image for Testing
-
-Use the following command to build a Docker image:
-
-```bash
-make build_test_docker
-```
-
-This command builds a Docker image named `scroll_test_image` using the Dockerfile found at `./build/dockerfiles/local_test.Dockerfile`.
-
-#### Run Docker Image
-
-After the image is built, run a Docker container from it:
-
-```bash
-make run_test_docker
-```
-
-This command runs a Docker container named `scroll_test_container` from the `scroll_test_image` image. The container uses the host network and has access to the Docker socket and the current directory.
-
-Once the Docker container is running, execute the tests using the following commands:
-
-```bash
-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/...
-```
-
 ## Testing Contracts
 
 You can find the unit tests in [`contracts/src/test/`](/contracts/src/test/), and integration tests in [`contracts/integration-test/`](/contracts/integration-test/).

bridge-history-api/README.md

@@ -79,3 +79,50 @@ provides REST APIs. Please refer to the API details below.
 // @Success      200
 // @Router       /api/txsbyhashes [post]
 ```
+
+## Running bridge-history-api locally
+
+1. Pull the latest Redis image:
+   ```
+   docker pull redis:latest
+   ```
+
+2. Run the Redis container:
+   ```
+   docker run --name bridgehistoryapi-redis -d -p 6379:6379 redis:latest
+   ```
+
+3. Pull the latest PostgreSQL image:
+   ```
+   docker pull postgres:latest
+   ```
+
+4. Run the PostgreSQL container:
+   ```
+   docker run --name bridgehistoryapi-history-db -p 5444:5432 -e POSTGRES_PASSWORD=123456 -e POSTGRES_DB=test -d postgres
+   ```
+
+5. Run database migrations to initialize the tables:
+   ```
+   make bridgehistoryapi-db-cli
+   ./build/bin/bridgehistoryapi-db-cli migrate
+   ```
+
+6. Run bridgehistoryapi-fetcher:
+   ```
+   make bridgehistoryapi-fetcher
+   ./build/bin/bridgehistoryapi-fetcher
+   ```
+
+7. Run bridgehistoryapi-api:
+   ```
+   make bridgehistoryapi-api
+   ./build/bin/bridgehistoryapi-api
+   ```
+
+The endpoints provided in [./conf/config.json](./conf/config.json) are all public endpoints and have rate limits.
+
+For production usage:
+
+- For L1 endpoints, utilizing a service provider's free tier should suffice.
+- For L2 endpoints, consider [running a Scroll L2geth node](https://docs.scroll.xyz/en/developers/guides/running-a-scroll-node) and using the exposed HTTP port.

bridge-history-api/conf/config.json

@@ -15,6 +15,7 @@
 		"USDCGatewayAddr": "0xf1AF3b23DE0A5Ca3CAb7261cb0061C0D779A5c7B",
 		"LIDOGatewayAddr": "0x6625C6332c9F91F2D27c304E729B86db87A3f504",
 		"DAIGatewayAddr": "0x67260A8B73C5B77B55c1805218A42A7A6F98F515",
+		"PufferGatewayAddr": "0xA033Ff09f2da45f0e9ae495f525363722Df42b2a",
 		"ScrollChainAddr": "0xa13BAF47339d63B743e7Da8741db5456DAc1E556",
 		"GatewayRouterAddr": "0xF8B1378579659D8F7EE5f3C929c2f3E332E41Fd6",
 		"MessageQueueAddr": "0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B"
@@ -34,7 +35,9 @@
 		"USDCGatewayAddr": "0x33B60d5Dd260d453cAC3782b0bDC01ce84672142",
 		"LIDOGatewayAddr": "0x8aE8f22226B9d789A36AC81474e633f8bE2856c9",
 		"DAIGatewayAddr": "0xaC78dff3A87b5b534e366A93E785a0ce8fA6Cc62",
-		"GatewayRouterAddr": "0x4C0926FF5252A435FD19e10ED15e5a249Ba19d79"
+		"PufferGatewayAddr": "0x9eBf2f33526CD571f8b2ad312492cb650870CFd6",
+		"GatewayRouterAddr": "0x4C0926FF5252A435FD19e10ED15e5a249Ba19d79",
+		"MessageQueueAddr": "0x5300000000000000000000000000000000000000"
 	},
 	"db": {
 		"dsn": "postgres://postgres:123456@localhost:5444/test?sslmode=disable",

build/dockerfiles/bridgehistoryapi-api.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM golang:1.20-alpine3.16 as base
+FROM golang:1.21-alpine3.19 as base
 
 WORKDIR /src
 COPY go.mod* ./

build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM golang:1.20-alpine3.16 as base
+FROM golang:1.21-alpine3.19 as base
 
 WORKDIR /src
 COPY ./bridge-history-api/go.* ./

build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM golang:1.20-alpine3.16 as base
+FROM golang:1.21-alpine3.19 as base
 
 WORKDIR /src
 COPY go.mod* ./

build/dockerfiles/coordinator-api.Dockerfile

@@ -1,5 +1,5 @@
 # Build libzkp dependency
-FROM scrolltech/go-rust-builder:go-1.20-rust-nightly-2022-12-10 as chef
+FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as chef
 WORKDIR app
 
 FROM chef as planner
@@ -17,7 +17,7 @@ RUN find ./ | grep libzktrie.so | xargs -I{} cp {} /app/target/release/
 
 
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.20-rust-nightly-2022-12-10 as base
+FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as base
 WORKDIR /src
 COPY go.work* ./
 COPY ./rollup/go.* ./rollup/

build/dockerfiles/coordinator-cron.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.20 as base
+FROM scrolltech/go-alpine-builder:1.21 as base
 
 WORKDIR /src
 COPY go.work* ./

build/dockerfiles/db_cli.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.20 as base
+FROM scrolltech/go-alpine-builder:1.21 as base
 
 WORKDIR /src
 COPY go.work* ./

build/dockerfiles/event_watcher.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.20 as base
+FROM scrolltech/go-alpine-builder:1.21 as base
 
 WORKDIR /src
 COPY go.work* ./

build/dockerfiles/gas_oracle.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.20 as base
+FROM scrolltech/go-alpine-builder:1.21 as base
 
 WORKDIR /src
 COPY go.work* ./

build/dockerfiles/intermediate/Makefile

@@ -1,8 +1,8 @@
 ifeq ($(GO_VERSION),)
-  GO_VERSION=1.20
+  GO_VERSION=1.21
 endif
 ifeq ($(RUST_VERSION),)
-  RUST_VERSION=nightly-2022-12-10
+  RUST_VERSION=nightly-2023-12-03
 endif
 ifeq ($(PYTHON_VERSION),)
   PYTHON_VERSION=3.10

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

@@ -1,6 +1,6 @@
 ARG CUDA_VERSION=11.7.1
-ARG GO_VERSION=1.20
+ARG GO_VERSION=1.21
-ARG RUST_VERSION=nightly-2022-12-10
+ARG RUST_VERSION=nightly-2023-12-03
 ARG CARGO_CHEF_TAG=0.1.41
 
 FROM nvidia/cuda:${CUDA_VERSION}-devel-ubuntu22.04

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

@@ -1,4 +1,4 @@
-ARG GO_VERSION=1.20
+ARG GO_VERSION=1.21
 
 FROM golang:${GO_VERSION}-alpine
 

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

@@ -1,5 +1,5 @@
-ARG GO_VERSION=1.20
+ARG GO_VERSION=1.21
-ARG RUST_VERSION=nightly-2022-12-10
+ARG RUST_VERSION=nightly-2023-12-03
 ARG CARGO_CHEF_TAG=0.1.41
 
 FROM golang:${GO_VERSION}-alpine

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

@@ -1,5 +1,5 @@
-ARG GO_VERSION=1.20
+ARG GO_VERSION=1.21
-ARG RUST_VERSION=nightly-2022-12-10
+ARG RUST_VERSION=nightly-2023-12-03
 ARG CARGO_CHEF_TAG=0.1.41
 
 FROM ubuntu:20.04

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

@@ -1,5 +1,5 @@
 ARG ALPINE_VERSION=3.15
-ARG RUST_VERSION=nightly-2022-12-10
+ARG RUST_VERSION=nightly-2023-12-03
 ARG CARGO_CHEF_TAG=0.1.41
 
 FROM alpine:${ALPINE_VERSION}

build/dockerfiles/intermediate/rust-builder.Dockerfile

@@ -1,4 +1,4 @@
-ARG RUST_VERSION=nightly-2022-12-10
+ARG RUST_VERSION=nightly-2023-12-03
 ARG CARGO_CHEF_TAG=0.1.41
 
 FROM ubuntu:20.04

build/dockerfiles/local_testing.Dockerfile

@@ -1,11 +0,0 @@
-# Start from the latest golang base image
-FROM golang:1.21
-
-# Install Docker
-RUN apt-get update && apt-get install -y docker.io docker-compose
-
-# Set the working directory
-WORKDIR /go/src/app
-
-# This container will be executable 
-ENTRYPOINT [ "/bin/bash" ]

build/dockerfiles/rollup_relayer.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.20 as base
+FROM scrolltech/go-alpine-builder:1.21 as base
 
 WORKDIR /src
 COPY go.work* ./

common/testcontainers/testcontainers.go

@@ -61,8 +61,11 @@ func (t *TestcontainerApps) StartL1GethContainer() error {
 	req := testcontainers.ContainerRequest{
 		Image:        "scroll_l1geth",
 		ExposedPorts: []string{"8546/tcp", "8545/tcp"},
-		WaitingFor:   wait.ForHTTP("/").WithPort("8545").WithStartupTimeout(100 * time.Second),
+		WaitingFor: wait.ForAll(
-		Cmd:          []string{"--log.debug", "ANY"},
+			wait.ForListeningPort("8546").WithStartupTimeout(100*time.Second),
+			wait.ForListeningPort("8545").WithStartupTimeout(100*time.Second),
+		),
+		Cmd: []string{"--log.debug", "ANY"},
 	}
 	genericContainerReq := testcontainers.GenericContainerRequest{
 		ContainerRequest: req,
@@ -85,7 +88,10 @@ func (t *TestcontainerApps) StartL2GethContainer() error {
 	req := testcontainers.ContainerRequest{
 		Image:        "scroll_l2geth",
 		ExposedPorts: []string{"8546/tcp", "8545/tcp"},
-		WaitingFor:   wait.ForHTTP("/").WithPort("8545").WithStartupTimeout(100 * time.Second),
+		WaitingFor: wait.ForAll(
+			wait.ForListeningPort("8546").WithStartupTimeout(100*time.Second),
+			wait.ForListeningPort("8545").WithStartupTimeout(100*time.Second),
+		),
 	}
 	genericContainerReq := testcontainers.GenericContainerRequest{
 		ContainerRequest: req,

common/types/constructing-target-payload-tx-in-different-chunks/main.go

@@ -1,133 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"math/big"
-	"time"
-
-	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
-	"github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/crypto"
-	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/scroll-tech/go-ethereum/rlp"
-)
-
-const targetTxSize = 126914
-
-func main() {
-	privateKeyHex := "0000000000000000000000000000000000000000000000000000000000000042"
-	privateKey, err := crypto.HexToECDSA(privateKeyHex)
-	if err != nil {
-		log.Fatalf("Invalid private key: %v", err)
-	}
-
-	client, err := ethclient.Dial("http://localhost:9999")
-	if err != nil {
-		log.Fatalf("Failed to connect to the Ethereum client: %v", err)
-	}
-
-	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(222222))
-	if err != nil {
-		log.Fatalf("Failed to create transactor with chain ID 222222: %v", err)
-	}
-
-	nonce, err := client.PendingNonceAt(context.Background(), auth.From)
-	if err != nil {
-		log.Fatalf("Failed to retrieve account nonce: %v", err)
-	}
-
-	totalTxNum := []uint64{2, 3, 4, 5, 6}
-	for _, num := range totalTxNum {
-		prepareAndSendTransactions(client, auth, nonce, num)
-		nonce += num
-	}
-}
-
-func prepareAndSendTransactions(client *ethclient.Client, auth *bind.TransactOpts, initialNonce uint64, totalTxNum uint64) error {
-	gasLimit := uint64(5000000)
-	gasPrice := big.NewInt(1000000000)
-
-	var signedTxs []*types.Transaction
-	payloadSum := 0
-
-	dataPayload := make([]byte, targetTxSize/totalTxNum)
-	for i := range dataPayload {
-		dataPayload[i] = 0xff
-	}
-
-	for i := uint64(0); i < totalTxNum-1; i++ {
-		txData := &types.LegacyTx{
-			Nonce:    initialNonce + i,
-			GasPrice: gasPrice,
-			Gas:      gasLimit,
-			To:       &auth.From,
-			Data:     dataPayload,
-		}
-
-		signedTx, err := auth.Signer(auth.From, types.NewTx(txData))
-		if err != nil {
-			log.Fatalf("Failed to sign tx: %v", err)
-		}
-
-		rlpTxData, err := rlp.EncodeToBytes(signedTx)
-		if err != nil {
-			log.Fatalf("Failed to RLP encode the tx: %v", err)
-		}
-
-		payloadSum += len(rlpTxData)
-		signedTxs = append(signedTxs, signedTx)
-	}
-
-	fmt.Println("payload sum", payloadSum)
-
-	lowerBound := 0
-	upperBound := targetTxSize
-	for lowerBound <= upperBound {
-		mid := (lowerBound + upperBound) / 2
-		data := make([]byte, mid)
-		for i := range data {
-			data[i] = 0xff
-		}
-
-		txData := &types.LegacyTx{
-			Nonce:    initialNonce + totalTxNum - 1,
-			GasPrice: gasPrice,
-			Gas:      gasLimit,
-			To:       &auth.From,
-			Data:     data,
-		}
-
-		signedTx, err := auth.Signer(auth.From, types.NewTx(txData))
-		if err != nil {
-			log.Fatalf("Failed to sign tx: %v", err)
-		}
-
-		rlpTxData, err := rlp.EncodeToBytes(signedTx)
-		if err != nil {
-			log.Fatalf("Failed to RLP encode the tx: %v", err)
-		}
-		txSize := len(rlpTxData)
-
-		if payloadSum+txSize < targetTxSize {
-			lowerBound = mid + 1
-		} else if payloadSum+txSize > targetTxSize {
-			upperBound = mid - 1
-		} else {
-			fmt.Println("payloadSum+txSize", payloadSum+txSize)
-			signedTxs = append(signedTxs, signedTx)
-			break
-		}
-	}
-
-	for _, signedTx := range signedTxs {
-		if err := client.SendTransaction(context.Background(), signedTx); err != nil {
-			return fmt.Errorf("failed to send transaction: %v", err)
-		}
-		fmt.Printf("Transaction with nonce %d sent\n", signedTx.Nonce())
-		time.Sleep(10 * time.Second)
-	}
-
-	return nil
-}

common/types/constructing-target-payload-tx/main.go

@@ -1,131 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"math/big"
-
-	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
-	"github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/crypto"
-	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/scroll-tech/go-ethereum/rlp"
-)
-
-const targetTxSize = 120568
-
-func main() {
-	privateKeyHex := "0000000000000000000000000000000000000000000000000000000000000042"
-	privateKey, err := crypto.HexToECDSA(privateKeyHex)
-	if err != nil {
-		log.Fatalf("Invalid private key: %v", err)
-	}
-
-	client, err := ethclient.Dial("http://localhost:9999")
-	if err != nil {
-		log.Fatalf("Failed to connect to the Ethereum client: %v", err)
-	}
-
-	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(222222))
-	if err != nil {
-		log.Fatalf("Failed to create transactor with chain ID 222222: %v", err)
-	}
-
-	nonce, err := client.PendingNonceAt(context.Background(), auth.From)
-	if err != nil {
-		log.Fatalf("Failed to retrieve account nonce: %v", err)
-	}
-	prepareAndSendTransactions(client, auth, nonce, 1)
-	prepareAndSendTransactions(client, auth, nonce+1, 2)
-	prepareAndSendTransactions(client, auth, nonce+1+2, 3)
-	prepareAndSendTransactions(client, auth, nonce+1+2+3, 4)
-	prepareAndSendTransactions(client, auth, nonce+1+2+3+4, 5)
-	prepareAndSendTransactions(client, auth, nonce+1+2+3+4+5, 6)
-}
-
-func prepareAndSendTransactions(client *ethclient.Client, auth *bind.TransactOpts, initialNonce uint64, totalTxNum uint64) error {
-	gasLimit := uint64(5000000)
-	gasPrice := big.NewInt(1000000000)
-
-	var signedTxs []*types.Transaction
-	payloadSum := 0
-
-	dataPayload := make([]byte, targetTxSize/totalTxNum)
-	for i := range dataPayload {
-		dataPayload[i] = 0xff
-	}
-
-	for i := uint64(0); i < totalTxNum-1; i++ {
-		txData := &types.LegacyTx{
-			Nonce:    initialNonce + i,
-			GasPrice: gasPrice,
-			Gas:      gasLimit,
-			To:       &auth.From,
-			Data:     dataPayload,
-		}
-
-		signedTx, err := auth.Signer(auth.From, types.NewTx(txData))
-		if err != nil {
-			log.Fatalf("Failed to sign tx: %v", err)
-		}
-
-		rlpTxData, err := rlp.EncodeToBytes(signedTx)
-		if err != nil {
-			log.Fatalf("Failed to RLP encode the tx: %v", err)
-		}
-
-		payloadSum += len(rlpTxData)
-		signedTxs = append(signedTxs, signedTx)
-	}
-
-	fmt.Println("payload sum", payloadSum)
-
-	lowerBound := 0
-	upperBound := targetTxSize
-	for lowerBound <= upperBound {
-		mid := (lowerBound + upperBound) / 2
-		data := make([]byte, mid)
-		for i := range data {
-			data[i] = 0xff
-		}
-
-		txData := &types.LegacyTx{
-			Nonce:    initialNonce + totalTxNum - 1,
-			GasPrice: gasPrice,
-			Gas:      gasLimit,
-			To:       &auth.From,
-			Data:     data,
-		}
-
-		signedTx, err := auth.Signer(auth.From, types.NewTx(txData))
-		if err != nil {
-			log.Fatalf("Failed to sign tx: %v", err)
-		}
-
-		rlpTxData, err := rlp.EncodeToBytes(signedTx)
-		if err != nil {
-			log.Fatalf("Failed to RLP encode the tx: %v", err)
-		}
-		txSize := len(rlpTxData)
-
-		if payloadSum+txSize < targetTxSize {
-			lowerBound = mid + 1
-		} else if payloadSum+txSize > targetTxSize {
-			upperBound = mid - 1
-		} else {
-			fmt.Println("payloadSum+txSize", payloadSum+txSize)
-			signedTxs = append(signedTxs, signedTx)
-			break
-		}
-	}
-
-	for i := len(signedTxs) - 1; i >= 0; i-- {
-		if err := client.SendTransaction(context.Background(), signedTxs[i]); err != nil {
-			return fmt.Errorf("failed to send transaction: %v", err)
-		}
-		fmt.Printf("Transaction with nonce %d sent\n", signedTxs[i].Nonce())
-	}
-
-	return nil
-}

common/version/version.go

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

contracts/scripts/foundry/DeployEcc.s.sol

@@ -1,23 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity =0.8.24;
-
-import {Script} from "forge-std/Script.sol";
-import {console} from "forge-std/console.sol";
-
-import {Ecc} from "../../src/misc/ecc.sol";
-
-contract DeployEcc is Script {
-    function run() external {
-        uint256 L2_DEPLOYER_PRIVATE_KEY = vm.envUint("L2_DEPLOYER_PRIVATE_KEY");
-        vm.startBroadcast(L2_DEPLOYER_PRIVATE_KEY);
-        Ecc ecc = new Ecc();
-        address L2_ECC_ADDR = address(ecc);
-        vm.stopBroadcast();
-
-        logAddress("L2_ECC_ADDR", L2_ECC_ADDR);
-    }
-
-    function logAddress(string memory name, address addr) internal view {
-        console.log(string(abi.encodePacked(name, "=", vm.toString(address(addr)))));
-    }
-}

contracts/scripts/foundry/DeployHash.s.sol

@@ -1,23 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity =0.8.24;
-
-import {Script} from "forge-std/Script.sol";
-import {console} from "forge-std/console.sol";
-
-import {Hash} from "../../src/misc/hash.sol";
-
-contract DeployHash is Script {
-    function run() external {
-        uint256 L2_DEPLOYER_PRIVATE_KEY = vm.envUint("L2_DEPLOYER_PRIVATE_KEY");
-        vm.startBroadcast(L2_DEPLOYER_PRIVATE_KEY);
-        Hash hash = new Hash();
-        address L2_HASH_ADDR = address(hash);
-        vm.stopBroadcast();
-
-        logAddress("L2_HASH_ADDR", L2_HASH_ADDR);
-    }
-
-    function logAddress(string memory name, address addr) internal view {
-        console.log(string(abi.encodePacked(name, "=", vm.toString(address(addr)))));
-    }
-}

contracts/scripts/foundry/DeployL1BridgeContracts.s.sol

@@ -92,12 +92,10 @@ contract DeployL1BridgeContracts is Script {
     }
 
     function deployMultipleVersionRollupVerifier() internal {
-        uint256[] memory _versions = new uint256[](2);
+        uint256[] memory _versions = new uint256[](1);
-        address[] memory _verifiers = new address[](2);
+        address[] memory _verifiers = new address[](1);
         _versions[0] = 0;
         _verifiers[0] = address(zkEvmVerifierV1);
-        _versions[1] = 1;
-        _verifiers[1] = address(zkEvmVerifierV1);
         rollupVerifier = new MultipleVersionRollupVerifier(L1_SCROLL_CHAIN_PROXY_ADDR, _versions, _verifiers);
 
         logAddress("L1_MULTIPLE_VERSION_ROLLUP_VERIFIER_ADDR", address(rollupVerifier));

contracts/scripts/relay-skipped-tx.ts

@@ -1,34 +0,0 @@
-/* eslint-disable node/no-missing-import */
-import * as dotenv from "dotenv";
-
-import { ethers } from "hardhat";
-
-dotenv.config();
-
-async function main() {
-  const [deployer] = await ethers.getSigners();
-
-  const l1ScrollMessengerAddress = process.env.L1_SCROLL_MESSENGER_PROXY_ADDR!;
-  const l2EccContractAddress = process.env.L2_ECC_ADDR!;
-  const payload = process.env.SKIPPED_TX_PAYLOAD!; // TODO: calc the payload, parse as bytes
-
-  const L1ScrollMessenger = await ethers.getContractAt("L1ScrollMessenger", l1ScrollMessengerAddress, deployer);
-
-  const tx = await L1ScrollMessenger.sendMessage(
-    l2EccContractAddress, // address _to
-    0, // uint256 _value
-    payload, // bytes memory _message
-    100000000 // uint256 _gasLimit
-  );
-
-  console.log(`calling ${l2EccContractAddress} with payload from l1, hash:`, tx.hash);
-  const receipt = await tx.wait();
-  console.log(`✅ Done, gas used: ${receipt.gasUsed}`);
-}
-
-// We recommend this pattern to be able to use async/await everywhere
-// and properly handle errors.
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

contracts/src/misc/ecc.sol

@@ -1,127 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-
-pragma solidity =0.8.24;
-
-contract Ecc {
-    /* ECC Functions */
-    // https://etherscan.io/address/0x41bf00f080ed41fa86201eac56b8afb170d9e36d#code
-    function ecAdd(uint256[2] memory p0, uint256[2] memory p1) public view returns (uint256[2] memory retP) {
-        uint256[4] memory i = [p0[0], p0[1], p1[0], p1[1]];
-
-        assembly {
-            // call ecadd precompile
-            // inputs are: x1, y1, x2, y2
-            if iszero(staticcall(not(0), 0x06, i, 0x80, retP, 0x40)) {
-                revert(0, 0)
-            }
-        }
-    }
-
-    // https://etherscan.io/address/0x41bf00f080ed41fa86201eac56b8afb170d9e36d#code
-    function ecMul(uint256[2] memory p, uint256 s) public view returns (uint256[2] memory retP) {
-        // With a public key (x, y), this computes p = scalar * (x, y).
-        uint256[3] memory i = [p[0], p[1], s];
-
-        assembly {
-            // call ecmul precompile
-            // inputs are: x, y, scalar
-            if iszero(staticcall(not(0), 0x07, i, 0x60, retP, 0x40)) {
-                revert(0, 0)
-            }
-        }
-    }
-
-    // scroll-tech/scroll/contracts/src/libraries/verifier/RollupVerifier.sol
-    struct G1Point {
-        uint256 x;
-        uint256 y;
-    }
-    struct G2Point {
-        uint256[2] x;
-        uint256[2] y;
-    }
-
-    function ecPairing(G1Point[] memory p1, G2Point[] memory p2) internal view returns (bool) {
-        uint256 length = p1.length * 6;
-        uint256[] memory input = new uint256[](length);
-        uint256[1] memory result;
-        bool ret;
-
-        require(p1.length == p2.length);
-
-        for (uint256 i = 0; i < p1.length; i++) {
-            input[0 + i * 6] = p1[i].x;
-            input[1 + i * 6] = p1[i].y;
-            input[2 + i * 6] = p2[i].x[0];
-            input[3 + i * 6] = p2[i].x[1];
-            input[4 + i * 6] = p2[i].y[0];
-            input[5 + i * 6] = p2[i].y[1];
-        }
-
-        assembly {
-            ret := staticcall(gas(), 8, add(input, 0x20), mul(length, 0x20), result, 0x20)
-        }
-        require(ret);
-        return result[0] != 0;
-    }
-
-    /* Bench */
-    function ecAdds(uint256 n) public {
-        uint256[2] memory p0;
-        p0[0] = 1;
-        p0[1] = 2;
-        uint256[2] memory p1;
-        p1[0] = 1;
-        p1[1] = 2;
-
-        for (uint256 i = 0; i < n; i++) {
-            ecAdd(p0, p1);
-        }
-    }
-
-    function ecMuls(uint256 n) public {
-        uint256[2] memory p0;
-        p0[0] = 1;
-        p0[1] = 2;
-
-        for (uint256 i = 0; i < n; i++) {
-            ecMul(p0, 3);
-        }
-    }
-
-    function ecPairings(uint256 n) public {
-        G1Point[] memory g1_points = new G1Point[](2);
-        G2Point[] memory g2_points = new G2Point[](2);
-        g1_points[0].x = 0x0000000000000000000000000000000000000000000000000000000000000001;
-        g1_points[0].y = 0x0000000000000000000000000000000000000000000000000000000000000002;
-        g2_points[0].x[1] = 0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed;
-        g2_points[0].x[0] = 0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2;
-        g2_points[0].y[1] = 0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa;
-        g2_points[0].y[0] = 0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b;
-        g1_points[1].x = 0x1aa125a22bd902874034e67868aed40267e5575d5919677987e3bc6dd42a32fe;
-        g1_points[1].y = 0x1bacc186725464068956d9a191455c2d6f6db282d83645c610510d8d4efbaee0;
-        g2_points[1].x[1] = 0x1b7734c80605f71f1e2de61e998ce5854ff2abebb76537c3d67e50d71422a852;
-        g2_points[1].x[0] = 0x10d5a1e34b2388a5ebe266033a5e0e63c89084203784da0c6bd9b052a78a2cac;
-        g2_points[1].y[1] = 0x275739c5c2cdbc72e37c689e2ab441ea76c1d284b9c46ae8f5c42ead937819e1;
-        g2_points[1].y[0] = 0x018de34c5b7c3d3d75428bbe050f1449ea3d9961d563291f307a1874f7332e65;
-
-        for (uint256 i = 0; i < n; i++) {
-            ecPairing(g1_points, g2_points);
-            // bool checked = false;
-            // checked = ecPairing(g1_points, g2_points);
-            // require(checked);
-        }
-    }
-
-    // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/8a0b7bed82d6b8053872c3fd40703efd58f5699d/test/utils/cryptography/ECDSA.test.js#L230
-    function ecRecovers(uint256 n) public {
-        bytes32 hash = 0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9;
-        bytes32 r = 0xe742ff452d41413616a5bf43fe15dd88294e983d3d36206c2712f39083d638bd;
-        uint8 v = 0x1b;
-        bytes32 s = 0xe0a0fc89be718fbc1033e1d30d78be1c68081562ed2e97af876f286f3453231d;
-
-        for (uint256 i = 0; i < n; i++) {
-            ecrecover(hash, v, r, s);
-        }
-    }
-}

contracts/src/misc/hash.sol

@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-
-pragma solidity =0.8.24;
-
-contract Hash {
-    function sha256(bytes memory input) public view returns (bytes memory out) {
-        (bool ok, bytes memory out) = address(2).staticcall(input);
-        require(ok);
-    }
-
-    function sha256Yul(bytes memory input) public view returns (bytes memory out) {
-        assembly {
-            // mstore(0, input)
-            if iszero(staticcall(gas(), 2, 0, 32, 0, 32)) {
-                revert(0, 0)
-            }
-            // return(0, 32)
-        }
-    }
-
-    function sha256s(bytes memory input, uint256 n) public {
-        for (uint256 i = 0; i < n; i++) {
-            sha256(input);
-        }
-    }
-
-    function keccak256s(uint256 n) public {
-        bytes32[] memory output = new bytes32[](n);
-        for (uint256 i = 0; i < n; i++) {
-            bytes memory input = abi.encode(i);
-            output[i] = keccak256(input);
-        }
-    }
-}

coordinator/README.md

@@ -38,7 +38,7 @@ make lint
 
 ## Configure
 
-The coordinator behavior can be configured using [`config.json`](config.json). Check the code comments under `ProverManager` in [`config/config.go`](config/config.go) for more details.
+The coordinator behavior can be configured using [`conf/config.json`](conf/config.json). Check the code comments under `ProverManager` in [`internal/config/config.go`](internal/config/config.go) for more details.
 
 
 ## Start

coordinator/go.mod

@@ -1,6 +1,6 @@
 module scroll-tech/coordinator
 
-go 1.20
+go 1.21
 
 require (
 	github.com/appleboy/gin-jwt/v2 v2.9.1

coordinator/go.sum

@@ -59,6 +59,7 @@ 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-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs=
 github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
 github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
@@ -95,6 +96,7 @@ github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3
 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/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=
@@ -117,11 +119,13 @@ github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORN
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 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/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
 github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
 github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
@@ -144,6 +148,7 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJ
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/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/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
@@ -153,6 +158,7 @@ github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6
 github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.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 v1.16.0 h1:yk/hx9hDbrGHovbci4BY+pRMfSuuat626eFsHb7tmT8=
@@ -164,6 +170,7 @@ github.com/prometheus/common v0.42.0/go.mod h1:xBwqVerjNdUDjgODMpudtOMwlOwf2SaTr
 github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
 github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
 github.com/prometheus/tsdb v0.7.1 h1:YZcsG11NqnK4czYLrWd9mpEuAJIHVQLwdrleYfszMAA=
+github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
@@ -197,6 +204,7 @@ github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8
 github.com/supranational/blst v0.3.11-0.20230124161941-ca03e11a3ff2 h1:wh1wzwAhZBNiZO37uWS/nDaKiIwHz4mDo4pnA+fqTO0=
 github.com/supranational/blst v0.3.11-0.20230124161941-ca03e11a3ff2/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
+github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
 github.com/tidwall/gjson v1.14.3 h1:9jvXn7olKEHU1S9vwoMGliaT8jq1vJ7IH/n9zD9Dnlw=
 github.com/tidwall/gjson v1.14.3/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
 github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=

coordinator/internal/controller/cron/cleanup_challenge.go

@@ -30,8 +30,8 @@ func (c *Collector) cleanupChallenge() {
 				log.Error("manager context canceled with error", "error", c.ctx.Err())
 			}
 			return
-		case <-c.stopTimeoutChan:
+		case <-c.stopCleanChallengeChan:
-			log.Info("the coordinator run loop exit")
+			log.Info("the coordinator cleanupChallenge run loop exit")
 			return
 		}
 	}

coordinator/internal/controller/cron/collect_proof.go

@@ -23,7 +23,10 @@ type Collector struct {
 	db  *gorm.DB
 	ctx context.Context
 
-	stopTimeoutChan chan struct{}
+	stopChunkTimeoutChan       chan struct{}
+	stopBatchTimeoutChan       chan struct{}
+	stopBatchAllChunkReadyChan chan struct{}
+	stopCleanChallengeChan     chan struct{}
 
 	proverTaskOrm *orm.ProverTask
 	chunkOrm      *orm.Chunk
@@ -40,14 +43,17 @@ type Collector struct {
 // NewCollector create a collector to cron collect the data to send to prover
 func NewCollector(ctx context.Context, db *gorm.DB, cfg *config.Config, reg prometheus.Registerer) *Collector {
 	c := &Collector{
-		cfg:             cfg,
+		cfg:                        cfg,
-		db:              db,
+		db:                         db,
-		ctx:             ctx,
+		ctx:                        ctx,
-		stopTimeoutChan: make(chan struct{}),
+		stopChunkTimeoutChan:       make(chan struct{}),
-		proverTaskOrm:   orm.NewProverTask(db),
+		stopBatchTimeoutChan:       make(chan struct{}),
-		chunkOrm:        orm.NewChunk(db),
+		stopBatchAllChunkReadyChan: make(chan struct{}),
-		batchOrm:        orm.NewBatch(db),
+		stopCleanChallengeChan:     make(chan struct{}),
-		challenge:       orm.NewChallenge(db),
+		proverTaskOrm:              orm.NewProverTask(db),
+		chunkOrm:                   orm.NewChunk(db),
+		batchOrm:                   orm.NewBatch(db),
+		challenge:                  orm.NewChallenge(db),
 
 		timeoutBatchCheckerRunTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 			Name: "coordinator_batch_timeout_checker_run_total",
@@ -83,7 +89,10 @@ func NewCollector(ctx context.Context, db *gorm.DB, cfg *config.Config, reg prom
 
 // Stop all the collector
 func (c *Collector) Stop() {
-	c.stopTimeoutChan <- struct{}{}
+	c.stopChunkTimeoutChan <- struct{}{}
+	c.stopBatchTimeoutChan <- struct{}{}
+	c.stopBatchAllChunkReadyChan <- struct{}{}
+	c.stopCleanChallengeChan <- struct{}{}
 }
 
 // timeoutTask cron check the send task is timeout. if timeout reached, restore the
@@ -113,8 +122,8 @@ func (c *Collector) timeoutBatchProofTask() {
 				log.Error("manager context canceled with error", "error", c.ctx.Err())
 			}
 			return
-		case <-c.stopTimeoutChan:
+		case <-c.stopBatchTimeoutChan:
-			log.Info("the coordinator run loop exit")
+			log.Info("the coordinator timeoutBatchProofTask run loop exit")
 			return
 		}
 	}
@@ -146,8 +155,8 @@ func (c *Collector) timeoutChunkProofTask() {
 				log.Error("manager context canceled with error", "error", c.ctx.Err())
 			}
 			return
-		case <-c.stopTimeoutChan:
+		case <-c.stopChunkTimeoutChan:
-			log.Info("the coordinator run loop exit")
+			log.Info("the coordinator timeoutChunkProofTask run loop exit")
 			return
 		}
 	}
@@ -253,8 +262,8 @@ func (c *Collector) checkBatchAllChunkReady() {
 				log.Error("manager context canceled with error", "error", c.ctx.Err())
 			}
 			return
-		case <-c.stopTimeoutChan:
+		case <-c.stopBatchAllChunkReadyChan:
-			log.Info("the coordinator run loop exit")
+			log.Info("the coordinator checkBatchAllChunkReady run loop exit")
 			return
 		}
 	}

coordinator/internal/logic/auth/login.go

@@ -21,5 +21,5 @@ func NewLoginLogic(db *gorm.DB) *LoginLogic {
 
 // InsertChallengeString insert and check the challenge string is existed
 func (l *LoginLogic) InsertChallengeString(ctx *gin.Context, challenge string) error {
-	return l.challengeOrm.InsertChallenge(ctx, challenge)
+	return l.challengeOrm.InsertChallenge(ctx.Copy(), challenge)
 }

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -83,7 +83,7 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	var endChunkIndex uint64 = math.MaxInt64
 	fromBlockNum, toBlockNum := forks.BlockRange(hardForkNumber, bp.forkHeights)
 	if fromBlockNum != 0 {
-		startChunk, chunkErr := bp.chunkOrm.GetChunkByStartBlockNumber(ctx, fromBlockNum)
+		startChunk, chunkErr := bp.chunkOrm.GetChunkByStartBlockNumber(ctx.Copy(), fromBlockNum)
 		if chunkErr != nil {
 			log.Error("failed to get fork start chunk index", "forkName", taskCtx.HardForkName, "fromBlockNumber", fromBlockNum, "err", chunkErr)
 			return nil, ErrCoordinatorInternalFailure
@@ -94,7 +94,7 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		startChunkIndex = startChunk.Index
 	}
 	if toBlockNum != math.MaxInt64 {
-		toChunk, chunkErr := bp.chunkOrm.GetChunkByStartBlockNumber(ctx, toBlockNum)
+		toChunk, chunkErr := bp.chunkOrm.GetChunkByStartBlockNumber(ctx.Copy(), toBlockNum)
 		if chunkErr != nil {
 			log.Error("failed to get fork end chunk index", "forkName", taskCtx.HardForkName, "toBlockNumber", toBlockNum, "err", chunkErr)
 			return nil, ErrCoordinatorInternalFailure
@@ -112,7 +112,7 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpBatchTask *orm.Batch
-		tmpBatchTask, getTaskError = bp.batchOrm.GetAssignedBatch(ctx, startChunkIndex, endChunkIndex, maxActiveAttempts, maxTotalAttempts)
+		tmpBatchTask, getTaskError = bp.batchOrm.GetAssignedBatch(ctx.Copy(), startChunkIndex, endChunkIndex, maxActiveAttempts, maxTotalAttempts)
 		if getTaskError != nil {
 			log.Error("failed to get assigned batch proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 			return nil, ErrCoordinatorInternalFailure
@@ -121,7 +121,7 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		// Why here need get again? In order to support a task can assign to multiple prover, need also assign `ProvingTaskAssigned`
 		// batch to prover. But use `proving_status in (1, 2)` will not use the postgres index. So need split the sql.
 		if tmpBatchTask == nil {
-			tmpBatchTask, getTaskError = bp.batchOrm.GetUnassignedBatch(ctx, startChunkIndex, endChunkIndex, maxActiveAttempts, maxTotalAttempts)
+			tmpBatchTask, getTaskError = bp.batchOrm.GetUnassignedBatch(ctx.Copy(), startChunkIndex, endChunkIndex, maxActiveAttempts, maxTotalAttempts)
 			if getTaskError != nil {
 				log.Error("failed to get unassigned batch proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 				return nil, ErrCoordinatorInternalFailure
@@ -133,7 +133,7 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 			return nil, nil
 		}
 
-		rowsAffected, updateAttemptsErr := bp.batchOrm.UpdateBatchAttempts(ctx, tmpBatchTask.Index, tmpBatchTask.ActiveAttempts, tmpBatchTask.TotalAttempts)
+		rowsAffected, updateAttemptsErr := bp.batchOrm.UpdateBatchAttempts(ctx.Copy(), tmpBatchTask.Index, tmpBatchTask.ActiveAttempts, tmpBatchTask.TotalAttempts)
 		if updateAttemptsErr != nil {
 			log.Error("failed to update batch attempts", "height", getTaskParameter.ProverHeight, "err", updateAttemptsErr)
 			return nil, ErrCoordinatorInternalFailure
@@ -168,13 +168,13 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	}
 
 	// Store session info.
-	if err = bp.proverTaskOrm.InsertProverTask(ctx, &proverTask); err != nil {
+	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)
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	taskMsg, err := bp.formatProverTask(ctx, &proverTask)
+	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)
@@ -242,7 +242,7 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 }
 
 func (bp *BatchProverTask) recoverActiveAttempts(ctx *gin.Context, batchTask *orm.Batch) {
-	if err := bp.chunkOrm.DecreaseActiveAttemptsByHash(ctx, batchTask.Hash); err != nil {
+	if err := bp.chunkOrm.DecreaseActiveAttemptsByHash(ctx.Copy(), batchTask.Hash); err != nil {
 		log.Error("failed to recover batch active attempts", "hash", batchTask.Hash, "error", err)
 	}
 }

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -85,7 +85,7 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpChunkTask *orm.Chunk
-		tmpChunkTask, getTaskError = cp.chunkOrm.GetAssignedChunk(ctx, fromBlockNum, toBlockNum, maxActiveAttempts, maxTotalAttempts)
+		tmpChunkTask, getTaskError = cp.chunkOrm.GetAssignedChunk(ctx.Copy(), fromBlockNum, toBlockNum, maxActiveAttempts, maxTotalAttempts)
 		if getTaskError != nil {
 			log.Error("failed to get assigned chunk proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 			return nil, ErrCoordinatorInternalFailure
@@ -94,7 +94,7 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		// Why here need get again? In order to support a task can assign to multiple prover, need also assign `ProvingTaskAssigned`
 		// chunk to prover. But use `proving_status in (1, 2)` will not use the postgres index. So need split the sql.
 		if tmpChunkTask == nil {
-			tmpChunkTask, getTaskError = cp.chunkOrm.GetUnassignedChunk(ctx, fromBlockNum, toBlockNum, maxActiveAttempts, maxTotalAttempts)
+			tmpChunkTask, getTaskError = cp.chunkOrm.GetUnassignedChunk(ctx.Copy(), fromBlockNum, toBlockNum, maxActiveAttempts, maxTotalAttempts)
 			if getTaskError != nil {
 				log.Error("failed to get unassigned chunk proving tasks", "height", getTaskParameter.ProverHeight, "err", getTaskError)
 				return nil, ErrCoordinatorInternalFailure
@@ -106,7 +106,7 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 			return nil, nil
 		}
 
-		rowsAffected, updateAttemptsErr := cp.chunkOrm.UpdateChunkAttempts(ctx, tmpChunkTask.Index, tmpChunkTask.ActiveAttempts, tmpChunkTask.TotalAttempts)
+		rowsAffected, updateAttemptsErr := cp.chunkOrm.UpdateChunkAttempts(ctx.Copy(), tmpChunkTask.Index, tmpChunkTask.ActiveAttempts, tmpChunkTask.TotalAttempts)
 		if updateAttemptsErr != nil {
 			log.Error("failed to update chunk attempts", "height", getTaskParameter.ProverHeight, "err", updateAttemptsErr)
 			return nil, ErrCoordinatorInternalFailure
@@ -140,13 +140,13 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		AssignedAt: utils.NowUTC(),
 	}
 
-	if err = cp.proverTaskOrm.InsertProverTask(ctx, &proverTask); err != nil {
+	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)
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	taskMsg, err := cp.formatProverTask(ctx, &proverTask)
+	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)

coordinator/internal/logic/provertask/prover_task.go

@@ -100,7 +100,7 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context, getTaskParameter *coor
 		return nil, fmt.Errorf("incompatible vk. please check your params files or config files")
 	}
 
-	isBlocked, err := b.proverBlockListOrm.IsPublicKeyBlocked(ctx, publicKey.(string))
+	isBlocked, err := b.proverBlockListOrm.IsPublicKeyBlocked(ctx.Copy(), publicKey.(string))
 	if err != nil {
 		return nil, fmt.Errorf("failed to check whether the public key %s is blocked before assigning a chunk task, err: %w, proverName: %s, proverVersion: %s", publicKey, err, proverName, proverVersion)
 	}
@@ -108,7 +108,7 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context, getTaskParameter *coor
 		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, publicKey.(string))
+	isAssigned, err := b.proverTaskOrm.IsProverAssigned(ctx.Copy(), publicKey.(string))
 	if err != nil {
 		return nil, fmt.Errorf("failed to check if prover %s is assigned a task, err: %w", publicKey.(string), err)
 	}

coordinator/internal/logic/submitproof/proof_receiver.go

@@ -139,14 +139,14 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofMsg *message.P
 	var proverTask *orm.ProverTask
 	var err error
 	if proofParameter.UUID != "" {
-		proverTask, err = m.proverTaskOrm.GetProverTaskByUUIDAndPublicKey(ctx, proofParameter.UUID, pk)
+		proverTask, err = m.proverTaskOrm.GetProverTaskByUUIDAndPublicKey(ctx.Copy(), proofParameter.UUID, pk)
 		if proverTask == nil || err != nil {
 			log.Error("get none prover task for the proof", "uuid", proofParameter.UUID, "key", pk, "taskID", proofMsg.ID, "error", err)
 			return ErrValidatorFailureProverTaskEmpty
 		}
 	} else {
 		// TODO When prover all have upgrade, need delete this logic
-		proverTask, err = m.proverTaskOrm.GetAssignedProverTaskByTaskIDAndProver(ctx, proofMsg.Type, proofMsg.ID, pk, pv)
+		proverTask, err = m.proverTaskOrm.GetAssignedProverTaskByTaskIDAndProver(ctx.Copy(), proofMsg.Type, proofMsg.ID, pk, pv)
 		if proverTask == nil || err != nil {
 			log.Error("get none prover task for the proof", "key", pk, "taskID", proofMsg.ID, "error", err)
 			return ErrValidatorFailureProverTaskEmpty
@@ -159,7 +159,7 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofMsg *message.P
 	log.Info("handling zk proof", "proofID", proofMsg.ID, "proverName", proverTask.ProverName,
 		"proverPublicKey", pk, "proveType", proverTask.TaskType, "proofTime", proofTimeSec, "hardForkName", hardForkName)
 
-	if err = m.validator(ctx, proverTask, pk, proofMsg, proofParameter, hardForkName); err != nil {
+	if err = m.validator(ctx.Copy(), proverTask, pk, proofMsg, proofParameter, hardForkName); err != nil {
 		return err
 	}
 
@@ -175,7 +175,7 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofMsg *message.P
 	if verifyErr != nil || !success {
 		m.verifierFailureTotal.WithLabelValues(pv).Inc()
 
-		m.proofRecover(ctx, proverTask, types.ProverTaskFailureTypeVerifiedFailed, proofMsg)
+		m.proofRecover(ctx.Copy(), proverTask, types.ProverTaskFailureTypeVerifiedFailed, proofMsg)
 
 		log.Info("proof verified by coordinator failed", "proof id", proofMsg.ID, "prover name", proverTask.ProverName,
 			"prover pk", pk, "forkName", hardForkName, "prove type", proofMsg.Type, "proof time", proofTimeSec, "error", verifyErr)
@@ -191,10 +191,10 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofMsg *message.P
 	log.Info("proof verified and valid", "proof id", proofMsg.ID, "prover name", proverTask.ProverName,
 		"prover pk", pk, "prove type", proofMsg.Type, "proof time", proofTimeSec, "forkName", hardForkName)
 
-	if err := m.closeProofTask(ctx, proverTask, proofMsg, proofTimeSec); err != nil {
+	if err := m.closeProofTask(ctx.Copy(), proverTask, proofMsg, proofTimeSec); err != nil {
 		m.proofSubmitFailure.Inc()
 
-		m.proofRecover(ctx, proverTask, types.ProverTaskFailureTypeServerError, proofMsg)
+		m.proofRecover(ctx.Copy(), proverTask, types.ProverTaskFailureTypeServerError, proofMsg)
 
 		return ErrCoordinatorInternalFailure
 	}

database/migrate/migrate_test.go

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

database/migrate/migrations/00018_add_index_taskid_createdat_prover_task.sql

@@ -0,0 +1,18 @@
+-- +goose Up
+-- +goose StatementBegin
+
+create index if not exists idx_prover_task_created_at on prover_task(created_at) where deleted_at IS NULL;
+
+create index if not exists idx_prover_task_task_id on prover_task(task_id) where deleted_at IS NULL;
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+
+drop index if exists idx_prover_task_created_at;
+
+drop index if exists idx_prover_task_task_id;
+
+
+-- +goose StatementEnd

database/migrate/migrations/00019_add_blob_base_fee.sql

@@ -0,0 +1,15 @@
+-- +goose Up
+-- +goose StatementBegin
+
+ALTER TABLE l1_block
+ADD COLUMN blob_base_fee BIGINT DEFAULT 0;
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+
+ALTER TABLE IF EXISTS l1_block
+DROP COLUMN blob_base_fee;
+
+-- +goose StatementEnd

database/migrate/migrations/00020_alter_publickey_unique_prover_block.sql

@@ -0,0 +1,17 @@
+-- +goose Up
+-- +goose StatementBegin
+
+DROP INDEX if exists idx_prover_block_list_on_public_key;
+
+CREATE UNIQUE INDEX if not exists uniq_prover_block_list_on_public_key ON prover_block_list(public_key) where deleted_at IS NULL;
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+
+CREATE INDEX if not exists idx_prover_block_list_on_public_key ON prover_block_list(public_key);
+
+DROP INDEX if exists uniq_prover_block_list_on_public_key;
+
+-- +goose StatementEnd

rollup/Makefile

@@ -24,7 +24,7 @@ rollup_relayer: ## Builds the rollup_relayer bin
 test:
 	go test -v -race -coverprofile=coverage.txt -covermode=atomic -p 1 $(PWD)/...
 
-lint: ## Lint the files - used for CI
+lint: mock_abi ## Lint the files - used for CI
 	GOBIN=$(PWD)/build/bin go run ../build/lint.go
 
 clean: ## Empty out the bin folder

rollup/cmd/gas_oracle/app/app.go

@@ -78,9 +78,15 @@ func action(ctx *cli.Context) error {
 		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
 	}
 
+	genesisPath := ctx.String(utils.Genesis.Name)
+	genesis, err := utils.ReadGenesis(genesisPath)
+	if err != nil {
+		log.Crit("failed to read genesis", "genesis file", genesisPath, "error", err)
+	}
+
 	l1watcher := watcher.NewL1WatcherClient(ctx.Context, l1client, cfg.L1Config.StartHeight, cfg.L1Config.Confirmations, cfg.L1Config.L1MessageQueueAddress, cfg.L1Config.ScrollChainContractAddress, db, registry)
 
-	l1relayer, err := relayer.NewLayer1Relayer(ctx.Context, db, cfg.L1Config.RelayerConfig, relayer.ServiceTypeL1GasOracle, registry)
+	l1relayer, err := relayer.NewLayer1Relayer(ctx.Context, db, cfg.L1Config.RelayerConfig, genesis.Config, relayer.ServiceTypeL1GasOracle, registry)
 	if err != nil {
 		log.Crit("failed to create new l1 relayer", "config file", cfgFile, "error", err)
 	}

rollup/conf/config.json

@@ -19,7 +19,9 @@
       },
       "gas_oracle_config": {
         "min_gas_price": 0,
-        "gas_price_diff": 50000
+        "gas_price_diff": 50000,
+        "l1_base_fee_weight": 0.132,
+        "l1_blob_base_fee_weight":  0.145
       },
       "gas_oracle_sender_private_key": "1313131313131313131313131313131313131313131313131313131313131313"
     }

rollup/dump-batch-info/main.go

@@ -1,103 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/hex"
-	"os"
-	"strconv"
-
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/log"
-
-	"scroll-tech/common/database"
-	"scroll-tech/common/types/encoding"
-	"scroll-tech/common/types/encoding/codecv1"
-	"scroll-tech/rollup/internal/orm"
-)
-
-func main() {
-	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.LogfmtFormat()))
-	glogger.Verbosity(log.LvlInfo)
-	log.Root().SetHandler(glogger)
-
-	if len(os.Args) < 2 {
-		log.Crit("no batch index provided")
-		return
-	}
-
-	batchIndexStr := os.Args[1]
-	batchIndexInt, err := strconv.Atoi(batchIndexStr)
-	if err != nil || batchIndexInt <= 0 {
-		log.Crit("invalid batch index", "indexStr", batchIndexStr, "err", err)
-		return
-	}
-	batchIndex := uint64(batchIndexInt)
-
-	db, err := database.InitDB(&database.Config{
-		DriverName: "postgres",
-		DSN:        os.Getenv("DB_DSN"),
-		MaxOpenNum: 200,
-		MaxIdleNum: 20,
-	})
-	if err != nil {
-		log.Crit("failed to init db", "err", err)
-	}
-	defer func() {
-		if deferErr := database.CloseDB(db); deferErr != nil {
-			log.Error("failed to close db", "err", err)
-		}
-	}()
-
-	l2BlockOrm := orm.NewL2Block(db)
-	chunkOrm := orm.NewChunk(db)
-	batchOrm := orm.NewBatch(db)
-
-	dbBatch, err := batchOrm.GetBatchByIndex(context.Background(), batchIndex)
-	if err != nil {
-		log.Crit("failed to get batch", "index", batchIndex, "err", err)
-		return
-	}
-
-	dbParentBatch, err := batchOrm.GetBatchByIndex(context.Background(), batchIndex-1)
-	if err != nil {
-		log.Crit("failed to get batch", "index", batchIndex-1, "err", err)
-		return
-	}
-
-	dbChunks, err := chunkOrm.GetChunksInRange(context.Background(), dbBatch.StartChunkIndex, dbBatch.EndChunkIndex)
-	if err != nil {
-		log.Crit("failed to fetch chunks", "err", err)
-		return
-	}
-
-	chunks := make([]*encoding.Chunk, len(dbChunks))
-	for i, c := range dbChunks {
-		blocks, err := l2BlockOrm.GetL2BlocksInRange(context.Background(), c.StartBlockNumber, c.EndBlockNumber)
-		if err != nil {
-			log.Crit("failed to fetch blocks", "err", err)
-			return
-		}
-		chunks[i] = &encoding.Chunk{Blocks: blocks}
-	}
-
-	batch := &encoding.Batch{
-		Index:                      dbBatch.Index,
-		TotalL1MessagePoppedBefore: dbChunks[0].TotalL1MessagesPoppedBefore,
-		ParentBatchHash:            common.HexToHash(dbParentBatch.Hash),
-		Chunks:                     chunks,
-	}
-
-	daBatch, err := codecv1.NewDABatch(batch)
-	if err != nil {
-		log.Crit("failed to create DA batch", "err", err)
-		return
-	}
-
-	blobDataProof, err := daBatch.BlobDataProof()
-	if err != nil {
-		log.Crit("failed to get blob data proof", "err", err)
-		return
-	}
-
-	log.Info("batchMeta", "batchHash", daBatch.Hash().Hex(), "batchDataHash", daBatch.DataHash.Hex(), "blobDataProof", hex.EncodeToString(blobDataProof), "blobData", hex.EncodeToString(daBatch.Blob()[:]))
-}

rollup/go.mod

@@ -3,7 +3,7 @@ module scroll-tech/rollup
 go 1.21
 
 require (
-	github.com/agiledragon/gomonkey/v2 v2.9.0
+	github.com/agiledragon/gomonkey/v2 v2.11.0
 	github.com/consensys/gnark-crypto v0.12.1
 	github.com/crate-crypto/go-kzg-4844 v0.7.0
 	github.com/gin-gonic/gin v1.9.1

rollup/go.sum

@@ -2,8 +2,8 @@ github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAE
 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/agiledragon/gomonkey/v2 v2.9.0 h1:PDiKKybR596O6FHW+RVSG0Z7uGCBNbmbUXh3uCNQ7Hc=
+github.com/agiledragon/gomonkey/v2 v2.11.0 h1:5oxSgA+tC1xuGsrIorR+sYiziYltmJyEZ9qA25b6l5U=
-github.com/agiledragon/gomonkey/v2 v2.9.0/go.mod h1:ap1AmDzcVOAz1YpeJ3TCzIgstoaWLA6jbbgxfB4w2iY=
+github.com/agiledragon/gomonkey/v2 v2.11.0/go.mod h1:ap1AmDzcVOAz1YpeJ3TCzIgstoaWLA6jbbgxfB4w2iY=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=

rollup/internal/config/relayer.go

@@ -70,8 +70,14 @@ type RelayerConfig struct {
 type GasOracleConfig struct {
 	// MinGasPrice store the minimum gas price to set.
 	MinGasPrice uint64 `json:"min_gas_price"`
-	// GasPriceDiff store the percentage of gas price difference.
+	// GasPriceDiff is the minimum percentage of gas price difference to update gas oracle.
 	GasPriceDiff uint64 `json:"gas_price_diff"`
+
+	// The following configs are only for updating L1 gas price, used for sender in L2.
+	// The weight for L1 base fee.
+	L1BaseFeeWeight float64 `json:"l1_base_fee_weight"`
+	// The weight for L1 blob base fee.
+	L1BlobBaseFeeWeight float64 `json:"l1_blob_base_fee_weight"`
 }
 
 // relayerConfigAlias RelayerConfig alias name

rollup/internal/controller/relayer/l1_relayer.go

@@ -3,12 +3,14 @@ package relayer
 import (
 	"context"
 	"fmt"
+	"math"
 	"math/big"
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
 	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
 	"scroll-tech/common/types"
@@ -28,21 +30,26 @@ import (
 type Layer1Relayer struct {
 	ctx context.Context
 
-	cfg *config.RelayerConfig
+	cfg      *config.RelayerConfig
+	chainCfg *params.ChainConfig
 
 	gasOracleSender *sender.Sender
 	l1GasOracleABI  *abi.ABI
 
-	lastGasPrice uint64
+	lastGasPrice        uint64
-	minGasPrice  uint64
+	minGasPrice         uint64
-	gasPriceDiff uint64
+	gasPriceDiff        uint64
+	l1BaseFeeWeight     float64
+	l1BlobBaseFeeWeight float64
 
 	l1BlockOrm *orm.L1Block
-	metrics    *l1RelayerMetrics
+	l2BlockOrm *orm.L2Block
+
+	metrics *l1RelayerMetrics
 }
 
 // NewLayer1Relayer will return a new instance of Layer1RelayerClient
-func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfig, serviceType ServiceType, reg prometheus.Registerer) (*Layer1Relayer, error) {
+func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfig, chainCfg *params.ChainConfig, serviceType ServiceType, reg prometheus.Registerer) (*Layer1Relayer, error) {
 	var gasOracleSender *sender.Sender
 	var err error
 
@@ -74,14 +81,18 @@ func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfi
 
 	l1Relayer := &Layer1Relayer{
 		cfg:        cfg,
+		chainCfg:   chainCfg,
 		ctx:        ctx,
 		l1BlockOrm: orm.NewL1Block(db),
+		l2BlockOrm: orm.NewL2Block(db),
 
 		gasOracleSender: gasOracleSender,
 		l1GasOracleABI:  bridgeAbi.L1GasPriceOracleABI,
 
-		minGasPrice:  minGasPrice,
+		minGasPrice:         minGasPrice,
-		gasPriceDiff: gasPriceDiff,
+		gasPriceDiff:        gasPriceDiff,
+		l1BaseFeeWeight:     cfg.GasOracleConfig.L1BaseFeeWeight,
+		l1BlobBaseFeeWeight: cfg.GasOracleConfig.L1BlobBaseFeeWeight,
 	}
 
 	l1Relayer.metrics = initL1RelayerMetrics(reg)
@@ -123,12 +134,27 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 		if r.lastGasPrice > 0 && expectedDelta == 0 {
 			expectedDelta = 1
 		}
-		// last is undefine or (block.BaseFee >= minGasPrice && exceed diff)
+
-		if r.lastGasPrice == 0 || (block.BaseFee >= r.minGasPrice && (block.BaseFee >= r.lastGasPrice+expectedDelta || block.BaseFee <= r.lastGasPrice-expectedDelta)) {
+		latestL2Height, err := r.l2BlockOrm.GetL2BlocksLatestHeight(r.ctx)
-			baseFee := big.NewInt(int64(block.BaseFee))
+		if err != nil {
-			data, err := r.l1GasOracleABI.Pack("setL1BaseFee", baseFee)
+			log.Warn("Failed to fetch latest L2 block height from db", "err", err)
+			return
+		}
+
+		var isBernoulli = r.chainCfg.IsBernoulli(new(big.Int).SetUint64(latestL2Height))
+
+		var baseFee uint64
+		if isBernoulli && block.BlobBaseFee != 0 {
+			baseFee = uint64(math.Ceil(r.l1BaseFeeWeight*float64(block.BaseFee) + r.l1BlobBaseFeeWeight*float64(block.BlobBaseFee)))
+		} else {
+			baseFee = block.BaseFee
+		}
+
+		// last is undefined or (baseFee >= minGasPrice && exceed diff)
+		if r.lastGasPrice == 0 || (baseFee >= r.minGasPrice && (baseFee >= r.lastGasPrice+expectedDelta || baseFee <= r.lastGasPrice-expectedDelta)) {
+			data, err := r.l1GasOracleABI.Pack("setL1BaseFee", new(big.Int).SetUint64(baseFee))
 			if err != nil {
-				log.Error("Failed to pack setL1BaseFee", "block.Hash", block.Hash, "block.Height", block.Number, "block.BaseFee", block.BaseFee, "err", err)
+				log.Error("Failed to pack setL1BaseFee", "block.Hash", block.Hash, "block.Height", block.Number, "block.BaseFee", baseFee, "isBernoulli", isBernoulli, "err", err)
 				return
 			}
 
@@ -143,9 +169,9 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 				log.Error("UpdateGasOracleStatusAndOracleTxHash failed", "block.Hash", block.Hash, "block.Height", block.Number, "err", err)
 				return
 			}
-			r.lastGasPrice = block.BaseFee
+			r.lastGasPrice = baseFee
 			r.metrics.rollupL1RelayerLastGasPrice.Set(float64(r.lastGasPrice))
-			log.Info("Update l1 base fee", "txHash", hash.String(), "baseFee", baseFee)
+			log.Info("Update l1 base fee", "txHash", hash.String(), "baseFee", baseFee, "isBernoulli", isBernoulli)
 		}
 	}
 }

rollup/internal/controller/relayer/l1_relayer_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/agiledragon/gomonkey/v2"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
+	"github.com/scroll-tech/go-ethereum/params"
 	"github.com/smartystreets/goconvey/convey"
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
@@ -35,7 +36,7 @@ func setupL1RelayerDB(t *testing.T) *gorm.DB {
 func testCreateNewL1Relayer(t *testing.T) {
 	db := setupL1RelayerDB(t)
 	defer database.CloseDB(db)
-	relayer, err := NewLayer1Relayer(context.Background(), db, cfg.L2Config.RelayerConfig, ServiceTypeL1GasOracle, nil)
+	relayer, err := NewLayer1Relayer(context.Background(), db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, ServiceTypeL1GasOracle, nil)
 	assert.NoError(t, err)
 	assert.NotNil(t, relayer)
 	defer relayer.StopSenders()
@@ -57,7 +58,7 @@ func testL1RelayerGasOracleConfirm(t *testing.T) {
 	l1Cfg := cfg.L1Config
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig, ServiceTypeL1GasOracle, nil)
+	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig, &params.ChainConfig{}, ServiceTypeL1GasOracle, nil)
 	assert.NoError(t, err)
 	defer l1Relayer.StopSenders()
 
@@ -90,7 +91,7 @@ func testL1RelayerProcessGasPriceOracle(t *testing.T) {
 	l1Cfg := cfg.L1Config
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig, ServiceTypeL1GasOracle, nil)
+	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig, &params.ChainConfig{}, ServiceTypeL1GasOracle, nil)
 	assert.NoError(t, err)
 	assert.NotNil(t, l1Relayer)
 	defer l1Relayer.StopSenders()

rollup/internal/controller/relayer/l2_relayer.go

@@ -578,7 +578,7 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 		return err
 	}
 
-	log.Info("finalizeBatch in layer1", "with proof", withProof, "index", dbBatch.Index, "batch hash", dbBatch.Hash, "tx hash", txHash)
+	log.Info("finalizeBatch in layer1", "with proof", withProof, "index", dbBatch.Index, "batch hash", dbBatch.Hash, "tx hash", txHash.String())
 
 	// record and sync with db, @todo handle db error
 	if err := r.batchOrm.UpdateFinalizeTxHashAndRollupStatus(r.ctx, dbBatch.Hash, txHash.String(), types.RollupFinalizing); err != nil {

rollup/internal/controller/watcher/l1_watcher.go

@@ -9,6 +9,7 @@ import (
 	geth "github.com/scroll-tech/go-ethereum"
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
 	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/consensus/misc"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/ethclient"
@@ -135,10 +136,16 @@ func (w *L1WatcherClient) FetchBlockHeader(blockHeight uint64) error {
 		baseFee = block.BaseFee.Uint64()
 	}
 
+	var blobBaseFee uint64
+	if excess := block.ExcessBlobGas; excess != nil {
+		blobBaseFee = misc.CalcBlobFee(*excess).Uint64()
+	}
+
 	l1Block := orm.L1Block{
 		Number:          blockHeight,
 		Hash:            block.Hash().String(),
 		BaseFee:         baseFee,
+		BlobBaseFee:     blobBaseFee,
 		GasOracleStatus: int16(types.GasOraclePending),
 	}
 

rollup/internal/orm/l1_block.go

@@ -15,9 +15,10 @@ type L1Block struct {
 	db *gorm.DB `gorm:"column:-"`
 
 	// block
-	Number  uint64 `json:"number" gorm:"column:number"`
+	Number      uint64 `json:"number" gorm:"column:number"`
-	Hash    string `json:"hash" gorm:"column:hash"`
+	Hash        string `json:"hash" gorm:"column:hash"`
-	BaseFee uint64 `json:"base_fee" gorm:"column:base_fee"`
+	BaseFee     uint64 `json:"base_fee" gorm:"column:base_fee"`
+	BlobBaseFee uint64 `json:"blob_base_fee" gorm:"column:blob_base_fee"`
 
 	// oracle
 	GasOracleStatus int16  `json:"oracle_status" gorm:"column:oracle_status;default:1"`

rollup/tests/gas_oracle_test.go

@@ -28,7 +28,7 @@ func testImportL1GasPrice(t *testing.T) {
 	l1Cfg := rollupApp.Config.L1Config
 
 	// Create L1Relayer
-	l1Relayer, err := relayer.NewLayer1Relayer(context.Background(), db, l1Cfg.RelayerConfig, relayer.ServiceTypeL1GasOracle, nil)
+	l1Relayer, err := relayer.NewLayer1Relayer(context.Background(), db, l1Cfg.RelayerConfig, &params.ChainConfig{}, relayer.ServiceTypeL1GasOracle, nil)
 	assert.NoError(t, err)
 	defer l1Relayer.StopSenders()
 

rollup/tests/process_start_test.go

@@ -21,7 +21,7 @@ func testProcessStart(t *testing.T) {
 	defer database.CloseDB(db)
 
 	rollupApp.RunApp(t, cutils.EventWatcherApp)
-	rollupApp.RunApp(t, cutils.GasOracleApp)
+	rollupApp.RunApp(t, cutils.GasOracleApp, "--genesis", "../conf/genesis.json")
 	rollupApp.RunApp(t, cutils.RollupRelayerApp, "--genesis", "../conf/genesis.json")
 
 	rollupApp.WaitExit()
@@ -39,7 +39,7 @@ func testProcessStartEnableMetrics(t *testing.T) {
 	port, err = rand.Int(rand.Reader, big.NewInt(10000))
 	assert.NoError(t, err)
 	svrPort = strconv.FormatInt(port.Int64()+20000, 10)
-	rollupApp.RunApp(t, cutils.GasOracleApp, "--metrics", "--metrics.addr", "localhost", "--metrics.port", svrPort)
+	rollupApp.RunApp(t, cutils.GasOracleApp, "--metrics", "--metrics.addr", "localhost", "--metrics.port", svrPort, "--genesis", "../conf/genesis.json")
 
 	port, err = rand.Int(rand.Reader, big.NewInt(10000))
 	assert.NoError(t, err)