Merge branch 'feat/equivalent-messages' into test_feat/equivalent-mes…

…sages

common/common.go

@@ -6,8 +6,6 @@ import (
 	"github.com/multiversx/mx-chain-core-go/core"
 	"github.com/multiversx/mx-chain-core-go/core/check"
 	"github.com/multiversx/mx-chain-core-go/data"
-	"github.com/multiversx/mx-chain-go/storage"
-	"github.com/multiversx/mx-chain-vm-v1_2-go/ipc/marshaling"
 )
 
 // IsValidRelayedTxV3 returns true if the provided transaction is a valid transaction of type relayed v3
@@ -77,28 +75,3 @@ func VerifyProofAgainstHeader(proof data.HeaderProofHandler, header data.HeaderH
 
 	return nil
 }
-
-// GetHeader tries to get the header from pool first and if not found, searches for it through storer
-func GetHeader(
-	headerHash []byte,
-	headersPool HeadersPool,
-	headersStorer storage.Storer,
-	marshaller marshaling.Marshalizer,
-) (data.HeaderHandler, error) {
-	header, err := headersPool.GetHeaderByHash(headerHash)
-	if err == nil {
-		return header, nil
-	}
-
-	headerBytes, err := headersStorer.SearchFirst(headerHash)
-	if err != nil {
-		return nil, err
-	}
-
-	err = marshaller.Unmarshal(header, headerBytes)
-	if err != nil {
-		return nil, err
-	}
-
-	return header, nil
-}

process/block/baseProcess.go

@@ -124,7 +124,8 @@ type baseProcessor struct {
 	nonceOfFirstCommittedBlock    core.OptionalUint64
 	extraDelayRequestBlockInfo    time.Duration
 
-	proofsPool dataRetriever.ProofsPool
+	proofsPool     dataRetriever.ProofsPool
+	chanNextHeader chan bool
 }
 
 type bootStorerDataArgs struct {
@@ -2297,3 +2298,57 @@ func (bp *baseProcessor) getHeaderHash(header data.HeaderHandler) ([]byte, error
 
 	return bp.hasher.Compute(string(marshalledHeader)), nil
 }
+
+func (bp *baseProcessor) checkProofRequestingNextHeaderBlockingIfMissing(
+	headerShard uint32,
+	headerHash []byte,
+	headerNonce uint64,
+) error {
+	if bp.proofsPool.HasProof(headerShard, headerHash) {
+		return nil
+	}
+
+	log.Trace("could not find proof for header, requesting the next one",
+		"current hash", hex.EncodeToString(headerHash),
+		"header shard", headerShard)
+	err := bp.requestNextHeaderBlocking(headerNonce+1, headerShard)
+	if err != nil {
+		return err
+	}
+
+	if bp.proofsPool.HasProof(headerShard, headerHash) {
+		return nil
+	}
+
+	return fmt.Errorf("%w for header hash %s", process.ErrMissingHeaderProof, hex.EncodeToString(headerHash))
+}
+
+func (bp *baseProcessor) requestNextHeaderBlocking(nonce uint64, shardID uint32) error {
+	headersPool := bp.dataPool.Headers()
+
+	_ = core.EmptyChannel(bp.chanNextHeader)
+
+	if shardID == core.MetachainShardId {
+		go bp.requestHandler.RequestMetaHeaderByNonce(nonce)
+	} else {
+		go bp.requestHandler.RequestShardHeaderByNonce(shardID, nonce)
+	}
+
+	err := bp.waitForNextHeader()
+	if err != nil {
+		return err
+	}
+
+	_, _, err = process.GetShardHeaderFromPoolWithNonce(nonce, shardID, headersPool)
+
+	return err
+}
+
+func (bp *baseProcessor) waitForNextHeader() error {
+	select {
+	case <-bp.chanNextHeader:
+		return nil
+	case <-time.After(bp.extraDelayRequestBlockInfo):
+		return process.ErrTimeIsOut
+	}
+}

process/block/metablock.go

@@ -437,8 +437,9 @@ func (mp *metaProcessor) checkProofsForShardData(header *block.MetaBlock) error
 			continue
 		}
 
-		if !mp.proofsPool.HasProof(shardData.ShardID, shardData.HeaderHash) {
-			return fmt.Errorf("%w for header hash %s", process.ErrMissingHeaderProof, hex.EncodeToString(shardData.HeaderHash))
+		err := mp.checkProofRequestingNextHeaderBlockingIfMissing(shardData.ShardID, shardData.HeaderHash, shardData.Nonce)
+		if err != nil {
+			return err
 		}
 
 		if !common.ShouldBlockHavePrevProof(shardHeader.hdr, mp.enableEpochsHandler, common.EquivalentMessagesFlag) {
@@ -452,7 +453,7 @@ func (mp *metaProcessor) checkProofsForShardData(header *block.MetaBlock) error
 
 		prevProof := shardData.GetPreviousProof()
 		headersPool := mp.dataPool.Headers()
-		prevHeader, err := common.GetHeader(prevProof.GetHeaderHash(), headersPool, shardHeadersStorer, mp.marshalizer)
+		prevHeader, err := process.GetHeader(prevProof.GetHeaderHash(), headersPool, shardHeadersStorer, mp.marshalizer, prevProof.GetHeaderShardId())
 		if err != nil {
 			return err
 		}

process/block/shardblock.go

@@ -305,8 +305,9 @@ func (sp *shardProcessor) ProcessBlock(
 				continue
 			}
 
-			if !sp.proofsPool.HasProof(core.MetachainShardId, metaBlockHash) {
-				return fmt.Errorf("%w for header hash %s", process.ErrMissingHeaderProof, hex.EncodeToString(metaBlockHash))
+			err = sp.checkProofRequestingNextHeaderBlockingIfMissing(core.MetachainShardId, metaBlockHash, hInfo.hdr.GetNonce())
+			if err != nil {
+				return err
 			}
 		}
 	}

process/common.go

@@ -18,8 +18,10 @@ import (
 	"github.com/multiversx/mx-chain-core-go/data/typeConverters"
 	"github.com/multiversx/mx-chain-core-go/hashing"
 	"github.com/multiversx/mx-chain-core-go/marshal"
+	"github.com/multiversx/mx-chain-go/common"
 	"github.com/multiversx/mx-chain-go/dataRetriever"
 	"github.com/multiversx/mx-chain-go/state"
+	"github.com/multiversx/mx-chain-go/storage"
 	logger "github.com/multiversx/mx-chain-logger-go"
 	vmcommon "github.com/multiversx/mx-chain-vm-common-go"
 )
@@ -774,6 +776,27 @@ func GetSortedStorageUpdates(account *vmcommon.OutputAccount) []*vmcommon.Storag
 	return storageUpdates
 }
 
+// GetHeader tries to get the header from pool first and if not found, searches for it through storer
+func GetHeader(
+	headerHash []byte,
+	headersPool common.HeadersPool,
+	headersStorer storage.Storer,
+	marshaller marshal.Marshalizer,
+	shardID uint32,
+) (data.HeaderHandler, error) {
+	header, err := headersPool.GetHeaderByHash(headerHash)
+	if err == nil {
+		return header, nil
+	}
+
+	headerBytes, err := headersStorer.SearchFirst(headerHash)
+	if err != nil {
+		return nil, err
+	}
+
+	return UnmarshalHeader(shardID, marshaller, headerBytes)
+}
+
 // UnmarshalHeader unmarshalls a block header
 func UnmarshalHeader(shardId uint32, marshalizer marshal.Marshalizer, headerBuffer []byte) (data.HeaderHandler, error) {
 	if shardId == core.MetachainShardId {

process/track/baseBlockTrack.go

@@ -131,7 +131,7 @@ func (bbt *baseBlockTrack) receivedProof(proof data.HeaderProofHandler) {
 	}
 
 	headerHash := proof.GetHeaderHash()
-	header, err := bbt.headersPool.GetHeaderByHash(headerHash)
+	header, err := bbt.getHeaderForProof(proof)
 	if err != nil {
 		log.Debug("baseBlockTrack.receivedProof with missing header", "headerHash", headerHash)
 		return
@@ -147,6 +147,16 @@ func (bbt *baseBlockTrack) receivedProof(proof data.HeaderProofHandler) {
 	bbt.receivedHeader(header, headerHash)
 }
 
+func (bbt *baseBlockTrack) getHeaderForProof(proof data.HeaderProofHandler) (data.HeaderHandler, error) {
+	headerUnit := dataRetriever.GetHeadersDataUnit(proof.GetHeaderShardId())
+	headersStorer, err := bbt.store.GetStorer(headerUnit)
+	if err != nil {
+		return nil, err
+	}
+
+	return process.GetHeader(proof.GetHeaderHash(), bbt.headersPool, headersStorer, bbt.marshalizer, proof.GetHeaderShardId())
+}
+
 func (bbt *baseBlockTrack) receivedHeader(headerHandler data.HeaderHandler, headerHash []byte) {
 	if bbt.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, headerHandler.GetEpoch()) {
 		if !bbt.proofsPool.HasProof(headerHandler.GetShardID(), headerHash) {