stabilization-equivalent-proofs

consensus/spos/bls/v2/subroundBlock.go

@@ -104,12 +104,6 @@ func (sr *subroundBlock) doBlockJob(ctx context.Context) bool {
 		return false
 	}
 
-	// This must be done after createBlock, in order to have the proper epoch set
-	wasProofAdded := sr.addProofOnHeader(header)
-	if !wasProofAdded {
-		return false
-	}
-
 	// block proof verification should be done over the header that contains the leader signature
 	leaderSignature, err := sr.signBlockHeader(header)
 	if err != nil {
@@ -359,30 +353,6 @@ func (sr *subroundBlock) createHeader() (data.HeaderHandler, error) {
 	return hdr, nil
 }
 
-func (sr *subroundBlock) addProofOnHeader(header data.HeaderHandler) bool {
-	prevBlockProof, err := sr.EquivalentProofsPool().GetProof(sr.ShardCoordinator().SelfId(), header.GetPrevHash())
-	if err != nil {
-		// for the first block after activation we won't add the proof
-		// TODO: fix this on verifications as well
-		return common.IsEpochChangeBlockForFlagActivation(header, sr.EnableEpochsHandler(), common.EquivalentMessagesFlag)
-	}
-
-	if !isProofEmpty(prevBlockProof) {
-		header.SetPreviousProof(prevBlockProof)
-		return true
-	}
-
-	log.Debug("addProofOnHeader: no proof found", "header hash", header.GetPrevHash())
-
-	return false
-}
-
-func isProofEmpty(proof data.HeaderProofHandler) bool {
-	return len(proof.GetAggregatedSignature()) == 0 ||
-		len(proof.GetPubKeysBitmap()) == 0 ||
-		len(proof.GetHeaderHash()) == 0
-}
-
 func (sr *subroundBlock) saveProofForPreviousHeaderIfNeeded(header data.HeaderHandler, prevHeader data.HeaderHandler) {
 	hasProof := sr.EquivalentProofsPool().HasProof(sr.ShardCoordinator().SelfId(), header.GetPrevHash())
 	if hasProof {

process/block/baseProcess.go

@@ -547,6 +547,7 @@ func checkProcessorParameters(arguments ArgBaseProcessor) error {
 		common.ScheduledMiniBlocksFlag,
 		common.StakingV2Flag,
 		common.CurrentRandomnessOnSortingFlag,
+		common.EquivalentMessagesFlag,
 	})
 	if err != nil {
 		return err
@@ -2200,3 +2201,28 @@ func (bp *baseProcessor) checkSentSignaturesAtCommitTime(header data.HeaderHandl
 
 	return nil
 }
+
+func isProofEmpty(proof data.HeaderProofHandler) bool {
+	return len(proof.GetAggregatedSignature()) == 0 ||
+		len(proof.GetPubKeysBitmap()) == 0 ||
+		len(proof.GetHeaderHash()) == 0
+}
+
+func (bp *baseProcessor) addPrevProofIfNeeded(header data.HeaderHandler) error {
+	if !common.ShouldBlockHavePrevProof(header, bp.enableEpochsHandler, common.EquivalentMessagesFlag) {
+		return nil
+	}
+
+	prevBlockProof, err := bp.proofsPool.GetProof(bp.shardCoordinator.SelfId(), header.GetPrevHash())
+	if err != nil {
+		return err
+	}
+
+	if !isProofEmpty(prevBlockProof) {
+		header.SetPreviousProof(prevBlockProof)
+		return nil
+	}
+
+	log.Debug("addPrevProofIfNeeded: no proof found", "header hash", header.GetPrevHash())
+	return process.ErrNilHeaderProof
+}

process/block/metablock.go

@@ -756,6 +756,33 @@ func (mp *metaProcessor) RestoreBlockIntoPools(headerHandler data.HeaderHandler,
 	return nil
 }
 
+func (mp *metaProcessor) updateHeaderForEpochStartIfNeeded(metaHdr *block.MetaBlock) error {
+	isEpochStart := mp.epochStartTrigger.IsEpochStart()
+	if !isEpochStart {
+		return nil
+	}
+	return mp.updateEpochStartHeader(metaHdr)
+}
+
+func (mp *metaProcessor) createBody(metaHdr *block.MetaBlock, haveTime func() bool) (data.BodyHandler, error) {
+	isEpochStart := mp.epochStartTrigger.IsEpochStart()
+	var body data.BodyHandler
+	var err error
+	if isEpochStart {
+		body, err = mp.createEpochStartBody(metaHdr)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		body, err = mp.createBlockBody(metaHdr, haveTime)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return body, nil
+}
+
 // CreateBlock creates the final block and header for the current round
 func (mp *metaProcessor) CreateBlock(
 	initialHdr data.HeaderHandler,
@@ -789,21 +816,19 @@ func (mp *metaProcessor) CreateBlock(
 		return nil, nil, err
 	}
 
-	if mp.epochStartTrigger.IsEpochStart() {
-		err = mp.updateEpochStartHeader(metaHdr)
-		if err != nil {
-			return nil, nil, err
-		}
+	err = mp.updateHeaderForEpochStartIfNeeded(metaHdr)
+	if err != nil {
+		return nil, nil, err
+	}
 
-		body, err = mp.createEpochStartBody(metaHdr)
-		if err != nil {
-			return nil, nil, err
-		}
-	} else {
-		body, err = mp.createBlockBody(metaHdr, haveTime)
-		if err != nil {
-			return nil, nil, err
-		}
+	err = mp.addPrevProofIfNeeded(metaHdr)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	body, err = mp.createBody(metaHdr, haveTime)
+	if err != nil {
+		return nil, nil, err
 	}
 
 	body, err = mp.applyBodyToHeader(metaHdr, body)

process/block/shardblock.go

@@ -878,6 +878,11 @@ func (sp *shardProcessor) CreateBlock(
 		}
 	}
 
+	err = sp.addPrevProofIfNeeded(shardHdr)
+	if err != nil {
+		return nil, nil, err
+	}
+
 	sp.epochNotifier.CheckEpoch(shardHdr)
 	sp.blockChainHook.SetCurrentHeader(shardHdr)
 	body, processedMiniBlocksDestMeInfo, err := sp.createBlockBody(shardHdr, haveTime)

process/peer/process.go

@@ -406,10 +406,7 @@ func (vs *validatorStatistics) UpdatePeerState(header data.MetaHeaderHandler, ca
 	log.Debug("UpdatePeerState - registering meta previous leader fees", "metaNonce", previousHeader.GetNonce())
 	bitmap := previousHeader.GetPubKeysBitmap()
 	if vs.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, previousHeader.GetEpoch()) {
-		proof := previousHeader.GetPreviousProof()
-		if !check.IfNilReflect(proof) {
-			bitmap = proof.GetPubKeysBitmap()
-		}
+		bitmap = vs.getBitmapForFullConsensus(previousHeader.GetShardID(), previousHeader.GetEpoch())
 	}
 	err = vs.updateValidatorInfoOnSuccessfulBlock(
 		leader,
@@ -903,6 +900,17 @@ func (vs *validatorStatistics) RevertPeerState(header data.MetaHeaderHandler) er
 	return vs.peerAdapter.RecreateTrie(rootHashHolder)
 }
 
+// TODO: check if this can be taken from somewhere else
+func (vs *validatorStatistics) getBitmapForFullConsensus(shardID uint32, epoch uint32) []byte {
+	consensusSize := vs.nodesCoordinator.ConsensusGroupSizeForShardAndEpoch(shardID, epoch)
+	bitmap := make([]byte, consensusSize/8+1)
+	for i := 0; i < consensusSize; i++ {
+		bitmap[i/8] |= 1 << (uint16(i) % 8)
+	}
+
+	return bitmap
+}
+
 func (vs *validatorStatistics) updateShardDataPeerState(
 	header data.HeaderHandler,
 	cacheMap map[string]data.HeaderHandler,
@@ -935,10 +943,14 @@ func (vs *validatorStatistics) updateShardDataPeerState(
 		}
 
 		log.Debug("updateShardDataPeerState - registering shard leader fees", "shard headerHash", h.HeaderHash, "accumulatedFees", h.AccumulatedFees.String(), "developerFees", h.DeveloperFees.String())
+		bitmap := h.PubKeysBitmap
+		if vs.enableEpochsHandler.IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, h.Epoch) {
+			bitmap = vs.getBitmapForFullConsensus(h.ShardID, h.Epoch)
+		}
 		shardInfoErr = vs.updateValidatorInfoOnSuccessfulBlock(
 			leader,
 			shardConsensus,
-			h.PubKeysBitmap,
+			bitmap,
 			big.NewInt(0).Sub(h.AccumulatedFees, h.DeveloperFees),
 			h.ShardID,
 		)