make the version correct

bridge-history-api/abi/backend_abi.go

@@ -43,6 +43,8 @@ var (
 
 	// ScrollChainABI holds information about ScrollChain's context and available invokable methods.
 	ScrollChainABI *abi.ABI
+	// ScrollChainV2ABI holds information about ScrollChainV2's context and available invokable methods.
+	ScrollChainV2ABI *abi.ABI
 	// L1ScrollMessengerABI holds information about L1ScrollMessenger's context and available invokable methods.
 	L1ScrollMessengerABI *abi.ABI
 	// L1MessageQueueABI holds information about L1MessageQueue contract's context and available invokable methods.
@@ -116,6 +118,7 @@ func init() {
 
 	// scroll monorepo
 	ScrollChainABI, _ = ScrollChainMetaData.GetAbi()
+	ScrollChainV2ABI, _ = ScrollChainV2MetaData.GetAbi()
 	L1ScrollMessengerABI, _ = L1ScrollMessengerMetaData.GetAbi()
 	L1MessageQueueABI, _ = L1MessageQueueMetaData.GetAbi()
 	L2GasPriceOracleABI, _ = L2GasPriceOracleMetaData.GetAbi()
@@ -198,6 +201,11 @@ var ScrollChainMetaData = &bind.MetaData{
 	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"CommitBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"FinalizeBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"RevertBatch\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"parentHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"baseFee\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"gasLimit\",\"type\":\"uint64\"},{\"internalType\":\"uint16\",\"name\":\"numTransactions\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"numL1Messages\",\"type\":\"uint16\"}],\"internalType\":\"structIScrollChain.BlockContext[]\",\"name\":\"blocks\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes32\",\"name\":\"prevStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"withdrawTrieRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"batchIndex\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"parentBatchHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"l2Transactions\",\"type\":\"bytes\"}],\"internalType\":\"structIScrollChain.Batch\",\"name\":\"batch\",\"type\":\"tuple\"}],\"name\":\"commitBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"parentHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"baseFee\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"gasLimit\",\"type\":\"uint64\"},{\"internalType\":\"uint16\",\"name\":\"numTransactions\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"numL1Messages\",\"type\":\"uint16\"}],\"internalType\":\"structIScrollChain.BlockContext[]\",\"name\":\"blocks\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes32\",\"name\":\"prevStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"withdrawTrieRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"batchIndex\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"parentBatchHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"l2Transactions\",\"type\":\"bytes\"}],\"internalType\":\"structIScrollChain.Batch[]\",\"name\":\"batches\",\"type\":\"tuple[]\"}],\"name\":\"commitBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"batchId\",\"type\":\"bytes32\"},{\"internalType\":\"uint256[]\",\"name\":\"proof\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"instances\",\"type\":\"uint256[]\"}],\"name\":\"finalizeBatchWithProof\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"getL2MessageRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"isBatchFinalized\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"batchId\",\"type\":\"bytes32\"}],\"name\":\"revertBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
 }
 
+// ScrollChainV2MetaData contains all meta data concerning the ScrollChain contract.
+var ScrollChainV2MetaData = &bind.MetaData{
+	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"CommitBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"withdrawRoot\",\"type\":\"bytes32\"}],\"name\":\"FinalizeBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"RevertBatch\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"parentBatchHeader\",\"type\":\"bytes\"},{\"internalType\":\"bytes[]\",\"name\":\"chunks\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes\",\"name\":\"skippedL1MessageBitmap\",\"type\":\"bytes\"}],\"name\":\"commitBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"batchIndex\",\"type\":\"uint256\"}],\"name\":\"committedBatches\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"batchHeader\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"prevStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"postStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"withdrawRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"aggrProof\",\"type\":\"bytes\"}],\"name\":\"finalizeBatchWithProof\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"batchIndex\",\"type\":\"uint256\"}],\"name\":\"finalizedStateRoots\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"batchIndex\",\"type\":\"uint256\"}],\"name\":\"isBatchFinalized\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"batchHeader\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"count\",\"type\":\"uint256\"}],\"name\":\"revertBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"batchIndex\",\"type\":\"uint256\"}],\"name\":\"withdrawRoots\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
 // L1ScrollMessengerMetaData contains all meta data concerning the L1ScrollMessenger contract.
 var L1ScrollMessengerMetaData = &bind.MetaData{
 	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"messageHash\",\"type\":\"bytes32\"}],\"name\":\"FailedRelayedMessage\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"messageHash\",\"type\":\"bytes32\"}],\"name\":\"RelayedMessage\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"messageNonce\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"SentMessage\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"merkleProof\",\"type\":\"bytes\"}],\"internalType\":\"structIL1ScrollMessenger.L2MessageProof\",\"name\":\"proof\",\"type\":\"tuple\"}],\"name\":\"relayMessageWithProof\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"queueIndex\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"},{\"internalType\":\"uint32\",\"name\":\"oldGasLimit\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"newGasLimit\",\"type\":\"uint32\"}],\"name\":\"replayMessage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"sendMessage\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"xDomainMessageSender\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
@@ -325,3 +333,31 @@ type L2FailedRelayedMessageEvent struct {
 type L2RelayedMessageEvent struct {
 	MessageHash common.Hash
 }
+
+// IScrollChainBatch is an auto generated low-level Go binding around an user-defined struct.
+type IScrollChainBatch struct {
+	Blocks           []IScrollChainBlockContext
+	PrevStateRoot    common.Hash
+	NewStateRoot     common.Hash
+	WithdrawTrieRoot common.Hash
+	BatchIndex       uint64
+	ParentBatchHash  common.Hash
+	L2Transactions   []byte
+}
+
+// L1CommitBatchEvent represents a CommitBatch event raised by the ScrollChain contract.
+type L1CommitBatchEvent struct {
+	BatchHash common.Hash
+}
+
+// IScrollChainBlockContext is an auto generated low-level Go binding around an user-defined struct.
+type IScrollChainBlockContext struct {
+	BlockHash       common.Hash
+	ParentHash      common.Hash
+	BlockNumber     uint64
+	Timestamp       uint64
+	BaseFee         *big.Int
+	GasLimit        uint64
+	NumTransactions uint16
+	NumL1Messages   uint16
+}

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

@@ -5,6 +5,7 @@ import (
 	"os"
 
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/iris-contrib/middleware/cors"
 	"github.com/kataras/iris/v12"
 	"github.com/kataras/iris/v12/mvc"
 	"github.com/urfave/cli/v2"
@@ -60,6 +61,11 @@ func init() {
 }
 
 func action(ctx *cli.Context) error {
+	corsOptions := cors.New(cors.Options{
+		AllowedOrigins:   []string{"*"},
+		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE"},
+		AllowCredentials: true,
+	})
 	// Load config file.
 	cfgFile := ctx.String(cutils.ConfigFileFlag.Name)
 	cfg, err := config.NewConfig(cfgFile)
@@ -72,13 +78,14 @@ func action(ctx *cli.Context) error {
 	}
 	defer database.Close()
 	bridgeApp := iris.New()
+	bridgeApp.UseRouter(corsOptions)
 	bridgeApp.Get("/ping", pong).Describe("healthcheck")
 
 	mvc.Configure(bridgeApp.Party("/api/txs"), setupQueryByAddressHandler)
 	mvc.Configure(bridgeApp.Party("/api/txsbyhashes"), setupQueryByHashHandler)
 
 	// TODO: make debug mode configurable
-	err = bridgeApp.Listen(":8080", iris.WithLogLevel("debug"))
+	err = bridgeApp.Listen(cfg.Server.HostPort, iris.WithLogLevel("debug"))
 	if err != nil {
 		log.Crit("can not start server", "err", err)
 	}

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

@@ -13,6 +13,7 @@ import (
 
 	"bridge-history-api/config"
 	"bridge-history-api/cross_msg"
+	"bridge-history-api/cross_msg/message_proof"
 	"bridge-history-api/db"
 	cutils "bridge-history-api/utils"
 )
@@ -54,6 +55,7 @@ func action(ctx *cli.Context) error {
 		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
 	}
 	db, err := db.NewOrmFactory(cfg)
+	defer db.Close()
 	if err != nil {
 		log.Crit("failed to connect to db", "config file", cfgFile, "error", err)
 	}
@@ -98,6 +100,21 @@ func action(ctx *cli.Context) error {
 	go l2crossMsgFetcher.Start()
 	defer l2crossMsgFetcher.Stop()
 
+	// BlockTimestamp fetcher for l1 and l2
+	l1BlockTimeFetcher := cross_msg.NewBlockTimestampFetcher(subCtx, cfg.L1.Confirmation, int(cfg.L1.BlockTime), l1client, db.UpdateL1BlockTimestamp, db.GetL1EarliestNoBlockTimestampHeight)
+	go l1BlockTimeFetcher.Start()
+	defer l1BlockTimeFetcher.Stop()
+
+	l2BlockTimeFetcher := cross_msg.NewBlockTimestampFetcher(subCtx, cfg.L2.Confirmation, int(cfg.L2.BlockTime), l2client, db.UpdateL2BlockTimestamp, db.GetL2EarliestNoBlockTimestampHeight)
+	go l2BlockTimeFetcher.Start()
+	defer l2BlockTimeFetcher.Stop()
+
+	// Proof updater and batch fetcher
+	l2msgProofUpdater := message_proof.NewMsgProofUpdater(subCtx, cfg.L1.Confirmation, cfg.BatchInfoFetcher.BatchIndexStartBlock, db)
+	batchFetcher := cross_msg.NewBatchInfoFetcher(subCtx, common.HexToAddress(cfg.BatchInfoFetcher.ScrollChainAddr), cfg.BatchInfoFetcher.BatchIndexStartBlock, cfg.L1.Confirmation, int(cfg.L1.BlockTime), l1client, db, l2msgProofUpdater)
+	go batchFetcher.Start()
+	defer batchFetcher.Stop()
+
 	// Catch CTRL-C to ensure a graceful shutdown.
 	interrupt := make(chan os.Signal, 1)
 	signal.Notify(interrupt, os.Interrupt)

bridge-history-api/config.json

@@ -1,34 +1,41 @@
 {
+	"batchInfoFetcher": {
+		"batchIndexStartBlock": 9091265,
+		"ScrollChainAddr": "0xcD00DB804C819175B381b2B44Aa16A391c8a01D6"
+	},
 	"l1": {
 		"confirmation": 64,
 		"endpoint": "https://rpc.ankr.com/eth_goerli",
-		"startHeight": 8890194 ,
+		"startHeight": 9090194 ,
 		"blockTime": 10,
-		"MessengerAddr": "0x5260e38080BFe97e6C4925d9209eCc5f964373b6",
-		"ETHGatewayAddr": "0x429b73A21cF3BF1f3E696a21A95408161daF311f",
-		"WETHGatewayAddr": "0x8be69E499D8848DfFb4cF9bac909f3e2cF2FeFa0",
-		"StandardERC20Gateway": "0xeF37207c1A1efF6D6a9d7BfF3cF4270e406d319b",
-		"CustomERC20GatewayAddr": "0x920f906B814597cF5DC76F95100F09CBAF9c5748",
-		"ERC721GatewayAddr": "0x1C441Dfc5C2eD7A2AA8636748A664E59CB029157",
-		"ERC1155GatewayAddr": "0xd1bE599aaCBC21448fD6373bbc7c1b4c7806f135"
+		"MessengerAddr": "0x326517Eb8eB1Ce5eaB5b513C2e9A24839b402d90",
+		"ETHGatewayAddr": "0x8305cB7B8448677736095965B63d7431017328fe",
+		"WETHGatewayAddr": "0xe3bA3c60d99a2d9a5f817734bC85353470b23931",
+		"StandardERC20Gateway": "0x16c1079B27eD9c363B7D08aC5Ae937A398972A5C",
+		"CustomERC20GatewayAddr": "0x61f08caD3d6F77801167d3bA8669433701586643",
+		"ERC721GatewayAddr": "0x4A73D25A4C99CB912acaf6C5B5e554f2982201c5",
+		"ERC1155GatewayAddr": "0xa3F5DD3033698c2832C53f3C3Fe6E062F58cD808"
 	},
 	"l2": {
 		"confirmation": 1,
-		"endpoint": "https://alpha-rpc.scroll.io/l2",
+		"endpoint": "http://staging-l2geth-rpc0.scroll.tech:8545",
 		"blockTime": 3,
-		"startHeight": 1600068,
-		"CustomERC20GatewayAddr": "0xa07Cb742657294C339fB4d5d6CdF3fdBeE8C1c68",
-		"ERC721GatewayAddr": "0x8Fee20e0C0Ef16f2898a8073531a857D11b9C700",
-		"StandardERC20Gateway": "0xB878F37BB278bf0e4974856fFe86f5e6F66BD725",
-		"MessengerAddr": "0xb75d7e84517e1504C151B270255B087Fd746D34C",
-		"ETHGatewayAddr": "0x32139B5C8838E94fFcD83E60dff95Daa7F0bA14c",
-		"WETHGatewayAddr": "0xBb88bF582F2BBa46702621dae5CB9271057bC85b",
-		"ERC1155GatewayAddr": "0x2946cB860028276b3C4bccE1767841641C2E0828"
+		"startHeight": 0,
+		"CustomERC20GatewayAddr": "0x905db21f836749fEeD12de781afc4A5Ab4Dd0d51",
+		"ERC721GatewayAddr": "0xC53D835514780664BCd7eCfcE7c2E5d9554dc41B",
+		"StandardERC20Gateway": "0x90271634BCB020e06ea4840C3f7aa61b8F860651",
+		"MessengerAddr": "0xE8b0956Ac75c65Aa1669e83888DA13afF2E108f4",
+		"ETHGatewayAddr": "0xD5938590D5dD8ce95812D4D515a219C12C551D67",
+		"WETHGatewayAddr": "0xb0aaA582564fade4232a16fdB1383004A6A7247F",
+		"ERC1155GatewayAddr": "0x4f33B1655619c2C0B7C450128Df760B4365Cb549"
 	},
 	"db": {
 		"dsn": "postgres://postgres:1234@localhost:5444/test?sslmode=disable",
 		"driverName": "postgres",
 		"maxOpenNum": 200,
 		"maxIdleNum": 20
+	},
+	"server": {
+		"hostPort": "0.0.0.0:20006"
 	}
 }

bridge-history-api/config/config.go

@@ -6,6 +6,11 @@ import (
 	"path/filepath"
 )
 
+type BatchInfoFetcherConfig struct {
+	BatchIndexStartBlock uint64 `json:"batchIndexStartBlock"`
+	ScrollChainAddr      string `json:"ScrollChainAddr"`
+}
+
 // DBConfig db config
 type DBConfig struct {
 	// data source name
@@ -30,6 +35,10 @@ type LayerConfig struct {
 	CustomERC20GatewayAddr string `json:"CustomERC20GatewayAddr"`
 }
 
+type ServerConfig struct {
+	HostPort string `json:"hostPort"`
+}
+
 // Config is the configuration of the bridge history backend
 type Config struct {
 	// chain config
@@ -37,7 +46,9 @@ type Config struct {
 	L2 *LayerConfig `json:"l2"`
 
 	// data source name
-	DB *DBConfig `json:"db"`
+	DB               *DBConfig               `json:"db"`
+	Server           *ServerConfig           `json:"server"`
+	BatchInfoFetcher *BatchInfoFetcherConfig `json:"batchInfoFetcher"`
 }
 
 // NewConfig returns a new instance of Config.

bridge-history-api/controller/controller.go

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

bridge-history-api/cross_msg/batch_info_fetcher.go

@@ -0,0 +1,105 @@
+package cross_msg
+
+import (
+	"context"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+
+	"bridge-history-api/cross_msg/message_proof"
+	"bridge-history-api/db"
+	"bridge-history-api/utils"
+)
+
+type BatchInfoFetcher struct {
+	ctx                  context.Context
+	scrollChainAddr      common.Address
+	batchInfoStartNumber uint64
+	confirmation         uint64
+	blockTimeInSec       int
+	client               *ethclient.Client
+	db                   db.OrmFactory
+	msgProofUpdater      *message_proof.MsgProofUpdater
+}
+
+func NewBatchInfoFetcher(ctx context.Context, scrollChainAddr common.Address, batchInfoStartNumber uint64, confirmation uint64, blockTimeInSec int, client *ethclient.Client, db db.OrmFactory, msgProofUpdater *message_proof.MsgProofUpdater) *BatchInfoFetcher {
+	return &BatchInfoFetcher{
+		ctx:                  ctx,
+		scrollChainAddr:      scrollChainAddr,
+		batchInfoStartNumber: batchInfoStartNumber,
+		confirmation:         confirmation,
+		blockTimeInSec:       blockTimeInSec,
+		client:               client,
+		db:                   db,
+		msgProofUpdater:      msgProofUpdater,
+	}
+}
+
+func (b *BatchInfoFetcher) Start() {
+	log.Info("BatchInfoFetcher Start")
+	// Fetch batch info at beginning
+	// Then start msg proof updater after db have some bridge batch
+	err := b.fetchBatchInfo()
+	if err != nil {
+		log.Error("fetch batch info at begining failed: ", "err", err)
+	}
+
+	go b.msgProofUpdater.Start()
+
+	go func() {
+		tick := time.NewTicker(time.Duration(b.blockTimeInSec) * time.Second)
+		for {
+			select {
+			case <-b.ctx.Done():
+				tick.Stop()
+				return
+			case <-tick.C:
+				err := b.fetchBatchInfo()
+				if err != nil {
+					log.Error("fetch batch info failed: ", "err", err)
+				}
+			}
+		}
+	}()
+}
+
+func (b *BatchInfoFetcher) Stop() {
+	log.Info("BatchInfoFetcher Stop")
+	b.msgProofUpdater.Stop()
+}
+
+func (b *BatchInfoFetcher) fetchBatchInfo() error {
+	number, err := utils.GetSafeBlockNumber(b.ctx, b.client, b.confirmation)
+	if err != nil {
+		log.Error("Can not get latest block number: ", "err", err)
+		return err
+	}
+	latestBatch, err := b.db.GetLatestRollupBatch()
+	if err != nil {
+		log.Error("Can not get latest BatchInfo: ", "err", err)
+		return err
+	}
+	var startHeight uint64
+	if latestBatch == nil {
+		startHeight = b.batchInfoStartNumber
+	} else {
+		startHeight = latestBatch.CommitHeight + 1
+	}
+	for from := startHeight; number >= from; from += uint64(fetchLimit) {
+		to := from + uint64(fetchLimit) - 1
+		// number - confirmation can never less than 0 since the for loop condition
+		// but watch out the overflow
+		if to > number {
+			to = number
+		}
+		// filter logs to fetch batches
+		err = FetchAndSaveBatchIndex(b.ctx, b.client, b.db, int64(from), int64(to), b.scrollChainAddr)
+		if err != nil {
+			log.Error("Can not fetch and save from chain: ", "err", err)
+			return err
+		}
+	}
+	return nil
+}

bridge-history-api/cross_msg/block_timestamp_fetcher.go

@@ -0,0 +1,78 @@
+package cross_msg
+
+import (
+	"context"
+	"math/big"
+	"time"
+
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+type GetEarliestNoBlockTimestampHeightFunc func() (uint64, error)
+type UpdateBlockTimestampFunc func(height uint64, timestamp time.Time) error
+
+type BlockTimestampFetcher struct {
+	ctx                                   context.Context
+	confirmation                          uint64
+	blockTimeInSec                        int
+	client                                *ethclient.Client
+	updateBlockTimestampFunc              UpdateBlockTimestampFunc
+	getEarliestNoBlockTimestampHeightFunc GetEarliestNoBlockTimestampHeightFunc
+}
+
+func NewBlockTimestampFetcher(ctx context.Context, confirmation uint64, blockTimeInSec int, client *ethclient.Client, updateBlockTimestampFunc UpdateBlockTimestampFunc, getEarliestNoBlockTimestampHeightFunc GetEarliestNoBlockTimestampHeightFunc) *BlockTimestampFetcher {
+	return &BlockTimestampFetcher{
+		ctx:                                   ctx,
+		confirmation:                          confirmation,
+		blockTimeInSec:                        blockTimeInSec,
+		client:                                client,
+		getEarliestNoBlockTimestampHeightFunc: getEarliestNoBlockTimestampHeightFunc,
+		updateBlockTimestampFunc:              updateBlockTimestampFunc,
+	}
+}
+
+func (b *BlockTimestampFetcher) Start() {
+	go func() {
+		tick := time.NewTicker(time.Duration(b.blockTimeInSec) * time.Second)
+		for {
+			select {
+			case <-b.ctx.Done():
+				tick.Stop()
+				return
+			case <-tick.C:
+				number, err := b.client.BlockNumber(b.ctx)
+				if err != nil {
+					log.Error("Can not get latest block number", "err", err)
+					continue
+				}
+				startHeight, err := b.getEarliestNoBlockTimestampHeightFunc()
+				if err != nil {
+					log.Error("Can not get latest record without block timestamp", "err", err)
+					continue
+				}
+				for height := startHeight; number >= height+b.confirmation && height > 0; {
+					block, err := b.client.HeaderByNumber(b.ctx, new(big.Int).SetUint64(height))
+					if err != nil {
+						log.Error("Can not get block by number", "err", err)
+						break
+					}
+					err = b.updateBlockTimestampFunc(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()
+					if err != nil {
+						log.Error("Can not get latest record without block timestamp", "err", err)
+						break
+					}
+				}
+			}
+		}
+	}()
+}
+
+func (b *BlockTimestampFetcher) Stop() {
+	log.Info("BlockTimestampFetcher Stop")
+}

bridge-history-api/cross_msg/cross_msg_fetcher.go

@@ -27,13 +27,12 @@ type CrossMsgFetcher struct {
 	reorgHandling ReorgHandling
 	addressList   []common.Address
 	cachedHeaders []*types.Header
-	mu            *sync.Mutex
+	mu            sync.Mutex
 	reorgStartCh  chan struct{}
 	reorgEndCh    chan struct{}
 }
 
 func NewCrossMsgFetcher(ctx context.Context, config *config.LayerConfig, db db.OrmFactory, client *ethclient.Client, worker *FetchEventWorker, addressList []common.Address, reorg ReorgHandling) (*CrossMsgFetcher, error) {
-	newMU := &sync.Mutex{}
 	crossMsgFetcher := &CrossMsgFetcher{
 		ctx:           ctx,
 		config:        config,
@@ -41,7 +40,6 @@ func NewCrossMsgFetcher(ctx context.Context, config *config.LayerConfig, db db.O
 		client:        client,
 		worker:        worker,
 		reorgHandling: reorg,
-		mu:            newMU,
 		addressList:   addressList,
 		cachedHeaders: make([]*types.Header, 0),
 		reorgStartCh:  make(chan struct{}),
@@ -97,7 +95,6 @@ func (c *CrossMsgFetcher) Start() {
 }
 
 func (c *CrossMsgFetcher) Stop() {
-	c.db.Close()
 	log.Info("CrossMsgFetcher Stop")
 }
 
@@ -106,7 +103,7 @@ func (c *CrossMsgFetcher) forwardFetchAndSaveMissingEvents(confirmation uint64)
 	// if we fetch to the latest block, shall not exceed cachedHeaders
 	var number uint64
 	var err error
-	if len(c.cachedHeaders) != 0 && confirmation <= 0 {
+	if len(c.cachedHeaders) != 0 && confirmation == 0 {
 		number = c.cachedHeaders[len(c.cachedHeaders)-1].Number.Uint64() - 1
 	} else {
 		number, err = utils.GetSafeBlockNumber(c.ctx, c.client, confirmation)
@@ -119,22 +116,22 @@ func (c *CrossMsgFetcher) forwardFetchAndSaveMissingEvents(confirmation uint64)
 		log.Error(fmt.Sprintf("%s: invalid get/fetch function", c.worker.Name))
 		return
 	}
-	processed_height, err := c.worker.G(c.db)
+	processedHeight, err := c.worker.G(c.db)
 	if err != nil {
 		log.Error(fmt.Sprintf("%s: can not get latest processed block height", c.worker.Name))
 	}
-	log.Info(fmt.Sprintf("%s: ", c.worker.Name), "height", processed_height)
-	if processed_height <= 0 || processed_height < int64(c.config.StartHeight) {
-		processed_height = int64(c.config.StartHeight)
+	log.Info(fmt.Sprintf("%s: ", c.worker.Name), "height", processedHeight)
+	if processedHeight <= 0 || processedHeight < int64(c.config.StartHeight) {
+		processedHeight = int64(c.config.StartHeight)
 	} else {
-		processed_height += 1
+		processedHeight += 1
 	}
-	for n := processed_height; n <= int64(number); n += FETCH_LIMIT {
-		iter_end := n + FETCH_LIMIT - 1
-		if iter_end > int64(number) {
-			iter_end = int64(number)
+	for from := processedHeight; from <= int64(number); from += fetchLimit {
+		to := from + fetchLimit - 1
+		if to > int64(number) {
+			to = int64(number)
 		}
-		err := c.worker.F(c.ctx, c.client, c.db, n, iter_end, c.addressList)
+		err := c.worker.F(c.ctx, c.client, c.db, from, to, c.addressList)
 		if err != nil {
 			log.Error(fmt.Sprintf("%s: failed!", c.worker.Name), "err", err)
 			break

bridge-history-api/cross_msg/fetch_missing_event.go

@@ -6,21 +6,19 @@ import (
 
 	geth "github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/jmoiron/sqlx"
 
 	backendabi "bridge-history-api/abi"
 	"bridge-history-api/db"
-	"bridge-history-api/db/orm"
 	"bridge-history-api/utils"
 )
 
 // Todo : read from config
 var (
 	// the number of blocks fetch per round
-	FETCH_LIMIT = int64(3000)
+	fetchLimit = int64(3000)
 )
 
 // FetchAndSave is a function type that fetches events from blockchain and saves them to database
@@ -36,11 +34,6 @@ type FetchEventWorker struct {
 	Name string
 }
 
-type msgHashWrapper struct {
-	msgHash common.Hash
-	txHash  common.Hash
-}
-
 func GetLatestL1ProcessedHeight(db db.OrmFactory) (int64, error) {
 	crossHeight, err := db.GetLatestL1ProcessedHeight()
 	if err != nil {
@@ -70,15 +63,22 @@ func GetLatestL2ProcessedHeight(db db.OrmFactory) (int64, error) {
 		log.Error("failed to get L2 relayed message processed height", "err", err)
 		return 0, err
 	}
-	if crossHeight > relayedHeight {
-		return crossHeight, nil
-	} else {
-		return relayedHeight, nil
+	l2SentHeight, err := db.GetLatestSentMsgHeightOnL2()
+	if err != nil {
+		log.Error("failed to get L2 sent message processed height", "err", err)
+		return 0, err
 	}
+	maxHeight := crossHeight
+	if maxHeight < relayedHeight {
+		maxHeight = relayedHeight
+	}
+	if maxHeight < l2SentHeight {
+		maxHeight = l2SentHeight
+	}
+	return maxHeight, nil
 }
 
 func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addrList []common.Address) error {
-
 	query := geth.FilterQuery{
 		FromBlock: big.NewInt(from), // inclusive
 		ToBlock:   big.NewInt(to),   // inclusive
@@ -99,7 +99,7 @@ func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 		log.Warn("Failed to get l1 event logs", "err", err)
 		return err
 	}
-	depositL1CrossMsgs, msgHashes, relayedMsg, err := parseBackendL1EventLogs(logs)
+	depositL1CrossMsgs, msgHashes, relayedMsg, err := utils.ParseBackendL1EventLogs(logs)
 	if err != nil {
 		log.Error("l1FetchAndSaveEvents: Failed to parse cross msg event logs", "err", err)
 		return err
@@ -157,7 +157,7 @@ func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 		log.Warn("Failed to get l2 event logs", "err", err)
 		return err
 	}
-	depositL2CrossMsgs, msgHashes, relayedMsg, err := parseBackendL2EventLogs(logs)
+	depositL2CrossMsgs, msgHashes, relayedMsg, l2sentMsgs, err := utils.ParseBackendL2EventLogs(logs)
 	if err != nil {
 		log.Error("l2FetchAndSaveEvents: Failed to parse cross msg event logs", "err", err)
 		return err
@@ -178,11 +178,19 @@ func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 		dbTx.Rollback()
 		log.Crit("l2FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
 	}
+
 	err = updateL2CrossMsgMsgHash(ctx, dbTx, database, msgHashes)
 	if err != nil {
 		dbTx.Rollback()
 		log.Crit("l2FetchAndSaveEvents: Failed to update msgHash in L2 cross msg", "err", err)
 	}
+
+	err = database.BatchInsertL2SentMsgDBTx(dbTx, l2sentMsgs)
+	if err != nil {
+		dbTx.Rollback()
+		log.Crit("l2FetchAndSaveEvents: Failed to insert l2 sent message", "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
@@ -194,234 +202,61 @@ func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 	return nil
 }
 
-func parseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []msgHashWrapper, []*orm.RelayedMsg, error) {
-	// Need use contract abi to parse event Log
-	// Can only be tested after we have our contracts set up
-
-	var l1CrossMsg []*orm.CrossMsg
-	var relayedMsgs []*orm.RelayedMsg
-	var msgHashes []msgHashWrapper
-	for _, vlog := range logs {
-		switch vlog.Topics[0] {
-		case backendabi.L1DepositETHSig:
-			event := backendabi.DepositETH{}
-			err := utils.UnpackLog(backendabi.L1ETHGatewayABI, &event, "DepositETH", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositETH event", "err", err)
-				return l1CrossMsg, msgHashes, relayedMsgs, err
-			}
-			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
-				Height:     vlog.BlockNumber,
-				Sender:     event.From.String(),
-				Target:     event.To.String(),
-				Amount:     event.Amount.String(),
-				Asset:      int(orm.ETH),
-				Layer1Hash: vlog.TxHash.Hex(),
-			})
-		case backendabi.L1DepositERC20Sig:
-			event := backendabi.ERC20MessageEvent{}
-			err := utils.UnpackLog(backendabi.L1StandardERC20GatewayABI, &event, "DepositERC20", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositERC20 event", "err", err)
-				return l1CrossMsg, msgHashes, relayedMsgs, err
-			}
-			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Amount:      event.Amount.String(),
-				Asset:       int(orm.ERC20),
-				Layer1Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-			})
-		case backendabi.L1DepositERC721Sig:
-			event := backendabi.ERC721MessageEvent{}
-			err := utils.UnpackLog(backendabi.L1ERC721GatewayABI, &event, "DepositERC721", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositERC721 event", "err", err)
-				return l1CrossMsg, msgHashes, relayedMsgs, err
-			}
-			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Asset:       int(orm.ERC721),
-				Layer1Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				TokenID:     event.TokenID.Uint64(),
-			})
-		case backendabi.L1DepositERC1155Sig:
-			event := backendabi.ERC1155MessageEvent{}
-			err := utils.UnpackLog(backendabi.L1ERC1155GatewayABI, &event, "DepositERC1155", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositERC1155 event", "err", err)
-				return l1CrossMsg, msgHashes, relayedMsgs, err
-			}
-			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Asset:       int(orm.ERC1155),
-				Layer1Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				TokenID:     event.TokenID.Uint64(),
-				Amount:      event.Amount.String(),
-			})
-		case backendabi.L1SentMessageEventSignature:
-			event := backendabi.L1SentMessageEvent{}
-			err := utils.UnpackLog(backendabi.L1ScrollMessengerABI, &event, "SentMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack SentMessage event", "err", err)
-				return l1CrossMsg, msgHashes, relayedMsgs, err
-			}
-			msgHash := utils.ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message)
-			msgHashes = append(msgHashes, msgHashWrapper{
-				msgHash: msgHash,
-				txHash:  vlog.TxHash})
-		case backendabi.L1RelayedMessageEventSignature:
-			event := backendabi.L1RelayedMessageEvent{}
-			err := utils.UnpackLog(backendabi.L1ScrollMessengerABI, &event, "RelayedMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack RelayedMessage event", "err", err)
-				return l1CrossMsg, msgHashes, relayedMsgs, err
-			}
-			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
-				MsgHash:    event.MessageHash.String(),
-				Height:     vlog.BlockNumber,
-				Layer1Hash: vlog.TxHash.Hex(),
-			})
-
-		}
-
+func FetchAndSaveBatchIndex(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, scrollChainAddr common.Address) error {
+	query := geth.FilterQuery{
+		FromBlock: big.NewInt(from), // inclusive
+		ToBlock:   big.NewInt(to),   // inclusive
+		Addresses: []common.Address{scrollChainAddr},
+		Topics:    make([][]common.Hash, 1),
 	}
-	return l1CrossMsg, msgHashes, relayedMsgs, nil
+	query.Topics[0] = make([]common.Hash, 1)
+	query.Topics[0][0] = backendabi.L1CommitBatchEventSignature
+	logs, err := client.FilterLogs(ctx, query)
+	if err != nil {
+		log.Warn("Failed to get batch commit event logs", "err", err)
+		return err
+	}
+	rollupBatches, err := utils.ParseBatchInfoFromScrollChain(ctx, client, logs)
+	if err != nil {
+		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 {
+		dbTx.Rollback()
+		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
+		dbTx.Rollback()
+		log.Error("FetchAndSaveBatchIndex: Failed to commit db transaction", "err", err)
+		return err
+	}
+	return nil
 }
 
-func parseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []msgHashWrapper, []*orm.RelayedMsg, error) {
-	// Need use contract abi to parse event Log
-	// Can only be tested after we have our contracts set up
-
-	var l2CrossMsg []*orm.CrossMsg
-	var relayedMsgs []*orm.RelayedMsg
-	var msgHashes []msgHashWrapper
-	for _, vlog := range logs {
-		switch vlog.Topics[0] {
-		case backendabi.L2WithdrawETHSig:
-			event := backendabi.DepositETH{}
-			err := utils.UnpackLog(backendabi.L2ETHGatewayABI, &event, "WithdrawETH", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawETH event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
-				Height:     vlog.BlockNumber,
-				Sender:     event.From.String(),
-				Target:     event.To.String(),
-				Amount:     event.Amount.String(),
-				Asset:      int(orm.ETH),
-				Layer2Hash: vlog.TxHash.Hex(),
-			})
-		case backendabi.L2WithdrawERC20Sig:
-			event := backendabi.ERC20MessageEvent{}
-			err := utils.UnpackLog(backendabi.L2StandardERC20GatewayABI, &event, "WithdrawERC20", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawERC20 event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Amount:      event.Amount.String(),
-				Asset:       int(orm.ERC20),
-				Layer2Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-			})
-		case backendabi.L2WithdrawERC721Sig:
-			event := backendabi.ERC721MessageEvent{}
-			err := utils.UnpackLog(backendabi.L2ERC721GatewayABI, &event, "WithdrawERC721", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawERC721 event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Asset:       int(orm.ERC721),
-				Layer2Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				TokenID:     event.TokenID.Uint64(),
-			})
-		case backendabi.L2WithdrawERC1155Sig:
-			event := backendabi.ERC1155MessageEvent{}
-			err := utils.UnpackLog(backendabi.L2ERC1155GatewayABI, &event, "WithdrawERC1155", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawERC1155 event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Asset:       int(orm.ERC1155),
-				Layer2Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				TokenID:     event.TokenID.Uint64(),
-				Amount:      event.Amount.String(),
-			})
-		case backendabi.L2SentMessageEventSignature:
-			event := backendabi.L2SentMessageEvent{}
-			err := utils.UnpackLog(backendabi.L2ScrollMessengerABI, &event, "SentMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack SentMessage event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			msgHash := utils.ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message)
-			msgHashes = append(msgHashes, msgHashWrapper{
-				msgHash: msgHash,
-				txHash:  vlog.TxHash})
-		case backendabi.L2RelayedMessageEventSignature:
-			event := backendabi.L2RelayedMessageEvent{}
-			err := utils.UnpackLog(backendabi.L2ScrollMessengerABI, &event, "RelayedMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack RelayedMessage event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
-				MsgHash:    event.MessageHash.String(),
-				Height:     vlog.BlockNumber,
-				Layer2Hash: vlog.TxHash.Hex(),
-			})
-
-		}
-
-	}
-	return l2CrossMsg, msgHashes, relayedMsgs, nil
-}
-
-func updateL1CrossMsgMsgHash(ctx context.Context, dbTx *sqlx.Tx, database db.OrmFactory, msgHashes []msgHashWrapper) error {
+func updateL1CrossMsgMsgHash(ctx context.Context, dbTx *sqlx.Tx, database db.OrmFactory, msgHashes []utils.MsgHashWrapper) error {
 	for _, msgHash := range msgHashes {
-		err := database.UpdateL1CrossMsgHashDBTx(ctx, dbTx, msgHash.txHash, msgHash.msgHash)
+		err := database.UpdateL1CrossMsgHashDBTx(ctx, dbTx, msgHash.TxHash, msgHash.MsgHash)
 		if err != nil {
-			log.Error("updateL1CrossMsgMsgHash: can not update layer1 cross msg MsgHash", "layer1 hash", msgHash.txHash, "err", err)
+			log.Error("updateL1CrossMsgMsgHash: can not update layer1 cross msg MsgHash", "layer1 hash", msgHash.TxHash, "err", err)
 			continue
 		}
 	}
 	return nil
 }
 
-func updateL2CrossMsgMsgHash(ctx context.Context, dbTx *sqlx.Tx, database db.OrmFactory, msgHashes []msgHashWrapper) error {
+func updateL2CrossMsgMsgHash(ctx context.Context, dbTx *sqlx.Tx, database db.OrmFactory, msgHashes []utils.MsgHashWrapper) error {
 	for _, msgHash := range msgHashes {
-		err := database.UpdateL2CrossMsgHashDBTx(ctx, dbTx, msgHash.txHash, msgHash.msgHash)
+		err := database.UpdateL2CrossMsgHashDBTx(ctx, dbTx, msgHash.TxHash, msgHash.MsgHash)
 		if err != nil {
-			log.Error("updateL2CrossMsgMsgHash: can not update layer2 cross msg MsgHash", "layer2 hash", msgHash.txHash, "err", err)
+			log.Error("updateL2CrossMsgMsgHash: can not update layer2 cross msg MsgHash", "layer2 hash", msgHash.TxHash, "err", err)
 			continue
 		}
 	}

bridge-history-api/cross_msg/message_proof/msg_proof_updater.go

@@ -0,0 +1,241 @@
+package message_proof
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+
+	"bridge-history-api/db"
+	"bridge-history-api/db/orm"
+)
+
+type MsgProofUpdater struct {
+	ctx          context.Context
+	db           db.OrmFactory
+	withdrawTrie *WithdrawTrie
+}
+
+func NewMsgProofUpdater(ctx context.Context, confirmations uint64, startBlock uint64, db db.OrmFactory) *MsgProofUpdater {
+	return &MsgProofUpdater{
+		ctx:          ctx,
+		db:           db,
+		withdrawTrie: NewWithdrawTrie(),
+	}
+}
+
+func (m *MsgProofUpdater) Start() {
+	log.Info("MsgProofUpdater Start")
+	m.initialize(m.ctx)
+	go func() {
+		tick := time.NewTicker(10 * time.Second)
+		for {
+			select {
+			case <-m.ctx.Done():
+				tick.Stop()
+				return
+			case <-tick.C:
+				latestBatch, err := m.db.GetLatestRollupBatch()
+				if err != nil {
+					log.Warn("MsgProofUpdater: Can not get latest RollupBatch: ", "err", err)
+					continue
+				}
+				if latestBatch == nil {
+					continue
+				}
+				latestBatchIndexWithProof, err := m.db.GetLatestL2SentMsgBatchIndex()
+				if err != nil {
+					log.Error("MsgProofUpdater: Can not get latest L2SentMsgBatchIndex: ", "err", err)
+					continue
+				}
+				var start uint64
+				if latestBatchIndexWithProof < 0 {
+					start = 1
+				} else {
+					start = uint64(latestBatchIndexWithProof) + 1
+				}
+				for i := start; i <= latestBatch.BatchIndex; i++ {
+					batch, err := m.db.GetRollupBatchByIndex(i)
+					if err != nil {
+						log.Error("MsgProofUpdater: Can not get RollupBatch: ", "err", err, "index", i)
+						break
+					}
+					// get all l2 messages in this batch
+					msgs, proofs, err := m.appendL2Messages(batch.StartBlockNumber, batch.EndBlockNumber)
+					if err != nil {
+						log.Error("MsgProofUpdater: can not append l2messages", "startBlockNumber", batch.StartBlockNumber, "endBlockNumber", batch.EndBlockNumber, "err", err)
+						break
+					}
+					err = m.updateMsgProof(msgs, proofs, batch.BatchIndex)
+					if err != nil {
+						log.Error("MsgProofUpdater: can not update msg proof", "err", err)
+						break
+					}
+				}
+
+			}
+		}
+	}()
+
+}
+
+func (m *MsgProofUpdater) Stop() {
+	log.Info("MsgProofUpdater Stop")
+}
+
+func (m *MsgProofUpdater) initialize(ctx context.Context) {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+			err := m.initializeWithdrawTrie()
+			if err != nil {
+				log.Error("can not initialize withdraw trie", "err", err)
+				// give it some time to retry
+				time.Sleep(10 * time.Second)
+				continue
+			}
+			return
+		}
+	}
+}
+
+func (m *MsgProofUpdater) initializeWithdrawTrie() error {
+	var batch *orm.RollupBatch
+	firstMsg, err := m.db.GetL2SentMessageByNonce(0)
+	if err != nil && !errors.Is(err, sql.ErrNoRows) {
+		return fmt.Errorf("failed to get first l2 message: %v", err)
+	}
+	// no l2 message
+	// 	TO DO: check if we realy dont have l2 sent message with nonce 0
+	if firstMsg == nil {
+		log.Info("No first l2sentmsg in db")
+		return nil
+	}
+
+	// if no batch, return and wait for next try round
+	batch, err = m.db.GetLatestRollupBatch()
+	if err != nil {
+		return fmt.Errorf("failed to get latest batch: %v", err)
+	}
+	if batch == nil {
+		return fmt.Errorf("no batch found")
+	}
+
+	var batches []*orm.RollupBatch
+	batchIndex := batch.BatchIndex
+	for {
+		var msg *orm.L2SentMsg
+		msg, err = m.db.GetLatestL2SentMsgLEHeight(batch.EndBlockNumber)
+		if err != nil {
+			log.Warn("failed to get l2 sent message less than height", "endBlocknum", batch.EndBlockNumber, "err", err)
+		}
+		if msg != nil && msg.MsgProof != "" {
+			log.Info("Found latest l2 sent msg with proof: ", "msg_proof", msg.MsgProof, "height", msg.Height, "msg_hash", msg.MsgHash)
+			// initialize withdrawTrie
+			proofBytes := common.Hex2Bytes(msg.MsgProof)
+			m.withdrawTrie.Initialize(msg.Nonce, common.HexToHash(msg.MsgHash), proofBytes)
+			break
+		}
+
+		// append unprocessed batch
+		batches = append(batches, batch)
+
+		if batchIndex == 1 {
+			// otherwise overflow
+			// and batchIndex 0 is not in DB
+			// To Do: check if we dont have batch with index 0 in future
+			break
+		}
+		// iterate for next batch
+		batchIndex--
+
+		batch, err = m.db.GetRollupBatchByIndex(batchIndex)
+		if err != nil {
+			return fmt.Errorf("failed to get block batch %v: %v", batchIndex, err)
+		}
+	}
+
+	log.Info("Build withdraw trie with pending messages")
+	for i := len(batches) - 1; i >= 0; i-- {
+		b := batches[i]
+		msgs, proofs, err := m.appendL2Messages(b.StartBlockNumber, b.EndBlockNumber)
+		if err != nil {
+			return err
+		}
+
+		err = m.updateMsgProof(msgs, proofs, b.BatchIndex)
+		if err != nil {
+			return err
+		}
+	}
+	log.Info("Build withdraw trie finished")
+
+	return nil
+}
+
+func (m *MsgProofUpdater) updateMsgProof(msgs []*orm.L2SentMsg, proofs [][]byte, batchIndex uint64) error {
+	if len(msgs) == 0 {
+		return nil
+	}
+	// this should not happend, but double checked
+	if len(msgs) != len(proofs) {
+		return fmt.Errorf("illegal state: len(msgs) != len(proofs)")
+	}
+	dbTx, err := m.db.Beginx()
+	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)
+	if err != nil {
+		log.Error("GetL2SentMsgMsgHashByHeightRange failed", "error", err, "firstBlock", firstBlock, "lastBlock", lastBlock)
+		return messages, msgProofs, err
+	}
+	if len(messages) == 0 {
+		return messages, msgProofs, nil
+	}
+
+	// double check whether nonce is matched
+	if messages[0].Nonce != m.withdrawTrie.NextMessageNonce {
+		log.Error("L2 message nonce mismatch", "expected", m.withdrawTrie.NextMessageNonce, "found", messages[0].Nonce)
+		return messages, msgProofs, fmt.Errorf("l2 message nonce mismatch, expected: %v, found: %v", m.withdrawTrie.NextMessageNonce, messages[0].Nonce)
+	}
+
+	var hashes []common.Hash
+	for _, msg := range messages {
+		hashes = append(hashes, common.HexToHash(msg.MsgHash))
+	}
+	msgProofs = m.withdrawTrie.AppendMessages(hashes)
+
+	return messages, msgProofs, nil
+}

bridge-history-api/cross_msg/message_proof/withdraw_trie.go

@@ -0,0 +1,189 @@
+package message_proof
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+
+	"bridge-history-api/utils"
+)
+
+// MaxHeight is the maixium possible height of withdraw trie
+const MaxHeight = 40
+
+// WithdrawTrie is an append only merkle trie
+type WithdrawTrie struct {
+	// used to rebuild the merkle tree
+	NextMessageNonce uint64
+
+	height int // current height of withdraw trie
+
+	branches []common.Hash
+	zeroes   []common.Hash
+}
+
+// NewWithdrawTrie will return a new instance of WithdrawTrie
+func NewWithdrawTrie() *WithdrawTrie {
+	zeroes := make([]common.Hash, MaxHeight)
+	branches := make([]common.Hash, MaxHeight)
+
+	zeroes[0] = common.Hash{}
+	for i := 1; i < MaxHeight; i++ {
+		zeroes[i] = utils.Keccak2(zeroes[i-1], zeroes[i-1])
+	}
+
+	return &WithdrawTrie{
+		zeroes:           zeroes,
+		branches:         branches,
+		height:           -1,
+		NextMessageNonce: 0,
+	}
+}
+
+// Initialize will initialize the merkle trie with rightest leaf node
+func (w *WithdrawTrie) Initialize(currentMessageNonce uint64, msgHash common.Hash, proofBytes []byte) {
+	proof := DecodeBytesToMerkleProof(proofBytes)
+	branches := RecoverBranchFromProof(proof, currentMessageNonce, msgHash)
+	w.height = len(proof)
+	w.branches = branches
+	w.NextMessageNonce = currentMessageNonce + 1
+}
+
+// AppendMessages appends a list of new messages as leaf nodes to the rightest of the tree and returns the proofs for all messages.
+func (w *WithdrawTrie) AppendMessages(hashes []common.Hash) [][]byte {
+	length := len(hashes)
+	if length == 0 {
+		return make([][]byte, 0)
+	}
+
+	cache := make([]map[uint64]common.Hash, MaxHeight)
+	for h := 0; h < MaxHeight; h++ {
+		cache[h] = make(map[uint64]common.Hash)
+	}
+
+	// cache all branches will be used later.
+	if w.NextMessageNonce != 0 {
+		index := w.NextMessageNonce
+		for h := 0; h <= w.height; h++ {
+			if index%2 == 1 {
+				// right child, `w.branches[h]` is the corresponding left child
+				// the index of left child should be `index ^ 1`.
+				cache[h][index^1] = w.branches[h]
+			}
+			index >>= 1
+		}
+	}
+	// cache all new leaves
+	for i := 0; i < length; i++ {
+		cache[0][w.NextMessageNonce+uint64(i)] = hashes[i]
+	}
+
+	// build withdraw trie with new hashes
+	minIndex := w.NextMessageNonce
+	maxIndex := w.NextMessageNonce + uint64(length) - 1
+	for h := 0; maxIndex > 0; h++ {
+		if minIndex%2 == 1 {
+			minIndex--
+		}
+		if maxIndex%2 == 0 {
+			cache[h][maxIndex^1] = w.zeroes[h]
+		}
+		for i := minIndex; i <= maxIndex; i += 2 {
+			cache[h+1][i>>1] = utils.Keccak2(cache[h][i], cache[h][i^1])
+		}
+		minIndex >>= 1
+		maxIndex >>= 1
+	}
+
+	// update branches using hashes one by one
+	for i := 0; i < length; i++ {
+		proof := UpdateBranchWithNewMessage(w.zeroes, w.branches, w.NextMessageNonce, hashes[i])
+		w.NextMessageNonce++
+		w.height = len(proof)
+	}
+
+	proofs := make([][]byte, length)
+	// retrieve merkle proof from cache
+	for i := 0; i < length; i++ {
+		index := w.NextMessageNonce + uint64(i) - uint64(length)
+		var merkleProof []common.Hash
+		for h := 0; h < w.height; h++ {
+			merkleProof = append(merkleProof, cache[h][index^1])
+			index >>= 1
+		}
+		proofs[i] = EncodeMerkleProofToBytes(merkleProof)
+	}
+
+	return proofs
+}
+
+// MessageRoot return the current root hash of withdraw trie.
+func (w *WithdrawTrie) MessageRoot() common.Hash {
+	if w.height == -1 {
+		return common.Hash{}
+	}
+	return w.branches[w.height]
+}
+
+// DecodeBytesToMerkleProof transfer byte array to bytes32 array. The caller should make sure the length is matched.
+func DecodeBytesToMerkleProof(proofBytes []byte) []common.Hash {
+	proof := make([]common.Hash, len(proofBytes)/32)
+	for i := 0; i < len(proofBytes); i += 32 {
+		proof[i/32] = common.BytesToHash(proofBytes[i : i+32])
+	}
+	return proof
+}
+
+// EncodeMerkleProofToBytes transfer byte32 array to byte array by concatenation.
+func EncodeMerkleProofToBytes(proof []common.Hash) []byte {
+	var proofBytes []byte
+	for i := 0; i < len(proof); i++ {
+		proofBytes = append(proofBytes, proof[i][:]...)
+	}
+	return proofBytes
+}
+
+// UpdateBranchWithNewMessage update the branches to latest with new message and return the merkle proof for the message.
+func UpdateBranchWithNewMessage(zeroes []common.Hash, branches []common.Hash, index uint64, msgHash common.Hash) []common.Hash {
+	root := msgHash
+	var merkleProof []common.Hash
+	var height uint64
+	for height = 0; index > 0; height++ {
+		if index%2 == 0 {
+			// it may be used in next round.
+			branches[height] = root
+			merkleProof = append(merkleProof, zeroes[height])
+			// it's a left child, the right child must be null
+			root = utils.Keccak2(root, zeroes[height])
+		} else {
+			// it's a right child, use previously computed hash
+			root = utils.Keccak2(branches[height], root)
+			merkleProof = append(merkleProof, branches[height])
+		}
+		index >>= 1
+	}
+	branches[height] = root
+	return merkleProof
+}
+
+// RecoverBranchFromProof will recover latest branches from merkle proof and message hash
+func RecoverBranchFromProof(proof []common.Hash, index uint64, msgHash common.Hash) []common.Hash {
+	branches := make([]common.Hash, 64)
+	root := msgHash
+	var height uint64
+	for height = 0; index > 0; height++ {
+		if index%2 == 0 {
+			branches[height] = root
+			// it's a left child, the right child must be null
+			root = utils.Keccak2(root, proof[height])
+		} else {
+			// it's a right child, use previously computed hash
+			branches[height] = proof[height]
+			root = utils.Keccak2(proof[height], root)
+		}
+		index >>= 1
+	}
+	branches[height] = root
+	for height++; height < 64; height++ {
+		branches[height] = common.Hash{}
+	}
+	return branches
+}

bridge-history-api/cross_msg/message_proof/withdraw_trie_test.go

@@ -0,0 +1,212 @@
+package message_proof
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/assert"
+
+	"bridge-history-api/utils"
+)
+
+func TestUpdateBranchWithNewMessage(t *testing.T) {
+	zeroes := make([]common.Hash, 64)
+	branches := make([]common.Hash, 64)
+	zeroes[0] = common.Hash{}
+	for i := 1; i < 64; i++ {
+		zeroes[i] = utils.Keccak2(zeroes[i-1], zeroes[i-1])
+	}
+
+	UpdateBranchWithNewMessage(zeroes, branches, 0, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"))
+	if branches[0] != common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001") {
+		t.Fatalf("Invalid root, want %s, got %s", "0x0000000000000000000000000000000000000000000000000000000000000001", branches[0].Hex())
+	}
+
+	UpdateBranchWithNewMessage(zeroes, branches, 1, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
+	if branches[1] != common.HexToHash("0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0") {
+		t.Fatalf("Invalid root, want %s, got %s", "0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0", branches[1].Hex())
+	}
+
+	UpdateBranchWithNewMessage(zeroes, branches, 2, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003"))
+	if branches[2] != common.HexToHash("0x222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c") {
+		t.Fatalf("Invalid root, want %s, got %s", "0x222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c", branches[2].Hex())
+	}
+
+	UpdateBranchWithNewMessage(zeroes, branches, 3, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"))
+	if branches[2] != common.HexToHash("0xa9bb8c3f1f12e9aa903a50c47f314b57610a3ab32f2d463293f58836def38d36") {
+		t.Fatalf("Invalid root, want %s, got %s", "0xa9bb8c3f1f12e9aa903a50c47f314b57610a3ab32f2d463293f58836def38d36", branches[2].Hex())
+	}
+}
+
+func TestDecodeEncodeMerkleProof(t *testing.T) {
+	proof := DecodeBytesToMerkleProof(common.Hex2Bytes("2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49012ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49022ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49032ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4904"))
+	if len(proof) != 4 {
+		t.Fatalf("proof length mismatch, want %d, got %d", 4, len(proof))
+	}
+	if proof[0] != common.HexToHash("0x2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4901") {
+		t.Fatalf("proof[0] mismatch, want %s, got %s", "0x2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4901", proof[0].Hex())
+	}
+	if proof[1] != common.HexToHash("0x2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4902") {
+		t.Fatalf("proof[1] mismatch, want %s, got %s", "0x2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4902", proof[0].Hex())
+	}
+	if proof[2] != common.HexToHash("0x2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4903") {
+		t.Fatalf("proof[2] mismatch, want %s, got %s", "0x2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4903", proof[0].Hex())
+	}
+	if proof[3] != common.HexToHash("0x2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4904") {
+		t.Fatalf("proof[3] mismatch, want %s, got %s", "0x2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4904", proof[0].Hex())
+	}
+
+	bytes := EncodeMerkleProofToBytes(proof)
+	if common.Bytes2Hex(bytes) != "2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49012ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49022ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49032ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4904" {
+		t.Fatalf("wrong encoded bytes")
+	}
+}
+
+func TestRecoverBranchFromProof(t *testing.T) {
+	zeroes := make([]common.Hash, 64)
+	branches := make([]common.Hash, 64)
+	zeroes[0] = common.Hash{}
+	for i := 1; i < 64; i++ {
+		zeroes[i] = utils.Keccak2(zeroes[i-1], zeroes[i-1])
+	}
+
+	proof := UpdateBranchWithNewMessage(zeroes, branches, 0, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"))
+	tmpBranches := RecoverBranchFromProof(proof, 0, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"))
+	for i := 0; i < 64; i++ {
+		if tmpBranches[i] != branches[i] {
+			t.Fatalf("Invalid branch, want %s, got %s", branches[i].Hex(), tmpBranches[i].Hex())
+		}
+	}
+
+	proof = UpdateBranchWithNewMessage(zeroes, branches, 1, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
+	tmpBranches = RecoverBranchFromProof(proof, 1, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
+	for i := 0; i < 64; i++ {
+		if tmpBranches[i] != branches[i] {
+			t.Fatalf("Invalid branch, want %s, got %s", branches[i].Hex(), tmpBranches[i].Hex())
+		}
+	}
+
+	proof = UpdateBranchWithNewMessage(zeroes, branches, 2, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003"))
+	tmpBranches = RecoverBranchFromProof(proof, 2, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003"))
+	for i := 0; i < 64; i++ {
+		if tmpBranches[i] != branches[i] {
+			t.Fatalf("Invalid branch, want %s, got %s", branches[i].Hex(), tmpBranches[i].Hex())
+		}
+	}
+
+	proof = UpdateBranchWithNewMessage(zeroes, branches, 3, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"))
+	tmpBranches = RecoverBranchFromProof(proof, 3, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"))
+	for i := 0; i < 64; i++ {
+		if tmpBranches[i] != branches[i] {
+			t.Fatalf("Invalid branch, want %s, got %s", branches[i].Hex(), tmpBranches[i].Hex())
+		}
+	}
+}
+
+func TestWithdrawTrieOneByOne(t *testing.T) {
+	for initial := 0; initial < 128; initial++ {
+		withdrawTrie := NewWithdrawTrie()
+		var hashes []common.Hash
+		for i := 0; i < initial; i++ {
+			hash := common.BigToHash(big.NewInt(int64(i + 1)))
+			hashes = append(hashes, hash)
+			withdrawTrie.AppendMessages([]common.Hash{
+				hash,
+			})
+		}
+
+		for i := initial; i < 128; i++ {
+			hash := common.BigToHash(big.NewInt(int64(i + 1)))
+			hashes = append(hashes, hash)
+			expectedRoot := computeMerkleRoot(hashes)
+			proofBytes := withdrawTrie.AppendMessages([]common.Hash{
+				hash,
+			})
+			assert.Equal(t, withdrawTrie.NextMessageNonce, uint64(i+1))
+			assert.Equal(t, expectedRoot.String(), withdrawTrie.MessageRoot().String())
+			proof := DecodeBytesToMerkleProof(proofBytes[0])
+			verifiedRoot := verifyMerkleProof(uint64(i), hash, proof)
+			assert.Equal(t, expectedRoot.String(), verifiedRoot.String())
+		}
+	}
+}
+
+func TestWithdrawTrieMultiple(t *testing.T) {
+	var expectedRoots []common.Hash
+
+	{
+		var hashes []common.Hash
+		for i := 0; i < 128; i++ {
+			hash := common.BigToHash(big.NewInt(int64(i + 1)))
+			hashes = append(hashes, hash)
+			expectedRoots = append(expectedRoots, computeMerkleRoot(hashes))
+		}
+	}
+
+	for initial := 0; initial < 100; initial++ {
+		var hashes []common.Hash
+		for i := 0; i < initial; i++ {
+			hash := common.BigToHash(big.NewInt(int64(i + 1)))
+			hashes = append(hashes, hash)
+		}
+
+		for finish := initial; finish < 100; finish++ {
+			withdrawTrie := NewWithdrawTrie()
+			withdrawTrie.AppendMessages(hashes)
+
+			var newHashes []common.Hash
+			for i := initial; i <= finish; i++ {
+				hash := common.BigToHash(big.NewInt(int64(i + 1)))
+				newHashes = append(newHashes, hash)
+			}
+			proofBytes := withdrawTrie.AppendMessages(newHashes)
+			assert.Equal(t, withdrawTrie.NextMessageNonce, uint64(finish+1))
+			assert.Equal(t, expectedRoots[finish].String(), withdrawTrie.MessageRoot().String())
+
+			for i := initial; i <= finish; i++ {
+				hash := common.BigToHash(big.NewInt(int64(i + 1)))
+				proof := DecodeBytesToMerkleProof(proofBytes[i-initial])
+				verifiedRoot := verifyMerkleProof(uint64(i), hash, proof)
+				assert.Equal(t, expectedRoots[finish].String(), verifiedRoot.String())
+			}
+		}
+	}
+}
+
+func verifyMerkleProof(index uint64, leaf common.Hash, proof []common.Hash) common.Hash {
+	root := leaf
+	for _, h := range proof {
+		if index%2 == 0 {
+			root = utils.Keccak2(root, h)
+		} else {
+			root = utils.Keccak2(h, root)
+		}
+		index >>= 1
+	}
+	return root
+}
+
+func computeMerkleRoot(hashes []common.Hash) common.Hash {
+	if len(hashes) == 0 {
+		return common.Hash{}
+	}
+
+	zeroHash := common.Hash{}
+	for {
+		if len(hashes) == 1 {
+			break
+		}
+		var newHashes []common.Hash
+		for i := 0; i < len(hashes); i += 2 {
+			if i+1 < len(hashes) {
+				newHashes = append(newHashes, utils.Keccak2(hashes[i], hashes[i+1]))
+			} else {
+				newHashes = append(newHashes, utils.Keccak2(hashes[i], zeroHash))
+			}
+		}
+		hashes = newHashes
+		zeroHash = utils.Keccak2(zeroHash, zeroHash)
+	}
+	return hashes[0]
+}

bridge-history-api/cross_msg/msg_fetcher_test.go

@@ -1,7 +1,6 @@
 package cross_msg_test
 
 import (
-	"bridge-history-api/cross_msg"
 	"crypto/rand"
 	"math/big"
 	"testing"
@@ -9,6 +8,8 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/stretchr/testify/assert"
+
+	"bridge-history-api/cross_msg"
 )
 
 func TestMergeIntoList(t *testing.T) {

bridge-history-api/cross_msg/reorg_handle.go

@@ -94,6 +94,11 @@ func L2ReorgHandling(ctx context.Context, reorgHeight int64, db db.OrmFactory) e
 		dbTx.Rollback()
 		log.Crit("delete l2 relayed hash from height", "height", reorgHeight, "err", err)
 	}
+	err = db.DeleteL2SentMsgAfterHeightDBTx(dbTx, reorgHeight)
+	if err != nil {
+		dbTx.Rollback()
+		log.Crit("delete l2 sent msg from height", "height", reorgHeight, "err", err)
+	}
 	err = dbTx.Commit()
 	if err != nil {
 		dbTx.Rollback()

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

@@ -2,23 +2,24 @@
 -- +goose StatementBegin
 create table cross_message
 (
-    id           BIGSERIAL PRIMARY KEY,
-    msg_hash     VARCHAR NOT NULL DEFAULT '',
-    height       BIGINT  NOT NULL,
-    sender       VARCHAR NOT NULL,
-    target       VARCHAR NOT NULL,
-    amount       VARCHAR NOT NULL,
-    layer1_hash  VARCHAR NOT NULL DEFAULT '',
-    layer2_hash  VARCHAR NOT NULL DEFAULT '',
-    layer1_token VARCHAR NOT NULL DEFAULT '',
-    layer2_token VARCHAR NOT NULL DEFAULT '',
-    token_id     BIGINT NOT NULL DEFAULT 0,
-    asset        SMALLINT NOT NULL,
-    msg_type     SMALLINT NOT NULL,
-    is_deleted   BOOLEAN NOT NULL DEFAULT FALSE,
-    created_at   TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at   TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    deleted_at   TIMESTAMP(0) DEFAULT NULL
+    id              BIGSERIAL PRIMARY KEY,
+    msg_hash        VARCHAR NOT NULL DEFAULT '',
+    height          BIGINT  NOT NULL,
+    sender          VARCHAR NOT NULL,
+    target          VARCHAR NOT NULL,
+    amount          VARCHAR NOT NULL,
+    layer1_hash     VARCHAR NOT NULL DEFAULT '',
+    layer2_hash     VARCHAR NOT NULL DEFAULT '',
+    layer1_token    VARCHAR NOT NULL DEFAULT '',
+    layer2_token    VARCHAR NOT NULL DEFAULT '',
+    token_id        BIGINT NOT NULL DEFAULT 0,
+    asset           SMALLINT NOT NULL,
+    msg_type        SMALLINT NOT NULL,
+    is_deleted      BOOLEAN NOT NULL DEFAULT FALSE,
+    block_timestamp TIMESTAMP(0) 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
 );
 
 comment
@@ -48,20 +49,20 @@ CREATE TRIGGER update_timestamp BEFORE UPDATE
 ON cross_message FOR EACH ROW EXECUTE PROCEDURE
 update_timestamp();
 
-CREATE OR REPLACE FUNCTION delete_at_trigger()
+CREATE OR REPLACE FUNCTION deleted_at_trigger()
 RETURNS TRIGGER AS $$
 BEGIN
     IF NEW.is_deleted AND OLD.is_deleted != NEW.is_deleted THEN
-        UPDATE cross_message SET delete_at = NOW() WHERE id = NEW.id;
+        UPDATE cross_message SET deleted_at = NOW() WHERE id = NEW.id;
     END IF;
     RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;
 
-CREATE TRIGGER delete_at_trigger
+CREATE TRIGGER deleted_at_trigger
 AFTER UPDATE ON cross_message
 FOR EACH ROW
-EXECUTE FUNCTION delete_at_trigger();
+EXECUTE FUNCTION deleted_at_trigger();
 
 
 -- +goose StatementEnd

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

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

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

@@ -0,0 +1,57 @@
+-- +goose Up
+-- +goose StatementBegin
+create table l2_sent_msg
+(
+    id               BIGSERIAL PRIMARY KEY,
+    sender           VARCHAR NOT NULL,
+    target           VARCHAR NOT NULL,
+    value            VARCHAR NOT NULL,
+    msg_hash         VARCHAR NOT NULL,
+    height           BIGINT NOT NULL,
+    nonce            BIGINT NOT NULL,
+    batch_index      BIGINT NOT NULL DEFAULT 0,
+    msg_proof        TEXT NOT NULL DEFAULT '',
+    msg_data         TEXT NOT NULL DEFAULT '',
+    is_deleted       BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at       TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at       TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at       TIMESTAMP(0) DEFAULT NULL
+);
+
+comment 
+on column l2_sent_msg.is_deleted is 'NotDeleted, Deleted';
+
+CREATE OR REPLACE FUNCTION update_timestamp()
+RETURNS TRIGGER AS $$
+BEGIN
+   NEW.updated_at = CURRENT_TIMESTAMP;
+   RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+CREATE TRIGGER update_timestamp BEFORE UPDATE
+ON l2_sent_msg FOR EACH ROW EXECUTE PROCEDURE
+update_timestamp();
+
+CREATE OR REPLACE FUNCTION deleted_at_trigger()
+RETURNS TRIGGER AS $$
+BEGIN
+    IF NEW.is_deleted AND OLD.is_deleted != NEW.is_deleted THEN
+        UPDATE l2_sent_msg SET deleted_at = NOW() WHERE id = NEW.id;
+    END IF;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER deleted_at_trigger
+AFTER UPDATE ON l2_sent_msg
+FOR EACH ROW
+EXECUTE FUNCTION deleted_at_trigger();
+
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+drop table if exists l2_sent_msg;
+-- +goose StatementEnd

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

@@ -0,0 +1,49 @@
+-- +goose Up
+-- +goose StatementBegin
+create table rollup_batch
+(
+    id                  BIGSERIAL PRIMARY KEY,
+    batch_index         BIGINT NOT NULL,
+    commit_height       BIGINT NOT NULL,
+    start_block_number  BIGINT NOT NULL,
+    end_block_number    BIGINT NOT NULL,
+    batch_hash          VARCHAR NOT NULL,
+    is_deleted          BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at          TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at          TIMESTAMP(0) DEFAULT NULL
+);
+
+CREATE OR REPLACE FUNCTION update_timestamp()
+RETURNS TRIGGER AS $$
+BEGIN
+   NEW.updated_at = CURRENT_TIMESTAMP;
+   RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+CREATE TRIGGER update_timestamp BEFORE UPDATE
+ON rollup_batch FOR EACH ROW EXECUTE PROCEDURE
+update_timestamp();
+
+CREATE OR REPLACE FUNCTION deleted_at_trigger()
+RETURNS TRIGGER AS $$
+BEGIN
+    IF NEW.is_deleted AND OLD.is_deleted != NEW.is_deleted THEN
+        UPDATE rollup_batch SET deleted_at = NOW() WHERE id = NEW.id;
+    END IF;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER deleted_at_trigger
+AFTER UPDATE ON rollup_batch
+FOR EACH ROW
+EXECUTE FUNCTION deleted_at_trigger();
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+drop table if exists rollup_batch;
+-- +goose StatementEnd

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

@@ -0,0 +1,79 @@
+package orm
+
+import (
+	"database/sql"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/jmoiron/sqlx"
+)
+
+type rollupBatchOrm struct {
+	db *sqlx.DB
+}
+
+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,
+		}
+		var exists bool
+		err = dbTx.QueryRow(`SELECT EXISTS(SELECT 1 FROM rollup_batch WHERE batch_index = $1 AND NOT is_deleted)`, batch.BatchIndex).Scan(&exists)
+		if err != nil {
+			return err
+		}
+		if exists {
+			return fmt.Errorf("BatchInsertRollupBatchDBTx: batch index %v already exists at height %v", batch.BatchIndex, batch.CommitHeight)
+		}
+	}
+	_, 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

@@ -54,6 +54,7 @@ type CrossMsg struct {
 	Asset       int        `json:"asset" db:"asset"`
 	MsgType     int        `json:"msg_type" db:"msg_type"`
 	IsDeleted   bool       `json:"is_deleted" db:"is_deleted"`
+	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"`
@@ -71,23 +72,27 @@ type L1CrossMsgOrm interface {
 	GetL1CrossMsgByHash(l1Hash common.Hash) (*CrossMsg, error)
 	GetL1CrossMsgsByAddress(sender common.Address) ([]*CrossMsg, error)
 	BatchInsertL1CrossMsgDBTx(dbTx *sqlx.Tx, messages []*CrossMsg) error
-	// UpdateL1CrossMsgHash invoked when SentMessage event is received
+	// 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 l2_cross_message table
+// 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
-	// UpdateL2CrossMsgHash invoked when SentMessage event is received
+	// 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)
 }
 
 type RelayedMsgOrm interface {
@@ -98,3 +103,21 @@ type RelayedMsgOrm interface {
 	DeleteL1RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
 	DeleteL2RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
 }
+
+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, batch_index uint64) error
+	GetLatestL2SentMsgBatchIndex() (int64, error)
+	DeleteL2SentMsgAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
+}
+
+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

@@ -4,6 +4,8 @@ import (
 	"context"
 	"database/sql"
 	"errors"
+	"fmt"
+	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
@@ -70,14 +72,22 @@ func (l *l1CrossMsgOrm) BatchInsertL1CrossMsgDBTx(dbTx *sqlx.Tx, messages []*Cro
 			"token_id":     msg.TokenID,
 			"msg_type":     Layer1Msg,
 		}
-
-		_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer1_hash, layer1_token, layer2_token, token_id, amount, msg_type) select :height, :sender, :target, :asset, :layer1_hash, :layer1_token, :layer2_token, :token_id, :amount, :msg_type WHERE NOT EXISTS (SELECT 1 FROM cross_message WHERE layer1_hash = :layer1_hash AND NOT is_deleted);`, messageMaps[i])
+		var exists bool
+		err = dbTx.QueryRow(`SELECT EXISTS(SELECT 1 FROM cross_message WHERE layer1_hash = $1 AND NOT is_deleted)`, msg.Layer1Hash).Scan(&exists)
 		if err != nil {
-			log.Error("BatchInsertL1CrossMsgDBTx: failed to insert l1 cross msgs", "l1hashes", msg.Layer1Hash, "heights", msg.Height, "err", err)
-			break
+			return err
+		}
+		if exists {
+			return fmt.Errorf("BatchInsertL1CrossMsgDBTx: l1 cross msg layer1Hash %v already exists at height %v", msg.Layer1Hash, msg.Height)
 		}
 	}
-	return err
+	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer1_hash, layer1_token, layer2_token, token_id, amount, msg_type) values(:height, :sender, :target, :asset, :layer1_hash, :layer1_token, :layer2_token, :token_id, :amount, :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
@@ -118,3 +128,22 @@ func (l *l1CrossMsgOrm) DeleteL1CrossMsgAfterHeightDBTx(dbTx *sqlx.Tx, height in
 	}
 	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 NOT is_deleted`, 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 NOT is_deleted 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

@@ -4,6 +4,8 @@ import (
 	"context"
 	"database/sql"
 	"errors"
+	"fmt"
+	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
@@ -21,7 +23,7 @@ func NewL2CrossMsgOrm(db *sqlx.DB) L2CrossMsgOrm {
 
 func (l *l2CrossMsgOrm) GetL2CrossMsgByHash(l2Hash common.Hash) (*CrossMsg, error) {
 	result := &CrossMsg{}
-	row := l.db.QueryRowx(`SELECT * FROM l2_cross_message WHERE layer2_hash = $1 AND NOT is_deleted;`, l2Hash.String())
+	row := l.db.QueryRowx(`SELECT * FROM cross_message WHERE layer2_hash = $1 AND NOT is_deleted;`, l2Hash.String())
 	if err := row.StructScan(result); err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
@@ -31,7 +33,7 @@ func (l *l2CrossMsgOrm) GetL2CrossMsgByHash(l2Hash common.Hash) (*CrossMsg, erro
 	return result, nil
 }
 
-// GetL2CrossMsgsByAddress returns all layer2 cross messages under given address
+// 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
@@ -83,14 +85,21 @@ func (l *l2CrossMsgOrm) BatchInsertL2CrossMsgDBTx(dbTx *sqlx.Tx, messages []*Cro
 			"amount":       msg.Amount,
 			"msg_type":     Layer2Msg,
 		}
-
-		_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer2_hash, layer1_token, layer2_token, token_id, amount, msg_type) select :height, :sender, :target, :asset, :layer2_hash, :layer1_token, :layer2_token, :token_id, :amount, :msg_type WHERE NOT EXISTS (SELECT 1 FROM cross_message WHERE layer2_hash = :layer2_hash AND NOT is_deleted);`, messageMaps[i])
+		var exists bool
+		err = dbTx.QueryRow(`SELECT EXISTS(SELECT 1 FROM cross_message WHERE layer2_hash = $1 AND NOT is_deleted)`, msg.Layer2Hash).Scan(&exists)
 		if err != nil {
-			log.Error("BatchInsertL2CrossMsgDBTx: failed to insert l2 cross msgs", "layer2hash", msg.Layer2Hash, "heights", msg.Height, "err", err)
-			break
+			return err
+		}
+		if exists {
+			return fmt.Errorf("BatchInsertL2CrossMsgDBTx: l2 cross msg layer2Hash %v already exists at height %v", msg.Layer2Hash, msg.Height)
 		}
 	}
-	return err
+	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer2_hash, layer1_token, layer2_token, token_id, amount, msg_type) values(:height, :sender, :target, :asset, :layer2_hash, :layer1_token, :layer2_token, :token_id, :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 {
@@ -121,3 +130,22 @@ func (l *l2CrossMsgOrm) GetLatestL2ProcessedHeight() (int64, error) {
 	}
 	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 NOT is_deleted`, 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 NOT is_deleted 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
+}

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

@@ -0,0 +1,159 @@
+package orm
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/jmoiron/sqlx"
+)
+
+type L2SentMsg struct {
+	ID         uint64     `json:"id" db:"id"`
+	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"`
+	IsDeleted  bool       `json:"is_deleted" db:"is_deleted"`
+	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 NOT is_deleted;`, 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{}{
+			"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,
+		}
+		var exists bool
+		err = dbTx.QueryRow(`SELECT EXISTS(SELECT 1 FROM l2_sent_msg WHERE (msg_hash = $1 OR nonce = $2) AND NOT is_deleted)`, msg.MsgHash, msg.Nonce).Scan(&exists)
+		if err != nil {
+			return err
+		}
+		if exists {
+			return fmt.Errorf("BatchInsertL2SentMsgDBTx: l2 sent msg_hash %v already exists at height %v", msg.MsgHash, msg.Height)
+		}
+	}
+	_, err = dbTx.NamedExec(`insert into l2_sent_msg(sender, target, value, msg_hash, height, nonce, batch_index, msg_proof, msg_data) values(: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", "msg_Hash", "err", err)
+		return err
+	}
+	return err
+}
+
+func (l *l2SentMsgOrm) GetLatestSentMsgHeightOnL2() (int64, error) {
+	row := l.db.QueryRow(`SELECT height FROM l2_sent_msg WHERE NOT is_deleted 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, batch_index uint64) error {
+	if _, err := dbTx.ExecContext(ctx, l.db.Rebind("update l2_sent_msg set msg_proof = ?, batch_index = ? where msg_hash = ? AND NOT is_deleted;"), proof, batch_index, 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 msg_proof != '' AND NOT is_deleted 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 NOT is_deleted ORDER BY nonce ASC;`, startHeight, endHeight)
+	if err != nil {
+		return nil, 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 NOT is_deleted;`, 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 NOT is_deleted 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 is_deleted = true WHERE height > $1;`, height)
+	return err
+}

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

@@ -3,7 +3,6 @@ package orm
 import (
 	"database/sql"
 	"errors"
-	"strings"
 
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/jmoiron/sqlx"
@@ -31,14 +30,13 @@ func (l *relayedMsgOrm) BatchInsertRelayedMsgDBTx(dbTx *sqlx.Tx, messages []*Rel
 			"layer1_hash": msg.Layer1Hash,
 			"layer2_hash": msg.Layer2Hash,
 		}
-
-		_, err = dbTx.NamedExec(`insert into relayed_msg(msg_hash, height, layer1_hash, layer2_hash) values(:msg_hash, :height, :layer1_hash, :layer2_hash);`, messageMaps[i])
-		if err != nil && !strings.Contains(err.Error(), "pq: duplicate key value violates unique constraint \"relayed_msg_hash_uindex") {
-			log.Error("BatchInsertRelayedMsgDBTx: failed to insert l1 cross msgs", "msg_Hashe", msg.MsgHash, "height", msg.Height, "err", err)
-			break
-		}
 	}
-	return err
+	_, 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 l1 cross msgs", "msg_Hashe", "err", err)
+		return err
+	}
+	return nil
 }
 
 func (l *relayedMsgOrm) GetRelayedMsgByHash(msg_hash string) (*RelayedMsg, error) {

bridge-history-api/db/orm_factory.go

@@ -16,6 +16,9 @@ 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)
@@ -26,6 +29,8 @@ type ormFactory struct {
 	orm.L1CrossMsgOrm
 	orm.L2CrossMsgOrm
 	orm.RelayedMsgOrm
+	orm.L2SentMsgOrm
+	orm.RollupBatchOrm
 	*sqlx.DB
 }
 
@@ -44,10 +49,12 @@ func NewOrmFactory(cfg *config.Config) (OrmFactory, error) {
 	}
 
 	return &ormFactory{
-		L1CrossMsgOrm: orm.NewL1CrossMsgOrm(db),
-		L2CrossMsgOrm: orm.NewL2CrossMsgOrm(db),
-		RelayedMsgOrm: orm.NewRelayedMsgOrm(db),
-		DB:            db,
+		L1CrossMsgOrm:  orm.NewL1CrossMsgOrm(db),
+		L2CrossMsgOrm:  orm.NewL2CrossMsgOrm(db),
+		RelayedMsgOrm:  orm.NewRelayedMsgOrm(db),
+		L2SentMsgOrm:   orm.NewL2SentMsgOrm(db),
+		RollupBatchOrm: orm.NewRollupBatchOrm(db),
+		DB:             db,
 	}, nil
 }
 
@@ -59,10 +66,19 @@ func (o *ormFactory) Beginx() (*sqlx.Tx, error) {
 	return o.DB.Beginx()
 }
 
+func (o *ormFactory) GetTotalCrossMsgCountByAddress(sender string) (uint64, error) {
+	var count uint64
+	row := o.DB.QueryRowx(`SELECT COUNT(*) FROM cross_message WHERE sender = $1 AND NOT is_deleted;`, sender)
+	if err := row.Scan(&count); err != nil {
+		return 0, err
+	}
+	return count, nil
+}
+
 func (o *ormFactory) GetCrossMsgsByAddressWithOffset(sender string, offset int64, limit int64) ([]*orm.CrossMsg, error) {
 	para := sender
 	var results []*orm.CrossMsg
-	rows, err := o.DB.Queryx(`SELECT * FROM cross_message WHERE sender = $1 AND NOT is_deleted ORDER BY id DESC LIMIT $2 OFFSET $3;`, para, limit, offset)
+	rows, err := o.DB.Queryx(`SELECT * FROM cross_message WHERE sender = $1 AND NOT is_deleted ORDER BY block_timestamp DESC NULLS FIRST, id DESC LIMIT $2 OFFSET $3;`, para, limit, offset)
 	if err != nil || rows == nil {
 		return nil, err
 	}

bridge-history-api/go.mod

@@ -1,9 +1,10 @@
 module bridge-history-api
 
-go 1.20
+go 1.19
 
 require (
-	github.com/ethereum/go-ethereum v1.11.6
+	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
@@ -26,6 +27,7 @@ require (
 	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
@@ -34,14 +36,17 @@ require (
 	github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect
 	github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811 // indirect
 	github.com/cockroachdb/redact v1.1.3 // indirect
+	github.com/consensys/bavard v0.1.13 // indirect
+	github.com/consensys/gnark-crypto v0.10.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
+	github.com/crate-crypto/go-kzg-4844 v0.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/deckarep/golang-set/v2 v2.1.0 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
 	github.com/deepmap/oapi-codegen v1.8.2 // indirect
 	github.com/docker/docker v20.10.21+incompatible // indirect
-	github.com/edsrzf/mmap-go v1.0.0 // indirect
 	github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385 // indirect
+	github.com/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
@@ -92,6 +97,7 @@ require (
 	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
@@ -115,6 +121,7 @@ require (
 	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
@@ -127,12 +134,12 @@ require (
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	github.com/yosssi/ace v0.0.5 // indirect
 	github.com/yusufpapurcu/wmi v1.2.2 // indirect
-	golang.org/x/crypto v0.9.0 // indirect
+	golang.org/x/crypto v0.10.0 // indirect
 	golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect
 	golang.org/x/net v0.10.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/sys v0.8.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
+	golang.org/x/sys v0.9.0 // indirect
+	golang.org/x/text v0.10.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
 	golang.org/x/tools v0.8.0 // indirect
 	golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df // indirect
@@ -142,5 +149,6 @@ require (
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
+	rsc.io/tmplfunc v0.0.3 // indirect
 
 )

bridge-history-api/go.sum

@@ -32,6 +32,8 @@ github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd3
 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=
@@ -65,12 +67,18 @@ github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811/go.mod h1:Nb5lg
 github.com/cockroachdb/redact v1.1.3 h1:AKZds10rFSIj7qADf0g46UixK8NNLwWTNdCIGS5wfSQ=
 github.com/cockroachdb/redact v1.1.3/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg=
 github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM=
+github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ=
+github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI=
+github.com/consensys/gnark-crypto v0.10.0 h1:zRh22SR7o4K35SoNqouS9J/TKHTyU2QWaj5ldehyXtA=
+github.com/consensys/gnark-crypto v0.10.0/go.mod h1:Iq/P3HHl0ElSjsg2E1gsMwhAyxnxoKK5nVyZKd+/KhU=
 github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/crate-crypto/go-kzg-4844 v0.2.0 h1:UVuHOE+5tIWrim4zf/Xaa43+MIsDCPyW76QhUpiMGj4=
+github.com/crate-crypto/go-kzg-4844 v0.2.0/go.mod h1:SBP7ikXEgDnUPONgm33HtuDZEDtWa3L4QtN1ocJSEQ4=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -92,8 +100,6 @@ github.com/djherbis/atime v1.1.0/go.mod h1:28OF6Y8s3NQWwacXc5eZTsEsiMzp7LF8MbXE+
 github.com/docker/docker v20.10.21+incompatible h1:UTLdBmHk3bEY+w8qeO5KttOhy6OmXWsl/FEet9Uswog=
 github.com/docker/docker v20.10.21+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
-github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
-github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
 github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385 h1:clC1lXBpe2kTj2VHdaIu9ajZQe4kcEY9j0NsnDDBZ3o=
 github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
@@ -101,8 +107,10 @@ github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.m
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
-github.com/ethereum/go-ethereum v1.11.6 h1:2VF8Mf7XiSUfmoNOy3D+ocfl9Qu8baQBrCNbo2CXQ8E=
-github.com/ethereum/go-ethereum v1.11.6/go.mod h1:+a8pUj1tOyJ2RinsNQD4326YS+leSoKGiG/uVVb0x6Y=
+github.com/ethereum/c-kzg-4844 v0.2.0 h1:+cUvymlnoDDQgMInp25Bo3OmLajmmY8mLJ/tLjqd77Q=
+github.com/ethereum/c-kzg-4844 v0.2.0/go.mod h1:WI2Nd82DMZAAZI1wV2neKGost9EKjvbpQR9OqE5Qqa8=
+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=
@@ -193,6 +201,7 @@ 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=
@@ -233,6 +242,8 @@ github.com/iris-contrib/go.uuid v2.0.0+incompatible h1:XZubAYg61/JwnJNbZilGjf3b3
 github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0=
 github.com/iris-contrib/httpexpect/v2 v2.12.1 h1:3cTZSyBBen/kfjCtgNFoUKi1u0FVXNaAjyRJOo6AVS4=
 github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk=
+github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458 h1:V60rHQJc6DieKV1BqHIGclraPdO4kinuFAZIrPGHN7s=
+github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458/go.mod h1:7eVziAp1yUwFB/ZMg71n84VWQH+7wukvxcHuF2e7cbg=
 github.com/iris-contrib/pongo2 v0.0.1/go.mod h1:Ssh+00+3GAZqSQb30AvBRNxBx7rf0GqwkjqxNd0u65g=
 github.com/iris-contrib/schema v0.0.1/go.mod h1:urYA3uvUNG1TIIjOSCzHr9/LmbQo8LrOcOqfqxa4hXw=
 github.com/iris-contrib/schema v0.0.6 h1:CPSBLyx2e91H2yJzPuhGuifVRnZBBJ3pCOMbOvPZaTw=
@@ -290,6 +301,7 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0
 github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg=
 github.com/labstack/echo/v4 v4.5.0/go.mod h1:czIriw4a0C1dFun+ObrXp7ok03xON0N1awStJ6ArI7Y=
 github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
+github.com/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=
@@ -341,6 +353,9 @@ 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/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY=
+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/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
@@ -453,6 +468,8 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/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=
@@ -520,8 +537,8 @@ golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWP
 golang.org/x/crypto v0.0.0-20210314154223-e6e6c4f2bb5b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
-golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
+golang.org/x/crypto v0.10.0 h1:LKqV2xt9+kDzSTfOhx4FrkEBcMrAgHSYgzywV9zcGmM=
+golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20230206171751-46f607a40771 h1:xP7rWLUr1e1n2xkK5YB4LI0hPEy3LJC6Wk+D4pGlOJg=
 golang.org/x/exp v0.0.0-20230206171751-46f607a40771/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
@@ -611,8 +628,8 @@ golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.9.0 h1:KS/R3tvhPqvJvwcKfnBHJwwthS11LRhmM5D59eEXa0s=
+golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -621,8 +638,8 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.10.0 h1:UpjohKhiEgNc0CSauXmwYftY1+LlaC75SJwh0SgCX58=
+golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
@@ -720,3 +737,5 @@ 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/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU=
+rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA=

bridge-history-api/model/response.go

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

bridge-history-api/service/service.go

@@ -1,6 +1,7 @@
 package service
 
 import (
+	"strconv"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -19,20 +20,32 @@ type Finalized struct {
 	BlockTimestamp *time.Time `json:"blockTimestamp"` // uselesss
 }
 
+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"`
+}
+
 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"`
-	CreatedAt      *time.Time `json:"createdTime"`
+	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, error)
+	GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error)
 	GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, error)
 }
 
@@ -47,6 +60,30 @@ type historyBackend struct {
 	db     db.OrmFactory
 }
 
+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:      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 {
@@ -69,28 +106,35 @@ func updateCrossTxHash(msgHash string, txInfo *TxHistoryInfo, db db.OrmFactory)
 
 }
 
-func (h *historyBackend) GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, error) {
-	txHistories := make([]*TxHistoryInfo, 0)
+func (h *historyBackend) GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error) {
+	var txHistories []*TxHistoryInfo
+	total, err := h.db.GetTotalCrossMsgCountByAddress(address.String())
+	if err != nil || total == 0 {
+		return txHistories, 0, err
+	}
 	result, err := h.db.GetCrossMsgsByAddressWithOffset(address.String(), offset, limit)
+
 	if err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 	for _, msg := range result {
 		txHistory := &TxHistoryInfo{
-			Hash:        msg.MsgHash,
-			Amount:      msg.Amount,
-			To:          msg.Target,
-			IsL1:        msg.MsgType == int(orm.Layer1Msg),
-			BlockNumber: msg.Height,
-			CreatedAt:   msg.CreatedAt,
+			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, nil
+	return txHistories, total, nil
 }
 
 func (h *historyBackend) GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, error) {
@@ -102,12 +146,13 @@ func (h *historyBackend) GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, erro
 		}
 		if l1result != nil {
 			txHistory := &TxHistoryInfo{
-				Hash:        l1result.Layer1Hash,
-				Amount:      l1result.Amount,
-				To:          l1result.Target,
-				IsL1:        true,
-				BlockNumber: l1result.Height,
-				CreatedAt:   l1result.CreatedAt,
+				Hash:           l1result.Layer1Hash,
+				Amount:         l1result.Amount,
+				To:             l1result.Target,
+				IsL1:           true,
+				BlockNumber:    l1result.Height,
+				BlockTimestamp: l1result.Timestamp,
+				CreatedAt:      l1result.CreatedAt,
 				FinalizeTx: &Finalized{
 					Hash: "",
 				},
@@ -122,15 +167,17 @@ func (h *historyBackend) GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, erro
 		}
 		if l2result != nil {
 			txHistory := &TxHistoryInfo{
-				Hash:        l2result.Layer2Hash,
-				Amount:      l2result.Amount,
-				To:          l2result.Target,
-				IsL1:        false,
-				BlockNumber: l2result.Height,
-				CreatedAt:   l2result.CreatedAt,
+				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)

bridge-history-api/utils/parse_event.go

@@ -0,0 +1,305 @@
+package utils
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+
+	backendabi "bridge-history-api/abi"
+	"bridge-history-api/db/orm"
+)
+
+type MsgHashWrapper struct {
+	MsgHash common.Hash
+	TxHash  common.Hash
+}
+
+type CachedParsedTxCalldata struct {
+	CallDataIndex uint64
+	BatchIndices  []uint64
+	StartBlocks   []uint64
+	EndBlocks     []uint64
+}
+
+func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []MsgHashWrapper, []*orm.RelayedMsg, error) {
+	// Need use contract abi to parse event Log
+	// Can only be tested after we have our contracts set up
+
+	var l1CrossMsg []*orm.CrossMsg
+	var relayedMsgs []*orm.RelayedMsg
+	var msgHashes []MsgHashWrapper
+	for _, vlog := range logs {
+		switch vlog.Topics[0] {
+		case backendabi.L1DepositETHSig:
+			event := backendabi.DepositETH{}
+			err := UnpackLog(backendabi.L1ETHGatewayABI, &event, "DepositETH", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositETH event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
+				Height:     vlog.BlockNumber,
+				Sender:     event.From.String(),
+				Target:     event.To.String(),
+				Amount:     event.Amount.String(),
+				Asset:      int(orm.ETH),
+				Layer1Hash: vlog.TxHash.Hex(),
+			})
+		case backendabi.L1DepositERC20Sig:
+			event := backendabi.ERC20MessageEvent{}
+			err := UnpackLog(backendabi.L1StandardERC20GatewayABI, &event, "DepositERC20", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositERC20 event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Amount:      event.Amount.String(),
+				Asset:       int(orm.ERC20),
+				Layer1Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+			})
+		case backendabi.L1DepositERC721Sig:
+			event := backendabi.ERC721MessageEvent{}
+			err := UnpackLog(backendabi.L1ERC721GatewayABI, &event, "DepositERC721", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositERC721 event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Asset:       int(orm.ERC721),
+				Layer1Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+				TokenID:     event.TokenID.Uint64(),
+			})
+		case backendabi.L1DepositERC1155Sig:
+			event := backendabi.ERC1155MessageEvent{}
+			err := UnpackLog(backendabi.L1ERC1155GatewayABI, &event, "DepositERC1155", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack DepositERC1155 event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Asset:       int(orm.ERC1155),
+				Layer1Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+				TokenID:     event.TokenID.Uint64(),
+				Amount:      event.Amount.String(),
+			})
+		case backendabi.L1SentMessageEventSignature:
+			event := backendabi.L1SentMessageEvent{}
+			err := UnpackLog(backendabi.L1ScrollMessengerABI, &event, "SentMessage", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack SentMessage event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			msgHash := ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message)
+			msgHashes = append(msgHashes, MsgHashWrapper{
+				MsgHash: msgHash,
+				TxHash:  vlog.TxHash})
+		case backendabi.L1RelayedMessageEventSignature:
+			event := backendabi.L1RelayedMessageEvent{}
+			err := UnpackLog(backendabi.L1ScrollMessengerABI, &event, "RelayedMessage", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack RelayedMessage event", "err", err)
+				return l1CrossMsg, msgHashes, relayedMsgs, err
+			}
+			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
+				MsgHash:    event.MessageHash.String(),
+				Height:     vlog.BlockNumber,
+				Layer1Hash: vlog.TxHash.Hex(),
+			})
+
+		}
+
+	}
+	return l1CrossMsg, msgHashes, relayedMsgs, nil
+}
+
+func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []MsgHashWrapper, []*orm.RelayedMsg, []*orm.L2SentMsg, error) {
+	// Need use contract abi to parse event Log
+	// Can only be tested after we have our contracts set up
+
+	var l2CrossMsg []*orm.CrossMsg
+	// this is use to confirm finalized l1 msg
+	var relayedMsgs []*orm.RelayedMsg
+	var l2SentMsg []*orm.L2SentMsg
+	var msgHashes []MsgHashWrapper
+	for _, vlog := range logs {
+		switch vlog.Topics[0] {
+		case backendabi.L2WithdrawETHSig:
+			event := backendabi.DepositETH{}
+			err := UnpackLog(backendabi.L2ETHGatewayABI, &event, "WithdrawETH", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack WithdrawETH event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, l2SentMsg, err
+			}
+			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
+				Height:     vlog.BlockNumber,
+				Sender:     event.From.String(),
+				Target:     event.To.String(),
+				Amount:     event.Amount.String(),
+				Asset:      int(orm.ETH),
+				Layer2Hash: vlog.TxHash.Hex(),
+			})
+		case backendabi.L2WithdrawERC20Sig:
+			event := backendabi.ERC20MessageEvent{}
+			err := UnpackLog(backendabi.L2StandardERC20GatewayABI, &event, "WithdrawERC20", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack WithdrawERC20 event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, l2SentMsg, err
+			}
+			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Amount:      event.Amount.String(),
+				Asset:       int(orm.ERC20),
+				Layer2Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+			})
+		case backendabi.L2WithdrawERC721Sig:
+			event := backendabi.ERC721MessageEvent{}
+			err := UnpackLog(backendabi.L2ERC721GatewayABI, &event, "WithdrawERC721", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack WithdrawERC721 event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, l2SentMsg, err
+			}
+			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Asset:       int(orm.ERC721),
+				Layer2Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+				TokenID:     event.TokenID.Uint64(),
+			})
+		case backendabi.L2WithdrawERC1155Sig:
+			event := backendabi.ERC1155MessageEvent{}
+			err := UnpackLog(backendabi.L2ERC1155GatewayABI, &event, "WithdrawERC1155", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack WithdrawERC1155 event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, l2SentMsg, err
+			}
+			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
+				Height:      vlog.BlockNumber,
+				Sender:      event.From.String(),
+				Target:      event.To.String(),
+				Asset:       int(orm.ERC1155),
+				Layer2Hash:  vlog.TxHash.Hex(),
+				Layer1Token: event.L1Token.Hex(),
+				Layer2Token: event.L2Token.Hex(),
+				TokenID:     event.TokenID.Uint64(),
+				Amount:      event.Amount.String(),
+			})
+		case backendabi.L2SentMessageEventSignature:
+			event := backendabi.L2SentMessageEvent{}
+			err := UnpackLog(backendabi.L2ScrollMessengerABI, &event, "SentMessage", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack SentMessage event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, l2SentMsg, err
+			}
+			msgHash := ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message)
+			msgHashes = append(msgHashes, MsgHashWrapper{
+				MsgHash: msgHash,
+				TxHash:  vlog.TxHash})
+			l2SentMsg = append(l2SentMsg, &orm.L2SentMsg{
+				Sender:  event.Sender.Hex(),
+				Target:  event.Target.Hex(),
+				Value:   event.Value.String(),
+				MsgHash: msgHash.Hex(),
+				Height:  vlog.BlockNumber,
+				Nonce:   event.MessageNonce.Uint64(),
+				MsgData: hexutil.Encode(event.Message),
+			})
+		case backendabi.L2RelayedMessageEventSignature:
+			event := backendabi.L2RelayedMessageEvent{}
+			err := UnpackLog(backendabi.L2ScrollMessengerABI, &event, "RelayedMessage", vlog)
+			if err != nil {
+				log.Warn("Failed to unpack RelayedMessage event", "err", err)
+				return l2CrossMsg, msgHashes, relayedMsgs, l2SentMsg, err
+			}
+			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
+				MsgHash:    event.MessageHash.String(),
+				Height:     vlog.BlockNumber,
+				Layer2Hash: vlog.TxHash.Hex(),
+			})
+
+		}
+	}
+	return l2CrossMsg, msgHashes, relayedMsgs, l2SentMsg, nil
+}
+
+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:
+			event := backendabi.L1CommitBatchEvent{}
+			err := UnpackLog(backendabi.ScrollChainABI, &event, "CommitBatch", vlog)
+			if err != nil {
+				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())
+			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],
+				BatchHash:        event.BatchHash.Hex(),
+				StartBlockNumber: startBlocks[0],
+				EndBlockNumber:   endBlocks[0],
+			})
+
+		default:
+			continue
+		}
+	}
+	return rollupBatches, nil
+}

bridge-history-api/utils/utils.go

@@ -1,7 +1,10 @@
 package utils
 
 import (
+	"bytes"
 	"context"
+	"encoding/binary"
+	"errors"
 	"fmt"
 	"math/big"
 
@@ -14,6 +17,11 @@ import (
 	backendabi "bridge-history-api/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()[:]...)))
+}
+
 func GetSafeBlockNumber(ctx context.Context, client *ethclient.Client, confirmations uint64) (uint64, error) {
 	number, err := client.BlockNumber(ctx)
 	if err != nil || number <= confirmations {
@@ -54,3 +62,95 @@ func ComputeMessageHash(
 	data, _ := backendabi.L2ScrollMessengerABI.Pack("relayMessage", sender, target, value, messageNonce, message)
 	return common.BytesToHash(crypto.Keccak256(data))
 }
+
+type commitBatchArgs struct {
+	Version                uint8
+	ParentBatchHeader      []byte
+	Chunks                 [][]byte
+	SkippedL1MessageBitmap []byte
+}
+
+// GetBatchRangeFromCalldataV2 find the block range from calldata, both inclusive.
+func GetBatchRangeFromCalldataV2(calldata []byte) (uint64, uint64, uint64, error) {
+	method := backendabi.ScrollChainV2ABI.Methods["commitBatch"]
+	values, err := method.Inputs.Unpack(calldata[4:])
+	if err != nil {
+		return 0, 0, 0, err
+	}
+	args := commitBatchArgs{}
+	err = method.Inputs.Copy(&args, values)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+
+	var startBlock uint64
+	var finishBlock uint64
+
+	// decode batchIndex from ParentBatchHeader
+	if len(args.ParentBatchHeader) < 9 {
+		return 0, 0, 0, errors.New("invalid parent batch header")
+	}
+	batchIndex := binary.BigEndian.Uint64(args.ParentBatchHeader[1:9]) + 1
+
+	// decode blocks from chunk and assume that there's no empty chunk
+	// |   1 byte   | 60 bytes | ... | 60 bytes |
+	// | num blocks |  block 1 | ... |  block n |
+	if len(args.Chunks) == 0 {
+		return 0, 0, 0, errors.New("invalid chunks")
+	}
+	chunk := args.Chunks[0]
+	block := chunk[1:61] // first block in chunk
+	startBlock = binary.BigEndian.Uint64(block[0:8])
+
+	chunk = args.Chunks[len(args.Chunks)-1]
+	lastBlockIndex := int(chunk[0]) - 1
+	block = chunk[1+lastBlockIndex*60 : 1+lastBlockIndex*60+60] // last block in chunk
+	finishBlock = binary.BigEndian.Uint64(block[0:8])
+
+	return batchIndex, startBlock, finishBlock, err
+}
+
+// GetBatchRangeFromCalldataV1 find the block range from calldata, both inclusive.
+func GetBatchRangeFromCalldataV1(calldata []byte) ([]uint64, []uint64, []uint64, error) {
+	var batchIndices []uint64
+	var startBlocks []uint64
+	var finishBlocks []uint64
+	if bytes.Equal(calldata[0:4], common.Hex2Bytes("cb905499")) {
+		// commitBatches
+		method := backendabi.ScrollChainABI.Methods["commitBatches"]
+		values, err := method.Inputs.Unpack(calldata[4:])
+		if err != nil {
+			return batchIndices, startBlocks, finishBlocks, err
+		}
+		args := make([]backendabi.IScrollChainBatch, len(values))
+		err = method.Inputs.Copy(&args, values)
+		if err != nil {
+			return batchIndices, startBlocks, finishBlocks, err
+		}
+
+		for i := 0; i < len(args); i++ {
+			batchIndices = append(batchIndices, args[i].BatchIndex)
+			startBlocks = append(startBlocks, args[i].Blocks[0].BlockNumber)
+			finishBlocks = append(finishBlocks, args[i].Blocks[len(args[i].Blocks)-1].BlockNumber)
+		}
+	} else if bytes.Equal(calldata[0:4], common.Hex2Bytes("8c73235d")) {
+		// commitBatch
+		method := backendabi.ScrollChainABI.Methods["commitBatch"]
+		values, err := method.Inputs.Unpack(calldata[4:])
+		if err != nil {
+			return batchIndices, startBlocks, finishBlocks, err
+		}
+
+		args := backendabi.IScrollChainBatch{}
+		err = method.Inputs.Copy(&args, values)
+		if err != nil {
+			return batchIndices, startBlocks, finishBlocks, err
+		}
+		batchIndices = append(batchIndices, args.BatchIndex)
+		startBlocks = append(startBlocks, args.Blocks[0].BlockNumber)
+		finishBlocks = append(finishBlocks, args.Blocks[len(args.Blocks)-1].BlockNumber)
+	} else {
+		return batchIndices, startBlocks, finishBlocks, errors.New("invalid selector")
+	}
+	return batchIndices, startBlocks, finishBlocks, nil
+}

bridge-history-api/utils/utils_test.go

@@ -0,0 +1,64 @@
+package utils_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/assert"
+
+	"bridge-history-api/utils"
+)
+
+func TestKeccak2(t *testing.T) {
+	a := common.HexToHash("0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0")
+	b := common.HexToHash("0x222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c")
+	c := utils.Keccak2(a, b)
+	assert.NotEmpty(t, c)
+	assert.NotEqual(t, a, c)
+	assert.NotEqual(t, b, c)
+	assert.Equal(t, "0xc0ffbd7f501bd3d49721b0724b2bff657cb2378f15d5a9b97cd7ea5bf630d512", c.Hex())
+}
+
+func TestGetBatchRangeFromCalldataV2(t *testing.T) {
+	// single chunk
+	batchIndex, start, finish, err := utils.GetBatchRangeFromCalldataV2(common.Hex2Bytes("1325aca000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001a0000000000000000000000000000000000000000000000000000000000000005900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003d0100000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000100000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000"))
+	assert.NoError(t, err)
+	assert.Equal(t, start, uint64(1))
+	assert.Equal(t, finish, uint64(1))
+	assert.Equal(t, batchIndex, uint64(1))
+
+	// multiple chunk
+	batchIndex, start, finish, err = utils.GetBatchRangeFromCalldataV2(common.Hex2Bytes("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"))
+	assert.NoError(t, err)
+	assert.Equal(t, start, uint64(10))
+	assert.Equal(t, finish, uint64(20))
+	assert.Equal(t, batchIndex, uint64(2))
+}
+
+func TestGetBatchRangeFromCalldataV1(t *testing.T) {
+	calldata, err := os.ReadFile("../testdata/commit-batches-0x3095e91db7ba4a6fbf4654d607db322e58ff5579c502219c8024acaea74cf311.txt")
+	assert.NoError(t, err)
+
+	// multiple batches
+	batchIndices, startBlocks, finishBlocks, err := utils.GetBatchRangeFromCalldataV1(common.Hex2Bytes(string(calldata[:])))
+	assert.NoError(t, err)
+	assert.Equal(t, len(batchIndices), 5)
+	assert.Equal(t, len(startBlocks), 5)
+	assert.Equal(t, len(finishBlocks), 5)
+	assert.Equal(t, batchIndices[0], uint64(1))
+	assert.Equal(t, batchIndices[1], uint64(2))
+	assert.Equal(t, batchIndices[2], uint64(3))
+	assert.Equal(t, batchIndices[3], uint64(4))
+	assert.Equal(t, batchIndices[4], uint64(5))
+	assert.Equal(t, startBlocks[0], uint64(1))
+	assert.Equal(t, startBlocks[1], uint64(6))
+	assert.Equal(t, startBlocks[2], uint64(7))
+	assert.Equal(t, startBlocks[3], uint64(19))
+	assert.Equal(t, startBlocks[4], uint64(20))
+	assert.Equal(t, finishBlocks[0], uint64(5))
+	assert.Equal(t, finishBlocks[1], uint64(6))
+	assert.Equal(t, finishBlocks[2], uint64(18))
+	assert.Equal(t, finishBlocks[3], uint64(19))
+	assert.Equal(t, finishBlocks[4], uint64(20))
+}

bridge/Makefile

@@ -1,7 +1,7 @@
 .PHONY: lint docker clean bridge
 
 IMAGE_NAME=bridge
-IMAGE_VERSION=latest
+IMAGE_VERSION=v9.9
 REPO_ROOT_DIR=./..
 
 mock_abi:

bridge/cmd/msg_relayer/app/app.go

@@ -7,7 +7,6 @@ import (
 	"os/signal"
 	"time"
 
-	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/urfave/cli/v2"
 
@@ -64,29 +63,16 @@ func action(ctx *cli.Context) error {
 	metrics.Serve(subCtx, ctx)
 
 	// Init l2geth connection
-	l2client, err := ethclient.Dial(cfg.L2Config.Endpoint)
-	if err != nil {
-		log.Error("failed to connect l2 geth", "config file", cfgFile, "error", err)
-		return err
-	}
 
 	l1relayer, err := relayer.NewLayer1Relayer(ctx.Context, db, cfg.L1Config.RelayerConfig)
 	if err != nil {
 		log.Error("failed to create new l1 relayer", "config file", cfgFile, "error", err)
 		return err
 	}
-	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig)
-	if err != nil {
-		log.Error("failed to create new l2 relayer", "config file", cfgFile, "error", err)
-		return err
-	}
 
 	// Start l1relayer process
 	go cutils.Loop(subCtx, 10*time.Second, l1relayer.ProcessSavedEvents)
 
-	// Start l2relayer process
-	go cutils.Loop(subCtx, 2*time.Second, l2relayer.ProcessSavedEvents)
-
 	// Finish start all message relayer functions
 	log.Info("Start message-relayer successfully")
 

bridge/internal/controller/relayer/l2_relayer.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"math/big"
-	"runtime"
 	"sync"
 
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
@@ -13,9 +12,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
 	gethMetrics "github.com/scroll-tech/go-ethereum/metrics"
-	"golang.org/x/sync/errgroup"
 	"gorm.io/gorm"
-	"modernc.org/mathutil"
 
 	"scroll-tech/common/metrics"
 	"scroll-tech/common/types"
@@ -153,120 +150,6 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 
 const processMsgLimit = 100
 
-// ProcessSavedEvents relays saved un-processed cross-domain transactions to desired blockchain
-func (r *Layer2Relayer) ProcessSavedEvents() {
-	batch, err := r.blockBatchOrm.GetLatestBatchByRollupStatus([]types.RollupStatus{types.RollupFinalized})
-	if err != nil {
-		log.Error("GetLatestFinalizedBatch failed", "err", err)
-		return
-	}
-
-	// msgs are sorted by nonce in increasing order
-	fields := map[string]interface{}{
-		"status":        int(types.MsgPending),
-		"height <= (?)": batch.EndBlockNumber,
-	}
-	orderByList := []string{
-		"nonce ASC",
-	}
-	limit := processMsgLimit
-
-	msgs, err := r.l2MessageOrm.GetL2Messages(fields, orderByList, limit)
-	if err != nil {
-		log.Error("Failed to fetch unprocessed L2 messages", "err", err)
-		return
-	}
-
-	// process messages in batches
-	batchSize := mathutil.Min((runtime.GOMAXPROCS(0)+1)/2, r.messageSender.NumberOfAccounts())
-	for size := 0; len(msgs) > 0; msgs = msgs[size:] {
-		if size = len(msgs); size > batchSize {
-			size = batchSize
-		}
-		var g errgroup.Group
-		for _, msg := range msgs[:size] {
-			msg := msg
-			g.Go(func() error {
-				return r.processSavedEvent(&msg)
-			})
-		}
-		if err := g.Wait(); err != nil {
-			if !errors.Is(err, sender.ErrNoAvailableAccount) && !errors.Is(err, sender.ErrFullPending) {
-				log.Error("failed to process l2 saved event", "err", err)
-			}
-			return
-		}
-	}
-}
-
-func (r *Layer2Relayer) processSavedEvent(msg *orm.L2Message) error {
-	// @todo fetch merkle proof from l2geth
-	log.Info("Processing L2 Message", "msg.nonce", msg.Nonce, "msg.height", msg.Height)
-
-	// Get the block info that contains the message
-	blockInfos, err := r.blockTraceOrm.GetL2BlockInfos(map[string]interface{}{"number": msg.Height}, nil, 0)
-	if err != nil {
-		log.Error("Failed to GetL2BlockInfos from DB", "number", msg.Height)
-	}
-	if len(blockInfos) == 0 {
-		return errors.New("get block trace len is 0, exit")
-	}
-
-	blockInfo := blockInfos[0]
-	if blockInfo.BatchHash == "" {
-		log.Error("Block has not been batched yet", "number", blockInfo.Number, "msg.nonce", msg.Nonce)
-		return nil
-	}
-
-	// TODO: rebuild the withdraw trie to generate the merkle proof
-	proof := bridgeAbi.IL1ScrollMessengerL2MessageProof{
-		BatchHash:   common.HexToHash(blockInfo.BatchHash),
-		MerkleProof: make([]byte, 0),
-	}
-	from := common.HexToAddress(msg.Sender)
-	target := common.HexToAddress(msg.Target)
-	value, ok := big.NewInt(0).SetString(msg.Value, 10)
-	if !ok {
-		// @todo maybe panic?
-		log.Error("Failed to parse message value", "msg.nonce", msg.Nonce, "msg.height", msg.Height)
-		// TODO: need to skip this message by changing its status to MsgError
-	}
-	msgNonce := big.NewInt(int64(msg.Nonce))
-	calldata := common.Hex2Bytes(msg.Calldata)
-	data, err := r.l1MessengerABI.Pack("relayMessageWithProof", from, target, value, msgNonce, calldata, proof)
-	if err != nil {
-		log.Error("Failed to pack relayMessageWithProof", "msg.nonce", msg.Nonce, "err", err)
-		// TODO: need to skip this message by changing its status to MsgError
-		return err
-	}
-
-	hash, err := r.messageSender.SendTransaction(msg.MsgHash, &r.cfg.MessengerContractAddress, big.NewInt(0), data, r.minGasLimitForMessageRelay)
-	if err != nil && errors.Is(err, ErrExecutionRevertedMessageExpired) {
-		return r.l2MessageOrm.UpdateLayer2Status(r.ctx, msg.MsgHash, types.MsgExpired)
-	}
-	if err != nil && errors.Is(err, ErrExecutionRevertedAlreadySuccessExecuted) {
-		return r.l2MessageOrm.UpdateLayer2Status(r.ctx, msg.MsgHash, types.MsgConfirmed)
-	}
-	if err != nil {
-		if !errors.Is(err, sender.ErrNoAvailableAccount) && !errors.Is(err, sender.ErrFullPending) {
-			log.Error("Failed to send relayMessageWithProof tx to layer1 ", "msg.height", msg.Height, "msg.MsgHash", msg.MsgHash, "err", err)
-		}
-		return err
-	}
-	bridgeL2MsgsRelayedTotalCounter.Inc(1)
-	log.Info("relayMessageWithProof to layer1", "msgHash", msg.MsgHash, "txhash", hash.String())
-
-	// save status in db
-	// @todo handle db error
-	err = r.l2MessageOrm.UpdateLayer2StatusAndLayer1Hash(r.ctx, msg.MsgHash, types.MsgSubmitted, hash.String())
-	if err != nil {
-		log.Error("UpdateLayer2StatusAndLayer1Hash failed", "msgHash", msg.MsgHash, "err", err)
-		return err
-	}
-	r.processingMessage.Store(msg.MsgHash, msg.MsgHash)
-	return nil
-}
-
 // ProcessGasPriceOracle imports gas price to layer1
 func (r *Layer2Relayer) ProcessGasPriceOracle() {
 	batch, err := r.blockBatchOrm.GetLatestBatch()

go.work.sum

@@ -114,8 +114,6 @@ github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2 h1:IKgmqgMQlVJIZj19CdocBeS
 github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0 h1:sDMmm+q/3+BukdIpxwO365v/Rbspp2Nt5XntgQRXq8Q=
 github.com/consensys/bavard v0.1.8-0.20210406032232-f3452dc9b572 h1:+R8G1+Ftumd0DaveLgMIjrFPcAS4G8MsVXWXiyZL5BY=
 github.com/consensys/bavard v0.1.8-0.20210406032232-f3452dc9b572/go.mod h1:Bpd0/3mZuaj6Sj+PqrmIquiOKy397AKGThQPaGzNXAQ=
-github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ=
-github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI=
 github.com/consensys/gnark-crypto v0.4.1-0.20210426202927-39ac3d4b3f1f h1:C43yEtQ6NIf4ftFXD/V55gnGFgPbMQobd//YlnLjUJ8=
 github.com/consensys/gnark-crypto v0.4.1-0.20210426202927-39ac3d4b3f1f/go.mod h1:815PAHg3wvysy0SyIqanF8gZ0Y1wjk/hrDHD/iT88+Q=
 github.com/consensys/gnark-crypto v0.9.1-0.20230105202408-1a7a29904a7c h1:llSLg4o9EgH3SrXky+Q5BqEYqV76NGKo07K5Ps2pIKo=
@@ -242,7 +240,6 @@ github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc h1:DLpL8pWq0v4JYoRpEh
 github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/google/renameio v0.1.0 h1:GOZbcHa3HfsPKPlmyPyN2KEohoMXOhdMbHrvbpl2QaA=
 github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=
-github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
 github.com/google/uuid v1.1.5/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go/v2 v2.0.5 h1:sjZBwGj9Jlw33ImPtvFviGYvseOtDM7hkSKB7+Tv3SM=
@@ -337,9 +334,6 @@ github.com/mattn/go-tty v0.0.0-20180907095812-13ff1204f104 h1:d8RFOZ2IiFtFWBcKEH
 github.com/mattn/goveralls v0.0.2 h1:7eJB6EqsPhRVxvwEXGnqdO2sJI0PTsrWoTMXEk9/OQc=
 github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
-github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY=
-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-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modocache/gover v0.0.0-20171022184752-b58185e213c5/go.mod h1:caMODM3PzxT8aQXRPkAt8xlV/e7d7w8GM5g0fa5F0D8=
 github.com/moul/http2curl v1.0.0 h1:dRMWoAtb+ePxMlLkrCbAqh4TlPHXvoGUSQ323/9Zahs=
@@ -432,7 +426,6 @@ github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77 h1:ESFSdwY
 github.com/yudai/pp v2.0.1+incompatible h1:Q4//iY4pNF6yPLZIigmvcl7k/bPgrcTPIFIcmawg5bI=
 github.com/yuin/goldmark v1.4.13 h1:fVcFKWvrslecOb/tg+Cc05dkeYx540o0FuFt3nUVDoE=
 github.com/ziutek/mymysql v1.5.4 h1:GB0qdRGsTwQSBVYuVShFBKaXSnSnYYC2d9knnE1LHFs=
-go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw=
 go.etcd.io/gofail v0.1.0 h1:XItAMIhOojXFQMgrxjnd2EIIHun/d5qL0Pf7FzVTkFg=
 go.etcd.io/gofail v0.1.0/go.mod h1:VZBCXYGZhHAinaBiiqYvuDynvahNsAyLFwB3kEHKz1M=
 go.opencensus.io v0.22.2 h1:75k/FF0Q2YM8QYo07VPddOLBslDt1MZOdEslOHvmzAs=
@@ -475,19 +468,15 @@ golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20211020174200-9d6173849985/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/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.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI=
 golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
 golang.org/x/term v0.7.0 h1:BEvjmm5fURWqcfbSKTdpkDXYBrUS1c0m8agp14W48vQ=
 golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
 golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/time v0.0.0-20220922220347-f3bd1da661af/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.1.8-0.20211029000441-d6a9af8af023/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
@@ -525,5 +514,3 @@ honnef.co/go/tools v0.1.3 h1:qTakTkI6ni6LFD5sBwwsdSO+AQqbSIxOauHTTQKZ/7o=
 honnef.co/go/tools v0.1.3/go.mod h1:NgwopIslSNH47DimFoV78dnkksY2EFtX0ajyb3K/las=
 rsc.io/binaryregexp v0.2.0 h1:HfqmD5MEmC0zvwBuF187nq9mdnXjXsSivRiXN7SmRkE=
 rsc.io/pdf v0.1.1 h1:k1MczvYDUvJBe93bYd7wrZLLUEcLZAuF824/I4e5Xr4=
-rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU=
-rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA=