Filter auction nodes list

cmd/node/config/enableEpochs.toml

@@ -191,6 +191,9 @@
     # all nodes from staking queue are moved in the auction list
     StakingV4InitEnableEpoch = 4
 
+    # StakingV4EnableEpoch represents the epoch when staking v4 is enabled. Should have a greater value than StakingV4InitEnableEpoch
+    StakingV4EnableEpoch = 5
+
     # MaxNodesChangeEnableEpoch holds configuration for changing the maximum number of nodes and the enabling epoch
     MaxNodesChangeEnableEpoch = [
         { EpochEnable = 0, MaxNumNodes = 36, NodesToShufflePerShard = 4 },

config/epochConfig.go

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

epochStart/errors.go

@@ -334,3 +334,6 @@ var ErrNilScheduledDataSyncerFactory = errors.New("nil scheduled data syncer fac
 
 // ErrCouldNotInitLiquidStakingSystemSC signals that liquid staking system sc init failed
 var ErrCouldNotInitLiquidStakingSystemSC = errors.New("could not init liquid staking system sc")
+
+// ErrSortAuctionList signals that an error occurred while trying to sort auction list
+var ErrSortAuctionList = errors.New("error while trying to sort auction list")

epochStart/interface.go

@@ -158,9 +158,10 @@ type StakingDataProvider interface {
 	GetTotalStakeEligibleNodes() *big.Int
 	GetTotalTopUpStakeEligibleNodes() *big.Int
 	GetNodeStakedTopUp(blsKey []byte) (*big.Int, error)
-	PrepareStakingDataForRewards(keys map[uint32][][]byte) error
+	PrepareStakingData(keys map[uint32][][]byte) error
 	FillValidatorInfo(blsKey []byte) error
 	ComputeUnQualifiedNodes(validatorInfos map[uint32][]*state.ValidatorInfo) ([][]byte, map[string][][]byte, error)
+	GetBlsKeyOwner(blsKey []byte) (string, error)
 	Clean()
 	IsInterfaceNil() bool
 }

epochStart/metachain/stakingDataProvider.go

@@ -91,7 +91,7 @@ func (sdp *stakingDataProvider) GetTotalTopUpStakeEligibleNodes() *big.Int {
 
 // GetNodeStakedTopUp returns the owner of provided bls key staking stats for the current epoch
 func (sdp *stakingDataProvider) GetNodeStakedTopUp(blsKey []byte) (*big.Int, error) {
-	owner, err := sdp.getBlsKeyOwner(blsKey)
+	owner, err := sdp.GetBlsKeyOwner(blsKey)
 	if err != nil {
 		log.Debug("GetOwnerStakingStats", "key", hex.EncodeToString(blsKey), "error", err)
 		return nil, err
@@ -105,8 +105,8 @@ func (sdp *stakingDataProvider) GetNodeStakedTopUp(blsKey []byte) (*big.Int, err
 	return ownerInfo.topUpPerNode, nil
 }
 
-// PrepareStakingDataForRewards prepares the staking data for the given map of node keys per shard
-func (sdp *stakingDataProvider) PrepareStakingDataForRewards(keys map[uint32][][]byte) error {
+// PrepareStakingData prepares the staking data for the given map of node keys per shard
+func (sdp *stakingDataProvider) PrepareStakingData(keys map[uint32][][]byte) error {
 	sdp.Clean()
 
 	for _, keysList := range keys {
@@ -163,7 +163,7 @@ func (sdp *stakingDataProvider) FillValidatorInfo(blsKey []byte) error {
 }
 
 func (sdp *stakingDataProvider) getAndFillOwnerStatsFromSC(blsKey []byte) (*ownerStats, error) {
-	owner, err := sdp.getBlsKeyOwner(blsKey)
+	owner, err := sdp.GetBlsKeyOwner(blsKey)
 	if err != nil {
 		log.Debug("error fill owner stats", "step", "get owner from bls", "key", hex.EncodeToString(blsKey), "error", err)
 		return nil, err
@@ -195,7 +195,8 @@ func (sdp *stakingDataProvider) loadDataForBlsKey(blsKey []byte) error {
 	return nil
 }
 
-func (sdp *stakingDataProvider) getBlsKeyOwner(blsKey []byte) (string, error) {
+// GetBlsKeyOwner returns the owner's public key of the provided bls key
+func (sdp *stakingDataProvider) GetBlsKeyOwner(blsKey []byte) (string, error) {
 	vmInput := &vmcommon.ContractCallInput{
 		VMInput: vmcommon.VMInput{
 			CallerAddr: vm.ValidatorSCAddress,

epochStart/metachain/stakingDataProvider_test.go

@@ -366,7 +366,7 @@ func TestStakingDataProvider_PrepareStakingDataForRewards(t *testing.T) {
 
 	keys := make(map[uint32][][]byte)
 	keys[0] = append(keys[0], []byte("owner"))
-	err := sdp.PrepareStakingDataForRewards(keys)
+	err := sdp.PrepareStakingData(keys)
 	require.NoError(t, err)
 }
 

epochStart/metachain/systemSCs.go

@@ -13,7 +13,9 @@ import (
 	"github.com/ElrondNetwork/elrond-go-core/core/check"
 	"github.com/ElrondNetwork/elrond-go-core/data"
 	"github.com/ElrondNetwork/elrond-go-core/data/block"
+	"github.com/ElrondNetwork/elrond-go-core/display"
 	"github.com/ElrondNetwork/elrond-go-core/marshal"
+	logger "github.com/ElrondNetwork/elrond-go-logger"
 	"github.com/ElrondNetwork/elrond-go/common"
 	vInfo "github.com/ElrondNetwork/elrond-go/common/validatorInfo"
 	"github.com/ElrondNetwork/elrond-go/config"
@@ -73,6 +75,7 @@ type systemSCProcessor struct {
 	governanceEnableEpoch          uint32
 	builtInOnMetaEnableEpoch       uint32
 	stakingV4InitEnableEpoch       uint32
+	stakingV4EnableEpoch           uint32
 	maxNodesEnableConfig           []config.MaxNodesChangeConfig
 	maxNodes                       uint32
 	flagSwitchJailedWaiting        atomic.Flag
@@ -89,6 +92,7 @@ type systemSCProcessor struct {
 	flagBuiltInOnMetaEnabled       atomic.Flag
 	flagInitStakingV4Enabled       atomic.Flag
 	flagStakingQueueEnabled        atomic.Flag
+	flagStakingV4Enabled           atomic.Flag
 	esdtOwnerAddressBytes          []byte
 	mapNumSwitchedPerShard         map[uint32]uint32
 	mapNumSwitchablePerShard       map[uint32]uint32
@@ -186,6 +190,7 @@ func NewSystemSCProcessor(args ArgsNewEpochStartSystemSCProcessing) (*systemSCPr
 		governanceEnableEpoch:       args.EpochConfig.EnableEpochs.GovernanceEnableEpoch,
 		builtInOnMetaEnableEpoch:    args.EpochConfig.EnableEpochs.BuiltInFunctionOnMetaEnableEpoch,
 		stakingV4InitEnableEpoch:    args.EpochConfig.EnableEpochs.StakingV4InitEnableEpoch,
+		stakingV4EnableEpoch:        args.EpochConfig.EnableEpochs.StakingV4EnableEpoch,
 	}
 
 	log.Debug("systemSC: enable epoch for switch jail waiting", "epoch", s.switchEnableEpoch)
@@ -197,7 +202,8 @@ func NewSystemSCProcessor(args ArgsNewEpochStartSystemSCProcessing) (*systemSCPr
 	log.Debug("systemSC: enable epoch for save jailed always", "epoch", s.saveJailedAlwaysEnableEpoch)
 	log.Debug("systemSC: enable epoch for governanceV2 init", "epoch", s.governanceEnableEpoch)
 	log.Debug("systemSC: enable epoch for create NFT on meta", "epoch", s.builtInOnMetaEnableEpoch)
-	log.Debug("systemSC: enable epoch for staking v4", "epoch", s.stakingV4InitEnableEpoch)
+	log.Debug("systemSC: enable epoch for initializing staking v4", "epoch", s.stakingV4InitEnableEpoch)
+	log.Debug("systemSC: enable epoch for staking v4", "epoch", s.stakingV4EnableEpoch)
 
 	s.maxNodesEnableConfig = make([]config.MaxNodesChangeConfig, len(args.MaxNodesEnableConfig))
 	copy(s.maxNodesEnableConfig, args.MaxNodesEnableConfig)
@@ -214,6 +220,7 @@ func (s *systemSCProcessor) ProcessSystemSmartContract(
 	validatorInfos map[uint32][]*state.ValidatorInfo,
 	nonce uint64,
 	epoch uint32,
+	randomness []byte,
 ) error {
 	if s.flagHystNodesEnabled.IsSet() {
 		err := s.updateSystemSCConfigMinNodes()
@@ -327,9 +334,149 @@ func (s *systemSCProcessor) ProcessSystemSmartContract(
 		}
 	}
 
+	if s.flagStakingV4Enabled.IsSet() {
+		allNodesKeys := s.getAllNodeKeys(validatorInfos)
+
+		err := s.stakingDataProvider.PrepareStakingData(allNodesKeys)
+		if err != nil {
+			return err
+		}
+
+		err = s.selectNodesFromAuctionList(validatorInfos, randomness)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *systemSCProcessor) selectNodesFromAuctionList(validatorInfoMap map[uint32][]*state.ValidatorInfo, randomness []byte) error {
+	auctionList, numOfValidators := getAuctionListAndNumOfValidators(validatorInfoMap)
+	err := s.sortAuctionList(auctionList, randomness)
+	if err != nil {
+		return err
+	}
+
+	auctionListSize := uint32(len(auctionList))
+	numOfAvailableNodeSlots := core.MinUint32(auctionListSize, s.maxNodes-numOfValidators)
+	s.displayAuctionList(auctionList, numOfAvailableNodeSlots)
+
+	for i := uint32(0); i < numOfAvailableNodeSlots; i++ {
+		auctionList[i].List = string(common.NewList)
+	}
+
 	return nil
 }
 
+func getAuctionListAndNumOfValidators(validatorInfoMap map[uint32][]*state.ValidatorInfo) ([]*state.ValidatorInfo, uint32) {
+	auctionList := make([]*state.ValidatorInfo, 0)
+	numOfValidators := uint32(0)
+
+	for _, validatorsInShard := range validatorInfoMap {
+		for _, validator := range validatorsInShard {
+			if validator.List == string(common.AuctionList) {
+				auctionList = append(auctionList, validator)
+				continue
+			}
+			if isValidator(validator) {
+				numOfValidators++
+			}
+		}
+	}
+
+	return auctionList, numOfValidators
+}
+
+func (s *systemSCProcessor) sortAuctionList(auctionList []*state.ValidatorInfo, randomness []byte) error {
+	validatorTopUpMap, err := s.getValidatorTopUpMap(auctionList)
+	if err != nil {
+		return fmt.Errorf("%w: %v", epochStart.ErrSortAuctionList, err)
+	}
+
+	sort.SliceStable(auctionList, func(i, j int) bool {
+		pubKey1 := auctionList[i].PublicKey
+		pubKey2 := auctionList[j].PublicKey
+
+		nodeTopUpPubKey1 := validatorTopUpMap[string(pubKey1)]
+		nodeTopUpPubKey2 := validatorTopUpMap[string(pubKey2)]
+
+		if nodeTopUpPubKey1.Cmp(nodeTopUpPubKey2) == 0 {
+			return compareByXORWithRandomness(pubKey1, pubKey2, randomness)
+		}
+
+		return nodeTopUpPubKey1.Cmp(nodeTopUpPubKey2) == 1
+	})
+
+	return nil
+}
+
+func (s *systemSCProcessor) getValidatorTopUpMap(validators []*state.ValidatorInfo) (map[string]*big.Int, error) {
+	ret := make(map[string]*big.Int, len(validators))
+
+	for _, validator := range validators {
+		pubKey := validator.PublicKey
+		topUp, err := s.stakingDataProvider.GetNodeStakedTopUp(pubKey)
+		if err != nil {
+			return nil, fmt.Errorf("%w when trying to get top up per node for %s", err, hex.EncodeToString(pubKey))
+		}
+
+		ret[string(pubKey)] = topUp
+	}
+
+	return ret, nil
+}
+
+func compareByXORWithRandomness(pubKey1, pubKey2, randomness []byte) bool {
+	minLen := core.MinInt(len(pubKey1), len(randomness))
+
+	key1Xor := make([]byte, minLen)
+	key2Xor := make([]byte, minLen)
+
+	for idx := 0; idx < minLen; idx++ {
+		key1Xor[idx] = pubKey1[idx] ^ randomness[idx]
+		key2Xor[idx] = pubKey2[idx] ^ randomness[idx]
+	}
+
+	return bytes.Compare(key1Xor, key2Xor) == 1
+}
+
+func (s *systemSCProcessor) displayAuctionList(auctionList []*state.ValidatorInfo, numOfSelectedNodes uint32) {
+	if log.GetLevel() > logger.LogDebug {
+		return
+	}
+
+	tableHeader := []string{"Owner", "Registered key", "TopUp per node"}
+	lines := make([]*display.LineData, 0, len(auctionList))
+	horizontalLine := false
+	for idx, validator := range auctionList {
+		pubKey := validator.GetPublicKey()
+
+		owner, err := s.stakingDataProvider.GetBlsKeyOwner(pubKey)
+		log.LogIfError(err)
+
+		topUp, err := s.stakingDataProvider.GetNodeStakedTopUp(pubKey)
+		log.LogIfError(err)
+
+		horizontalLine = uint32(idx) == numOfSelectedNodes-1
+		line := display.NewLineData(horizontalLine, []string{
+			hex.EncodeToString([]byte(owner)),
+			hex.EncodeToString(pubKey),
+			topUp.String(),
+		})
+		lines = append(lines, line)
+	}
+
+	table, err := display.CreateTableString(tableHeader, lines)
+	if err != nil {
+		log.Error("could not create table", "error", err)
+		return
+	}
+
+	message := fmt.Sprintf("Auction list\n%s", table)
+	log.Debug(message)
+}
+
 // ToggleUnStakeUnBond will pause/unPause the unStake/unBond functions on the validator system sc
 func (s *systemSCProcessor) ToggleUnStakeUnBond(value bool) error {
 	if !s.flagStakingV2Enabled.IsSet() {
@@ -568,7 +715,7 @@ func (s *systemSCProcessor) prepareStakingDataForRewards(eligibleNodesKeys map[u
 		log.Debug("systemSCProcessor.prepareStakingDataForRewards time measurements", sw.GetMeasurements()...)
 	}()
 
-	return s.stakingDataProvider.PrepareStakingDataForRewards(eligibleNodesKeys)
+	return s.stakingDataProvider.PrepareStakingData(eligibleNodesKeys)
 }
 
 func (s *systemSCProcessor) getEligibleNodesKeyMapOfType(
@@ -587,6 +734,20 @@ func (s *systemSCProcessor) getEligibleNodesKeyMapOfType(
 	return eligibleNodesKeys
 }
 
+func (s *systemSCProcessor) getAllNodeKeys(
+	validatorsInfo map[uint32][]*state.ValidatorInfo,
+) map[uint32][][]byte {
+	nodeKeys := make(map[uint32][][]byte)
+	for shardID, validatorsInfoSlice := range validatorsInfo {
+		nodeKeys[shardID] = make([][]byte, 0, s.nodesConfigProvider.ConsensusGroupSize(shardID))
+		for _, validatorInfo := range validatorsInfoSlice {
+			nodeKeys[shardID] = append(nodeKeys[shardID], validatorInfo.PublicKey)
+		}
+	}
+
+	return nodeKeys
+}
+
 func getRewardsMiniBlockForMeta(miniBlocks block.MiniBlockSlice) *block.MiniBlock {
 	for _, miniBlock := range miniBlocks {
 		if miniBlock.Type != block.RewardsBlock {
@@ -1605,4 +1766,7 @@ func (s *systemSCProcessor) EpochConfirmed(epoch uint32, _ uint64) {
 
 	s.flagStakingQueueEnabled.SetValue(epoch < s.stakingV4InitEnableEpoch)
 	log.Debug("systemProcessor: staking queue on meta", "enabled", s.flagStakingQueueEnabled.IsSet())
+
+	s.flagStakingV4Enabled.SetValue(epoch >= s.stakingV4EnableEpoch)
+	log.Debug("systemProcessor: staking queue on meta", "enabled", s.flagStakingV4Enabled.IsSet())
 }