Integrate proof check on sync

dataRetriever/dataPool/proofsCache/proofsPool.go

@@ -1,6 +1,7 @@
 package proofscache
 
 import (
+	"encoding/hex"
 	"fmt"
 	"sync"
 
@@ -14,12 +15,16 @@ var log = logger.GetOrCreate("dataRetriever/proofscache")
 type proofsPool struct {
 	mutCache sync.RWMutex
 	cache    map[uint32]*proofsCache
+
+	mutAddedProofHandlers sync.RWMutex
+	addedProofHandlers    []func(headerProof data.HeaderProofHandler)
 }
 
 // NewProofsPool creates a new proofs pool component
 func NewProofsPool() *proofsPool {
 	return &proofsPool{
-		cache: make(map[uint32]*proofsCache),
+		cache:              make(map[uint32]*proofsCache),
+		addedProofHandlers: make([]func(headerProof data.HeaderProofHandler), 0),
 	}
 }
 
@@ -36,8 +41,7 @@ func (pp *proofsPool) AddProof(
 
 	hasProof := pp.HasProof(shardID, headerHash)
 	if hasProof {
-		log.Trace("there was already a valid proof for header, headerHash: %s", headerHash)
-		return nil
+		return fmt.Errorf("there was already a valid proof for header, headerHash: %s", hex.EncodeToString(headerHash))
 	}
 
 	pp.mutCache.Lock()
@@ -59,9 +63,20 @@ func (pp *proofsPool) AddProof(
 
 	proofsPerShard.addProof(headerProof)
 
+	pp.callAddedProofHandlers(headerProof)
+
 	return nil
 }
 
+func (pp *proofsPool) callAddedProofHandlers(headerProof data.HeaderProofHandler) {
+	pp.mutAddedProofHandlers.RLock()
+	defer pp.mutAddedProofHandlers.RUnlock()
+
+	for _, handler := range pp.addedProofHandlers {
+		go handler(headerProof)
+	}
+}
+
 // CleanupProofsBehindNonce will cleanup proofs from pool based on nonce
 func (pp *proofsPool) CleanupProofsBehindNonce(shardID uint32, nonce uint64) error {
 	if nonce == 0 {
@@ -120,6 +135,18 @@ func (pp *proofsPool) HasProof(
 	return err == nil
 }
 
+// RegisterHandler registers a new handler to be called when a new data is added
+func (pp *proofsPool) RegisterHandler(handler func(headerProof data.HeaderProofHandler)) {
+	if handler == nil {
+		log.Error("attempt to register a nil handler to proofs pool")
+		return
+	}
+
+	pp.mutAddedProofHandlers.Lock()
+	pp.addedProofHandlers = append(pp.addedProofHandlers, handler)
+	pp.mutAddedProofHandlers.Unlock()
+}
+
 // IsInterfaceNil returns true if there is no value under the interface
 func (pp *proofsPool) IsInterfaceNil() bool {
 	return pp == nil

dataRetriever/dataPool/proofsCache/proofsPool_test.go

@@ -8,6 +8,7 @@ import (
 	"sync/atomic"
 	"testing"
 
+	"github.com/multiversx/mx-chain-core-go/data"
 	"github.com/multiversx/mx-chain-core-go/data/block"
 	proofscache "github.com/multiversx/mx-chain-go/dataRetriever/dataPool/proofsCache"
 	"github.com/stretchr/testify/assert"
@@ -81,6 +82,28 @@ func TestProofsPool_ShouldWork(t *testing.T) {
 	require.Equal(t, proof4, proof)
 }
 
+func TestProofsPool_RegisterHandler(t *testing.T) {
+	t.Parallel()
+
+	pp := proofscache.NewProofsPool()
+
+	wasCalled := false
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	handler := func(proof data.HeaderProofHandler) {
+		wasCalled = true
+		wg.Done()
+	}
+	pp.RegisterHandler(nil)
+	pp.RegisterHandler(handler)
+
+	_ = pp.AddProof(generateProof())
+
+	wg.Wait()
+
+	assert.True(t, wasCalled)
+}
+
 func TestProofsPool_Concurrency(t *testing.T) {
 	t.Parallel()
 
@@ -95,7 +118,7 @@ func TestProofsPool_Concurrency(t *testing.T) {
 
 	for i := 0; i < numOperations; i++ {
 		go func(idx int) {
-			switch idx % 5 {
+			switch idx % 6 {
 			case 0, 1, 2:
 				_ = pp.AddProof(generateProof())
 			case 3:
@@ -105,6 +128,10 @@ func TestProofsPool_Concurrency(t *testing.T) {
 				}
 			case 4:
 				_ = pp.CleanupProofsBehindNonce(generateRandomShardID(), generateRandomNonce())
+			case 5:
+				handler := func(proof data.HeaderProofHandler) {
+				}
+				pp.RegisterHandler(handler)
 			default:
 				assert.Fail(t, "should have not beed called")
 			}

epochStart/bootstrap/common.go

@@ -123,6 +123,9 @@ func checkArguments(args ArgsEpochStartBootstrap) error {
 	if check.IfNil(args.NodesCoordinatorRegistryFactory) {
 		return fmt.Errorf("%s: %w", baseErrorMessage, nodesCoordinator.ErrNilNodesCoordinatorRegistryFactory)
 	}
+	if check.IfNil(args.EnableEpochsHandler) {
+		return fmt.Errorf("%s: %w", baseErrorMessage, epochStart.ErrNilEnableEpochsHandler)
+	}
 
 	return nil
 }