Merge pull request #7590 from multiversx/backup-fixes

sstanculeanu · web-flow · commit dbae8d79d943 · 2026-01-08T22:34:51.000+02:00
diff --git a/consensus/spos/bls/v1/subroundBlock.go b/consensus/spos/bls/v1/subroundBlock.go
@@ -66,7 +66,7 @@ func checkNewSubroundBlockParams(
 
 // doBlockJob method does the job of the subround Block
 func (sr *subroundBlock) doBlockJob(ctx context.Context) bool {
-	isSelfLeader := sr.IsSelfLeaderInCurrentRound() && sr.ShouldConsiderSelfKeyInConsensus()
+	isSelfLeader := sr.IsSelfLeaderInCurrentRound() && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())
 	if !isSelfLeader && !sr.IsMultiKeyLeaderInCurrentRound() { // is NOT self leader in this round?
 		return false
 	}
diff --git a/consensus/spos/bls/v1/subroundEndRound.go b/consensus/spos/bls/v1/subroundEndRound.go
@@ -594,7 +594,7 @@ func (sr *subroundEndRound) createAndBroadcastHeaderFinalInfo() {
 }
 
 func (sr *subroundEndRound) createAndBroadcastInvalidSigners(invalidSigners []byte) {
-	isSelfLeader := sr.IsSelfLeaderInCurrentRound() && sr.ShouldConsiderSelfKeyInConsensus()
+	isSelfLeader := sr.IsSelfLeaderInCurrentRound() && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())
 	if !(isSelfLeader || sr.IsMultiKeyLeaderInCurrentRound()) {
 		return
 	}
diff --git a/consensus/spos/bls/v1/subroundSignature.go b/consensus/spos/bls/v1/subroundSignature.go
@@ -81,8 +81,8 @@ func (sr *subroundSignature) doSignatureJob(_ context.Context) bool {
 		return false
 	}
 
-	isSelfLeader := sr.IsSelfLeaderInCurrentRound() && sr.ShouldConsiderSelfKeyInConsensus()
-	isSelfInConsensusGroup := sr.IsNodeInConsensusGroup(sr.SelfPubKey()) && sr.ShouldConsiderSelfKeyInConsensus()
+	isSelfLeader := sr.IsSelfLeaderInCurrentRound() && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())
+	isSelfInConsensusGroup := sr.IsNodeInConsensusGroup(sr.SelfPubKey()) && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())
 
 	if isSelfLeader || isSelfInConsensusGroup {
 		selfIndex, err := sr.SelfConsensusGroupIndex()
diff --git a/consensus/spos/bls/v1/subroundStartRound.go b/consensus/spos/bls/v1/subroundStartRound.go
@@ -173,7 +173,7 @@ func (sr *subroundStartRound) initCurrentRound() bool {
 	if sr.IsKeyManagedBySelf([]byte(leader)) {
 		msg = " (my turn in multi-key)"
 	}
-	if leader == sr.SelfPubKey() && sr.ShouldConsiderSelfKeyInConsensus() {
+	if leader == sr.SelfPubKey() && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler()) {
 		msg = " (my turn)"
 	}
 	if len(msg) != 0 {
@@ -192,7 +192,7 @@ func (sr *subroundStartRound) initCurrentRound() bool {
 
 	sr.indexRoundIfNeeded(pubKeys)
 
-	isSingleKeyLeader := leader == sr.SelfPubKey() && sr.ShouldConsiderSelfKeyInConsensus()
+	isSingleKeyLeader := leader == sr.SelfPubKey() && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())
 	isLeader := isSingleKeyLeader || sr.IsKeyManagedBySelf([]byte(leader))
 	isSelfInConsensus := sr.IsNodeInConsensusGroup(sr.SelfPubKey()) || numMultiKeysInConsensusGroup > 0
 	if !isSelfInConsensus {
diff --git a/consensus/spos/bls/v2/subroundBlock.go b/consensus/spos/bls/v2/subroundBlock.go
@@ -663,7 +663,7 @@ func (sr *subroundBlock) CanProcessReceivedHeader(headerLeader string) bool {
 }
 
 func (sr *subroundBlock) shouldProcessBlock(headerLeader string) bool {
-	if sr.IsNodeSelf(headerLeader) {
+	if sr.IsNodeSelf(headerLeader) && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler()) {
 		return false
 	}
 	if sr.IsJobDone(headerLeader, sr.Current()) {
diff --git a/consensus/spos/bls/v2/subroundEndRound.go b/consensus/spos/bls/v2/subroundEndRound.go
@@ -394,7 +394,7 @@ func (sr *subroundEndRound) shouldSendProof() bool {
 		return false
 	}
 
-	return sr.IsSelfInConsensusGroup()
+	return sr.IsSelfInConsensusGroup() && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())
 }
 
 func (sr *subroundEndRound) aggregateSigsAndHandleInvalidSigners(bitmap []byte, sender string) ([]byte, []byte, error) {
@@ -673,7 +673,7 @@ func (sr *subroundEndRound) createAndBroadcastInvalidSigners(
 	invalidSignersPubKeys []string,
 	sender string,
 ) {
-	if !sr.ShouldConsiderSelfKeyInConsensus() && !sr.IsMultiKeyInConsensusGroup() {
+	if !spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler()) && !sr.IsMultiKeyInConsensusGroup() {
 		return
 	}
 
diff --git a/consensus/spos/bls/v2/subroundSignature.go b/consensus/spos/bls/v2/subroundSignature.go
@@ -100,7 +100,7 @@ func (sr *subroundSignature) doSignatureJob(ctx context.Context) bool {
 		return true
 	}
 
-	isSelfSingleKeyInConsensusGroup := sr.IsNodeInConsensusGroup(sr.SelfPubKey()) && sr.ShouldConsiderSelfKeyInConsensus()
+	isSelfSingleKeyInConsensusGroup := sr.IsNodeInConsensusGroup(sr.SelfPubKey()) && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())
 	if isSelfSingleKeyInConsensusGroup {
 		if !sr.doSignatureJobForSingleKey() {
 			return false
diff --git a/consensus/spos/common.go b/consensus/spos/common.go
@@ -1,11 +1,29 @@
 package spos
 
 import (
+	"github.com/multiversx/mx-chain-core-go/core/check"
 	"github.com/multiversx/mx-chain-go/common"
+	"github.com/multiversx/mx-chain-go/consensus"
 	"github.com/multiversx/mx-chain-go/sharding"
 )
 
 // GetConsensusTopicID will construct and return the topic ID based on shard coordinator
 func GetConsensusTopicID(shardCoordinator sharding.Coordinator) string {
 	return common.ConsensusTopic + shardCoordinator.CommunicationIdentifier(shardCoordinator.SelfId())
 }
+
+// ShouldConsiderSelfKeyInConsensus returns true if current machine is the main one, or it is a backup machine but the main
+// machine failed
+func ShouldConsiderSelfKeyInConsensus(redundancyHandler consensus.NodeRedundancyHandler) bool {
+	if check.IfNil(redundancyHandler) {
+		log.Warn("redundancy handler is nil")
+		return false
+	}
+
+	isMainMachine := !redundancyHandler.IsRedundancyNode()
+	if isMainMachine {
+		return true
+	}
+	return !redundancyHandler.IsMainMachineActive()
+
+}
diff --git a/consensus/spos/common_test.go b/consensus/spos/common_test.go
@@ -0,0 +1,24 @@
+package spos
+
+import (
+	"testing"
+
+	"github.com/multiversx/mx-chain-go/consensus/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestShouldConsiderSelfKeyInConsensus(t *testing.T) {
+	t.Parallel()
+
+	require.False(t, ShouldConsiderSelfKeyInConsensus(nil))
+	require.True(t, ShouldConsiderSelfKeyInConsensus(&mock.NodeRedundancyHandlerStub{
+		IsRedundancyNodeCalled: func() bool {
+			return false
+		},
+	}))
+	require.True(t, ShouldConsiderSelfKeyInConsensus(&mock.NodeRedundancyHandlerStub{
+		IsMainMachineActiveCalled: func() bool {
+			return true
+		},
+	}))
+}
diff --git a/consensus/spos/consensusState.go b/consensus/spos/consensusState.go
@@ -48,19 +48,23 @@ type ConsensusState struct {
 	*roundStatus
 
 	mutState sync.RWMutex
+
+	redundancyHandler consensus.NodeRedundancyHandler
 }
 
 // NewConsensusState creates a new ConsensusState object
 func NewConsensusState(
 	roundConsensus *roundConsensus,
 	roundThreshold *roundThreshold,
 	roundStatus *roundStatus,
+	redundancyHandler consensus.NodeRedundancyHandler,
 ) *ConsensusState {
 
 	cns := ConsensusState{
-		roundConsensus: roundConsensus,
-		roundThreshold: roundThreshold,
-		roundStatus:    roundStatus,
+		roundConsensus:    roundConsensus,
+		roundThreshold:    roundThreshold,
+		roundStatus:       roundStatus,
+		redundancyHandler: redundancyHandler,
 	}
 
 	cns.ResetConsensusState()
@@ -266,7 +270,7 @@ func (cns *ConsensusState) CanDoSubroundJob(currentSubroundId int) bool {
 // CanProcessReceivedMessage method returns true if the message received can be processed and false otherwise
 func (cns *ConsensusState) CanProcessReceivedMessage(cnsDta *consensus.Message, currentRoundIndex int64,
 	currentSubroundId int) bool {
-	if cns.IsNodeSelf(string(cnsDta.PubKey)) {
+	if cns.IsNodeSelf(string(cnsDta.PubKey)) && ShouldConsiderSelfKeyInConsensus(cns.redundancyHandler) {
 		return false
 	}
 
diff --git a/consensus/spos/consensusState_test.go b/consensus/spos/consensusState_test.go
@@ -10,6 +10,7 @@ import (
 	p2pMessage "github.com/multiversx/mx-chain-communication-go/p2p/message"
 	"github.com/multiversx/mx-chain-core-go/core"
 	"github.com/multiversx/mx-chain-core-go/data/block"
+	"github.com/multiversx/mx-chain-go/consensus/mock"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -58,6 +59,7 @@ func internalInitConsensusStateWithKeysHandler(keysHandler consensus.KeysHandler
 		rcns,
 		rthr,
 		rstatus,
+		&mock.NodeRedundancyHandlerStub{},
 	)
 
 	return cns
@@ -423,11 +425,52 @@ func TestConsensusState_CanProcessReceivedMessageShouldReturnFalseWhenMessageIsR
 func TestConsensusState_CanProcessReceivedMessageShouldReturnFalseWhenMessageIsReceivedForOtherRound(t *testing.T) {
 	t.Parallel()
 
-	cns := internalInitConsensusState()
+	eligibleList := []string{"1", "2", "3"}
+
+	eligibleNodesPubKeys := make(map[string]struct{})
+	for _, key := range eligibleList {
+		eligibleNodesPubKeys[key] = struct{}{}
+	}
+
+	rcns, _ := spos.NewRoundConsensus(
+		eligibleNodesPubKeys,
+		3,
+		"2",
+		&testscommon.KeysHandlerStub{},
+	)
+
+	rcns.SetConsensusGroup(eligibleList)
+	rcns.SetLeader(eligibleList[0])
+	rcns.ResetRoundState()
+
+	rthr := spos.NewRoundThreshold()
+
+	rthr.SetThreshold(bls.SrBlock, 1)
+	rthr.SetThreshold(bls.SrSignature, 3)
+	rthr.SetFallbackThreshold(bls.SrBlock, 1)
+	rthr.SetFallbackThreshold(bls.SrSignature, 2)
+
+	rstatus := spos.NewRoundStatus()
+	rstatus.ResetRoundStatus()
+
+	// force backup case for coverage
+	cns := spos.NewConsensusState(
+		rcns,
+		rthr,
+		rstatus,
+		&mock.NodeRedundancyHandlerStub{
+			IsRedundancyNodeCalled: func() bool {
+				return true
+			},
+			IsMainMachineActiveCalled: func() bool {
+				return false
+			},
+		},
+	)
 
 	cnsDta := &consensus.Message{
 		RoundIndex: 0,
-		PubKey:     []byte("1"),
+		PubKey:     []byte(cns.SelfPubKey()),
 	}
 
 	assert.False(t, cns.CanProcessReceivedMessage(cnsDta, 1, bls.SrBlock))
diff --git a/consensus/spos/subround.go b/consensus/spos/subround.go
@@ -244,18 +244,6 @@ func (sr *Subround) GetAssociatedPid(pkBytes []byte) core.PeerID {
 	return sr.GetKeysHandler().GetAssociatedPid(pkBytes)
 }
 
-// ShouldConsiderSelfKeyInConsensus returns true if current machine is the main one, or it is a backup machine but the main
-// machine failed
-func (sr *Subround) ShouldConsiderSelfKeyInConsensus() bool {
-	isMainMachine := !sr.NodeRedundancyHandler().IsRedundancyNode()
-	if isMainMachine {
-		return true
-	}
-	isMainMachineInactive := !sr.NodeRedundancyHandler().IsMainMachineActive()
-
-	return isMainMachineInactive
-}
-
 // IsSelfInConsensusGroup returns true is the current node is in consensus group in single
 // key or in multi-key mode
 func (sr *Subround) IsSelfInConsensusGroup() bool {
@@ -270,7 +258,7 @@ func (sr *Subround) IsSelfLeader() bool {
 
 // IsSelfLeaderInCurrentRound method checks if the current node is leader in the current round
 func (sr *Subround) IsSelfLeaderInCurrentRound() bool {
-	return sr.IsNodeLeaderInCurrentRound(sr.SelfPubKey()) && sr.ShouldConsiderSelfKeyInConsensus()
+	return sr.IsNodeLeaderInCurrentRound(sr.SelfPubKey()) && ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())
 }
 
 // GetLeaderStartRoundMessage returns the leader start round message based on single key
diff --git a/consensus/spos/subround_test.go b/consensus/spos/subround_test.go
diff --git a/consensus/spos/worker.go b/consensus/spos/worker.go
diff --git a/factory/consensus/consensusComponents.go b/factory/consensus/consensusComponents.go
diff --git a/factory/consensus/consensusComponents_test.go b/factory/consensus/consensusComponents_test.go
diff --git a/testscommon/consensus/initializers/initializers.go b/testscommon/consensus/initializers/initializers.go

Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ func checkNewSubroundBlockParams(`
`66`	`66`
`67`	`67`	`// doBlockJob method does the job of the subround Block`
`68`	`68`	`func (sr *subroundBlock) doBlockJob(ctx context.Context) bool {`
`69`		`- isSelfLeader := sr.IsSelfLeaderInCurrentRound() && sr.ShouldConsiderSelfKeyInConsensus()`
	`69`	`+ isSelfLeader := sr.IsSelfLeaderInCurrentRound() && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())`
`70`	`70`	`if !isSelfLeader && !sr.IsMultiKeyLeaderInCurrentRound() { // is NOT self leader in this round?`
`71`	`71`	`return false`
`72`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -594,7 +594,7 @@ func (sr *subroundEndRound) createAndBroadcastHeaderFinalInfo() {`
`594`	`594`	`}`
`595`	`595`
`596`	`596`	`func (sr *subroundEndRound) createAndBroadcastInvalidSigners(invalidSigners []byte) {`
`597`		`- isSelfLeader := sr.IsSelfLeaderInCurrentRound() && sr.ShouldConsiderSelfKeyInConsensus()`
	`597`	`+ isSelfLeader := sr.IsSelfLeaderInCurrentRound() && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())`
`598`	`598`	`if !(isSelfLeader \|\| sr.IsMultiKeyLeaderInCurrentRound()) {`
`599`	`599`	`return`
`600`	`600`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,8 +81,8 @@ func (sr *subroundSignature) doSignatureJob(_ context.Context) bool {`
`81`	`81`	`return false`
`82`	`82`	`}`
`83`	`83`
`84`		`- isSelfLeader := sr.IsSelfLeaderInCurrentRound() && sr.ShouldConsiderSelfKeyInConsensus()`
`85`		`- isSelfInConsensusGroup := sr.IsNodeInConsensusGroup(sr.SelfPubKey()) && sr.ShouldConsiderSelfKeyInConsensus()`
	`84`	`+ isSelfLeader := sr.IsSelfLeaderInCurrentRound() && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())`
	`85`	`+ isSelfInConsensusGroup := sr.IsNodeInConsensusGroup(sr.SelfPubKey()) && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())`
`86`	`86`
`87`	`87`	`if isSelfLeader \|\| isSelfInConsensusGroup {`
`88`	`88`	`selfIndex, err := sr.SelfConsensusGroupIndex()`
Original file line number	Diff line number	Diff line change
`@@ -663,7 +663,7 @@ func (sr *subroundBlock) CanProcessReceivedHeader(headerLeader string) bool {`
`663`	`663`	`}`
`664`	`664`
`665`	`665`	`func (sr *subroundBlock) shouldProcessBlock(headerLeader string) bool {`
`666`		`- if sr.IsNodeSelf(headerLeader) {`
	`666`	`+ if sr.IsNodeSelf(headerLeader) && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler()) {`
`667`	`667`	`return false`
`668`	`668`	`}`
`669`	`669`	`if sr.IsJobDone(headerLeader, sr.Current()) {`
Original file line number	Diff line number	Diff line change
`@@ -394,7 +394,7 @@ func (sr *subroundEndRound) shouldSendProof() bool {`
`394`	`394`	`return false`
`395`	`395`	`}`
`396`	`396`
`397`		`- return sr.IsSelfInConsensusGroup()`
	`397`	`+ return sr.IsSelfInConsensusGroup() && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())`
`398`	`398`	`}`
`399`	`399`
`400`	`400`	`func (sr *subroundEndRound) aggregateSigsAndHandleInvalidSigners(bitmap []byte, sender string) ([]byte, []byte, error) {`
`@@ -673,7 +673,7 @@ func (sr *subroundEndRound) createAndBroadcastInvalidSigners(`
`673`	`673`	`invalidSignersPubKeys []string,`
`674`	`674`	`sender string,`
`675`	`675`	`) {`
`676`		`- if !sr.ShouldConsiderSelfKeyInConsensus() && !sr.IsMultiKeyInConsensusGroup() {`
	`676`	`+ if !spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler()) && !sr.IsMultiKeyInConsensusGroup() {`
`677`	`677`	`return`
`678`	`678`	`}`
`679`	`679`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ func (sr *subroundSignature) doSignatureJob(ctx context.Context) bool {`
`100`	`100`	`return true`
`101`	`101`	`}`
`102`	`102`
`103`		`- isSelfSingleKeyInConsensusGroup := sr.IsNodeInConsensusGroup(sr.SelfPubKey()) && sr.ShouldConsiderSelfKeyInConsensus()`
	`103`	`+ isSelfSingleKeyInConsensusGroup := sr.IsNodeInConsensusGroup(sr.SelfPubKey()) && spos.ShouldConsiderSelfKeyInConsensus(sr.NodeRedundancyHandler())`
`104`	`104`	`if isSelfSingleKeyInConsensusGroup {`
`105`	`105`	`if !sr.doSignatureJobForSingleKey() {`
`106`	`106`	`return false`