add root hash for state accesses event

data/outport.go

@@ -80,6 +80,8 @@ type BlockStateAccesses struct {
 	ShardID                  uint32                                `json:"shardID"`
 	TimeStampMs              uint64                                `json:"timestampMs"`
 	Nonce                    uint64                                `json:"nonce"`
+	RootHash                 []byte                                `json:"rootHash"`
+	ScheduledRootHash        []byte                                `json:"scheduledRootHash"`
 	StateAccessesPerAccounts map[string]*stateChange.StateAccesses `json:"stateAccessesPerAccounts"`
 }
 

process/eventsHandler.go

@@ -130,11 +130,18 @@ func (eh *eventsHandler) HandleSaveBlockEvents(allEvents data.ArgsSaveBlockData)
 	}
 	eh.handleBlockEventsWithOrder(txsWithOrder)
 
+	var scheduledRootHash []byte
+	if eventsData.Header.GetAdditionalData() != nil {
+		scheduledRootHash = eventsData.Header.GetAdditionalData().GetScheduledRootHash()
+	}
+
 	stateAccesses := data.BlockStateAccesses{
 		Hash:                     eventsData.Hash,
 		ShardID:                  eventsData.Header.GetShardID(),
 		TimeStampMs:              headerTimeStampMs,
 		Nonce:                    eventsData.Header.GetNonce(),
+		RootHash:                 eventsData.Header.GetRootHash(),
+		ScheduledRootHash:        scheduledRootHash,
 		StateAccessesPerAccounts: eventsData.StateAccessesPerAccounts,
 	}
 	eh.handleStateAccesses(stateAccesses)

process/eventsHandler_test.go

@@ -2,13 +2,15 @@ package process_test
 
 import (
 	"context"
+	"encoding/hex"
 	"errors"
 	"testing"
 
 	"github.com/multiversx/mx-chain-core-go/core/check"
 	"github.com/multiversx/mx-chain-core-go/data/block"
 	"github.com/multiversx/mx-chain-core-go/data/outport"
 	"github.com/multiversx/mx-chain-core-go/data/smartContractResult"
+	"github.com/multiversx/mx-chain-core-go/data/stateChange"
 	"github.com/multiversx/mx-chain-core-go/data/transaction"
 	"github.com/multiversx/mx-chain-notifier-go/common"
 	"github.com/multiversx/mx-chain-notifier-go/data"
@@ -181,9 +183,31 @@ func TestHandleSaveBlockEvents(t *testing.T) {
 			},
 		}
 
+		stateAccesses := make(map[string]*stateChange.StateAccesses)
+		stateAccesses["txHash1"] = &stateChange.StateAccesses{
+			StateAccess: []*stateChange.StateAccess{
+				&stateChange.StateAccess{
+					Type:        stateChange.Write,
+					MainTrieKey: []byte("mainTrieKey1"),
+					MainTrieVal: []byte("mainTrieVal1"),
+				},
+				&stateChange.StateAccess{
+					Type:        stateChange.Write,
+					MainTrieKey: []byte("mainTrieKey2"),
+					MainTrieVal: []byte("mainTrieVal2"),
+				},
+			},
+		}
+		stateAccesses["txHash2"] = &stateChange.StateAccesses{}
+
+		rootHash := []byte("rootHash1")
+		timeStamp := uint64(123)
+		timeStampMs := uint64(1234)
 		header := &block.HeaderV2{
 			Header: &block.Header{
-				ShardID: 2,
+				ShardID:   2,
+				TimeStamp: timeStamp,
+				RootHash:  rootHash,
 			},
 		}
 		blockData := data.ArgsSaveBlockData{
@@ -193,7 +217,9 @@ func TestHandleSaveBlockEvents(t *testing.T) {
 				SmartContractResults: scrs,
 				Logs:                 logData,
 			},
-			Header: &block.HeaderV2{},
+			Header:            &block.HeaderV2{},
+			StateAccesses:     stateAccesses,
+			HeaderTimeStampMs: timeStampMs,
 		}
 
 		expTxs := map[string]*transaction.Transaction{
@@ -216,9 +242,11 @@ func TestHandleSaveBlockEvents(t *testing.T) {
 			Scrs: expScrs,
 		}
 		expLogEvents := data.BlockEvents{
-			Hash:    blockHash,
-			Events:  logEvents,
-			ShardID: 2,
+			Hash:        blockHash,
+			TimeStamp:   timeStamp,
+			TimeStampMs: timeStampMs,
+			Events:      logEvents,
+			ShardID:     2,
 		}
 
 		expTxsWithOrder := map[string]*outport.TxInfo{
@@ -237,30 +265,61 @@ func TestHandleSaveBlockEvents(t *testing.T) {
 			},
 		}
 		expTxsWithOrderData := data.BlockEventsWithOrder{
-			Hash:    blockHash,
-			ShardID: 2,
-			Txs:     expTxsWithOrder,
-			Scrs:    expScrsWithOrder,
-			Events:  logEvents,
+			Hash:        blockHash,
+			TimeStamp:   timeStamp,
+			TimeStampMs: timeStampMs,
+			ShardID:     2,
+			Txs:         expTxsWithOrder,
+			Scrs:        expScrsWithOrder,
+			Events:      logEvents,
+		}
+
+		expStateAccessesPerAccounts := make(map[string]*stateChange.StateAccesses)
+		expStateAccessesPerAccounts[hex.EncodeToString([]byte("mainTrieKey1"))] = &stateChange.StateAccesses{
+			StateAccess: []*stateChange.StateAccess{
+				&stateChange.StateAccess{
+					Type:        stateChange.Write,
+					MainTrieKey: []byte("mainTrieKey1"),
+					MainTrieVal: []byte("mainTrieVal1"),
+				},
+			},
+		}
+		expStateAccessesPerAccounts[hex.EncodeToString([]byte("mainTrieKey2"))] = &stateChange.StateAccesses{
+			StateAccess: []*stateChange.StateAccess{
+				&stateChange.StateAccess{
+					Type:        stateChange.Write,
+					MainTrieKey: []byte("mainTrieKey2"),
+					MainTrieVal: []byte("mainTrieVal2"),
+				},
+			},
+		}
+		expStateAccesses := data.BlockStateAccesses{
+			Hash:                     blockHash,
+			ShardID:                  2,
+			TimeStampMs:              1234,
+			RootHash:                 rootHash,
+			StateAccessesPerAccounts: expStateAccessesPerAccounts,
 		}
 
 		pushWasCalled := false
 		txsWasCalled := false
 		scrsWasCalled := false
 		blockEventsWithOrderWasCalled := false
+		stateAccessesWasCalled := false
 
 		args := createMockEventsHandlerArgs()
 
 		args.EventsInterceptor = &mocks.EventsInterceptorStub{
 			ProcessBlockEventsCalled: func(eventsData *data.ArgsSaveBlockData) (*data.InterceptorBlockData, error) {
 				return &data.InterceptorBlockData{
-					Hash:          blockHash,
-					Header:        header,
-					Txs:           expTxs,
-					Scrs:          expScrs,
-					LogEvents:     logEvents,
-					TxsWithOrder:  expTxsWithOrder,
-					ScrsWithOrder: expScrsWithOrder,
+					Hash:                     blockHash,
+					Header:                   header,
+					Txs:                      expTxs,
+					Scrs:                     expScrs,
+					LogEvents:                logEvents,
+					TxsWithOrder:             expTxsWithOrder,
+					ScrsWithOrder:            expScrsWithOrder,
+					StateAccessesPerAccounts: expStateAccessesPerAccounts,
 				}, nil
 			},
 		}
@@ -282,6 +341,10 @@ func TestHandleSaveBlockEvents(t *testing.T) {
 				blockEventsWithOrderWasCalled = true
 				assert.Equal(t, expTxsWithOrderData, event)
 			},
+			BroadcastStateAccessesCalled: func(event data.BlockStateAccesses) {
+				stateAccessesWasCalled = true
+				assert.Equal(t, expStateAccesses, event)
+			},
 		}
 
 		eventsHandler, err := process.NewEventsHandler(args)
@@ -294,6 +357,7 @@ func TestHandleSaveBlockEvents(t *testing.T) {
 		assert.True(t, txsWasCalled)
 		assert.True(t, scrsWasCalled)
 		assert.True(t, blockEventsWithOrderWasCalled)
+		assert.True(t, stateAccessesWasCalled)
 	})
 }
 

process/eventsInterceptor.go

@@ -2,7 +2,9 @@ package process
 
 import (
 	"encoding/hex"
+	"fmt"
 	"sort"
+	"strings"
 
 	"github.com/multiversx/mx-chain-core-go/core"
 	"github.com/multiversx/mx-chain-core-go/core/check"
@@ -173,19 +175,37 @@ func (ei *eventsInterceptor) getStateAccessesPerAccounts(eventsData *data.ArgsSa
 		}
 	}
 
-	log.Trace("getStateAccessesPerAccounts",
-		"num stateAccessesPerAccounts", len(stateAccessesPerAccounts),
-	)
+	logStateAccessesPerAccounts(stateAccessesPerAccounts)
 
 	return stateAccessesPerAccounts
 }
 
+func logStateAccessesPerAccounts(stateAccesses map[string]*stateChange.StateAccesses) {
+	if log.GetLevel() > logger.LogTrace {
+		return
+	}
+
+	log.Trace("state accesses per accounts",
+		"num stateAccessesPerAccounts", len(stateAccesses),
+	)
+
+	for accKey, sts := range stateAccesses {
+		log.Trace("stateAccessesPerAccount",
+			"account", accKey,
+			"num stateAccesses", len(sts.StateAccess),
+		)
+		for _, st := range sts.StateAccess {
+			log.Trace("state access", "stateChange", stateAccessToString(st))
+		}
+	}
+}
+
 func logStateAccessesPerTxs(stateAccesses map[string]*stateChange.StateAccesses) {
 	if log.GetLevel() > logger.LogTrace {
 		return
 	}
 
-	log.Trace("getStateAccessesPerAccounts",
+	log.Trace("state accesses per transaction",
 		"num stateAccessesPerTxs", len(stateAccesses),
 	)
 
@@ -195,14 +215,27 @@ func logStateAccessesPerTxs(stateAccesses map[string]*stateChange.StateAccesses)
 		)
 
 		for _, st := range sts.StateAccess {
-			log.Trace("st",
-				"actionType", st.GetType(),
-				"operation", st.GetOperation(),
-			)
+			log.Trace("state access", "stateChange", stateAccessToString(st))
 		}
 	}
 }
 
+func stateAccessToString(stateAccess *stateChange.StateAccess) string {
+	dataTrieChanges := make([]string, len(stateAccess.GetDataTrieChanges()))
+	for i, dataTrieChange := range stateAccess.GetDataTrieChanges() {
+		dataTrieChanges[i] = fmt.Sprintf("key: %v, val: %v, type: %v, operation %v, version %v", hex.EncodeToString(dataTrieChange.Key), hex.EncodeToString(dataTrieChange.Val), dataTrieChange.Type, dataTrieChange.Operation, dataTrieChange.Version)
+	}
+	return fmt.Sprintf("type: %v, operation: %v, mainTrieKey: %v, mainTrieVal: %v, index: %v, dataTrieChanges: %v, accountChanges %v",
+		stateAccess.GetType(),
+		stateAccess.GetOperation(),
+		hex.EncodeToString(stateAccess.GetMainTrieKey()),
+		hex.EncodeToString(stateAccess.GetMainTrieVal()),
+		stateAccess.GetIndex(),
+		strings.Join(dataTrieChanges, ", "),
+		stateAccess.GetAccountChanges(),
+	)
+}
+
 func (ei *eventsInterceptor) getLogEventsFromTransactionsPool(logs []*outport.LogData) []data.Event {
 	var logEvents []*logEvent
 	for _, logData := range logs {