fixes after review

Author: ssd04

consensus/spos/bls/v2/subroundBlock.go

@@ -348,7 +348,7 @@ func (sr *subroundBlock) sendBlockHeader(
 	sr.SetData(headerHash)
 	sr.SetHeader(headerHandler)
 
-	sr.triggerCreateSignaturesForManagedKeys(ctx)
+	go sr.triggerCreateSignaturesForManagedKeys(ctx)
 
 	// log the header output for debugging purposes
 	headerOutput, err := common.PrettifyStruct(headerHandler)
@@ -360,12 +360,21 @@ func (sr *subroundBlock) sendBlockHeader(
 }
 
 func (sr *subroundBlock) triggerCreateSignaturesForManagedKeys(ctx context.Context) {
+	if check.IfNil(sr.GetHeader()) {
+		log.Debug("triggerCreateSignaturesForManagedKeys: triggered with nil header")
+		return
+	}
+
+	currentHash := sr.GetData()
+	currentEpoch := sr.GetHeader().GetEpoch()
+
 	sigSubroundEndTime := time.Duration(float64(sr.RoundHandler().TimeDuration()) * srSignatureEndTime)
 	timeLeft := sr.RoundHandler().RemainingTime(sr.RoundHandler().TimeStamp(), sigSubroundEndTime)
-
 	sigCtx, cancel := context.WithTimeout(ctx, timeLeft)
 	sr.SetSignaturesCtxCancelFunc(cancel)
 
+	wg := sr.SignaturesWaitGroup()
+
 	for idx, pk := range sr.ConsensusGroup() {
 		pkBytes := []byte(pk)
 		if !sr.IsKeyManagedBySelf(pkBytes) {
@@ -379,11 +388,11 @@ func (sr *subroundBlock) triggerCreateSignaturesForManagedKeys(ctx context.Conte
 			return
 		}
 		sr.signatureThrottler.StartProcessing()
-		sr.SignaturesWaitGroup().Add(1)
+		wg.Add(1)
 
 		go func(sigCtx context.Context, idx int, pk string) {
 			defer sr.signatureThrottler.EndProcessing()
-			defer sr.SignaturesWaitGroup().Done()
+			defer wg.Done()
 
 			select {
 			case <-sigCtx.Done():
@@ -393,13 +402,12 @@ func (sr *subroundBlock) triggerCreateSignaturesForManagedKeys(ctx context.Conte
 			}
 
 			pkBytes := []byte(pk)
-			currentHash := sr.GetData()
 
 			_, err := sr.SigningHandler().CreateSignatureShareForPublicKey(
 				sigCtx,
 				currentHash,
 				uint16(idx),
-				sr.GetHeader().GetEpoch(),
+				currentEpoch,
 				pkBytes,
 			)
 			if err != nil {
@@ -710,7 +718,7 @@ func (sr *subroundBlock) receivedBlockHeader(headerHandler data.HeaderHandler) {
 
 	sr.AddReceivedHeader(headerHandler)
 
-	sr.triggerCreateSignaturesForManagedKeys(context.Background())
+	go sr.triggerCreateSignaturesForManagedKeys(context.Background())
 
 	ctx, cancel := context.WithTimeout(context.Background(), sr.RoundHandler().TimeDuration())
 	defer cancel()

consensus/spos/bls/v2/subroundBlock_test.go

@@ -1844,6 +1844,8 @@ func TestSubroundBlock_TriggerCreateSignaturesForManagedKeys(t *testing.T) {
 	t.Run("should work", func(t *testing.T) {
 		t.Parallel()
 
+		currEpoch := uint32(2)
+
 		container := consensusMocks.InitConsensusCore()
 		enableEpochsHandler := &enableEpochsHandlerMock.EnableEpochsHandlerStub{
 			IsFlagEnabledInEpochCalled: func(flag core.EnableEpochFlag, epoch uint32) bool {
@@ -1857,6 +1859,8 @@ func TestSubroundBlock_TriggerCreateSignaturesForManagedKeys(t *testing.T) {
 		signingHandler := &consensusMocks.SigningHandlerStub{
 			CreateSignatureShareForPublicKeyCalled: func(_ context.Context, msg []byte, index uint16, epoch uint32, publicKeyBytes []byte) ([]byte, error) {
 				atomic.AddInt32(&numMultiKeysSignaturesCreated, 1)
+				require.Equal(t, currEpoch, epoch)
+
 				return []byte("SIG"), nil
 			},
 		}
@@ -1895,7 +1899,7 @@ func TestSubroundBlock_TriggerCreateSignaturesForManagedKeys(t *testing.T) {
 			&dataRetrieverMock.ThrottlerStub{},
 		)
 
-		sr.SetHeader(&block.Header{})
+		sr.SetHeader(&block.Header{Epoch: currEpoch})
 		sr.SetSelfPubKey("OTHER")
 
 		srBlock.TriggerCreateSignaturesForManagedKeys(context.TODO())
@@ -1974,6 +1978,76 @@ func TestSubroundBlock_TriggerCreateSignaturesForManagedKeys(t *testing.T) {
 
 		assert.Equal(t, int32(0), atomic.LoadInt32(&numMultiKeysSignaturesCreated))
 	})
+
+	t.Run("should return early if header not set", func(t *testing.T) {
+		t.Parallel()
+
+		container := consensusMocks.InitConsensusCore()
+		enableEpochsHandler := &enableEpochsHandlerMock.EnableEpochsHandlerStub{
+			IsFlagEnabledInEpochCalled: func(flag core.EnableEpochFlag, epoch uint32) bool {
+				return flag == common.AndromedaFlag
+			},
+		}
+		container.SetEnableEpochsHandler(enableEpochsHandler)
+
+		numMultiKeysSignaturesCreated := int32(0)
+
+		signingHandler := &consensusMocks.SigningHandlerStub{
+			CreateSignatureShareForPublicKeyCalled: func(_ context.Context, msg []byte, index uint16, epoch uint32, publicKeyBytes []byte) ([]byte, error) {
+				atomic.AddInt32(&numMultiKeysSignaturesCreated, 1)
+				return []byte("SIG"), nil
+			},
+		}
+		container.SetSigningHandler(signingHandler)
+		consensusState := initializers.InitConsensusStateWithKeysHandler(
+			&testscommon.KeysHandlerStub{
+				IsKeyManagedByCurrentNodeCalled: func(pkBytes []byte) bool {
+					return true
+				},
+			},
+		)
+		ch := make(chan bool, 1)
+
+		sr, _ := spos.NewSubround(
+			bls.SrBlock,
+			bls.SrSignature,
+			bls.SrEndRound,
+			roundTimeDuration,
+			0.7,
+			0.85,
+			"(SIGNATURE)",
+			consensusState,
+			ch,
+			executeStoredMessages,
+			container,
+			chainID,
+			currentPid,
+			&statusHandler.AppStatusHandlerStub{},
+		)
+
+		srBlock, _ := v2.NewSubroundBlock(
+			sr,
+			v2.ProcessingThresholdPercent,
+			&consensusMocks.SposWorkerMock{},
+			&consensusMocks.NtpSyncControllerMock{},
+			&dataRetrieverMock.ThrottlerStub{
+				CanProcessCalled: func() bool {
+					return false
+				},
+			},
+		)
+
+		sr.SetHeader(nil)
+		sr.SetSelfPubKey("OTHER")
+
+		ctx, cancel := context.WithCancel(context.TODO())
+		cancel()
+		srBlock.TriggerCreateSignaturesForManagedKeys(ctx)
+
+		srBlock.SignaturesWaitGroup().Wait()
+
+		assert.Equal(t, int32(0), atomic.LoadInt32(&numMultiKeysSignaturesCreated))
+	})
 }
 
 func TestSubroundBlock_IsInterfaceNil(t *testing.T) {