fix

bridge-history-api/cross_msg/fetch_missing_event.go

@@ -8,9 +8,11 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"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"
 )
 
@@ -98,11 +100,19 @@ func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 		log.Warn("Failed to get l1 event logs", "err", err)
 		return err
 	}
-	depositL1CrossMsgs, relayedMsg, err := utils.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
 	}
+	for i := range depositL1CrossMsgs {
+		for _, msgHash := range msgHashes {
+			if depositL1CrossMsgs[i].Layer1Hash == msgHash.TxHash.Hex() {
+				depositL1CrossMsgs[i].MsgHash = msgHash.MsgHash.Hex()
+				break
+			}
+		}
+	}
 	dbTx, err := database.Beginx()
 	if err != nil {
 		log.Error("l2FetchAndSaveEvents: Failed to begin db transaction", "err", err)
@@ -151,12 +161,22 @@ func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 		log.Warn("Failed to get l2 event logs", "err", err)
 		return err
 	}
-	depositL2CrossMsgs, relayedMsg, l2SentMsgs, err := utils.ParseBackendL2EventLogs(logs)
+	depositL2CrossMsgs, relayedMsg, L2SentMsgWrappers, err := utils.ParseBackendL2EventLogs(logs)
 	if err != nil {
 		log.Error("l2FetchAndSaveEvents: Failed to parse cross msg event logs", "err", err)
 		return err
 	}
-
+	var l2SentMsgs []*orm.L2SentMsg
+	for i := range depositL2CrossMsgs {
+		for _, l2SentMsgWrapper := range L2SentMsgWrappers {
+			if depositL2CrossMsgs[i].Layer2Hash == l2SentMsgWrapper.TxHash.Hex() {
+				depositL2CrossMsgs[i].MsgHash = l2SentMsgWrapper.L2SentMsg.MsgHash
+				l2SentMsgWrapper.L2SentMsg.TxSender = depositL2CrossMsgs[i].Sender
+				l2SentMsgs = append(l2SentMsgs, l2SentMsgWrapper.L2SentMsg)
+				break
+			}
+		}
+	}
 	dbTx, err := database.Beginx()
 	if err != nil {
 		log.Error("l2FetchAndSaveEvents: Failed to begin db transaction", "err", err)
@@ -174,10 +194,12 @@ func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 		log.Crit("l2FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
 	}
 
-	err = database.BatchInsertL2SentMsgDBTx(dbTx, l2SentMsgs)
-	if err != nil {
-		dbTx.Rollback()
-		log.Crit("l2FetchAndSaveEvents: Failed to insert l2 sent message", "err", err)
+	if len(l2SentMsgs) > 0 {
+		err = database.BatchInsertL2SentMsgDBTx(dbTx, l2SentMsgs)
+		if err != nil {
+			dbTx.Rollback()
+			log.Crit("l2FetchAndSaveEvents: Failed to insert l2 sent message", "err", err)
+		}
 	}
 
 	err = dbTx.Commit()
@@ -229,3 +251,25 @@ func FetchAndSaveBatchIndex(ctx context.Context, client *ethclient.Client, datab
 	}
 	return nil
 }
+
+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)
+		if err != nil {
+			log.Error("updateL1CrossMsgMsgHash: can not update layer1 cross msg MsgHash", "layer1 hash", msgHash.TxHash, "err", err)
+			continue
+		}
+	}
+	return nil
+}
+
+func updateL2CrossMsgMsgHash(ctx context.Context, dbTx *sqlx.Tx, database db.OrmFactory, msgHashes []utils.MsgHashWrapper) error {
+	for _, msgHash := range msgHashes {
+		err := database.UpdateL2CrossMsgHashDBTx(ctx, dbTx, msgHash.TxHash, msgHash.MsgHash)
+		if err != nil {
+			log.Error("updateL2CrossMsgMsgHash: can not update layer2 cross msg MsgHash", "layer2 hash", msgHash.TxHash, "err", err)
+			continue
+		}
+	}
+	return nil
+}

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

@@ -3,7 +3,7 @@
 create table l2_sent_msg
 (
     id               BIGSERIAL PRIMARY KEY,
-    original_sender  VARCHAR NOT NULL DEFAULT '',
+    tx_sender        VARCHAR NOT NULL,
     sender           VARCHAR NOT NULL,
     target           VARCHAR NOT NULL,
     value            VARCHAR NOT NULL,

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

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

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

@@ -85,7 +85,7 @@ func (l *l2CrossMsgOrm) BatchInsertL2CrossMsgDBTx(dbTx *sqlx.Tx, messages []*Cro
 			"msg_type":     Layer2Msg,
 		}
 	}
-	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, msg_hash, layer2_hash, layer1_token, layer2_token, token_ids, amount, msg_type) values(:height, :sender, :target, :asset, :msg_hash, :layer2_hash, :layer1_token, :layer2_token, :token_ids, :amount, :msg_type);`, messageMaps)
+	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer2_hash, layer1_token, layer2_token, token_ids, amount, msg_type, msg_hash) values(:height, :sender, :target, :asset, :layer2_hash, :layer1_token, :layer2_token, :token_ids, :amount, :msg_type, :msg_hash);`, messageMaps)
 	if err != nil {
 		log.Error("BatchInsertL2CrossMsgDBTx: failed to insert l2 cross msgs", "err", err)
 		return err

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

@@ -10,20 +10,20 @@ import (
 )
 
 type L2SentMsg struct {
-	ID             uint64     `json:"id" db:"id"`
-	OriginalSender string     `json:"original_sender" db:"original_sender"`
-	MsgHash        string     `json:"msg_hash" db:"msg_hash"`
-	Sender         string     `json:"sender" db:"sender"`
-	Target         string     `json:"target" db:"target"`
-	Value          string     `json:"value" db:"value"`
-	Height         uint64     `json:"height" db:"height"`
-	Nonce          uint64     `json:"nonce" db:"nonce"`
-	BatchIndex     uint64     `json:"batch_index" db:"batch_index"`
-	MsgProof       string     `json:"msg_proof" db:"msg_proof"`
-	MsgData        string     `json:"msg_data" db:"msg_data"`
-	CreatedAt      *time.Time `json:"created_at" db:"created_at"`
-	UpdatedAt      *time.Time `json:"updated_at" db:"updated_at"`
-	DeletedAt      *time.Time `json:"deleted_at" db:"deleted_at"`
+	ID         uint64     `json:"id" db:"id"`
+	TxSender   string     `json:"tx_sender" db:"tx_sender"`
+	MsgHash    string     `json:"msg_hash" db:"msg_hash"`
+	Sender     string     `json:"sender" db:"sender"`
+	Target     string     `json:"target" db:"target"`
+	Value      string     `json:"value" db:"value"`
+	Height     uint64     `json:"height" db:"height"`
+	Nonce      uint64     `json:"nonce" db:"nonce"`
+	BatchIndex uint64     `json:"batch_index" db:"batch_index"`
+	MsgProof   string     `json:"msg_proof" db:"msg_proof"`
+	MsgData    string     `json:"msg_data" db:"msg_data"`
+	CreatedAt  *time.Time `json:"created_at" db:"created_at"`
+	UpdatedAt  *time.Time `json:"updated_at" db:"updated_at"`
+	DeletedAt  *time.Time `json:"deleted_at" db:"deleted_at"`
 }
 
 type l2SentMsgOrm struct {
@@ -52,19 +52,19 @@ func (l *l2SentMsgOrm) BatchInsertL2SentMsgDBTx(dbTx *sqlx.Tx, messages []*L2Sen
 	messageMaps := make([]map[string]interface{}, len(messages))
 	for i, msg := range messages {
 		messageMaps[i] = map[string]interface{}{
-			"original_sender": msg.OriginalSender,
-			"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,
+			"tx_sender":   msg.TxSender,
+			"sender":      msg.Sender,
+			"target":      msg.Target,
+			"value":       msg.Value,
+			"msg_hash":    msg.MsgHash,
+			"height":      msg.Height,
+			"nonce":       msg.Nonce,
+			"batch_index": msg.BatchIndex,
+			"msg_proof":   msg.MsgProof,
+			"msg_data":    msg.MsgData,
 		}
 	}
-	_, err = dbTx.NamedExec(`insert into l2_sent_msg(original_sender, sender, target, value, msg_hash, height, nonce, batch_index, msg_proof, msg_data) values(:original_sender, :sender, :target, :value, :msg_hash, :height, :nonce, :batch_index, :msg_proof, :msg_data);`, messageMaps)
+	_, err = dbTx.NamedExec(`insert into l2_sent_msg(tx_sender, sender, target, value, msg_hash, height, nonce, batch_index, msg_proof, msg_data) values(:tx_sender, :sender, :target, :value, :msg_hash, :height, :nonce, :batch_index, :msg_proof, :msg_data);`, messageMaps)
 	if err != nil {
 		log.Error("BatchInsertL2SentMsgDBTx: failed to insert l2 sent msgs", "err", err)
 		return err
@@ -95,7 +95,7 @@ func (l *l2SentMsgOrm) UpdateL2MessageProofInDBTx(ctx context.Context, dbTx *sql
 }
 
 func (l *l2SentMsgOrm) GetLatestL2SentMsgBatchIndex() (int64, error) {
-	row := l.db.QueryRow(`SELECT batch_index FROM l2_sent_msg WHERE batch_index != 0 AND deleted_at IS NULL ORDER BY batch_index DESC LIMIT 1;`)
+	row := l.db.QueryRow(`SELECT batch_index FROM l2_sent_msg WHERE batch_index !=0 AND deleted_at IS NULL ORDER BY batch_index DESC LIMIT 1;`)
 	var result sql.NullInt64
 	if err := row.Scan(&result); err != nil {
 		if err == sql.ErrNoRows || !result.Valid {

bridge-history-api/utils/parse_event.go

@@ -3,6 +3,7 @@ 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"
@@ -12,6 +13,16 @@ import (
 	"bridge-history-api/db/orm"
 )
 
+type MsgHashWrapper struct {
+	MsgHash common.Hash
+	TxHash  common.Hash
+}
+
+type L2SentMsgWrapper struct {
+	L2SentMsg *orm.L2SentMsg
+	TxHash    common.Hash
+}
+
 type CachedParsedTxCalldata struct {
 	CallDataIndex uint64
 	BatchIndices  []uint64
@@ -19,13 +30,13 @@ type CachedParsedTxCalldata struct {
 	EndBlocks     []uint64
 }
 
-func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedMsg, error) {
+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 msgHash string
+	var msgHashes []MsgHashWrapper
 	for _, vlog := range logs {
 		switch vlog.Topics[0] {
 		case backendabi.L1DepositETHSig:
@@ -33,7 +44,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 			err := UnpackLog(backendabi.L1ETHGatewayABI, &event, "DepositETH", vlog)
 			if err != nil {
 				log.Warn("Failed to unpack DepositETH event", "err", err)
-				return l1CrossMsg, relayedMsgs, err
+				return l1CrossMsg, msgHashes, relayedMsgs, err
 			}
 			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
 				Height:     vlog.BlockNumber,
@@ -42,14 +53,13 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Amount:     event.Amount.String(),
 				Asset:      int(orm.ETH),
 				Layer1Hash: vlog.TxHash.Hex(),
-				MsgHash:    msgHash,
 			})
 		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, relayedMsgs, err
+				return l1CrossMsg, msgHashes, relayedMsgs, err
 			}
 			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
 				Height:      vlog.BlockNumber,
@@ -60,14 +70,13 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
-				MsgHash:     msgHash,
 			})
 		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, relayedMsgs, err
+				return l1CrossMsg, msgHashes, relayedMsgs, err
 			}
 			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
 				Height:      vlog.BlockNumber,
@@ -78,14 +87,13 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    event.TokenID.String(),
-				MsgHash:     msgHash,
 			})
 		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, relayedMsgs, err
+				return l1CrossMsg, msgHashes, relayedMsgs, err
 			}
 			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
 				Height:      vlog.BlockNumber,
@@ -97,24 +105,24 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    event.TokenID.String(),
 				Amount:      event.Amount.String(),
-				MsgHash:     msgHash,
 			})
 		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, relayedMsgs, err
+				return l1CrossMsg, msgHashes, relayedMsgs, err
 			}
-			// since every deposit event will emit after a sent event, so can use this msg_hash as next withdraw event's msg_hash
-			msgHash = ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message).Hex()
-
+			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, relayedMsgs, err
+				return l1CrossMsg, msgHashes, relayedMsgs, err
 			}
 			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
 				MsgHash:    event.MessageHash.String(),
@@ -125,17 +133,17 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 		}
 
 	}
-	return l1CrossMsg, relayedMsgs, nil
+	return l1CrossMsg, msgHashes, relayedMsgs, nil
 }
 
-func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedMsg, []*orm.L2SentMsg, error) {
+func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedMsg, []L2SentMsgWrapper, 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 l2SentMsgs []*orm.L2SentMsg
+	var l2SentMsg []L2SentMsgWrapper
 	for _, vlog := range logs {
 		switch vlog.Topics[0] {
 		case backendabi.L2WithdrawETHSig:
@@ -143,9 +151,8 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 			err := UnpackLog(backendabi.L2ETHGatewayABI, &event, "WithdrawETH", vlog)
 			if err != nil {
 				log.Warn("Failed to unpack WithdrawETH event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
+				return l2CrossMsg, relayedMsgs, l2SentMsg, err
 			}
-			l2SentMsgs[len(l2SentMsgs)-1].OriginalSender = event.From.Hex()
 			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
 				Height:     vlog.BlockNumber,
 				Sender:     event.From.String(),
@@ -153,16 +160,14 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Amount:     event.Amount.String(),
 				Asset:      int(orm.ETH),
 				Layer2Hash: vlog.TxHash.Hex(),
-				MsgHash:    l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
 		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, relayedMsgs, l2SentMsgs, err
+				return l2CrossMsg, relayedMsgs, l2SentMsg, err
 			}
-			l2SentMsgs[len(l2SentMsgs)-1].OriginalSender = event.From.Hex()
 			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
 				Height:      vlog.BlockNumber,
 				Sender:      event.From.String(),
@@ -178,9 +183,8 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 			err := UnpackLog(backendabi.L2ERC721GatewayABI, &event, "WithdrawERC721", vlog)
 			if err != nil {
 				log.Warn("Failed to unpack WithdrawERC721 event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
+				return l2CrossMsg, relayedMsgs, l2SentMsg, err
 			}
-			l2SentMsgs[len(l2SentMsgs)-1].OriginalSender = event.From.Hex()
 			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
 				Height:      vlog.BlockNumber,
 				Sender:      event.From.String(),
@@ -196,9 +200,8 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 			err := UnpackLog(backendabi.L2ERC1155GatewayABI, &event, "WithdrawERC1155", vlog)
 			if err != nil {
 				log.Warn("Failed to unpack WithdrawERC1155 event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
+				return l2CrossMsg, relayedMsgs, l2SentMsg, err
 			}
-			l2SentMsgs[len(l2SentMsgs)-1].OriginalSender = event.From.Hex()
 			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
 				Height:      vlog.BlockNumber,
 				Sender:      event.From.String(),
@@ -215,26 +218,28 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 			err := UnpackLog(backendabi.L2ScrollMessengerABI, &event, "SentMessage", vlog)
 			if err != nil {
 				log.Warn("Failed to unpack SentMessage event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
+				return l2CrossMsg, relayedMsgs, l2SentMsg, err
 			}
-			// since every withdraw event will emit after a sent event, so can use this msg_hash as next withdraw event's msg_hash
 			msgHash := ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message)
-			l2SentMsgs = append(l2SentMsgs,
-				&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),
+			l2SentMsg = append(l2SentMsg,
+				L2SentMsgWrapper{
+					TxHash: vlog.TxHash,
+					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, relayedMsgs, l2SentMsgs, err
+				return l2CrossMsg, relayedMsgs, l2SentMsg, err
 			}
 			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
 				MsgHash:    event.MessageHash.String(),
@@ -244,7 +249,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 
 		}
 	}
-	return l2CrossMsg, relayedMsgs, l2SentMsgs, nil
+	return l2CrossMsg, relayedMsgs, l2SentMsg, nil
 }
 
 func ParseBatchInfoFromScrollChain(ctx context.Context, client *ethclient.Client, logs []types.Log) ([]*orm.RollupBatch, error) {

common/version/version.go

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

contracts/src/L1/gateways/L1ERC1155Gateway.sol

@@ -105,7 +105,7 @@ contract L1ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         address _to,
         uint256 _tokenId,
         uint256 _amount
-    ) external virtual onlyCallByCounterpart nonReentrant {
+    ) external override onlyCallByCounterpart nonReentrant {
         require(_l2Token != address(0), "token address cannot be 0");
         require(_l2Token == tokenMapping[_l1Token], "l2 token mismatch");
 
@@ -122,7 +122,7 @@ contract L1ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         address _to,
         uint256[] calldata _tokenIds,
         uint256[] calldata _amounts
-    ) external virtual onlyCallByCounterpart nonReentrant {
+    ) external override onlyCallByCounterpart nonReentrant {
         require(_l2Token != address(0), "token address cannot be 0");
         require(_l2Token == tokenMapping[_l1Token], "l2 token mismatch");
 
@@ -162,7 +162,7 @@ contract L1ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         uint256 _tokenId,
         uint256 _amount,
         uint256 _gasLimit
-    ) internal virtual nonReentrant {
+    ) internal nonReentrant {
         require(_amount > 0, "deposit zero amount");
 
         address _l2Token = tokenMapping[_token];
@@ -200,7 +200,7 @@ contract L1ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         uint256[] calldata _tokenIds,
         uint256[] calldata _amounts,
         uint256 _gasLimit
-    ) internal virtual nonReentrant {
+    ) internal nonReentrant {
         require(_tokenIds.length > 0, "no token to deposit");
         require(_tokenIds.length == _amounts.length, "length mismatch");
 

contracts/src/L1/gateways/L1ERC721Gateway.sol

@@ -99,7 +99,7 @@ contract L1ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         address _from,
         address _to,
         uint256 _tokenId
-    ) external virtual onlyCallByCounterpart nonReentrant {
+    ) external override onlyCallByCounterpart nonReentrant {
         require(_l2Token != address(0), "token address cannot be 0");
         require(_l2Token == tokenMapping[_l1Token], "l2 token mismatch");
 
@@ -115,7 +115,7 @@ contract L1ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         address _from,
         address _to,
         uint256[] calldata _tokenIds
-    ) external virtual onlyCallByCounterpart nonReentrant {
+    ) external override onlyCallByCounterpart nonReentrant {
         require(_l2Token != address(0), "token address cannot be 0");
         require(_l2Token == tokenMapping[_l1Token], "l2 token mismatch");
 
@@ -155,7 +155,7 @@ contract L1ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         address _to,
         uint256 _tokenId,
         uint256 _gasLimit
-    ) internal virtual nonReentrant {
+    ) internal nonReentrant {
         address _l2Token = tokenMapping[_token];
         require(_l2Token != address(0), "no corresponding l2 token");
 
@@ -188,7 +188,7 @@ contract L1ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         address _to,
         uint256[] calldata _tokenIds,
         uint256 _gasLimit
-    ) internal virtual nonReentrant {
+    ) internal nonReentrant {
         require(_tokenIds.length > 0, "no token to deposit");
 
         address _l2Token = tokenMapping[_token];

contracts/src/L1/gateways/L1ETHGateway.sol

@@ -95,7 +95,7 @@ contract L1ETHGateway is Initializable, ScrollGatewayBase, IL1ETHGateway {
         uint256 _amount,
         bytes memory _data,
         uint256 _gasLimit
-    ) internal virtual nonReentrant {
+    ) internal nonReentrant {
         require(_amount > 0, "deposit zero eth");
 
         // 1. Extract real sender if this call is from L1GatewayRouter.

contracts/src/L2/gateways/L2ERC1155Gateway.sol

@@ -103,7 +103,7 @@ contract L2ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         address _to,
         uint256 _tokenId,
         uint256 _amount
-    ) external virtual onlyCallByCounterpart nonReentrant {
+    ) external override onlyCallByCounterpart nonReentrant {
         require(_l1Token != address(0), "token address cannot be 0");
         require(_l1Token == tokenMapping[_l2Token], "l2 token mismatch");
 
@@ -120,7 +120,7 @@ contract L2ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         address _to,
         uint256[] calldata _tokenIds,
         uint256[] calldata _amounts
-    ) external virtual onlyCallByCounterpart nonReentrant {
+    ) external override onlyCallByCounterpart nonReentrant {
         require(_l1Token != address(0), "token address cannot be 0");
         require(_l1Token == tokenMapping[_l2Token], "l2 token mismatch");
 
@@ -160,7 +160,7 @@ contract L2ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         uint256 _tokenId,
         uint256 _amount,
         uint256 _gasLimit
-    ) internal virtual nonReentrant {
+    ) internal nonReentrant {
         require(_amount > 0, "withdraw zero amount");
 
         address _l1Token = tokenMapping[_token];
@@ -198,7 +198,7 @@ contract L2ERC1155Gateway is OwnableUpgradeable, ERC1155HolderUpgradeable, Scrol
         uint256[] calldata _tokenIds,
         uint256[] calldata _amounts,
         uint256 _gasLimit
-    ) internal virtual nonReentrant {
+    ) internal nonReentrant {
         require(_tokenIds.length > 0, "no token to withdraw");
         require(_tokenIds.length == _amounts.length, "length mismatch");
 

contracts/src/L2/gateways/L2ERC721Gateway.sol

@@ -97,7 +97,7 @@ contract L2ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         address _from,
         address _to,
         uint256 _tokenId
-    ) external virtual onlyCallByCounterpart nonReentrant {
+    ) external override onlyCallByCounterpart nonReentrant {
         require(_l1Token != address(0), "token address cannot be 0");
         require(_l1Token == tokenMapping[_l2Token], "l2 token mismatch");
 
@@ -113,7 +113,7 @@ contract L2ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         address _from,
         address _to,
         uint256[] calldata _tokenIds
-    ) external virtual onlyCallByCounterpart nonReentrant {
+    ) external override onlyCallByCounterpart nonReentrant {
         require(_l1Token != address(0), "token address cannot be 0");
         require(_l1Token == tokenMapping[_l2Token], "l2 token mismatch");
 
@@ -153,7 +153,7 @@ contract L2ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         address _to,
         uint256 _tokenId,
         uint256 _gasLimit
-    ) internal virtual nonReentrant {
+    ) internal nonReentrant {
         address _l1Token = tokenMapping[_token];
         require(_l1Token != address(0), "no corresponding l1 token");
 
@@ -188,7 +188,7 @@ contract L2ERC721Gateway is OwnableUpgradeable, ERC721HolderUpgradeable, ScrollG
         address _to,
         uint256[] calldata _tokenIds,
         uint256 _gasLimit
-    ) internal virtual nonReentrant {
+    ) internal nonReentrant {
         require(_tokenIds.length > 0, "no token to withdraw");
 
         address _l1Token = tokenMapping[_token];

contracts/src/L2/gateways/L2ETHGateway.sol

@@ -88,7 +88,7 @@ contract L2ETHGateway is Initializable, ScrollGatewayBase, IL2ETHGateway {
         uint256 _amount,
         bytes memory _data,
         uint256 _gasLimit
-    ) internal virtual nonReentrant {
+    ) internal nonReentrant {
         require(msg.value > 0, "withdraw zero eth");
 
         // 1. Extract real sender if this call is from L1GatewayRouter.

contracts/src/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@scroll-tech/contracts",
     "description": "A library for interacting with Scroll contracts.",
-    "version": "0.0.4",
+    "version": "0.0.3",
     "repository": {
       "type": "git",
       "url": "https://github.com/scroll-tech/scroll.git"