Integration tests staking v4

cmd/node/config/enableEpochs.toml

@@ -200,10 +200,18 @@
     # StakingV4EnableEpoch represents the epoch when staking v4 is enabled. Should have a greater value than StakingV4InitEnableEpoch
     StakingV4EnableEpoch = 5
 
+    # StakingV4DistributeAuctionToWaitingEpoch represents the epoch in which selected nodes from auction will be distributed to waiting list
+    StakingV4DistributeAuctionToWaitingEpoch = 6
+
     # MaxNodesChangeEnableEpoch holds configuration for changing the maximum number of nodes and the enabling epoch
     MaxNodesChangeEnableEpoch = [
         { EpochEnable = 0, MaxNumNodes = 36, NodesToShufflePerShard = 4 },
-        { EpochEnable = 1, MaxNumNodes = 56, NodesToShufflePerShard = 2 }
+        { EpochEnable = 1, MaxNumNodes = 56, NodesToShufflePerShard = 2 },
+        # Staking v4 configuration, where:
+        # - Enable epoch = StakingV4DistributeAuctionToWaitingEpoch
+        # - NodesToShufflePerShard = same as previous entry in MaxNodesChangeEnableEpoch
+        # - MaxNumNodes = (MaxNumNodesFromPreviousEpochEnable - (numOfShards+1)*NodesToShufflePerShard)
+        { EpochEnable = 6, MaxNumNodes = 48, NodesToShufflePerShard = 2 },
     ]
 
 [GasSchedule]

config/epochConfig.go

@@ -79,6 +79,7 @@ type EnableEpochs struct {
 	StakeLimitsEnableEpoch                            uint32
 	StakingV4InitEnableEpoch                          uint32
 	StakingV4EnableEpoch                              uint32
+	StakingV4DistributeAuctionToWaitingEpoch          uint32
 }
 
 // GasScheduleByEpochs represents a gas schedule toml entry that will be applied from the provided epoch

epochStart/metachain/legacySystemSCs.go

@@ -46,6 +46,7 @@ type legacySystemSCProcessor struct {
 	mapNumSwitchedPerShard   map[uint32]uint32
 	mapNumSwitchablePerShard map[uint32]uint32
 	maxNodesEnableConfig     []config.MaxNodesChangeConfig
+	currentNodesEnableConfig config.MaxNodesChangeConfig
 	maxNodes                 uint32
 
 	switchEnableEpoch           uint32
@@ -56,6 +57,7 @@ type legacySystemSCProcessor struct {
 	esdtEnableEpoch             uint32
 	saveJailedAlwaysEnableEpoch uint32
 	stakingV4InitEnableEpoch    uint32
+	stakingV4EnableEpoch        uint32
 
 	flagSwitchJailedWaiting        atomic.Flag
 	flagHystNodesEnabled           atomic.Flag
@@ -101,6 +103,7 @@ func newLegacySystemSCProcessor(args ArgsNewEpochStartSystemSCProcessing) (*lega
 		esdtOwnerAddressBytes:       args.ESDTOwnerAddressBytes,
 		saveJailedAlwaysEnableEpoch: args.EpochConfig.EnableEpochs.SaveJailedAlwaysEnableEpoch,
 		stakingV4InitEnableEpoch:    args.EpochConfig.EnableEpochs.StakingV4InitEnableEpoch,
+		stakingV4EnableEpoch:        args.EpochConfig.EnableEpochs.StakingV4EnableEpoch,
 	}
 
 	log.Debug("legacySystemSC: enable epoch for switch jail waiting", "epoch", legacy.switchEnableEpoch)
@@ -111,6 +114,7 @@ func newLegacySystemSCProcessor(args ArgsNewEpochStartSystemSCProcessing) (*lega
 	log.Debug("legacySystemSC: enable epoch for correct last unjailed", "epoch", legacy.correctLastUnJailEpoch)
 	log.Debug("legacySystemSC: enable epoch for save jailed always", "epoch", legacy.saveJailedAlwaysEnableEpoch)
 	log.Debug("legacySystemSC: enable epoch for initializing staking v4", "epoch", legacy.stakingV4InitEnableEpoch)
+	log.Debug("legacySystemSC: enable epoch for staking v4", "epoch", legacy.stakingV4EnableEpoch)
 
 	legacy.maxNodesEnableConfig = make([]config.MaxNodesChangeConfig, len(args.MaxNodesEnableConfig))
 	copy(legacy.maxNodesEnableConfig, args.MaxNodesEnableConfig)
@@ -615,10 +619,6 @@ func (s *legacySystemSCProcessor) updateMaxNodes(validatorsInfoMap state.ShardVa
 		return err
 	}
 
-	if maxNumberOfNodes < prevMaxNumberOfNodes {
-		return epochStart.ErrInvalidMaxNumberOfNodes
-	}
-
 	if s.flagStakingQueueEnabled.IsSet() {
 		sw.Start("stakeNodesFromQueue")
 		err = s.stakeNodesFromQueue(validatorsInfoMap, maxNumberOfNodes-prevMaxNumberOfNodes, nonce, common.NewList)
@@ -1364,6 +1364,7 @@ func (s *legacySystemSCProcessor) legacyEpochConfirmed(epoch uint32) {
 		if epoch == maxNodesConfig.EpochEnable {
 			s.flagChangeMaxNodesEnabled.SetValue(true)
 			s.maxNodes = maxNodesConfig.MaxNumNodes
+			s.currentNodesEnableConfig = maxNodesConfig
 			break
 		}
 	}
@@ -1387,7 +1388,7 @@ func (s *legacySystemSCProcessor) legacyEpochConfirmed(epoch uint32) {
 	s.flagCorrectLastUnjailedEnabled.SetValue(epoch == s.correctLastUnJailEpoch)
 	log.Debug("legacySystemSC: correct last unjailed", "enabled", s.flagCorrectLastUnjailedEnabled.IsSet())
 
-	s.flagCorrectNumNodesToStake.SetValue(epoch >= s.correctLastUnJailEpoch)
+	s.flagCorrectNumNodesToStake.SetValue(epoch >= s.correctLastUnJailEpoch && epoch < s.stakingV4EnableEpoch)
 	log.Debug("legacySystemSC: correct last unjailed", "enabled", s.flagCorrectNumNodesToStake.IsSet())
 
 	s.flagESDTEnabled.SetValue(epoch == s.esdtEnableEpoch)

epochStart/metachain/systemSCs.go

@@ -54,7 +54,6 @@ type systemSCProcessor struct {
 
 	governanceEnableEpoch    uint32
 	builtInOnMetaEnableEpoch uint32
-	stakingV4EnableEpoch     uint32
 
 	flagGovernanceEnabled    atomic.Flag
 	flagBuiltInOnMetaEnabled atomic.Flag
@@ -77,7 +76,6 @@ func NewSystemSCProcessor(args ArgsNewEpochStartSystemSCProcessing) (*systemSCPr
 		legacySystemSCProcessor:  legacy,
 		governanceEnableEpoch:    args.EpochConfig.EnableEpochs.GovernanceEnableEpoch,
 		builtInOnMetaEnableEpoch: args.EpochConfig.EnableEpochs.BuiltInFunctionOnMetaEnableEpoch,
-		stakingV4EnableEpoch:     args.EpochConfig.EnableEpochs.StakingV4EnableEpoch,
 	}
 
 	log.Debug("systemSC: enable epoch for governanceV2 init", "epoch", s.governanceEnableEpoch)
@@ -150,20 +148,46 @@ func (s *systemSCProcessor) processWithNewFlags(
 	return nil
 }
 
+// TODO: Staking v4: perhaps create a subcomponent which handles selection, which would be also very useful in tests
 func (s *systemSCProcessor) selectNodesFromAuctionList(validatorsInfoMap state.ShardValidatorsInfoMapHandler, randomness []byte) error {
-	auctionList, numOfValidators := getAuctionListAndNumOfValidators(validatorsInfoMap)
-	availableSlots := s.maxNodes - numOfValidators
-	if availableSlots <= 0 {
-		log.Info("not enough available slots for auction nodes; skip selecting nodes from auction list")
+	auctionList, currNumOfValidators := getAuctionListAndNumOfValidators(validatorsInfoMap)
+	numOfShuffledNodes := s.currentNodesEnableConfig.NodesToShufflePerShard * (s.shardCoordinator.NumberOfShards() + 1)
+
+	numOfValidatorsAfterShuffling, err := safeSub(currNumOfValidators, numOfShuffledNodes)
+	if err != nil {
+		log.Warn(fmt.Sprintf("%v when trying to compute numOfValidatorsAfterShuffling = %v - %v (currNumOfValidators - numOfShuffledNodes)",
+			err,
+			currNumOfValidators,
+			numOfShuffledNodes,
+		))
+		numOfValidatorsAfterShuffling = 0
+	}
+
+	availableSlots, err := safeSub(s.maxNodes, numOfValidatorsAfterShuffling)
+	if availableSlots == 0 || err != nil {
+		log.Info(fmt.Sprintf("%v or zero value when trying to compute availableSlots = %v - %v (maxNodes - numOfValidatorsAfterShuffling); skip selecting nodes from auction list",
+			err,
+			s.maxNodes,
+			numOfValidatorsAfterShuffling,
+		))
 		return nil
 	}
 
-	err := s.sortAuctionList(auctionList, randomness)
+	auctionListSize := uint32(len(auctionList))
+	log.Info("systemSCProcessor.selectNodesFromAuctionList",
+		"max nodes", s.maxNodes,
+		"current number of validators", currNumOfValidators,
+		"num of nodes which will be shuffled out", numOfShuffledNodes,
+		"num of validators after shuffling", numOfValidatorsAfterShuffling,
+		"auction list size", auctionListSize,
+		fmt.Sprintf("available slots (%v -%v)", s.maxNodes, numOfValidatorsAfterShuffling), availableSlots,
+	)
+
+	err = s.sortAuctionList(auctionList, randomness)
 	if err != nil {
 		return err
 	}
 
-	auctionListSize := uint32(len(auctionList))
 	numOfAvailableNodeSlots := core.MinUint32(auctionListSize, availableSlots)
 	s.displayAuctionList(auctionList, numOfAvailableNodeSlots)
 
@@ -179,6 +203,14 @@ func (s *systemSCProcessor) selectNodesFromAuctionList(validatorsInfoMap state.S
 	return nil
 }
 
+// TODO: Move this in elrond-go-core
+func safeSub(a, b uint32) (uint32, error) {
+	if a < b {
+		return 0, core.ErrSubtractionOverflow
+	}
+	return a - b, nil
+}
+
 func getAuctionListAndNumOfValidators(validatorsInfoMap state.ShardValidatorsInfoMapHandler) ([]state.ValidatorInfoHandler, uint32) {
 	auctionList := make([]state.ValidatorInfoHandler, 0)
 	numOfValidators := uint32(0)
@@ -197,11 +229,17 @@ func getAuctionListAndNumOfValidators(validatorsInfoMap state.ShardValidatorsInf
 }
 
 func (s *systemSCProcessor) sortAuctionList(auctionList []state.ValidatorInfoHandler, randomness []byte) error {
+	if len(auctionList) == 0 {
+		return nil
+	}
+
 	validatorTopUpMap, err := s.getValidatorTopUpMap(auctionList)
 	if err != nil {
 		return fmt.Errorf("%w: %v", epochStart.ErrSortAuctionList, err)
 	}
 
+	pubKeyLen := len(auctionList[0].GetPublicKey())
+	normRandomness := calcNormRand(randomness, pubKeyLen)
 	sort.SliceStable(auctionList, func(i, j int) bool {
 		pubKey1 := auctionList[i].GetPublicKey()
 		pubKey2 := auctionList[j].GetPublicKey()
@@ -210,7 +248,7 @@ func (s *systemSCProcessor) sortAuctionList(auctionList []state.ValidatorInfoHan
 		nodeTopUpPubKey2 := validatorTopUpMap[string(pubKey2)]
 
 		if nodeTopUpPubKey1.Cmp(nodeTopUpPubKey2) == 0 {
-			return compareByXORWithRandomness(pubKey1, pubKey2, randomness)
+			return compareByXORWithRandomness(pubKey1, pubKey2, normRandomness)
 		}
 
 		return nodeTopUpPubKey1.Cmp(nodeTopUpPubKey2) > 0
@@ -235,13 +273,26 @@ func (s *systemSCProcessor) getValidatorTopUpMap(validators []state.ValidatorInf
 	return ret, nil
 }
 
+func calcNormRand(randomness []byte, expectedLen int) []byte {
+	rand := randomness
+	randLen := len(rand)
+
+	if expectedLen > randLen {
+		repeatedCt := expectedLen/randLen + 1
+		rand = bytes.Repeat(randomness, repeatedCt)
+	}
+
+	rand = rand[:expectedLen]
+	return rand
+}
+
 func compareByXORWithRandomness(pubKey1, pubKey2, randomness []byte) bool {
-	minLen := core.MinInt(len(pubKey1), len(randomness))
+	xorLen := len(randomness)
 
-	key1Xor := make([]byte, minLen)
-	key2Xor := make([]byte, minLen)
+	key1Xor := make([]byte, xorLen)
+	key2Xor := make([]byte, xorLen)
 
-	for idx := 0; idx < minLen; idx++ {
+	for idx := 0; idx < xorLen; idx++ {
 		key1Xor[idx] = pubKey1[idx] ^ randomness[idx]
 		key2Xor[idx] = pubKey2[idx] ^ randomness[idx]
 	}