Integration tests staking v4

config/epochConfig.go

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

epochStart/metachain/systemSCs.go

@@ -229,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()
@@ -242,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
@@ -267,35 +273,32 @@ func (s *systemSCProcessor) getValidatorTopUpMap(validators []state.ValidatorInf
 	return ret, nil
 }
 
-func compareByXORWithRandomness(pubKey1, pubKey2, randomness []byte) bool {
-	lenPubKey := len(pubKey1)
+func calcNormRand(randomness []byte, expectedLen int) []byte {
 	lenRand := len(randomness)
-
-	minLen := core.MinInt(lenPubKey, lenRand)
-	maxLen := core.MaxInt(lenPubKey, lenRand)
-	repeatedCt := maxLen/minLen + 1
+	minLen := core.MinInt(expectedLen, lenRand)
+	maxLen := core.MaxInt(expectedLen, lenRand)
 
 	rnd := randomness
-	pk1 := pubKey1
-	pk2 := pubKey2
-
-	if lenPubKey > lenRand {
+	if expectedLen > lenRand {
+		repeatedCt := maxLen/minLen + 1
 		rnd = bytes.Repeat(randomness, repeatedCt)
 		rnd = rnd[:maxLen]
 	} else {
-		pk1 = bytes.Repeat(pk1, repeatedCt)
-		pk2 = bytes.Repeat(pk2, repeatedCt)
-
-		pk1 = pk1[:maxLen]
-		pk2 = pk2[:maxLen]
+		rnd = rnd[:minLen]
 	}
 
-	key1Xor := make([]byte, maxLen)
-	key2Xor := make([]byte, maxLen)
+	return rnd
+}
+
+func compareByXORWithRandomness(pubKey1, pubKey2, randomness []byte) bool {
+	xorLen := len(randomness)
+
+	key1Xor := make([]byte, xorLen)
+	key2Xor := make([]byte, xorLen)
 
-	for idx := 0; idx < maxLen; idx++ {
-		key1Xor[idx] = pk1[idx] ^ rnd[idx]
-		key2Xor[idx] = pk2[idx] ^ rnd[idx]
+	for idx := 0; idx < xorLen; idx++ {
+		key1Xor[idx] = pubKey1[idx] ^ randomness[idx]
+		key2Xor[idx] = pubKey2[idx] ^ randomness[idx]
 	}
 
 	return bytes.Compare(key1Xor, key2Xor) == 1

factory/coreComponents.go

@@ -310,16 +310,13 @@ func (ccf *coreComponentsFactory) Create() (*coreComponents, error) {
 	}
 
 	argsNodesShuffler := &nodesCoordinator.NodesShufflerArgs{
-		NodesShard:                               genesisNodesConfig.MinNumberOfShardNodes(),
-		NodesMeta:                                genesisNodesConfig.MinNumberOfMetaNodes(),
-		Hysteresis:                               genesisNodesConfig.GetHysteresis(),
-		Adaptivity:                               genesisNodesConfig.GetAdaptivity(),
-		ShuffleBetweenShards:                     true,
-		MaxNodesEnableConfig:                     ccf.epochConfig.EnableEpochs.MaxNodesChangeEnableEpoch,
-		BalanceWaitingListsEnableEpoch:           ccf.epochConfig.EnableEpochs.BalanceWaitingListsEnableEpoch,
-		WaitingListFixEnableEpoch:                ccf.epochConfig.EnableEpochs.WaitingListFixEnableEpoch,
-		StakingV4EnableEpoch:                     ccf.epochConfig.EnableEpochs.StakingV4EnableEpoch,
-		StakingV4DistributeAuctionToWaitingEpoch: ccf.epochConfig.EnableEpochs.StakingV4DistributeAuctionToWaiting,
+		NodesShard:           genesisNodesConfig.MinNumberOfShardNodes(),
+		NodesMeta:            genesisNodesConfig.MinNumberOfMetaNodes(),
+		Hysteresis:           genesisNodesConfig.GetHysteresis(),
+		Adaptivity:           genesisNodesConfig.GetAdaptivity(),
+		ShuffleBetweenShards: true,
+		MaxNodesEnableConfig: ccf.epochConfig.EnableEpochs.MaxNodesChangeEnableEpoch,
+		EnableEpochs:         ccf.epochConfig.EnableEpochs,
 	}
 
 	nodesShuffler, err := nodesCoordinator.NewHashValidatorsShuffler(argsNodesShuffler)

integrationTests/nodesCoordinatorFactory.go

@@ -42,14 +42,12 @@ func (tpn *IndexHashedNodesCoordinatorFactory) CreateNodesCoordinator(arg ArgInd
 	pubKeyBytes, _ := keys.Pk.ToByteArray()
 
 	nodeShufflerArgs := &nodesCoordinator.NodesShufflerArgs{
-		NodesShard:                     uint32(arg.nodesPerShard),
-		NodesMeta:                      uint32(arg.nbMetaNodes),
-		Hysteresis:                     hysteresis,
-		Adaptivity:                     adaptivity,
-		ShuffleBetweenShards:           shuffleBetweenShards,
-		MaxNodesEnableConfig:           nil,
-		WaitingListFixEnableEpoch:      0,
-		BalanceWaitingListsEnableEpoch: 0,
+		NodesShard:           uint32(arg.nodesPerShard),
+		NodesMeta:            uint32(arg.nbMetaNodes),
+		Hysteresis:           hysteresis,
+		Adaptivity:           adaptivity,
+		ShuffleBetweenShards: shuffleBetweenShards,
+		MaxNodesEnableConfig: nil,
 	}
 
 	nodeShuffler, _ := nodesCoordinator.NewHashValidatorsShuffler(nodeShufflerArgs)
@@ -102,14 +100,12 @@ func (ihncrf *IndexHashedNodesCoordinatorWithRaterFactory) CreateNodesCoordinato
 	pubKeyBytes, _ := keys.Pk.ToByteArray()
 
 	shufflerArgs := &nodesCoordinator.NodesShufflerArgs{
-		NodesShard:                     uint32(arg.nodesPerShard),
-		NodesMeta:                      uint32(arg.nbMetaNodes),
-		Hysteresis:                     hysteresis,
-		Adaptivity:                     adaptivity,
-		ShuffleBetweenShards:           shuffleBetweenShards,
-		MaxNodesEnableConfig:           nil,
-		BalanceWaitingListsEnableEpoch: 0,
-		WaitingListFixEnableEpoch:      0,
+		NodesShard:           uint32(arg.nodesPerShard),
+		NodesMeta:            uint32(arg.nbMetaNodes),
+		Hysteresis:           hysteresis,
+		Adaptivity:           adaptivity,
+		ShuffleBetweenShards: shuffleBetweenShards,
+		MaxNodesEnableConfig: nil,
 	}
 
 	nodeShuffler, _ := nodesCoordinator.NewHashValidatorsShuffler(shufflerArgs)

integrationTests/testProcessorNodeWithMultisigner.go

@@ -477,14 +477,12 @@ func CreateNodesWithNodesCoordinatorAndHeaderSigVerifier(
 	nodesMap := make(map[uint32][]*TestProcessorNode)
 
 	shufflerArgs := &nodesCoordinator.NodesShufflerArgs{
-		NodesShard:                     uint32(nodesPerShard),
-		NodesMeta:                      uint32(nbMetaNodes),
-		Hysteresis:                     hysteresis,
-		Adaptivity:                     adaptivity,
-		ShuffleBetweenShards:           shuffleBetweenShards,
-		MaxNodesEnableConfig:           nil,
-		WaitingListFixEnableEpoch:      0,
-		BalanceWaitingListsEnableEpoch: 0,
+		NodesShard:           uint32(nodesPerShard),
+		NodesMeta:            uint32(nbMetaNodes),
+		Hysteresis:           hysteresis,
+		Adaptivity:           adaptivity,
+		ShuffleBetweenShards: shuffleBetweenShards,
+		MaxNodesEnableConfig: nil,
 	}
 	nodeShuffler, _ := nodesCoordinator.NewHashValidatorsShuffler(shufflerArgs)
 	epochStartSubscriber := notifier.NewEpochStartSubscriptionHandler()

integrationTests/vm/staking/metaBlockProcessorCreator.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ElrondNetwork/elrond-go-core/data"
 	"github.com/ElrondNetwork/elrond-go-core/data/block"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever"
+	"github.com/ElrondNetwork/elrond-go/dataRetriever/dataPool"
 	"github.com/ElrondNetwork/elrond-go/epochStart"
 	"github.com/ElrondNetwork/elrond-go/epochStart/metachain"
 	"github.com/ElrondNetwork/elrond-go/factory"
@@ -86,11 +87,15 @@ func createMetaBlockProcessor(
 			VMContainersFactory:            metaVMFactory,
 			VmContainer:                    vmContainer,
 		},
-		SCToProtocol:                 &mock.SCToProtocolStub{},
-		PendingMiniBlocksHandler:     &mock.PendingMiniBlocksHandlerStub{},
-		EpochStartDataCreator:        epochStartDataCreator,
-		EpochEconomics:               &mock.EpochEconomicsStub{},
-		EpochRewardsCreator:          &testscommon.RewardsCreatorStub{},
+		SCToProtocol:             &mock.SCToProtocolStub{},
+		PendingMiniBlocksHandler: &mock.PendingMiniBlocksHandlerStub{},
+		EpochStartDataCreator:    epochStartDataCreator,
+		EpochEconomics:           &mock.EpochEconomicsStub{},
+		EpochRewardsCreator: &testscommon.RewardsCreatorStub{
+			GetLocalTxCacheCalled: func() epochStart.TransactionCacher {
+				return dataPool.NewCurrentBlockPool()
+			},
+		},
 		EpochValidatorInfoCreator:    valInfoCreator,
 		ValidatorStatisticsProcessor: validatorsInfoCreator,
 		EpochSystemSCProcessor:       systemSCProcessor,

integrationTests/vm/staking/nodesCoordiantorCreator.go

@@ -46,14 +46,16 @@ func createNodesCoordinator(
 	)
 
 	shufflerArgs := &nodesCoordinator.NodesShufflerArgs{
-		NodesShard:                               numOfEligibleNodesPerShard,
-		NodesMeta:                                numOfMetaNodes,
-		Hysteresis:                               hysteresis,
-		Adaptivity:                               adaptivity,
-		ShuffleBetweenShards:                     shuffleBetweenShards,
-		MaxNodesEnableConfig:                     maxNodesConfig,
-		StakingV4EnableEpoch:                     stakingV4EnableEpoch,
-		StakingV4DistributeAuctionToWaitingEpoch: stakingV4DistributeAuctionToWaitingEpoch,
+		NodesShard:           numOfEligibleNodesPerShard,
+		NodesMeta:            numOfMetaNodes,
+		Hysteresis:           hysteresis,
+		Adaptivity:           adaptivity,
+		ShuffleBetweenShards: shuffleBetweenShards,
+		MaxNodesEnableConfig: maxNodesConfig,
+		EnableEpochs: config.EnableEpochs{
+			StakingV4EnableEpoch:                     stakingV4EnableEpoch,
+			StakingV4DistributeAuctionToWaitingEpoch: stakingV4DistributeAuctionToWaitingEpoch,
+		},
 	}
 	nodeShuffler, _ := nodesCoordinator.NewHashValidatorsShuffler(shufflerArgs)
 

sharding/nodesCoordinator/hashValidatorShuffler.go

@@ -16,16 +16,13 @@ var _ NodesShuffler = (*randHashShuffler)(nil)
 
 // NodesShufflerArgs defines the arguments required to create a nodes shuffler
 type NodesShufflerArgs struct {
-	NodesShard                               uint32
-	NodesMeta                                uint32
-	Hysteresis                               float32
-	Adaptivity                               bool
-	ShuffleBetweenShards                     bool
-	MaxNodesEnableConfig                     []config.MaxNodesChangeConfig
-	BalanceWaitingListsEnableEpoch           uint32
-	WaitingListFixEnableEpoch                uint32
-	StakingV4EnableEpoch                     uint32
-	StakingV4DistributeAuctionToWaitingEpoch uint32
+	NodesShard           uint32
+	NodesMeta            uint32
+	Hysteresis           float32
+	Adaptivity           bool
+	ShuffleBetweenShards bool
+	MaxNodesEnableConfig []config.MaxNodesChangeConfig
+	EnableEpochs         config.EnableEpochs
 }
 
 type shuffleNodesArg struct {
@@ -82,9 +79,9 @@ func NewHashValidatorsShuffler(args *NodesShufflerArgs) (*randHashShuffler, erro
 	var configs []config.MaxNodesChangeConfig
 
 	log.Debug("hashValidatorShuffler: enable epoch for max nodes change", "epoch", args.MaxNodesEnableConfig)
-	log.Debug("hashValidatorShuffler: enable epoch for balance waiting lists", "epoch", args.BalanceWaitingListsEnableEpoch)
-	log.Debug("hashValidatorShuffler: enable epoch for staking v4", "epoch", args.StakingV4EnableEpoch)
-	log.Debug("hashValidatorShuffler: enable epoch for staking v4 distribute auction list to waiting list", "epoch", args.StakingV4DistributeAuctionToWaitingEpoch)
+	log.Debug("hashValidatorShuffler: enable epoch for balance waiting lists", "epoch", args.EnableEpochs.BalanceWaitingListsEnableEpoch)
+	log.Debug("hashValidatorShuffler: enable epoch for staking v4", "epoch", args.EnableEpochs.StakingV4EnableEpoch)
+	log.Debug("hashValidatorShuffler: enable epoch for staking v4 distribute auction list to waiting list", "epoch", args.EnableEpochs.StakingV4DistributeAuctionToWaitingEpoch)
 
 	if args.MaxNodesEnableConfig != nil {
 		configs = make([]config.MaxNodesChangeConfig, len(args.MaxNodesEnableConfig))
@@ -95,10 +92,10 @@ func NewHashValidatorsShuffler(args *NodesShufflerArgs) (*randHashShuffler, erro
 	rxs := &randHashShuffler{
 		shuffleBetweenShards:                     args.ShuffleBetweenShards,
 		availableNodesConfigs:                    configs,
-		balanceWaitingListsEnableEpoch:           args.BalanceWaitingListsEnableEpoch,
-		waitingListFixEnableEpoch:                args.WaitingListFixEnableEpoch,
-		stakingV4DistributeAuctionToWaitingEpoch: args.StakingV4DistributeAuctionToWaitingEpoch,
-		stakingV4EnableEpoch:                     args.StakingV4EnableEpoch,
+		balanceWaitingListsEnableEpoch:           args.EnableEpochs.BalanceWaitingListsEnableEpoch,
+		waitingListFixEnableEpoch:                args.EnableEpochs.WaitingListFixEnableEpoch,
+		stakingV4DistributeAuctionToWaitingEpoch: args.EnableEpochs.StakingV4DistributeAuctionToWaitingEpoch,
+		stakingV4EnableEpoch:                     args.EnableEpochs.StakingV4EnableEpoch,
 	}
 
 	log.Debug("randHashShuffler: enable epoch for balance waiting list", "epoch", rxs.balanceWaitingListsEnableEpoch)

sharding/nodesCoordinator/hashValidatorShuffler_test.go

@@ -186,14 +186,15 @@ func testShuffledOut(
 
 func createHashShufflerInter() (*randHashShuffler, error) {
 	shufflerArgs := &NodesShufflerArgs{
-		NodesShard:                               eligiblePerShard,
-		NodesMeta:                                eligiblePerShard,
-		Hysteresis:                               hysteresis,
-		Adaptivity:                               adaptivity,
-		ShuffleBetweenShards:                     true,
-		MaxNodesEnableConfig:                     nil,
-		StakingV4EnableEpoch:                     443,
-		StakingV4DistributeAuctionToWaitingEpoch: 444,
+		NodesShard:           eligiblePerShard,
+		NodesMeta:            eligiblePerShard,
+		Hysteresis:           hysteresis,
+		Adaptivity:           adaptivity,
+		ShuffleBetweenShards: true,
+		EnableEpochs: config.EnableEpochs{
+			StakingV4EnableEpoch:                     443,
+			StakingV4DistributeAuctionToWaitingEpoch: 444,
+		},
 	}
 
 	shuffler, err := NewHashValidatorsShuffler(shufflerArgs)
@@ -203,14 +204,15 @@ func createHashShufflerInter() (*randHashShuffler, error) {
 
 func createHashShufflerIntraShards() (*randHashShuffler, error) {
 	shufflerArgs := &NodesShufflerArgs{
-		NodesShard:                               eligiblePerShard,
-		NodesMeta:                                eligiblePerShard,
-		Hysteresis:                               hysteresis,
-		Adaptivity:                               adaptivity,
-		ShuffleBetweenShards:                     shuffleBetweenShards,
-		MaxNodesEnableConfig:                     nil,
-		StakingV4EnableEpoch:                     443,
-		StakingV4DistributeAuctionToWaitingEpoch: 444,
+		NodesShard:           eligiblePerShard,
+		NodesMeta:            eligiblePerShard,
+		Hysteresis:           hysteresis,
+		Adaptivity:           adaptivity,
+		ShuffleBetweenShards: shuffleBetweenShards,
+		EnableEpochs: config.EnableEpochs{
+			StakingV4EnableEpoch:                     443,
+			StakingV4DistributeAuctionToWaitingEpoch: 444,
+		},
 	}
 	shuffler, err := NewHashValidatorsShuffler(shufflerArgs)
 
@@ -1333,7 +1335,9 @@ func testUpdateNodesAndCheckNumLeaving(t *testing.T, beforeFix bool) {
 				NodesToShufflePerShard: uint32(numNodesToShuffle),
 			},
 		},
-		WaitingListFixEnableEpoch: uint32(waitingListFixEnableEpoch),
+		EnableEpochs: config.EnableEpochs{
+			WaitingListFixEnableEpoch: uint32(waitingListFixEnableEpoch),
+		},
 	}
 
 	shuffler, err := NewHashValidatorsShuffler(shufflerArgs)
@@ -1403,7 +1407,9 @@ func testUpdateNodeListsAndCheckWaitingList(t *testing.T, beforeFix bool) {
 				NodesToShufflePerShard: uint32(numNodesToShuffle),
 			},
 		},
-		WaitingListFixEnableEpoch: uint32(waitingListFixEnableEpoch),
+		EnableEpochs: config.EnableEpochs{
+			WaitingListFixEnableEpoch: uint32(waitingListFixEnableEpoch),
+		},
 	}
 
 	shuffler, err := NewHashValidatorsShuffler(shufflerArgs)
@@ -2379,14 +2385,15 @@ func TestRandHashShuffler_UpdateNodeLists_All(t *testing.T) {
 	unstakeLeavingList, additionalLeavingList := prepareListsFromMaps(unstakeLeaving, additionalLeaving)
 
 	shufflerArgs := &NodesShufflerArgs{
-		NodesShard:                               uint32(eligiblePerShard),
-		NodesMeta:                                uint32(eligiblePerShard),
-		Hysteresis:                               hysteresis,
-		Adaptivity:                               adaptivity,
-		ShuffleBetweenShards:                     shuffleBetweenShards,
-		MaxNodesEnableConfig:                     nil,
-		StakingV4EnableEpoch:                     443,
-		StakingV4DistributeAuctionToWaitingEpoch: 444,
+		NodesShard:           uint32(eligiblePerShard),
+		NodesMeta:            uint32(eligiblePerShard),
+		Hysteresis:           hysteresis,
+		Adaptivity:           adaptivity,
+		ShuffleBetweenShards: shuffleBetweenShards,
+		EnableEpochs: config.EnableEpochs{
+			StakingV4EnableEpoch:                     443,
+			StakingV4DistributeAuctionToWaitingEpoch: 444,
+		},
 	}
 	shuffler, err := NewHashValidatorsShuffler(shufflerArgs)
 	require.Nil(t, err)
@@ -2728,14 +2735,15 @@ func TestRandHashShuffler_UpdateNodeLists_WithNewNodes_WithWaiting_WithLeaving(t
 	}
 
 	shufflerArgs := &NodesShufflerArgs{
-		NodesShard:                               uint32(numEligiblePerShard),
-		NodesMeta:                                uint32(numEligiblePerShard),
-		Hysteresis:                               hysteresis,
-		Adaptivity:                               adaptivity,
-		ShuffleBetweenShards:                     shuffleBetweenShards,
-		MaxNodesEnableConfig:                     nil,
-		StakingV4EnableEpoch:                     443,
-		StakingV4DistributeAuctionToWaitingEpoch: 444,
+		NodesShard:           uint32(numEligiblePerShard),
+		NodesMeta:            uint32(numEligiblePerShard),
+		Hysteresis:           hysteresis,
+		Adaptivity:           adaptivity,
+		ShuffleBetweenShards: shuffleBetweenShards,
+		EnableEpochs: config.EnableEpochs{
+			StakingV4EnableEpoch:                     443,
+			StakingV4DistributeAuctionToWaitingEpoch: 444,
+		},
 	}
 	shuffler, err := NewHashValidatorsShuffler(shufflerArgs)
 	require.Nil(t, err)