Merge pull request #366 from multiversx/last-execution-nonce-and-hash-on-block

Last execution results nonce and hash on block

Author: miiu96

data/block.go

@@ -52,6 +52,8 @@ type Block struct {
 	Reserved                   []byte                 `json:"reserved,omitempty"`
 	ProposerBlsKey             string                 `json:"proposerBlsKey,omitempty"`
 	ExecutionResultBlockHashes []string               `json:"executionResultBlockHashes,omitempty"`
+	LastExecutionResultHash    string                 `json:"lastExecutionResultHash,omitempty"`
+	LastExecutionResultNonce   uint64                 `json:"lastExecutionResultNonce,omitempty"`
 }
 
 // ExecutionResult is a structure containing all the fields that need

process/elasticproc/block/blockProcessor.go

@@ -142,6 +142,7 @@ func (bp *blockProcessor) PrepareBlockForDB(obh *outport.OutportBlockWithHeader)
 
 	appendBlockDetailsFromIntraShardMbs(elasticBlock, obh.BlockData.IntraShardMiniBlocks, obh.TransactionPool, len(obh.Header.GetMiniBlockHeaderHandlers()))
 
+	addInBlockLastExecutionResultData(elasticBlock, obh)
 	addProofs(elasticBlock, obh)
 
 	return &data.PreparedBlockResults{
@@ -150,6 +151,25 @@ func (bp *blockProcessor) PrepareBlockForDB(obh *outport.OutportBlockWithHeader)
 	}, nil
 }
 
+func addInBlockLastExecutionResultData(elasticBlock *data.Block, obh *outport.OutportBlockWithHeader) {
+	lastExecutionResult := obh.Header.GetLastExecutionResultHandler()
+	if check.IfNil(lastExecutionResult) {
+		return
+	}
+
+	switch t := lastExecutionResult.(type) {
+	case *nodeBlock.ExecutionResultInfo:
+		elasticBlock.LastExecutionResultHash = hex.EncodeToString(t.ExecutionResult.GetHeaderHash())
+		elasticBlock.LastExecutionResultNonce = t.ExecutionResult.GetHeaderNonce()
+
+	case *nodeBlock.MetaExecutionResultInfo:
+		elasticBlock.LastExecutionResultHash = hex.EncodeToString(t.ExecutionResult.GetHeaderHash())
+		elasticBlock.LastExecutionResultNonce = t.ExecutionResult.GetHeaderNonce()
+	default:
+		return
+	}
+}
+
 func (bp *blockProcessor) prepareExecutionResults(obh *outport.OutportBlockWithHeader) []*data.ExecutionResult {
 	if !obh.Header.IsHeaderV3() {
 		return []*data.ExecutionResult{}
@@ -244,19 +264,19 @@ func getTxsCount(header coreData.HeaderHandler) (numTxs, notarizedTxs uint32) {
 		return numTxs, notarizedTxs
 	}
 
-	metaHeader, ok := header.(*nodeBlock.MetaBlock)
+	metaHeader, ok := header.(coreData.MetaHeaderHandler)
 	if !ok {
 		return 0, 0
 	}
 
-	notarizedTxs = metaHeader.TxCount
+	notarizedTxs = metaHeader.GetTxCount()
 	numTxs = 0
-	for _, mb := range metaHeader.MiniBlockHeaders {
-		if mb.Type == nodeBlock.PeerBlock {
+	for _, mb := range metaHeader.GetMiniBlockHeaderHandlers() {
+		if mb.GetTypeInt32() == int32(nodeBlock.PeerBlock) {
 			continue
 		}
 
-		numTxs += mb.TxCount
+		numTxs += mb.GetTxCount()
 	}
 
 	notarizedTxs = notarizedTxs - numTxs
@@ -269,7 +289,7 @@ func (bp *blockProcessor) addEpochStartInfoForMeta(header coreData.HeaderHandler
 		return
 	}
 
-	metaHeader, ok := header.(*nodeBlock.MetaBlock)
+	metaHeader, ok := header.(coreData.MetaHeaderHandler)
 	if !ok {
 		return
 	}
@@ -278,55 +298,55 @@ func (bp *blockProcessor) addEpochStartInfoForMeta(header coreData.HeaderHandler
 		return
 	}
 
-	metaHeaderEconomics := metaHeader.EpochStart.Economics
+	metaHeaderEconomics := metaHeader.GetEpochStartHandler().GetEconomicsHandler()
 
 	block.EpochStartInfo = &data.EpochStartInfo{
-		TotalSupply:                      metaHeaderEconomics.TotalSupply.String(),
-		TotalToDistribute:                metaHeaderEconomics.TotalToDistribute.String(),
-		TotalNewlyMinted:                 metaHeaderEconomics.TotalNewlyMinted.String(),
-		RewardsPerBlock:                  metaHeaderEconomics.RewardsPerBlock.String(),
-		RewardsForProtocolSustainability: metaHeaderEconomics.RewardsForProtocolSustainability.String(),
-		NodePrice:                        metaHeaderEconomics.NodePrice.String(),
-		PrevEpochStartRound:              metaHeaderEconomics.PrevEpochStartRound,
-		PrevEpochStartHash:               hex.EncodeToString(metaHeaderEconomics.PrevEpochStartHash),
-	}
-	if len(metaHeader.EpochStart.LastFinalizedHeaders) == 0 {
+		TotalSupply:                      metaHeaderEconomics.GetTotalSupply().String(),
+		TotalToDistribute:                metaHeaderEconomics.GetTotalToDistribute().String(),
+		TotalNewlyMinted:                 metaHeaderEconomics.GetTotalNewlyMinted().String(),
+		RewardsPerBlock:                  metaHeaderEconomics.GetRewardsPerBlock().String(),
+		RewardsForProtocolSustainability: metaHeaderEconomics.GetRewardsForProtocolSustainability().String(),
+		NodePrice:                        metaHeaderEconomics.GetNodePrice().String(),
+		PrevEpochStartRound:              metaHeaderEconomics.GetPrevEpochStartRound(),
+		PrevEpochStartHash:               hex.EncodeToString(metaHeaderEconomics.GetPrevEpochStartHash()),
+	}
+	if len(metaHeader.GetEpochStartHandler().GetLastFinalizedHeaderHandlers()) == 0 {
 		return
 	}
 
-	epochStartShardsData := metaHeader.EpochStart.LastFinalizedHeaders
-	block.EpochStartShardsData = make([]*data.EpochStartShardData, 0, len(metaHeader.EpochStart.LastFinalizedHeaders))
-	for _, epochStartShardData := range epochStartShardsData {
-		bp.addEpochStartShardDataForMeta(epochStartShardData, block)
+	epochStartShardsData := metaHeader.GetEpochStartHandler().GetLastFinalizedHeaderHandlers()
+	block.EpochStartShardsData = make([]*data.EpochStartShardData, 0, len(epochStartShardsData))
+	for _, epochStartShardDataHandler := range epochStartShardsData {
+		bp.addEpochStartShardDataForMeta(epochStartShardDataHandler, block)
 	}
 }
 
-func (bp *blockProcessor) addEpochStartShardDataForMeta(epochStartShardData nodeBlock.EpochStartShardData, block *data.Block) {
+func (bp *blockProcessor) addEpochStartShardDataForMeta(epochStartShardData coreData.EpochStartShardDataHandler, block *data.Block) {
 	shardData := &data.EpochStartShardData{
-		ShardID:               epochStartShardData.ShardID,
-		Epoch:                 epochStartShardData.Epoch,
-		Round:                 epochStartShardData.Round,
-		Nonce:                 epochStartShardData.Nonce,
-		HeaderHash:            hex.EncodeToString(epochStartShardData.HeaderHash),
-		RootHash:              hex.EncodeToString(epochStartShardData.RootHash),
-		ScheduledRootHash:     hex.EncodeToString(epochStartShardData.ScheduledRootHash),
-		FirstPendingMetaBlock: hex.EncodeToString(epochStartShardData.FirstPendingMetaBlock),
-		LastFinishedMetaBlock: hex.EncodeToString(epochStartShardData.LastFinishedMetaBlock),
-	}
-
-	if len(epochStartShardData.PendingMiniBlockHeaders) == 0 {
+		ShardID:               epochStartShardData.GetShardID(),
+		Epoch:                 epochStartShardData.GetEpoch(),
+		Round:                 epochStartShardData.GetRound(),
+		Nonce:                 epochStartShardData.GetNonce(),
+		HeaderHash:            hex.EncodeToString(epochStartShardData.GetHeaderHash()),
+		RootHash:              hex.EncodeToString(epochStartShardData.GetRootHash()),
+		ScheduledRootHash:     hex.EncodeToString(epochStartShardData.GetScheduledRootHash()),
+		FirstPendingMetaBlock: hex.EncodeToString(epochStartShardData.GetFirstPendingMetaBlock()),
+		LastFinishedMetaBlock: hex.EncodeToString(epochStartShardData.GetLastFinishedMetaBlock()),
+	}
+
+	if len(epochStartShardData.GetPendingMiniBlockHeaderHandlers()) == 0 {
 		block.EpochStartShardsData = append(block.EpochStartShardsData, shardData)
 		return
 	}
 
-	shardData.PendingMiniBlockHeaders = make([]*data.Miniblock, 0, len(epochStartShardData.PendingMiniBlockHeaders))
-	for _, pendingMb := range epochStartShardData.PendingMiniBlockHeaders {
+	shardData.PendingMiniBlockHeaders = make([]*data.Miniblock, 0, len(epochStartShardData.GetPendingMiniBlockHeaderHandlers()))
+	for _, pendingMb := range epochStartShardData.GetPendingMiniBlockHeaderHandlers() {
 		shardData.PendingMiniBlockHeaders = append(shardData.PendingMiniBlockHeaders, &data.Miniblock{
-			Hash:            hex.EncodeToString(pendingMb.Hash),
-			SenderShardID:   pendingMb.SenderShardID,
-			ReceiverShardID: pendingMb.ReceiverShardID,
-			Type:            pendingMb.Type.String(),
-			Reserved:        pendingMb.Reserved,
+			Hash:            hex.EncodeToString(pendingMb.GetHash()),
+			SenderShardID:   pendingMb.GetSenderShardID(),
+			ReceiverShardID: pendingMb.GetReceiverShardID(),
+			Type:            nodeBlock.Type(pendingMb.GetTypeInt32()).String(),
+			Reserved:        pendingMb.GetReserved(),
 		})
 	}
 

process/elasticproc/block/blockProcessor_test.go

@@ -662,3 +662,69 @@ func TestPrepareExecutionResult(t *testing.T) {
 		},
 	}, results.ExecutionResults[0])
 }
+
+func TestAddInBlockLastExecutionResultData(t *testing.T) {
+	t.Parallel()
+
+	t.Run("nil last execution result", func(t *testing.T) {
+		elasticBlock := &data.Block{}
+		obh := &outport.OutportBlockWithHeader{
+			Header: &dataBlock.Header{},
+		}
+
+		addInBlockLastExecutionResultData(elasticBlock, obh)
+
+		require.Equal(t, "", elasticBlock.LastExecutionResultHash)
+		require.Equal(t, uint64(0), elasticBlock.LastExecutionResultNonce)
+	})
+
+	t.Run("with ExecutionResultInfo", func(t *testing.T) {
+		elasticBlock := &data.Block{}
+		headerHash := []byte("headerHash")
+		nonce := uint64(10)
+
+		execResultInfo := &dataBlock.ExecutionResultInfo{
+			ExecutionResult: &dataBlock.BaseExecutionResult{
+				HeaderHash:  headerHash,
+				HeaderNonce: nonce,
+			},
+		}
+
+		obh := &outport.OutportBlockWithHeader{
+			Header: &dataBlock.HeaderV3{
+				LastExecutionResult: execResultInfo,
+			},
+		}
+
+		addInBlockLastExecutionResultData(elasticBlock, obh)
+
+		require.Equal(t, hex.EncodeToString(headerHash), elasticBlock.LastExecutionResultHash)
+		require.Equal(t, nonce, elasticBlock.LastExecutionResultNonce)
+	})
+
+	t.Run("with MetaExecutionResultInfo", func(t *testing.T) {
+		elasticBlock := &data.Block{}
+		headerHash := []byte("headerHashMeta")
+		nonce := uint64(20)
+
+		execResultInfo := &dataBlock.MetaExecutionResultInfo{
+			ExecutionResult: &dataBlock.BaseMetaExecutionResult{
+				BaseExecutionResult: &dataBlock.BaseExecutionResult{
+					HeaderHash:  headerHash,
+					HeaderNonce: nonce,
+				},
+			},
+		}
+
+		obh := &outport.OutportBlockWithHeader{
+			Header: &dataBlock.MetaBlockV3{
+				LastExecutionResult: execResultInfo,
+			},
+		}
+
+		addInBlockLastExecutionResultData(elasticBlock, obh)
+
+		require.Equal(t, hex.EncodeToString(headerHash), elasticBlock.LastExecutionResultHash)
+		require.Equal(t, nonce, elasticBlock.LastExecutionResultNonce)
+	})
+}