feat: add grom logger

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

@@ -3,7 +3,7 @@
 create table cross_message
 (
     id              BIGSERIAL PRIMARY KEY,
-    msg_hash        VARCHAR NOT NULL,
+    msg_hash        VARCHAR NOT NULL DEFAULT '',
     height          BIGINT  NOT NULL,
     sender          VARCHAR NOT NULL,
     target          VARCHAR NOT NULL,
@@ -14,8 +14,10 @@ create table cross_message
     layer2_token    VARCHAR NOT NULL DEFAULT '',
     asset           SMALLINT NOT NULL,
     msg_type        SMALLINT NOT NULL,
-    token_ids       TEXT NOT NULL DEFAULT '',
-    token_amounts   TEXT NOT NULL DEFAULT '',
+    -- use array to support nft bridge
+    token_ids       VARCHAR[] NOT NULL DEFAULT '{}',
+     -- use array to support nft bridge
+    token_amounts   VARCHAR[] NOT NULL DEFAULT '{}',
     block_timestamp TIMESTAMP(0) DEFAULT NULL,
     created_at      TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at      TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,

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

@@ -12,12 +12,12 @@ create table relayed_msg
     deleted_at  TIMESTAMP(0) DEFAULT NULL
 );
 
-create unique index uk_msg_hash_l1_hash_l2_hash
-on relayed_msg (msg_hash, layer1_hash, layer2_hash) where deleted_at IS NULL;
+create unique index uk_msg_hash
+on relayed_msg (msg_hash) where deleted_at IS NULL;
 
-CREATE INDEX idx_l1_msg_relayed_msg ON relayed_msg (layer1_hash, deleted_at);
+CREATE INDEX idx_l1_msg_index ON relayed_msg (layer1_hash, deleted_at);
 
-CREATE INDEX idx_l2_msg_relayed_msg ON relayed_msg (layer2_hash, deleted_at);
+CREATE INDEX idx_l2_msg_index ON relayed_msg (layer2_hash, deleted_at);
 
 CREATE OR REPLACE FUNCTION update_timestamp()
 RETURNS TRIGGER AS $$

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

@@ -50,8 +50,8 @@ type CrossMsg struct {
 	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"`
+	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"`

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

@@ -65,7 +65,6 @@ func (l *l1CrossMsgOrm) BatchInsertL1CrossMsgDBTx(dbTx *sqlx.Tx, messages []*Cro
 			"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,
@@ -73,7 +72,7 @@ func (l *l1CrossMsgOrm) BatchInsertL1CrossMsgDBTx(dbTx *sqlx.Tx, messages []*Cro
 			"msg_type":     Layer1Msg,
 		}
 	}
-	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer1_hash, layer1_token, layer2_token, token_ids, amount, msg_type, msg_hash) values(:height, :sender, :target, :asset, :layer1_hash, :layer1_token, :layer2_token, :token_ids, :amount, :msg_type, :msg_hash);`, messageMaps)
+	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer1_hash, layer1_token, layer2_token, token_ids, amount, msg_type) values(:height, :sender, :target, :asset, :layer1_hash, :layer1_token, :layer2_token, :token_ids, :amount, :msg_type);`, messageMaps)
 	if err != nil {
 		log.Error("BatchInsertL1CrossMsgDBTx: failed to insert l1 cross msgs", "err", err)
 		return err

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

@@ -71,12 +71,12 @@ func (l *l2CrossMsgOrm) BatchInsertL2CrossMsgDBTx(dbTx *sqlx.Tx, messages []*Cro
 	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,
@@ -85,7 +85,7 @@ func (l *l2CrossMsgOrm) BatchInsertL2CrossMsgDBTx(dbTx *sqlx.Tx, messages []*Cro
 			"msg_type":     Layer2Msg,
 		}
 	}
-	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer2_hash, layer1_token, layer2_token, token_ids, amount, msg_type, msg_hash) values(:height, :sender, :target, :asset, :layer2_hash, :layer1_token, :layer2_token, :token_ids, :amount, :msg_type, :msg_hash);`, messageMaps)
+	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer2_hash, layer1_token, layer2_token, token_ids, amount, msg_type) values(:height, :sender, :target, :asset, :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

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

@@ -95,7 +95,7 @@ func (l *l2SentMsgOrm) UpdateL2MessageProofInDBTx(ctx context.Context, dbTx *sql
 }
 
 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;`)
+	row := l.db.QueryRow(`SELECT batch_index FROM l2_sent_msg WHERE msg_proof != '' 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 {

bridge-history-api/utils/parse_event.go

@@ -86,7 +86,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []MsgHashWrappe
 				Layer1Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
-				TokenIDs:    event.TokenID.String(),
+				TokenIDs:    []string{event.TokenID.String()},
 			})
 		case backendabi.L1DepositERC1155Sig:
 			event := backendabi.ERC1155MessageEvent{}
@@ -103,7 +103,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []MsgHashWrappe
 				Layer1Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
-				TokenIDs:    event.TokenID.String(),
+				TokenIDs:    []string{event.TokenID.String()},
 				Amount:      event.Amount.String(),
 			})
 		case backendabi.L1SentMessageEventSignature:
@@ -193,7 +193,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
-				TokenIDs:    event.TokenID.String(),
+				TokenIDs:    []string{event.TokenID.String()},
 			})
 		case backendabi.L2WithdrawERC1155Sig:
 			event := backendabi.ERC1155MessageEvent{}
@@ -210,7 +210,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
-				TokenIDs:    event.TokenID.String(),
+				TokenIDs:    []string{event.TokenID.String()},
 				Amount:      event.Amount.String(),
 			})
 		case backendabi.L2SentMessageEventSignature:

bridge/cmd/event_watcher/app/app.go

@@ -21,6 +21,7 @@ import (
 )
 
 var app *cli.App
+var logger log.Logger
 
 func init() {
 	// Set up event-watcher app info.
@@ -32,7 +33,9 @@ func init() {
 	app.Flags = append(app.Flags, cutils.CommonFlags...)
 	app.Commands = []*cli.Command{}
 	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
+		var err error
+		logger, err = cutils.LogSetup(ctx)
+		return err
 	}
 	// Register `event-watcher-test` app for integration-test.
 	cutils.RegisterSimulation(app, cutils.EventWatcherApp)
@@ -48,7 +51,7 @@ func action(ctx *cli.Context) error {
 
 	subCtx, cancel := context.WithCancel(ctx.Context)
 	// Init db connection
-	db, err := utils.InitDB(cfg.DBConfig)
+	db, err := utils.InitDB(cfg.DBConfig, logger)
 	if err != nil {
 		log.Crit("failed to init db connection", "err", err)
 	}

bridge/cmd/gas_oracle/app/app.go

@@ -22,6 +22,7 @@ import (
 )
 
 var app *cli.App
+var logger log.Logger
 
 func init() {
 	// Set up gas-oracle app info.
@@ -34,7 +35,9 @@ func init() {
 	app.Flags = append(app.Flags, cutils.CommonFlags...)
 	app.Commands = []*cli.Command{}
 	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
+		var err error
+		logger, err = cutils.LogSetup(ctx)
+		return err
 	}
 	// Register `gas-oracle-test` app for integration-test.
 	cutils.RegisterSimulation(app, cutils.GasOracleApp)
@@ -49,7 +52,7 @@ func action(ctx *cli.Context) error {
 	}
 	subCtx, cancel := context.WithCancel(ctx.Context)
 	// Init db connection
-	db, err := utils.InitDB(cfg.DBConfig)
+	db, err := utils.InitDB(cfg.DBConfig, logger)
 	if err != nil {
 		log.Crit("failed to init db connection", "err", err)
 	}

bridge/cmd/msg_relayer/app/app.go

@@ -20,6 +20,7 @@ import (
 )
 
 var app *cli.App
+var logger log.Logger
 
 func init() {
 	// Set up message-relayer app info.
@@ -32,7 +33,9 @@ func init() {
 	app.Flags = append(app.Flags, cutils.CommonFlags...)
 	app.Commands = []*cli.Command{}
 	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
+		var err error
+		logger, err = cutils.LogSetup(ctx)
+		return err
 	}
 	// Register `message-relayer-test` app for integration-test.
 	cutils.RegisterSimulation(app, cutils.MessageRelayerApp)
@@ -48,7 +51,7 @@ func action(ctx *cli.Context) error {
 
 	subCtx, cancel := context.WithCancel(ctx.Context)
 	// Init db connection
-	db, err := utils.InitDB(cfg.DBConfig)
+	db, err := utils.InitDB(cfg.DBConfig, logger)
 	if err != nil {
 		log.Crit("failed to init db connection", "err", err)
 	}

bridge/cmd/rollup_relayer/app/app.go

@@ -22,6 +22,7 @@ import (
 )
 
 var app *cli.App
+var logger log.Logger
 
 func init() {
 	// Set up rollup-relayer app info.
@@ -34,7 +35,9 @@ func init() {
 	app.Flags = append(app.Flags, cutils.RollupRelayerFlags...)
 	app.Commands = []*cli.Command{}
 	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
+		var err error
+		logger, err = cutils.LogSetup(ctx)
+		return err
 	}
 	// Register `rollup-relayer-test` app for integration-test.
 	cutils.RegisterSimulation(app, cutils.RollupRelayerApp)
@@ -50,7 +53,7 @@ func action(ctx *cli.Context) error {
 
 	subCtx, cancel := context.WithCancel(ctx.Context)
 	// Init db connection
-	db, err := utils.InitDB(cfg.DBConfig)
+	db, err := utils.InitDB(cfg.DBConfig, logger)
 	if err != nil {
 		log.Crit("failed to init db connection", "err", err)
 	}

bridge/internal/controller/relayer/l1_relayer_test.go

@@ -49,7 +49,9 @@ var (
 )
 
 func setupL1RelayerDB(t *testing.T) *gorm.DB {
-	db, err := bridgeUtils.InitDB(cfg.DBConfig)
+	logger, err1 := utils.LogSetup(nil)
+	assert.NoError(t, err1)
+	db, err := bridgeUtils.InitDB(cfg.DBConfig, logger)
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)

bridge/internal/controller/relayer/l2_relayer_test.go

@@ -24,7 +24,9 @@ import (
 )
 
 func setupL2RelayerDB(t *testing.T) *gorm.DB {
-	db, err := bridgeUtils.InitDB(cfg.DBConfig)
+	logger, err1 := utils.LogSetup(nil)
+	assert.NoError(t, err1)
+	db, err := bridgeUtils.InitDB(cfg.DBConfig, logger)
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)

bridge/internal/controller/watcher/watcher_test.go

@@ -10,6 +10,7 @@ import (
 	"gorm.io/gorm"
 
 	"scroll-tech/common/docker"
+	cutils "scroll-tech/common/utils"
 
 	"scroll-tech/bridge/internal/config"
 	"scroll-tech/bridge/internal/orm/migrate"
@@ -74,7 +75,9 @@ func setupEnv(t *testing.T) (err error) {
 }
 
 func setupDB(t *testing.T) *gorm.DB {
-	db, err := utils.InitDB(cfg.DBConfig)
+	logger, err1 := cutils.LogSetup(nil)
+	assert.NoError(t, err1)
+	db, err := utils.InitDB(cfg.DBConfig, logger)
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)

bridge/internal/orm/orm_test.go

@@ -12,6 +12,7 @@ import (
 
 	"scroll-tech/common/docker"
 	"scroll-tech/common/types"
+	cutils "scroll-tech/common/utils"
 
 	"scroll-tech/bridge/internal/config"
 	"scroll-tech/bridge/internal/orm/migrate"
@@ -45,6 +46,10 @@ func TestMain(m *testing.M) {
 func setupEnv(t *testing.T) {
 	base = docker.NewDockerApp()
 	base.RunDBImage(t)
+
+	logger, err1 := cutils.LogSetup(nil)
+	assert.NoError(t, err1)
+
 	var err error
 	db, err = utils.InitDB(
 		&config.DBConfig{
@@ -53,6 +58,7 @@ func setupEnv(t *testing.T) {
 			MaxOpenNum: base.DBConfig.MaxOpenNum,
 			MaxIdleNum: base.DBConfig.MaxIdleNum,
 		},
+		logger,
 	)
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()

bridge/internal/utils/db.go

@@ -1,17 +1,52 @@
 package utils
 
 import (
+	"context"
+	"time"
+
+	"github.com/scroll-tech/go-ethereum/log"
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
+	"gorm.io/gorm/utils"
 
 	"scroll-tech/bridge/internal/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{}) {
+	g.gethLogger.Info(msg, data)
+}
+
+func (g *gormLogger) Warn(_ context.Context, msg string, data ...interface{}) {
+	g.gethLogger.Warn(msg, data)
+}
+
+func (g *gormLogger) Error(_ context.Context, msg string, data ...interface{}) {
+	g.gethLogger.Error(msg, data)
+}
+
+func (g *gormLogger) Trace(_ context.Context, begin time.Time, fc func() (string, int64), err error) {
+	elapsed := time.Since(begin)
+	rows, sql := fc()
+	g.gethLogger.Debug("gorm", "line", utils.FileWithLineNum(), "cost", elapsed, "rows", sql, "sql", rows)
+}
+
 // InitDB init the db handler
-func InitDB(config *config.DBConfig) (*gorm.DB, error) {
+func InitDB(config *config.DBConfig, gethLogger log.Logger) (*gorm.DB, error) {
+	tmpGormLogger := gormLogger{
+		gethLogger: gethLogger,
+	}
+
 	db, err := gorm.Open(postgres.Open(config.DSN), &gorm.Config{
-		Logger: logger.Default.LogMode(logger.Info),
+		Logger: &tmpGormLogger,
 	})
 	if err != nil {
 		return nil, err

bridge/tests/bridge_test.go

@@ -12,6 +12,7 @@ import (
 	"gorm.io/gorm"
 
 	"scroll-tech/common/docker"
+	cutils "scroll-tech/common/utils"
 
 	bcmd "scroll-tech/bridge/cmd"
 	"scroll-tech/bridge/internal/config"
@@ -52,7 +53,9 @@ func setupDB(t *testing.T) *gorm.DB {
 		MaxOpenNum: base.DBConfig.MaxOpenNum,
 		MaxIdleNum: base.DBConfig.MaxIdleNum,
 	}
-	db, err := utils.InitDB(cfg)
+	logger, err1 := cutils.LogSetup(nil)
+	assert.NoError(t, err1)
+	db, err := utils.InitDB(cfg, logger)
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)

bridge/utils/confirmation.go

@@ -1,56 +0,0 @@
-package utils
-
-import (
-	"context"
-	"fmt"
-	"math/big"
-
-	"github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/rpc"
-)
-
-type ethClient interface {
-	BlockNumber(ctx context.Context) (uint64, error)
-	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
-}
-
-// GetLatestConfirmedBlockNumber get confirmed block number by rpc.BlockNumber type.
-func GetLatestConfirmedBlockNumber(ctx context.Context, client ethClient, confirm rpc.BlockNumber) (uint64, error) {
-	switch true {
-	case confirm == rpc.SafeBlockNumber || confirm == rpc.FinalizedBlockNumber:
-		var tag *big.Int
-		if confirm == rpc.FinalizedBlockNumber {
-			tag = big.NewInt(int64(rpc.FinalizedBlockNumber))
-		} else {
-			tag = big.NewInt(int64(rpc.SafeBlockNumber))
-		}
-
-		header, err := client.HeaderByNumber(ctx, tag)
-		if err != nil {
-			return 0, err
-		}
-		if !header.Number.IsInt64() {
-			return 0, fmt.Errorf("received invalid block confirm: %v", header.Number)
-		}
-		return header.Number.Uint64(), nil
-	case confirm == rpc.LatestBlockNumber:
-		number, err := client.BlockNumber(ctx)
-		if err != nil {
-			return 0, err
-		}
-		return number, nil
-	case confirm.Int64() >= 0: // If it's positive integer, consider it as a certain confirm value.
-		number, err := client.BlockNumber(ctx)
-		if err != nil {
-			return 0, err
-		}
-		cfmNum := uint64(confirm.Int64())
-
-		if number >= cfmNum {
-			return number - cfmNum, nil
-		}
-		return 0, nil
-	default:
-		return 0, fmt.Errorf("unknown confirmation type: %v", confirm)
-	}
-}

bridge/utils/confirmation_test.go

@@ -1,134 +0,0 @@
-package utils
-
-import (
-	"context"
-	"encoding/json"
-	"math/big"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/scroll-tech/go-ethereum/common/math"
-	"github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/rpc"
-)
-
-var (
-	tests = []struct {
-		input    string
-		mustFail bool
-		expected rpc.BlockNumber
-	}{
-		{`"0x"`, true, rpc.BlockNumber(0)},
-		{`"0x0"`, false, rpc.BlockNumber(0)},
-		{`"0X1"`, false, rpc.BlockNumber(1)},
-		{`"0x00"`, true, rpc.BlockNumber(0)},
-		{`"0x01"`, true, rpc.BlockNumber(0)},
-		{`"0x1"`, false, rpc.BlockNumber(1)},
-		{`"0x12"`, false, rpc.BlockNumber(18)},
-		{`"0x7fffffffffffffff"`, false, rpc.BlockNumber(math.MaxInt64)},
-		{`"0x8000000000000000"`, true, rpc.BlockNumber(0)},
-		{"0", true, rpc.BlockNumber(0)},
-		{`"ff"`, true, rpc.BlockNumber(0)},
-		{`"safe"`, false, rpc.SafeBlockNumber},
-		{`"finalized"`, false, rpc.FinalizedBlockNumber},
-		{`"pending"`, false, rpc.PendingBlockNumber},
-		{`"latest"`, false, rpc.LatestBlockNumber},
-		{`"earliest"`, false, rpc.EarliestBlockNumber},
-		{`someString`, true, rpc.BlockNumber(0)},
-		{`""`, true, rpc.BlockNumber(0)},
-		{``, true, rpc.BlockNumber(0)},
-	}
-)
-
-func TestUnmarshalJSON(t *testing.T) {
-	for i, test := range tests {
-		var num rpc.BlockNumber
-		err := json.Unmarshal([]byte(test.input), &num)
-		if test.mustFail && err == nil {
-			t.Errorf("Test %d should fail", i)
-			continue
-		}
-		if !test.mustFail && err != nil {
-			t.Errorf("Test %d should pass but got err: %v", i, err)
-			continue
-		}
-		if num != test.expected {
-			t.Errorf("Test %d got unexpected value, want %d, got %d", i, test.expected, num)
-		}
-	}
-}
-
-func TestMarshalJSON(t *testing.T) {
-	for i, test := range tests {
-		var num rpc.BlockNumber
-		want, err := json.Marshal(test.expected)
-		assert.NoError(t, err)
-		if !test.mustFail {
-			err = json.Unmarshal([]byte(test.input), &num)
-			assert.NoError(t, err)
-			got, err := json.Marshal(&num)
-			assert.NoError(t, err)
-			if string(want) != string(got) {
-				t.Errorf("Test %d got unexpected value, want %d, got %d", i, test.expected, num)
-			}
-		}
-	}
-}
-
-type MockEthClient struct {
-	val uint64
-}
-
-func (e MockEthClient) BlockNumber(ctx context.Context) (uint64, error) {
-	return e.val, nil
-}
-
-func (e MockEthClient) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
-	var blockNumber int64
-	switch number.Int64() {
-	case int64(rpc.LatestBlockNumber):
-		blockNumber = int64(e.val)
-	case int64(rpc.SafeBlockNumber):
-		blockNumber = int64(e.val) - 6
-	case int64(rpc.FinalizedBlockNumber):
-		blockNumber = int64(e.val) - 12
-	default:
-		blockNumber = number.Int64()
-	}
-	if blockNumber < 0 {
-		blockNumber = 0
-	}
-
-	return &types.Header{Number: new(big.Int).SetInt64(blockNumber)}, nil
-}
-
-func TestGetLatestConfirmedBlockNumber(t *testing.T) {
-	ctx := context.Background()
-	client := MockEthClient{}
-
-	testCases := []struct {
-		blockNumber    uint64
-		confirmation   rpc.BlockNumber
-		expectedResult uint64
-	}{
-		{5, 6, 0},
-		{7, 6, 1},
-		{10, 2, 8},
-		{0, 1, 0},
-		{3, 0, 3},
-		{15, 15, 0},
-		{16, rpc.SafeBlockNumber, 10},
-		{22, rpc.FinalizedBlockNumber, 10},
-		{10, rpc.LatestBlockNumber, 10},
-		{5, rpc.SafeBlockNumber, 0},
-		{11, rpc.FinalizedBlockNumber, 0},
-	}
-
-	for _, testCase := range testCases {
-		client.val = testCase.blockNumber
-		confirmed, err := GetLatestConfirmedBlockNumber(ctx, &client, testCase.confirmation)
-		assert.NoError(t, err)
-		assert.Equal(t, testCase.expectedResult, confirmed)
-	}
-}

bridge/utils/utils.go

@@ -1,65 +0,0 @@
-package utils
-
-import (
-	"fmt"
-	"math/big"
-
-	"github.com/scroll-tech/go-ethereum/accounts/abi"
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/crypto"
-
-	bridgeabi "scroll-tech/bridge/abi"
-)
-
-// Keccak2 compute the keccack256 of two concatenations of bytes32
-func Keccak2(a common.Hash, b common.Hash) common.Hash {
-	return common.BytesToHash(crypto.Keccak256(append(a.Bytes()[:], b.Bytes()[:]...)))
-}
-
-// ComputeMessageHash compute the message hash
-func ComputeMessageHash(
-	sender common.Address,
-	target common.Address,
-	value *big.Int,
-	messageNonce *big.Int,
-	message []byte,
-) common.Hash {
-	data, _ := bridgeabi.L2ScrollMessengerABI.Pack("relayMessage", sender, target, value, messageNonce, message)
-	return common.BytesToHash(crypto.Keccak256(data))
-}
-
-// BufferToUint256Le convert bytes array to uint256 array assuming little-endian
-func BufferToUint256Le(buffer []byte) []*big.Int {
-	buffer256 := make([]*big.Int, len(buffer)/32)
-	for i := 0; i < len(buffer)/32; i++ {
-		v := big.NewInt(0)
-		shft := big.NewInt(1)
-		for j := 0; j < 32; j++ {
-			v = new(big.Int).Add(v, new(big.Int).Mul(shft, big.NewInt(int64(buffer[i*32+j]))))
-			shft = new(big.Int).Mul(shft, big.NewInt(256))
-		}
-		buffer256[i] = v
-	}
-	return buffer256
-}
-
-// UnpackLog unpacks a retrieved log into the provided output structure.
-// @todo: add unit test.
-func UnpackLog(c *abi.ABI, out interface{}, event string, log types.Log) error {
-	if log.Topics[0] != c.Events[event].ID {
-		return fmt.Errorf("event signature mismatch")
-	}
-	if len(log.Data) > 0 {
-		if err := c.UnpackIntoInterface(out, event, log.Data); err != nil {
-			return err
-		}
-	}
-	var indexed abi.Arguments
-	for _, arg := range c.Events[event].Inputs {
-		if arg.Indexed {
-			indexed = append(indexed, arg)
-		}
-	}
-	return abi.ParseTopics(out, indexed, log.Topics[1:])
-}

bridge/utils/utils_test.go

@@ -1,49 +0,0 @@
-package utils
-
-import (
-	"math/big"
-	"testing"
-
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestKeccak2(t *testing.T) {
-	hash := Keccak2(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"))
-	if hash != common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5") {
-		t.Fatalf("Invalid keccak, want %s, got %s", "0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5", hash.Hex())
-	}
-
-	hash = Keccak2(common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5"), common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5"))
-	if hash != common.HexToHash("0xb4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30") {
-		t.Fatalf("Invalid keccak, want %s, got %s", "0xb4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30", hash.Hex())
-	}
-
-	hash = Keccak2(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"), common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
-	if hash != common.HexToHash("0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0") {
-		t.Fatalf("Invalid keccak, want %s, got %s", "0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0", hash.Hex())
-	}
-}
-
-func TestComputeMessageHash(t *testing.T) {
-	hash := ComputeMessageHash(
-		common.HexToAddress("0x1C5A77d9FA7eF466951B2F01F724BCa3A5820b63"),
-		common.HexToAddress("0x4592D8f8D7B001e72Cb26A73e4Fa1806a51aC79d"),
-		big.NewInt(0),
-		big.NewInt(1),
-		[]byte("testbridgecontract"),
-	)
-	assert.Equal(t, "0xda253c04595a49017bb54b1b46088c69752b5ad2f0c47971ac76b8b25abec202", hash.String())
-}
-
-func TestBufferToUint256Le(t *testing.T) {
-	input := []byte{
-		0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	}
-	expectedOutput := []*big.Int{big.NewInt(1)}
-	result := BufferToUint256Le(input)
-	assert.Equal(t, expectedOutput, result)
-}

common/utils/logger.go

@@ -13,7 +13,7 @@ import (
 )
 
 // LogSetup is for setup logger
-func LogSetup(ctx *cli.Context) error {
+func LogSetup(ctx *cli.Context) (log.Logger, error) {
 	var ostream log.Handler
 	if logFile := ctx.String(LogFileFlag.Name); len(logFile) > 0 {
 		fp, err := os.OpenFile(filepath.Clean(logFile), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0600)
@@ -38,6 +38,7 @@ func LogSetup(ctx *cli.Context) error {
 	glogger := log.NewGlogHandler(ostream)
 	// Set log level
 	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
-	log.Root().SetHandler(glogger)
-	return nil
+	logger := log.Root()
+	logger.SetHandler(glogger)
+	return logger, nil
 }

common/version/version.go

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

coordinator/cmd/app/app.go

@@ -7,7 +7,6 @@ import (
 	"os/signal"
 
 	"github.com/scroll-tech/go-ethereum/ethclient"
-
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/urfave/cli/v2"
 
@@ -36,7 +35,8 @@ func init() {
 	app.Flags = append(app.Flags, apiFlags...)
 
 	app.Before = func(ctx *cli.Context) error {
-		return utils.LogSetup(ctx)
+		_, err := utils.LogSetup(ctx)
+		return err
 	}
 
 	// Register `coordinator-test` app for integration-test.

database/cmd/app/app.go

@@ -24,7 +24,8 @@ func init() {
 	app.Flags = append(app.Flags, utils.CommonFlags...)
 
 	app.Before = func(ctx *cli.Context) error {
-		return utils.LogSetup(ctx)
+		_, err := utils.LogSetup(ctx)
+		return err
 	}
 
 	app.Commands = []*cli.Command{

roller/cmd/app/app.go

@@ -26,7 +26,8 @@ func init() {
 	app.Version = version.Version
 	app.Flags = append(app.Flags, utils.CommonFlags...)
 	app.Before = func(ctx *cli.Context) error {
-		return utils.LogSetup(ctx)
+		_, err := utils.LogSetup(ctx)
+		return err
 	}
 
 	// Register `roller-test` app for integration-test.