feat(bridge-history-api): server api add return l1l2token (#705)

Co-authored-by: colinlyguo <colinlyguo@scroll.io>
Co-authored-by: colin <102356659+colinlyguo@users.noreply.github.com>

.github/workflows/bridge.yml

@@ -81,7 +81,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.19.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc

.github/workflows/bridge_history_api.yml

@@ -51,7 +51,6 @@ jobs:
       uses: actions/checkout@v2
     - name: Test
       run: |
-        go get ./...
         make test
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v3

.github/workflows/common.yml

@@ -77,7 +77,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.19.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc

.github/workflows/coordinator.yml

@@ -93,7 +93,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.19.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc

.github/workflows/database.yml

@@ -70,7 +70,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.19.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc

.github/workflows/integration.yaml

@@ -22,7 +22,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.19.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc

.github/workflows/prover.yml

@@ -1,4 +1,4 @@
-name: Roller
+name: Prover
 
 on:
   push:
@@ -8,8 +8,8 @@ on:
       - develop
       - alpha
     paths:
-      - 'roller/**'
-      - '.github/workflows/roller.yml'
+      - 'prover/**'
+      - '.github/workflows/prover.yml'
   pull_request:
     types:
       - opened
@@ -17,12 +17,12 @@ on:
       - synchronize
       - ready_for_review
     paths:
-      - 'roller/**'
-      - '.github/workflows/roller.yml'
+      - 'prover/**'
+      - '.github/workflows/prover.yml'
 
 defaults:
   run:
-    working-directory: 'roller'
+    working-directory: 'prover'
 
 jobs:
   test:
@@ -43,7 +43,7 @@ jobs:
       env:
         CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
       with:
-        flags: roller
+        flags: prover
   compile:
     if: github.event_name == 'push' # will only be triggered when pushing to main & staging & develop & alpha
     runs-on: ubuntu-latest
@@ -65,7 +65,7 @@ jobs:
         workspaces: "common/libzkp/impl -> target"
     - name: Test
       run: |
-        make roller
+        make prover
   check:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest
@@ -92,7 +92,7 @@ jobs:
       uses: actions/checkout@v2
     - name: Install goimports
       run: go install golang.org/x/tools/cmd/goimports
-    - run: goimports -local scroll-tech/roller/ -w .
+    - run: goimports -local scroll-tech/prover/ -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

Makefile

@@ -10,7 +10,7 @@ lint: ## The code's format and security checks.
 	make -C common lint
 	make -C coordinator lint
 	make -C database lint
-	make -C roller lint
+	make -C prover lint
 	make -C bridge-history-api lint
 
 update: ## update dependencies
@@ -20,13 +20,13 @@ update: ## update dependencies
 	cd $(PWD)/common/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
 	cd $(PWD)/coordinator/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
 	cd $(PWD)/database/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
-	cd $(PWD)/roller/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
+	cd $(PWD)/prover/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
 	goimports -local $(PWD)/bridge/ -w .
 	goimports -local $(PWD)/bridge-history-api/ -w .
 	goimports -local $(PWD)/common/ -w .
 	goimports -local $(PWD)/coordinator/ -w .
 	goimports -local $(PWD)/database/ -w .
-	goimports -local $(PWD)/roller/ -w .
+	goimports -local $(PWD)/prover/ -w .
 
 dev_docker: ## build docker images for development/testing usages
 	docker build -t scroll_l1geth ./common/docker/l1geth/

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

@@ -3,111 +3,70 @@ package app
 import (
 	"fmt"
 	"os"
+	"os/signal"
 
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/iris-contrib/middleware/cors"
-	"github.com/kataras/iris/v12"
-	"github.com/kataras/iris/v12/mvc"
+	"github.com/gin-gonic/gin"
 	"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"
+	"bridge-history-api/internal/controller"
+	"bridge-history-api/internal/route"
+	"bridge-history-api/utils"
 )
 
 var (
 	app *cli.App
 )
 
-var database db.OrmFactory
-
-func pong(ctx iris.Context) {
-	_, err := ctx.WriteString("pong")
-	if err != nil {
-		log.Error("failed to write pong", "err", err)
-	}
-}
-
-func setupQueryByAddressHandler(backendApp *mvc.Application) {
-	// Register Dependencies.
-	backendApp.Register(
-		database,
-		service.NewHistoryService,
-	)
-
-	// Register Controllers.
-	backendApp.Handle(new(controller.QueryAddressController))
-}
-
-func setupQueryClaimableHandler(backendApp *mvc.Application) {
-	// Register Dependencies.
-	backendApp.Register(
-		database,
-		service.NewHistoryService,
-	)
-
-	// Register Controllers.
-	backendApp.Handle(new(controller.QueryClaimableController))
-}
-
-func setupQueryByHashHandler(backendApp *mvc.Application) {
-	backendApp.Register(
-		database,
-		service.NewHistoryService,
-	)
-	backendApp.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.Flags = append(app.Flags, utils.CommonFlags...)
 	app.Commands = []*cli.Command{}
 
 	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
+		return utils.LogSetup(ctx)
 	}
 }
 
 func action(ctx *cli.Context) error {
-	corsOptions := cors.New(cors.Options{
-		AllowedOrigins:   []string{"*"},
-		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE"},
-		AllowCredentials: true,
-	})
 	// Load config file.
-	cfgFile := ctx.String(cutils.ConfigFileFlag.Name)
+	cfgFile := ctx.String(utils.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)
+	db, err := utils.InitDB(cfg.DB)
 	if err != nil {
-		log.Crit("can not connect to database", "err", err)
+		log.Crit("failed to init db", "err", err)
 	}
 	defer func() {
-		if err = database.Close(); err != nil {
-			log.Error("failed to close database", "err", err)
+		if deferErr := utils.CloseDB(db); deferErr != nil {
+			log.Error("failed to close db", "err", err)
 		}
 	}()
-	bridgeApp := iris.New()
-	bridgeApp.UseRouter(corsOptions)
-	bridgeApp.Get("/ping", pong).Describe("healthcheck")
+	// init Prover Stats API
+	port := cfg.Server.HostPort
 
-	mvc.Configure(bridgeApp.Party("/api/txs"), setupQueryByAddressHandler)
-	mvc.Configure(bridgeApp.Party("/api/txsbyhashes"), setupQueryByHashHandler)
-	mvc.Configure(bridgeApp.Party("/api/claimable"), setupQueryClaimableHandler)
+	router := gin.Default()
+	controller.InitController(db)
+	route.Route(router, cfg)
 
-	// TODO: make debug mode configurable
-	err = bridgeApp.Listen(cfg.Server.HostPort, iris.WithLogLevel("debug"))
-	if err != nil {
-		log.Crit("can not start server", "err", err)
-	}
+	go func() {
+		if runServerErr := router.Run(fmt.Sprintf(":%s", port)); runServerErr != nil {
+			log.Crit("run http server failure", "error", runServerErr)
+		}
+	}()
+	// 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
 }

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

@@ -14,8 +14,8 @@ import (
 	"bridge-history-api/config"
 	"bridge-history-api/crossmsg"
 	"bridge-history-api/crossmsg/messageproof"
-	"bridge-history-api/db"
-	cutils "bridge-history-api/utils"
+	"bridge-history-api/orm"
+	"bridge-history-api/utils"
 )
 
 var (
@@ -28,17 +28,17 @@ func init() {
 	app.Action = action
 	app.Name = "Scroll Bridge History API"
 	app.Usage = "The Scroll Bridge Web Backend"
-	app.Flags = append(app.Flags, cutils.CommonFlags...)
+	app.Flags = append(app.Flags, utils.CommonFlags...)
 	app.Commands = []*cli.Command{}
 
 	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
+		return utils.LogSetup(ctx)
 	}
 }
 
 func action(ctx *cli.Context) error {
 	// Load config file.
-	cfgFile := ctx.String(cutils.ConfigFileFlag.Name)
+	cfgFile := ctx.String(utils.ConfigFileFlag.Name)
 	cfg, err := config.NewConfig(cfgFile)
 	if err != nil {
 		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
@@ -55,9 +55,12 @@ func action(ctx *cli.Context) error {
 		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
 	}
 
-	db, err := db.NewOrmFactory(cfg)
+	db, err := utils.InitDB(cfg.DB)
+	if err != nil {
+		log.Crit("failed to init db", "err", err)
+	}
 	defer func() {
-		if deferErr := db.Close(); deferErr != nil {
+		if deferErr := utils.CloseDB(db); deferErr != nil {
 			log.Error("failed to close db", "err", err)
 		}
 	}()
@@ -105,12 +108,14 @@ func action(ctx *cli.Context) error {
 	go l2crossMsgFetcher.Start()
 	defer l2crossMsgFetcher.Stop()
 
+	CrossMsgOrm := orm.NewCrossMsg(db)
+
 	// BlockTimestamp fetcher for l1 and l2
-	l1BlockTimeFetcher := crossmsg.NewBlockTimestampFetcher(subCtx, cfg.L1.Confirmation, int(cfg.L1.BlockTime), l1client, db.UpdateL1BlockTimestamp, db.GetL1EarliestNoBlockTimestampHeight)
+	l1BlockTimeFetcher := crossmsg.NewBlockTimestampFetcher(subCtx, cfg.L1.Confirmation, int(cfg.L1.BlockTime), l1client, CrossMsgOrm.UpdateL1BlockTimestamp, CrossMsgOrm.GetL1EarliestNoBlockTimestampHeight)
 	go l1BlockTimeFetcher.Start()
 	defer l1BlockTimeFetcher.Stop()
 
-	l2BlockTimeFetcher := crossmsg.NewBlockTimestampFetcher(subCtx, cfg.L2.Confirmation, int(cfg.L2.BlockTime), l2client, db.UpdateL2BlockTimestamp, db.GetL2EarliestNoBlockTimestampHeight)
+	l2BlockTimeFetcher := crossmsg.NewBlockTimestampFetcher(subCtx, cfg.L2.Confirmation, int(cfg.L2.BlockTime), l2client, CrossMsgOrm.UpdateL2BlockTimestamp, CrossMsgOrm.GetL2EarliestNoBlockTimestampHeight)
 	go l2BlockTimeFetcher.Start()
 	defer l2BlockTimeFetcher.Stop()
 

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

@@ -2,12 +2,11 @@ package app
 
 import (
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
 	"github.com/urfave/cli/v2"
+	"gorm.io/gorm"
 
 	"bridge-history-api/config"
-	"bridge-history-api/db"
-	"bridge-history-api/db/migrate"
+	"bridge-history-api/orm/migrate"
 	"bridge-history-api/utils"
 )
 
@@ -20,14 +19,8 @@ func getConfig(ctx *cli.Context) (*config.Config, error) {
 	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
+func initDB(dbCfg *config.DBConfig) (*gorm.DB, error) {
+	return utils.InitDB(dbCfg)
 }
 
 // resetDB clean or reset database.
@@ -36,11 +29,15 @@ func resetDB(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	db, err := initDB(cfg)
+	gormDB, err := initDB(cfg.DB)
 	if err != nil {
 		return err
 	}
-	err = migrate.ResetDB(db.DB)
+	db, err := gormDB.DB()
+	if err != nil {
+		return err
+	}
+	err = migrate.ResetDB(db)
 	if err != nil {
 		return err
 	}
@@ -54,12 +51,15 @@ func checkDBStatus(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	db, err := initDB(cfg)
+	gormDB, err := initDB(cfg.DB)
 	if err != nil {
 		return err
 	}
-
-	return migrate.Status(db.DB)
+	db, err := gormDB.DB()
+	if err != nil {
+		return err
+	}
+	return migrate.Status(db)
 }
 
 // dbVersion return the latest version
@@ -68,12 +68,15 @@ func dbVersion(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	db, err := initDB(cfg)
+	gormDB, err := initDB(cfg.DB)
 	if err != nil {
 		return err
 	}
-
-	version, err := migrate.Current(db.DB)
+	db, err := gormDB.DB()
+	if err != nil {
+		return err
+	}
+	version, err := migrate.Current(db)
 	log.Info("show database version", "db version", version)
 
 	return err
@@ -85,12 +88,15 @@ func migrateDB(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	db, err := initDB(cfg)
+	gormDB, err := initDB(cfg.DB)
 	if err != nil {
 		return err
 	}
-
-	return migrate.Migrate(db.DB)
+	db, err := gormDB.DB()
+	if err != nil {
+		return err
+	}
+	return migrate.Migrate(db)
 }
 
 // rollbackDB rollback db by version
@@ -99,10 +105,14 @@ func rollbackDB(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	db, err := initDB(cfg)
+	gormDB, err := initDB(cfg.DB)
+	if err != nil {
+		return err
+	}
+	db, err := gormDB.DB()
 	if err != nil {
 		return err
 	}
 	version := ctx.Int64("version")
-	return migrate.Rollback(db.DB, &version)
+	return migrate.Rollback(db, &version)
 }

bridge-history-api/config.json

@@ -36,6 +36,6 @@
 		"maxIdleNum": 20
 	},
 	"server": {
-		"hostPort": "0.0.0.0:20006"
+		"hostPort": "20006"
 	}
-}
+}

bridge-history-api/controller/controller.go

@@ -1,60 +0,0 @@
-package controller
-
-import (
-	"bridge-history-api/model"
-	"bridge-history-api/service"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-// QueryAddressController contains the query by address service
-type QueryAddressController struct {
-	Service service.HistoryService
-}
-
-// QueryHashController contains the query by hash service
-type QueryHashController struct {
-	Service service.HistoryService
-}
-
-// QueryClaimableController contains the query claimable txs service
-type QueryClaimableController struct {
-	Service service.HistoryService
-}
-
-// Get defines the http get method behavior for QueryClaimableController
-func (c *QueryClaimableController) Get(req model.QueryByAddressRequest) (*model.QueryByAddressResponse, error) {
-	txs, total, err := c.Service.GetClaimableTxsByAddress(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: txs,
-			Total:  total,
-		}}, nil
-}
-
-// Get defines the http get method behavior for QueryAddressController
-func (c *QueryAddressController) Get(req model.QueryByAddressRequest) (*model.QueryByAddressResponse, error) {
-	message, total, err := c.Service.GetTxsByAddress(common.HexToAddress(req.Address), int64(req.Offset), int64(req.Limit))
-	if err != nil {
-		return &model.QueryByAddressResponse{Message: "500", Data: &model.Data{}}, err
-	}
-
-	return &model.QueryByAddressResponse{Message: "ok",
-		Data: &model.Data{
-			Result: message,
-			Total:  total,
-		}}, nil
-}
-
-// Post defines the http post method behavior for QueryHashController
-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/crossmsg/batch_info_fetcher.go

@@ -7,9 +7,10 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
 
 	"bridge-history-api/crossmsg/messageproof"
-	"bridge-history-api/db"
+	"bridge-history-api/orm"
 	"bridge-history-api/utils"
 )
 
@@ -21,12 +22,13 @@ type BatchInfoFetcher struct {
 	confirmation         uint64
 	blockTimeInSec       int
 	client               *ethclient.Client
-	db                   db.OrmFactory
+	db                   *gorm.DB
+	rollupOrm            *orm.RollupBatch
 	msgProofUpdater      *messageproof.MsgProofUpdater
 }
 
 // NewBatchInfoFetcher creates a new BatchInfoFetcher instance
-func NewBatchInfoFetcher(ctx context.Context, scrollChainAddr common.Address, batchInfoStartNumber uint64, confirmation uint64, blockTimeInSec int, client *ethclient.Client, db db.OrmFactory, msgProofUpdater *messageproof.MsgProofUpdater) *BatchInfoFetcher {
+func NewBatchInfoFetcher(ctx context.Context, scrollChainAddr common.Address, batchInfoStartNumber uint64, confirmation uint64, blockTimeInSec int, client *ethclient.Client, db *gorm.DB, msgProofUpdater *messageproof.MsgProofUpdater) *BatchInfoFetcher {
 	return &BatchInfoFetcher{
 		ctx:                  ctx,
 		scrollChainAddr:      scrollChainAddr,
@@ -35,6 +37,7 @@ func NewBatchInfoFetcher(ctx context.Context, scrollChainAddr common.Address, ba
 		blockTimeInSec:       blockTimeInSec,
 		client:               client,
 		db:                   db,
+		rollupOrm:            orm.NewRollupBatch(db),
 		msgProofUpdater:      msgProofUpdater,
 	}
 }
@@ -80,19 +83,20 @@ func (b *BatchInfoFetcher) fetchBatchInfo() error {
 		log.Error("Can not get latest block number: ", "err", err)
 		return err
 	}
-	latestBatch, err := b.db.GetLatestRollupBatch()
+	latestBatchHeight, err := b.rollupOrm.GetLatestRollupBatchProcessedHeight(b.ctx)
 	if err != nil {
 		log.Error("Can not get latest BatchInfo: ", "err", err)
 		return err
 	}
 	var startHeight uint64
-	if latestBatch == nil {
+	if latestBatchHeight == 0 {
+		log.Info("no batch record in database, start from batchInfoStartNumber", "batchInfoStartNumber", b.batchInfoStartNumber)
 		startHeight = b.batchInfoStartNumber
 	} else {
-		startHeight = latestBatch.CommitHeight + 1
+		startHeight = latestBatchHeight + 1
 	}
-	for from := startHeight; number >= from; from += uint64(fetchLimit) {
-		to := from + uint64(fetchLimit) - 1
+	for from := startHeight; number >= from; from += fetchLimit {
+		to := from + fetchLimit - 1
 		// number - confirmation can never less than 0 since the for loop condition
 		// but watch out the overflow
 		if to > number {

bridge-history-api/crossmsg/block_timestamp_fetcher.go

@@ -10,10 +10,10 @@ import (
 )
 
 // GetEarliestNoBlockTimestampHeightFunc is a function type that gets the earliest record without block timestamp from database
-type GetEarliestNoBlockTimestampHeightFunc func() (uint64, error)
+type GetEarliestNoBlockTimestampHeightFunc func(ctx context.Context) (uint64, error)
 
 // UpdateBlockTimestampFunc is a function type that updates block timestamp into database
-type UpdateBlockTimestampFunc func(height uint64, timestamp time.Time) error
+type UpdateBlockTimestampFunc func(ctx context.Context, height uint64, timestamp time.Time) error
 
 // BlockTimestampFetcher fetches block timestamp from blockchain and saves them to database
 type BlockTimestampFetcher struct {
@@ -52,7 +52,7 @@ func (b *BlockTimestampFetcher) Start() {
 					log.Error("Can not get latest block number", "err", err)
 					continue
 				}
-				startHeight, err := b.getEarliestNoBlockTimestampHeightFunc()
+				startHeight, err := b.getEarliestNoBlockTimestampHeightFunc(b.ctx)
 				if err != nil {
 					log.Error("Can not get latest record without block timestamp", "err", err)
 					continue
@@ -63,12 +63,12 @@ func (b *BlockTimestampFetcher) Start() {
 						log.Error("Can not get block by number", "err", err)
 						break
 					}
-					err = b.updateBlockTimestampFunc(height, time.Unix(int64(block.Time), 0))
+					err = b.updateBlockTimestampFunc(b.ctx, height, time.Unix(int64(block.Time), 0))
 					if err != nil {
 						log.Error("Can not update blockTimestamp into DB ", "err", err)
 						break
 					}
-					height, err = b.getEarliestNoBlockTimestampHeightFunc()
+					height, err = b.getEarliestNoBlockTimestampHeightFunc(b.ctx)
 					if err != nil {
 						log.Error("Can not get latest record without block timestamp", "err", err)
 						break

bridge-history-api/crossmsg/cross_msg_fetcher.go

@@ -12,9 +12,9 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/modern-go/reflect2"
+	"gorm.io/gorm"
 
 	"bridge-history-api/config"
-	"bridge-history-api/db"
 	"bridge-history-api/utils"
 )
 
@@ -22,7 +22,7 @@ import (
 type MsgFetcher struct {
 	ctx           context.Context
 	config        *config.LayerConfig
-	db            db.OrmFactory
+	db            *gorm.DB
 	client        *ethclient.Client
 	worker        *FetchEventWorker
 	reorgHandling ReorgHandling
@@ -34,7 +34,7 @@ type MsgFetcher struct {
 }
 
 // NewMsgFetcher creates a new MsgFetcher instance
-func NewMsgFetcher(ctx context.Context, config *config.LayerConfig, db db.OrmFactory, client *ethclient.Client, worker *FetchEventWorker, addressList []common.Address, reorg ReorgHandling) (*MsgFetcher, error) {
+func NewMsgFetcher(ctx context.Context, config *config.LayerConfig, db *gorm.DB, client *ethclient.Client, worker *FetchEventWorker, addressList []common.Address, reorg ReorgHandling) (*MsgFetcher, error) {
 	msgFetcher := &MsgFetcher{
 		ctx:           ctx,
 		config:        config,
@@ -120,22 +120,23 @@ func (c *MsgFetcher) forwardFetchAndSaveMissingEvents(confirmation uint64) {
 		log.Error(fmt.Sprintf("%s: invalid get/fetch function", c.worker.Name))
 		return
 	}
-	processedHeight, err := c.worker.G(c.db)
+	processedHeight, err := c.worker.G(c.ctx, 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", processedHeight)
-	if processedHeight <= 0 || processedHeight < int64(c.config.StartHeight) {
-		processedHeight = int64(c.config.StartHeight)
+	if processedHeight <= 0 || processedHeight < c.config.StartHeight {
+		processedHeight = c.config.StartHeight
 	} else {
 		processedHeight++
 	}
-	for from := processedHeight; from <= int64(number); from += fetchLimit {
+	for from := processedHeight; from <= number; from += fetchLimit {
 		to := from + fetchLimit - 1
-		if to > int64(number) {
-			to = int64(number)
+		if to > number {
+			to = number
 		}
-		err := c.worker.F(c.ctx, c.client, c.db, from, to, c.addressList)
+		// watch for overflow here, tho its unlikely to happen
+		err := c.worker.F(c.ctx, c.client, c.db, int64(from), int64(to), c.addressList)
 		if err != nil {
 			log.Error(fmt.Sprintf("%s: failed!", c.worker.Name), "err", err)
 			break
@@ -191,7 +192,7 @@ func (c *MsgFetcher) fetchMissingLatestHeaders() {
 					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
-				err = c.reorgHandling(c.ctx, int64(num), c.db)
+				err = c.reorgHandling(c.ctx, num, c.db)
 				// if handling success then we can update the cachedHeaders
 				if err == nil {
 					c.cachedHeaders = c.cachedHeaders[:0]
@@ -200,7 +201,7 @@ func (c *MsgFetcher) fetchMissingLatestHeaders() {
 				c.reorgEndCh <- struct{}{}
 				return
 			}
-			err = c.reorgHandling(c.ctx, c.cachedHeaders[index].Number.Int64(), c.db)
+			err = c.reorgHandling(c.ctx, c.cachedHeaders[index].Number.Uint64(), c.db)
 			// if handling success then we can update the cachedHeaders
 			if err == nil {
 				c.cachedHeaders = c.cachedHeaders[:index+1]

bridge-history-api/crossmsg/fetch_missing_event.go

@@ -8,23 +8,24 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
 
 	backendabi "bridge-history-api/abi"
-	"bridge-history-api/db"
+	"bridge-history-api/orm"
 	"bridge-history-api/utils"
 )
 
 // Todo : read from config
 var (
 	// the number of blocks fetch per round
-	fetchLimit = int64(3000)
+	fetchLimit = uint64(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
+type FetchAndSave func(ctx context.Context, client *ethclient.Client, database *gorm.DB, 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 GetLatestProcessed func(ctx context.Context, db *gorm.DB) (uint64, error)
 
 // FetchEventWorker defines worker with fetch and save function, processed number getter, and name
 type FetchEventWorker struct {
@@ -34,13 +35,15 @@ type FetchEventWorker struct {
 }
 
 // GetLatestL1ProcessedHeight get L1 the latest processed height
-func GetLatestL1ProcessedHeight(db db.OrmFactory) (int64, error) {
-	crossHeight, err := db.GetLatestL1ProcessedHeight()
+func GetLatestL1ProcessedHeight(ctx context.Context, db *gorm.DB) (uint64, error) {
+	l1CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
+	crossHeight, err := l1CrossMsgOrm.GetLatestL1ProcessedHeight(ctx)
 	if err != nil {
 		log.Error("failed to get L1 cross message processed height: ", "err", err)
 		return 0, err
 	}
-	relayedHeight, err := db.GetLatestRelayedHeightOnL1()
+	relayedHeight, err := relayedOrm.GetLatestRelayedHeightOnL1(ctx)
 	if err != nil {
 		log.Error("failed to get L1 relayed message processed height: ", "err", err)
 		return 0, err
@@ -52,18 +55,21 @@ func GetLatestL1ProcessedHeight(db db.OrmFactory) (int64, error) {
 }
 
 // GetLatestL2ProcessedHeight get L2 latest processed height
-func GetLatestL2ProcessedHeight(db db.OrmFactory) (int64, error) {
-	crossHeight, err := db.GetLatestL2ProcessedHeight()
+func GetLatestL2ProcessedHeight(ctx context.Context, db *gorm.DB) (uint64, error) {
+	l2CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
+	l2SentMsgOrm := orm.NewL2SentMsg(db)
+	crossHeight, err := l2CrossMsgOrm.GetLatestL2ProcessedHeight(ctx)
 	if err != nil {
 		log.Error("failed to get L2 cross message processed height", "err", err)
 		return 0, err
 	}
-	relayedHeight, err := db.GetLatestRelayedHeightOnL2()
+	relayedHeight, err := relayedOrm.GetLatestRelayedHeightOnL2(ctx)
 	if err != nil {
 		log.Error("failed to get L2 relayed message processed height", "err", err)
 		return 0, err
 	}
-	l2SentHeight, err := db.GetLatestSentMsgHeightOnL2()
+	l2SentHeight, err := l2SentMsgOrm.GetLatestSentMsgHeightOnL2(ctx)
 	if err != nil {
 		log.Error("failed to get L2 sent message processed height", "err", err)
 		return 0, err
@@ -79,7 +85,9 @@ func GetLatestL2ProcessedHeight(db db.OrmFactory) (int64, error) {
 }
 
 // L1FetchAndSaveEvents fetch and save events on L1
-func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addrList []common.Address) error {
+func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, db *gorm.DB, from int64, to int64, addrList []common.Address) error {
+	l1CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
 	query := geth.FilterQuery{
 		FromBlock: big.NewInt(from), // inclusive
 		ToBlock:   big.NewInt(to),   // inclusive
@@ -105,41 +113,28 @@ func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 		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 {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+	err = db.Transaction(func(tx *gorm.DB) error {
+		if txErr := l1CrossMsgOrm.InsertL1CrossMsg(ctx, depositL1CrossMsgs, tx); txErr != nil {
+			log.Error("l1FetchAndSaveEvents: Failed to insert cross msg event logs", "err", txErr)
+			return txErr
 		}
-		log.Crit("l1FetchAndSaveEvents: Failed to insert cross msg event logs", "err", err)
-	}
-
-	err = database.BatchInsertRelayedMsgDBTx(dbTx, relayedMsg)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if txErr := relayedOrm.InsertRelayedMsg(ctx, relayedMsg, tx); txErr != nil {
+			log.Error("l1FetchAndSaveEvents: Failed to insert relayed msg event logs", "err", txErr)
+			return txErr
 		}
-		log.Crit("l1FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
-	}
-	err = dbTx.Commit()
+		return nil
+	})
 	if err != nil {
-		// if we can not insert into DB, there must something wrong, need a on-call member handle the dababase manually
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("l1FetchAndSaveEvents: Failed to commit db transaction", "err", err)
-		return err
+		log.Crit("l2FetchAndSaveEvents: Failed to finish transaction", "err", err)
 	}
-
-	return nil
+	return err
 }
 
 // L2FetchAndSaveEvents fetche and save events on L2
-func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addrList []common.Address) error {
+func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, db *gorm.DB, from int64, to int64, addrList []common.Address) error {
+	l2CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
+	l2SentMsgOrm := orm.NewL2SentMsg(db)
 	query := geth.FilterQuery{
 		FromBlock: big.NewInt(from), // inclusive
 		ToBlock:   big.NewInt(to),   // inclusive
@@ -166,50 +161,32 @@ func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 		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 {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+	err = db.Transaction(func(tx *gorm.DB) error {
+		if txErr := l2CrossMsgOrm.InsertL2CrossMsg(ctx, depositL2CrossMsgs, tx); txErr != nil {
+			log.Error("l2FetchAndSaveEvents: Failed to insert cross msg event logs", "err", txErr)
+			return txErr
 		}
-		log.Crit("l2FetchAndSaveEvents: Failed to insert cross msg event logs", "err", err)
-	}
 
-	err = database.BatchInsertRelayedMsgDBTx(dbTx, relayedMsg)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if txErr := relayedOrm.InsertRelayedMsg(ctx, relayedMsg, tx); txErr != nil {
+			log.Error("l2FetchAndSaveEvents: Failed to insert relayed message event logs", "err", txErr)
+			return txErr
 		}
-		log.Crit("l2FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
-	}
 
-	err = database.BatchInsertL2SentMsgDBTx(dbTx, l2SentMsgs)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if txErr := l2SentMsgOrm.InsertL2SentMsg(ctx, l2SentMsgs, tx); txErr != nil {
+			log.Error("l2FetchAndSaveEvents: Failed to insert l2 sent message", "err", txErr)
+			return txErr
 		}
-		log.Crit("l2FetchAndSaveEvents: Failed to insert l2 sent message", "err", err)
-	}
-
-	err = dbTx.Commit()
+		return nil
+	})
 	if err != nil {
-		// if we can not insert into DB, there must something wrong, need a on-call member handle the dababase manually
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("l2FetchAndSaveEvents: Failed to commit db transaction", "err", err)
-		return err
+		log.Crit("l2FetchAndSaveEvents: Failed to begin db transaction", "err", err)
 	}
-
-	return nil
+	return err
 }
 
 // FetchAndSaveBatchIndex fetche and save batch index
-func FetchAndSaveBatchIndex(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, scrollChainAddr common.Address) error {
+func FetchAndSaveBatchIndex(ctx context.Context, client *ethclient.Client, db *gorm.DB, from int64, to int64, scrollChainAddr common.Address) error {
+	rollupBatchOrm := orm.NewRollupBatch(db)
 	query := geth.FilterQuery{
 		FromBlock: big.NewInt(from), // inclusive
 		ToBlock:   big.NewInt(to),   // inclusive
@@ -228,26 +205,9 @@ func FetchAndSaveBatchIndex(ctx context.Context, client *ethclient.Client, datab
 		log.Error("FetchAndSaveBatchIndex: Failed to parse batch commit msg event logs", "err", err)
 		return err
 	}
-	dbTx, err := database.Beginx()
-	if err != nil {
-		log.Error("FetchAndSaveBatchIndex: Failed to begin db transaction", "err", err)
-		return err
-	}
-	err = database.BatchInsertRollupBatchDBTx(dbTx, rollupBatches)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("FetchAndSaveBatchIndex: Failed to insert batch commit msg event logs", "err", 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
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("FetchAndSaveBatchIndex: Failed to commit db transaction", "err", err)
-		return err
+	if txErr := rollupBatchOrm.InsertRollupBatch(ctx, rollupBatches); txErr != nil {
+		log.Crit("FetchAndSaveBatchIndex: Failed to insert batch commit msg event logs", "err", txErr)
+		return txErr
 	}
 	return nil
 }

bridge-history-api/crossmsg/messageproof/msg_proof_updater.go

@@ -2,30 +2,32 @@ package messageproof
 
 import (
 	"context"
-	"database/sql"
-	"errors"
 	"fmt"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
 
-	"bridge-history-api/db"
-	"bridge-history-api/db/orm"
+	"bridge-history-api/orm"
 )
 
 // MsgProofUpdater is used to update message proof in db
 type MsgProofUpdater struct {
 	ctx          context.Context
-	db           db.OrmFactory
+	db           *gorm.DB
+	l2SentMsgOrm *orm.L2SentMsg
+	rollupOrm    *orm.RollupBatch
 	withdrawTrie *WithdrawTrie
 }
 
 // NewMsgProofUpdater new MsgProofUpdater instance
-func NewMsgProofUpdater(ctx context.Context, confirmations uint64, startBlock uint64, db db.OrmFactory) *MsgProofUpdater {
+func NewMsgProofUpdater(ctx context.Context, confirmations uint64, startBlock uint64, db *gorm.DB) *MsgProofUpdater {
 	return &MsgProofUpdater{
 		ctx:          ctx,
 		db:           db,
+		l2SentMsgOrm: orm.NewL2SentMsg(db),
+		rollupOrm:    orm.NewRollupBatch(db),
 		withdrawTrie: NewWithdrawTrie(),
 	}
 }
@@ -42,7 +44,7 @@ func (m *MsgProofUpdater) Start() {
 				tick.Stop()
 				return
 			case <-tick.C:
-				latestBatch, err := m.db.GetLatestRollupBatch()
+				latestBatch, err := m.rollupOrm.GetLatestRollupBatch(m.ctx)
 				if err != nil {
 					log.Warn("MsgProofUpdater: Can not get latest RollupBatch: ", "err", err)
 					continue
@@ -50,7 +52,7 @@ func (m *MsgProofUpdater) Start() {
 				if latestBatch == nil {
 					continue
 				}
-				latestBatchIndexWithProof, err := m.db.GetLatestL2SentMsgBatchIndex()
+				latestBatchIndexWithProof, err := m.l2SentMsgOrm.GetLatestL2SentMsgBatchIndex(m.ctx)
 				if err != nil {
 					log.Error("MsgProofUpdater: Can not get latest L2SentMsgBatchIndex: ", "err", err)
 					continue
@@ -62,7 +64,7 @@ func (m *MsgProofUpdater) Start() {
 					start = uint64(latestBatchIndexWithProof) + 1
 				}
 				for i := start; i <= latestBatch.BatchIndex; i++ {
-					batch, err := m.db.GetRollupBatchByIndex(i)
+					batch, err := m.rollupOrm.GetRollupBatchByIndex(m.ctx, i)
 					if err != nil {
 						log.Error("MsgProofUpdater: Can not get RollupBatch: ", "err", err, "index", i)
 						break
@@ -73,8 +75,16 @@ func (m *MsgProofUpdater) Start() {
 						log.Error("MsgProofUpdater: can not append l2messages", "startBlockNumber", batch.StartBlockNumber, "endBlockNumber", batch.EndBlockNumber, "err", err)
 						break
 					}
+					// here we update batch withdraw root
+					err = m.rollupOrm.UpdateRollupBatchWithdrawRoot(m.ctx, batch.BatchIndex, m.withdrawTrie.MessageRoot().Hex())
+					if err != nil {
+						// if failed better restart the binary
+						log.Error("MsgProofUpdater: can not update batch withdraw root", "err", err)
+						break
+					}
 					err = m.updateMsgProof(msgs, proofs, batch.BatchIndex)
 					if err != nil {
+						// if failed better restart the binary
 						log.Error("MsgProofUpdater: can not update msg proof", "err", err)
 						break
 					}
@@ -111,8 +121,8 @@ func (m *MsgProofUpdater) initialize(ctx context.Context) {
 
 func (m *MsgProofUpdater) initializeWithdrawTrie() error {
 	var batch *orm.RollupBatch
-	firstMsg, err := m.db.GetL2SentMessageByNonce(0)
-	if err != nil && !errors.Is(err, sql.ErrNoRows) {
+	firstMsg, err := m.l2SentMsgOrm.GetL2SentMessageByNonce(m.ctx, 0)
+	if err != nil {
 		return fmt.Errorf("failed to get first l2 message: %v", err)
 	}
 	// no l2 message
@@ -123,7 +133,7 @@ func (m *MsgProofUpdater) initializeWithdrawTrie() error {
 	}
 
 	// if no batch, return and wait for next try round
-	batch, err = m.db.GetLatestRollupBatch()
+	batch, err = m.rollupOrm.GetLatestRollupBatch(m.ctx)
 	if err != nil {
 		return fmt.Errorf("failed to get latest batch: %v", err)
 	}
@@ -135,7 +145,7 @@ func (m *MsgProofUpdater) initializeWithdrawTrie() error {
 	batchIndex := batch.BatchIndex
 	for {
 		var msg *orm.L2SentMsg
-		msg, err = m.db.GetLatestL2SentMsgLEHeight(batch.EndBlockNumber)
+		msg, err = m.l2SentMsgOrm.GetLatestL2SentMsgLEHeight(m.ctx, batch.EndBlockNumber)
 		if err != nil {
 			log.Warn("failed to get l2 sent message less than height", "endBlocknum", batch.EndBlockNumber, "err", err)
 		}
@@ -159,8 +169,8 @@ func (m *MsgProofUpdater) initializeWithdrawTrie() error {
 		// iterate for next batch
 		batchIndex--
 
-		batch, err = m.db.GetRollupBatchByIndex(batchIndex)
-		if err != nil {
+		batch, err = m.rollupOrm.GetRollupBatchByIndex(m.ctx, batchIndex)
+		if err != nil || batch == nil {
 			return fmt.Errorf("failed to get block batch %v: %v", batchIndex, err)
 		}
 	}
@@ -172,7 +182,10 @@ func (m *MsgProofUpdater) initializeWithdrawTrie() error {
 		if err != nil {
 			return err
 		}
-
+		err = m.rollupOrm.UpdateRollupBatchWithdrawRoot(m.ctx, b.BatchIndex, m.withdrawTrie.MessageRoot().Hex())
+		if err != nil {
+			return err
+		}
 		err = m.updateMsgProof(msgs, proofs, b.BatchIndex)
 		if err != nil {
 			return err
@@ -191,36 +204,26 @@ func (m *MsgProofUpdater) updateMsgProof(msgs []*orm.L2SentMsg, proofs [][]byte,
 	if len(msgs) != len(proofs) {
 		return fmt.Errorf("illegal state: len(msgs) != len(proofs)")
 	}
-	dbTx, err := m.db.Beginx()
+	err := m.db.Transaction(func(tx *gorm.DB) error {
+		for i, msg := range msgs {
+			proofHex := common.Bytes2Hex(proofs[i])
+			log.Debug("updateMsgProof", "msgHash", msg.MsgHash, "batchIndex", batchIndex, "proof", proofHex)
+			if err := m.l2SentMsgOrm.UpdateL2MessageProof(m.ctx, msg.MsgHash, proofHex, batchIndex, tx); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
 	if err != nil {
 		return err
 	}
-
-	for i, msg := range msgs {
-		proofHex := common.Bytes2Hex(proofs[i])
-		log.Debug("updateMsgProof", "msgHash", msg.MsgHash, "batchIndex", batchIndex, "proof", proofHex)
-		if dbTxErr := m.db.UpdateL2MessageProofInDBTx(m.ctx, dbTx, msg.MsgHash, proofHex, batchIndex); dbTxErr != nil {
-			if err := dbTx.Rollback(); err != nil {
-				log.Error("dbTx.Rollback()", "err", err)
-			}
-			return dbTxErr
-		}
-	}
-
-	if dbTxErr := dbTx.Commit(); dbTxErr != nil {
-		if err := dbTx.Rollback(); err != nil {
-			log.Error("dbTx.Rollback()", "err", err)
-		}
-		return dbTxErr
-	}
-
 	return nil
 }
 
 // appendL2Messages will append all messages between firstBlock and lastBlock (both inclusive) to withdrawTrie and compute corresponding merkle proof of each message.
 func (m *MsgProofUpdater) appendL2Messages(firstBlock, lastBlock uint64) ([]*orm.L2SentMsg, [][]byte, error) {
 	var msgProofs [][]byte
-	messages, err := m.db.GetL2SentMsgMsgHashByHeightRange(firstBlock, lastBlock)
+	messages, err := m.l2SentMsgOrm.GetL2SentMsgMsgHashByHeightRange(m.ctx, firstBlock, lastBlock)
 	if err != nil {
 		log.Error("GetL2SentMsgMsgHashByHeightRange failed", "error", err, "firstBlock", firstBlock, "lastBlock", lastBlock)
 		return messages, msgProofs, err

bridge-history-api/crossmsg/reorg_handle.go

@@ -6,12 +6,13 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
 
-	"bridge-history-api/db"
+	"bridge-history-api/orm"
 )
 
 // ReorgHandling handles reorg function type
-type ReorgHandling func(ctx context.Context, reorgHeight int64, db db.OrmFactory) error
+type ReorgHandling func(ctx context.Context, reorgHeight uint64, db *gorm.DB) error
 
 func reverseArray(arr []*types.Header) []*types.Header {
 	for i := 0; i < len(arr)/2; i++ {
@@ -60,73 +61,48 @@ func BackwardFindReorgBlock(ctx context.Context, headers []*types.Header, client
 }
 
 // L1ReorgHandling handles l1 reorg
-func L1ReorgHandling(ctx context.Context, reorgHeight int64, db db.OrmFactory) error {
-	dbTx, err := db.Beginx()
-	if err != nil {
-		log.Crit("begin db tx failed", "err", err)
-	}
-	err = db.DeleteL1CrossMsgAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+func L1ReorgHandling(ctx context.Context, reorgHeight uint64, db *gorm.DB) error {
+	l1CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
+	err := db.Transaction(func(tx *gorm.DB) error {
+		if err := l1CrossMsgOrm.DeleteL1CrossMsgAfterHeight(ctx, reorgHeight, tx); err != nil {
+			log.Error("delete l1 cross msg from height", "height", reorgHeight, "err", err)
+			return err
 		}
-		log.Crit("delete l1 cross msg from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL1RelayedHashAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if err := relayedOrm.DeleteL1RelayedHashAfterHeight(ctx, reorgHeight, tx); err != nil {
+			log.Error("delete l1 relayed msg from height", "height", reorgHeight, "err", err)
+			return err
 		}
-		log.Crit("delete l1 relayed hash from height", "height", reorgHeight, "err", err)
-	}
-	err = dbTx.Commit()
+		return nil
+	})
 	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("commit tx failed", "err", err)
-		return err
+		log.Crit("l1 reorg handling failed", "err", err)
 	}
-	return nil
+	return err
 }
 
 // L2ReorgHandling handles l2 reorg
-func L2ReorgHandling(ctx context.Context, reorgHeight int64, db db.OrmFactory) error {
-	dbTx, err := db.Beginx()
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+func L2ReorgHandling(ctx context.Context, reorgHeight uint64, db *gorm.DB) error {
+	l2CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
+	l2SentMsgOrm := orm.NewL2SentMsg(db)
+	err := db.Transaction(func(tx *gorm.DB) error {
+		if err := l2CrossMsgOrm.DeleteL2CrossMsgFromHeight(ctx, reorgHeight, tx); err != nil {
+			log.Error("delete l2 cross msg from height", "height", reorgHeight, "err", err)
+			return err
 		}
-		log.Crit("begin db tx failed", "err", err)
-	}
-	err = db.DeleteL2CrossMsgFromHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if err := relayedOrm.DeleteL2RelayedHashAfterHeight(ctx, reorgHeight, tx); err != nil {
+			log.Error("delete l2 relayed msg from height", "height", reorgHeight, "err", err)
+			return err
 		}
-		log.Crit("delete l2 cross msg from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL2RelayedHashAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if err := l2SentMsgOrm.DeleteL2SentMsgAfterHeight(ctx, reorgHeight, tx); err != nil {
+			log.Error("delete l2 sent msg from height", "height", reorgHeight, "err", err)
+			return err
 		}
-		log.Crit("delete l2 relayed hash from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL2SentMsgAfterHeightDBTx(dbTx, reorgHeight)
+		return nil
+	})
 	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("delete l2 sent msg from height", "height", reorgHeight, "err", err)
+		log.Crit("l2 reorg handling failed", "err", err)
 	}
-	err = dbTx.Commit()
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("commit tx failed", "err", err)
-		return err
-	}
-	return nil
+	return err
 }

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

@@ -1,71 +0,0 @@
-package orm
-
-import (
-	"database/sql"
-
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-)
-
-type rollupBatchOrm struct {
-	db *sqlx.DB
-}
-
-// RollupBatch is the struct for rollup_batch table
-type RollupBatch struct {
-	ID               uint64 `json:"id" db:"id"`
-	BatchIndex       uint64 `json:"batch_index" db:"batch_index"`
-	BatchHash        string `json:"batch_hash" db:"batch_hash"`
-	CommitHeight     uint64 `json:"commit_height" db:"commit_height"`
-	StartBlockNumber uint64 `json:"start_block_number" db:"start_block_number"`
-	EndBlockNumber   uint64 `json:"end_block_number" db:"end_block_number"`
-}
-
-// NewRollupBatchOrm create an NewRollupBatchOrm instance
-func NewRollupBatchOrm(db *sqlx.DB) RollupBatchOrm {
-	return &rollupBatchOrm{db: db}
-}
-
-func (b *rollupBatchOrm) BatchInsertRollupBatchDBTx(dbTx *sqlx.Tx, batches []*RollupBatch) error {
-	if len(batches) == 0 {
-		return nil
-	}
-	var err error
-	batchMaps := make([]map[string]interface{}, len(batches))
-	for i, batch := range batches {
-		batchMaps[i] = map[string]interface{}{
-			"commit_height":      batch.CommitHeight,
-			"batch_index":        batch.BatchIndex,
-			"batch_hash":         batch.BatchHash,
-			"start_block_number": batch.StartBlockNumber,
-			"end_block_number":   batch.EndBlockNumber,
-		}
-	}
-	_, err = dbTx.NamedExec(`insert into rollup_batch(commit_height, batch_index, batch_hash, start_block_number, end_block_number) values(:commit_height, :batch_index, :batch_hash, :start_block_number, :end_block_number);`, batchMaps)
-	if err != nil {
-		log.Error("BatchInsertRollupBatchDBTx: failed to insert batch event msgs", "err", err)
-		return err
-	}
-	return nil
-}
-
-func (b *rollupBatchOrm) GetLatestRollupBatch() (*RollupBatch, error) {
-	result := &RollupBatch{}
-	row := b.db.QueryRowx(`SELECT id, batch_index, commit_height, batch_hash, start_block_number, end_block_number FROM rollup_batch ORDER BY batch_index DESC LIMIT 1;`)
-	if err := row.StructScan(result); err != nil {
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return result, nil
-}
-
-func (b *rollupBatchOrm) GetRollupBatchByIndex(index uint64) (*RollupBatch, error) {
-	result := &RollupBatch{}
-	row := b.db.QueryRowx(`SELECT id, batch_index, batch_hash, commit_height, start_block_number, end_block_number FROM rollup_batch WHERE batch_index = $1;`, index)
-	if err := row.StructScan(result); err != nil {
-		return nil, err
-	}
-	return result, nil
-}

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

@@ -1,132 +0,0 @@
-package orm
-
-import (
-	"context"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/jmoiron/sqlx"
-)
-
-// AssetType can be ETH/ERC20/ERC1155/ERC721
-type AssetType int
-
-// MsgType can be layer1/layer2 msg
-type MsgType int
-
-func (a AssetType) String() string {
-	switch a {
-	case ETH:
-		return "ETH"
-	case ERC20:
-		return "ERC20"
-	case ERC1155:
-		return "ERC1155"
-	case ERC721:
-		return "ERC721"
-	}
-	return "Unknown Asset Type"
-}
-
-const (
-	// ETH = 0
-	ETH AssetType = iota
-	// ERC20 = 1
-	ERC20
-	// ERC721 = 2
-	ERC721
-	// ERC1155 = 3
-	ERC1155
-)
-
-const (
-	// UnknownMsg = 0
-	UnknownMsg MsgType = iota
-	// Layer1Msg = 1
-	Layer1Msg
-	// Layer2Msg = 2
-	Layer2Msg
-)
-
-// CrossMsg represents a cross message from layer 1 to layer 2
-type CrossMsg struct {
-	ID           uint64     `json:"id" db:"id"`
-	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"`
-	TokenIDs     string     `json:"token_ids" db:"token_ids"`
-	TokenAmounts string     `json:"token_amounts" db:"token_amounts"`
-	Asset        int        `json:"asset" db:"asset"`
-	MsgType      int        `json:"msg_type" db:"msg_type"`
-	Timestamp    *time.Time `json:"timestamp" db:"block_timestamp"`
-	CreatedAt    *time.Time `json:"created_at" db:"created_at"`
-	UpdatedAt    *time.Time `json:"updated_at" db:"updated_at"`
-	DeletedAt    *time.Time `json:"deleted_at" db:"deleted_at"`
-}
-
-// L1CrossMsgOrm provides operations on l1_cross_message table
-type L1CrossMsgOrm interface {
-	GetL1CrossMsgByHash(l1Hash common.Hash) (*CrossMsg, error)
-	GetL1CrossMsgsByAddress(sender common.Address) ([]*CrossMsg, error)
-	BatchInsertL1CrossMsgDBTx(dbTx *sqlx.Tx, messages []*CrossMsg) error
-	// UpdateL1CrossMsgHashDBTx 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
-	UpdateL1BlockTimestamp(height uint64, timestamp time.Time) error
-	GetL1EarliestNoBlockTimestampHeight() (uint64, error)
-}
-
-// L2CrossMsgOrm provides operations on cross_message table
-type L2CrossMsgOrm interface {
-	GetL2CrossMsgByHash(l2Hash common.Hash) (*CrossMsg, error)
-	GetL2CrossMsgByAddress(sender common.Address) ([]*CrossMsg, error)
-	BatchInsertL2CrossMsgDBTx(dbTx *sqlx.Tx, messages []*CrossMsg) error
-	// UpdateL2CrossMsgHashDBTx 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)
-	DeleteL2CrossMsgFromHeightDBTx(dbTx *sqlx.Tx, height int64) error
-	UpdateL2BlockTimestamp(height uint64, timestamp time.Time) error
-	GetL2EarliestNoBlockTimestampHeight() (uint64, error)
-	GetL2CrossMsgByMsgHashList(msgHashList []string) ([]*CrossMsg, error)
-}
-
-// RelayedMsgOrm provides operations on relayed_msg table
-type RelayedMsgOrm interface {
-	BatchInsertRelayedMsgDBTx(dbTx *sqlx.Tx, messages []*RelayedMsg) error
-	GetRelayedMsgByHash(msgHash string) (*RelayedMsg, error)
-	GetLatestRelayedHeightOnL1() (int64, error)
-	GetLatestRelayedHeightOnL2() (int64, error)
-	DeleteL1RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
-	DeleteL2RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
-}
-
-// L2SentMsgOrm provides operations on l2_sent_msg table
-type L2SentMsgOrm interface {
-	BatchInsertL2SentMsgDBTx(dbTx *sqlx.Tx, messages []*L2SentMsg) error
-	GetL2SentMsgByHash(l2Hash string) (*L2SentMsg, error)
-	GetLatestSentMsgHeightOnL2() (int64, error)
-	GetL2SentMessageByNonce(nonce uint64) (*L2SentMsg, error)
-	GetLatestL2SentMsgLEHeight(endBlockNumber uint64) (*L2SentMsg, error)
-	GetL2SentMsgMsgHashByHeightRange(startHeight, endHeight uint64) ([]*L2SentMsg, error)
-	UpdateL2MessageProofInDBTx(ctx context.Context, dbTx *sqlx.Tx, msgHash string, proof string, batchIndex uint64) error
-	GetLatestL2SentMsgBatchIndex() (int64, error)
-	GetClaimableL2SentMsgByAddressWithOffset(address string, offset int64, limit int64) ([]*L2SentMsg, error)
-	GetClaimableL2SentMsgByAddressTotalNum(address string) (uint64, error)
-	DeleteL2SentMsgAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
-}
-
-// RollupBatchOrm provides operations on rollup_batch table
-type RollupBatchOrm interface {
-	GetLatestRollupBatch() (*RollupBatch, error)
-	GetRollupBatchByIndex(index uint64) (*RollupBatch, error)
-	BatchInsertRollupBatchDBTx(dbTx *sqlx.Tx, messages []*RollupBatch) error
-}

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

@@ -1,148 +0,0 @@
-package orm
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"time"
-
-	"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) (*CrossMsg, error) {
-	result := &CrossMsg{}
-	row := l.db.QueryRowx(`SELECT * FROM cross_message WHERE layer1_hash = $1 AND msg_type = $2 AND deleted_at IS NULL;`, l1Hash.String(), Layer1Msg)
-	if err := row.StructScan(result); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return result, 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) ([]*CrossMsg, error) {
-	var results []*CrossMsg
-	rows, err := l.db.Queryx(`SELECT * FROM cross_message WHERE sender = $1 AND msg_type = 1 AND deleted_at IS NULL;`, sender.String(), Layer1Msg)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &CrossMsg{}
-		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 []*CrossMsg) 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,
-			"msg_hash":     msg.MsgHash,
-			"layer1_hash":  msg.Layer1Hash,
-			"layer1_token": msg.Layer1Token,
-			"layer2_token": msg.Layer2Token,
-			"token_ids":    msg.TokenIDs,
-			"msg_type":     Layer1Msg,
-		}
-	}
-	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, amount, asset, msg_hash, layer1_hash, layer1_token, layer2_token, token_ids, msg_type) values(:height, :sender, :target, :amount, :asset, :msg_hash, :layer1_hash, :layer1_token, :layer2_token, :token_ids, :msg_type);`, messageMaps)
-	if err != nil {
-		log.Error("BatchInsertL1CrossMsgDBTx: failed to insert l1 cross msgs", "err", err)
-		return err
-	}
-
-	return nil
-}
-
-// UpdateL1CrossMsgHashDBTx update l1 cross msg hash in db, no need to check msg_type since layer1_hash wont be empty if its layer1 msg
-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.cross_message set msg_hash = ? where layer1_hash = ? AND deleted_at IS NULL;"), 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 = ? AND deleted_at IS NULL;"), msgHash.String(), l1Hash.String()); err != nil {
-		return err
-	}
-	return nil
-
-}
-
-func (l *l1CrossMsgOrm) GetLatestL1ProcessedHeight() (int64, error) {
-	row := l.db.QueryRowx(`SELECT height FROM cross_message WHERE msg_type = $1 AND deleted_at IS NULL ORDER BY id DESC LIMIT 1;`, Layer1Msg)
-	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(`UPDATE cross_message SET deleted_at = current_timestamp WHERE height > $1 AND msg_type = $2;`, height, Layer1Msg); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l1CrossMsgOrm) UpdateL1BlockTimestamp(height uint64, timestamp time.Time) error {
-	if _, err := l.db.Exec(`UPDATE cross_message SET block_timestamp = $1 where height = $2 AND msg_type = $3 AND deleted_at IS NULL`, timestamp, height, Layer1Msg); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l1CrossMsgOrm) GetL1EarliestNoBlockTimestampHeight() (uint64, error) {
-	row := l.db.QueryRowx(`SELECT height FROM cross_message WHERE block_timestamp IS NULL AND msg_type = $1 AND deleted_at IS NULL ORDER BY height ASC LIMIT 1;`, Layer1Msg)
-	var result uint64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows {
-			return 0, nil
-		}
-		return 0, err
-	}
-	return result, nil
-}

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

@@ -1,177 +0,0 @@
-package orm
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-	"github.com/lib/pq"
-)
-
-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) (*CrossMsg, error) {
-	result := &CrossMsg{}
-	row := l.db.QueryRowx(`SELECT * FROM cross_message WHERE layer2_hash = $1 AND deleted_at IS NULL;`, l2Hash.String())
-	if err := row.StructScan(result); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return result, nil
-}
-
-// GetL2CrossMsgByAddress returns all layer2 cross messages under given address
-// Warning: return empty slice if no data found
-func (l *l2CrossMsgOrm) GetL2CrossMsgByAddress(sender common.Address) ([]*CrossMsg, error) {
-	var results []*CrossMsg
-	rows, err := l.db.Queryx(`SELECT * FROM cross_message WHERE sender = $1 AND msg_type = $2 AND deleted_at IS NULL;`, sender.String(), Layer2Msg)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &CrossMsg{}
-		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(`UPDATE cross_message SET deleted_at = current_timestamp where height > $1 AND msg_type = $2 ;`, height, Layer2Msg)
-	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 []*CrossMsg) 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,
-			"msg_hash":     msg.MsgHash,
-			"layer2_hash":  msg.Layer2Hash,
-			"layer1_token": msg.Layer1Token,
-			"layer2_token": msg.Layer2Token,
-			"token_ids":    msg.TokenIDs,
-			"amount":       msg.Amount,
-			"msg_type":     Layer2Msg,
-		}
-	}
-	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, msg_hash, layer2_hash, layer1_token, layer2_token, token_ids, amount, msg_type) values(:height, :sender, :target, :asset, :msg_hash, :layer2_hash, :layer1_token, :layer2_token, :token_ids, :amount, :msg_type);`, messageMaps)
-	if err != nil {
-		log.Error("BatchInsertL2CrossMsgDBTx: failed to insert l2 cross msgs", "err", err)
-		return err
-	}
-	return nil
-}
-
-func (l *l2CrossMsgOrm) UpdateL2CrossMsgHashDBTx(ctx context.Context, dbTx *sqlx.Tx, l2Hash, msgHash common.Hash) error {
-	if _, err := dbTx.ExecContext(ctx, l.db.Rebind("update cross_message set msg_hash = ? where layer2_hash = ? AND deleted_at IS NULL;"), 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 cross_message set msg_hash = ? where layer2_hash = ? AND deleted_at IS NULL;"), msgHash.String(), l2Hash.String()); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l2CrossMsgOrm) GetLatestL2ProcessedHeight() (int64, error) {
-	row := l.db.QueryRowx(`SELECT height FROM cross_message WHERE msg_type = $1 AND deleted_at IS NULL ORDER BY id DESC LIMIT 1;`, Layer2Msg)
-	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 *l2CrossMsgOrm) UpdateL2BlockTimestamp(height uint64, timestamp time.Time) error {
-	if _, err := l.db.Exec(`UPDATE cross_message SET block_timestamp = $1 where height = $2 AND msg_type = $3 AND deleted_at IS NULL`, timestamp, height, Layer2Msg); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l2CrossMsgOrm) GetL2EarliestNoBlockTimestampHeight() (uint64, error) {
-	row := l.db.QueryRowx(`SELECT height FROM cross_message WHERE block_timestamp IS NULL AND msg_type = $1 AND deleted_at IS NULL ORDER BY height ASC LIMIT 1;`, Layer2Msg)
-	var result uint64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows {
-			return 0, nil
-		}
-		return 0, err
-	}
-	return result, nil
-}
-
-func (l *l2CrossMsgOrm) GetL2CrossMsgByMsgHashList(msgHashList []string) ([]*CrossMsg, error) {
-	var results []*CrossMsg
-	rows, err := l.db.Queryx(`SELECT * FROM cross_message WHERE msg_hash = ANY($1) AND msg_type = $2 AND deleted_at IS NULL;`, pq.Array(msgHashList), Layer2Msg)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &CrossMsg{}
-		if err = rows.StructScan(msg); err != nil {
-			break
-		}
-		results = append(results, msg)
-	}
-	if err != nil && !errors.Is(err, sql.ErrNoRows) {
-		return nil, err
-	}
-	if len(results) == 0 {
-		log.Debug("no L2CrossMsg under given msg hashes", "msg hash list", msgHashList)
-	}
-	return results, nil
-}

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

@@ -1,189 +0,0 @@
-package orm
-
-import (
-	"context"
-	"database/sql"
-	"time"
-
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-)
-
-// L2SentMsg defines the struct for l2_sent_msg table record
-type L2SentMsg struct {
-	ID             uint64     `json:"id" db:"id"`
-	OriginalSender string     `json:"original_sender" db:"original_sender"`
-	TxHash         string     `json:"tx_hash" db:"tx_hash"`
-	MsgHash        string     `json:"msg_hash" db:"msg_hash"`
-	Sender         string     `json:"sender" db:"sender"`
-	Target         string     `json:"target" db:"target"`
-	Value          string     `json:"value" db:"value"`
-	Height         uint64     `json:"height" db:"height"`
-	Nonce          uint64     `json:"nonce" db:"nonce"`
-	BatchIndex     uint64     `json:"batch_index" db:"batch_index"`
-	MsgProof       string     `json:"msg_proof" db:"msg_proof"`
-	MsgData        string     `json:"msg_data" db:"msg_data"`
-	CreatedAt      *time.Time `json:"created_at" db:"created_at"`
-	UpdatedAt      *time.Time `json:"updated_at" db:"updated_at"`
-	DeletedAt      *time.Time `json:"deleted_at" db:"deleted_at"`
-}
-
-type l2SentMsgOrm struct {
-	db *sqlx.DB
-}
-
-// NewL2SentMsgOrm create an NewRollupBatchOrm instance
-func NewL2SentMsgOrm(db *sqlx.DB) L2SentMsgOrm {
-	return &l2SentMsgOrm{db: db}
-}
-
-func (l *l2SentMsgOrm) GetL2SentMsgByHash(msgHash string) (*L2SentMsg, error) {
-	result := &L2SentMsg{}
-	row := l.db.QueryRowx(`SELECT * FROM l2_sent_msg WHERE msg_hash = $1 AND deleted_at IS NULL;`, msgHash)
-	if err := row.StructScan(result); err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (l *l2SentMsgOrm) BatchInsertL2SentMsgDBTx(dbTx *sqlx.Tx, messages []*L2SentMsg) 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{}{
-			"original_sender": msg.OriginalSender,
-			"tx_hash":         msg.TxHash,
-			"sender":          msg.Sender,
-			"target":          msg.Target,
-			"value":           msg.Value,
-			"msg_hash":        msg.MsgHash,
-			"height":          msg.Height,
-			"nonce":           msg.Nonce,
-			"batch_index":     msg.BatchIndex,
-			"msg_proof":       msg.MsgProof,
-			"msg_data":        msg.MsgData,
-		}
-	}
-	_, err = dbTx.NamedExec(`insert into l2_sent_msg(original_sender, tx_hash, sender, target, value, msg_hash, height, nonce, batch_index, msg_proof, msg_data) values(:original_sender, :tx_hash, :sender, :target, :value, :msg_hash, :height, :nonce, :batch_index, :msg_proof, :msg_data);`, messageMaps)
-	if err != nil {
-		log.Error("BatchInsertL2SentMsgDBTx: failed to insert l2 sent msgs", "err", err)
-		return err
-	}
-	return err
-}
-
-func (l *l2SentMsgOrm) GetLatestSentMsgHeightOnL2() (int64, error) {
-	row := l.db.QueryRow(`SELECT height FROM l2_sent_msg WHERE deleted_at IS NULL ORDER BY nonce DESC LIMIT 1;`)
-	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 *l2SentMsgOrm) UpdateL2MessageProofInDBTx(ctx context.Context, dbTx *sqlx.Tx, msgHash string, proof string, batchIndex uint64) error {
-	if _, err := dbTx.ExecContext(ctx, l.db.Rebind("update l2_sent_msg set msg_proof = ?, batch_index = ? where msg_hash = ? AND deleted_at IS NULL;"), proof, batchIndex, msgHash); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l2SentMsgOrm) GetLatestL2SentMsgBatchIndex() (int64, error) {
-	row := l.db.QueryRow(`SELECT batch_index FROM l2_sent_msg WHERE batch_index != 0 AND deleted_at IS NULL ORDER BY batch_index DESC LIMIT 1;`)
-	var result sql.NullInt64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows || !result.Valid {
-			return -1, nil
-		}
-		return -1, err
-	}
-	if result.Valid {
-		return result.Int64, nil
-	}
-	return -1, nil
-}
-
-func (l *l2SentMsgOrm) GetL2SentMsgMsgHashByHeightRange(startHeight, endHeight uint64) ([]*L2SentMsg, error) {
-	var results []*L2SentMsg
-	rows, err := l.db.Queryx(`SELECT * FROM l2_sent_msg WHERE height >= $1 AND height <= $2 AND deleted_at IS NULL ORDER BY nonce ASC;`, startHeight, endHeight)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &L2SentMsg{}
-		if err = rows.StructScan(msg); err != nil {
-			break
-		}
-		results = append(results, msg)
-	}
-	return results, err
-}
-
-func (l *l2SentMsgOrm) GetL2SentMessageByNonce(nonce uint64) (*L2SentMsg, error) {
-	result := &L2SentMsg{}
-	row := l.db.QueryRowx(`SELECT * FROM l2_sent_msg WHERE nonce = $1 AND deleted_at IS NULL;`, nonce)
-	err := row.StructScan(result)
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (l *l2SentMsgOrm) GetLatestL2SentMsgLEHeight(endBlockNumber uint64) (*L2SentMsg, error) {
-	result := &L2SentMsg{}
-	row := l.db.QueryRowx(`select * from l2_sent_msg where height <= $1 AND deleted_at IS NULL order by nonce desc limit 1`, endBlockNumber)
-	err := row.StructScan(result)
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (l *l2SentMsgOrm) DeleteL2SentMsgAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error {
-	_, err := dbTx.Exec(`UPDATE l2_sent_msg SET deleted_at = current_timestamp WHERE height > $1;`, height)
-	return err
-}
-
-func (l *l2SentMsgOrm) GetClaimableL2SentMsgByAddressWithOffset(address string, offset int64, limit int64) ([]*L2SentMsg, error) {
-	var results []*L2SentMsg
-	rows, err := l.db.Queryx(`SELECT * FROM l2_sent_msg WHERE id NOT IN (SELECT l2_sent_msg.id FROM l2_sent_msg INNER JOIN relayed_msg ON l2_sent_msg.msg_hash = relayed_msg.msg_hash WHERE l2_sent_msg.deleted_at IS NULL AND relayed_msg.deleted_at IS NULL) AND (original_sender=$1 OR sender = $1) ORDER BY id DESC LIMIT $2 OFFSET $3;`, address, limit, offset)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &L2SentMsg{}
-		if err = rows.StructScan(msg); err != nil {
-			break
-		}
-		results = append(results, msg)
-	}
-	return results, err
-}
-
-func (l *l2SentMsgOrm) GetClaimableL2SentMsgByAddressTotalNum(address string) (uint64, error) {
-	var count uint64
-	row := l.db.QueryRowx(`SELECT COUNT(*) FROM l2_sent_msg WHERE id NOT IN (SELECT l2_sent_msg.id FROM l2_sent_msg INNER JOIN relayed_msg ON l2_sent_msg.msg_hash = relayed_msg.msg_hash WHERE l2_sent_msg.deleted_at IS NULL AND relayed_msg.deleted_at IS NULL) AND (original_sender=$1 OR sender = $1);`, address)
-	if err := row.Scan(&count); err != nil {
-		return 0, err
-	}
-	return count, nil
-}

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

@@ -1,100 +0,0 @@
-package orm
-
-import (
-	"database/sql"
-	"errors"
-
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-)
-
-// RelayedMsg is the struct for relayed_msg table
-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"`
-}
-
-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)
-	if err != nil {
-		log.Error("BatchInsertRelayedMsgDBTx: failed to insert relayed msgs", "err", err)
-		return err
-	}
-	return nil
-}
-
-func (l *relayedMsgOrm) GetRelayedMsgByHash(msgHash string) (*RelayedMsg, error) {
-	result := &RelayedMsg{}
-	row := l.db.QueryRowx(`SELECT msg_hash, height, layer1_hash, layer2_hash FROM relayed_msg WHERE msg_hash = $1 AND deleted_at IS NULL;`, msgHash)
-	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 height FROM relayed_msg WHERE layer1_hash != '' AND deleted_at IS NULL ORDER BY height DESC LIMIT 1;`)
-	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) GetLatestRelayedHeightOnL2() (int64, error) {
-	row := l.db.QueryRow(`SELECT height FROM relayed_msg WHERE layer2_hash != '' AND deleted_at IS NULL ORDER BY height DESC LIMIT 1;`)
-	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) DeleteL1RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error {
-	_, err := dbTx.Exec(`UPDATE relayed_msg SET deleted_at = current_timestamp WHERE height > $1 AND layer1_hash != '';`, height)
-	return err
-}
-
-func (l *relayedMsgOrm) DeleteL2RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error {
-	_, err := dbTx.Exec(`UPDATE relayed_msg SET deleted_at = current_timestamp WHERE height > $1 AND layer2_hash != '';`, height)
-	return err
-}

bridge-history-api/db/orm_factory.go

@@ -1,103 +0,0 @@
-package db
-
-import (
-	"database/sql"
-	"errors"
-
-	"github.com/ethereum/go-ethereum/log"
-	"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
-	orm.L2SentMsgOrm
-	orm.RollupBatchOrm
-	GetTotalCrossMsgCountByAddress(sender string) (uint64, error)
-	GetCrossMsgsByAddressWithOffset(sender string, offset int64, limit int64) ([]*orm.CrossMsg, error)
-	GetDB() *sqlx.DB
-	Beginx() (*sqlx.Tx, error)
-	Close() error
-}
-
-type ormFactory struct {
-	orm.L1CrossMsgOrm
-	orm.L2CrossMsgOrm
-	orm.RelayedMsgOrm
-	orm.L2SentMsgOrm
-	orm.RollupBatchOrm
-	*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),
-		L2SentMsgOrm:   orm.NewL2SentMsgOrm(db),
-		RollupBatchOrm: orm.NewRollupBatchOrm(db),
-		DB:             db,
-	}, nil
-}
-
-func (o *ormFactory) GetDB() *sqlx.DB {
-	return o.DB
-}
-
-func (o *ormFactory) Beginx() (*sqlx.Tx, error) {
-	return o.DB.Beginx()
-}
-
-func (o *ormFactory) GetTotalCrossMsgCountByAddress(sender string) (uint64, error) {
-	var count uint64
-	row := o.DB.QueryRowx(`SELECT COUNT(*) FROM cross_message WHERE sender = $1 AND deleted_at IS NULL;`, sender)
-	if err := row.Scan(&count); err != nil {
-		return 0, err
-	}
-	return count, nil
-}
-
-func (o *ormFactory) GetCrossMsgsByAddressWithOffset(sender string, offset int64, limit int64) ([]*orm.CrossMsg, error) {
-	para := sender
-	var results []*orm.CrossMsg
-	rows, err := o.DB.Queryx(`SELECT * FROM cross_message WHERE sender = $1 AND deleted_at IS NULL ORDER BY block_timestamp DESC NULLS FIRST, id DESC LIMIT $2 OFFSET $3;`, para, limit, offset)
-	if err != nil || rows == nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &orm.CrossMsg{}
-		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
-}

bridge-history-api/go.mod

@@ -4,34 +4,28 @@ go 1.19
 
 require (
 	github.com/ethereum/go-ethereum v1.12.0
-	github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458
-	github.com/jmoiron/sqlx v1.3.5
-	github.com/kataras/iris/v12 v12.2.0
-	github.com/lib/pq v1.10.7
+	github.com/gin-contrib/cors v1.4.0
+	github.com/gin-gonic/gin v1.9.1
 	github.com/mattn/go-colorable v0.1.13
 	github.com/mattn/go-isatty v0.0.19
 	github.com/modern-go/reflect2 v1.0.2
 	github.com/pressly/goose/v3 v3.7.0
 	github.com/stretchr/testify v1.8.3
 	github.com/urfave/cli/v2 v2.25.7
+	gorm.io/driver/postgres v1.5.0
+	gorm.io/gorm v1.25.2
 )
 
 require (
-	github.com/BurntSushi/toml v1.3.2 // 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/bits-and-blooms/bitset v1.7.0 // indirect
-	github.com/blang/semver/v4 v4.0.0 // indirect
 	github.com/btcsuite/btcd v0.20.1-beta // indirect
 	github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
+	github.com/bytedance/sonic v1.9.2 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // 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
@@ -44,28 +38,26 @@ require (
 	github.com/deckarep/golang-set/v2 v2.1.0 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
 	github.com/deepmap/oapi-codegen v1.8.2 // indirect
-	github.com/docker/docker v20.10.21+incompatible // indirect
-	github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385 // indirect
+	github.com/docker/docker v23.0.6+incompatible // indirect
 	github.com/ethereum/c-kzg-4844 v0.2.0 // 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/gabriel-vasile/mimetype v1.4.2 // indirect
 	github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect
 	github.com/getsentry/sentry-go v0.18.0 // indirect
+	github.com/gin-contrib/sse v0.1.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-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.14.1 // 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/goccy/go-json v0.10.2 // indirect
 	github.com/gofrs/flock v0.8.1 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang-jwt/jwt/v4 v4.5.0 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
 	github.com/google/uuid v1.3.0 // indirect
-	github.com/gorilla/css v1.0.0 // indirect
 	github.com/gorilla/websocket v1.5.0 // indirect
 	github.com/graph-gophers/graphql-go v1.3.0 // indirect
 	github.com/hashicorp/go-bexpr v0.1.10 // indirect
@@ -75,36 +67,29 @@ require (
 	github.com/influxdata/influxdb-client-go/v2 v2.4.0 // indirect
 	github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c // indirect
 	github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect
-	github.com/iris-contrib/go.uuid v2.0.0+incompatible // indirect
-	github.com/iris-contrib/schema v0.0.6 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/pgx/v5 v5.3.1 // 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/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/compress v1.16.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // 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/leodido/go-urn v1.2.4 // 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/mmcloughlin/addchain v0.4.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/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // 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/pelletier/go-toml/v2 v2.0.8 // 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
@@ -116,24 +101,18 @@ require (
 	github.com/rogpeppe/go-internal v1.10.0 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/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/supranational/blst v0.3.11-0.20230406105308-e9dfc5ee724b // 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/twitchyliquid64/golang-asm v0.15.1 // 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/ugorji/go/codec v1.2.11 // 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/arch v0.4.0 // indirect
 	golang.org/x/crypto v0.11.0 // indirect
 	golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect
 	golang.org/x/net v0.12.0 // indirect
@@ -142,9 +121,7 @@ require (
 	golang.org/x/text v0.11.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
 	golang.org/x/tools v0.11.0 // indirect
-	golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df // indirect
 	google.golang.org/protobuf v1.31.0 // indirect
-	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect

bridge-history-api/go.sum

@@ -2,40 +2,24 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT
 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.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
-github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
-github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53 h1:sR+/8Yb4slttB4vD+b9btVEnWgL3Q00OBTzVT8B9C0c=
 github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53/go.mod h1:+3IMCy2vIlbG1XG/0ggNQv0SvxCAIpPM5b1nCz56Xno=
 github.com/CloudyKit/jet/v3 v3.0.0/go.mod h1:HKQPgSJmdK8hdoAbKUUWajkHyHo4RaU5rMdUywE7VMo=
-github.com/CloudyKit/jet/v6 v6.2.0 h1:EpcZ6SR9n28BUGtNJSvlBqf90IpjeFr36Tizxhn/oME=
-github.com/CloudyKit/jet/v6 v6.2.0/go.mod h1:d3ypHeIRNo2+XyqnGA8s+aphtcVpjP5hPwP/Lzo7Ro4=
 github.com/DataDog/zstd v1.5.2 h1:vUG4lAyuPCXO0TLbXvPv7EB7cNK1QV/luu55UHLrrn8=
 github.com/DataDog/zstd v1.5.2/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw=
-github.com/Joker/hpp v1.0.0 h1:65+iuJYdRXv/XyN62C1uEmmOx3432rNG/rKlX6V7Kkc=
 github.com/Joker/hpp v1.0.0/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY=
-github.com/Joker/jade v1.1.3 h1:Qbeh12Vq6BxURXT1qZBRHsDxeURB8ztcL6f3EXSGeHk=
-github.com/Joker/jade v1.1.3/go.mod h1:T+2WLyt7VH6Lp0TRxQrUYEs64nRc83wkMQrfeIQKduM=
 github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0=
-github.com/Shopify/goreferrer v0.0.0-20220729165902-8cddb4f5de06 h1:KkH3I3sJuOLP3TjA/dfr4NAY8bghDwnXiU7cTKxQqo0=
-github.com/Shopify/goreferrer v0.0.0-20220729165902-8cddb4f5de06/go.mod h1:7erjKLwalezA0k99cWs5L11HWOAPNjdUZ6RxH1BXbbM=
 github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o=
 github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw=
 github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
-github.com/ajg/form v1.5.1 h1:t9c7v8JUKu/XxOGBU0yjNpaMloxGEJhUkqFRq0ibGeU=
 github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY=
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
-github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
-github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
-github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
-github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
 github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bits-and-blooms/bitset v1.7.0 h1:YjAGVd3XmtK9ktAbX8Zg2g2PwLIMjGREZJHlV4j7NEo=
 github.com/bits-and-blooms/bitset v1.7.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
-github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM=
-github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ=
 github.com/btcsuite/btcd v0.20.1-beta h1:Ik4hyJqN8Jfyv3S4AGBOmyouMsYE3EdYODkMbQjwPGw=
 github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
 github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U=
@@ -47,12 +31,17 @@ github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVa
 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/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
+github.com/bytedance/sonic v1.9.2 h1:GDaNjuWSGu09guE9Oql0MSTNhNCLlWwO8y/xM5BzcbM=
+github.com/bytedance/sonic v1.9.2/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cheekybits/is v0.0.0-20150225183255-68e9c0620927/go.mod h1:h/aW8ynjgkuj+NQRlZcDbAbM1ORAbXjXX77sX7T289U=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
 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=
@@ -96,11 +85,9 @@ github.com/deepmap/oapi-codegen v1.8.2/go.mod h1:YLgSKSDv/bZQB7N4ws6luhozi3cEdRk
 github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
-github.com/djherbis/atime v1.1.0/go.mod h1:28OF6Y8s3NQWwacXc5eZTsEsiMzp7LF8MbXE+XJPdBE=
-github.com/docker/docker v20.10.21+incompatible h1:UTLdBmHk3bEY+w8qeO5KttOhy6OmXWsl/FEet9Uswog=
-github.com/docker/docker v20.10.21+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v23.0.6+incompatible h1:aBD4np894vatVX99UTx/GyOUOK4uEcROwA3+bQhEcoU=
+github.com/docker/docker v23.0.6+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
-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=
@@ -112,17 +99,15 @@ github.com/ethereum/c-kzg-4844 v0.2.0/go.mod h1:WI2Nd82DMZAAZI1wV2neKGost9EKjvbp
 github.com/ethereum/go-ethereum v1.12.0 h1:bdnhLPtqETd4m3mS8BGMNvBTf36bO5bx/hxE2zljOa0=
 github.com/ethereum/go-ethereum v1.12.0/go.mod h1:/oo2X/dZLJjf2mJ6YT9wcWxa4nNJDBKDBU6sFIpx1Gs=
 github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=
-github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c=
 github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
-github.com/flosch/pongo2/v4 v4.0.2 h1:gv+5Pe3vaSVmiJvh/BZa82b7/00YUGm0PIyVVLop0Hw=
-github.com/flosch/pongo2/v4 v4.0.2/go.mod h1:B5ObFANs/36VwxxlgKpdchIJHMvHB562PW+BWPhwZD8=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
 github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
 github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
+github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
+github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
 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=
@@ -132,8 +117,15 @@ github.com/getsentry/sentry-go v0.12.0/go.mod h1:NSap0JBYWzHND8oMbyi0+XZhUalc1TB
 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/cors v1.4.0 h1:oJ6gwtUl3lqV0WEIwM/LxPF1QZ5qe2lGWdY2+bz7y0g=
+github.com/gin-contrib/cors v1.4.0/go.mod h1:bs9pNM0x/UsmHPBWT2xZz9ROh8xYjYkiURUfmBoMlcs=
 github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM=
+github.com/gin-gonic/gin v1.8.1/go.mod h1:ji8BvRH1azfM+SYow9zQ6SZMvR8qOMZHmsCuWR9tTTk=
+github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
 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=
@@ -143,21 +135,26 @@ github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
 github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
-github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
-github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc=
-github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.10.0/go.mod h1:74x4gJWsvQexRdW8Pn3dXSGrTK4nAUsbPlLADvpJkos=
+github.com/go-playground/validator/v10 v10.14.1 h1:9c50NUPC30zyuKprjL3vNZ0m5oG+jU0zvx4AqHGnv4k=
+github.com/go-playground/validator/v10 v10.14.1/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
 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/goccy/go-json v0.9.7/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
 github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
 github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
@@ -199,15 +196,12 @@ github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 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/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
-github.com/gorilla/css v1.0.0 h1:BQqNyPTi50JCFMTw/b67hByjMVXZRwGha6wxVGkeihY=
-github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
 github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
 github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
@@ -227,7 +221,6 @@ github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=
 github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y=
 github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
 github.com/hydrogen18/memlistener v0.0.0-20200120041712-dcc25e7acd91/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE=
-github.com/imkira/go-interpol v1.1.0 h1:KIiKr0VSG2CUW1hl1jpiyuzuJeKUUpC8iM1AIE7N1Vk=
 github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/influxdata/influxdb-client-go/v2 v2.4.0 h1:HGBfZYStlx3Kqvsv1h2pJixbCl/jhnFtxpKFAv9Tu5k=
@@ -238,48 +231,38 @@ github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839/go.mod h1
 github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 h1:vilfsDSy7TDxedi9gyBkMvAirat/oRcL0lFdJBf6tdM=
 github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
 github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI=
-github.com/iris-contrib/go.uuid v2.0.0+incompatible h1:XZubAYg61/JwnJNbZilGjf3b3pB80+OQg2qf6c8BfWE=
 github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0=
-github.com/iris-contrib/httpexpect/v2 v2.12.1 h1:3cTZSyBBen/kfjCtgNFoUKi1u0FVXNaAjyRJOo6AVS4=
 github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk=
-github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458 h1:V60rHQJc6DieKV1BqHIGclraPdO4kinuFAZIrPGHN7s=
-github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458/go.mod h1:7eVziAp1yUwFB/ZMg71n84VWQH+7wukvxcHuF2e7cbg=
 github.com/iris-contrib/pongo2 v0.0.1/go.mod h1:Ssh+00+3GAZqSQb30AvBRNxBx7rf0GqwkjqxNd0u65g=
 github.com/iris-contrib/schema v0.0.1/go.mod h1:urYA3uvUNG1TIIjOSCzHr9/LmbQo8LrOcOqfqxa4hXw=
-github.com/iris-contrib/schema v0.0.6 h1:CPSBLyx2e91H2yJzPuhGuifVRnZBBJ3pCOMbOvPZaTw=
-github.com/iris-contrib/schema v0.0.6/go.mod h1:iYszG0IOsuIsfzjymw1kMzTL8YQcCWlm65f3wX8J5iA=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.3.0/go.mod h1:t3JDKnCBlYIc0ewLF0Q7B8MXmoIaBOZj/ic7iHozM/8=
+github.com/jackc/pgx/v5 v5.3.1 h1:Fcr8QJ1ZeLi5zsPZqQeUZhNhxfkkKBOgJuYkJHoBOtU=
+github.com/jackc/pgx/v5 v5.3.1/go.mod h1:t3JDKnCBlYIc0ewLF0Q7B8MXmoIaBOZj/ic7iHozM/8=
+github.com/jackc/puddle/v2 v2.2.0/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 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/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
+github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 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/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U=
 github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k=
-github.com/kataras/blocks v0.0.7 h1:cF3RDY/vxnSRezc7vLFlQFTYXG/yAr1o7WImJuZbzC4=
-github.com/kataras/blocks v0.0.7/go.mod h1:UJIU97CluDo0f+zEjbnbkeMRlvYORtmc1304EeyXf4I=
 github.com/kataras/golog v0.0.10/go.mod h1:yJ8YKCmyL+nWjERB90Qwn+bdyBZsaQwU3bTVFgkFIp8=
-github.com/kataras/golog v0.1.8 h1:isP8th4PJH2SrbkciKnylaND9xoTtfxv++NB+DF0l9g=
-github.com/kataras/golog v0.1.8/go.mod h1:rGPAin4hYROfk1qT9wZP6VY2rsb4zzc37QpdPjdkqVw=
 github.com/kataras/iris/v12 v12.1.8/go.mod h1:LMYy4VlP67TQ3Zgriz8RE2h2kMZV2SgMYbq3UhfoFmE=
-github.com/kataras/iris/v12 v12.2.0 h1:WzDY5nGuW/LgVaFS5BtTkW3crdSKJ/FEgWnxPnIVVLI=
-github.com/kataras/iris/v12 v12.2.0/go.mod h1:BLzBpEunc41GbE68OUaQlqX4jzi791mx5HU04uPb90Y=
 github.com/kataras/neffos v0.0.14/go.mod h1:8lqADm8PnbeFfL7CLXh1WHw53dG27MC3pgi2R1rmoTE=
-github.com/kataras/neffos v0.0.21 h1:UwN/F44jlqdtgFI29y3VhA7IlJ4JbK3UjCbTDg1pYoo=
-github.com/kataras/neffos v0.0.21/go.mod h1:FeGka8lu8cjD2H+0OpBvW8c6xXawy3fj5VX6xcIJ1Fg=
 github.com/kataras/pio v0.0.2/go.mod h1:hAoW0t9UmXi4R5Oyq5Z4irTbaTsOemSrDGUtaTl7Dro=
-github.com/kataras/pio v0.0.11 h1:kqreJ5KOEXGMwHAWHDwIl+mjfNCPhAwZPa8gK7MKlyw=
-github.com/kataras/pio v0.0.11/go.mod h1:38hH6SWH6m4DKSYmRhlrCJ5WItwWgCVrTNU62XZyUvI=
 github.com/kataras/sitemap v0.0.5/go.mod h1:KY2eugMKiPwsJgx7+U103YZehfvNGOXURubcGyk0Bz8=
-github.com/kataras/sitemap v0.0.6 h1:w71CRMMKYMJh6LR2wTgnk5hSgjVNB9KL60n5e2KHvLY=
-github.com/kataras/sitemap v0.0.6/go.mod h1:dW4dOCNs896OR1HmG+dMLdT7JjDk7mYBzoIRwuj5jA4=
-github.com/kataras/tunnel v0.0.4 h1:sCAqWuJV7nPzGrlb0os3j49lk2JhILT0rID38NHNLpA=
-github.com/kataras/tunnel v0.0.4/go.mod h1:9FkU4LaeifdMWqZu7o20ojmW4B7hdhv2CMLwfnHGpYw=
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
@@ -289,7 +272,11 @@ github.com/klauspost/compress v1.9.7/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0
 github.com/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4=
 github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg=
+github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.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=
@@ -302,18 +289,13 @@ github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4F
 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/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
-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/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
-github.com/mailgun/raymond/v2 v2.0.48 h1:5dmlB680ZkFG2RN/0lvTAghrSxIESeu9/2aeDqACtjw=
-github.com/mailgun/raymond/v2 v2.0.48/go.mod h1:lsgvL50kgt1ylcFJYZiULi5fjPBkkhNfj4KA0W54Z18=
 github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
-github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/matryer/moq v0.0.0-20190312154309-6cfb0558e1bd/go.mod h1:9ELz6aaclSIGnZBoaSLZ3NAl1VTufbOrXBPvtcy6WiQ=
-github.com/matryer/try v0.0.0-20161228173917-9ac251b645a2/go.mod h1:0KeJpeMD6o+O4hW7qJOT7vyQPKrWmj26uf5wMc/IiIs=
 github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
 github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
@@ -332,21 +314,12 @@ github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzp
 github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
 github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
-github.com/mattn/go-sqlite3 v1.14.14 h1:qZgc/Rwetq+MtyE18WhzjokPD93dNqLGNT3QJuLvBGw=
-github.com/mattn/go-sqlite3 v1.14.14/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
 github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw=
 github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
 github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
 github.com/mediocregopher/radix/v3 v3.4.2/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8=
-github.com/mediocregopher/radix/v3 v3.8.1 h1:rOkHflVuulFKlwsLY01/M2cM2tWCjDoETcMqKbAWu1M=
-github.com/mediocregopher/radix/v3 v3.8.1/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8=
 github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc=
-github.com/microcosm-cc/bluemonday v1.0.23 h1:SMZe2IGa0NuHvnVNAZ+6B38gsTbi5e4sViiWJyDDqFY=
-github.com/microcosm-cc/bluemonday v1.0.23/go.mod h1:mN70sk7UkkF8TUr2IGBpNN0jAgStuPzlK76QuruE/z4=
-github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
@@ -357,25 +330,17 @@ github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iP
 github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU=
 github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ=
-github.com/nats-io/jwt v0.3.0 h1:xdnzwFETV++jNc4W1mw//qFyJGb2ABOombmZJQS4+Qo=
 github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg=
-github.com/nats-io/jwt/v2 v2.3.0 h1:z2mA1a7tIf5ShggOFlR1oBPgd6hGqcDYsISxZByUzdI=
-github.com/nats-io/nats-server/v2 v2.9.11 h1:4y5SwWvWI59V5mcqtuoqKq6L9NDUydOP3Ekwuwl8cZI=
 github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w=
-github.com/nats-io/nats.go v1.23.0 h1:lR28r7IX44WjYgdiKz9GmUeW0uh/m33uD3yEjLZ2cOE=
-github.com/nats-io/nats.go v1.23.0/go.mod h1:ki/Scsa23edbh8IRZbCuNXR9TDcbvfaSijKtaqQgw+Q=
 github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
-github.com/nats-io/nkeys v0.3.0 h1:cgM5tL53EvYRU+2YLXIK0G2mJtK12Ft9oeooSZMA2G8=
-github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4=
-github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
@@ -396,6 +361,9 @@ github.com/onsi/gomega v1.27.1/go.mod h1:aHX5xOykVYzWOV4WqQy0sy8BQptgukenXpCXfad
 github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/pelletier/go-toml/v2 v2.0.1/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZOjgMj2KwnJFUo=
+github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
+github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
 github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQmzR3rNLYGGz4g/UgFcjb28p/viDM=
 github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0=
 github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
@@ -422,6 +390,7 @@ github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJ
 github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
 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=
@@ -432,18 +401,11 @@ github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
-github.com/sanity-io/litter v1.5.5 h1:iE+sBxPBzoK6uaEP5Lt3fHNgpKcHXc/A2HGETy0uJQo=
-github.com/schollz/closestmatch v2.1.0+incompatible h1:Uel2GXEpJqOWBrlyI+oY9LTiyyjYS17cCYRqP13/SHk=
 github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
-github.com/sergi/go-diff v1.2.0 h1:XU+rvMAioB0UC3q1MFrIQy4Vo5/4VsRDQQXHsEya6xQ=
-github.com/sergi/go-diff v1.2.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
-github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
-github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
-github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
@@ -451,76 +413,71 @@ github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkU
 github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
 github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA=
 github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
 github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/supranational/blst v0.3.11-0.20230406105308-e9dfc5ee724b h1:u49mjRnygnB34h8OKbnNJFVUtWSKIKb1KukdV8bILUM=
 github.com/supranational/blst v0.3.11-0.20230406105308-e9dfc5ee724b/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
-github.com/tdewolff/minify/v2 v2.12.4 h1:kejsHQMM17n6/gwdw53qsi6lg0TGddZADVyQOz1KMdE=
-github.com/tdewolff/minify/v2 v2.12.4/go.mod h1:h+SRvSIX3kwgwTFOpSckvSxgax3uy8kZTSF1Ojrr3bk=
-github.com/tdewolff/parse/v2 v2.6.4 h1:KCkDvNUMof10e3QExio9OPZJT8SbdKojLBumw8YZycQ=
-github.com/tdewolff/parse/v2 v2.6.4/go.mod h1:woz0cgbLwFdtbjJu8PIKxhW05KplTFQkOdX78o+Jgrs=
-github.com/tdewolff/test v1.0.7 h1:8Vs0142DmPFW/bQeHRP3MV19m1gvndjUb1sn8yy74LM=
-github.com/tdewolff/test v1.0.7/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
 github.com/tklauser/go-sysconf v0.3.11 h1:89WgdJhk5SNwJfu+GKyYveZ4IaJ7xAkecBo+KdJV0CM=
 github.com/tklauser/go-sysconf v0.3.11/go.mod h1:GqXfhXY3kiPa0nAXPDIQIWzJbMCB7AmcWpGR8lSZfqI=
 github.com/tklauser/numcpus v0.6.0 h1:kebhY2Qt+3U6RNK7UqpYNA+tJ23IBEGKkB7JQBfDYms=
 github.com/tklauser/numcpus v0.6.0/go.mod h1:FEZLMke0lhOUG6w2JadTzp0a+Nl8PF/GFkQ5UVIcaL4=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 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 v1.2.7/go.mod h1:nF9osbDWLy6bDVv/Rtoh6QgnvNDpmCalQV5urGCCS6M=
 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/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs=
 github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
 github.com/urfave/negroni v1.0.0/go.mod h1:Meg73S6kFm/4PpbYdq35yYWoCZ9mS/YSx+lKnmiohz4=
-github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasthttp v1.6.0/go.mod h1:FstJa9V+Pj9vQ7OJie2qMHdwemEDaDiSdBnvPM1Su9w=
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
 github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
 github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
-github.com/vmihailenco/msgpack/v5 v5.3.5 h1:5gO0H1iULLWGhs2H5tbAHIZTV8/cYafcFOr9znI5mJU=
-github.com/vmihailenco/msgpack/v5 v5.3.5/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc=
-github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
-github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
 github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
-github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo=
-github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=
 github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
-github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
 github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
-github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0 h1:6fRhSjgLCkTD3JnJxvaJ4Sj+TYblw757bqYgZaOq5ZY=
 github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI=
-github.com/yosssi/ace v0.0.5 h1:tUkIP/BLdKqrlrPwcmH0shwEEhTRHoGnc1wFIWmaBUA=
-github.com/yosssi/ace v0.0.5/go.mod h1:ALfIzm2vT7t5ZE7uoIZqF3TQ7SAOyupFZnkrF5id+K0=
-github.com/yudai/gojsondiff v1.0.0 h1:27cbfqXLVEJ1o8I6v3y9lg8Ydm53EKqHXAOMxEGlCOA=
 github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg=
-github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 h1:BHyfKlQyqbsFN5p3IfnEUduWvb9is428/nNb5L3U01M=
 github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM=
 github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/yusufpapurcu/wmi v1.2.2 h1:KBNDSne4vP5mbSWnJbO+51IMOXJB67QiYCSBrubbPRg=
 github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.4.0 h1:A8WCeEWhLwPBKNbFi5Wv5UTCBx5zzubnXDlMOFAzFMc=
+golang.org/x/arch v0.4.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
@@ -530,9 +487,10 @@ golang.org/x/crypto v0.0.0-20191227163750-53104e6ec876/go.mod h1:LzIPMQfyMNhhGPh
 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-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
 golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA=
 golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -546,7 +504,7 @@ golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzB
 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.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
 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=
@@ -569,7 +527,8 @@ golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v
 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.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50=
 golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -581,6 +540,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ
 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.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
 golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -604,7 +565,6 @@ 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-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=
@@ -614,26 +574,30 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w
 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-20210806184541-e5e7981a1069/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-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/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.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
 golang.org/x/sys v0.10.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/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.11.0 h1:LAntKIrcmeSKERyiOh0XMV39LXS8IE9UL2yP7+f5ij4=
 golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -655,15 +619,13 @@ golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roY
 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.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.11.0 h1:EMCa6U9S2LtZXLAMoWiR/R8dAQFRqbAitmbJ2UKhoi8=
 golang.org/x/tools v0.11.0/go.mod h1:anzJrxPjNtfgiYQYirP2CPGzGLxrH2u2QBhn6Bf3qY8=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df h1:5Pf6pFKu98ODmgnpvkJ3kFUOQGGLIzLIkbzUHp47618=
-golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
@@ -688,20 +650,19 @@ google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpAD
 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.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
 google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
 gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y=
 gopkg.in/ini.v1 v1.51.1/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
-gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
-gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA=
 gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8=
 gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
@@ -720,6 +681,11 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C
 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=
+gorm.io/driver/postgres v1.5.0 h1:u2FXTy14l45qc3UeCJ7QaAXZmZfDDv0YrthvmRq1l0U=
+gorm.io/driver/postgres v1.5.0/go.mod h1:FUZXzO+5Uqg5zzwzv4KK49R8lvGIyscBOqYrtI1Ce9A=
+gorm.io/gorm v1.24.7-0.20230306060331-85eaf9eeda11/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
+gorm.io/gorm v1.25.2 h1:gs1o6Vsa+oVKG/a9ElL3XgyGfghFfkKA2SInQaCyMho=
+gorm.io/gorm v1.25.2/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 lukechampine.com/uint128 v1.2.0 h1:mBi/5l91vocEN8otkC5bDLhi2KdCticRiwbdB0O+rjI=
@@ -732,6 +698,6 @@ 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/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
 rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU=
 rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA=

bridge-history-api/internal/controller/controller.go

@@ -0,0 +1,20 @@
+package controller
+
+import (
+	"sync"
+
+	"gorm.io/gorm"
+)
+
+var (
+	// HistoryCtrler is controller instance
+	HistoryCtrler      *HistoryController
+	initControllerOnce sync.Once
+)
+
+// InitController inits Controller with database
+func InitController(db *gorm.DB) {
+	initControllerOnce.Do(func() {
+		HistoryCtrler = NewHistoryController(db)
+	})
+}

bridge-history-api/internal/controller/history_controller.go

@@ -0,0 +1,72 @@
+package controller
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+
+	"bridge-history-api/internal/logic"
+	"bridge-history-api/internal/types"
+)
+
+// HistoryController contains the query claimable txs service
+type HistoryController struct {
+	historyLogic *logic.HistoryLogic
+}
+
+// NewHistoryController return HistoryController instance
+func NewHistoryController(db *gorm.DB) *HistoryController {
+	return &HistoryController{
+		historyLogic: logic.NewHistoryLogic(db),
+	}
+}
+
+// GetAllClaimableTxsByAddr defines the http get method behavior
+func (c *HistoryController) GetAllClaimableTxsByAddr(ctx *gin.Context) {
+	var req types.QueryByAddressRequest
+	if err := ctx.ShouldBind(&req); err != nil {
+		types.RenderJSON(ctx, types.ErrParameterInvalidNo, err, nil)
+		return
+	}
+	offset := (req.Page - 1) * req.PageSize
+	limit := req.PageSize
+	txs, total, err := c.historyLogic.GetClaimableTxsByAddress(ctx, common.HexToAddress(req.Address), offset, limit)
+	if err != nil {
+		types.RenderJSON(ctx, types.ErrGetClaimablesFailure, err, nil)
+		return
+	}
+
+	types.RenderJSON(ctx, types.Success, nil, &types.ResultData{Result: txs, Total: total})
+}
+
+// GetAllTxsByAddr defines the http get method behavior
+func (c *HistoryController) GetAllTxsByAddr(ctx *gin.Context) {
+	var req types.QueryByAddressRequest
+	if err := ctx.ShouldBind(&req); err != nil {
+		types.RenderJSON(ctx, types.ErrParameterInvalidNo, err, nil)
+		return
+	}
+	offset := (req.Page - 1) * req.PageSize
+	limit := req.PageSize
+	message, total, err := c.historyLogic.GetTxsByAddress(ctx, common.HexToAddress(req.Address), offset, limit)
+	if err != nil {
+		types.RenderJSON(ctx, types.ErrGetTxsByAddrFailure, err, nil)
+		return
+	}
+	types.RenderJSON(ctx, types.Success, nil, &types.ResultData{Result: message, Total: total})
+}
+
+// PostQueryTxsByHash defines the http post method behavior
+func (c *HistoryController) PostQueryTxsByHash(ctx *gin.Context) {
+	var req types.QueryByHashRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		types.RenderJSON(ctx, types.ErrParameterInvalidNo, err, nil)
+		return
+	}
+	result, err := c.historyLogic.GetTxsByHashes(ctx, req.Txs)
+	if err != nil {
+		types.RenderJSON(ctx, types.ErrGetTxsByHashFailure, err, nil)
+		return
+	}
+	types.RenderJSON(ctx, types.Success, nil, &types.ResultData{Result: result, Total: 0})
+}

bridge-history-api/internal/logic/history_logic.go

@@ -0,0 +1,212 @@
+package logic
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+
+	"bridge-history-api/internal/types"
+	"bridge-history-api/orm"
+)
+
+// HistoryLogic example service.
+type HistoryLogic struct {
+	db *gorm.DB
+}
+
+// NewHistoryLogic returns services backed with a "db"
+func NewHistoryLogic(db *gorm.DB) *HistoryLogic {
+	logic := &HistoryLogic{db: db}
+	return logic
+}
+
+// getCrossTxClaimInfo get UserClaimInfos by address
+func getCrossTxClaimInfo(ctx context.Context, msgHash string, db *gorm.DB) *types.UserClaimInfo {
+	l2SentMsgOrm := orm.NewL2SentMsg(db)
+	rollupOrm := orm.NewRollupBatch(db)
+	l2sentMsg, err := l2SentMsgOrm.GetL2SentMsgByHash(ctx, msgHash)
+	if err != nil || l2sentMsg == nil {
+		log.Debug("getCrossTxClaimInfo failed", "error", err)
+		return &types.UserClaimInfo{}
+	}
+	batch, err := rollupOrm.GetRollupBatchByIndex(ctx, l2sentMsg.BatchIndex)
+	if err != nil {
+		log.Debug("getCrossTxClaimInfo failed", "error", err)
+		return &types.UserClaimInfo{}
+	}
+	return &types.UserClaimInfo{
+		From:       l2sentMsg.Sender,
+		To:         l2sentMsg.Target,
+		Value:      l2sentMsg.Value,
+		Nonce:      strconv.FormatUint(l2sentMsg.Nonce, 10),
+		Message:    l2sentMsg.MsgData,
+		Proof:      "0x" + l2sentMsg.MsgProof,
+		BatchHash:  batch.BatchHash,
+		BatchIndex: strconv.FormatUint(l2sentMsg.BatchIndex, 10),
+	}
+
+}
+
+func updateCrossTxHash(ctx context.Context, msgHash string, txInfo *types.TxHistoryInfo, db *gorm.DB) {
+	relayed := orm.NewRelayedMsg(db)
+	relayed, err := relayed.GetRelayedMsgByHash(ctx, msgHash)
+	if err != nil {
+		log.Debug("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
+	}
+
+}
+
+// GetClaimableTxsByAddress get all claimable txs under given address
+func (h *HistoryLogic) GetClaimableTxsByAddress(ctx context.Context, address common.Address, offset int, limit int) ([]*types.TxHistoryInfo, uint64, error) {
+	var txHistories []*types.TxHistoryInfo
+	l2SentMsgOrm := orm.NewL2SentMsg(h.db)
+	l2CrossMsgOrm := orm.NewCrossMsg(h.db)
+	total, err := l2SentMsgOrm.GetClaimableL2SentMsgByAddressTotalNum(ctx, address.Hex())
+	if err != nil || total == 0 {
+		return txHistories, 0, err
+	}
+	results, err := l2SentMsgOrm.GetClaimableL2SentMsgByAddressWithOffset(ctx, address.Hex(), offset, limit)
+	if err != nil || len(results) == 0 {
+		return txHistories, 0, err
+	}
+	var msgHashList []string
+	for _, result := range results {
+		msgHashList = append(msgHashList, result.MsgHash)
+	}
+	crossMsgs, err := l2CrossMsgOrm.GetL2CrossMsgByMsgHashList(ctx, msgHashList)
+	// crossMsgs can be empty, because they can be emitted by user directly call contract
+	if err != nil {
+		return txHistories, 0, err
+	}
+	crossMsgMap := make(map[string]*orm.CrossMsg)
+	for _, crossMsg := range crossMsgs {
+		crossMsgMap[crossMsg.MsgHash] = crossMsg
+	}
+	for _, result := range results {
+		txInfo := &types.TxHistoryInfo{
+			Hash:        result.TxHash,
+			IsL1:        false,
+			BlockNumber: result.Height,
+			FinalizeTx:  &types.Finalized{},
+			ClaimInfo:   getCrossTxClaimInfo(ctx, result.MsgHash, h.db),
+		}
+		if crossMsg, exist := crossMsgMap[result.MsgHash]; exist {
+			txInfo.Amount = crossMsg.Amount
+			txInfo.To = crossMsg.Target
+			txInfo.BlockTimestamp = crossMsg.Timestamp
+			txInfo.CreatedAt = crossMsg.CreatedAt
+			txInfo.L1Token = crossMsg.Layer1Token
+			txInfo.L2Token = crossMsg.Layer2Token
+		}
+		txHistories = append(txHistories, txInfo)
+	}
+	return txHistories, total, err
+}
+
+// GetTxsByAddress get all txs under given address
+func (h *HistoryLogic) GetTxsByAddress(ctx context.Context, address common.Address, offset int, limit int) ([]*types.TxHistoryInfo, uint64, error) {
+	var txHistories []*types.TxHistoryInfo
+	utilOrm := orm.NewCrossMsg(h.db)
+	total, err := utilOrm.GetTotalCrossMsgCountByAddress(ctx, address.String())
+	if err != nil || total == 0 {
+		return txHistories, 0, err
+	}
+	result, err := utilOrm.GetCrossMsgsByAddressWithOffset(ctx, address.String(), offset, limit)
+
+	if err != nil {
+		return nil, 0, err
+	}
+	for _, msg := range result {
+		txHistory := &types.TxHistoryInfo{
+			Hash:           msg.Layer1Hash + msg.Layer2Hash,
+			Amount:         msg.Amount,
+			To:             msg.Target,
+			L1Token:        msg.Layer1Token,
+			L2Token:        msg.Layer2Token,
+			IsL1:           msg.MsgType == int(orm.Layer1Msg),
+			BlockNumber:    msg.Height,
+			BlockTimestamp: msg.Timestamp,
+			CreatedAt:      msg.CreatedAt,
+			FinalizeTx: &types.Finalized{
+				Hash: "",
+			},
+			ClaimInfo: getCrossTxClaimInfo(ctx, msg.MsgHash, h.db),
+		}
+		updateCrossTxHash(ctx, msg.MsgHash, txHistory, h.db)
+		txHistories = append(txHistories, txHistory)
+	}
+	return txHistories, total, nil
+}
+
+// GetTxsByHashes get tx infos under given tx hashes
+func (h *HistoryLogic) GetTxsByHashes(ctx context.Context, hashes []string) ([]*types.TxHistoryInfo, error) {
+	txHistories := make([]*types.TxHistoryInfo, 0)
+	CrossMsgOrm := orm.NewCrossMsg(h.db)
+	for _, hash := range hashes {
+		l1result, err := CrossMsgOrm.GetL1CrossMsgByHash(ctx, common.HexToHash(hash))
+		if err != nil {
+			return nil, err
+		}
+		if l1result != nil {
+			txHistory := &types.TxHistoryInfo{
+				Hash:           l1result.Layer1Hash,
+				Amount:         l1result.Amount,
+				To:             l1result.Target,
+				IsL1:           true,
+				L1Token:        l1result.Layer1Token,
+				L2Token:        l1result.Layer2Token,
+				BlockNumber:    l1result.Height,
+				BlockTimestamp: l1result.Timestamp,
+				CreatedAt:      l1result.CreatedAt,
+				FinalizeTx: &types.Finalized{
+					Hash: "",
+				},
+			}
+			updateCrossTxHash(ctx, l1result.MsgHash, txHistory, h.db)
+			txHistories = append(txHistories, txHistory)
+			continue
+		}
+		l2result, err := CrossMsgOrm.GetL2CrossMsgByHash(ctx, common.HexToHash(hash))
+		if err != nil {
+			return nil, err
+		}
+		if l2result != nil {
+			txHistory := &types.TxHistoryInfo{
+				Hash:           l2result.Layer2Hash,
+				Amount:         l2result.Amount,
+				To:             l2result.Target,
+				IsL1:           false,
+				L1Token:        l2result.Layer1Token,
+				L2Token:        l2result.Layer2Token,
+				BlockNumber:    l2result.Height,
+				BlockTimestamp: l2result.Timestamp,
+				CreatedAt:      l2result.CreatedAt,
+				FinalizeTx: &types.Finalized{
+					Hash: "",
+				},
+				ClaimInfo: getCrossTxClaimInfo(ctx, l2result.MsgHash, h.db),
+			}
+			updateCrossTxHash(ctx, l2result.MsgHash, txHistory, h.db)
+			txHistories = append(txHistories, txHistory)
+			continue
+		}
+	}
+	return txHistories, nil
+}

bridge-history-api/internal/route/route.go

@@ -0,0 +1,26 @@
+package route
+
+import (
+	"time"
+
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+
+	"bridge-history-api/config"
+	"bridge-history-api/internal/controller"
+)
+
+// Route routes the APIs
+func Route(router *gin.Engine, conf *config.Config) {
+	router.Use(cors.New(cors.Config{
+		AllowOrigins:     []string{"*"},
+		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE"},
+		AllowCredentials: true,
+		MaxAge:           12 * time.Hour,
+	}))
+
+	r := router.Group("api/")
+	r.GET("/txs", controller.HistoryCtrler.GetAllTxsByAddr)
+	r.POST("/txsbyhashes", controller.HistoryCtrler.PostQueryTxsByHash)
+	r.GET("/claimable", controller.HistoryCtrler.GetAllClaimableTxsByAddr)
+}

bridge-history-api/internal/types/history_types.go

@@ -0,0 +1,97 @@
+package types
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+const (
+	// Success shows OK.
+	Success = 0
+	// ErrParameterInvalidNo is invalid params
+	ErrParameterInvalidNo = 40001
+	// ErrGetClaimablesFailure is getting all claimables txs error
+	ErrGetClaimablesFailure = 40002
+	// ErrGetTxsByHashFailure is getting txs by hash list error
+	ErrGetTxsByHashFailure = 40003
+	// ErrGetTxsByAddrFailure is getting txs by address error
+	ErrGetTxsByAddrFailure = 40004
+)
+
+// QueryByAddressRequest the request parameter of address api
+type QueryByAddressRequest struct {
+	Address  string `form:"address" binding:"required"`
+	Page     int    `form:"page" binding:"required"`
+	PageSize int    `form:"page_size" binding:"required"`
+}
+
+// QueryByHashRequest the request parameter of hash api
+type QueryByHashRequest struct {
+	Txs []string `raw:"txs" binding:"required"`
+}
+
+// ResultData contains return txs and total
+type ResultData struct {
+	Result []*TxHistoryInfo `json:"result"`
+	Total  uint64           `json:"total"`
+}
+
+// Response the response schema
+type Response struct {
+	ErrCode int         `json:"errcode"`
+	ErrMsg  string      `json:"errmsg"`
+	Data    interface{} `json:"data"`
+}
+
+// Finalized the schema of tx finalized infos
+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
+}
+
+// UserClaimInfo the schema of tx claim infos
+type UserClaimInfo struct {
+	From       string `json:"from"`
+	To         string `json:"to"`
+	Value      string `json:"value"`
+	Nonce      string `json:"nonce"`
+	BatchHash  string `json:"batch_hash"`
+	Message    string `json:"message"`
+	Proof      string `json:"proof"`
+	BatchIndex string `json:"batch_index"`
+}
+
+// TxHistoryInfo the schema of tx history infos
+type TxHistoryInfo struct {
+	Hash           string         `json:"hash"`
+	Amount         string         `json:"amount"`
+	To             string         `json:"to"` // useless
+	IsL1           bool           `json:"isL1"`
+	L1Token        string         `json:"l1Token"`
+	L2Token        string         `json:"l2Token"`
+	BlockNumber    uint64         `json:"blockNumber"`
+	BlockTimestamp *time.Time     `json:"blockTimestamp"` // useless
+	FinalizeTx     *Finalized     `json:"finalizeTx"`
+	ClaimInfo      *UserClaimInfo `json:"claimInfo"`
+	CreatedAt      *time.Time     `json:"createdTime"`
+}
+
+// RenderJSON renders response with json
+func RenderJSON(ctx *gin.Context, errCode int, err error, data interface{}) {
+	var errMsg string
+	if err != nil {
+		errMsg = err.Error()
+	}
+	renderData := Response{
+		ErrCode: errCode,
+		ErrMsg:  errMsg,
+		Data:    data,
+	}
+	ctx.JSON(http.StatusOK, renderData)
+}

bridge-history-api/model/request.go

@@ -1,13 +0,0 @@
-package model
-
-// QueryByAddressRequest the request parameter of address api
-type QueryByAddressRequest struct {
-	Address string `url:"address"`
-	Offset  int    `url:"offset"`
-	Limit   int    `url:"limit"`
-}
-
-// QueryByHashRequest the request parameter of hash api
-type QueryByHashRequest struct {
-	Txs []string `url:"txs"`
-}

bridge-history-api/model/response.go

@@ -1,21 +0,0 @@
-package model
-
-import "bridge-history-api/service"
-
-// Data the return struct of apis
-type Data struct {
-	Result []*service.TxHistoryInfo `json:"result"`
-	Total  uint64                   `json:"total"`
-}
-
-// QueryByAddressResponse the schema of address api response
-type QueryByAddressResponse struct {
-	Message string `json:"message"`
-	Data    *Data  `json:"data"`
-}
-
-// QueryByHashResponse the schema of hash api response
-type QueryByHashResponse struct {
-	Message string `json:"message"`
-	Data    *Data  `json:"data"`
-}

bridge-history-api/orm/batch.go

@@ -0,0 +1,103 @@
+package orm
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+)
+
+// RollupBatch is the struct for rollup_batch table
+type RollupBatch struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID               uint64         `json:"id" gorm:"column:id"`
+	BatchIndex       uint64         `json:"batch_index" gorm:"column:batch_index"`
+	BatchHash        string         `json:"batch_hash" gorm:"column:batch_hash"`
+	CommitHeight     uint64         `json:"commit_height" gorm:"column:commit_height"`
+	StartBlockNumber uint64         `json:"start_block_number" gorm:"column:start_block_number"`
+	EndBlockNumber   uint64         `json:"end_block_number" gorm:"column:end_block_number"`
+	CreatedAt        *time.Time     `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt        *time.Time     `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt        gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at;default:NULL"`
+}
+
+// NewRollupBatch create an RollupBatch instance
+func NewRollupBatch(db *gorm.DB) *RollupBatch {
+	return &RollupBatch{db: db}
+}
+
+// TableName returns the table name for the Batch model.
+func (*RollupBatch) TableName() string {
+	return "rollup_batch"
+}
+
+// GetLatestRollupBatchProcessedHeight return latest processed height from rollup_batch table
+func (r *RollupBatch) GetLatestRollupBatchProcessedHeight(ctx context.Context) (uint64, error) {
+	var result RollupBatch
+	err := r.db.WithContext(ctx).Unscoped().Select("commit_height").Order("id desc").First(&result).Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("RollupBatch.GetLatestRollupBatchProcessedHeight error: %w", err)
+	}
+	return result.CommitHeight, nil
+}
+
+// GetLatestRollupBatch return the latest rollup batch in db
+func (r *RollupBatch) GetLatestRollupBatch(ctx context.Context) (*RollupBatch, error) {
+	var result RollupBatch
+	err := r.db.WithContext(ctx).Model(&RollupBatch{}).Where("batch_hash is not NULL").Order("batch_index desc").First(&result).Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("RollupBatch.GetLatestRollupBatch error: %w", err)
+	}
+	return &result, nil
+}
+
+// GetRollupBatchByIndex return the rollup batch by index
+func (r *RollupBatch) GetRollupBatchByIndex(ctx context.Context, index uint64) (*RollupBatch, error) {
+	var result RollupBatch
+	err := r.db.WithContext(ctx).Model(&RollupBatch{}).Where("batch_index = ?", index).First(&result).Error
+	if err != nil {
+		return nil, fmt.Errorf("RollupBatch.GetRollupBatchByIndex error: %w", err)
+	}
+	return &result, nil
+}
+
+// InsertRollupBatch batch insert rollup batch into db and return the transaction
+func (r *RollupBatch) InsertRollupBatch(ctx context.Context, batches []*RollupBatch, dbTx ...*gorm.DB) error {
+	if len(batches) == 0 {
+		return nil
+	}
+	db := r.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	err := db.WithContext(ctx).Model(&RollupBatch{}).Create(&batches).Error
+	if err != nil {
+		batchIndexes := make([]uint64, 0, len(batches))
+		heights := make([]uint64, 0, len(batches))
+		for _, batch := range batches {
+			batchIndexes = append(batchIndexes, batch.BatchIndex)
+			heights = append(heights, batch.CommitHeight)
+		}
+		log.Error("failed to insert rollup batch", "batchIndexes", batchIndexes, "heights", heights)
+		return fmt.Errorf("RollupBatch.InsertRollupBatch error: %w", err)
+	}
+	return nil
+}
+
+// UpdateRollupBatchWithdrawRoot updates the withdraw_root column in rollup_batch table
+func (r *RollupBatch) UpdateRollupBatchWithdrawRoot(ctx context.Context, batchIndex uint64, withdrawRoot string) error {
+	err := r.db.WithContext(ctx).Model(&RollupBatch{}).Where("batch_index = ?", batchIndex).Update("withdraw_root", withdrawRoot).Error
+	if err != nil {
+		return fmt.Errorf("RollupBatch.UpdateRuollupBatch error: %w", err)
+	}
+	return nil
+}

bridge-history-api/orm/cross_msg.go

@@ -0,0 +1,370 @@
+package orm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+)
+
+// AssetType can be ETH/ERC20/ERC1155/ERC721
+type AssetType int
+
+// MsgType can be layer1/layer2 msg
+type MsgType int
+
+func (a AssetType) String() string {
+	switch a {
+	case ETH:
+		return "ETH"
+	case ERC20:
+		return "ERC20"
+	case ERC1155:
+		return "ERC1155"
+	case ERC721:
+		return "ERC721"
+	}
+	return "Unknown Asset Type"
+}
+
+const (
+	// ETH = 0
+	ETH AssetType = iota
+	// ERC20 = 1
+	ERC20
+	// ERC721 = 2
+	ERC721
+	// ERC1155 = 3
+	ERC1155
+)
+
+const (
+	// UnknownMsg = 0
+	UnknownMsg MsgType = iota
+	// Layer1Msg = 1
+	Layer1Msg
+	// Layer2Msg = 2
+	Layer2Msg
+)
+
+// CrossMsg represents a cross message from layer 1 to layer 2
+type CrossMsg struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID           uint64         `json:"id" gorm:"column:id"`
+	MsgHash      string         `json:"msg_hash" gorm:"column:msg_hash"`
+	Height       uint64         `json:"height" gorm:"column:height"`
+	Sender       string         `json:"sender" gorm:"column:sender"`
+	Target       string         `json:"target" gorm:"column:target"`
+	Amount       string         `json:"amount" gorm:"column:amount"`
+	Layer1Hash   string         `json:"layer1_hash" gorm:"column:layer1_hash;default:''"`
+	Layer2Hash   string         `json:"layer2_hash" gorm:"column:layer2_hash;default:''"`
+	Layer1Token  string         `json:"layer1_token" gorm:"column:layer1_token;default:''"`
+	Layer2Token  string         `json:"layer2_token" gorm:"column:layer2_token;default:''"`
+	TokenIDs     string         `json:"token_ids" gorm:"column:token_ids;default:''"`
+	TokenAmounts string         `json:"token_amounts" gorm:"column:token_amounts;default:''"`
+	Asset        int            `json:"asset" gorm:"column:asset"`
+	MsgType      int            `json:"msg_type" gorm:"column:msg_type"`
+	Timestamp    *time.Time     `json:"timestamp" gorm:"column:block_timestamp;default;NULL"`
+	CreatedAt    *time.Time     `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt    *time.Time     `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt    gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at;default:NULL"`
+}
+
+// TableName returns the table name for the CrossMsg model.
+func (*CrossMsg) TableName() string {
+	return "cross_message"
+}
+
+// NewCrossMsg returns a new instance of CrossMsg.
+func NewCrossMsg(db *gorm.DB) *CrossMsg {
+	return &CrossMsg{db: db}
+}
+
+// L1 Cross Msgs Operations
+
+// GetL1CrossMsgByHash returns layer1 cross message by given hash
+func (c *CrossMsg) GetL1CrossMsgByHash(ctx context.Context, l1Hash common.Hash) (*CrossMsg, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).Where("layer1_hash = ? AND msg_type = ?", l1Hash.String(), Layer1Msg).First(&result).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("CrossMsg.GetL1CrossMsgByHash error: %w", err)
+	}
+	return &result, nil
+}
+
+// GetLatestL1ProcessedHeight returns the latest processed height of layer1 cross messages
+func (c *CrossMsg) GetLatestL1ProcessedHeight(ctx context.Context) (uint64, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).Where("msg_type = ?", Layer1Msg).
+		Select("height").
+		Order("id DESC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("CrossMsg.GetLatestL1ProcessedHeight error: %w", err)
+	}
+	return result.Height, nil
+}
+
+// GetL1EarliestNoBlockTimestampHeight returns the earliest layer1 cross message height which has no block timestamp
+func (c *CrossMsg) GetL1EarliestNoBlockTimestampHeight(ctx context.Context) (uint64, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("block_timestamp IS NULL AND msg_type = ?", Layer1Msg).
+		Select("height").
+		Order("height ASC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("CrossMsg.GetL1EarliestNoBlockTimestampHeight error: %w", err)
+	}
+	return result.Height, nil
+}
+
+// InsertL1CrossMsg batch insert layer1 cross messages into db
+func (c *CrossMsg) InsertL1CrossMsg(ctx context.Context, messages []*CrossMsg, dbTx ...*gorm.DB) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&CrossMsg{}).Create(&messages).Error
+	if err != nil {
+		l1hashes := make([]string, 0, len(messages))
+		heights := make([]uint64, 0, len(messages))
+		for _, msg := range messages {
+			l1hashes = append(l1hashes, msg.Layer1Hash)
+			heights = append(heights, msg.Height)
+		}
+		log.Error("failed to insert l1 cross messages", "l1hashes", l1hashes, "heights", heights, "err", err)
+		return fmt.Errorf("CrossMsg.InsertL1CrossMsg error: %w", err)
+	}
+	return nil
+}
+
+// UpdateL1CrossMsgHash update l1 cross msg hash in db, no need to check msg_type since layer1_hash wont be empty if its layer1 msg
+func (c *CrossMsg) UpdateL1CrossMsgHash(ctx context.Context, l1Hash, msgHash common.Hash, dbTx ...*gorm.DB) error {
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := c.db.Model(&CrossMsg{}).Where("layer1_hash = ?", l1Hash.Hex()).Update("msg_hash", msgHash.Hex()).Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.UpdateL1CrossMsgHash error: %w", err)
+	}
+	return nil
+
+}
+
+// UpdateL1BlockTimestamp update layer1 block timestamp
+func (c *CrossMsg) UpdateL1BlockTimestamp(ctx context.Context, height uint64, timestamp time.Time) error {
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("height = ? AND msg_type = ?", height, Layer1Msg).
+		Update("block_timestamp", timestamp).Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.UpdateL1BlockTimestamp error: %w", err)
+	}
+	return err
+}
+
+// DeleteL1CrossMsgAfterHeight soft delete layer1 cross messages after given height
+func (c *CrossMsg) DeleteL1CrossMsgAfterHeight(ctx context.Context, height uint64, dbTx ...*gorm.DB) error {
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Delete(&CrossMsg{}, "height > ? AND msg_type = ?", height, Layer1Msg).Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.DeleteL1CrossMsgAfterHeight error: %w", err)
+	}
+	return nil
+}
+
+// L2 Cross Msgs Operations
+
+// GetL2CrossMsgByHash returns layer2 cross message by given hash
+func (c *CrossMsg) GetL2CrossMsgByHash(ctx context.Context, l2Hash common.Hash) (*CrossMsg, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).Where("layer2_hash = ? AND msg_type = ?", l2Hash.String(), Layer1Msg).First(&result).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("CrossMsg.GetL2CrossMsgByHash error: %w", err)
+	}
+	return &result, nil
+}
+
+// GetLatestL2ProcessedHeight returns the latest processed height of layer2 cross messages
+func (c *CrossMsg) GetLatestL2ProcessedHeight(ctx context.Context) (uint64, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Select("height").
+		Where("msg_type = ?", Layer2Msg).
+		Order("id DESC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("CrossMsg.GetLatestL2ProcessedHeight error: %w", err)
+	}
+	return result.Height, nil
+}
+
+// GetL2CrossMsgByMsgHashList returns layer2 cross messages under given msg hashes
+func (c *CrossMsg) GetL2CrossMsgByMsgHashList(ctx context.Context, msgHashList []string) ([]*CrossMsg, error) {
+	var results []*CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("msg_hash IN (?) AND msg_type = ?", msgHashList, Layer2Msg).
+		Find(&results).
+		Error
+
+	if err != nil {
+		return nil, fmt.Errorf("CrossMsg.GetL2CrossMsgByMsgHashList error: %w", err)
+	}
+	if len(results) == 0 {
+		log.Debug("no CrossMsg under given msg hashes", "msg hash list", msgHashList)
+	}
+	return results, nil
+}
+
+// GetL2EarliestNoBlockTimestampHeight returns the earliest layer2 cross message height which has no block timestamp
+func (c *CrossMsg) GetL2EarliestNoBlockTimestampHeight(ctx context.Context) (uint64, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("block_timestamp IS NULL AND msg_type = ?", Layer2Msg).
+		Select("height").
+		Order("height ASC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("CrossMsg.GetL2EarliestNoBlockTimestampHeight error: %w", err)
+	}
+	return result.Height, nil
+}
+
+// InsertL2CrossMsg batch insert layer2 cross messages
+func (c *CrossMsg) InsertL2CrossMsg(ctx context.Context, messages []*CrossMsg, dbTx ...*gorm.DB) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&CrossMsg{}).Create(&messages).Error
+	if err != nil {
+		l2hashes := make([]string, 0, len(messages))
+		heights := make([]uint64, 0, len(messages))
+		for _, msg := range messages {
+			l2hashes = append(l2hashes, msg.Layer2Hash)
+			heights = append(heights, msg.Height)
+		}
+		log.Error("failed to insert l2 cross messages", "l2hashes", l2hashes, "heights", heights, "err", err)
+		return fmt.Errorf("CrossMsg.InsertL2CrossMsg error: %w", err)
+	}
+	return nil
+}
+
+// UpdateL2CrossMsgHash update layer2 cross message hash
+func (c *CrossMsg) UpdateL2CrossMsgHash(ctx context.Context, l2Hash, msgHash common.Hash, dbTx ...*gorm.DB) error {
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&CrossMsg{}).
+		Where("layer2_hash = ?", l2Hash.String()).
+		Update("msg_hash", msgHash.String()).
+		Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.UpdateL2CrossMsgHash error: %w", err)
+	}
+	return nil
+}
+
+// UpdateL2BlockTimestamp update layer2 cross message block timestamp
+func (c *CrossMsg) UpdateL2BlockTimestamp(ctx context.Context, height uint64, timestamp time.Time) error {
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("height = ? AND msg_type = ?", height, Layer2Msg).
+		Update("block_timestamp", timestamp).Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.UpdateL2BlockTimestamp error: %w", err)
+	}
+	return nil
+}
+
+// DeleteL2CrossMsgFromHeight delete layer2 cross messages from given height
+func (c *CrossMsg) DeleteL2CrossMsgFromHeight(ctx context.Context, height uint64, dbTx ...*gorm.DB) error {
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&CrossMsg{}).Delete("height > ? AND msg_type = ?", height, Layer2Msg).Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.DeleteL2CrossMsgFromHeight error: %w", err)
+
+	}
+	return nil
+}
+
+// General Operations
+
+// GetTotalCrossMsgCountByAddress get total cross msg count by address
+func (c *CrossMsg) GetTotalCrossMsgCountByAddress(ctx context.Context, sender string) (uint64, error) {
+	var count int64
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("sender = ?", sender).
+		Count(&count).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("CrossMsg.GetTotalCrossMsgCountByAddress error: %w", err)
+
+	}
+	return uint64(count), nil
+}
+
+// GetCrossMsgsByAddressWithOffset get cross msgs by address with offset
+func (c *CrossMsg) GetCrossMsgsByAddressWithOffset(ctx context.Context, sender string, offset int, limit int) ([]CrossMsg, error) {
+	var messages []CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("sender = ?", sender).
+		Order("block_timestamp DESC NULLS FIRST, id DESC").
+		Limit(limit).
+		Offset(offset).
+		Find(&messages).
+		Error
+	if err != nil {
+		return nil, fmt.Errorf("CrossMsg.GetCrossMsgsByAddressWithOffset error: %w", err)
+	}
+	return messages, nil
+}

bridge-history-api/orm/l2_sent_msg.go

@@ -0,0 +1,215 @@
+package orm
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+)
+
+// L2SentMsg defines the struct for l2_sent_msg table record
+type L2SentMsg struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID             uint64         `json:"id" gorm:"column:id"`
+	OriginalSender string         `json:"original_sender" gorm:"column:original_sender;default:''"`
+	TxHash         string         `json:"tx_hash" gorm:"column:tx_hash"`
+	MsgHash        string         `json:"msg_hash" gorm:"column:msg_hash"`
+	Sender         string         `json:"sender" gorm:"column:sender"`
+	Target         string         `json:"target" gorm:"column:target"`
+	Value          string         `json:"value" gorm:"column:value"`
+	Height         uint64         `json:"height" gorm:"column:height"`
+	Nonce          uint64         `json:"nonce" gorm:"column:nonce"`
+	BatchIndex     uint64         `json:"batch_index" gorm:"column:batch_index;default:0"`
+	MsgProof       string         `json:"msg_proof" gorm:"column:msg_proof;default:''"`
+	MsgData        string         `json:"msg_data" gorm:"column:msg_data;default:''"`
+	CreatedAt      *time.Time     `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt      *time.Time     `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt      gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at;default:NULL"`
+}
+
+// NewL2SentMsg create an NewL2SentMsg instance
+func NewL2SentMsg(db *gorm.DB) *L2SentMsg {
+	return &L2SentMsg{db: db}
+}
+
+// TableName returns the table name for the L2SentMsg model.
+func (*L2SentMsg) TableName() string {
+	return "l2_sent_msg"
+}
+
+// GetL2SentMsgByHash get l2 sent msg by hash
+func (l *L2SentMsg) GetL2SentMsgByHash(ctx context.Context, msgHash string) (*L2SentMsg, error) {
+	var result L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Where("msg_hash = ?", msgHash).
+		First(&result).
+		Error
+	if err != nil {
+		return nil, fmt.Errorf("L2SentMsg.GetL2SentMsgByHash error: %w", err)
+	}
+	return &result, nil
+}
+
+// GetLatestSentMsgHeightOnL2 get latest sent msg height on l2
+func (l *L2SentMsg) GetLatestSentMsgHeightOnL2(ctx context.Context) (uint64, error) {
+	var result L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Select("height").
+		Order("nonce DESC").
+		First(&result).Error
+
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("L2SentMsg.GetLatestSentMsgHeightOnL2 error: %w", err)
+
+	}
+	return result.Height, nil
+}
+
+// GetClaimableL2SentMsgByAddressWithOffset get claimable l2 sent msg by address with offset
+func (l *L2SentMsg) GetClaimableL2SentMsgByAddressWithOffset(ctx context.Context, address string, offset int, limit int) ([]*L2SentMsg, error) {
+	var results []*L2SentMsg
+	err := l.db.WithContext(ctx).Raw(`SELECT * FROM l2_sent_msg WHERE id NOT IN (SELECT l2_sent_msg.id FROM l2_sent_msg INNER JOIN relayed_msg ON l2_sent_msg.msg_hash = relayed_msg.msg_hash WHERE l2_sent_msg.deleted_at IS NULL AND relayed_msg.deleted_at IS NULL) AND (original_sender=$1 OR sender = $1) AND msg_proof !='' ORDER BY id DESC LIMIT $2 OFFSET $3;`, address, limit, offset).
+		Scan(&results).Error
+	if err != nil {
+		return nil, fmt.Errorf("L2SentMsg.GetClaimableL2SentMsgByAddressWithOffset error: %w", err)
+	}
+	return results, nil
+}
+
+// GetClaimableL2SentMsgByAddressTotalNum get claimable l2 sent msg by address total num
+func (l *L2SentMsg) GetClaimableL2SentMsgByAddressTotalNum(ctx context.Context, address string) (uint64, error) {
+	var count uint64
+	err := l.db.WithContext(ctx).Raw(`SELECT COUNT(*) FROM l2_sent_msg WHERE id NOT IN (SELECT l2_sent_msg.id FROM l2_sent_msg INNER JOIN relayed_msg ON l2_sent_msg.msg_hash = relayed_msg.msg_hash WHERE l2_sent_msg.deleted_at IS NULL AND relayed_msg.deleted_at IS NULL) AND (original_sender=$1 OR sender = $1) AND msg_proof !='';`, address).
+		Scan(&count).Error
+	if err != nil {
+		return 0, fmt.Errorf("L2SentMsg.GetClaimableL2SentMsgByAddressTotalNum error: %w", err)
+	}
+	return count, nil
+}
+
+// GetLatestL2SentMsgBatchIndex get latest l2 sent msg batch index
+func (l *L2SentMsg) GetLatestL2SentMsgBatchIndex(ctx context.Context) (int64, error) {
+	var result L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Where("batch_index != 0").
+		Order("batch_index DESC").
+		Select("batch_index").
+		First(&result).
+		Error
+	if err != nil {
+		return -1, fmt.Errorf("L2SentMsg.GetLatestL2SentMsgBatchIndex error: %w", err)
+	}
+	// Watch for overflow, tho its not likely to happen
+	return int64(result.Height), nil
+}
+
+// GetL2SentMsgMsgHashByHeightRange get l2 sent msg msg hash by height range
+func (l *L2SentMsg) GetL2SentMsgMsgHashByHeightRange(ctx context.Context, startHeight, endHeight uint64) ([]*L2SentMsg, error) {
+	var results []*L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Where("height >= ? AND height <= ?", startHeight, endHeight).
+		Order("nonce ASC").
+		Find(&results).
+		Error
+	if err != nil {
+		return nil, fmt.Errorf("L2SentMsg.GetL2SentMsgMsgHashByHeightRange error: %w", err)
+	}
+	return results, nil
+}
+
+// GetL2SentMessageByNonce get l2 sent message by nonce
+func (l *L2SentMsg) GetL2SentMessageByNonce(ctx context.Context, nonce uint64) (*L2SentMsg, error) {
+	var result L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Where("nonce = ?", nonce).
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("L2SentMsg.GetL2SentMessageByNonce error: %w", err)
+
+	}
+	return &result, nil
+}
+
+// GetLatestL2SentMsgLEHeight get latest l2 sent msg less than or equal to end block number
+func (l *L2SentMsg) GetLatestL2SentMsgLEHeight(ctx context.Context, endBlockNumber uint64) (*L2SentMsg, error) {
+	var result L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Where("height <= ?", endBlockNumber).
+		Order("nonce DESC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("L2SentMsg.GetLatestL2SentMsgLEHeight error: %w", err)
+
+	}
+	return &result, nil
+}
+
+// InsertL2SentMsg batch insert l2 sent msg
+func (l *L2SentMsg) InsertL2SentMsg(ctx context.Context, messages []*L2SentMsg, dbTx ...*gorm.DB) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	db := l.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&L2SentMsg{}).Create(&messages).Error
+	if err != nil {
+		l2hashes := make([]string, 0, len(messages))
+		heights := make([]uint64, 0, len(messages))
+		for _, msg := range messages {
+			l2hashes = append(l2hashes, msg.TxHash)
+			heights = append(heights, msg.Height)
+		}
+		log.Error("failed to insert l2 sent messages", "l2hashes", l2hashes, "heights", heights, "err", err)
+		return fmt.Errorf("L2SentMsg.InsertL2SentMsg error: %w", err)
+	}
+	return nil
+}
+
+// UpdateL2MessageProof update l2 message proof in db tx
+func (l *L2SentMsg) UpdateL2MessageProof(ctx context.Context, msgHash string, proof string, batchIndex uint64, dbTx ...*gorm.DB) error {
+	db := l.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&L2SentMsg{}).
+		Where("msg_hash = ?", msgHash).
+		Updates(map[string]interface{}{
+			"msg_proof":   proof,
+			"batch_index": batchIndex,
+		}).Error
+	if err != nil {
+		return fmt.Errorf("L2SentMsg.UpdateL2MessageProof error: %w", err)
+	}
+	return nil
+}
+
+// DeleteL2SentMsgAfterHeight delete l2 sent msg after height
+func (l *L2SentMsg) DeleteL2SentMsgAfterHeight(ctx context.Context, height uint64, dbTx ...*gorm.DB) error {
+	db := l.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	err := db.WithContext(ctx).Model(&L2SentMsg{}).Delete("height > ?", height).Error
+	if err != nil {
+		return fmt.Errorf("L2SentMsg.DeleteL2SentMsgAfterHeight error: %w", err)
+	}
+	return nil
+}

bridge-history-api/orm/migrate/migrations/00004_rollup_batch.sql

@@ -8,6 +8,7 @@ create table rollup_batch
     start_block_number  BIGINT NOT NULL,
     end_block_number    BIGINT NOT NULL,
     batch_hash          VARCHAR NOT NULL,
+    withdraw_root       TEXT DEFAULT NULL,
     created_at          TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at          TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
     deleted_at          TIMESTAMP(0) DEFAULT NULL

bridge-history-api/orm/relayed_msg.go

@@ -0,0 +1,142 @@
+package orm
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+)
+
+// RelayedMsg is the struct for relayed_msg table
+type RelayedMsg struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID         uint64         `json:"id" gorm:"column:id"`
+	MsgHash    string         `json:"msg_hash" gorm:"column:msg_hash"`
+	Height     uint64         `json:"height" gorm:"column:height"`
+	Layer1Hash string         `json:"layer1_hash" gorm:"column:layer1_hash;default:''"`
+	Layer2Hash string         `json:"layer2_hash" gorm:"column:layer2_hash;default:''"`
+	CreatedAt  *time.Time     `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt  *time.Time     `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt  gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at;default:NULL"`
+}
+
+// NewRelayedMsg create an NewRelayedMsg instance
+func NewRelayedMsg(db *gorm.DB) *RelayedMsg {
+	return &RelayedMsg{db: db}
+}
+
+// TableName returns the table name for the RelayedMsg model.
+func (*RelayedMsg) TableName() string {
+	return "relayed_msg"
+}
+
+// GetRelayedMsgByHash get relayed msg by hash
+func (r *RelayedMsg) GetRelayedMsgByHash(ctx context.Context, msgHash string) (*RelayedMsg, error) {
+	var result RelayedMsg
+	err := r.db.WithContext(ctx).Model(&RelayedMsg{}).
+		Where("msg_hash = ?", msgHash).
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("RelayedMsg.GetRelayedMsgByHash error: %w", err)
+	}
+	return &result, nil
+}
+
+// GetLatestRelayedHeightOnL1 get latest relayed height on l1
+func (r *RelayedMsg) GetLatestRelayedHeightOnL1(ctx context.Context) (uint64, error) {
+	var result RelayedMsg
+	err := r.db.WithContext(ctx).Model(&RelayedMsg{}).
+		Select("height").
+		Where("layer1_hash != ''").
+		Order("height DESC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("RelayedMsg.GetLatestRelayedHeightOnL1 error: %w", err)
+	}
+	return result.Height, err
+}
+
+// GetLatestRelayedHeightOnL2 get latest relayed height on l2
+func (r *RelayedMsg) GetLatestRelayedHeightOnL2(ctx context.Context) (uint64, error) {
+	var result RelayedMsg
+	err := r.db.WithContext(ctx).Model(&RelayedMsg{}).
+		Select("height").
+		Where("layer2_hash != ''").
+		Order("height DESC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("RelayedMsg.GetLatestRelayedHeightOnL2 error: %w", err)
+	}
+	return result.Height, nil
+}
+
+// InsertRelayedMsg batch insert relayed msg into db and return the transaction
+func (r *RelayedMsg) InsertRelayedMsg(ctx context.Context, messages []*RelayedMsg, dbTx ...*gorm.DB) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	db := r.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&RelayedMsg{}).Create(&messages).Error
+	if err != nil {
+		l2hashes := make([]string, 0, len(messages))
+		l1hashes := make([]string, 0, len(messages))
+		heights := make([]uint64, 0, len(messages))
+		for _, msg := range messages {
+			l2hashes = append(l2hashes, msg.Layer2Hash)
+			l1hashes = append(l1hashes, msg.Layer1Hash)
+			heights = append(heights, msg.Height)
+		}
+		log.Error("failed to insert l2 sent messages", "l2hashes", l2hashes, "l1hashes", l1hashes, "heights", heights, "err", err)
+		return fmt.Errorf("RelayedMsg.InsertRelayedMsg error: %w", err)
+	}
+	return nil
+}
+
+// DeleteL1RelayedHashAfterHeight delete l1 relayed hash after height
+func (r *RelayedMsg) DeleteL1RelayedHashAfterHeight(ctx context.Context, height uint64, dbTx ...*gorm.DB) error {
+	db := r.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&RelayedMsg{}).
+		Delete("height > ? AND layer1_hash != ''", height).Error
+	if err != nil {
+		return fmt.Errorf("RelayedMsg.DeleteL1RelayedHashAfterHeight error: %w", err)
+	}
+	return nil
+}
+
+// DeleteL2RelayedHashAfterHeight delete l2 relayed hash after heights
+func (r *RelayedMsg) DeleteL2RelayedHashAfterHeight(ctx context.Context, height uint64, dbTx ...*gorm.DB) error {
+	db := r.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&RelayedMsg{}).
+		Delete("height > ? AND layer2_hash != ''", height).Error
+	if err != nil {
+		return fmt.Errorf("RelayedMsg.DeleteL2RelayedHashAfterHeight error: %w", err)
+	}
+	return nil
+}

bridge-history-api/service/service.go

@@ -1,238 +0,0 @@
-package service
-
-import (
-	"strconv"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-
-	"bridge-history-api/db"
-	"bridge-history-api/db/orm"
-)
-
-// Finalized the schema of tx finalized infos
-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
-}
-
-// UserClaimInfo the schema of tx claim infos
-type UserClaimInfo struct {
-	From       string `json:"from"`
-	To         string `json:"to"`
-	Value      string `json:"value"`
-	Nonce      string `json:"nonce"`
-	BatchHash  string `json:"batch_hash"`
-	Message    string `json:"message"`
-	Proof      string `json:"proof"`
-	BatchIndex string `json:"batch_index"`
-}
-
-// TxHistoryInfo the schema of tx history infos
-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"`
-	ClaimInfo      *UserClaimInfo `json:"claimInfo"`
-	CreatedAt      *time.Time     `json:"createdTime"`
-}
-
-// HistoryService example service.
-type HistoryService interface {
-	GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error)
-	GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, error)
-	GetClaimableTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, 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
-}
-
-// GetCrossTxClaimInfo get UserClaimInfos by address
-func GetCrossTxClaimInfo(msgHash string, db db.OrmFactory) *UserClaimInfo {
-	l2sentMsg, err := db.GetL2SentMsgByHash(msgHash)
-	if err != nil {
-		log.Debug("GetCrossTxClaimInfo failed", "error", err)
-		return &UserClaimInfo{}
-	}
-	batch, err := db.GetRollupBatchByIndex(l2sentMsg.BatchIndex)
-	if err != nil {
-		log.Debug("GetCrossTxClaimInfo failed", "error", err)
-		return &UserClaimInfo{}
-	}
-	return &UserClaimInfo{
-		From:       l2sentMsg.Sender,
-		To:         l2sentMsg.Target,
-		Value:      l2sentMsg.Value,
-		Nonce:      strconv.FormatUint(l2sentMsg.Nonce, 10),
-		Message:    l2sentMsg.MsgData,
-		Proof:      "0x" + l2sentMsg.MsgProof,
-		BatchHash:  batch.BatchHash,
-		BatchIndex: strconv.FormatUint(l2sentMsg.BatchIndex, 10),
-	}
-
-}
-
-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
-	}
-
-}
-
-// GetClaimableTxsByAddress get all claimable txs under given address
-func (h *historyBackend) GetClaimableTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error) {
-	var txHistories []*TxHistoryInfo
-	total, err := h.db.GetClaimableL2SentMsgByAddressTotalNum(address.Hex())
-	if err != nil || total == 0 {
-		return txHistories, 0, err
-	}
-	results, err := h.db.GetClaimableL2SentMsgByAddressWithOffset(address.Hex(), offset, limit)
-	if err != nil || len(results) == 0 {
-		return txHistories, 0, err
-	}
-	var msgHashList []string
-	for _, result := range results {
-		msgHashList = append(msgHashList, result.MsgHash)
-	}
-	crossMsgs, err := h.db.GetL2CrossMsgByMsgHashList(msgHashList)
-	// crossMsgs can be empty, because they can be emitted by user directly call contract
-	if err != nil {
-		return txHistories, 0, err
-	}
-	crossMsgMap := make(map[string]*orm.CrossMsg)
-	for _, crossMsg := range crossMsgs {
-		crossMsgMap[crossMsg.MsgHash] = crossMsg
-	}
-	for _, result := range results {
-		txInfo := &TxHistoryInfo{
-			Hash:        result.TxHash,
-			IsL1:        false,
-			BlockNumber: result.Height,
-			FinalizeTx:  &Finalized{},
-			ClaimInfo:   GetCrossTxClaimInfo(result.MsgHash, h.db),
-		}
-		if crossMsg, exist := crossMsgMap[result.MsgHash]; exist {
-			txInfo.Amount = crossMsg.Amount
-			txInfo.To = crossMsg.Target
-			txInfo.BlockTimestamp = crossMsg.Timestamp
-			txInfo.CreatedAt = crossMsg.CreatedAt
-		}
-		txHistories = append(txHistories, txInfo)
-	}
-	return txHistories, total, err
-}
-
-// GetTxsByAddress get all txs under given address
-func (h *historyBackend) GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error) {
-	var txHistories []*TxHistoryInfo
-	total, err := h.db.GetTotalCrossMsgCountByAddress(address.String())
-	if err != nil || total == 0 {
-		return txHistories, 0, err
-	}
-	result, err := h.db.GetCrossMsgsByAddressWithOffset(address.String(), offset, limit)
-
-	if err != nil {
-		return nil, 0, err
-	}
-	for _, msg := range result {
-		txHistory := &TxHistoryInfo{
-			Hash:           msg.Layer1Hash + msg.Layer2Hash,
-			Amount:         msg.Amount,
-			To:             msg.Target,
-			IsL1:           msg.MsgType == int(orm.Layer1Msg),
-			BlockNumber:    msg.Height,
-			BlockTimestamp: msg.Timestamp,
-			CreatedAt:      msg.CreatedAt,
-			FinalizeTx: &Finalized{
-				Hash: "",
-			},
-			ClaimInfo: GetCrossTxClaimInfo(msg.MsgHash, h.db),
-		}
-		updateCrossTxHash(msg.MsgHash, txHistory, h.db)
-		txHistories = append(txHistories, txHistory)
-	}
-	return txHistories, total, nil
-}
-
-// GetTxsByHashes get tx infos under given tx hashes
-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,
-				BlockTimestamp: l1result.Timestamp,
-				CreatedAt:      l1result.CreatedAt,
-				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,
-				BlockTimestamp: l2result.Timestamp,
-				CreatedAt:      l2result.CreatedAt,
-				FinalizeTx: &Finalized{
-					Hash: "",
-				},
-				ClaimInfo: GetCrossTxClaimInfo(l2result.MsgHash, h.db),
-			}
-			updateCrossTxHash(l2result.MsgHash, txHistory, h.db)
-			txHistories = append(txHistories, txHistory)
-			continue
-		}
-	}
-	return txHistories, nil
-}

bridge-history-api/utils/database.go

@@ -0,0 +1,103 @@
+package utils
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+	"gorm.io/gorm/utils"
+
+	"bridge-history-api/config"
+)
+
+type gormLogger struct {
+	gethLogger log.Logger
+}
+
+func (g *gormLogger) LogMode(level logger.LogLevel) logger.Interface {
+	return g
+}
+
+func (g *gormLogger) Info(_ context.Context, msg string, data ...interface{}) {
+	infoMsg := fmt.Sprintf(msg, data...)
+	g.gethLogger.Info("gorm", "info message", infoMsg)
+}
+
+func (g *gormLogger) Warn(_ context.Context, msg string, data ...interface{}) {
+	warnMsg := fmt.Sprintf(msg, data...)
+	g.gethLogger.Warn("gorm", "warn message", warnMsg)
+}
+
+func (g *gormLogger) Error(_ context.Context, msg string, data ...interface{}) {
+	errMsg := fmt.Sprintf(msg, data...)
+	g.gethLogger.Error("gorm", "err message", errMsg)
+}
+
+func (g *gormLogger) Trace(_ context.Context, begin time.Time, fc func() (string, int64), err error) {
+	elapsed := time.Since(begin)
+	sql, rowsAffected := fc()
+	g.gethLogger.Debug("gorm", "line", utils.FileWithLineNum(), "cost", elapsed, "sql", sql, "rowsAffected", rowsAffected, "err", err)
+}
+
+// InitDB init the db handler
+func InitDB(config *config.DBConfig) (*gorm.DB, error) {
+	tmpGormLogger := gormLogger{
+		gethLogger: log.Root(),
+	}
+
+	db, err := gorm.Open(postgres.Open(config.DSN), &gorm.Config{
+		Logger: &tmpGormLogger,
+		NowFunc: func() time.Time {
+			// why set time to UTC.
+			// if now set this, the inserted data time will use local timezone. like 2023-07-18 18:24:00 CST+8
+			// but when inserted, store to postgres is 2023-07-18 18:24:00 UTC+0 the timezone is incorrect.
+			// As mysql dsn user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local, we cant set
+			// the timezone by loc=Local. but postgres's dsn don't have loc option to set timezone, so just need set the gorm option like that.
+			t, err := nowUTC()
+			if err != nil {
+				log.Error("Can not get UTC time: ", "err", err)
+			}
+			return t
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	sqlDB.SetMaxOpenConns(config.MaxOpenNum)
+	sqlDB.SetMaxIdleConns(config.MaxIdleNum)
+
+	if err = sqlDB.Ping(); err != nil {
+		return nil, err
+	}
+	return db, nil
+}
+
+// CloseDB close the db handler. notice the db handler only can close when then program exit.
+func CloseDB(db *gorm.DB) error {
+	sqlDB, err := db.DB()
+	if err != nil {
+		return err
+	}
+	if err := sqlDB.Close(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// nowUTC get the utc time.Now
+func nowUTC() (time.Time, error) {
+	utc, err := time.LoadLocation("")
+	if err != nil {
+		return time.Time{}, err
+	}
+	return time.Now().In(utc), nil
+}

bridge-history-api/utils/parse_event.go

@@ -11,7 +11,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 
 	backendabi "bridge-history-api/abi"
-	"bridge-history-api/db/orm"
+	"bridge-history-api/orm"
 )
 
 // CachedParsedTxCalldata store parsed batch infos
@@ -46,6 +46,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Amount:     event.Amount.String(),
 				Asset:      int(orm.ETH),
 				Layer1Hash: vlog.TxHash.Hex(),
+				MsgType:    int(orm.Layer1Msg),
 				MsgHash:    msgHash,
 			})
 		case backendabi.L1DepositERC20Sig:
@@ -64,6 +65,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
+				MsgType:     int(orm.Layer1Msg),
 				MsgHash:     msgHash,
 			})
 		case backendabi.L1DepositERC721Sig:
@@ -82,6 +84,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    event.TokenID.String(),
+				MsgType:     int(orm.Layer1Msg),
 				MsgHash:     msgHash,
 			})
 		case backendabi.L1DepositERC1155Sig:
@@ -101,6 +104,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    event.TokenID.String(),
 				Amount:      event.Amount.String(),
+				MsgType:     int(orm.Layer1Msg),
 				MsgHash:     msgHash,
 			})
 		case backendabi.L1SentMessageEventSignature:
@@ -128,6 +132,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    convertBigIntArrayToString(event.TokenIDs),
+				MsgType:     int(orm.Layer1Msg),
 				MsgHash:     msgHash,
 			})
 		case backendabi.L1BatchDepositERC1155Sig:
@@ -147,6 +152,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Token:  event.L2Token.Hex(),
 				TokenIDs:     convertBigIntArrayToString(event.TokenIDs),
 				TokenAmounts: convertBigIntArrayToString(event.TokenAmounts),
+				MsgType:      int(orm.Layer1Msg),
 				MsgHash:      msgHash,
 			})
 		case backendabi.L1RelayedMessageEventSignature:
@@ -194,6 +200,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Amount:     event.Amount.String(),
 				Asset:      int(orm.ETH),
 				Layer2Hash: vlog.TxHash.Hex(),
+				MsgType:    int(orm.Layer2Msg),
 				MsgHash:    l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
 		case backendabi.L2WithdrawERC20Sig:
@@ -213,6 +220,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
+				MsgType:     int(orm.Layer2Msg),
 				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
 		case backendabi.L2WithdrawERC721Sig:
@@ -232,6 +240,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    event.TokenID.String(),
+				MsgType:     int(orm.Layer2Msg),
 				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
 		case backendabi.L2WithdrawERC1155Sig:
@@ -252,6 +261,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    event.TokenID.String(),
 				Amount:      event.Amount.String(),
+				MsgType:     int(orm.Layer2Msg),
 				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
 		case backendabi.L2BatchWithdrawERC721Sig:
@@ -270,6 +280,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
+				MsgType:     int(orm.Layer2Msg),
 				TokenIDs:    convertBigIntArrayToString(event.TokenIDs),
 				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
@@ -289,6 +300,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Hash:   vlog.TxHash.Hex(),
 				Layer1Token:  event.L1Token.Hex(),
 				Layer2Token:  event.L2Token.Hex(),
+				MsgType:      int(orm.Layer2Msg),
 				TokenIDs:     convertBigIntArrayToString(event.TokenIDs),
 				TokenAmounts: convertBigIntArrayToString(event.TokenAmounts),
 				MsgHash:      l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
@@ -334,7 +346,6 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 // ParseBatchInfoFromScrollChain parses ScrollChain events
 func ParseBatchInfoFromScrollChain(ctx context.Context, client *ethclient.Client, logs []types.Log) ([]*orm.RollupBatch, error) {
 	var rollupBatches []*orm.RollupBatch
-	cache := make(map[string]CachedParsedTxCalldata)
 	for _, vlog := range logs {
 		switch vlog.Topics[0] {
 		case backendabi.L1CommitBatchEventSignature:
@@ -344,42 +355,22 @@ func ParseBatchInfoFromScrollChain(ctx context.Context, client *ethclient.Client
 				log.Warn("Failed to unpack CommitBatch event", "err", err)
 				return rollupBatches, err
 			}
-			if _, ok := cache[vlog.TxHash.Hex()]; ok {
-				c := cache[vlog.TxHash.Hex()]
-				c.CallDataIndex++
-				rollupBatches = append(rollupBatches, &orm.RollupBatch{
-					CommitHeight:     vlog.BlockNumber,
-					BatchIndex:       c.BatchIndices[c.CallDataIndex],
-					BatchHash:        event.BatchHash.Hex(),
-					StartBlockNumber: c.StartBlocks[c.CallDataIndex],
-					EndBlockNumber:   c.EndBlocks[c.CallDataIndex],
-				})
-				cache[vlog.TxHash.Hex()] = c
-				continue
-			}
-
 			commitTx, isPending, err := client.TransactionByHash(ctx, vlog.TxHash)
 			if err != nil || isPending {
 				log.Warn("Failed to get commit Batch tx receipt or the tx is still pending", "err", err)
 				return rollupBatches, err
 			}
-			indices, startBlocks, endBlocks, err := GetBatchRangeFromCalldataV1(commitTx.Data())
+			index, startBlock, endBlock, err := GetBatchRangeFromCalldataV2(commitTx.Data())
 			if err != nil {
 				log.Warn("Failed to get batch range from calldata", "hash", commitTx.Hash().Hex(), "height", vlog.BlockNumber)
 				return rollupBatches, err
 			}
-			cache[vlog.TxHash.Hex()] = CachedParsedTxCalldata{
-				CallDataIndex: 0,
-				BatchIndices:  indices,
-				StartBlocks:   startBlocks,
-				EndBlocks:     endBlocks,
-			}
 			rollupBatches = append(rollupBatches, &orm.RollupBatch{
 				CommitHeight:     vlog.BlockNumber,
-				BatchIndex:       indices[0],
+				BatchIndex:       index,
 				BatchHash:        event.BatchHash.Hex(),
-				StartBlockNumber: startBlocks[0],
-				EndBlockNumber:   endBlocks[0],
+				StartBlockNumber: startBlock,
+				EndBlockNumber:   endBlock,
 			})
 
 		default:

bridge/conf/config.json

@@ -78,14 +78,16 @@
       "max_l1_commit_gas_per_chunk": 11234567,
       "max_l1_commit_calldata_size_per_chunk": 112345,
       "min_l1_commit_calldata_size_per_chunk": 11234,
-      "chunk_timeout_sec": 300
+      "chunk_timeout_sec": 300,
+      "gas_cost_increase_multiplier": 1.2
     },
     "batch_proposer_config": {
       "max_chunk_num_per_batch": 112,
       "max_l1_commit_gas_per_batch": 11234567,
       "max_l1_commit_calldata_size_per_batch": 112345,
       "min_chunk_num_per_batch": 11,
-      "batch_timeout_sec": 300
+      "batch_timeout_sec": 300,
+      "gas_cost_increase_multiplier": 1.2
     }
   },
   "db_config": {

bridge/internal/config/l2.go

@@ -28,19 +28,21 @@ type L2Config struct {
 
 // ChunkProposerConfig loads chunk_proposer configuration items.
 type ChunkProposerConfig struct {
-	MaxTxGasPerChunk                uint64 `json:"max_tx_gas_per_chunk"`
-	MaxL2TxNumPerChunk              uint64 `json:"max_l2_tx_num_per_chunk"`
-	MaxL1CommitGasPerChunk          uint64 `json:"max_l1_commit_gas_per_chunk"`
-	MaxL1CommitCalldataSizePerChunk uint64 `json:"max_l1_commit_calldata_size_per_chunk"`
-	MinL1CommitCalldataSizePerChunk uint64 `json:"min_l1_commit_calldata_size_per_chunk"`
-	ChunkTimeoutSec                 uint64 `json:"chunk_timeout_sec"`
+	MaxTxGasPerChunk                uint64  `json:"max_tx_gas_per_chunk"`
+	MaxL2TxNumPerChunk              uint64  `json:"max_l2_tx_num_per_chunk"`
+	MaxL1CommitGasPerChunk          uint64  `json:"max_l1_commit_gas_per_chunk"`
+	MaxL1CommitCalldataSizePerChunk uint64  `json:"max_l1_commit_calldata_size_per_chunk"`
+	MinL1CommitCalldataSizePerChunk uint64  `json:"min_l1_commit_calldata_size_per_chunk"`
+	ChunkTimeoutSec                 uint64  `json:"chunk_timeout_sec"`
+	GasCostIncreaseMultiplier       float64 `json:"gas_cost_increase_multiplier"`
 }
 
 // BatchProposerConfig loads batch_proposer configuration items.
 type BatchProposerConfig struct {
-	MaxChunkNumPerBatch             uint64 `json:"max_chunk_num_per_batch"`
-	MaxL1CommitGasPerBatch          uint64 `json:"max_l1_commit_gas_per_batch"`
-	MaxL1CommitCalldataSizePerBatch uint32 `json:"max_l1_commit_calldata_size_per_batch"`
-	MinChunkNumPerBatch             uint64 `json:"min_chunk_num_per_batch"`
-	BatchTimeoutSec                 uint64 `json:"batch_timeout_sec"`
+	MaxChunkNumPerBatch             uint64  `json:"max_chunk_num_per_batch"`
+	MaxL1CommitGasPerBatch          uint64  `json:"max_l1_commit_gas_per_batch"`
+	MaxL1CommitCalldataSizePerBatch uint32  `json:"max_l1_commit_calldata_size_per_batch"`
+	MinChunkNumPerBatch             uint64  `json:"min_chunk_num_per_batch"`
+	BatchTimeoutSec                 uint64  `json:"batch_timeout_sec"`
+	GasCostIncreaseMultiplier       float64 `json:"gas_cost_increase_multiplier"`
 }

bridge/internal/config/relayer.go

@@ -109,7 +109,7 @@ func (r *RelayerConfig) UnmarshalJSON(input []byte) error {
 	for _, privStr := range jsonConfig.RollupSenderPrivateKeys {
 		priv, err := crypto.ToECDSA(common.FromHex(privStr))
 		if err != nil {
-			return fmt.Errorf("incorrect roller_private_key format, err: %v", err)
+			return fmt.Errorf("incorrect prover_private_key format, err: %v", err)
 		}
 		r.RollupSenderPrivateKeys = append(r.RollupSenderPrivateKeys, priv)
 	}

bridge/internal/controller/relayer/l2_relayer.go

@@ -171,9 +171,9 @@ func (r *Layer2Relayer) initializeGenesis() error {
 
 	chunk := &types.Chunk{
 		Blocks: []*types.WrappedBlock{{
-			Header:           genesis,
-			Transactions:     nil,
-			WithdrawTrieRoot: common.Hash{},
+			Header:       genesis,
+			Transactions: nil,
+			WithdrawRoot: common.Hash{},
 		}},
 	}
 
@@ -417,7 +417,7 @@ func (r *Layer2Relayer) ProcessCommittedBatches() {
 		// The proof for this block is not ready yet.
 		return
 	case types.ProvingTaskProved:
-		// It's an intermediate state. The roller manager received the proof but has not verified
+		// It's an intermediate state. The prover manager received the proof but has not verified
 		// the proof yet. We don't roll up the proof until it's verified.
 		return
 	case types.ProvingTaskVerified:

bridge/internal/controller/relayer/l2_relayer_test.go

@@ -94,9 +94,8 @@ func testL2RelayerProcessCommittedBatches(t *testing.T) {
 
 	err = batchOrm.UpdateRollupStatus(context.Background(), batch.Hash, types.RollupCommitted)
 	assert.NoError(t, err)
-	proof := &message.AggProof{
-		Proof:     []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
-		FinalPair: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
+	proof := &message.BatchProof{
+		Proof: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
 	}
 	err = batchOrm.UpdateProofByHash(context.Background(), batch.Hash, proof, 100)
 	assert.NoError(t, err)

bridge/internal/controller/watcher/batch_proposer.go

@@ -28,6 +28,7 @@ type BatchProposer struct {
 	maxL1CommitCalldataSizePerBatch uint32
 	minChunkNumPerBatch             uint64
 	batchTimeoutSec                 uint64
+	gasCostIncreaseMultiplier       float64
 }
 
 // NewBatchProposer creates a new BatchProposer instance.
@@ -43,6 +44,7 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, db *
 		maxL1CommitCalldataSizePerBatch: cfg.MaxL1CommitCalldataSizePerBatch,
 		minChunkNumPerBatch:             cfg.MinChunkNumPerBatch,
 		batchTimeoutSec:                 cfg.BatchTimeoutSec,
+		gasCostIncreaseMultiplier:       cfg.GasCostIncreaseMultiplier,
 	}
 }
 
@@ -99,11 +101,40 @@ func (p *BatchProposer) proposeBatchChunks() ([]*orm.Chunk, error) {
 	firstChunk := dbChunks[0]
 	totalL1CommitCalldataSize := firstChunk.TotalL1CommitCalldataSize
 	totalL1CommitGas := firstChunk.TotalL1CommitGas
-	var totalChunks uint64 = 1
+	totalChunks := uint64(1)
+	totalL1MessagePopped := firstChunk.TotalL1MessagesPoppedBefore + uint64(firstChunk.TotalL1MessagesPoppedInChunk)
+
+	parentBatch, err := p.batchOrm.GetLatestBatch(p.ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	getKeccakGas := func(size uint64) uint64 {
+		return 30 + 6*((size+31)/32) // 30 + 6 * ceil(size / 32)
+	}
+
+	// Add extra gas costs
+	totalL1CommitGas += 4 * 2100                                       // 4 one-time cold sload for commitBatch
+	totalL1CommitGas += 20000                                          // 1 time sstore
+	totalL1CommitGas += 16                                             // version in calldata
+	totalL1CommitGas += 16 * (32 * (totalL1MessagePopped + 255) / 256) // _skippedL1MessageBitmap in calldata
+
+	// adjusting gas:
+	// add 1 time cold sload (2100 gas) for L1MessageQueue
+	// add 1 time cold address access (2600 gas) for L1MessageQueue
+	// minus 1 time warm sload (100 gas) & 1 time warm address access (100 gas)
+	totalL1CommitGas += (2100 + 2600 - 100 - 100)
+	totalL1CommitGas += getKeccakGas(32 * totalChunks) // batch data hash
+	if parentBatch != nil {
+		totalL1CommitGas += getKeccakGas(uint64(len(parentBatch.BatchHeader))) // parent batch header hash
+		totalL1CommitGas += 16 * uint64(len(parentBatch.BatchHeader))          // parent batch header in calldata
+	}
+	// batch header size: 89 + 32 * ceil(l1MessagePopped / 256)
+	totalL1CommitGas += getKeccakGas(89 + 32*(totalL1MessagePopped+255)/256)
 
 	// Check if the first chunk breaks hard limits.
 	// If so, it indicates there are bugs in chunk-proposer, manual fix is needed.
-	if totalL1CommitGas > p.maxL1CommitGasPerBatch {
+	if p.gasCostIncreaseMultiplier*float64(totalL1CommitGas) > float64(p.maxL1CommitGasPerBatch) {
 		return nil, fmt.Errorf(
 			"the first chunk exceeds l1 commit gas limit; start block number: %v, end block number: %v, commit gas: %v, max commit gas limit: %v",
 			firstChunk.StartBlockNumber,
@@ -124,12 +155,21 @@ func (p *BatchProposer) proposeBatchChunks() ([]*orm.Chunk, error) {
 	}
 
 	for i, chunk := range dbChunks[1:] {
-		totalChunks++
 		totalL1CommitCalldataSize += chunk.TotalL1CommitCalldataSize
 		totalL1CommitGas += chunk.TotalL1CommitGas
+		// adjust batch data hash gas cost
+		totalL1CommitGas -= getKeccakGas(32 * totalChunks)
+		totalChunks++
+		totalL1CommitGas += getKeccakGas(32 * totalChunks)
+		// adjust batch header hash gas cost
+		totalL1CommitGas -= getKeccakGas(89 + 32*(totalL1MessagePopped+255)/256)
+		totalL1CommitGas -= 16 * (32 * (totalL1MessagePopped + 255) / 256)
+		totalL1MessagePopped += uint64(chunk.TotalL1MessagesPoppedInChunk)
+		totalL1CommitGas += 16 * (32 * (totalL1MessagePopped + 255) / 256)
+		totalL1CommitGas += getKeccakGas(89 + 32*(totalL1MessagePopped+255)/256)
 		if totalChunks > p.maxChunkNumPerBatch ||
 			totalL1CommitCalldataSize > p.maxL1CommitCalldataSizePerBatch ||
-			totalL1CommitGas > p.maxL1CommitGasPerBatch {
+			p.gasCostIncreaseMultiplier*float64(totalL1CommitGas) > float64(p.maxL1CommitGasPerBatch) {
 			return dbChunks[:i+1], nil
 		}
 	}

bridge/internal/controller/watcher/chunk_proposer.go

@@ -28,6 +28,7 @@ type ChunkProposer struct {
 	maxL1CommitCalldataSizePerChunk uint64
 	minL1CommitCalldataSizePerChunk uint64
 	chunkTimeoutSec                 uint64
+	gasCostIncreaseMultiplier       float64
 }
 
 // NewChunkProposer creates a new ChunkProposer instance.
@@ -43,6 +44,7 @@ func NewChunkProposer(ctx context.Context, cfg *config.ChunkProposerConfig, db *
 		maxL1CommitCalldataSizePerChunk: cfg.MaxL1CommitCalldataSizePerChunk,
 		minL1CommitCalldataSizePerChunk: cfg.MinL1CommitCalldataSizePerChunk,
 		chunkTimeoutSec:                 cfg.ChunkTimeoutSec,
+		gasCostIncreaseMultiplier:       cfg.GasCostIncreaseMultiplier,
 	}
 }
 
@@ -88,11 +90,12 @@ func (p *ChunkProposer) proposeChunk() (*types.Chunk, error) {
 		return nil, nil
 	}
 
-	firstBlock := blocks[0]
+	chunk := &types.Chunk{Blocks: blocks[:1]}
+	firstBlock := chunk.Blocks[0]
 	totalTxGasUsed := firstBlock.Header.GasUsed
 	totalL2TxNum := firstBlock.L2TxsNum()
 	totalL1CommitCalldataSize := firstBlock.EstimateL1CommitCalldataSize()
-	totalL1CommitGas := firstBlock.EstimateL1CommitGas()
+	totalL1CommitGas := chunk.EstimateL1CommitGas()
 
 	// Check if the first block breaks hard limits.
 	// If so, it indicates there are bugs in sequencer, manual fix is needed.
@@ -105,7 +108,7 @@ func (p *ChunkProposer) proposeChunk() (*types.Chunk, error) {
 		)
 	}
 
-	if totalL1CommitGas > p.maxL1CommitGasPerChunk {
+	if p.gasCostIncreaseMultiplier*float64(totalL1CommitGas) > float64(p.maxL1CommitGasPerChunk) {
 		return nil, fmt.Errorf(
 			"the first block exceeds l1 commit gas limit; block number: %v, commit gas: %v, max commit gas limit: %v",
 			firstBlock.Header.Number,
@@ -133,16 +136,17 @@ func (p *ChunkProposer) proposeChunk() (*types.Chunk, error) {
 		)
 	}
 
-	for i, block := range blocks[1:] {
+	for _, block := range blocks[1:] {
+		chunk.Blocks = append(chunk.Blocks, block)
 		totalTxGasUsed += block.Header.GasUsed
 		totalL2TxNum += block.L2TxsNum()
 		totalL1CommitCalldataSize += block.EstimateL1CommitCalldataSize()
-		totalL1CommitGas += block.EstimateL1CommitGas()
+		totalL1CommitGas = chunk.EstimateL1CommitGas()
 		if totalTxGasUsed > p.maxTxGasPerChunk ||
 			totalL2TxNum > p.maxL2TxNumPerChunk ||
 			totalL1CommitCalldataSize > p.maxL1CommitCalldataSizePerChunk ||
-			totalL1CommitGas > p.maxL1CommitGasPerChunk {
-			blocks = blocks[:i+1]
+			p.gasCostIncreaseMultiplier*float64(totalL1CommitGas) > float64(p.maxL1CommitGasPerChunk) {
+			chunk.Blocks = chunk.Blocks[:len(chunk.Blocks)-1] // remove the last block from chunk
 			break
 		}
 	}
@@ -165,5 +169,5 @@ func (p *ChunkProposer) proposeChunk() (*types.Chunk, error) {
 		)
 		return nil, nil
 	}
-	return &types.Chunk{Blocks: blocks}, nil
+	return chunk, nil
 }

bridge/internal/controller/watcher/l2_watcher.go

@@ -169,15 +169,15 @@ func (w *L2WatcherClient) getAndStoreBlockTraces(ctx context.Context, from, to u
 
 		log.Info("retrieved block", "height", block.Header().Number, "hash", block.Header().Hash().String())
 
-		withdrawTrieRoot, err3 := w.StorageAt(ctx, w.messageQueueAddress, w.withdrawTrieRootSlot, big.NewInt(int64(number)))
+		withdrawRoot, err3 := w.StorageAt(ctx, w.messageQueueAddress, w.withdrawTrieRootSlot, big.NewInt(int64(number)))
 		if err3 != nil {
-			return fmt.Errorf("failed to get withdrawTrieRoot: %v. number: %v", err3, number)
+			return fmt.Errorf("failed to get withdrawRoot: %v. number: %v", err3, number)
 		}
 
 		blocks = append(blocks, &types.WrappedBlock{
-			Header:           block.Header(),
-			Transactions:     txsToTxsData(block.Transactions()),
-			WithdrawTrieRoot: common.BytesToHash(withdrawTrieRoot),
+			Header:       block.Header(),
+			Transactions: txsToTxsData(block.Transactions()),
+			WithdrawRoot: common.BytesToHash(withdrawRoot),
 		})
 	}
 

bridge/internal/orm/batch.go

@@ -30,6 +30,7 @@ type Batch struct {
 	EndChunkHash    string `json:"end_chunk_hash" gorm:"column:end_chunk_hash"`
 	StateRoot       string `json:"state_root" gorm:"column:state_root"`
 	WithdrawRoot    string `json:"withdraw_root" gorm:"column:withdraw_root"`
+	ParentBatchHash string `json:"parent_batch_hash" gorm:"column:parent_batch_hash"`
 	BatchHeader     []byte `json:"batch_header" gorm:"column:batch_header"`
 
 	// proof
@@ -107,7 +108,7 @@ func (o *Batch) GetBatchCount(ctx context.Context) (uint64, error) {
 }
 
 // GetVerifiedProofByHash retrieves the verified aggregate proof for a batch with the given hash.
-func (o *Batch) GetVerifiedProofByHash(ctx context.Context, hash string) (*message.AggProof, error) {
+func (o *Batch) GetVerifiedProofByHash(ctx context.Context, hash string) (*message.BatchProof, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&Batch{})
 	db = db.Select("proof")
@@ -118,7 +119,7 @@ func (o *Batch) GetVerifiedProofByHash(ctx context.Context, hash string) (*messa
 		return nil, fmt.Errorf("Batch.GetVerifiedProofByHash error: %w, batch hash: %v", err, hash)
 	}
 
-	var proof message.AggProof
+	var proof message.BatchProof
 	if err := json.Unmarshal(batch.Proof, &proof); err != nil {
 		return nil, fmt.Errorf("Batch.GetVerifiedProofByHash error: %w, batch hash: %v", err, hash)
 	}
@@ -133,6 +134,9 @@ func (o *Batch) GetLatestBatch(ctx context.Context) (*Batch, error) {
 
 	var latestBatch Batch
 	if err := db.First(&latestBatch).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
 		return nil, fmt.Errorf("Batch.GetLatestBatch error: %w", err)
 	}
 	return &latestBatch, nil
@@ -211,7 +215,7 @@ func (o *Batch) InsertBatch(ctx context.Context, startChunkIndex, endChunkIndex
 	}
 
 	parentBatch, err := o.GetLatestBatch(ctx)
-	if err != nil && !errors.Is(errors.Unwrap(err), gorm.ErrRecordNotFound) {
+	if err != nil {
 		log.Error("failed to get the latest batch", "err", err)
 		return nil, err
 	}
@@ -258,7 +262,8 @@ func (o *Batch) InsertBatch(ctx context.Context, startChunkIndex, endChunkIndex
 		EndChunkHash:      endChunkHash,
 		EndChunkIndex:     endChunkIndex,
 		StateRoot:         chunks[numChunks-1].Blocks[lastChunkBlockNum-1].Header.Root.Hex(),
-		WithdrawRoot:      chunks[numChunks-1].Blocks[lastChunkBlockNum-1].WithdrawTrieRoot.Hex(),
+		WithdrawRoot:      chunks[numChunks-1].Blocks[lastChunkBlockNum-1].WithdrawRoot.Hex(),
+		ParentBatchHash:   parentBatchHash.Hex(),
 		BatchHeader:       batchHeader.Encode(),
 		ChunkProofsStatus: int16(types.ChunkProofsStatusPending),
 		ProvingStatus:     int16(types.ProvingTaskUnassigned),
@@ -390,7 +395,7 @@ func (o *Batch) UpdateFinalizeTxHashAndRollupStatus(ctx context.Context, hash st
 
 // UpdateProofByHash updates the batch proof by hash.
 // for unit test.
-func (o *Batch) UpdateProofByHash(ctx context.Context, hash string, proof *message.AggProof, proofTimeSec uint64) error {
+func (o *Batch) UpdateProofByHash(ctx context.Context, hash string, proof *message.BatchProof, proofTimeSec uint64) error {
 	proofBytes, err := json.Marshal(proof)
 	if err != nil {
 		return fmt.Errorf("Batch.UpdateProofByHash error: %w, batch hash: %v", err, hash)

bridge/internal/orm/chunk.go

@@ -26,6 +26,10 @@ type Chunk struct {
 	StartBlockTime               uint64 `json:"start_block_time" gorm:"column:start_block_time"`
 	TotalL1MessagesPoppedBefore  uint64 `json:"total_l1_messages_popped_before" gorm:"column:total_l1_messages_popped_before"`
 	TotalL1MessagesPoppedInChunk uint32 `json:"total_l1_messages_popped_in_chunk" gorm:"column:total_l1_messages_popped_in_chunk"`
+	ParentChunkHash              string `json:"parent_chunk_hash" gorm:"column:parent_chunk_hash"`
+	StateRoot                    string `json:"state_root" gorm:"column:state_root"`
+	ParentChunkStateRoot         string `json:"parent_chunk_state_root" gorm:"column:parent_chunk_state_root"`
+	WithdrawRoot                 string `json:"withdraw_root" gorm:"column:withdraw_root"`
 
 	// proof
 	ProvingStatus    int16      `json:"proving_status" gorm:"column:proving_status;default:1"`
@@ -118,6 +122,8 @@ func (o *Chunk) InsertChunk(ctx context.Context, chunk *types.Chunk, dbTX ...*go
 
 	var chunkIndex uint64
 	var totalL1MessagePoppedBefore uint64
+	var parentChunkHash string
+	var parentChunkStateRoot string
 	parentChunk, err := o.GetLatestChunk(ctx)
 	if err != nil && !errors.Is(errors.Unwrap(err), gorm.ErrRecordNotFound) {
 		log.Error("failed to get latest chunk", "err", err)
@@ -130,6 +136,8 @@ func (o *Chunk) InsertChunk(ctx context.Context, chunk *types.Chunk, dbTX ...*go
 	if parentChunk != nil {
 		chunkIndex = parentChunk.Index + 1
 		totalL1MessagePoppedBefore = parentChunk.TotalL1MessagesPoppedBefore + uint64(parentChunk.TotalL1MessagesPoppedInChunk)
+		parentChunkHash = parentChunk.Hash
+		parentChunkStateRoot = parentChunk.StateRoot
 	}
 
 	hash, err := chunk.Hash(totalL1MessagePoppedBefore)
@@ -141,12 +149,10 @@ func (o *Chunk) InsertChunk(ctx context.Context, chunk *types.Chunk, dbTX ...*go
 	var totalL2TxGas uint64
 	var totalL2TxNum uint64
 	var totalL1CommitCalldataSize uint64
-	var totalL1CommitGas uint64
 	for _, block := range chunk.Blocks {
 		totalL2TxGas += block.Header.GasUsed
 		totalL2TxNum += block.L2TxsNum()
 		totalL1CommitCalldataSize += block.EstimateL1CommitCalldataSize()
-		totalL1CommitGas += block.EstimateL1CommitGas()
 	}
 
 	numBlocks := len(chunk.Blocks)
@@ -160,10 +166,14 @@ func (o *Chunk) InsertChunk(ctx context.Context, chunk *types.Chunk, dbTX ...*go
 		TotalL2TxGas:                 totalL2TxGas,
 		TotalL2TxNum:                 uint32(totalL2TxNum),
 		TotalL1CommitCalldataSize:    uint32(totalL1CommitCalldataSize),
-		TotalL1CommitGas:             totalL1CommitGas,
+		TotalL1CommitGas:             chunk.EstimateL1CommitGas(),
 		StartBlockTime:               chunk.Blocks[0].Header.Time,
 		TotalL1MessagesPoppedBefore:  totalL1MessagePoppedBefore,
 		TotalL1MessagesPoppedInChunk: uint32(chunk.NumL1Messages(totalL1MessagePoppedBefore)),
+		ParentChunkHash:              parentChunkHash,
+		StateRoot:                    chunk.Blocks[numBlocks-1].Header.Root.Hex(),
+		ParentChunkStateRoot:         parentChunkStateRoot,
+		WithdrawRoot:                 chunk.Blocks[numBlocks-1].WithdrawRoot.Hex(),
 		ProvingStatus:                int16(types.ProvingTaskUnassigned),
 	}
 

bridge/internal/orm/l2_block.go

@@ -19,15 +19,16 @@ type L2Block struct {
 	db *gorm.DB `gorm:"column:-"`
 
 	// block
-	Number           uint64 `json:"number" gorm:"number"`
-	Hash             string `json:"hash" gorm:"hash"`
-	ParentHash       string `json:"parent_hash" gorm:"parent_hash"`
-	Header           string `json:"header" gorm:"header"`
-	Transactions     string `json:"transactions" gorm:"transactions"`
-	WithdrawTrieRoot string `json:"withdraw_trie_root" gorm:"withdraw_trie_root"`
-	TxNum            uint32 `json:"tx_num" gorm:"tx_num"`
-	GasUsed          uint64 `json:"gas_used" gorm:"gas_used"`
-	BlockTimestamp   uint64 `json:"block_timestamp" gorm:"block_timestamp"`
+	Number         uint64 `json:"number" gorm:"number"`
+	Hash           string `json:"hash" gorm:"hash"`
+	ParentHash     string `json:"parent_hash" gorm:"parent_hash"`
+	Header         string `json:"header" gorm:"header"`
+	Transactions   string `json:"transactions" gorm:"transactions"`
+	WithdrawRoot   string `json:"withdraw_root" gorm:"withdraw_root"`
+	StateRoot      string `json:"state_root" gorm:"state_root"`
+	TxNum          uint32 `json:"tx_num" gorm:"tx_num"`
+	GasUsed        uint64 `json:"gas_used" gorm:"gas_used"`
+	BlockTimestamp uint64 `json:"block_timestamp" gorm:"block_timestamp"`
 
 	// chunk
 	ChunkHash string `json:"chunk_hash" gorm:"chunk_hash;default:NULL"`
@@ -67,7 +68,7 @@ func (o *L2Block) GetL2BlocksLatestHeight(ctx context.Context) (uint64, error) {
 func (o *L2Block) GetUnchunkedBlocks(ctx context.Context) ([]*types.WrappedBlock, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&L2Block{})
-	db = db.Select("header, transactions, withdraw_trie_root")
+	db = db.Select("header, transactions, withdraw_root")
 	db = db.Where("chunk_hash IS NULL")
 	db = db.Order("number ASC")
 
@@ -89,7 +90,7 @@ func (o *L2Block) GetUnchunkedBlocks(ctx context.Context) ([]*types.WrappedBlock
 			return nil, fmt.Errorf("L2Block.GetUnchunkedBlocks error: %w", err)
 		}
 
-		wrappedBlock.WithdrawTrieRoot = common.HexToHash(v.WithdrawTrieRoot)
+		wrappedBlock.WithdrawRoot = common.HexToHash(v.WithdrawRoot)
 		wrappedBlocks = append(wrappedBlocks, &wrappedBlock)
 	}
 
@@ -133,7 +134,7 @@ func (o *L2Block) GetL2BlocksInRange(ctx context.Context, startBlockNumber uint6
 
 	db := o.db.WithContext(ctx)
 	db = db.Model(&L2Block{})
-	db = db.Select("header, transactions, withdraw_trie_root")
+	db = db.Select("header, transactions, withdraw_root")
 	db = db.Where("number >= ? AND number <= ?", startBlockNumber, endBlockNumber)
 	db = db.Order("number ASC")
 
@@ -160,7 +161,7 @@ func (o *L2Block) GetL2BlocksInRange(ctx context.Context, startBlockNumber uint6
 			return nil, fmt.Errorf("L2Block.GetL2BlocksInRange error: %w, start block: %v, end block: %v", err, startBlockNumber, endBlockNumber)
 		}
 
-		wrappedBlock.WithdrawTrieRoot = common.HexToHash(v.WithdrawTrieRoot)
+		wrappedBlock.WithdrawRoot = common.HexToHash(v.WithdrawRoot)
 		wrappedBlocks = append(wrappedBlocks, &wrappedBlock)
 	}
 
@@ -184,15 +185,16 @@ func (o *L2Block) InsertL2Blocks(ctx context.Context, blocks []*types.WrappedBlo
 		}
 
 		l2Block := L2Block{
-			Number:           block.Header.Number.Uint64(),
-			Hash:             block.Header.Hash().String(),
-			ParentHash:       block.Header.ParentHash.String(),
-			Transactions:     string(txs),
-			WithdrawTrieRoot: block.WithdrawTrieRoot.Hex(),
-			TxNum:            uint32(len(block.Transactions)),
-			GasUsed:          block.Header.GasUsed,
-			BlockTimestamp:   block.Header.Time,
-			Header:           string(header),
+			Number:         block.Header.Number.Uint64(),
+			Hash:           block.Header.Hash().String(),
+			ParentHash:     block.Header.ParentHash.String(),
+			Transactions:   string(txs),
+			WithdrawRoot:   block.WithdrawRoot.Hex(),
+			StateRoot:      block.Header.Root.Hex(),
+			TxNum:          uint32(len(block.Transactions)),
+			GasUsed:        block.Header.GasUsed,
+			BlockTimestamp: block.Header.Time,
+			Header:         string(header),
 		}
 		l2Blocks = append(l2Blocks, l2Block)
 	}

bridge/mock_bridge/MockBridgeL1.sol

@@ -60,8 +60,8 @@ contract MockBridgeL1 {
 
   /// @notice Emitted when a batch is finalized.
   /// @param batchHash The hash of the batch
-  /// @param stateRoot The state root in layer 2 after this batch.
-  /// @param withdrawRoot The merkle root in layer2 after this batch.
+  /// @param stateRoot The state root on layer 2 after this batch.
+  /// @param withdrawRoot The merkle root on layer2 after this batch.
   event FinalizeBatch(bytes32 indexed batchHash, bytes32 stateRoot, bytes32 withdrawRoot);
 
   /***********

bridge/tests/gas_oracle_test.go

@@ -80,8 +80,8 @@ func testImportL2GasPrice(t *testing.T) {
 					Difficulty: big.NewInt(0),
 					BaseFee:    big.NewInt(0),
 				},
-				Transactions:     nil,
-				WithdrawTrieRoot: common.Hash{},
+				Transactions: nil,
+				WithdrawRoot: common.Hash{},
 			},
 		},
 	}

bridge/tests/rollup_test.go

@@ -45,9 +45,9 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 			BaseFee:    big.NewInt(0),
 		}
 		wrappedBlocks = append(wrappedBlocks, &types.WrappedBlock{
-			Header:           &header,
-			Transactions:     nil,
-			WithdrawTrieRoot: common.Hash{},
+			Header:       &header,
+			Transactions: nil,
+			WithdrawRoot: common.Hash{},
 		})
 	}
 
@@ -104,9 +104,8 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 	assert.Equal(t, types.RollupCommitted, statuses[0])
 
 	// add dummy proof
-	proof := &message.AggProof{
-		Proof:     []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
-		FinalPair: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
+	proof := &message.BatchProof{
+		Proof: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
 	}
 	err = batchOrm.UpdateProofByHash(context.Background(), batchHash, proof, 100)
 	assert.NoError(t, err)

build/.golangci.yml

@@ -75,6 +75,10 @@ linters-settings:
     # report about shadowed variables
     check-shadowing: true
 
+  gosec:
+    disable:
+      - G108
+
   golint:
     # minimal confidence for issues, default is 0.8
     min-confidence: 0.8
@@ -227,7 +231,12 @@ issues:
         - lll
       source: "^//go:generate "
       text: "long-lines"
-    
+
+    # Exclude gosec issues for G108: Profiling endpoint is automatically exposed
+    - linters:
+        - gosec
+      text: "G108"
+
     - linters:
         - wsl
       text: "return statements should not be cuddled if block has more than two lines"

build/dockerfiles/coordinator.Dockerfile

@@ -1,5 +1,5 @@
 # Build libzkp dependency
-FROM scrolltech/go-rust-builder:go-1.18-rust-nightly-2022-12-10 as chef
+FROM scrolltech/go-rust-builder:go-1.19-rust-nightly-2022-12-10 as chef
 WORKDIR app
 
 FROM chef as planner
@@ -17,14 +17,15 @@ RUN find ./ | grep libzktrie.so | xargs -I{} cp {} /app/target/release/
 
 
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.18-rust-nightly-2022-12-10 as base
+FROM scrolltech/go-rust-builder:go-1.19-rust-nightly-2022-12-10 as base
 WORKDIR /src
 COPY go.work* ./
 COPY ./bridge/go.* ./bridge/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
@@ -33,17 +34,17 @@ RUN go mod download -x
 # Build coordinator
 FROM base as builder
 COPY . .
-RUN cp -r ./common/libzkp/interface ./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/
+RUN cp -r ./common/libzkp/interface ./coordinator/internal/logic/verifier/lib
+COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/internal/logic/verifier/lib/
+COPY --from=zkp-builder /app/target/release/libzktrie.so ./coordinator/internal/logic/verifier/lib/
+RUN cd ./coordinator && go build -v -p 4 -o /bin/coordinator ./cmd && mv internal/logic/verifier/lib /bin/
 
 # Pull coordinator into a second stage deploy alpine container
 FROM ubuntu:20.04
-ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/src/coordinator/verifier/lib
+ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/src/coordinator/internal/logic/verifier/lib
 # ENV CHAIN_ID=534353
-RUN mkdir -p /src/coordinator/verifier/lib
-COPY --from=builder /bin/lib /src/coordinator/verifier/lib
+RUN mkdir -p /src/coordinator/internal/logic/verifier/lib
+COPY --from=builder /bin/lib /src/coordinator/internal/logic/verifier/lib
 COPY --from=builder /bin/coordinator /bin/
 
 

build/dockerfiles/db_cli.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.18 as base
+FROM scrolltech/go-alpine-builder:1.19 as base
 
 WORKDIR /src
 COPY go.work* ./
@@ -7,7 +7,8 @@ COPY ./bridge/go.* ./bridge/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x

build/dockerfiles/event_watcher.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.18 as base
+FROM scrolltech/go-alpine-builder:1.19 as base
 
 WORKDIR /src
 COPY go.work* ./
@@ -7,7 +7,8 @@ COPY ./bridge/go.* ./bridge/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x

build/dockerfiles/gas_oracle.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.18 as base
+FROM scrolltech/go-alpine-builder:1.19 as base
 
 WORKDIR /src
 COPY go.work* ./
@@ -7,7 +7,8 @@ COPY ./bridge/go.* ./bridge/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x

build/dockerfiles/local_testing.Dockerfile

@@ -1,5 +1,5 @@
 # Start from the latest golang base image
-FROM golang:1.18
+FROM golang:1.19
 
 # Install Docker
 RUN apt-get update && apt-get install -y docker.io

build/dockerfiles/msg_relayer.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.18 as base
+FROM scrolltech/go-alpine-builder:1.19 as base
 
 WORKDIR /src
 COPY go.work* ./
@@ -7,7 +7,8 @@ COPY ./bridge/go.* ./bridge/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x

build/dockerfiles/rollup_relayer.Dockerfile

@@ -1,5 +1,5 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.18 as base
+FROM scrolltech/go-alpine-builder:1.19 as base
 
 WORKDIR /src
 COPY go.work* ./
@@ -7,7 +7,8 @@ COPY ./bridge/go.* ./bridge/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x

build/run_tests.sh

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

codecov.yml

@@ -31,7 +31,7 @@ flag_management:
         - type: project
           target: auto
           threshold: 1%
-    - name: roller
+    - name: prover
       statuses:
         - type: project
           target: auto

common/database/db.go

@@ -10,6 +10,8 @@ import (
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 	"gorm.io/gorm/utils"
+
+	cutils "scroll-tech/common/utils"
 )
 
 type gormLogger struct {
@@ -49,6 +51,14 @@ func InitDB(config *Config) (*gorm.DB, error) {
 
 	db, err := gorm.Open(postgres.Open(config.DSN), &gorm.Config{
 		Logger: &tmpGormLogger,
+		NowFunc: func() time.Time {
+			// why set time to UTC.
+			// if now set this, the inserted data time will use local timezone. like 2023-07-18 18:24:00 CST+8
+			// but when inserted, store to postgres is 2023-07-18 18:24:00 UTC+0 the timezone is incorrect.
+			// As mysql dsn user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local, we cant set
+			// the timezone by loc=Local. but postgres's dsn don't have loc option to set timezone, so just need set the gorm option like that.
+			return cutils.NowUTC()
+		},
 	})
 	if err != nil {
 		return nil, err

common/docker/docker_db.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
 
 	"scroll-tech/common/cmd"
 	"scroll-tech/common/utils"
@@ -65,8 +66,12 @@ func (i *ImgDB) Stop() error {
 	if i.id == "" {
 		i.id = GetContainerID(i.name)
 	}
-	timeout := time.Second * 3
-	if err := cli.ContainerStop(ctx, i.id, &timeout); err != nil {
+
+	timeoutSec := 3
+	timeout := container.StopOptions{
+		Timeout: &timeoutSec,
+	}
+	if err := cli.ContainerStop(ctx, i.id, timeout); err != nil {
 		return err
 	}
 	// remove the stopped container.

common/docker/docker_geth.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 
 	"scroll-tech/common/cmd"
@@ -135,8 +136,11 @@ func (i *ImgGeth) Stop() error {
 	// check if container is running, stop the running container.
 	id := GetContainerID(i.name)
 	if id != "" {
-		timeout := time.Second * 3
-		if err := cli.ContainerStop(ctx, id, &timeout); err != nil {
+		timeoutSec := 3
+		timeout := container.StopOptions{
+			Timeout: &timeoutSec,
+		}
+		if err := cli.ContainerStop(ctx, id, timeout); err != nil {
 			return err
 		}
 		i.id = id

common/go.mod

@@ -3,9 +3,9 @@ module scroll-tech/common
 go 1.19
 
 require (
-	github.com/docker/docker v20.10.21+incompatible
+	github.com/docker/docker v23.0.6+incompatible
 	github.com/jmoiron/sqlx v1.3.5
-	github.com/lib/pq v1.10.7
+	github.com/lib/pq v1.10.9
 	github.com/mattn/go-colorable v0.1.13
 	github.com/mattn/go-isatty v0.0.19
 	github.com/modern-go/reflect2 v1.0.2
@@ -18,7 +18,8 @@ require (
 )
 
 require (
-	github.com/Microsoft/go-winio v0.6.0 // indirect
+	github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 // indirect
+	github.com/Microsoft/go-winio v0.6.1 // indirect
 	github.com/VictoriaMetrics/fastcache v1.6.0 // indirect
 	github.com/btcsuite/btcd v0.20.1-beta // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
@@ -36,7 +37,7 @@ require (
 	github.com/go-kit/kit v0.9.0 // indirect
 	github.com/go-logfmt/logfmt v0.5.1 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
-	github.com/go-sql-driver/mysql v1.7.0 // indirect
+	github.com/go-sql-driver/mysql v1.7.1 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
@@ -55,23 +56,23 @@ require (
 	github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
-	github.com/jackc/pgx/v5 v5.3.0 // indirect
+	github.com/jackc/pgx/v5 v5.3.1 // indirect
 	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/julienschmidt/httprouter v1.3.0 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/mattn/go-runewidth v0.0.14 // indirect
-	github.com/mattn/go-sqlite3 v1.14.14 // indirect
+	github.com/mattn/go-sqlite3 v1.14.16 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/mitchellh/pointerstructure v1.2.0 // indirect
-	github.com/moby/term v0.0.0-20220808134915-39b0c02b01ae // indirect
+	github.com/moby/term v0.5.0 // indirect
 	github.com/morikuni/aec v1.0.0 // 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/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.0.2 // indirect
+	github.com/opencontainers/image-spec v1.1.0-rc3 // 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
@@ -84,7 +85,6 @@ require (
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/scroll-tech/zktrie v0.5.3 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
-	github.com/sirupsen/logrus v1.9.0 // indirect
 	github.com/status-im/keycard-go v0.2.0 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
 	github.com/tklauser/go-sysconf v0.3.11 // indirect

common/go.sum

@@ -18,13 +18,13 @@ cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiy
 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/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8=
-github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
-github.com/Microsoft/go-winio v0.6.0 h1:slsWYD/zyx7lCXoZVlvQrj0hPTM1HI4+v1sIda2yDvg=
-github.com/Microsoft/go-winio v0.6.0/go.mod h1:cTAf44im0RAYeL23bpB+fzCyDH2MJiz2BO69KH/soAE=
+github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
+github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o=
 github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw=
@@ -63,7 +63,6 @@ github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDk
 github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/creack/pty v1.1.11/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
 github.com/dave/jennifer v1.2.0/go.mod h1:fIb+770HOpJ2fmN9EPPKOqm1vMGhB+TwXKMZhrIygKg=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -80,8 +79,8 @@ github.com/dgryski/go-bitstream v0.0.0-20180413035011-3522498ce2c8/go.mod h1:VMa
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
 github.com/docker/distribution v2.8.1+incompatible h1:Q50tZOPR6T/hjNsyc9g8/syEs6bk8XXApsHjKukMl68=
 github.com/docker/distribution v2.8.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
-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/docker/docker v23.0.6+incompatible h1:aBD4np894vatVX99UTx/GyOUOK4uEcROwA3+bQhEcoU=
+github.com/docker/docker v23.0.6+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKohAFqRJQ=
 github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
 github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
@@ -121,8 +120,8 @@ github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34
 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-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
+github.com/go-sql-driver/mysql v1.7.1/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=
@@ -216,8 +215,9 @@ github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsI
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.3.0 h1:/NQi8KHMpKWHInxXesC8yD4DhkXPrVhmnwYkjp9AmBA=
 github.com/jackc/pgx/v5 v5.3.0/go.mod h1:t3JDKnCBlYIc0ewLF0Q7B8MXmoIaBOZj/ic7iHozM/8=
+github.com/jackc/pgx/v5 v5.3.1 h1:Fcr8QJ1ZeLi5zsPZqQeUZhNhxfkkKBOgJuYkJHoBOtU=
+github.com/jackc/pgx/v5 v5.3.1/go.mod h1:t3JDKnCBlYIc0ewLF0Q7B8MXmoIaBOZj/ic7iHozM/8=
 github.com/jackc/puddle/v2 v2.2.0/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 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=
@@ -263,8 +263,8 @@ github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL
 github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
 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/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 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/matryer/moq v0.0.0-20190312154309-6cfb0558e1bd/go.mod h1:9ELz6aaclSIGnZBoaSLZ3NAl1VTufbOrXBPvtcy6WiQ=
@@ -287,8 +287,8 @@ github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWV
 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-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
+github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
 github.com/mattn/go-tty v0.0.0-20180907095812-13ff1204f104/go.mod h1:XPvLUNfbS4fJH25nqRHfWLMa1ONC8Amw+mIA639KxkE=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
@@ -296,8 +296,8 @@ github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyua
 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/moby/term v0.0.0-20220808134915-39b0c02b01ae h1:O4SWKdcHVCvYqyDV+9CJA1fcDN2L11Bule0iFy3YlAI=
-github.com/moby/term v0.0.0-20220808134915-39b0c02b01ae/go.mod h1:E2VnQOmVuvZB6UYnnDB0qG5Nq/1tD9acaOpo6xmt0Kw=
+github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
+github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
@@ -325,8 +325,8 @@ 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=
-github.com/opencontainers/image-spec v1.0.2/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0=
+github.com/opencontainers/image-spec v1.1.0-rc3 h1:fzg1mXZFj8YdPeNkRXMg+zb88BFV0Ys52cJydRwBkb8=
+github.com/opencontainers/image-spec v1.1.0-rc3/go.mod h1:X4pATf0uXsnn3g5aiGIsVnJBR4mxhKzfwmvK/B2NTm8=
 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=
@@ -384,8 +384,6 @@ github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAm
 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/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-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=
@@ -563,7 +561,6 @@ golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/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-20220722155257-8c9f86f7a55f/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=
@@ -606,7 +603,6 @@ golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBn
 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-20190624222133-a101b041ded4/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=
@@ -699,7 +695,6 @@ gorm.io/driver/postgres v1.5.0/go.mod h1:FUZXzO+5Uqg5zzwzv4KK49R8lvGIyscBOqYrtI1
 gorm.io/gorm v1.24.7-0.20230306060331-85eaf9eeda11/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
 gorm.io/gorm v1.25.2 h1:gs1o6Vsa+oVKG/a9ElL3XgyGfghFfkKA2SInQaCyMho=
 gorm.io/gorm v1.25.2/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
-gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
 gotest.tools/v3 v3.4.0 h1:ZazjZUfuVeZGLAmlKKuyv3IKP5orXcwtOwDQH6YVr6o=
 gotest.tools/v3 v3.4.0/go.mod h1:CtbdzLSsqVhDgMtKsx03ird5YTGB3ar27v0u/yKBW5g=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

common/libzkp/impl/Cargo.toml

@@ -7,18 +7,20 @@ edition = "2021"
 [lib]
 crate-type = ["cdylib"]
 
-# `//` is used to skip https://github.com/rust-lang/cargo/issues/5478#issuecomment-522719793.
-[patch."https://github.com/privacy-scaling-explorations/halo2curves.git"]
-halo2curves = { git = 'https://github.com/privacy-scaling-explorations//halo2curves.git', rev = "9b67e19" }
 [patch."https://github.com/privacy-scaling-explorations/halo2.git"]
-halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "scroll-dev-0220"  }
+halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "develop" }
 [patch."https://github.com/privacy-scaling-explorations/poseidon.git"]
 poseidon = { git = "https://github.com/scroll-tech/poseidon.git", branch = "scroll-dev-0220" }
+[patch."https://github.com/privacy-scaling-explorations/halo2wrong.git"]
+halo2wrong = { git = "https://github.com/scroll-tech/halo2wrong.git", branch = "halo2-ecc-snark-verifier-0323" }
+maingate = { git = "https://github.com/scroll-tech/halo2wrong", branch = "halo2-ecc-snark-verifier-0323" }
+[patch."https://github.com/privacy-scaling-explorations/halo2curves.git"]
+halo2curves = { git = "https://github.com/scroll-tech/halo2curves.git", branch = "0.3.1-derive-serde" }
 
 [dependencies]
-zkevm = { git = "https://github.com/scroll-tech/scroll-prover", rev="78ab7a7" }
-types = { git = "https://github.com/scroll-tech/scroll-prover", rev="78ab7a7" }
-halo2_proofs = { git = "https://github.com/privacy-scaling-explorations/halo2.git", tag = "v2022_09_10" }
+prover = { git = "https://github.com/scroll-tech/scroll-prover", rev = "b877e67" }
+types = { git = "https://github.com/scroll-tech/scroll-prover", rev = "b877e67" }
+halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "develop" }
 
 log = "0.4"
 env_logger = "0.9.0"
@@ -31,8 +33,8 @@ once_cell = "1.8.0"
 
 [profile.test]
 opt-level = 3
-debug-assertions = true
+# debug-assertions = true
 
 [profile.release]
 opt-level = 3
-debug-assertions = true
+# debug-assertions = true

common/libzkp/impl/rustfmt.toml

@@ -0,0 +1,9 @@
+edition = "2021"
+
+comment_width = 100
+imports_granularity = "Crate"
+max_width = 100
+newline_style = "Unix"
+# normalize_comments = true
+reorder_imports = true
+wrap_comments = true

common/libzkp/impl/src/batch.rs

@@ -0,0 +1,90 @@
+use crate::utils::{c_char_to_str, c_char_to_vec, vec_to_c_char, OUTPUT_DIR};
+use libc::c_char;
+use prover::{
+    aggregator::{Prover, Verifier},
+    utils::{chunk_trace_to_witness_block, init_env_and_log},
+    ChunkHash, ChunkProof, Proof,
+};
+use std::{cell::OnceCell, panic, ptr::null};
+use types::eth::BlockTrace;
+
+static mut PROVER: OnceCell<Prover> = OnceCell::new();
+static mut VERIFIER: OnceCell<Verifier> = OnceCell::new();
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_batch_prover(params_dir: *const c_char) {
+    init_env_and_log("ffi_batch_prove");
+
+    let params_dir = c_char_to_str(params_dir);
+    let prover = Prover::from_params_dir(params_dir);
+
+    PROVER.set(prover).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_batch_verifier(params_dir: *const c_char, assets_dir: *const c_char) {
+    init_env_and_log("ffi_batch_verify");
+
+    let params_dir = c_char_to_str(params_dir);
+    let assets_dir = c_char_to_str(assets_dir);
+
+    let verifier = Verifier::from_dirs(params_dir, assets_dir);
+
+    VERIFIER.set(verifier).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn gen_batch_proof(
+    chunk_hashes: *const c_char,
+    chunk_proofs: *const c_char,
+) -> *const c_char {
+    let chunk_hashes = c_char_to_vec(chunk_hashes);
+    let chunk_proofs = c_char_to_vec(chunk_proofs);
+
+    let chunk_hashes = serde_json::from_slice::<Vec<ChunkHash>>(&chunk_hashes).unwrap();
+    let chunk_proofs = serde_json::from_slice::<Vec<ChunkProof>>(&chunk_proofs).unwrap();
+    assert_eq!(chunk_hashes.len(), chunk_proofs.len());
+
+    let chunk_hashes_proofs = chunk_hashes
+        .into_iter()
+        .zip(chunk_proofs.into_iter())
+        .collect();
+
+    let proof_result = panic::catch_unwind(|| {
+        let proof = PROVER
+            .get_mut()
+            .unwrap()
+            .gen_agg_evm_proof(chunk_hashes_proofs, None, OUTPUT_DIR.as_deref())
+            .unwrap();
+
+        serde_json::to_vec(&proof).unwrap()
+    });
+    proof_result.map_or(null(), vec_to_c_char)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_batch_proof(proof: *const c_char) -> c_char {
+    let proof = c_char_to_vec(proof);
+    let proof = serde_json::from_slice::<Proof>(proof.as_slice()).unwrap();
+
+    let verified = panic::catch_unwind(|| VERIFIER.get().unwrap().verify_agg_evm_proof(&proof));
+    verified.unwrap_or(false) as c_char
+}
+
+// This function is only used for debugging on Go side.
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn block_traces_to_chunk_info(block_traces: *const c_char) -> *const c_char {
+    let block_traces = c_char_to_vec(block_traces);
+    let block_traces = serde_json::from_slice::<Vec<BlockTrace>>(&block_traces).unwrap();
+
+    let witness_block = chunk_trace_to_witness_block(block_traces).unwrap();
+    let chunk_info = ChunkHash::from_witness_block(&witness_block, false);
+
+    let chunk_info_bytes = serde_json::to_vec(&chunk_info).unwrap();
+    vec_to_c_char(chunk_info_bytes)
+}

common/libzkp/impl/src/chunk.rs

@@ -0,0 +1,65 @@
+use crate::utils::{c_char_to_str, c_char_to_vec, vec_to_c_char, OUTPUT_DIR};
+use libc::c_char;
+use prover::{
+    utils::init_env_and_log,
+    zkevm::{Prover, Verifier},
+    ChunkProof,
+};
+use std::{cell::OnceCell, panic, ptr::null};
+use types::eth::BlockTrace;
+
+static mut PROVER: OnceCell<Prover> = OnceCell::new();
+static mut VERIFIER: OnceCell<Verifier> = OnceCell::new();
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_chunk_prover(params_dir: *const c_char) {
+    init_env_and_log("ffi_chunk_prove");
+
+    let params_dir = c_char_to_str(params_dir);
+    let prover = Prover::from_params_dir(params_dir);
+
+    PROVER.set(prover).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_chunk_verifier(params_dir: *const c_char, assets_dir: *const c_char) {
+    init_env_and_log("ffi_chunk_verify");
+
+    let params_dir = c_char_to_str(params_dir);
+    let assets_dir = c_char_to_str(assets_dir);
+
+    let verifier = Verifier::from_dirs(params_dir, assets_dir);
+
+    VERIFIER.set(verifier).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn gen_chunk_proof(block_traces: *const c_char) -> *const c_char {
+    let block_traces = c_char_to_vec(block_traces);
+    let block_traces = serde_json::from_slice::<Vec<BlockTrace>>(&block_traces).unwrap();
+
+    let proof_result = panic::catch_unwind(|| {
+        let proof = PROVER
+            .get_mut()
+            .unwrap()
+            .gen_chunk_proof(block_traces, None, OUTPUT_DIR.as_deref())
+            .unwrap();
+
+        serde_json::to_vec(&proof).unwrap()
+    });
+
+    proof_result.map_or(null(), vec_to_c_char)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_chunk_proof(proof: *const c_char) -> c_char {
+    let proof = c_char_to_vec(proof);
+    let proof = serde_json::from_slice::<ChunkProof>(proof.as_slice()).unwrap();
+
+    let verified = panic::catch_unwind(|| VERIFIER.get().unwrap().verify_chunk_proof(proof));
+    verified.unwrap_or(false) as c_char
+}

common/libzkp/impl/src/lib.rs

@@ -1,23 +1,5 @@
 #![feature(once_cell)]
 
-pub mod prove;
-pub mod verify;
-
-pub(crate) mod utils {
-    use std::ffi::{CStr, CString};
-    use std::os::raw::c_char;
-
-    pub(crate) fn c_char_to_str(c: *const c_char) -> &'static str {
-        let cstr = unsafe { CStr::from_ptr(c) };
-        cstr.to_str().unwrap()
-    }
-
-    pub(crate) fn c_char_to_vec(c: *const c_char) -> Vec<u8> {
-        let cstr = unsafe { CStr::from_ptr(c) };
-        cstr.to_bytes().to_vec()
-    }
-
-    pub(crate) fn vec_to_c_char(bytes: Vec<u8>) -> *const c_char {
-        CString::new(bytes).unwrap().into_raw()
-    }
-}
+mod batch;
+mod chunk;
+mod utils;

common/libzkp/impl/src/prove.rs

@@ -1,58 +0,0 @@
-use crate::utils::{c_char_to_str, c_char_to_vec, vec_to_c_char};
-use halo2_proofs::SerdeFormat;
-use libc::c_char;
-use std::cell::OnceCell;
-use std::panic;
-use std::ptr::null;
-use types::eth::BlockTrace;
-use zkevm::circuit::AGG_DEGREE;
-use zkevm::utils::{load_params, load_seed};
-use zkevm::{circuit::DEGREE, prover::Prover};
-
-static mut PROVER: OnceCell<Prover> = OnceCell::new();
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn init_prover(params_path: *const c_char, seed_path: *const c_char) {
-    env_logger::init();
-
-    let params_path = c_char_to_str(params_path);
-    let seed_path = c_char_to_str(seed_path);
-    let params = load_params(params_path, *DEGREE, SerdeFormat::RawBytesUnchecked).unwrap();
-    let agg_params = load_params(params_path, *AGG_DEGREE, SerdeFormat::RawBytesUnchecked).unwrap();
-    let seed = load_seed(seed_path).unwrap();
-    let p = Prover::from_params_and_seed(params, agg_params, seed);
-    PROVER.set(p).unwrap();
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn create_agg_proof(trace_char: *const c_char) -> *const c_char {
-    let trace_vec = c_char_to_vec(trace_char);
-    let trace = serde_json::from_slice::<BlockTrace>(&trace_vec).unwrap();
-    let proof_result = panic::catch_unwind(|| {
-        let proof = PROVER
-            .get_mut()
-            .unwrap()
-            .create_agg_circuit_proof(&trace)
-            .unwrap();
-        serde_json::to_vec(&proof).unwrap()
-    });
-    proof_result.map_or(null(), vec_to_c_char)
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn create_agg_proof_multi(trace_char: *const c_char) -> *const c_char {
-    let trace_vec = c_char_to_vec(trace_char);
-    let traces = serde_json::from_slice::<Vec<BlockTrace>>(&trace_vec).unwrap();
-    let proof_result = panic::catch_unwind(|| {
-        let proof = PROVER
-            .get_mut()
-            .unwrap()
-            .create_agg_circuit_proof_batch(traces.as_slice())
-            .unwrap();
-        serde_json::to_vec(&proof).unwrap()
-    });
-    proof_result.map_or(null(), vec_to_c_char)
-}

common/libzkp/impl/src/utils.rs

@@ -0,0 +1,24 @@
+use once_cell::sync::Lazy;
+use std::{
+    env,
+    ffi::{CStr, CString},
+    os::raw::c_char,
+};
+
+// Only used for debugging.
+pub(crate) static OUTPUT_DIR: Lazy<Option<String>> =
+    Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
+
+pub(crate) fn c_char_to_str(c: *const c_char) -> &'static str {
+    let cstr = unsafe { CStr::from_ptr(c) };
+    cstr.to_str().unwrap()
+}
+
+pub(crate) fn c_char_to_vec(c: *const c_char) -> Vec<u8> {
+    let cstr = unsafe { CStr::from_ptr(c) };
+    cstr.to_bytes().to_vec()
+}
+
+pub(crate) fn vec_to_c_char(bytes: Vec<u8>) -> *const c_char {
+    CString::new(bytes).unwrap().into_raw()
+}

common/libzkp/impl/src/verify.rs

@@ -1,44 +0,0 @@
-use crate::utils::{c_char_to_str, c_char_to_vec};
-use halo2_proofs::SerdeFormat;
-use libc::c_char;
-use std::fs::File;
-use std::io::Read;
-use std::panic;
-use zkevm::circuit::{AGG_DEGREE, DEGREE};
-use zkevm::prover::AggCircuitProof;
-use zkevm::utils::load_params;
-use zkevm::verifier::Verifier;
-
-static mut VERIFIER: Option<&Verifier> = None;
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn init_verifier(params_path: *const c_char, agg_vk_path: *const c_char) {
-    env_logger::init();
-
-    let params_path = c_char_to_str(params_path);
-    let agg_vk_path = c_char_to_str(agg_vk_path);
-    let mut f = File::open(agg_vk_path).unwrap();
-    let mut agg_vk = vec![];
-    f.read_to_end(&mut agg_vk).unwrap();
-
-    let params = load_params(params_path, *DEGREE, SerdeFormat::RawBytesUnchecked).unwrap();
-    let agg_params = load_params(params_path, *AGG_DEGREE, SerdeFormat::RawBytesUnchecked).unwrap();
-
-    let v = Box::new(Verifier::from_params(params, agg_params, Some(agg_vk)));
-    VERIFIER = Some(Box::leak(v))
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn verify_agg_proof(proof: *const c_char) -> c_char {
-    let proof_vec = c_char_to_vec(proof);
-    let agg_proof = serde_json::from_slice::<AggCircuitProof>(proof_vec.as_slice()).unwrap();
-    let verified = panic::catch_unwind(|| {
-        VERIFIER
-            .unwrap()
-            .verify_agg_circuit_proof(agg_proof)
-            .is_ok()
-    });
-    verified.unwrap_or(false) as c_char
-}

common/libzkp/interface/libzkp.h

@@ -1,5 +1,11 @@
-void init_prover(char *params_path, char *seed_path);
-char* create_agg_proof(char *trace);
-char* create_agg_proof_multi(char *trace);
-void init_verifier(char *params_path, char *agg_vk_path);
-char verify_agg_proof(char *proof);
+void init_batch_prover(char* params_dir);
+void init_batch_verifier(char* params_dir, char* assets_dir);
+char* gen_batch_proof(char* chunk_hashes, char* chunk_proofs);
+char verify_batch_proof(char* proof);
+
+void init_chunk_prover(char* params_dir);
+void init_chunk_verifier(char* params_dir, char* assets_dir);
+char* gen_chunk_proof(char* block_traces);
+char verify_chunk_proof(char* proof);
+
+char* block_traces_to_chunk_info(char* block_traces);

common/types/block.go

@@ -10,15 +10,12 @@ import (
 	"github.com/scroll-tech/go-ethereum/core/types"
 )
 
-const nonZeroByteGas uint64 = 16
-const zeroByteGas uint64 = 4
-
 // WrappedBlock contains the block's Header, Transactions and WithdrawTrieRoot hash.
 type WrappedBlock struct {
 	Header *types.Header `json:"header"`
 	// Transactions is only used for recover types.Transactions, the from of types.TransactionData field is missing.
-	Transactions     []*types.TransactionData `json:"transactions"`
-	WithdrawTrieRoot common.Hash              `json:"withdraw_trie_root,omitempty"`
+	Transactions []*types.TransactionData `json:"transactions"`
+	WithdrawRoot common.Hash              `json:"withdraw_trie_root,omitempty"`
 }
 
 // NumL1Messages returns the number of L1 messages in this block.
@@ -78,16 +75,20 @@ func (w *WrappedBlock) EstimateL1CommitCalldataSize() uint64 {
 	return size
 }
 
-// EstimateL1CommitGas calculates the calldata gas in l1 commit approximately.
-// TODO: This will need to be adjusted.
-// The part added here is only the calldata cost,
-// but we have execution cost for verifying blocks / chunks / batches and storing the batch hash.
+// EstimateL1CommitGas calculates the total L1 commit gas for this block approximately.
 func (w *WrappedBlock) EstimateL1CommitGas() uint64 {
+	getKeccakGas := func(size uint64) uint64 {
+		return 30 + 6*((size+31)/32) // 30 + 6 * ceil(size / 32)
+	}
+
 	var total uint64
+	var numL1Messages uint64
 	for _, txData := range w.Transactions {
 		if txData.Type == types.L1MessageTxType {
+			numL1Messages++
 			continue
 		}
+
 		data, _ := hexutil.Decode(txData.Data)
 		tx := types.NewTx(&types.LegacyTx{
 			Nonce:    txData.Nonce,
@@ -101,26 +102,19 @@ func (w *WrappedBlock) EstimateL1CommitGas() uint64 {
 			S:        txData.S.ToInt(),
 		})
 		rlpTxData, _ := tx.MarshalBinary()
-
-		for _, b := range rlpTxData {
-			if b == 0 {
-				total += zeroByteGas
-			} else {
-				total += nonZeroByteGas
-			}
-		}
-
-		var txLen [4]byte
-		binary.BigEndian.PutUint32(txLen[:], uint32(len(rlpTxData)))
-
-		for _, b := range txLen {
-			if b == 0 {
-				total += zeroByteGas
-			} else {
-				total += nonZeroByteGas
-			}
-		}
+		txPayloadLength := uint64(len(rlpTxData))
+		total += 16 * txPayloadLength          // an over-estimate: treat each byte as non-zero
+		total += 16 * 4                        // size of a uint32 field
+		total += getKeccakGas(txPayloadLength) // l2 tx hash
 	}
+
+	// sload
+	total += 2100 * numL1Messages // numL1Messages times cold sload in L1MessageQueue
+
+	// staticcall
+	total += 100 * numL1Messages // numL1Messages times call to L1MessageQueue
+	total += 100 * numL1Messages // numL1Messages times warm address access to L1MessageQueue
+
 	return total
 }
 

common/types/chunk.go

@@ -135,3 +135,25 @@ func (c *Chunk) Hash(totalL1MessagePoppedBefore uint64) (common.Hash, error) {
 	hash := crypto.Keccak256Hash(dataBytes)
 	return hash, nil
 }
+
+// EstimateL1CommitGas calculates the total L1 commit gas for this chunk approximately
+func (c *Chunk) EstimateL1CommitGas() uint64 {
+	var totalTxNum uint64
+	var totalL1CommitGas uint64
+	for _, block := range c.Blocks {
+		totalTxNum += uint64(len(block.Transactions))
+		totalL1CommitGas += block.EstimateL1CommitGas()
+	}
+
+	numBlocks := uint64(len(c.Blocks))
+	totalL1CommitGas += 100 * numBlocks     // numBlocks times warm sload
+	totalL1CommitGas += 16                  // numBlocks field of chunk encoding in calldata
+	totalL1CommitGas += 16 * 60 * numBlocks // BlockContext in chunk
+
+	getKeccakGas := func(size uint64) uint64 {
+		return 30 + 6*((size+31)/32) // 30 + 6 * ceil(size / 32)
+	}
+
+	totalL1CommitGas += getKeccakGas(58*numBlocks + 32*totalTxNum) // chunk hash
+	return totalL1CommitGas
+}

common/types/db.go

@@ -68,45 +68,51 @@ const (
 	MsgRelayFailed
 )
 
-// RollerProveStatus is the roller prove status of a block batch (session)
-type RollerProveStatus int32
+// ProverProveStatus is the prover prove status of a block batch (session)
+type ProverProveStatus int32
 
 const (
-	// RollerProveStatusUndefined indicates an unknown roller proving status
-	RollerProveStatusUndefined RollerProveStatus = iota
-	// RollerAssigned indicates roller assigned but has not submitted proof
-	RollerAssigned
-	// RollerProofValid indicates roller has submitted valid proof
-	RollerProofValid
-	// RollerProofInvalid indicates roller has submitted invalid proof
-	RollerProofInvalid
+	// ProverProveStatusUndefined indicates an unknown prover proving status
+	ProverProveStatusUndefined ProverProveStatus = iota
+	// ProverAssigned indicates prover assigned but has not submitted proof
+	ProverAssigned
+	// ProverProofValid indicates prover has submitted valid proof
+	ProverProofValid
+	// ProverProofInvalid indicates prover has submitted invalid proof
+	ProverProofInvalid
 )
 
-func (s RollerProveStatus) String() string {
+func (s ProverProveStatus) String() string {
 	switch s {
-	case RollerAssigned:
-		return "RollerAssigned"
-	case RollerProofValid:
-		return "RollerProofValid"
-	case RollerProofInvalid:
-		return "RollerProofInvalid"
+	case ProverAssigned:
+		return "ProverAssigned"
+	case ProverProofValid:
+		return "ProverProofValid"
+	case ProverProofInvalid:
+		return "ProverProofInvalid"
 	default:
 		return fmt.Sprintf("Bad Value: %d", int32(s))
 	}
 }
 
-// RollerFailureType is the type of a roller session's failure
-type RollerFailureType int
+// ProverTaskFailureType the type of prover task failure
+type ProverTaskFailureType int
 
 const (
-	// RollerFailureTypeUndefined indicates an unknown roller failure type
-	RollerFailureTypeUndefined RollerFailureType = iota
+	// ProverTaskFailureTypeUndefined indicates an unknown prover failure type
+	ProverTaskFailureTypeUndefined ProverTaskFailureType = iota
+	// ProverTaskFailureTypeTimeout prover task failure of timeout
+	ProverTaskFailureTypeTimeout
 )
 
-func (s RollerFailureType) String() string {
-	switch s {
+func (r ProverTaskFailureType) String() string {
+	switch r {
+	case ProverTaskFailureTypeUndefined:
+		return "prover task failure undefined"
+	case ProverTaskFailureTypeTimeout:
+		return "prover task failure timeout"
 	default:
-		return fmt.Sprintf("Undefined (%d)", int32(s))
+		return "illegal prover task failure type"
 	}
 }
 

common/types/db_test.go

@@ -6,30 +6,30 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestRollerProveStatus(t *testing.T) {
+func TestProverProveStatus(t *testing.T) {
 	tests := []struct {
 		name string
-		s    RollerProveStatus
+		s    ProverProveStatus
 		want string
 	}{
 		{
-			"RollerAssigned",
-			RollerAssigned,
-			"RollerAssigned",
+			"ProverAssigned",
+			ProverAssigned,
+			"ProverAssigned",
 		},
 		{
-			"RollerProofValid",
-			RollerProofValid,
-			"RollerProofValid",
+			"ProverProofValid",
+			ProverProofValid,
+			"ProverProofValid",
 		},
 		{
-			"RollerProofInvalid",
-			RollerProofInvalid,
-			"RollerProofInvalid",
+			"ProverProofInvalid",
+			ProverProofInvalid,
+			"ProverProofInvalid",
 		},
 		{
 			"Bad Value",
-			RollerProveStatus(999), // Invalid value.
+			ProverProveStatus(999), // Invalid value.
 			"Bad Value: 999",
 		},
 	}

common/types/message/message.go

@@ -13,7 +13,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/rlp"
 )
 
-// RespStatus represents status code from roller to scroll
+// RespStatus represents status code from prover to scroll
 type RespStatus uint32
 
 const (
@@ -23,7 +23,7 @@ const (
 	StatusProofError
 )
 
-// ProofType represents the type of roller.
+// ProofType represents the type of prover.
 type ProofType uint8
 
 func (r ProofType) String() string {
@@ -40,28 +40,28 @@ func (r ProofType) String() string {
 const (
 	// ProofTypeUndefined is an unknown proof type
 	ProofTypeUndefined ProofType = iota
-	// ProofTypeChunk is default roller, it only generates zk proof from traces.
+	// ProofTypeChunk is default prover, it only generates zk proof from traces.
 	ProofTypeChunk
 	// ProofTypeBatch generates zk proof from other zk proofs and aggregate them into one proof.
 	ProofTypeBatch
 )
 
-// AuthMsg is the first message exchanged from the Roller to the Sequencer.
-// It effectively acts as a registration, and makes the Roller identification
+// AuthMsg is the first message exchanged from the Prover to the Sequencer.
+// It effectively acts as a registration, and makes the Prover identification
 // known to the Sequencer.
 type AuthMsg struct {
 	// Message fields
 	Identity *Identity `json:"message"`
-	// Roller signature
+	// Prover signature
 	Signature string `json:"signature"`
 }
 
-// Identity contains all the fields to be signed by the roller.
+// Identity contains all the fields to be signed by the prover.
 type Identity struct {
-	// Roller name
+	// Prover name
 	Name string `json:"name"`
-	// Roller RollerType
-	RollerType ProofType `json:"roller_type,omitempty"`
+	// Prover ProverType
+	ProverType ProofType `json:"prover_type,omitempty"`
 	// Version is common.Version+ZkVersion. Use the following to check the latest ZkVersion version.
 	// curl -sL https://api.github.com/repos/scroll-tech/scroll-prover/commits | jq -r ".[0].sha"
 	Version string `json:"version"`
@@ -140,10 +140,10 @@ func (i *Identity) Hash() ([]byte, error) {
 // ProofMsg is the data structure sent to the coordinator.
 type ProofMsg struct {
 	*ProofDetail `json:"zkProof"`
-	// Roller signature
+	// Prover signature
 	Signature string `json:"signature"`
 
-	// Roller public key
+	// Prover public key
 	publicKey string
 }
 
@@ -202,22 +202,32 @@ func (a *ProofMsg) PublicKey() (string, error) {
 
 // TaskMsg is a wrapper type around db ProveTask type.
 type TaskMsg struct {
-	ID   string    `json:"id"`
-	Type ProofType `json:"type,omitempty"`
-	// For decentralization, basic rollers will get block hashes from the coordinator. So that they can refer to the block hashes and fetch traces locally. Only applicable for basic rollers.
-	BlockHashes []common.Hash `json:"block_hashes,omitempty"`
-	// Only applicable for aggregator rollers.
-	SubProofs []*AggProof `json:"sub_proofs,omitempty"`
+	ID              string           `json:"id"`
+	Type            ProofType        `json:"type,omitempty"`
+	BatchTaskDetail *BatchTaskDetail `json:"batch_task_detail,omitempty"`
+	ChunkTaskDetail *ChunkTaskDetail `json:"chunk_task_detail,omitempty"`
 }
 
-// ProofDetail is the message received from rollers that contains zk proof, the status of
+// ChunkTaskDetail is a type containing ChunkTask detail.
+type ChunkTaskDetail struct {
+	BlockHashes []common.Hash `json:"block_hashes"`
+}
+
+// BatchTaskDetail is a type containing BatchTask detail.
+type BatchTaskDetail struct {
+	ChunkInfos  []*ChunkInfo  `json:"chunk_infos"`
+	ChunkProofs []*ChunkProof `json:"chunk_proofs"`
+}
+
+// ProofDetail is the message received from provers 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   ProofType  `json:"type,omitempty"`
-	Status RespStatus `json:"status"`
-	Proof  *AggProof  `json:"proof"`
-	Error  string     `json:"error,omitempty"`
+	ID         string      `json:"id"`
+	Type       ProofType   `json:"type,omitempty"`
+	Status     RespStatus  `json:"status"`
+	ChunkProof *ChunkProof `json:"chunk_proof,omitempty"`
+	BatchProof *BatchProof `json:"batch_proof,omitempty"`
+	Error      string      `json:"error,omitempty"`
 }
 
 // Hash return proofMsg content hash.
@@ -231,18 +241,35 @@ func (z *ProofDetail) Hash() ([]byte, error) {
 	return hash[:], nil
 }
 
-// AggProof includes the proof and public input that are required to verification and rollup.
-type AggProof struct {
-	Proof      []byte `json:"proof"`
-	Instance   []byte `json:"instance"`
-	FinalPair  []byte `json:"final_pair"`
-	Vk         []byte `json:"vk"`
-	BlockCount uint   `json:"block_count"`
+// ChunkInfo is for calculating pi_hash for chunk
+type ChunkInfo struct {
+	ChainID       uint64      `json:"chain_id"`
+	PrevStateRoot common.Hash `json:"prev_state_root"`
+	PostStateRoot common.Hash `json:"post_state_root"`
+	WithdrawRoot  common.Hash `json:"withdraw_root"`
+	DataHash      common.Hash `json:"data_hash"`
+	IsPadding     bool        `json:"is_padding"`
 }
 
-// SanityCheck checks whether an AggProof is in a legal format
+// ChunkProof includes the proof info that are required for chunk verification and rollup.
+type ChunkProof struct {
+	StorageTrace []byte `json:"storage_trace"`
+	Protocol     []byte `json:"protocol"`
+	Proof        []byte `json:"proof"`
+	Instances    []byte `json:"instances"`
+	Vk           []byte `json:"vk"`
+}
+
+// BatchProof includes the proof info that are required for batch verification and rollup.
+type BatchProof struct {
+	Proof     []byte `json:"proof"`
+	Instances []byte `json:"instances"`
+	Vk        []byte `json:"vk"`
+}
+
+// SanityCheck checks whether an BatchProof is in a legal format
 // TODO: change to check Proof&Instance when upgrading to snark verifier v0.4
-func (ap *AggProof) SanityCheck() error {
+func (ap *BatchProof) SanityCheck() error {
 	if ap == nil {
 		return errors.New("agg_proof is nil")
 	}
@@ -250,15 +277,9 @@ func (ap *AggProof) SanityCheck() error {
 	if len(ap.Proof) == 0 {
 		return errors.New("proof not ready")
 	}
-	if len(ap.FinalPair) == 0 {
-		return errors.New("final_pair not ready")
-	}
 	if len(ap.Proof)%32 != 0 {
 		return fmt.Errorf("proof buffer has wrong length, expected: 32, got: %d", len(ap.Proof))
 	}
-	if len(ap.FinalPair)%32 != 0 {
-		return fmt.Errorf("final_pair buffer has wrong length, expected: 32, got: %d", len(ap.FinalPair))
-	}
 
 	return nil
 }

common/types/message/message_test.go

@@ -47,7 +47,7 @@ func TestGenerateToken(t *testing.T) {
 func TestIdentityHash(t *testing.T) {
 	identity := &Identity{
 		Name:       "testName",
-		RollerType: ProofTypeChunk,
+		ProverType: ProofTypeChunk,
 		Version:    "testVersion",
 		Token:      "testToken",
 	}
@@ -67,12 +67,12 @@ func TestProofMessageSignVerifyPublicKey(t *testing.T) {
 			ID:     "testID",
 			Type:   ProofTypeChunk,
 			Status: StatusOk,
-			Proof: &AggProof{
-				Proof:      []byte("testProof"),
-				Instance:   []byte("testInstance"),
-				FinalPair:  []byte("testFinalPair"),
-				Vk:         []byte("testVk"),
-				BlockCount: 1,
+			ChunkProof: &ChunkProof{
+				StorageTrace: []byte("testStorageTrace"),
+				Protocol:     []byte("testProtocol"),
+				Proof:        []byte("testProof"),
+				Instances:    []byte("testInstance"),
+				Vk:           []byte("testVk"),
 			},
 			Error: "testError",
 		},
@@ -95,18 +95,18 @@ func TestProofDetailHash(t *testing.T) {
 		ID:     "testID",
 		Type:   ProofTypeChunk,
 		Status: StatusOk,
-		Proof: &AggProof{
-			Proof:      []byte("testProof"),
-			Instance:   []byte("testInstance"),
-			FinalPair:  []byte("testFinalPair"),
-			Vk:         []byte("testVk"),
-			BlockCount: 1,
+		ChunkProof: &ChunkProof{
+			StorageTrace: []byte("testStorageTrace"),
+			Protocol:     []byte("testProtocol"),
+			Proof:        []byte("testProof"),
+			Instances:    []byte("testInstance"),
+			Vk:           []byte("testVk"),
 		},
 		Error: "testError",
 	}
 	hash, err := proofDetail.Hash()
 	assert.NoError(t, err)
-	expectedHash := "8ad894c2047166a98b1a389b716b06b01dc1bd29e950e2687ffbcb3c328edda5"
+	expectedHash := "4165f5ab3399001002a5b8e4062914249a2deb72f6133d647b586f53e236802d"
 	assert.Equal(t, expectedHash, hex.EncodeToString(hash))
 }
 
@@ -130,12 +130,12 @@ func TestProofMsgPublicKey(t *testing.T) {
 			ID:     "testID",
 			Type:   ProofTypeChunk,
 			Status: StatusOk,
-			Proof: &AggProof{
-				Proof:      []byte("testProof"),
-				Instance:   []byte("testInstance"),
-				FinalPair:  []byte("testFinalPair"),
-				Vk:         []byte("testVk"),
-				BlockCount: 1,
+			ChunkProof: &ChunkProof{
+				StorageTrace: []byte("testStorageTrace"),
+				Protocol:     []byte("testProtocol"),
+				Proof:        []byte("testProof"),
+				Instances:    []byte("testInstance"),
+				Vk:           []byte("testVk"),
 			},
 			Error: "testError",
 		},

common/utils/simulation.go

@@ -24,8 +24,8 @@ var (
 	CoordinatorApp MockAppName = "coordinator-test"
 	// DBCliApp the name of mock database app.
 	DBCliApp MockAppName = "db_cli-test"
-	// RollerApp the name of mock roller app.
-	RollerApp MockAppName = "roller-test"
+	// ProverApp the name of mock prover app.
+	ProverApp MockAppName = "prover-test"
 )
 
 // RegisterSimulation register initializer function for integration-test.

common/utils/timezone.go

@@ -0,0 +1,9 @@
+package utils
+
+import "time"
+
+// NowUTC get the utc time.Now
+func NowUTC() time.Time {
+	utc, _ := time.LoadLocation("")
+	return time.Now().In(utc)
+}

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.0.25"
+var tag = "v4.0.38"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {
@@ -25,5 +25,5 @@ var commit = func() string {
 // ZkVersion is commit-id of common/libzkp/impl/cargo.lock/scroll-prover
 var ZkVersion string
 
-// Version denote the version of scroll protocol, including the l2geth, relayer, coordinator, roller, contracts and etc.
+// Version denote the version of scroll protocol, including the l2geth, relayer, coordinator, prover, contracts and etc.
 var Version = fmt.Sprintf("%s-%s-%s", tag, commit, ZkVersion)

contracts/docs/CrossDomainMessaging.md

@@ -24,7 +24,7 @@ The execution in layer 2 may be failed due to out of gas problem. In such case,
 
 ### Send Message from L2 to L1
 
-Similar to sending message from L1 to L2, you should call `L2ScrollMessenger.sendMessage` first in layer 2. The `L2ScrollMessenger` contract will emit a `SentMessage` event, which will be notified by the Sequencer. Unlike above, the Sequencer will first batch submit layer 2 transactions (or block) to `ZKRollup` contract in layer 1. Then the Sequencer will wait the proof generated by roller and submit the proof to `ZKRollup` contract in layer 1 again. Finally, anyone can call `L1ScrollMessenger.relayMessageWithProof` with correct proof to execute the message in layer 1.
+Similar to sending message from L1 to L2, you should call `L2ScrollMessenger.sendMessage` first in layer 2. The `L2ScrollMessenger` contract will emit a `SentMessage` event, which will be notified by the Sequencer. Unlike above, the Sequencer will first batch submit layer 2 transactions (or block) to `ZKRollup` contract in layer 1. Then the Sequencer will wait the proof generated by prover and submit the proof to `ZKRollup` contract in layer 1 again. Finally, anyone can call `L1ScrollMessenger.relayMessageWithProof` with correct proof to execute the message in layer 1.
 
 Currently, for the safety reason, we only allow privileged contracts to send cross domain messages. And only privileged accounts can call `L2ScrollMessenger.relayMessage`.
 

contracts/docs/apis/L1ERC1155Gateway.md

@@ -4,7 +4,7 @@
 
 > L1ERC1155Gateway
 
-The `L1ERC1155Gateway` is used to deposit ERC1155 compatible NFT in layer 1 and finalize withdraw the NFTs from layer 2.
+The `L1ERC1155Gateway` is used to deposit ERC1155 compatible NFT on layer 1 and finalize withdraw the NFTs from layer 2.
 
 *The deposited NFTs are held in this gateway. On finalizing withdraw, the corresponding NFT will be transfer to the recipient directly. This will be changed if we have more specific scenarios.*
 
@@ -24,7 +24,7 @@ Deposit a list of some ERC1155 NFT to caller's account on layer 2.
 
 | Name | Type | Description |
 |---|---|---|
-| _token | address | The address of ERC1155 NFT in layer 1. |
+| _token | address | The address of ERC1155 NFT on layer 1. |
 | _tokenIds | uint256[] | The list of token ids to deposit. |
 | _amounts | uint256[] | The list of corresponding number of token to deposit. |
 | _gasLimit | uint256 | Estimated gas limit required to complete the deposit on layer 2. |
@@ -43,8 +43,8 @@ Deposit a list of some ERC1155 NFT to a recipient's account on layer 2.
 
 | Name | Type | Description |
 |---|---|---|
-| _token | address | The address of ERC1155 NFT in layer 1. |
-| _to | address | The address of recipient in layer 2. |
+| _token | address | The address of ERC1155 NFT on layer 1. |
+| _to | address | The address of recipient on layer 2. |
 | _tokenIds | uint256[] | The list of token ids to deposit. |
 | _amounts | uint256[] | The list of corresponding number of token to deposit. |
 | _gasLimit | uint256 | Estimated gas limit required to complete the deposit on layer 2. |
@@ -80,8 +80,8 @@ Deposit some ERC1155 NFT to a recipient's account on layer 2.
 
 | Name | Type | Description |
 |---|---|---|
-| _token | address | The address of ERC1155 NFT in layer 1. |
-| _to | address | The address of recipient in layer 2. |
+| _token | address | The address of ERC1155 NFT on layer 1. |
+| _to | address | The address of recipient on layer 2. |
 | _tokenId | uint256 | The token id to deposit. |
 | _amount | uint256 | The amount of token to deposit. |
 | _gasLimit | uint256 | Estimated gas limit required to complete the deposit on layer 2. |
@@ -100,7 +100,7 @@ Deposit some ERC1155 NFT to caller's account on layer 2.
 
 | Name | Type | Description |
 |---|---|---|
-| _token | address | The address of ERC1155 NFT in layer 1. |
+| _token | address | The address of ERC1155 NFT on layer 1. |
 | _tokenId | uint256 | The token id to deposit. |
 | _amount | uint256 | The amount of token to deposit. |
 | _gasLimit | uint256 | Estimated gas limit required to complete the deposit on layer 2. |
@@ -111,7 +111,7 @@ Deposit some ERC1155 NFT to caller's account on layer 2.
 function finalizeBatchWithdrawERC1155(address _l1Token, address _l2Token, address _from, address _to, uint256[] _tokenIds, uint256[] _amounts) external nonpayable
 ```
 
-Complete ERC1155 batch withdraw from layer 2 to layer 1 and send fund to recipient's account in layer 1.      The function should only be called by L1ScrollMessenger.      The function should also only be called by L2ERC1155Gateway in layer 2.
+Complete ERC1155 batch withdraw from layer 2 to layer 1 and send fund to recipient's account on layer 1.      The function should only be called by L1ScrollMessenger.      The function should also only be called by L2ERC1155Gateway on layer 2.
 
 
 
@@ -121,8 +121,8 @@ Complete ERC1155 batch withdraw from layer 2 to layer 1 and send fund to recipie
 |---|---|---|
 | _l1Token | address | The address of corresponding layer 1 token. |
 | _l2Token | address | The address of corresponding layer 2 token. |
-| _from | address | The address of account who withdraw the token in layer 2. |
-| _to | address | The address of recipient in layer 1 to receive the token. |
+| _from | address | The address of account who withdraw the token on layer 2. |
+| _to | address | The address of recipient on layer 1 to receive the token. |
 | _tokenIds | uint256[] | The list of token ids to withdraw. |
 | _amounts | uint256[] | The list of corresponding number of token to withdraw. |
 
@@ -132,7 +132,7 @@ Complete ERC1155 batch withdraw from layer 2 to layer 1 and send fund to recipie
 function finalizeWithdrawERC1155(address _l1Token, address _l2Token, address _from, address _to, uint256 _tokenId, uint256 _amount) external nonpayable
 ```
 
-Complete ERC1155 withdraw from layer 2 to layer 1 and send fund to recipient's account in layer 1.      The function should only be called by L1ScrollMessenger.      The function should also only be called by L2ERC1155Gateway in layer 2.
+Complete ERC1155 withdraw from layer 2 to layer 1 and send fund to recipient's account on layer 1.      The function should only be called by L1ScrollMessenger.      The function should also only be called by L2ERC1155Gateway on layer 2.
 
 
 
@@ -142,8 +142,8 @@ Complete ERC1155 withdraw from layer 2 to layer 1 and send fund to recipient&#39
 |---|---|---|
 | _l1Token | address | The address of corresponding layer 1 token. |
 | _l2Token | address | The address of corresponding layer 2 token. |
-| _from | address | The address of account who withdraw the token in layer 2. |
-| _to | address | The address of recipient in layer 1 to receive the token. |
+| _from | address | The address of account who withdraw the token on layer 2. |
+| _to | address | The address of recipient on layer 1 to receive the token. |
 | _tokenId | uint256 | The token id to withdraw. |
 | _amount | uint256 | The amount of token to withdraw. |
 
@@ -368,8 +368,8 @@ Update layer 2 to layer 2 token mapping.
 
 | Name | Type | Description |
 |---|---|---|
-| _l1Token | address | The address of corresponding ERC1155 token in layer 2. |
-| _l2Token | address | undefined |
+| _l1Token | address | The address of ERC1155 token on layer 1. |
+| _l2Token | address | The address of corresponding ERC1155 token on layer 2. |
 
 
 
@@ -381,7 +381,7 @@ Update layer 2 to layer 2 token mapping.
 event BatchDepositERC1155(address indexed _l1Token, address indexed _l2Token, address indexed _from, address _to, uint256[] _tokenIds, uint256[] _amounts)
 ```
 
-Emitted when the ERC1155 NFT is batch deposited to gateway in layer 1.
+Emitted when the ERC1155 NFT is batch deposited to gateway on layer 1.
 
 
 
@@ -421,7 +421,7 @@ Emitted when some ERC1155 token is refunded.
 event DepositERC1155(address indexed _l1Token, address indexed _l2Token, address indexed _from, address _to, uint256 _tokenId, uint256 _amount)
 ```
 
-Emitted when the ERC1155 NFT is deposited to gateway in layer 1.
+Emitted when the ERC1155 NFT is deposited to gateway on layer 1.
 
 
 
@@ -442,7 +442,7 @@ Emitted when the ERC1155 NFT is deposited to gateway in layer 1.
 event FinalizeBatchWithdrawERC1155(address indexed _l1Token, address indexed _l2Token, address indexed _from, address _to, uint256[] _tokenIds, uint256[] _amounts)
 ```
 
-Emitted when the ERC1155 NFT is batch transfered to recipient in layer 1.
+Emitted when the ERC1155 NFT is batch transfered to recipient on layer 1.
 
 
 
@@ -463,7 +463,7 @@ Emitted when the ERC1155 NFT is batch transfered to recipient in layer 1.
 event FinalizeWithdrawERC1155(address indexed _l1Token, address indexed _l2Token, address indexed _from, address _to, uint256 _tokenId, uint256 _amount)
 ```
 
-Emitted when the ERC1155 NFT is transfered to recipient in layer 1.
+Emitted when the ERC1155 NFT is transfered to recipient on layer 1.
 
 
 
@@ -544,8 +544,8 @@ Emitted when token mapping for ERC1155 token is updated.
 
 | Name | Type | Description |
 |---|---|---|
-| _l1Token  | address | The address of corresponding ERC1155 token in layer 2. |
-| _l2Token  | address | undefined |
+| _l1Token  | address | The address of ERC1155 token on layer 1. |
+| _l2Token  | address | The address of corresponding ERC1155 token on layer 2. |
 
 
 

contracts/docs/apis/L1ERC721Gateway.md

@@ -4,7 +4,7 @@
 
 > L1ERC721Gateway
 
-The `L1ERC721Gateway` is used to deposit ERC721 compatible NFT in layer 1 and finalize withdraw the NFTs from layer 2.
+The `L1ERC721Gateway` is used to deposit ERC721 compatible NFT on layer 1 and finalize withdraw the NFTs from layer 2.
 
 *The deposited NFTs are held in this gateway. On finalizing withdraw, the corresponding NFT will be transfer to the recipient directly. This will be changed if we have more specific scenarios.*
 
@@ -24,8 +24,8 @@ Deposit a list of some ERC721 NFT to a recipient's account on layer 2.
 
 | Name | Type | Description |
 |---|---|---|
-| _token | address | The address of ERC721 NFT in layer 1. |
-| _to | address | The address of recipient in layer 2. |
+| _token | address | The address of ERC721 NFT on layer 1. |
+| _to | address | The address of recipient on layer 2. |
 | _tokenIds | uint256[] | The list of token ids to deposit. |
 | _gasLimit | uint256 | Estimated gas limit required to complete the deposit on layer 2. |
 
@@ -43,7 +43,7 @@ Deposit a list of some ERC721 NFT to caller's account on layer 2.
 
 | Name | Type | Description |
 |---|---|---|
-| _token | address | The address of ERC721 NFT in layer 1. |
+| _token | address | The address of ERC721 NFT on layer 1. |
 | _tokenIds | uint256[] | The list of token ids to deposit. |
 | _gasLimit | uint256 | Estimated gas limit required to complete the deposit on layer 2. |
 
@@ -78,8 +78,8 @@ Deposit some ERC721 NFT to a recipient's account on layer 2.
 
 | Name | Type | Description |
 |---|---|---|
-| _token | address | The address of ERC721 NFT in layer 1. |
-| _to | address | The address of recipient in layer 2. |
+| _token | address | The address of ERC721 NFT on layer 1. |
+| _to | address | The address of recipient on layer 2. |
 | _tokenId | uint256 | The token id to deposit. |
 | _gasLimit | uint256 | Estimated gas limit required to complete the deposit on layer 2. |
 
@@ -97,7 +97,7 @@ Deposit some ERC721 NFT to caller's account on layer 2.
 
 | Name | Type | Description |
 |---|---|---|
-| _token | address | The address of ERC721 NFT in layer 1. |
+| _token | address | The address of ERC721 NFT on layer 1. |
 | _tokenId | uint256 | The token id to deposit. |
 | _gasLimit | uint256 | Estimated gas limit required to complete the deposit on layer 2. |
 
@@ -107,9 +107,9 @@ Deposit some ERC721 NFT to caller's account on layer 2.
 function finalizeBatchWithdrawERC721(address _l1Token, address _l2Token, address _from, address _to, uint256[] _tokenIds) external nonpayable
 ```
 
-Complete ERC721 batch withdraw from layer 2 to layer 1 and send NFT to recipient's account in layer 1.
+Complete ERC721 batch withdraw from layer 2 to layer 1 and send NFT to recipient's account on layer 1.
 
-*Requirements:  - The function should only be called by L1ScrollMessenger.  - The function should also only be called by L2ERC721Gateway in layer 2.*
+*Requirements:  - The function should only be called by L1ScrollMessenger.  - The function should also only be called by L2ERC721Gateway on layer 2.*
 
 #### Parameters
 
@@ -117,8 +117,8 @@ Complete ERC721 batch withdraw from layer 2 to layer 1 and send NFT to recipient
 |---|---|---|
 | _l1Token | address | The address of corresponding layer 1 token. |
 | _l2Token | address | The address of corresponding layer 2 token. |
-| _from | address | The address of account who withdraw the token in layer 2. |
-| _to | address | The address of recipient in layer 1 to receive the token. |
+| _from | address | The address of account who withdraw the token on layer 2. |
+| _to | address | The address of recipient on layer 1 to receive the token. |
 | _tokenIds | uint256[] | The list of token ids to withdraw. |
 
 ### finalizeWithdrawERC721
@@ -127,9 +127,9 @@ Complete ERC721 batch withdraw from layer 2 to layer 1 and send NFT to recipient
 function finalizeWithdrawERC721(address _l1Token, address _l2Token, address _from, address _to, uint256 _tokenId) external nonpayable
 ```
 
-Complete ERC721 withdraw from layer 2 to layer 1 and send NFT to recipient's account in layer 1.
+Complete ERC721 withdraw from layer 2 to layer 1 and send NFT to recipient's account on layer 1.
 
-*Requirements:  - The function should only be called by L1ScrollMessenger.  - The function should also only be called by L2ERC721Gateway in layer 2.*
+*Requirements:  - The function should only be called by L1ScrollMessenger.  - The function should also only be called by L2ERC721Gateway on layer 2.*
 
 #### Parameters
 
@@ -137,8 +137,8 @@ Complete ERC721 withdraw from layer 2 to layer 1 and send NFT to recipient's
 |---|---|---|
 | _l1Token | address | The address of corresponding layer 1 token. |
 | _l2Token | address | The address of corresponding layer 2 token. |
-| _from | address | The address of account who withdraw the token in layer 2. |
-| _to | address | The address of recipient in layer 1 to receive the token. |
+| _from | address | The address of account who withdraw the token on layer 2. |
+| _to | address | The address of recipient on layer 1 to receive the token. |
 | _tokenId | uint256 | The token id to withdraw. |
 
 ### initialize
@@ -313,8 +313,8 @@ Update layer 2 to layer 2 token mapping.
 
 | Name | Type | Description |
 |---|---|---|
-| _l1Token | address | The address of corresponding ERC721 token in layer 2. |
-| _l2Token | address | undefined |
+| _l1Token | address | The address of ERC721 token on layer 1. |
+| _l2Token | address | The address of corresponding ERC721 token on layer 2. |
 
 
 
@@ -326,7 +326,7 @@ Update layer 2 to layer 2 token mapping.
 event BatchDepositERC721(address indexed _l1Token, address indexed _l2Token, address indexed _from, address _to, uint256[] _tokenIds)
 ```
 
-Emitted when the ERC721 NFT is batch deposited to gateway in layer 1.
+Emitted when the ERC721 NFT is batch deposited to gateway on layer 1.
 
 
 
@@ -364,7 +364,7 @@ Emitted when a batch of ERC721 tokens are refunded.
 event DepositERC721(address indexed _l1Token, address indexed _l2Token, address indexed _from, address _to, uint256 _tokenId)
 ```
 
-Emitted when the ERC721 NFT is deposited to gateway in layer 1.
+Emitted when the ERC721 NFT is deposited to gateway on layer 1.
 
 
 
@@ -384,7 +384,7 @@ Emitted when the ERC721 NFT is deposited to gateway in layer 1.
 event FinalizeBatchWithdrawERC721(address indexed _l1Token, address indexed _l2Token, address indexed _from, address _to, uint256[] _tokenIds)
 ```
 
-Emitted when the ERC721 NFT is batch transfered to recipient in layer 1.
+Emitted when the ERC721 NFT is batch transfered to recipient on layer 1.
 
 
 
@@ -404,7 +404,7 @@ Emitted when the ERC721 NFT is batch transfered to recipient in layer 1.
 event FinalizeWithdrawERC721(address indexed _l1Token, address indexed _l2Token, address indexed _from, address _to, uint256 _tokenId)
 ```
 
-Emitted when the ERC721 NFT is transfered to recipient in layer 1.
+Emitted when the ERC721 NFT is transfered to recipient on layer 1.
 
 
 
@@ -483,8 +483,8 @@ Emitted when token mapping for ERC721 token is updated.
 
 | Name | Type | Description |
 |---|---|---|
-| _l1Token  | address | The address of corresponding ERC721 token in layer 2. |
-| _l2Token  | address | undefined |
+| _l1Token  | address | The address of ERC721 token on layer 1. |
+| _l2Token  | address | The address of corresponding ERC721 token on layer 2. |
 
 
 

contracts/docs/apis/L1StandardERC20Gateway.md

@@ -4,7 +4,7 @@
 
 > L1StandardERC20Gateway
 
-The `L1StandardERC20Gateway` is used to deposit standard ERC20 tokens in layer 1 and finalize withdraw the tokens from layer 2.
+The `L1StandardERC20Gateway` is used to deposit standard ERC20 tokens on layer 1 and finalize withdraw the tokens from layer 2.
 
 *The deposited ERC20 tokens are held in this gateway. On finalizing withdraw, the corresponding token will be transfer to the recipient directly. Any ERC20 that requires non-standard functionality should use a separate gateway.*
 

contracts/docs/apis/L1WETHGateway.md

@@ -4,7 +4,7 @@
 
 > L1WETHGateway
 
-The `L1WETHGateway` contract is used to deposit `WETH` token in layer 1 and finalize withdraw `WETH` from layer 2.
+The `L1WETHGateway` contract is used to deposit `WETH` token on layer 1 and finalize withdraw `WETH` from layer 2.
 
 *The deposited WETH tokens are not held in the gateway. It will first be unwrapped as Ether and then the Ether will be sent to the `L1ScrollMessenger` contract. On finalizing withdraw, the Ether will be transfered from `L1ScrollMessenger`, then wrapped as WETH and finally transfer to recipient.*