refactor(API): refactor SubmitProof (#318)

Co-authored-by: colin <102356659+colinlyguo@users.noreply.github.com>
Co-authored-by: Lawliet-Chan <1576710154@qq.com>
Co-authored-by: HAOYUatHZ <37070449+HAOYUatHZ@users.noreply.github.com>
Co-authored-by: Péter Garamvölgyi <peter@scroll.io>
Co-authored-by: HAOYUatHZ <haoyu@protonmail.com>
Co-authored-by: Haichen Shen <shenhaichen@gmail.com>

.github/pull_request_template.md

@@ -1,7 +1,19 @@
-1. Purpose or design rationale of this PR
+## 1. Purpose or design rationale of this PR
+
+...
 
 
-2. Does this PR involve a new deployment, and involve a new git tag & docker image tag? If so, has `tag` in `common/version.go` been updated? 
+## 2. Deployment tag versioning
+
+Has `tag` in `common/version.go` been updated?
+
+- [ ] This PR doesn't involve a new deployment, git tag, docker image tag
+- [ ] Yes
 
 
-3. Is this PR a breaking change? If so, have it been attached a `breaking-change` label?
+## 3. Breaking change label
+
+Does this PR have the `breaking-change` label?
+
+- [ ] This PR is not a breaking change
+- [ ] Yes

.github/workflows/bridge_history_api.yml

@@ -0,0 +1,73 @@
+name: BridgeHistoryApi
+
+on:
+  push:
+    branches:
+      - main
+      - staging
+      - develop
+      - alpha
+    paths:
+      - 'bridge-history-api/**'
+      - '.github/workflows/bridge_history_api.yml'
+  pull_request:
+    branches:
+      - main
+      - staging
+      - develop
+      - alpha
+    paths:
+      - 'bridge-history-api/**'
+      - '.github/workflows/bridge_history_api.yml'
+
+defaults:
+  run:
+    working-directory: 'bridge-history-api'
+
+jobs:
+  # check:
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #   - name: Install Go
+  #     uses: actions/setup-go@v2
+  #     with:
+  #       go-version: 1.20.x
+  #   - name: Checkout code
+  #     uses: actions/checkout@v2
+  #   - name: Lint
+  #     run: |
+  #       rm -rf $HOME/.cache/golangci-lint 
+  #       make lint
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Install Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.20.x
+    - name: Checkout code
+      uses: actions/checkout@v2
+    - name: Test
+      run: |
+        go get ./...
+        make test
+  goimports-lint:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Install Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.20.x
+    - name: Checkout code
+      uses: actions/checkout@v2
+    - name: Install goimports
+      run: go install golang.org/x/tools/cmd/goimports
+    - run: goimports -local scroll-tech/bridge-history-api/ -w .
+    - run: go mod tidy
+    # If there are any diffs from goimports or go mod tidy, fail.
+    - name: Verify no changes from goimports and go mod tidy
+      run: |
+        if [ -n "$(git status --porcelain)" ]; then
+          exit 1
+        fi
+  

.github/workflows/docker.yaml

@@ -63,3 +63,21 @@ jobs:
         tags: scrolltech/rollup-relayer:${{github.ref_name}}
         # cache-from: type=gha,scope=${{ github.workflow }}
         # cache-to: type=gha,scope=${{ github.workflow }}
+    - name: Build and push bridgehistoryapi-cross-msg-fetcher docker
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./build/dockerfiles/bridgehistoryapi-cross-msg-fetcher.Dockerfile
+        push: true
+        tags: scrolltech/bridgehistoryapi-cross-msg-fetcher:${{github.ref_name}}
+        # cache-from: type=gha,scope=${{ github.workflow }}
+        # cache-to: type=gha,scope=${{ github.workflow }}
+    - name: Build and push bridgehistoryapi-server docker
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./build/dockerfiles/bridgehistoryapi-server.Dockerfile
+        push: true
+        tags: scrolltech/bridgehistoryapi-server:${{github.ref_name}}
+        # cache-from: type=gha,scope=${{ github.workflow }}
+        # cache-to: type=gha,scope=${{ github.workflow }}

.github/workflows/roller.yml

@@ -46,9 +46,7 @@ jobs:
     - name: Test
       run: |
         make roller
-        export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:./prover/lib
-        export CHAIN_ID=534353
-        go test -v ./...
+        go test -tags="mock_prover" -v ./...
   check:
     runs-on: ubuntu-latest
     steps:

Jenkinsfile

@@ -64,7 +64,7 @@ pipeline {
                 }
                 stage('Race test coordinator package') {
                     steps {
-                        sh "cd ./coordinator && ../build/run_tests.sh coordinator"
+                        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') {
@@ -96,4 +96,4 @@ pipeline {
             slackSend(message: "${JOB_BASE_NAME} ${GIT_COMMIT} #${BUILD_NUMBER} deploy ${currentBuild.result}")
         }
     }
-}
+}

Makefile

@@ -13,15 +13,18 @@ lint: ## The code's format and security checks.
 	make -C coordinator lint
 	make -C database lint
 	make -C roller lint
+	make -C bridge-history-api lint
 
 update: ## update dependencies
 	go work sync
-	cd $(PWD)/bridge/ && go get -u github.com/scroll-tech/go-ethereum@scroll && go mod tidy
-	cd $(PWD)/common/ && go get -u github.com/scroll-tech/go-ethereum@scroll && go mod tidy
-	cd $(PWD)/coordinator/ && go get -u github.com/scroll-tech/go-ethereum@scroll && go mod tidy
-	cd $(PWD)/database/ && go get -u github.com/scroll-tech/go-ethereum@scroll && go mod tidy
-	cd $(PWD)/roller/ && go get -u github.com/scroll-tech/go-ethereum@scroll && go mod tidy
+	cd $(PWD)/bridge/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v3.1.12 && go mod tidy
+	cd $(PWD)/bridge-history-api/ && go get -u github.com/ethereum/go-ethereum@latest && go mod tidy
+	cd $(PWD)/common/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v3.1.12 && go mod tidy
+	cd $(PWD)/coordinator/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v3.1.12 && go mod tidy
+	cd $(PWD)/database/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v3.1.12 && go mod tidy
+	cd $(PWD)/roller/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v3.1.12 && go mod tidy
 	goimports -local $(PWD)/bridge/ -w .
+	goimports -local $(PWD)/bridge-history-api/ -w .
 	goimports -local $(PWD)/common/ -w .
 	goimports -local $(PWD)/coordinator/ -w .
 	goimports -local $(PWD)/database/ -w .

bridge-history-api/.gitignore

@@ -0,0 +1 @@
+/build/bin

bridge-history-api/Makefile

@@ -0,0 +1,26 @@
+.PHONY: lint
+REPO_ROOT_DIR=./..
+IMAGE_VERSION=latest
+
+lint: ## Lint the files - used for CI
+	GOBIN=$(PWD)/build/bin go run ../build/lint.go
+
+test:
+	go test -v -race -coverprofile=coverage.txt -covermode=atomic -p 1 $(PWD)/...
+
+bridgehistoryapi-db-cli:
+	go build -o $(PWD)/build/bin/bridgehistoryapi-db-cli ./cmd/db_cli
+	
+bridgehistoryapi-cross-msg-fetcher:
+	go build -o $(PWD)/build/bin/bridgehistoryapi-cross-msg-fetcher ./cmd/cross_msg_fetcher
+
+bridgehistoryapi-server:
+	go build -o $(PWD)/build/bin/bridgehistoryapi-server ./cmd/backend_server
+
+db-docker:
+	docker run --name bridgehistoryapi-history-db -p 5444:5432 -e POSTGRES_PASSWORD=123456 -e POSTGRES_DB=test -d postgres
+
+bridgehistoryapi-docker:
+	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-cross-msg-fetcher:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-cross-msg-fetcher.Dockerfile
+	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-server:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-server.Dockerfile
+	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-db-cli:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile

bridge-history-api/README.md

@@ -0,0 +1 @@
+# bridge-history-api

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

@@ -0,0 +1,95 @@
+package app
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/kataras/iris/v12"
+	"github.com/kataras/iris/v12/mvc"
+	"github.com/urfave/cli/v2"
+
+	"bridge-history-api/config"
+	"bridge-history-api/controller"
+	"bridge-history-api/db"
+	"bridge-history-api/service"
+	cutils "bridge-history-api/utils"
+)
+
+var (
+	app *cli.App
+)
+
+var database db.OrmFactory
+
+func pong(ctx iris.Context) {
+	ctx.WriteString("pong")
+}
+
+func setupQueryByAddressHandler(backend_app *mvc.Application) {
+	// Register Dependencies.
+	backend_app.Register(
+		database,
+		service.NewHistoryService,
+	)
+
+	// Register Controllers.
+	backend_app.Handle(new(controller.QueryAddressController))
+}
+
+func setupQueryByHashHandler(backend_app *mvc.Application) {
+	backend_app.Register(
+		database,
+		service.NewHistoryService,
+	)
+	backend_app.Handle(new(controller.QueryHashController))
+}
+
+func init() {
+	app = cli.NewApp()
+
+	app.Action = action
+	app.Name = "Scroll Bridge History Web Service"
+	app.Usage = "The Scroll Bridge History Web Service"
+	app.Flags = append(app.Flags, cutils.CommonFlags...)
+	app.Commands = []*cli.Command{}
+
+	app.Before = func(ctx *cli.Context) error {
+		return cutils.LogSetup(ctx)
+	}
+}
+
+func action(ctx *cli.Context) error {
+	// Load config file.
+	cfgFile := ctx.String(cutils.ConfigFileFlag.Name)
+	cfg, err := config.NewConfig(cfgFile)
+	if err != nil {
+		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
+	}
+	database, err = db.NewOrmFactory(cfg)
+	if err != nil {
+		log.Crit("can not connect to database", "err", err)
+	}
+	defer database.Close()
+	bridgeApp := iris.New()
+	bridgeApp.Get("/ping", pong).Describe("healthcheck")
+
+	mvc.Configure(bridgeApp.Party("/api/txs"), setupQueryByAddressHandler)
+	mvc.Configure(bridgeApp.Party("/api/txsbyhashes"), setupQueryByHashHandler)
+
+	// TODO: make debug mode configurable
+	err = bridgeApp.Listen(":8080", iris.WithLogLevel("debug"))
+	if err != nil {
+		log.Crit("can not start server", "err", err)
+	}
+
+	return nil
+}
+
+// Run event watcher cmd instance.
+func Run() {
+	if err := app.Run(os.Args); err != nil {
+		_, _ = fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

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

@@ -0,0 +1,7 @@
+package main
+
+import "bridge-history-api/cmd/backend_server/app"
+
+func main() {
+	app.Run()
+}

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

@@ -0,0 +1,117 @@
+package app
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/urfave/cli/v2"
+
+	"bridge-history-api/config"
+	"bridge-history-api/cross_msg"
+	"bridge-history-api/db"
+	cutils "bridge-history-api/utils"
+)
+
+var (
+	app *cli.App
+)
+
+func init() {
+	app = cli.NewApp()
+
+	app.Action = action
+	app.Name = "Scroll Bridge History API"
+	app.Usage = "The Scroll Bridge Web Backend"
+	app.Flags = append(app.Flags, cutils.CommonFlags...)
+	app.Commands = []*cli.Command{}
+
+	app.Before = func(ctx *cli.Context) error {
+		return cutils.LogSetup(ctx)
+	}
+}
+
+func action(ctx *cli.Context) error {
+	// Load config file.
+	cfgFile := ctx.String(cutils.ConfigFileFlag.Name)
+	cfg, err := config.NewConfig(cfgFile)
+	if err != nil {
+		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
+	}
+	subCtx, cancel := context.WithCancel(ctx.Context)
+	defer cancel()
+
+	l1client, err := ethclient.Dial(cfg.L1.Endpoint)
+	if err != nil {
+		log.Crit("failed to connect l1 geth", "config file", cfgFile, "error", err)
+	}
+	l2client, err := ethclient.Dial(cfg.L2.Endpoint)
+	if err != nil {
+		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
+	}
+	db, err := db.NewOrmFactory(cfg)
+	if err != nil {
+		log.Crit("failed to connect to db", "config file", cfgFile, "error", err)
+	}
+
+	l1worker := &cross_msg.FetchEventWorker{F: cross_msg.L1FetchAndSaveEvents, G: cross_msg.GetLatestL1ProcessedHeight, Name: "L1 events fetch Worker"}
+
+	l2worker := &cross_msg.FetchEventWorker{F: cross_msg.L2FetchAndSaveEvents, G: cross_msg.GetLatestL2ProcessedHeight, Name: "L2 events fetch Worker"}
+
+	l1AddressList := []common.Address{
+		common.HexToAddress(cfg.L1.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.L1.ERC721GatewayAddr),
+		common.HexToAddress(cfg.L1.ERC1155GatewayAddr),
+		common.HexToAddress(cfg.L1.MessengerAddr),
+		common.HexToAddress(cfg.L1.ETHGatewayAddr),
+		common.HexToAddress(cfg.L1.StandardERC20Gateway),
+		common.HexToAddress(cfg.L1.WETHGatewayAddr),
+	}
+
+	l2AddressList := []common.Address{
+		common.HexToAddress(cfg.L2.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.L2.ERC721GatewayAddr),
+		common.HexToAddress(cfg.L2.ERC1155GatewayAddr),
+		common.HexToAddress(cfg.L2.MessengerAddr),
+		common.HexToAddress(cfg.L2.ETHGatewayAddr),
+		common.HexToAddress(cfg.L2.StandardERC20Gateway),
+		common.HexToAddress(cfg.L2.WETHGatewayAddr),
+	}
+
+	l1crossMsgFetcher, err := cross_msg.NewCrossMsgFetcher(subCtx, cfg.L1, db, l1client, l1worker, l1AddressList, cross_msg.L1ReorgHandling)
+	if err != nil {
+		log.Crit("failed to create l1 cross message fetcher", "error", err)
+	}
+
+	go l1crossMsgFetcher.Start()
+	defer l1crossMsgFetcher.Stop()
+
+	l2crossMsgFetcher, err := cross_msg.NewCrossMsgFetcher(subCtx, cfg.L2, db, l2client, l2worker, l2AddressList, cross_msg.L2ReorgHandling)
+	if err != nil {
+		log.Crit("failed to create l2 cross message fetcher", "error", err)
+	}
+
+	go l2crossMsgFetcher.Start()
+	defer l2crossMsgFetcher.Stop()
+
+	// Catch CTRL-C to ensure a graceful shutdown.
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, os.Interrupt)
+
+	// Wait until the interrupt signal is received from an OS signal.
+	<-interrupt
+
+	return nil
+}
+
+// Run event watcher cmd instance.
+func Run() {
+	if err := app.Run(os.Args); err != nil {
+		_, _ = fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

bridge-history-api/cmd/cross_msg_fetcher/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "bridge-history-api/cmd/cross_msg_fetcher/app"
+
+func main() {
+	app.Run()
+}

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

@@ -0,0 +1,75 @@
+package app
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/urfave/cli/v2"
+
+	"bridge-history-api/utils"
+)
+
+var (
+	// Set up database app info.
+	app *cli.App
+)
+
+func init() {
+	app = cli.NewApp()
+	// Set up database app info.
+	app.Name = "db_cli"
+	app.Usage = "The Scroll Bridge-history-api DB CLI"
+	app.Flags = append(app.Flags, utils.CommonFlags...)
+
+	app.Before = func(ctx *cli.Context) error {
+		return utils.LogSetup(ctx)
+	}
+
+	app.Commands = []*cli.Command{
+		{
+			Name:   "reset",
+			Usage:  "Clean and reset database.",
+			Action: resetDB,
+			Flags:  []cli.Flag{&utils.ConfigFileFlag},
+		},
+		{
+			Name:   "status",
+			Usage:  "Check migration status.",
+			Action: checkDBStatus,
+			Flags:  []cli.Flag{&utils.ConfigFileFlag},
+		},
+		{
+			Name:   "version",
+			Usage:  "Display the current database version.",
+			Action: dbVersion,
+			Flags:  []cli.Flag{&utils.ConfigFileFlag},
+		},
+		{
+			Name:   "migrate",
+			Usage:  "Migrate the database to the latest version.",
+			Action: migrateDB,
+			Flags:  []cli.Flag{&utils.ConfigFileFlag},
+		},
+		{
+			Name:   "rollback",
+			Usage:  "Roll back the database to a previous <version>. Rolls back a single migration if no version specified.",
+			Action: rollbackDB,
+			Flags: []cli.Flag{
+				&utils.ConfigFileFlag,
+				&cli.IntFlag{
+					Name:  "version",
+					Usage: "Rollback to the specified version.",
+					Value: 0,
+				}},
+		},
+	}
+}
+
+// Run database cmd instance.
+func Run() {
+	// RunApp the db_cli.
+	if err := app.Run(os.Args); err != nil {
+		_, _ = fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

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

@@ -0,0 +1,108 @@
+package app
+
+import (
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/jmoiron/sqlx"
+	"github.com/urfave/cli/v2"
+
+	"bridge-history-api/config"
+	"bridge-history-api/db"
+	"bridge-history-api/db/migrate"
+	"bridge-history-api/utils"
+)
+
+func getConfig(ctx *cli.Context) (*config.Config, error) {
+	file := ctx.String(utils.ConfigFileFlag.Name)
+	dbCfg, err := config.NewConfig(file)
+	if err != nil {
+		return nil, err
+	}
+	return dbCfg, nil
+}
+
+func initDB(dbCfg *config.Config) (*sqlx.DB, error) {
+	factory, err := db.NewOrmFactory(dbCfg)
+	if err != nil {
+		return nil, err
+	}
+	log.Debug("Got db config from env", "driver name", dbCfg.DB.DriverName, "dsn", dbCfg.DB.DSN)
+
+	return factory.GetDB(), nil
+}
+
+// resetDB clean or reset database.
+func resetDB(ctx *cli.Context) error {
+	cfg, err := getConfig(ctx)
+	if err != nil {
+		return err
+	}
+	db, err := initDB(cfg)
+	if err != nil {
+		return err
+	}
+	err = migrate.ResetDB(db.DB)
+	if err != nil {
+		return err
+	}
+	log.Info("successful to reset")
+	return nil
+}
+
+// checkDBStatus check db status
+func checkDBStatus(ctx *cli.Context) error {
+	cfg, err := getConfig(ctx)
+	if err != nil {
+		return err
+	}
+	db, err := initDB(cfg)
+	if err != nil {
+		return err
+	}
+
+	return migrate.Status(db.DB)
+}
+
+// dbVersion return the latest version
+func dbVersion(ctx *cli.Context) error {
+	cfg, err := getConfig(ctx)
+	if err != nil {
+		return err
+	}
+	db, err := initDB(cfg)
+	if err != nil {
+		return err
+	}
+
+	version, err := migrate.Current(db.DB)
+	log.Info("show database version", "db version", version)
+
+	return err
+}
+
+// migrateDB migrate db
+func migrateDB(ctx *cli.Context) error {
+	cfg, err := getConfig(ctx)
+	if err != nil {
+		return err
+	}
+	db, err := initDB(cfg)
+	if err != nil {
+		return err
+	}
+
+	return migrate.Migrate(db.DB)
+}
+
+// rollbackDB rollback db by version
+func rollbackDB(ctx *cli.Context) error {
+	cfg, err := getConfig(ctx)
+	if err != nil {
+		return err
+	}
+	db, err := initDB(cfg)
+	if err != nil {
+		return err
+	}
+	version := ctx.Int64("version")
+	return migrate.Rollback(db.DB, &version)
+}

bridge-history-api/cmd/db_cli/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "bridge-history-api/cmd/db_cli/app"
+
+func main() {
+	app.Run()
+}

bridge-history-api/config.json

@@ -0,0 +1,34 @@
+{
+	"l1": {
+		"confirmation": 64,
+		"endpoint": "https://rpc.ankr.com/eth_goerli",
+		"startHeight": 8890194 ,
+		"blockTime": 10,
+		"MessengerAddr": "0x5260e38080BFe97e6C4925d9209eCc5f964373b6",
+		"ETHGatewayAddr": "0x429b73A21cF3BF1f3E696a21A95408161daF311f",
+		"WETHGatewayAddr": "0x8be69E499D8848DfFb4cF9bac909f3e2cF2FeFa0",
+		"StandardERC20Gateway": "0xeF37207c1A1efF6D6a9d7BfF3cF4270e406d319b",
+		"CustomERC20GatewayAddr": "0x920f906B814597cF5DC76F95100F09CBAF9c5748",
+		"ERC721GatewayAddr": "0x1C441Dfc5C2eD7A2AA8636748A664E59CB029157",
+		"ERC1155GatewayAddr": "0xd1bE599aaCBC21448fD6373bbc7c1b4c7806f135"
+	},
+	"l2": {
+		"confirmation": 1,
+		"endpoint": "https://alpha-rpc.scroll.io/l2",
+		"blockTime": 3,
+		"startHeight": 1600068,
+		"CustomERC20GatewayAddr": "0xa07Cb742657294C339fB4d5d6CdF3fdBeE8C1c68",
+		"ERC721GatewayAddr": "0x8Fee20e0C0Ef16f2898a8073531a857D11b9C700",
+		"StandardERC20Gateway": "0xB878F37BB278bf0e4974856fFe86f5e6F66BD725",
+		"MessengerAddr": "0xb75d7e84517e1504C151B270255B087Fd746D34C",
+		"ETHGatewayAddr": "0x32139B5C8838E94fFcD83E60dff95Daa7F0bA14c",
+		"WETHGatewayAddr": "0xBb88bF582F2BBa46702621dae5CB9271057bC85b",
+		"ERC1155GatewayAddr": "0x2946cB860028276b3C4bccE1767841641C2E0828"
+	},
+	"db": {
+		"dsn": "postgres://postgres:1234@localhost:5444/test?sslmode=disable",
+		"driverName": "postgres",
+		"maxOpenNum": 200,
+		"maxIdleNum": 20
+	}
+}

bridge-history-api/config/config.go

@@ -0,0 +1,57 @@
+package config
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+)
+
+// DBConfig db config
+type DBConfig struct {
+	// data source name
+	DSN        string `json:"dsn"`
+	DriverName string `json:"driverName"`
+
+	MaxOpenNum int `json:"maxOpenNum"`
+	MaxIdleNum int `json:"maxIdleNum"`
+}
+
+type LayerConfig struct {
+	Confirmation           uint64 `json:"confirmation"`
+	Endpoint               string `json:"endpoint"`
+	StartHeight            uint64 `json:"startHeight"`
+	BlockTime              int64  `json:"blockTime"`
+	MessengerAddr          string `json:"MessengerAddr"`
+	ETHGatewayAddr         string `json:"ETHGatewayAddr"`
+	WETHGatewayAddr        string `json:"WETHGatewayAddr"`
+	StandardERC20Gateway   string `json:"StandardERC20Gateway"`
+	ERC721GatewayAddr      string `json:"ERC721GatewayAddr"`
+	ERC1155GatewayAddr     string `json:"ERC1155GatewayAddr"`
+	CustomERC20GatewayAddr string `json:"CustomERC20GatewayAddr"`
+}
+
+// Config is the configuration of the bridge history backend
+type Config struct {
+	// chain config
+	L1 *LayerConfig `json:"l1"`
+	L2 *LayerConfig `json:"l2"`
+
+	// data source name
+	DB *DBConfig `json:"db"`
+}
+
+// NewConfig returns a new instance of Config.
+func NewConfig(file string) (*Config, error) {
+	buf, err := os.ReadFile(filepath.Clean(file))
+	if err != nil {
+		return nil, err
+	}
+
+	cfg := &Config{}
+	err = json.Unmarshal(buf, cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	return cfg, nil
+}

bridge-history-api/controller/controller.go

@@ -0,0 +1,37 @@
+package controller
+
+import (
+	"bridge-history-api/model"
+	"bridge-history-api/service"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type QueryAddressController struct {
+	Service service.HistoryService
+}
+
+type QueryHashController struct {
+	Service service.HistoryService
+}
+
+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))
+	if err != nil {
+		return &model.QueryByAddressResponse{Message: "500", Data: &model.Data{}}, err
+	}
+
+	return &model.QueryByAddressResponse{Message: "ok",
+		Data: &model.Data{
+			Result: message,
+			Total:  len(message),
+		}}, nil
+}
+
+func (c *QueryHashController) Post(req model.QueryByHashRequest) (*model.QueryByHashResponse, error) {
+	result, err := c.Service.GetTxsByHashes(req.Txs)
+	if err != nil {
+		return &model.QueryByHashResponse{Message: "500", Data: &model.Data{}}, err
+	}
+	return &model.QueryByHashResponse{Message: "ok", Data: &model.Data{Result: result}}, nil
+}

bridge-history-api/cross_msg/cross_msg_fetcher.go

@@ -0,0 +1,207 @@
+package cross_msg
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/modern-go/reflect2"
+
+	"bridge-history-api/config"
+	"bridge-history-api/db"
+	"bridge-history-api/utils"
+)
+
+type CrossMsgFetcher struct {
+	ctx           context.Context
+	config        *config.LayerConfig
+	db            db.OrmFactory
+	client        *ethclient.Client
+	worker        *FetchEventWorker
+	reorgHandling ReorgHandling
+	addressList   []common.Address
+	cachedHeaders []*types.Header
+	mu            *sync.Mutex
+	reorgStartCh  chan struct{}
+	reorgEndCh    chan struct{}
+}
+
+func NewCrossMsgFetcher(ctx context.Context, config *config.LayerConfig, db db.OrmFactory, client *ethclient.Client, worker *FetchEventWorker, addressList []common.Address, reorg ReorgHandling) (*CrossMsgFetcher, error) {
+	newMU := &sync.Mutex{}
+	crossMsgFetcher := &CrossMsgFetcher{
+		ctx:           ctx,
+		config:        config,
+		db:            db,
+		client:        client,
+		worker:        worker,
+		reorgHandling: reorg,
+		mu:            newMU,
+		addressList:   addressList,
+		cachedHeaders: make([]*types.Header, 0),
+		reorgStartCh:  make(chan struct{}),
+		reorgEndCh:    make(chan struct{}),
+	}
+	return crossMsgFetcher, nil
+}
+
+func (c *CrossMsgFetcher) Start() {
+	log.Info("CrossMsgFetcher Start")
+	// fetch missing events from finalized blocks, we don't handle reorgs here
+	c.forwardFetchAndSaveMissingEvents(c.config.Confirmation)
+
+	tick := time.NewTicker(time.Duration(c.config.BlockTime) * time.Second)
+	headerTick := time.NewTicker(time.Duration(c.config.BlockTime/2) * time.Second)
+	go func() {
+		for {
+			select {
+			case <-c.reorgStartCh:
+				// create timeout here
+				timeout := time.NewTicker(300 * time.Second)
+				select {
+				case <-c.reorgEndCh:
+					log.Info("Reorg finished")
+					timeout.Stop()
+				case <-timeout.C:
+					// TODO: need to notify the on-call members to handle reorg manually
+					timeout.Stop()
+					log.Crit("Reorg timeout")
+				}
+			case <-c.ctx.Done():
+				tick.Stop()
+				return
+			case <-tick.C:
+				c.mu.Lock()
+				c.forwardFetchAndSaveMissingEvents(0)
+				c.mu.Unlock()
+			}
+		}
+	}()
+
+	go func() {
+		for {
+			select {
+			case <-c.ctx.Done():
+				headerTick.Stop()
+				return
+			case <-headerTick.C:
+				c.fetchMissingLatestHeaders()
+			}
+		}
+	}()
+}
+
+func (c *CrossMsgFetcher) Stop() {
+	c.db.Close()
+	log.Info("CrossMsgFetcher Stop")
+}
+
+// forwardFetchAndSaveMissingEvents will fetch all events from the latest processed height to the latest block number.
+func (c *CrossMsgFetcher) forwardFetchAndSaveMissingEvents(confirmation uint64) {
+	// if we fetch to the latest block, shall not exceed cachedHeaders
+	var number uint64
+	var err error
+	if len(c.cachedHeaders) != 0 && confirmation <= 0 {
+		number = c.cachedHeaders[len(c.cachedHeaders)-1].Number.Uint64() - 1
+	} else {
+		number, err = utils.GetSafeBlockNumber(c.ctx, c.client, confirmation)
+		if err != nil {
+			log.Error(fmt.Sprintf("%s: can not get the safe block number", c.worker.Name), "err", err)
+			return
+		}
+	}
+	if reflect2.IsNil(c.worker.G) || reflect2.IsNil(c.worker.F) {
+		log.Error(fmt.Sprintf("%s: invalid get/fetch function", c.worker.Name))
+		return
+	}
+	processed_height, err := c.worker.G(c.db)
+	if err != nil {
+		log.Error(fmt.Sprintf("%s: can not get latest processed block height", c.worker.Name))
+	}
+	log.Info(fmt.Sprintf("%s: ", c.worker.Name), "height", processed_height)
+	if processed_height <= 0 || processed_height < int64(c.config.StartHeight) {
+		processed_height = int64(c.config.StartHeight)
+	} else {
+		processed_height += 1
+	}
+	for n := processed_height; n <= int64(number); n += FETCH_LIMIT {
+		iter_end := n + FETCH_LIMIT - 1
+		if iter_end > int64(number) {
+			iter_end = int64(number)
+		}
+		err := c.worker.F(c.ctx, c.client, c.db, n, iter_end, c.addressList)
+		if err != nil {
+			log.Error(fmt.Sprintf("%s: failed!", c.worker.Name), "err", err)
+			break
+		}
+	}
+}
+
+func (c *CrossMsgFetcher) fetchMissingLatestHeaders() {
+	var start int64
+	number, err := c.client.BlockNumber(c.ctx)
+	if err != nil {
+		log.Error("fetchMissingLatestHeaders(): can not get the latest block number", "err", err)
+		return
+	}
+
+	if len(c.cachedHeaders) > 0 {
+		start = c.cachedHeaders[len(c.cachedHeaders)-1].Number.Int64() + 1
+	} else {
+		start = int64(number - c.config.Confirmation)
+	}
+	for i := start; i <= int64(number); i++ {
+		select {
+		case <-c.ctx.Done():
+			close(c.reorgStartCh)
+			close(c.reorgEndCh)
+			return
+		default:
+			header, err := c.client.HeaderByNumber(c.ctx, big.NewInt(int64(i)))
+			if err != nil {
+				log.Error("failed to get latest header", "err", err)
+				return
+			}
+			if len(c.cachedHeaders) == 0 {
+				c.cachedHeaders = MergeAddIntoHeaderList(c.cachedHeaders, []*types.Header{header}, int(c.config.Confirmation))
+				return
+			}
+			//check if the fetched header is child from the last cached header
+			if IsParentAndChild(c.cachedHeaders[len(c.cachedHeaders)-1], header) {
+				c.cachedHeaders = MergeAddIntoHeaderList(c.cachedHeaders, []*types.Header{header}, int(c.config.Confirmation))
+				log.Debug("fetched block into cache", "height", header.Number, "parent hash", header.ParentHash.Hex(), "block hash", c.cachedHeaders[len(c.cachedHeaders)-1].Hash().Hex(), "len", len(c.cachedHeaders))
+				continue
+			}
+			// reorg happened
+			log.Warn("Reorg happened", "height", header.Number, "parent hash", header.ParentHash.Hex(), "last cached hash", c.cachedHeaders[len(c.cachedHeaders)-1].Hash().Hex(), "last cached height", c.cachedHeaders[len(c.cachedHeaders)-1].Number)
+			c.reorgStartCh <- struct{}{}
+			// waiting here if there is fetcher running
+			c.mu.Lock()
+			index, ok, validHeaders := BackwardFindReorgBlock(c.ctx, c.cachedHeaders, c.client, header)
+			if !ok {
+				log.Error("Reorg happended too earlier than cached headers", "reorg height", header.Number)
+				num, err := utils.GetSafeBlockNumber(c.ctx, c.client, c.config.Confirmation)
+				if err != nil {
+					log.Crit("Can not get safe number during reorg, quit the process", "err", err)
+				}
+				// clear all our saved data, because no data is safe now
+				c.reorgHandling(c.ctx, int64(num), c.db)
+				c.cachedHeaders = c.cachedHeaders[:0]
+				c.mu.Unlock()
+				c.reorgEndCh <- struct{}{}
+				return
+			}
+			c.reorgHandling(c.ctx, c.cachedHeaders[index].Number.Int64(), c.db)
+			c.cachedHeaders = c.cachedHeaders[:index+1]
+			c.cachedHeaders = MergeAddIntoHeaderList(c.cachedHeaders, validHeaders, int(c.config.Confirmation))
+			c.mu.Unlock()
+			c.reorgEndCh <- struct{}{}
+		}
+	}
+
+}

bridge-history-api/cross_msg/fetch_missing_event.go

@@ -0,0 +1,489 @@
+package cross_msg
+
+import (
+	"context"
+	"math/big"
+
+	geth "github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/jmoiron/sqlx"
+
+	backendabi "bridge-history-api/abi"
+	"bridge-history-api/db"
+	"bridge-history-api/db/orm"
+	"bridge-history-api/utils"
+)
+
+// Todo : read from config
+var (
+	// the number of blocks fetch per round
+	FETCH_LIMIT = int64(3000)
+)
+
+// FetchAndSave is a function type that fetches events from blockchain and saves them to database
+type FetchAndSave func(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addressList []common.Address) error
+
+// GetLatestProcessed is a function type that gets the latest processed block height from database
+type GetLatestProcessed func(db db.OrmFactory) (int64, error)
+type UpdateXHash func(ctx context.Context)
+
+type FetchEventWorker struct {
+	F    FetchAndSave
+	G    GetLatestProcessed
+	Name string
+}
+
+type msgHashWrapper struct {
+	msgHash common.Hash
+	txHash  common.Hash
+}
+
+func GetLatestL1ProcessedHeight(db db.OrmFactory) (int64, error) {
+	crossHeight, err := db.GetLatestL1ProcessedHeight()
+	if err != nil {
+		log.Error("failed to get L1 cross message processed height: ", "err", err)
+		return 0, err
+	}
+	relayedHeight, err := db.GetLatestRelayedHeightOnL1()
+	if err != nil {
+		log.Error("failed to get L1 relayed message processed height: ", "err", err)
+		return 0, err
+	}
+	if crossHeight > relayedHeight {
+		return crossHeight, nil
+	} else {
+		return relayedHeight, nil
+	}
+}
+
+func GetLatestL2ProcessedHeight(db db.OrmFactory) (int64, error) {
+	crossHeight, err := db.GetLatestL2ProcessedHeight()
+	if err != nil {
+		log.Error("failed to get L2 cross message processed height", "err", err)
+		return 0, err
+	}
+	relayedHeight, err := db.GetLatestRelayedHeightFromL2()
+	if err != nil {
+		log.Error("failed to get L2 relayed message processed height", "err", err)
+		return 0, err
+	}
+	if crossHeight > relayedHeight {
+		return crossHeight, nil
+	} else {
+		return relayedHeight, nil
+	}
+}
+
+func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addrList []common.Address) error {
+
+	query := geth.FilterQuery{
+		FromBlock: big.NewInt(from), // inclusive
+		ToBlock:   big.NewInt(to),   // inclusive
+		Addresses: addrList,
+		Topics:    make([][]common.Hash, 1),
+	}
+	query.Topics[0] = make([]common.Hash, 7)
+	query.Topics[0][0] = backendabi.L1DepositETHSig
+	query.Topics[0][1] = backendabi.L1DepositERC20Sig
+	query.Topics[0][2] = backendabi.L1RelayedMessageEventSignature
+	query.Topics[0][3] = backendabi.L1SentMessageEventSignature
+	query.Topics[0][4] = backendabi.L1DepositERC721Sig
+	query.Topics[0][5] = backendabi.L1DepositERC1155Sig
+	query.Topics[0][6] = backendabi.L1DepositWETHSig
+
+	logs, err := client.FilterLogs(ctx, query)
+	if err != nil {
+		log.Warn("Failed to get l1 event logs", "err", err)
+		return err
+	}
+	depositL1CrossMsgs, msgHashes, relayedMsg, err := parseBackendL1EventLogs(logs)
+	if err != nil {
+		log.Error("l1FetchAndSaveEvents: Failed to parse cross msg event logs", "err", err)
+		return err
+	}
+	dbTx, err := database.Beginx()
+	if err != nil {
+		log.Error("l2FetchAndSaveEvents: Failed to begin db transaction", "err", err)
+		return err
+	}
+	err = database.BatchInsertL1CrossMsgDBTx(dbTx, depositL1CrossMsgs)
+	if err != nil {
+		log.Error("l1FetchAndSaveEvents: Failed to insert cross msg event logs", "err", err)
+		return err
+	}
+
+	err = database.BatchInsertRelayedMsgDBTx(dbTx, relayedMsg)
+	if err != nil {
+		log.Error("l1FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
+		return err
+	}
+	err = updateL1CrossMsgMsgHash(ctx, dbTx, database, msgHashes)
+	if err != nil {
+		log.Error("l1FetchAndSaveEvents: Failed to update msgHash in L1 cross msg", "err", err)
+		return err
+	}
+	err = dbTx.Commit()
+	if err != nil {
+		// if we can not insert into DB, there must something wrong, need a on-call member handle the dababase manually
+		log.Crit("l1FetchAndSaveEvents: Failed to commit db transaction", "err", err)
+	}
+
+	return nil
+}
+
+func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addrList []common.Address) error {
+	query := geth.FilterQuery{
+		FromBlock: big.NewInt(from), // inclusive
+		ToBlock:   big.NewInt(to),   // inclusive
+		Addresses: addrList,
+		Topics:    make([][]common.Hash, 1),
+	}
+	query.Topics[0] = make([]common.Hash, 7)
+	query.Topics[0][0] = backendabi.L2WithdrawETHSig
+	query.Topics[0][1] = backendabi.L2WithdrawERC20Sig
+	query.Topics[0][2] = backendabi.L2RelayedMessageEventSignature
+	query.Topics[0][3] = backendabi.L2SentMessageEventSignature
+	query.Topics[0][4] = backendabi.L2WithdrawERC721Sig
+	query.Topics[0][5] = backendabi.L2WithdrawERC1155Sig
+	query.Topics[0][6] = backendabi.L2WithdrawWETHSig
+
+	logs, err := client.FilterLogs(ctx, query)
+	if err != nil {
+		log.Warn("Failed to get l2 event logs", "err", err)
+		return err
+	}
+	depositL2CrossMsgs, msgHashes, relayedMsg, err := parseBackendL2EventLogs(logs)
+	if err != nil {
+		log.Error("l2FetchAndSaveEvents: Failed to parse cross msg event logs", "err", err)
+		return err
+	}
+	dbTx, err := database.Beginx()
+	if err != nil {
+		log.Error("l2FetchAndSaveEvents: Failed to begin db transaction", "err", err)
+		return err
+	}
+	err = database.BatchInsertL2CrossMsgDBTx(dbTx, depositL2CrossMsgs)
+	if err != nil {
+		log.Error("l2FetchAndSaveEvents: Failed to insert cross msg event logs", "err", err)
+		return err
+	}
+
+	err = database.BatchInsertRelayedMsgDBTx(dbTx, relayedMsg)
+	if err != nil {
+		log.Error("l2FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
+		return err
+	}
+	err = updateL2CrossMsgMsgHash(ctx, dbTx, database, msgHashes)
+	if err != nil {
+		log.Error("l2FetchAndSaveEvents: Failed to update msgHash in L2 cross msg", "err", err)
+		return err
+	}
+	err = dbTx.Commit()
+	if err != nil {
+		// if we can not insert into DB, there must something wrong, need a on-call member handle the dababase manually
+		log.Crit("l2FetchAndSaveEvents: Failed to commit db transaction", "err", err)
+	}
+
+	return nil
+}
+
+func parseBackendL1EventLogs(logs []types.Log) ([]*orm.L1CrossMsg, []msgHashWrapper, []*orm.RelayedMsg, error) {
+	// Need use contract abi to parse event Log
+	// Can only be tested after we have our contracts set up
+
+	var l1CrossMsg []*orm.L1CrossMsg
+	var relayedMsgs []*orm.RelayedMsg
+	var msgHashes []msgHashWrapper
+	for _, vlog := range logs {
+		switch vlog.Topics[0] {
+		case backendabi.L1DepositETHSig:
+			event := backendabi.DepositETH{}
+			err := utils.UnpackLog(backendabi.L1ETHGatewayABI, &event, "DepositETH", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositETH event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l1CrossMsg = append(l1CrossMsg, &orm.L1CrossMsg{
+				Height:     vlog.BlockNumber,
+				Sender:     event.From.String(),
+				Target:     event.To.String(),
+				Amount:     event.Amount.String(),
+				Asset:      int(orm.ETH),
+				Layer1Hash: vlog.TxHash.Hex(),
+			})
+		case backendabi.L1DepositWETHSig:
+			event := backendabi.ERC20MessageEvent{}
+			err := utils.UnpackLog(backendabi.L1WETHGatewayABI, &event, "DepositERC20", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositWETH event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l1CrossMsg = append(l1CrossMsg, &orm.L1CrossMsg{
+				Height:     vlog.BlockNumber,
+				Sender:     event.From.String(),
+				Target:     event.To.String(),
+				Amount:     event.Amount.String(),
+				Asset:      int(orm.WETH),
+				Layer1Hash: vlog.TxHash.Hex(),
+			})
+		case backendabi.L1DepositERC20Sig:
+			event := backendabi.ERC20MessageEvent{}
+			err := utils.UnpackLog(backendabi.L1StandardERC20GatewayABI, &event, "DepositERC20", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositERC20 event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l1CrossMsg = append(l1CrossMsg, &orm.L1CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Amount:      event.Amount.String(),
+				Asset:       int(orm.ERC20),
+				Layer1Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+			})
+		case backendabi.L1DepositCustomERC20Sig:
+			event := backendabi.ERC20MessageEvent{}
+			err := utils.UnpackLog(backendabi.L1CustomERC20GatewayABI, &event, "DepositERC20", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositCustomERC20 event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l1CrossMsg = append(l1CrossMsg, &orm.L1CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Amount:      event.Amount.String(),
+				Asset:       int(orm.ERC20),
+				Layer1Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+			})
+		case backendabi.L1DepositERC721Sig:
+			event := backendabi.ERC721MessageEvent{}
+			err := utils.UnpackLog(backendabi.L1ERC721GatewayABI, &event, "DepositERC721", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositERC721 event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l1CrossMsg = append(l1CrossMsg, &orm.L1CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Asset:       int(orm.ERC721),
+				Layer1Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+				TokenID:     event.TokenID.Uint64(),
+			})
+		case backendabi.L1DepositERC1155Sig:
+			event := backendabi.ERC1155MessageEvent{}
+			err := utils.UnpackLog(backendabi.L1ERC1155GatewayABI, &event, "DepositERC1155", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositERC1155 event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l1CrossMsg = append(l1CrossMsg, &orm.L1CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Asset:       int(orm.ERC1155),
+				Layer1Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+				TokenID:     event.TokenID.Uint64(),
+				Amount:      event.Amount.String(),
+			})
+		case backendabi.L1SentMessageEventSignature:
+			event := backendabi.L1SentMessageEvent{}
+			err := utils.UnpackLog(backendabi.L1ScrollMessengerABI, &event, "SentMessage", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack SentMessage event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			msgHash := utils.ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message)
+			msgHashes = append(msgHashes, msgHashWrapper{
+				msgHash: msgHash,
+				txHash:  vlog.TxHash})
+		case backendabi.L1RelayedMessageEventSignature:
+			event := backendabi.L1RelayedMessageEvent{}
+			err := utils.UnpackLog(backendabi.L1ScrollMessengerABI, &event, "RelayedMessage", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack RelayedMessage event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
+				MsgHash:    event.MessageHash.String(),
+				Height:     vlog.BlockNumber,
+				Layer1Hash: vlog.TxHash.Hex(),
+			})
+
+		}
+
+	}
+	return l1CrossMsg, msgHashes, relayedMsgs, nil
+}
+
+func parseBackendL2EventLogs(logs []types.Log) ([]*orm.L2CrossMsg, []msgHashWrapper, []*orm.RelayedMsg, error) {
+	// Need use contract abi to parse event Log
+	// Can only be tested after we have our contracts set up
+
+	var l2CrossMsg []*orm.L2CrossMsg
+	var relayedMsgs []*orm.RelayedMsg
+	var msgHashes []msgHashWrapper
+	for _, vlog := range logs {
+		switch vlog.Topics[0] {
+		case backendabi.L2WithdrawETHSig:
+			event := backendabi.DepositETH{}
+			err := utils.UnpackLog(backendabi.L2ETHGatewayABI, &event, "WithdrawETH", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack WithdrawETH event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l2CrossMsg = append(l2CrossMsg, &orm.L2CrossMsg{
+				Height:     vlog.BlockNumber,
+				Sender:     event.From.String(),
+				Target:     event.To.String(),
+				Amount:     event.Amount.String(),
+				Asset:      int(orm.ETH),
+				Layer2Hash: vlog.TxHash.Hex(),
+			})
+		case backendabi.L2WithdrawWETHSig:
+			event := backendabi.ERC20MessageEvent{}
+			err := utils.UnpackLog(backendabi.L2WETHGatewayABI, &event, "WithdrawERC20", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack WithdrawWETH event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l2CrossMsg = append(l2CrossMsg, &orm.L2CrossMsg{
+				Height:     vlog.BlockNumber,
+				Sender:     event.From.String(),
+				Target:     event.To.String(),
+				Amount:     event.Amount.String(),
+				Asset:      int(orm.WETH),
+				Layer2Hash: vlog.TxHash.Hex(),
+			})
+		case backendabi.L2WithdrawERC20Sig:
+			event := backendabi.ERC20MessageEvent{}
+			err := utils.UnpackLog(backendabi.L2StandardERC20GatewayABI, &event, "WithdrawERC20", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack WithdrawERC20 event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l2CrossMsg = append(l2CrossMsg, &orm.L2CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Amount:      event.Amount.String(),
+				Asset:       int(orm.ERC20),
+				Layer2Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+			})
+		case backendabi.L2WithdrawCustomERC20Sig:
+			event := backendabi.ERC20MessageEvent{}
+			err := utils.UnpackLog(backendabi.L2CustomERC20GatewayABI, &event, "WithdrawERC20", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositCustomERC20 event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l2CrossMsg = append(l2CrossMsg, &orm.L2CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Amount:      event.Amount.String(),
+				Asset:       int(orm.ERC20),
+				Layer2Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+			})
+		case backendabi.L2WithdrawERC721Sig:
+			event := backendabi.ERC721MessageEvent{}
+			err := utils.UnpackLog(backendabi.L2ERC721GatewayABI, &event, "WithdrawERC721", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack WithdrawERC721 event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l2CrossMsg = append(l2CrossMsg, &orm.L2CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Asset:       int(orm.ERC721),
+				Layer2Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+				TokenID:     event.TokenID.Uint64(),
+			})
+		case backendabi.L2WithdrawERC1155Sig:
+			event := backendabi.ERC1155MessageEvent{}
+			err := utils.UnpackLog(backendabi.L2ERC1155GatewayABI, &event, "WithdrawERC1155", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack WithdrawERC1155 event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l2CrossMsg = append(l2CrossMsg, &orm.L2CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Asset:       int(orm.ERC1155),
+				Layer2Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+				TokenID:     event.TokenID.Uint64(),
+				Amount:      event.Amount.String(),
+			})
+		case backendabi.L2SentMessageEventSignature:
+			event := backendabi.L2SentMessageEvent{}
+			err := utils.UnpackLog(backendabi.L2ScrollMessengerABI, &event, "SentMessage", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack SentMessage event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, err
+			}
+			msgHash := utils.ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message)
+			msgHashes = append(msgHashes, msgHashWrapper{
+				msgHash: msgHash,
+				txHash:  vlog.TxHash})
+		case backendabi.L2RelayedMessageEventSignature:
+			event := backendabi.L2RelayedMessageEvent{}
+			err := utils.UnpackLog(backendabi.L2ScrollMessengerABI, &event, "RelayedMessage", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack RelayedMessage event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, err
+			}
+			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
+				MsgHash:    event.MessageHash.String(),
+				Height:     vlog.BlockNumber,
+				Layer2Hash: vlog.TxHash.Hex(),
+			})
+
+		}
+
+	}
+	return l2CrossMsg, msgHashes, relayedMsgs, nil
+}
+
+func updateL1CrossMsgMsgHash(ctx context.Context, dbTx *sqlx.Tx, database db.OrmFactory, msgHashes []msgHashWrapper) error {
+	for _, msgHash := range msgHashes {
+		err := database.UpdateL1CrossMsgHashDBTx(ctx, dbTx, msgHash.txHash, msgHash.msgHash)
+		if err != nil {
+			log.Error("updateL1CrossMsgMsgHash: can not update layer1 cross msg MsgHash", "layer1 hash", msgHash.txHash, "err", err)
+			continue
+		}
+	}
+	return nil
+}
+
+func updateL2CrossMsgMsgHash(ctx context.Context, dbTx *sqlx.Tx, database db.OrmFactory, msgHashes []msgHashWrapper) error {
+	for _, msgHash := range msgHashes {
+		err := database.UpdateL2CrossMsgHashDBTx(ctx, dbTx, msgHash.txHash, msgHash.msgHash)
+		if err != nil {
+			log.Error("updateL2CrossMsgMsgHash: can not update layer2 cross msg MsgHash", "layer2 hash", msgHash.txHash, "err", err)
+			continue
+		}
+	}
+	return nil
+}

bridge-history-api/cross_msg/msg_fetcher_test.go

@@ -0,0 +1,64 @@
+package cross_msg_test
+
+import (
+	"bridge-history-api/cross_msg"
+	"crypto/rand"
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMergeIntoList(t *testing.T) {
+	headers, err := generateHeaders(64)
+	assert.NoError(t, err)
+	assert.Equal(t, headers[0].Hash(), headers[1].ParentHash)
+	headers2, err := generateHeaders(18)
+	assert.NoError(t, err)
+	result := cross_msg.MergeAddIntoHeaderList(headers, headers2, 64)
+	assert.Equal(t, 64, len(result))
+	assert.Equal(t, headers2[len(headers2)-1], result[len(result)-1])
+	assert.NotEqual(t, headers[0], result[0])
+}
+
+func generateHeaders(amount int) ([]*types.Header, error) {
+	headers := make([]*types.Header, amount)
+
+	for i := 0; i < amount; i++ {
+		var parentHash common.Hash
+		if i > 0 {
+			parentHash = headers[i-1].Hash()
+		}
+		nonce, err := rand.Int(rand.Reader, big.NewInt(1<<63-1))
+		if err != nil {
+			return nil, err
+		}
+		difficulty := big.NewInt(131072)
+
+		header := &types.Header{
+			ParentHash:  parentHash,
+			UncleHash:   types.EmptyUncleHash,
+			Coinbase:    common.Address{},
+			Root:        common.Hash{},
+			TxHash:      types.EmptyRootHash,
+			ReceiptHash: types.EmptyRootHash,
+			Bloom:       types.Bloom{},
+			Difficulty:  difficulty,
+			Number:      big.NewInt(int64(i)),
+			GasLimit:    5000000,
+			GasUsed:     0,
+			Time:        uint64(i * 15),
+			Extra:       []byte{},
+			MixDigest:   common.Hash{},
+			Nonce:       types.EncodeNonce(uint64(nonce.Uint64())),
+		}
+		headers[i] = header
+	}
+
+	return headers, nil
+}
+
+// TODO: add more test cases
+// func TestReorg(t *testing.T)

bridge-history-api/cross_msg/reorg_handle.go

@@ -0,0 +1,93 @@
+package cross_msg
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+
+	"bridge-history-api/db"
+)
+
+type ReorgHandling func(ctx context.Context, reorgHeight int64, db db.OrmFactory)
+
+func reverseArray(arr []*types.Header) []*types.Header {
+	for i := 0; i < len(arr)/2; i++ {
+		j := len(arr) - i - 1
+		arr[i], arr[j] = arr[j], arr[i]
+	}
+	return arr
+}
+
+func IsParentAndChild(parentHeader *types.Header, header *types.Header) bool {
+	return header.ParentHash == parentHeader.Hash()
+}
+
+func MergeAddIntoHeaderList(baseArr, extraArr []*types.Header, maxLength int) []*types.Header {
+	mergedArr := append(baseArr, extraArr...)
+	if len(mergedArr) <= maxLength {
+		return mergedArr
+	}
+
+	startIndex := len(mergedArr) - maxLength
+	return mergedArr[startIndex:]
+}
+
+func BackwardFindReorgBlock(ctx context.Context, headers []*types.Header, client *ethclient.Client, header *types.Header) (int, bool, []*types.Header) {
+	maxStep := len(headers)
+	backwardHeaderList := []*types.Header{header}
+	for iterRound := 0; iterRound < maxStep; iterRound++ {
+		header, err := client.HeaderByHash(ctx, header.ParentHash)
+		if err != nil {
+			log.Error("BackwardFindReorgBlock failed", "error", err)
+			return -1, false, nil
+		}
+		backwardHeaderList = append(backwardHeaderList, header)
+		for j := len(headers) - 1; j >= 0; j-- {
+			if IsParentAndChild(headers[j], header) {
+				backwardHeaderList = reverseArray(backwardHeaderList)
+				return j, true, backwardHeaderList
+			}
+		}
+	}
+	return -1, false, nil
+}
+
+func L1ReorgHandling(ctx context.Context, reorgHeight int64, db db.OrmFactory) {
+	dbTx, err := db.Beginx()
+	if err != nil {
+		log.Crit("begin db tx failed", "err", err)
+	}
+	err = db.DeleteL1CrossMsgAfterHeightDBTx(dbTx, reorgHeight)
+	if err != nil {
+		log.Crit("delete l1 cross msg from height", "height", reorgHeight, "err", err)
+	}
+	err = db.DeleteL1RelayedHashFromHeightDBTx(dbTx, reorgHeight)
+	if err != nil {
+		log.Crit("delete l1 relayed hash from height", "height", reorgHeight, "err", err)
+	}
+	err = dbTx.Commit()
+	if err != nil {
+		log.Crit("commit tx failed", "err", err)
+	}
+}
+
+func L2ReorgHandling(ctx context.Context, reorgHeight int64, db db.OrmFactory) {
+	dbTx, err := db.Beginx()
+	if err != nil {
+		log.Crit("begin db tx failed", "err", err)
+	}
+	err = db.DeleteL2CrossMsgFromHeightDBTx(dbTx, reorgHeight)
+	if err != nil {
+		log.Crit("delete l2 cross msg from height", "height", reorgHeight, "err", err)
+	}
+	err = db.DeleteL2RelayedHashFromHeightDBTx(dbTx, reorgHeight)
+	if err != nil {
+		log.Crit("delete l2 relayed hash from height", "height", reorgHeight, "err", err)
+	}
+	err = dbTx.Commit()
+	if err != nil {
+		log.Crit("commit tx failed", "err", err)
+	}
+}

bridge-history-api/db/migrate/migrate.go

@@ -0,0 +1,61 @@
+package migrate
+
+import (
+	"database/sql"
+	"embed"
+	"os"
+	"strconv"
+
+	"github.com/pressly/goose/v3"
+)
+
+//go:embed migrations/*.sql
+var embedMigrations embed.FS
+
+// MigrationsDir migration dir
+const MigrationsDir string = "migrations"
+
+func init() {
+	goose.SetBaseFS(embedMigrations)
+	goose.SetSequential(true)
+	goose.SetTableName("bridge_history_migrations")
+
+	verbose, _ := strconv.ParseBool(os.Getenv("LOG_SQL_MIGRATIONS"))
+	goose.SetVerbose(verbose)
+}
+
+// Migrate migrate db
+func Migrate(db *sql.DB) error {
+	return goose.Up(db, MigrationsDir, goose.WithAllowMissing())
+}
+
+// Rollback rollback to the given version
+func Rollback(db *sql.DB, version *int64) error {
+	if version != nil {
+		return goose.DownTo(db, MigrationsDir, *version)
+	}
+	return goose.Down(db, MigrationsDir)
+}
+
+// ResetDB clean and migrate db.
+func ResetDB(db *sql.DB) error {
+	if err := Rollback(db, new(int64)); err != nil {
+		return err
+	}
+	return Migrate(db)
+}
+
+// Current get current version
+func Current(db *sql.DB) (int64, error) {
+	return goose.GetDBVersion(db)
+}
+
+// Status is normal or not
+func Status(db *sql.DB) error {
+	return goose.Version(db, MigrationsDir)
+}
+
+// Create a new migration folder
+func Create(db *sql.DB, name, migrationType string) error {
+	return goose.Create(db, MigrationsDir, name, migrationType)
+}

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

@@ -0,0 +1,47 @@
+-- +goose Up
+-- +goose StatementBegin
+create table l1_cross_message
+(
+    msg_hash     VARCHAR DEFAULT '',
+    height       BIGINT  NOT NULL,
+    sender       VARCHAR NOT NULL,
+    target       VARCHAR NOT NULL,
+    amount       VARCHAR NOT NULL,
+    layer1_hash  VARCHAR NOT NULL,
+    layer2_hash  VARCHAR DEFAULT '',
+    layer1_token VARCHAR DEFAULT '',
+    layer2_token VARCHAR DEFAULT '',
+    token_id     BIGINT DEFAULT 0,
+    asset        SMALLINT  DEFAULT 1,
+    created_time TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_time TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+comment
+on column l1_cross_message.asset is 'ETH, ERC20, ERC721, ERC1155, WETH';
+
+create unique index l1_cross_message_hash_uindex
+on l1_cross_message (layer1_hash);
+
+create index l1_cross_message_height_index
+    on l1_cross_message (height);
+
+CREATE OR REPLACE FUNCTION update_timestamp()
+RETURNS TRIGGER AS $$
+BEGIN
+   NEW.updated_time = CURRENT_TIMESTAMP;
+   RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+CREATE TRIGGER update_timestamp BEFORE UPDATE
+ON l1_cross_message FOR EACH ROW EXECUTE PROCEDURE
+update_timestamp();
+
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+drop table if exists l1_cross_message;
+-- +goose StatementEnd

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

@@ -0,0 +1,46 @@
+-- +goose Up
+-- +goose StatementBegin
+create table l2_cross_message
+(
+    msg_hash     VARCHAR DEFAULT '',
+    height       BIGINT  NOT NULL,
+    sender       VARCHAR NOT NULL,
+    target       VARCHAR NOT NULL,
+    amount       VARCHAR NOT NULL,
+    layer1_hash  VARCHAR DEFAULT '',
+    layer2_hash  VARCHAR NOT NULL,
+    layer1_token VARCHAR DEFAULT '',
+    layer2_token VARCHAR DEFAULT '',
+    token_id     BIGINT DEFAULT 0,
+    asset        SMALLINT  DEFAULT 1,
+    created_time TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_time TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+comment
+on column l2_cross_message.asset is 'ETH, ERC20, ERC721, ERC1155, WETH';
+
+create unique index l2_cross_message_hash_uindex
+on l2_cross_message (layer2_hash);
+
+create index l2_cross_message_height_index
+    on l2_cross_message (height);
+
+CREATE OR REPLACE FUNCTION update_timestamp()
+RETURNS TRIGGER AS $$
+BEGIN
+   NEW.updated_time = CURRENT_TIMESTAMP;
+   RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+CREATE TRIGGER update_timestamp BEFORE UPDATE
+ON l2_cross_message FOR EACH ROW EXECUTE PROCEDURE
+update_timestamp();
+
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+drop table if exists l2_cross_message;
+-- +goose StatementEnd

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

@@ -0,0 +1,34 @@
+-- +goose Up
+-- +goose StatementBegin
+create table relayed_msg
+(
+    msg_hash     VARCHAR NOT NULL,
+    height       BIGINT NOT NULL,
+    layer1_hash  VARCHAR DEFAULT '',
+    layer2_hash  VARCHAR DEFAULT '',
+    created_time TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_time TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+create unique index relayed_msg_hash_uindex
+on relayed_msg (msg_hash);
+
+CREATE OR REPLACE FUNCTION update_timestamp()
+RETURNS TRIGGER AS $$
+BEGIN
+   NEW.updated_time = CURRENT_TIMESTAMP;
+   RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+CREATE TRIGGER update_timestamp BEFORE UPDATE
+ON relayed_msg FOR EACH ROW EXECUTE PROCEDURE
+update_timestamp();
+
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+drop table if exists relayed_msg;
+-- +goose StatementEnd

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

@@ -0,0 +1,111 @@
+package orm
+
+import (
+	"context"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/jmoiron/sqlx"
+)
+
+type AssetType int
+
+func (a AssetType) String() string {
+	switch a {
+	case ETH:
+		return "ETH"
+	case ERC20:
+		return "ERC20"
+	case ERC1155:
+		return "ERC1155"
+	case ERC721:
+		return "ERC721"
+	case WETH:
+		return "WETH"
+	}
+	return "Unknown Asset Type"
+}
+
+const (
+	ETH AssetType = iota
+	ERC20
+	ERC721
+	ERC1155
+	WETH
+)
+
+// L1CrossMsg represents a cross message from layer 1 to layer 2
+type L1CrossMsg struct {
+	MsgHash     string     `json:"msg_hash" db:"msg_hash"`
+	Height      uint64     `json:"height" db:"height"`
+	Sender      string     `json:"sender" db:"sender"`
+	Target      string     `json:"target" db:"target"`
+	Amount      string     `json:"amount" db:"amount"`
+	Layer1Hash  string     `json:"layer1_hash" db:"layer1_hash"`
+	Layer2Hash  string     `json:"layer2_hash" db:"layer2_hash"`
+	Layer1Token string     `json:"layer1_token" db:"layer1_token"`
+	Layer2Token string     `json:"layer2_token" db:"layer2_token"`
+	TokenID     uint64     `json:"token_id" db:"token_id"`
+	CreatedTime *time.Time `json:"created_time" db:"created_time"`
+	Asset       int        `json:"asset" db:"asset"`
+	UpdatedTime *time.Time `json:"updated_time" db:"updated_time"`
+}
+
+// L2CrossMsg represents a cross message from layer 2 to layer 1
+type L2CrossMsg struct {
+	MsgHash     string     `json:"msg_hash" db:"msg_hash"`
+	Height      uint64     `json:"height" db:"height"`
+	Sender      string     `json:"sender" db:"sender"`
+	Target      string     `json:"target" db:"target"`
+	Amount      string     `json:"value" db:"amount"`
+	Layer1Hash  string     `json:"layer1_hash" db:"layer1_hash"`
+	Layer2Hash  string     `json:"layer2_hash" db:"layer2_hash"`
+	Layer1Token string     `json:"layer1_token" db:"layer1_token"`
+	Layer2Token string     `json:"layer2_token" db:"layer2_token"`
+	TokenID     uint64     `json:"token_id" db:"token_id"`
+	CreatedTime *time.Time `json:"created_time" db:"created_time"`
+	Asset       int        `json:"asset" db:"asset"`
+	UpdatedTime *time.Time `json:"updated_time" db:"updated_time"`
+}
+
+type RelayedMsg struct {
+	MsgHash    string `json:"msg_hash" db:"msg_hash"`
+	Height     uint64 `json:"height" db:"height"`
+	Layer1Hash string `json:"layer1_hash" db:"layer1_hash"`
+	Layer2Hash string `json:"layer2_hash" db:"layer2_hash"`
+}
+
+// L1CrossMsgOrm provides operations on l1_cross_message table
+type L1CrossMsgOrm interface {
+	GetL1CrossMsgByHash(l1Hash common.Hash) (*L1CrossMsg, error)
+	GetL1CrossMsgsByAddress(sender common.Address) ([]*L1CrossMsg, error)
+	BatchInsertL1CrossMsgDBTx(dbTx *sqlx.Tx, messages []*L1CrossMsg) error
+	// UpdateL1CrossMsgHash invoked when SentMessage event is received
+	UpdateL1CrossMsgHashDBTx(ctx context.Context, dbTx *sqlx.Tx, l1Hash, msgHash common.Hash) error
+	UpdateL1CrossMsgHash(ctx context.Context, l1Hash, msgHash common.Hash) error
+	GetLatestL1ProcessedHeight() (int64, error)
+	DeleteL1CrossMsgAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
+	GetL1CrossMsgsByAddressWithOffset(sender common.Address, offset int64, limit int64) ([]*L1CrossMsg, error)
+}
+
+// L2CrossMsgOrm provides operations on l2_cross_message table
+type L2CrossMsgOrm interface {
+	GetL2CrossMsgByHash(l2Hash common.Hash) (*L2CrossMsg, error)
+	GetL2CrossMsgByAddress(sender common.Address) ([]*L2CrossMsg, error)
+	BatchInsertL2CrossMsgDBTx(dbTx *sqlx.Tx, messages []*L2CrossMsg) error
+	// UpdateL2CrossMsgHash invoked when SentMessage event is received
+	UpdateL2CrossMsgHashDBTx(ctx context.Context, dbTx *sqlx.Tx, l2Hash, msgHash common.Hash) error
+	UpdateL2CrossMsgHash(ctx context.Context, l2Hash, msgHash common.Hash) error
+	GetLatestL2ProcessedHeight() (int64, error)
+	GetL2CrossMsgsByAddressWithOffset(sender common.Address, offset int64, limit int64) ([]*L2CrossMsg, error)
+	DeleteL2CrossMsgFromHeightDBTx(dbTx *sqlx.Tx, height int64) error
+}
+
+type RelayedMsgOrm interface {
+	BatchInsertRelayedMsgDBTx(dbTx *sqlx.Tx, messages []*RelayedMsg) error
+	GetRelayedMsgByHash(msg_hash string) (*RelayedMsg, error)
+	GetLatestRelayedHeightOnL1() (int64, error)
+	GetLatestRelayedHeightFromL2() (int64, error)
+	DeleteL1RelayedHashFromHeightDBTx(dbTx *sqlx.Tx, height int64) error
+	DeleteL2RelayedHashFromHeightDBTx(dbTx *sqlx.Tx, height int64) error
+}

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

@@ -0,0 +1,137 @@
+package orm
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/jmoiron/sqlx"
+)
+
+type l1CrossMsgOrm struct {
+	db *sqlx.DB
+}
+
+// NewL1CrossMsgOrm create an NewL1CrossMsgOrm instance
+func NewL1CrossMsgOrm(db *sqlx.DB) L1CrossMsgOrm {
+	return &l1CrossMsgOrm{db: db}
+}
+
+func (l *l1CrossMsgOrm) GetL1CrossMsgByHash(l1Hash common.Hash) (*L1CrossMsg, error) {
+	result := &L1CrossMsg{}
+	row := l.db.QueryRowx(`SELECT * FROM l1_cross_message WHERE layer1_hash = $1;`, l1Hash.String())
+	if err := row.StructScan(result); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return result, nil
+}
+
+func (l *l1CrossMsgOrm) GetL1CrossMsgsByAddressWithOffset(sender common.Address, offset int64, limit int64) ([]*L1CrossMsg, error) {
+	para := sender.String()
+	var results []*L1CrossMsg
+	rows, err := l.db.Queryx(`SELECT * FROM l1_cross_message WHERE sender = $1 ORDER BY height DESC LIMIT $2 OFFSET $3;`, para, limit, offset)
+	for rows.Next() {
+		msg := &L1CrossMsg{}
+		if err = rows.StructScan(msg); err != nil {
+			break
+		}
+		results = append(results, msg)
+	}
+	if len(results) == 0 && errors.Is(err, sql.ErrNoRows) {
+	} else if err != nil {
+		return nil, err
+	}
+	return results, nil
+}
+
+// GetL1CrossMsgsByAddress returns all layer1 cross messages under given address
+// Warning: return empty slice if no data found
+func (l *l1CrossMsgOrm) GetL1CrossMsgsByAddress(sender common.Address) ([]*L1CrossMsg, error) {
+	para := sender.String()
+	var results []*L1CrossMsg
+	rows, err := l.db.Queryx(`SELECT * FROM l1_cross_message WHERE sender = $1;`, para)
+
+	for rows.Next() {
+		msg := &L1CrossMsg{}
+		if err = rows.StructScan(msg); err != nil {
+			break
+		}
+		results = append(results, msg)
+	}
+	if len(results) == 0 && errors.Is(err, sql.ErrNoRows) {
+	} else if err != nil {
+		return nil, err
+	}
+	return results, nil
+}
+
+func (l *l1CrossMsgOrm) BatchInsertL1CrossMsgDBTx(dbTx *sqlx.Tx, messages []*L1CrossMsg) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	var err error
+	messageMaps := make([]map[string]interface{}, len(messages))
+	for i, msg := range messages {
+		messageMaps[i] = map[string]interface{}{
+			"height":       msg.Height,
+			"sender":       msg.Sender,
+			"target":       msg.Target,
+			"amount":       msg.Amount,
+			"asset":        msg.Asset,
+			"layer1_hash":  msg.Layer1Hash,
+			"layer1_token": msg.Layer1Token,
+			"layer2_token": msg.Layer2Token,
+			"token_id":     msg.TokenID,
+		}
+
+		_, err := dbTx.NamedExec(`insert into l1_cross_message(height, sender, target, asset, layer1_hash, layer1_token, layer2_token, token_id, amount) values(:height, :sender, :target, :asset, :layer1_hash, :layer1_token, :layer2_token, :token_id, :amount);`, messageMaps[i])
+		if err != nil {
+			log.Error("BatchInsertL1CrossMsgDBTx: failed to insert l1 cross msgs", "l1hashes", msg.Layer1Hash, "heights", msg.Height, "err", err)
+			break
+		}
+	}
+	return err
+}
+
+func (l *l1CrossMsgOrm) UpdateL1CrossMsgHashDBTx(ctx context.Context, dbTx *sqlx.Tx, l1Hash, msgHash common.Hash) error {
+	if _, err := dbTx.ExecContext(ctx, l.db.Rebind("update public.l1_cross_message set msg_hash = ? where layer1_hash = ?;"), msgHash.String(), l1Hash.String()); err != nil {
+		return err
+	}
+	return nil
+
+}
+
+func (l *l1CrossMsgOrm) UpdateL1CrossMsgHash(ctx context.Context, l1Hash, msgHash common.Hash) error {
+	if _, err := l.db.ExecContext(ctx, l.db.Rebind("update public.l1_cross_message set msg_hash = ? where layer1_hash = ?;"), msgHash.String(), l1Hash.String()); err != nil {
+		return err
+	}
+	return nil
+
+}
+
+func (l *l1CrossMsgOrm) GetLatestL1ProcessedHeight() (int64, error) {
+	row := l.db.QueryRowx(`SELECT MAX(height) FROM l1_cross_message;`)
+	var result sql.NullInt64
+	if err := row.Scan(&result); err != nil {
+		if err == sql.ErrNoRows || !result.Valid {
+			return -1, nil
+		}
+		return 0, err
+	}
+	if result.Valid {
+		return result.Int64, nil
+	}
+	return 0, nil
+}
+
+func (l *l1CrossMsgOrm) DeleteL1CrossMsgAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error {
+	if _, err := l.db.Exec(`DELETE FROM l1_cross_message WHERE height > $1;`, height); err != nil {
+		return err
+	}
+	return nil
+}

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

@@ -0,0 +1,141 @@
+package orm
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/jmoiron/sqlx"
+)
+
+type l2CrossMsgOrm struct {
+	db *sqlx.DB
+}
+
+// NewL2CrossMsgOrm create an NewL2CrossMsgOrm instance
+func NewL2CrossMsgOrm(db *sqlx.DB) L2CrossMsgOrm {
+	return &l2CrossMsgOrm{db: db}
+}
+
+func (l *l2CrossMsgOrm) GetL2CrossMsgByHash(l2Hash common.Hash) (*L2CrossMsg, error) {
+	result := &L2CrossMsg{}
+	row := l.db.QueryRowx(`SELECT * FROM l2_cross_message WHERE layer2_hash = $1;`, l2Hash.String())
+	if err := row.StructScan(result); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return result, nil
+}
+
+func (l *l2CrossMsgOrm) GetL2CrossMsgsByAddressWithOffset(sender common.Address, offset int64, limit int64) ([]*L2CrossMsg, error) {
+	para := sender.String()
+	var results []*L2CrossMsg
+	rows, err := l.db.Queryx(`SELECT * FROM l2_cross_message WHERE sender = $1 ORDER BY height DESC LIMIT $2 OFFSET $3;`, para, limit, offset)
+	for rows.Next() {
+		msg := &L2CrossMsg{}
+		if err = rows.StructScan(msg); err != nil {
+			break
+		}
+		results = append(results, msg)
+	}
+	if len(results) == 0 && errors.Is(err, sql.ErrNoRows) {
+	} else if err != nil {
+		return nil, err
+	}
+	return results, nil
+}
+
+// GetL2CrossMsgsByAddress returns all layer2 cross messages under given address
+// Warning: return empty slice if no data found
+func (l *l2CrossMsgOrm) GetL2CrossMsgByAddress(sender common.Address) ([]*L2CrossMsg, error) {
+	para := sender.String()
+	var results []*L2CrossMsg
+	rows, err := l.db.Queryx(`SELECT * FROM l2_cross_message WHERE sender = $1;`, para)
+
+	for rows.Next() {
+		msg := &L2CrossMsg{}
+		if err = rows.StructScan(msg); err != nil {
+			break
+		}
+		results = append(results, msg)
+	}
+	if len(results) == 0 && errors.Is(err, sql.ErrNoRows) {
+		// log.Warn("no unprocessed layer1 messages in db", "err", err)
+	} else if err != nil {
+		return nil, err
+	}
+	return results, nil
+
+}
+
+func (l *l2CrossMsgOrm) DeleteL2CrossMsgFromHeightDBTx(dbTx *sqlx.Tx, height int64) error {
+	_, err := dbTx.Exec(`delete from l2_cross_message where height > $1;`, height)
+	if err != nil {
+		log.Error("DeleteL1CrossMsgAfterHeightDBTx: failed to delete", "height", height, "err", err)
+		return err
+	}
+	return nil
+}
+
+func (l *l2CrossMsgOrm) BatchInsertL2CrossMsgDBTx(dbTx *sqlx.Tx, messages []*L2CrossMsg) error {
+	if len(messages) == 0 {
+		return nil
+	}
+
+	var err error
+	messageMaps := make([]map[string]interface{}, len(messages))
+	for i, msg := range messages {
+
+		messageMaps[i] = map[string]interface{}{
+			"height":       msg.Height,
+			"sender":       msg.Sender,
+			"target":       msg.Target,
+			"asset":        msg.Asset,
+			"layer2_hash":  msg.Layer2Hash,
+			"layer1_token": msg.Layer1Token,
+			"layer2_token": msg.Layer2Token,
+			"token_id":     msg.TokenID,
+			"amount":       msg.Amount,
+		}
+
+		_, err := dbTx.NamedExec(`insert into l2_cross_message(height, sender, target, asset, layer2_hash, layer1_token, layer2_token, token_id, amount) values(:height, :sender, :target, :asset, :layer2_hash, :layer1_token, :layer2_token, :token_id, :amount);`, messageMaps[i])
+		if err != nil {
+			log.Error("BatchInsertL2CrossMsgDBTx: failed to insert l2 cross msgs", "layer2hash", msg.Layer2Hash, "heights", msg.Height, "err", err)
+			break
+		}
+	}
+	return err
+}
+
+func (l *l2CrossMsgOrm) UpdateL2CrossMsgHashDBTx(ctx context.Context, dbTx *sqlx.Tx, l2Hash, msgHash common.Hash) error {
+	if _, err := dbTx.ExecContext(ctx, l.db.Rebind("update public.l2_cross_message set msg_hash = ? where layer2_hash = ?;"), msgHash.String(), l2Hash.String()); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (l *l2CrossMsgOrm) UpdateL2CrossMsgHash(ctx context.Context, l2Hash, msgHash common.Hash) error {
+	if _, err := l.db.ExecContext(ctx, l.db.Rebind("update public.l2_cross_message set msg_hash = ? where layer2_hash = ?;"), msgHash.String(), l2Hash.String()); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (l *l2CrossMsgOrm) GetLatestL2ProcessedHeight() (int64, error) {
+	row := l.db.QueryRowx(`SELECT MAX(height) FROM l2_cross_message WHERE layer2_hash IS NOT NULL;`)
+	var result sql.NullInt64
+	if err := row.Scan(&result); err != nil {
+		if err == sql.ErrNoRows || !result.Valid {
+			return -1, nil
+		}
+		return 0, err
+	}
+	if result.Valid {
+		return result.Int64, nil
+	}
+	return 0, nil
+}

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

@@ -0,0 +1,94 @@
+package orm
+
+import (
+	"database/sql"
+	"errors"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/jmoiron/sqlx"
+)
+
+type relayedMsgOrm struct {
+	db *sqlx.DB
+}
+
+// NewRelayedMsgOrm create an NewRelayedMsgOrm instance
+func NewRelayedMsgOrm(db *sqlx.DB) RelayedMsgOrm {
+	return &relayedMsgOrm{db: db}
+}
+
+func (l *relayedMsgOrm) BatchInsertRelayedMsgDBTx(dbTx *sqlx.Tx, messages []*RelayedMsg) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	var err error
+	messageMaps := make([]map[string]interface{}, len(messages))
+	for i, msg := range messages {
+		messageMaps[i] = map[string]interface{}{
+			"msg_hash":    msg.MsgHash,
+			"height":      msg.Height,
+			"layer1_hash": msg.Layer1Hash,
+			"layer2_hash": msg.Layer2Hash,
+		}
+
+		_, err := dbTx.NamedExec(`insert into relayed_msg(msg_hash, height, layer1_hash, layer2_hash) values(:msg_hash, :height, :layer1_hash, :layer2_hash);`, messageMaps[i])
+		if err != nil && !strings.Contains(err.Error(), "pq: duplicate key value violates unique constraint \"relayed_msg_hash_uindex") {
+			log.Error("BatchInsertRelayedMsgDBTx: failed to insert l1 cross msgs", "msg_Hashe", msg.MsgHash, "height", msg.Height, "err", err)
+			break
+		}
+	}
+	return err
+}
+
+func (l *relayedMsgOrm) GetRelayedMsgByHash(msg_hash string) (*RelayedMsg, error) {
+	result := &RelayedMsg{}
+	row := l.db.QueryRowx(`SELECT msg_hash, height, layer1_hash, layer2_hash FROM relayed_msg WHERE msg_hash = $1;`, msg_hash)
+	if err := row.StructScan(result); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return result, nil
+}
+
+func (l *relayedMsgOrm) GetLatestRelayedHeightOnL1() (int64, error) {
+	row := l.db.QueryRow(`SELECT MAX(height) FROM relayed_msg WHERE layer1_hash != '';`)
+	var result sql.NullInt64
+	if err := row.Scan(&result); err != nil {
+		if err == sql.ErrNoRows || !result.Valid {
+			return -1, nil
+		}
+		return 0, err
+	}
+	if result.Valid {
+		return result.Int64, nil
+	}
+	return 0, nil
+}
+
+func (l *relayedMsgOrm) GetLatestRelayedHeightFromL2() (int64, error) {
+	row := l.db.QueryRow(`SELECT MAX(height) FROM relayed_msg WHERE layer2_hash != '';`)
+	var result sql.NullInt64
+	if err := row.Scan(&result); err != nil {
+		if err == sql.ErrNoRows || !result.Valid {
+			return -1, nil
+		}
+		return 0, err
+	}
+	if result.Valid {
+		return result.Int64, nil
+	}
+	return 0, nil
+}
+
+func (l *relayedMsgOrm) DeleteL1RelayedHashFromHeightDBTx(dbTx *sqlx.Tx, height int64) error {
+	_, err := dbTx.Exec(`DELETE FROM relayed_msg WHERE height > $1 AND layer1_hash != '';`, height)
+	return err
+}
+
+func (l *relayedMsgOrm) DeleteL2RelayedHashFromHeightDBTx(dbTx *sqlx.Tx, height int64) error {
+	_, err := dbTx.Exec(`DELETE FROM relayed_msg WHERE height > $1 AND layer2_hash != '';`, height)
+	return err
+}

bridge-history-api/db/orm_factory.go

@@ -0,0 +1,56 @@
+package db
+
+import (
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq" //nolint:golint
+
+	"bridge-history-api/config"
+	"bridge-history-api/db/orm"
+)
+
+// OrmFactory include all ormFactory interface
+type OrmFactory interface {
+	orm.L1CrossMsgOrm
+	orm.L2CrossMsgOrm
+	orm.RelayedMsgOrm
+	GetDB() *sqlx.DB
+	Beginx() (*sqlx.Tx, error)
+	Close() error
+}
+
+type ormFactory struct {
+	orm.L1CrossMsgOrm
+	orm.L2CrossMsgOrm
+	orm.RelayedMsgOrm
+	*sqlx.DB
+}
+
+// NewOrmFactory create an ormFactory factory include all ormFactory interface
+func NewOrmFactory(cfg *config.Config) (OrmFactory, error) {
+	// Initialize sql/sqlx
+	db, err := sqlx.Open(cfg.DB.DriverName, cfg.DB.DSN)
+	if err != nil {
+		return nil, err
+	}
+
+	db.SetMaxOpenConns(cfg.DB.MaxOpenNum)
+	db.SetMaxIdleConns(cfg.DB.MaxIdleNum)
+	if err = db.Ping(); err != nil {
+		return nil, err
+	}
+
+	return &ormFactory{
+		L1CrossMsgOrm: orm.NewL1CrossMsgOrm(db),
+		L2CrossMsgOrm: orm.NewL2CrossMsgOrm(db),
+		RelayedMsgOrm: orm.NewRelayedMsgOrm(db),
+		DB:            db,
+	}, nil
+}
+
+func (o *ormFactory) GetDB() *sqlx.DB {
+	return o.DB
+}
+
+func (o *ormFactory) Beginx() (*sqlx.Tx, error) {
+	return o.DB.Beginx()
+}

bridge-history-api/go.mod

@@ -0,0 +1,146 @@
+module bridge-history-api
+
+go 1.20
+
+require (
+	github.com/ethereum/go-ethereum v1.11.6
+	github.com/jmoiron/sqlx v1.3.5
+	github.com/kataras/iris/v12 v12.2.0
+	github.com/lib/pq v1.10.7
+	github.com/mattn/go-colorable v0.1.13
+	github.com/mattn/go-isatty v0.0.18
+	github.com/modern-go/reflect2 v1.0.2
+	github.com/pressly/goose/v3 v3.7.0
+	github.com/stretchr/testify v1.8.2
+	github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa
+)
+
+require (
+	github.com/BurntSushi/toml v1.2.1 // indirect
+	github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53 // indirect
+	github.com/CloudyKit/jet/v6 v6.2.0 // indirect
+	github.com/DataDog/zstd v1.5.2 // indirect
+	github.com/Joker/jade v1.1.3 // indirect
+	github.com/Shopify/goreferrer v0.0.0-20220729165902-8cddb4f5de06 // indirect
+	github.com/VictoriaMetrics/fastcache v1.6.0 // indirect
+	github.com/andybalholm/brotli v1.0.5 // indirect
+	github.com/aymerick/douceur v0.2.0 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/blang/semver/v4 v4.0.0 // indirect
+	github.com/btcsuite/btcd v0.20.1-beta // indirect
+	github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/cockroachdb/errors v1.9.1 // indirect
+	github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect
+	github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811 // indirect
+	github.com/cockroachdb/redact v1.1.3 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/deckarep/golang-set/v2 v2.1.0 // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
+	github.com/deepmap/oapi-codegen v1.8.2 // indirect
+	github.com/docker/docker v20.10.21+incompatible // indirect
+	github.com/edsrzf/mmap-go v1.0.0 // indirect
+	github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385 // indirect
+	github.com/fatih/structs v1.1.0 // indirect
+	github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 // indirect
+	github.com/flosch/pongo2/v4 v4.0.2 // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
+	github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect
+	github.com/getsentry/sentry-go v0.18.0 // indirect
+	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/go-sql-driver/mysql v1.7.0 // indirect
+	github.com/go-stack/stack v1.8.1 // indirect
+	github.com/gobwas/httphead v0.1.0 // indirect
+	github.com/gobwas/pool v0.2.1 // indirect
+	github.com/gobwas/ws v1.1.0 // indirect
+	github.com/gofrs/flock v0.8.1 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang-jwt/jwt/v4 v4.5.0 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
+	github.com/google/uuid v1.3.0 // indirect
+	github.com/gorilla/css v1.0.0 // indirect
+	github.com/gorilla/websocket v1.5.0 // indirect
+	github.com/graph-gophers/graphql-go v1.3.0 // indirect
+	github.com/hashicorp/go-bexpr v0.1.10 // indirect
+	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
+	github.com/holiman/uint256 v1.2.2 // indirect
+	github.com/huin/goupnp v1.0.3 // indirect
+	github.com/influxdata/influxdb-client-go/v2 v2.4.0 // indirect
+	github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c // indirect
+	github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect
+	github.com/iris-contrib/go.uuid v2.0.0+incompatible // indirect
+	github.com/iris-contrib/schema v0.0.6 // indirect
+	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/kataras/blocks v0.0.7 // indirect
+	github.com/kataras/golog v0.1.8 // indirect
+	github.com/kataras/neffos v0.0.21 // indirect
+	github.com/kataras/pio v0.0.11 // indirect
+	github.com/kataras/sitemap v0.0.6 // indirect
+	github.com/kataras/tunnel v0.0.4 // indirect
+	github.com/klauspost/compress v1.16.0 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/mailgun/raymond/v2 v2.0.48 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mattn/go-runewidth v0.0.14 // indirect
+	github.com/mattn/go-sqlite3 v1.14.14 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
+	github.com/mediocregopher/radix/v3 v3.8.1 // indirect
+	github.com/microcosm-cc/bluemonday v1.0.23 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/mitchellh/pointerstructure v1.2.0 // indirect
+	github.com/nats-io/nats.go v1.23.0 // indirect
+	github.com/nats-io/nkeys v0.3.0 // indirect
+	github.com/nats-io/nuid v1.0.1 // indirect
+	github.com/olekukonko/tablewriter v0.0.5 // indirect
+	github.com/onsi/ginkgo v1.16.5 // indirect
+	github.com/onsi/gomega v1.27.1 // indirect
+	github.com/opentracing/opentracing-go v1.1.0 // indirect
+	github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/prometheus/client_golang v1.14.0 // indirect
+	github.com/prometheus/client_model v0.3.0 // indirect
+	github.com/prometheus/common v0.39.0 // indirect
+	github.com/prometheus/procfs v0.9.0 // indirect
+	github.com/rivo/uniseg v0.4.4 // indirect
+	github.com/rogpeppe/go-internal v1.10.0 // indirect
+	github.com/rs/cors v1.7.0 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	github.com/schollz/closestmatch v2.1.0+incompatible // indirect
+	github.com/sergi/go-diff v1.2.0 // indirect
+	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
+	github.com/sirupsen/logrus v1.9.0 // indirect
+	github.com/status-im/keycard-go v0.2.0 // indirect
+	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
+	github.com/tdewolff/minify/v2 v2.12.4 // indirect
+	github.com/tdewolff/parse/v2 v2.6.4 // indirect
+	github.com/tklauser/go-sysconf v0.3.11 // indirect
+	github.com/tklauser/numcpus v0.6.0 // indirect
+	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect
+	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
+	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
+	github.com/yosssi/ace v0.0.5 // indirect
+	github.com/yusufpapurcu/wmi v1.2.2 // indirect
+	golang.org/x/crypto v0.9.0 // indirect
+	golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect
+	golang.org/x/net v0.10.0 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+	golang.org/x/sys v0.8.0 // indirect
+	golang.org/x/text v0.9.0 // indirect
+	golang.org/x/time v0.3.0 // indirect
+	golang.org/x/tools v0.8.0 // indirect
+	golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df // indirect
+	google.golang.org/protobuf v1.29.0 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
+	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+
+)

bridge-history-api/go.sum

@@ -0,0 +1,722 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/toml v1.2.1 h1:9F2/+DoOYIOksmaJFPw1tGFy1eDnIJXg+UHjuD8lTak=
+github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53 h1:sR+/8Yb4slttB4vD+b9btVEnWgL3Q00OBTzVT8B9C0c=
+github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53/go.mod h1:+3IMCy2vIlbG1XG/0ggNQv0SvxCAIpPM5b1nCz56Xno=
+github.com/CloudyKit/jet/v3 v3.0.0/go.mod h1:HKQPgSJmdK8hdoAbKUUWajkHyHo4RaU5rMdUywE7VMo=
+github.com/CloudyKit/jet/v6 v6.2.0 h1:EpcZ6SR9n28BUGtNJSvlBqf90IpjeFr36Tizxhn/oME=
+github.com/CloudyKit/jet/v6 v6.2.0/go.mod h1:d3ypHeIRNo2+XyqnGA8s+aphtcVpjP5hPwP/Lzo7Ro4=
+github.com/DataDog/zstd v1.5.2 h1:vUG4lAyuPCXO0TLbXvPv7EB7cNK1QV/luu55UHLrrn8=
+github.com/DataDog/zstd v1.5.2/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw=
+github.com/Joker/hpp v1.0.0 h1:65+iuJYdRXv/XyN62C1uEmmOx3432rNG/rKlX6V7Kkc=
+github.com/Joker/hpp v1.0.0/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY=
+github.com/Joker/jade v1.1.3 h1:Qbeh12Vq6BxURXT1qZBRHsDxeURB8ztcL6f3EXSGeHk=
+github.com/Joker/jade v1.1.3/go.mod h1:T+2WLyt7VH6Lp0TRxQrUYEs64nRc83wkMQrfeIQKduM=
+github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0=
+github.com/Shopify/goreferrer v0.0.0-20220729165902-8cddb4f5de06 h1:KkH3I3sJuOLP3TjA/dfr4NAY8bghDwnXiU7cTKxQqo0=
+github.com/Shopify/goreferrer v0.0.0-20220729165902-8cddb4f5de06/go.mod h1:7erjKLwalezA0k99cWs5L11HWOAPNjdUZ6RxH1BXbbM=
+github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o=
+github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw=
+github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
+github.com/ajg/form v1.5.1 h1:t9c7v8JUKu/XxOGBU0yjNpaMloxGEJhUkqFRq0ibGeU=
+github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY=
+github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
+github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
+github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
+github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
+github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
+github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
+github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM=
+github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ=
+github.com/btcsuite/btcd v0.20.1-beta h1:Ik4hyJqN8Jfyv3S4AGBOmyouMsYE3EdYODkMbQjwPGw=
+github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
+github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U=
+github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04=
+github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
+github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
+github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg=
+github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY=
+github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
+github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
+github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cheekybits/is v0.0.0-20150225183255-68e9c0620927/go.mod h1:h/aW8ynjgkuj+NQRlZcDbAbM1ORAbXjXX77sX7T289U=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
+github.com/cockroachdb/datadriven v1.0.2 h1:H9MtNqVoVhvd9nCBwOyDjUEdZCREqbIdCJD93PBm/jA=
+github.com/cockroachdb/datadriven v1.0.2/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU=
+github.com/cockroachdb/errors v1.9.1 h1:yFVvsI0VxmRShfawbt/laCIDy/mtTqqnvoNgiy5bEV8=
+github.com/cockroachdb/errors v1.9.1/go.mod h1:2sxOtL2WIc096WSZqZ5h8fa17rdDq9HZOZLBCor4mBk=
+github.com/cockroachdb/logtags v0.0.0-20211118104740-dabe8e521a4f/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs=
+github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE=
+github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs=
+github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811 h1:ytcWPaNPhNoGMWEhDvS3zToKcDpRsLuRolQJBVGdozk=
+github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811/go.mod h1:Nb5lgvnQ2+oGlE/EyZy4+2/CxRh9KfvCXnag1vtpxVM=
+github.com/cockroachdb/redact v1.1.3 h1:AKZds10rFSIj7qADf0g46UixK8NNLwWTNdCIGS5wfSQ=
+github.com/cockroachdb/redact v1.1.3/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg=
+github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM=
+github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
+github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
+github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
+github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
+github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/deckarep/golang-set/v2 v2.1.0 h1:g47V4Or+DUdzbs8FxCCmgb6VYd+ptPAngjM6dtGktsI=
+github.com/deckarep/golang-set/v2 v2.1.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
+github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
+github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M=
+github.com/deepmap/oapi-codegen v1.8.2 h1:SegyeYGcdi0jLLrpbCMoJxnUUn8GBXHsvr4rbzjuhfU=
+github.com/deepmap/oapi-codegen v1.8.2/go.mod h1:YLgSKSDv/bZQB7N4ws6luhozi3cEdRktEqrX88CvjIw=
+github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
+github.com/djherbis/atime v1.1.0/go.mod h1:28OF6Y8s3NQWwacXc5eZTsEsiMzp7LF8MbXE+XJPdBE=
+github.com/docker/docker v20.10.21+incompatible h1:UTLdBmHk3bEY+w8qeO5KttOhy6OmXWsl/FEet9Uswog=
+github.com/docker/docker v20.10.21+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
+github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
+github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385 h1:clC1lXBpe2kTj2VHdaIu9ajZQe4kcEY9j0NsnDDBZ3o=
+github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
+github.com/ethereum/go-ethereum v1.11.6 h1:2VF8Mf7XiSUfmoNOy3D+ocfl9Qu8baQBrCNbo2CXQ8E=
+github.com/ethereum/go-ethereum v1.11.6/go.mod h1:+a8pUj1tOyJ2RinsNQD4326YS+leSoKGiG/uVVb0x6Y=
+github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=
+github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
+github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
+github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c=
+github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
+github.com/flosch/pongo2/v4 v4.0.2 h1:gv+5Pe3vaSVmiJvh/BZa82b7/00YUGm0PIyVVLop0Hw=
+github.com/flosch/pongo2/v4 v4.0.2/go.mod h1:B5ObFANs/36VwxxlgKpdchIJHMvHB562PW+BWPhwZD8=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
+github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
+github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
+github.com/gavv/httpexpect v2.0.0+incompatible/go.mod h1:x+9tiU1YnrOvnB725RkpoLv1M62hOWzwo5OXotisrKc=
+github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
+github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
+github.com/getkin/kin-openapi v0.53.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
+github.com/getkin/kin-openapi v0.61.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
+github.com/getsentry/sentry-go v0.12.0/go.mod h1:NSap0JBYWzHND8oMbyi0+XZhUalc1TBdRL1M71JZW2c=
+github.com/getsentry/sentry-go v0.18.0 h1:MtBW5H9QgdcJabtZcuJG80BMOwaBpkRDZkxRkNC1sN0=
+github.com/getsentry/sentry-go v0.18.0/go.mod h1:Kgon4Mby+FJ7ZWHFUAZgVaIa8sxHtnRJRLTXZr51aKQ=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s=
+github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM=
+github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98=
+github.com/go-chi/chi/v5 v5.0.0/go.mod h1:BBug9lr0cqtdAhsu6R4AAdvufI0/XBzAQSsUqJpoZOs=
+github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
+github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
+github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab/go.mod h1:/P9AEU963A2AYjv4d1V5eVL1CQbEJq6aCNHDDjibzu8=
+github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
+github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
+github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
+github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc=
+github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
+github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
+github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
+github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
+github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
+github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
+github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
+github.com/gobwas/ws v1.1.0 h1:7RFti/xnNkMJnrK7D1yQ/iCIB5OrrY/54/H930kIbHA=
+github.com/gobwas/ws v1.1.0/go.mod h1:nzvNcVha5eUziGrbxFCo6qFIojQHjJV5cLYIbezhfL0=
+github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
+github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
+github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
+github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4=
+github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/gogo/status v1.1.0/go.mod h1:BFv9nrluPLmrS0EmGVvLaPNmRosr9KapBYd5/hpY1WM=
+github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
+github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg=
+github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk=
+github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219/go.mod h1:/X8TswGSh1pIozq4ZwCfxS0WA5JGXguxk94ar/4c87Y=
+github.com/gomodule/redigo v1.7.1-0.20190724094224-574c33c3df38/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
+github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/css v1.0.0 h1:BQqNyPTi50JCFMTw/b67hByjMVXZRwGha6wxVGkeihY=
+github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
+github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
+github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
+github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/graph-gophers/graphql-go v1.3.0 h1:Eb9x/q6MFpCLz7jBCiP/WTxjSDrYLR1QY41SORZyNJ0=
+github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc=
+github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE=
+github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0=
+github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
+github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA=
+github.com/holiman/uint256 v1.2.2 h1:TXKcSGc2WaxPD2+bmzAsVthL4+pEN0YwXcL5qED83vk=
+github.com/holiman/uint256 v1.2.2/go.mod h1:SC8Ryt4n+UBbPbIBKaG9zbbDlp4jOru9xFZmPzLUTxw=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=
+github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y=
+github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
+github.com/hydrogen18/memlistener v0.0.0-20200120041712-dcc25e7acd91/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE=
+github.com/imkira/go-interpol v1.1.0 h1:KIiKr0VSG2CUW1hl1jpiyuzuJeKUUpC8iM1AIE7N1Vk=
+github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/influxdata/influxdb-client-go/v2 v2.4.0 h1:HGBfZYStlx3Kqvsv1h2pJixbCl/jhnFtxpKFAv9Tu5k=
+github.com/influxdata/influxdb-client-go/v2 v2.4.0/go.mod h1:vLNHdxTJkIf2mSLvGrpj8TCcISApPoXkaxP8g9uRlW8=
+github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c h1:qSHzRbhzK8RdXOsAdfDgO49TtqC1oZ+acxPrkfTxcCs=
+github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo=
+github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
+github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 h1:vilfsDSy7TDxedi9gyBkMvAirat/oRcL0lFdJBf6tdM=
+github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
+github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI=
+github.com/iris-contrib/go.uuid v2.0.0+incompatible h1:XZubAYg61/JwnJNbZilGjf3b3pB80+OQg2qf6c8BfWE=
+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/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=
+github.com/iris-contrib/schema v0.0.6/go.mod h1:iYszG0IOsuIsfzjymw1kMzTL8YQcCWlm65f3wX8J5iA=
+github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
+github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
+github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
+github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U=
+github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k=
+github.com/kataras/blocks v0.0.7 h1:cF3RDY/vxnSRezc7vLFlQFTYXG/yAr1o7WImJuZbzC4=
+github.com/kataras/blocks v0.0.7/go.mod h1:UJIU97CluDo0f+zEjbnbkeMRlvYORtmc1304EeyXf4I=
+github.com/kataras/golog v0.0.10/go.mod h1:yJ8YKCmyL+nWjERB90Qwn+bdyBZsaQwU3bTVFgkFIp8=
+github.com/kataras/golog v0.1.8 h1:isP8th4PJH2SrbkciKnylaND9xoTtfxv++NB+DF0l9g=
+github.com/kataras/golog v0.1.8/go.mod h1:rGPAin4hYROfk1qT9wZP6VY2rsb4zzc37QpdPjdkqVw=
+github.com/kataras/iris/v12 v12.1.8/go.mod h1:LMYy4VlP67TQ3Zgriz8RE2h2kMZV2SgMYbq3UhfoFmE=
+github.com/kataras/iris/v12 v12.2.0 h1:WzDY5nGuW/LgVaFS5BtTkW3crdSKJ/FEgWnxPnIVVLI=
+github.com/kataras/iris/v12 v12.2.0/go.mod h1:BLzBpEunc41GbE68OUaQlqX4jzi791mx5HU04uPb90Y=
+github.com/kataras/neffos v0.0.14/go.mod h1:8lqADm8PnbeFfL7CLXh1WHw53dG27MC3pgi2R1rmoTE=
+github.com/kataras/neffos v0.0.21 h1:UwN/F44jlqdtgFI29y3VhA7IlJ4JbK3UjCbTDg1pYoo=
+github.com/kataras/neffos v0.0.21/go.mod h1:FeGka8lu8cjD2H+0OpBvW8c6xXawy3fj5VX6xcIJ1Fg=
+github.com/kataras/pio v0.0.2/go.mod h1:hAoW0t9UmXi4R5Oyq5Z4irTbaTsOemSrDGUtaTl7Dro=
+github.com/kataras/pio v0.0.11 h1:kqreJ5KOEXGMwHAWHDwIl+mjfNCPhAwZPa8gK7MKlyw=
+github.com/kataras/pio v0.0.11/go.mod h1:38hH6SWH6m4DKSYmRhlrCJ5WItwWgCVrTNU62XZyUvI=
+github.com/kataras/sitemap v0.0.5/go.mod h1:KY2eugMKiPwsJgx7+U103YZehfvNGOXURubcGyk0Bz8=
+github.com/kataras/sitemap v0.0.6 h1:w71CRMMKYMJh6LR2wTgnk5hSgjVNB9KL60n5e2KHvLY=
+github.com/kataras/sitemap v0.0.6/go.mod h1:dW4dOCNs896OR1HmG+dMLdT7JjDk7mYBzoIRwuj5jA4=
+github.com/kataras/tunnel v0.0.4 h1:sCAqWuJV7nPzGrlb0os3j49lk2JhILT0rID38NHNLpA=
+github.com/kataras/tunnel v0.0.4/go.mod h1:9FkU4LaeifdMWqZu7o20ojmW4B7hdhv2CMLwfnHGpYw=
+github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
+github.com/klauspost/compress v1.8.2/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+github.com/klauspost/compress v1.9.7/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+github.com/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4=
+github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg=
+github.com/labstack/echo/v4 v4.5.0/go.mod h1:czIriw4a0C1dFun+ObrXp7ok03xON0N1awStJ6ArI7Y=
+github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
+github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw=
+github.com/lib/pq v1.10.7/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/mailgun/raymond/v2 v2.0.48 h1:5dmlB680ZkFG2RN/0lvTAghrSxIESeu9/2aeDqACtjw=
+github.com/mailgun/raymond/v2 v2.0.48/go.mod h1:lsgvL50kgt1ylcFJYZiULi5fjPBkkhNfj4KA0W54Z18=
+github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/matryer/moq v0.0.0-20190312154309-6cfb0558e1bd/go.mod h1:9ELz6aaclSIGnZBoaSLZ3NAl1VTufbOrXBPvtcy6WiQ=
+github.com/matryer/try v0.0.0-20161228173917-9ac251b645a2/go.mod h1:0KeJpeMD6o+O4hW7qJOT7vyQPKrWmj26uf5wMc/IiIs=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98=
+github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
+github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+github.com/mattn/go-sqlite3 v1.14.14 h1:qZgc/Rwetq+MtyE18WhzjokPD93dNqLGNT3QJuLvBGw=
+github.com/mattn/go-sqlite3 v1.14.14/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw=
+github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
+github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
+github.com/mediocregopher/radix/v3 v3.4.2/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8=
+github.com/mediocregopher/radix/v3 v3.8.1 h1:rOkHflVuulFKlwsLY01/M2cM2tWCjDoETcMqKbAWu1M=
+github.com/mediocregopher/radix/v3 v3.8.1/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8=
+github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc=
+github.com/microcosm-cc/bluemonday v1.0.23 h1:SMZe2IGa0NuHvnVNAZ+6B38gsTbi5e4sViiWJyDDqFY=
+github.com/microcosm-cc/bluemonday v1.0.23/go.mod h1:mN70sk7UkkF8TUr2IGBpNN0jAgStuPzlK76QuruE/z4=
+github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
+github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
+github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A=
+github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ=
+github.com/nats-io/jwt v0.3.0 h1:xdnzwFETV++jNc4W1mw//qFyJGb2ABOombmZJQS4+Qo=
+github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg=
+github.com/nats-io/jwt/v2 v2.3.0 h1:z2mA1a7tIf5ShggOFlR1oBPgd6hGqcDYsISxZByUzdI=
+github.com/nats-io/nats-server/v2 v2.9.11 h1:4y5SwWvWI59V5mcqtuoqKq6L9NDUydOP3Ekwuwl8cZI=
+github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w=
+github.com/nats-io/nats.go v1.23.0 h1:lR28r7IX44WjYgdiKz9GmUeW0uh/m33uD3yEjLZ2cOE=
+github.com/nats-io/nats.go v1.23.0/go.mod h1:ki/Scsa23edbh8IRZbCuNXR9TDcbvfaSijKtaqQgw+Q=
+github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nkeys v0.3.0 h1:cgM5tL53EvYRU+2YLXIK0G2mJtK12Ft9oeooSZMA2G8=
+github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4=
+github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
+github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
+github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
+github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/onsi/gomega v1.27.1 h1:rfztXRbg6nv/5f+Raen9RcGoSecHIFgBBLQK3Wdj754=
+github.com/onsi/gomega v1.27.1/go.mod h1:aHX5xOykVYzWOV4WqQy0sy8BQptgukenXpCXfadcIAw=
+github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU=
+github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQmzR3rNLYGGz4g/UgFcjb28p/viDM=
+github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0=
+github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
+github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pressly/goose/v3 v3.7.0 h1:jblaZul15uCIEKHRu5KUdA+5wDA7E60JC0TOthdrtf8=
+github.com/pressly/goose/v3 v3.7.0/go.mod h1:N5gqPdIzdxf3BiPWdmoPreIwHStkxsvKWE5xjUvfYNk=
+github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw=
+github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.3.0 h1:UBgGFHqYdG/TPFD1B1ogZywDqEkwp3fBMvqdiQ7Xew4=
+github.com/prometheus/client_model v0.3.0/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w=
+github.com/prometheus/common v0.39.0 h1:oOyhkDq05hPZKItWVBkJ6g6AtGxi+fy7F4JvUV8uhsI=
+github.com/prometheus/common v0.39.0/go.mod h1:6XBZ7lYdLCbkAVhwRsWTZn+IN5AB9F/NXd5w0BbEX0Y=
+github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJfhI=
+github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY=
+github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6OkFY5QxjkYwrChwuRruF69c169dPK26NUlk=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
+github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
+github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
+github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
+github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/sanity-io/litter v1.5.5 h1:iE+sBxPBzoK6uaEP5Lt3fHNgpKcHXc/A2HGETy0uJQo=
+github.com/schollz/closestmatch v2.1.0+incompatible h1:Uel2GXEpJqOWBrlyI+oY9LTiyyjYS17cCYRqP13/SHk=
+github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/sergi/go-diff v1.2.0 h1:XU+rvMAioB0UC3q1MFrIQy4Vo5/4VsRDQQXHsEya6xQ=
+github.com/sergi/go-diff v1.2.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
+github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
+github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
+github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
+github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
+github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
+github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA=
+github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
+github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
+github.com/tdewolff/minify/v2 v2.12.4 h1:kejsHQMM17n6/gwdw53qsi6lg0TGddZADVyQOz1KMdE=
+github.com/tdewolff/minify/v2 v2.12.4/go.mod h1:h+SRvSIX3kwgwTFOpSckvSxgax3uy8kZTSF1Ojrr3bk=
+github.com/tdewolff/parse/v2 v2.6.4 h1:KCkDvNUMof10e3QExio9OPZJT8SbdKojLBumw8YZycQ=
+github.com/tdewolff/parse/v2 v2.6.4/go.mod h1:woz0cgbLwFdtbjJu8PIKxhW05KplTFQkOdX78o+Jgrs=
+github.com/tdewolff/test v1.0.7 h1:8Vs0142DmPFW/bQeHRP3MV19m1gvndjUb1sn8yy74LM=
+github.com/tdewolff/test v1.0.7/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
+github.com/tklauser/go-sysconf v0.3.11 h1:89WgdJhk5SNwJfu+GKyYveZ4IaJ7xAkecBo+KdJV0CM=
+github.com/tklauser/go-sysconf v0.3.11/go.mod h1:GqXfhXY3kiPa0nAXPDIQIWzJbMCB7AmcWpGR8lSZfqI=
+github.com/tklauser/numcpus v0.6.0 h1:kebhY2Qt+3U6RNK7UqpYNA+tJ23IBEGKkB7JQBfDYms=
+github.com/tklauser/numcpus v0.6.0/go.mod h1:FEZLMke0lhOUG6w2JadTzp0a+Nl8PF/GFkQ5UVIcaL4=
+github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
+github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
+github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
+github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
+github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
+github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa h1:5SqCsI/2Qya2bCzK15ozrqo2sZxkh0FHynJZOTVoV6Q=
+github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa/go.mod h1:1CNUng3PtjQMtRzJO4FMXBQvkGtuYRxxiR9xMa7jMwI=
+github.com/urfave/negroni v1.0.0/go.mod h1:Meg73S6kFm/4PpbYdq35yYWoCZ9mS/YSx+lKnmiohz4=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasthttp v1.6.0/go.mod h1:FstJa9V+Pj9vQ7OJie2qMHdwemEDaDiSdBnvPM1Su9w=
+github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
+github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
+github.com/vmihailenco/msgpack/v5 v5.3.5 h1:5gO0H1iULLWGhs2H5tbAHIZTV8/cYafcFOr9znI5mJU=
+github.com/vmihailenco/msgpack/v5 v5.3.5/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc=
+github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
+github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
+github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
+github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo=
+github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=
+github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
+github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
+github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
+github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
+github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
+github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
+github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0 h1:6fRhSjgLCkTD3JnJxvaJ4Sj+TYblw757bqYgZaOq5ZY=
+github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI=
+github.com/yosssi/ace v0.0.5 h1:tUkIP/BLdKqrlrPwcmH0shwEEhTRHoGnc1wFIWmaBUA=
+github.com/yosssi/ace v0.0.5/go.mod h1:ALfIzm2vT7t5ZE7uoIZqF3TQ7SAOyupFZnkrF5id+K0=
+github.com/yudai/gojsondiff v1.0.0 h1:27cbfqXLVEJ1o8I6v3y9lg8Ydm53EKqHXAOMxEGlCOA=
+github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg=
+github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 h1:BHyfKlQyqbsFN5p3IfnEUduWvb9is428/nNb5L3U01M=
+github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM=
+github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yusufpapurcu/wmi v1.2.2 h1:KBNDSne4vP5mbSWnJbO+51IMOXJB67QiYCSBrubbPRg=
+github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
+golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191227163750-53104e6ec876/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/crypto v0.0.0-20210314154223-e6e6c4f2bb5b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
+golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
+golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20230206171751-46f607a40771 h1:xP7rWLUr1e1n2xkK5YB4LI0hPEy3LJC6Wk+D4pGlOJg=
+golang.org/x/exp v0.0.0-20230206171751-46f607a40771/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190327091125-710a502c58a2/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
+golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181221001348-537d06c36207/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190327201419-c70d86f8b7cf/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
+golang.org/x/tools v0.8.0 h1:vSDcovVPld282ceKgDimkRSC8kpaH1dgyc9UMzlt84Y=
+golang.org/x/tools v0.8.0/go.mod h1:JxBZ99ISMI5ViVkT1tr6tdNmXeTrcpVSD3vZ1RsRdN4=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df h1:5Pf6pFKu98ODmgnpvkJ3kFUOQGGLIzLIkbzUHp47618=
+golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24=
+google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.29.0 h1:44S3JjaKmLEE4YIkjzexaP+NzZsudE3Zin5Njn/pYX0=
+google.golang.org/protobuf v1.29.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
+gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y=
+gopkg.in/ini.v1 v1.51.1/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA=
+gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8=
+gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
+gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU=
+gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20191120175047-4206685974f2/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+lukechampine.com/uint128 v1.2.0 h1:mBi/5l91vocEN8otkC5bDLhi2KdCticRiwbdB0O+rjI=
+modernc.org/cc/v3 v3.36.1 h1:CICrjwr/1M4+6OQ4HJZ/AHxjcwe67r5vPUF518MkO8A=
+modernc.org/ccgo/v3 v3.16.8 h1:G0QNlTqI5uVgczBWfGKs7B++EPwCfXPWGD2MdeKloDs=
+modernc.org/libc v1.16.19 h1:S8flPn5ZeXx6iw/8yNa986hwTQDrY8RXU7tObZuAozo=
+modernc.org/mathutil v1.4.1 h1:ij3fYGe8zBF4Vu+g0oT7mB06r8sqGWKuJu1yXeR4by8=
+modernc.org/memory v1.1.1 h1:bDOL0DIDLQv7bWhP3gMvIrnoFw+Eo6F7a2QK9HPDiFU=
+modernc.org/opt v0.1.3 h1:3XOZf2yznlhC+ibLltsDGzABUGVx8J6pnFMS3E4dcq4=
+modernc.org/sqlite v1.18.1 h1:ko32eKt3jf7eqIkCgPAeHMBXw3riNSLhl2f3loEF7o8=
+modernc.org/strutil v1.1.2 h1:iFBDH6j1Z0bN/Q9udJnnFoFpENA4252qe/7/5woE5MI=
+modernc.org/token v1.0.0 h1:a0jaWiNMDhDUtqOj09wvjWWAqd3q7WpBulmL9H2egsk=
+moul.io/http2curl/v2 v2.3.0 h1:9r3JfDzWPcbIklMOs2TnIFzDYvfAZvjeavG6EzP7jYs=

bridge-history-api/model/request.go

@@ -0,0 +1,11 @@
+package model
+
+type QueryByAddressRequest struct {
+	Address string `url:"address"`
+	Offset  int    `url:"offset"`
+	Limit   int    `url:"limit"`
+}
+
+type QueryByHashRequest struct {
+	Txs []string `url:"txs"`
+}

bridge-history-api/model/response.go

@@ -0,0 +1,18 @@
+package model
+
+import "bridge-history-api/service"
+
+type Data struct {
+	Result []*service.TxHistoryInfo `json:"result"`
+	Total  int                      `json:"total"`
+}
+
+type QueryByAddressResponse struct {
+	Message string `json:"message"`
+	Data    *Data  `json:"data"`
+}
+
+type QueryByHashResponse struct {
+	Message string `json:"message"`
+	Data    *Data  `json:"data"`
+}

bridge-history-api/service/service.go

@@ -0,0 +1,170 @@
+package service
+
+import (
+	"sort"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+
+	"bridge-history-api/db"
+)
+
+type Finalized struct {
+	Hash           string     `json:"hash"`
+	Amount         string     `json:"amount"`
+	To             string     `json:"to"` // useless
+	IsL1           bool       `json:"isL1"`
+	BlockNumber    uint64     `json:"blockNumber"`
+	BlockTimestamp *time.Time `json:"blockTimestamp"` // uselesss
+}
+
+type TxHistoryInfo struct {
+	Hash           string     `json:"hash"`
+	Amount         string     `json:"amount"`
+	To             string     `json:"to"` // useless
+	IsL1           bool       `json:"isL1"`
+	BlockNumber    uint64     `json:"blockNumber"`
+	BlockTimestamp *time.Time `json:"blockTimestamp"` // useless
+	FinalizeTx     *Finalized `json:"finalizeTx"`
+	CreatedTime    *time.Time `json:"createdTime"`
+}
+
+// HistoryService example service.
+type HistoryService interface {
+	GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, error)
+	GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, error)
+}
+
+// NewHistoryService returns a service backed with a "db"
+func NewHistoryService(db db.OrmFactory) HistoryService {
+	service := &historyBackend{db: db, prefix: "Scroll-Bridge-History-Server"}
+	return service
+}
+
+type historyBackend struct {
+	prefix string
+	db     db.OrmFactory
+}
+
+func updateCrossTxHash(msgHash string, txInfo *TxHistoryInfo, db db.OrmFactory) {
+	relayed, err := db.GetRelayedMsgByHash(msgHash)
+	if err != nil {
+		log.Error("updateCrossTxHash failed", "error", err)
+		return
+	}
+	if relayed == nil {
+		return
+	}
+	if relayed.Layer1Hash != "" {
+		txInfo.FinalizeTx.Hash = relayed.Layer1Hash
+		txInfo.FinalizeTx.BlockNumber = relayed.Height
+		return
+	}
+	if relayed.Layer2Hash != "" {
+		txInfo.FinalizeTx.Hash = relayed.Layer2Hash
+		txInfo.FinalizeTx.BlockNumber = relayed.Height
+		return
+	}
+
+}
+
+func (h *historyBackend) GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, error) {
+	txHistories := make([]*TxHistoryInfo, 0)
+	result, err := h.db.GetL1CrossMsgsByAddressWithOffset(address, offset, limit)
+	if err != nil {
+		return nil, err
+	}
+	if len(result) > 0 {
+		for _, r := range result {
+			txHistory := &TxHistoryInfo{
+				Hash:        r.Layer1Hash,
+				Amount:      r.Amount,
+				To:          r.Target,
+				IsL1:        true,
+				BlockNumber: r.Height,
+				CreatedTime: r.CreatedTime,
+				FinalizeTx: &Finalized{
+					Hash: "",
+				},
+			}
+			// update relayed info into results
+			updateCrossTxHash(r.MsgHash, txHistory, h.db)
+			txHistories = append(txHistories, txHistory)
+		}
+	}
+	l2Result, err := h.db.GetL2CrossMsgsByAddressWithOffset(address, offset, limit)
+	if err != nil {
+		return nil, err
+	}
+	if len(l2Result) > 0 {
+		for _, r := range l2Result {
+			txHistory := &TxHistoryInfo{
+				Hash:        r.Layer2Hash,
+				Amount:      r.Amount,
+				To:          r.Target,
+				IsL1:        false,
+				BlockNumber: r.Height,
+				CreatedTime: r.CreatedTime,
+				FinalizeTx: &Finalized{
+					Hash: "",
+				},
+			}
+			updateCrossTxHash(r.MsgHash, txHistory, h.db)
+			txHistories = append(txHistories, txHistory)
+		}
+	}
+	if len(txHistories) > 0 {
+		sort.Slice(txHistories, func(i, j int) bool {
+			return txHistories[i].CreatedTime.Second() > txHistories[j].CreatedTime.Second()
+		})
+	}
+	return txHistories, nil
+}
+
+func (h *historyBackend) GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, error) {
+	txHistories := make([]*TxHistoryInfo, 0)
+	for _, hash := range hashes {
+		l1result, err := h.db.GetL1CrossMsgByHash(common.HexToHash(hash))
+		if err != nil {
+			return nil, err
+		}
+		if l1result != nil {
+			txHistory := &TxHistoryInfo{
+				Hash:        l1result.Layer1Hash,
+				Amount:      l1result.Amount,
+				To:          l1result.Target,
+				IsL1:        true,
+				BlockNumber: l1result.Height,
+				CreatedTime: l1result.CreatedTime,
+				FinalizeTx: &Finalized{
+					Hash: "",
+				},
+			}
+			updateCrossTxHash(l1result.MsgHash, txHistory, h.db)
+			txHistories = append(txHistories, txHistory)
+			continue
+		}
+		l2result, err := h.db.GetL2CrossMsgByHash(common.HexToHash(hash))
+		if err != nil {
+			return nil, err
+		}
+		if l2result != nil {
+			txHistory := &TxHistoryInfo{
+				Hash:        l2result.Layer2Hash,
+				Amount:      l2result.Amount,
+				To:          l2result.Target,
+				IsL1:        false,
+				BlockNumber: l2result.Height,
+				CreatedTime: l2result.CreatedTime,
+				FinalizeTx: &Finalized{
+					Hash: "",
+				},
+			}
+			updateCrossTxHash(l2result.MsgHash, txHistory, h.db)
+			txHistories = append(txHistories, txHistory)
+			continue
+		}
+	}
+	return txHistories, nil
+}

bridge-history-api/utils/flags.go

@@ -0,0 +1,69 @@
+package utils
+
+import (
+	"github.com/urfave/cli/v2"
+)
+
+var (
+	// CommonFlags is used for app common flags in different modules
+	CommonFlags = []cli.Flag{
+		&ConfigFileFlag,
+		&VerbosityFlag,
+		&LogFileFlag,
+		&LogJSONFormat,
+		&LogDebugFlag,
+		&MetricsEnabled,
+		&MetricsAddr,
+		&MetricsPort,
+	}
+	// ConfigFileFlag load json type config file.
+	ConfigFileFlag = cli.StringFlag{
+		Name:  "config",
+		Usage: "JSON configuration file",
+		Value: "./config.json",
+	}
+	// VerbosityFlag log level.
+	VerbosityFlag = cli.IntFlag{
+		Name:  "verbosity",
+		Usage: "Logging verbosity: 0=silent, 1=error, 2=warn, 3=info, 4=debug, 5=detail",
+		Value: 3,
+	}
+	// LogFileFlag decides where the logger output is sent. If this flag is left
+	// empty, it will log to stdout.
+	LogFileFlag = cli.StringFlag{
+		Name:  "log.file",
+		Usage: "Tells the module where to write log entries",
+	}
+	// LogJSONFormat decides the log format is json or not
+	LogJSONFormat = cli.BoolFlag{
+		Name:  "log.json",
+		Usage: "Tells the module whether log format is json or not",
+		Value: true,
+	}
+	// LogDebugFlag make log messages with call-site location
+	LogDebugFlag = cli.BoolFlag{
+		Name:  "log.debug",
+		Usage: "Prepends log messages with call-site location (file and line number)",
+	}
+	// MetricsEnabled enable metrics collection and reporting
+	MetricsEnabled = cli.BoolFlag{
+		Name:     "metrics",
+		Usage:    "Enable metrics collection and reporting",
+		Category: "METRICS",
+		Value:    false,
+	}
+	// MetricsAddr is listening address of Metrics reporting server
+	MetricsAddr = cli.StringFlag{
+		Name:     "metrics.addr",
+		Usage:    "Metrics reporting server listening address",
+		Category: "METRICS",
+		Value:    "127.0.0.1",
+	}
+	// MetricsPort is listening port of Metrics reporting server
+	MetricsPort = cli.IntFlag{
+		Name:     "metrics.port",
+		Usage:    "Metrics reporting server listening port",
+		Category: "METRICS",
+		Value:    6060,
+	}
+)

bridge-history-api/utils/logger.go

@@ -0,0 +1,43 @@
+package utils
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/mattn/go-colorable"
+	"github.com/mattn/go-isatty"
+	"github.com/urfave/cli/v2"
+)
+
+// LogSetup is for setup logger
+func LogSetup(ctx *cli.Context) error {
+	var ostream log.Handler
+	if logFile := ctx.String(LogFileFlag.Name); len(logFile) > 0 {
+		fp, err := os.OpenFile(filepath.Clean(logFile), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0600)
+		if err != nil {
+			utils.Fatalf("Failed to open log file", "err", err)
+		}
+		if ctx.Bool(LogJSONFormat.Name) {
+			ostream = log.StreamHandler(io.Writer(fp), log.JSONFormat())
+		} else {
+			ostream = log.StreamHandler(io.Writer(fp), log.TerminalFormat(true))
+		}
+	} else {
+		output := io.Writer(os.Stderr)
+		usecolor := (isatty.IsTerminal(os.Stderr.Fd()) || isatty.IsCygwinTerminal(os.Stderr.Fd())) && os.Getenv("TERM") != "dumb"
+		if usecolor {
+			output = colorable.NewColorableStderr()
+		}
+		ostream = log.StreamHandler(output, log.TerminalFormat(usecolor))
+	}
+	// show the call file and line number
+	log.PrintOrigins(ctx.Bool(LogDebugFlag.Name))
+	glogger := log.NewGlogHandler(ostream)
+	// Set log level
+	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
+	log.Root().SetHandler(glogger)
+	return nil
+}

bridge-history-api/utils/utils.go

@@ -0,0 +1,56 @@
+package utils
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient"
+
+	backendabi "bridge-history-api/abi"
+)
+
+func GetSafeBlockNumber(ctx context.Context, client *ethclient.Client, confirmations uint64) (uint64, error) {
+	number, err := client.BlockNumber(ctx)
+	if err != nil || number <= confirmations {
+		return 0, err
+	}
+	number = number - confirmations
+	return number, nil
+}
+
+// UnpackLog unpacks a retrieved log into the provided output structure.
+// @todo: add unit test.
+func UnpackLog(c *abi.ABI, out interface{}, event string, log types.Log) error {
+	if log.Topics[0] != c.Events[event].ID {
+		return fmt.Errorf("event signature mismatch")
+	}
+	if len(log.Data) > 0 {
+		if err := c.UnpackIntoInterface(out, event, log.Data); err != nil {
+			return err
+		}
+	}
+	var indexed abi.Arguments
+	for _, arg := range c.Events[event].Inputs {
+		if arg.Indexed {
+			indexed = append(indexed, arg)
+		}
+	}
+	return abi.ParseTopics(out, indexed, log.Topics[1:])
+}
+
+// ComputeMessageHash compute the message hash
+func ComputeMessageHash(
+	sender common.Address,
+	target common.Address,
+	value *big.Int,
+	messageNonce *big.Int,
+	message []byte,
+) common.Hash {
+	data, _ := backendabi.L2ScrollMessengerABI.Pack("relayMessage", sender, target, value, messageNonce, message)
+	return common.BytesToHash(crypto.Keccak256(data))
+}

bridge/config.json

@@ -1,7 +1,7 @@
 {
   "l1_config": {
     "confirmations": "0x6",
-    "endpoint": "https://goerli.infura.io/v3/9aa3d95b3bc440fa88ea12eaa4456161",
+    "endpoint": "DUMMY_ENDPOINT",
     "l1_messenger_address": "0x0000000000000000000000000000000000000000",
     "l1_message_queue_address": "0x0000000000000000000000000000000000000000",
     "scroll_chain_address": "0x0000000000000000000000000000000000000000",
@@ -31,7 +31,7 @@
         "1212121212121212121212121212121212121212121212121212121212121212"
       ],
       "gas_oracle_sender_private_keys": [
-        "1212121212121212121212121212121212121212121212121212121212121212"
+        "1313131313131313131313131313131313131313131313131313131313131313"
       ]
     }
   },
@@ -45,7 +45,7 @@
       "messenger_contract_address": "0x0000000000000000000000000000000000000000",
       "gas_price_oracle_address": "0x0000000000000000000000000000000000000000",
       "sender_config": {
-        "endpoint": "https://goerli.infura.io/v3/9aa3d95b3bc440fa88ea12eaa4456161",
+        "endpoint": "DUMMY_ENDPOINT",
         "check_pending_time": 10,
         "check_balance_time": 100,
         "escalate_blocks": 100,
@@ -66,10 +66,10 @@
         "1212121212121212121212121212121212121212121212121212121212121212"
       ],
       "gas_oracle_sender_private_keys": [
-        "1212121212121212121212121212121212121212121212121212121212121212"
+        "1313131313131313131313131313131313131313131313131313131313131313"
       ],
       "rollup_sender_private_keys": [
-        "1212121212121212121212121212121212121212121212121212121212121212"
+        "1414141414141414141414141414141414141414141414141414141414141414"
       ]
     },
     "batch_proposer_config": {

bridge/config/config_test.go

@@ -13,7 +13,7 @@ import (
 func TestConfig(t *testing.T) {
 	t.Run("Success Case", func(t *testing.T) {
 		cfg, err := NewConfig("../config.json")
-		assert.NoError(t, err, "failed to load config")
+		assert.NoError(t, err)
 
 		assert.Len(t, cfg.L1Config.RelayerConfig.MessageSenderPrivateKeys, 1)
 		assert.Len(t, cfg.L2Config.RelayerConfig.MessageSenderPrivateKeys, 1)
@@ -23,7 +23,11 @@ func TestConfig(t *testing.T) {
 		assert.NoError(t, err)
 
 		tmpJSON := fmt.Sprintf("/tmp/%d_bridge_config.json", time.Now().Nanosecond())
-		defer func() { _ = os.Remove(tmpJSON) }()
+		defer func() {
+			if _, err = os.Stat(tmpJSON); err == nil {
+				assert.NoError(t, os.Remove(tmpJSON))
+			}
+		}()
 
 		assert.NoError(t, os.WriteFile(tmpJSON, data, 0644))
 
@@ -42,14 +46,17 @@ func TestConfig(t *testing.T) {
 
 	t.Run("Invalid JSON Content", func(t *testing.T) {
 		// Create a temporary file with invalid JSON content
-		tempFile, err := os.CreateTemp("", "invalid_json_config.json")
+		tmpFile, err := os.CreateTemp("", "invalid_json_config.json")
 		assert.NoError(t, err)
-		defer os.Remove(tempFile.Name())
+		defer func() {
+			assert.NoError(t, tmpFile.Close())
+			assert.NoError(t, os.Remove(tmpFile.Name()))
+		}()
 
-		_, err = tempFile.WriteString("{ invalid_json: ")
+		_, err = tmpFile.WriteString("{ invalid_json: ")
 		assert.NoError(t, err)
 
-		_, err = NewConfig(tempFile.Name())
+		_, err = NewConfig(tmpFile.Name())
 		assert.Error(t, err)
 	})
 }

bridge/go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/agiledragon/gomonkey/v2 v2.9.0
 	github.com/orcaman/concurrent-map v1.0.0
 	github.com/orcaman/concurrent-map/v2 v2.0.1
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20230321020420-127af384ed04
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20230508165858-27a3830afa61
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/stretchr/testify v1.8.2
 	github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa
@@ -16,17 +16,21 @@ require (
 
 require (
 	github.com/btcsuite/btcd v0.20.1-beta // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/deckarep/golang-set v1.8.0 // indirect
-	github.com/ethereum/go-ethereum v1.11.4 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/google/uuid v1.3.0 // indirect
 	github.com/gopherjs/gopherjs v1.17.2 // indirect
 	github.com/gorilla/websocket v1.5.0 // indirect
-	github.com/iden3/go-iden3-crypto v0.0.14 // indirect
+	github.com/huin/goupnp v1.0.3 // indirect
+	github.com/iden3/go-iden3-crypto v0.0.15 // indirect
+	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
 	github.com/jtolds/gls v4.20.0+incompatible // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.18 // indirect
 	github.com/mattn/go-runewidth v0.0.14 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
@@ -36,17 +40,18 @@ require (
 	github.com/rjeczalik/notify v0.9.1 // indirect
 	github.com/rogpeppe/go-internal v1.10.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/scroll-tech/zktrie v0.5.2 // indirect
+	github.com/scroll-tech/zktrie v0.5.3 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
 	github.com/smartystreets/assertions v1.13.1 // indirect
+	github.com/status-im/keycard-go v0.2.0 // indirect
 	github.com/tklauser/go-sysconf v0.3.11 // indirect
 	github.com/tklauser/numcpus v0.6.0 // indirect
+	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	github.com/yusufpapurcu/wmi v1.2.2 // indirect
-	golang.org/x/crypto v0.7.0 // indirect
-	golang.org/x/sys v0.7.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
-	golang.org/x/time v0.1.0 // indirect
+	golang.org/x/crypto v0.9.0 // indirect
+	golang.org/x/sys v0.8.0 // indirect
+	golang.org/x/time v0.3.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

bridge/go.sum

@@ -13,8 +13,10 @@ github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtE
 github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
 github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
 github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -22,8 +24,6 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4=
 github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo=
 github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
-github.com/ethereum/go-ethereum v1.11.4 h1:KG81SnUHXWk8LJB3mBcHg/E2yLvXoiPmRMCIRxgx3cE=
-github.com/ethereum/go-ethereum v1.11.4/go.mod h1:it7x0DWnTDMfVFdXcU6Ti4KEFQynLHVRarcSlPr0HBo=
 github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
@@ -46,9 +46,12 @@ github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZ
 github.com/holiman/uint256 v1.2.0 h1:gpSYcPLWGv4sG43I2mVLiDZCNDh/EpGjSk8tmtxitHM=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=
-github.com/iden3/go-iden3-crypto v0.0.14 h1:HQnFchY735JRNQxof6n/Vbyon4owj4+Ku+LNAamWV6c=
-github.com/iden3/go-iden3-crypto v0.0.14/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBeOT/3UEhXsEsP3E=
+github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y=
+github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
+github.com/iden3/go-iden3-crypto v0.0.15 h1:4MJYlrot1l31Fzlo2sF56u7EVFeHHJkxGXXZCtESgK4=
+github.com/iden3/go-iden3-crypto v0.0.15/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBeOT/3UEhXsEsP3E=
 github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
+github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
 github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
@@ -56,11 +59,15 @@ github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfV
 github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98=
 github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
@@ -76,6 +83,7 @@ github.com/orcaman/concurrent-map v1.0.0 h1:I/2A2XPCb4IuQWcQhBhSwGfiuybl/J0ev9HD
 github.com/orcaman/concurrent-map v1.0.0/go.mod h1:Lu3tH6HLW3feq74c2GC+jIMS/K2CFcDWnWD9XkenwhI=
 github.com/orcaman/concurrent-map/v2 v2.0.1 h1:jOJ5Pg2w1oeB6PeDurIYf6k9PQ+aTITr/6lP/L/zp6c=
 github.com/orcaman/concurrent-map/v2 v2.0.1/go.mod h1:9Eq3TG2oBe5FirmYWQfYO5iH1q0Jv47PLaNK++uCdOM=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
@@ -87,15 +95,16 @@ github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeCE=
 github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230321020420-127af384ed04 h1:PpI31kaBVm6+7sZtyK03Ex0QIg3P821Ktae0FHFh7IM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230321020420-127af384ed04/go.mod h1:jH8c08L9K8Hieaf0r/ur2P/cpesn4dFhmLm2Mmoi8kI=
-github.com/scroll-tech/zktrie v0.5.2 h1:U34jPXMLGOlRHfdvYp5VVgOcC0RuPeJmcS3bWotCWiY=
-github.com/scroll-tech/zktrie v0.5.2/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20230508165858-27a3830afa61 h1:4fslVpNOPLeJPYX3tivrVWgqNvChPs7/y9OqWvQSNCw=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20230508165858-27a3830afa61/go.mod h1:45PZqlQCqV0dU4o4+SE8LoJLEvXkK5j45ligvbih9QY=
+github.com/scroll-tech/zktrie v0.5.3 h1:jjzQchGU6XPL5s1C5bwwivSadefSRuYASE9OL7UKAdE=
+github.com/scroll-tech/zktrie v0.5.3/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
@@ -105,6 +114,7 @@ github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9
 github.com/smartystreets/goconvey v1.8.0 h1:Oi49ha/2MURE0WexF052Z0m+BNSGirfjg5RL+JXWq3w=
 github.com/smartystreets/goconvey v1.8.0/go.mod h1:EdX8jtrTIj26jmjCOVNMVSIYAtgexqXKHOXW2Dx9JLg=
 github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA=
+github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -118,6 +128,7 @@ github.com/tklauser/go-sysconf v0.3.11/go.mod h1:GqXfhXY3kiPa0nAXPDIQIWzJbMCB7Am
 github.com/tklauser/numcpus v0.6.0 h1:kebhY2Qt+3U6RNK7UqpYNA+tJ23IBEGKkB7JQBfDYms=
 github.com/tklauser/numcpus v0.6.0/go.mod h1:FEZLMke0lhOUG6w2JadTzp0a+Nl8PF/GFkQ5UVIcaL4=
 github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
+github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
 github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa h1:5SqCsI/2Qya2bCzK15ozrqo2sZxkh0FHynJZOTVoV6Q=
 github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa/go.mod h1:1CNUng3PtjQMtRzJO4FMXBQvkGtuYRxxiR9xMa7jMwI=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
@@ -126,25 +137,29 @@ github.com/yusufpapurcu/wmi v1.2.2 h1:KBNDSne4vP5mbSWnJbO+51IMOXJB67QiYCSBrubbPR
 github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.7.0 h1:AvwMYaRytfdeVt3u6mLaxYtErKYjxA2OXjJ1HHq6t3A=
-golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
+golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/time v0.1.0 h1:xYY+Bajn2a7VBmTM5GikTmnK8ZuX8YgnQCqZpbBNtmA=
-golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
+golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=

bridge/relayer/l1_relayer_test.go

@@ -2,13 +2,20 @@ package relayer
 
 import (
 	"context"
+	"errors"
+	"math/big"
 	"testing"
 
+	"github.com/agiledragon/gomonkey/v2"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/smartystreets/goconvey/convey"
+
 	"github.com/stretchr/testify/assert"
 
+	"scroll-tech/database/migrate"
+
 	"scroll-tech/common/types"
 	"scroll-tech/common/utils"
-	"scroll-tech/database/migrate"
 
 	"scroll-tech/bridge/sender"
 
@@ -94,6 +101,7 @@ func testL1RelayerMsgConfirm(t *testing.T) {
 	defer cancel()
 	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig)
 	assert.NoError(t, err)
+	assert.NotNil(t, l1Relayer)
 
 	// Simulate message confirmations.
 	l1Relayer.messageSender.SendConfirmation(&sender.Confirmation{
@@ -106,12 +114,13 @@ func testL1RelayerMsgConfirm(t *testing.T) {
 	})
 
 	// Check the database for the updated status using TryTimes.
-	utils.TryTimes(5, func() bool {
+	ok := utils.TryTimes(5, func() bool {
 		msg1, err1 := db.GetL1MessageByMsgHash("msg-1")
 		msg2, err2 := db.GetL1MessageByMsgHash("msg-2")
 		return err1 == nil && msg1.Status == types.MsgConfirmed &&
 			err2 == nil && msg2.Status == types.MsgRelayFailed
 	})
+	assert.True(t, ok)
 }
 
 func testL1RelayerGasOracleConfirm(t *testing.T) {
@@ -134,6 +143,7 @@ func testL1RelayerGasOracleConfirm(t *testing.T) {
 	defer cancel()
 	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig)
 	assert.NoError(t, err)
+	assert.NotNil(t, l1Relayer)
 
 	// Simulate message confirmations.
 	l1Relayer.gasOracleSender.SendConfirmation(&sender.Confirmation{
@@ -146,10 +156,107 @@ func testL1RelayerGasOracleConfirm(t *testing.T) {
 	})
 
 	// Check the database for the updated status using TryTimes.
-	utils.TryTimes(5, func() bool {
+	ok := utils.TryTimes(5, func() bool {
 		msg1, err1 := db.GetL1BlockInfos(map[string]interface{}{"hash": "gas-oracle-1"})
 		msg2, err2 := db.GetL1BlockInfos(map[string]interface{}{"hash": "gas-oracle-2"})
 		return err1 == nil && len(msg1) == 1 && msg1[0].GasOracleStatus == types.GasOracleImported &&
 			err2 == nil && len(msg2) == 1 && msg2[0].GasOracleStatus == types.GasOracleFailed
 	})
+	assert.True(t, ok)
+}
+
+func testL1RelayerProcessGasPriceOracle(t *testing.T) {
+	db, err := database.NewOrmFactory(cfg.DBConfig)
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
+	defer db.Close()
+
+	l1Cfg := cfg.L1Config
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	l1Relayer, err := NewLayer1Relayer(ctx, db, l1Cfg.RelayerConfig)
+	assert.NoError(t, err)
+	assert.NotNil(t, l1Relayer)
+
+	convey.Convey("GetLatestL1BlockHeight failure", t, func() {
+		targetErr := errors.New("GetLatestL1BlockHeight error")
+		patchGuard := gomonkey.ApplyMethodFunc(db, "GetLatestL1BlockHeight", func() (uint64, error) {
+			return 0, targetErr
+		})
+		defer patchGuard.Reset()
+		l1Relayer.ProcessGasPriceOracle()
+	})
+
+	patchGuard := gomonkey.ApplyMethodFunc(db, "GetLatestL1BlockHeight", func() (uint64, error) {
+		return 100, nil
+	})
+	defer patchGuard.Reset()
+
+	convey.Convey("GetL1BlockInfos failure", t, func() {
+		targetErr := errors.New("GetL1BlockInfos error")
+		patchGuard.ApplyMethodFunc(db, "GetL1BlockInfos", func(fields map[string]interface{}, args ...string) ([]*types.L1BlockInfo, error) {
+			return nil, targetErr
+		})
+		l1Relayer.ProcessGasPriceOracle()
+	})
+
+	convey.Convey("Block not exist", t, func() {
+		patchGuard.ApplyMethodFunc(db, "GetL1BlockInfos", func(fields map[string]interface{}, args ...string) ([]*types.L1BlockInfo, error) {
+			tmpInfo := []*types.L1BlockInfo{
+				{Hash: "gas-oracle-1", Number: 0},
+				{Hash: "gas-oracle-2", Number: 1},
+			}
+			return tmpInfo, nil
+		})
+		l1Relayer.ProcessGasPriceOracle()
+	})
+
+	patchGuard.ApplyMethodFunc(db, "GetL1BlockInfos", func(fields map[string]interface{}, args ...string) ([]*types.L1BlockInfo, error) {
+		tmpInfo := []*types.L1BlockInfo{
+			{
+				Hash:            "gas-oracle-1",
+				Number:          0,
+				GasOracleStatus: types.GasOraclePending,
+			},
+		}
+		return tmpInfo, nil
+	})
+
+	convey.Convey("setL1BaseFee failure", t, func() {
+		targetErr := errors.New("pack setL1BaseFee error")
+		patchGuard.ApplyMethodFunc(l1Relayer.l1GasOracleABI, "Pack", func(name string, args ...interface{}) ([]byte, error) {
+			return nil, targetErr
+		})
+		l1Relayer.ProcessGasPriceOracle()
+	})
+
+	patchGuard.ApplyMethodFunc(l1Relayer.l1GasOracleABI, "Pack", func(name string, args ...interface{}) ([]byte, error) {
+		return []byte("for test"), nil
+	})
+
+	convey.Convey("send transaction failure", t, func() {
+		targetErr := errors.New("send transaction failure")
+		patchGuard.ApplyMethodFunc(l1Relayer.gasOracleSender, "SendTransaction", func(string, *common.Address, *big.Int, []byte, uint64) (hash common.Hash, err error) {
+			return common.Hash{}, targetErr
+		})
+		l1Relayer.ProcessGasPriceOracle()
+	})
+
+	patchGuard.ApplyMethodFunc(l1Relayer.gasOracleSender, "SendTransaction", func(string, *common.Address, *big.Int, []byte, uint64) (hash common.Hash, err error) {
+		return common.Hash{}, nil
+	})
+
+	convey.Convey("UpdateL1GasOracleStatusAndOracleTxHash failure", t, func() {
+		targetErr := errors.New("UpdateL1GasOracleStatusAndOracleTxHash failure")
+		patchGuard.ApplyMethodFunc(db, "UpdateL1GasOracleStatusAndOracleTxHash", func(context.Context, string, types.GasOracleStatus, string) error {
+			return targetErr
+		})
+		l1Relayer.ProcessGasPriceOracle()
+	})
+
+	patchGuard.ApplyMethodFunc(db, "UpdateL1GasOracleStatusAndOracleTxHash", func(context.Context, string, types.GasOracleStatus, string) error {
+		return nil
+	})
+
+	l1Relayer.ProcessGasPriceOracle()
 }

bridge/relayer/l2_relayer_test.go

@@ -3,13 +3,17 @@ package relayer
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"math/big"
 	"os"
 	"strconv"
 	"testing"
 
+	"github.com/agiledragon/gomonkey/v2"
+	"github.com/scroll-tech/go-ethereum/accounts/abi"
 	"github.com/scroll-tech/go-ethereum/common"
 	geth_types "github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/smartystreets/goconvey/convey"
 	"github.com/stretchr/testify/assert"
 
 	"scroll-tech/common/types"
@@ -240,12 +244,12 @@ func testL2RelayerMsgConfirm(t *testing.T) {
 	})
 
 	// Check the database for the updated status using TryTimes.
-	utils.TryTimes(5, func() bool {
+	assert.True(t, utils.TryTimes(5, func() bool {
 		msg1, err1 := db.GetL2MessageByMsgHash("msg-1")
 		msg2, err2 := db.GetL2MessageByMsgHash("msg-2")
 		return err1 == nil && msg1.Status == types.MsgConfirmed &&
 			err2 == nil && msg2.Status == types.MsgRelayFailed
-	})
+	}))
 }
 
 func testL2RelayerRollupConfirm(t *testing.T) {
@@ -299,7 +303,7 @@ func testL2RelayerRollupConfirm(t *testing.T) {
 	}
 
 	// Check the database for the updated status using TryTimes.
-	utils.TryTimes(5, func() bool {
+	ok := utils.TryTimes(5, func() bool {
 		expectedStatuses := []types.RollupStatus{
 			types.RollupCommitted,
 			types.RollupCommitted,
@@ -317,6 +321,7 @@ func testL2RelayerRollupConfirm(t *testing.T) {
 		}
 		return true
 	})
+	assert.True(t, ok)
 }
 
 func testL2RelayerGasOracleConfirm(t *testing.T) {
@@ -356,7 +361,7 @@ func testL2RelayerGasOracleConfirm(t *testing.T) {
 	}
 
 	// Check the database for the updated status using TryTimes.
-	utils.TryTimes(5, func() bool {
+	ok := utils.TryTimes(5, func() bool {
 		expectedStatuses := []types.GasOracleStatus{types.GasOracleImported, types.GasOracleFailed}
 		for i, batch := range batches {
 			gasOracle, err := db.GetBlockBatches(map[string]interface{}{"hash": batch.Hash().Hex()})
@@ -366,6 +371,7 @@ func testL2RelayerGasOracleConfirm(t *testing.T) {
 		}
 		return true
 	})
+	assert.True(t, ok)
 }
 
 func genBatchData(t *testing.T, index uint64) *types.BatchData {
@@ -382,3 +388,165 @@ func genBatchData(t *testing.T, index uint64) *types.BatchData {
 	}
 	return types.NewBatchData(parentBatch, []*types.WrappedBlock{wrappedBlock}, nil)
 }
+
+func testLayer2RelayerProcessGasPriceOracle(t *testing.T) {
+	db, err := database.NewOrmFactory(cfg.DBConfig)
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
+	defer db.Close()
+
+	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig)
+	assert.NoError(t, err)
+	assert.NotNil(t, relayer)
+
+	convey.Convey("Failed to GetLatestBatch", t, func() {
+		targetErr := errors.New("GetLatestBatch error")
+		patchGuard := gomonkey.ApplyMethodFunc(db, "GetLatestBatch", func() (*types.BlockBatch, error) {
+			return nil, targetErr
+		})
+		defer patchGuard.Reset()
+		relayer.ProcessGasPriceOracle()
+	})
+
+	patchGuard := gomonkey.ApplyMethodFunc(db, "GetLatestBatch", func() (*types.BlockBatch, error) {
+		batch := types.BlockBatch{
+			OracleStatus: types.GasOraclePending,
+			Hash:         "0x0000000000000000000000000000000000000000",
+		}
+		return &batch, nil
+	})
+	defer patchGuard.Reset()
+
+	convey.Convey("Failed to fetch SuggestGasPrice from l2geth", t, func() {
+		targetErr := errors.New("SuggestGasPrice error")
+		patchGuard.ApplyMethodFunc(relayer.l2Client, "SuggestGasPrice", func(ctx context.Context) (*big.Int, error) {
+			return nil, targetErr
+		})
+		relayer.ProcessGasPriceOracle()
+	})
+
+	patchGuard.ApplyMethodFunc(relayer.l2Client, "SuggestGasPrice", func(ctx context.Context) (*big.Int, error) {
+		return big.NewInt(100), nil
+	})
+
+	convey.Convey("Failed to pack setL2BaseFee", t, func() {
+		targetErr := errors.New("setL2BaseFee error")
+		patchGuard.ApplyMethodFunc(relayer.l2GasOracleABI, "Pack", func(name string, args ...interface{}) ([]byte, error) {
+			return nil, targetErr
+		})
+		relayer.ProcessGasPriceOracle()
+	})
+
+	patchGuard.ApplyMethodFunc(relayer.l2GasOracleABI, "Pack", func(name string, args ...interface{}) ([]byte, error) {
+		return nil, nil
+	})
+
+	convey.Convey("Failed to send setL2BaseFee tx to layer2", t, func() {
+		targetErr := errors.New("failed to send setL2BaseFee tx to layer2 error")
+		patchGuard.ApplyMethodFunc(relayer.gasOracleSender, "SendTransaction", func(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (hash common.Hash, err error) {
+			return common.Hash{}, targetErr
+		})
+		relayer.ProcessGasPriceOracle()
+	})
+
+	patchGuard.ApplyMethodFunc(relayer.gasOracleSender, "SendTransaction", func(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (hash common.Hash, err error) {
+		return common.HexToHash("0x56789abcdef1234"), nil
+	})
+
+	convey.Convey("UpdateGasOracleStatusAndOracleTxHash failed", t, func() {
+		targetErr := errors.New("UpdateL2GasOracleStatusAndOracleTxHash error")
+		patchGuard.ApplyMethodFunc(db, "UpdateL2GasOracleStatusAndOracleTxHash", func(ctx context.Context, hash string, status types.GasOracleStatus, txHash string) error {
+			return targetErr
+		})
+		relayer.ProcessGasPriceOracle()
+	})
+
+	patchGuard.ApplyMethodFunc(db, "UpdateL2GasOracleStatusAndOracleTxHash", func(ctx context.Context, hash string, status types.GasOracleStatus, txHash string) error {
+		return nil
+	})
+	relayer.ProcessGasPriceOracle()
+}
+
+func testLayer2RelayerSendCommitTx(t *testing.T) {
+	db, err := database.NewOrmFactory(cfg.DBConfig)
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
+	defer db.Close()
+
+	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig)
+	assert.NoError(t, err)
+	assert.NotNil(t, relayer)
+
+	var batchDataList []*types.BatchData
+	convey.Convey("SendCommitTx receives empty batch", t, func() {
+		err = relayer.SendCommitTx(batchDataList)
+		assert.NoError(t, err)
+	})
+
+	parentBatch := &types.BlockBatch{
+		Index: 0,
+		Hash:  "0x0000000000000000000000000000000000000000",
+	}
+
+	traces := []*types.WrappedBlock{
+		{
+			Header: &geth_types.Header{
+				Number:     big.NewInt(1000),
+				ParentHash: common.Hash{},
+				Difficulty: big.NewInt(0),
+				BaseFee:    big.NewInt(0),
+			},
+			Transactions:     nil,
+			WithdrawTrieRoot: common.Hash{},
+		},
+	}
+
+	blocks := []*types.WrappedBlock{traces[0]}
+	tmpBatchData := types.NewBatchData(parentBatch, blocks, cfg.L2Config.BatchProposerConfig.PublicInputConfig)
+	batchDataList = append(batchDataList, tmpBatchData)
+
+	var s abi.ABI
+	convey.Convey("Failed to pack commitBatches", t, func() {
+		targetErr := errors.New("commitBatches error")
+		patchGuard := gomonkey.ApplyMethodFunc(s, "Pack", func(name string, args ...interface{}) ([]byte, error) {
+			return nil, targetErr
+		})
+		defer patchGuard.Reset()
+
+		err = relayer.SendCommitTx(batchDataList)
+		assert.EqualError(t, err, targetErr.Error())
+	})
+
+	patchGuard := gomonkey.ApplyMethodFunc(s, "Pack", func(name string, args ...interface{}) ([]byte, error) {
+		return nil, nil
+	})
+	defer patchGuard.Reset()
+
+	convey.Convey("Failed to send commitBatches tx to layer1", t, func() {
+		targetErr := errors.New("SendTransaction failure")
+		patchGuard.ApplyMethodFunc(relayer.rollupSender, "SendTransaction", func(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (hash common.Hash, err error) {
+			return common.Hash{}, targetErr
+		})
+		err = relayer.SendCommitTx(batchDataList)
+		assert.EqualError(t, err, targetErr.Error())
+	})
+
+	patchGuard.ApplyMethodFunc(relayer.rollupSender, "SendTransaction", func(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (hash common.Hash, err error) {
+		return common.HexToHash("0x56789abcdef1234"), nil
+	})
+
+	convey.Convey("UpdateCommitTxHashAndRollupStatus failed", t, func() {
+		targetErr := errors.New("UpdateCommitTxHashAndRollupStatus failure")
+		patchGuard.ApplyMethodFunc(db, "UpdateCommitTxHashAndRollupStatus", func(ctx context.Context, hash string, commitTxHash string, status types.RollupStatus) error {
+			return targetErr
+		})
+		err = relayer.SendCommitTx(batchDataList)
+		assert.NoError(t, err)
+	})
+
+	patchGuard.ApplyMethodFunc(db, "UpdateCommitTxHashAndRollupStatus", func(ctx context.Context, hash string, commitTxHash string, status types.RollupStatus) error {
+		return nil
+	})
+	err = relayer.SendCommitTx(batchDataList)
+	assert.NoError(t, err)
+}

bridge/relayer/relayer_test.go

@@ -102,6 +102,8 @@ func TestFunctions(t *testing.T) {
 	t.Run("TestL1RelayerProcessSaveEvents", testL1RelayerProcessSaveEvents)
 	t.Run("TestL1RelayerMsgConfirm", testL1RelayerMsgConfirm)
 	t.Run("TestL1RelayerGasOracleConfirm", testL1RelayerGasOracleConfirm)
+	t.Run("TestL1RelayerProcessGasPriceOracle", testL1RelayerProcessGasPriceOracle)
+
 	// Run l2 relayer test cases.
 	t.Run("TestCreateNewRelayer", testCreateNewRelayer)
 	t.Run("TestL2RelayerProcessSaveEvents", testL2RelayerProcessSaveEvents)
@@ -110,4 +112,6 @@ func TestFunctions(t *testing.T) {
 	t.Run("TestL2RelayerMsgConfirm", testL2RelayerMsgConfirm)
 	t.Run("TestL2RelayerRollupConfirm", testL2RelayerRollupConfirm)
 	t.Run("TestL2RelayerGasOracleConfirm", testL2RelayerGasOracleConfirm)
+	t.Run("TestLayer2RelayerProcessGasPriceOracle", testLayer2RelayerProcessGasPriceOracle)
+	t.Run("TestLayer2RelayerSendCommitTx", testLayer2RelayerSendCommitTx)
 }

bridge/sender/sender_test.go

@@ -11,7 +11,9 @@ import (
 
 	"golang.org/x/sync/errgroup"
 
+	"github.com/agiledragon/gomonkey/v2"
 	cmap "github.com/orcaman/concurrent-map"
+	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto"
@@ -63,7 +65,8 @@ func TestSender(t *testing.T) {
 	t.Run("test pending limit", testPendLimit)
 
 	t.Run("test min gas limit", testMinGasLimit)
-	t.Run("test resubmit transaction", func(t *testing.T) { testResubmitTransaction(t) })
+	t.Run("test resubmit transaction", testResubmitTransaction)
+	t.Run("test check pending transaction", testCheckPendingTransaction)
 
 	t.Run("test 1 account sender", func(t *testing.T) { testBatchSender(t, 1) })
 	t.Run("test 3 account sender", func(t *testing.T) { testBatchSender(t, 3) })
@@ -152,6 +155,95 @@ func testResubmitTransaction(t *testing.T) {
 	}
 }
 
+func testCheckPendingTransaction(t *testing.T) {
+	for _, txType := range txTypes {
+		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy.TxType = txType
+		s, err := NewSender(context.Background(), &cfgCopy, privateKeys)
+		assert.NoError(t, err)
+
+		header := &types.Header{Number: big.NewInt(100), BaseFee: big.NewInt(100)}
+		confirmed := uint64(100)
+		receipt := &types.Receipt{Status: types.ReceiptStatusSuccessful, BlockNumber: big.NewInt(90)}
+		auth := s.auths.getAccount()
+		tx := types.NewTransaction(auth.Nonce.Uint64(), common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil)
+
+		testCases := []struct {
+			name          string
+			receipt       *types.Receipt
+			receiptErr    error
+			resubmitErr   error
+			expectedCount int
+			expectedFound bool
+		}{
+			{
+				name:          "Normal case, transaction receipt exists and successful",
+				receipt:       receipt,
+				receiptErr:    nil,
+				resubmitErr:   nil,
+				expectedCount: 0,
+				expectedFound: false,
+			},
+			{
+				name:          "Resubmit case, resubmitTransaction error (not nonce) case",
+				receipt:       receipt,
+				receiptErr:    errors.New("receipt error"),
+				resubmitErr:   errors.New("resubmit error"),
+				expectedCount: 1,
+				expectedFound: true,
+			},
+			{
+				name:          "Resubmit case, resubmitTransaction success case",
+				receipt:       receipt,
+				receiptErr:    errors.New("receipt error"),
+				resubmitErr:   nil,
+				expectedCount: 1,
+				expectedFound: true,
+			},
+		}
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				var c *ethclient.Client
+				patchGuard := gomonkey.ApplyMethodFunc(c, "TransactionReceipt", func(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
+					return tc.receipt, tc.receiptErr
+				})
+				patchGuard.ApplyPrivateMethod(s, "resubmitTransaction",
+					func(feeData *FeeData, auth *bind.TransactOpts, tx *types.Transaction) (*types.Transaction, error) {
+						return tx, tc.resubmitErr
+					},
+				)
+
+				pendingTx := &PendingTransaction{id: "abc", tx: tx, submitAt: header.Number.Uint64() - s.config.EscalateBlocks - 1}
+				s.pendingTxs.Set(pendingTx.id, pendingTx)
+				s.checkPendingTransaction(header, confirmed)
+
+				if tc.receiptErr == nil {
+					expectedConfirmation := &Confirmation{
+						ID:           pendingTx.id,
+						IsSuccessful: tc.receipt.Status == types.ReceiptStatusSuccessful,
+						TxHash:       pendingTx.tx.Hash(),
+					}
+					actualConfirmation := <-s.confirmCh
+					assert.Equal(t, expectedConfirmation, actualConfirmation)
+				}
+
+				if tc.expectedFound && tc.resubmitErr == nil {
+					actualPendingTx, found := s.pendingTxs.Get(pendingTx.id)
+					assert.Equal(t, true, found)
+					assert.Equal(t, header.Number.Uint64(), actualPendingTx.submitAt)
+				}
+
+				_, found := s.pendingTxs.Get(pendingTx.id)
+				assert.Equal(t, tc.expectedFound, found)
+				assert.Equal(t, tc.expectedCount, s.pendingTxs.Count())
+				patchGuard.Reset()
+			})
+		}
+		s.Stop()
+	}
+}
+
 func testBatchSender(t *testing.T, batchSize int) {
 	for _, txType := range txTypes {
 		for len(privateKeys) < batchSize {

bridge/tests/bridge_test.go

@@ -2,31 +2,23 @@ package tests
 
 import (
 	"context"
-	"crypto/ecdsa"
-	"math/big"
 	"testing"
 
 	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/stretchr/testify/assert"
 
-	"scroll-tech/bridge/config"
+	bcmd "scroll-tech/bridge/cmd"
 	"scroll-tech/bridge/mock_bridge"
 
 	"scroll-tech/common/docker"
 )
 
 var (
-	// config
-	cfg *config.Config
-
-	// private key
-	privateKey *ecdsa.PrivateKey
-	base       *docker.App
+	base      *docker.App
+	bridgeApp *bcmd.MockApp
 
 	// clients
 	l1Client *ethclient.Client
@@ -51,99 +43,32 @@ var (
 
 func TestMain(m *testing.M) {
 	base = docker.NewDockerApp()
-
+	bridgeApp = bcmd.NewBridgeApp(base, "../config.json")
 	m.Run()
-
+	bridgeApp.Free()
 	base.Free()
 }
 
 func setupEnv(t *testing.T) {
-	var err error
-	privateKey, err = crypto.ToECDSA(common.FromHex("1212121212121212121212121212121212121212121212121212121212121212"))
-	assert.NoError(t, err)
-	messagePrivateKey, err := crypto.ToECDSA(common.FromHex("1212121212121212121212121212121212121212121212121212121212121213"))
-	assert.NoError(t, err)
-	rollupPrivateKey, err := crypto.ToECDSA(common.FromHex("1212121212121212121212121212121212121212121212121212121212121214"))
-	assert.NoError(t, err)
-	gasOraclePrivateKey, err := crypto.ToECDSA(common.FromHex("1212121212121212121212121212121212121212121212121212121212121215"))
-	assert.NoError(t, err)
-
-	// Load config.
-	cfg, err = config.NewConfig("../config.json")
-	assert.NoError(t, err)
-	cfg.L1Config.Confirmations = rpc.LatestBlockNumber
-	cfg.L1Config.RelayerConfig.MessageSenderPrivateKeys = []*ecdsa.PrivateKey{messagePrivateKey}
-	cfg.L1Config.RelayerConfig.RollupSenderPrivateKeys = []*ecdsa.PrivateKey{rollupPrivateKey}
-	cfg.L1Config.RelayerConfig.GasOracleSenderPrivateKeys = []*ecdsa.PrivateKey{gasOraclePrivateKey}
-	cfg.L2Config.Confirmations = rpc.LatestBlockNumber
-	cfg.L2Config.RelayerConfig.MessageSenderPrivateKeys = []*ecdsa.PrivateKey{messagePrivateKey}
-	cfg.L2Config.RelayerConfig.RollupSenderPrivateKeys = []*ecdsa.PrivateKey{rollupPrivateKey}
-	cfg.L2Config.RelayerConfig.GasOracleSenderPrivateKeys = []*ecdsa.PrivateKey{gasOraclePrivateKey}
 	base.RunImages(t)
 
-	// Create l1geth container.
-	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint = base.L1gethImg.Endpoint()
-	cfg.L1Config.Endpoint = base.L1gethImg.Endpoint()
-
-	// Create l2geth container.
-	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint = base.L2gethImg.Endpoint()
-	cfg.L2Config.Endpoint = base.L2gethImg.Endpoint()
-
-	// Create db container.
-	cfg.DBConfig = base.DBConfig
-
-	// Create l1geth and l2geth client.
-	l1Client, err = ethclient.Dial(cfg.L1Config.Endpoint)
+	var err error
+	l1Client, err = base.L1Client()
 	assert.NoError(t, err)
-	l2Client, err = ethclient.Dial(cfg.L2Config.Endpoint)
+	l2Client, err = base.L2Client()
 	assert.NoError(t, err)
 
-	// Create l1 and l2 auth
-	l1Auth = prepareAuth(t, l1Client, privateKey)
-	l2Auth = prepareAuth(t, l2Client, privateKey)
+	l1Cfg, l2Cfg := bridgeApp.Config.L1Config, bridgeApp.Config.L2Config
+	l1Cfg.Confirmations = 0
+	l1Cfg.RelayerConfig.SenderConfig.Confirmations = 0
+	l2Cfg.Confirmations = 0
+	l2Cfg.RelayerConfig.SenderConfig.Confirmations = 0
 
-	// send some balance to message and rollup sender
-	transferEther(t, l1Auth, l1Client, messagePrivateKey)
-	transferEther(t, l1Auth, l1Client, rollupPrivateKey)
-	transferEther(t, l1Auth, l1Client, gasOraclePrivateKey)
-	transferEther(t, l2Auth, l2Client, messagePrivateKey)
-	transferEther(t, l2Auth, l2Client, rollupPrivateKey)
-	transferEther(t, l2Auth, l2Client, gasOraclePrivateKey)
-}
-
-func transferEther(t *testing.T, auth *bind.TransactOpts, client *ethclient.Client, privateKey *ecdsa.PrivateKey) {
-	targetAddress := crypto.PubkeyToAddress(privateKey.PublicKey)
-
-	gasPrice, err := client.SuggestGasPrice(context.Background())
-	assert.NoError(t, err)
-	gasPrice.Mul(gasPrice, big.NewInt(2))
-
-	// Get pending nonce
-	nonce, err := client.PendingNonceAt(context.Background(), auth.From)
+	l1Auth, err = bind.NewKeyedTransactorWithChainID(bridgeApp.Config.L2Config.RelayerConfig.MessageSenderPrivateKeys[0], base.L1gethImg.ChainID())
 	assert.NoError(t, err)
 
-	// 200 ether should be enough
-	value, ok := big.NewInt(0).SetString("0xad78ebc5ac6200000", 0)
-	assert.Equal(t, ok, true)
-
-	tx := types.NewTx(&types.LegacyTx{
-		Nonce:    nonce,
-		To:       &targetAddress,
-		Value:    value,
-		Gas:      500000,
-		GasPrice: gasPrice,
-	})
-	signedTx, err := auth.Signer(auth.From, tx)
+	l2Auth, err = bind.NewKeyedTransactorWithChainID(bridgeApp.Config.L1Config.RelayerConfig.MessageSenderPrivateKeys[0], base.L2gethImg.ChainID())
 	assert.NoError(t, err)
-
-	err = client.SendTransaction(context.Background(), signedTx)
-	assert.NoError(t, err)
-
-	receipt, err := bind.WaitMined(context.Background(), client, signedTx)
-	assert.NoError(t, err)
-	if receipt.Status != types.ReceiptStatusSuccessful {
-		t.Fatalf("Call failed")
-	}
 }
 
 func prepareContracts(t *testing.T) {
@@ -168,27 +93,18 @@ func prepareContracts(t *testing.T) {
 	l2MessengerAddress, err = bind.WaitDeployed(context.Background(), l2Client, tx)
 	assert.NoError(t, err)
 
-	cfg.L1Config.L1MessengerAddress = l1MessengerAddress
-	cfg.L1Config.L1MessageQueueAddress = l1MessengerAddress
-	cfg.L1Config.ScrollChainContractAddress = scrollChainAddress
-	cfg.L1Config.RelayerConfig.MessengerContractAddress = l2MessengerAddress
-	cfg.L1Config.RelayerConfig.GasPriceOracleContractAddress = l1MessengerAddress
+	l1Config, l2Config := bridgeApp.Config.L1Config, bridgeApp.Config.L2Config
+	l1Config.L1MessengerAddress = l1MessengerAddress
+	l1Config.L1MessageQueueAddress = l1MessengerAddress
+	l1Config.ScrollChainContractAddress = scrollChainAddress
+	l1Config.RelayerConfig.MessengerContractAddress = l2MessengerAddress
+	l1Config.RelayerConfig.GasPriceOracleContractAddress = l1MessengerAddress
 
-	cfg.L2Config.L2MessengerAddress = l2MessengerAddress
-	cfg.L2Config.L2MessageQueueAddress = l2MessengerAddress
-	cfg.L2Config.RelayerConfig.MessengerContractAddress = l1MessengerAddress
-	cfg.L2Config.RelayerConfig.RollupContractAddress = scrollChainAddress
-	cfg.L2Config.RelayerConfig.GasPriceOracleContractAddress = l2MessengerAddress
-}
-
-func prepareAuth(t *testing.T, client *ethclient.Client, privateKey *ecdsa.PrivateKey) *bind.TransactOpts {
-	chainID, err := client.ChainID(context.Background())
-	assert.NoError(t, err)
-	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
-	assert.NoError(t, err)
-	auth.Value = big.NewInt(0) // in wei
-	assert.NoError(t, err)
-	return auth
+	l2Config.L2MessengerAddress = l2MessengerAddress
+	l2Config.L2MessageQueueAddress = l2MessengerAddress
+	l2Config.RelayerConfig.MessengerContractAddress = l1MessengerAddress
+	l2Config.RelayerConfig.RollupContractAddress = scrollChainAddress
+	l2Config.RelayerConfig.GasPriceOracleContractAddress = l2MessengerAddress
 }
 
 func TestFunction(t *testing.T) {

bridge/tests/gas_oracle_test.go

@@ -20,14 +20,14 @@ import (
 
 func testImportL1GasPrice(t *testing.T) {
 	// Create db handler and reset db.
-	db, err := database.NewOrmFactory(cfg.DBConfig)
+	db, err := database.NewOrmFactory(base.DBConfig)
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
 	defer db.Close()
 
 	prepareContracts(t)
 
-	l1Cfg := cfg.L1Config
+	l1Cfg := bridgeApp.Config.L1Config
 
 	// Create L1Relayer
 	l1Relayer, err := relayer.NewLayer1Relayer(context.Background(), db, l1Cfg.RelayerConfig)
@@ -70,14 +70,14 @@ func testImportL1GasPrice(t *testing.T) {
 
 func testImportL2GasPrice(t *testing.T) {
 	// Create db handler and reset db.
-	db, err := database.NewOrmFactory(cfg.DBConfig)
+	db, err := database.NewOrmFactory(base.DBConfig)
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
 	defer db.Close()
 
 	prepareContracts(t)
 
-	l2Cfg := cfg.L2Config
+	l2Cfg := bridgeApp.Config.L2Config
 
 	// Create L2Relayer
 	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig)
@@ -104,7 +104,7 @@ func testImportL2GasPrice(t *testing.T) {
 	}
 	batchData := types.NewBatchData(parentBatch, []*types.WrappedBlock{
 		traces[0],
-	}, cfg.L2Config.BatchProposerConfig.PublicInputConfig)
+	}, l2Cfg.BatchProposerConfig.PublicInputConfig)
 
 	// add fake batch
 	dbTx, err := db.Beginx()

bridge/tests/l1_message_relay_test.go

@@ -22,15 +22,15 @@ import (
 
 func testRelayL1MessageSucceed(t *testing.T) {
 	// Create db handler and reset db.
-	db, err := database.NewOrmFactory(cfg.DBConfig)
+	db, err := database.NewOrmFactory(base.DBConfig)
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
 	defer db.Close()
 
 	prepareContracts(t)
 
-	l1Cfg := cfg.L1Config
-	l2Cfg := cfg.L2Config
+	l1Cfg := bridgeApp.Config.L1Config
+	l2Cfg := bridgeApp.Config.L2Config
 
 	// Create L1Relayer
 	l1Relayer, err := relayer.NewLayer1Relayer(context.Background(), db, l1Cfg.RelayerConfig)

bridge/tests/l2_message_relay_test.go

@@ -22,14 +22,14 @@ import (
 
 func testRelayL2MessageSucceed(t *testing.T) {
 	// Create db handler and reset db.
-	db, err := database.NewOrmFactory(cfg.DBConfig)
+	db, err := database.NewOrmFactory(base.DBConfig)
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
 	defer db.Close()
 
 	prepareContracts(t)
 
-	l2Cfg := cfg.L2Config
+	l2Cfg := bridgeApp.Config.L2Config
 
 	// Create L2Watcher
 	confirmations := rpc.LatestBlockNumber
@@ -40,7 +40,7 @@ func testRelayL2MessageSucceed(t *testing.T) {
 	assert.NoError(t, err)
 
 	// Create L1Watcher
-	l1Cfg := cfg.L1Config
+	l1Cfg := bridgeApp.Config.L1Config
 	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1Client, 0, confirmations, l1Cfg.L1MessengerAddress, l1Cfg.L1MessageQueueAddress, l1Cfg.ScrollChainContractAddress, db)
 
 	// send message through l2 messenger contract
@@ -85,7 +85,7 @@ func testRelayL2MessageSucceed(t *testing.T) {
 	}
 	batchData := types.NewBatchData(parentBatch, []*types.WrappedBlock{
 		traces[0],
-	}, cfg.L2Config.BatchProposerConfig.PublicInputConfig)
+	}, l2Cfg.BatchProposerConfig.PublicInputConfig)
 	batchHash := batchData.Hash().String()
 
 	// add fake batch

bridge/tests/rollup_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"scroll-tech/common/types"
+	"scroll-tech/common/utils"
 
 	"scroll-tech/bridge/relayer"
 	"scroll-tech/bridge/watcher"
@@ -21,7 +22,7 @@ import (
 
 func testCommitBatchAndFinalizeBatch(t *testing.T) {
 	// Create db handler and reset db.
-	db, err := database.NewOrmFactory(cfg.DBConfig)
+	db, err := database.NewOrmFactory(base.DBConfig)
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
 	defer db.Close()
@@ -29,12 +30,12 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 	prepareContracts(t)
 
 	// Create L2Relayer
-	l2Cfg := cfg.L2Config
+	l2Cfg := bridgeApp.Config.L2Config
 	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig)
 	assert.NoError(t, err)
 
 	// Create L1Watcher
-	l1Cfg := cfg.L1Config
+	l1Cfg := bridgeApp.Config.L1Config
 	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1Client, 0, l1Cfg.Confirmations, l1Cfg.L1MessengerAddress, l1Cfg.L1MessageQueueAddress, l1Cfg.ScrollChainContractAddress, db)
 
 	// add some blocks to db
@@ -63,7 +64,7 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 	batchData := types.NewBatchData(parentBatch, []*types.WrappedBlock{
 		wrappedBlocks[0],
 		wrappedBlocks[1],
-	}, cfg.L2Config.BatchProposerConfig.PublicInputConfig)
+	}, l2Cfg.BatchProposerConfig.PublicInputConfig)
 
 	batchHash := batchData.Hash().String()
 
@@ -80,7 +81,7 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 	assert.NoError(t, dbTx.Commit())
 
 	// process pending batch and check status
-	l2Relayer.SendCommitTx([]*types.BatchData{batchData})
+	assert.NoError(t, l2Relayer.SendCommitTx([]*types.BatchData{batchData}))
 
 	status, err := db.GetRollupStatus(batchHash)
 	assert.NoError(t, err)
@@ -97,9 +98,11 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 	// fetch rollup events
 	err = l1Watcher.FetchContractEvent()
 	assert.NoError(t, err)
-	status, err = db.GetRollupStatus(batchHash)
-	assert.NoError(t, err)
-	assert.Equal(t, types.RollupCommitted, status)
+	ok := utils.TryTimes(20, func() bool {
+		status, err = db.GetRollupStatus(batchHash)
+		return err == nil && status == types.RollupCommitted
+	})
+	assert.True(t, ok)
 
 	// add dummy proof
 	tProof := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}
@@ -112,9 +115,12 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 	// process committed batch and check status
 	l2Relayer.ProcessCommittedBatches()
 
-	status, err = db.GetRollupStatus(batchHash)
-	assert.NoError(t, err)
-	assert.Equal(t, types.RollupFinalizing, status)
+	ok = utils.TryTimes(20, func() bool {
+		status, err = db.GetRollupStatus(batchHash)
+		return err == nil && status == types.RollupFinalizing
+	})
+	assert.True(t, ok)
+
 	finalizeTxHash, err := db.GetFinalizeTxHash(batchHash)
 	assert.NoError(t, err)
 	assert.Equal(t, true, finalizeTxHash.Valid)

bridge/watcher/l1_watcher.go

@@ -140,10 +140,14 @@ func (w *L1WatcherClient) FetchBlockHeader(blockHeight uint64) error {
 			log.Warn("Failed to get block", "height", height, "err", err)
 			break
 		}
+		var baseFee uint64
+		if block.BaseFee != nil {
+			baseFee = block.BaseFee.Uint64()
+		}
 		blocks = append(blocks, &types.L1BlockInfo{
 			Number:  uint64(height),
 			Hash:    block.Hash().String(),
-			BaseFee: block.BaseFee.Uint64(),
+			BaseFee: baseFee,
 		})
 	}
 

bridge/watcher/l2_watcher_test.go

@@ -131,22 +131,17 @@ func testMonitorBridgeContract(t *testing.T) {
 		t.Fatalf("Call failed")
 	}
 
-	// wait for dealing time
-	<-time.After(6 * time.Second)
-
-	var latestHeight uint64
-	latestHeight, err = l2Cli.BlockNumber(context.Background())
-	assert.NoError(t, err)
-	t.Log("Latest height is", latestHeight)
-
 	// check if we successfully stored events
-	height, err := db.GetLayer2LatestWatchedHeight()
-	assert.NoError(t, err)
-	t.Log("Height in DB is", height)
-	assert.Greater(t, height, int64(previousHeight))
-	msgs, err := db.GetL2Messages(map[string]interface{}{"status": types.MsgPending})
-	assert.NoError(t, err)
-	assert.Equal(t, 2, len(msgs))
+	assert.True(t, cutils.TryTimes(10, func() bool {
+		height, err := db.GetLayer2LatestWatchedHeight()
+		return err == nil && height > int64(previousHeight)
+	}))
+
+	// check l1 messages.
+	assert.True(t, cutils.TryTimes(10, func() bool {
+		msgs, err := db.GetL2Messages(map[string]interface{}{"status": types.MsgPending})
+		return err == nil && len(msgs) == 2
+	}))
 }
 
 func testFetchMultipleSentMessageInOneBlock(t *testing.T) {
@@ -213,17 +208,16 @@ func testFetchMultipleSentMessageInOneBlock(t *testing.T) {
 		t.Fatalf("Call failed")
 	}
 
-	// wait for dealing time
-	<-time.After(6 * time.Second)
-
 	// check if we successfully stored events
-	height, err := db.GetLayer2LatestWatchedHeight()
-	assert.NoError(t, err)
-	t.Log("LatestHeight is", height)
-	assert.Greater(t, height, int64(previousHeight)) // height must be greater than previousHeight because confirmations is 0
-	msgs, err := db.GetL2Messages(map[string]interface{}{"status": types.MsgPending})
-	assert.NoError(t, err)
-	assert.Equal(t, 5, len(msgs))
+	assert.True(t, cutils.TryTimes(10, func() bool {
+		height, err := db.GetLayer2LatestWatchedHeight()
+		return err == nil && height > int64(previousHeight)
+	}))
+
+	assert.True(t, cutils.TryTimes(10, func() bool {
+		msgs, err := db.GetL2Messages(map[string]interface{}{"status": types.MsgPending})
+		return err == nil && len(msgs) == 5
+	}))
 }
 
 func testFetchRunningMissingBlocks(t *testing.T) {
@@ -241,16 +235,17 @@ func testFetchRunningMissingBlocks(t *testing.T) {
 	address, err := bind.WaitDeployed(context.Background(), l2Cli, tx)
 	assert.NoError(t, err)
 
-	// wait for dealing time
-	<-time.After(3 * time.Second)
-
-	latestHeight, err := l2Cli.BlockNumber(context.Background())
-	assert.NoError(t, err)
-	wc := prepareWatcherClient(l2Cli, db, address)
-	wc.TryFetchRunningMissingBlocks(context.Background(), latestHeight)
-	fetchedHeight, err := db.GetL2BlocksLatestHeight()
-	assert.NoError(t, err)
-	assert.Equal(t, uint64(fetchedHeight), latestHeight)
+	ok := cutils.TryTimes(10, func() bool {
+		latestHeight, err := l2Cli.BlockNumber(context.Background())
+		if err != nil {
+			return false
+		}
+		wc := prepareWatcherClient(l2Cli, db, address)
+		wc.TryFetchRunningMissingBlocks(context.Background(), latestHeight)
+		fetchedHeight, err := db.GetL2BlocksLatestHeight()
+		return err == nil && uint64(fetchedHeight) == latestHeight
+	})
+	assert.True(t, ok)
 }
 
 func prepareWatcherClient(l2Cli *ethclient.Client, db database.OrmFactory, contractAddr common.Address) *L2WatcherClient {

build/dockerfiles/bridgehistoryapi-cross-msg-fetcher.Dockerfile

@@ -0,0 +1,21 @@
+# Download Go dependencies
+FROM golang:1.20-alpine3.16 as base
+
+WORKDIR /src
+COPY go.mod* ./
+COPY ./bridge-history-api/go.* ./
+RUN go mod download -x
+
+# Build bridgehistoryapi-cross-msg-fetcher
+FROM base as builder
+
+RUN --mount=target=. \
+    --mount=type=cache,target=/root/.cache/go-build \
+    cd /src/bridge-history-api/cmd/cross_msg_fetcher && go build -v -p 4 -o /bin/bridgehistoryapi-cross-msg-fetcher
+
+# Pull bridgehistoryapi-cross-msg-fetcher into a second stage deploy alpine container
+FROM alpine:latest
+
+COPY --from=builder /bin/bridgehistoryapi-cross-msg-fetcher /bin/
+
+ENTRYPOINT ["bridgehistoryapi-cross-msg-fetcher"]

build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile

@@ -0,0 +1,20 @@
+# Download Go dependencies
+FROM golang:1.20-alpine3.16 as base
+
+WORKDIR /src
+COPY ./bridge-history-api/go.* ./
+RUN go mod download -x
+
+# Build db_cli
+FROM base as builder
+
+RUN --mount=target=. \
+    --mount=type=cache,target=/root/.cache/go-build \
+    cd /src/bridge-history-api/cmd/db_cli && go build -v -p 4 -o /bin/db_cli
+
+# Pull db_cli into a second stage deploy alpine container
+FROM alpine:latest
+
+COPY --from=builder /bin/db_cli /bin/
+
+ENTRYPOINT ["db_cli"]

build/dockerfiles/bridgehistoryapi-server.Dockerfile

@@ -0,0 +1,21 @@
+# Download Go dependencies
+FROM golang:1.20-alpine3.16 as base
+
+WORKDIR /src
+COPY go.mod* ./
+COPY ./bridge-history-api/go.* ./
+RUN go mod download -x
+
+# Build bridgehistoryapi-server
+FROM base as builder
+
+RUN --mount=target=. \
+    --mount=type=cache,target=/root/.cache/go-build \
+    cd /src/bridge-history-api/cmd/backend_server && go build -v -p 4 -o /bin/bridgehistoryapi-server
+
+# Pull bridgehistoryapi-server into a second stage deploy alpine container
+FROM alpine:latest
+
+COPY --from=builder /bin/bridgehistoryapi-server /bin/
+
+ENTRYPOINT ["bridgehistoryapi-server"]

build/dockerfiles/coordinator.Dockerfile

@@ -26,6 +26,7 @@ COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
 COPY ./roller/go.* ./roller/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
+COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
 
 
@@ -33,7 +34,7 @@ RUN go mod download -x
 FROM base as builder
 COPY . .
 RUN cp -r ./common/libzkp/interface ./coordinator/verifier/lib
-COPY --from=zkp-builder /app/target/release/libzkp.a ./coordinator/verifier/lib/
+COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/verifier/lib/
 COPY --from=zkp-builder /app/target/release/libzktrie.so ./coordinator/verifier/lib/
 RUN cd ./coordinator && go build -v -p 4 -o /bin/coordinator ./cmd && mv verifier/lib /bin/
 

build/dockerfiles/db_cli.Dockerfile

@@ -9,6 +9,7 @@ COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
 COPY ./roller/go.* ./roller/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
+COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
 
 # Build db_cli

build/dockerfiles/event_watcher.Dockerfile

@@ -9,6 +9,7 @@ COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
 COPY ./roller/go.* ./roller/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
+COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
 
 # Build event_watcher

build/dockerfiles/gas_oracle.Dockerfile

@@ -9,6 +9,7 @@ COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
 COPY ./roller/go.* ./roller/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
+COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
 
 # Build gas_oracle

build/dockerfiles/msg_relayer.Dockerfile

@@ -9,6 +9,7 @@ COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
 COPY ./roller/go.* ./roller/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
+COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
 
 # Build msg_relayer

build/dockerfiles/rollup_relayer.Dockerfile

@@ -9,6 +9,7 @@ COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
 COPY ./roller/go.* ./roller/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
+COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
 
 # Build rollup_relayer

build/run_tests.sh

@@ -3,7 +3,7 @@ set -uex
 
 profile_name=$1
 
-exclude_dirs=("scroll-tech/bridge/cmd" "scroll-tech/bridge/tests" "scroll-tech/bridge/mock_bridge" "scroll-tech/coordinator/cmd")
+exclude_dirs=("scroll-tech/bridge/cmd" "scroll-tech/bridge/tests" "scroll-tech/bridge/mock_bridge" "scroll-tech/coordinator/cmd" "scroll-tech/coordinator/verifier")
 
 all_packages=$(go list ./... | grep -v "^scroll-tech/${profile_name}$")
 coverpkg="scroll-tech/${profile_name}"

common/docker/docker_app.go

@@ -76,14 +76,13 @@ func (b *App) RunDBImage(t *testing.T) {
 		return
 	}
 	assert.NoError(t, b.DBImg.Start())
-	var isRun bool
+
 	// try 5 times until the db is ready.
-	utils.TryTimes(10, func() bool {
+	ok := utils.TryTimes(10, func() bool {
 		db, err := sqlx.Open("postgres", b.DBImg.Endpoint())
-		isRun = err == nil && db != nil && db.Ping() == nil
-		return isRun
+		return err == nil && db != nil && db.Ping() == nil
 	})
-	assert.Equal(t, true, isRun)
+	assert.True(t, ok)
 }
 
 // Free clear all running images, double check and recycle docker container.

common/docker/l2geth/Dockerfile

@@ -1,4 +1,4 @@
-FROM scrolltech/l2geth:scroll-v3.1.4
+FROM scrolltech/l2geth:scroll-v3.1.12
 
 RUN mkdir -p /l2geth/keystore
 

common/go.mod

@@ -10,10 +10,9 @@ require (
 	github.com/mattn/go-isatty v0.0.18
 	github.com/modern-go/reflect2 v1.0.2
 	github.com/orcaman/concurrent-map v1.0.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20230321020420-127af384ed04
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20230508165858-27a3830afa61
 	github.com/stretchr/testify v1.8.2
 	github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa
-	gotest.tools v2.2.0+incompatible
 )
 
 require (
@@ -29,8 +28,8 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.5.0 // indirect
 	github.com/edsrzf/mmap-go v1.0.0 // indirect
-	github.com/ethereum/go-ethereum v1.11.4 // indirect
 	github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect
 	github.com/go-kit/kit v0.9.0 // indirect
 	github.com/go-logfmt/logfmt v0.5.1 // indirect
@@ -48,11 +47,13 @@ require (
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
 	github.com/holiman/uint256 v1.2.0 // indirect
 	github.com/huin/goupnp v1.0.3 // indirect
-	github.com/iden3/go-iden3-crypto v0.0.14 // indirect
+	github.com/iden3/go-iden3-crypto v0.0.15 // indirect
 	github.com/influxdata/influxdb v1.8.3 // indirect
 	github.com/influxdata/influxdb-client-go/v2 v2.4.0 // indirect
 	github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect
 	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
+	github.com/julienschmidt/httprouter v1.3.0 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
 	github.com/mattn/go-runewidth v0.0.14 // indirect
 	github.com/mattn/go-sqlite3 v1.14.14 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
@@ -60,7 +61,8 @@ require (
 	github.com/moby/term v0.0.0-20220808134915-39b0c02b01ae // indirect
 	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/olekukonko/tablewriter v0.0.5 // indirect
-	github.com/onsi/gomega v1.26.0 // indirect
+	github.com/onsi/ginkgo v1.16.5 // indirect
+	github.com/onsi/gomega v1.27.1 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
 	github.com/opencontainers/image-spec v1.0.2 // indirect
 	github.com/opentracing/opentracing-go v1.1.0 // indirect
@@ -73,7 +75,7 @@ require (
 	github.com/rogpeppe/go-internal v1.10.0 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/scroll-tech/zktrie v0.5.2 // indirect
+	github.com/scroll-tech/zktrie v0.5.3 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
 	github.com/sirupsen/logrus v1.9.0 // indirect
 	github.com/status-im/keycard-go v0.2.0 // indirect
@@ -83,13 +85,13 @@ require (
 	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	github.com/yusufpapurcu/wmi v1.2.2 // indirect
-	golang.org/x/crypto v0.7.0 // indirect
+	golang.org/x/crypto v0.9.0 // indirect
 	golang.org/x/mod v0.10.0 // indirect
-	golang.org/x/net v0.9.0 // indirect
+	golang.org/x/net v0.10.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/sys v0.7.0 // indirect
+	golang.org/x/sys v0.8.0 // indirect
 	golang.org/x/text v0.9.0 // indirect
-	golang.org/x/time v0.1.0 // indirect
+	golang.org/x/time v0.3.0 // indirect
 	golang.org/x/tools v0.8.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect

common/go.sum

@@ -62,6 +62,7 @@ github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMn
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/creack/pty v1.1.11/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
 github.com/dave/jennifer v1.2.0/go.mod h1:fIb+770HOpJ2fmN9EPPKOqm1vMGhB+TwXKMZhrIygKg=
@@ -90,14 +91,13 @@ github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
 github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/ethereum/go-ethereum v1.11.4 h1:KG81SnUHXWk8LJB3mBcHg/E2yLvXoiPmRMCIRxgx3cE=
-github.com/ethereum/go-ethereum v1.11.4/go.mod h1:it7x0DWnTDMfVFdXcU6Ti4KEFQynLHVRarcSlPr0HBo=
 github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c=
 github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
+github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
 github.com/getkin/kin-openapi v0.53.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
@@ -126,6 +126,7 @@ github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
 github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
+github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/gofrs/uuid v3.3.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
@@ -193,8 +194,8 @@ github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=
 github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y=
 github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/iden3/go-iden3-crypto v0.0.14 h1:HQnFchY735JRNQxof6n/Vbyon4owj4+Ku+LNAamWV6c=
-github.com/iden3/go-iden3-crypto v0.0.14/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBeOT/3UEhXsEsP3E=
+github.com/iden3/go-iden3-crypto v0.0.15 h1:4MJYlrot1l31Fzlo2sF56u7EVFeHHJkxGXXZCtESgK4=
+github.com/iden3/go-iden3-crypto v0.0.15/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBeOT/3UEhXsEsP3E=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/influxdata/flux v0.65.1/go.mod h1:J754/zds0vvpfwuq7Gc2wRdVwEodfpCFM7mYlOw2LqY=
 github.com/influxdata/influxdb v1.8.3 h1:WEypI1BQFTT4teLM+1qkEcvUi0dAvopAI/ir0vAiBg8=
@@ -223,6 +224,7 @@ github.com/jsternberg/zap-logfmt v1.0.0/go.mod h1:uvPs/4X51zdkcm5jXl5SYoN+4RK21K
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U=
+github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
 github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
 github.com/jwilder/encoding v0.0.0-20170811194829-b4e1701a28ef/go.mod h1:Ct9fl0F6iIOGgxJ5npU/IUOhOhqlVrGjyIZc8/MagT0=
 github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
@@ -238,9 +240,11 @@ github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFB
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg=
 github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
 github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
@@ -289,21 +293,23 @@ github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
 github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
 github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae/go.mod h1:qAyveg+e4CE+eKJXWVjKXM4ck2QobLqTDytGJbLLhJg=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
+github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
-github.com/onsi/ginkgo v1.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA=
 github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
+github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
-github.com/onsi/gomega v1.26.0 h1:03cDLK28U6hWvCAns6NeydX3zIm4SF3ci69ulidS32Q=
-github.com/onsi/gomega v1.26.0/go.mod h1:r+zV744Re+DiYCIPRlYOTxn0YkOLcAnW8k1xXdMPGhM=
+github.com/onsi/gomega v1.27.1 h1:rfztXRbg6nv/5f+Raen9RcGoSecHIFgBBLQK3Wdj754=
+github.com/onsi/gomega v1.27.1/go.mod h1:aHX5xOykVYzWOV4WqQy0sy8BQptgukenXpCXfadcIAw=
 github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
 github.com/opencontainers/image-spec v1.0.2 h1:9yCKha/T5XdGtO0q9Q9a6T5NUCsTn/DrBg0D7ufOcFM=
@@ -320,6 +326,7 @@ github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQm
 github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0=
 github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -346,16 +353,17 @@ github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUc
 github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeCE=
 github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230321020420-127af384ed04 h1:PpI31kaBVm6+7sZtyK03Ex0QIg3P821Ktae0FHFh7IM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230321020420-127af384ed04/go.mod h1:jH8c08L9K8Hieaf0r/ur2P/cpesn4dFhmLm2Mmoi8kI=
-github.com/scroll-tech/zktrie v0.5.2 h1:U34jPXMLGOlRHfdvYp5VVgOcC0RuPeJmcS3bWotCWiY=
-github.com/scroll-tech/zktrie v0.5.2/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20230508165858-27a3830afa61 h1:4fslVpNOPLeJPYX3tivrVWgqNvChPs7/y9OqWvQSNCw=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20230508165858-27a3830afa61/go.mod h1:45PZqlQCqV0dU4o4+SE8LoJLEvXkK5j45ligvbih9QY=
+github.com/scroll-tech/zktrie v0.5.3 h1:jjzQchGU6XPL5s1C5bwwivSadefSRuYASE9OL7UKAdE=
+github.com/scroll-tech/zktrie v0.5.3/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/segmentio/kafka-go v0.1.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=
 github.com/segmentio/kafka-go v0.2.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
@@ -423,8 +431,8 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.7.0 h1:AvwMYaRytfdeVt3u6mLaxYtErKYjxA2OXjJ1HHq6t3A=
-golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
+golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
+golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
 golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -476,8 +484,8 @@ golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81R
 golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -524,16 +532,18 @@ golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -547,8 +557,8 @@ golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxb
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.1.0 h1:xYY+Bajn2a7VBmTM5GikTmnK8ZuX8YgnQCqZpbBNtmA=
-golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
+golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -577,6 +587,7 @@ golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapK
 golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20200108203644-89082a384178/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
 golang.org/x/tools v0.8.0 h1:vSDcovVPld282ceKgDimkRSC8kpaH1dgyc9UMzlt84Y=
@@ -650,8 +661,6 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
-gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
 gotest.tools/v3 v3.4.0 h1:ZazjZUfuVeZGLAmlKKuyv3IKP5orXcwtOwDQH6YVr6o=
 gotest.tools/v3 v3.4.0/go.mod h1:CtbdzLSsqVhDgMtKsx03ird5YTGB3ar27v0u/yKBW5g=

common/libzkp/impl/Cargo.lock

@@ -241,6 +241,12 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
 
+[[package]]
+name = "base64"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
+
 [[package]]
 name = "base64ct"
 version = "1.0.1"
@@ -301,9 +307,9 @@ dependencies = [
 
 [[package]]
 name = "blake2b_simd"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72936ee4afc7f8f736d1c38383b56480b5497b4617b4a77bdbf1d2ababc76127"
+checksum = "3c2f0dc9a68c6317d884f97cc36cf5a3d20ba14ce404227df55e1af708ab04bc"
 dependencies = [
  "arrayref",
  "arrayvec 0.7.2",
@@ -339,7 +345,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
 dependencies = [
  "block-padding 0.2.1",
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
 ]
 
 [[package]]
@@ -348,7 +354,7 @@ version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0bf7fe51849ea569fd452f37822f606a5cabb684dc918707a0193fd4664ff324"
 dependencies = [
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
 ]
 
 [[package]]
@@ -402,7 +408,7 @@ checksum = "8f1e260c3a9040a7c19a12468758f4c16f31a81a1fe087482be9570ec864bb6c"
 [[package]]
 name = "bus-mapping"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=goerli-0215#3395fe1abfb39000da19631af27508e33437295d"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=v0.3#c1c400436fd60b2e80e223e4c10cbff38d41e307"
 dependencies = [
  "eth-types",
  "ethers-core",
@@ -423,6 +429,7 @@ dependencies = [
  "pallet-evm-precompile-curve25519",
  "pallet-evm-precompile-modexp",
  "pallet-evm-precompile-simple",
+ "poseidon-circuit",
  "primitive-types 0.12.1",
  "rand 0.8.5",
  "serde",
@@ -457,9 +464,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "bytes"
-version = "1.2.1"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec8a7b6a70fde80372154c65702f00a0f56f3e1c36abbc6c440484be248856db"
+checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
 dependencies = [
  "serde",
 ]
@@ -532,7 +539,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ee52072ec15386f770805afd189a01c8841be8696bed250fa2f13c4c0d6dfb7"
 dependencies = [
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
 ]
 
 [[package]]
@@ -621,7 +628,7 @@ dependencies = [
  "bech32",
  "blake2",
  "digest 0.10.3",
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
  "hex",
  "ripemd",
  "serde",
@@ -639,9 +646,9 @@ checksum = "722e23542a15cea1f65d4a1419c4cfd7a26706c70871a13a04238ca3f40f1661"
 
 [[package]]
 name = "constant_time_eq"
-version = "0.1.5"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
+checksum = "13418e745008f7349ec7e449155f419a61b92b58a99cc3616942b926825ec76b"
 
 [[package]]
 name = "convert_case"
@@ -669,8 +676,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-entity"
-version = "0.92.0"
-source = "git+https://github.com/paritytech/wasmtime.git?branch=v5.0.0_lto_fix#8a02705ad378108e43abe23c538688adf73f3b71"
+version = "0.93.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cf583f7b093f291005f9fb1323e2c37f6ee4c7909e39ce016b2e8360d461705"
 dependencies = [
  "serde",
 ]
@@ -741,7 +749,7 @@ version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f2b443d17d49dad5ef0ede301c3179cc923b8822f3393b4d2c28c269dd4a122"
 dependencies = [
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
  "rand_core 0.6.3",
  "subtle",
  "zeroize",
@@ -753,7 +761,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8"
 dependencies = [
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
  "typenum",
 ]
 
@@ -763,7 +771,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b584a330336237c1eecd3e94266efb216c56ed91225d634cb2991c5f3fd1aeab"
 dependencies = [
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
  "subtle",
 ]
 
@@ -773,7 +781,7 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"
 dependencies = [
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
  "subtle",
 ]
 
@@ -922,7 +930,7 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
 dependencies = [
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
 ]
 
 [[package]]
@@ -1053,7 +1061,7 @@ dependencies = [
  "der",
  "digest 0.10.3",
  "ff",
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
  "group",
  "pkcs8",
  "rand_core 0.6.3",
@@ -1136,11 +1144,10 @@ dependencies = [
 [[package]]
 name = "eth-types"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=goerli-0215#3395fe1abfb39000da19631af27508e33437295d"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=v0.3#c1c400436fd60b2e80e223e4c10cbff38d41e307"
 dependencies = [
  "ethers-core",
  "ethers-signers",
- "halo2-mpt-circuits",
  "halo2_proofs",
  "hex",
  "itertools",
@@ -1148,6 +1155,7 @@ dependencies = [
  "libsecp256k1",
  "num",
  "num-bigint",
+ "poseidon-circuit",
  "regex",
  "serde",
  "serde_json",
@@ -1212,7 +1220,7 @@ checksum = "6a89fb87a9e103f71b903b80b670200b54cc67a07578f070681f1fffb7396fb7"
 dependencies = [
  "bytes",
  "ethereum-types 0.14.1",
- "hash-db",
+ "hash-db 0.15.2",
  "hash256-std-hasher",
  "parity-scale-codec",
  "rlp",
@@ -1265,7 +1273,7 @@ dependencies = [
  "elliptic-curve",
  "ethabi",
  "fastrlp",
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
  "hex",
  "k256",
  "proc-macro2",
@@ -1395,13 +1403,27 @@ dependencies = [
  "sha3 0.10.1",
 ]
 
+[[package]]
+name = "expander"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f360349150728553f92e4c997a16af8915f418d3a0f21b440d34c5632f16ed84"
+dependencies = [
+ "blake2",
+ "fs-err",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "external-tracer"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=goerli-0215#3395fe1abfb39000da19631af27508e33437295d"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=v0.3#c1c400436fd60b2e80e223e4c10cbff38d41e307"
 dependencies = [
  "eth-types",
  "geth-utils",
+ "log",
  "serde",
  "serde_json",
 ]
@@ -1506,7 +1528,7 @@ dependencies = [
 [[package]]
 name = "fp-evm"
 version = "3.0.0-dev"
-source = "git+https://github.com/paritytech/frontier?rev=73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca#73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca"
+source = "git+https://github.com/paritytech/frontier?rev=76ad4c8f#76ad4c8fe970e15fafcdd931fa00d8af237ec513"
 dependencies = [
  "evm",
  "frame-support",
@@ -1531,9 +1553,10 @@ dependencies = [
 [[package]]
 name = "frame-support"
 version = "4.0.0-dev"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "bitflags",
+ "environmental",
  "frame-metadata",
  "frame-support-procedural",
  "impl-trait-for-tuples",
@@ -1563,7 +1586,7 @@ dependencies = [
 [[package]]
 name = "frame-support-procedural"
 version = "4.0.0-dev"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "Inflector",
  "cfg-expr",
@@ -1578,7 +1601,7 @@ dependencies = [
 [[package]]
 name = "frame-support-procedural-tools"
 version = "4.0.0-dev"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "frame-support-procedural-tools-derive",
  "proc-macro-crate",
@@ -1590,13 +1613,19 @@ dependencies = [
 [[package]]
 name = "frame-support-procedural-tools-derive"
 version = "3.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
+[[package]]
+name = "fs-err"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0845fa252299212f0389d64ba26f34fa32cfe41588355f21ed507c59a0f64541"
+
 [[package]]
 name = "funty"
 version = "2.0.0"
@@ -1711,7 +1740,7 @@ dependencies = [
 [[package]]
 name = "gadgets"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=goerli-0215#3395fe1abfb39000da19631af27508e33437295d"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=v0.3#c1c400436fd60b2e80e223e4c10cbff38d41e307"
 dependencies = [
  "digest 0.7.6",
  "eth-types",
@@ -1740,9 +1769,9 @@ dependencies = [
 
 [[package]]
 name = "generic-array"
-version = "0.14.5"
+version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd48d33ec7f05fbfa152300fdad764757cbded343c1aa1cff2fbaf4134851803"
+checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
 dependencies = [
  "typenum",
  "version_check",
@@ -1751,7 +1780,7 @@ dependencies = [
 [[package]]
 name = "geth-utils"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=goerli-0215#3395fe1abfb39000da19631af27508e33437295d"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=v0.3#c1c400436fd60b2e80e223e4c10cbff38d41e307"
 dependencies = [
  "env_logger",
  "gobuild",
@@ -1877,7 +1906,7 @@ dependencies = [
 [[package]]
 name = "halo2-mpt-circuits"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/mpt-circuit.git?branch=scroll-dev-0216#051b5efc54512d1422eba35338364473fe3a65c0"
+source = "git+https://github.com/scroll-tech/mpt-circuit.git?branch=goerli-0215-dual-hash#ae8acdf37eafbbb5b6dffcb9e977dab465970c83"
 dependencies = [
  "halo2_proofs",
  "hex",
@@ -1979,7 +2008,7 @@ dependencies = [
 [[package]]
 name = "halo2_proofs"
 version = "0.2.0"
-source = "git+https://github.com/scroll-tech/halo2.git?branch=scroll-dev-0220#49f4c58908095b46b4f0983404c12106b725df4e"
+source = "git+https://github.com/scroll-tech/halo2.git?branch=scroll-dev-0220#5689a747c6acf9f7316b73dbe5ce4a1b3628c60c"
 dependencies = [
  "ark-std",
  "blake2b_simd",
@@ -2050,6 +2079,12 @@ version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d23bd4e7b5eda0d0f3a307e8b381fdc8ba9000f26fbe912250c0a4cc3956364a"
 
+[[package]]
+name = "hash-db"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e7d7786361d7425ae2fe4f9e407eb0efaa0840f5212d109cc018c40c35c6ab4"
+
 [[package]]
 name = "hash256-std-hasher"
 version = "0.15.2"
@@ -2073,6 +2108,9 @@ name = "hashbrown"
 version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
+dependencies = [
+ "ahash 0.8.3",
+]
 
 [[package]]
 name = "hashers"
@@ -2140,7 +2178,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "17ea0a1394df5b6574da6e0c1ade9e78868c9fb0a4e5ef4428e32da4676b85b1"
 dependencies = [
  "digest 0.9.0",
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
  "hmac 0.8.1",
 ]
 
@@ -2437,7 +2475,7 @@ checksum = "f9b7d56ba4a8344d6be9729995e6b06f928af29998cdf79fe390cbf6b1fee838"
 [[package]]
 name = "keccak256"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=goerli-0215#3395fe1abfb39000da19631af27508e33437295d"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=v0.3#c1c400436fd60b2e80e223e4c10cbff38d41e307"
 dependencies = [
  "env_logger",
  "eth-types",
@@ -2613,12 +2651,11 @@ dependencies = [
 
 [[package]]
 name = "memory-db"
-version = "0.31.0"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e0c7cba9ce19ac7ffd2053ac9f49843bbd3f4318feedfd74e85c19d5fb0ba66"
+checksum = "808b50db46293432a45e63bc15ea51e0ab4c0a1647b8eb114e31a3e698dd6fbe"
 dependencies = [
- "hash-db",
- "hashbrown 0.12.3",
+ "hash-db 0.16.0",
 ]
 
 [[package]]
@@ -2678,7 +2715,7 @@ dependencies = [
 [[package]]
 name = "mock"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=goerli-0215#3395fe1abfb39000da19631af27508e33437295d"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=v0.3#c1c400436fd60b2e80e223e4c10cbff38d41e307"
 dependencies = [
  "eth-types",
  "ethers-core",
@@ -2693,13 +2730,12 @@ dependencies = [
 [[package]]
 name = "mpt-zktrie"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=goerli-0215#3395fe1abfb39000da19631af27508e33437295d"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=v0.3#c1c400436fd60b2e80e223e4c10cbff38d41e307"
 dependencies = [
  "bus-mapping",
  "eth-types",
  "halo2-mpt-circuits",
  "halo2_proofs",
- "hex",
  "lazy_static",
  "log",
  "num-bigint",
@@ -2857,7 +2893,7 @@ checksum = "21326818e99cfe6ce1e524c2a805c189a99b5ae555a35d19f9a284b427d86afa"
 [[package]]
 name = "pallet-evm-precompile-blake2"
 version = "2.0.0-dev"
-source = "git+https://github.com/paritytech/frontier?rev=73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca#73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca"
+source = "git+https://github.com/paritytech/frontier?rev=76ad4c8f#76ad4c8fe970e15fafcdd931fa00d8af237ec513"
 dependencies = [
  "fp-evm",
 ]
@@ -2865,7 +2901,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-bn128"
 version = "2.0.0-dev"
-source = "git+https://github.com/paritytech/frontier?rev=73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca#73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca"
+source = "git+https://github.com/paritytech/frontier?rev=76ad4c8f#76ad4c8fe970e15fafcdd931fa00d8af237ec513"
 dependencies = [
  "fp-evm",
  "sp-core",
@@ -2875,7 +2911,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-curve25519"
 version = "1.0.0-dev"
-source = "git+https://github.com/paritytech/frontier?rev=73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca#73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca"
+source = "git+https://github.com/paritytech/frontier?rev=76ad4c8f#76ad4c8fe970e15fafcdd931fa00d8af237ec513"
 dependencies = [
  "curve25519-dalek 4.0.0-pre.1",
  "fp-evm",
@@ -2884,7 +2920,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-modexp"
 version = "2.0.0-dev"
-source = "git+https://github.com/paritytech/frontier?rev=73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca#73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca"
+source = "git+https://github.com/paritytech/frontier?rev=76ad4c8f#76ad4c8fe970e15fafcdd931fa00d8af237ec513"
 dependencies = [
  "fp-evm",
  "num",
@@ -2893,7 +2929,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-simple"
 version = "2.0.0-dev"
-source = "git+https://github.com/paritytech/frontier?rev=73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca#73e6223e8bc26bf8e57cd9b212f1bc2fd288c5ca"
+source = "git+https://github.com/paritytech/frontier?rev=76ad4c8f#76ad4c8fe970e15fafcdd931fa00d8af237ec513"
 dependencies = [
  "fp-evm",
  "ripemd",
@@ -3216,7 +3252,7 @@ dependencies = [
 [[package]]
 name = "poseidon-circuit"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/poseidon-circuit.git?branch=scroll-dev-0215#1eea94a77a2252f2e8ca4eb5b98b66934b32623e"
+source = "git+https://github.com/scroll-tech/poseidon-circuit.git?branch=scroll-dev-0215#b5e9b1440de088648a8661ccefbd28f7ebb3f252"
 dependencies = [
  "bitvec 1.0.1",
  "halo2_proofs",
@@ -3515,11 +3551,11 @@ checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
 
 [[package]]
 name = "reqwest"
-version = "0.11.11"
+version = "0.11.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b75aa69a3f06bbcc66ede33af2af253c6f7a86b1ca0033f60c580a27074fbf92"
+checksum = "0ba30cc2c0cd02af1222ed216ba659cdb2f879dfe3181852fe7c50b1d0005949"
 dependencies = [
- "base64 0.13.0",
+ "base64 0.21.0",
  "bytes",
  "encoding_rs",
  "futures-core",
@@ -3531,9 +3567,9 @@ dependencies = [
  "hyper-rustls",
  "ipnet",
  "js-sys",
- "lazy_static",
  "log",
  "mime",
+ "once_cell",
  "percent-encoding",
  "pin-project-lite",
  "rustls",
@@ -3818,7 +3854,7 @@ checksum = "3be24c1842290c45df0a7bf069e0c268a747ad05a192f2fd7dcfdbc1cba40928"
 dependencies = [
  "base16ct",
  "der",
- "generic-array 0.14.5",
+ "generic-array 0.14.6",
  "pkcs8",
  "subtle",
  "zeroize",
@@ -4109,9 +4145,9 @@ dependencies = [
 [[package]]
 name = "sp-api"
 version = "4.0.0-dev"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
- "hash-db",
+ "hash-db 0.16.0",
  "log",
  "parity-scale-codec",
  "sp-api-proc-macro",
@@ -4127,9 +4163,11 @@ dependencies = [
 [[package]]
 name = "sp-api-proc-macro"
 version = "4.0.0-dev"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
+ "Inflector",
  "blake2",
+ "expander",
  "proc-macro-crate",
  "proc-macro2",
  "quote",
@@ -4139,7 +4177,7 @@ dependencies = [
 [[package]]
 name = "sp-application-crypto"
 version = "7.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -4152,7 +4190,7 @@ dependencies = [
 [[package]]
 name = "sp-arithmetic"
 version = "6.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "integer-sqrt",
  "num-traits",
@@ -4166,7 +4204,7 @@ dependencies = [
 [[package]]
 name = "sp-core"
 version = "7.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "array-bytes",
  "base58 0.2.0",
@@ -4176,7 +4214,7 @@ dependencies = [
  "dyn-clonable",
  "ed25519-zebra",
  "futures",
- "hash-db",
+ "hash-db 0.16.0",
  "hash256-std-hasher",
  "impl-serde 0.4.0",
  "lazy_static",
@@ -4209,9 +4247,9 @@ dependencies = [
 [[package]]
 name = "sp-core-hashing"
 version = "5.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
- "blake2",
+ "blake2b_simd",
  "byteorder",
  "digest 0.10.3",
  "sha2 0.10.2",
@@ -4223,7 +4261,7 @@ dependencies = [
 [[package]]
 name = "sp-core-hashing-proc-macro"
 version = "5.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4234,7 +4272,7 @@ dependencies = [
 [[package]]
 name = "sp-debug-derive"
 version = "5.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4244,7 +4282,7 @@ dependencies = [
 [[package]]
 name = "sp-externalities"
 version = "0.13.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "environmental",
  "parity-scale-codec",
@@ -4255,7 +4293,7 @@ dependencies = [
 [[package]]
 name = "sp-inherents"
 version = "4.0.0-dev"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "async-trait",
  "impl-trait-for-tuples",
@@ -4270,7 +4308,7 @@ dependencies = [
 [[package]]
 name = "sp-io"
 version = "7.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "bytes",
  "ed25519",
@@ -4295,9 +4333,8 @@ dependencies = [
 [[package]]
 name = "sp-keystore"
 version = "0.13.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
- "async-trait",
  "futures",
  "merlin",
  "parity-scale-codec",
@@ -4311,7 +4348,7 @@ dependencies = [
 [[package]]
 name = "sp-panic-handler"
 version = "5.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "backtrace",
  "lazy_static",
@@ -4321,7 +4358,7 @@ dependencies = [
 [[package]]
 name = "sp-runtime"
 version = "7.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "either",
  "hash256-std-hasher",
@@ -4343,7 +4380,7 @@ dependencies = [
 [[package]]
 name = "sp-runtime-interface"
 version = "7.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "bytes",
  "impl-trait-for-tuples",
@@ -4361,7 +4398,7 @@ dependencies = [
 [[package]]
 name = "sp-runtime-interface-proc-macro"
 version = "6.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "Inflector",
  "proc-macro-crate",
@@ -4373,7 +4410,7 @@ dependencies = [
 [[package]]
 name = "sp-staking"
 version = "4.0.0-dev"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -4385,9 +4422,9 @@ dependencies = [
 [[package]]
 name = "sp-state-machine"
 version = "0.13.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
- "hash-db",
+ "hash-db 0.16.0",
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.1",
@@ -4405,12 +4442,12 @@ dependencies = [
 [[package]]
 name = "sp-std"
 version = "5.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 
 [[package]]
 name = "sp-storage"
 version = "7.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "impl-serde 0.4.0",
  "parity-scale-codec",
@@ -4423,7 +4460,7 @@ dependencies = [
 [[package]]
 name = "sp-tracing"
 version = "6.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "parity-scale-codec",
  "sp-std",
@@ -4435,11 +4472,11 @@ dependencies = [
 [[package]]
 name = "sp-trie"
 version = "7.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "ahash 0.8.3",
- "hash-db",
- "hashbrown 0.12.3",
+ "hash-db 0.16.0",
+ "hashbrown 0.13.2",
  "lazy_static",
  "memory-db",
  "nohash-hasher",
@@ -4458,7 +4495,7 @@ dependencies = [
 [[package]]
 name = "sp-version"
 version = "5.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "impl-serde 0.4.0",
  "parity-scale-codec",
@@ -4475,7 +4512,7 @@ dependencies = [
 [[package]]
 name = "sp-version-proc-macro"
 version = "4.0.0-dev"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "parity-scale-codec",
  "proc-macro2",
@@ -4486,7 +4523,7 @@ dependencies = [
 [[package]]
 name = "sp-wasm-interface"
 version = "7.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "anyhow",
  "impl-trait-for-tuples",
@@ -4500,7 +4537,7 @@ dependencies = [
 [[package]]
 name = "sp-weights"
 version = "4.0.0"
-source = "git+https://github.com/paritytech/substrate?branch=master#d97a18851f9da0b1c299daa8fb18022794065779"
+source = "git+https://github.com/paritytech/substrate?branch=master#8f0b0f69e79c0dcf1487b9858792439c35a1d4cd"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -4844,9 +4881,9 @@ checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
 
 [[package]]
 name = "tracing"
-version = "0.1.35"
+version = "0.1.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a400e31aa60b9d44a52a8ee0343b5b18566b03a8321e0d321f695cf56e940160"
+checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
 dependencies = [
  "cfg-if 1.0.0",
  "pin-project-lite",
@@ -4856,9 +4893,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.22"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11c75893af559bc8e10716548bdef5cb2b983f8e637db9d0e15126b61b484ee2"
+checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4930,12 +4967,12 @@ dependencies = [
 
 [[package]]
 name = "trie-db"
-version = "0.24.0"
+version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "004e1e8f92535694b4cb1444dc5a8073ecf0815e3357f729638b9f8fc4062908"
+checksum = "634d75c77ea43f2ad8ea9d9c58de49dfc9c3995bdef32b503df7883ff054e7f1"
 dependencies = [
- "hash-db",
- "hashbrown 0.12.3",
+ "hash-db 0.16.0",
+ "hashbrown 0.13.2",
  "log",
  "rustc-hex",
  "smallvec",
@@ -4943,11 +4980,11 @@ dependencies = [
 
 [[package]]
 name = "trie-root"
-version = "0.17.0"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a36c5ca3911ed3c9a5416ee6c679042064b93fc637ded67e25f92e68d783891"
+checksum = "d4ed310ef5ab98f5fa467900ed906cb9232dd5376597e00fd4cba2a449d06c0b"
 dependencies = [
- "hash-db",
+ "hash-db 0.16.0",
 ]
 
 [[package]]
@@ -4956,7 +4993,7 @@ version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1631b201eb031b563d2e85ca18ec8092508e262a3196ce9bd10a67ec87b9f5c"
 dependencies = [
- "hash-db",
+ "hash-db 0.15.2",
  "rlp",
 ]
 
@@ -5001,7 +5038,7 @@ checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
 dependencies = [
  "cfg-if 1.0.0",
  "digest 0.10.3",
- "rand 0.8.5",
+ "rand 0.7.3",
  "static_assertions",
 ]
 
@@ -5013,8 +5050,8 @@ checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
 
 [[package]]
 name = "types"
-version = "0.1.0"
-source = "git+https://github.com/scroll-tech/scroll-zkevm?branch=goerli-0215#1f7a3c7da2370860087555a11346bd5d96f609fd"
+version = "0.3.0"
+source = "git+https://github.com/scroll-tech/scroll-zkevm?rev=78ab7a7#78ab7a770f7753fa88c8aab4969296f06e1c811a"
 dependencies = [
  "base64 0.13.0",
  "blake2",
@@ -5330,9 +5367,9 @@ dependencies = [
 
 [[package]]
 name = "wasmparser"
-version = "0.96.0"
+version = "0.100.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adde01ade41ab9a5d10ec8ed0bb954238cf8625b5cd5a13093d6de2ad9c2be1a"
+checksum = "64b20236ab624147dfbb62cf12a19aaf66af0e41b8398838b66e997d07d269d4"
 dependencies = [
  "indexmap",
  "url",
@@ -5340,8 +5377,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime"
-version = "5.0.0"
-source = "git+https://github.com/paritytech/wasmtime.git?branch=v5.0.0_lto_fix#8a02705ad378108e43abe23c538688adf73f3b71"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6e89f9819523447330ffd70367ef4a18d8c832e24e8150fe054d1d912841632"
 dependencies = [
  "anyhow",
  "bincode",
@@ -5364,16 +5402,18 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-asm-macros"
-version = "5.0.0"
-source = "git+https://github.com/paritytech/wasmtime.git?branch=v5.0.0_lto_fix#8a02705ad378108e43abe23c538688adf73f3b71"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bd3a5e46c198032da934469f3a6e48649d1f9142438e4fd4617b68a35644b8a"
 dependencies = [
  "cfg-if 1.0.0",
 ]
 
 [[package]]
 name = "wasmtime-environ"
-version = "5.0.0"
-source = "git+https://github.com/paritytech/wasmtime.git?branch=v5.0.0_lto_fix#8a02705ad378108e43abe23c538688adf73f3b71"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a6db9fc52985ba06ca601f2ff0ff1f526c5d724c7ac267b47326304b0c97883"
 dependencies = [
  "anyhow",
  "cranelift-entity",
@@ -5390,8 +5430,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-jit"
-version = "5.0.0"
-source = "git+https://github.com/paritytech/wasmtime.git?branch=v5.0.0_lto_fix#8a02705ad378108e43abe23c538688adf73f3b71"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b77e3a52cd84d0f7f18554afa8060cfe564ccac61e3b0802d3fd4084772fa5f6"
 dependencies = [
  "addr2line 0.17.0",
  "anyhow",
@@ -5412,16 +5453,18 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-jit-debug"
-version = "5.0.0"
-source = "git+https://github.com/paritytech/wasmtime.git?branch=v5.0.0_lto_fix#8a02705ad378108e43abe23c538688adf73f3b71"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0245e8a9347017c7185a72e215218a802ff561545c242953c11ba00fccc930f"
 dependencies = [
  "once_cell",
 ]
 
 [[package]]
 name = "wasmtime-jit-icache-coherence"
-version = "5.0.0"
-source = "git+https://github.com/paritytech/wasmtime.git?branch=v5.0.0_lto_fix#8a02705ad378108e43abe23c538688adf73f3b71"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67d412e9340ab1c83867051d8d1d7c90aa8c9afc91da086088068e2734e25064"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
@@ -5430,8 +5473,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-runtime"
-version = "5.0.0"
-source = "git+https://github.com/paritytech/wasmtime.git?branch=v5.0.0_lto_fix#8a02705ad378108e43abe23c538688adf73f3b71"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d594e791b5fdd4dbaf8cf7ae62f2e4ff85018ce90f483ca6f42947688e48827d"
 dependencies = [
  "anyhow",
  "cc",
@@ -5453,8 +5497,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-types"
-version = "5.0.0"
-source = "git+https://github.com/paritytech/wasmtime.git?branch=v5.0.0_lto_fix#8a02705ad378108e43abe23c538688adf73f3b71"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6688d6f96d4dbc1f89fab626c56c1778936d122b5f4ae7a57c2eb42b8d982e2"
 dependencies = [
  "cranelift-entity",
  "serde",
@@ -5681,8 +5726,8 @@ dependencies = [
 
 [[package]]
 name = "zkevm"
-version = "0.1.0"
-source = "git+https://github.com/scroll-tech/scroll-zkevm?branch=goerli-0215#1f7a3c7da2370860087555a11346bd5d96f609fd"
+version = "0.3.0"
+source = "git+https://github.com/scroll-tech/scroll-zkevm?rev=78ab7a7#78ab7a770f7753fa88c8aab4969296f06e1c811a"
 dependencies = [
  "anyhow",
  "blake2",
@@ -5719,7 +5764,7 @@ dependencies = [
 [[package]]
 name = "zkevm-circuits"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=goerli-0215#3395fe1abfb39000da19631af27508e33437295d"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?branch=v0.3#c1c400436fd60b2e80e223e4c10cbff38d41e307"
 dependencies = [
  "array-init",
  "bus-mapping",
@@ -5759,6 +5804,7 @@ name = "zkp"
 version = "0.1.0"
 dependencies = [
  "env_logger",
+ "halo2_proofs",
  "libc",
  "log",
  "once_cell",
@@ -5772,7 +5818,7 @@ dependencies = [
 [[package]]
 name = "zktrie"
 version = "0.1.2"
-source = "git+https://github.com/lispc/zktrie?branch=scroll-dev-0215#0bd8820fea4fea1ad10371ae9cae49622bd5413b"
+source = "git+https://github.com/scroll-tech/zktrie.git?branch=scroll-dev-0226#1a5562f663a81ff903383db69dc6c9404b63e69d"
 dependencies = [
  "gobuild",
 ]

common/libzkp/impl/Cargo.toml

@@ -5,18 +5,17 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
-crate-type = ["staticlib"]
+crate-type = ["cdylib"]
 
 [patch."https://github.com/privacy-scaling-explorations/halo2.git"]
 halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "scroll-dev-0220"  }
 [patch."https://github.com/privacy-scaling-explorations/poseidon.git"]
 poseidon = { git = "https://github.com/scroll-tech/poseidon.git", branch = "scroll-dev-0220" }
-[patch."https://github.com/scroll-tech/zktrie.git"]
-zktrie = { git = "https://github.com/lispc/zktrie", branch = "scroll-dev-0215" }
 
 [dependencies]
-zkevm = { git = "https://github.com/scroll-tech/scroll-zkevm", branch="goerli-0215" }
-types = { git = "https://github.com/scroll-tech/scroll-zkevm", branch="goerli-0215" }
+zkevm = { git = "https://github.com/scroll-tech/scroll-zkevm", rev="78ab7a7" }
+types = { git = "https://github.com/scroll-tech/scroll-zkevm", rev="78ab7a7" }
+halo2_proofs = { git = "https://github.com/privacy-scaling-explorations/halo2.git", tag = "v2022_09_10" }
 
 log = "0.4"
 env_logger = "0.9.0"

common/libzkp/impl/src/prove.rs

@@ -1,4 +1,5 @@
 use crate::utils::{c_char_to_str, c_char_to_vec, vec_to_c_char};
+use halo2_proofs::SerdeFormat;
 use libc::c_char;
 use std::cell::OnceCell;
 use std::panic;
@@ -17,8 +18,8 @@ pub unsafe extern "C" fn init_prover(params_path: *const c_char, seed_path: *con
 
     let params_path = c_char_to_str(params_path);
     let seed_path = c_char_to_str(seed_path);
-    let params = load_params(params_path, *DEGREE).unwrap();
-    let agg_params = load_params(params_path, *AGG_DEGREE).unwrap();
+    let params = load_params(params_path, *DEGREE, SerdeFormat::RawBytesUnchecked).unwrap();
+    let agg_params = load_params(params_path, *AGG_DEGREE, SerdeFormat::RawBytesUnchecked).unwrap();
     let seed = load_seed(seed_path).unwrap();
     let p = Prover::from_params_and_seed(params, agg_params, seed);
     PROVER.set(p).unwrap();

common/libzkp/impl/src/verify.rs

@@ -1,4 +1,5 @@
 use crate::utils::{c_char_to_str, c_char_to_vec};
+use halo2_proofs::SerdeFormat;
 use libc::c_char;
 use std::fs::File;
 use std::io::Read;
@@ -21,8 +22,8 @@ pub unsafe extern "C" fn init_verifier(params_path: *const c_char, agg_vk_path:
     let mut agg_vk = vec![];
     f.read_to_end(&mut agg_vk).unwrap();
 
-    let params = load_params(params_path, *DEGREE).unwrap();
-    let agg_params = load_params(params_path, *AGG_DEGREE).unwrap();
+    let params = load_params(params_path, *DEGREE, SerdeFormat::RawBytesUnchecked).unwrap();
+    let agg_params = load_params(params_path, *AGG_DEGREE, SerdeFormat::RawBytesUnchecked).unwrap();
 
     let v = Box::new(Verifier::from_params(params, agg_params, Some(agg_vk)));
     VERIFIER = Some(Box::leak(v))

common/types/batch_test.go

@@ -1,10 +1,12 @@
 package types
 
 import (
+	"encoding/json"
 	"math/big"
+	"os"
 	"testing"
 
-	"gotest.tools/assert"
+	"github.com/stretchr/testify/assert"
 
 	"github.com/scroll-tech/go-ethereum/common"
 	geth_types "github.com/scroll-tech/go-ethereum/core/types"
@@ -89,3 +91,53 @@ func TestNewGenesisBatch(t *testing.T) {
 		"wrong genesis batch hash",
 	)
 }
+
+func TestNewBatchData(t *testing.T) {
+	templateBlockTrace, err := os.ReadFile("../testdata/blockTrace_02.json")
+	assert.NoError(t, err)
+
+	wrappedBlock := &WrappedBlock{}
+	assert.NoError(t, json.Unmarshal(templateBlockTrace, wrappedBlock))
+
+	parentBatch := &BlockBatch{
+		Index:     1,
+		Hash:      "0x0000000000000000000000000000000000000000",
+		StateRoot: "0x0000000000000000000000000000000000000000",
+	}
+	batchData1 := NewBatchData(parentBatch, []*WrappedBlock{wrappedBlock}, nil)
+	assert.NotNil(t, batchData1)
+	assert.NotNil(t, batchData1.Batch)
+	assert.Equal(t, "0xac4487c0d8f429dafda3c68cbb8983ac08af83c03c83c365d7df02864f80af37", batchData1.Hash().Hex())
+
+	templateBlockTrace, err = os.ReadFile("../testdata/blockTrace_03.json")
+	assert.NoError(t, err)
+
+	wrappedBlock2 := &WrappedBlock{}
+	assert.NoError(t, json.Unmarshal(templateBlockTrace, wrappedBlock2))
+
+	parentBatch2 := &BlockBatch{
+		Index:     batchData1.Batch.BatchIndex,
+		Hash:      batchData1.Hash().Hex(),
+		StateRoot: batchData1.Batch.NewStateRoot.Hex(),
+	}
+	batchData2 := NewBatchData(parentBatch2, []*WrappedBlock{wrappedBlock2}, nil)
+	assert.NotNil(t, batchData2)
+	assert.NotNil(t, batchData2.Batch)
+	assert.Equal(t, "0x8f1447573740b3e75b979879866b8ad02eecf88e1946275eb8cf14ab95876efc", batchData2.Hash().Hex())
+}
+
+func TestBatchDataTimestamp(t *testing.T) {
+	// Test case 1: when the batch data contains no blocks.
+	assert.Equal(t, uint64(0), (&BatchData{}).Timestamp())
+
+	// Test case 2: when the batch data contains blocks.
+	batchData := &BatchData{
+		Batch: abi.IScrollChainBatch{
+			Blocks: []abi.IScrollChainBlockContext{
+				{Timestamp: 123456789},
+				{Timestamp: 234567891},
+			},
+		},
+	}
+	assert.Equal(t, uint64(123456789), batchData.Timestamp())
+}

common/types/db_test.go

@@ -0,0 +1,92 @@
+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRollerProveStatus(t *testing.T) {
+	tests := []struct {
+		name string
+		s    RollerProveStatus
+		want string
+	}{
+		{
+			"RollerAssigned",
+			RollerAssigned,
+			"RollerAssigned",
+		},
+		{
+			"RollerProofValid",
+			RollerProofValid,
+			"RollerProofValid",
+		},
+		{
+			"RollerProofInvalid",
+			RollerProofInvalid,
+			"RollerProofInvalid",
+		},
+		{
+			"Bad Value",
+			RollerProveStatus(999), // Invalid value.
+			"Bad Value: 999",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, tt.s.String())
+		})
+	}
+}
+
+func TestProvingStatus(t *testing.T) {
+	tests := []struct {
+		name string
+		s    ProvingStatus
+		want string
+	}{
+		{
+			"ProvingTaskUnassigned",
+			ProvingTaskUnassigned,
+			"unassigned",
+		},
+		{
+			"ProvingTaskSkipped",
+			ProvingTaskSkipped,
+			"skipped",
+		},
+		{
+			"ProvingTaskAssigned",
+			ProvingTaskAssigned,
+			"assigned",
+		},
+		{
+			"ProvingTaskProved",
+			ProvingTaskProved,
+			"proved",
+		},
+		{
+			"ProvingTaskVerified",
+			ProvingTaskVerified,
+			"verified",
+		},
+		{
+			"ProvingTaskFailed",
+			ProvingTaskFailed,
+			"failed",
+		},
+		{
+			"Undefined",
+			ProvingStatus(999), // Invalid value.
+			"undefined",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, tt.s.String())
+		})
+	}
+}

common/types/message/message_test.go

@@ -1,6 +1,7 @@
 package message
 
 import (
+	"encoding/hex"
 	"testing"
 	"time"
 
@@ -15,13 +16,15 @@ func TestAuthMessageSignAndVerify(t *testing.T) {
 
 	authMsg := &AuthMsg{
 		Identity: &Identity{
-			Name:      "testRoller",
+			Name:      "testName",
 			Timestamp: uint32(time.Now().Unix()),
+			Version:   "testVersion",
+			Token:     "testToken",
 		},
 	}
 	assert.NoError(t, authMsg.SignWithKey(privkey))
 
-	// check public key.
+	// Check public key.
 	pk, err := authMsg.PublicKey()
 	assert.NoError(t, err)
 	assert.Equal(t, common.Bytes2Hex(crypto.CompressPubkey(&privkey.PublicKey)), pk)
@@ -36,3 +39,120 @@ func TestAuthMessageSignAndVerify(t *testing.T) {
 	pubkey := crypto.CompressPubkey(&privkey.PublicKey)
 	assert.Equal(t, pub, common.Bytes2Hex(pubkey))
 }
+
+func TestGenerateToken(t *testing.T) {
+	token, err := GenerateToken()
+	assert.NoError(t, err)
+	assert.Equal(t, 32, len(token))
+}
+
+func TestIdentityHash(t *testing.T) {
+	identity := &Identity{
+		Name:       "testName",
+		RollerType: BasicProve,
+		Timestamp:  uint32(1622428800),
+		Version:    "testVersion",
+		Token:      "testToken",
+	}
+	hash, err := identity.Hash()
+	assert.NoError(t, err)
+
+	expectedHash := "b3f152958dc881446fc131a250526139d909710c6b91b4d3281ceded28ce2e32"
+	assert.Equal(t, expectedHash, hex.EncodeToString(hash))
+}
+
+func TestProofMessageSignVerifyPublicKey(t *testing.T) {
+	privkey, err := crypto.GenerateKey()
+	assert.NoError(t, err)
+
+	proofMsg := &ProofMsg{
+		ProofDetail: &ProofDetail{
+			ID:     "testID",
+			Type:   BasicProve,
+			Status: StatusOk,
+			Proof: &AggProof{
+				Proof:      []byte("testProof"),
+				Instance:   []byte("testInstance"),
+				FinalPair:  []byte("testFinalPair"),
+				Vk:         []byte("testVk"),
+				BlockCount: 1,
+			},
+			Error: "testError",
+		},
+	}
+	assert.NoError(t, proofMsg.Sign(privkey))
+
+	// Test when publicKey is not set.
+	ok, err := proofMsg.Verify()
+	assert.NoError(t, err)
+	assert.Equal(t, true, ok)
+
+	// Test when publicKey is already set.
+	ok, err = proofMsg.Verify()
+	assert.NoError(t, err)
+	assert.Equal(t, true, ok)
+}
+
+func TestProofDetailHash(t *testing.T) {
+	proofDetail := &ProofDetail{
+		ID:     "testID",
+		Type:   BasicProve,
+		Status: StatusOk,
+		Proof: &AggProof{
+			Proof:      []byte("testProof"),
+			Instance:   []byte("testInstance"),
+			FinalPair:  []byte("testFinalPair"),
+			Vk:         []byte("testVk"),
+			BlockCount: 1,
+		},
+		Error: "testError",
+	}
+	hash, err := proofDetail.Hash()
+	assert.NoError(t, err)
+	expectedHash := "fdfaae752d6fd72a7fdd2ad034ef504d3acda9e691a799323cfa6e371684ba2b"
+	assert.Equal(t, expectedHash, hex.EncodeToString(hash))
+}
+
+func TestProveTypeString(t *testing.T) {
+	basicProve := ProveType(0)
+	assert.Equal(t, "Basic Prove", basicProve.String())
+
+	aggregatorProve := ProveType(1)
+	assert.Equal(t, "Aggregator Prove", aggregatorProve.String())
+
+	illegalProve := ProveType(3)
+	assert.Equal(t, "Illegal Prove type", illegalProve.String())
+}
+
+func TestProofMsgPublicKey(t *testing.T) {
+	privkey, err := crypto.GenerateKey()
+	assert.NoError(t, err)
+
+	proofMsg := &ProofMsg{
+		ProofDetail: &ProofDetail{
+			ID:     "testID",
+			Type:   BasicProve,
+			Status: StatusOk,
+			Proof: &AggProof{
+				Proof:      []byte("testProof"),
+				Instance:   []byte("testInstance"),
+				FinalPair:  []byte("testFinalPair"),
+				Vk:         []byte("testVk"),
+				BlockCount: 1,
+			},
+			Error: "testError",
+		},
+	}
+	assert.NoError(t, proofMsg.Sign(privkey))
+
+	// Test when publicKey is not set.
+	pk, err := proofMsg.PublicKey()
+	assert.NoError(t, err)
+	assert.Equal(t, common.Bytes2Hex(crypto.CompressPubkey(&privkey.PublicKey)), pk)
+
+	// Test when publicKey is already set.
+	proofMsg.publicKey = common.Bytes2Hex(crypto.CompressPubkey(&privkey.PublicKey))
+	pk, err = proofMsg.PublicKey()
+	assert.NoError(t, err)
+	assert.Equal(t, common.Bytes2Hex(crypto.CompressPubkey(&privkey.PublicKey)), pk)
+}

common/utils/utils.go

@@ -8,13 +8,14 @@ import (
 )
 
 // TryTimes try run several times until the function return true.
-func TryTimes(times int, run func() bool) {
+func TryTimes(times int, run func() bool) bool {
 	for i := 0; i < times; i++ {
 		if run() {
-			return
+			return true
 		}
 		time.Sleep(time.Millisecond * 500)
 	}
+	return false
 }
 
 // LoopWithContext Run the f func with context periodically.

common/version/version.go

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

contracts/docs/apis/L1ScrollMessenger.md

@@ -215,7 +215,7 @@ function renounceOwnership() external nonpayable
 ### replayMessage
 
 ```solidity
-function replayMessage(address _from, address _to, uint256 _value, uint256 _queueIndex, bytes _message, uint32 _oldGasLimit, uint32 _newGasLimit) external nonpayable
+function replayMessage(address _from, address _to, uint256 _value, uint256 _queueIndex, bytes _message, uint32 _oldGasLimit, uint32 _newGasLimit, address _refundAddress) external payable
 ```
 
 Replay an exsisting message.
@@ -233,6 +233,7 @@ Replay an exsisting message.
 | _message | bytes | undefined |
 | _oldGasLimit | uint32 | undefined |
 | _newGasLimit | uint32 | undefined |
+| _refundAddress | address | undefined |
 
 ### rollup
 

contracts/foundry.toml

@@ -26,4 +26,6 @@ gas_price = 0                                                 # the gas price (i
 block_base_fee_per_gas = 0                                    # the base fee (in wei) in tests
 block_coinbase = '0x0000000000000000000000000000000000000000' # the address of `block.coinbase` in tests
 block_timestamp = 0                                           # the value of `block.timestamp` in tests
-block_difficulty = 0                                          # the value of `block.difficulty` in tests
+block_difficulty = 0                                          # the value of `block.difficulty` in tests
+
+gas_reports = ["L2GasPriceOracle"]

contracts/integration-test/L1MessageQueue.spec.ts

@@ -0,0 +1,70 @@
+/* eslint-disable node/no-unpublished-import */
+/* eslint-disable node/no-missing-import */
+import { expect } from "chai";
+import { BigNumber, constants } from "ethers";
+import { concat, hexlify, keccak256, randomBytes, RLP } from "ethers/lib/utils";
+import { ethers } from "hardhat";
+import { L1MessageQueue } from "../typechain";
+
+describe("L1MessageQueue", async () => {
+  let queue: L1MessageQueue;
+
+  beforeEach(async () => {
+    const [deployer] = await ethers.getSigners();
+
+    const L1MessageQueue = await ethers.getContractFactory("L1MessageQueue", deployer);
+    queue = await L1MessageQueue.deploy();
+    await queue.deployed();
+
+    await queue.initialize(constants.AddressZero, constants.AddressZero, 10000000);
+  });
+
+  it("should succeed", async () => {
+    const sender = hexlify(randomBytes(20));
+    const target = hexlify(randomBytes(20));
+    const transactionType = "0x7E";
+
+    for (const nonce of [
+      BigNumber.from(0),
+      BigNumber.from(1),
+      BigNumber.from(127),
+      BigNumber.from(128),
+      BigNumber.from(22334455),
+      constants.MaxUint256,
+    ]) {
+      for (const value of [
+        BigNumber.from(0),
+        BigNumber.from(1),
+        BigNumber.from(127),
+        BigNumber.from(128),
+        BigNumber.from(22334455),
+        constants.MaxUint256,
+      ]) {
+        for (const gasLimit of [
+          BigNumber.from(0),
+          BigNumber.from(1),
+          BigNumber.from(127),
+          BigNumber.from(128),
+          BigNumber.from(22334455),
+          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);
+          }
+        }
+      }
+    }
+  });
+});

contracts/integration-test/ScrollChain.spec.ts

@@ -29,7 +29,7 @@ describe("ScrollChain", async () => {
 
     await chain.initialize(queue.address);
     await chain.updateSequencer(deployer.address, true);
-    await queue.initialize(constants.AddressZero, constants.AddressZero);
+    await queue.initialize(constants.AddressZero, constants.AddressZero, 10000000);
   });
 
   it("should succeed", async () => {

contracts/scripts/foundry/InitializeL1BridgeContracts.s.sol

@@ -55,13 +55,14 @@ contract InitializeL1BridgeContracts is Script {
     ScrollChain(L1_ZK_ROLLUP_PROXY_ADDR).updateSequencer(L1_ROLLUP_OPERATOR_ADDR, true);
 
     // initialize L2GasPriceOracle
-    L2GasPriceOracle(L2_GAS_PRICE_ORACLE_PROXY_ADDR).initialize();
+    L2GasPriceOracle(L2_GAS_PRICE_ORACLE_PROXY_ADDR).initialize(0, 0, 0, 0);
     L2GasPriceOracle(L2_GAS_PRICE_ORACLE_PROXY_ADDR).updateWhitelist(L1_WHITELIST_ADDR);
 
     // initialize L1MessageQueue
     L1MessageQueue(L1_MESSAGE_QUEUE_PROXY_ADDR).initialize(
       L1_SCROLL_MESSENGER_PROXY_ADDR,
-      L2_GAS_PRICE_ORACLE_PROXY_ADDR
+      L2_GAS_PRICE_ORACLE_PROXY_ADDR,
+      10000000
     );
 
     // initialize L1ScrollMessenger

contracts/src/L1/IL1ScrollMessenger.sol

@@ -44,6 +44,7 @@ interface IL1ScrollMessenger is IScrollMessenger {
     /// @param message The content of the message.
     /// @param oldGasLimit Original gas limit used to send the message.
     /// @param newGasLimit New gas limit to be used for this message.
+    /// @param refundAddress The address of account who will receive the refunded fee.
     function replayMessage(
         address from,
         address to,
@@ -51,6 +52,7 @@ interface IL1ScrollMessenger is IScrollMessenger {
         uint256 queueIndex,
         bytes memory message,
         uint32 oldGasLimit,
-        uint32 newGasLimit
-    ) external;
+        uint32 newGasLimit,
+        address refundAddress
+    ) external payable;
 }

contracts/src/L1/L1ScrollMessenger.sol

@@ -10,6 +10,7 @@ import {IL1ScrollMessenger} from "./IL1ScrollMessenger.sol";
 import {ScrollConstants} from "../libraries/constants/ScrollConstants.sol";
 import {IScrollMessenger} from "../libraries/IScrollMessenger.sol";
 import {ScrollMessengerBase} from "../libraries/ScrollMessengerBase.sol";
+import {AddressAliasHelper} from "../libraries/common/AddressAliasHelper.sol";
 import {WithdrawTrieVerifier} from "../libraries/verifier/WithdrawTrieVerifier.sol";
 
 // solhint-disable avoid-low-level-calls
@@ -136,14 +137,11 @@ contract L1ScrollMessenger is PausableUpgradeable, ScrollMessengerBase, IL1Scrol
         {
             address _rollup = rollup;
             require(IScrollChain(_rollup).isBatchFinalized(_proof.batchHash), "Batch is not finalized");
-            // @note skip verify for now
-            /*
-      bytes32 _messageRoot = IScrollChain(_rollup).getL2MessageRoot(_proof.batchHash);
-      require(
-        WithdrawTrieVerifier.verifyMerkleProof(_messageRoot, _xDomainCalldataHash, _nonce, _proof.merkleProof),
-        "Invalid proof"
-      );
-      */
+            bytes32 _messageRoot = IScrollChain(_rollup).getL2MessageRoot(_proof.batchHash);
+            require(
+                WithdrawTrieVerifier.verifyMerkleProof(_messageRoot, _xDomainCalldataHash, _nonce, _proof.merkleProof),
+                "Invalid proof"
+            );
         }
 
         // @todo check more `_to` address to avoid attack.
@@ -177,9 +175,54 @@ contract L1ScrollMessenger is PausableUpgradeable, ScrollMessengerBase, IL1Scrol
         uint256 _queueIndex,
         bytes memory _message,
         uint32 _oldGasLimit,
-        uint32 _newGasLimit
-    ) external override whenNotPaused {
-        // @todo
+        uint32 _newGasLimit,
+        address _refundAddress
+    ) external payable override whenNotPaused {
+        // We will use a different `queueIndex` for the replaced message. However, the original `queueIndex` or `nonce`
+        // is encoded in the `_message`. We will check the `xDomainCalldata` in layer 2 to avoid duplicated execution.
+        // So, only one message will succeed in layer 2. If one of the message is executed successfully, the other one
+        // will revert with "Message was already successfully executed".
+        address _messageQueue = messageQueue;
+        address _counterpart = counterpart;
+        bytes memory _xDomainCalldata = _encodeXDomainCalldata(_from, _to, _value, _queueIndex, _message);
+
+        // compute the expected transaction hash
+        bytes32 _computedTransactionHash = IL1MessageQueue(_messageQueue).computeTransactionHash(
+            AddressAliasHelper.applyL1ToL2Alias(address(this)),
+            _queueIndex,
+            0,
+            _counterpart,
+            _oldGasLimit,
+            _xDomainCalldata
+        );
+
+        // check the provided message matching with enqueued one.
+        require(
+            _computedTransactionHash == IL1MessageQueue(_messageQueue).getCrossDomainMessage(_queueIndex),
+            "Provided message has not been enqueued"
+        );
+
+        // compute and deduct the messaging fee to fee vault.
+        uint256 _fee = IL1MessageQueue(_messageQueue).estimateCrossDomainMessageFee(_newGasLimit);
+
+        // charge relayer fee
+        require(msg.value >= _fee, "Insufficient msg.value for fee");
+        if (_fee > 0) {
+            (bool _success, ) = feeVault.call{value: _fee}("");
+            require(_success, "Failed to deduct the fee");
+        }
+
+        // enqueue the new transaction
+        IL1MessageQueue(_messageQueue).appendCrossDomainMessage(_counterpart, _newGasLimit, _xDomainCalldata);
+
+        // refund fee to `_refundAddress`
+        unchecked {
+            uint256 _refund = msg.value - _fee;
+            if (_refund > 0) {
+                (bool _success, ) = _refundAddress.call{value: _refund}("");
+                require(_success, "Failed to refund the fee");
+            }
+        }
     }
 
     /************************
@@ -235,7 +278,7 @@ contract L1ScrollMessenger is PausableUpgradeable, ScrollMessengerBase, IL1Scrol
 
         emit SentMessage(msg.sender, _to, _value, _messageNonce, _gasLimit, _message);
 
-        // refund fee to tx.origin
+        // refund fee to `_refundAddress`
         unchecked {
             uint256 _refund = msg.value - _fee - _value;
             if (_refund > 0) {

contracts/src/L1/gateways/L1CustomERC20Gateway.sol

@@ -77,8 +77,9 @@ contract L1CustomERC20Gateway is OwnableUpgradeable, ScrollGatewayBase, L1ERC20G
         address _to,
         uint256 _amount,
         bytes calldata _data
-    ) external payable override onlyCallByCounterpart {
+    ) external payable override onlyCallByCounterpart nonReentrant {
         require(msg.value == 0, "nonzero msg.value");
+        require(_l2Token != address(0), "token address cannot be 0");
         require(_l2Token == tokenMapping[_l1Token], "l2 token mismatch");
 
         // @note can possible trigger reentrant call to this contract or messenger,
@@ -98,7 +99,7 @@ contract L1CustomERC20Gateway is OwnableUpgradeable, ScrollGatewayBase, L1ERC20G
     /// @param _l1Token The address of ERC20 token in layer 1.
     /// @param _l2Token The address of corresponding ERC20 token in layer 2.
     function updateTokenMapping(address _l1Token, address _l2Token) external onlyOwner {
-        require(_l2Token != address(0), "map to zero address");
+        require(_l2Token != address(0), "token address cannot be 0");
 
         tokenMapping[_l1Token] = _l2Token;
 

contracts/src/L1/gateways/L1ERC1155Gateway.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.0;
 
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import {IERC1155Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC1155/IERC1155Upgradeable.sol";
-import {ERC1155HolderUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC1155/utils/ERC1155HolderUpgradeable.sol";
+import {ERC1155HolderUpgradeable, ERC1155ReceiverUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC1155/utils/ERC1155HolderUpgradeable.sol";
 
 import {IL2ERC1155Gateway} from "../../L2/gateways/IL2ERC1155Gateway.sol";
 import {IL1ScrollMessenger} from "../IL1ScrollMessenger.sol";
@@ -46,6 +46,9 @@ contract L1ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
     /// @param _messenger The address of L1ScrollMessenger.
     function initialize(address _counterpart, address _messenger) external initializer {
         OwnableUpgradeable.__Ownable_init();
+        ERC1155HolderUpgradeable.__ERC1155Holder_init();
+        ERC1155ReceiverUpgradeable.__ERC1155Receiver_init();
+
         ScrollGatewayBase._initialize(_counterpart, address(0), _messenger);
     }
 
@@ -103,7 +106,8 @@ contract L1ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         address _to,
         uint256 _tokenId,
         uint256 _amount
-    ) external override nonReentrant onlyCallByCounterpart {
+    ) external override onlyCallByCounterpart nonReentrant {
+        require(_l2Token != address(0), "token address cannot be 0");
         require(_l2Token == tokenMapping[_l1Token], "l2 token mismatch");
 
         IERC1155Upgradeable(_l1Token).safeTransferFrom(address(this), _to, _tokenId, _amount, "");
@@ -119,7 +123,8 @@ contract L1ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         address _to,
         uint256[] calldata _tokenIds,
         uint256[] calldata _amounts
-    ) external override nonReentrant onlyCallByCounterpart {
+    ) external override onlyCallByCounterpart nonReentrant {
+        require(_l2Token != address(0), "token address cannot be 0");
         require(_l2Token == tokenMapping[_l1Token], "l2 token mismatch");
 
         IERC1155Upgradeable(_l1Token).safeBatchTransferFrom(address(this), _to, _tokenIds, _amounts, "");
@@ -135,7 +140,7 @@ contract L1ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
     /// @param _l1Token The address of ERC1155 token in layer 1.
     /// @param _l1Token The address of corresponding ERC1155 token in layer 2.
     function updateTokenMapping(address _l1Token, address _l2Token) external onlyOwner {
-        require(_l2Token != address(0), "map to zero address");
+        require(_l2Token != address(0), "token address cannot be 0");
 
         tokenMapping[_l1Token] = _l2Token;
 
@@ -162,7 +167,7 @@ contract L1ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         require(_amount > 0, "deposit zero amount");
 
         address _l2Token = tokenMapping[_token];
-        require(_l2Token != address(0), "token not supported");
+        require(_l2Token != address(0), "no corresponding l2 token");
 
         // 1. transfer token to this contract
         IERC1155Upgradeable(_token).safeTransferFrom(msg.sender, address(this), _tokenId, _amount, "");
@@ -205,7 +210,7 @@ contract L1ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         }
 
         address _l2Token = tokenMapping[_token];
-        require(_l2Token != address(0), "token not supported");
+        require(_l2Token != address(0), "no corresponding l2 token");
 
         // 1. transfer token to this contract
         IERC1155Upgradeable(_token).safeBatchTransferFrom(msg.sender, address(this), _tokenIds, _amounts, "");

contracts/src/L1/gateways/L1ERC721Gateway.sol

@@ -46,6 +46,8 @@ contract L1ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
     /// @param _messenger The address of L1ScrollMessenger.
     function initialize(address _counterpart, address _messenger) external initializer {
         OwnableUpgradeable.__Ownable_init();
+        ERC721HolderUpgradeable.__ERC721Holder_init();
+
         ScrollGatewayBase._initialize(_counterpart, address(0), _messenger);
     }
 
@@ -98,7 +100,8 @@ contract L1ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         address _from,
         address _to,
         uint256 _tokenId
-    ) external override nonReentrant onlyCallByCounterpart {
+    ) external override onlyCallByCounterpart nonReentrant {
+        require(_l2Token != address(0), "token address cannot be 0");
         require(_l2Token == tokenMapping[_l1Token], "l2 token mismatch");
 
         IERC721Upgradeable(_l1Token).safeTransferFrom(address(this), _to, _tokenId);
@@ -113,7 +116,8 @@ contract L1ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         address _from,
         address _to,
         uint256[] calldata _tokenIds
-    ) external override nonReentrant onlyCallByCounterpart {
+    ) external override onlyCallByCounterpart nonReentrant {
+        require(_l2Token != address(0), "token address cannot be 0");
         require(_l2Token == tokenMapping[_l1Token], "l2 token mismatch");
 
         for (uint256 i = 0; i < _tokenIds.length; i++) {
@@ -131,7 +135,7 @@ contract L1ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
     /// @param _l1Token The address of ERC721 token in layer 1.
     /// @param _l1Token The address of corresponding ERC721 token in layer 2.
     function updateTokenMapping(address _l1Token, address _l2Token) external onlyOwner {
-        require(_l2Token != address(0), "map to zero address");
+        require(_l2Token != address(0), "token address cannot be 0");
 
         tokenMapping[_l1Token] = _l2Token;
 
@@ -154,7 +158,7 @@ contract L1ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         uint256 _gasLimit
     ) internal nonReentrant {
         address _l2Token = tokenMapping[_token];
-        require(_l2Token != address(0), "token not supported");
+        require(_l2Token != address(0), "no corresponding l2 token");
 
         // 1. transfer token to this contract
         IERC721Upgradeable(_token).safeTransferFrom(msg.sender, address(this), _tokenId);
@@ -189,7 +193,7 @@ contract L1ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         require(_tokenIds.length > 0, "no token to deposit");
 
         address _l2Token = tokenMapping[_token];
-        require(_l2Token != address(0), "token not supported");
+        require(_l2Token != address(0), "no corresponding l2 token");
 
         // 1. transfer token to this contract
         for (uint256 i = 0; i < _tokenIds.length; i++) {

contracts/src/L1/gateways/L1ETHGateway.sol

@@ -67,8 +67,10 @@ contract L1ETHGateway is Initializable, ScrollGatewayBase, IL1ETHGateway {
         address _to,
         uint256 _amount,
         bytes calldata _data
-    ) external payable override onlyCallByCounterpart {
-        // @note can possible trigger reentrant call to this contract or messenger,
+    ) external payable override onlyCallByCounterpart nonReentrant {
+        require(msg.value == _amount, "msg.value mismatch");
+
+        // @note can possible trigger reentrant call to messenger,
         // but it seems not a big problem.
         // solhint-disable-next-line avoid-low-level-calls
         (bool _success, ) = _to.call{value: _amount}("");

contracts/src/L1/gateways/L1StandardERC20Gateway.sol

@@ -92,10 +92,12 @@ contract L1StandardERC20Gateway is Initializable, ScrollGatewayBase, L1ERC20Gate
         address _to,
         uint256 _amount,
         bytes calldata _data
-    ) external payable override onlyCallByCounterpart {
+    ) external payable override onlyCallByCounterpart nonReentrant {
         require(msg.value == 0, "nonzero msg.value");
+        require(_l2Token != address(0), "token address cannot be 0");
+        require(getL2ERC20Address(_l1Token) == _l2Token, "l2 token mismatch");
 
-        // @note can possible trigger reentrant call to this contract or messenger,
+        // @note can possible trigger reentrant call to messenger,
         // but it seems not a big problem.
         IERC20(_l1Token).safeTransfer(_to, _amount);
 

contracts/src/L1/gateways/L1WETHGateway.sol

@@ -82,7 +82,7 @@ contract L1WETHGateway is Initializable, ScrollGatewayBase, L1ERC20Gateway {
         address _to,
         uint256 _amount,
         bytes calldata _data
-    ) external payable override onlyCallByCounterpart {
+    ) external payable override onlyCallByCounterpart nonReentrant {
         require(_l1Token == WETH, "l1 token not WETH");
         require(_l2Token == l2WETH, "l2 token not WETH");
         require(_amount == msg.value, "msg.value mismatch");

contracts/src/L1/rollup/IL1MessageQueue.sol

@@ -39,6 +39,26 @@ interface IL1MessageQueue {
     /// @param gasLimit Gas limit required to complete the message relay on L2.
     function estimateCrossDomainMessageFee(uint256 gasLimit) external view returns (uint256);
 
+    /// @notice Return the amount of intrinsic gas fee should pay for cross domain message.
+    /// @param _calldata The calldata of L1-initiated transaction.
+    function calculateIntrinsicGasFee(bytes memory _calldata) external view returns (uint256);
+
+    /// @notice Return the hash of a L1 message.
+    /// @param sender The address of sender.
+    /// @param queueIndex The queue index of this message.
+    /// @param value The amount of Ether transfer to target.
+    /// @param target The address of target.
+    /// @param gasLimit The gas limit provided.
+    /// @param data The calldata passed to target address.
+    function computeTransactionHash(
+        address sender,
+        uint256 queueIndex,
+        uint256 value,
+        address target,
+        uint256 gasLimit,
+        bytes calldata data
+    ) external view returns (bytes32);
+
     /*****************************
      * Public Mutating Functions *
      *****************************/

contracts/src/L1/rollup/IL2GasPriceOracle.sol

@@ -6,4 +6,8 @@ interface IL2GasPriceOracle {
     /// @notice Estimate fee for cross chain message call.
     /// @param _gasLimit Gas limit required to complete the message relay on L2.
     function estimateCrossDomainMessageFee(uint256 _gasLimit) external view returns (uint256);
+
+    /// @notice Estimate intrinsic gas fee for cross chain message call.
+    /// @param _message The message to be relayed on L2.
+    function calculateIntrinsicGasFee(bytes memory _message) external view returns (uint256);
 }

contracts/src/L1/rollup/L1MessageQueue.sol

@@ -11,7 +11,7 @@ import {AddressAliasHelper} from "../../libraries/common/AddressAliasHelper.sol"
 
 /// @title L1MessageQueue
 /// @notice This contract will hold all L1 to L2 messages.
-/// Each appended message is assigned with a unique and increasing `uint256` index denoting the message nonce.
+/// Each appended message is assigned with a unique and increasing `uint256` index.
 contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
     /**********
      * Events *
@@ -22,6 +22,11 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
     /// @param _newGasOracle The address of new gas oracle contract.
     event UpdateGasOracle(address _oldGasOracle, address _newGasOracle);
 
+    /// @notice Emitted when owner updates max gas limit.
+    /// @param _oldMaxGasLimit The old max gas limit.
+    /// @param _newMaxGasLimit The new max gas limit.
+    event UpdateMaxGasLimit(uint256 _oldMaxGasLimit, uint256 _newMaxGasLimit);
+
     /*************
      * Variables *
      *************/
@@ -35,15 +40,19 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
     /// @notice The list of queued cross domain messages.
     bytes32[] public messageQueue;
 
+    /// @notice The max gas limit of L1 transactions.
+    uint256 public maxGasLimit;
+
     /***************
      * Constructor *
      ***************/
 
-    function initialize(address _messenger, address _gasOracle) external initializer {
+    function initialize(address _messenger, address _gasOracle, uint256 _maxGasLimit) external initializer {
         OwnableUpgradeable.__Ownable_init();
 
         messenger = _messenger;
         gasOracle = _gasOracle;
+        maxGasLimit = _maxGasLimit;
     }
 
     /*************************
@@ -67,38 +76,162 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
         return IL2GasPriceOracle(_oracle).estimateCrossDomainMessageFee(_gasLimit);
     }
 
+    /// @inheritdoc IL1MessageQueue
+    function calculateIntrinsicGasFee(bytes memory _calldata) public view override returns (uint256) {
+        address _oracle = gasOracle;
+        if (_oracle == address(0)) return 0;
+        return IL2GasPriceOracle(_oracle).calculateIntrinsicGasFee(_calldata);
+    }
+
+    /// @inheritdoc IL1MessageQueue
+    function computeTransactionHash(
+        address _sender,
+        uint256 _queueIndex,
+        uint256 _value,
+        address _target,
+        uint256 _gasLimit,
+        bytes calldata _data
+    ) public pure override returns (bytes32) {
+        // We use EIP-2718 to encode the L1 message, and the encoding of the message is
+        //      `TransactionType || TransactionPayload`
+        // where
+        //  1. `TransactionType` is 0x7E
+        //  2. `TransactionPayload` is `rlp([queueIndex, gasLimit, to, value, data, sender])`
+        //
+        // The spec of rlp: https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
+        uint256 transactionType = 0x7E;
+        bytes32 hash;
+        assembly {
+            function get_uint_bytes(v) -> len {
+                if eq(v, 0) {
+                    len := 1
+                    leave
+                }
+                for {
+
+                } gt(v, 0) {
+
+                } {
+                    len := add(len, 1)
+                    v := shr(8, v)
+                }
+            }
+
+            function store_uint(_ptr, v) -> ptr {
+                ptr := _ptr
+                switch lt(v, 128)
+                case 1 {
+                    // single byte in the [0x00, 0x7f]
+                    mstore(ptr, shl(248, v))
+                    ptr := add(ptr, 1)
+                }
+                default {
+                    // 1-32 bytes long
+                    let len := get_uint_bytes(v)
+                    mstore(ptr, shl(248, add(len, 0x80)))
+                    ptr := add(ptr, 1)
+                    mstore(ptr, shl(mul(8, sub(32, len)), v))
+                    ptr := add(ptr, len)
+                }
+            }
+
+            function store_address(_ptr, v) -> ptr {
+                ptr := _ptr
+                // 20 bytes long
+                mstore(ptr, shl(248, 0x94)) // 0x80 + 0x14
+                ptr := add(ptr, 1)
+                mstore(ptr, shl(96, v))
+                ptr := add(ptr, 0x14)
+            }
+
+            // 1 byte for TransactionType
+            // 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_address(ptr, _target)
+            ptr := store_uint(ptr, _value)
+
+            switch eq(_data.length, 1)
+            case 1 {
+                // single byte
+                ptr := store_uint(ptr, shr(248, calldataload(_data.offset)))
+            }
+            default {
+                switch lt(_data.length, 56)
+                case 1 {
+                    // a string is 0-55 bytes long
+                    mstore(ptr, shl(248, add(0x80, _data.length)))
+                    ptr := add(ptr, 1)
+                    calldatacopy(ptr, _data.offset, _data.length)
+                    ptr := add(ptr, _data.length)
+                }
+                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)))
+                    ptr := add(ptr, 1)
+                    mstore(ptr, shl(mul(8, sub(32, len_bytes)), _data.length))
+                    ptr := add(ptr, len_bytes)
+                    calldatacopy(ptr, _data.offset, _data.length)
+                    ptr := add(ptr, _data.length)
+                }
+            }
+            ptr := store_address(ptr, _sender)
+
+            let payload_len := sub(ptr, start_ptr)
+            let value
+            let value_bytes
+            switch lt(payload_len, 56)
+            case 1 {
+                // the total payload of a list is 0-55 bytes long
+                value := add(0xc0, payload_len)
+                value_bytes := 1
+            }
+            default {
+                // If the total payload of a list is more than 55 bytes long
+                let len_bytes := get_uint_bytes(payload_len)
+                value_bytes := add(len_bytes, 1)
+                value := add(0xf7, len_bytes)
+                value := shl(mul(len_bytes, 8), value)
+                value := or(value, payload_len)
+            }
+            value := or(value, shl(mul(8, value_bytes), transactionType))
+            value_bytes := add(value_bytes, 1)
+            let value_bits := mul(8, value_bytes)
+            value := or(shl(sub(256, value_bits), value), shr(value_bits, mload(start_ptr)))
+            start_ptr := sub(start_ptr, value_bytes)
+            mstore(start_ptr, value)
+            hash := keccak256(start_ptr, sub(ptr, start_ptr))
+        }
+        return hash;
+    }
+
     /*****************************
      * Public Mutating Functions *
      *****************************/
 
     /// @inheritdoc IL1MessageQueue
-    function appendCrossDomainMessage(
-        address _target,
-        uint256 _gasLimit,
-        bytes calldata _data
-    ) external override {
+    function appendCrossDomainMessage(address _target, uint256 _gasLimit, bytes calldata _data) external override {
         require(msg.sender == messenger, "Only callable by the L1ScrollMessenger");
 
+        // validate gas limit
+        _validateGasLimit(_gasLimit, _data);
+
         // do address alias to avoid replay attack in L2.
         address _sender = AddressAliasHelper.applyL1ToL2Alias(msg.sender);
 
-        // @todo Change it to rlp encoding later.
-        bytes32 _hash = keccak256(abi.encode(_sender, _target, 0, _gasLimit, _data));
-
+        // compute transaction hash
         uint256 _queueIndex = messageQueue.length;
-        emit QueueTransaction(_sender, _target, 0, _queueIndex, _gasLimit, _data);
-
+        bytes32 _hash = computeTransactionHash(_sender, _queueIndex, 0, _target, _gasLimit, _data);
         messageQueue.push(_hash);
+
+        emit QueueTransaction(_sender, _target, 0, _queueIndex, _gasLimit, _data);
     }
 
     /// @inheritdoc IL1MessageQueue
-    function appendEnforcedTransaction(
-        address,
-        address,
-        uint256,
-        uint256,
-        bytes calldata
-    ) external override {
+    function appendEnforcedTransaction(address, address, uint256, uint256, bytes calldata) external override {
         // @todo
     }
 
@@ -115,4 +248,25 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
 
         emit UpdateGasOracle(_oldGasOracle, _newGasOracle);
     }
+
+    /// @notice Update the max gas limit.
+    /// @dev This function can only called by contract owner.
+    /// @param _newMaxGasLimit The new max gas limit.
+    function updateMaxGasLimit(uint256 _newMaxGasLimit) external onlyOwner {
+        uint256 _oldMaxGasLimit = maxGasLimit;
+        maxGasLimit = _newMaxGasLimit;
+
+        emit UpdateMaxGasLimit(_oldMaxGasLimit, _newMaxGasLimit);
+    }
+
+    /**********************
+     * Internal Functions *
+     **********************/
+
+    function _validateGasLimit(uint256 _gasLimit, bytes memory _calldata) internal {
+        require(_gasLimit <= maxGasLimit, "Gas limit must not exceed maxGasLimit");
+        // check if the gas limit is above intrinsic gas
+        uint256 intrinsicGas = calculateIntrinsicGasFee(_calldata);
+        require(_gasLimit >= intrinsicGas, "Insufficient gas limit, must be above intrinsic gas");
+    }
 }

contracts/src/L1/rollup/L2GasPriceOracle.sol

@@ -22,6 +22,13 @@ contract L2GasPriceOracle is OwnableUpgradeable, IL2GasPriceOracle {
     /// @param l2BaseFee The current l2 base fee updated.
     event L2BaseFeeUpdated(uint256 l2BaseFee);
 
+    /// @notice Emitted when intrinsic params are updated.
+    /// @param txGas The intrinsic gas for transaction.
+    /// @param txGasContractCreation The intrinsic gas for contract creation.
+    /// @param zeroGas The intrinsic gas for each zero byte.
+    /// @param nonZeroGas The intrinsic gas for each nonzero byte.
+    event IntrinsicParamsUpdated(uint256 txGas, uint256 txGasContractCreation, uint256 zeroGas, uint256 nonZeroGas);
+
     /*************
      * Variables *
      *************/
@@ -32,18 +39,56 @@ contract L2GasPriceOracle is OwnableUpgradeable, IL2GasPriceOracle {
     /// @notice The address of whitelist contract.
     IWhitelist public whitelist;
 
+
+    struct IntrinsicParams {
+        uint64 txGas;
+        uint64 txGasContractCreation;
+        uint64 zeroGas;
+        uint64 nonZeroGas;
+    }
+
+    /// @notice The intrinsic params for transaction.
+    IntrinsicParams public intrinsicParams;
+
     /***************
      * Constructor *
      ***************/
 
-    function initialize() external initializer {
+    function initialize(uint64 _txGas, uint64 _txGasContractCreation, uint64 _zeroGas, uint64 _nonZeroGas) external initializer {
         OwnableUpgradeable.__Ownable_init();
+
+        intrinsicParams = IntrinsicParams({
+            txGas: _txGas,
+            txGasContractCreation: _txGasContractCreation,
+            zeroGas: _zeroGas,
+            nonZeroGas: _nonZeroGas
+        });
     }
 
     /*************************
      * Public View Functions *
      *************************/
 
+    /// @inheritdoc IL2GasPriceOracle
+    function calculateIntrinsicGasFee(bytes memory _message) external view override returns (uint256) {
+        // @note currently we don't support contract deployment via L1 messages.
+        uint256 _txGas = uint256(intrinsicParams.txGas);
+        uint256 _zeroGas = uint256(intrinsicParams.zeroGas);
+        uint256 _nonZeroGas = uint256(intrinsicParams.nonZeroGas);
+
+        uint256 gas = _txGas;
+        if (_message.length > 0) {
+            uint256 nz = 0;
+            for (uint256 i = 0; i < _message.length; i++) {
+                if (_message[i] != 0) {
+                    nz++;
+                }
+            }
+            gas += nz * _nonZeroGas + (_message.length - nz) * _zeroGas;
+        }
+        return uint256(gas);
+    }
+
     /// @inheritdoc IL2GasPriceOracle
     function estimateCrossDomainMessageFee(uint256 _gasLimit) external view override returns (uint256) {
         return _gasLimit * l2BaseFee;
@@ -53,6 +98,24 @@ contract L2GasPriceOracle is OwnableUpgradeable, IL2GasPriceOracle {
      * Public Mutating Functions *
      *****************************/
 
+    /// @notice Allows the owner to update parameters for intrinsic gas calculation.
+    /// @param _txGas The intrinsic gas for transaction.
+    /// @param _txGasContractCreation The intrinsic gas for contract creation.
+    /// @param _zeroGas The intrinsic gas for each zero byte.
+    /// @param _nonZeroGas The intrinsic gas for each nonzero byte.
+    function setIntrinsicParams(uint64 _txGas, uint64 _txGasContractCreation, uint64 _zeroGas, uint64 _nonZeroGas) public {
+        require(whitelist.isSenderAllowed(msg.sender), "Not whitelisted sender");
+
+        intrinsicParams = IntrinsicParams({
+            txGas: _txGas,
+            txGasContractCreation: _txGasContractCreation,
+            zeroGas: _zeroGas,
+            nonZeroGas: _nonZeroGas
+        });
+
+        emit IntrinsicParamsUpdated(_txGas, _txGasContractCreation,  _zeroGas, _nonZeroGas);
+    }
+
     /// @notice Allows the owner to modify the l2 base fee.
     /// @param _l2BaseFee The new l2 base fee.
     function setL2BaseFee(uint256 _l2BaseFee) external {

contracts/src/L1/rollup/ScrollChain.sol

@@ -264,13 +264,6 @@ contract ScrollChain is OwnableUpgradeable, IScrollChain {
 
         emit CommitBatch(publicInputHash);
 
-        // As we are getting close to sunsetting the Alpha testnet,
-        // we now auto-finalize every batch to enable withdrawals.
-        lastFinalizedBatchHash = publicInputHash;
-        finalizedBatches[_batch.batchIndex] = publicInputHash;
-        _batchInStorage.finalized = true;
-        emit FinalizeBatch(publicInputHash);
-
         return publicInputHash;
     }
 

contracts/src/L2/L2ScrollMessenger.sol

@@ -11,6 +11,7 @@ import {IL1GasPriceOracle} from "./predeploys/IL1GasPriceOracle.sol";
 
 import {PatriciaMerkleTrieVerifier} from "../libraries/verifier/PatriciaMerkleTrieVerifier.sol";
 import {ScrollConstants} from "../libraries/constants/ScrollConstants.sol";
+import {AddressAliasHelper} from "../libraries/common/AddressAliasHelper.sol";
 import {IScrollMessenger} from "../libraries/IScrollMessenger.sol";
 import {ScrollMessengerBase} from "../libraries/ScrollMessengerBase.sol";
 
@@ -126,9 +127,12 @@ contract L2ScrollMessenger is ScrollMessengerBase, PausableUpgradeable, IL2Scrol
         bytes32 _expectedStateRoot = IL1BlockContainer(blockContainer).getStateRoot(_blockHash);
         require(_expectedStateRoot != bytes32(0), "Block is not imported");
 
-        // @todo fix the actual slot later.
         bytes32 _storageKey;
         // `mapping(bytes32 => bool) public isL1MessageSent` is the 105-nd slot of contract `L1ScrollMessenger`.
+        // + 50 from `OwnableUpgradeable`
+        // + 4 from `ScrollMessengerBase`
+        // + 50 from `PausableUpgradeable`
+        // + 2-nd in `L1ScrollMessenger`
         assembly {
             mstore(0x00, _msgHash)
             mstore(0x20, 105)
@@ -158,9 +162,12 @@ contract L2ScrollMessenger is ScrollMessengerBase, PausableUpgradeable, IL2Scrol
         bytes32 _expectedStateRoot = IL1BlockContainer(blockContainer).getStateRoot(_blockHash);
         require(_expectedStateRoot != bytes32(0), "Block not imported");
 
-        // @todo fix the actual slot later.
         bytes32 _storageKey;
         // `mapping(bytes32 => bool) public isL2MessageExecuted` is the 106-th slot of contract `L1ScrollMessenger`.
+        // + 50 from `OwnableUpgradeable`
+        // + 4 from `ScrollMessengerBase`
+        // + 50 from `PausableUpgradeable`
+        // + 3-rd in `L1ScrollMessenger`
         assembly {
             mstore(0x00, _msgHash)
             mstore(0x20, 106)
@@ -208,14 +215,9 @@ contract L2ScrollMessenger is ScrollMessengerBase, PausableUpgradeable, IL2Scrol
         uint256 _value,
         uint256 _nonce,
         bytes memory _message
-    ) external override whenNotPaused onlyWhitelistedSender(msg.sender) {
-        // anti reentrance
-        require(
-            xDomainMessageSender == ScrollConstants.DEFAULT_XDOMAIN_MESSAGE_SENDER,
-            "Message is already in execution"
-        );
-
-        // @todo address unalis to check sender is L1ScrollMessenger
+    ) external override whenNotPaused {
+        // It is impossible to deploy a contract with the same address, reentrance is prevented in nature.
+        require(AddressAliasHelper.undoL1ToL2Alias(msg.sender) == counterpart, "Caller is not L1ScrollMessenger");
 
         bytes32 _xDomainCalldataHash = keccak256(_encodeXDomainCalldata(_from, _to, _value, _nonce, _message));