adapt integration tests for consensus v2

consensus/spos/bls/v2/subroundBlock.go

@@ -448,7 +448,10 @@ func (sr *subroundBlock) isHeaderForCurrentConsensus(header data.HeaderHandler)
 func (sr *subroundBlock) getLeaderForHeader(headerHandler data.HeaderHandler) ([]byte, error) {
 	nc := sr.NodesCoordinator()
 
-	prevBlockEpoch := sr.Blockchain().GetCurrentBlockHeader().GetEpoch()
+	prevBlockEpoch := uint32(0)
+	if sr.Blockchain().GetCurrentBlockHeader() != nil {
+		prevBlockEpoch = sr.Blockchain().GetCurrentBlockHeader().GetEpoch()
+	}
 	// TODO: remove this if first block in new epoch will be validated by epoch validators
 	// first block in epoch is validated by previous epoch validators
 	selectionEpoch := headerHandler.GetEpoch()

consensus/spos/bls/v2/subroundEndRound.go

@@ -393,7 +393,7 @@ func (sr *subroundEndRound) checkGoRoutinesThrottler(ctx context.Context) error
 func (sr *subroundEndRound) verifySignature(i int, pk string, sigShare []byte) error {
 	err := sr.SigningHandler().VerifySignatureShare(uint16(i), sigShare, sr.GetData(), sr.GetHeader().GetEpoch())
 	if err != nil {
-		log.Trace("VerifySignatureShare returned an error: ", err)
+		log.Trace("VerifySignatureShare returned an error: ", "error", err)
 		errSetJob := sr.SetJobDone(pk, bls.SrSignature, false)
 		if errSetJob != nil {
 			return errSetJob
@@ -541,6 +541,12 @@ func (sr *subroundEndRound) computeAggSigOnValidNodes() ([]byte, []byte, error)
 		return nil, nil, err
 	}
 
+	log.Trace("computeAggSigOnValidNodes",
+		"bitmap", bitmap,
+		"threshold", threshold,
+		"numValidSigShares", numValidSigShares,
+	)
+
 	return bitmap, sig, nil
 }
 

consensus/spos/worker.go

@@ -580,6 +580,11 @@ func (wrk *Worker) doJobOnMessageWithSignature(cnsMsg *consensus.Message, p2pMsg
 	wrk.mapDisplayHashConsensusMessage[hash] = append(wrk.mapDisplayHashConsensusMessage[hash], cnsMsg)
 
 	wrk.consensusState.AddMessageWithSignature(string(cnsMsg.PubKey), p2pMsg)
+
+	log.Trace("received message with signature",
+		"from", core.GetTrimmedPk(hex.EncodeToString(cnsMsg.PubKey)),
+		"header hash", cnsMsg.BlockHeaderHash,
+	)
 }
 
 func (wrk *Worker) addBlockToPool(bodyBytes []byte) {

integrationTests/consensus/consensusSigning_test.go

@@ -4,12 +4,13 @@ import (
 	"bytes"
 	"encoding/hex"
 	"fmt"
-	"sync"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
+	"github.com/multiversx/mx-chain-core-go/core/check"
 	"github.com/multiversx/mx-chain-go/integrationTests"
 )
 
@@ -20,25 +21,27 @@ func initNodesWithTestSigner(
 	numInvalid uint32,
 	roundTime uint64,
 	consensusType string,
-) map[uint32][]*integrationTests.TestConsensusNode {
+) map[uint32][]*integrationTests.TestFullNode {
 
 	fmt.Println("Step 1. Setup nodes...")
 
+	equivalentProofsActivationEpoch := uint32(0)
+
 	enableEpochsConfig := integrationTests.CreateEnableEpochsConfig()
-	nodes := integrationTests.CreateNodesWithTestConsensusNode(
+	enableEpochsConfig.EquivalentMessagesEnableEpoch = equivalentProofsActivationEpoch
+	enableEpochsConfig.FixedOrderInConsensusEnableEpoch = equivalentProofsActivationEpoch
+
+	nodes := integrationTests.CreateNodesWithTestFullNode(
 		int(numMetaNodes),
 		int(numNodes),
 		int(consensusSize),
 		roundTime,
 		consensusType,
 		1,
 		enableEpochsConfig,
+		false,
 	)
 
-	for shardID, nodesList := range nodes {
-		displayAndStartNodes(shardID, nodesList)
-	}
-
 	time.Sleep(p2pBootstrapDelay)
 
 	for shardID := range nodes {
@@ -54,7 +57,7 @@ func initNodesWithTestSigner(
 						// sig share with invalid size
 						invalidSigShare = bytes.Repeat([]byte("a"), 3)
 					}
-					log.Warn("invalid sig share from ", "pk", getPkEncoded(nodes[shardID][ii].NodeKeys.Pk), "sig", invalidSigShare)
+					log.Warn("invalid sig share from ", "pk", getPkEncoded(nodes[shardID][ii].NodeKeys.MainKey.Pk), "sig", invalidSigShare)
 
 					return invalidSigShare, nil
 				}
@@ -75,7 +78,6 @@ func TestConsensusWithInvalidSigners(t *testing.T) {
 	consensusSize := uint32(4)
 	numInvalid := uint32(1)
 	roundTime := uint64(1000)
-	numCommBlock := uint64(8)
 
 	nodes := initNodesWithTestSigner(numMetaNodes, numNodes, consensusSize, numInvalid, roundTime, blsConsensusType)
 
@@ -92,27 +94,29 @@ func TestConsensusWithInvalidSigners(t *testing.T) {
 	fmt.Println("Start consensus...")
 	time.Sleep(time.Second)
 
-	for shardID := range nodes {
-		mutex := &sync.Mutex{}
-		nonceForRoundMap := make(map[uint64]uint64)
-		totalCalled := 0
-
-		err := startNodesWithCommitBlock(nodes[shardID], mutex, nonceForRoundMap, &totalCalled)
-		assert.Nil(t, err)
-
-		chDone := make(chan bool)
-		go checkBlockProposedEveryRound(numCommBlock, nonceForRoundMap, mutex, chDone, t)
-
-		extraTime := uint64(2)
-		endTime := time.Duration(roundTime)*time.Duration(numCommBlock+extraTime)*time.Millisecond + time.Minute
-		select {
-		case <-chDone:
-		case <-time.After(endTime):
-			mutex.Lock()
-			log.Error("currently saved nonces for rounds", "nonceForRoundMap", nonceForRoundMap)
-			assert.Fail(t, "consensus too slow, not working.")
-			mutex.Unlock()
-			return
+	for _, nodesList := range nodes {
+		for _, n := range nodesList {
+			err := startFullConsensusNode(n)
+			require.Nil(t, err)
+		}
+	}
+
+	fmt.Println("Wait for several rounds...")
+
+	time.Sleep(15 * time.Second)
+
+	fmt.Println("Checking shards...")
+
+	expectedNonce := uint64(10)
+	for _, nodesList := range nodes {
+		for _, n := range nodesList {
+			for i := 1; i < len(nodes); i++ {
+				if check.IfNil(n.Node.GetDataComponents().Blockchain().GetCurrentBlockHeader()) {
+					assert.Fail(t, fmt.Sprintf("Node with idx %d does not have a current block", i))
+				} else {
+					assert.GreaterOrEqual(t, n.Node.GetDataComponents().Blockchain().GetCurrentBlockHeader().GetNonce(), expectedNonce)
+				}
+			}
 		}
 	}
 }