add timestamp & tx hash to withdrawals

.golangci.yml

@@ -5,7 +5,7 @@ linters:
     - dogsled
     - dupl
     - errcheck
-    - exportloopref
+    - copyloopvar
     - goconst
     - gofmt
     - goimports
@@ -23,12 +23,12 @@ linters:
     - typecheck
     - unconvert
     - unused
-
 issues:
   exclude-rules:
     - path: _test\.go
       linters:
         - gosec
+        - unused
     - linters:
         - stylecheck
       text: "ST1003:"

executor/batchsubmitter/db_test.go

@@ -20,7 +20,7 @@ func TestSaveGetLocalBatchInfo(t *testing.T) {
 	localBatchInfo := executortypes.LocalBatchInfo{
 		Start:              1,
 		End:                2,
-		LastSubmissionTime: time.Unix(0, 10000),
+		LastSubmissionTime: time.Unix(0, 10000).UTC(),
 		BatchSize:          1000,
 	}
 

executor/celestia/node.go

@@ -8,7 +8,6 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
-	btypes "github.com/initia-labs/opinit-bots/node/broadcaster/types"
 	"github.com/initia-labs/opinit-bots/txutils"
 	celestiatypes "github.com/initia-labs/opinit-bots/types/celestia"
 )
@@ -59,7 +58,7 @@ func (c *Celestia) BuildTxWithMessages(
 		return nil, "", errors.Wrap(err, "failed to marshal blob tx")
 	}
 
-	return blobTxBytes, btypes.TxHash(txBytes), nil
+	return blobTxBytes, txutils.TxHash(txBytes), nil
 }
 
 func (c *Celestia) PendingTxToProcessedMsgs(

executor/child/query.go

@@ -27,6 +27,9 @@ func (ch Child) QueryWithdrawal(sequence uint64) (executortypes.QueryWithdrawalR
 		Sequence: sequence,
 		Amount:   amount,
 		Version:  []byte{ch.Version()},
+		TxHeight: withdrawal.TxHeight,
+		TxTime:   withdrawal.TxTime,
+		TxHash:   withdrawal.TxHash,
 	}
 
 	proofs, outputIndex, outputRoot, extraDataBytes, err := merkle.GetProofs(ch.DB(), sequence)

executor/child/query_test.go

@@ -2,6 +2,7 @@ package child
 
 import (
 	"encoding/json"
+	"fmt"
 	"testing"
 
 	ophosttypes "github.com/initia-labs/OPinit/x/ophost/types"
@@ -31,6 +32,9 @@ func saveQueryData(t *testing.T, db types.DB) {
 			Amount:         100,
 			BaseDenom:      "baseDenom",
 			WithdrawalHash: []byte("withdrawalHash"),
+			TxTime:         int64(i),
+			TxHeight:       int64(i),
+			TxHash:         fmt.Sprintf("txHash%d", i),
 		}
 		err := SaveWithdrawal(db, withdrawal)
 		require.NoError(t, err)
@@ -44,12 +48,15 @@ func saveQueryData(t *testing.T, db types.DB) {
 			Amount:         1000,
 			BaseDenom:      "baseDenom",
 			WithdrawalHash: []byte("withdrawalHash"),
+			TxTime:         int64(i),
+			TxHeight:       int64(i),
+			TxHash:         fmt.Sprintf("txHash%d", i),
 		}
 		err := SaveWithdrawal(db, withdrawal)
 		require.NoError(t, err)
 	}
 
-	extraData := executortypes.NewTreeExtraData(10, []byte("00000000000000000000000blockid10"))
+	extraData := executortypes.NewTreeExtraData(10, 10, []byte("00000000000000000000000blockid10"))
 	extraDataBz, err := json.Marshal(extraData)
 	require.NoError(t, err)
 
@@ -73,7 +80,7 @@ func saveQueryData(t *testing.T, db types.DB) {
 	}...)
 	require.NoError(t, err)
 
-	extraData = executortypes.NewTreeExtraData(100, []byte("0000000000000000000000blockid100"))
+	extraData = executortypes.NewTreeExtraData(100, 100, []byte("0000000000000000000000blockid100"))
 	extraDataBz, err = json.Marshal(extraData)
 	require.NoError(t, err)
 	err = merkle.SaveFinalizedTree(db, merkletypes.FinalizedTreeInfo{
@@ -104,7 +111,7 @@ func saveQueryData(t *testing.T, db types.DB) {
 	}...)
 	require.NoError(t, err)
 
-	extraData = executortypes.NewTreeExtraData(1000, []byte("000000000000000000000blockid1000"))
+	extraData = executortypes.NewTreeExtraData(1000, 1000, []byte("000000000000000000000blockid1000"))
 	extraDataBz, err = json.Marshal(extraData)
 	require.NoError(t, err)
 	err = merkle.SaveFinalizedTree(db, merkletypes.FinalizedTreeInfo{
@@ -161,6 +168,9 @@ func TestQueryWithdrawal(t *testing.T) {
 				Version:       []byte{0},
 				StorageRoot:   []byte("000000000000000000000000hash1234"),
 				LastBlockHash: []byte("00000000000000000000000blockid10"),
+				TxTime:        1,
+				TxHeight:      1,
+				TxHash:        "txHash1",
 			},
 			expected: true,
 		},
@@ -182,6 +192,9 @@ func TestQueryWithdrawal(t *testing.T) {
 				Version:       []byte{0},
 				StorageRoot:   []byte("00000000000000000000hash56789999"),
 				LastBlockHash: []byte("0000000000000000000000blockid100"),
+				TxTime:        5,
+				TxHeight:      5,
+				TxHash:        "txHash5",
 			},
 			expected: true,
 		},
@@ -209,6 +222,9 @@ func TestQueryWithdrawal(t *testing.T) {
 				Version:       []byte{0},
 				StorageRoot:   []byte("00000000000000000000hash56789999"),
 				LastBlockHash: []byte("0000000000000000000000blockid100"),
+				TxTime:        7,
+				TxHeight:      7,
+				TxHash:        "txHash7",
 			},
 			expected: true,
 		},
@@ -226,6 +242,9 @@ func TestQueryWithdrawal(t *testing.T) {
 				Version:          []byte{0},
 				StorageRoot:      nil,
 				LastBlockHash:    nil,
+				TxTime:           11,
+				TxHeight:         11,
+				TxHash:           "txHash11",
 			},
 			expected: true,
 		},
@@ -301,6 +320,9 @@ func TestQueryWithdrawals(t *testing.T) {
 						Version:       []byte{0},
 						StorageRoot:   []byte("000000000000000000000000hash1234"),
 						LastBlockHash: []byte("00000000000000000000000blockid10"),
+						TxTime:        1,
+						TxHeight:      1,
+						TxHash:        "txHash1",
 					},
 					{
 						Sequence:    2,
@@ -316,6 +338,9 @@ func TestQueryWithdrawals(t *testing.T) {
 						Version:       []byte{0},
 						StorageRoot:   []byte("000000000000000000000000hash1234"),
 						LastBlockHash: []byte("00000000000000000000000blockid10"),
+						TxTime:        2,
+						TxHeight:      2,
+						TxHash:        "txHash2",
 					},
 					{
 						Sequence:    3,
@@ -331,6 +356,9 @@ func TestQueryWithdrawals(t *testing.T) {
 						Version:       []byte{0},
 						StorageRoot:   []byte("000000000000000000000000hash1234"),
 						LastBlockHash: []byte("00000000000000000000000blockid10"),
+						TxTime:        3,
+						TxHeight:      3,
+						TxHash:        "txHash3",
 					},
 				},
 				Next: uint64Ptr(4),
@@ -371,6 +399,9 @@ func TestQueryWithdrawals(t *testing.T) {
 						Version:       []byte{0},
 						StorageRoot:   []byte("000000000000000000000000hash1234"),
 						LastBlockHash: []byte("00000000000000000000000blockid10"),
+						TxTime:        1,
+						TxHeight:      1,
+						TxHash:        "txHash1",
 					},
 				},
 			},
@@ -395,6 +426,9 @@ func TestQueryWithdrawals(t *testing.T) {
 						Version:          []byte{0},
 						StorageRoot:      nil,
 						LastBlockHash:    nil,
+						TxTime:           11,
+						TxHeight:         11,
+						TxHash:           "txHash11",
 					},
 					{
 						Sequence:    10,
@@ -409,6 +443,9 @@ func TestQueryWithdrawals(t *testing.T) {
 						Version:       []byte{0},
 						StorageRoot:   []byte("000000000000000000000000hash1010"),
 						LastBlockHash: []byte("000000000000000000000blockid1000"),
+						TxTime:        10,
+						TxHeight:      10,
+						TxHash:        "txHash10",
 					},
 					{
 						Sequence:    9,
@@ -425,6 +462,9 @@ func TestQueryWithdrawals(t *testing.T) {
 						Version:       []byte{0},
 						StorageRoot:   []byte("00000000000000000000hash56789999"),
 						LastBlockHash: []byte("0000000000000000000000blockid100"),
+						TxTime:        9,
+						TxHeight:      9,
+						TxHash:        "txHash9",
 					},
 					{
 						Sequence:    8,
@@ -441,6 +481,9 @@ func TestQueryWithdrawals(t *testing.T) {
 						Version:       []byte{0},
 						StorageRoot:   []byte("00000000000000000000hash56789999"),
 						LastBlockHash: []byte("0000000000000000000000blockid100"),
+						TxTime:        8,
+						TxHeight:      8,
+						TxHash:        "txHash8",
 					},
 					{
 						Sequence:    7,
@@ -457,6 +500,9 @@ func TestQueryWithdrawals(t *testing.T) {
 						Version:       []byte{0},
 						StorageRoot:   []byte("00000000000000000000hash56789999"),
 						LastBlockHash: []byte("0000000000000000000000blockid100"),
+						TxTime:        7,
+						TxHeight:      7,
+						TxHash:        "txHash7",
 					},
 				},
 			},

executor/child/withdraw.go

@@ -5,10 +5,12 @@ import (
 	"encoding/base64"
 	"fmt"
 	"strings"
+	"time"
 
 	ophosttypes "github.com/initia-labs/OPinit/x/ophost/types"
 	executortypes "github.com/initia-labs/opinit-bots/executor/types"
 	"github.com/initia-labs/opinit-bots/merkle"
+	"github.com/initia-labs/opinit-bots/txutils"
 	"github.com/initia-labs/opinit-bots/types"
 	"github.com/pkg/errors"
 	"go.uber.org/zap"
@@ -24,16 +26,16 @@ func (ch *Child) initiateWithdrawalHandler(ctx types.Context, args nodetypes.Eve
 	if err != nil {
 		return errors.Wrap(err, "failed to parse initiate withdrawal event")
 	}
-	err = ch.handleInitiateWithdrawal(ctx, l2Sequence, from, to, baseDenom, amount)
+	err = ch.handleInitiateWithdrawal(ctx, l2Sequence, from, to, baseDenom, amount, args.BlockTime, args.BlockHeight, txutils.TxHash(args.Tx))
 	if err != nil {
 		return errors.Wrap(err, "failed to handle initiate withdrawal")
 	}
 	return nil
 }
 
-func (ch *Child) handleInitiateWithdrawal(ctx types.Context, l2Sequence uint64, from string, to string, baseDenom string, amount uint64) error {
+func (ch *Child) handleInitiateWithdrawal(ctx types.Context, l2Sequence uint64, from string, to string, baseDenom string, amount uint64, blockTime time.Time, blockHeight int64, txHash string) error {
 	withdrawalHash := ophosttypes.GenerateWithdrawalHash(ch.BridgeId(), l2Sequence, from, to, baseDenom, amount)
-	data := executortypes.NewWithdrawalData(l2Sequence, from, to, amount, baseDenom, withdrawalHash[:])
+	data := executortypes.NewWithdrawalData(l2Sequence, from, to, amount, baseDenom, withdrawalHash[:], blockHeight, blockTime.UnixNano(), txHash)
 
 	// store to database
 	err := SaveWithdrawal(ch.stage, data)
@@ -63,6 +65,8 @@ func (ch *Child) handleInitiateWithdrawal(ctx types.Context, l2Sequence uint64,
 		zap.Uint64("amount", amount),
 		zap.String("base_denom", baseDenom),
 		zap.String("withdrawal", base64.StdEncoding.EncodeToString(withdrawalHash[:])),
+		zap.Int64("height", blockHeight),
+		zap.String("tx_hash", txHash),
 	)
 
 	return nil
@@ -132,7 +136,7 @@ func (ch *Child) handleTree(ctx types.Context, blockHeight int64, latestHeight i
 			blockHeight == latestHeight &&
 			blockHeader.Time.After(ch.nextOutputTime)) {
 
-		treeExtraData := executortypes.NewTreeExtraData(blockHeight, blockId)
+		treeExtraData := executortypes.NewTreeExtraData(blockHeight, blockHeader.Time.UnixNano(), blockId)
 		data, err := treeExtraData.Marshal()
 		if err != nil {
 			return nil, err