Rc to feat async exec 9 dec

cmd/node/config/economics.toml

@@ -18,22 +18,36 @@
     Denomination = 18 # represents the smallest eGLD subdivision (10^-X eGLD for a denomination of X)
     GenesisMintingSenderAddress = "erd17rc0pu8s7rc0pu8s7rc0pu8s7rc0pu8s7rc0pu8s7rc0pu8s7rcqqkhty3"
 
+    [GlobalSettings.TailInflation]
+        EnableEpoch        = 1
+        StartYearInflation = 0.08757
+        DecayPercentage    = 0.0025
+        MinimumInflation   = 0.02
+
 [RewardsSettings]
     [[RewardsSettings.RewardsConfigByEpoch]]
         EpochEnable = 0
         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 (eligible topUp)
-        TopUpFactor = 0.25 # fraction of value 0.25 - 25%
+        ProtocolSustainabilityAddress = "erd1e5cw5pegj9w2zfpzeq94wf3d5tp6g943xuhgnyysdwyr63rlkspqr0u05s"
+        EcosystemGrowthPercentage = 0.0
+        EcosystemGrowthAddress = "erd1k8d58eve7aa64wjad35sx6z8ckgr738wl7jyz54pez0t4zr98fuqz6hxvs"
+        GrowthDividendPercentage = 0.0
+        GrowthDividendAddress = "erd1enva49yfy9ja0e4ttncfmzr0vjv9k9rawuyg2h2g8nepqwmz8ltssvkglr"
+        TopUpGradientPoint = "2000000000000000000000000" # 2MIL eGLD (eligible topUp)
+        TopUpFactor = 0.5 # fraction of value 0.5 - 50%
 
     [[RewardsSettings.RewardsConfigByEpoch]]
         EpochEnable = 1
         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 = "erd1e5cw5pegj9w2zfpzeq94wf3d5tp6g943xuhgnyysdwyr63rlkspqr0u05s"
+        EcosystemGrowthPercentage = 0.2 #fraction of value 0.2 - 20%
+        EcosystemGrowthAddress = "erd1k8d58eve7aa64wjad35sx6z8ckgr738wl7jyz54pez0t4zr98fuqz6hxvs"
+        GrowthDividendPercentage = 0.2 #fraction of value 0.2 - 20%
+        GrowthDividendAddress = "erd1enva49yfy9ja0e4ttncfmzr0vjv9k9rawuyg2h2g8nepqwmz8ltssvkglr"
         TopUpGradientPoint = "2000000000000000000000000" # 2MIL eGLD (eligible topUp)
         TopUpFactor = 0.5 # fraction of value 0.5 - 50%
 

config/economicsConfig.go

@@ -7,6 +7,15 @@ type GlobalSettings struct {
 	YearSettings                []*YearSetting
 	Denomination                int
 	GenesisMintingSenderAddress string
+	TailInflation               TailInflationSettings
+}
+
+// TailInflationSettings will hold the tail inflation settings
+type TailInflationSettings struct {
+	EnableEpoch        uint32
+	StartYearInflation float64
+	DecayPercentage    float64
+	MinimumInflation   float64
 }
 
 // YearSetting will hold the maximum inflation rate for year
@@ -26,6 +35,10 @@ type EpochRewardSettings struct {
 	DeveloperPercentage              float64
 	ProtocolSustainabilityPercentage float64
 	ProtocolSustainabilityAddress    string
+	EcosystemGrowthPercentage        float64
+	EcosystemGrowthAddress           string
+	GrowthDividendPercentage         float64
+	GrowthDividendAddress            string
 	TopUpGradientPoint               string
 	TopUpFactor                      float64
 	EpochEnable                      uint32

consensus/broadcast/delayedBroadcast_test.go

@@ -391,6 +391,7 @@ func TestDelayedBlockBroadcaster_HeaderReceivedWithoutSignaturesForShardShouldNo
 	require.Contains(t, logOutputStr, expectedLogMsg)
 	require.Contains(t, logOutputStr, fmt.Sprintf("headerHash = %s", hex.EncodeToString(headerHash)))
 
+	_ = logger.SetLogLevel("*:DEBUG")
 	assert.False(t, mbBroadcastCalled.IsSet())
 	assert.False(t, txBroadcastCalled.IsSet())
 }
@@ -655,6 +656,7 @@ func TestDelayedBlockBroadcaster_SetHeaderForValidatorWithoutSignaturesShouldNot
 	expectedLogMsg := "delayedBlockBroadcaster.SetHeaderForValidator: header alarm has not been set"
 	require.Contains(t, logOutputStr, expectedLogMsg)
 	require.Contains(t, logOutputStr, fmt.Sprintf("validatorConsensusOrder = %d", vArgs.order))
+	_ = logger.SetLogLevel("*:DEBUG")
 
 	vbb := dbb.GetValidatorHeaderBroadcastData()
 	require.Equal(t, 0, len(vbb))

epochStart/interface.go

@@ -7,10 +7,9 @@ import (
 
 	"github.com/multiversx/mx-chain-core-go/data"
 	"github.com/multiversx/mx-chain-core-go/data/block"
-	vmcommon "github.com/multiversx/mx-chain-vm-common-go"
-
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/state"
+	vmcommon "github.com/multiversx/mx-chain-vm-common-go"
 )
 
 // TriggerHandler defines the functionalities for an start of epoch trigger
@@ -186,11 +185,19 @@ type EpochEconomicsDataProvider interface {
 	SetLeadersFees(fees *big.Int)
 	SetRewardsToBeDistributed(rewards *big.Int)
 	SetRewardsToBeDistributedForBlocks(rewards *big.Int)
+	SetRewardsForProtocolSustainability(rewards *big.Int)
+	SetRewardsForEcosystemGrowth(rewards *big.Int)
+	SetRewardsForGrowthDividend(rewards *big.Int)
 	NumberOfBlocks() uint64
 	NumberOfBlocksPerShard() map[uint32]uint64
 	LeaderFees() *big.Int
 	RewardsToBeDistributed() *big.Int
 	RewardsToBeDistributedForBlocks() *big.Int
+	RewardsForProtocolSustainability() *big.Int
+	RewardsForEcosystemGrowth() *big.Int
+	RewardsForGrowthDividend() *big.Int
+	RewardsForAccelerator() *big.Int
+	Clean()
 	IsInterfaceNil() bool
 }
 
@@ -208,7 +215,7 @@ type RewardsCreator interface {
 		computedEconomics *block.Economics,
 		prevBlockExecutionResults data.BaseMetaExecutionResultHandler,
 	) (block.MiniBlockSlice, error)
-	GetProtocolSustainabilityRewards() *big.Int
+	GetAcceleratorRewards() *big.Int
 	GetLocalTxCache() TransactionCacher
 	CreateMarshalledData(body *block.Body) map[string][][]byte
 	GetRewardsTxs(body *block.Body) map[string]data.TransactionHandler

epochStart/metachain/baseRewards.go

@@ -42,6 +42,7 @@ type BaseRewardsCreatorArgs struct {
 	EnableEpochsHandler   common.EnableEpochsHandler
 	ExecutionOrderHandler common.TxExecutionOrderHandler
 	RewardsHandler        process.RewardsHandler
+	EconomicsData         epochStart.EpochEconomicsDataProvider
 }
 
 type baseRewardsCreator struct {
@@ -56,7 +57,6 @@ type baseRewardsCreator struct {
 	dataPool                           dataRetriever.PoolsHolder
 	mapBaseRewardsPerBlockPerValidator map[uint32]*big.Int
 	accumulatedRewards                 *big.Int
-	protocolSustainabilityValue        *big.Int
 	flagDelegationSystemSCEnabled      atomic.Flag // nolint
 	userAccountsDB                     state.AccountsAdapter
 	enableEpochsHandler                common.EnableEpochsHandler
@@ -84,7 +84,6 @@ func NewBaseRewardsCreator(args BaseRewardsCreatorArgs) (*baseRewardsCreator, er
 		dataPool:                           args.DataPool,
 		nodesConfigProvider:                args.NodesConfigProvider,
 		accumulatedRewards:                 big.NewInt(0),
-		protocolSustainabilityValue:        big.NewInt(0),
 		userAccountsDB:                     args.UserAccountsDB,
 		mapBaseRewardsPerBlockPerValidator: make(map[uint32]*big.Int),
 		enableEpochsHandler:                args.EnableEpochsHandler,
@@ -95,14 +94,6 @@ func NewBaseRewardsCreator(args BaseRewardsCreatorArgs) (*baseRewardsCreator, er
 	return brc, nil
 }
 
-// GetProtocolSustainabilityRewards returns the sum of all rewards
-func (brc *baseRewardsCreator) GetProtocolSustainabilityRewards() *big.Int {
-	brc.mutRewardsData.RLock()
-	defer brc.mutRewardsData.RUnlock()
-
-	return brc.protocolSustainabilityValue
-}
-
 // GetLocalTxCache returns the local tx cache which holds all the rewards
 func (brc *baseRewardsCreator) GetLocalTxCache() epochStart.TransactionCacher {
 	return brc.currTxs
@@ -321,7 +312,6 @@ func (brc *baseRewardsCreator) clean() {
 	brc.mapBaseRewardsPerBlockPerValidator = make(map[uint32]*big.Int)
 	brc.currTxs.Clean()
 	brc.accumulatedRewards = big.NewInt(0)
-	brc.protocolSustainabilityValue = big.NewInt(0)
 }
 
 func (brc *baseRewardsCreator) isSystemDelegationSC(address []byte) bool {
@@ -346,14 +336,14 @@ func (brc *baseRewardsCreator) isSystemDelegationSC(address []byte) bool {
 func (brc *baseRewardsCreator) createProtocolSustainabilityRewardTransaction(
 	epoch uint32,
 	round uint64,
-	computedEconomics *block.Economics,
+	protocolSustainability *big.Int,
 ) (*rewardTx.RewardTx, uint32, error) {
 
 	protocolSustainabilityAddressForEpoch := brc.rewardsHandler.ProtocolSustainabilityAddressInEpoch(epoch)
 	protocolSustainabilityShardID := brc.shardCoordinator.ComputeId([]byte(protocolSustainabilityAddressForEpoch))
 	protocolSustainabilityRwdTx := &rewardTx.RewardTx{
 		Round:   round,
-		Value:   big.NewInt(0).Set(computedEconomics.RewardsForProtocolSustainability),
+		Value:   big.NewInt(0).Set(protocolSustainability),
 		RcvAddr: []byte(protocolSustainabilityAddressForEpoch),
 		Epoch:   epoch,
 	}
@@ -404,19 +394,25 @@ func (brc *baseRewardsCreator) initializeRewardsMiniBlocks() block.MiniBlockSlic
 	return miniBlocks
 }
 
-func (brc *baseRewardsCreator) addProtocolRewardToMiniBlocks(
-	protocolSustainabilityRwdTx *rewardTx.RewardTx,
+func (brc *baseRewardsCreator) addAcceleratorRewardToMiniBlocks(
+	acceleratorRewardTx *rewardTx.RewardTx,
 	miniBlocks block.MiniBlockSlice,
-	protocolSustainabilityShardId uint32,
+	shardID uint32,
 ) error {
-	protocolSustainabilityRwdHash, errHash := core.CalculateHash(brc.marshalizer, brc.hasher, protocolSustainabilityRwdTx)
+	acceleratorRwdHash, errHash := core.CalculateHash(brc.marshalizer, brc.hasher, acceleratorRewardTx)
 	if errHash != nil {
 		return errHash
 	}
+	if acceleratorRewardTx.Value.Cmp(zero) < 0 {
+		return errNegativeAcceleratorReward
+	}
+	if acceleratorRewardTx.Value.Cmp(zero) == 0 {
+		// do not add to the miniblock
+		return nil
+	}
 
-	brc.currTxs.AddTx(protocolSustainabilityRwdHash, protocolSustainabilityRwdTx)
-	miniBlocks[protocolSustainabilityShardId].TxHashes = append(miniBlocks[protocolSustainabilityShardId].TxHashes, protocolSustainabilityRwdHash)
-	brc.protocolSustainabilityValue.Set(protocolSustainabilityRwdTx.Value)
+	brc.currTxs.AddTx(acceleratorRwdHash, acceleratorRewardTx)
+	miniBlocks[shardID].TxHashes = append(miniBlocks[shardID].TxHashes, acceleratorRwdHash)
 
 	return nil
 }

epochStart/metachain/baseRewards_test.go

@@ -185,14 +185,12 @@ func TestBaseRewardsCreator_clean(t *testing.T) {
 	require.Nil(t, err)
 
 	rwd.accumulatedRewards = big.NewInt(1000)
-	rwd.protocolSustainabilityValue = big.NewInt(100)
 	rwd.mapBaseRewardsPerBlockPerValidator[0] = big.NewInt(10)
 	txHash := []byte("txHash")
 	rwd.currTxs.AddTx(txHash, &rewardTx.RewardTx{})
 
 	rwd.clean()
 	require.Equal(t, big.NewInt(0), rwd.accumulatedRewards)
-	require.Equal(t, big.NewInt(0), rwd.protocolSustainabilityValue)
 	require.Equal(t, 0, len(rwd.mapBaseRewardsPerBlockPerValidator))
 	tx, err := rwd.currTxs.GetTx(txHash)
 	require.Nil(t, tx)
@@ -220,28 +218,15 @@ func TestBaseRewardsCreator_GetLocalTxCache(t *testing.T) {
 	require.False(t, check.IfNil(txCache))
 }
 
-func TestBaseRewardsCreator_GetProtocolSustainabilityRewards(t *testing.T) {
+func TestBaseRewardsCreator_addAcceleratorRewardToMiniBlocks(t *testing.T) {
 	t.Parallel()
 
 	args := getBaseRewardsArguments()
 	rwd, err := NewBaseRewardsCreator(args)
 	require.Nil(t, err)
 	require.NotNil(t, rwd)
 
-	// should return 0 as just initialized
-	rewards := rwd.GetProtocolSustainabilityRewards()
-	require.Zero(t, big.NewInt(0).Cmp(rewards))
-}
-
-func TestBaseRewardsCreator_addProtocolRewardToMiniblocks(t *testing.T) {
-	t.Parallel()
-
-	args := getBaseRewardsArguments()
-	rwd, err := NewBaseRewardsCreator(args)
-	require.Nil(t, err)
-	require.NotNil(t, rwd)
-
-	initialProtRewardValue := big.NewInt(-100)
+	initialProtRewardValue := big.NewInt(100)
 	protRwAddr, _ := args.PubkeyConverter.Decode(args.RewardsHandler.ProtocolSustainabilityAddressInEpoch(0))
 	protRwTx := &rewardTx.RewardTx{
 		Round:   100,
@@ -257,7 +242,7 @@ func TestBaseRewardsCreator_addProtocolRewardToMiniblocks(t *testing.T) {
 
 	protRwShard := args.ShardCoordinator.ComputeId(protRwAddr)
 	mbSlice := createDefaultMiniBlocksSlice()
-	err = rwd.addProtocolRewardToMiniBlocks(protRwTx, mbSlice, protRwShard)
+	err = rwd.addAcceleratorRewardToMiniBlocks(protRwTx, mbSlice, protRwShard)
 	require.Nil(t, err)
 
 	found := false
@@ -898,7 +883,7 @@ func TestBaseRewardsCreator_createProtocolSustainabilityRewardTransaction(t *tes
 		DevFeesInEpoch: big.NewInt(0),
 	}
 
-	rwTx, _, err := rwd.createProtocolSustainabilityRewardTransaction(metaBlk.GetEpoch(), metaBlk.GetRound(), &metaBlk.EpochStart.Economics)
+	rwTx, _, err := rwd.createProtocolSustainabilityRewardTransaction(metaBlk.GetEpoch(), metaBlk.GetRound(), metaBlk.EpochStart.Economics.GetRewardsForProtocolSustainability())
 	require.Nil(t, err)
 	require.NotNil(t, rwTx)
 	require.Equal(t, metaBlk.EpochStart.Economics.RewardsForProtocolSustainability, rwTx.Value)