feat(libzkp): change linkage from staticlib to dylib (#471)

Co-authored-by: xinran chen <lawliet@xinran-m1x.local>

.github/workflows/bridge_hisotry_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') {

Makefile

@@ -13,6 +13,7 @@ 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

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,145 @@
+module bridge-history-api
+
+go 1.20
+
+require (
+	github.com/ethereum/go-ethereum v1.11.4
+	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.2.0 // 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.0.1 // 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.3.0 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/golang/snappy v0.0.4 // 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.0 // indirect
+	github.com/huin/goupnp v1.0.3 // 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/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.7.0 // indirect
+	golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect
+	golang.org/x/net v0.9.0 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+	golang.org/x/sys v0.7.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/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,957 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.43.0/go.mod h1:BOSR3VbTLkk6FDC/TcffxP4NF/FFBGA5ku+jvKOP7pg=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.51.0/go.mod h1:hWtGJ6gnXH+KgDv+V0zFGDvpi07n3z8ZNj3T1RW0Gcw=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigtable v1.2.0/go.mod h1:JcVAOl45lrTmQfLj7T6TxyMzIN/3FGGcFm+2xVAli2o=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+collectd.org v0.3.0/go.mod h1:A/8DzQBkF6abtvrT2j/AU/4tiBgJWYyh0y/oB/4MlWE=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+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/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+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/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+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/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+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/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
+github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
+github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8=
+github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
+github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/apache/arrow/go/arrow v0.0.0-20191024131854-af6fa24be0db/go.mod h1:VTxUBvSJ3s3eHAg65PNgrsn5BtqCRPdmyXh6rAfdxN0=
+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 v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+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/bmizerany/pat v0.0.0-20170815010413-6226ea591a40/go.mod h1:8rLXio+WjiTceGBHIoTvn60HIbs7Hm7bcHjyrSqYB9c=
+github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
+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.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k=
+github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU=
+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/c-bata/go-prompt v0.2.2/go.mod h1:VzqtzE2ksDBcdln8G7mk2RX9QyGjH+OVqOCSiVIqS34=
+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 v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+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/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+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/dave/jennifer v1.2.0/go.mod h1:fIb+770HOpJ2fmN9EPPKOqm1vMGhB+TwXKMZhrIygKg=
+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.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0=
+github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
+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-bitstream v0.0.0-20180413035011-3522498ce2c8/go.mod h1:VMaSuZ+SZcx/wljOQKvp5srsbCiKDEb6K2wC4+PiBmQ=
+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/eclipse/paho.mqtt.golang v1.2.0/go.mod h1:H9keYFcgq3Qr5OUJm/JZI/i6U7joQ8SYLhZwfeOo6Ts=
+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.4 h1:KG81SnUHXWk8LJB3mBcHg/E2yLvXoiPmRMCIRxgx3cE=
+github.com/ethereum/go-ethereum v1.11.4/go.mod h1:it7x0DWnTDMfVFdXcU6Ti4KEFQynLHVRarcSlPr0HBo=
+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/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.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/glycerine/go-unsnap-stream v0.0.0-20180323001048-9f0cb55181dd/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
+github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
+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-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+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.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+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.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/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/gofrs/uuid v3.3.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
+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.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
+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.3.0 h1:kHL1vqdqWNfATmA0FNMdmZNMyZI1U6O31X4rlIPoBog=
+github.com/golang-jwt/jwt/v4 v4.3.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg=
+github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/golang/geo v0.0.0-20190916061304-5b978397cfec/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+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.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
+github.com/golang/snappy v0.0.4/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/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/flatbuffers v1.11.0/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+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/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+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/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+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/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+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.0 h1:gpSYcPLWGv4sG43I2mVLiDZCNDh/EpGjSk8tmtxitHM=
+github.com/holiman/uint256 v1.2.0/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw=
+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/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+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/flux v0.65.1/go.mod h1:J754/zds0vvpfwuq7Gc2wRdVwEodfpCFM7mYlOw2LqY=
+github.com/influxdata/influxdb v1.8.3 h1:WEypI1BQFTT4teLM+1qkEcvUi0dAvopAI/ir0vAiBg8=
+github.com/influxdata/influxdb v1.8.3/go.mod h1:JugdFhsvvI8gadxOI6noqNeeBHvWNTbfYGtiAn+2jhI=
+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/influxql v1.1.1-0.20200828144457-65d3ef77d385/go.mod h1:gHp9y86a/pxhjJ+zMjNXiQAA197Xk9wLxaz+fGG+kWk=
+github.com/influxdata/line-protocol v0.0.0-20180522152040-32c6aa80de5e/go.mod h1:4kt73NQhadE3daL3WhR5EJ/J2ocX0PZzwxQ0gXJ7oFE=
+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/influxdata/promql/v2 v2.12.0/go.mod h1:fxOPu+DY0bqCTCECchSRtWfc+0X19ybifQhZoQNF5D8=
+github.com/influxdata/roaring v0.4.13-0.20180809181101-fc520f41fab6/go.mod h1:bSgUQ7q5ZLSO+bKBGqJiCBGAl+9DxyW63zLTujjUlOE=
+github.com/influxdata/tdigest v0.0.0-20181121200506-bf2b5ad3c0a9/go.mod h1:Js0mqiSBE6Ffsg94weZZ2c+v/ciT8QRHFOap7EKDrR0=
+github.com/influxdata/usage-client v0.0.0-20160829180054-6d3895376368/go.mod h1:Wbbw6tYNvwa5dlB6304Sd+82Z3f7PmVZHVKU637d4po=
+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/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/jsternberg/zap-logfmt v1.0.0/go.mod h1:uvPs/4X51zdkcm5jXl5SYoN+4RK21K8mysFmDaM/h+o=
+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/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/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.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
+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.4.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+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 v0.0.0-20170728055534-ae7887de9fa5/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/klauspost/crc32 v0.0.0-20161016154125-cb6bfca970f6/go.mod h1:+ZoRqAPRLkC4NPOvfYeR5KNOrY6TD+/sAC3HXPZgDYg=
+github.com/klauspost/pgzip v1.0.2-0.20170402124221-0bf5dcad4ada/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+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.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+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.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+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.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+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.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
+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/go-tty v0.0.0-20180907095812-13ff1204f104/go.mod h1:XPvLUNfbS4fJH25nqRHfWLMa1ONC8Amw+mIA639KxkE=
+github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+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/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/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.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/opentracing/opentracing-go v1.0.3-0.20180606204148-bd9c31933947/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+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/paulbellamy/ratecounter v0.2.0/go.mod h1:Hfx1hDpSGoqxkVVpBi/IlYD7kChlfo5C6hzIHwPqfFE=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/peterh/liner v1.0.1-0.20180619022028-8c1271fcf47f/go.mod h1:xIteQHvHuaLYG9IFj6mSxM0fCKrs34IrEQUhOYuGPHc=
+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/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/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.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=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/term v0.0.0-20180730021639-bffc007b7fd5/go.mod h1:eCbImbZ95eXtAUIbLAuAVnBnwf83mjf6QIVH8SHYwqQ=
+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 v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+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-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+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.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=
+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.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+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/retailnext/hllpp v1.0.1-0.20180308014038-101a6d2f8b52/go.mod h1:RDpi1RftBQPUCDRw6SmxeaREsAaRKnOclghuzp/WRzc=
+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.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+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/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=
+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.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+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/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+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.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+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.1.1/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.0/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+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/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
+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/willf/bitset v1.1.3/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
+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/xlab/treeprint v0.0.0-20180616005107-d6fb6747feb6/go.mod h1:ce1O1j6UtZfjr22oyGxGLbauSBp2YVXpARAosm7dHBg=
+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=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/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-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+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.7.0 h1:AvwMYaRytfdeVt3u6mLaxYtErKYjxA2OXjJ1HHq6t3A=
+golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
+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=
+golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+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/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+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-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+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-20181114220301-adae6a3d119a/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-20190108225652-1e06a53dbb7e/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-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/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.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
+golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
+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=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+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-20180905080454-ebe1bf3edb33/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-20181116152217-5ac8a444bdc5/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-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/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-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200107162124-548cf772de50/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.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
+golang.org/x/sys v0.7.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.1-0.20180807135948-17ff2d5776d2/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-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+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.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=
+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-20190206041539-40960b6deb8e/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-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/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-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+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-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+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-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=
+gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo=
+gonum.org/v1/gonum v0.0.0-20181121035319-3f7ecaa7e8ca/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo=
+gonum.org/v1/gonum v0.6.0/go.mod h1:9mxDZsDKxgMAuccQkewq682L+0eCu4dCN2yonUJTCLU=
+gonum.org/v1/netlib v0.0.0-20181029234149-ec6d1f5cefe6/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw=
+gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw=
+gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+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/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+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-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190716160619-c506a9f90610/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200108215221-bd8f9a0ef82f/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+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.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+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.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+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/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-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/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-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+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=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

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/abi/bridge_abi.go

@@ -104,7 +104,7 @@ var L1MessageQueueMetaData = &bind.MetaData{
 
 // L2GasPriceOracleMetaData contains all meta data concerning the L2GasPriceOracle contract.
 var L2GasPriceOracleMetaData = &bind.MetaData{
-	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"l2BaseFee\",\"type\":\"uint256\"}],\"name\":\"L2BaseFeeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"overhead\",\"type\":\"uint256\"}],\"name\":\"OverheadUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"scalar\",\"type\":\"uint256\"}],\"name\":\"ScalarUpdated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"_message\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"_gasLimit\",\"type\":\"uint256\"}],\"name\":\"estimateCrossDomainMessageFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"getL1GasUsed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1BaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2BaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"overhead\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"scalar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2BaseFee\",\"type\":\"uint256\"}],\"name\":\"setL2BaseFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_overhead\",\"type\":\"uint256\"}],\"name\":\"setOverhead\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_scalar\",\"type\":\"uint256\"}],\"name\":\"setScalar\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
+	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"l2BaseFee\",\"type\":\"uint256\"}],\"name\":\"L2BaseFeeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_oldWhitelist\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_newWhitelist\",\"type\":\"address\"}],\"name\":\"UpdateWhitelist\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"_gasLimit\",\"type\":\"uint256\"}],\"name\":\"estimateCrossDomainMessageFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2BaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2BaseFee\",\"type\":\"uint256\"}],\"name\":\"setL2BaseFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newWhitelist\",\"type\":\"address\"}],\"name\":\"updateWhitelist\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"whitelist\",\"outputs\":[{\"internalType\":\"contract IWhitelist\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
 }
 
 // L2ScrollMessengerMetaData contains all meta data concerning the L2ScrollMessenger contract.

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",
@@ -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,

bridge/go.mod

@@ -7,6 +7,7 @@ require (
 	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/smartystreets/goconvey v1.8.0
 	github.com/stretchr/testify v1.8.2
 	github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa
 	golang.org/x/sync v0.1.0
@@ -22,8 +23,10 @@ require (
 	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/jtolds/gls v4.20.0+incompatible // 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
@@ -35,6 +38,7 @@ require (
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/scroll-tech/zktrie v0.5.2 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
+	github.com/smartystreets/assertions v1.13.1 // indirect
 	github.com/tklauser/go-sysconf v0.3.11 // indirect
 	github.com/tklauser/numcpus v0.6.0 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
@@ -42,7 +46,7 @@ require (
 	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/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

@@ -36,6 +36,8 @@ github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 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/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g=
+github.com/gopherjs/gopherjs v1.17.2/go.mod h1:pRRIvn/QzFLrKfvEz3qUuEhtE/zLCWfreZ6J5gM2i+k=
 github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
 github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE=
@@ -49,6 +51,7 @@ github.com/iden3/go-iden3-crypto v0.0.14/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBe
 github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
 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=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 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=
@@ -96,7 +99,11 @@ github.com/scroll-tech/zktrie v0.5.2/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ7
 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=
+github.com/smartystreets/assertions v1.13.1 h1:Ef7KhSmjZcK6AVf9YbJdvPYG9avaF0ZxudX+ThRdWfU=
+github.com/smartystreets/assertions v1.13.1/go.mod h1:cXr/IwVfSo/RbCSPhoAPv73p3hlSdrBH/b3SdnW/LMY=
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+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/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
@@ -136,8 +143,8 @@ golang.org/x/sys v0.7.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.go

@@ -135,7 +135,7 @@ func (r *Layer1Relayer) ProcessSavedEvents() {
 func (r *Layer1Relayer) processSavedEvent(msg *types.L1Message) error {
 	calldata := common.Hex2Bytes(msg.Calldata)
 
-	from, tx, err := r.messageSender.SendTransaction(msg.MsgHash, &r.cfg.MessengerContractAddress, big.NewInt(0), calldata, r.minGasLimitForMessageRelay)
+	hash, err := r.messageSender.SendTransaction(msg.MsgHash, &r.cfg.MessengerContractAddress, big.NewInt(0), calldata, r.minGasLimitForMessageRelay)
 	if err != nil && err.Error() == "execution reverted: Message expired" {
 		return r.db.UpdateLayer1Status(r.ctx, msg.MsgHash, types.MsgExpired)
 	}
@@ -146,17 +146,12 @@ func (r *Layer1Relayer) processSavedEvent(msg *types.L1Message) error {
 		return err
 	}
 	bridgeL1MsgsRelayedTotalCounter.Inc(1)
-	log.Info("relayMessage to layer2", "msg hash", msg.MsgHash, "tx hash", tx.Hash().String())
+	log.Info("relayMessage to layer2", "msg hash", msg.MsgHash, "tx hash", hash)
 
-	err = r.db.UpdateLayer1StatusAndLayer2Hash(r.ctx, msg.MsgHash, types.MsgSubmitted, tx.Hash().String())
+	err = r.db.UpdateLayer1StatusAndLayer2Hash(r.ctx, msg.MsgHash, types.MsgSubmitted, hash.String())
 	if err != nil {
 		log.Error("UpdateLayer1StatusAndLayer2Hash failed", "msg.msgHash", msg.MsgHash, "msg.height", msg.Height, "err", err)
 	}
-	err = r.db.SaveScrollTx(msg.MsgHash, from.String(), types.L1toL2MessageTx, tx, "")
-	if err != nil {
-		log.Error("failed to save l1 relay tx message", "msg.msgHash", msg.MsgHash, "msg.height", msg.Height, "tx.hash", tx.Hash().String(), "err", err)
-	}
-
 	return err
 }
 
@@ -192,7 +187,7 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 				return
 			}
 
-			_, tx, err := r.gasOracleSender.SendTransaction(block.Hash, &r.cfg.GasPriceOracleContractAddress, big.NewInt(0), data, 0)
+			hash, err := r.gasOracleSender.SendTransaction(block.Hash, &r.cfg.GasPriceOracleContractAddress, big.NewInt(0), data, 0)
 			if err != nil {
 				if !errors.Is(err, sender.ErrNoAvailableAccount) && !errors.Is(err, sender.ErrFullPending) {
 					log.Error("Failed to send setL1BaseFee tx to layer2 ", "block.Hash", block.Hash, "block.Height", block.Number, "err", err)
@@ -200,13 +195,13 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 				return
 			}
 
-			err = r.db.UpdateL1GasOracleStatusAndOracleTxHash(r.ctx, block.Hash, types.GasOracleImporting, tx.Hash().String())
+			err = r.db.UpdateL1GasOracleStatusAndOracleTxHash(r.ctx, block.Hash, types.GasOracleImporting, hash.String())
 			if err != nil {
 				log.Error("UpdateGasOracleStatusAndOracleTxHash failed", "block.Hash", block.Hash, "block.Height", block.Number, "err", err)
 				return
 			}
 			r.lastGasPrice = block.BaseFee
-			log.Info("Update l1 base fee", "txHash", tx.Hash().String(), "baseFee", baseFee)
+			log.Info("Update l1 base fee", "txHash", hash.String(), "baseFee", baseFee)
 		}
 	}
 }
@@ -230,9 +225,6 @@ func (r *Layer1Relayer) handleConfirmLoop(ctx context.Context) {
 				if err != nil {
 					log.Warn("UpdateLayer1StatusAndLayer2Hash failed", "err", err)
 				}
-				if err = r.db.SetScrollTxConfirmedByID(cfm.ID, cfm.TxHash.String()); err != nil {
-					log.Warn("failed to delete l1 relayer tx data by hash", "msg.msgHash", cfm.ID, "tx.Hash", cfm.TxHash.String(), "err", err)
-				}
 				log.Info("transaction confirmed in layer2", "confirmation", cfm)
 			}
 		case cfm := <-r.gasOracleSender.ConfirmChan():
@@ -249,7 +241,6 @@ func (r *Layer1Relayer) handleConfirmLoop(ctx context.Context) {
 				if err != nil {
 					log.Warn("UpdateGasOracleStatusAndOracleTxHash failed", "err", err)
 				}
-
 				log.Info("transaction confirmed in layer2", "confirmation", cfm)
 			}
 		}

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.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"math/big"
 	"runtime"
-	"strings"
 	"sync"
 
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
@@ -18,11 +17,11 @@ import (
 	"golang.org/x/sync/errgroup"
 	"modernc.org/mathutil"
 
-	"scroll-tech/database"
-
 	"scroll-tech/common/metrics"
 	"scroll-tech/common/types"
 
+	"scroll-tech/database"
+
 	bridge_abi "scroll-tech/bridge/abi"
 	"scroll-tech/bridge/config"
 	"scroll-tech/bridge/sender"
@@ -227,7 +226,7 @@ func (r *Layer2Relayer) processSavedEvent(msg *types.L2Message) error {
 		return err
 	}
 
-	senderAddr, tx, err := r.messageSender.SendTransaction(msg.MsgHash, &r.cfg.MessengerContractAddress, big.NewInt(0), data, r.minGasLimitForMessageRelay)
+	hash, err := r.messageSender.SendTransaction(msg.MsgHash, &r.cfg.MessengerContractAddress, big.NewInt(0), data, r.minGasLimitForMessageRelay)
 	if err != nil && err.Error() == "execution reverted: Message expired" {
 		return r.db.UpdateLayer2Status(r.ctx, msg.MsgHash, types.MsgExpired)
 	}
@@ -241,20 +240,15 @@ func (r *Layer2Relayer) processSavedEvent(msg *types.L2Message) error {
 		return err
 	}
 	bridgeL2MsgsRelayedTotalCounter.Inc(1)
-	log.Info("relayMessageWithProof to layer1", "msgHash", msg.MsgHash, "txhash", tx.Hash().String())
+	log.Info("relayMessageWithProof to layer1", "msgHash", msg.MsgHash, "txhash", hash.String())
 
 	// save status in db
 	// @todo handle db error
-	err = r.db.UpdateLayer2StatusAndLayer1Hash(r.ctx, msg.MsgHash, types.MsgSubmitted, tx.Hash().String())
+	err = r.db.UpdateLayer2StatusAndLayer1Hash(r.ctx, msg.MsgHash, types.MsgSubmitted, hash.String())
 	if err != nil {
 		log.Error("UpdateLayer2StatusAndLayer1Hash failed", "msgHash", msg.MsgHash, "err", err)
 		return err
 	}
-	err = r.db.SaveScrollTx(msg.MsgHash, senderAddr.String(), types.L2toL1MessageTx, tx, "")
-	if err != nil {
-		log.Error("failed to save l2 relay tx message", "msg.hash", msg.MsgHash, "tx.hash", tx.Hash().String(), "err", err)
-	}
-
 	r.processingMessage.Store(msg.MsgHash, msg.MsgHash)
 	return nil
 }
@@ -284,7 +278,7 @@ func (r *Layer2Relayer) ProcessGasPriceOracle() {
 				return
 			}
 
-			_, tx, err := r.gasOracleSender.SendTransaction(batch.Hash, &r.cfg.GasPriceOracleContractAddress, big.NewInt(0), data, 0)
+			hash, err := r.gasOracleSender.SendTransaction(batch.Hash, &r.cfg.GasPriceOracleContractAddress, big.NewInt(0), data, 0)
 			if err != nil {
 				if !errors.Is(err, sender.ErrNoAvailableAccount) && !errors.Is(err, sender.ErrFullPending) {
 					log.Error("Failed to send setL2BaseFee tx to layer2 ", "batch.Hash", batch.Hash, "err", err)
@@ -292,13 +286,13 @@ func (r *Layer2Relayer) ProcessGasPriceOracle() {
 				return
 			}
 
-			err = r.db.UpdateL2GasOracleStatusAndOracleTxHash(r.ctx, batch.Hash, types.GasOracleImporting, tx.Hash().String())
+			err = r.db.UpdateL2GasOracleStatusAndOracleTxHash(r.ctx, batch.Hash, types.GasOracleImporting, hash.String())
 			if err != nil {
 				log.Error("UpdateGasOracleStatusAndOracleTxHash failed", "batch.Hash", batch.Hash, "err", err)
 				return
 			}
 			r.lastGasPrice = suggestGasPriceUint64
-			log.Info("Update l2 gas price", "txHash", tx.Hash().String(), "GasPrice", suggestGasPrice)
+			log.Info("Update l2 gas price", "txHash", hash.String(), "GasPrice", suggestGasPrice)
 		}
 	}
 }
@@ -330,7 +324,7 @@ func (r *Layer2Relayer) SendCommitTx(batchData []*types.BatchData) error {
 		bytes = append(bytes, batch.Hash().Bytes()...)
 	}
 	txID := crypto.Keccak256Hash(bytes).String()
-	from, tx, err := r.rollupSender.SendTransaction(txID, &r.cfg.RollupContractAddress, big.NewInt(0), calldata, 0)
+	txHash, err := r.rollupSender.SendTransaction(txID, &r.cfg.RollupContractAddress, big.NewInt(0), calldata, 0)
 	if err != nil {
 		if !errors.Is(err, sender.ErrNoAvailableAccount) && !errors.Is(err, sender.ErrFullPending) {
 			log.Error("Failed to send commitBatches tx to layer1 ", "err", err)
@@ -339,7 +333,7 @@ func (r *Layer2Relayer) SendCommitTx(batchData []*types.BatchData) error {
 	}
 	bridgeL2BatchesCommittedTotalCounter.Inc(int64(len(commitBatches)))
 	log.Info("Sent the commitBatches tx to layer1",
-		"tx_hash", tx.Hash().Hex(),
+		"tx_hash", txHash.Hex(),
 		"start_batch_index", commitBatches[0].BatchIndex,
 		"end_batch_index", commitBatches[len(commitBatches)-1].BatchIndex)
 
@@ -347,16 +341,11 @@ func (r *Layer2Relayer) SendCommitTx(batchData []*types.BatchData) error {
 	batchHashes := make([]string, len(batchData))
 	for i, batch := range batchData {
 		batchHashes[i] = batch.Hash().Hex()
-		err = r.db.UpdateCommitTxHashAndRollupStatus(r.ctx, batchHashes[i], tx.Hash().String(), types.RollupCommitting)
+		err = r.db.UpdateCommitTxHashAndRollupStatus(r.ctx, batchHashes[i], txHash.String(), types.RollupCommitting)
 		if err != nil {
 			log.Error("UpdateCommitTxHashAndRollupStatus failed", "hash", batchHashes[i], "index", batch.Batch.BatchIndex, "err", err)
 		}
 	}
-	// Record batches tx message.
-	err = r.db.SaveScrollTx(txID, from.String(), types.RollUpCommitTx, tx, strings.Join(batchHashes, ","))
-	if err != nil {
-		log.Error("failed to save l2 commitBatches tx message", "batches.id", txID, "tx.hash", tx.Hash().String(), "err", err)
-	}
 	r.processingBatchesCommitment.Store(txID, batchHashes)
 	return nil
 }
@@ -484,7 +473,8 @@ func (r *Layer2Relayer) ProcessCommittedBatches() {
 
 		txID := hash + "-finalize"
 		// add suffix `-finalize` to avoid duplication with commit tx in unit tests
-		from, tx, err := r.rollupSender.SendTransaction(txID, &r.cfg.RollupContractAddress, big.NewInt(0), data, 0)
+		txHash, err := r.rollupSender.SendTransaction(txID, &r.cfg.RollupContractAddress, big.NewInt(0), data, 0)
+		finalizeTxHash := &txHash
 		if err != nil {
 			if !errors.Is(err, sender.ErrNoAvailableAccount) && !errors.Is(err, sender.ErrFullPending) {
 				log.Error("finalizeBatchWithProof in layer1 failed", "hash", hash, "err", err)
@@ -495,15 +485,10 @@ func (r *Layer2Relayer) ProcessCommittedBatches() {
 		log.Info("finalizeBatchWithProof in layer1", "batch_hash", hash, "tx_hash", hash)
 
 		// record and sync with db, @todo handle db error
-		err = r.db.UpdateFinalizeTxHashAndRollupStatus(r.ctx, hash, tx.Hash().String(), types.RollupFinalizing)
+		err = r.db.UpdateFinalizeTxHashAndRollupStatus(r.ctx, hash, finalizeTxHash.String(), types.RollupFinalizing)
 		if err != nil {
 			log.Warn("UpdateFinalizeTxHashAndRollupStatus failed", "batch_hash", hash, "err", err)
 		}
-		err = r.db.SaveScrollTx(txID, from.String(), types.RollupFinalizeTx, tx, "")
-		if err != nil {
-			log.Error("failed to save l2 committed tx message", "batch.hash", txID, "tx.hash", tx.Hash().String(), "err", err)
-		}
-
 		success = true
 		r.processingFinalization.Store(txID, hash)
 
@@ -531,9 +516,6 @@ func (r *Layer2Relayer) handleConfirmation(confirmation *sender.Confirmation) {
 		if err != nil {
 			log.Warn("UpdateLayer2StatusAndLayer1Hash failed", "msgHash", msgHash.(string), "err", err)
 		}
-		if err = r.db.SetScrollTxConfirmedByID(confirmation.ID, confirmation.TxHash.String()); err != nil {
-			log.Warn("failed to delete l2 relayer message tx data", "msg.Hash", confirmation.ID, "tx.Hash", confirmation.TxHash.String(), "err", err)
-		}
 		bridgeL2MsgsRelayedConfirmedTotalCounter.Inc(1)
 		r.processingMessage.Delete(confirmation.ID)
 	}
@@ -556,9 +538,6 @@ func (r *Layer2Relayer) handleConfirmation(confirmation *sender.Confirmation) {
 				log.Warn("UpdateCommitTxHashAndRollupStatus failed", "batch_hash", batchHash, "err", err)
 			}
 		}
-		if err := r.db.SetScrollTxConfirmedByID(confirmation.ID, confirmation.TxHash.String()); err != nil {
-			log.Warn("failed to delete commitBatches committed tx data", "batched.id", confirmation.ID, "tx.Hash", confirmation.TxHash.String(), "err", err)
-		}
 		bridgeL2BatchesCommittedConfirmedTotalCounter.Inc(int64(len(batchHashes)))
 		r.processingBatchesCommitment.Delete(confirmation.ID)
 	}
@@ -578,9 +557,6 @@ func (r *Layer2Relayer) handleConfirmation(confirmation *sender.Confirmation) {
 		if err != nil {
 			log.Warn("UpdateFinalizeTxHashAndRollupStatus failed", "batch_hash", batchHash.(string), "err", err)
 		}
-		if err = r.db.SetScrollTxConfirmedByID(confirmation.ID, confirmation.TxHash.String()); err != nil {
-			log.Warn("failed to delete finalizeBatchWithProof tx data", "batch.Hash", confirmation.ID, "tx.Hash", confirmation.TxHash.String(), "err", err)
-		}
 		bridgeL2BatchesFinalizedConfirmedTotalCounter.Inc(1)
 		r.processingFinalization.Delete(confirmation.ID)
 	}

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.go

@@ -188,22 +188,21 @@ func (s *Sender) getFeeData(auth *bind.TransactOpts, target *common.Address, val
 }
 
 // SendTransaction send a signed L2tL1 transaction.
-func (s *Sender) SendTransaction(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (common.Address, *types.Transaction, error) {
+func (s *Sender) SendTransaction(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (hash common.Hash, err error) {
 	if s.IsFull() {
-		return common.Address{}, nil, ErrFullPending
+		return common.Hash{}, ErrFullPending
 	}
 	// We occupy the ID, in case some other threads call with the same ID in the same time
 	if ok := s.pendingTxs.SetIfAbsent(ID, nil); !ok {
-		return common.Address{}, nil, fmt.Errorf("has the repeat tx ID, ID: %s", ID)
+		return common.Hash{}, fmt.Errorf("has the repeat tx ID, ID: %s", ID)
 	}
 	// get
 	auth := s.auths.getAccount()
 	if auth == nil {
 		s.pendingTxs.Remove(ID) // release the ID on failure
-		return common.Address{}, nil, ErrNoAvailableAccount
+		return common.Hash{}, ErrNoAvailableAccount
 	}
 
-	var err error
 	defer s.auths.releaseAccount(auth)
 	defer func() {
 		if err != nil {
@@ -217,21 +216,22 @@ func (s *Sender) SendTransaction(ID string, target *common.Address, value *big.I
 	)
 	// estimate gas fee
 	if feeData, err = s.getFeeData(auth, target, value, data, minGasLimit); err != nil {
-		return common.Address{}, nil, err
+		return
 	}
-	if tx, err = s.createAndSendTx(auth, feeData, target, value, data, nil); err != nil {
-		return common.Address{}, nil, err
+	if tx, err = s.createAndSendTx(auth, feeData, target, value, data, nil); err == nil {
+		// add pending transaction to queue
+		pending := &PendingTransaction{
+			tx:       tx,
+			id:       ID,
+			signer:   auth,
+			submitAt: atomic.LoadUint64(&s.blockNumber),
+			feeData:  feeData,
+		}
+		s.pendingTxs.Set(ID, pending)
+		return tx.Hash(), nil
 	}
-	// add pending transaction to queue
-	s.pendingTxs.Set(ID, &PendingTransaction{
-		tx:       tx,
-		id:       ID,
-		signer:   auth,
-		submitAt: atomic.LoadUint64(&s.blockNumber),
-		feeData:  feeData,
-	})
 
-	return auth.From, tx, nil
+	return
 }
 
 func (s *Sender) createAndSendTx(auth *bind.TransactOpts, feeData *FeeData, target *common.Address, value *big.Int, data []byte, overrideNonce *uint64) (tx *types.Transaction, err error) {

bridge/sender/sender_test.go

@@ -99,7 +99,7 @@ func testPendLimit(t *testing.T) {
 		assert.NoError(t, err)
 
 		for i := 0; i < 2*newSender.PendingLimit(); i++ {
-			_, _, err = newSender.SendTransaction(strconv.Itoa(i), &common.Address{}, big.NewInt(1), nil, 0)
+			_, err = newSender.SendTransaction(strconv.Itoa(i), &common.Address{}, big.NewInt(1), nil, 0)
 			assert.True(t, err == nil || (err != nil && err.Error() == "sender's pending pool is full"))
 		}
 		assert.True(t, newSender.PendingCount() <= newSender.PendingLimit())
@@ -119,16 +119,16 @@ func testMinGasLimit(t *testing.T) {
 		assert.NoError(t, err)
 
 		// MinGasLimit = 0
-		_, tx, err := newSender.SendTransaction("0", &common.Address{}, big.NewInt(1), nil, 0)
+		txHash0, err := newSender.SendTransaction("0", &common.Address{}, big.NewInt(1), nil, 0)
 		assert.NoError(t, err)
-		tx0, _, err := client.TransactionByHash(context.Background(), tx.Hash())
+		tx0, _, err := client.TransactionByHash(context.Background(), txHash0)
 		assert.NoError(t, err)
 		assert.Greater(t, tx0.Gas(), uint64(0))
 
 		// MinGasLimit = 100000
-		_, tx, err = newSender.SendTransaction("1", &common.Address{}, big.NewInt(1), nil, 100000)
+		txHash1, err := newSender.SendTransaction("1", &common.Address{}, big.NewInt(1), nil, 100000)
 		assert.NoError(t, err)
-		tx1, _, err := client.TransactionByHash(context.Background(), tx.Hash())
+		tx1, _, err := client.TransactionByHash(context.Background(), txHash1)
 		assert.NoError(t, err)
 		assert.Equal(t, tx1.Gas(), uint64(150000))
 
@@ -179,7 +179,7 @@ func testBatchSender(t *testing.T, batchSize int) {
 				for i := 0; i < TXBatch; i++ {
 					toAddr := common.HexToAddress("0x4592d8f8d7b001e72cb26a73e4fa1806a51ac79d")
 					id := strconv.Itoa(i + index*1000)
-					_, _, err := newSender.SendTransaction(id, &toAddr, big.NewInt(1), nil, 0)
+					_, err := newSender.SendTransaction(id, &toAddr, big.NewInt(1), nil, 0)
 					if errors.Is(err, ErrNoAvailableAccount) || errors.Is(err, ErrFullPending) {
 						<-time.After(time.Second)
 						continue

bridge/watcher/batch_proposer_test.go

@@ -36,7 +36,7 @@ func testBatchProposerProposeBatch(t *testing.T) {
 		commitCalldataSizeLimit: 500,
 		orm:                     db,
 	}
-	patchGuard1 := gomonkey.ApplyMethodFunc(p.orm, "GetL2WrappedBlocks", func(fields map[string]interface{}, args ...string) ([]*types.WrappedBlock, error) {
+	patchGuard := gomonkey.ApplyMethodFunc(p.orm, "GetL2WrappedBlocks", func(fields map[string]interface{}, args ...string) ([]*types.WrappedBlock, error) {
 		hash, _ := fields["hash"].(string)
 		if hash == "blockWithLongData" {
 			longData := strings.Repeat("0", 1000)
@@ -52,11 +52,10 @@ func testBatchProposerProposeBatch(t *testing.T) {
 			}},
 		}}, nil
 	})
-	defer patchGuard1.Reset()
-	patchGuard2 := gomonkey.ApplyPrivateMethod(p, "createBatchForBlocks", func(*BatchProposer, []*types.BlockInfo) error {
+	defer patchGuard.Reset()
+	patchGuard.ApplyPrivateMethod(p, "createBatchForBlocks", func(*BatchProposer, []*types.BlockInfo) error {
 		return nil
 	})
-	defer patchGuard2.Reset()
 
 	block1 := &types.BlockInfo{Number: 1, GasUsed: 100, TxNum: 1, BlockTimestamp: uint64(time.Now().Unix()) - 200}
 	block2 := &types.BlockInfo{Number: 2, GasUsed: 200, TxNum: 2, BlockTimestamp: uint64(time.Now().Unix())}

bridge/watcher/l1_watcher.go

@@ -14,11 +14,11 @@ import (
 	geth_metrics "github.com/scroll-tech/go-ethereum/metrics"
 	"github.com/scroll-tech/go-ethereum/rpc"
 
-	"scroll-tech/database"
-
 	"scroll-tech/common/metrics"
 	"scroll-tech/common/types"
 
+	"scroll-tech/database"
+
 	bridge_abi "scroll-tech/bridge/abi"
 	"scroll-tech/bridge/utils"
 )
@@ -101,6 +101,24 @@ func NewL1WatcherClient(ctx context.Context, client *ethclient.Client, startHeig
 	}
 }
 
+// ProcessedBlockHeight get processedBlockHeight
+// Currently only use for unit test
+func (w *L1WatcherClient) ProcessedBlockHeight() uint64 {
+	return w.processedBlockHeight
+}
+
+// Confirmations get confirmations
+// Currently only use for unit test
+func (w *L1WatcherClient) Confirmations() rpc.BlockNumber {
+	return w.confirmations
+}
+
+// SetConfirmations set the confirmations for L1WatcherClient
+// Currently only use for unit test
+func (w *L1WatcherClient) SetConfirmations(confirmations rpc.BlockNumber) {
+	w.confirmations = confirmations
+}
+
 // FetchBlockHeader pull latest L1 blocks and save in DB
 func (w *L1WatcherClient) FetchBlockHeader(blockHeight uint64) error {
 	fromBlock := int64(w.processedBlockHeight) + 1

bridge/watcher/l1_watcher_test.go

@@ -2,21 +2,34 @@ package watcher
 
 import (
 	"context"
+	"errors"
+	"math/big"
 	"testing"
 
+	"github.com/agiledragon/gomonkey/v2"
+	"github.com/scroll-tech/go-ethereum"
+	"github.com/scroll-tech/go-ethereum/accounts/abi"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/core/types"
+	geth_types "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/ethclient"
+	"github.com/scroll-tech/go-ethereum/rpc"
+	"github.com/smartystreets/goconvey/convey"
 	"github.com/stretchr/testify/assert"
 
+	bridge_abi "scroll-tech/bridge/abi"
+	"scroll-tech/bridge/utils"
+
+	commonTypes "scroll-tech/common/types"
+
 	"scroll-tech/database"
 	"scroll-tech/database/migrate"
 )
 
-func testStartWatcher(t *testing.T) {
-	// Create db handler and reset db.
+func setupL1Watcher(t *testing.T) (*L1WatcherClient, database.OrmFactory) {
 	db, err := database.NewOrmFactory(cfg.DBConfig)
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
-	defer db.Close()
 
 	client, err := ethclient.Dial(base.L1gethImg.Endpoint())
 	assert.NoError(t, err)
@@ -25,4 +38,477 @@ func testStartWatcher(t *testing.T) {
 
 	watcher := NewL1WatcherClient(context.Background(), client, l1Cfg.StartHeight, l1Cfg.Confirmations, l1Cfg.L1MessengerAddress, l1Cfg.L1MessageQueueAddress, l1Cfg.RelayerConfig.RollupContractAddress, db)
 	assert.NoError(t, watcher.FetchContractEvent())
+	return watcher, db
+}
+
+func testFetchContractEvent(t *testing.T) {
+	watcher, db := setupL1Watcher(t)
+	defer db.Close()
+	assert.NoError(t, watcher.FetchContractEvent())
+}
+
+func testL1WatcherClientFetchBlockHeader(t *testing.T) {
+	watcher, db := setupL1Watcher(t)
+	defer db.Close()
+	convey.Convey("test toBlock < fromBlock", t, func() {
+		var blockHeight uint64
+		if watcher.ProcessedBlockHeight() <= 0 {
+			blockHeight = 0
+		} else {
+			blockHeight = watcher.ProcessedBlockHeight() - 1
+		}
+		err := watcher.FetchBlockHeader(blockHeight)
+		assert.NoError(t, err)
+	})
+
+	convey.Convey("test get header from client error", t, func() {
+		var c *ethclient.Client
+		patchGuard := gomonkey.ApplyMethodFunc(c, "HeaderByNumber", func(ctx context.Context, height *big.Int) (*types.Header, error) {
+			return nil, ethereum.NotFound
+		})
+		defer patchGuard.Reset()
+
+		var blockHeight uint64 = 10
+		err := watcher.FetchBlockHeader(blockHeight)
+		assert.Error(t, err)
+	})
+
+	convey.Convey("insert l1 block error", t, func() {
+		var c *ethclient.Client
+		patchGuard := gomonkey.ApplyMethodFunc(c, "HeaderByNumber", func(ctx context.Context, height *big.Int) (*types.Header, error) {
+			if height == nil {
+				height = big.NewInt(100)
+			}
+			t.Log(height)
+			return &types.Header{
+				BaseFee: big.NewInt(100),
+			}, nil
+		})
+		defer patchGuard.Reset()
+
+		patchGuard.ApplyMethodFunc(db, "InsertL1Blocks", func(ctx context.Context, blocks []*commonTypes.L1BlockInfo) error {
+			return errors.New("insert failed")
+		})
+
+		var blockHeight uint64 = 10
+		err := watcher.FetchBlockHeader(blockHeight)
+		assert.Error(t, err)
+	})
+
+	convey.Convey("fetch block header success", t, func() {
+		var c *ethclient.Client
+		patchGuard := gomonkey.ApplyMethodFunc(c, "HeaderByNumber", func(ctx context.Context, height *big.Int) (*types.Header, error) {
+			if height == nil {
+				height = big.NewInt(100)
+			}
+			t.Log(height)
+			return &types.Header{
+				BaseFee: big.NewInt(100),
+			}, nil
+		})
+		defer patchGuard.Reset()
+
+		patchGuard.ApplyMethodFunc(db, "InsertL1Blocks", func(ctx context.Context, blocks []*commonTypes.L1BlockInfo) error {
+			return nil
+		})
+
+		var blockHeight uint64 = 10
+		err := watcher.FetchBlockHeader(blockHeight)
+		assert.NoError(t, err)
+	})
+}
+
+func testL1WatcherClientFetchContractEvent(t *testing.T) {
+	watcher, db := setupL1Watcher(t)
+	defer db.Close()
+
+	watcher.SetConfirmations(rpc.SafeBlockNumber)
+	convey.Convey("get latest confirmed block number failure", t, func() {
+		var c *ethclient.Client
+		patchGuard := gomonkey.ApplyMethodFunc(c, "HeaderByNumber", func(ctx context.Context, height *big.Int) (*types.Header, error) {
+			return nil, ethereum.NotFound
+		})
+		defer patchGuard.Reset()
+		err := watcher.FetchContractEvent()
+		assert.Error(t, err)
+	})
+
+	var c *ethclient.Client
+	patchGuard := gomonkey.ApplyMethodFunc(c, "HeaderByNumber", func(ctx context.Context, height *big.Int) (*types.Header, error) {
+		if height == nil {
+			height = big.NewInt(100)
+		}
+		t.Log(height)
+		return &types.Header{
+			Number:  big.NewInt(100),
+			BaseFee: big.NewInt(100),
+		}, nil
+	})
+	defer patchGuard.Reset()
+
+	convey.Convey("filter logs failure", t, func() {
+		targetErr := errors.New("call filter failure")
+		patchGuard.ApplyMethodFunc(c, "FilterLogs", func(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error) {
+			return nil, targetErr
+		})
+		err := watcher.FetchContractEvent()
+		assert.EqualError(t, err, targetErr.Error())
+	})
+
+	patchGuard.ApplyMethodFunc(c, "FilterLogs", func(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error) {
+		return []types.Log{
+			{
+				Address: common.HexToAddress("0x0000000000000000000000000000000000000000"),
+			},
+		}, nil
+	})
+
+	convey.Convey("parse bridge event logs failure", t, func() {
+		targetErr := errors.New("parse log failure")
+		patchGuard.ApplyPrivateMethod(watcher, "parseBridgeEventLogs", func(*L1WatcherClient, []geth_types.Log) ([]*commonTypes.L1Message, []relayedMessage, []rollupEvent, error) {
+			return nil, nil, nil, targetErr
+		})
+		err := watcher.FetchContractEvent()
+		assert.Equal(t, err.Error(), targetErr.Error())
+	})
+
+	patchGuard.ApplyPrivateMethod(watcher, "parseBridgeEventLogs", func(*L1WatcherClient, []geth_types.Log) ([]*commonTypes.L1Message, []relayedMessage, []rollupEvent, error) {
+		rollupEvents := []rollupEvent{
+			{
+				batchHash: common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+				txHash:    common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5"),
+				status:    commonTypes.RollupFinalized,
+			},
+			{
+				batchHash: common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5"),
+				txHash:    common.HexToHash("0xb4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30"),
+				status:    commonTypes.RollupCommitted,
+			},
+		}
+
+		relayedMessageEvents := []relayedMessage{
+			{
+				msgHash:      common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+				txHash:       common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5"),
+				isSuccessful: true,
+			},
+			{
+				msgHash:      common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5"),
+				txHash:       common.HexToHash("0xb4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30"),
+				isSuccessful: false,
+			},
+		}
+		return nil, relayedMessageEvents, rollupEvents, nil
+	})
+
+	convey.Convey("db get rollup status by hash list failure", t, func() {
+		targetErr := errors.New("get db failure")
+		patchGuard.ApplyMethodFunc(db, "GetRollupStatusByHashList", func(hashes []string) ([]commonTypes.RollupStatus, error) {
+			return nil, targetErr
+		})
+		err := watcher.FetchContractEvent()
+		assert.Equal(t, err.Error(), targetErr.Error())
+	})
+
+	convey.Convey("rollup status mismatch batch hashes length", t, func() {
+		patchGuard.ApplyMethodFunc(db, "GetRollupStatusByHashList", func(hashes []string) ([]commonTypes.RollupStatus, error) {
+			s := []commonTypes.RollupStatus{
+				commonTypes.RollupFinalized,
+			}
+			return s, nil
+		})
+		err := watcher.FetchContractEvent()
+		assert.NoError(t, err)
+	})
+
+	patchGuard.ApplyMethodFunc(db, "GetRollupStatusByHashList", func(hashes []string) ([]commonTypes.RollupStatus, error) {
+		s := []commonTypes.RollupStatus{
+			commonTypes.RollupPending,
+			commonTypes.RollupCommitting,
+		}
+		return s, nil
+	})
+
+	convey.Convey("db update RollupFinalized status failure", t, func() {
+		targetErr := errors.New("UpdateFinalizeTxHashAndRollupStatus RollupFinalized failure")
+		patchGuard.ApplyMethodFunc(db, "UpdateFinalizeTxHashAndRollupStatus", func(context.Context, string, string, commonTypes.RollupStatus) error {
+			return targetErr
+		})
+		err := watcher.FetchContractEvent()
+		assert.Equal(t, targetErr.Error(), err.Error())
+	})
+
+	patchGuard.ApplyMethodFunc(db, "UpdateFinalizeTxHashAndRollupStatus", func(context.Context, string, string, commonTypes.RollupStatus) error {
+		return nil
+	})
+
+	convey.Convey("db update RollupCommitted status failure", t, func() {
+		targetErr := errors.New("UpdateCommitTxHashAndRollupStatus RollupCommitted failure")
+		patchGuard.ApplyMethodFunc(db, "UpdateCommitTxHashAndRollupStatus", func(context.Context, string, string, commonTypes.RollupStatus) error {
+			return targetErr
+		})
+		err := watcher.FetchContractEvent()
+		assert.Equal(t, targetErr.Error(), err.Error())
+	})
+
+	patchGuard.ApplyMethodFunc(db, "UpdateCommitTxHashAndRollupStatus", func(context.Context, string, string, commonTypes.RollupStatus) error {
+		return nil
+	})
+
+	convey.Convey("db update layer2 status and layer1 hash failure", t, func() {
+		targetErr := errors.New("UpdateLayer2StatusAndLayer1Hash failure")
+		patchGuard.ApplyMethodFunc(db, "UpdateLayer2StatusAndLayer1Hash", func(context.Context, string, commonTypes.MsgStatus, string) error {
+			return targetErr
+		})
+		err := watcher.FetchContractEvent()
+		assert.Equal(t, targetErr.Error(), err.Error())
+	})
+
+	patchGuard.ApplyMethodFunc(db, "UpdateLayer2StatusAndLayer1Hash", func(context.Context, string, commonTypes.MsgStatus, string) error {
+		return nil
+	})
+
+	convey.Convey("db save l1 message failure", t, func() {
+		targetErr := errors.New("SaveL1Messages failure")
+		patchGuard.ApplyMethodFunc(db, "SaveL1Messages", func(context.Context, []*commonTypes.L1Message) error {
+			return targetErr
+		})
+		err := watcher.FetchContractEvent()
+		assert.Equal(t, targetErr.Error(), err.Error())
+	})
+
+	patchGuard.ApplyMethodFunc(db, "SaveL1Messages", func(context.Context, []*commonTypes.L1Message) error {
+		return nil
+	})
+
+	convey.Convey("FetchContractEvent success", t, func() {
+		err := watcher.FetchContractEvent()
+		assert.NoError(t, err)
+	})
+}
+
+func testParseBridgeEventLogsL1QueueTransactionEventSignature(t *testing.T) {
+	watcher, db := setupL1Watcher(t)
+	defer db.Close()
+
+	logs := []geth_types.Log{
+		{
+			Topics:      []common.Hash{bridge_abi.L1QueueTransactionEventSignature},
+			BlockNumber: 100,
+			TxHash:      common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+		},
+	}
+
+	convey.Convey("unpack QueueTransaction log failure", t, func() {
+		targetErr := errors.New("UnpackLog QueueTransaction failure")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log types.Log) error {
+			return targetErr
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, rollupEvents, err := watcher.parseBridgeEventLogs(logs)
+		assert.EqualError(t, err, targetErr.Error())
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+		assert.Empty(t, rollupEvents)
+	})
+
+	convey.Convey("L1QueueTransactionEventSignature success", t, func() {
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log types.Log) error {
+			tmpOut := out.(*bridge_abi.L1QueueTransactionEvent)
+			tmpOut.QueueIndex = big.NewInt(100)
+			tmpOut.Data = []byte("test data")
+			tmpOut.Sender = common.HexToAddress("0xb4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30")
+			tmpOut.Value = big.NewInt(1000)
+			tmpOut.Target = common.HexToAddress("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5")
+			tmpOut.GasLimit = big.NewInt(10)
+			return nil
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, rollupEvents, err := watcher.parseBridgeEventLogs(logs)
+		assert.NoError(t, err)
+		assert.Empty(t, relayedMessages)
+		assert.Empty(t, rollupEvents)
+		assert.Len(t, l2Messages, 1)
+		assert.Equal(t, l2Messages[0].Value, big.NewInt(1000).String())
+	})
+}
+
+func testParseBridgeEventLogsL1RelayedMessageEventSignature(t *testing.T) {
+	watcher, db := setupL1Watcher(t)
+	defer db.Close()
+
+	logs := []geth_types.Log{
+		{
+			Topics:      []common.Hash{bridge_abi.L1RelayedMessageEventSignature},
+			BlockNumber: 100,
+			TxHash:      common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+		},
+	}
+
+	convey.Convey("unpack RelayedMessage log failure", t, func() {
+		targetErr := errors.New("UnpackLog RelayedMessage failure")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log types.Log) error {
+			return targetErr
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, rollupEvents, err := watcher.parseBridgeEventLogs(logs)
+		assert.EqualError(t, err, targetErr.Error())
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+		assert.Empty(t, rollupEvents)
+	})
+
+	convey.Convey("L1RelayedMessageEventSignature success", t, func() {
+		msgHash := common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log types.Log) error {
+			tmpOut := out.(*bridge_abi.L1RelayedMessageEvent)
+			tmpOut.MessageHash = msgHash
+			return nil
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, rollupEvents, err := watcher.parseBridgeEventLogs(logs)
+		assert.NoError(t, err)
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, rollupEvents)
+		assert.Len(t, relayedMessages, 1)
+		assert.Equal(t, relayedMessages[0].msgHash, msgHash)
+	})
+}
+
+func testParseBridgeEventLogsL1FailedRelayedMessageEventSignature(t *testing.T) {
+	watcher, db := setupL1Watcher(t)
+	defer db.Close()
+
+	logs := []geth_types.Log{
+		{
+			Topics:      []common.Hash{bridge_abi.L1FailedRelayedMessageEventSignature},
+			BlockNumber: 100,
+			TxHash:      common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+		},
+	}
+
+	convey.Convey("unpack FailedRelayedMessage log failure", t, func() {
+		targetErr := errors.New("UnpackLog FailedRelayedMessage failure")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log types.Log) error {
+			return targetErr
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, rollupEvents, err := watcher.parseBridgeEventLogs(logs)
+		assert.EqualError(t, err, targetErr.Error())
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+		assert.Empty(t, rollupEvents)
+	})
+
+	convey.Convey("L1FailedRelayedMessageEventSignature success", t, func() {
+		msgHash := common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log types.Log) error {
+			tmpOut := out.(*bridge_abi.L1FailedRelayedMessageEvent)
+			tmpOut.MessageHash = msgHash
+			return nil
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, rollupEvents, err := watcher.parseBridgeEventLogs(logs)
+		assert.NoError(t, err)
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, rollupEvents)
+		assert.Len(t, relayedMessages, 1)
+		assert.Equal(t, relayedMessages[0].msgHash, msgHash)
+	})
+}
+
+func testParseBridgeEventLogsL1CommitBatchEventSignature(t *testing.T) {
+	watcher, db := setupL1Watcher(t)
+	defer db.Close()
+
+	logs := []geth_types.Log{
+		{
+			Topics:      []common.Hash{bridge_abi.L1CommitBatchEventSignature},
+			BlockNumber: 100,
+			TxHash:      common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+		},
+	}
+
+	convey.Convey("unpack CommitBatch log failure", t, func() {
+		targetErr := errors.New("UnpackLog CommitBatch failure")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log types.Log) error {
+			return targetErr
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, rollupEvents, err := watcher.parseBridgeEventLogs(logs)
+		assert.EqualError(t, err, targetErr.Error())
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+		assert.Empty(t, rollupEvents)
+	})
+
+	convey.Convey("L1CommitBatchEventSignature success", t, func() {
+		msgHash := common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log types.Log) error {
+			tmpOut := out.(*bridge_abi.L1CommitBatchEvent)
+			tmpOut.BatchHash = msgHash
+			return nil
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, rollupEvents, err := watcher.parseBridgeEventLogs(logs)
+		assert.NoError(t, err)
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+		assert.Len(t, rollupEvents, 1)
+		assert.Equal(t, rollupEvents[0].batchHash, msgHash)
+		assert.Equal(t, rollupEvents[0].status, commonTypes.RollupCommitted)
+	})
+}
+
+func testParseBridgeEventLogsL1FinalizeBatchEventSignature(t *testing.T) {
+	watcher, db := setupL1Watcher(t)
+	defer db.Close()
+
+	logs := []geth_types.Log{
+		{
+			Topics:      []common.Hash{bridge_abi.L1FinalizeBatchEventSignature},
+			BlockNumber: 100,
+			TxHash:      common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+		},
+	}
+
+	convey.Convey("unpack FinalizeBatch log failure", t, func() {
+		targetErr := errors.New("UnpackLog FinalizeBatch failure")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log types.Log) error {
+			return targetErr
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, rollupEvents, err := watcher.parseBridgeEventLogs(logs)
+		assert.EqualError(t, err, targetErr.Error())
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+		assert.Empty(t, rollupEvents)
+	})
+
+	convey.Convey("L1FinalizeBatchEventSignature success", t, func() {
+		msgHash := common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log types.Log) error {
+			tmpOut := out.(*bridge_abi.L1FinalizeBatchEvent)
+			tmpOut.BatchHash = msgHash
+			return nil
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, rollupEvents, err := watcher.parseBridgeEventLogs(logs)
+		assert.NoError(t, err)
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+		assert.Len(t, rollupEvents, 1)
+		assert.Equal(t, rollupEvents[0].batchHash, msgHash)
+		assert.Equal(t, rollupEvents[0].status, commonTypes.RollupFinalized)
+	})
 }

bridge/watcher/l2_watcher.go

@@ -17,11 +17,11 @@ import (
 	geth_metrics "github.com/scroll-tech/go-ethereum/metrics"
 	"github.com/scroll-tech/go-ethereum/rpc"
 
-	"scroll-tech/database"
-
 	"scroll-tech/common/metrics"
 	"scroll-tech/common/types"
 
+	"scroll-tech/database"
+
 	bridge_abi "scroll-tech/bridge/abi"
 	"scroll-tech/bridge/utils"
 )

bridge/watcher/l2_watcher_test.go

@@ -3,28 +3,46 @@ package watcher
 import (
 	"context"
 	"crypto/ecdsa"
+	"errors"
 	"math/big"
 	"strconv"
 	"testing"
 	"time"
 
+	"github.com/agiledragon/gomonkey/v2"
+	"github.com/scroll-tech/go-ethereum/accounts/abi"
 	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
 	"github.com/scroll-tech/go-ethereum/common"
 	geth_types "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/rpc"
+	"github.com/smartystreets/goconvey/convey"
 	"github.com/stretchr/testify/assert"
 
 	"scroll-tech/common/types"
-	cutils "scroll-tech/common/utils"
 
+	bridge_abi "scroll-tech/bridge/abi"
 	"scroll-tech/bridge/mock_bridge"
 	"scroll-tech/bridge/sender"
+	"scroll-tech/bridge/utils"
+
+	cutils "scroll-tech/common/utils"
 
 	"scroll-tech/database"
 	"scroll-tech/database/migrate"
 )
 
+func setupL2Watcher(t *testing.T) *L2WatcherClient {
+	db, err := database.NewOrmFactory(cfg.DBConfig)
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(db.GetDB().DB))
+	defer db.Close()
+
+	l2cfg := cfg.L2Config
+	watcher := NewL2WatcherClient(context.Background(), l2Cli, l2cfg.Confirmations, l2cfg.L2MessengerAddress, l2cfg.L2MessageQueueAddress, l2cfg.WithdrawTrieRootSlot, db)
+	return watcher
+}
+
 func testCreateNewWatcherAndStop(t *testing.T) {
 	// Create db handler and reset db.
 	l2db, err := database.NewOrmFactory(cfg.DBConfig)
@@ -50,7 +68,7 @@ func testCreateNewWatcherAndStop(t *testing.T) {
 	numTransactions := 3
 	toAddress := common.HexToAddress("0x4592d8f8d7b001e72cb26a73e4fa1806a51ac79d")
 	for i := 0; i < numTransactions; i++ {
-		_, _, err = newSender.SendTransaction(strconv.Itoa(1000+i), &toAddress, big.NewInt(1000000000), nil, 0)
+		_, err = newSender.SendTransaction(strconv.Itoa(1000+i), &toAddress, big.NewInt(1000000000), nil, 0)
 		assert.NoError(t, err)
 		<-newSender.ConfirmChan()
 	}
@@ -113,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) {
@@ -195,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) {
@@ -223,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 {
@@ -253,3 +266,172 @@ func prepareAuth(t *testing.T, l2Cli *ethclient.Client, privateKey *ecdsa.Privat
 func loopToFetchEvent(subCtx context.Context, watcher *L2WatcherClient) {
 	go cutils.Loop(subCtx, 2*time.Second, watcher.FetchContractEvent)
 }
+
+func testParseBridgeEventLogsL2SentMessageEventSignature(t *testing.T) {
+	watcher := setupL2Watcher(t)
+	logs := []geth_types.Log{
+		{
+			Topics: []common.Hash{
+				bridge_abi.L2SentMessageEventSignature,
+			},
+			BlockNumber: 100,
+			TxHash:      common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+		},
+	}
+
+	convey.Convey("unpack SentMessage log failure", t, func() {
+		targetErr := errors.New("UnpackLog SentMessage failure")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log geth_types.Log) error {
+			return targetErr
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, err := watcher.parseBridgeEventLogs(logs)
+		assert.EqualError(t, err, targetErr.Error())
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+	})
+
+	convey.Convey("L2SentMessageEventSignature success", t, func() {
+		tmpSendAddr := common.HexToAddress("0xb4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30")
+		tmpTargetAddr := common.HexToAddress("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5")
+		tmpValue := big.NewInt(1000)
+		tmpMessageNonce := big.NewInt(100)
+		tmpMessage := []byte("test for L2SentMessageEventSignature")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log geth_types.Log) error {
+			tmpOut := out.(*bridge_abi.L2SentMessageEvent)
+			tmpOut.Sender = tmpSendAddr
+			tmpOut.Value = tmpValue
+			tmpOut.Target = tmpTargetAddr
+			tmpOut.MessageNonce = tmpMessageNonce
+			tmpOut.Message = tmpMessage
+			return nil
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, err := watcher.parseBridgeEventLogs(logs)
+		assert.Error(t, err)
+		assert.Empty(t, relayedMessages)
+		assert.Empty(t, l2Messages)
+	})
+}
+
+func testParseBridgeEventLogsL2RelayedMessageEventSignature(t *testing.T) {
+	watcher := setupL2Watcher(t)
+	logs := []geth_types.Log{
+		{
+			Topics:      []common.Hash{bridge_abi.L2RelayedMessageEventSignature},
+			BlockNumber: 100,
+			TxHash:      common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+		},
+	}
+
+	convey.Convey("unpack RelayedMessage log failure", t, func() {
+		targetErr := errors.New("UnpackLog RelayedMessage failure")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log geth_types.Log) error {
+			return targetErr
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, err := watcher.parseBridgeEventLogs(logs)
+		assert.EqualError(t, err, targetErr.Error())
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+	})
+
+	convey.Convey("L2RelayedMessageEventSignature success", t, func() {
+		msgHash := common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log geth_types.Log) error {
+			tmpOut := out.(*bridge_abi.L2RelayedMessageEvent)
+			tmpOut.MessageHash = msgHash
+			return nil
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, err := watcher.parseBridgeEventLogs(logs)
+		assert.NoError(t, err)
+		assert.Empty(t, l2Messages)
+		assert.Len(t, relayedMessages, 1)
+		assert.Equal(t, relayedMessages[0].msgHash, msgHash)
+	})
+}
+
+func testParseBridgeEventLogsL2FailedRelayedMessageEventSignature(t *testing.T) {
+	watcher := setupL2Watcher(t)
+	logs := []geth_types.Log{
+		{
+			Topics:      []common.Hash{bridge_abi.L2FailedRelayedMessageEventSignature},
+			BlockNumber: 100,
+			TxHash:      common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+		},
+	}
+
+	convey.Convey("unpack FailedRelayedMessage log failure", t, func() {
+		targetErr := errors.New("UnpackLog FailedRelayedMessage failure")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log geth_types.Log) error {
+			return targetErr
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, err := watcher.parseBridgeEventLogs(logs)
+		assert.EqualError(t, err, targetErr.Error())
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+	})
+
+	convey.Convey("L2FailedRelayedMessageEventSignature success", t, func() {
+		msgHash := common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log geth_types.Log) error {
+			tmpOut := out.(*bridge_abi.L2FailedRelayedMessageEvent)
+			tmpOut.MessageHash = msgHash
+			return nil
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, err := watcher.parseBridgeEventLogs(logs)
+		assert.NoError(t, err)
+		assert.Empty(t, l2Messages)
+		assert.Len(t, relayedMessages, 1)
+		assert.Equal(t, relayedMessages[0].msgHash, msgHash)
+	})
+}
+
+func testParseBridgeEventLogsL2AppendMessageEventSignature(t *testing.T) {
+	watcher := setupL2Watcher(t)
+	logs := []geth_types.Log{
+		{
+			Topics:      []common.Hash{bridge_abi.L2AppendMessageEventSignature},
+			BlockNumber: 100,
+			TxHash:      common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
+		},
+	}
+
+	convey.Convey("unpack AppendMessage log failure", t, func() {
+		targetErr := errors.New("UnpackLog AppendMessage failure")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log geth_types.Log) error {
+			return targetErr
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, err := watcher.parseBridgeEventLogs(logs)
+		assert.EqualError(t, err, targetErr.Error())
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+	})
+
+	convey.Convey("L2AppendMessageEventSignature success", t, func() {
+		msgHash := common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5")
+		patchGuard := gomonkey.ApplyFunc(utils.UnpackLog, func(c *abi.ABI, out interface{}, event string, log geth_types.Log) error {
+			tmpOut := out.(*bridge_abi.L2AppendMessageEvent)
+			tmpOut.MessageHash = msgHash
+			tmpOut.Index = big.NewInt(100)
+			return nil
+		})
+		defer patchGuard.Reset()
+
+		l2Messages, relayedMessages, err := watcher.parseBridgeEventLogs(logs)
+		assert.NoError(t, err)
+		assert.Empty(t, l2Messages)
+		assert.Empty(t, relayedMessages)
+	})
+}

bridge/watcher/watcher_test.go

@@ -77,13 +77,26 @@ func TestFunction(t *testing.T) {
 	if err := setupEnv(t); err != nil {
 		t.Fatal(err)
 	}
+
 	// Run l1 watcher test cases.
-	t.Run("TestStartWatcher", testStartWatcher)
+	t.Run("TestStartWatcher", testFetchContractEvent)
+	t.Run("TestL1WatcherClientFetchBlockHeader", testL1WatcherClientFetchBlockHeader)
+	t.Run("TestL1WatcherClientFetchContractEvent", testL1WatcherClientFetchContractEvent)
+	t.Run("TestParseBridgeEventLogsL1QueueTransactionEventSignature", testParseBridgeEventLogsL1QueueTransactionEventSignature)
+	t.Run("TestParseBridgeEventLogsL1RelayedMessageEventSignature", testParseBridgeEventLogsL1RelayedMessageEventSignature)
+	t.Run("TestParseBridgeEventLogsL1FailedRelayedMessageEventSignature", testParseBridgeEventLogsL1FailedRelayedMessageEventSignature)
+	t.Run("TestParseBridgeEventLogsL1CommitBatchEventSignature", testParseBridgeEventLogsL1CommitBatchEventSignature)
+	t.Run("TestParseBridgeEventLogsL1FinalizeBatchEventSignature", testParseBridgeEventLogsL1FinalizeBatchEventSignature)
+
 	// Run l2 watcher test cases.
 	t.Run("TestCreateNewWatcherAndStop", testCreateNewWatcherAndStop)
 	t.Run("TestMonitorBridgeContract", testMonitorBridgeContract)
 	t.Run("TestFetchMultipleSentMessageInOneBlock", testFetchMultipleSentMessageInOneBlock)
 	t.Run("TestFetchRunningMissingBlocks", testFetchRunningMissingBlocks)
+	t.Run("TestParseBridgeEventLogsL2SentMessageEventSignature", testParseBridgeEventLogsL2SentMessageEventSignature)
+	t.Run("TestParseBridgeEventLogsL2RelayedMessageEventSignature", testParseBridgeEventLogsL2RelayedMessageEventSignature)
+	t.Run("TestParseBridgeEventLogsL2FailedRelayedMessageEventSignature", testParseBridgeEventLogsL2FailedRelayedMessageEventSignature)
+	t.Run("TestParseBridgeEventLogsL2AppendMessageEventSignature", testParseBridgeEventLogsL2AppendMessageEventSignature)
 
 	// Run batch proposer test cases.
 	t.Run("TestBatchProposerProposeBatch", testBatchProposerProposeBatch)

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

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:prealpha-v5.1
+FROM scrolltech/l2geth:scroll-v3.1.4
 
 RUN mkdir -p /l2geth/keystore
 

common/docker/l2geth/genesis.json

@@ -16,7 +16,13 @@
       "period": 3,
       "epoch": 30000
     },
-    "zktrie": true
+    "scroll": {
+      "useZktrie": true,
+      "maxTxPerBlock": 44,
+      "feeVaultAddress": "0x5300000000000000000000000000000000000005",
+      "enableEIP2718": false,
+      "enableEIP1559": false
+    }
   },
   "nonce": "0x0",
   "timestamp": "0x61bc34a0",
@@ -50,5 +56,5 @@
   "number": "0x0",
   "gasUsed": "0x0",
   "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "baseFeePerGas": "0x2710"
+  "baseFeePerGas": null
 }

common/go.mod

@@ -60,7 +60,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
@@ -89,7 +90,7 @@ require (
 	golang.org/x/sync v0.1.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/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

@@ -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=
@@ -289,21 +290,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=
@@ -524,6 +527,7 @@ 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=
@@ -547,8 +551,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 +581,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=

common/libzkp/impl/Cargo.toml

@@ -5,7 +5,7 @@ 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"  }

common/types/db.go

@@ -5,6 +5,8 @@ import (
 	"database/sql"
 	"fmt"
 	"time"
+
+	"scroll-tech/common/types/message"
 )
 
 // L1BlockStatus represents current l1 block processing status
@@ -163,6 +165,7 @@ type SessionInfo struct {
 	Rollers        map[string]*RollerStatus `json:"rollers"`
 	StartTimestamp int64                    `json:"start_timestamp"`
 	Attempts       uint8                    `json:"attempts,omitempty"`
+	ProveType      message.ProveType        `json:"prove_type,omitempty"`
 }
 
 // ProvingStatus block_batch proving_status (unassigned, assigned, proved, verified, submitted)
@@ -256,3 +259,16 @@ type BlockBatch struct {
 	CommittedAt         *time.Time      `json:"committed_at" db:"committed_at"`
 	FinalizedAt         *time.Time      `json:"finalized_at" db:"finalized_at"`
 }
+
+// AggTask is a wrapper type around db AggProveTask type.
+type AggTask struct {
+	ID              string        `json:"id" db:"id"`
+	StartBatchIndex uint64        `json:"start_batch_index" db:"start_batch_index"`
+	StartBatchHash  string        `json:"start_batch_hash" db:"start_batch_hash"`
+	EndBatchIndex   uint64        `json:"end_batch_index" db:"end_batch_index"`
+	EndBatchHash    string        `json:"end_batch_hash" db:"end_batch_hash"`
+	ProvingStatus   ProvingStatus `json:"proving_status" db:"proving_status"`
+	Proof           []byte        `json:"proof" db:"proof"`
+	CreatedTime     *time.Time    `json:"created_time" db:"created_time"`
+	UpdatedTime     *time.Time    `json:"updated_time" db:"updated_time"`
+}

common/types/message/message.go

@@ -22,6 +22,27 @@ const (
 	StatusProofError
 )
 
+// ProveType represents the type of roller.
+type ProveType uint8
+
+func (r ProveType) String() string {
+	switch r {
+	case BasicProve:
+		return "Basic Prove"
+	case AggregatorProve:
+		return "Aggregator Prove"
+	default:
+		return "Illegal Prove type"
+	}
+}
+
+const (
+	// BasicProve is default roller, it only generates zk proof from traces.
+	BasicProve ProveType = iota
+	// AggregatorProve generates zk proof from other zk proofs and aggregate them into one proof.
+	AggregatorProve
+)
+
 // AuthMsg is the first message exchanged from the Roller to the Sequencer.
 // It effectively acts as a registration, and makes the Roller identification
 // known to the Sequencer.
@@ -36,6 +57,8 @@ type AuthMsg struct {
 type Identity struct {
 	// Roller name
 	Name string `json:"name"`
+	// Roller RollerType
+	RollerType ProveType `json:"roller_type,omitempty"`
 	// Unverified Unix timestamp of message creation
 	Timestamp uint32 `json:"timestamp"`
 	// Version is common.Version+ZkVersion. Use the following to check the latest ZkVersion version.
@@ -178,14 +201,19 @@ func (a *ProofMsg) PublicKey() (string, error) {
 
 // TaskMsg is a wrapper type around db ProveTask type.
 type TaskMsg struct {
-	ID     string              `json:"id"`
-	Traces []*types.BlockTrace `json:"blockTraces"`
+	ID   string    `json:"id"`
+	Type ProveType `json:"type,omitempty"`
+	// Only basic rollers need traces, aggregator rollers don't!
+	Traces []*types.BlockTrace `json:"blockTraces,omitempty"`
+	// Only aggregator rollers need proofs to aggregate, basic rollers don't!
+	SubProofs [][]byte `json:"sub_proofs,omitempty"`
 }
 
 // ProofDetail is the message received from rollers that contains zk proof, the status of
 // the proof generation succeeded, and an error message if proof generation failed.
 type ProofDetail struct {
 	ID     string     `json:"id"`
+	Type   ProveType  `json:"type,omitempty"`
 	Status RespStatus `json:"status"`
 	Proof  *AggProof  `json:"proof"`
 	Error  string     `json:"error,omitempty"`

common/types/transaction.go

@@ -1,35 +0,0 @@
-package types
-
-import "database/sql"
-
-// ScrollTxType scroll tx type (l1_message_tx, l1_gasOracle_tx, l2_message_tx, l2_gasOracle_tx, l2_rollupCommit_tx, l2_rollupFinalize_tx)
-type ScrollTxType int
-
-const (
-	// UndefinedScrollTx undefined scroll tx type
-	UndefinedScrollTx ScrollTxType = iota
-	// L1toL2MessageTx is sent by l1 relayer but to L2
-	L1toL2MessageTx
-	// L1toL2GasOracleTx  is sent by l1 relayer but to L2
-	L1toL2GasOracleTx
-	// L2toL1MessageTx  is sent by l2 relayer but to L1
-	L2toL1MessageTx
-	// L2toL1GasOracleTx  is sent by l2 relayer but to L1
-	L2toL1GasOracleTx
-	// RollUpCommitTx  is sent to L1
-	RollUpCommitTx
-	// RollupFinalizeTx  is sent to L1
-	RollupFinalizeTx
-)
-
-// ScrollTx Contains tx message, hash is the index.
-type ScrollTx struct {
-	ID     string         `json:"id" db:"id"`
-	TxHash sql.NullString `json:"tx_hash" db:"tx_hash"`
-	Sender sql.NullString `json:"sender" db:"sender"`
-	Nonce  sql.NullInt64  `json:"nonce" db:"nonce"`
-	Target sql.NullString `json:"target" db:"target"`
-	Value  sql.NullString `json:"value" db:"value"`
-	Data   []byte         `json:"data" db:"data"`
-	Note   sql.NullString `json:"note" db:"note"`
-}

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.12"
+var tag = "v3.0.15"
 
 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/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);
+  });
+
+  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/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");
+            }
+        }
     }
 
     /************************
@@ -216,12 +259,7 @@ contract L1ScrollMessenger is PausableUpgradeable, ScrollMessengerBase, IL1Scrol
         bytes memory _xDomainCalldata = _encodeXDomainCalldata(msg.sender, _to, _value, _messageNonce, _message);
 
         // compute and deduct the messaging fee to fee vault.
-        uint256 _fee = IL1MessageQueue(_messageQueue).estimateCrossDomainMessageFee(
-            address(this),
-            _counterpart,
-            _xDomainCalldata,
-            _gasLimit
-        );
+        uint256 _fee = IL1MessageQueue(_messageQueue).estimateCrossDomainMessageFee(_gasLimit);
         require(msg.value >= _fee + _value, "Insufficient msg.value");
         if (_fee > 0) {
             (bool _success, ) = feeVault.call{value: _fee}("");
@@ -240,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/rollup/IL1MessageQueue.sol

@@ -36,16 +36,24 @@ interface IL1MessageQueue {
     function getCrossDomainMessage(uint256 queueIndex) external view returns (bytes32);
 
     /// @notice Return the amount of ETH should pay for cross domain message.
-    /// @param sender The address of account who initiates the message in L1.
-    /// @param target The address of account who will recieve the message in L2.
-    /// @param message The content of the message.
     /// @param gasLimit Gas limit required to complete the message relay on L2.
-    function estimateCrossDomainMessageFee(
+    function estimateCrossDomainMessageFee(uint256 gasLimit) 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,
-        bytes memory message,
-        uint256 gasLimit
-    ) external view returns (uint256);
+        uint256 gasLimit,
+        bytes calldata data
+    ) external view returns (bytes32);
 
     /*****************************
      * Public Mutating Functions *

contracts/src/L1/rollup/IL2GasPriceOracle.sol

@@ -4,13 +4,6 @@ pragma solidity ^0.8.0;
 
 interface IL2GasPriceOracle {
     /// @notice Estimate fee for cross chain message call.
-    /// @param _sender The address of sender who invoke the call.
-    /// @param _to The target address to receive the call.
-    /// @param _message The message will be passed to the target address.
-    function estimateCrossDomainMessageFee(
-        address _sender,
-        address _to,
-        bytes memory _message,
-        uint256 _gasLimit
-    ) external view returns (uint256);
+    /// @param _gasLimit Gas limit required to complete the message relay on L2.
+    function estimateCrossDomainMessageFee(uint256 _gasLimit) 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 *
@@ -61,15 +61,135 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
     }
 
     /// @inheritdoc IL1MessageQueue
-    function estimateCrossDomainMessageFee(
-        address _sender,
-        address _target,
-        bytes memory _message,
-        uint256 _gasLimit
-    ) external view override returns (uint256) {
+    function estimateCrossDomainMessageFee(uint256 _gasLimit) external view override returns (uint256) {
         address _oracle = gasOracle;
         if (_oracle == address(0)) return 0;
-        return IL2GasPriceOracle(_oracle).estimateCrossDomainMessageFee(_sender, _target, _message, _gasLimit);
+        return IL2GasPriceOracle(_oracle).estimateCrossDomainMessageFee(_gasLimit);
+    }
+
+    /// @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;
     }
 
     /*****************************
@@ -87,13 +207,12 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
         // 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

contracts/src/L1/rollup/L2GasPriceOracle.sol

@@ -18,43 +18,14 @@ contract L2GasPriceOracle is OwnableUpgradeable, IL2GasPriceOracle {
     /// @param _newWhitelist The address of new whitelist contract.
     event UpdateWhitelist(address _oldWhitelist, address _newWhitelist);
 
-    /// @notice Emitted when current fee overhead is updated.
-    /// @param overhead The current fee overhead updated.
-    event OverheadUpdated(uint256 overhead);
-
-    /// @notice Emitted when current fee scalar is updated.
-    /// @param scalar The current fee scalar updated.
-    event ScalarUpdated(uint256 scalar);
-
     /// @notice Emitted when current l2 base fee is updated.
     /// @param l2BaseFee The current l2 base fee updated.
     event L2BaseFeeUpdated(uint256 l2BaseFee);
 
-    /*************
-     * Constants *
-     *************/
-
-    /// @dev The precision used in the scalar.
-    uint256 private constant PRECISION = 1e9;
-
-    /// @dev The maximum possible l1 fee overhead.
-    ///      Computed based on current l1 block gas limit.
-    uint256 private constant MAX_OVERHEAD = 30000000 / 16;
-
-    /// @dev The maximum possible l1 fee scale.
-    ///      x1000 should be enough.
-    uint256 private constant MAX_SCALE = 1000 * PRECISION;
-
     /*************
      * Variables *
      *************/
 
-    /// @notice The current l1 fee overhead.
-    uint256 public overhead;
-
-    /// @notice The current l1 fee scalar.
-    uint256 public scalar;
-
     /// @notice The latest known l2 base fee.
     uint256 public l2BaseFee;
 
@@ -73,46 +44,9 @@ contract L2GasPriceOracle is OwnableUpgradeable, IL2GasPriceOracle {
      * Public View Functions *
      *************************/
 
-    /// @notice Return the current l1 base fee.
-    function l1BaseFee() public view returns (uint256) {
-        return block.basefee;
-    }
-
     /// @inheritdoc IL2GasPriceOracle
-    function estimateCrossDomainMessageFee(
-        address,
-        address,
-        bytes memory _message,
-        uint256 _gasLimit
-    ) external view override returns (uint256) {
-        unchecked {
-            uint256 _l1GasUsed = getL1GasUsed(_message);
-            uint256 _rollupFee = (_l1GasUsed * l1BaseFee() * scalar) / PRECISION;
-            uint256 _l2Fee = _gasLimit * l2BaseFee;
-            return _l2Fee + _rollupFee;
-        }
-    }
-
-    /// @notice Computes the amount of L1 gas used for a transaction. Adds the overhead which
-    ///         represents the per-transaction gas overhead of posting the transaction and state
-    ///         roots to L1. Adds 68 bytes of padding to account for the fact that the input does
-    ///         not have a signature.
-    /// @param _data Unsigned fully RLP-encoded transaction to get the L1 gas for.
-    /// @return Amount of L1 gas used to publish the transaction.
-    function getL1GasUsed(bytes memory _data) public view returns (uint256) {
-        uint256 _total = 0;
-        uint256 _length = _data.length;
-        unchecked {
-            for (uint256 i = 0; i < _length; i++) {
-                if (_data[i] == 0) {
-                    _total += 4;
-                } else {
-                    _total += 16;
-                }
-            }
-            uint256 _unsigned = _total + overhead;
-            return _unsigned + (68 * 16);
-        }
+    function estimateCrossDomainMessageFee(uint256 _gasLimit) external view override returns (uint256) {
+        return _gasLimit * l2BaseFee;
     }
 
     /*****************************
@@ -133,24 +67,6 @@ contract L2GasPriceOracle is OwnableUpgradeable, IL2GasPriceOracle {
      * Restricted Functions *
      ************************/
 
-    /// @notice Allows the owner to modify the overhead.
-    /// @param _overhead New overhead
-    function setOverhead(uint256 _overhead) external onlyOwner {
-        require(_overhead <= MAX_OVERHEAD, "exceed maximum overhead");
-
-        overhead = _overhead;
-        emit OverheadUpdated(_overhead);
-    }
-
-    /// Allows the owner to modify the scalar.
-    /// @param _scalar The new scalar
-    function setScalar(uint256 _scalar) external onlyOwner {
-        require(_scalar <= MAX_SCALE, "exceed maximum scale");
-
-        scalar = _scalar;
-        emit ScalarUpdated(_scalar);
-    }
-
     /// @notice Update whitelist contract.
     /// @dev This function can only called by contract owner.
     /// @param _newWhitelist The address of new whitelist contract.

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));
 

contracts/src/test/L1CustomERC20Gateway.t.sol

@@ -290,7 +290,14 @@ contract L1CustomERC20GatewayTest is L1GatewayTestBase {
         // emit FinalizeWithdrawERC20 from L1StandardERC20Gateway
         {
             hevm.expectEmit(true, true, true, true);
-            emit FinalizeWithdrawERC20(address(l1Token), address(l2Token), sender, address(recipient), amount, dataToCall);
+            emit FinalizeWithdrawERC20(
+                address(l1Token),
+                address(l2Token),
+                sender,
+                address(recipient),
+                amount,
+                dataToCall
+            );
         }
 
         // emit RelayedMessage from L1ScrollMessenger

contracts/src/test/L1ScrollMessengerTest.t.sol

@@ -5,6 +5,7 @@ pragma solidity ^0.8.0;
 import {DSTestPlus} from "solmate/test/utils/DSTestPlus.sol";
 
 import {L1MessageQueue} from "../L1/rollup/L1MessageQueue.sol";
+import {L2GasPriceOracle} from "../L1/rollup/L2GasPriceOracle.sol";
 import {IScrollChain, ScrollChain} from "../L1/rollup/ScrollChain.sol";
 import {Whitelist} from "../L2/predeploys/Whitelist.sol";
 import {IL1ScrollMessenger, L1ScrollMessenger} from "../L1/L1ScrollMessenger.sol";
@@ -18,6 +19,8 @@ contract L1ScrollMessengerTest is DSTestPlus {
     L1ScrollMessenger internal l1Messenger;
     ScrollChain internal scrollChain;
     L1MessageQueue internal l1MessageQueue;
+    L2GasPriceOracle internal gasOracle;
+    Whitelist internal whitelist;
 
     function setUp() public {
         // Deploy L2 contracts
@@ -27,16 +30,25 @@ contract L1ScrollMessengerTest is DSTestPlus {
         scrollChain = new ScrollChain(0, 0, bytes32(0));
         l1MessageQueue = new L1MessageQueue();
         l1Messenger = new L1ScrollMessenger();
+        gasOracle = new L2GasPriceOracle();
+        whitelist = new Whitelist(address(this));
 
         // Initialize L1 contracts
         l1Messenger.initialize(address(l2Messenger), feeVault, address(scrollChain), address(l1MessageQueue));
-        l1MessageQueue.initialize(address(l1Messenger), address(0));
+        l1MessageQueue.initialize(address(l1Messenger), address(gasOracle));
+        gasOracle.initialize();
         scrollChain.initialize(address(l1MessageQueue));
+
+        gasOracle.updateWhitelist(address(whitelist));
+        address[] memory _accounts = new address[](1);
+        _accounts[0] = address(this);
+        whitelist.updateWhitelistStatus(_accounts, true);
     }
 
-    function testForbidCallFromL2() external {
+    function testForbidCallMessageQueueFromL2() external {
         IScrollChain.Batch memory genesisBatch;
         genesisBatch.newStateRoot = bytes32(uint256(1));
+        genesisBatch.withdrawTrieRoot = 0x35626eedbe5d8fb495fd20259ecb6c9a5574babab0b9ada1e93652baf717b085;
         genesisBatch.blocks = new IScrollChain.BlockContext[](1);
         genesisBatch.blocks[0].blockHash = bytes32(uint256(1));
         scrollChain.importGenesisBatch(genesisBatch);
@@ -46,6 +58,18 @@ contract L1ScrollMessengerTest is DSTestPlus {
 
         hevm.expectRevert("Forbid to call message queue");
         l1Messenger.relayMessageWithProof(address(this), address(l1MessageQueue), 0, 0, new bytes(0), proof);
+    }
+
+    function testForbidCallSelfFromL2() external {
+        IScrollChain.Batch memory genesisBatch;
+        genesisBatch.newStateRoot = bytes32(uint256(1));
+        genesisBatch.withdrawTrieRoot = 0x6e17d04543a7177b7ab3c42130fef5a10e6f47e9dfbd4ed577706ffb9d9273cc;
+        genesisBatch.blocks = new IScrollChain.BlockContext[](1);
+        genesisBatch.blocks[0].blockHash = bytes32(uint256(1));
+        scrollChain.importGenesisBatch(genesisBatch);
+
+        IL1ScrollMessenger.L2MessageProof memory proof;
+        proof.batchHash = scrollChain.lastFinalizedBatchHash();
 
         hevm.expectRevert("Forbid to call self");
         l1Messenger.relayMessageWithProof(address(this), address(l1Messenger), 0, 0, new bytes(0), proof);
@@ -54,7 +78,6 @@ contract L1ScrollMessengerTest is DSTestPlus {
     function testSendMessage(uint256 exceedValue, address refundAddress) external {
         hevm.assume(refundAddress.code.length == 0);
         hevm.assume(uint256(uint160(refundAddress)) > 100); // ignore some precompile contracts
-        hevm.assume(refundAddress != address(this));
 
         exceedValue = bound(exceedValue, 1, address(this).balance / 2);
 
@@ -67,4 +90,41 @@ contract L1ScrollMessengerTest is DSTestPlus {
         l1Messenger.sendMessage{value: 1 + exceedValue}(address(0), 1, new bytes(0), 0, refundAddress);
         assertEq(balanceBefore + exceedValue, refundAddress.balance);
     }
+
+    function testReplayMessage(uint256 exceedValue, address refundAddress) external {
+        hevm.assume(refundAddress.code.length == 0);
+        hevm.assume(uint256(uint160(refundAddress)) > 100); // ignore some precompile contracts
+
+        exceedValue = bound(exceedValue, 1, address(this).balance / 2);
+
+        // append a message
+        l1Messenger.sendMessage{value: 100}(address(0), 100, new bytes(0), 0, refundAddress);
+
+        // Provided message has not been enqueued
+        hevm.expectRevert("Provided message has not been enqueued");
+        l1Messenger.replayMessage(address(this), address(0), 101, 0, new bytes(0), 0, 1, refundAddress);
+
+        gasOracle.setL2BaseFee(1);
+        // Insufficient msg.value
+        hevm.expectRevert("Insufficient msg.value for fee");
+        l1Messenger.replayMessage(address(this), address(0), 100, 0, new bytes(0), 0, 1, refundAddress);
+
+        uint256 _fee = gasOracle.l2BaseFee() * 100;
+
+        // refund exceed fee
+        uint256 balanceBefore = refundAddress.balance;
+        uint256 feeVaultBefore = feeVault.balance;
+        l1Messenger.replayMessage{value: _fee + exceedValue}(
+            address(this),
+            address(0),
+            100,
+            0,
+            new bytes(0),
+            0,
+            100,
+            refundAddress
+        );
+        assertEq(balanceBefore + exceedValue, refundAddress.balance);
+        assertEq(feeVaultBefore + _fee, feeVault.balance);
+    }
 }

contracts/src/test/L1StandardERC20Gateway.t.sol

@@ -364,7 +364,14 @@ contract L1StandardERC20GatewayTest is L1GatewayTestBase {
         // emit FinalizeWithdrawERC20 from L1StandardERC20Gateway
         {
             hevm.expectEmit(true, true, true, true);
-            emit FinalizeWithdrawERC20(address(l1Token), address(l2Token), sender, address(recipient), amount, dataToCall);
+            emit FinalizeWithdrawERC20(
+                address(l1Token),
+                address(l2Token),
+                sender,
+                address(recipient),
+                amount,
+                dataToCall
+            );
         }
 
         // emit RelayedMessage from L1ScrollMessenger

contracts/src/test/L1WETHGateway.t.sol

@@ -316,7 +316,14 @@ contract L1WETHGatewayTest is L1GatewayTestBase {
         // emit FinalizeWithdrawERC20 from L1WETHGateway
         {
             hevm.expectEmit(true, true, true, true);
-            emit FinalizeWithdrawERC20(address(l1weth), address(l2weth), sender, address(recipient), amount, dataToCall);
+            emit FinalizeWithdrawERC20(
+                address(l1weth),
+                address(l2weth),
+                sender,
+                address(recipient),
+                amount,
+                dataToCall
+            );
         }
 
         // emit RelayedMessage from L1ScrollMessenger

contracts/src/test/L2CustomERC20Gateway.t.sol

@@ -8,6 +8,8 @@ import {IL1ERC20Gateway, L1CustomERC20Gateway} from "../L1/gateways/L1CustomERC2
 import {IL2ERC20Gateway, L2CustomERC20Gateway} from "../L2/gateways/L2CustomERC20Gateway.sol";
 import {L2GatewayRouter} from "../L2/gateways/L2GatewayRouter.sol";
 
+import {AddressAliasHelper} from "../libraries/common/AddressAliasHelper.sol";
+
 import {L2GatewayTestBase} from "./L2GatewayTestBase.t.sol";
 import {MockScrollMessenger} from "./mocks/MockScrollMessenger.sol";
 import {MockGatewayRecipient} from "./mocks/MockGatewayRecipient.sol";
@@ -224,7 +226,9 @@ contract L2CustomERC20GatewayTest is L2GatewayTestBase {
         uint256 gatewayBalance = l2Token.balanceOf(address(gateway));
         uint256 recipientBalance = l2Token.balanceOf(recipient);
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
+        hevm.startPrank(AddressAliasHelper.applyL1ToL2Alias(address(l1Messenger)));
         l2Messenger.relayMessage(address(uint160(address(counterpartGateway)) + 1), address(gateway), 0, 0, message);
+        hevm.stopPrank();
         assertEq(gatewayBalance, l2Token.balanceOf(address(gateway)));
         assertEq(recipientBalance, l2Token.balanceOf(recipient));
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
@@ -263,7 +267,14 @@ contract L2CustomERC20GatewayTest is L2GatewayTestBase {
         // emit FinalizeDepositERC20 from L2CustomERC20Gateway
         {
             hevm.expectEmit(true, true, true, true);
-            emit FinalizeDepositERC20(address(l1Token), address(l2Token), sender, address(recipient), amount, dataToCall);
+            emit FinalizeDepositERC20(
+                address(l1Token),
+                address(l2Token),
+                sender,
+                address(recipient),
+                amount,
+                dataToCall
+            );
         }
 
         // emit RelayedMessage from L2ScrollMessenger
@@ -275,7 +286,9 @@ contract L2CustomERC20GatewayTest is L2GatewayTestBase {
         uint256 gatewayBalance = l2Token.balanceOf(address(gateway));
         uint256 recipientBalance = l2Token.balanceOf(address(recipient));
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
+        hevm.startPrank(AddressAliasHelper.applyL1ToL2Alias(address(l1Messenger)));
         l2Messenger.relayMessage(address(counterpartGateway), address(gateway), 0, 0, message);
+        hevm.stopPrank();
         assertEq(gatewayBalance, l2Token.balanceOf(address(gateway)));
         assertEq(recipientBalance + amount, l2Token.balanceOf(address(recipient)));
         assertBoolEq(true, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));

contracts/src/test/L2ETHGateway.t.sol

@@ -6,6 +6,8 @@ import {L2GatewayRouter} from "../L2/gateways/L2GatewayRouter.sol";
 import {IL1ETHGateway, L1ETHGateway} from "../L1/gateways/L1ETHGateway.sol";
 import {IL2ETHGateway, L2ETHGateway} from "../L2/gateways/L2ETHGateway.sol";
 
+import {AddressAliasHelper} from "../libraries/common/AddressAliasHelper.sol";
+
 import {L2GatewayTestBase} from "./L2GatewayTestBase.t.sol";
 import {MockScrollMessenger} from "./mocks/MockScrollMessenger.sol";
 import {MockGatewayRecipient} from "./mocks/MockGatewayRecipient.sol";
@@ -167,6 +169,7 @@ contract L2ETHGatewayTest is L2GatewayTestBase {
         uint256 messengerBalance = address(l2Messenger).balance;
         uint256 recipientBalance = recipient.balance;
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
+        hevm.startPrank(AddressAliasHelper.applyL1ToL2Alias(address(l1Messenger)));
         l2Messenger.relayMessage(
             address(uint160(address(counterpartGateway)) + 1),
             address(gateway),
@@ -174,6 +177,7 @@ contract L2ETHGatewayTest is L2GatewayTestBase {
             0,
             message
         );
+        hevm.stopPrank();
         assertEq(messengerBalance, address(l2Messenger).balance);
         assertEq(recipientBalance, recipient.balance);
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
@@ -224,7 +228,9 @@ contract L2ETHGatewayTest is L2GatewayTestBase {
         uint256 messengerBalance = address(l2Messenger).balance;
         uint256 recipientBalance = address(recipient).balance;
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
+        hevm.startPrank(AddressAliasHelper.applyL1ToL2Alias(address(l1Messenger)));
         l2Messenger.relayMessage(address(counterpartGateway), address(gateway), amount, 0, message);
+        hevm.stopPrank();
         assertEq(messengerBalance - amount, address(l2Messenger).balance);
         assertEq(recipientBalance + amount, address(recipient).balance);
         assertBoolEq(true, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));

contracts/src/test/L2ScrollMessenger.t.sol

@@ -11,6 +11,8 @@ import {Whitelist} from "../L2/predeploys/Whitelist.sol";
 import {L1ScrollMessenger} from "../L1/L1ScrollMessenger.sol";
 import {L2ScrollMessenger} from "../L2/L2ScrollMessenger.sol";
 
+import {AddressAliasHelper} from "../libraries/common/AddressAliasHelper.sol";
+
 contract L2ScrollMessengerTest is DSTestPlus {
     L1ScrollMessenger internal l1Messenger;
 
@@ -40,12 +42,19 @@ contract L2ScrollMessengerTest is DSTestPlus {
         l1GasOracle.updateWhitelist(address(whitelist));
     }
 
+    function testRelayByCounterparty() external {
+        hevm.expectRevert("Caller is not L1ScrollMessenger");
+        l2Messenger.relayMessage(address(this), address(this), 0, 0, new bytes(0));
+    }
+
     function testForbidCallFromL1() external {
+        hevm.startPrank(AddressAliasHelper.applyL1ToL2Alias(address(l1Messenger)));
         hevm.expectRevert("Forbid to call message queue");
         l2Messenger.relayMessage(address(this), address(l2MessageQueue), 0, 0, new bytes(0));
 
         hevm.expectRevert("Forbid to call self");
         l2Messenger.relayMessage(address(this), address(l2Messenger), 0, 0, new bytes(0));
+        hevm.stopPrank();
     }
 
     function testSendMessage(uint256 exceedValue, address refundAddress) external {

contracts/src/test/L2StandardERC20Gateway.t.sol

@@ -10,6 +10,8 @@ import {IL2ERC20Gateway, L2StandardERC20Gateway} from "../L2/gateways/L2Standard
 import {ScrollStandardERC20} from "../libraries/token/ScrollStandardERC20.sol";
 import {ScrollStandardERC20Factory} from "../libraries/token/ScrollStandardERC20Factory.sol";
 
+import {AddressAliasHelper} from "../libraries/common/AddressAliasHelper.sol";
+
 import {L2GatewayTestBase} from "./L2GatewayTestBase.t.sol";
 import {MockScrollMessenger} from "./mocks/MockScrollMessenger.sol";
 import {MockGatewayRecipient} from "./mocks/MockGatewayRecipient.sol";
@@ -68,6 +70,7 @@ contract L2StandardERC20GatewayTest is L2GatewayTestBase {
 
         // Prepare token balances
         l2Token = MockERC20(gateway.getL2ERC20Address(address(l1Token)));
+        hevm.startPrank(AddressAliasHelper.applyL1ToL2Alias(address(l1Messenger)));
         l2Messenger.relayMessage(
             address(counterpartGateway),
             address(gateway),
@@ -83,6 +86,7 @@ contract L2StandardERC20GatewayTest is L2GatewayTestBase {
                 abi.encode("", abi.encode("symbol", "name", 18))
             )
         );
+        hevm.stopPrank();
     }
 
     function testInitialized() public {
@@ -256,7 +260,9 @@ contract L2StandardERC20GatewayTest is L2GatewayTestBase {
         uint256 gatewayBalance = l2Token.balanceOf(address(gateway));
         uint256 recipientBalance = l2Token.balanceOf(recipient);
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
+        hevm.startPrank(AddressAliasHelper.applyL1ToL2Alias(address(l1Messenger)));
         l2Messenger.relayMessage(address(uint160(address(counterpartGateway)) + 1), address(gateway), 0, 0, message);
+        hevm.stopPrank();
         assertEq(gatewayBalance, l2Token.balanceOf(address(gateway)));
         assertEq(recipientBalance, l2Token.balanceOf(recipient));
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
@@ -293,7 +299,14 @@ contract L2StandardERC20GatewayTest is L2GatewayTestBase {
         // emit FinalizeDepositERC20 from L2StandardERC20Gateway
         {
             hevm.expectEmit(true, true, true, true);
-            emit FinalizeDepositERC20(address(l1Token), address(l2Token), sender, address(recipient), amount, dataToCall);
+            emit FinalizeDepositERC20(
+                address(l1Token),
+                address(l2Token),
+                sender,
+                address(recipient),
+                amount,
+                dataToCall
+            );
         }
 
         // emit RelayedMessage from L2ScrollMessenger
@@ -305,7 +318,9 @@ contract L2StandardERC20GatewayTest is L2GatewayTestBase {
         uint256 gatewayBalance = l2Token.balanceOf(address(gateway));
         uint256 recipientBalance = l2Token.balanceOf(address(recipient));
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
+        hevm.startPrank(AddressAliasHelper.applyL1ToL2Alias(address(l1Messenger)));
         l2Messenger.relayMessage(address(counterpartGateway), address(gateway), 0, 0, message);
+        hevm.stopPrank();
         assertEq(gatewayBalance, l2Token.balanceOf(address(gateway)));
         assertEq(recipientBalance + amount, l2Token.balanceOf(address(recipient)));
         assertBoolEq(true, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));

contracts/src/test/L2WETHGateway.t.sol

@@ -8,6 +8,8 @@ import {IL1ERC20Gateway, L1WETHGateway} from "../L1/gateways/L1WETHGateway.sol";
 import {L2GatewayRouter} from "../L2/gateways/L2GatewayRouter.sol";
 import {IL2ERC20Gateway, L2WETHGateway} from "../L2/gateways/L2WETHGateway.sol";
 
+import {AddressAliasHelper} from "../libraries/common/AddressAliasHelper.sol";
+
 import {L2GatewayTestBase} from "./L2GatewayTestBase.t.sol";
 import {MockScrollMessenger} from "./mocks/MockScrollMessenger.sol";
 import {MockGatewayRecipient} from "./mocks/MockGatewayRecipient.sol";
@@ -258,6 +260,7 @@ contract L2WETHGatewayTest is L2GatewayTestBase {
         uint256 messengerBalance = address(l2Messenger).balance;
         uint256 recipientBalance = l2weth.balanceOf(recipient);
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
+        hevm.startPrank(AddressAliasHelper.applyL1ToL2Alias(address(l1Messenger)));
         l2Messenger.relayMessage(
             address(uint160(address(counterpartGateway)) + 1),
             address(gateway),
@@ -265,6 +268,7 @@ contract L2WETHGatewayTest is L2GatewayTestBase {
             0,
             message
         );
+        hevm.stopPrank();
         assertEq(messengerBalance, address(l2Messenger).balance);
         assertEq(recipientBalance, l2weth.balanceOf(recipient));
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
@@ -317,7 +321,9 @@ contract L2WETHGatewayTest is L2GatewayTestBase {
         uint256 messengerBalance = address(l2Messenger).balance;
         uint256 recipientBalance = l2weth.balanceOf(address(recipient));
         assertBoolEq(false, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));
+        hevm.startPrank(AddressAliasHelper.applyL1ToL2Alias(address(l1Messenger)));
         l2Messenger.relayMessage(address(counterpartGateway), address(gateway), amount, 0, message);
+        hevm.stopPrank();
         assertEq(messengerBalance - amount, address(l2Messenger).balance);
         assertEq(recipientBalance + amount, l2weth.balanceOf(address(recipient)));
         assertBoolEq(true, l2Messenger.isL1MessageExecuted(keccak256(xDomainCalldata)));

coordinator/Makefile

@@ -14,7 +14,7 @@ test:
 	go test -v -race -coverprofile=coverage.txt -covermode=atomic -p 1 $(PWD)/...
 
 libzkp:
-	cd ../common/libzkp/impl && cargo build --release && cp ./target/release/libzkp.a ../interface/
+	cd ../common/libzkp/impl && cargo build --release && cp ./target/release/libzkp.so ../interface/
 	rm -rf ./verifier/lib && cp -r ../common/libzkp/interface ./verifier/lib
 	find ../common | grep libzktrie.so | xargs -I{} cp {} ./verifier/lib/
 

coordinator/go.mod

@@ -18,7 +18,7 @@ require (
 	github.com/rivo/uniseg v0.4.4 // indirect
 	github.com/rogpeppe/go-internal v1.10.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
 )
 
 require (

coordinator/go.sum

@@ -138,8 +138,8 @@ golang.org/x/sys v0.7.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=

coordinator/manager.go

@@ -18,13 +18,13 @@ import (
 	geth_metrics "github.com/scroll-tech/go-ethereum/metrics"
 	"github.com/scroll-tech/go-ethereum/rpc"
 
-	"scroll-tech/database"
-
 	"scroll-tech/common/metrics"
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/message"
 	"scroll-tech/common/utils/workerpool"
 
+	"scroll-tech/database"
+
 	"scroll-tech/coordinator/config"
 	"scroll-tech/coordinator/verifier"
 )
@@ -51,6 +51,7 @@ const (
 
 type rollerProofStatus struct {
 	id     string
+	typ    message.ProveType
 	pk     string
 	status types.RollerProveStatus
 }
@@ -161,14 +162,30 @@ func (m *Manager) isRunning() bool {
 // Loop keeps the manager running.
 func (m *Manager) Loop() {
 	var (
-		tick  = time.NewTicker(time.Second * 2)
-		tasks []*types.BlockBatch
+		tick     = time.NewTicker(time.Second * 2)
+		tasks    []*types.BlockBatch
+		aggTasks []*types.AggTask
 	)
 	defer tick.Stop()
 
 	for {
 		select {
 		case <-tick.C:
+			// load and send aggregator tasks
+			if len(aggTasks) == 0 && m.orm != nil {
+				var err error
+				aggTasks, err = m.orm.GetUnassignedAggTasks()
+				if err != nil {
+					log.Error("failed to get unassigned aggregator proving tasks", "error", err)
+					continue
+				}
+			}
+			// Select aggregator type roller and send message
+			for len(aggTasks) > 0 && m.StartAggProofGenerationSession(aggTasks[0], nil) {
+				aggTasks = aggTasks[1:]
+			}
+
+			// load and send basic tasks
 			if len(tasks) == 0 && m.orm != nil {
 				var err error
 				// TODO: add cache
@@ -177,15 +194,15 @@ func (m *Manager) Loop() {
 					fmt.Sprintf(
 						"ORDER BY index %s LIMIT %d;",
 						m.cfg.OrderSession,
-						m.GetNumberOfIdleRollers(),
+						m.GetNumberOfIdleRollers(message.BasicProve),
 					),
 				); err != nil {
-					log.Error("failed to get unassigned proving tasks", "error", err)
+					log.Error("failed to get unassigned basic proving tasks", "error", err)
 					continue
 				}
 			}
-			// Select roller and send message
-			for len(tasks) > 0 && m.StartProofGenerationSession(tasks[0], nil) {
+			// Select basic type roller and send message
+			for len(tasks) > 0 && m.StartBasicProofGenerationSession(tasks[0], nil) {
 				tasks = tasks[1:]
 			}
 		case <-m.ctx.Done():
@@ -208,31 +225,51 @@ func (m *Manager) restorePrevSessions() {
 
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	if hashes, err := m.orm.GetAssignedBatchHashes(); err != nil {
-		log.Error("failed to get assigned batch hashes from db", "error", err)
-	} else if prevSessions, err := m.orm.GetSessionInfosByHashes(hashes); err != nil {
-		log.Error("failed to recover roller session info from db", "error", err)
-	} else {
-		for _, v := range prevSessions {
-			sess := &session{
-				info:       v,
-				finishChan: make(chan rollerProofStatus, proofAndPkBufferSize),
-			}
-			m.sessions[sess.info.ID] = sess
 
-			log.Info("Coordinator restart reload sessions", "session start time", time.Unix(sess.info.StartTimestamp, 0))
-			for _, roller := range sess.info.Rollers {
-				log.Info(
-					"restore roller info for session",
-					"session id", sess.info.ID,
-					"roller name", roller.Name,
-					"public key", roller.PublicKey,
-					"proof status", roller.Status)
-			}
-
-			go m.CollectProofs(sess)
-		}
+	var hashes []string
+	// load assigned aggregator tasks from db
+	aggTasks, err := m.orm.GetAssignedAggTasks()
+	if err != nil {
+		log.Error("failed to load assigned aggregator tasks from db", "error", err)
+		return
 	}
+	for _, aggTask := range aggTasks {
+		hashes = append(hashes, aggTask.ID)
+	}
+	// load assigned basic tasks from db
+	batchHashes, err := m.orm.GetAssignedBatchHashes()
+	if err != nil {
+		log.Error("failed to get assigned batch batchHashes from db", "error", err)
+		return
+	}
+	hashes = append(hashes, batchHashes...)
+
+	prevSessions, err := m.orm.GetSessionInfosByHashes(hashes)
+	if err != nil {
+		log.Error("failed to recover roller session info from db", "error", err)
+		return
+	}
+	for _, v := range prevSessions {
+		sess := &session{
+			info:       v,
+			finishChan: make(chan rollerProofStatus, proofAndPkBufferSize),
+		}
+		m.sessions[sess.info.ID] = sess
+
+		log.Info("Coordinator restart reload sessions", "session start time", time.Unix(sess.info.StartTimestamp, 0))
+		for _, roller := range sess.info.Rollers {
+			log.Info(
+				"restore roller info for session",
+				"session id", sess.info.ID,
+				"roller name", roller.Name,
+				"prove type", sess.info.ProveType,
+				"public key", roller.PublicKey,
+				"proof status", roller.Status)
+		}
+
+		go m.CollectProofs(sess)
+	}
+
 }
 
 // HandleZkProof handle a ZkProof submitted from a roller.
@@ -257,7 +294,7 @@ func (m *Manager) handleZkProof(pk string, msg *message.ProofDetail) error {
 	// Ensure this roller is eligible to participate in the session.
 	roller, ok := sess.info.Rollers[pk]
 	if !ok {
-		return fmt.Errorf("roller %s (%s) is not eligible to partake in proof session %v", roller.Name, roller.PublicKey, msg.ID)
+		return fmt.Errorf("roller %s %s (%s) is not eligible to partake in proof session %v", roller.Name, sess.info.ProveType, roller.PublicKey, msg.ID)
 	}
 	if roller.Status == types.RollerProofValid {
 		// In order to prevent DoS attacks, it is forbidden to repeatedly submit valid proofs.
@@ -268,6 +305,7 @@ func (m *Manager) handleZkProof(pk string, msg *message.ProofDetail) error {
 			"roller has already submitted valid proof in proof session",
 			"roller name", roller.Name,
 			"roller pk", roller.PublicKey,
+			"prove type", sess.info.ProveType,
 			"proof id", msg.ID,
 		)
 		return nil
@@ -277,6 +315,7 @@ func (m *Manager) handleZkProof(pk string, msg *message.ProofDetail) error {
 		"proof id", msg.ID,
 		"roller name", roller.Name,
 		"roller pk", roller.PublicKey,
+		"prove type", sess.info.ProveType,
 		"proof time", proofTimeSec,
 	)
 
@@ -284,8 +323,15 @@ func (m *Manager) handleZkProof(pk string, msg *message.ProofDetail) error {
 		// TODO: maybe we should use db tx for the whole process?
 		// Roll back current proof's status.
 		if dbErr != nil {
-			if err := m.orm.UpdateProvingStatus(msg.ID, types.ProvingTaskUnassigned); err != nil {
-				log.Error("fail to reset task status as Unassigned", "msg.ID", msg.ID)
+			if msg.Type == message.BasicProve {
+				if err := m.orm.UpdateProvingStatus(msg.ID, types.ProvingTaskUnassigned); err != nil {
+					log.Error("fail to reset basic task status as Unassigned", "msg.ID", msg.ID)
+				}
+			}
+			if msg.Type == message.AggregatorProve {
+				if err := m.orm.UpdateAggTaskStatus(msg.ID, types.ProvingTaskUnassigned); err != nil {
+					log.Error("fail to reset aggregator task status as Unassigned", "msg.ID", msg.ID)
+				}
 			}
 		}
 		// set proof status
@@ -294,7 +340,7 @@ func (m *Manager) handleZkProof(pk string, msg *message.ProofDetail) error {
 			status = types.RollerProofValid
 		}
 		// notify the session that the roller finishes the proving process
-		sess.finishChan <- rollerProofStatus{msg.ID, pk, status}
+		sess.finishChan <- rollerProofStatus{msg.ID, msg.Type, pk, status}
 	}()
 
 	if msg.Status != message.StatusOk {
@@ -305,6 +351,7 @@ func (m *Manager) handleZkProof(pk string, msg *message.ProofDetail) error {
 			"proof id", msg.ID,
 			"roller name", roller.Name,
 			"roller pk", roller.PublicKey,
+			"prove type", msg.Type,
 			"proof time", proofTimeSec,
 			"error", msg.Error,
 		)
@@ -312,45 +359,67 @@ func (m *Manager) handleZkProof(pk string, msg *message.ProofDetail) error {
 	}
 
 	// store proof content
-	if dbErr = m.orm.UpdateProofByHash(m.ctx, msg.ID, msg.Proof.Proof, msg.Proof.FinalPair, proofTimeSec); dbErr != nil {
-		log.Error("failed to store proof into db", "error", dbErr)
-		return dbErr
+	if msg.Type == message.BasicProve {
+		if dbErr = m.orm.UpdateProofByHash(m.ctx, msg.ID, msg.Proof.Proof, msg.Proof.FinalPair, proofTimeSec); dbErr != nil {
+			log.Error("failed to store basic proof into db", "error", dbErr)
+			return dbErr
+		}
+		if dbErr = m.orm.UpdateProvingStatus(msg.ID, types.ProvingTaskProved); dbErr != nil {
+			log.Error("failed to update basic task status as proved", "error", dbErr)
+			return dbErr
+		}
 	}
-	if dbErr = m.orm.UpdateProvingStatus(msg.ID, types.ProvingTaskProved); dbErr != nil {
-		log.Error("failed to update task status as proved", "error", dbErr)
-		return dbErr
+	if msg.Type == message.AggregatorProve {
+		if dbErr = m.orm.UpdateProofForAggTask(msg.ID, msg.Proof); dbErr != nil {
+			log.Error("failed to store aggregator proof into db", "error", dbErr)
+			return dbErr
+		}
 	}
 
 	coordinatorProofsReceivedTotalCounter.Inc(1)
 
 	var verifyErr error
+	// TODO: wrap both basic verifier and aggregator verifier
 	success, verifyErr = m.verifyProof(msg.Proof)
 	if verifyErr != nil {
 		// TODO: this is only a temp workaround for testnet, we should return err in real cases
 		success = false
 		log.Error("Failed to verify zk proof", "proof id", msg.ID, "roller name", roller.Name,
-			"roller pk", roller.PublicKey, "proof time", proofTimeSec, "error", verifyErr)
+			"roller pk", roller.PublicKey, "prove type", msg.Type, "proof time", proofTimeSec, "error", verifyErr)
 		// TODO: Roller needs to be slashed if proof is invalid.
 	}
 
 	if success {
-		if dbErr = m.orm.UpdateProvingStatus(msg.ID, types.ProvingTaskVerified); dbErr != nil {
-			log.Error(
-				"failed to update proving_status",
-				"msg.ID", msg.ID,
-				"status", types.ProvingTaskVerified,
-				"error", dbErr)
-			return dbErr
+		if msg.Type == message.AggregatorProve {
+			if dbErr = m.orm.UpdateAggTaskStatus(msg.ID, types.ProvingTaskVerified); dbErr != nil {
+				log.Error(
+					"failed to update aggregator proving_status",
+					"msg.ID", msg.ID,
+					"status", types.ProvingTaskVerified,
+					"error", dbErr)
+				return dbErr
+			}
 		}
+		if msg.Type == message.BasicProve {
+			if dbErr = m.orm.UpdateProvingStatus(msg.ID, types.ProvingTaskVerified); dbErr != nil {
+				log.Error(
+					"failed to update basic proving_status",
+					"msg.ID", msg.ID,
+					"status", types.ProvingTaskVerified,
+					"error", dbErr)
+				return dbErr
+			}
+		}
+
 		coordinatorProofsVerifiedSuccessTimeTimer.Update(proofTime)
 		m.updateMetricRollerProofsVerifiedSuccessTimeTimer(roller.PublicKey, proofTime)
 		log.Info("proof verified by coordinator success", "proof id", msg.ID, "roller name", roller.Name,
-			"roller pk", roller.PublicKey, "proof time", proofTimeSec)
+			"roller pk", roller.PublicKey, "prove type", msg.Type, "proof time", proofTimeSec)
 	} else {
 		coordinatorProofsVerifiedFailedTimeTimer.Update(proofTime)
 		m.updateMetricRollerProofsVerifiedFailedTimeTimer(roller.PublicKey, proofTime)
 		log.Info("proof verified by coordinator failed", "proof id", msg.ID, "roller name", roller.Name,
-			"roller pk", roller.PublicKey, "proof time", proofTimeSec, "error", verifyErr)
+			"roller pk", roller.PublicKey, "prove type", msg.Type, "proof time", proofTimeSec, "error", verifyErr)
 	}
 	return nil
 }
@@ -366,7 +435,13 @@ func (m *Manager) CollectProofs(sess *session) {
 		case <-time.After(time.Duration(m.cfg.CollectionTime) * time.Minute):
 			// Check if session can be replayed
 			if sess.info.Attempts < m.cfg.SessionAttempts {
-				if m.StartProofGenerationSession(nil, sess) {
+				var success bool
+				if sess.info.ProveType == message.AggregatorProve {
+					success = m.StartAggProofGenerationSession(nil, sess)
+				} else if sess.info.ProveType == message.BasicProve {
+					success = m.StartBasicProofGenerationSession(nil, sess)
+				}
+				if success {
 					m.mu.Lock()
 					for pk := range sess.info.Rollers {
 						m.freeTaskIDForRoller(pk, sess.info.ID)
@@ -384,9 +459,17 @@ func (m *Manager) CollectProofs(sess *session) {
 			// Note that this is only a workaround for testnet here.
 			// TODO: In real cases we should reset to orm.ProvingTaskUnassigned
 			// so as to re-distribute the task in the future
-			if err := m.orm.UpdateProvingStatus(sess.info.ID, types.ProvingTaskFailed); err != nil {
-				log.Error("fail to reset task_status as Unassigned", "id", sess.info.ID, "err", err)
+			if sess.info.ProveType == message.BasicProve {
+				if err := m.orm.UpdateProvingStatus(sess.info.ID, types.ProvingTaskFailed); err != nil {
+					log.Error("fail to reset basic task_status as Unassigned", "id", sess.info.ID, "err", err)
+				}
 			}
+			if sess.info.ProveType == message.AggregatorProve {
+				if err := m.orm.UpdateAggTaskStatus(sess.info.ID, types.ProvingTaskFailed); err != nil {
+					log.Error("fail to reset aggregator task_status as Unassigned", "id", sess.info.ID, "err", err)
+				}
+			}
+
 			m.mu.Lock()
 			for pk := range sess.info.Rollers {
 				m.freeTaskIDForRoller(pk, sess.info.ID)
@@ -401,9 +484,17 @@ func (m *Manager) CollectProofs(sess *session) {
 			m.mu.Lock()
 			sess.info.Rollers[ret.pk].Status = ret.status
 			if sess.isSessionFailed() {
-				if err := m.orm.UpdateProvingStatus(ret.id, types.ProvingTaskFailed); err != nil {
-					log.Error("failed to update proving_status as failed", "msg.ID", ret.id, "error", err)
+				if ret.typ == message.BasicProve {
+					if err := m.orm.UpdateProvingStatus(ret.id, types.ProvingTaskFailed); err != nil {
+						log.Error("failed to update basic proving_status as failed", "msg.ID", ret.id, "error", err)
+					}
 				}
+				if ret.typ == message.AggregatorProve {
+					if err := m.orm.UpdateAggTaskStatus(ret.id, types.ProvingTaskFailed); err != nil {
+						log.Error("failed to update aggregator proving_status as failed", "msg.ID", ret.id, "error", err)
+					}
+				}
+
 				coordinatorSessionsFailedTotalCounter.Inc(1)
 			}
 			if err := m.orm.SetSessionInfo(sess.info); err != nil {
@@ -477,20 +568,21 @@ func (m *Manager) APIs() []rpc.API {
 	}
 }
 
-// StartProofGenerationSession starts a proof generation session
-func (m *Manager) StartProofGenerationSession(task *types.BlockBatch, prevSession *session) (success bool) {
+// StartBasicProofGenerationSession starts a basic proof generation session
+func (m *Manager) StartBasicProofGenerationSession(task *types.BlockBatch, prevSession *session) (success bool) {
 	var taskId string
 	if task != nil {
 		taskId = task.Hash
 	} else {
 		taskId = prevSession.info.ID
 	}
-	if m.GetNumberOfIdleRollers() == 0 {
-		log.Warn("no idle roller when starting proof generation session", "id", taskId)
+	if m.GetNumberOfIdleRollers(message.BasicProve) == 0 {
+		log.Warn("no idle basic roller when starting proof generation session", "id", taskId)
 		return false
 	}
 
-	log.Info("start proof generation session", "id", taskId)
+	log.Info("start basic proof generation session", "id", taskId)
+
 	defer func() {
 		if !success {
 			if task != nil {
@@ -529,17 +621,17 @@ func (m *Manager) StartProofGenerationSession(task *types.BlockBatch, prevSessio
 		}
 	}
 
-	// Dispatch task to rollers.
+	// Dispatch task to basic rollers.
 	rollers := make(map[string]*types.RollerStatus)
 	for i := 0; i < int(m.cfg.RollersPerSession); i++ {
-		roller := m.selectRoller()
+		roller := m.selectRoller(message.BasicProve)
 		if roller == nil {
 			log.Info("selectRoller returns nil")
 			break
 		}
 		log.Info("roller is picked", "session id", taskId, "name", roller.Name, "public key", roller.PublicKey)
 		// send trace to roller
-		if !roller.sendTask(taskId, traces) {
+		if !roller.sendTask(&message.TaskMsg{ID: taskId, Type: message.BasicProve, Traces: traces}) {
 			log.Error("send task failed", "roller name", roller.Name, "public key", roller.PublicKey, "id", taskId)
 			continue
 		}
@@ -548,7 +640,7 @@ func (m *Manager) StartProofGenerationSession(task *types.BlockBatch, prevSessio
 	}
 	// No roller assigned.
 	if len(rollers) == 0 {
-		log.Error("no roller assigned", "id", taskId, "number of idle rollers", m.GetNumberOfIdleRollers())
+		log.Error("no roller assigned", "id", taskId, "number of idle basic rollers", m.GetNumberOfIdleRollers(message.BasicProve))
 		return false
 	}
 
@@ -563,6 +655,7 @@ func (m *Manager) StartProofGenerationSession(task *types.BlockBatch, prevSessio
 		info: &types.SessionInfo{
 			ID:             taskId,
 			Rollers:        rollers,
+			ProveType:      message.BasicProve,
 			StartTimestamp: time.Now().Unix(),
 			Attempts:       1,
 		},
@@ -576,6 +669,114 @@ func (m *Manager) StartProofGenerationSession(task *types.BlockBatch, prevSessio
 		log.Info(
 			"assigned proof to roller",
 			"session id", sess.info.ID,
+			"session type", sess.info.ProveType,
+			"roller name", roller.Name,
+			"roller pk", roller.PublicKey,
+			"proof status", roller.Status)
+	}
+
+	// Store session info.
+	if err = m.orm.SetSessionInfo(sess.info); err != nil {
+		log.Error("db set session info fail", "session id", sess.info.ID, "error", err)
+		return false
+	}
+
+	m.mu.Lock()
+	m.sessions[taskId] = sess
+	m.mu.Unlock()
+	go m.CollectProofs(sess)
+
+	return true
+}
+
+// StartAggProofGenerationSession starts an aggregator proof generation.
+func (m *Manager) StartAggProofGenerationSession(task *types.AggTask, prevSession *session) (success bool) {
+	var taskId string
+	if task != nil {
+		taskId = task.ID
+	} else {
+		taskId = prevSession.info.ID
+	}
+	if m.GetNumberOfIdleRollers(message.AggregatorProve) == 0 {
+		log.Warn("no idle common roller when starting proof generation session", "id", taskId)
+		return false
+	}
+
+	log.Info("start aggregator proof generation session", "id", taskId)
+
+	defer func() {
+		if !success {
+			if task != nil {
+				if err := m.orm.UpdateAggTaskStatus(taskId, types.ProvingTaskUnassigned); err != nil {
+					log.Error("fail to reset task_status as Unassigned", "id", taskId, "err", err)
+				} else if err := m.orm.UpdateAggTaskStatus(taskId, types.ProvingTaskFailed); err != nil {
+					log.Error("fail to reset task_status as Failed", "id", taskId, "err", err)
+				}
+			}
+		}
+
+	}()
+
+	// get agg task from db
+	subProofs, err := m.orm.GetSubProofsByAggTaskID(taskId)
+	if err != nil {
+		log.Error("failed to get sub proofs for aggregator task", "id", taskId, "error", err)
+		return false
+	}
+
+	// Dispatch task to basic rollers.
+	rollers := make(map[string]*types.RollerStatus)
+	for i := 0; i < int(m.cfg.RollersPerSession); i++ {
+		roller := m.selectRoller(message.AggregatorProve)
+		if roller == nil {
+			log.Info("selectRoller returns nil")
+			break
+		}
+		log.Info("roller is picked", "session id", taskId, "name", roller.Name, "type", roller.Type, "public key", roller.PublicKey)
+		// send trace to roller
+		if !roller.sendTask(&message.TaskMsg{
+			ID:        taskId,
+			Type:      message.AggregatorProve,
+			SubProofs: subProofs,
+		}) {
+			log.Error("send task failed", "roller name", roller.Name, "public key", roller.PublicKey, "id", taskId)
+			continue
+		}
+		m.updateMetricRollerProofsLastAssignedTimestampGauge(roller.PublicKey)
+		rollers[roller.PublicKey] = &types.RollerStatus{PublicKey: roller.PublicKey, Name: roller.Name, Status: types.RollerAssigned}
+	}
+	// No roller assigned.
+	if len(rollers) == 0 {
+		log.Error("no roller assigned", "id", taskId, "number of idle aggregator rollers", m.GetNumberOfIdleRollers(message.AggregatorProve))
+		return false
+	}
+
+	// Update session proving status as assigned.
+	if err = m.orm.UpdateAggTaskStatus(taskId, types.ProvingTaskAssigned); err != nil {
+		log.Error("failed to update task status", "id", taskId, "err", err)
+		return false
+	}
+
+	// Create a proof generation session.
+	sess := &session{
+		info: &types.SessionInfo{
+			ID:             taskId,
+			Rollers:        rollers,
+			ProveType:      message.AggregatorProve,
+			StartTimestamp: time.Now().Unix(),
+			Attempts:       1,
+		},
+		finishChan: make(chan rollerProofStatus, proofAndPkBufferSize),
+	}
+	if prevSession != nil {
+		sess.info.Attempts += prevSession.info.Attempts
+	}
+
+	for _, roller := range sess.info.Rollers {
+		log.Info(
+			"assigned proof to roller",
+			"session id", sess.info.ID,
+			"session type", sess.info.ProveType,
 			"roller name", roller.Name,
 			"roller pk", roller.PublicKey,
 			"proof status", roller.Status)
@@ -606,7 +807,7 @@ func (m *Manager) VerifyToken(authMsg *message.AuthMsg) (bool, error) {
 	pubkey, _ := authMsg.PublicKey()
 	// GetValue returns nil if value is expired
 	if token, ok := m.tokenCache.Get(pubkey); !ok || token != authMsg.Identity.Token {
-		return false, errors.New("failed to find corresponding token")
+		return false, fmt.Errorf("failed to find corresponding token. roller name: %s. roller pk: %s.", authMsg.Identity.Name, pubkey)
 	}
 	return true, nil
 }

coordinator/manager_test.go

@@ -111,7 +111,7 @@ func testHandshake(t *testing.T) {
 	roller := newMockRoller(t, "roller_test", wsURL)
 	defer roller.close()
 
-	assert.Equal(t, 1, rollerManager.GetNumberOfIdleRollers())
+	assert.Equal(t, 1, rollerManager.GetNumberOfIdleRollers(message.BasicProve))
 }
 
 func testFailedHandshake(t *testing.T) {
@@ -174,7 +174,7 @@ func testFailedHandshake(t *testing.T) {
 	_, err = client.RegisterAndSubscribe(ctx, make(chan *message.TaskMsg, 4), authMsg)
 	assert.Error(t, err)
 
-	assert.Equal(t, 0, rollerManager.GetNumberOfIdleRollers())
+	assert.Equal(t, 0, rollerManager.GetNumberOfIdleRollers(message.BasicProve))
 }
 
 func testSeveralConnections(t *testing.T) {
@@ -204,7 +204,7 @@ func testSeveralConnections(t *testing.T) {
 	assert.NoError(t, eg.Wait())
 
 	// check roller's idle connections
-	assert.Equal(t, batch, rollerManager.GetNumberOfIdleRollers())
+	assert.Equal(t, batch, rollerManager.GetNumberOfIdleRollers(message.BasicProve))
 
 	// close connection
 	for _, roller := range rollers {
@@ -218,7 +218,7 @@ func testSeveralConnections(t *testing.T) {
 	for {
 		select {
 		case <-tick:
-			if rollerManager.GetNumberOfIdleRollers() == 0 {
+			if rollerManager.GetNumberOfIdleRollers(message.BasicProve) == 0 {
 				return
 			}
 		case <-tickStop:
@@ -260,7 +260,7 @@ func testValidProof(t *testing.T) {
 			roller.close()
 		}
 	}()
-	assert.Equal(t, 3, rollerManager.GetNumberOfIdleRollers())
+	assert.Equal(t, 3, rollerManager.GetNumberOfIdleRollers(message.BasicProve))
 
 	var hashes = make([]string, 1)
 	dbTx, err := l2db.Beginx()
@@ -318,7 +318,7 @@ func testInvalidProof(t *testing.T) {
 			roller.close()
 		}
 	}()
-	assert.Equal(t, 3, rollerManager.GetNumberOfIdleRollers())
+	assert.Equal(t, 3, rollerManager.GetNumberOfIdleRollers(message.BasicProve))
 
 	var hashes = make([]string, 1)
 	dbTx, err := l2db.Beginx()
@@ -376,7 +376,7 @@ func testProofGeneratedFailed(t *testing.T) {
 			roller.close()
 		}
 	}()
-	assert.Equal(t, 3, rollerManager.GetNumberOfIdleRollers())
+	assert.Equal(t, 3, rollerManager.GetNumberOfIdleRollers(message.BasicProve))
 
 	var hashes = make([]string, 1)
 	dbTx, err := l2db.Beginx()
@@ -428,36 +428,33 @@ func testTimedoutProof(t *testing.T) {
 		// close connection
 		roller1.close()
 	}()
-	assert.Equal(t, 1, rollerManager.GetNumberOfIdleRollers())
+	assert.Equal(t, 1, rollerManager.GetNumberOfIdleRollers(message.BasicProve))
 
-	var hashes = make([]string, 1)
+	var (
+		hashesAssigned = make([]string, 1)
+		hashesVerified = make([]string, 1)
+	)
 	dbTx, err := l2db.Beginx()
 	assert.NoError(t, err)
-	for i := range hashes {
+	for i := range hashesAssigned {
 		assert.NoError(t, l2db.NewBatchInDBTx(dbTx, batchData))
-		hashes[i] = batchData.Hash().Hex()
-
+		hashesAssigned[i] = batchData.Hash().Hex()
+		hashesVerified[i] = batchData.Hash().Hex()
 	}
 	assert.NoError(t, dbTx.Commit())
 
 	// verify proof status, it should be assigned, because roller didn't send any proof
-	var (
-		tick     = time.Tick(500 * time.Millisecond)
-		tickStop = time.Tick(10 * time.Second)
-	)
-	for len(hashes) > 0 {
-		select {
-		case <-tick:
-			status, err := l2db.GetProvingStatusByHash(hashes[0])
-			assert.NoError(t, err)
-			if status == types.ProvingTaskAssigned {
-				hashes = hashes[1:]
-			}
-		case <-tickStop:
-			t.Error("failed to check proof status")
-			return
+	ok := utils.TryTimes(30, func() bool {
+		status, err := l2db.GetProvingStatusByHash(hashesAssigned[0])
+		if err != nil {
+			return false
 		}
-	}
+		if status == types.ProvingTaskAssigned {
+			hashesAssigned = hashesAssigned[1:]
+		}
+		return len(hashesAssigned) == 0
+	})
+	assert.Falsef(t, !ok, "failed to check proof status")
 
 	// create second mock roller, that will send valid proof.
 	roller2 := newMockRoller(t, "roller_test"+strconv.Itoa(1), wsURL)
@@ -466,25 +463,20 @@ func testTimedoutProof(t *testing.T) {
 		// close connection
 		roller2.close()
 	}()
-	assert.Equal(t, 1, rollerManager.GetNumberOfIdleRollers())
-
-	// wait manager to finish first CollectProofs
-	<-time.After(60 * time.Second)
+	assert.Equal(t, 1, rollerManager.GetNumberOfIdleRollers(message.BasicProve))
 
 	// verify proof status, it should be verified now, because second roller sent valid proof
-	for len(hashes) > 0 {
-		select {
-		case <-tick:
-			status, err := l2db.GetProvingStatusByHash(hashes[0])
-			assert.NoError(t, err)
-			if status == types.ProvingTaskVerified {
-				hashes = hashes[1:]
-			}
-		case <-tickStop:
-			t.Error("failed to check proof status")
-			return
+	ok = utils.TryTimes(200, func() bool {
+		status, err := l2db.GetProvingStatusByHash(hashesVerified[0])
+		if err != nil {
+			return false
 		}
-	}
+		if status == types.ProvingTaskVerified {
+			hashesVerified = hashesVerified[1:]
+		}
+		return len(hashesVerified) == 0
+	})
+	assert.Falsef(t, !ok, "failed to check proof status")
 }
 
 func testIdleRollerSelection(t *testing.T) {
@@ -515,7 +507,7 @@ func testIdleRollerSelection(t *testing.T) {
 		}
 	}()
 
-	assert.Equal(t, len(rollers), rollerManager.GetNumberOfIdleRollers())
+	assert.Equal(t, len(rollers), rollerManager.GetNumberOfIdleRollers(message.BasicProve))
 
 	var hashes = make([]string, 1)
 	dbTx, err := l2db.Beginx()