Fix missing storage resolver for validator info

dataRetriever/factory/storageResolversContainer/baseResolversContainerFactory.go

@@ -240,3 +240,28 @@ func (brcf *baseResolversContainerFactory) generatePeerAuthenticationResolver()
 
 	return brcf.container.Add(identifierPeerAuth, peerAuthResolver)
 }
+
+func (brcf *baseResolversContainerFactory) generateValidatorInfoResolver() error {
+	validatorInfoStorer, err := brcf.store.GetStorer(dataRetriever.UnsignedTransactionUnit)
+	if err != nil {
+		return err
+	}
+
+	identifierValidatorInfo := common.ValidatorInfoTopic
+	arg := storageResolvers.ArgSliceResolver{
+		Messenger:                brcf.messenger,
+		ResponseTopicName:        identifierValidatorInfo,
+		Storage:                  validatorInfoStorer,
+		DataPacker:               brcf.dataPacker,
+		Marshalizer:              brcf.marshalizer,
+		ManualEpochStartNotifier: brcf.manualEpochStartNotifier,
+		ChanGracefullyClose:      brcf.chanGracefullyClose,
+		DelayBeforeGracefulClose: defaultBeforeGracefulClose,
+	}
+	validatorInfoResolver, err := storageResolvers.NewSliceResolver(arg)
+	if err != nil {
+		return err
+	}
+
+	return brcf.container.Add(identifierValidatorInfo, validatorInfoResolver)
+}

dataRetriever/factory/storageResolversContainer/metaResolversContainerFactory.go

@@ -99,6 +99,11 @@ func (mrcf *metaResolversContainerFactory) Create() (dataRetriever.ResolversCont
 		return nil, err
 	}
 
+	err = mrcf.generateValidatorInfoResolver()
+	if err != nil {
+		return nil, err
+	}
+
 	return mrcf.container, nil
 }
 

dataRetriever/factory/storageResolversContainer/metaResolversContainerFactory_test.go

@@ -170,8 +170,10 @@ func TestMetaResolversContainerFactory_With4ShardsShouldWork(t *testing.T) {
 	numResolversTxs := noOfShards + 1
 	numResolversTrieNodes := 2
 	numPeerAuthentication := 1
+	numValidatorInfo := 1
 	totalResolvers := numResolversShardHeadersForMetachain + numResolverMetablocks + numResolversMiniBlocks +
-		numResolversUnsigned + numResolversTxs + numResolversTrieNodes + numResolversRewards + numPeerAuthentication
+		numResolversUnsigned + numResolversTxs + numResolversTrieNodes + numResolversRewards + numPeerAuthentication +
+		numValidatorInfo
 
 	assert.Equal(t, totalResolvers, container.Len())
 	assert.Equal(t, totalResolvers, container.Len())

dataRetriever/factory/storageResolversContainer/shardResolversContainerFactory.go

@@ -99,6 +99,11 @@ func (srcf *shardResolversContainerFactory) Create() (dataRetriever.ResolversCon
 		return nil, err
 	}
 
+	err = srcf.generateValidatorInfoResolver()
+	if err != nil {
+		return nil, err
+	}
+
 	return srcf.container, nil
 }
 

dataRetriever/factory/storageResolversContainer/shardResolversContainerFactory_test.go

@@ -174,8 +174,10 @@ func TestShardResolversContainerFactory_With4ShardsShouldWork(t *testing.T) {
 	numResolverMetaBlockHeaders := 1
 	numResolverTrieNodes := 1
 	numPeerAuthentication := 1
+	numValidatorInfo := 1
 	totalResolvers := numResolverTxs + numResolverHeaders + numResolverMiniBlocks +
-		numResolverMetaBlockHeaders + numResolverSCRs + numResolverRewardTxs + numResolverTrieNodes + numPeerAuthentication
+		numResolverMetaBlockHeaders + numResolverSCRs + numResolverRewardTxs + numResolverTrieNodes +
+		numPeerAuthentication + numValidatorInfo
 
 	assert.Equal(t, totalResolvers, container.Len())
 }

dataRetriever/storageResolvers/sliceResolver.go

@@ -98,9 +98,10 @@ func (sliceRes *sliceResolver) RequestDataFromHashArray(hashes [][]byte, _ uint3
 		mb, errTemp := sliceRes.storage.Get(hash)
 		if errTemp != nil {
 			errFetch = fmt.Errorf("%w for hash %s", errTemp, logger.DisplayByteSlice(hash))
-			log.Trace("fetchMbAsByteSlice missing",
+			log.Trace("fetchByteSlice missing",
 				"error", errFetch.Error(),
-				"hash", hash)
+				"hash", hash,
+				"topic", sliceRes.responseTopicName)
 			errorsFound++
 
 			continue
@@ -121,7 +122,8 @@ func (sliceRes *sliceResolver) RequestDataFromHashArray(hashes [][]byte, _ uint3
 	}
 
 	if errFetch != nil {
-		errFetch = fmt.Errorf("resolveMbRequestByHashArray last error %w from %d encountered errors", errFetch, errorsFound)
+		errFetch = fmt.Errorf("resolveRequestByHashArray on topic %s, last error %w from %d encountered errors",
+			sliceRes.responseTopicName, errFetch, errorsFound)
 		sliceRes.signalGracefullyClose()
 	}
 

epochStart/shardchain/peerMiniBlocksSyncer.go

@@ -277,13 +277,13 @@ func (p *peerMiniBlockSyncer) setMissingValidatorsInfo(miniBlock *block.MiniBloc
 	for _, txHash := range miniBlock.TxHashes {
 		p.mapAllValidatorsInfo[string(txHash)] = nil
 
-		validatorInfoObjectFound, ok := p.validatorsInfoPool.SearchFirstData(txHash)
+		val, ok := p.validatorsInfoPool.SearchFirstData(txHash)
 		if !ok {
 			numMissingValidatorsInfo++
 			continue
 		}
 
-		validatorInfo, ok := validatorInfoObjectFound.(*state.ShardValidatorInfo)
+		validatorInfo, ok := val.(*state.ShardValidatorInfo)
 		if !ok {
 			numMissingValidatorsInfo++
 			continue

process/block/preprocess/basePreProcess.go

@@ -250,21 +250,22 @@ func (bpp *basePreProcess) saveTransactionToStorage(
 	forBlock.mutTxsForBlock.RUnlock()
 
 	if txInfoFromMap == nil || txInfoFromMap.tx == nil {
-		log.Warn("basePreProcess.saveTransactionToStorage", "type", dataUnit, "txHash", txHash, "error", process.ErrMissingTransaction.Error())
+		log.Warn("basePreProcess.saveTransactionToStorage", "txHash", txHash, "dataUnit", dataUnit, "error", process.ErrMissingTransaction)
 		return
 	}
 
 	buff, err := bpp.marshalizer.Marshal(txInfoFromMap.tx)
 	if err != nil {
-		log.Warn("basePreProcess.saveTransactionToStorage", "txHash", txHash, "error", err.Error())
+		log.Warn("basePreProcess.saveTransactionToStorage: Marshal", "txHash", txHash, "error", err)
 		return
 	}
 
 	errNotCritical := store.Put(dataUnit, txHash, buff)
 	if errNotCritical != nil {
-		log.Debug("store.Put",
-			"error", errNotCritical.Error(),
+		log.Debug("basePreProcess.saveTransactionToStorage: Put",
+			"txHash", txHash,
 			"dataUnit", dataUnit,
+			"error", errNotCritical,
 		)
 	}
 }

process/block/preprocess/validatorInfoPreProcessor.go

@@ -165,11 +165,55 @@ func (vip *validatorInfoPreprocessor) ProcessBlockTransactions(
 	return nil
 }
 
-// SaveTxsToStorage does nothing
-func (vip *validatorInfoPreprocessor) SaveTxsToStorage(_ *block.Body) error {
+// SaveTxsToStorage saves validator info from body into storage
+func (vip *validatorInfoPreprocessor) SaveTxsToStorage(body *block.Body) error {
+	if check.IfNil(body) {
+		return process.ErrNilBlockBody
+	}
+
+	for i := 0; i < len(body.MiniBlocks); i++ {
+		miniBlock := body.MiniBlocks[i]
+		if miniBlock.Type != block.PeerBlock {
+			continue
+		}
+
+		vip.saveValidatorInfoToStorage(miniBlock)
+	}
+
 	return nil
 }
 
+func (vip *validatorInfoPreprocessor) saveValidatorInfoToStorage(miniBlock *block.MiniBlock) {
+	for _, txHash := range miniBlock.TxHashes {
+		val, ok := vip.validatorsInfoPool.SearchFirstData(txHash)
+		if !ok {
+			log.Debug("validatorInfoPreprocessor.saveValidatorInfoToStorage: SearchFirstData: tx not found in validator info pool", "txHash", txHash)
+			continue
+		}
+
+		validatorInfo, ok := val.(*state.ShardValidatorInfo)
+		if !ok {
+			log.Warn("validatorInfoPreprocessor.saveValidatorInfoToStorage: wrong type assertion", "txHash", txHash)
+			continue
+		}
+
+		buff, err := vip.marshalizer.Marshal(validatorInfo)
+		if err != nil {
+			log.Warn("validatorInfoPreprocessor.saveValidatorInfoToStorage: Marshal", "txHash", txHash, "error", err)
+			continue
+		}
+
+		err = vip.storage.Put(dataRetriever.UnsignedTransactionUnit, txHash, buff)
+		if err != nil {
+			log.Debug("validatorInfoPreprocessor.saveValidatorInfoToStorage: Put",
+				"txHash", txHash,
+				"dataUnit", dataRetriever.UnsignedTransactionUnit,
+				"error", err,
+			)
+		}
+	}
+}
+
 // CreateBlockStarted cleans the local cache map for processed/created validators info at this round
 func (vip *validatorInfoPreprocessor) CreateBlockStarted() {
 	_ = core.EmptyChannel(vip.chReceivedAllValidatorsInfo)

process/block/preprocess/validatorInfoPreProcessor_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/ElrondNetwork/elrond-go-core/core"
 	"github.com/ElrondNetwork/elrond-go-core/data/block"
+	"github.com/ElrondNetwork/elrond-go-core/data/rewardTx"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever"
 	"github.com/ElrondNetwork/elrond-go/process"
 	"github.com/ElrondNetwork/elrond-go/state"
@@ -15,6 +16,7 @@ import (
 	"github.com/ElrondNetwork/elrond-go/testscommon/hashingMocks"
 	"github.com/ElrondNetwork/elrond-go/testscommon/storage"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewValidatorInfoPreprocessor_NilHasherShouldErr(t *testing.T) {
@@ -495,3 +497,75 @@ func TestNewValidatorInfoPreprocessor_RestoreValidatorsInfo(t *testing.T) {
 		assert.True(t, wasCalledWithExpectedKey)
 	})
 }
+
+func TestValidatorInfoPreprocessor_SaveTxsToStorageShouldWork(t *testing.T) {
+	t.Parallel()
+
+	txHash1 := []byte("txHash1")
+	txHash2 := []byte("txHash2")
+	txHash3 := []byte("txHash3")
+	txHash4 := []byte("txHash4")
+
+	tdp := initDataPool()
+
+	tdp.ValidatorsInfoCalled = func() dataRetriever.ShardedDataCacherNotifier {
+		return &testscommon.ShardedDataStub{
+			SearchFirstDataCalled: func(key []byte) (value interface{}, ok bool) {
+				if bytes.Equal(key, txHash1) {
+					return nil, false
+				}
+				if bytes.Equal(key, txHash2) {
+					return &state.ValidatorInfo{}, true
+				}
+				if bytes.Equal(key, txHash3) {
+					return &state.ShardValidatorInfo{}, true
+				}
+				if bytes.Equal(key, txHash4) {
+					return &rewardTx.RewardTx{}, true
+				}
+				return nil, false
+			},
+		}
+	}
+
+	putHashes := make([][]byte, 0)
+	storer := &storage.ChainStorerStub{
+		PutCalled: func(unitType dataRetriever.UnitType, key []byte, value []byte) error {
+			putHashes = append(putHashes, key)
+			return nil
+		},
+	}
+
+	vip, _ := NewValidatorInfoPreprocessor(
+		&hashingMocks.HasherMock{},
+		&testscommon.MarshalizerMock{},
+		&testscommon.BlockSizeComputationStub{},
+		tdp.ValidatorsInfo(),
+		storer,
+		&testscommon.EnableEpochsHandlerStub{},
+	)
+
+	err := vip.SaveTxsToStorage(nil)
+	assert.Equal(t, process.ErrNilBlockBody, err)
+
+	peersHashes := [][]byte{txHash1, txHash2, txHash3}
+	rewardsHashes := [][]byte{txHash4}
+
+	mb1 := block.MiniBlock{
+		TxHashes: rewardsHashes,
+		Type:     block.RewardsBlock,
+	}
+	mb2 := block.MiniBlock{
+		TxHashes: peersHashes,
+		Type:     block.PeerBlock,
+	}
+
+	blockBody := &block.Body{}
+	blockBody.MiniBlocks = append(blockBody.MiniBlocks, &mb1, &mb2)
+
+	err = vip.SaveTxsToStorage(blockBody)
+
+	assert.Nil(t, err)
+	require.Equal(t, 1, len(putHashes))
+	assert.Equal(t, txHash3, putHashes[0])
+}