Feat/staking delegation v2

cmd/node/config/config.toml

@@ -12,13 +12,13 @@
    StartInEpochEnabled = true
 
    # SCDeployEnableEpoch represents the epoch when the deployment of smart contracts will be enabled
-   SCDeployEnableEpoch = 2
+   SCDeployEnableEpoch = 3
 
    # BuiltInFunctionsEnableEpoch represents the epoch when the built in functions will be enabled
-   BuiltInFunctionsEnableEpoch = 2
+   BuiltInFunctionsEnableEpoch = 3
 
    # RelayedTransactionsEnableEpoch represents the epoch when the relayed transactions will be enabled
-   RelayedTransactionsEnableEpoch = 2
+   RelayedTransactionsEnableEpoch = 3
 
    # PenalizedTooMuchGasEnableEpoch represents the epoch when the penalization for using too much gas will be enabled
    PenalizedTooMuchGasEnableEpoch = 2
@@ -35,16 +35,23 @@
 
     # TransactionSignedWithTxHashEnableEpoch represents the epoch when the node will also accept transactions that are
     # signed with the hash of transaction
-    TransactionSignedWithTxHashEnableEpoch = 2
+    TransactionSignedWithTxHashEnableEpoch = 3
 
    # MetaProtectionEnableEpoch represents the epoch when the transactions to the metachain are checked to have enough gas
-   MetaProtectionEnableEpoch = 2
+   MetaProtectionEnableEpoch = 3
 
    # AheadOfTimeGasUsageEnableEpoch represents the epoch when the cost of smart contract prepare changes from compiler per byte to ahead of time prepare per byte
-   AheadOfTimeGasUsageEnableEpoch = 2
+   AheadOfTimeGasUsageEnableEpoch = 3
 
    # GasPriceModifierEnableEpoch represents the epoch when the gas price modifier in fee computation is enabled
-   GasPriceModifierEnableEpoch = 2
+   GasPriceModifierEnableEpoch = 3
+
+   # TO BE CHANGED IN MAINNET AND PUBLIC TESTNET CONFIGS
+   # MaxNodesChangeEnableEpoch holds configuration for changing the maximum number of nodes and the enabling epoch
+   MaxNodesChangeEnableEpoch = [
+        { EpochEnable = 0, MaxNumNodes = 36, NodesToShufflePerShard = 4 },
+        { EpochEnable = 3, MaxNumNodes = 56, NodesToShufflePerShard = 2 }
+   ]
 
    # GenesisString represents the encoded string for the genesis block
    GenesisString = "67656E65736973"
@@ -65,7 +72,7 @@
 [GasSchedule]
     GasScheduleByEpochs = [
         { StartEpoch = 0, FileName = "gasScheduleV1.toml" },
-        { StartEpoch = 2, FileName = "gasScheduleV2.toml" },
+        { StartEpoch = 3, FileName = "gasScheduleV2.toml" },
     ]
 
 [StoragePruning]

cmd/node/config/economics.toml

@@ -18,10 +18,12 @@
     Denomination = 18 # represents the smallest eGLD subdivision (10^-X eGLD for a denomination of X)
 
 [RewardsSettings]
-    LeaderPercentage = 0.1 #fraction of value 1 - 10%
-    DeveloperPercentage = 0.3 #fraction of value 1 - 30%
+    LeaderPercentage = 0.1 #fraction of value 0.1 - 10%
+    DeveloperPercentage = 0.3 #fraction of value 0.3 - 30%
     ProtocolSustainabilityPercentage = 0.1 #fraction of value 0.1 - 10%
     ProtocolSustainabilityAddress = "erd1j25xk97yf820rgdp3mj5scavhjkn6tjyn0t63pmv5qyjj7wxlcfqqe2rw5"
+    TopUpGradientPoint = "3000000000000000000000000" # 3MIL eGLD
+    TopUpFactor = 0.25 # fraction of value 0.25 - 25%
 
 [FeeSettings]
     MaxGasLimitPerBlock     = "1500000000"

cmd/node/config/gasSchedules/gasScheduleV1.toml

@@ -22,6 +22,10 @@
     DelegateVote        = 1000000
     RevokeVote          = 500000
     CloseProposal       = 1000000
+    DelegationOps       = 1000000
+    UnstakeTokens       = 5000000
+    UnbondTokens        = 5000000
+    DelegationMgrOps    = 50000000
 
 [BaseOperationCost]
     StorePerByte      = 50000

cmd/node/config/gasSchedules/gasScheduleV2.toml

@@ -15,6 +15,8 @@
     ChangeRewardAddress = 5000000
     ChangeValidatorKeys = 5000000
     UnJail              = 5000000
+    DelegationOps       = 1000000
+    DelegationMgrOps    = 50000000
     ESDTIssue           = 50000000
     ESDTOperations      = 50000000
     Proposal            = 5000000

cmd/node/config/genesisSmartContracts.json

@@ -3,7 +3,7 @@
     "owner": "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80",
     "filename": "./config/genesisContracts/delegation.wasm",
     "vm-type": "0500",
-    "init-parameters": "%auction_sc_address%@03E8@00@030D40@030D40",
+    "init-parameters": "%validator_sc_address%@03E8@00@030D40@030D40",
     "type": "delegation",
     "version": "0.4.*"
   },

cmd/node/config/systemSmartContractsConfig.toml

@@ -1,28 +1,39 @@
 [StakingSystemSCConfig]
     GenesisNodePrice = "2500000000000000000000" #2.5K eGLD
     MinStakeValue = "100000000000000000000" #100 eGLD
+    MinUnstakeTokensValue = "10000000000000000000" #10eGLD
     UnBondPeriod = 250
     MinStepValue = "100000000000000000000"
-    AuctionEnableEpoch = 100000
     StakeEnableEpoch = 2
-    DoubleKeyProtectionEnableEpoch = 2
+    StakingV2Epoch = 3
+    DoubleKeyProtectionEnableEpoch = 3
     NumRoundsWithoutBleed = 100
     MaximumPercentageToBleed = 0.5
     BleedPercentagePerRound = 0.00001
     MaxNumberOfNodesForStake = 36
-    NodesToSelectInAuction = 36
     UnJailValue = "2500000000000000000" #0.1% of genesis node price
     ActivateBLSPubKeyMessageVerification = false
 
 [ESDTSystemSCConfig]
     BaseIssuingCost = "5000000000000000000" #5 eGLD
     OwnerAddress = "erd1fpkcgel4gcmh8zqqdt043yfcn5tyx8373kg6q2qmkxzu4dqamc0swts65c"
-    EnabledEpoch = 2
+    EnabledEpoch = 3
 
 [GovernanceSystemSCConfig]
     ProposalCost = "5000000000000000000" #5 eGLD
     NumNodes     = 500
     MinQuorum    = 400
     MinPassThreshold = 300
     MinVetoThreshold = 50
-    EnabledEpoch = 2
+    EnabledEpoch = 3
+
+[DelegationManagerSystemSCConfig]
+    BaseIssuingCost = "0" #0 eGLD
+    MinCreationDeposit = "1250000000000000000000" #1.25K eGLD
+    EnabledEpoch = 3
+
+[DelegationSystemSCConfig]
+    MinStakeAmount = "10000000000000000000" #10 eGLD
+    EnabledEpoch   = 3
+    MinServiceFee  = 0
+    MaxServiceFee  = 10000

cmd/node/factory/structs.go

@@ -1869,19 +1869,20 @@ func newMetaBlockProcessor(
 		WorkingDir:         workingDir,
 		NilCompiledSCStore: false,
 	}
-	vmFactory, err := metachain.NewVMContainerFactory(
-		argsHook,
-		economicsData,
-		messageSignVerifier,
-		gasSchedule,
-		nodesSetup,
-		core.Hasher,
-		core.InternalMarshalizer,
-		systemSCConfig,
-		stateComponents.PeerAccounts,
-		rater,
-		epochNotifier,
-	)
+	argsNewVMContainer := metachain.ArgsNewVMContainerFactory{
+		ArgBlockChainHook:   argsHook,
+		Economics:           economicsData,
+		MessageSignVerifier: messageSignVerifier,
+		GasSchedule:         gasSchedule,
+		NodesConfigProvider: nodesSetup,
+		Hasher:              core.Hasher,
+		Marshalizer:         core.InternalMarshalizer,
+		SystemSCConfig:      systemSCConfig,
+		ValidatorAccountsDB: stateComponents.PeerAccounts,
+		ChanceComputer:      rater,
+		EpochNotifier:       epochNotifier,
+	}
+	vmFactory, err := metachain.NewVMContainerFactory(argsNewVMContainer)
 	if err != nil {
 		return nil, err
 	}
@@ -2094,37 +2095,61 @@ func newMetaBlockProcessor(
 		return nil, err
 	}
 
+	economicsDataProvider := metachainEpochStart.NewEpochEconomicsStatistics()
 	argsEpochEconomics := metachainEpochStart.ArgsNewEpochEconomics{
-		Marshalizer:        core.InternalMarshalizer,
-		Hasher:             core.Hasher,
-		Store:              data.Store,
-		ShardCoordinator:   shardCoordinator,
-		RewardsHandler:     economicsData,
-		RoundTime:          rounder,
-		GenesisNonce:       genesisHdr.GetNonce(),
-		GenesisEpoch:       genesisHdr.GetEpoch(),
-		GenesisTotalSupply: economicsData.GenesisTotalSupply(),
+		Marshalizer:           core.InternalMarshalizer,
+		Hasher:                core.Hasher,
+		Store:                 data.Store,
+		ShardCoordinator:      shardCoordinator,
+		RewardsHandler:        economicsData,
+		RoundTime:             rounder,
+		GenesisNonce:          genesisHdr.GetNonce(),
+		GenesisEpoch:          genesisHdr.GetEpoch(),
+		GenesisTotalSupply:    economicsData.GenesisTotalSupply(),
+		EconomicsDataNotified: economicsDataProvider,
 	}
 	epochEconomics, err := metachainEpochStart.NewEndOfEpochEconomicsDataCreator(argsEpochEconomics)
 	if err != nil {
 		return nil, err
 	}
 
+	systemVM, err := vmContainer.Get(factory.SystemVirtualMachine)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: in case of changing the minimum node price, make sure to update the staking data provider
+	stakingDataProvider, err := metachainEpochStart.NewStakingDataProvider(systemVM, systemSCConfig.StakingSystemSCConfig.GenesisNodePrice)
+	if err != nil {
+		return nil, err
+	}
+
 	rewardsStorage := data.Store.GetStorer(dataRetriever.RewardTransactionUnit)
 	miniBlockStorage := data.Store.GetStorer(dataRetriever.MiniBlockUnit)
-	argsEpochRewards := metachainEpochStart.ArgsNewRewardsCreator{
-		ShardCoordinator:              shardCoordinator,
-		PubkeyConverter:               stateComponents.AddressPubkeyConverter,
-		RewardsStorage:                rewardsStorage,
-		MiniBlockStorage:              miniBlockStorage,
-		Hasher:                        core.Hasher,
-		Marshalizer:                   core.InternalMarshalizer,
-		DataPool:                      data.Datapool,
-		ProtocolSustainabilityAddress: economicsData.ProtocolSustainabilityAddress(),
-		NodesConfigProvider:           nodesCoordinator,
-		RewardsFix1EpochEnable:        generalConfig.GeneralSettings.SwitchJailWaitingEnableEpoch,
+	argsEpochRewards := metachainEpochStart.RewardsCreatorProxyArgs{
+		BaseRewardsCreatorArgs: metachainEpochStart.BaseRewardsCreatorArgs{
+			ShardCoordinator:              shardCoordinator,
+			PubkeyConverter:               stateComponents.AddressPubkeyConverter,
+			RewardsStorage:                rewardsStorage,
+			MiniBlockStorage:              miniBlockStorage,
+			Hasher:                        core.Hasher,
+			Marshalizer:                   core.InternalMarshalizer,
+			DataPool:                      data.Datapool,
+			ProtocolSustainabilityAddress: economicsData.ProtocolSustainabilityAddress(),
+			NodesConfigProvider:           nodesCoordinator,
+			UserAccountsDB:                stateComponents.AccountsAdapter,
+			RewardsFix1EpochEnable:        generalConfig.GeneralSettings.SwitchJailWaitingEnableEpoch,
+			DelegationSystemSCEnableEpoch: systemSCConfig.DelegationSystemSCConfig.EnabledEpoch,
+		},
+
+		StakingDataProvider:   stakingDataProvider,
+		TopUpRewardFactor:     economicsData.RewardsTopUpFactor(),
+		TopUpGradientPoint:    economicsData.RewardsTopUpGradientPoint(),
+		EconomicsDataProvider: economicsDataProvider,
+		EpochEnableV2:         systemSCConfig.StakingSystemSCConfig.StakingV2Epoch,
 	}
-	epochRewards, err := metachainEpochStart.NewEpochStartRewardsCreator(argsEpochRewards)
+
+	epochRewards, err := metachainEpochStart.NewRewardsCreatorProxy(argsEpochRewards)
 	if err != nil {
 		return nil, err
 	}
@@ -2174,10 +2199,6 @@ func newMetaBlockProcessor(
 		EpochNotifier:           epochNotifier,
 	}
 
-	systemVM, err := vmContainer.Get(factory.SystemVirtualMachine)
-	if err != nil {
-		return nil, err
-	}
 	argsEpochSystemSC := metachainEpochStart.ArgsNewEpochStartSystemSCProcessing{
 		SystemVM:                               systemVM,
 		UserAccountsDB:                         stateComponents.AccountsAdapter,
@@ -2191,7 +2212,12 @@ func newMetaBlockProcessor(
 		EpochNotifier:                          epochNotifier,
 		SwitchJailWaitingEnableEpoch:           generalConfig.GeneralSettings.SwitchJailWaitingEnableEpoch,
 		SwitchHysteresisForMinNodesEnableEpoch: generalConfig.GeneralSettings.SwitchHysteresisForMinNodesEnableEpoch,
+		DelegationEnableEpoch:                  systemSCConfig.DelegationManagerSystemSCConfig.EnabledEpoch,
+		StakingV2EnableEpoch:                   systemSCConfig.StakingSystemSCConfig.StakingV2Epoch,
 		GenesisNodesConfig:                     nodesSetup,
+		MaxNodesEnableConfig:                   generalConfig.GeneralSettings.MaxNodesChangeEnableEpoch,
+		StakingDataProvider:                    stakingDataProvider,
+		NodesConfigProvider:                    nodesCoordinator,
 	}
 	epochStartSystemSCProcessor, err := metachainEpochStart.NewSystemSCProcessor(argsEpochSystemSC)
 	if err != nil {

cmd/node/main.go

@@ -861,13 +861,19 @@ func startNode(ctx *cli.Context, log logger.Logger, version string) error {
 		return err
 	}
 
-	nodesShuffler := sharding.NewHashValidatorsShuffler(
-		genesisNodesConfig.MinNodesPerShard,
-		genesisNodesConfig.MetaChainMinNodes,
-		genesisNodesConfig.Hysteresis,
-		genesisNodesConfig.Adaptivity,
-		true,
-	)
+	argsNodesShuffler := &sharding.NodesShufflerArgs{
+		NodesShard:           genesisNodesConfig.MinNodesPerShard,
+		NodesMeta:            genesisNodesConfig.MetaChainMinNodes,
+		Hysteresis:           genesisNodesConfig.Hysteresis,
+		Adaptivity:           genesisNodesConfig.Adaptivity,
+		ShuffleBetweenShards: true,
+		MaxNodesEnableConfig: generalConfig.GeneralSettings.MaxNodesChangeEnableEpoch,
+	}
+
+	nodesShuffler, err := sharding.NewHashValidatorsShuffler(argsNodesShuffler)
+	if err != nil {
+		return err
+	}
 
 	destShardIdAsObserver, err := processDestinationShardAsObserver(preferencesConfig.Preferences)
 	if err != nil {
@@ -2470,19 +2476,20 @@ func createApiResolver(
 	}
 
 	if shardCoordinator.SelfId() == core.MetachainShardId {
-		vmFactory, err = metachain.NewVMContainerFactory(
-			argsHook,
-			economics,
-			messageSigVerifier,
-			gasScheduleNotifier,
-			nodesSetup,
-			hasher,
-			marshalizer,
-			systemSCConfig,
-			validatorAccounts,
-			rater,
-			epochNotifier,
-		)
+		argsNewVmFactory := metachain.ArgsNewVMContainerFactory{
+			ArgBlockChainHook:   argsHook,
+			Economics:           economics,
+			MessageSignVerifier: messageSigVerifier,
+			GasSchedule:         gasScheduleNotifier,
+			NodesConfigProvider: nodesSetup,
+			Hasher:              hasher,
+			Marshalizer:         marshalizer,
+			SystemSCConfig:      systemSCConfig,
+			ValidatorAccountsDB: validatorAccounts,
+			ChanceComputer:      rater,
+			EpochNotifier:       epochNotifier,
+		}
+		vmFactory, err = metachain.NewVMContainerFactory(argsNewVmFactory)
 		if err != nil {
 			return nil, err
 		}

config/config.go

@@ -205,6 +205,13 @@ type ValidatorStatisticsConfig struct {
 	CacheRefreshIntervalInSec uint32
 }
 
+// ChangeMaxNodesConfig defines a config change tuple, with a maximum number enabled in a certain epoch number
+type MaxNodesChangeConfig struct {
+	EpochEnable            uint32
+	MaxNumNodes            uint32
+	NodesToShufflePerShard uint32
+}
+
 // GeneralSettingsConfig will hold the general settings for a node
 type GeneralSettingsConfig struct {
 	StatusPollingIntervalSec               int
@@ -221,6 +228,7 @@ type GeneralSettingsConfig struct {
 	MetaProtectionEnableEpoch              uint32
 	AheadOfTimeGasUsageEnableEpoch         uint32
 	GasPriceModifierEnableEpoch            uint32
+	MaxNodesChangeEnableEpoch              []MaxNodesChangeConfig
 	GenesisString                          string
 	GenesisMaxNumberOfShards               uint32
 }

config/economicsConfig.go

@@ -20,6 +20,8 @@ type RewardsSettings struct {
 	DeveloperPercentage              float64
 	ProtocolSustainabilityPercentage float64
 	ProtocolSustainabilityAddress    string
+	TopUpGradientPoint               string
+	TopUpFactor                      float64
 }
 
 // FeeSettings will hold economics fee settings