Merge pull request #7897 from multiversx/quarantined-headers-detection

AdoAdoAdo · web-flow · commit bf3575367ee8 · 2026-07-09T11:43:38.000+03:00
added new cache for quarantined headers on late proofs
diff --git a/cmd/node/config/config.toml b/cmd/node/config/config.toml
@@ -619,6 +619,12 @@
     Type = "SizeLRU"
     SizeInBytes = 52428800 # 50MB
 
+[QuarantinedHeadersCache]
+    Name = "QuarantinedHeadersCache"
+    Capacity = 100
+    Type = "SizeLRU"
+    SizeInBytes = 10485760 # 10MB
+
 [PostProcessTransactionsCache]
     Name = "PostProcessTransactionsCache"
     Capacity = 250000
diff --git a/config/config.go b/config/config.go
@@ -227,6 +227,7 @@ type Config struct {
 	SmartContractDataPool        CacheConfig
 	ValidatorInfoPool            CacheConfig
 	ExecutedMiniBlocksCache      CacheConfig
+	QuarantinedHeadersCache      CacheConfig
 	PostProcessTransactionsCache CacheConfig
 	HeaderBodyCacheConfig        HeaderBodyCacheConfig
 	TrieSyncStorage              TrieSyncStorageConfig
diff --git a/dataRetriever/dataPool/dataPool.go b/dataRetriever/dataPool/dataPool.go
@@ -30,6 +30,7 @@ type dataPool struct {
 	executedMiniBlocks      storage.Cacher
 	postProcessTransactions storage.Cacher
 	directSentTransactions  storage.Cacher
+	quarantinedHeaders      storage.Cacher
 }
 
 // DataPoolArgs represents the data pool's constructor structure
@@ -52,6 +53,7 @@ type DataPoolArgs struct {
 	ExecutedMiniBlocks        storage.Cacher
 	PostProcessTransactions   storage.Cacher
 	DirectSentTransactions    storage.Cacher
+	QuarantinedHeaders        storage.Cacher
 }
 
 // NewDataPool creates a data pools holder object
@@ -110,6 +112,9 @@ func NewDataPool(args DataPoolArgs) (*dataPool, error) {
 	if check.IfNil(args.DirectSentTransactions) {
 		return nil, dataRetriever.ErrNilDirectSentTransactionsCache
 	}
+	if check.IfNil(args.QuarantinedHeaders) {
+		return nil, dataRetriever.ErrNilQuarantinedHeadersCache
+	}
 
 	return &dataPool{
 		transactions:            args.Transactions,
@@ -130,6 +135,7 @@ func NewDataPool(args DataPoolArgs) (*dataPool, error) {
 		executedMiniBlocks:      args.ExecutedMiniBlocks,
 		postProcessTransactions: args.PostProcessTransactions,
 		directSentTransactions:  args.DirectSentTransactions,
+		quarantinedHeaders:      args.QuarantinedHeaders,
 	}, nil
 }
 
@@ -223,6 +229,11 @@ func (dp *dataPool) PostProcessTransactions() storage.Cacher {
 	return dp.postProcessTransactions
 }
 
+// QuarantinedHeaders returns the holder for quarantined header hashes (late-arriving equivalent proofs)
+func (dp *dataPool) QuarantinedHeaders() storage.Cacher {
+	return dp.quarantinedHeaders
+}
+
 // Close closes all the components
 func (dp *dataPool) Close() error {
 	var lastError error
diff --git a/dataRetriever/dataPool/dataPool_test.go b/dataRetriever/dataPool/dataPool_test.go
@@ -37,6 +37,7 @@ func createMockDataPoolArgs() dataPool.DataPoolArgs {
 		ExecutedMiniBlocks:        cache.NewCacherStub(),
 		PostProcessTransactions:   cache.NewCacherStub(),
 		DirectSentTransactions:    cache.NewCacherStub(),
+		QuarantinedHeaders:        cache.NewCacherStub(),
 	}
 }
 
@@ -216,6 +217,17 @@ func TestNewDataPool_NilPostProcessTransactionsShouldErr(t *testing.T) {
 	require.Equal(t, dataRetriever.ErrNilPostProcessTransactionsCache, err)
 }
 
+func TestNewDataPool_NilQuarantinedHeadersShouldErr(t *testing.T) {
+	t.Parallel()
+
+	args := createMockDataPoolArgs()
+	args.QuarantinedHeaders = nil
+	tdp, err := dataPool.NewDataPool(args)
+
+	require.Nil(t, tdp)
+	require.Equal(t, dataRetriever.ErrNilQuarantinedHeadersCache, err)
+}
+
 func TestNewDataPool_NilCurrEpochValidatorInfoShouldErr(t *testing.T) {
 	t.Parallel()
 
@@ -253,6 +265,7 @@ func TestNewDataPool_OkValsShouldWork(t *testing.T) {
 	assert.True(t, args.ExecutedMiniBlocks == tdp.ExecutedMiniBlocks())
 	assert.True(t, args.PostProcessTransactions == tdp.PostProcessTransactions())
 	assert.True(t, args.DirectSentTransactions == tdp.DirectSentTransactions())
+	assert.True(t, args.QuarantinedHeaders == tdp.QuarantinedHeaders())
 }
 
 func TestNewDataPool_Close(t *testing.T) {
diff --git a/dataRetriever/errors.go b/dataRetriever/errors.go
@@ -275,6 +275,9 @@ var ErrNilPostProcessTransactionsCache = errors.New("nil post process transactio
 // ErrNilDirectSentTransactionsCache signals that a nil direct-sent transactions cache has been provided
 var ErrNilDirectSentTransactionsCache = errors.New("nil direct sent transactions cache")
 
+// ErrNilQuarantinedHeadersCache signals that a nil quarantined headers cache has been provided
+var ErrNilQuarantinedHeadersCache = errors.New("nil quarantined headers cache")
+
 // ErrEquivalentProofsNotFound signals that no equivalent proof found
 var ErrEquivalentProofsNotFound = errors.New("equivalent proof not found")
 
diff --git a/dataRetriever/factory/dataPoolFactory.go b/dataRetriever/factory/dataPoolFactory.go
@@ -162,6 +162,12 @@ func NewDataPoolFromConfig(args ArgsDataPool) (dataRetriever.PoolsHolder, error)
 		return nil, fmt.Errorf("%w while creating the cache for the executed mini blocks", err)
 	}
 
+	cacherCfg = factory.GetCacherFromConfig(mainConfig.QuarantinedHeadersCache)
+	quarantinedHeaders, err := storageunit.NewCache(cacherCfg)
+	if err != nil {
+		return nil, fmt.Errorf("%w while creating the cache for the quarantined headers", err)
+	}
+
 	cacherCfg = factory.GetCacherFromConfig(mainConfig.PostProcessTransactionsCache)
 	postProcessTransactionsCache, err := storageunit.NewCache(cacherCfg)
 	if err != nil {
@@ -195,6 +201,7 @@ func NewDataPoolFromConfig(args ArgsDataPool) (dataRetriever.PoolsHolder, error)
 		ExecutedMiniBlocks:        executedMiniBlocksCache,
 		PostProcessTransactions:   postProcessTransactionsCache,
 		DirectSentTransactions:    directSentTransactionsCache,
+		QuarantinedHeaders:        quarantinedHeaders,
 	}
 	return dataPool.NewDataPool(dataPoolArgs)
 }
diff --git a/dataRetriever/factory/dataPoolFactory_test.go b/dataRetriever/factory/dataPoolFactory_test.go
@@ -144,6 +144,13 @@ func TestNewDataPoolFromConfig_BadConfigShouldErr(t *testing.T) {
 	require.True(t, errors.Is(err, storage.ErrNotSupportedCacheType))
 	require.True(t, strings.Contains(err.Error(), "the cache for the executed mini blocks"))
 
+	args = getGoodArgs()
+	args.Config.QuarantinedHeadersCache.Type = "invalid cache type"
+	holder, err = NewDataPoolFromConfig(args)
+	require.Nil(t, holder)
+	require.True(t, errors.Is(err, storage.ErrNotSupportedCacheType))
+	require.True(t, strings.Contains(err.Error(), "the cache for the quarantined headers"))
+
 	args = getGoodArgs()
 	args.Config.PostProcessTransactionsCache.Type = "invalid cache type"
 	holder, err = NewDataPoolFromConfig(args)
diff --git a/dataRetriever/interface.go b/dataRetriever/interface.go
@@ -268,6 +268,7 @@ type PoolsHolder interface {
 	ExecutedMiniBlocks() storage.Cacher
 	PostProcessTransactions() storage.Cacher
 	DirectSentTransactions() storage.Cacher
+	QuarantinedHeaders() storage.Cacher
 	Close() error
 	IsInterfaceNil() bool
 }
diff --git a/factory/mock/blockTrackerStub.go b/factory/mock/blockTrackerStub.go
@@ -40,6 +40,7 @@ type BlockTrackerStub struct {
 	RestoreToGenesisCalled                             func()
 	ShouldAddHeaderCalled                              func(headerHandler data.HeaderHandler) bool
 	ComputeOwnShardStuckCalled                         func(lastExecutionResultsInfo data.BaseExecutionResultHandler, currentNonce uint64)
+	IsHeaderQuarantinedCalled                          func(hash []byte) bool
 }
 
 // AddTrackedHeader -
@@ -309,6 +310,19 @@ func (bts *BlockTrackerStub) ComputeOwnShardStuck(lastExecutionResultsInfo data.
 	}
 }
 
+// IsHeaderQuarantined -
+func (bts *BlockTrackerStub) IsHeaderQuarantined(hash []byte) bool {
+	if bts.IsHeaderQuarantinedCalled != nil {
+		return bts.IsHeaderQuarantinedCalled(hash)
+	}
+	return false
+}
+
+// Close -
+func (bts *BlockTrackerStub) Close() error {
+	return nil
+}
+
 // IsInterfaceNil -
 func (bts *BlockTrackerStub) IsInterfaceNil() bool {
 	return bts == nil
diff --git a/factory/processing/processComponents.go b/factory/processing/processComponents.go
@@ -2192,6 +2192,9 @@ func (pc *processComponents) Close() error {
 	if !check.IfNil(pc.aotSelector) {
 		log.LogIfError(pc.aotSelector.Close())
 	}
+	if !check.IfNil(pc.blockTracker) {
+		log.LogIfError(pc.blockTracker.Close())
+	}
 
 	return nil
 }
diff --git a/integrationTests/mock/blockTrackerStub.go b/integrationTests/mock/blockTrackerStub.go
@@ -41,6 +41,7 @@ type BlockTrackerStub struct {
 	RestoreToGenesisCalled                             func()
 	ShouldAddHeaderCalled                              func(headerHandler data.HeaderHandler) bool
 	ComputeOwnShardStuckCalled                         func(lastExecutionResultsInfo data.BaseExecutionResultHandler, currentNonce uint64)
+	IsHeaderQuarantinedCalled                          func(hash []byte) bool
 }
 
 // AddTrackedHeader -
@@ -309,6 +310,19 @@ func (bts *BlockTrackerStub) ComputeOwnShardStuck(lastExecutionResultsInfo data.
 	}
 }
 
+// IsHeaderQuarantined -
+func (bts *BlockTrackerStub) IsHeaderQuarantined(hash []byte) bool {
+	if bts.IsHeaderQuarantinedCalled != nil {
+		return bts.IsHeaderQuarantinedCalled(hash)
+	}
+	return false
+}
+
+// Close -
+func (bts *BlockTrackerStub) Close() error {
+	return nil
+}
+
 // IsInterfaceNil -
 func (bts *BlockTrackerStub) IsInterfaceNil() bool {
 	return bts == nil
diff --git a/node/mock/blockTrackerStub.go b/node/mock/blockTrackerStub.go
@@ -40,6 +40,7 @@ type BlockTrackerStub struct {
 	ComputeOwnShardStuckCalled                         func(lastExecutionResultsInfo data.BaseExecutionResultHandler, currentNonce uint64)
 	CheckProofAgainstFinalCalled                       func(proof data.HeaderProofHandler) error
 	CheckProofAgainstRoundHandlerCalled                func(proof data.HeaderProofHandler) error
+	IsHeaderQuarantinedCalled                          func(hash []byte) bool
 }
 
 // CheckProofAgainstFinal -
@@ -307,6 +308,19 @@ func (bts *BlockTrackerStub) ComputeOwnShardStuck(lastExecutionResultsInfo data.
 	}
 }
 
+// IsHeaderQuarantined -
+func (bts *BlockTrackerStub) IsHeaderQuarantined(hash []byte) bool {
+	if bts.IsHeaderQuarantinedCalled != nil {
+		return bts.IsHeaderQuarantinedCalled(hash)
+	}
+	return false
+}
+
+// Close -
+func (bts *BlockTrackerStub) Close() error {
+	return nil
+}
+
 // IsInterfaceNil -
 func (bts *BlockTrackerStub) IsInterfaceNil() bool {
 	return bts == nil
diff --git a/process/block/errors.go b/process/block/errors.go
@@ -9,3 +9,5 @@ var errInvalidNumOutGoingTxsInMetaHdrProposal = errors.New("invalid number of ou
 var errNilPreviousHeader = errors.New("nil previous header")
 
 var errInvalidMiniBlocks = errors.New("invalid mini blocks")
+
+var errIncludedQuarantinedHeader = errors.New("included quarantined header")
diff --git a/process/block/metablockProposal.go b/process/block/metablockProposal.go
@@ -1205,6 +1205,10 @@ func (mp *metaProcessor) checkHeadersSequenceCorrectness(hdrsForShard []ShardHea
 			continue
 		}
 
+		if mp.blockTracker.IsHeaderQuarantined(shardHdrInfo.Hash) {
+			return fmt.Errorf("%w with hash %x", errIncludedQuarantinedHeader, shardHdrInfo.Hash)
+		}
+
 		err = mp.headerValidator.IsHeaderConstructionValid(shardHdrInfo.Header, lastNotarizedHeaderInfoForShard.Header)
 		if err != nil {
 			return err
diff --git a/process/block/metablockProposal_test.go b/process/block/metablockProposal_test.go
@@ -3583,6 +3583,7 @@ func TestMetaProcessor_checkHeadersSequenceCorrectness(t *testing.T) {
 					return expectedErr
 				},
 			},
+			"blockTracker": &integrationTestsMock.BlockTrackerStub{},
 		})
 		require.Nil(t, err)
 
@@ -3608,6 +3609,7 @@ func TestMetaProcessor_checkHeadersSequenceCorrectness(t *testing.T) {
 					return nil
 				},
 			},
+			"blockTracker": &integrationTestsMock.BlockTrackerStub{},
 		})
 		require.Nil(t, err)
 
diff --git a/process/block/shardblockProposal.go b/process/block/shardblockProposal.go
@@ -817,12 +817,16 @@ func (sp *shardProcessor) checkMetaHeadersValidityAndFinalityProposal(header dat
 	if err != nil {
 		return err
 	}
-	_, usedMetaHeaders, err := sp.getReferencedMetaHeadersFromPool(header)
+	usedMetaHashes, usedMetaHeaders, err := sp.getReferencedMetaHeadersFromPool(header)
 	if err != nil {
 		return fmt.Errorf("%w : checkMetaHeadersValidityAndFinalityProposal -> getReferencedMetaHeadersFromPool", err)
 	}
 
-	for _, metaHeader := range usedMetaHeaders {
+	for idx, metaHeader := range usedMetaHeaders {
+		if sp.blockTracker.IsHeaderQuarantined(usedMetaHashes[idx]) {
+			return fmt.Errorf("%w with hash %x", errIncludedQuarantinedHeader, usedMetaHashes[idx])
+		}
+
 		err = sp.headerValidator.IsHeaderConstructionValid(metaHeader, lastCrossNotarizedHeader)
 		if err != nil {
 			return fmt.Errorf("%w : checkMetaHeadersValidityAndFinalityProposal -> isHdrConstructionValid", err)
diff --git a/process/errors.go b/process/errors.go
@@ -254,6 +254,9 @@ var ErrNilMetaBlocksPool = errors.New("nil meta blocks pool")
 // ErrNilProofsPool signals that a nil proofs pool was used
 var ErrNilProofsPool = errors.New("nil proofs pool")
 
+// ErrNilQuarantinedHeadersCache signals that a nil quarantined headers cache was used
+var ErrNilQuarantinedHeadersCache = errors.New("nil quarantined headers cache")
+
 // ErrNilTxProcessor signals that a nil transactions processor was used
 var ErrNilTxProcessor = errors.New("nil transactions processor")
 
diff --git a/process/interface.go b/process/interface.go
@@ -1050,6 +1050,8 @@ type BlockTracker interface {
 	ShouldAddHeader(headerHandler data.HeaderHandler) bool
 	ComputeOwnShardStuck(lastExecutionResultsInfo data.BaseExecutionResultHandler, currentNonce uint64)
 	IsOwnShardStuck() bool
+	IsHeaderQuarantined(hash []byte) bool
+	Close() error
 	IsInterfaceNil() bool
 }
 
diff --git a/process/mock/blockTrackerHandlerMock.go b/process/mock/blockTrackerHandlerMock.go
@@ -12,6 +12,7 @@ type BlockTrackerHandlerMock struct {
 	ComputeLongestSelfChainCalled func() (data.HeaderHandler, []byte, []data.HeaderHandler, [][]byte)
 	SortHeadersFromNonceCalled    func(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)
 	AddHeaderFromPoolCalled       func(shardID uint32, nonce uint64)
+	IsHeaderQuarantinedCalled     func(hash []byte) bool
 }
 
 // GetSelfHeaders -
@@ -55,6 +56,15 @@ func (bthm *BlockTrackerHandlerMock) AddHeaderFromPool(shardID uint32, nonce uin
 	}
 }
 
+// IsHeaderQuarantined -
+func (bthm *BlockTrackerHandlerMock) IsHeaderQuarantined(hash []byte) bool {
+	if bthm.IsHeaderQuarantinedCalled != nil {
+		return bthm.IsHeaderQuarantinedCalled(hash)
+	}
+
+	return false
+}
+
 // IsInterfaceNil -
 func (bthm *BlockTrackerHandlerMock) IsInterfaceNil() bool {
 	return bthm == nil
diff --git a/process/mock/blockTrackerMock.go b/process/mock/blockTrackerMock.go
@@ -54,6 +54,7 @@ type BlockTrackerMock struct {
 	RestoreToGenesisCalled                             func()
 	ShouldAddHeaderCalled                              func(headerHandler data.HeaderHandler) bool
 	ComputeOwnShardStuckCalled                         func(lastExecutionResultsInfo data.BaseExecutionResultHandler, currentNonce uint64)
+	IsHeaderQuarantinedCalled                          func(hash []byte) bool
 
 	shardCoordinator sharding.Coordinator
 
@@ -561,6 +562,19 @@ func (btm *BlockTrackerMock) ComputeOwnShardStuck(lastExecutionResultsInfo data.
 	}
 }
 
+// IsHeaderQuarantined -
+func (btm *BlockTrackerMock) IsHeaderQuarantined(hash []byte) bool {
+	if btm.IsHeaderQuarantinedCalled != nil {
+		return btm.IsHeaderQuarantinedCalled(hash)
+	}
+	return false
+}
+
+// Close -
+func (btm *BlockTrackerMock) Close() error {
+	return nil
+}
+
 // IsInterfaceNil -
 func (btm *BlockTrackerMock) IsInterfaceNil() bool {
 	return btm == nil
diff --git a/process/track/baseBlockTrack.go b/process/track/baseBlockTrack.go
diff --git a/process/track/baseBlockTrack_test.go b/process/track/baseBlockTrack_test.go
diff --git a/process/track/blockProcessor.go b/process/track/blockProcessor.go
diff --git a/process/track/blockProcessor_test.go b/process/track/blockProcessor_test.go
diff --git a/process/track/export_test.go b/process/track/export_test.go
diff --git a/process/track/interface.go b/process/track/interface.go
diff --git a/testscommon/dataRetriever/poolFactory.go b/testscommon/dataRetriever/poolFactory.go
diff --git a/testscommon/dataRetriever/poolsHolderMock.go b/testscommon/dataRetriever/poolsHolderMock.go
diff --git a/testscommon/dataRetriever/poolsHolderStub.go b/testscommon/dataRetriever/poolsHolderStub.go
diff --git a/testscommon/generalConfig.go b/testscommon/generalConfig.go

Original file line number	Diff line number	Diff line change
`@@ -162,6 +162,12 @@ func NewDataPoolFromConfig(args ArgsDataPool) (dataRetriever.PoolsHolder, error)`
`162`	`162`	`return nil, fmt.Errorf("%w while creating the cache for the executed mini blocks", err)`
`163`	`163`	`}`
`164`	`164`
	`165`	`+ cacherCfg = factory.GetCacherFromConfig(mainConfig.QuarantinedHeadersCache)`
	`166`	`+ quarantinedHeaders, err := storageunit.NewCache(cacherCfg)`
	`167`	`+ if err != nil {`
	`168`	`+ return nil, fmt.Errorf("%w while creating the cache for the quarantined headers", err)`
	`169`	`+ }`
	`170`	`+`
`165`	`171`	`cacherCfg = factory.GetCacherFromConfig(mainConfig.PostProcessTransactionsCache)`
`166`	`172`	`postProcessTransactionsCache, err := storageunit.NewCache(cacherCfg)`
`167`	`173`	`if err != nil {`
`@@ -195,6 +201,7 @@ func NewDataPoolFromConfig(args ArgsDataPool) (dataRetriever.PoolsHolder, error)`
`195`	`201`	`ExecutedMiniBlocks: executedMiniBlocksCache,`
`196`	`202`	`PostProcessTransactions: postProcessTransactionsCache,`
`197`	`203`	`DirectSentTransactions: directSentTransactionsCache,`
	`204`	`+ QuarantinedHeaders: quarantinedHeaders,`
`198`	`205`	`}`
`199`	`206`	`return dataPool.NewDataPool(dataPoolArgs)`
`200`	`207`	`}`
Original file line number	Diff line number	Diff line change
`@@ -268,6 +268,7 @@ type PoolsHolder interface {`
`268`	`268`	`ExecutedMiniBlocks() storage.Cacher`
`269`	`269`	`PostProcessTransactions() storage.Cacher`
`270`	`270`	`DirectSentTransactions() storage.Cacher`
	`271`	`+ QuarantinedHeaders() storage.Cacher`
`271`	`272`	`Close() error`
`272`	`273`	`IsInterfaceNil() bool`
`273`	`274`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2192,6 +2192,9 @@ func (pc *processComponents) Close() error {`
`2192`	`2192`	`if !check.IfNil(pc.aotSelector) {`
`2193`	`2193`	`log.LogIfError(pc.aotSelector.Close())`
`2194`	`2194`	`}`
	`2195`	`+ if !check.IfNil(pc.blockTracker) {`
	`2196`	`+ log.LogIfError(pc.blockTracker.Close())`
	`2197`	`+ }`
`2195`	`2198`
`2196`	`2199`	`return nil`
`2197`	`2200`	`}`