Feat equivalent proofs tmp1

consensus/interface.go

@@ -208,3 +208,13 @@ type EquivalentProofsPool interface {
 	HasProof(shardID uint32, headerHash []byte) bool
 	IsInterfaceNil() bool
 }
+
+// ProofHandler defines the interface for a proof handler
+type ProofHandler interface {
+	GetPubKeysBitmap() []byte
+	GetAggregatedSignature() []byte
+	GetHeaderHash() []byte
+	GetHeaderEpoch() uint32
+	GetHeaderNonce() uint64
+	GetHeaderShardId() uint32
+}

consensus/spos/bls/v2/blsSubroundsFactory.go

@@ -284,10 +284,9 @@ func (fct *factory) generateEndRoundSubround() error {
 		return err
 	}
 
-	fct.worker.AddReceivedMessageCall(bls.MtBlockHeaderFinalInfo, subroundEndRoundObject.receivedBlockHeaderFinalInfo)
+	fct.worker.AddReceivedProofHandler(subroundEndRoundObject.receivedProof)
 	fct.worker.AddReceivedMessageCall(bls.MtInvalidSigners, subroundEndRoundObject.receivedInvalidSignersInfo)
 	fct.worker.AddReceivedMessageCall(bls.MtSignature, subroundEndRoundObject.receivedSignature)
-	fct.worker.AddReceivedHeaderHandler(subroundEndRoundObject.receivedHeader)
 	fct.consensusCore.Chronology().AddSubround(subroundEndRoundObject)
 
 	return nil

consensus/spos/bls/v2/errors.go

@@ -4,3 +4,9 @@ import "errors"
 
 // ErrNilSentSignatureTracker defines the error for setting a nil SentSignatureTracker
 var ErrNilSentSignatureTracker = errors.New("nil sent signature tracker")
+
+// ErrWrongSizeBitmap defines the error for wrong size bitmap
+var ErrWrongSizeBitmap = errors.New("wrong size bitmap")
+
+// ErrNotEnoughSignatures defines the error for not enough signatures
+var ErrNotEnoughSignatures = errors.New("not enough signatures")

consensus/spos/bls/v2/export_test.go

@@ -256,39 +256,19 @@
 	return sr.checkSignaturesValidity(bitmap)
 }
 
-// DoEndRoundJobByParticipant calls the unexported doEndRoundJobByParticipant function
-func (sr *subroundEndRound) DoEndRoundJobByParticipant(cnsDta *consensus.Message) bool {
-	return sr.doEndRoundJobByParticipant(cnsDta)
+// DoEndRoundJobByLeader calls the unexported doEndRoundJobByNode function
+func (sr *subroundEndRound) DoEndRoundJobByNode() bool {
+	return sr.doEndRoundJobByNode()
 }
 
-// DoEndRoundJobByLeader calls the unexported doEndRoundJobByLeader function
-func (sr *subroundEndRound) DoEndRoundJobByLeader() bool {
-	return sr.doEndRoundJobByLeader()
+// CreateAndBroadcastProof calls the unexported createAndBroadcastHeaderFinalInfo function
+func (sr *subroundEndRound) CreateAndBroadcastProof(signature []byte, bitmap []byte) {
+	sr.createAndBroadcastProof(signature, bitmap)
 }
 
-// HaveConsensusHeaderWithFullInfo calls the unexported haveConsensusHeaderWithFullInfo function
-func (sr *subroundEndRound) HaveConsensusHeaderWithFullInfo(cnsDta *consensus.Message) (bool, data.HeaderHandler) {
-	return sr.haveConsensusHeaderWithFullInfo(cnsDta)
-}
-
-// CreateAndBroadcastHeaderFinalInfo calls the unexported createAndBroadcastHeaderFinalInfo function
-func (sr *subroundEndRound) CreateAndBroadcastHeaderFinalInfo(signature []byte, bitmap []byte, leaderSignature []byte, pk []byte) {
-	sr.createAndBroadcastHeaderFinalInfoForKey(signature, bitmap, leaderSignature, pk)
-}
-
-// ReceivedBlockHeaderFinalInfo calls the unexported receivedBlockHeaderFinalInfo function
-func (sr *subroundEndRound) ReceivedBlockHeaderFinalInfo(cnsDta *consensus.Message) bool {
-	return sr.receivedBlockHeaderFinalInfo(context.Background(), cnsDta)
-}
-
-// IsBlockHeaderFinalInfoValid calls the unexported isBlockHeaderFinalInfoValid function
-func (sr *subroundEndRound) IsBlockHeaderFinalInfoValid(cnsDta *consensus.Message) bool {
-	return sr.isBlockHeaderFinalInfoValid(cnsDta)
-}
-
-// IsConsensusHeaderReceived calls the unexported isConsensusHeaderReceived function
-func (sr *subroundEndRound) IsConsensusHeaderReceived() (bool, data.HeaderHandler) {
-	return sr.isConsensusHeaderReceived()
+// ReceivedProof calls the unexported receivedProof function
+func (sr *subroundEndRound) ReceivedProof(proof consensus.ProofHandler) {
+	sr.receivedProof(proof)
 }
 
 // IsOutOfTime calls the unexported isOutOfTime function
@@ -355,3 +335,8 @@
 func (sr *subroundSignature) DoSignatureJobForManagedKeys(ctx context.Context) bool {
 	return sr.doSignatureJobForManagedKeys(ctx)
 }
+
+// ReceivedSignature method is called when a signature is received through the signature channel
+func (sr *subroundEndRound) ReceivedSignature(cnsDta *consensus.Message) bool {
+	return sr.receivedSignature(context.Background(), cnsDta)
+}

consensus/spos/bls/v2/subroundBlock.go

@@ -8,8 +8,6 @@ import (
 	"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"
-	"github.com/multiversx/mx-chain-core-go/data/block"
-
 	"github.com/multiversx/mx-chain-go/common"
 	"github.com/multiversx/mx-chain-go/consensus"
 	"github.com/multiversx/mx-chain-go/consensus/spos"
@@ -361,44 +359,29 @@ func (sr *subroundBlock) createHeader() (data.HeaderHandler, error) {
 	return hdr, nil
 }
 
+func (sr *subroundBlock) isEpochChangeBlockForEquivalentMessagesActivation(header data.HeaderHandler) bool {
+	isEquivalentMessagesFlagEnabledForHeader := sr.EnableEpochsHandler().IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, header.GetEpoch())
+	isStartOfEpochBlock := header.IsStartOfEpochBlock()
+	isBlockInActivationEpoch := header.GetEpoch() == sr.EnableEpochsHandler().GetActivationEpoch(common.EquivalentMessagesFlag)
+
+	return isEquivalentMessagesFlagEnabledForHeader && isStartOfEpochBlock && isBlockInActivationEpoch
+}
+
 func (sr *subroundBlock) addProofOnHeader(header data.HeaderHandler) bool {
 	prevBlockProof, err := sr.EquivalentProofsPool().GetProof(sr.ShardCoordinator().SelfId(), sr.GetData())
 	if err != nil {
-		return false
+		// for the first block after activation we won't add the proof
+		// TODO: fix this on verifications as well
+		return sr.isEpochChangeBlockForEquivalentMessagesActivation(header)
 	}
 
 	if !isProofEmpty(prevBlockProof) {
 		header.SetPreviousProof(prevBlockProof)
 		return true
 	}
 
-	// this may happen in 2 cases:
-	// 1. on the very first block, after equivalent messages flag activation
-	// in this case, we set the previous proof as signature and bitmap from the previous header
-	// 2. current node is leader in the first block after sync
-	// in this case, we won't set the proof, return false and wait for the next round to receive a proof
-	prevBlockHeader := sr.Blockchain().GetCurrentBlockHeader()
-	if check.IfNil(prevBlockHeader) {
-		log.Debug("addProofOnHeader.GetCurrentBlockHeader, returned nil header")
-		return false
-	}
-
-	isFlagEnabledForPrevHeader := sr.EnableEpochsHandler().IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, prevBlockHeader.GetEpoch())
-	if !isFlagEnabledForPrevHeader {
-		proof := &block.HeaderProof{
-			PubKeysBitmap:       prevBlockHeader.GetSignature(),
-			AggregatedSignature: prevBlockHeader.GetPubKeysBitmap(),
-			HeaderHash:          sr.Blockchain().GetCurrentBlockHeaderHash(),
-			HeaderEpoch:         prevBlockHeader.GetEpoch(),
-			HeaderNonce:         prevBlockHeader.GetNonce(),
-			HeaderShardId:       prevBlockHeader.GetShardID(),
-		}
-
-		header.SetPreviousProof(proof)
-		return true
-	}
+	log.Debug("addProofOnHeader: no proof found")
 
-	log.Debug("addProofOnHeader: leader after sync, no proof for current header, will wait one round")
 	return false
 }
 

consensus/spos/bls/v2/subroundBlock_test.go

@@ -554,35 +554,6 @@ func TestSubroundBlock_DoBlockJob(t *testing.T) {
 		assert.Equal(t, providedSignature, proof.GetAggregatedSignature())
 		assert.Equal(t, providedBitmap, proof.GetPubKeysBitmap())
 	})
-	t.Run("should work, equivalent messages flag not enabled", func(t *testing.T) {
-		t.Parallel()
-		container := consensusMocks.InitConsensusCore()
-		sr := initSubroundBlock(nil, container, &statusHandler.AppStatusHandlerStub{})
-
-		container.SetRoundHandler(&testscommon.RoundHandlerMock{
-			IndexCalled: func() int64 {
-				return 1
-			},
-		})
-
-		leader, err := sr.GetLeader()
-		assert.Nil(t, err)
-		sr.SetSelfPubKey(leader)
-		bpm := consensusMocks.InitBlockProcessorMock(container.Marshalizer())
-		container.SetBlockProcessor(bpm)
-		bm := &consensusMocks.BroadcastMessengerMock{
-			BroadcastConsensusMessageCalled: func(message *consensus.Message) error {
-				return nil
-			},
-		}
-		container.SetBroadcastMessenger(bm)
-		container.SetRoundHandler(&consensusMocks.RoundHandlerMock{
-			RoundIndex: 1,
-		})
-		r := sr.DoBlockJob()
-		assert.True(t, r)
-		assert.Equal(t, uint64(1), sr.GetHeader().GetNonce())
-	})
 }
 
 func TestSubroundBlock_ReceivedBlock(t *testing.T) {