stabilization-equivalent-proofs

cmd/node/config/enableEpochs.toml

@@ -319,10 +319,10 @@
     CryptoOpcodesV2EnableEpoch = 4
 
     # EquivalentMessagesEnableEpoch represents the epoch when the equivalent messages are enabled
-    EquivalentMessagesEnableEpoch = 4
+    EquivalentMessagesEnableEpoch = 8 # the chain simulator tests for staking v4 fail if this is set earlier, as they test the transition in epochs 4-7
 
     # FixedOrderInConsensusEnableEpoch represents the epoch when the fixed order in consensus is enabled
-    FixedOrderInConsensusEnableEpoch = 4
+    FixedOrderInConsensusEnableEpoch = 8 # the chain simulator tests for staking v4 fail if this is set earlier, as they test the transition in epochs 4-7
 
     # BLSMultiSignerEnableEpoch represents the activation epoch for different types of BLS multi-signers
     BLSMultiSignerEnableEpoch = [

common/common.go

@@ -19,3 +19,8 @@ func IsFlagEnabledAfterEpochsStartBlock(header data.HeaderHandler, enableEpochsH
 	isEpochStartBlock := IsEpochChangeBlockForFlagActivation(header, enableEpochsHandler, flag)
 	return isFlagEnabled && !isEpochStartBlock
 }
+
+// ShouldBlockHavePrevProof returns true if the block should have a proof
+func ShouldBlockHavePrevProof(header data.HeaderHandler, enableEpochsHandler EnableEpochsHandler, flag core.EnableEpochFlag) bool {
+	return IsFlagEnabledAfterEpochsStartBlock(header, enableEpochsHandler, flag) && header.GetNonce() > 1
+}

consensus/spos/bls/proxy/subroundsHandler.go

@@ -3,7 +3,6 @@ package proxy
 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"
 	logger "github.com/multiversx/mx-chain-logger-go"
 
 	"github.com/multiversx/mx-chain-go/common"
@@ -57,6 +56,14 @@ type SubroundsHandler struct {
 	currentConsensusType consensusStateMachineType
 }
 
+// EpochConfirmed is called when the epoch is confirmed (this is registered as callback)
+func (s *SubroundsHandler) EpochConfirmed(epoch uint32, _ uint64) {
+	err := s.initSubroundsForEpoch(epoch)
+	if err != nil {
+		log.Error("SubroundsHandler.EpochStartAction: cannot initialize subrounds", "error", err)
+	}
+}
+
 const (
 	consensusNone consensusStateMachineType = iota
 	consensusV1
@@ -85,7 +92,7 @@ func NewSubroundsHandler(args *SubroundsHandlerArgs) (*SubroundsHandler, error)
 		currentConsensusType: consensusNone,
 	}
 
-	subroundHandler.consensusCoreHandler.EpochStartRegistrationHandler().RegisterHandler(subroundHandler)
+	subroundHandler.consensusCoreHandler.EpochNotifier().RegisterNotifyHandler(subroundHandler)
 
 	return subroundHandler, nil
 }
@@ -189,28 +196,6 @@ func (s *SubroundsHandler) initSubroundsForEpoch(epoch uint32) error {
 	return nil
 }
 
-// EpochStartAction is called when the epoch starts
-func (s *SubroundsHandler) EpochStartAction(hdr data.HeaderHandler) {
-	if check.IfNil(hdr) {
-		log.Error("SubroundsHandler.EpochStartAction: nil header")
-		return
-	}
-
-	err := s.initSubroundsForEpoch(hdr.GetEpoch())
-	if err != nil {
-		log.Error("SubroundsHandler.EpochStartAction: cannot initialize subrounds", "error", err)
-	}
-}
-
-// EpochStartPrepare prepares the subrounds handler for the epoch start
-func (s *SubroundsHandler) EpochStartPrepare(_ data.HeaderHandler, _ data.BodyHandler) {
-}
-
-// NotifyOrder returns the order of the subrounds handler
-func (s *SubroundsHandler) NotifyOrder() uint32 {
-	return common.ConsensusHandlerOrder
-}
-
 // IsInterfaceNil returns true if there is no value under the interface
 func (s *SubroundsHandler) IsInterfaceNil() bool {
 	return s == nil

consensus/spos/bls/proxy/subroundsHandler_test.go

@@ -8,7 +8,6 @@ import (
 	crypto "github.com/multiversx/mx-chain-crypto-go"
 	"github.com/stretchr/testify/require"
 
-	chainCommon "github.com/multiversx/mx-chain-go/common"
 	mock2 "github.com/multiversx/mx-chain-go/consensus/mock"
 	"github.com/multiversx/mx-chain-go/testscommon"
 	"github.com/multiversx/mx-chain-go/testscommon/bootstrapperStubs"
@@ -17,6 +16,7 @@ import (
 	"github.com/multiversx/mx-chain-go/testscommon/cryptoMocks"
 	"github.com/multiversx/mx-chain-go/testscommon/dataRetriever"
 	"github.com/multiversx/mx-chain-go/testscommon/enableEpochsHandlerMock"
+	epochNotifierMock "github.com/multiversx/mx-chain-go/testscommon/epochNotifier"
 	mock "github.com/multiversx/mx-chain-go/testscommon/epochstartmock"
 	outportStub "github.com/multiversx/mx-chain-go/testscommon/outport"
 	"github.com/multiversx/mx-chain-go/testscommon/shardingMocks"
@@ -29,6 +29,7 @@ func getDefaultArgumentsSubroundHandler() (*SubroundsHandlerArgs, *consensus.Con
 	epochsEnable := &enableEpochsHandlerMock.EnableEpochsHandlerStub{}
 	epochStartNotifier := &mock.EpochStartNotifierStub{}
 	consensusState := &consensus.ConsensusStateMock{}
+	epochNotifier := &epochNotifierMock.EpochNotifierStub{}
 	worker := &consensus.SposWorkerMock{
 		RemoveAllReceivedMessagesCallsCalled: func() {},
 		GetConsensusStateChangedChannelsCalled: func() chan bool {
@@ -78,6 +79,7 @@ func getDefaultArgumentsSubroundHandler() (*SubroundsHandlerArgs, *consensus.Con
 	consensusCore.SetSigningHandler(&consensus.SigningHandlerStub{})
 	consensusCore.SetEnableEpochsHandler(epochsEnable)
 	consensusCore.SetEquivalentProofsPool(&dataRetriever.ProofsPoolMock{})
+	consensusCore.SetEpochNotifier(epochNotifier)
 	handlerArgs.ConsensusCoreHandler = consensusCore
 
 	return handlerArgs, consensusCore
@@ -221,12 +223,14 @@ func TestSubroundsHandler_initSubroundsForEpoch(t *testing.T) {
 		sh, err := NewSubroundsHandler(handlerArgs)
 		require.Nil(t, err)
 		require.NotNil(t, sh)
+		// first call on register to EpochNotifier
+		require.Equal(t, int32(1), startCalled.Load())
 		sh.currentConsensusType = consensusNone
 
 		err = sh.initSubroundsForEpoch(0)
 		require.Nil(t, err)
 		require.Equal(t, consensusV1, sh.currentConsensusType)
-		require.Equal(t, int32(1), startCalled.Load())
+		require.Equal(t, int32(2), startCalled.Load())
 	})
 	t.Run("equivalent messages not enabled, with previous consensus type consensusV1", func(t *testing.T) {
 		t.Parallel()
@@ -251,12 +255,15 @@ func TestSubroundsHandler_initSubroundsForEpoch(t *testing.T) {
 		sh, err := NewSubroundsHandler(handlerArgs)
 		require.Nil(t, err)
 		require.NotNil(t, sh)
+		// first call on register to EpochNotifier
+		require.Equal(t, int32(1), startCalled.Load())
 		sh.currentConsensusType = consensusV1
 
 		err = sh.initSubroundsForEpoch(0)
 		require.Nil(t, err)
 		require.Equal(t, consensusV1, sh.currentConsensusType)
-		require.Equal(t, int32(0), startCalled.Load())
+		require.Equal(t, int32(1), startCalled.Load())
+
 	})
 	t.Run("equivalent messages enabled, with previous consensus type consensusNone", func(t *testing.T) {
 		t.Parallel()
@@ -280,12 +287,14 @@ func TestSubroundsHandler_initSubroundsForEpoch(t *testing.T) {
 		sh, err := NewSubroundsHandler(handlerArgs)
 		require.Nil(t, err)
 		require.NotNil(t, sh)
+		// first call on register to EpochNotifier
+		require.Equal(t, int32(1), startCalled.Load())
 		sh.currentConsensusType = consensusNone
 
 		err = sh.initSubroundsForEpoch(0)
 		require.Nil(t, err)
 		require.Equal(t, consensusV2, sh.currentConsensusType)
-		require.Equal(t, int32(1), startCalled.Load())
+		require.Equal(t, int32(2), startCalled.Load())
 	})
 	t.Run("equivalent messages enabled, with previous consensus type consensusV1", func(t *testing.T) {
 		t.Parallel()
@@ -309,12 +318,14 @@ func TestSubroundsHandler_initSubroundsForEpoch(t *testing.T) {
 		sh, err := NewSubroundsHandler(handlerArgs)
 		require.Nil(t, err)
 		require.NotNil(t, sh)
+		// first call on register to EpochNotifier
+		require.Equal(t, int32(1), startCalled.Load())
 		sh.currentConsensusType = consensusV1
 
 		err = sh.initSubroundsForEpoch(0)
 		require.Nil(t, err)
 		require.Equal(t, consensusV2, sh.currentConsensusType)
-		require.Equal(t, int32(1), startCalled.Load())
+		require.Equal(t, int32(2), startCalled.Load())
 	})
 	t.Run("equivalent messages enabled, with previous consensus type consensusV2", func(t *testing.T) {
 		t.Parallel()
@@ -339,12 +350,14 @@ func TestSubroundsHandler_initSubroundsForEpoch(t *testing.T) {
 		sh, err := NewSubroundsHandler(handlerArgs)
 		require.Nil(t, err)
 		require.NotNil(t, sh)
+		// first call on register to EpochNotifier
+		require.Equal(t, int32(1), startCalled.Load())
 		sh.currentConsensusType = consensusV2
 
 		err = sh.initSubroundsForEpoch(0)
 		require.Nil(t, err)
 		require.Equal(t, consensusV2, sh.currentConsensusType)
-		require.Equal(t, int32(0), startCalled.Load())
+		require.Equal(t, int32(1), startCalled.Load())
 	})
 }
 
@@ -375,27 +388,17 @@ func TestSubroundsHandler_Start(t *testing.T) {
 		sh, err := NewSubroundsHandler(handlerArgs)
 		require.Nil(t, err)
 		require.NotNil(t, sh)
+		// first call on init of EpochNotifier
+		require.Equal(t, int32(1), startCalled.Load())
 		sh.currentConsensusType = consensusNone
 
 		err = sh.Start(0)
 		require.Nil(t, err)
 		require.Equal(t, consensusV1, sh.currentConsensusType)
-		require.Equal(t, int32(1), startCalled.Load())
+		require.Equal(t, int32(2), startCalled.Load())
 	})
 }
 
-func TestSubroundsHandler_NotifyOrder(t *testing.T) {
-	t.Parallel()
-
-	handlerArgs, _ := getDefaultArgumentsSubroundHandler()
-	sh, err := NewSubroundsHandler(handlerArgs)
-	require.Nil(t, err)
-	require.NotNil(t, sh)
-
-	order := sh.NotifyOrder()
-	require.Equal(t, uint32(chainCommon.ConsensusHandlerOrder), order)
-}
-
 func TestSubroundsHandler_IsInterfaceNil(t *testing.T) {
 	t.Parallel()
 
@@ -417,7 +420,7 @@ func TestSubroundsHandler_IsInterfaceNil(t *testing.T) {
 	})
 }
 
-func TestSubroundsHandler_EpochStartAction(t *testing.T) {
+func TestSubroundsHandler_EpochConfirmed(t *testing.T) {
 	t.Parallel()
 
 	t.Run("nil handler does not panic", func(t *testing.T) {
@@ -431,7 +434,7 @@ func TestSubroundsHandler_EpochStartAction(t *testing.T) {
 		handlerArgs, _ := getDefaultArgumentsSubroundHandler()
 		sh, err := NewSubroundsHandler(handlerArgs)
 		require.Nil(t, err)
-		sh.EpochStartAction(&testscommon.HeaderHandlerStub{})
+		sh.EpochConfirmed(0, 0)
 	})
 
 	// tested through initSubroundsForEpoch
@@ -458,11 +461,13 @@ func TestSubroundsHandler_EpochStartAction(t *testing.T) {
 		sh, err := NewSubroundsHandler(handlerArgs)
 		require.Nil(t, err)
 		require.NotNil(t, sh)
+		// first call on register to EpochNotifier
+		require.Equal(t, int32(1), startCalled.Load())
 
 		sh.currentConsensusType = consensusNone
-		sh.EpochStartAction(&testscommon.HeaderHandlerStub{})
+		sh.EpochConfirmed(0, 0)
 		require.Nil(t, err)
 		require.Equal(t, consensusV1, sh.currentConsensusType)
-		require.Equal(t, int32(1), startCalled.Load())
+		require.Equal(t, int32(2), startCalled.Load())
 	})
 }

consensus/spos/bls/v1/blsSubroundsFactory.go

@@ -206,6 +206,7 @@ func (fct *factory) generateBlockSubround() error {
 	fct.worker.AddReceivedMessageCall(bls.MtBlockBodyAndHeader, subroundBlockInstance.receivedBlockBodyAndHeader)
 	fct.worker.AddReceivedMessageCall(bls.MtBlockBody, subroundBlockInstance.receivedBlockBody)
 	fct.worker.AddReceivedMessageCall(bls.MtBlockHeader, subroundBlockInstance.receivedBlockHeader)
+	fct.worker.AddReceivedHeaderHandler(subroundBlockInstance.receivedFullHeader)
 	fct.consensusCore.Chronology().AddSubround(subroundBlockInstance)
 
 	return nil

consensus/spos/bls/v1/errors.go

@@ -4,3 +4,6 @@ import "errors"
 
 // ErrNilSentSignatureTracker defines the error for setting a nil SentSignatureTracker
 var ErrNilSentSignatureTracker = errors.New("nil sent signature tracker")
+
+// ErrEquivalentMessagesFlagEnabledWithConsensusV1 defines the error for running with the equivalent messages flag enabled under v1 consensus
+var ErrEquivalentMessagesFlagEnabledWithConsensusV1 = errors.New("equivalent messages flag enabled with consensus v1")

consensus/spos/bls/v1/subroundBlock.go

@@ -1,6 +1,7 @@
 package v1
 
 import (
+	"bytes"
 	"context"
 	"time"
 
@@ -334,6 +335,10 @@ func (sr *subroundBlock) createHeader() (data.HeaderHandler, error) {
 		return nil, err
 	}
 
+	if sr.EnableEpochsHandler().IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, hdr.GetEpoch()) {
+		return nil, ErrEquivalentMessagesFlagEnabledWithConsensusV1
+	}
+
 	err = hdr.SetPrevHash(prevHash)
 	if err != nil {
 		return nil, err
@@ -491,6 +496,27 @@ func (sr *subroundBlock) receivedBlockBody(ctx context.Context, cnsDta *consensu
 	return blockProcessedWithSuccess
 }
 
+func (sr *subroundBlock) receivedFullHeader(headerHandler data.HeaderHandler) {
+	if sr.ShardCoordinator().SelfId() != headerHandler.GetShardID() {
+		log.Debug("subroundBlock.ReceivedFullHeader early exit", "headerShardID", headerHandler.GetShardID(), "selfShardID", sr.ShardCoordinator().SelfId())
+		return
+	}
+
+	if !sr.EnableEpochsHandler().IsFlagEnabledInEpoch(common.EquivalentMessagesFlag, headerHandler.GetEpoch()) {
+		log.Debug("subroundBlock.ReceivedFullHeader early exit", "flagNotEnabled in header epoch", headerHandler.GetEpoch())
+		return
+	}
+
+	log.Debug("subroundBlock.ReceivedFullHeader", "nonce", headerHandler.GetNonce(), "epoch", headerHandler.GetEpoch())
+
+	lastCommittedBlockHash := sr.Blockchain().GetCurrentBlockHeaderHash()
+	if bytes.Equal(lastCommittedBlockHash, headerHandler.GetPrevHash()) {
+		// Need to switch to consensus v2
+		log.Debug("subroundBlock.ReceivedFullHeader switching epoch")
+		go sr.EpochNotifier().CheckEpoch(headerHandler)
+	}
+}
+
 // receivedBlockHeader method is called when a block header is received through the block header channel.
 // If the block header is valid, then the validatorRoundStates map corresponding to the node which sent it,
 // is set on true for the subround Block

consensus/spos/bls/v2/subroundEndRound.go

@@ -533,6 +533,7 @@ func (sr *subroundEndRound) createAndBroadcastProof(signature []byte, bitmap []b
 		HeaderEpoch:         sr.GetHeader().GetEpoch(),
 		HeaderNonce:         sr.GetHeader().GetNonce(),
 		HeaderShardId:       sr.GetHeader().GetShardID(),
+		HeaderRound:         sr.GetHeader().GetRound(),
 	}
 
 	err := sr.BroadcastMessenger().BroadcastEquivalentProof(headerProof, []byte(sr.SelfPubKey()))

consensus/spos/consensusCore.go

@@ -4,6 +4,7 @@ import (
 	"github.com/multiversx/mx-chain-core-go/data"
 	"github.com/multiversx/mx-chain-core-go/hashing"
 	"github.com/multiversx/mx-chain-core-go/marshal"
+
 	"github.com/multiversx/mx-chain-go/common"
 	cryptoCommon "github.com/multiversx/mx-chain-go/common/crypto"
 	"github.com/multiversx/mx-chain-go/consensus"
@@ -41,6 +42,7 @@ type ConsensusCore struct {
 	signingHandler                consensus.SigningHandler
 	enableEpochsHandler           common.EnableEpochsHandler
 	equivalentProofsPool          consensus.EquivalentProofsPool
+	epochNotifier                 process.EpochNotifier
 }
 
 // ConsensusCoreArgs store all arguments that are needed to create a ConsensusCore object
@@ -69,6 +71,7 @@ type ConsensusCoreArgs struct {
 	SigningHandler                consensus.SigningHandler
 	EnableEpochsHandler           common.EnableEpochsHandler
 	EquivalentProofsPool          consensus.EquivalentProofsPool
+	EpochNotifier                 process.EpochNotifier
 }
 
 // NewConsensusCore creates a new ConsensusCore instance
@@ -100,6 +103,7 @@ func NewConsensusCore(
 		signingHandler:                args.SigningHandler,
 		enableEpochsHandler:           args.EnableEpochsHandler,
 		equivalentProofsPool:          args.EquivalentProofsPool,
+		epochNotifier:                 args.EpochNotifier,
 	}
 
 	err := ValidateConsensusCore(consensusCore)
@@ -180,6 +184,11 @@ func (cc *ConsensusCore) EpochStartRegistrationHandler() epochStart.Registration
 	return cc.epochStartRegistrationHandler
 }
 
+// EpochNotifier returns the epoch notifier
+func (cc *ConsensusCore) EpochNotifier() process.EpochNotifier {
+	return cc.epochNotifier
+}
+
 // PeerHonestyHandler will return the peer honesty handler which will be used in subrounds
 func (cc *ConsensusCore) PeerHonestyHandler() consensus.PeerHonestyHandler {
 	return cc.peerHonestyHandler

consensus/spos/consensusCoreValidator.go

@@ -80,6 +80,9 @@ func ValidateConsensusCore(container ConsensusCoreHandler) error {
 	if check.IfNil(container.EquivalentProofsPool()) {
 		return ErrNilEquivalentProofPool
 	}
+	if check.IfNil(container.EpochNotifier()) {
+		return ErrNilEpochNotifier
+	}
 
 	return nil
 }