drop proofs and headers received too late in the next round

integrationTests/testProcessorNode.go

@@ -3540,7 +3540,10 @@ func (tpn *TestProcessorNode) MiniBlocksPresent(hashes [][]byte) bool {
 }
 
 func (tpn *TestProcessorNode) initRoundHandler(roundTime time.Duration) {
-	tpn.RoundHandler = &mock.RoundHandlerMock{TimeDurationField: roundTime}
+	tpn.RoundHandler = &mock.RoundHandlerMock{
+		TimeDurationField:  roundTime,
+		RemainingTimeField: roundTime,
+	}
 }
 
 func (tpn *TestProcessorNode) initRequestedItemsHandler() {

process/interface.go

@@ -1189,6 +1189,8 @@ type RoundTimeDurationHandler interface {
 type RoundHandler interface {
 	Index() int64
 	TimeDuration() time.Duration
+	RemainingTime(startTime time.Time, maxTime time.Duration) time.Duration
+	TimeStamp() time.Time
 	IsInterfaceNil() bool
 }
 

process/mock/rounderMock.go

@@ -11,6 +11,7 @@ type RoundHandlerMock struct {
 	RoundTimeStamp      time.Time
 	RoundTimeDuration   time.Duration
 	BeforeGenesisCalled func() bool
+	RemainingTimeCalled func(startTime time.Time, maxTime time.Duration) time.Duration
 }
 
 // BeforeGenesis -
@@ -55,7 +56,10 @@ func (rndm *RoundHandlerMock) UpdateRound(genesisRoundTimeStamp time.Time, timeS
 }
 
 // RemainingTime -
-func (rndm *RoundHandlerMock) RemainingTime(_ time.Time, _ time.Duration) time.Duration {
+func (rndm *RoundHandlerMock) RemainingTime(startTime time.Time, maxTime time.Duration) time.Duration {
+	if rndm.RemainingTimeCalled != nil {
+		return rndm.RemainingTimeCalled(startTime, maxTime)
+	}
 	return rndm.RoundTimeDuration
 }
 

process/track/baseBlockTrack.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"sort"
 	"sync"
+	"time"
 
 	"github.com/multiversx/mx-chain-core-go/core"
 	"github.com/multiversx/mx-chain-core-go/core/check"
@@ -25,6 +26,9 @@ var log = logger.GetOrCreate("process/track")
 
 const maxNonceDifference = 3 // TODO move this to a config file
 
+// receivedProofDelay is the fraction of the full round time to accept a proof
+const receivedProofDelay = 0.5
+
 // HeaderInfo holds the information about a header
 type HeaderInfo struct {
 	Hash   []byte
@@ -494,6 +498,18 @@ func (bbt *baseBlockTrack) checkAgainstRoundHandler(round uint64) error {
 			nextRound)
 	}
 
+	currentRoundStart := bbt.roundHandler.TimeStamp()
+	roundDuration := float64(bbt.roundHandler.TimeDuration())
+	maxTimeToAcceptProof := time.Duration(roundDuration + roundDuration*receivedProofDelay)
+	timeLeftToAcceptProof := bbt.roundHandler.RemainingTime(currentRoundStart, maxTimeToAcceptProof)
+	if timeLeftToAcceptProof <= 0 {
+		return fmt.Errorf("%w header round: %d, current round timestamp: %d, time left to accept proof: %d",
+			process.ErrHigherRoundInBlock,
+			round,
+			currentRoundStart.UnixMilli(),
+			timeLeftToAcceptProof.Milliseconds())
+	}
+
 	return nil
 }
 

process/track/baseBlockTrack_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"sync"
 	"testing"
+	"time"
 
 	"github.com/multiversx/mx-chain-core-go/core"
 	"github.com/multiversx/mx-chain-core-go/core/check"
@@ -2371,7 +2372,9 @@ func TestBaseBlockTrack_CheckBlockAgainstRoundHandlerShouldWork(t *testing.T) {
 	currentRound := int64(50)
 	bbt.SetRoundHandler(
 		&mock.RoundHandlerMock{
-			RoundIndex: currentRound,
+			RoundIndex:        currentRound,
+			RoundTimeStamp:    time.Now(),
+			RoundTimeDuration: time.Second,
 		},
 	)
 
@@ -2383,6 +2386,39 @@ func TestBaseBlockTrack_CheckBlockAgainstRoundHandlerShouldWork(t *testing.T) {
 	assert.Nil(t, err)
 }
 
+func TestBaseBlockTrack_CheckBlockAgainstRoundHandlerShouldFailOnInvalidWindow(t *testing.T) {
+	t.Parallel()
+
+	bbt := track.NewBaseBlockTrack()
+	currentRound := int64(50)
+	roundDuration := time.Millisecond * 200
+	bbt.SetRoundHandler(
+		&mock.RoundHandlerMock{
+			RoundIndex:        currentRound,
+			RoundTimeStamp:    time.Now(),
+			RoundTimeDuration: roundDuration,
+			RemainingTimeCalled: func(startTime time.Time, maxTime time.Duration) time.Duration {
+				currentTime := time.Now()
+				elapsedTime := currentTime.Sub(startTime)
+				remainingTime := maxTime - elapsedTime
+
+				return remainingTime
+			},
+		},
+	)
+
+	hdr := &block.Header{
+		Round: uint64(currentRound + 1), // proper round but received too late
+	}
+
+	// wait until after half of the next round passed
+	timeToSleep := roundDuration + time.Duration(float64(roundDuration)*0.6)
+	time.Sleep(timeToSleep)
+	err := bbt.CheckBlockAgainstRoundHandler(hdr)
+	require.ErrorIs(t, err, process.ErrHigherRoundInBlock)
+	require.Contains(t, err.Error(), "current round timestamp")
+}
+
 // ------- CheckBlockAgainstFinal
 
 func TestBaseBlockTrack_CheckBlockAgainstFinalNilHeaderShouldErr(t *testing.T) {