add a new script

.github/workflows/common.yml

@@ -29,7 +29,7 @@ jobs:
     steps:
     - uses: actions-rs/toolchain@v1
       with:
-        toolchain: nightly-2023-12-03
+        toolchain: nightly-2022-12-10
         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-2023-12-03
+        toolchain: nightly-2022-12-10
         override: true
         components: rustfmt, clippy
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.21.x
+        go-version: 1.20.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.21.x
+        go-version: 1.20.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.21.x
+        go-version: 1.20.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc

.github/workflows/docker.yml

@@ -46,7 +46,6 @@ 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 }}
@@ -91,7 +90,6 @@ 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 }}
@@ -136,52 +134,6 @@ 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 }}
@@ -226,7 +178,6 @@ 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 }}
@@ -271,7 +222,6 @@ 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 }}
@@ -316,7 +266,6 @@ jobs:
         with:
           context: .
           file: ./build/dockerfiles/coordinator-api.Dockerfile
-          platforms: linux/amd64
           push: true
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
@@ -361,7 +310,6 @@ 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.21'
+        default: '1.20'
       RUST_VERSION:
         description: 'Rust toolchain version'
         required: true
         type: string
-        default: 'nightly-2023-12-03'
+        default: 'nightly-2022-12-10'
       PYTHON_VERSION:
         description: 'Python version'
         required: false

.github/workflows/prover.yml

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

bridge-history-api/README.md

@@ -79,50 +79,3 @@ 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,7 +15,6 @@
 		"USDCGatewayAddr": "0xf1AF3b23DE0A5Ca3CAb7261cb0061C0D779A5c7B",
 		"LIDOGatewayAddr": "0x6625C6332c9F91F2D27c304E729B86db87A3f504",
 		"DAIGatewayAddr": "0x67260A8B73C5B77B55c1805218A42A7A6F98F515",
-		"PufferGatewayAddr": "0xA033Ff09f2da45f0e9ae495f525363722Df42b2a",
 		"ScrollChainAddr": "0xa13BAF47339d63B743e7Da8741db5456DAc1E556",
 		"GatewayRouterAddr": "0xF8B1378579659D8F7EE5f3C929c2f3E332E41Fd6",
 		"MessageQueueAddr": "0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B"
@@ -35,9 +34,7 @@
 		"USDCGatewayAddr": "0x33B60d5Dd260d453cAC3782b0bDC01ce84672142",
 		"LIDOGatewayAddr": "0x8aE8f22226B9d789A36AC81474e633f8bE2856c9",
 		"DAIGatewayAddr": "0xaC78dff3A87b5b534e366A93E785a0ce8fA6Cc62",
-		"PufferGatewayAddr": "0x9eBf2f33526CD571f8b2ad312492cb650870CFd6",
-		"GatewayRouterAddr": "0x4C0926FF5252A435FD19e10ED15e5a249Ba19d79",
-		"MessageQueueAddr": "0x5300000000000000000000000000000000000000"
+		"GatewayRouterAddr": "0x4C0926FF5252A435FD19e10ED15e5a249Ba19d79"
 	},
 	"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.21-alpine3.19 as base
+FROM golang:1.20-alpine3.16 as base
 
 WORKDIR /src
 COPY go.mod* ./

build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile

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

build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile

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

build/dockerfiles/coordinator-api.Dockerfile

@@ -1,5 +1,5 @@
 # Build libzkp dependency
-FROM scrolltech/go-rust-builder:go-1.21-rust-nightly-2023-12-03 as chef
+FROM scrolltech/go-rust-builder:go-1.20-rust-nightly-2022-12-10 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.21-rust-nightly-2023-12-03 as base
+FROM scrolltech/go-rust-builder:go-1.20-rust-nightly-2022-12-10 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.21 as base
+FROM scrolltech/go-alpine-builder:1.20 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.21 as base
+FROM scrolltech/go-alpine-builder:1.20 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.21 as base
+FROM scrolltech/go-alpine-builder:1.20 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.21 as base
+FROM scrolltech/go-alpine-builder:1.20 as base
 
 WORKDIR /src
 COPY go.work* ./

build/dockerfiles/intermediate/Makefile

@@ -1,8 +1,8 @@
 ifeq ($(GO_VERSION),)
-  GO_VERSION=1.21
+  GO_VERSION=1.20
 endif
 ifeq ($(RUST_VERSION),)
-  RUST_VERSION=nightly-2023-12-03
+  RUST_VERSION=nightly-2022-12-10
 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.21
-ARG RUST_VERSION=nightly-2023-12-03
+ARG GO_VERSION=1.20
+ARG RUST_VERSION=nightly-2022-12-10
 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.21
+ARG GO_VERSION=1.20
 
 FROM golang:${GO_VERSION}-alpine
 

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

@@ -1,5 +1,5 @@
-ARG GO_VERSION=1.21
-ARG RUST_VERSION=nightly-2023-12-03
+ARG GO_VERSION=1.20
+ARG RUST_VERSION=nightly-2022-12-10
 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.21
-ARG RUST_VERSION=nightly-2023-12-03
+ARG GO_VERSION=1.20
+ARG RUST_VERSION=nightly-2022-12-10
 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-2023-12-03
+ARG RUST_VERSION=nightly-2022-12-10
 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-2023-12-03
+ARG RUST_VERSION=nightly-2022-12-10
 ARG CARGO_CHEF_TAG=0.1.41
 
 FROM ubuntu:20.04

build/dockerfiles/rollup_relayer.Dockerfile

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

common/testcontainers/testcontainers.go

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

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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,131 @@
+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.4.0"
+var tag = "v4.3.92"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

contracts/scripts/foundry/DeployEcc.s.sol

@@ -0,0 +1,23 @@
+// 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

@@ -0,0 +1,23 @@
+// 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,10 +92,12 @@ contract DeployL1BridgeContracts is Script {
     }
 
     function deployMultipleVersionRollupVerifier() internal {
-        uint256[] memory _versions = new uint256[](1);
-        address[] memory _verifiers = new address[](1);
+        uint256[] memory _versions = new uint256[](2);
+        address[] memory _verifiers = new address[](2);
         _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

@@ -0,0 +1,34 @@
+/* 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

@@ -0,0 +1,127 @@
+// 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

@@ -0,0 +1,34 @@
+// 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 [`conf/config.json`](conf/config.json). Check the code comments under `ProverManager` in [`internal/config/config.go`](internal/config/config.go) for more details.
+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.
 
 
 ## Start

coordinator/go.mod

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

coordinator/go.sum

@@ -59,7 +59,6 @@ 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=
@@ -96,7 +95,6 @@ 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=
@@ -119,13 +117,11 @@ 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=
@@ -148,7 +144,6 @@ 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=
@@ -158,7 +153,6 @@ 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=
@@ -170,7 +164,6 @@ 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=
@@ -204,7 +197,6 @@ 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.stopCleanChallengeChan:
-			log.Info("the coordinator cleanupChallenge run loop exit")
+		case <-c.stopTimeoutChan:
+			log.Info("the coordinator run loop exit")
 			return
 		}
 	}

coordinator/internal/controller/cron/collect_proof.go

@@ -23,10 +23,7 @@ type Collector struct {
 	db  *gorm.DB
 	ctx context.Context
 
-	stopChunkTimeoutChan       chan struct{}
-	stopBatchTimeoutChan       chan struct{}
-	stopBatchAllChunkReadyChan chan struct{}
-	stopCleanChallengeChan     chan struct{}
+	stopTimeoutChan chan struct{}
 
 	proverTaskOrm *orm.ProverTask
 	chunkOrm      *orm.Chunk
@@ -43,17 +40,14 @@ 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,
-		db:                         db,
-		ctx:                        ctx,
-		stopChunkTimeoutChan:       make(chan struct{}),
-		stopBatchTimeoutChan:       make(chan struct{}),
-		stopBatchAllChunkReadyChan: make(chan struct{}),
-		stopCleanChallengeChan:     make(chan struct{}),
-		proverTaskOrm:              orm.NewProverTask(db),
-		chunkOrm:                   orm.NewChunk(db),
-		batchOrm:                   orm.NewBatch(db),
-		challenge:                  orm.NewChallenge(db),
+		cfg:             cfg,
+		db:              db,
+		ctx:             ctx,
+		stopTimeoutChan: make(chan struct{}),
+		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",
@@ -89,10 +83,7 @@ func NewCollector(ctx context.Context, db *gorm.DB, cfg *config.Config, reg prom
 
 // Stop all the collector
 func (c *Collector) Stop() {
-	c.stopChunkTimeoutChan <- struct{}{}
-	c.stopBatchTimeoutChan <- struct{}{}
-	c.stopBatchAllChunkReadyChan <- struct{}{}
-	c.stopCleanChallengeChan <- struct{}{}
+	c.stopTimeoutChan <- struct{}{}
 }
 
 // timeoutTask cron check the send task is timeout. if timeout reached, restore the
@@ -122,8 +113,8 @@ func (c *Collector) timeoutBatchProofTask() {
 				log.Error("manager context canceled with error", "error", c.ctx.Err())
 			}
 			return
-		case <-c.stopBatchTimeoutChan:
-			log.Info("the coordinator timeoutBatchProofTask run loop exit")
+		case <-c.stopTimeoutChan:
+			log.Info("the coordinator run loop exit")
 			return
 		}
 	}
@@ -155,8 +146,8 @@ func (c *Collector) timeoutChunkProofTask() {
 				log.Error("manager context canceled with error", "error", c.ctx.Err())
 			}
 			return
-		case <-c.stopChunkTimeoutChan:
-			log.Info("the coordinator timeoutChunkProofTask run loop exit")
+		case <-c.stopTimeoutChan:
+			log.Info("the coordinator run loop exit")
 			return
 		}
 	}
@@ -262,8 +253,8 @@ func (c *Collector) checkBatchAllChunkReady() {
 				log.Error("manager context canceled with error", "error", c.ctx.Err())
 			}
 			return
-		case <-c.stopBatchAllChunkReadyChan:
-			log.Info("the coordinator checkBatchAllChunkReady run loop exit")
+		case <-c.stopTimeoutChan:
+			log.Info("the coordinator 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.Copy(), challenge)
+	return l.challengeOrm.InsertChallenge(ctx, 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.Copy(), fromBlockNum)
+		startChunk, chunkErr := bp.chunkOrm.GetChunkByStartBlockNumber(ctx, 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.Copy(), toBlockNum)
+		toChunk, chunkErr := bp.chunkOrm.GetChunkByStartBlockNumber(ctx, 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.Copy(), startChunkIndex, endChunkIndex, maxActiveAttempts, maxTotalAttempts)
+		tmpBatchTask, getTaskError = bp.batchOrm.GetAssignedBatch(ctx, 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.Copy(), startChunkIndex, endChunkIndex, maxActiveAttempts, maxTotalAttempts)
+			tmpBatchTask, getTaskError = bp.batchOrm.GetUnassignedBatch(ctx, 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.Copy(), tmpBatchTask.Index, tmpBatchTask.ActiveAttempts, tmpBatchTask.TotalAttempts)
+		rowsAffected, updateAttemptsErr := bp.batchOrm.UpdateBatchAttempts(ctx, 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.Copy(), &proverTask); err != nil {
+	if err = bp.proverTaskOrm.InsertProverTask(ctx, &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.Copy(), &proverTask)
+	taskMsg, err := bp.formatProverTask(ctx, &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.Copy(), batchTask.Hash); err != nil {
+	if err := bp.chunkOrm.DecreaseActiveAttemptsByHash(ctx, 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.Copy(), fromBlockNum, toBlockNum, maxActiveAttempts, maxTotalAttempts)
+		tmpChunkTask, getTaskError = cp.chunkOrm.GetAssignedChunk(ctx, 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.Copy(), fromBlockNum, toBlockNum, maxActiveAttempts, maxTotalAttempts)
+			tmpChunkTask, getTaskError = cp.chunkOrm.GetUnassignedChunk(ctx, 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.Copy(), tmpChunkTask.Index, tmpChunkTask.ActiveAttempts, tmpChunkTask.TotalAttempts)
+		rowsAffected, updateAttemptsErr := cp.chunkOrm.UpdateChunkAttempts(ctx, 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.Copy(), &proverTask); err != nil {
+	if err = cp.proverTaskOrm.InsertProverTask(ctx, &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.Copy(), &proverTask)
+	taskMsg, err := cp.formatProverTask(ctx, &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.Copy(), publicKey.(string))
+	isBlocked, err := b.proverBlockListOrm.IsPublicKeyBlocked(ctx, 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.Copy(), publicKey.(string))
+	isAssigned, err := b.proverTaskOrm.IsProverAssigned(ctx, 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.Copy(), proofParameter.UUID, pk)
+		proverTask, err = m.proverTaskOrm.GetProverTaskByUUIDAndPublicKey(ctx, proofParameter.UUID, pk)
 		if proverTask == nil || err != nil {
 			log.Error("get none prover task for the proof", "uuid", proofParameter.UUID, "key", pk, "taskID", proofMsg.ID, "error", err)
 			return ErrValidatorFailureProverTaskEmpty
 		}
 	} else {
 		// TODO When prover all have upgrade, need delete this logic
-		proverTask, err = m.proverTaskOrm.GetAssignedProverTaskByTaskIDAndProver(ctx.Copy(), proofMsg.Type, proofMsg.ID, pk, pv)
+		proverTask, err = m.proverTaskOrm.GetAssignedProverTaskByTaskIDAndProver(ctx, 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.Copy(), proverTask, pk, proofMsg, proofParameter, hardForkName); err != nil {
+	if err = m.validator(ctx, 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.Copy(), proverTask, types.ProverTaskFailureTypeVerifiedFailed, proofMsg)
+		m.proofRecover(ctx, 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.Copy(), proverTask, proofMsg, proofTimeSec); err != nil {
+	if err := m.closeProofTask(ctx, proverTask, proofMsg, proofTimeSec); err != nil {
 		m.proofSubmitFailure.Inc()
 
-		m.proofRecover(ctx.Copy(), proverTask, types.ProverTaskFailureTypeServerError, proofMsg)
+		m.proofRecover(ctx, 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(19), cur)
+	assert.Equal(t, int64(17), cur)
 }
 
 func testMigrate(t *testing.T) {
 	assert.NoError(t, Migrate(pgDB))
 	cur, err := Current(pgDB)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(19), cur)
+	assert.Equal(t, int64(17), cur)
 }
 
 func testRollback(t *testing.T) {
 	version, err := Current(pgDB)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(19), version)
+	assert.Equal(t, int64(17), version)
 
 	assert.NoError(t, Rollback(pgDB, nil))
 

database/migrate/migrations/00018_add_index_taskid_createdat_prover_task.sql

@@ -1,18 +0,0 @@
--- +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

@@ -1,15 +0,0 @@
--- +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

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: mock_abi ## Lint the files - used for CI
+lint: ## 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,15 +78,9 @@ 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, genesis.Config, relayer.ServiceTypeL1GasOracle, registry)
+	l1relayer, err := relayer.NewLayer1Relayer(ctx.Context, db, cfg.L1Config.RelayerConfig, relayer.ServiceTypeL1GasOracle, registry)
 	if err != nil {
 		log.Crit("failed to create new l1 relayer", "config file", cfgFile, "error", err)
 	}

rollup/dump-batch-info/main.go

@@ -0,0 +1,103 @@
+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.11.0
+	github.com/agiledragon/gomonkey/v2 v2.9.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.11.0 h1:5oxSgA+tC1xuGsrIorR+sYiziYltmJyEZ9qA25b6l5U=
-github.com/agiledragon/gomonkey/v2 v2.11.0/go.mod h1:ap1AmDzcVOAz1YpeJ3TCzIgstoaWLA6jbbgxfB4w2iY=
+github.com/agiledragon/gomonkey/v2 v2.9.0 h1:PDiKKybR596O6FHW+RVSG0Z7uGCBNbmbUXh3uCNQ7Hc=
+github.com/agiledragon/gomonkey/v2 v2.9.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/controller/relayer/l1_relayer.go

@@ -9,7 +9,6 @@ import (
 	"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"
@@ -29,8 +28,7 @@ import (
 type Layer1Relayer struct {
 	ctx context.Context
 
-	cfg      *config.RelayerConfig
-	chainCfg *params.ChainConfig
+	cfg *config.RelayerConfig
 
 	gasOracleSender *sender.Sender
 	l1GasOracleABI  *abi.ABI
@@ -40,13 +38,11 @@ type Layer1Relayer struct {
 	gasPriceDiff uint64
 
 	l1BlockOrm *orm.L1Block
-	l2BlockOrm *orm.L2Block
-
-	metrics *l1RelayerMetrics
+	metrics    *l1RelayerMetrics
 }
 
 // NewLayer1Relayer will return a new instance of Layer1RelayerClient
-func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfig, chainCfg *params.ChainConfig, serviceType ServiceType, reg prometheus.Registerer) (*Layer1Relayer, error) {
+func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfig, serviceType ServiceType, reg prometheus.Registerer) (*Layer1Relayer, error) {
 	var gasOracleSender *sender.Sender
 	var err error
 
@@ -78,10 +74,8 @@ 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,
@@ -129,27 +123,12 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 		if r.lastGasPrice > 0 && expectedDelta == 0 {
 			expectedDelta = 1
 		}
-
-		latestL2Height, err := r.l2BlockOrm.GetL2BlocksLatestHeight(r.ctx)
-		if err != nil {
-			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 = 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))
+		// 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)) {
+			baseFee := big.NewInt(int64(block.BaseFee))
+			data, err := r.l1GasOracleABI.Pack("setL1BaseFee", baseFee)
 			if err != nil {
-				log.Error("Failed to pack setL1BaseFee", "block.Hash", block.Hash, "block.Height", block.Number, "block.BaseFee", baseFee, "isBernoulli", isBernoulli, "err", err)
+				log.Error("Failed to pack setL1BaseFee", "block.Hash", block.Hash, "block.Height", block.Number, "block.BaseFee", block.BaseFee, "err", err)
 				return
 			}
 
@@ -164,9 +143,9 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 				log.Error("UpdateGasOracleStatusAndOracleTxHash failed", "block.Hash", block.Hash, "block.Height", block.Number, "err", err)
 				return
 			}
-			r.lastGasPrice = baseFee
+			r.lastGasPrice = block.BaseFee
 			r.metrics.rollupL1RelayerLastGasPrice.Set(float64(r.lastGasPrice))
-			log.Info("Update l1 base fee", "txHash", hash.String(), "baseFee", baseFee, "isBernoulli", isBernoulli)
+			log.Info("Update l1 base fee", "txHash", hash.String(), "baseFee", baseFee)
 		}
 	}
 }

rollup/internal/controller/relayer/l1_relayer_test.go

@@ -8,7 +8,6 @@ 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"
@@ -36,7 +35,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, &params.ChainConfig{}, ServiceTypeL1GasOracle, nil)
+	relayer, err := NewLayer1Relayer(context.Background(), db, cfg.L2Config.RelayerConfig, ServiceTypeL1GasOracle, nil)
 	assert.NoError(t, err)
 	assert.NotNil(t, relayer)
 	defer relayer.StopSenders()
@@ -58,7 +57,7 @@ func testL1RelayerGasOracleConfirm(t *testing.T) {
 	l1Cfg := cfg.L1Config
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig, &params.ChainConfig{}, ServiceTypeL1GasOracle, nil)
+	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig, ServiceTypeL1GasOracle, nil)
 	assert.NoError(t, err)
 	defer l1Relayer.StopSenders()
 
@@ -91,7 +90,7 @@ func testL1RelayerProcessGasPriceOracle(t *testing.T) {
 	l1Cfg := cfg.L1Config
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig, &params.ChainConfig{}, ServiceTypeL1GasOracle, nil)
+	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig, 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.String())
+	log.Info("finalizeBatch in layer1", "with proof", withProof, "index", dbBatch.Index, "batch hash", dbBatch.Hash, "tx hash", txHash)
 
 	// 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,7 +9,6 @@ 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"
@@ -136,16 +135,10 @@ 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,10 +15,9 @@ type L1Block struct {
 	db *gorm.DB `gorm:"column:-"`
 
 	// block
-	Number      uint64 `json:"number" gorm:"column:number"`
-	Hash        string `json:"hash" gorm:"column:hash"`
-	BaseFee     uint64 `json:"base_fee" gorm:"column:base_fee"`
-	BlobBaseFee uint64 `json:"blob_base_fee" gorm:"column:blob_base_fee"`
+	Number  uint64 `json:"number" gorm:"column:number"`
+	Hash    string `json:"hash" gorm:"column:hash"`
+	BaseFee uint64 `json:"base_fee" gorm:"column: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, &params.ChainConfig{}, relayer.ServiceTypeL1GasOracle, nil)
+	l1Relayer, err := relayer.NewLayer1Relayer(context.Background(), db, l1Cfg.RelayerConfig, 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, "--genesis", "../conf/genesis.json")
+	rollupApp.RunApp(t, cutils.GasOracleApp)
 	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, "--genesis", "../conf/genesis.json")
+	rollupApp.RunApp(t, cutils.GasOracleApp, "--metrics", "--metrics.addr", "localhost", "--metrics.port", svrPort)
 
 	port, err = rand.Int(rand.Reader, big.NewInt(10000))
 	assert.NoError(t, err)