add ValidatorRewardPercentage param (#1199)

Author: paologalligit

builtin/energy/energy.go

@@ -276,12 +276,19 @@ func (e *Energy) DistributeRewards(beneficiary, signer thor.Address, staker stak
 	if err != nil {
 		return err
 	}
+	validatorRewardPerc, err := e.params.Get(thor.KeyValidatorRewardPercentage)
+	if err != nil {
+		return err
+	}
+	if validatorRewardPerc.Uint64() == 0 {
+		validatorRewardPerc = big.NewInt(int64(thor.InitialValidatorRewardPercentage))
+	}
 
 	// If delegated amount of VET is 0 then transfer the whole reward to the validator
 	proposerReward := new(big.Int).Set(reward)
 	if hasDelegations {
-		proposerReward.Mul(proposerReward, big.NewInt(3))
-		proposerReward.Div(proposerReward, big.NewInt(10))
+		proposerReward.Mul(proposerReward, validatorRewardPerc)
+		proposerReward.Div(proposerReward, big.NewInt(100))
 
 		val, err := e.params.Get(thor.KeyStargateContractAddress)
 		if err != nil {

builtin/energy/energy_test.go

@@ -6,6 +6,7 @@
 package energy
 
 import (
+	"errors"
 	"math"
 	"math/big"
 	"testing"
@@ -269,3 +270,92 @@ func TestCalculateRewards(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, big.NewInt(121432908318154219), reward)
 }
+
+func TestDistributeRewards(t *testing.T) {
+	st := state.New(muxdb.NewMem(), trie.Root{})
+
+	beneficiary := thor.BytesToAddress([]byte("beneficiary"))
+	signer := thor.BytesToAddress([]byte("signer"))
+	stargateAddr := thor.BytesToAddress([]byte("stargate"))
+	energyAddr := thor.BytesToAddress([]byte("eng"))
+
+	paramsAddr := thor.BytesToAddress([]byte("par"))
+	p := params.New(paramsAddr, st)
+
+	st.SetStorage(paramsAddr, thor.KeyValidatorRewardPercentage, thor.BytesToBytes32(big.NewInt(int64(thor.InitialValidatorRewardPercentage)).Bytes()))
+	st.SetStorage(paramsAddr, thor.KeyStargateContractAddress, thor.BytesToBytes32(stargateAddr.Bytes()))
+
+	eng := New(thor.BytesToAddress([]byte("eng")), st, 1, p)
+
+	stake := big.NewInt(0).Mul(big.NewInt(25), big.NewInt(1e18))
+	expectedReward := big.NewInt(121765601217656012)
+
+	expectedBeneficiaryReward := big.NewInt(0).Mul(expectedReward, big.NewInt(3))
+	expectedBeneficiaryReward = big.NewInt(0).Div(expectedBeneficiaryReward, big.NewInt(10))
+
+	tests := []struct {
+		name                      string
+		hasDelegations            bool
+		expectedErr               error
+		expectedBeneficiaryReward *big.Int
+		expectedDelegatorReward   *big.Int
+		expectedIssued            *big.Int
+	}{
+		{
+			name:                      "No delegations - full reward to beneficiary",
+			hasDelegations:            false,
+			expectedErr:               nil,
+			expectedBeneficiaryReward: expectedReward,
+			expectedDelegatorReward:   big.NewInt(0),
+			expectedIssued:            expectedReward,
+		},
+		{
+			name:                      "With delegations - split reward",
+			hasDelegations:            true,
+			expectedErr:               nil,
+			expectedBeneficiaryReward: expectedBeneficiaryReward,
+			expectedDelegatorReward:   new(big.Int).Sub(expectedReward, expectedBeneficiaryReward),
+			expectedIssued:            expectedReward,
+		},
+		{
+			name:                      "With delegations - IncreaseDelegatorsReward fails",
+			hasDelegations:            true,
+			expectedErr:               errors.New("increase reward failed"),
+			expectedBeneficiaryReward: big.NewInt(0),
+			expectedDelegatorReward:   big.NewInt(0),
+			expectedIssued:            big.NewInt(0),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Reset state for each test
+			st.SetEnergy(beneficiary, big.NewInt(0), 1)
+			st.SetEnergy(stargateAddr, big.NewInt(0), 1)
+			st.SetStorage(energyAddr, issuedKey, thor.Bytes32{})
+
+			mockStaker := &mockStaker{
+				lockedVET:         stake,
+				hasDelegations:    tt.hasDelegations,
+				increaseRewardErr: tt.expectedErr,
+			}
+
+			err := eng.DistributeRewards(beneficiary, signer, mockStaker)
+			assert.Equal(t, tt.expectedErr, err)
+
+			beneficiaryEnergy, err := eng.Get(beneficiary)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.expectedBeneficiaryReward, beneficiaryEnergy)
+
+			if tt.hasDelegations {
+				stargateEnergy, err := eng.Get(stargateAddr)
+				assert.NoError(t, err)
+				assert.Equal(t, tt.expectedDelegatorReward, stargateEnergy)
+			}
+
+			issued, err := eng.getIssued()
+			assert.NoError(t, err)
+			assert.Equal(t, tt.expectedIssued, issued)
+		})
+	}
+}

thor/params.go

@@ -51,18 +51,20 @@ const (
 
 // Keys of governance params.
 var (
-	KeyExecutorAddress         = BytesToBytes32([]byte("executor"))
-	KeyRewardRatio             = BytesToBytes32([]byte("reward-ratio"))
-	KeyLegacyTxBaseGasPrice    = BytesToBytes32([]byte("base-gas-price")) // the legacy tx default gas price
-	KeyProposerEndorsement     = BytesToBytes32([]byte("proposer-endorsement"))
-	KeyMaxBlockProposers       = BytesToBytes32([]byte("max-block-proposers"))
-	KeyStargateContractAddress = BytesToBytes32([]byte("stargate-contract-address"))
-	KeyCurveFactor             = BytesToBytes32([]byte("curve-factor")) // curve factor to define VTHO issuance after PoS
-
-	InitialRewardRatio         = big.NewInt(3e17) // 30%
-	InitialBaseGasPrice        = big.NewInt(1e15)
-	InitialProposerEndorsement = new(big.Int).Mul(big.NewInt(1e18), big.NewInt(25000000))
-	InitialCurveFactor         = big.NewInt(76800)
+	KeyExecutorAddress           = BytesToBytes32([]byte("executor"))
+	KeyRewardRatio               = BytesToBytes32([]byte("reward-ratio"))
+	KeyValidatorRewardPercentage = BytesToBytes32([]byte("validator-reward-percentage"))
+	KeyLegacyTxBaseGasPrice      = BytesToBytes32([]byte("base-gas-price")) // the legacy tx default gas price
+	KeyProposerEndorsement       = BytesToBytes32([]byte("proposer-endorsement"))
+	KeyMaxBlockProposers         = BytesToBytes32([]byte("max-block-proposers"))
+	KeyStargateContractAddress   = BytesToBytes32([]byte("stargate-contract-address"))
+	KeyCurveFactor               = BytesToBytes32([]byte("curve-factor")) // curve factor to define VTHO issuance after PoS
+
+	InitialRewardRatio               = big.NewInt(3e17) // 30%
+	InitialValidatorRewardPercentage = 30               // 30%
+	InitialBaseGasPrice              = big.NewInt(1e15)
+	InitialProposerEndorsement       = new(big.Int).Mul(big.NewInt(1e18), big.NewInt(25000000))
+	InitialCurveFactor               = big.NewInt(76800)
 
 	EnergyGrowthRate      = big.NewInt(5000000000) // WEI THOR per token(VET) per second. about 0.000432 THOR per token per day.
 	NumberOfBlocksPerYear = big.NewInt(3153600)    // number of blocks per year, non leap