drop proofs and headers received too late in the next round

epochStart/mock/rounderStub.go

@@ -8,11 +8,12 @@ import (
 type RoundHandlerStub struct {
 	RoundIndex int64
 
-	IndexCalled         func() int64
-	TimeDurationCalled  func() time.Duration
-	TimeStampCalled     func() time.Time
-	UpdateRoundCalled   func(time.Time, time.Time)
-	RemainingTimeCalled func(startTime time.Time, maxTime time.Duration) time.Duration
+	IndexCalled                func() int64
+	TimeDurationCalled         func() time.Duration
+	TimeStampCalled            func() time.Time
+	UpdateRoundCalled          func(time.Time, time.Time)
+	RemainingTimeCalled        func(startTime time.Time, maxTime time.Duration) time.Duration
+	GetTimeStampForRoundCalled func(round uint64) uint64
 }
 
 // Index -
@@ -61,6 +62,15 @@ func (rndm *RoundHandlerStub) RemainingTime(startTime time.Time, maxTime time.Du
 	return 4000 * time.Millisecond
 }
 
+// GetTimeStampForRound -
+func (rndm *RoundHandlerStub) GetTimeStampForRound(round uint64) uint64 {
+	if rndm.GetTimeStampForRoundCalled != nil {
+		return rndm.GetTimeStampForRoundCalled(round)
+	}
+
+	return uint64(time.Unix(0, 0).UnixMilli())
+}
+
 // IsInterfaceNil returns true if there is no value under the interface
 func (rndm *RoundHandlerStub) IsInterfaceNil() bool {
 	return rndm == nil

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
+	GetTimeStampForRound(round uint64) uint64
 	IsInterfaceNil() bool
 }
 

process/mock/roundStub.go

@@ -6,11 +6,12 @@ import (
 
 // RoundStub -
 type RoundStub struct {
-	IndexCalled         func() int64
-	TimeDurationCalled  func() time.Duration
-	TimeStampCalled     func() time.Time
-	UpdateRoundCalled   func(time.Time, time.Time)
-	RemainingTimeCalled func(time.Time, time.Duration) time.Duration
+	IndexCalled                func() int64
+	TimeDurationCalled         func() time.Duration
+	TimeStampCalled            func() time.Time
+	UpdateRoundCalled          func(time.Time, time.Time)
+	RemainingTimeCalled        func(time.Time, time.Duration) time.Duration
+	GetTimeStampForRoundCalled func(round uint64) uint64
 }
 
 // Index -
@@ -38,6 +39,15 @@ func (rnds *RoundStub) RemainingTime(startTime time.Time, maxTime time.Duration)
 	return rnds.RemainingTimeCalled(startTime, maxTime)
 }
 
+// GetTimeStampForRound -
+func (rnds *RoundStub) GetTimeStampForRound(round uint64) uint64 {
+	if rnds.GetTimeStampForRoundCalled != nil {
+		return rnds.GetTimeStampForRoundCalled(round)
+	}
+
+	return uint64(time.Unix(0, 0).UnixMilli())
+}
+
 // IsInterfaceNil --
 func (rnds *RoundStub) IsInterfaceNil() bool {
 	return rnds == nil

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,10 @@ var log = logger.GetOrCreate("process/track")
 
 const maxNonceDifference = 3 // TODO move this to a config file
 
+// receivedProofDelay is the extra fraction of one full round time during which
+// a proof is still accepted, i.e. total allowed time = roundDuration * (1 + receivedProofDelay)
+const receivedProofDelay = 0.5
+
 // HeaderInfo holds the information about a header
 type HeaderInfo struct {
 	Hash   []byte
@@ -494,6 +499,18 @@ func (bbt *baseBlockTrack) checkAgainstRoundHandler(round uint64) error {
 			nextRound)
 	}
 
+	roundTimestamp := time.UnixMilli(int64(bbt.roundHandler.GetTimeStampForRound(round)))
+	roundDuration := float64(bbt.roundHandler.TimeDuration())
+	maxTimeToAcceptProof := time.Duration(roundDuration + roundDuration*receivedProofDelay)
+	timeLeftToAcceptProof := bbt.roundHandler.RemainingTime(roundTimestamp, maxTimeToAcceptProof)
+	if timeLeftToAcceptProof <= 0 {
+		return fmt.Errorf("%w header round: %d, current round timestamp: %d, time left to accept proof: %d",
+			process.ErrHigherRoundInBlock,
+			round,
+			roundTimestamp.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) {