fix(bridge-history-api): fix wrong table name (#584)

Co-authored-by: vincent <419436363@qq.com>

.github/workflows/bridge.yml

@@ -103,7 +103,13 @@ jobs:
     - name: Test bridge packages
       working-directory: 'bridge'
       run: |
-        go test -v -race -gcflags="-l" -ldflags="-s=false" -covermode=atomic ./...
+        go test -v -race -gcflags="-l" -ldflags="-s=false" -coverprofile=coverage.txt -covermode=atomic ./...
+    - name: Upload coverage reports to Codecov
+      uses: codecov/codecov-action@v3
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      with:
+        flags: bridge
   # docker-build:
   #   if: github.event.pull_request.draft == false
   #   runs-on: ubuntu-latest

.github/workflows/bridge_history_api.yml

@@ -53,6 +53,12 @@ jobs:
       run: |
         go get ./...
         make test
+    - name: Upload coverage reports to Codecov
+      uses: codecov/codecov-action@v3
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      with:
+        flags: bridge-history-api
   goimports-lint:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest

.github/workflows/common.yml

@@ -94,4 +94,10 @@ jobs:
     - name: Test common packages
       working-directory: 'common'
       run: |
-        go test -v -race -gcflags="-l" -ldflags="-s=false" -covermode=atomic ./...
+        go test -v -race -gcflags="-l" -ldflags="-s=false" -coverprofile=coverage.txt -covermode=atomic ./...
+    - name: Upload coverage reports to Codecov
+      uses: codecov/codecov-action@v3
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      with:
+        flags: common

.github/workflows/coordinator.yml

@@ -110,4 +110,11 @@ jobs:
     - name: Test coordinator packages
       working-directory: 'coordinator'
       run: |
-        go test -v -race -gcflags="-l" -ldflags="-s=false" -covermode=atomic -tags mock_verifier ./...
+        # go test -exec "env LD_LIBRARY_PATH=${PWD}/verifier/lib" -v -race -gcflags="-l" -ldflags="-s=false" -coverpkg="scroll-tech/coordinator" -coverprofile=coverage.txt -covermode=atomic ./...
+        go test -v -race -gcflags="-l" -ldflags="-s=false" -coverprofile=coverage.txt -covermode=atomic -tags mock_verifier ./...
+    - name: Upload coverage reports to Codecov
+      uses: codecov/codecov-action@v3
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      with:
+        flags: coordinator

.github/workflows/database.yml

@@ -87,4 +87,10 @@ jobs:
     - name: Test database packages
       working-directory: 'database'
       run: |
-        go test -v -race -gcflags="-l" -ldflags="-s=false" -covermode=atomic ./...
+        go test -v -race -gcflags="-l" -ldflags="-s=false" -coverprofile=coverage.txt -covermode=atomic ./...
+    - name: Upload coverage reports to Codecov
+      uses: codecov/codecov-action@v3
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      with:
+        flags: database

.github/workflows/integration.yaml

@@ -40,4 +40,4 @@ jobs:
         make -C common/bytecode all
     - name: Run integration tests
       run: |
-        go test -v -tags="mock_prover mock_verifier" -p 1 scroll-tech/integration-test/...
+        go test -v -tags="mock_prover mock_verifier" -p 1 -coverprofile=coverage.txt scroll-tech/integration-test/...

.github/workflows/roller.yml

@@ -47,7 +47,13 @@ jobs:
     - name: Test
       run: |
         make roller
-        go test -tags="mock_prover" -v ./...
+        go test -tags="mock_prover" -v -coverprofile=coverage.txt ./...
+    - name: Upload coverage reports to Codecov
+      uses: codecov/codecov-action@v3
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      with:
+        flags: roller
   check:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest

Jenkinsfile

@@ -1,100 +0,0 @@
-imagePrefix = 'scrolltech'
-credentialDocker = 'dockerhub'
-
-pipeline {
-    agent any
-    options {
-        timeout (20)
-    }
-    tools {
-        nodejs "nodejs"
-        go 'go-1.19'
-    }
-    environment {
-        GOBIN = '/home/ubuntu/go/bin/'
-        GO111MODULE = 'on'
-        PATH="/home/ubuntu/.cargo/bin:$PATH"
-        LD_LIBRARY_PATH="$LD_LIBRARY_PATH:./coordinator/verifier/lib"
-        CHAIN_ID='534353'
-        // LOG_DOCKER = 'true'
-    }
-    stages {
-        stage('Build') {
-            parallel {
-                stage('Build Prerequisite') {
-                    steps {
-                        sh 'make dev_docker'
-                        sh 'make -C bridge mock_abi'
-                        sh 'make -C common/bytecode all'
-                    }
-                }
-                stage('Check Bridge Compilation') {
-                    steps {
-                        sh 'make -C bridge bridge_bins'
-                    }
-                }
-                stage('Check Coordinator Compilation') {
-                    steps {
-                        sh 'export PATH=/home/ubuntu/go/bin:$PATH'
-                        sh 'make -C coordinator coordinator'
-                    }
-                }
-                stage('Check Database Compilation') {
-                    steps {
-                        sh 'make -C database db_cli'
-                    }
-                }
-                stage('Check Database Docker Build') {
-                    steps {
-                        sh 'make -C database docker'
-                    }
-                }
-            }
-        }
-        stage('Parallel Test') {
-            parallel{
-                stage('Race test common package') {
-                    steps {
-                        sh 'go test -v -race -coverprofile=coverage.common.txt -covermode=atomic scroll-tech/common/...'
-                    }
-                }
-                stage('Race test bridge package') {
-                    steps {
-                        sh "cd ./bridge && ../build/run_tests.sh bridge"
-                    }
-                }
-                stage('Race test coordinator package') {
-                    steps {
-                        sh 'cd ./coordinator && go test -exec "env LD_LIBRARY_PATH=${PWD}/verifier/lib" -v -race -gcflags="-l" -ldflags="-s=false" -coverpkg="scroll-tech/coordinator" -coverprofile=../coverage.coordinator.txt -covermode=atomic ./...'
-                    }
-                }
-                stage('Race test database package') {
-                    steps {
-                        sh 'go test -v -race -coverprofile=coverage.db.txt -covermode=atomic scroll-tech/database/...'
-                    }
-                }
-                stage('Integration test') {
-                    steps {
-                        sh 'go test -v -tags="mock_prover mock_verifier" -p 1 scroll-tech/integration-test/...'
-                    }
-                }
-            }
-        }
-        stage('Compare Coverage') {
-            steps {
-                sh './build/post-test-report-coverage.sh'
-                script {
-                    currentBuild.result = 'SUCCESS'
-                }
-                step([$class: 'CompareCoverageAction', publishResultAs: 'Comment', scmVars: [GIT_URL: env.GIT_URL]])
-            }
-        }
-    }
-    post {
-        always {
-            publishCoverage adapters: [coberturaReportAdapter(path: 'cobertura.xml', thresholds: [[thresholdTarget: 'Aggregated Report', unhealthyThreshold: 40.0]])], checksName: '', sourceFileResolver: sourceFiles('NEVER_STORE') 
-            cleanWs() 
-            slackSend(message: "${JOB_BASE_NAME} ${GIT_COMMIT} #${BUILD_NUMBER} deploy ${currentBuild.result}")
-        }
-    }
-}

README.md

@@ -1,5 +1,7 @@
 # Scroll Monorepo
 
+[![codecov](https://codecov.io/gh/scroll-tech/scroll/branch/develop/graph/badge.svg?token=VJVHNQWGGW)](https://codecov.io/gh/scroll-tech/scroll)
+
 ## Prerequisites
 + Go 1.19
 + Rust (for version, see [rust-toolchain](./common/libzkp/impl/rust-toolchain))

bridge-history-api/abi/backend_abi.go

@@ -325,3 +325,26 @@ type L2FailedRelayedMessageEvent struct {
 type L2RelayedMessageEvent struct {
 	MessageHash common.Hash
 }
+
+// IScrollChainBatch is an auto generated low-level Go binding around an user-defined struct.
+type IScrollChainBatch struct {
+	Blocks           []IScrollChainBlockContext
+	PrevStateRoot    common.Hash
+	NewStateRoot     common.Hash
+	WithdrawTrieRoot common.Hash
+	BatchIndex       uint64
+	ParentBatchHash  common.Hash
+	L2Transactions   []byte
+}
+
+// IScrollChainBlockContext is an auto generated low-level Go binding around an user-defined struct.
+type IScrollChainBlockContext struct {
+	BlockHash       common.Hash
+	ParentHash      common.Hash
+	BlockNumber     uint64
+	Timestamp       uint64
+	BaseFee         *big.Int
+	GasLimit        uint64
+	NumTransactions uint16
+	NumL1Messages   uint16
+}

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

@@ -5,6 +5,7 @@ import (
 	"os"
 
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/iris-contrib/middleware/cors"
 	"github.com/kataras/iris/v12"
 	"github.com/kataras/iris/v12/mvc"
 	"github.com/urfave/cli/v2"
@@ -60,6 +61,11 @@ func init() {
 }
 
 func action(ctx *cli.Context) error {
+	corsOptions := cors.New(cors.Options{
+		AllowedOrigins:   []string{"*"},
+		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE"},
+		AllowCredentials: true,
+	})
 	// Load config file.
 	cfgFile := ctx.String(cutils.ConfigFileFlag.Name)
 	cfg, err := config.NewConfig(cfgFile)
@@ -72,6 +78,7 @@ func action(ctx *cli.Context) error {
 	}
 	defer database.Close()
 	bridgeApp := iris.New()
+	bridgeApp.UseRouter(corsOptions)
 	bridgeApp.Get("/ping", pong).Describe("healthcheck")
 
 	mvc.Configure(bridgeApp.Party("/api/txs"), setupQueryByAddressHandler)

bridge-history-api/config.json

@@ -2,28 +2,28 @@
 	"l1": {
 		"confirmation": 64,
 		"endpoint": "https://rpc.ankr.com/eth_goerli",
-		"startHeight": 9890194 ,
+		"startHeight": 9090194 ,
 		"blockTime": 10,
-		"MessengerAddr": "0x5260e38080BFe97e6C4925d9209eCc5f964373b6",
-		"ETHGatewayAddr": "0x429b73A21cF3BF1f3E696a21A95408161daF311f",
-		"WETHGatewayAddr": "0x8be69E499D8848DfFb4cF9bac909f3e2cF2FeFa0",
-		"StandardERC20Gateway": "0xeF37207c1A1efF6D6a9d7BfF3cF4270e406d319b",
-		"CustomERC20GatewayAddr": "0x920f906B814597cF5DC76F95100F09CBAF9c5748",
-		"ERC721GatewayAddr": "0x1C441Dfc5C2eD7A2AA8636748A664E59CB029157",
-		"ERC1155GatewayAddr": "0xd1bE599aaCBC21448fD6373bbc7c1b4c7806f135"
+		"MessengerAddr": "0x326517Eb8eB1Ce5eaB5b513C2e9A24839b402d90",
+		"ETHGatewayAddr": "0x8305cB7B8448677736095965B63d7431017328fe",
+		"WETHGatewayAddr": "0xe3bA3c60d99a2d9a5f817734bC85353470b23931",
+		"StandardERC20Gateway": "0x16c1079B27eD9c363B7D08aC5Ae937A398972A5C",
+		"CustomERC20GatewayAddr": "0x61f08caD3d6F77801167d3bA8669433701586643",
+		"ERC721GatewayAddr": "0x4A73D25A4C99CB912acaf6C5B5e554f2982201c5",
+		"ERC1155GatewayAddr": "0xa3F5DD3033698c2832C53f3C3Fe6E062F58cD808"
 	},
 	"l2": {
 		"confirmation": 1,
-		"endpoint": "https://alpha-rpc.scroll.io/l2",
+		"endpoint": "http://staging-l2geth-rpc0.scroll.tech:8545",
 		"blockTime": 3,
-		"startHeight": 1900068,
-		"CustomERC20GatewayAddr": "0xa07Cb742657294C339fB4d5d6CdF3fdBeE8C1c68",
-		"ERC721GatewayAddr": "0x8Fee20e0C0Ef16f2898a8073531a857D11b9C700",
-		"StandardERC20Gateway": "0xB878F37BB278bf0e4974856fFe86f5e6F66BD725",
-		"MessengerAddr": "0xb75d7e84517e1504C151B270255B087Fd746D34C",
-		"ETHGatewayAddr": "0x32139B5C8838E94fFcD83E60dff95Daa7F0bA14c",
-		"WETHGatewayAddr": "0xBb88bF582F2BBa46702621dae5CB9271057bC85b",
-		"ERC1155GatewayAddr": "0x2946cB860028276b3C4bccE1767841641C2E0828"
+		"startHeight": 0,
+		"CustomERC20GatewayAddr": "0x905db21f836749fEeD12de781afc4A5Ab4Dd0d51",
+		"ERC721GatewayAddr": "0xC53D835514780664BCd7eCfcE7c2E5d9554dc41B",
+		"StandardERC20Gateway": "0x90271634BCB020e06ea4840C3f7aa61b8F860651",
+		"MessengerAddr": "0xE8b0956Ac75c65Aa1669e83888DA13afF2E108f4",
+		"ETHGatewayAddr": "0xD5938590D5dD8ce95812D4D515a219C12C551D67",
+		"WETHGatewayAddr": "0xb0aaA582564fade4232a16fdB1383004A6A7247F",
+		"ERC1155GatewayAddr": "0x4f33B1655619c2C0B7C450128Df760B4365Cb549"
 	},
 	"db": {
 		"dsn": "postgres://postgres:1234@localhost:5444/test?sslmode=disable",

bridge-history-api/controller/controller.go

@@ -16,7 +16,7 @@ type QueryHashController struct {
 }
 
 func (c *QueryAddressController) Get(req model.QueryByAddressRequest) (*model.QueryByAddressResponse, error) {
-	message, err := c.Service.GetTxsByAddress(common.HexToAddress(req.Address), int64(req.Offset), int64(req.Limit))
+	message, total, err := c.Service.GetTxsByAddress(common.HexToAddress(req.Address), int64(req.Offset), int64(req.Limit))
 	if err != nil {
 		return &model.QueryByAddressResponse{Message: "500", Data: &model.Data{}}, err
 	}
@@ -24,7 +24,7 @@ func (c *QueryAddressController) Get(req model.QueryByAddressRequest) (*model.Qu
 	return &model.QueryByAddressResponse{Message: "ok",
 		Data: &model.Data{
 			Result: message,
-			Total:  len(message),
+			Total:  total,
 		}}, nil
 }
 

bridge-history-api/db/migrate/migrations/00001_cross_msg.sql

@@ -49,20 +49,20 @@ CREATE TRIGGER update_timestamp BEFORE UPDATE
 ON cross_message FOR EACH ROW EXECUTE PROCEDURE
 update_timestamp();
 
-CREATE OR REPLACE FUNCTION delete_at_trigger()
+CREATE OR REPLACE FUNCTION deleted_at_trigger()
 RETURNS TRIGGER AS $$
 BEGIN
     IF NEW.is_deleted AND OLD.is_deleted != NEW.is_deleted THEN
-        UPDATE cross_message SET delete_at = NOW() WHERE id = NEW.id;
+        UPDATE cross_message SET deleted_at = NOW() WHERE id = NEW.id;
     END IF;
     RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;
 
-CREATE TRIGGER delete_at_trigger
+CREATE TRIGGER deleted_at_trigger
 AFTER UPDATE ON cross_message
 FOR EACH ROW
-EXECUTE FUNCTION delete_at_trigger();
+EXECUTE FUNCTION deleted_at_trigger();
 
 
 -- +goose StatementEnd

bridge-history-api/db/migrate/migrations/00002_relayed_msg.sql

@@ -31,20 +31,20 @@ CREATE TRIGGER update_timestamp BEFORE UPDATE
 ON relayed_msg FOR EACH ROW EXECUTE PROCEDURE
 update_timestamp();
 
-CREATE OR REPLACE FUNCTION delete_at_trigger()
+CREATE OR REPLACE FUNCTION deleted_at_trigger()
 RETURNS TRIGGER AS $$
 BEGIN
     IF NEW.is_deleted AND OLD.is_deleted != NEW.is_deleted THEN
-        UPDATE relayed_msg SET delete_at = NOW() WHERE id = NEW.id;
+        UPDATE relayed_msg SET deleted_at = NOW() WHERE id = NEW.id;
     END IF;
     RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;
 
-CREATE TRIGGER delete_at_trigger
+CREATE TRIGGER deleted_at_trigger
 AFTER UPDATE ON relayed_msg
 FOR EACH ROW
-EXECUTE FUNCTION delete_at_trigger();
+EXECUTE FUNCTION deleted_at_trigger();
 
 
 -- +goose StatementEnd

bridge-history-api/db/orm/l2_cross_msg.go

@@ -22,7 +22,7 @@ func NewL2CrossMsgOrm(db *sqlx.DB) L2CrossMsgOrm {
 
 func (l *l2CrossMsgOrm) GetL2CrossMsgByHash(l2Hash common.Hash) (*CrossMsg, error) {
 	result := &CrossMsg{}
-	row := l.db.QueryRowx(`SELECT * FROM l2_cross_message WHERE layer2_hash = $1 AND NOT is_deleted;`, l2Hash.String())
+	row := l.db.QueryRowx(`SELECT * FROM cross_message WHERE layer2_hash = $1 AND NOT is_deleted;`, l2Hash.String())
 	if err := row.StructScan(result); err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil

bridge-history-api/db/orm_factory.go

@@ -16,6 +16,7 @@ type OrmFactory interface {
 	orm.L1CrossMsgOrm
 	orm.L2CrossMsgOrm
 	orm.RelayedMsgOrm
+	GetTotalCrossMsgCountByAddress(sender string) (uint64, error)
 	GetCrossMsgsByAddressWithOffset(sender string, offset int64, limit int64) ([]*orm.CrossMsg, error)
 	GetDB() *sqlx.DB
 	Beginx() (*sqlx.Tx, error)
@@ -59,6 +60,15 @@ func (o *ormFactory) Beginx() (*sqlx.Tx, error) {
 	return o.DB.Beginx()
 }
 
+func (o *ormFactory) GetTotalCrossMsgCountByAddress(sender string) (uint64, error) {
+	var count uint64
+	row := o.DB.QueryRowx(`SELECT COUNT(*) FROM cross_message WHERE sender = $1 AND NOT is_deleted;`, sender)
+	if err := row.Scan(&count); err != nil {
+		return 0, err
+	}
+	return count, nil
+}
+
 func (o *ormFactory) GetCrossMsgsByAddressWithOffset(sender string, offset int64, limit int64) ([]*orm.CrossMsg, error) {
 	para := sender
 	var results []*orm.CrossMsg

bridge-history-api/go.mod

@@ -4,6 +4,7 @@ go 1.19
 
 require (
 	github.com/ethereum/go-ethereum v1.12.0
+	github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458
 	github.com/jmoiron/sqlx v1.3.5
 	github.com/kataras/iris/v12 v12.2.0
 	github.com/lib/pq v1.10.7

bridge-history-api/go.sum

@@ -242,6 +242,8 @@ github.com/iris-contrib/go.uuid v2.0.0+incompatible h1:XZubAYg61/JwnJNbZilGjf3b3
 github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0=
 github.com/iris-contrib/httpexpect/v2 v2.12.1 h1:3cTZSyBBen/kfjCtgNFoUKi1u0FVXNaAjyRJOo6AVS4=
 github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk=
+github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458 h1:V60rHQJc6DieKV1BqHIGclraPdO4kinuFAZIrPGHN7s=
+github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458/go.mod h1:7eVziAp1yUwFB/ZMg71n84VWQH+7wukvxcHuF2e7cbg=
 github.com/iris-contrib/pongo2 v0.0.1/go.mod h1:Ssh+00+3GAZqSQb30AvBRNxBx7rf0GqwkjqxNd0u65g=
 github.com/iris-contrib/schema v0.0.1/go.mod h1:urYA3uvUNG1TIIjOSCzHr9/LmbQo8LrOcOqfqxa4hXw=
 github.com/iris-contrib/schema v0.0.6 h1:CPSBLyx2e91H2yJzPuhGuifVRnZBBJ3pCOMbOvPZaTw=

bridge-history-api/model/response.go

@@ -4,7 +4,7 @@ import "bridge-history-api/service"
 
 type Data struct {
 	Result []*service.TxHistoryInfo `json:"result"`
-	Total  int                      `json:"total"`
+	Total  uint64                   `json:"total"`
 }
 
 type QueryByAddressResponse struct {

bridge-history-api/service/service.go

@@ -32,7 +32,7 @@ type TxHistoryInfo struct {
 
 // HistoryService example service.
 type HistoryService interface {
-	GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, error)
+	GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error)
 	GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, error)
 }
 
@@ -69,15 +69,19 @@ func updateCrossTxHash(msgHash string, txInfo *TxHistoryInfo, db db.OrmFactory)
 
 }
 
-func (h *historyBackend) GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, error) {
-	txHistories := make([]*TxHistoryInfo, 0)
+func (h *historyBackend) GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error) {
+	var txHistories []*TxHistoryInfo
+	total, err := h.db.GetTotalCrossMsgCountByAddress(address.String())
+	if err != nil || total == 0 {
+		return txHistories, 0, err
+	}
 	result, err := h.db.GetCrossMsgsByAddressWithOffset(address.String(), offset, limit)
 	if err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 	for _, msg := range result {
 		txHistory := &TxHistoryInfo{
-			Hash:           msg.MsgHash,
+			Hash:           msg.Layer1Hash + msg.Layer2Hash,
 			Amount:         msg.Amount,
 			To:             msg.Target,
 			IsL1:           msg.MsgType == int(orm.Layer1Msg),
@@ -91,7 +95,7 @@ func (h *historyBackend) GetTxsByAddress(address common.Address, offset int64, l
 		updateCrossTxHash(msg.MsgHash, txHistory, h.db)
 		txHistories = append(txHistories, txHistory)
 	}
-	return txHistories, nil
+	return txHistories, total, nil
 }
 
 func (h *historyBackend) GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, error) {

bridge-history-api/utils/utils.go

@@ -1,7 +1,9 @@
 package utils
 
 import (
+	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"math/big"
 
@@ -59,3 +61,48 @@ func ComputeMessageHash(
 	data, _ := backendabi.L2ScrollMessengerABI.Pack("relayMessage", sender, target, value, messageNonce, message)
 	return common.BytesToHash(crypto.Keccak256(data))
 }
+
+// GetBatchRangeFromCalldataV1 find the block range from calldata, both inclusive.
+func GetBatchRangeFromCalldataV1(calldata []byte) ([]uint64, []uint64, []uint64, error) {
+	var batchIndices []uint64
+	var startBlocks []uint64
+	var finishBlocks []uint64
+	if bytes.Equal(calldata[0:4], common.Hex2Bytes("cb905499")) {
+		// commitBatches
+		method := backendabi.ScrollChainABI.Methods["commitBatches"]
+		values, err := method.Inputs.Unpack(calldata[4:])
+		if err != nil {
+			return batchIndices, startBlocks, finishBlocks, err
+		}
+		args := make([]backendabi.IScrollChainBatch, len(values))
+		err = method.Inputs.Copy(&args, values)
+		if err != nil {
+			return batchIndices, startBlocks, finishBlocks, err
+		}
+
+		for i := 0; i < len(args); i++ {
+			batchIndices = append(batchIndices, args[i].BatchIndex)
+			startBlocks = append(startBlocks, args[i].Blocks[0].BlockNumber)
+			finishBlocks = append(finishBlocks, args[i].Blocks[len(args[i].Blocks)-1].BlockNumber)
+		}
+	} else if bytes.Equal(calldata[0:4], common.Hex2Bytes("8c73235d")) {
+		// commitBatch
+		method := backendabi.ScrollChainABI.Methods["commitBatch"]
+		values, err := method.Inputs.Unpack(calldata[4:])
+		if err != nil {
+			return batchIndices, startBlocks, finishBlocks, err
+		}
+
+		args := backendabi.IScrollChainBatch{}
+		err = method.Inputs.Copy(&args, values)
+		if err != nil {
+			return batchIndices, startBlocks, finishBlocks, err
+		}
+		batchIndices = append(batchIndices, args.BatchIndex)
+		startBlocks = append(startBlocks, args.Blocks[0].BlockNumber)
+		finishBlocks = append(finishBlocks, args.Blocks[len(args.Blocks)-1].BlockNumber)
+	} else {
+		return batchIndices, startBlocks, finishBlocks, errors.New("invalid selector")
+	}
+	return batchIndices, startBlocks, finishBlocks, nil
+}

bridge-history-api/utils/utils_test.go

@@ -1,6 +1,7 @@
 package utils_test
 
 import (
+	"os"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -18,3 +19,30 @@ func TestKeccak2(t *testing.T) {
 	assert.NotEqual(t, b, c)
 	assert.Equal(t, "0xc0ffbd7f501bd3d49721b0724b2bff657cb2378f15d5a9b97cd7ea5bf630d512", c.Hex())
 }
+
+func TestGetBatchRangeFromCalldataV1(t *testing.T) {
+	calldata, err := os.ReadFile("../testdata/commit-batches-0x3095e91db7ba4a6fbf4654d607db322e58ff5579c502219c8024acaea74cf311.txt")
+	assert.NoError(t, err)
+
+	// multiple batches
+	batchIndices, startBlocks, finishBlocks, err := utils.GetBatchRangeFromCalldataV1(common.Hex2Bytes(string(calldata[:])))
+	assert.NoError(t, err)
+	assert.Equal(t, len(batchIndices), 5)
+	assert.Equal(t, len(startBlocks), 5)
+	assert.Equal(t, len(finishBlocks), 5)
+	assert.Equal(t, batchIndices[0], uint64(1))
+	assert.Equal(t, batchIndices[1], uint64(2))
+	assert.Equal(t, batchIndices[2], uint64(3))
+	assert.Equal(t, batchIndices[3], uint64(4))
+	assert.Equal(t, batchIndices[4], uint64(5))
+	assert.Equal(t, startBlocks[0], uint64(1))
+	assert.Equal(t, startBlocks[1], uint64(6))
+	assert.Equal(t, startBlocks[2], uint64(7))
+	assert.Equal(t, startBlocks[3], uint64(19))
+	assert.Equal(t, startBlocks[4], uint64(20))
+	assert.Equal(t, finishBlocks[0], uint64(5))
+	assert.Equal(t, finishBlocks[1], uint64(6))
+	assert.Equal(t, finishBlocks[2], uint64(18))
+	assert.Equal(t, finishBlocks[3], uint64(19))
+	assert.Equal(t, finishBlocks[4], uint64(20))
+}

bridge/internal/controller/watcher/l2_watcher_test.go

@@ -236,6 +236,7 @@ func prepareAuth(t *testing.T, l2Cli *ethclient.Client, privateKey *ecdsa.Privat
 	assert.NoError(t, err)
 	auth.GasPrice, err = l2Cli.SuggestGasPrice(context.Background())
 	assert.NoError(t, err)
+	auth.GasLimit = 500000
 	return auth
 }
 

build/post-test-report-coverage.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-set -uex
-${GOBIN}/gocover-cobertura  < coverage.bridge.txt > coverage.bridge.xml
-${GOBIN}/gocover-cobertura  < coverage.db.txt > coverage.db.xml
-${GOBIN}/gocover-cobertura  < coverage.common.txt > coverage.common.xml
-${GOBIN}/gocover-cobertura  < coverage.coordinator.txt > coverage.coordinator.xml
-#${GOROOT}/bin/bin/gocover-cobertura < coverage.integration.txt > coverage.integration.xml
-
-npx cobertura-merge -o cobertura.xml \
-    package1=coverage.bridge.xml \
-    package2=coverage.db.xml \
-    package3=coverage.common.xml \
-    package4=coverage.coordinator.xml
-    # package5=coverage.integration.xml

build/push-docker-tag.Jenkinsfile

@@ -1,85 +0,0 @@
-imagePrefix = 'scrolltech'
-credentialDocker = 'dockerhub'
-TAGNAME = ''
-pipeline {
-    agent any
-    options {
-        timeout (20)
-    }
-    tools {
-        go 'go-1.19'
-        nodejs "nodejs"
-    }
-    environment {
-        GO111MODULE = 'on'
-        PATH="/home/ubuntu/.cargo/bin:$PATH"
-        // LOG_DOCKER = 'true'
-    }
-    stages {
-        stage('Tag') {
-            steps {
-                script {
-                    TAGNAME = sh(returnStdout: true, script: 'git tag -l --points-at HEAD')
-                    sh "echo ${TAGNAME}"
-                    // ... 
-                }
-            }
-        }
-        stage('Build') {
-            environment {
-                // Extract the username and password of our credentials into "DOCKER_CREDENTIALS_USR" and "DOCKER_CREDENTIALS_PSW".
-                // (NOTE 1: DOCKER_CREDENTIALS will be set to "your_username:your_password".)
-                // The new variables will always be YOUR_VARIABLE_NAME + _USR and _PSW.
-                // (NOTE 2: You can't print credentials in the pipeline for security reasons.)
-                DOCKER_CREDENTIALS = credentials('dockerhub')
-            }
-           steps {
-               withCredentials([usernamePassword(credentialsId: "${credentialDocker}", passwordVariable: 'dockerPassword', usernameVariable: 'dockerUser')]) {
-                    // Use a scripted pipeline.
-                    script {
-                            stage('Push image') {
-                                if (TAGNAME == ""){
-                                    return;
-                                }
-                                sh "docker login --username=$dockerUser --password=$dockerPassword"
-                                catchError(buildResult: 'SUCCESS', stageResult: 'SUCCESS') {
-                                    script {
-                                        try {
-                                            sh "docker manifest inspect scrolltech/bridge:$TAGNAME > /dev/null"
-                                        } catch (e) {
-                                            // only build if the tag non existed
-                                            //sh "docker login --username=${dockerUser} --password=${dockerPassword}"
-                                            sh "make -C bridge docker"
-                                            sh "docker tag scrolltech/bridge:latest scrolltech/bridge:${TAGNAME}"
-                                            sh "docker push scrolltech/bridge:${TAGNAME}"
-                                            throw e
-                                        }
-                                    }
-                                }
-                                catchError(buildResult: 'SUCCESS', stageResult: 'SUCCESS') {
-                                    script {
-                                        try {
-                                            sh "docker manifest inspect scrolltech/coordinator:$TAGNAME > /dev/null"
-                                        } catch (e) {
-                                            // only build if the tag non existed
-                                            //sh "docker login --username=${dockerUser} --password=${dockerPassword}"
-                                            sh "make -C coordinator docker"
-                                            sh "docker tag scrolltech/coordinator:latest scrolltech/coordinator:${TAGNAME}"
-                                            sh "docker push scrolltech/coordinator:${TAGNAME}"
-                                            throw e
-                                        }
-                                    }
-                                }
-                            }                              
-                    }
-                }
-            }
-        }
-    }
-    post {
-        always {
-            cleanWs() 
-            slackSend(message: "${JOB_BASE_NAME} ${GIT_COMMIT} #${TAGNAME} Tag build ${currentBuild.result}")
-        }
-    }
-}

codecov.yml

@@ -0,0 +1,38 @@
+coverage:
+  status:
+    project: off
+    patch: off
+flag_management:
+  default_rules:
+    carryforward: true
+  individual_flags:
+    - name: bridge
+      statuses:
+        - type: project
+          target: auto
+          threshold: 1%
+    - name: bridge-history-api
+      statuses:
+        - type: project
+          target: auto
+          threshold: 1%
+    - name: common
+      statuses:
+        - type: project
+          target: auto
+          threshold: 1%
+    - name: coordinator
+      statuses:
+        - type: project
+          target: auto
+          threshold: 1%
+    - name: database
+      statuses:
+        - type: project
+          target: auto
+          threshold: 1%
+    - name: roller
+      statuses:
+        - type: project
+          target: auto
+          threshold: 1%

common/testdata/blockTrace_04.json

@@ -0,0 +1,868 @@
+{
+  "coinbase": {
+    "address": "0x5300000000000000000000000000000000000005",
+    "nonce": 0,
+    "balance": "0x2aa86921dcd2c0",
+    "keccakCodeHash": "0x256e306f068f0847c8aab5819879b2ff45c021ce2e2f428be51be663415b1d60",
+    "poseidonCodeHash": "0x2c49d7de76e39008575f2f090bb3e90912bad475ea8102c8565c249a75575df5",
+    "codeSize": 1652
+  },
+  "header": {
+    "parentHash": "0xe761181afb179bc4e6848ecc4e32af82c0eeff4aca77024f985d1dffb0ba0013",
+    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "miner": "0x0000000000000000000000000000000000000000",
+    "stateRoot": "0x155c42b3ffa9b88987b02bc8f89fb31f2b555bb8bff971d6fcd92e04a144c248",
+    "transactionsRoot": "0x891f5907147c83867e1e7b200b9d26fb43c3c08f81202d04235c84a2aa79f72f",
+    "receiptsRoot": "0x7ad169feb178baf74f7c0a12a28570bd69bd10e616acad2caea09a55fd1fb541",
+    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "difficulty": "0x2",
+    "number": "0xd",
+    "gasLimit": "0x7a1200",
+    "gasUsed": "0x5dc0",
+    "timestamp": "0x646b6e13",
+    "extraData": "0xd983030201846765746889676f312e31382e3130856c696e7578000000000000f942387d5a3dba7786280b806f022e2afaec53939149ac7b132b4ef1cf5cdf393d688543d984ae15b1896185ea13f9e7ae18b22b65e5ffec9128195d7cde6fa700",
+    "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "nonce": "0x0000000000000000",
+    "baseFeePerGas": null,
+    "hash": "0x09f75bc27efe18cd77a82491370442ea5a6066e910b73dc99fe1caff950c357b"
+  },
+  "transactions": [
+    {
+      "type": 126,
+      "nonce": 10,
+      "txHash": "0xed6dff31c5516b3b9d169781865276cf27501aadd45c131bf8c841c5e619e56a",
+      "gas": 24000,
+      "gasPrice": "0x0",
+      "from": "0x478cdd110520a8e733e2acf9e543d2c687ea5239",
+      "to": "0x1a258d17bf244c4df02d40343a7626a9d321e105",
+      "chainId": "0x0",
+      "value": "0x0",
+      "data": "0x8ef1332e000000000000000000000000ea08a65b1829af779261e768d609e59279b510f2000000000000000000000000f2ec6b6206f6208e8f9b394efc1a01c1cbde77750000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000a4232e87480000000000000000000000002b5ad5c4795c026514f8317c7a215e218dccd6cf0000000000000000000000002b5ad5c4795c026514f8317c7a215e218dccd6cf00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "isCreate": false,
+      "v": "0x0",
+      "r": "0x0",
+      "s": "0x0"
+    },
+    {
+      "type": 0,
+      "nonce": 11,
+      "txHash": "0xed6dff31c5516b3b9d169781865276cf27501aadd45c131bf8c841c5e619e56a",
+      "gas": 24000,
+      "gasPrice": "0x0",
+      "from": "0x478cdd110520a8e733e2acf9e543d2c687ea5239",
+      "to": "0x1a258d17bf244c4df02d40343a7626a9d321e105",
+      "chainId": "0x0",
+      "value": "0x0",
+      "data": "0x",
+      "isCreate": false,
+      "v": "0x0",
+      "r": "0x0",
+      "s": "0x0"
+    }
+  ],
+  "storageTrace": {
+    "rootBefore": "0x16d403e1c55dee3e020457262414ee7a20596922c08cac631385d8ea6d6c2c2b",
+    "rootAfter": "0x155c42b3ffa9b88987b02bc8f89fb31f2b555bb8bff971d6fcd92e04a144c248",
+    "proofs": {
+      "0x1a258d17bF244C4dF02d40343a7626A9D321e105": [
+        "0x000f2d6436a450dc3daf4f111527f3e187a9641e7c5cbc4f53a386e6e4114bb8202cc33de5af63f5deca2409302103a4523463a3a16529835d526795e8966079db",
+        "0x0029ce00b3e5ddca3bd22d3a923b95239ed11243363803b8e1f5a89fb37ee3c6e52c0d8469864d5ee8e0d62944e8dc1de68f78b094d3ef7cf72a21b372866bab0a",
+        "0x001dcee8089ea21f679f1af199cc93ccb35fdea1257b9ffeac0ae5c89654a0dbce20790d9030fd3f822620f7395f1af3ca53789e7451f811c2364f2b4fa19be9fd",
+        "0x000d62fbf3a623b87d67d8f97132a8f1759360c03c1b78ea3654238eb6c72fd5dd0742c02437cc0294c49133a28968ba1f913963d9c2892254da675958cd4a4b2e",
+        "0x0026875849a967c3af8bbd7ac6efb4ef8250efaee44c8bd85ac026d541c7f509ac18ae138a98367696a39f7abe0a53fd3b32283fa843bdc4a2485d65b3b9651670",
+        "0x0125375fd5ae821cd3e835e2fba4ae79971635b7288d549ba8ba66bea36603686c05080000000000000000000000000000000000000000000000000867000000000000000130644e72e131a029b85045b68181585d2833e84879b9705b0e1847ce1160000030221b0e9cf191ce544dcc5c8927fd08af82cb88be110d9533468ffd2d575aed31f2125c021fb94759cb1993a2f07eae01792311e13f209441ff8969cf1eb8351cafbbe8f01ed4c292d9a27be523919a274441a076b20c7d713d192dbe6485c2201a258d17bf244c4df02d40343a7626a9d321e105000000000000000000000000",
+        "0x5448495320495320534f4d45204d4147494320425954455320464f5220534d54206d3172525867503278704449"
+      ],
+      "0x478CDd110520a8e733e2ACF9e543d2c687EA5239": [
+        "0x000f2d6436a450dc3daf4f111527f3e187a9641e7c5cbc4f53a386e6e4114bb8202cc33de5af63f5deca2409302103a4523463a3a16529835d526795e8966079db",
+        "0x0029ce00b3e5ddca3bd22d3a923b95239ed11243363803b8e1f5a89fb37ee3c6e52c0d8469864d5ee8e0d62944e8dc1de68f78b094d3ef7cf72a21b372866bab0a",
+        "0x000bf7d923da6cc335d4074262981bf4615b43a8eb2a4dd6f2eda4fd8e1503d9311c4e63762bb10044749243a2b52db21797da53a89ba6b8ceb5cee1596150ac45",
+        "0x002b29daef215b12b331bf75a98e595b8a10a91928f479cca3562db3859315055a1cb697055013d78d58072071584b3e40e8d846948c8e829cbbe9915e4bcf08f0",
+        "0x00000000000000000000000000000000000000000000000000000000000000000007b1a84d4b19493ba2ca6a59dbc42d0e8559a7f8fb0c066bb8b1d90ceee9ce5c",
+        "0x0000000000000000000000000000000000000000000000000000000000000000000e9e173703b7c89f67443e861d959df35575c16617ea238fd235d8612f9020ba",
+        "0x0000000000000000000000000000000000000000000000000000000000000000000ea71dd32b28e075772420197e740ad0ed7990e3f6e5be7f5051f0c0709defce",
+        "0x000000000000000000000000000000000000000000000000000000000000000000186f00dca57567f28233cef5140efd49b1624b0ec3aef5b7f7ee42f03c3b6231",
+        "0x0006aac99418e9b09baea374df117e64523910d04427251eec6a9b482b6433bc54186c0fb6b2462a9c851df47ab11054dac43ed5b3f9d8d8a5fcf2fd0f9eb3e147",
+        "0x0109c2edb6138e8d6dc8f0b8b5ae98dd721c7053061887757f6749c484bddf92fa05080000000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4702098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b6486420478cdd110520a8e733e2acf9e543d2c687ea5239000000000000000000000000",
+        "0x5448495320495320534f4d45204d4147494320425954455320464f5220534d54206d3172525867503278704449"
+      ],
+      "0x5300000000000000000000000000000000000000": [
+        "0x000f2d6436a450dc3daf4f111527f3e187a9641e7c5cbc4f53a386e6e4114bb8202cc33de5af63f5deca2409302103a4523463a3a16529835d526795e8966079db",
+        "0x0029ce00b3e5ddca3bd22d3a923b95239ed11243363803b8e1f5a89fb37ee3c6e52c0d8469864d5ee8e0d62944e8dc1de68f78b094d3ef7cf72a21b372866bab0a",
+        "0x001dcee8089ea21f679f1af199cc93ccb35fdea1257b9ffeac0ae5c89654a0dbce20790d9030fd3f822620f7395f1af3ca53789e7451f811c2364f2b4fa19be9fd",
+        "0x000d62fbf3a623b87d67d8f97132a8f1759360c03c1b78ea3654238eb6c72fd5dd0742c02437cc0294c49133a28968ba1f913963d9c2892254da675958cd4a4b2e",
+        "0x0026875849a967c3af8bbd7ac6efb4ef8250efaee44c8bd85ac026d541c7f509ac18ae138a98367696a39f7abe0a53fd3b32283fa843bdc4a2485d65b3b9651670",
+        "0x000a3197466e4643551413444b60bbf8ab0ced04566326492fdf1993586eec3fe10000000000000000000000000000000000000000000000000000000000000000",
+        "0x002143f0cbad38f9696bb9c0be84281e5b517a06983edef7c75485b7a06473c97921dd9af8de7aade9fba53909b1a98ae938236ceec8ba6346ba3ba75c039194d7",
+        "0x0115d04fcf1fe3d9a4cc7a76b70fafcd7b9304b42108af39d9e500be391563775c0508000000000000000000000000000000000000000000000000064d000000000000000000000000000000000000000000000000000000000000000000000000000000002908ab50d1edc9dac80a344f44731acf807809c545e3388816b97a9882b5d4f974ae902ff6a84825a9cde7cc5f26e8c414e88139716c3423ed908f0a60c996011c70d94e9dc7c85d39f6877b01e59a87c057882957d9fd16c55025dfdcaa4d93205300000000000000000000000000000000000000000000000000000000000000",
+        "0x5448495320495320534f4d45204d4147494320425954455320464f5220534d54206d3172525867503278704449"
+      ],
+      "0x5300000000000000000000000000000000000002": [
+        "0x000f2d6436a450dc3daf4f111527f3e187a9641e7c5cbc4f53a386e6e4114bb8202cc33de5af63f5deca2409302103a4523463a3a16529835d526795e8966079db",
+        "0x000150eaa497ee8904a3d2dc8350c03963fb1786ea5253d5cc16f321afcd862cee107e99fa497bffacfb8ab50a44b93c9a74bc7c669323c7fbd0560a657342c55a",
+        "0x000877a6983a09f78254ca94a086eb673296f5583aa33855bfbdbe6d2fadf0ff0107b2e01ad456a3ec4c88478c604ad6a15c6fb572259e49ef4cc781940fe1375e",
+        "0x0013b6a97296cf294d19f634904a7fa973d9714b90cc42e0456ad428b7278f338e0accad868d7f4aaa755b29eae6ad523415a9df210ffced28d7d33fa6d5a319b3",
+        "0x0011de0e672d258d43c785592fc939bc105441bafc9c1455901723358b0a73d5cc29562af63a2293f036058180ce56f5269c6a3d4d18d8e1dc75ef03cb8f51f8b9",
+        "0x01236b0ff4611519fb52869dd99bedcb730ebe17544687c5064da49f42f741831d05080000000000000000000000000000000000000000000000000873000000000000000000000000000000000000000000000000000000000000000000000000000000001bd955d4ef171429eb11fade67006376e84bf94630ddb9b9948c3f385ce0f05aa48c68219d344cebd30fca18d0777f587e55052ae6161c88fa4c16407211ddaa0d39d683afa3720f93c44224e2b95a5871a5a2207b5323f7fbf8f1862120ba90205300000000000000000000000000000000000002000000000000000000000000",
+        "0x5448495320495320534f4d45204d4147494320425954455320464f5220534d54206d3172525867503278704449"
+      ],
+      "0x5300000000000000000000000000000000000005": [
+        "0x000f2d6436a450dc3daf4f111527f3e187a9641e7c5cbc4f53a386e6e4114bb8202cc33de5af63f5deca2409302103a4523463a3a16529835d526795e8966079db",
+        "0x0029ce00b3e5ddca3bd22d3a923b95239ed11243363803b8e1f5a89fb37ee3c6e52c0d8469864d5ee8e0d62944e8dc1de68f78b094d3ef7cf72a21b372866bab0a",
+        "0x000bf7d923da6cc335d4074262981bf4615b43a8eb2a4dd6f2eda4fd8e1503d9311c4e63762bb10044749243a2b52db21797da53a89ba6b8ceb5cee1596150ac45",
+        "0x002b29daef215b12b331bf75a98e595b8a10a91928f479cca3562db3859315055a1cb697055013d78d58072071584b3e40e8d846948c8e829cbbe9915e4bcf08f0",
+        "0x011facf302b106912bccc8194dff4cb12139e7f04288d3f5eefb57ccf4d842ba22050800000000000000000000000000000000000000000000000006740000000000000000000000000000000000000000000000000000000000000000002aa86921dcd2c018f4988204e816e17e42d9f9a2a468d8ca70ad453a88d3e371a0d9f743b799a6256e306f068f0847c8aab5819879b2ff45c021ce2e2f428be51be663415b1d602c49d7de76e39008575f2f090bb3e90912bad475ea8102c8565c249a75575df5205300000000000000000000000000000000000005000000000000000000000000",
+        "0x5448495320495320534f4d45204d4147494320425954455320464f5220534d54206d3172525867503278704449"
+      ]
+    },
+    "storageProofs": {
+      "0x1a258d17bF244C4dF02d40343a7626A9D321e105": {
+        "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": [
+          "0x001914b8a8cb4d4339d89ed1d5e6cd54ec609082fdf42fadb2d4101f3214f2a2290a1746dfbdf492c00e2854b46eda6adad88ad1b0583997db4121cb7d8e6de5ca",
+          "0x00084878451370def5a5648862c037adb6ae24f29b9237a1823638ca29d573bdd42446af3926a42a7e8b65f9a5fdd5a00e82e4f2b9684816fdc5d52c238bef604a",
+          "0x00027f6e365685a83e63cde58e13d22b99c130a578178f8198d755171a2ff97bf303e187b8ea9652424a9d9dac9bc16796838b196f141c6db57136643f22b48468",
+          "0x00149dad479c283104bb461dcce598d82aacff80a5844d863d8f64e0d3f3e83b1a0000000000000000000000000000000000000000000000000000000000000000",
+          "0x001f232429e01853a7456bc8bb4cbc3a35c132f7783e2b300306bceb64a44ce81e0000000000000000000000000000000000000000000000000000000000000000",
+          "0x0027e1c425d61d4468534c93b8aa80c34bbdea9ec2d69df7a730ecacf0089b22640000000000000000000000000000000000000000000000000000000000000000",
+          "0x001f4bdfdda0df475064a0ea35302dddc6401b8c93afad9a7569afb9f2534750560000000000000000000000000000000000000000000000000000000000000000",
+          "0x0001fc65caf9a60abae81bcb17c4854fa114100528e73ab1e649fac03ed9fa764e304459eb829e92aa3009534c4eba916b2900783c694385d2e7f87004e7649215",
+          "0x01249c7b39f739f430be8e1e2cae0f1db06dfe2f8d4cc631d312d5b98efb3e7402010100000000000000000000000000008eebfef33eb00149852cadb631838ad9bfcce84820b53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103",
+          "0x5448495320495320534f4d45204d4147494320425954455320464f5220534d54206d3172525867503278704449"
+        ]
+      },
+      "0x5300000000000000000000000000000000000000": {
+        "0x0000000000000000000000000000000000000000000000000000000000000000": [
+          "0x0004f706d28ba7344cc73128f383e7f4df4c79f296a56e1bbc24cdfab5bc4cba5c2a970eaf68f6e47243e30bea39087adc0082afa5fd55fc5537baccd03f786953",
+          "0x00296af6438bc81ff661ef6d1bb16d33d6784e88ae39ff28258e56e4e72d5607052bb61b23d947a704c29df01936e7c557bf9ec541243566a336b43f8aeca37eed",
+          "0x001750ff1780c9b253cfcbd6274a4f79f3a95819e0856c31f0a6025e30ac3a5b261b73cc5623d88d2687f0fa6006bc823149c779b9e751477a6f2b83773062ddbe",
+          "0x0004c8c2bf27ee6712f4175555679ff662b9423a1d7205fe31e77999106cfb5a2f0efef64a4ef3d151d1364174e0e72745aeee51bf93fb17f8071e6daf4571a736",
+          "0x001de6dfed408db1b0cf580652da17c9277834302d9ee2c39ab074675ca61fd9e02ea58d0958b74734329987e16d8afa4d83a7acc46417a7f7dbc1fd42e305b394",
+          "0x001dd3e7dce636d92fdb4dd8b65cb4e5b8ffd3d64e54a51d93a527826bb1ec3a480000000000000000000000000000000000000000000000000000000000000000",
+          "0x02",
+          "0x5448495320495320534f4d45204d4147494320425954455320464f5220534d54206d3172525867503278704449"
+        ]
+      },
+      "0x5300000000000000000000000000000000000002": {
+        "0x0000000000000000000000000000000000000000000000000000000000000001": [
+          "0x00024a2d3ee220db30dece4b39c0cffc2ba97ddded52a3f2da3aeed1f485d0a7220000000000000000000000000000000000000000000000000000000000000000",
+          "0x001da3cd3096ffd62c95bad392eedc1c578e7ccf248898c49c5ed82abb49a4b31a2b63c0d58a64939cf9026618503b904e267eeb0e465e15812b85485e81fb856c",
+          "0x01232927899d46fea05cc897a4f4671f808aa83c4eaf89396dfab15480fee91e8e010100000000000000000000000000005300000000000000000000000000000000000003200000000000000000000000000000000000000000000000000000000000000004",
+          "0x5448495320495320534f4d45204d4147494320425954455320464f5220534d54206d3172525867503278704449"
+        ],
+        "0x0000000000000000000000000000000000000000000000000000000000000002": [
+          "0x00024a2d3ee220db30dece4b39c0cffc2ba97ddded52a3f2da3aeed1f485d0a7220000000000000000000000000000000000000000000000000000000000000000",
+          "0x001da3cd3096ffd62c95bad392eedc1c578e7ccf248898c49c5ed82abb49a4b31a2b63c0d58a64939cf9026618503b904e267eeb0e465e15812b85485e81fb856c",
+          "0x012098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864010100000000000000000000000000006f4c950442e1af093bcff730381e63ae9171b87a200000000000000000000000000000000000000000000000000000000000000000",
+          "0x5448495320495320534f4d45204d4147494320425954455320464f5220534d54206d3172525867503278704449"
+        ],
+        "0x0000000000000000000000000000000000000000000000000000000000000003": [
+          "0x00024a2d3ee220db30dece4b39c0cffc2ba97ddded52a3f2da3aeed1f485d0a7220000000000000000000000000000000000000000000000000000000000000000",
+          "0x001da3cd3096ffd62c95bad392eedc1c578e7ccf248898c49c5ed82abb49a4b31a2b63c0d58a64939cf9026618503b904e267eeb0e465e15812b85485e81fb856c",
+          "0x012098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864010100000000000000000000000000006f4c950442e1af093bcff730381e63ae9171b87a200000000000000000000000000000000000000000000000000000000000000000",
+          "0x5448495320495320534f4d45204d4147494320425954455320464f5220534d54206d3172525867503278704449"
+        ]
+      }
+    }
+  },
+  "executionResults": [
+    {
+      "gas": 24000,
+      "failed": true,
+      "returnValue": "",
+      "from": {
+        "address": "0x478cdd110520a8e733e2acf9e543d2c687ea5239",
+        "nonce": 10,
+        "balance": "0x0",
+        "keccakCodeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+        "poseidonCodeHash": "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
+        "codeSize": 0
+      },
+      "to": {
+        "address": "0x1a258d17bf244c4df02d40343a7626a9d321e105",
+        "nonce": 1,
+        "balance": "0x30644e72e131a029b85045b68181585d2833e84879b9705b0e1847ce11600000",
+        "keccakCodeHash": "0x31f2125c021fb94759cb1993a2f07eae01792311e13f209441ff8969cf1eb835",
+        "poseidonCodeHash": "0x1cafbbe8f01ed4c292d9a27be523919a274441a076b20c7d713d192dbe6485c2",
+        "codeSize": 2151
+      },
+      "accountAfter": [
+        {
+          "address": "0x478cdd110520a8e733e2acf9e543d2c687ea5239",
+          "nonce": 11,
+          "balance": "0x0",
+          "keccakCodeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+          "poseidonCodeHash": "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
+          "codeSize": 0
+        },
+        {
+          "address": "0x1a258d17bf244c4df02d40343a7626a9d321e105",
+          "nonce": 1,
+          "balance": "0x30644e72e131a029b85045b68181585d2833e84879b9705b0e1847ce11600000",
+          "keccakCodeHash": "0x31f2125c021fb94759cb1993a2f07eae01792311e13f209441ff8969cf1eb835",
+          "poseidonCodeHash": "0x1cafbbe8f01ed4c292d9a27be523919a274441a076b20c7d713d192dbe6485c2",
+          "codeSize": 2151
+        },
+        {
+          "address": "0x5300000000000000000000000000000000000005",
+          "nonce": 0,
+          "balance": "0x2aa86921dcd2c0",
+          "keccakCodeHash": "0x256e306f068f0847c8aab5819879b2ff45c021ce2e2f428be51be663415b1d60",
+          "poseidonCodeHash": "0x2c49d7de76e39008575f2f090bb3e90912bad475ea8102c8565c249a75575df5",
+          "codeSize": 1652
+        }
+      ],
+      "poseidonCodeHash": "0x1cafbbe8f01ed4c292d9a27be523919a274441a076b20c7d713d192dbe6485c2",
+      "byteCode": "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",
+      "structLogs": [
+        {
+          "pc": 0,
+          "op": "PUSH1",
+          "gas": 320,
+          "gasCost": 3,
+          "depth": 1
+        },
+        {
+          "pc": 2,
+          "op": "PUSH1",
+          "gas": 317,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x80"
+          ]
+        },
+        {
+          "pc": 4,
+          "op": "MSTORE",
+          "gas": 314,
+          "gasCost": 12,
+          "depth": 1,
+          "stack": [
+            "0x80",
+            "0x40"
+          ]
+        },
+        {
+          "pc": 5,
+          "op": "PUSH1",
+          "gas": 302,
+          "gasCost": 3,
+          "depth": 1
+        },
+        {
+          "pc": 7,
+          "op": "CALLDATASIZE",
+          "gas": 299,
+          "gasCost": 2,
+          "depth": 1,
+          "stack": [
+            "0x4"
+          ]
+        },
+        {
+          "pc": 8,
+          "op": "LT",
+          "gas": 297,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x4",
+            "0x184"
+          ]
+        },
+        {
+          "pc": 9,
+          "op": "PUSH2",
+          "gas": 294,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x0"
+          ]
+        },
+        {
+          "pc": 12,
+          "op": "JUMPI",
+          "gas": 291,
+          "gasCost": 10,
+          "depth": 1,
+          "stack": [
+            "0x0",
+            "0x4e"
+          ]
+        },
+        {
+          "pc": 13,
+          "op": "PUSH1",
+          "gas": 281,
+          "gasCost": 3,
+          "depth": 1
+        },
+        {
+          "pc": 15,
+          "op": "CALLDATALOAD",
+          "gas": 278,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x0"
+          ]
+        },
+        {
+          "pc": 16,
+          "op": "PUSH1",
+          "gas": 275,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e000000000000000000000000ea08a65b1829af779261e768d609e592"
+          ]
+        },
+        {
+          "pc": 18,
+          "op": "SHR",
+          "gas": 272,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e000000000000000000000000ea08a65b1829af779261e768d609e592",
+            "0xe0"
+          ]
+        },
+        {
+          "pc": 19,
+          "op": "DUP1",
+          "gas": 269,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 20,
+          "op": "PUSH4",
+          "gas": 266,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 25,
+          "op": "EQ",
+          "gas": 263,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x8ef1332e",
+            "0x3659cfe6"
+          ]
+        },
+        {
+          "pc": 26,
+          "op": "PUSH2",
+          "gas": 260,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x0"
+          ]
+        },
+        {
+          "pc": 29,
+          "op": "JUMPI",
+          "gas": 257,
+          "gasCost": 10,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x0",
+            "0x65"
+          ]
+        },
+        {
+          "pc": 30,
+          "op": "DUP1",
+          "gas": 247,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 31,
+          "op": "PUSH4",
+          "gas": 244,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 36,
+          "op": "EQ",
+          "gas": 241,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x8ef1332e",
+            "0x4f1ef286"
+          ]
+        },
+        {
+          "pc": 37,
+          "op": "PUSH2",
+          "gas": 238,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x0"
+          ]
+        },
+        {
+          "pc": 40,
+          "op": "JUMPI",
+          "gas": 235,
+          "gasCost": 10,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x0",
+            "0x85"
+          ]
+        },
+        {
+          "pc": 41,
+          "op": "DUP1",
+          "gas": 225,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 42,
+          "op": "PUSH4",
+          "gas": 222,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 47,
+          "op": "EQ",
+          "gas": 219,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x8ef1332e",
+            "0x5c60da1b"
+          ]
+        },
+        {
+          "pc": 48,
+          "op": "PUSH2",
+          "gas": 216,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x0"
+          ]
+        },
+        {
+          "pc": 51,
+          "op": "JUMPI",
+          "gas": 213,
+          "gasCost": 10,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x0",
+            "0x98"
+          ]
+        },
+        {
+          "pc": 52,
+          "op": "DUP1",
+          "gas": 203,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 53,
+          "op": "PUSH4",
+          "gas": 200,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 58,
+          "op": "EQ",
+          "gas": 197,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x8ef1332e",
+            "0x8f283970"
+          ]
+        },
+        {
+          "pc": 59,
+          "op": "PUSH2",
+          "gas": 194,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x0"
+          ]
+        },
+        {
+          "pc": 62,
+          "op": "JUMPI",
+          "gas": 191,
+          "gasCost": 10,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x0",
+            "0xc9"
+          ]
+        },
+        {
+          "pc": 63,
+          "op": "DUP1",
+          "gas": 181,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 64,
+          "op": "PUSH4",
+          "gas": 178,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 69,
+          "op": "EQ",
+          "gas": 175,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x8ef1332e",
+            "0xf851a440"
+          ]
+        },
+        {
+          "pc": 70,
+          "op": "PUSH2",
+          "gas": 172,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x0"
+          ]
+        },
+        {
+          "pc": 73,
+          "op": "JUMPI",
+          "gas": 169,
+          "gasCost": 10,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x0",
+            "0xe9"
+          ]
+        },
+        {
+          "pc": 74,
+          "op": "PUSH2",
+          "gas": 159,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 77,
+          "op": "JUMP",
+          "gas": 156,
+          "gasCost": 8,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5d"
+          ]
+        },
+        {
+          "pc": 93,
+          "op": "JUMPDEST",
+          "gas": 148,
+          "gasCost": 1,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 94,
+          "op": "PUSH2",
+          "gas": 147,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e"
+          ]
+        },
+        {
+          "pc": 97,
+          "op": "PUSH2",
+          "gas": 144,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b"
+          ]
+        },
+        {
+          "pc": 100,
+          "op": "JUMP",
+          "gas": 141,
+          "gasCost": 8,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0xfe"
+          ]
+        },
+        {
+          "pc": 254,
+          "op": "JUMPDEST",
+          "gas": 133,
+          "gasCost": 1,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b"
+          ]
+        },
+        {
+          "pc": 255,
+          "op": "PUSH2",
+          "gas": 132,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b"
+          ]
+        },
+        {
+          "pc": 258,
+          "op": "PUSH2",
+          "gas": 129,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106"
+          ]
+        },
+        {
+          "pc": 261,
+          "op": "JUMP",
+          "gas": 126,
+          "gasCost": 8,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106",
+            "0x29b"
+          ]
+        },
+        {
+          "pc": 667,
+          "op": "JUMPDEST",
+          "gas": 118,
+          "gasCost": 1,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106"
+          ]
+        },
+        {
+          "pc": 668,
+          "op": "PUSH2",
+          "gas": 117,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106"
+          ]
+        },
+        {
+          "pc": 671,
+          "op": "PUSH2",
+          "gas": 114,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106",
+            "0x2a3"
+          ]
+        },
+        {
+          "pc": 674,
+          "op": "JUMP",
+          "gas": 111,
+          "gasCost": 8,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106",
+            "0x2a3",
+            "0x368"
+          ]
+        },
+        {
+          "pc": 872,
+          "op": "JUMPDEST",
+          "gas": 103,
+          "gasCost": 1,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106",
+            "0x2a3"
+          ]
+        },
+        {
+          "pc": 873,
+          "op": "PUSH1",
+          "gas": 102,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106",
+            "0x2a3"
+          ]
+        },
+        {
+          "pc": 875,
+          "op": "PUSH32",
+          "gas": 99,
+          "gasCost": 3,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106",
+            "0x2a3",
+            "0x0"
+          ]
+        },
+        {
+          "pc": 908,
+          "op": "JUMPDEST",
+          "gas": 96,
+          "gasCost": 1,
+          "depth": 1,
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106",
+            "0x2a3",
+            "0x0",
+            "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103"
+          ]
+        },
+        {
+          "pc": 909,
+          "op": "SLOAD",
+          "gas": 95,
+          "gasCost": 2100,
+          "depth": 1,
+          "error": "out of gas",
+          "stack": [
+            "0x8ef1332e",
+            "0x5b",
+            "0x106",
+            "0x2a3",
+            "0x0",
+            "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103"
+          ],
+          "storage": {
+            "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0x0000000000000000000000008eebfef33eb00149852cadb631838ad9bfcce848"
+          },
+          "extraData": {
+            "proofList": [
+              {
+                "address": "0x1a258d17bf244c4df02d40343a7626a9d321e105",
+                "nonce": 1,
+                "balance": "0x30644e72e131a029b85045b68181585d2833e84879b9705b0e1847ce11600000",
+                "keccakCodeHash": "0x31f2125c021fb94759cb1993a2f07eae01792311e13f209441ff8969cf1eb835",
+                "poseidonCodeHash": "0x1cafbbe8f01ed4c292d9a27be523919a274441a076b20c7d713d192dbe6485c2",
+                "codeSize": 2151,
+                "storage": {
+                  "key": "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103",
+                  "value": "0x0000000000000000000000008eebfef33eb00149852cadb631838ad9bfcce848"
+                }
+              }
+            ]
+          }
+        }
+      ]
+    }
+  ],
+  "withdraw_trie_root": "0x0000000000000000000000000000000000000000000000000000000000000000"
+}

common/types/batch_header.go

@@ -2,6 +2,7 @@ package types
 
 import (
 	"encoding/binary"
+	"fmt"
 	"math/big"
 
 	"github.com/scroll-tech/go-ethereum/common"
@@ -17,46 +18,99 @@ type BatchHeader struct {
 	totalL1MessagePopped   uint64
 	dataHash               common.Hash
 	parentBatchHash        common.Hash
-	skippedL1MessageBitmap []*big.Int // LSB is the first L1 message
+	skippedL1MessageBitmap []byte
 }
 
 // NewBatchHeader creates a new BatchHeader
 func NewBatchHeader(version uint8, batchIndex, totalL1MessagePoppedBefore uint64, parentBatchHash common.Hash, chunks []*Chunk) (*BatchHeader, error) {
-	// TODO calculate `l1MessagePopped`, `totalL1MessagePopped`, and `skippedL1MessageBitmap` based on `chunks`
+	// buffer for storing chunk hashes in order to compute the batch data hash
 	var dataBytes []byte
+
+	// skipped L1 message bitmap, an array of 256-bit bitmaps
+	var skippedBitmap []*big.Int
+
+	// the first queue index that belongs to this batch
+	baseIndex := totalL1MessagePoppedBefore
+
+	// the next queue index that we need to process
+	nextIndex := totalL1MessagePoppedBefore
+
 	for _, chunk := range chunks {
-		// Build dataHash
-		chunkBytes, err := chunk.Hash()
+		// build data hash
+		totalL1MessagePoppedBeforeChunk := nextIndex
+		chunkBytes, err := chunk.Hash(totalL1MessagePoppedBeforeChunk)
 		if err != nil {
 			return nil, err
 		}
-
 		dataBytes = append(dataBytes, chunkBytes...)
+
+		// build skip bitmap
+		for _, block := range chunk.Blocks {
+			for _, tx := range block.Transactions {
+				if tx.Type != 0x7E {
+					continue
+				}
+				currentIndex := tx.Nonce
+
+				if currentIndex < nextIndex {
+					return nil, fmt.Errorf("unexpected batch payload, expected queue index: %d, got: %d", nextIndex, currentIndex)
+				}
+
+				// mark skipped messages
+				for skippedIndex := nextIndex; skippedIndex < currentIndex; skippedIndex++ {
+					quo := int((skippedIndex - baseIndex) / 256)
+					rem := int((skippedIndex - baseIndex) % 256)
+					for len(skippedBitmap) <= quo {
+						bitmap := big.NewInt(0)
+						skippedBitmap = append(skippedBitmap, bitmap)
+					}
+					skippedBitmap[quo].SetBit(skippedBitmap[quo], rem, 1)
+				}
+
+				// process included message
+				quo := int((currentIndex - baseIndex) / 256)
+				for len(skippedBitmap) <= quo {
+					bitmap := big.NewInt(0)
+					skippedBitmap = append(skippedBitmap, bitmap)
+				}
+
+				nextIndex = currentIndex + 1
+			}
+		}
 	}
+
+	// compute data hash
 	dataHash := crypto.Keccak256Hash(dataBytes)
 
+	// compute skipped bitmap
+	bitmapBytes := make([]byte, len(skippedBitmap)*32)
+	for ii, num := range skippedBitmap {
+		bytes := num.Bytes()
+		padding := 32 - len(bytes)
+		copy(bitmapBytes[32*ii+padding:], bytes)
+	}
+
 	return &BatchHeader{
 		version:                version,
 		batchIndex:             batchIndex,
-		l1MessagePopped:        0,                          // TODO
-		totalL1MessagePopped:   totalL1MessagePoppedBefore, // TODO
+		l1MessagePopped:        nextIndex - totalL1MessagePoppedBefore,
+		totalL1MessagePopped:   nextIndex,
 		dataHash:               dataHash,
 		parentBatchHash:        parentBatchHash,
-		skippedL1MessageBitmap: nil, // TODO
+		skippedL1MessageBitmap: bitmapBytes,
 	}, nil
 }
 
 // Encode encodes the BatchHeader into RollupV2 BatchHeaderV0Codec Encoding.
 func (b *BatchHeader) Encode() []byte {
-	batchBytes := make([]byte, 89)
+	batchBytes := make([]byte, 89+len(b.skippedL1MessageBitmap))
 	batchBytes[0] = b.version
 	binary.BigEndian.PutUint64(batchBytes[1:], b.batchIndex)
 	binary.BigEndian.PutUint64(batchBytes[9:], b.l1MessagePopped)
 	binary.BigEndian.PutUint64(batchBytes[17:], b.totalL1MessagePopped)
 	copy(batchBytes[25:], b.dataHash[:])
 	copy(batchBytes[57:], b.parentBatchHash[:])
-	// TODO: encode skippedL1MessageBitmap
-
+	copy(batchBytes[89:], b.skippedL1MessageBitmap[:])
 	return batchBytes
 }
 

common/types/batch_header_test.go

@@ -10,6 +10,7 @@ import (
 )
 
 func TestNewBatchHeader(t *testing.T) {
+	// Without L1 Msg
 	templateBlockTrace, err := os.ReadFile("../testdata/blockTrace_02.json")
 	assert.NoError(t, err)
 
@@ -32,9 +33,100 @@ func TestNewBatchHeader(t *testing.T) {
 	batchHeader, err := NewBatchHeader(1, 1, 0, parentBatchHeader.Hash(), []*Chunk{chunk})
 	assert.NoError(t, err)
 	assert.NotNil(t, batchHeader)
+	assert.Equal(t, 0, len(batchHeader.skippedL1MessageBitmap))
+
+	// 1 L1 Msg in 1 bitmap
+	templateBlockTrace2, err := os.ReadFile("../testdata/blockTrace_04.json")
+	assert.NoError(t, err)
+
+	wrappedBlock2 := &WrappedBlock{}
+	assert.NoError(t, json.Unmarshal(templateBlockTrace2, wrappedBlock2))
+	chunk = &Chunk{
+		Blocks: []*WrappedBlock{
+			wrappedBlock2,
+		},
+	}
+	batchHeader, err = NewBatchHeader(1, 1, 0, parentBatchHeader.Hash(), []*Chunk{chunk})
+	assert.NoError(t, err)
+	assert.NotNil(t, batchHeader)
+	assert.Equal(t, 32, len(batchHeader.skippedL1MessageBitmap))
+	expectedBitmap := "00000000000000000000000000000000000000000000000000000000000003ff" // skip first 10
+	assert.Equal(t, expectedBitmap, common.Bytes2Hex(batchHeader.skippedL1MessageBitmap))
+
+	// many consecutive L1 Msgs in 1 bitmap, no leading skipped msgs
+	templateBlockTrace3, err := os.ReadFile("../testdata/blockTrace_05.json")
+	assert.NoError(t, err)
+
+	wrappedBlock3 := &WrappedBlock{}
+	assert.NoError(t, json.Unmarshal(templateBlockTrace3, wrappedBlock3))
+	chunk = &Chunk{
+		Blocks: []*WrappedBlock{
+			wrappedBlock3,
+		},
+	}
+	batchHeader, err = NewBatchHeader(1, 1, 37, parentBatchHeader.Hash(), []*Chunk{chunk})
+	assert.NoError(t, err)
+	assert.NotNil(t, batchHeader)
+	assert.Equal(t, uint64(5), batchHeader.l1MessagePopped)
+	assert.Equal(t, 32, len(batchHeader.skippedL1MessageBitmap))
+	expectedBitmap = "0000000000000000000000000000000000000000000000000000000000000000" // all bits are included, so none are skipped
+	assert.Equal(t, expectedBitmap, common.Bytes2Hex(batchHeader.skippedL1MessageBitmap))
+
+	// many consecutive L1 Msgs in 1 bitmap, with leading skipped msgs
+	chunk = &Chunk{
+		Blocks: []*WrappedBlock{
+			wrappedBlock3,
+		},
+	}
+	batchHeader, err = NewBatchHeader(1, 1, 0, parentBatchHeader.Hash(), []*Chunk{chunk})
+	assert.NoError(t, err)
+	assert.NotNil(t, batchHeader)
+	assert.Equal(t, uint64(42), batchHeader.l1MessagePopped)
+	assert.Equal(t, 32, len(batchHeader.skippedL1MessageBitmap))
+	expectedBitmap = "0000000000000000000000000000000000000000000000000000001fffffffff" // skipped the first 37 messages
+	assert.Equal(t, expectedBitmap, common.Bytes2Hex(batchHeader.skippedL1MessageBitmap))
+
+	// many sparse L1 Msgs in 1 bitmap
+	templateBlockTrace4, err := os.ReadFile("../testdata/blockTrace_06.json")
+	assert.NoError(t, err)
+
+	wrappedBlock4 := &WrappedBlock{}
+	assert.NoError(t, json.Unmarshal(templateBlockTrace4, wrappedBlock4))
+	chunk = &Chunk{
+		Blocks: []*WrappedBlock{
+			wrappedBlock4,
+		},
+	}
+	batchHeader, err = NewBatchHeader(1, 1, 0, parentBatchHeader.Hash(), []*Chunk{chunk})
+	assert.NoError(t, err)
+	assert.NotNil(t, batchHeader)
+	assert.Equal(t, uint64(10), batchHeader.l1MessagePopped)
+	assert.Equal(t, 32, len(batchHeader.skippedL1MessageBitmap))
+	expectedBitmap = "00000000000000000000000000000000000000000000000000000000000001dd" // 0111011101
+	assert.Equal(t, expectedBitmap, common.Bytes2Hex(batchHeader.skippedL1MessageBitmap))
+
+	// many L1 Msgs in each of 2 bitmaps
+	templateBlockTrace5, err := os.ReadFile("../testdata/blockTrace_07.json")
+	assert.NoError(t, err)
+
+	wrappedBlock5 := &WrappedBlock{}
+	assert.NoError(t, json.Unmarshal(templateBlockTrace5, wrappedBlock5))
+	chunk = &Chunk{
+		Blocks: []*WrappedBlock{
+			wrappedBlock5,
+		},
+	}
+	batchHeader, err = NewBatchHeader(1, 1, 0, parentBatchHeader.Hash(), []*Chunk{chunk})
+	assert.NoError(t, err)
+	assert.NotNil(t, batchHeader)
+	assert.Equal(t, uint64(257), batchHeader.l1MessagePopped)
+	assert.Equal(t, 64, len(batchHeader.skippedL1MessageBitmap))
+	expectedBitmap = "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd0000000000000000000000000000000000000000000000000000000000000000"
+	assert.Equal(t, expectedBitmap, common.Bytes2Hex(batchHeader.skippedL1MessageBitmap))
 }
 
 func TestBatchHeaderEncode(t *testing.T) {
+	// Without L1 Msg
 	templateBlockTrace, err := os.ReadFile("../testdata/blockTrace_02.json")
 	assert.NoError(t, err)
 
@@ -60,9 +152,28 @@ func TestBatchHeaderEncode(t *testing.T) {
 	bytes := batchHeader.Encode()
 	assert.Equal(t, 89, len(bytes))
 	assert.Equal(t, "0100000000000000010000000000000000000000000000000010a64c9bd905f8caf5d668fbda622d6558c5a42cdb4b3895709743d159c22e534136709aabc8a23aa17fbcc833da2f7857d3c2884feec9aae73429c135f94985", common.Bytes2Hex(bytes))
+
+	// With L1 Msg
+	templateBlockTrace2, err := os.ReadFile("../testdata/blockTrace_04.json")
+	assert.NoError(t, err)
+
+	wrappedBlock2 := &WrappedBlock{}
+	assert.NoError(t, json.Unmarshal(templateBlockTrace2, wrappedBlock2))
+	chunk = &Chunk{
+		Blocks: []*WrappedBlock{
+			wrappedBlock2,
+		},
+	}
+	batchHeader, err = NewBatchHeader(1, 1, 0, parentBatchHeader.Hash(), []*Chunk{chunk})
+	assert.NoError(t, err)
+	assert.NotNil(t, batchHeader)
+	bytes = batchHeader.Encode()
+	assert.Equal(t, 121, len(bytes))
+	assert.Equal(t, "010000000000000001000000000000000b000000000000000b457a9e90e8e51ba2de2f66c6b589540b88cf594dac7fa7d04b99cdcfecf24e384136709aabc8a23aa17fbcc833da2f7857d3c2884feec9aae73429c135f9498500000000000000000000000000000000000000000000000000000000000003ff", common.Bytes2Hex(bytes))
 }
 
 func TestBatchHeaderHash(t *testing.T) {
+	// Without L1 Msg
 	templateBlockTrace, err := os.ReadFile("../testdata/blockTrace_02.json")
 	assert.NoError(t, err)
 
@@ -103,4 +214,21 @@ func TestBatchHeaderHash(t *testing.T) {
 	assert.NotNil(t, batchHeader2)
 	hash2 := batchHeader2.Hash()
 	assert.Equal(t, "34de600163aa745d4513113137a5b54960d13f0d3f2849e490c4b875028bf930", common.Bytes2Hex(hash2.Bytes()))
+
+	// With L1 Msg
+	templateBlockTrace3, err := os.ReadFile("../testdata/blockTrace_04.json")
+	assert.NoError(t, err)
+
+	wrappedBlock3 := &WrappedBlock{}
+	assert.NoError(t, json.Unmarshal(templateBlockTrace3, wrappedBlock3))
+	chunk = &Chunk{
+		Blocks: []*WrappedBlock{
+			wrappedBlock3,
+		},
+	}
+	batchHeader, err = NewBatchHeader(1, 1, 0, parentBatchHeader.Hash(), []*Chunk{chunk})
+	assert.NoError(t, err)
+	assert.NotNil(t, batchHeader)
+	hash = batchHeader.Hash()
+	assert.Equal(t, "0ec9547c6645d5f0c1254e121f49e93f54525cfda5bfb2236440fb3470f48902", common.Bytes2Hex(hash.Bytes()))
 }

common/types/block.go

@@ -17,29 +17,45 @@ type WrappedBlock struct {
 	WithdrawTrieRoot common.Hash              `json:"withdraw_trie_root,omitempty"`
 }
 
+// NumL1Messages returns the number of L1 messages in this block.
+// This number is the sum of included and skipped L1 messages.
+func (w *WrappedBlock) NumL1Messages(totalL1MessagePoppedBefore uint64) uint64 {
+	var lastQueueIndex *uint64
+	for _, txData := range w.Transactions {
+		if txData.Type == 0x7E {
+			lastQueueIndex = &txData.Nonce
+		}
+	}
+	if lastQueueIndex == nil {
+		return 0
+	}
+	// note: last queue index included before this block is totalL1MessagePoppedBefore - 1
+	// TODO: cache results
+	return *lastQueueIndex - totalL1MessagePoppedBefore + 1
+}
+
 // Encode encodes the WrappedBlock into RollupV2 BlockContext Encoding.
-func (w *WrappedBlock) Encode() ([]byte, error) {
+func (w *WrappedBlock) Encode(totalL1MessagePoppedBefore uint64) ([]byte, error) {
 	bytes := make([]byte, 60)
 
 	if !w.Header.Number.IsUint64() {
 		return nil, errors.New("block number is not uint64")
 	}
-
 	if len(w.Transactions) > math.MaxUint16 {
 		return nil, errors.New("number of transactions exceeds max uint16")
 	}
 
+	numL1Messages := w.NumL1Messages(totalL1MessagePoppedBefore)
+	if numL1Messages > math.MaxUint16 {
+		return nil, errors.New("number of L1 messages exceeds max uint16")
+	}
+
 	binary.BigEndian.PutUint64(bytes[0:], w.Header.Number.Uint64())
-
 	binary.BigEndian.PutUint64(bytes[8:], w.Header.Time)
-
-	// TODO: Currently, baseFee is 0
-
+	// TODO: [16:47] Currently, baseFee is 0, because we disable EIP-1559.
 	binary.BigEndian.PutUint64(bytes[48:], w.Header.GasLimit)
-
 	binary.BigEndian.PutUint16(bytes[56:], uint16(len(w.Transactions)))
-
-	// TODO: set numL1Messages properly
+	binary.BigEndian.PutUint16(bytes[58:], uint16(numL1Messages))
 
 	return bytes, nil
 }

common/types/chunk.go

@@ -17,8 +17,21 @@ type Chunk struct {
 	Blocks []*WrappedBlock `json:"blocks"`
 }
 
+// NumL1Messages returns the number of L1 messages in this chunk.
+// This number is the sum of included and skipped L1 messages.
+func (c *Chunk) NumL1Messages(totalL1MessagePoppedBefore uint64) uint64 {
+	var numL1Messages uint64
+	for _, block := range c.Blocks {
+		numL1MessagesInBlock := block.NumL1Messages(totalL1MessagePoppedBefore)
+		numL1Messages += numL1MessagesInBlock
+		totalL1MessagePoppedBefore += numL1MessagesInBlock
+	}
+	// TODO: cache results
+	return numL1Messages
+}
+
 // Encode encodes the Chunk into RollupV2 Chunk Encoding.
-func (c *Chunk) Encode() ([]byte, error) {
+func (c *Chunk) Encode(totalL1MessagePoppedBefore uint64) ([]byte, error) {
 	numBlocks := len(c.Blocks)
 
 	if numBlocks > 255 {
@@ -34,10 +47,11 @@ func (c *Chunk) Encode() ([]byte, error) {
 	var l2TxDataBytes []byte
 
 	for _, block := range c.Blocks {
-		blockBytes, err := block.Encode()
+		blockBytes, err := block.Encode(totalL1MessagePoppedBefore)
 		if err != nil {
 			return nil, fmt.Errorf("failed to encode block: %v", err)
 		}
+		totalL1MessagePoppedBefore += block.NumL1Messages(totalL1MessagePoppedBefore)
 
 		if len(blockBytes) != 60 {
 			return nil, fmt.Errorf("block encoding is not 60 bytes long %x", len(blockBytes))
@@ -45,7 +59,7 @@ func (c *Chunk) Encode() ([]byte, error) {
 
 		chunkBytes = append(chunkBytes, blockBytes...)
 
-		// Append l2Tx Hashes
+		// Append rlp-encoded l2Txs
 		for _, txData := range block.Transactions {
 			if txData.Type == 0x7E {
 				continue
@@ -77,15 +91,14 @@ func (c *Chunk) Encode() ([]byte, error) {
 }
 
 // Hash hashes the Chunk into RollupV2 Chunk Hash
-func (c *Chunk) Hash() ([]byte, error) {
-	chunkBytes, err := c.Encode()
+func (c *Chunk) Hash(totalL1MessagePoppedBefore uint64) ([]byte, error) {
+	chunkBytes, err := c.Encode(totalL1MessagePoppedBefore)
 	if err != nil {
 		return nil, err
 	}
 	numBlocks := chunkBytes[0]
 
 	// concatenate block contexts
-	// only first 58 bytes is needed
 	var dataBytes []byte
 	for i := 0; i < int(numBlocks); i++ {
 		// only first 58 bytes is needed
@@ -93,25 +106,25 @@ func (c *Chunk) Hash() ([]byte, error) {
 	}
 
 	// concatenate l1 and l2 tx hashes
-	var l2TxHashes []byte
 	for _, block := range c.Blocks {
+		var l1TxHashes []byte
+		var l2TxHashes []byte
 		for _, txData := range block.Transactions {
-			// TODO: concatenate l1 message hashes
-			if txData.Type == 0x7E {
-				continue
-			}
-			// concatenate l2 txs hashes
-			// retrieve the number of transactions in current block.
 			txHash := strings.TrimPrefix(txData.TxHash, "0x")
 			hashBytes, err := hex.DecodeString(txHash)
 			if err != nil {
 				return nil, err
 			}
-			l2TxHashes = append(l2TxHashes, hashBytes...)
+			if txData.Type == 0x7E {
+				l1TxHashes = append(l1TxHashes, hashBytes...)
+			} else {
+				l2TxHashes = append(l2TxHashes, hashBytes...)
+			}
 		}
+		dataBytes = append(dataBytes, l1TxHashes...)
+		dataBytes = append(dataBytes, l2TxHashes...)
 	}
 
-	dataBytes = append(dataBytes, l2TxHashes...)
 	hash := crypto.Keccak256Hash(dataBytes).Bytes()
 	return hash, nil
 }

common/types/chunk_test.go

@@ -14,7 +14,7 @@ func TestChunkEncode(t *testing.T) {
 	chunk := &Chunk{
 		Blocks: []*WrappedBlock{},
 	}
-	bytes, err := chunk.Encode()
+	bytes, err := chunk.Encode(0)
 	assert.Nil(t, bytes)
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "number of blocks is 0")
@@ -26,7 +26,7 @@ func TestChunkEncode(t *testing.T) {
 	for i := 0; i < 256; i++ {
 		chunk.Blocks = append(chunk.Blocks, &WrappedBlock{})
 	}
-	bytes, err = chunk.Encode()
+	bytes, err = chunk.Encode(0)
 	assert.Nil(t, bytes)
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "number of blocks exceeds 1 byte")
@@ -37,16 +37,48 @@ func TestChunkEncode(t *testing.T) {
 
 	wrappedBlock := &WrappedBlock{}
 	assert.NoError(t, json.Unmarshal(templateBlockTrace, wrappedBlock))
+	assert.Equal(t, uint64(0), wrappedBlock.NumL1Messages(0))
 	chunk = &Chunk{
 		Blocks: []*WrappedBlock{
 			wrappedBlock,
 		},
 	}
-	bytes, err = chunk.Encode()
+	bytes, err = chunk.Encode(0)
 	hexString := hex.EncodeToString(bytes)
 	assert.NoError(t, err)
 	assert.Equal(t, 299, len(bytes))
 	assert.Equal(t, "0100000000000000020000000063807b2a0000000000000000000000000000000000000000000000000000000000000000000355418d1e81840002000000000073f87180843b9aec2e8307a12094c0c4c8baea3f6acb49b6e1fb9e2adeceeacb0ca28a152d02c7e14af60000008083019ecea0ab07ae99c67aa78e7ba5cf6781e90cc32b219b1de102513d56548a41e86df514a034cbd19feacd73e8ce64d00c4d1996b9b5243c578fd7f51bfaec288bbaf42a8b00000073f87101843b9aec2e8307a1209401bae6bf68e9a03fb2bc0615b1bf0d69ce9411ed8a152d02c7e14af60000008083019ecea0f039985866d8256f10c1be4f7b2cace28d8f20bde27e2604393eb095b7f77316a05a3e6e81065f2b4604bcec5bd4aba684835996fc3f879380aac1c09c6eed32f1", hexString)
+
+	// Test case 4: when the chunk contains one block with 1 L1MsgTx
+	templateBlockTrace2, err := os.ReadFile("../testdata/blockTrace_04.json")
+	assert.NoError(t, err)
+
+	wrappedBlock2 := &WrappedBlock{}
+	assert.NoError(t, json.Unmarshal(templateBlockTrace2, wrappedBlock2))
+	assert.Equal(t, uint64(11), wrappedBlock2.NumL1Messages(0)) // 0..=9 skipped, 10 included
+	chunk = &Chunk{
+		Blocks: []*WrappedBlock{
+			wrappedBlock2,
+		},
+	}
+	bytes, err = chunk.Encode(0)
+	hexString = hex.EncodeToString(bytes)
+	assert.NoError(t, err)
+	assert.Equal(t, 97, len(bytes))
+	assert.Equal(t, "01000000000000000d00000000646b6e13000000000000000000000000000000000000000000000000000000000000000000000000007a12000002000b00000020df0b80825dc0941a258d17bf244c4df02d40343a7626a9d321e1058080808080", hexString)
+
+	// Test case 5: when the chunk contains two blocks each with 1 L1MsgTx
+	chunk = &Chunk{
+		Blocks: []*WrappedBlock{
+			wrappedBlock2,
+			wrappedBlock2,
+		},
+	}
+	bytes, err = chunk.Encode(0)
+	hexString = hex.EncodeToString(bytes)
+	assert.NoError(t, err)
+	assert.Equal(t, 193, len(bytes))
+	assert.Equal(t, "02000000000000000d00000000646b6e13000000000000000000000000000000000000000000000000000000000000000000000000007a12000002000b000000000000000d00000000646b6e13000000000000000000000000000000000000000000000000000000000000000000000000007a12000002000000000020df0b80825dc0941a258d17bf244c4df02d40343a7626a9d321e105808080808000000020df0b80825dc0941a258d17bf244c4df02d40343a7626a9d321e1058080808080", hexString)
 }
 
 func TestChunkHash(t *testing.T) {
@@ -54,7 +86,7 @@ func TestChunkHash(t *testing.T) {
 	chunk := &Chunk{
 		Blocks: []*WrappedBlock{},
 	}
-	bytes, err := chunk.Hash()
+	bytes, err := chunk.Hash(0)
 	assert.Nil(t, bytes)
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "number of blocks is 0")
@@ -69,7 +101,7 @@ func TestChunkHash(t *testing.T) {
 			wrappedBlock,
 		},
 	}
-	bytes, err = chunk.Hash()
+	bytes, err = chunk.Hash(0)
 	hexString := hex.EncodeToString(bytes)
 	assert.NoError(t, err)
 	assert.Equal(t, "78c839dfc494396c16b40946f32b3f4c3e8c2d4bfd04aefcf235edec474482f8", hexString)
@@ -85,8 +117,24 @@ func TestChunkHash(t *testing.T) {
 			wrappedBlock1,
 		},
 	}
-	bytes, err = chunk.Hash()
+	bytes, err = chunk.Hash(0)
 	hexString = hex.EncodeToString(bytes)
 	assert.NoError(t, err)
 	assert.Equal(t, "aa9e494f72bc6965857856f0fae6916f27b2a6591c714a573b2fab46df03b8ae", hexString)
+
+	// Test case 4: successfully hashing a chunk on two blocks each with L1 and L2 txs
+	templateBlockTrace2, err := os.ReadFile("../testdata/blockTrace_04.json")
+	assert.NoError(t, err)
+	wrappedBlock2 := &WrappedBlock{}
+	assert.NoError(t, json.Unmarshal(templateBlockTrace2, wrappedBlock2))
+	chunk = &Chunk{
+		Blocks: []*WrappedBlock{
+			wrappedBlock2,
+			wrappedBlock2,
+		},
+	}
+	bytes, err = chunk.Hash(0)
+	hexString = hex.EncodeToString(bytes)
+	assert.NoError(t, err)
+	assert.Equal(t, "42967825696a129e7a83f082097aca982747480956dcaa448c9296e795c9a91a", hexString)
 }

common/version/version.go

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

contracts/docs/apis/L1ScrollMessenger.md

@@ -63,28 +63,6 @@ Initialize the storage of L1ScrollMessenger.
 | _rollup | address | The address of ScrollChain contract. |
 | _messageQueue | address | The address of L1MessageQueue contract. |
 
-### isL1MessageRelayed
-
-```solidity
-function isL1MessageRelayed(bytes32) external view returns (bool)
-```
-
-Mapping from relay id to relay status.
-
-
-
-#### Parameters
-
-| Name | Type | Description |
-|---|---|---|
-| _0 | bytes32 | undefined |
-
-#### Returns
-
-| Name | Type | Description |
-|---|---|---|
-| _0 | bool | undefined |
-
 ### isL1MessageSent
 
 ```solidity

contracts/integration-test/L1MessageQueue.spec.ts

@@ -2,7 +2,16 @@
 /* eslint-disable node/no-missing-import */
 import { expect } from "chai";
 import { BigNumber, constants } from "ethers";
-import { concat, getAddress, hexlify, keccak256, randomBytes, RLP } from "ethers/lib/utils";
+import {
+  concat,
+  getAddress,
+  hexlify,
+  keccak256,
+  randomBytes,
+  RLP,
+  stripZeros,
+  TransactionTypes,
+} from "ethers/lib/utils";
 import { ethers } from "hardhat";
 import { L1MessageQueue, L2GasPriceOracle } from "../typechain";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers";
@@ -94,8 +103,8 @@ describe("L1MessageQueue", async () => {
 
   context("#computeTransactionHash", async () => {
     it("should succeed", async () => {
-      const sender = hexlify(randomBytes(20));
-      const target = hexlify(randomBytes(20));
+      const sender = "0xb2a70fab1a45b1b9be443b6567849a1702bc1232";
+      const target = "0xcb18150e4efefb6786130e289a5f61a82a5b86d7";
       const transactionType = "0x7E";
 
       for (const nonce of [
@@ -123,19 +132,30 @@ describe("L1MessageQueue", async () => {
             constants.MaxUint256,
           ]) {
             for (const dataLen of [0, 1, 2, 3, 4, 55, 56, 100]) {
-              const data = randomBytes(dataLen);
-              const transactionPayload = RLP.encode([
-                nonce.toHexString(),
-                gasLimit.toHexString(),
-                target,
-                value.toHexString(),
-                data,
-                sender,
-              ]);
-              const payload = concat([transactionType, transactionPayload]);
-              const expectedHash = keccak256(payload);
-              const computedHash = await queue.computeTransactionHash(sender, nonce, value, target, gasLimit, data);
-              expect(expectedHash).to.eq(computedHash);
+              const tests = [randomBytes(dataLen)];
+              if (dataLen === 1) {
+                for (const byte of [0, 1, 127, 128]) {
+                  tests.push(Uint8Array.from([byte]));
+                }
+              }
+              for (const data of tests) {
+                const transactionPayload = RLP.encode([
+                  stripZeros(nonce.toHexString()),
+                  stripZeros(gasLimit.toHexString()),
+                  target,
+                  stripZeros(value.toHexString()),
+                  data,
+                  sender,
+                ]);
+                const payload = concat([transactionType, transactionPayload]);
+                const expectedHash = keccak256(payload);
+                const computedHash = await queue.computeTransactionHash(sender, nonce, value, target, gasLimit, data);
+                if (computedHash !== expectedHash) {
+                  console.log(hexlify(transactionPayload));
+                  console.log(nonce, gasLimit, target, value, data, sender);
+                }
+                expect(expectedHash).to.eq(computedHash);
+              }
             }
           }
         }

contracts/src/L1/L1ScrollMessenger.sol

@@ -30,9 +30,6 @@ contract L1ScrollMessenger is PausableUpgradeable, ScrollMessengerBase, IL1Scrol
      * Variables *
      *************/
 
-    /// @notice Mapping from relay id to relay status.
-    mapping(bytes32 => bool) public isL1MessageRelayed;
-
     /// @notice Mapping from L1 message hash to sent status.
     mapping(bytes32 => bool) public isL1MessageSent;
 
@@ -45,28 +42,6 @@ contract L1ScrollMessenger is PausableUpgradeable, ScrollMessengerBase, IL1Scrol
     /// @notice The address of L1MessageQueue contract.
     address public messageQueue;
 
-    // @note move to ScrollMessengerBase in next big refactor
-    /// @dev The status of for non-reentrant check.
-    uint256 private _lock_status;
-
-    /**********************
-     * Function Modifiers *
-     **********************/
-
-    modifier nonReentrant() {
-        // On the first call to nonReentrant, _notEntered will be true
-        require(_lock_status != _ENTERED, "ReentrancyGuard: reentrant call");
-
-        // Any calls to nonReentrant after this point will fail
-        _lock_status = _ENTERED;
-
-        _;
-
-        // By storing the original value once again, a refund is triggered (see
-        // https://eips.ethereum.org/EIPS/eip-2200)
-        _lock_status = _NOT_ENTERED;
-    }
-
     /***************
      * Constructor *
      ***************/
@@ -162,9 +137,6 @@ contract L1ScrollMessenger is PausableUpgradeable, ScrollMessengerBase, IL1Scrol
         } else {
             emit FailedRelayedMessage(_xDomainCalldataHash);
         }
-
-        bytes32 _relayId = keccak256(abi.encodePacked(_xDomainCalldataHash, msg.sender, block.number));
-        isL1MessageRelayed[_relayId] = true;
     }
 
     /// @inheritdoc IL1ScrollMessenger

contracts/src/L1/rollup/L1MessageQueue.sol

@@ -139,18 +139,27 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
                 }
             }
 
-            function store_uint(_ptr, v) -> ptr {
+            // This is used for both store uint and single byte.
+            // Integer zero is special handled by geth to encode as `0x80`
+            function store_uint_or_byte(_ptr, v, is_uint) -> ptr {
                 ptr := _ptr
                 switch lt(v, 128)
                 case 1 {
-                    // single byte in the [0x00, 0x7f]
-                    mstore(ptr, shl(248, v))
+                    switch and(iszero(v), is_uint)
+                    case 1 {
+                        // integer 0
+                        mstore8(ptr, 0x80)
+                    }
+                    default {
+                        // single byte in the [0x00, 0x7f]
+                        mstore8(ptr, v)
+                    }
                     ptr := add(ptr, 1)
                 }
                 default {
                     // 1-32 bytes long
                     let len := get_uint_bytes(v)
-                    mstore(ptr, shl(248, add(len, 0x80)))
+                    mstore8(ptr, add(len, 0x80))
                     ptr := add(ptr, 1)
                     mstore(ptr, shl(mul(8, sub(32, len)), v))
                     ptr := add(ptr, len)
@@ -160,7 +169,7 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
             function store_address(_ptr, v) -> ptr {
                 ptr := _ptr
                 // 20 bytes long
-                mstore(ptr, shl(248, 0x94)) // 0x80 + 0x14
+                mstore8(ptr, 0x94) // 0x80 + 0x14
                 ptr := add(ptr, 1)
                 mstore(ptr, shl(96, v))
                 ptr := add(ptr, 0x14)
@@ -170,21 +179,21 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
             // 4 byte for list payload length
             let start_ptr := add(mload(0x40), 5)
             let ptr := start_ptr
-            ptr := store_uint(ptr, _queueIndex)
-            ptr := store_uint(ptr, _gasLimit)
+            ptr := store_uint_or_byte(ptr, _queueIndex, 1)
+            ptr := store_uint_or_byte(ptr, _gasLimit, 1)
             ptr := store_address(ptr, _target)
-            ptr := store_uint(ptr, _value)
+            ptr := store_uint_or_byte(ptr, _value, 1)
 
             switch eq(_data.length, 1)
             case 1 {
                 // single byte
-                ptr := store_uint(ptr, shr(248, calldataload(_data.offset)))
+                ptr := store_uint_or_byte(ptr, byte(0, calldataload(_data.offset)), 0)
             }
             default {
                 switch lt(_data.length, 56)
                 case 1 {
                     // a string is 0-55 bytes long
-                    mstore(ptr, shl(248, add(0x80, _data.length)))
+                    mstore8(ptr, add(0x80, _data.length))
                     ptr := add(ptr, 1)
                     calldatacopy(ptr, _data.offset, _data.length)
                     ptr := add(ptr, _data.length)
@@ -192,7 +201,7 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
                 default {
                     // a string is more than 55 bytes long
                     let len_bytes := get_uint_bytes(_data.length)
-                    mstore(ptr, shl(248, add(0xb7, len_bytes)))
+                    mstore8(ptr, add(0xb7, len_bytes))
                     ptr := add(ptr, 1)
                     mstore(ptr, shl(mul(8, sub(32, len_bytes)), _data.length))
                     ptr := add(ptr, len_bytes)

contracts/src/L1/rollup/MultipleVersionRollupVerifier.sol

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+import {IRollupVerifier} from "../../libraries/verifier/IRollupVerifier.sol";
+import {IZkEvmVerifier} from "../../libraries/verifier/IZkEvmVerifier.sol";
+
+contract MultipleVersionRollupVerifier is IRollupVerifier, Ownable {
+    /**********
+     * Events *
+     **********/
+
+    /// @notice Emitted when the address of verifier is updated.
+    /// @param startBatchIndex The start batch index when the verifier will be used.
+    /// @param verifier The address of new verifier.
+    event UpdateVerifier(uint256 startBatchIndex, address verifier);
+
+    /***********
+     * Structs *
+     ***********/
+
+    struct Verifier {
+        // The start batch index for the verifier.
+        uint64 startBatchIndex;
+        // The address of zkevm verifier.
+        address verifier;
+    }
+
+    /*************
+     * Variables *
+     *************/
+
+    /// @notice The list of legacy zkevm verifier, sorted by batchIndex in increasing order.
+    Verifier[] public legacyVerifiers;
+
+    /// @notice The lastest used zkevm verifier.
+    Verifier public latestVerifier;
+
+    /***************
+     * Constructor *
+     ***************/
+
+    constructor(address _verifier) {
+        require(_verifier != address(0), "zero verifier address");
+
+        latestVerifier.verifier = _verifier;
+    }
+
+    /*************************
+     * Public View Functions *
+     *************************/
+
+    /// @notice Return the number of legacy verifiers.
+    function legacyVerifiersLength() external view returns (uint256) {
+        return legacyVerifiers.length;
+    }
+
+    /// @notice Compute the verifier should be used for specific batch.
+    /// @param _batchIndex The batch index to query.
+    function getVerifier(uint256 _batchIndex) public view returns (address) {
+        // Normally, we will use the latest verifier.
+        Verifier memory _verifier = latestVerifier;
+
+        if (_verifier.startBatchIndex > _batchIndex) {
+            uint256 _length = legacyVerifiers.length;
+            // In most case, only last few verifier will be used by `ScrollChain`.
+            // So, we use linear search instead of binary search.
+            unchecked {
+                for (uint256 i = _length; i > 0; --i) {
+                    _verifier = legacyVerifiers[i - 1];
+                    if (_verifier.startBatchIndex <= _batchIndex) break;
+                }
+            }
+        }
+
+        return _verifier.verifier;
+    }
+
+    /*****************************
+     * Public Mutating Functions *
+     *****************************/
+
+    /// @inheritdoc IRollupVerifier
+    function verifyAggregateProof(
+        uint256 _batchIndex,
+        bytes calldata _aggrProof,
+        bytes32 _publicInputHash
+    ) external view override {
+        address _verifier = getVerifier(_batchIndex);
+
+        IZkEvmVerifier(_verifier).verify(_aggrProof, _publicInputHash);
+    }
+
+    /************************
+     * Restricted Functions *
+     ************************/
+
+    /// @notice Update the address of zkevm verifier.
+    /// @param _startBatchIndex The start batch index when the verifier will be used.
+    /// @param _verifier The address of new verifier.
+    function updateVerifier(uint64 _startBatchIndex, address _verifier) external onlyOwner {
+        Verifier memory _latestVerifier = latestVerifier;
+        require(_startBatchIndex >= _latestVerifier.startBatchIndex, "start batch index too small");
+        require(_verifier != address(0), "zero verifier address");
+
+        if (_latestVerifier.startBatchIndex < _startBatchIndex) {
+            legacyVerifiers.push(_latestVerifier);
+            _latestVerifier.startBatchIndex = _startBatchIndex;
+        }
+        _latestVerifier.verifier = _verifier;
+
+        latestVerifier = _latestVerifier;
+
+        emit UpdateVerifier(_startBatchIndex, _verifier);
+    }
+}

contracts/src/L1/rollup/ScrollChain.sol

@@ -25,6 +25,11 @@ contract ScrollChain is OwnableUpgradeable, IScrollChain {
     /// @param status The status of the account updated.
     event UpdateSequencer(address indexed account, bool status);
 
+    /// @notice Emitted when owner updates the status of prover.
+    /// @param account The address of account updated.
+    /// @param status The status of the account updated.
+    event UpdateProver(address indexed account, bool status);
+
     /// @notice Emitted when the address of rollup verifier is updated.
     /// @param oldVerifier The address of old rollup verifier.
     /// @param newVerifier The address of new rollup verifier.
@@ -58,6 +63,9 @@ contract ScrollChain is OwnableUpgradeable, IScrollChain {
     /// @notice Whether an account is a sequencer.
     mapping(address => bool) public isSequencer;
 
+    /// @notice Whether an account is a prover.
+    mapping(address => bool) public isProver;
+
     /// @notice The latest finalized batch index.
     uint256 public lastFinalizedBatchIndex;
 
@@ -80,6 +88,11 @@ contract ScrollChain is OwnableUpgradeable, IScrollChain {
         _;
     }
 
+    modifier OnlyProver() {
+        require(isProver[msg.sender], "caller not prover");
+        _;
+    }
+
     /***************
      * Constructor *
      ***************/
@@ -117,12 +130,7 @@ contract ScrollChain is OwnableUpgradeable, IScrollChain {
      *****************************/
 
     /// @notice Import layer 2 genesis block
-    /// @dev Although `_withdrawRoot` is always zero, we add this parameter for the convenience of unit testing.
-    function importGenesisBatch(
-        bytes calldata _batchHeader,
-        bytes32 _stateRoot,
-        bytes32 _withdrawRoot
-    ) external {
+    function importGenesisBatch(bytes calldata _batchHeader, bytes32 _stateRoot) external {
         // check genesis batch header length
         require(_stateRoot != bytes32(0), "zero state root");
 
@@ -144,10 +152,9 @@ contract ScrollChain is OwnableUpgradeable, IScrollChain {
 
         committedBatches[0] = _batchHash;
         finalizedStateRoots[0] = _stateRoot;
-        withdrawRoots[0] = _withdrawRoot;
 
         emit CommitBatch(_batchHash);
-        emit FinalizeBatch(_batchHash, _stateRoot, _withdrawRoot);
+        emit FinalizeBatch(_batchHash, _stateRoot, bytes32(0));
     }
 
     /// @inheritdoc IScrollChain
@@ -278,7 +285,7 @@ contract ScrollChain is OwnableUpgradeable, IScrollChain {
         bytes32 _postStateRoot,
         bytes32 _withdrawRoot,
         bytes calldata _aggrProof
-    ) external override OnlySequencer {
+    ) external override OnlyProver {
         require(_prevStateRoot != bytes32(0), "previous state root is zero");
         require(_postStateRoot != bytes32(0), "new state root is zero");
 
@@ -301,7 +308,7 @@ contract ScrollChain is OwnableUpgradeable, IScrollChain {
         );
 
         // verify batch
-        IRollupVerifier(verifier).verifyAggregateProof(_aggrProof, _publicInputHash);
+        IRollupVerifier(verifier).verifyAggregateProof(_batchIndex, _aggrProof, _publicInputHash);
 
         // check and update lastFinalizedBatchIndex
         unchecked {
@@ -352,6 +359,16 @@ contract ScrollChain is OwnableUpgradeable, IScrollChain {
         emit UpdateSequencer(_account, _status);
     }
 
+    /// @notice Update the status of prover.
+    /// @dev This function can only called by contract owner.
+    /// @param _account The address of account to update.
+    /// @param _status The status of the account to update.
+    function updateProver(address _account, bool _status) external onlyOwner {
+        isProver[_account] = _status;
+
+        emit UpdateProver(_account, _status);
+    }
+
     /// @notice Update the address verifier contract.
     /// @param _newVerifier The address of new verifier contract.
     function updateVerifier(address _newVerifier) external onlyOwner {

contracts/src/L2/L2ScrollMessenger.sol

@@ -62,28 +62,6 @@ contract L2ScrollMessenger is ScrollMessengerBase, PausableUpgradeable, IL2Scrol
     /// @notice The maximum number of times each L1 message can fail on L2.
     uint256 public maxFailedExecutionTimes;
 
-    // @note move to ScrollMessengerBase in next big refactor
-    /// @dev The status of for non-reentrant check.
-    uint256 private _lock_status;
-
-    /**********************
-     * Function Modifiers *
-     **********************/
-
-    modifier nonReentrant() {
-        // On the first call to nonReentrant, _notEntered will be true
-        require(_lock_status != _ENTERED, "ReentrancyGuard: reentrant call");
-
-        // Any calls to nonReentrant after this point will fail
-        _lock_status = _ENTERED;
-
-        _;
-
-        // By storing the original value once again, a refund is triggered (see
-        // https://eips.ethereum.org/EIPS/eip-2200)
-        _lock_status = _NOT_ENTERED;
-    }
-
     /***************
      * Constructor *
      ***************/
@@ -126,14 +104,16 @@ contract L2ScrollMessenger is ScrollMessengerBase, PausableUpgradeable, IL2Scrol
         require(_expectedStateRoot != bytes32(0), "Block is not imported");
 
         bytes32 _storageKey;
-        // `mapping(bytes32 => bool) public isL1MessageSent` is the 105-nd slot of contract `L1ScrollMessenger`.
+        // `mapping(bytes32 => bool) public isL1MessageSent` is the 155-th slot of contract `L1ScrollMessenger`.
+        // + 1 from `Initializable`
         // + 50 from `OwnableUpgradeable`
+        // + 50 from `ContextUpgradeable`
         // + 4 from `ScrollMessengerBase`
         // + 50 from `PausableUpgradeable`
-        // + 2-nd in `L1ScrollMessenger`
+        // + 1-st in `L1ScrollMessenger`
         assembly {
             mstore(0x00, _msgHash)
-            mstore(0x20, 105)
+            mstore(0x20, 155)
             _storageKey := keccak256(0x00, 0x40)
         }
 
@@ -161,14 +141,16 @@ contract L2ScrollMessenger is ScrollMessengerBase, PausableUpgradeable, IL2Scrol
         require(_expectedStateRoot != bytes32(0), "Block not imported");
 
         bytes32 _storageKey;
-        // `mapping(bytes32 => bool) public isL2MessageExecuted` is the 106-th slot of contract `L1ScrollMessenger`.
+        // `mapping(bytes32 => bool) public isL2MessageExecuted` is the 156-th slot of contract `L1ScrollMessenger`.
+        // + 1 from `Initializable`
         // + 50 from `OwnableUpgradeable`
+        // + 50 from `ContextUpgradeable`
         // + 4 from `ScrollMessengerBase`
         // + 50 from `PausableUpgradeable`
-        // + 3-rd in `L1ScrollMessenger`
+        // + 2-nd in `L1ScrollMessenger`
         assembly {
             mstore(0x00, _msgHash)
-            mstore(0x20, 106)
+            mstore(0x20, 156)
             _storageKey := keccak256(0x00, 0x40)
         }
 

contracts/src/L2/predeploys/WETH9.sol

@@ -51,7 +51,8 @@ contract WETH9 {
             balanceOf[msg.sender] -= wad;
         }
 
-        payable(msg.sender).transfer(wad);
+        (bool success, ) = msg.sender.call{value:wad}("");
+        require(success, "withdraw ETH failed");
 
         emit Withdrawal(msg.sender, wad);
     }

contracts/src/libraries/ScrollMessengerBase.sol

@@ -38,6 +38,28 @@ abstract contract ScrollMessengerBase is OwnableUpgradeable, IScrollMessenger {
     /// @notice The address of fee vault, collecting cross domain messaging fee.
     address public feeVault;
 
+    // @note move to ScrollMessengerBase in next big refactor
+    /// @dev The status of for non-reentrant check.
+    uint256 private _lock_status;
+
+    /**********************
+     * Function Modifiers *
+     **********************/
+
+    modifier nonReentrant() {
+        // On the first call to nonReentrant, _notEntered will be true
+        require(_lock_status != _ENTERED, "ReentrancyGuard: reentrant call");
+
+        // Any calls to nonReentrant after this point will fail
+        _lock_status = _ENTERED;
+
+        _;
+
+        // By storing the original value once again, a refund is triggered (see
+        // https://eips.ethereum.org/EIPS/eip-2200)
+        _lock_status = _NOT_ENTERED;
+    }
+
     /***************
      * Constructor *
      ***************/

contracts/src/libraries/verifier/IRollupVerifier.sol

@@ -4,7 +4,12 @@ pragma solidity ^0.8.0;
 
 interface IRollupVerifier {
     /// @notice Verify aggregate zk proof.
+    /// @param batchIndex The batch index to verify.
     /// @param aggrProof The aggregated proof.
     /// @param publicInputHash The public input hash.
-    function verifyAggregateProof(bytes calldata aggrProof, bytes32 publicInputHash) external view;
+    function verifyAggregateProof(
+        uint256 batchIndex,
+        bytes calldata aggrProof,
+        bytes32 publicInputHash
+    ) external view;
 }

contracts/src/libraries/verifier/IZkEvmVerifier.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface IZkEvmVerifier {
+    /// @notice Verify aggregate zk proof.
+    /// @param aggrProof The aggregated proof.
+    /// @param publicInputHash The public input hash.
+    function verify(bytes calldata aggrProof, bytes32 publicInputHash) external view;
+}

contracts/src/test/L1GatewayTestBase.t.sol

@@ -12,6 +12,10 @@ import {Whitelist} from "../L2/predeploys/Whitelist.sol";
 import {L1ScrollMessenger} from "../L1/L1ScrollMessenger.sol";
 import {L2ScrollMessenger} from "../L2/L2ScrollMessenger.sol";
 
+import {MockRollupVerifier} from "./mocks/MockRollupVerifier.sol";
+
+// solhint-disable no-inline-assembly
+
 abstract contract L1GatewayTestBase is DSTestPlus {
     // from L1MessageQueue
     event QueueTransaction(
@@ -44,6 +48,8 @@ abstract contract L1GatewayTestBase is DSTestPlus {
     EnforcedTxGateway internal enforcedTxGateway;
     ScrollChain internal rollup;
 
+    MockRollupVerifier internal verifier;
+
     address internal feeVault;
     Whitelist private whitelist;
 
@@ -59,6 +65,7 @@ abstract contract L1GatewayTestBase is DSTestPlus {
         rollup = new ScrollChain(1233);
         enforcedTxGateway = new EnforcedTxGateway();
         whitelist = new Whitelist(address(this));
+        verifier = new MockRollupVerifier();
 
         // Deploy L2 contracts
         l2Messenger = new L2ScrollMessenger(address(0), address(0), address(0));
@@ -74,7 +81,7 @@ abstract contract L1GatewayTestBase is DSTestPlus {
         );
         gasOracle.initialize(0, 0, 0, 0);
         gasOracle.updateWhitelist(address(whitelist));
-        rollup.initialize(address(messageQueue), address(0), 44);
+        rollup.initialize(address(messageQueue), address(verifier), 44);
 
         address[] memory _accounts = new address[](1);
         _accounts[0] = address(this);
@@ -82,11 +89,40 @@ abstract contract L1GatewayTestBase is DSTestPlus {
     }
 
     function prepareL2MessageRoot(bytes32 messageHash) internal {
-        bytes memory _batchHeader = new bytes(89);
+        rollup.updateSequencer(address(this), true);
+        rollup.updateProver(address(this), true);
+
+        // import genesis batch
+        bytes memory batchHeader0 = new bytes(89);
         assembly {
-            mstore(add(_batchHeader, add(0x20, 25)), 1)
+            mstore(add(batchHeader0, add(0x20, 25)), 1)
+        }
+        rollup.importGenesisBatch(batchHeader0, bytes32(uint256(1)));
+        bytes32 batchHash0 = rollup.committedBatches(0);
+
+        // commit one batch
+        bytes[] memory chunks = new bytes[](1);
+        bytes memory chunk0 = new bytes(1 + 60);
+        chunk0[0] = bytes1(uint8(1)); // one block in this chunk
+        chunks[0] = chunk0;
+        rollup.commitBatch(0, batchHeader0, chunks, new bytes(0));
+
+        bytes memory batchHeader1 = new bytes(89);
+        assembly {
+            mstore(add(batchHeader1, 0x20), 0) // version
+            mstore(add(batchHeader1, add(0x20, 1)), shl(192, 1)) // batchIndex
+            mstore(add(batchHeader1, add(0x20, 9)), 0) // l1MessagePopped
+            mstore(add(batchHeader1, add(0x20, 17)), 0) // totalL1MessagePopped
+            mstore(add(batchHeader1, add(0x20, 25)), 0x246394445f4fe64ed5598554d55d1682d6fb3fe04bf58eb54ef81d1189fafb51) // dataHash
+            mstore(add(batchHeader1, add(0x20, 57)), batchHash0) // parentBatchHash
         }
 
-        rollup.importGenesisBatch(_batchHeader, bytes32(uint256(1)), messageHash);
+        rollup.finalizeBatchWithProof(
+            batchHeader1,
+            bytes32(uint256(1)),
+            bytes32(uint256(2)),
+            messageHash,
+            new bytes(0)
+        );
     }
 }

contracts/src/test/L1ScrollMessengerTest.t.sol

@@ -12,81 +12,47 @@ import {Whitelist} from "../L2/predeploys/Whitelist.sol";
 import {IL1ScrollMessenger, L1ScrollMessenger} from "../L1/L1ScrollMessenger.sol";
 import {L2ScrollMessenger} from "../L2/L2ScrollMessenger.sol";
 
-contract L1ScrollMessengerTest is DSTestPlus {
-    L2ScrollMessenger internal l2Messenger;
-
-    address internal feeVault;
-
-    L1ScrollMessenger internal l1Messenger;
-    ScrollChain internal scrollChain;
-    L1MessageQueue internal l1MessageQueue;
-    L2GasPriceOracle internal gasOracle;
-    EnforcedTxGateway internal enforcedTxGateway;
-    Whitelist internal whitelist;
+import {L1GatewayTestBase} from "./L1GatewayTestBase.t.sol";
 
+contract L1ScrollMessengerTest is L1GatewayTestBase {
     function setUp() public {
-        // Deploy L2 contracts
-        l2Messenger = new L2ScrollMessenger(address(0), address(0), address(0));
-
-        // Deploy L1 contracts
-        scrollChain = new ScrollChain(0);
-        l1MessageQueue = new L1MessageQueue();
-        l1Messenger = new L1ScrollMessenger();
-        gasOracle = new L2GasPriceOracle();
-        enforcedTxGateway = new EnforcedTxGateway();
-        whitelist = new Whitelist(address(this));
-
-        // Initialize L1 contracts
-        l1Messenger.initialize(address(l2Messenger), feeVault, address(scrollChain), address(l1MessageQueue));
-        l1MessageQueue.initialize(
-            address(l1Messenger),
-            address(scrollChain),
-            address(enforcedTxGateway),
-            address(gasOracle),
-            10000000
-        );
-        gasOracle.initialize(0, 0, 0, 0);
-        scrollChain.initialize(address(l1MessageQueue), address(0), 44);
-
-        gasOracle.updateWhitelist(address(whitelist));
-        address[] memory _accounts = new address[](1);
-        _accounts[0] = address(this);
-        whitelist.updateWhitelistStatus(_accounts, true);
+        L1GatewayTestBase.setUpBase();
     }
 
     function testForbidCallMessageQueueFromL2() external {
-        // import genesis batch
-        bytes memory _batchHeader = new bytes(89);
-        assembly {
-            mstore(add(_batchHeader, add(0x20, 25)), 1)
-        }
-        scrollChain.importGenesisBatch(
-            _batchHeader,
-            bytes32(uint256(1)),
-            bytes32(0x3152134c22e545ab5d345248502b4f04ef5b45f735f939c7fe6ddc0ffefc9c52)
+        bytes32 _xDomainCalldataHash = keccak256(
+            abi.encodeWithSignature(
+                "relayMessage(address,address,uint256,uint256,bytes)",
+                address(this),
+                address(messageQueue),
+                0,
+                0,
+                new bytes(0)
+            )
         );
+        prepareL2MessageRoot(_xDomainCalldataHash);
 
         IL1ScrollMessenger.L2MessageProof memory proof;
-        proof.batchIndex = scrollChain.lastFinalizedBatchIndex();
+        proof.batchIndex = rollup.lastFinalizedBatchIndex();
 
         hevm.expectRevert("Forbid to call message queue");
-        l1Messenger.relayMessageWithProof(address(this), address(l1MessageQueue), 0, 0, new bytes(0), proof);
+        l1Messenger.relayMessageWithProof(address(this), address(messageQueue), 0, 0, new bytes(0), proof);
     }
 
     function testForbidCallSelfFromL2() external {
-        // import genesis batch
-        bytes memory _batchHeader = new bytes(89);
-        assembly {
-            mstore(add(_batchHeader, 57), 1)
-        }
-        scrollChain.importGenesisBatch(
-            _batchHeader,
-            bytes32(uint256(1)),
-            bytes32(0xf7c03e2b13c88e3fca1410b228b001dd94e3f5ab4b4a4a6981d09a4eb3e5b631)
+        bytes32 _xDomainCalldataHash = keccak256(
+            abi.encodeWithSignature(
+                "relayMessage(address,address,uint256,uint256,bytes)",
+                address(this),
+                address(l1Messenger),
+                0,
+                0,
+                new bytes(0)
+            )
         );
-
+        prepareL2MessageRoot(_xDomainCalldataHash);
         IL1ScrollMessenger.L2MessageProof memory proof;
-        proof.batchIndex = scrollChain.lastFinalizedBatchIndex();
+        proof.batchIndex = rollup.lastFinalizedBatchIndex();
 
         hevm.expectRevert("Forbid to call self");
         l1Messenger.relayMessageWithProof(address(this), address(l1Messenger), 0, 0, new bytes(0), proof);
@@ -110,7 +76,9 @@ contract L1ScrollMessengerTest is DSTestPlus {
 
     function testReplayMessage(uint256 exceedValue, address refundAddress) external {
         hevm.assume(refundAddress.code.length == 0);
-        hevm.assume(uint256(uint160(refundAddress)) > 100); // ignore some precompile contracts
+        hevm.assume(uint256(uint160(refundAddress)) > uint256(100)); // ignore some precompile contracts
+        hevm.assume(refundAddress != feeVault);
+        hevm.assume(refundAddress != address(0x000000000000000000636F6e736F6c652e6c6f67)); // ignore console/console2
 
         exceedValue = bound(exceedValue, 1, address(this).balance / 2);
 
@@ -170,7 +138,7 @@ contract L1ScrollMessengerTest is DSTestPlus {
         l1Messenger.sendMessage{value: _fee + value}(address(0), value, hex"0011220033", gasLimit);
 
         // update max gas limit
-        l1MessageQueue.updateMaxGasLimit(gasLimit);
+        messageQueue.updateMaxGasLimit(gasLimit);
         l1Messenger.sendMessage{value: _fee + value}(address(0), value, hex"0011220033", gasLimit);
     }
 }

contracts/src/test/MultipleVersionRollupVerifier.t.sol

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import {DSTestPlus} from "solmate/test/utils/DSTestPlus.sol";
+
+import {L1MessageQueue} from "../L1/rollup/L1MessageQueue.sol";
+import {MultipleVersionRollupVerifier} from "../L1/rollup/MultipleVersionRollupVerifier.sol";
+
+import {MockZkEvmVerifier} from "./mocks/MockZkEvmVerifier.sol";
+
+contract MultipleVersionRollupVerifierTest is DSTestPlus {
+    // from MultipleVersionRollupVerifier
+    event UpdateVerifier(uint256 startBatchIndex, address verifier);
+
+    MultipleVersionRollupVerifier private verifier;
+    MockZkEvmVerifier private v0;
+    MockZkEvmVerifier private v1;
+    MockZkEvmVerifier private v2;
+
+    function setUp() external {
+        v0 = new MockZkEvmVerifier();
+        v1 = new MockZkEvmVerifier();
+        v2 = new MockZkEvmVerifier();
+
+        verifier = new MultipleVersionRollupVerifier(address(v0));
+    }
+
+    function testUpdateVerifier(address _newVerifier) external {
+        hevm.assume(_newVerifier != address(0));
+
+        // set by non-owner, should revert
+        hevm.startPrank(address(1));
+        hevm.expectRevert("Ownable: caller is not the owner");
+        verifier.updateVerifier(0, address(0));
+        hevm.stopPrank();
+
+        // zero verifier address, revert
+        hevm.expectRevert("zero verifier address");
+        verifier.updateVerifier(0, address(0));
+
+        // change to random operator
+        assertEq(verifier.legacyVerifiersLength(), 0);
+        verifier.updateVerifier(uint64(100), _newVerifier);
+        assertEq(verifier.legacyVerifiersLength(), 1);
+        (uint64 _startBatchIndex, address _verifier) = verifier.latestVerifier();
+        assertEq(_startBatchIndex, uint64(100));
+        assertEq(_verifier, _newVerifier);
+        (_startBatchIndex, _verifier) = verifier.legacyVerifiers(0);
+        assertEq(_startBatchIndex, uint64(0));
+        assertEq(_verifier, address(v0));
+
+        // change to same batch index
+        verifier.updateVerifier(uint64(100), address(v1));
+        (_startBatchIndex, _verifier) = verifier.latestVerifier();
+        assertEq(_startBatchIndex, uint64(100));
+        assertEq(_verifier, address(v1));
+        (_startBatchIndex, _verifier) = verifier.legacyVerifiers(0);
+        assertEq(_startBatchIndex, uint64(0));
+        assertEq(_verifier, address(v0));
+
+        // start batch index too small, revert
+        hevm.expectRevert("start batch index too small");
+        verifier.updateVerifier(99, _newVerifier);
+    }
+
+    function testGetVerifier() external {
+        verifier.updateVerifier(100, address(v1));
+        verifier.updateVerifier(300, address(v2));
+
+        assertEq(verifier.getVerifier(0), address(v0));
+        assertEq(verifier.getVerifier(1), address(v0));
+        assertEq(verifier.getVerifier(99), address(v0));
+        assertEq(verifier.getVerifier(100), address(v1));
+        assertEq(verifier.getVerifier(101), address(v1));
+        assertEq(verifier.getVerifier(299), address(v1));
+        assertEq(verifier.getVerifier(300), address(v2));
+        assertEq(verifier.getVerifier(301), address(v2));
+        assertEq(verifier.getVerifier(10000), address(v2));
+    }
+
+    function testVerifyAggregateProof() external {
+        verifier.updateVerifier(100, address(v1));
+        verifier.updateVerifier(300, address(v2));
+
+        hevm.expectRevert(abi.encode(address(v0)));
+        verifier.verifyAggregateProof(0, new bytes(0), bytes32(0));
+        hevm.expectRevert(abi.encode(address(v0)));
+        verifier.verifyAggregateProof(1, new bytes(0), bytes32(0));
+        hevm.expectRevert(abi.encode(address(v0)));
+        verifier.verifyAggregateProof(99, new bytes(0), bytes32(0));
+        hevm.expectRevert(abi.encode(address(v1)));
+        verifier.verifyAggregateProof(100, new bytes(0), bytes32(0));
+        hevm.expectRevert(abi.encode(address(v1)));
+        verifier.verifyAggregateProof(101, new bytes(0), bytes32(0));
+        hevm.expectRevert(abi.encode(address(v1)));
+        verifier.verifyAggregateProof(299, new bytes(0), bytes32(0));
+        hevm.expectRevert(abi.encode(address(v2)));
+        verifier.verifyAggregateProof(300, new bytes(0), bytes32(0));
+        hevm.expectRevert(abi.encode(address(v2)));
+        verifier.verifyAggregateProof(301, new bytes(0), bytes32(0));
+        hevm.expectRevert(abi.encode(address(v2)));
+        verifier.verifyAggregateProof(10000, new bytes(0), bytes32(0));
+    }
+}

contracts/src/test/ScrollChain.t.sol

@@ -15,7 +15,9 @@ import {MockRollupVerifier} from "./mocks/MockRollupVerifier.sol";
 contract ScrollChainTest is DSTestPlus {
     // from ScrollChain
     event UpdateSequencer(address indexed account, bool status);
+    event UpdateProver(address indexed account, bool status);
     event UpdateVerifier(address oldVerifier, address newVerifier);
+    event UpdateMaxNumL2TxInChunk(uint256 oldMaxNumL2TxInChunk, uint256 newMaxNumL2TxInChunk);
 
     event CommitBatch(bytes32 indexed batchHash);
     event FinalizeBatch(bytes32 indexed batchHash, bytes32 stateRoot, bytes32 withdrawRoot);
@@ -51,7 +53,7 @@ contract ScrollChainTest is DSTestPlus {
         assembly {
             mstore(add(batchHeader0, add(0x20, 25)), 1)
         }
-        rollup.importGenesisBatch(batchHeader0, bytes32(uint256(1)), bytes32(uint256(0)));
+        rollup.importGenesisBatch(batchHeader0, bytes32(uint256(1)));
 
         // caller not sequencer, revert
         hevm.expectRevert("caller not sequencer");
@@ -121,10 +123,11 @@ contract ScrollChainTest is DSTestPlus {
     }
 
     function testFinalizeBatchWithProof() public {
-        // caller not sequencer, revert
-        hevm.expectRevert("caller not sequencer");
+        // caller not prover, revert
+        hevm.expectRevert("caller not prover");
         rollup.finalizeBatchWithProof(new bytes(0), bytes32(0), bytes32(0), bytes32(0), new bytes(0));
 
+        rollup.updateProver(address(this), true);
         rollup.updateSequencer(address(this), true);
 
         bytes memory batchHeader0 = new bytes(89);
@@ -133,7 +136,7 @@ contract ScrollChainTest is DSTestPlus {
         assembly {
             mstore(add(batchHeader0, add(0x20, 25)), 1)
         }
-        rollup.importGenesisBatch(batchHeader0, bytes32(uint256(1)), bytes32(uint256(0)));
+        rollup.importGenesisBatch(batchHeader0, bytes32(uint256(1)));
         bytes32 batchHash0 = rollup.committedBatches(0);
 
         bytes[] memory chunks = new bytes[](1);
@@ -213,6 +216,7 @@ contract ScrollChainTest is DSTestPlus {
 
     function testCommitAndFinalizeWithL1Messages() public {
         rollup.updateSequencer(address(this), true);
+        rollup.updateProver(address(this), true);
 
         // import 300 L1 messages
         for (uint256 i = 0; i < 300; i++) {
@@ -224,7 +228,7 @@ contract ScrollChainTest is DSTestPlus {
         assembly {
             mstore(add(batchHeader0, add(0x20, 25)), 1)
         }
-        rollup.importGenesisBatch(batchHeader0, bytes32(uint256(1)), bytes32(uint256(0)));
+        rollup.importGenesisBatch(batchHeader0, bytes32(uint256(1)));
         bytes32 batchHash0 = rollup.committedBatches(0);
 
         bytes memory bitmap;
@@ -239,28 +243,28 @@ contract ScrollChainTest is DSTestPlus {
         //   0000000000000000000000000000000000000000000000000000000000000000
         //   0000000000000000
         //   0001
-        //   50c3caa727394b95dc4885b7d25033ed22ac772b985fb274f2a7c0699a11346d
+        //   a2277fd30bbbe74323309023b56035b376d7768ad237ae4fc46ead7dc9591ae1
         // => data hash for chunk0
-        //   bb88f47194a07d59ed17bc9b2015f83d0afea8f7892d9c5f0b6565563bf06b26
+        //   9ef1e5694bdb014a1eea42be756a8f63bfd8781d6332e9ef3b5126d90c62f110
         // => data hash for all chunks
-        //   038433daac85a0b03cd443ed50bc85e832c883061651ae2182b2984751e0b340
+        //   d9cb6bf9264006fcea490d5c261f7453ab95b1b26033a3805996791b8e3a62f3
         // => payload for batch header
         //   00
-        //   0000000000000002
         //   0000000000000001
         //   0000000000000001
-        //   038433daac85a0b03cd443ed50bc85e832c883061651ae2182b2984751e0b340
+        //   0000000000000001
+        //   d9cb6bf9264006fcea490d5c261f7453ab95b1b26033a3805996791b8e3a62f3
         //   119b828c2a2798d2c957228ebeaff7e10bb099ae0d4e224f3eeb779ff61cba61
         //   0000000000000000000000000000000000000000000000000000000000000000
         // => hash for batch header
-        //   cef70bf80683c4d9b8b2813e90c314e8c56648e231300b8cfed9d666b0caf14e
+        //   00847173b29b238cf319cde79512b7c213e5a8b4138daa7051914c4592b6dfc7
         bytes memory batchHeader1 = new bytes(89 + 32);
         assembly {
             mstore(add(batchHeader1, 0x20), 0) // version
             mstore(add(batchHeader1, add(0x20, 1)), shl(192, 1)) // batchIndex = 1
             mstore(add(batchHeader1, add(0x20, 9)), shl(192, 1)) // l1MessagePopped = 1
             mstore(add(batchHeader1, add(0x20, 17)), shl(192, 1)) // totalL1MessagePopped = 1
-            mstore(add(batchHeader1, add(0x20, 25)), 0x038433daac85a0b03cd443ed50bc85e832c883061651ae2182b2984751e0b340) // dataHash
+            mstore(add(batchHeader1, add(0x20, 25)), 0xd9cb6bf9264006fcea490d5c261f7453ab95b1b26033a3805996791b8e3a62f3) // dataHash
             mstore(add(batchHeader1, add(0x20, 57)), batchHash0) // parentBatchHash
             mstore(add(batchHeader1, add(0x20, 89)), 0) // bitmap0
         }
@@ -276,7 +280,7 @@ contract ScrollChainTest is DSTestPlus {
         rollup.commitBatch(0, batchHeader0, chunks, bitmap);
         assertBoolEq(rollup.isBatchFinalized(1), false);
         bytes32 batchHash1 = rollup.committedBatches(1);
-        assertEq(batchHash1, bytes32(0xcef70bf80683c4d9b8b2813e90c314e8c56648e231300b8cfed9d666b0caf14e));
+        assertEq(batchHash1, bytes32(0x00847173b29b238cf319cde79512b7c213e5a8b4138daa7051914c4592b6dfc7));
 
         // finalize batch1
         rollup.finalizeBatchWithProof(
@@ -326,26 +330,26 @@ contract ScrollChainTest is DSTestPlus {
         //    012c
         //    ... (some tx hashes)
         //   => data hash for chunk2
-        //    5c91563ee8be18cb94accfc83728f883ff5e3aa600fd0799e0a4e39afc7970b9
+        //    0520f1fbe159af97fdf1d6cfcfe7605f99f7bfe3ed876e87b64250b1810df00b
         // => data hash for all chunks
-        //   bf38f308e0a87ed7bf92fa2da038fa1d59a7b9801eb0f6d487f8eef528632145
+        //   f52343299f6379fd15b20b23d51fc61b9b357b124be112686626b6278bcffa83
         // => payload for batch header
         //  00
         //  0000000000000002
         //  0000000000000108
         //  0000000000000109
-        //  bf38f308e0a87ed7bf92fa2da038fa1d59a7b9801eb0f6d487f8eef528632145
+        //  f52343299f6379fd15b20b23d51fc61b9b357b124be112686626b6278bcffa83
         //  cef70bf80683c4d9b8b2813e90c314e8c56648e231300b8cfed9d666b0caf14e
         //  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa800000000000000000000000000000000000000000000000000000000000000aa
         // => hash for batch header
-        //  17fe6c12739f3a6261ae6db6486f41758dbd5d0508f19a5ca9ac37df67bbfec2
+        //  2231cf185a5c07931584f970738b4cd2ae4fb39e2d90853b26746c7616ea71b9
         bytes memory batchHeader2 = new bytes(89 + 32 + 32);
         assembly {
             mstore(add(batchHeader2, 0x20), 0) // version
             mstore(add(batchHeader2, add(0x20, 1)), shl(192, 2)) // batchIndex = 2
             mstore(add(batchHeader2, add(0x20, 9)), shl(192, 264)) // l1MessagePopped = 264
             mstore(add(batchHeader2, add(0x20, 17)), shl(192, 265)) // totalL1MessagePopped = 265
-            mstore(add(batchHeader2, add(0x20, 25)), 0xbf38f308e0a87ed7bf92fa2da038fa1d59a7b9801eb0f6d487f8eef528632145) // dataHash
+            mstore(add(batchHeader2, add(0x20, 25)), 0xf52343299f6379fd15b20b23d51fc61b9b357b124be112686626b6278bcffa83) // dataHash
             mstore(add(batchHeader2, add(0x20, 57)), batchHash1) // parentBatchHash
             mstore(
                 add(batchHeader2, add(0x20, 89)),
@@ -394,7 +398,7 @@ contract ScrollChainTest is DSTestPlus {
         rollup.commitBatch(0, batchHeader1, chunks, bitmap);
         assertBoolEq(rollup.isBatchFinalized(2), false);
         bytes32 batchHash2 = rollup.committedBatches(2);
-        assertEq(batchHash2, bytes32(0x17fe6c12739f3a6261ae6db6486f41758dbd5d0508f19a5ca9ac37df67bbfec2));
+        assertEq(batchHash2, bytes32(0x2231cf185a5c07931584f970738b4cd2ae4fb39e2d90853b26746c7616ea71b9));
 
         // verify committed batch correctly
         rollup.finalizeBatchWithProof(
@@ -446,7 +450,7 @@ contract ScrollChainTest is DSTestPlus {
         assembly {
             mstore(add(batchHeader0, add(0x20, 25)), 1)
         }
-        rollup.importGenesisBatch(batchHeader0, bytes32(uint256(1)), bytes32(uint256(0)));
+        rollup.importGenesisBatch(batchHeader0, bytes32(uint256(1)));
         bytes32 batchHash0 = rollup.committedBatches(0);
 
         bytes[] memory chunks = new bytes[](1);
@@ -514,6 +518,27 @@ contract ScrollChainTest is DSTestPlus {
         assertBoolEq(rollup.isSequencer(_sequencer), false);
     }
 
+    function testUpdateProver(address _prover) public {
+        // set by non-owner, should revert
+        hevm.startPrank(address(1));
+        hevm.expectRevert("Ownable: caller is not the owner");
+        rollup.updateProver(_prover, true);
+        hevm.stopPrank();
+
+        // change to random operator
+        hevm.expectEmit(true, false, false, true);
+        emit UpdateProver(_prover, true);
+
+        assertBoolEq(rollup.isProver(_prover), false);
+        rollup.updateProver(_prover, true);
+        assertBoolEq(rollup.isProver(_prover), true);
+
+        hevm.expectEmit(true, false, false, true);
+        emit UpdateProver(_prover, false);
+        rollup.updateProver(_prover, false);
+        assertBoolEq(rollup.isProver(_prover), false);
+    }
+
     function testUpdateVerifier(address _newVerifier) public {
         // set by non-owner, should revert
         hevm.startPrank(address(1));
@@ -530,58 +555,74 @@ contract ScrollChainTest is DSTestPlus {
         assertEq(rollup.verifier(), _newVerifier);
     }
 
+    function testUpdateMaxNumL2TxInChunk(uint256 _maxNumL2TxInChunk) public {
+        // set by non-owner, should revert
+        hevm.startPrank(address(1));
+        hevm.expectRevert("Ownable: caller is not the owner");
+        rollup.updateMaxNumL2TxInChunk(_maxNumL2TxInChunk);
+        hevm.stopPrank();
+
+        // change to random operator
+        hevm.expectEmit(false, false, false, true);
+        emit UpdateMaxNumL2TxInChunk(100, _maxNumL2TxInChunk);
+
+        assertEq(rollup.maxNumL2TxInChunk(), 100);
+        rollup.updateMaxNumL2TxInChunk(_maxNumL2TxInChunk);
+        assertEq(rollup.maxNumL2TxInChunk(), _maxNumL2TxInChunk);
+    }
+
     function testImportGenesisBlock() public {
         bytes memory batchHeader;
 
         // zero state root, revert
         batchHeader = new bytes(89);
         hevm.expectRevert("zero state root");
-        rollup.importGenesisBatch(batchHeader, bytes32(0), bytes32(0));
+        rollup.importGenesisBatch(batchHeader, bytes32(0));
 
         // batch header length too small, revert
         batchHeader = new bytes(88);
         hevm.expectRevert("batch header length too small");
-        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)), bytes32(0));
+        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)));
 
         // wrong bitmap length, revert
         batchHeader = new bytes(90);
         hevm.expectRevert("wrong bitmap length");
-        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)), bytes32(0));
+        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)));
 
         // not all fields are zero, revert
         batchHeader = new bytes(89);
         batchHeader[0] = bytes1(uint8(1)); // version not zero
         hevm.expectRevert("not all fields are zero");
-        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)), bytes32(0));
+        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)));
 
         batchHeader = new bytes(89);
         batchHeader[1] = bytes1(uint8(1)); // batchIndex not zero
         hevm.expectRevert("not all fields are zero");
-        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)), bytes32(0));
+        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)));
 
         batchHeader = new bytes(89 + 32);
         assembly {
             mstore(add(batchHeader, add(0x20, 9)), shl(192, 1)) // l1MessagePopped not zero
         }
         hevm.expectRevert("not all fields are zero");
-        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)), bytes32(0));
+        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)));
 
         batchHeader = new bytes(89);
         batchHeader[17] = bytes1(uint8(1)); // totalL1MessagePopped not zero
         hevm.expectRevert("not all fields are zero");
-        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)), bytes32(0));
+        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)));
 
         // zero data hash, revert
         batchHeader = new bytes(89);
         hevm.expectRevert("zero data hash");
-        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)), bytes32(0));
+        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)));
 
         // nonzero parent batch hash, revert
         batchHeader = new bytes(89);
         batchHeader[25] = bytes1(uint8(1)); // dataHash not zero
         batchHeader[57] = bytes1(uint8(1)); // parentBatchHash not zero
         hevm.expectRevert("nonzero parent batch hash");
-        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)), bytes32(0));
+        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)));
 
         // import correctly
         batchHeader = new bytes(89);
@@ -589,13 +630,13 @@ contract ScrollChainTest is DSTestPlus {
         assertEq(rollup.finalizedStateRoots(0), bytes32(0));
         assertEq(rollup.withdrawRoots(0), bytes32(0));
         assertEq(rollup.committedBatches(0), bytes32(0));
-        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)), bytes32(uint256(2)));
+        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)));
         assertEq(rollup.finalizedStateRoots(0), bytes32(uint256(1)));
-        assertEq(rollup.withdrawRoots(0), bytes32(uint256(2)));
+        assertEq(rollup.withdrawRoots(0), bytes32(0));
         assertGt(uint256(rollup.committedBatches(0)), 0);
 
         // Genesis batch imported, revert
         hevm.expectRevert("Genesis batch imported");
-        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)), bytes32(uint256(2)));
+        rollup.importGenesisBatch(batchHeader, bytes32(uint256(1)));
     }
 }

contracts/src/test/mocks/MockRollupVerifier.sol

@@ -6,5 +6,9 @@ import {IRollupVerifier} from "../../libraries/verifier/IRollupVerifier.sol";
 
 contract MockRollupVerifier is IRollupVerifier {
     /// @inheritdoc IRollupVerifier
-    function verifyAggregateProof(bytes calldata, bytes32) external view {}
+    function verifyAggregateProof(
+        uint256,
+        bytes calldata,
+        bytes32
+    ) external view {}
 }

contracts/src/test/mocks/MockZkEvmVerifier.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import {IZkEvmVerifier} from "../../libraries/verifier/IZkEvmVerifier.sol";
+
+contract MockZkEvmVerifier is IZkEvmVerifier {
+    event Called(address);
+
+    /// @inheritdoc IZkEvmVerifier
+    function verify(bytes calldata, bytes32) external view {
+        revert(string(abi.encode(address(this))));
+    }
+}