diff --git a/consensus/spos/bls/v2/export_test.go b/consensus/spos/bls/v2/export_test.go index 1d7d1047526..633163c8ebc 100644 --- a/consensus/spos/bls/v2/export_test.go +++ b/consensus/spos/bls/v2/export_test.go @@ -226,11 +226,6 @@ func (sr *subroundBlock) GetLeaderForHeader(headerHandler data.HeaderHandler) ([ return sr.getLeaderForHeader(headerHandler) } -// SaveProofForPreviousHeaderIfNeeded will save proof if needed -func (sr *subroundBlock) SaveProofForPreviousHeaderIfNeeded(header data.HeaderHandler, prevHeader data.HeaderHandler) { - sr.saveProofForPreviousHeaderIfNeeded(header, prevHeader) -} - // subroundSignature // SubroundSignature defines an alias to the subroundSignature structure diff --git a/consensus/spos/bls/v2/subroundBlock.go b/consensus/spos/bls/v2/subroundBlock.go index 7110f5e1850..1a2c848c04f 100644 --- a/consensus/spos/bls/v2/subroundBlock.go +++ b/consensus/spos/bls/v2/subroundBlock.go @@ -3,7 +3,6 @@ package v2 import ( "bytes" "context" - "encoding/hex" "sync" "time" @@ -356,30 +355,6 @@ func (sr *subroundBlock) createHeader() (data.HeaderHandler, error) { return hdr, nil } -func (sr *subroundBlock) saveProofForPreviousHeaderIfNeeded(header data.HeaderHandler, prevHeader data.HeaderHandler) { - if !common.ShouldBlockHavePrevProof(header, sr.EnableEpochsHandler(), common.EquivalentMessagesFlag) { - return - } - - hasProof := sr.EquivalentProofsPool().HasProof(sr.ShardCoordinator().SelfId(), header.GetPrevHash()) - if hasProof { - log.Trace("saveProofForPreviousHeaderIfNeeded: proof already saved", "headerHash", hex.EncodeToString(header.GetPrevHash())) - return - } - - proof := header.GetPreviousProof() - err := common.VerifyProofAgainstHeader(proof, prevHeader) - if err != nil { - log.Warn("saveProofForPreviousHeaderIfNeeded: invalid proof", "error", err.Error()) - return - } - - ok := sr.EquivalentProofsPool().AddProof(proof) - if !ok { - log.Debug("saveProofForPreviousHeaderIfNeeded: proof not added", "headerHash", hex.EncodeToString(proof.GetHeaderHash())) - } -} - // receivedBlockBody method is called when a block body is received through the block body channel func (sr *subroundBlock) receivedBlockBody(ctx context.Context, cnsDta *consensus.Message) bool { node := string(cnsDta.PubKey) @@ -421,30 +396,30 @@ func (sr *subroundBlock) receivedBlockBody(ctx context.Context, cnsDta *consensu return blockProcessedWithSuccess } -func (sr *subroundBlock) isHeaderForCurrentConsensus(header data.HeaderHandler) (bool, data.HeaderHandler) { +func (sr *subroundBlock) isHeaderForCurrentConsensus(header data.HeaderHandler) bool { if check.IfNil(header) { - return false, nil + return false } if header.GetShardID() != sr.ShardCoordinator().SelfId() { - return false, nil + return false } if header.GetRound() != uint64(sr.RoundHandler().Index()) { - return false, nil + return false } prevHeader, prevHash := sr.getPrevHeaderAndHash() if check.IfNil(prevHeader) { - return false, nil + return false } if !bytes.Equal(header.GetPrevHash(), prevHash) { - return false, nil + return false } if header.GetNonce() != prevHeader.GetNonce()+1 { - return false, nil + return false } prevRandSeed := prevHeader.GetRandSeed() - return bytes.Equal(header.GetPrevRandSeed(), prevRandSeed), prevHeader + return bytes.Equal(header.GetPrevRandSeed(), prevRandSeed) } func (sr *subroundBlock) getLeaderForHeader(headerHandler data.HeaderHandler) ([]byte, error) { @@ -483,7 +458,7 @@ func (sr *subroundBlock) receivedBlockHeader(headerHandler data.HeaderHandler) { return } - isHeaderForCurrentConsensus, prevHeader := sr.isHeaderForCurrentConsensus(headerHandler) + isHeaderForCurrentConsensus := sr.isHeaderForCurrentConsensus(headerHandler) if !isHeaderForCurrentConsensus { log.Debug("subroundBlock.receivedBlockHeader - header is not for current consensus") return @@ -536,8 +511,6 @@ func (sr *subroundBlock) receivedBlockHeader(headerHandler data.HeaderHandler) { sr.SetData(headerHash) sr.SetHeader(headerHandler) - sr.saveProofForPreviousHeaderIfNeeded(headerHandler, prevHeader) - log.Debug("step 1: block header has been received", "nonce", sr.GetHeader().GetNonce(), "hash", sr.GetData()) diff --git a/consensus/spos/bls/v2/subroundBlock_test.go b/consensus/spos/bls/v2/subroundBlock_test.go index 152a9f53da6..f916dee00f3 100644 --- a/consensus/spos/bls/v2/subroundBlock_test.go +++ b/consensus/spos/bls/v2/subroundBlock_test.go @@ -1347,86 +1347,6 @@ func TestSubroundBlock_GetLeaderForHeader(t *testing.T) { }) } -func TestSubroundBlock_SaveProofForPreviousHeaderIfNeeded(t *testing.T) { - t.Parallel() - - t.Run("should not check pool if flag not activated", func(t *testing.T) { - t.Parallel() - - container := consensusMocks.InitConsensusCore() - sr := initSubroundBlock(nil, container, &statusHandler.AppStatusHandlerStub{}) - - container.SetEnableEpochsHandler(&enableEpochsHandlerMock.EnableEpochsHandlerStub{ - IsFlagEnabledInEpochCalled: func(flag core.EnableEpochFlag, epoch uint32) bool { - return flag != common.EquivalentMessagesFlag - }, - }) - - container.SetEquivalentProofsPool(&dataRetriever.ProofsPoolMock{ - HasProofCalled: func(shardID uint32, headerHash []byte) bool { - require.Fail(t, "should have not beed called") - return false - }, - }) - - sr.SaveProofForPreviousHeaderIfNeeded(&testscommon.HeaderHandlerStub{}, &testscommon.HeaderHandlerStub{}) - }) - - t.Run("should work", func(t *testing.T) { - t.Parallel() - - container := consensusMocks.InitConsensusCore() - sr := initSubroundBlock(nil, container, &statusHandler.AppStatusHandlerStub{}) - - container.SetEnableEpochsHandler(&enableEpochsHandlerMock.EnableEpochsHandlerStub{ - IsFlagEnabledInEpochCalled: func(flag core.EnableEpochFlag, epoch uint32) bool { - return flag == common.EquivalentMessagesFlag - }, - }) - - wasCalled := false - container.SetEquivalentProofsPool(&dataRetriever.ProofsPoolMock{ - HasProofCalled: func(shardID uint32, headerHash []byte) bool { - return false - }, - AddProofCalled: func(headerProof data.HeaderProofHandler) bool { - wasCalled = true - return true - }, - }) - - header := &block.HeaderV2{ - Header: &block.Header{ - Nonce: 3, - }, - PreviousHeaderProof: &block.HeaderProof{ - PubKeysBitmap: []byte("bitmap"), - AggregatedSignature: []byte("aggSig"), - HeaderHash: []byte("hash"), - HeaderEpoch: 2, - HeaderNonce: 2, - HeaderShardId: 2, - HeaderRound: 2, - IsStartOfEpoch: true, - }, - } - - prevHeader := &block.HeaderV2{ - Header: &block.Header{ - Nonce: 2, - ShardID: 2, - Round: 2, - Epoch: 2, - EpochStartMetaHash: []byte("epoch start meta hash"), - }, - } - - sr.SaveProofForPreviousHeaderIfNeeded(header, prevHeader) - - require.True(t, wasCalled) - }) -} - func TestSubroundBlock_IsInterfaceNil(t *testing.T) { t.Parallel() diff --git a/dataRetriever/dataPool/proofsCache/proofsPool.go b/dataRetriever/dataPool/proofsCache/proofsPool.go index c53e6d70b9c..86350ee1589 100644 --- a/dataRetriever/dataPool/proofsCache/proofsPool.go +++ b/dataRetriever/dataPool/proofsCache/proofsPool.go @@ -1,6 +1,7 @@ package proofscache import ( + "bytes" "fmt" "sync" @@ -43,22 +44,40 @@ func NewProofsPool(cleanupNonceDelta uint64, bucketSize int) *proofsPool { } } -// AddProof will add the provided proof to the pool -func (pp *proofsPool) AddProof( +// UpsertProof will add the provided proof to the pool. If there is already an existing proof, +// it will overwrite it. +func (pp *proofsPool) UpsertProof( headerProof data.HeaderProofHandler, ) bool { if check.IfNil(headerProof) { return false } - shardID := headerProof.GetHeaderShardId() - headerHash := headerProof.GetHeaderHash() + return pp.addProof(headerProof) +} + +// AddProof will add the provided proof to the pool, if it's not already in the pool. +// It will return true if the proof was added to the pool. +func (pp *proofsPool) AddProof( + headerProof data.HeaderProofHandler, +) bool { + if check.IfNil(headerProof) { + return false + } - hasProof := pp.HasProof(shardID, headerHash) + hasProof := pp.HasProof(headerProof.GetHeaderShardId(), headerProof.GetHeaderHash()) if hasProof { return false } + return pp.addProof(headerProof) +} + +func (pp *proofsPool) addProof( + headerProof data.HeaderProofHandler, +) bool { + shardID := headerProof.GetHeaderShardId() + pp.mutCache.Lock() proofsPerShard, ok := pp.cache[shardID] if !ok { @@ -85,6 +104,27 @@ func (pp *proofsPool) AddProof( return true } +// IsProofInPoolEqualTo will check if the provided proof is equal with the already existing proof in the pool +func (pp *proofsPool) IsProofInPoolEqualTo(headerProof data.HeaderProofHandler) bool { + if check.IfNil(headerProof) { + return false + } + + existingProof, err := pp.GetProof(headerProof.GetHeaderShardId(), headerProof.GetHeaderHash()) + if err != nil { + return false + } + + if !bytes.Equal(existingProof.GetAggregatedSignature(), headerProof.GetAggregatedSignature()) { + return false + } + if !bytes.Equal(existingProof.GetPubKeysBitmap(), headerProof.GetPubKeysBitmap()) { + return false + } + + return true +} + func (pp *proofsPool) callAddedProofSubscribers(headerProof data.HeaderProofHandler) { pp.mutAddedProofSubscribers.RLock() defer pp.mutAddedProofSubscribers.RUnlock() diff --git a/dataRetriever/dataPool/proofsCache/proofsPool_test.go b/dataRetriever/dataPool/proofsCache/proofsPool_test.go index 92be9475725..e9d25182a70 100644 --- a/dataRetriever/dataPool/proofsCache/proofsPool_test.go +++ b/dataRetriever/dataPool/proofsCache/proofsPool_test.go @@ -66,12 +66,15 @@ func TestProofsPool_ShouldWork(t *testing.T) { pp := proofscache.NewProofsPool(cleanupDelta, bucketSize) + ok := pp.AddProof(nil) + require.False(t, ok) + _ = pp.AddProof(proof1) _ = pp.AddProof(proof2) _ = pp.AddProof(proof3) _ = pp.AddProof(proof4) - ok := pp.AddProof(proof4) + ok = pp.AddProof(proof4) require.False(t, ok) proof, err := pp.GetProof(shardID, []byte("hash3")) @@ -90,6 +93,99 @@ func TestProofsPool_ShouldWork(t *testing.T) { require.Equal(t, proof4, proof) } +func TestProofsPool_Upsert(t *testing.T) { + t.Parallel() + + pp := proofscache.NewProofsPool(cleanupDelta, bucketSize) + + ok := pp.UpsertProof(nil) + require.False(t, ok) + + ok = pp.UpsertProof(proof1) + require.True(t, ok) + + proof, err := pp.GetProof(shardID, []byte("hash1")) + require.Nil(t, err) + require.NotNil(t, proof) + + require.Equal(t, proof1.GetAggregatedSignature(), proof.GetAggregatedSignature()) + require.Equal(t, proof1.GetPubKeysBitmap(), proof.GetPubKeysBitmap()) + + newProof1 := &block.HeaderProof{ + PubKeysBitmap: []byte("newpubKeysBitmap1"), + AggregatedSignature: []byte("newaggSig1"), + HeaderHash: []byte("hash1"), + HeaderEpoch: 1, + HeaderNonce: 1, + HeaderShardId: shardID, + } + + ok = pp.UpsertProof(newProof1) + require.True(t, ok) + + proof, err = pp.GetProof(shardID, []byte("hash1")) + require.Nil(t, err) + require.NotNil(t, proof) + + require.Equal(t, newProof1.GetAggregatedSignature(), proof.GetAggregatedSignature()) + require.Equal(t, newProof1.GetPubKeysBitmap(), proof.GetPubKeysBitmap()) +} + +func TestProofsPool_IsProofEqual(t *testing.T) { + t.Parallel() + + t.Run("not existing proof, should fail", func(t *testing.T) { + t.Parallel() + + pp := proofscache.NewProofsPool(cleanupDelta, bucketSize) + + ok := pp.IsProofInPoolEqualTo(proof1) + require.False(t, ok) + }) + + t.Run("nil provided proof, should fail", func(t *testing.T) { + t.Parallel() + + pp := proofscache.NewProofsPool(cleanupDelta, bucketSize) + + ok := pp.IsProofInPoolEqualTo(nil) + require.False(t, ok) + }) + + t.Run("same proof, should return true", func(t *testing.T) { + t.Parallel() + + pp := proofscache.NewProofsPool(cleanupDelta, bucketSize) + + ok := pp.UpsertProof(proof1) + require.True(t, ok) + + ok = pp.IsProofInPoolEqualTo(proof1) + require.True(t, ok) + }) + + t.Run("not equal, should return false", func(t *testing.T) { + t.Parallel() + + pp := proofscache.NewProofsPool(cleanupDelta, bucketSize) + + ok := pp.UpsertProof(proof1) + require.True(t, ok) + + newProof1 := &block.HeaderProof{ + PubKeysBitmap: []byte("newpubKeysBitmap1"), + AggregatedSignature: []byte("newaggSig1"), + HeaderHash: []byte("hash1"), + HeaderEpoch: 1, + HeaderNonce: 1, + HeaderShardId: shardID, + } + + ok = pp.IsProofInPoolEqualTo(newProof1) + require.False(t, ok) + }) +} + func TestProofsPool_RegisterHandler(t *testing.T) { t.Parallel() diff --git a/dataRetriever/interface.go b/dataRetriever/interface.go index ec833525195..db62694d962 100644 --- a/dataRetriever/interface.go +++ b/dataRetriever/interface.go @@ -363,9 +363,11 @@ type PeerAuthenticationPayloadValidator interface { // ProofsPool defines the behaviour of a proofs pool components type ProofsPool interface { AddProof(headerProof data.HeaderProofHandler) bool + UpsertProof(headerProof data.HeaderProofHandler) bool RegisterHandler(handler func(headerProof data.HeaderProofHandler)) CleanupProofsBehindNonce(shardID uint32, nonce uint64) error GetProof(shardID uint32, headerHash []byte) (data.HeaderProofHandler, error) HasProof(shardID uint32, headerHash []byte) bool + IsProofInPoolEqualTo(headerProof data.HeaderProofHandler) bool IsInterfaceNil() bool } diff --git a/epochStart/bootstrap/process.go b/epochStart/bootstrap/process.go index 91d40db1a8d..a17c74980db 100644 --- a/epochStart/bootstrap/process.go +++ b/epochStart/bootstrap/process.go @@ -574,6 +574,7 @@ func (e *epochStartBootstrap) prepareComponentsToSyncFromNetwork() error { HeaderIntegrityVerifier: e.headerIntegrityVerifier, MetaBlockProcessor: metaBlockProcessor, InterceptedDataVerifierFactory: e.interceptedDataVerifierFactory, + ProofsPool: e.dataPool.Proofs(), } e.epochStartMetaBlockSyncer, err = NewEpochStartMetaSyncer(argsEpochStartSyncer) if err != nil { diff --git a/epochStart/bootstrap/storageProcess.go b/epochStart/bootstrap/storageProcess.go index 0ec16f6548d..8cd6f055c6e 100644 --- a/epochStart/bootstrap/storageProcess.go +++ b/epochStart/bootstrap/storageProcess.go @@ -189,6 +189,7 @@ func (sesb *storageEpochStartBootstrap) prepareComponentsToSync() error { HeaderIntegrityVerifier: sesb.headerIntegrityVerifier, MetaBlockProcessor: metablockProcessor, InterceptedDataVerifierFactory: sesb.interceptedDataVerifierFactory, + ProofsPool: sesb.dataPool.Proofs(), } sesb.epochStartMetaBlockSyncer, err = NewEpochStartMetaSyncer(argsEpochStartSyncer) diff --git a/epochStart/bootstrap/syncEpochStartMeta.go b/epochStart/bootstrap/syncEpochStartMeta.go index b550a25911a..416fe17fea0 100644 --- a/epochStart/bootstrap/syncEpochStartMeta.go +++ b/epochStart/bootstrap/syncEpochStartMeta.go @@ -11,6 +11,7 @@ import ( "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/dataRetriever" "github.com/multiversx/mx-chain-go/epochStart" "github.com/multiversx/mx-chain-go/epochStart/bootstrap/disabled" "github.com/multiversx/mx-chain-go/process" @@ -46,6 +47,7 @@ type ArgsNewEpochStartMetaSyncer struct { HeaderIntegrityVerifier process.HeaderIntegrityVerifier MetaBlockProcessor EpochStartMetaBlockInterceptorProcessor InterceptedDataVerifierFactory process.InterceptedDataVerifierFactory + ProofsPool dataRetriever.ProofsPool } // NewEpochStartMetaSyncer will return a new instance of epochStartMetaSyncer @@ -90,8 +92,12 @@ func NewEpochStartMetaSyncer(args ArgsNewEpochStartMetaSyncer) (*epochStartMetaS EpochStartTrigger: disabled.NewEpochStartTrigger(), ArgsParser: args.ArgsParser, } + argsInterceptedMetaHeaderFactory := interceptorsFactory.ArgInterceptedMetaHeaderFactory{ + ArgInterceptedDataFactory: argsInterceptedDataFactory, + ProofsPool: args.ProofsPool, + } - interceptedMetaHdrDataFactory, err := interceptorsFactory.NewInterceptedMetaHeaderDataFactory(&argsInterceptedDataFactory) + interceptedMetaHdrDataFactory, err := interceptorsFactory.NewInterceptedMetaHeaderDataFactory(&argsInterceptedMetaHeaderFactory) if err != nil { return nil, err } diff --git a/epochStart/bootstrap/syncEpochStartMeta_test.go b/epochStart/bootstrap/syncEpochStartMeta_test.go index 6eea8336ab7..3af947a6b50 100644 --- a/epochStart/bootstrap/syncEpochStartMeta_test.go +++ b/epochStart/bootstrap/syncEpochStartMeta_test.go @@ -19,6 +19,7 @@ import ( processMock "github.com/multiversx/mx-chain-go/process/mock" "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/cryptoMocks" + "github.com/multiversx/mx-chain-go/testscommon/dataRetriever" "github.com/multiversx/mx-chain-go/testscommon/economicsmocks" "github.com/multiversx/mx-chain-go/testscommon/hashingMocks" "github.com/multiversx/mx-chain-go/testscommon/p2pmocks" @@ -171,5 +172,6 @@ func getEpochStartSyncerArgs() ArgsNewEpochStartMetaSyncer { HeaderIntegrityVerifier: &mock.HeaderIntegrityVerifierStub{}, MetaBlockProcessor: &mock.EpochStartMetaBlockProcessorStub{}, InterceptedDataVerifierFactory: &processMock.InterceptedDataVerifierFactoryMock{}, + ProofsPool: &dataRetriever.ProofsPoolMock{}, } } diff --git a/process/block/interceptedBlocks/argInterceptedBlockHeader.go b/process/block/interceptedBlocks/argInterceptedBlockHeader.go index 7e493d8b311..b29d7640278 100644 --- a/process/block/interceptedBlocks/argInterceptedBlockHeader.go +++ b/process/block/interceptedBlocks/argInterceptedBlockHeader.go @@ -19,4 +19,5 @@ type ArgInterceptedBlockHeader struct { ValidityAttester process.ValidityAttester EpochStartTrigger process.EpochStartTriggerHandler EnableEpochsHandler common.EnableEpochsHandler + ProofsPool process.ProofsPool } diff --git a/process/block/interceptedBlocks/common.go b/process/block/interceptedBlocks/common.go index 8c18a9cb6d6..420b76ec47d 100644 --- a/process/block/interceptedBlocks/common.go +++ b/process/block/interceptedBlocks/common.go @@ -1,8 +1,6 @@ package interceptedBlocks import ( - "sync" - "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" @@ -125,16 +123,12 @@ func checkMetaShardInfo( shardInfo []data.ShardDataHandler, coordinator sharding.Coordinator, headerSigVerifier process.InterceptedHeaderSigVerifier, + proofs process.ProofsPool, ) error { if coordinator.SelfId() != core.MetachainShardId { return nil } - wgProofsVerification := sync.WaitGroup{} - - errChan := make(chan error, len(shardInfo)) - defer close(errChan) - for _, sd := range shardInfo { if sd.GetShardID() >= coordinator.NumberOfShards() && sd.GetShardID() != core.MetachainShardId { return process.ErrInvalidShardId @@ -145,38 +139,18 @@ func checkMetaShardInfo( return err } - wgProofsVerification.Add(1) - checkProofAsync(sd.GetPreviousProof(), headerSigVerifier, &wgProofsVerification, errChan) - } - - wgProofsVerification.Wait() - - return readFromChanNonBlocking(errChan) -} + if proofs.IsProofInPoolEqualTo(sd.GetPreviousProof()) { + continue + } -func readFromChanNonBlocking(errChan chan error) error { - select { - case err := <-errChan: - return err - default: - return nil - } -} + err = checkProof(sd.GetPreviousProof(), headerSigVerifier) + if err != nil { + return err -func checkProofAsync( - proof data.HeaderProofHandler, - headerSigVerifier process.InterceptedHeaderSigVerifier, - wg *sync.WaitGroup, - errChan chan error, -) { - go func(proof data.HeaderProofHandler) { - errCheckProof := checkProof(proof, headerSigVerifier) - if errCheckProof != nil { - errChan <- errCheckProof } + } - wg.Done() - }(proof) + return nil } func checkProof(proof data.HeaderProofHandler, headerSigVerifier process.InterceptedHeaderSigVerifier) error { diff --git a/process/block/interceptedBlocks/common_test.go b/process/block/interceptedBlocks/common_test.go index bbf9296af6a..412c3445dfd 100644 --- a/process/block/interceptedBlocks/common_test.go +++ b/process/block/interceptedBlocks/common_test.go @@ -13,6 +13,7 @@ import ( "github.com/multiversx/mx-chain-go/process/mock" "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/consensus" + "github.com/multiversx/mx-chain-go/testscommon/dataRetriever" "github.com/multiversx/mx-chain-go/testscommon/enableEpochsHandlerMock" "github.com/multiversx/mx-chain-go/testscommon/hashingMocks" "github.com/stretchr/testify/assert" @@ -384,8 +385,8 @@ func TestCheckMetaShardInfo_WithNilOrEmptyShouldReturnNil(t *testing.T) { shardCoordinator := mock.NewOneShardCoordinatorMock() - err1 := checkMetaShardInfo(nil, shardCoordinator, &consensus.HeaderSigVerifierMock{}) - err2 := checkMetaShardInfo(make([]data.ShardDataHandler, 0), shardCoordinator, &consensus.HeaderSigVerifierMock{}) + err1 := checkMetaShardInfo(nil, shardCoordinator, &consensus.HeaderSigVerifierMock{}, &dataRetriever.ProofsPoolMock{}) + err2 := checkMetaShardInfo(make([]data.ShardDataHandler, 0), shardCoordinator, &consensus.HeaderSigVerifierMock{}, &dataRetriever.ProofsPoolMock{}) assert.Nil(t, err1) assert.Nil(t, err2) @@ -407,7 +408,7 @@ func TestCheckMetaShardInfo_ShouldNotCheckShardInfoForShards(t *testing.T) { }, } - err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, verifier) + err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, verifier, &dataRetriever.ProofsPoolMock{}) assert.Nil(t, err) assert.False(t, wasCalled) @@ -426,7 +427,7 @@ func TestCheckMetaShardInfo_WrongShardIdShouldErr(t *testing.T) { TxCount: 0, } - err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}) + err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}, &dataRetriever.ProofsPoolMock{}) assert.Equal(t, process.ErrInvalidShardId, err) } @@ -451,7 +452,7 @@ func TestCheckMetaShardInfo_WrongMiniblockSenderShardIdShouldErr(t *testing.T) { TxCount: 0, } - err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}) + err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}, &dataRetriever.ProofsPoolMock{}) assert.Equal(t, process.ErrInvalidShardId, err) } @@ -476,7 +477,7 @@ func TestCheckMetaShardInfo_WrongMiniblockReceiverShardIdShouldErr(t *testing.T) TxCount: 0, } - err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}) + err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}, &dataRetriever.ProofsPoolMock{}) assert.Equal(t, process.ErrInvalidShardId, err) } @@ -502,7 +503,7 @@ func TestCheckMetaShardInfo_ReservedPopulatedShouldErr(t *testing.T) { TxCount: 0, } - err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}) + err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}, &dataRetriever.ProofsPoolMock{}) assert.Equal(t, process.ErrReservedFieldInvalid, err) } @@ -526,12 +527,12 @@ func TestCheckMetaShardInfo_OkValsShouldWork(t *testing.T) { TxCount: 0, } - err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}) + err := checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}, &dataRetriever.ProofsPoolMock{}) assert.Nil(t, err) miniBlock.Reserved = []byte("r") sd.ShardMiniBlockHeaders = []block.MiniBlockHeader{miniBlock} - err = checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}) + err = checkMetaShardInfo([]data.ShardDataHandler{&sd}, shardCoordinator, &consensus.HeaderSigVerifierMock{}, &dataRetriever.ProofsPoolMock{}) assert.Nil(t, err) } @@ -580,6 +581,7 @@ func TestCheckMetaShardInfo_WithMultipleShardData(t *testing.T) { []data.ShardDataHandler{sd1, sd2}, shardCoordinator, &consensus.HeaderSigVerifierMock{}, + &dataRetriever.ProofsPoolMock{}, ) assert.Equal(t, process.ErrInvalidShardId, err) @@ -631,6 +633,7 @@ func TestCheckMetaShardInfo_WithMultipleShardData(t *testing.T) { []data.ShardDataHandler{sd1, sd2}, shardCoordinator, &consensus.HeaderSigVerifierMock{}, + &dataRetriever.ProofsPoolMock{}, ) assert.Equal(t, process.ErrInvalidHeaderProof, err) @@ -681,7 +684,7 @@ func TestCheckMetaShardInfo_FewShardDataErrorShouldReturnError(t *testing.T) { } } - err := checkMetaShardInfo(shardData, shardCoordinator, sigVerifier) + err := checkMetaShardInfo(shardData, shardCoordinator, sigVerifier, &dataRetriever.ProofsPoolMock{}) assert.Equal(t, providedRandomError, err) } diff --git a/process/block/interceptedBlocks/interceptedMetaBlockHeader.go b/process/block/interceptedBlocks/interceptedMetaBlockHeader.go index dee6028a3b2..c2273b1f57e 100644 --- a/process/block/interceptedBlocks/interceptedMetaBlockHeader.go +++ b/process/block/interceptedBlocks/interceptedMetaBlockHeader.go @@ -31,6 +31,7 @@ type InterceptedMetaHeader struct { validityAttester process.ValidityAttester epochStartTrigger process.EpochStartTriggerHandler enableEpochsHandler common.EnableEpochsHandler + proofsPool process.ProofsPool } // NewInterceptedMetaHeader creates a new instance of InterceptedMetaHeader struct @@ -54,6 +55,7 @@ func NewInterceptedMetaHeader(arg *ArgInterceptedBlockHeader) (*InterceptedMetaH validityAttester: arg.ValidityAttester, epochStartTrigger: arg.EpochStartTrigger, enableEpochsHandler: arg.EnableEpochsHandler, + proofsPool: arg.ProofsPool, } inHdr.processFields(arg.HdrBuff) @@ -168,7 +170,7 @@ func (imh *InterceptedMetaHeader) integrity() error { return err } - err = checkMetaShardInfo(imh.hdr.GetShardInfoHandlers(), imh.shardCoordinator, imh.sigVerifier) + err = checkMetaShardInfo(imh.hdr.GetShardInfoHandlers(), imh.shardCoordinator, imh.sigVerifier, imh.proofsPool) if err != nil { return err } diff --git a/process/factory/interceptorscontainer/baseInterceptorsContainerFactory.go b/process/factory/interceptorscontainer/baseInterceptorsContainerFactory.go index cb4e73e7dc3..4e10a59b775 100644 --- a/process/factory/interceptorscontainer/baseInterceptorsContainerFactory.go +++ b/process/factory/interceptorscontainer/baseInterceptorsContainerFactory.go @@ -566,7 +566,11 @@ func (bicf *baseInterceptorsContainerFactory) createOneMiniBlocksInterceptor(top func (bicf *baseInterceptorsContainerFactory) generateMetachainHeaderInterceptors() error { identifierHdr := factory.MetachainBlocksTopic - hdrFactory, err := interceptorFactory.NewInterceptedMetaHeaderDataFactory(bicf.argInterceptorFactory) + argsInterceptedMetaHeaderFactory := interceptorFactory.ArgInterceptedMetaHeaderFactory{ + ArgInterceptedDataFactory: *bicf.argInterceptorFactory, + ProofsPool: bicf.dataPool.Proofs(), + } + hdrFactory, err := interceptorFactory.NewInterceptedMetaHeaderDataFactory(&argsInterceptedMetaHeaderFactory) if err != nil { return err } diff --git a/process/headerCheck/headerSignatureVerify.go b/process/headerCheck/headerSignatureVerify.go index b44b0a34627..1d16f6165ea 100644 --- a/process/headerCheck/headerSignatureVerify.go +++ b/process/headerCheck/headerSignatureVerify.go @@ -340,7 +340,7 @@ func (hsv *HeaderSigVerifier) VerifyHeaderWithProof(header data.HeaderHandler) e return err } - _ = hsv.proofsPool.AddProof(prevProof) + _ = hsv.proofsPool.UpsertProof(prevProof) return nil } @@ -349,7 +349,7 @@ func (hsv *HeaderSigVerifier) VerifyHeaderWithProof(header data.HeaderHandler) e return err } - _ = hsv.proofsPool.AddProof(prevProof) + _ = hsv.proofsPool.UpsertProof(prevProof) return nil } diff --git a/process/headerCheck/headerSignatureVerify_test.go b/process/headerCheck/headerSignatureVerify_test.go index 1e2810352d2..264c364de6c 100644 --- a/process/headerCheck/headerSignatureVerify_test.go +++ b/process/headerCheck/headerSignatureVerify_test.go @@ -1325,7 +1325,7 @@ func TestHeaderSigVerifier_VerifyHeaderWithProof(t *testing.T) { } wasAddProofCalled := false args.ProofsPool = &dataRetrieverMocks.ProofsPoolMock{ - AddProofCalled: func(headerProof data.HeaderProofHandler) bool { + UpsertProofCalled: func(headerProof data.HeaderProofHandler) bool { wasAddProofCalled = true return true }, @@ -1418,7 +1418,7 @@ func TestHeaderSigVerifier_VerifyHeaderWithProof(t *testing.T) { } wasAddProofCalled := false args.ProofsPool = &dataRetrieverMocks.ProofsPoolMock{ - AddProofCalled: func(headerProof data.HeaderProofHandler) bool { + UpsertProofCalled: func(headerProof data.HeaderProofHandler) bool { wasAddProofCalled = true return true }, diff --git a/process/interceptors/factory/interceptedMetaHeaderDataFactory.go b/process/interceptors/factory/interceptedMetaHeaderDataFactory.go index 54c66ad687c..57b03210498 100644 --- a/process/interceptors/factory/interceptedMetaHeaderDataFactory.go +++ b/process/interceptors/factory/interceptedMetaHeaderDataFactory.go @@ -12,6 +12,12 @@ import ( var _ process.InterceptedDataFactory = (*interceptedMetaHeaderDataFactory)(nil) +// ArgInterceptedMetaHeaderFactory is the DTO used to create a new instance of meta header factory +type ArgInterceptedMetaHeaderFactory struct { + ArgInterceptedDataFactory + ProofsPool process.ProofsPool +} + type interceptedMetaHeaderDataFactory struct { marshalizer marshal.Marshalizer hasher hashing.Hasher @@ -21,10 +27,11 @@ type interceptedMetaHeaderDataFactory struct { validityAttester process.ValidityAttester epochStartTrigger process.EpochStartTriggerHandler enableEpochsHandler common.EnableEpochsHandler + proofsPool process.ProofsPool } // NewInterceptedMetaHeaderDataFactory creates an instance of interceptedMetaHeaderDataFactory -func NewInterceptedMetaHeaderDataFactory(argument *ArgInterceptedDataFactory) (*interceptedMetaHeaderDataFactory, error) { +func NewInterceptedMetaHeaderDataFactory(argument *ArgInterceptedMetaHeaderFactory) (*interceptedMetaHeaderDataFactory, error) { if argument == nil { return nil, process.ErrNilArgumentStruct } @@ -58,6 +65,9 @@ func NewInterceptedMetaHeaderDataFactory(argument *ArgInterceptedDataFactory) (* if check.IfNil(argument.ValidityAttester) { return nil, process.ErrNilValidityAttester } + if check.IfNil(argument.ProofsPool) { + return nil, process.ErrNilProofsPool + } return &interceptedMetaHeaderDataFactory{ marshalizer: argument.CoreComponents.InternalMarshalizer(), @@ -68,6 +78,7 @@ func NewInterceptedMetaHeaderDataFactory(argument *ArgInterceptedDataFactory) (* validityAttester: argument.ValidityAttester, epochStartTrigger: argument.EpochStartTrigger, enableEpochsHandler: argument.CoreComponents.EnableEpochsHandler(), + proofsPool: argument.ProofsPool, }, nil } @@ -83,6 +94,7 @@ func (imhdf *interceptedMetaHeaderDataFactory) Create(buff []byte) (process.Inte ValidityAttester: imhdf.validityAttester, EpochStartTrigger: imhdf.epochStartTrigger, EnableEpochsHandler: imhdf.enableEpochsHandler, + ProofsPool: imhdf.proofsPool, } return interceptedBlocks.NewInterceptedMetaHeader(arg) diff --git a/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go b/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go index bb5582fd7a2..5d2dc74055c 100644 --- a/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go +++ b/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go @@ -17,6 +17,7 @@ import ( "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/consensus" "github.com/multiversx/mx-chain-go/testscommon/cryptoMocks" + "github.com/multiversx/mx-chain-go/testscommon/dataRetriever" "github.com/multiversx/mx-chain-go/testscommon/economicsmocks" "github.com/multiversx/mx-chain-go/testscommon/enableEpochsHandlerMock" "github.com/multiversx/mx-chain-go/testscommon/epochNotifier" @@ -87,6 +88,32 @@ func createMockComponentHolders() (*mock.CoreComponentsMock, *mock.CryptoCompone return coreComponents, cryptoComponents } +func createMockArgMetaHeaderFactoryArgument( + coreComponents *mock.CoreComponentsMock, + cryptoComponents *mock.CryptoComponentsMock, +) *ArgInterceptedMetaHeaderFactory { + return &ArgInterceptedMetaHeaderFactory{ + ArgInterceptedDataFactory: ArgInterceptedDataFactory{ + CoreComponents: coreComponents, + CryptoComponents: cryptoComponents, + ShardCoordinator: mock.NewOneShardCoordinatorMock(), + NodesCoordinator: shardingMocks.NewNodesCoordinatorMock(), + FeeHandler: createMockFeeHandler(), + WhiteListerVerifiedTxs: &testscommon.WhiteListHandlerStub{}, + HeaderSigVerifier: &consensus.HeaderSigVerifierMock{}, + ValidityAttester: &mock.ValidityAttesterStub{}, + HeaderIntegrityVerifier: &mock.HeaderIntegrityVerifierStub{}, + EpochStartTrigger: &mock.EpochStartTriggerStub{}, + ArgsParser: &testscommon.ArgumentParserMock{}, + PeerSignatureHandler: &processMocks.PeerSignatureHandlerStub{}, + SignaturesHandler: &processMocks.SignaturesHandlerStub{}, + HeartbeatExpiryTimespanInSec: 30, + PeerID: "pid", + }, + ProofsPool: &dataRetriever.ProofsPoolMock{}, + } +} + func createMockArgument( coreComponents *mock.CoreComponentsMock, cryptoComponents *mock.CryptoComponentsMock, @@ -124,7 +151,7 @@ func TestNewInterceptedMetaHeaderDataFactory_NilMarshalizerShouldErr(t *testing. coreComp, cryptoComp := createMockComponentHolders() coreComp.IntMarsh = nil - arg := createMockArgument(coreComp, cryptoComp) + arg := createMockArgMetaHeaderFactoryArgument(coreComp, cryptoComp) imh, err := NewInterceptedMetaHeaderDataFactory(arg) assert.Nil(t, imh) @@ -136,7 +163,7 @@ func TestNewInterceptedMetaHeaderDataFactory_NilSignMarshalizerShouldErr(t *test coreComp, cryptoComp := createMockComponentHolders() coreComp.TxMarsh = nil - arg := createMockArgument(coreComp, cryptoComp) + arg := createMockArgMetaHeaderFactoryArgument(coreComp, cryptoComp) imh, err := NewInterceptedMetaHeaderDataFactory(arg) assert.True(t, check.IfNil(imh)) @@ -148,7 +175,7 @@ func TestNewInterceptedMetaHeaderDataFactory_NilHasherShouldErr(t *testing.T) { coreComp, cryptoComp := createMockComponentHolders() coreComp.Hash = nil - arg := createMockArgument(coreComp, cryptoComp) + arg := createMockArgMetaHeaderFactoryArgument(coreComp, cryptoComp) imh, err := NewInterceptedMetaHeaderDataFactory(arg) assert.True(t, check.IfNil(imh)) @@ -158,7 +185,7 @@ func TestNewInterceptedMetaHeaderDataFactory_NilHasherShouldErr(t *testing.T) { func TestNewInterceptedMetaHeaderDataFactory_NilHeaderSigVerifierShouldErr(t *testing.T) { t.Parallel() coreComp, cryptoComp := createMockComponentHolders() - arg := createMockArgument(coreComp, cryptoComp) + arg := createMockArgMetaHeaderFactoryArgument(coreComp, cryptoComp) arg.HeaderSigVerifier = nil imh, err := NewInterceptedMetaHeaderDataFactory(arg) @@ -170,7 +197,7 @@ func TestNewInterceptedMetaHeaderDataFactory_NilHeaderIntegrityVerifierShouldErr t.Parallel() coreComp, cryptoComp := createMockComponentHolders() - arg := createMockArgument(coreComp, cryptoComp) + arg := createMockArgMetaHeaderFactoryArgument(coreComp, cryptoComp) arg.HeaderIntegrityVerifier = nil imh, err := NewInterceptedMetaHeaderDataFactory(arg) @@ -182,7 +209,7 @@ func TestNewInterceptedMetaHeaderDataFactory_NilShardCoordinatorShouldErr(t *tes t.Parallel() coreComp, cryptoComp := createMockComponentHolders() - arg := createMockArgument(coreComp, cryptoComp) + arg := createMockArgMetaHeaderFactoryArgument(coreComp, cryptoComp) arg.ShardCoordinator = nil imh, err := NewInterceptedMetaHeaderDataFactory(arg) @@ -197,7 +224,7 @@ func TestNewInterceptedMetaHeaderDataFactory_NilChainIdShouldErr(t *testing.T) { coreComp.ChainIdCalled = func() string { return "" } - arg := createMockArgument(coreComp, cryptoComp) + arg := createMockArgMetaHeaderFactoryArgument(coreComp, cryptoComp) imh, err := NewInterceptedMetaHeaderDataFactory(arg) assert.True(t, check.IfNil(imh)) @@ -208,7 +235,7 @@ func TestNewInterceptedMetaHeaderDataFactory_NilValidityAttesterShouldErr(t *tes t.Parallel() coreComp, cryptoComp := createMockComponentHolders() - arg := createMockArgument(coreComp, cryptoComp) + arg := createMockArgMetaHeaderFactoryArgument(coreComp, cryptoComp) arg.ValidityAttester = nil imh, err := NewInterceptedMetaHeaderDataFactory(arg) @@ -220,7 +247,7 @@ func TestNewInterceptedMetaHeaderDataFactory_ShouldWorkAndCreate(t *testing.T) { t.Parallel() coreComp, cryptoComp := createMockComponentHolders() - arg := createMockArgument(coreComp, cryptoComp) + arg := createMockArgMetaHeaderFactoryArgument(coreComp, cryptoComp) imh, err := NewInterceptedMetaHeaderDataFactory(arg) assert.False(t, check.IfNil(imh)) diff --git a/process/interceptors/processor/hdrInterceptorProcessor.go b/process/interceptors/processor/hdrInterceptorProcessor.go index 22950e91785..524153a136a 100644 --- a/process/interceptors/processor/hdrInterceptorProcessor.go +++ b/process/interceptors/processor/hdrInterceptorProcessor.go @@ -80,11 +80,6 @@ func (hip *HdrInterceptorProcessor) Save(data process.InterceptedData, _ core.Pe hip.headers.AddHeader(interceptedHdr.Hash(), interceptedHdr.HeaderHandler()) - if common.ShouldBlockHavePrevProof(interceptedHdr.HeaderHandler(), hip.enableEpochsHandler, common.EquivalentMessagesFlag) { - ok = hip.proofs.AddProof(interceptedHdr.HeaderHandler().GetPreviousProof()) - log.Trace("HdrInterceptorProcessor.AddProof: add previous proof", "intercepted header hash", interceptedHdr.Hash(), "added", ok) - } - return nil } diff --git a/process/interceptors/processor/hdrInterceptorProcessor_test.go b/process/interceptors/processor/hdrInterceptorProcessor_test.go index 1dd904b38f7..bfac05fc4ab 100644 --- a/process/interceptors/processor/hdrInterceptorProcessor_test.go +++ b/process/interceptors/processor/hdrInterceptorProcessor_test.go @@ -205,14 +205,6 @@ func TestHdrInterceptorProcessor_SaveShouldWork(t *testing.T) { }, } - wasAddedProofs := false - arg.Proofs = &dataRetriever.ProofsPoolMock{ - AddProofCalled: func(headerProof data.HeaderProofHandler) bool { - wasAddedProofs = true - return true - }, - } - hip, _ := processor.NewHdrInterceptorProcessor(arg) chanCalled := make(chan struct{}, 1) hip.RegisterHandler(func(topic string, hash []byte, data interface{}) { @@ -223,7 +215,6 @@ func TestHdrInterceptorProcessor_SaveShouldWork(t *testing.T) { assert.Nil(t, err) assert.True(t, wasAddedHeaders) - assert.True(t, wasAddedProofs) timeout := time.Second * 2 select { diff --git a/process/interface.go b/process/interface.go index 3677184e9a6..7d6e9353a98 100644 --- a/process/interface.go +++ b/process/interface.go @@ -1430,5 +1430,6 @@ type InterceptedDataVerifierFactory interface { // ProofsPool defines the behaviour of a proofs pool components type ProofsPool interface { HasProof(shardID uint32, headerHash []byte) bool + IsProofInPoolEqualTo(headerProof data.HeaderProofHandler) bool IsInterfaceNil() bool } diff --git a/testscommon/dataRetriever/proofsPoolMock.go b/testscommon/dataRetriever/proofsPoolMock.go index 7461f28abef..a27c215a680 100644 --- a/testscommon/dataRetriever/proofsPoolMock.go +++ b/testscommon/dataRetriever/proofsPoolMock.go @@ -8,9 +8,11 @@ import ( // ProofsPoolMock - type ProofsPoolMock struct { AddProofCalled func(headerProof data.HeaderProofHandler) bool + UpsertProofCalled func(headerProof data.HeaderProofHandler) bool CleanupProofsBehindNonceCalled func(shardID uint32, nonce uint64) error GetProofCalled func(shardID uint32, headerHash []byte) (data.HeaderProofHandler, error) HasProofCalled func(shardID uint32, headerHash []byte) bool + IsProofInPoolEqualToCalled func(headerProof data.HeaderProofHandler) bool RegisterHandlerCalled func(handler func(headerProof data.HeaderProofHandler)) } @@ -23,6 +25,15 @@ func (p *ProofsPoolMock) AddProof(headerProof data.HeaderProofHandler) bool { return true } +// UpsertProof - +func (p *ProofsPoolMock) UpsertProof(headerProof data.HeaderProofHandler) bool { + if p.UpsertProofCalled != nil { + return p.UpsertProofCalled(headerProof) + } + + return true +} + // CleanupProofsBehindNonce - func (p *ProofsPoolMock) CleanupProofsBehindNonce(shardID uint32, nonce uint64) error { if p.CleanupProofsBehindNonceCalled != nil { @@ -50,6 +61,15 @@ func (p *ProofsPoolMock) HasProof(shardID uint32, headerHash []byte) bool { return false } +// IsProofInPoolEqualTo - +func (p *ProofsPoolMock) IsProofInPoolEqualTo(headerProof data.HeaderProofHandler) bool { + if p.IsProofInPoolEqualToCalled != nil { + return p.IsProofInPoolEqualToCalled(headerProof) + } + + return false +} + // RegisterHandler - func (p *ProofsPoolMock) RegisterHandler(handler func(headerProof data.HeaderProofHandler)) { if p.RegisterHandlerCalled != nil { diff --git a/update/factory/fullSyncInterceptors.go b/update/factory/fullSyncInterceptors.go index b31f236f396..592a11820fa 100644 --- a/update/factory/fullSyncInterceptors.go +++ b/update/factory/fullSyncInterceptors.go @@ -760,7 +760,12 @@ func (ficf *fullSyncInterceptorsContainerFactory) generateMetachainHeaderInterce return nil } - hdrFactory, err := interceptorFactory.NewInterceptedMetaHeaderDataFactory(ficf.argInterceptorFactory) + argsInterceptedMetaHeaderFactory := interceptorFactory.ArgInterceptedMetaHeaderFactory{ + ArgInterceptedDataFactory: *ficf.argInterceptorFactory, + ProofsPool: ficf.dataPool.Proofs(), + } + + hdrFactory, err := interceptorFactory.NewInterceptedMetaHeaderDataFactory(&argsInterceptedMetaHeaderFactory) if err != nil { return err }