feat: fixed commision rate and max rate parameter

proto/cosmos/staking/v1beta1/staking.proto

@@ -312,14 +312,24 @@ message Params {
   uint32 historical_entries = 4;
   // bond_denom defines the bondable coin denomination.
   string bond_denom = 5;
-  // min_commission_rate is the chain-wide minimum commission rate that a validator can charge their delegators
+
+  // min_commission_rate represents the minimum commission rate that a validator can charge their delegators
   string min_commission_rate = 6 [
     (gogoproto.moretags)   = "yaml:\"min_commission_rate\"",
     (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
     (gogoproto.nullable)   = false,
     (amino.dont_omitempty) = true,
     (cosmos_proto.scalar)  = "cosmos.Dec"
   ];
+
+  // max_commission_rate represents the maximum commission rate that a validator can charge their delegators
+  string max_commission_rate = 7 [
+    (gogoproto.moretags)   = "yaml:\"max_commission_rate\"",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
+    (gogoproto.nullable)   = false,
+    (amino.dont_omitempty) = true,
+    (cosmos_proto.scalar)  = "cosmos.Dec"
+  ];
 }
 
 // DelegationResponse is equivalent to Delegation except that it contains a

tests/integration/rapidgen/rapidgen.go

@@ -27,13 +27,13 @@ import (
 	mintapi "cosmossdk.io/api/cosmos/mint/v1beta1"
 	paramsapi "cosmossdk.io/api/cosmos/params/v1beta1"
 	slashingapi "cosmossdk.io/api/cosmos/slashing/v1beta1"
-	stakingapi "cosmossdk.io/api/cosmos/staking/v1beta1"
 	upgradeapi "cosmossdk.io/api/cosmos/upgrade/v1beta1"
 	vestingapi "cosmossdk.io/api/cosmos/vesting/v1beta1"
 	evidencetypes "cosmossdk.io/x/evidence/types"
 	feegranttypes "cosmossdk.io/x/feegrant"
 	upgradetypes "cosmossdk.io/x/upgrade/types"
 
+	stakingapi "github.com/cosmos/cosmos-sdk/atomone-api/cosmos/staking/v1beta1"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/multisig"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	vestingtypes "github.com/cosmos/cosmos-sdk/x/auth/vesting/types"

tests/integration/tx/aminojson/aminojson_test.go

@@ -29,7 +29,6 @@ import (
 	gov_v1beta1_api "cosmossdk.io/api/cosmos/gov/v1beta1"
 	msgv1 "cosmossdk.io/api/cosmos/msg/v1"
 	slashingapi "cosmossdk.io/api/cosmos/slashing/v1beta1"
-	stakingapi "cosmossdk.io/api/cosmos/staking/v1beta1"
 	txv1beta1 "cosmossdk.io/api/cosmos/tx/v1beta1"
 	vestingapi "cosmossdk.io/api/cosmos/vesting/v1beta1"
 	"cosmossdk.io/math"
@@ -39,6 +38,7 @@ import (
 	signing_testutil "cosmossdk.io/x/tx/signing/testutil"
 	"cosmossdk.io/x/upgrade"
 
+	stakingapi "github.com/cosmos/cosmos-sdk/atomone-api/cosmos/staking/v1beta1"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	ed25519types "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/multisig"

x/staking/autocli.go

@@ -5,8 +5,8 @@ import (
 
 	autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
 	_ "cosmossdk.io/api/cosmos/crypto/ed25519" // register to that it shows up in protoregistry.GlobalTypes
-	stakingv1beta "cosmossdk.io/api/cosmos/staking/v1beta1"
 
+	stakingv1beta "github.com/cosmos/cosmos-sdk/atomone-api/cosmos/staking/v1beta1"
 	"github.com/cosmos/cosmos-sdk/version"
 )
 

x/staking/keeper/msg_server.go

@@ -48,8 +48,23 @@ func (k msgServer) CreateValidator(ctx context.Context, msg *types.MsgCreateVali
 		return nil, err
 	}
 
-	if msg.Commission.Rate.LT(minCommRate) {
-		return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "cannot set validator commission to less than minimum rate of %s", minCommRate)
+	maxCommRate, err := k.MaxCommissionRate(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if maxCommRate.Equal(minCommRate) {
+		if !msg.Commission.Rate.Equal(minCommRate) {
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate (%s) must be equal too", minCommRate.String(), msg.Commission.Rate.String())
+		}
+	} else {
+		if msg.Commission.Rate.LT(minCommRate) {
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "cannot set validator commission (%s) to less than minimum rate of %s", msg.Commission.Rate.String(), minCommRate.String())
+		}
+
+		if msg.Commission.Rate.GT(maxCommRate) {
+			return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator commission (%s) to more than minimum rate of %s", msg.Commission.Rate.String(), maxCommRate.String())
+		}
 	}
 
 	// check to see if the pubkey or sender has been registered before
@@ -184,8 +199,23 @@ func (k msgServer) EditValidator(ctx context.Context, msg *types.MsgEditValidato
 			return nil, errorsmod.Wrap(sdkerrors.ErrLogic, err.Error())
 		}
 
-		if msg.CommissionRate.LT(minCommissionRate) {
-			return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "commission rate cannot be less than the min commission rate %s", minCommissionRate.String())
+		maxCommissionRate, err := k.MaxCommissionRate(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		if maxCommissionRate.Equal(minCommissionRate) {
+			if !msg.CommissionRate.Equal(minCommissionRate) {
+				return nil, errorsmod.Wrapf(types.ErrCommissionLTRateNotEqual, "if the validity minimum and maximum commission rates are equal (%s), the commission rate (%s) must be equal too", msg.CommissionRate.String(), minCommissionRate.String())
+			}
+		} else {
+			if msg.CommissionRate.LT(minCommissionRate) {
+				return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "commission rate (%s) cannot be less than the min commission rate %s", msg.CommissionRate.String(), minCommissionRate.String())
+			}
+
+			if msg.CommissionRate.GT(maxCommissionRate) {
+				return nil, errorsmod.Wrapf(types.ErrCommissionLTMaxRate, "cannot set validator (%s) commission to more than minimum rate of %s", msg.CommissionRate.String(), maxCommissionRate.String())
+			}
 		}
 	}
 

x/staking/keeper/params.go

@@ -56,6 +56,12 @@ func (k Keeper) MinCommissionRate(ctx context.Context) (math.LegacyDec, error) {
 	return params.MinCommissionRate, err
 }
 
+// MaxCommissionRate - Maximum validator commission rate
+func (k Keeper) MaxCommissionRate(ctx context.Context) (math.LegacyDec, error) {
+	params, err := k.GetParams(ctx)
+	return params.MaxCommissionRate, err
+}
+
 // SetParams sets the x/staking module parameters.
 // CONTRACT: This method performs no validation of the parameters.
 func (k Keeper) SetParams(ctx context.Context, params types.Params) error {

x/staking/migrations/v3/json_test.go

@@ -43,6 +43,7 @@ func TestMigrateJSON(t *testing.T) {
 	"params": {
 		"bond_denom": "stake",
 		"historical_entries": 10000,
+		"max_commission_rate": "1.000000000000000000",
 		"max_entries": 7,
 		"max_validators": 100,
 		"min_commission_rate": "0.000000000000000000",

x/staking/simulation/genesis.go

@@ -16,9 +16,10 @@ import (
 
 // Simulation parameter constants
 const (
-	unbondingTime     = "unbonding_time"
-	maxValidators     = "max_validators"
-	historicalEntries = "historical_entries"
+	unbondingTime         = "unbonding_time"
+	maxValidators         = "max_validators"
+	historicalEntries     = "historical_entries"
+	maximumCommissionRate = "max_commission_rate"
 )
 
 // genUnbondingTime returns randomized UnbondingTime
@@ -36,6 +37,11 @@ func getHistEntries(r *rand.Rand) uint32 {
 	return uint32(r.Intn(int(types.DefaultHistoricalEntries + 1)))
 }
 
+// getMaxCommissionRate returns randomized MaxCommissionRate between 0-100.
+func getMaxCommissionRate(r *rand.Rand) sdkmath.LegacyDec {
+	return sdkmath.LegacyNewDecWithPrec(int64(r.Intn(types.DefaultMaxCommission+1)), 2)
+}
+
 // RandomizedGenState generates a random GenesisState for staking
 func RandomizedGenState(simState *module.SimulationState) {
 	// params
@@ -44,6 +50,7 @@ func RandomizedGenState(simState *module.SimulationState) {
 		maxVals           uint32
 		histEntries       uint32
 		minCommissionRate sdkmath.LegacyDec
+		maxCommissionRate sdkmath.LegacyDec
 	)
 
 	simState.AppParams.GetOrGenerate(unbondingTime, &unbondTime, simState.Rand, func(r *rand.Rand) { unbondTime = genUnbondingTime(r) })
@@ -52,10 +59,12 @@ func RandomizedGenState(simState *module.SimulationState) {
 
 	simState.AppParams.GetOrGenerate(historicalEntries, &histEntries, simState.Rand, func(r *rand.Rand) { histEntries = getHistEntries(r) })
 
+	simState.AppParams.GetOrGenerate(maximumCommissionRate, &histEntries, simState.Rand, func(r *rand.Rand) { maxCommissionRate = getMaxCommissionRate(r) })
+
 	// NOTE: the slashing module need to be defined after the staking module on the
 	// NewSimulationManager constructor for this to work
 	simState.UnbondTime = unbondTime
-	params := types.NewParams(simState.UnbondTime, maxVals, 7, histEntries, simState.BondDenom, minCommissionRate)
+	params := types.NewParams(simState.UnbondTime, maxVals, 7, histEntries, simState.BondDenom, minCommissionRate, maxCommissionRate)
 
 	// validators & delegations
 	var (
@@ -69,7 +78,7 @@ func RandomizedGenState(simState *module.SimulationState) {
 		valAddr := sdk.ValAddress(simState.Accounts[i].Address)
 		valAddrs[i] = valAddr
 
-		maxCommission := sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(simState.Rand, 1, 100)), 2)
+		maxCommission := sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(simState.Rand, 1, types.DefaultMaxCommission)), 2)
 		commission := types.NewCommission(
 			simulation.RandomDecAmount(simState.Rand, maxCommission),
 			maxCommission,

x/staking/simulation/genesis_test.go

@@ -64,9 +64,9 @@ func TestRandomizedGenState(t *testing.T) {
 	require.Equal(t, "BOND_STATUS_UNBONDED", stakingGenesis.Validators[2].Status.String())
 	require.Equal(t, "1000", stakingGenesis.Validators[2].Tokens.String())
 	require.Equal(t, "1000.000000000000000000", stakingGenesis.Validators[2].DelegatorShares.String())
-	require.Equal(t, "0.292059246265731326", stakingGenesis.Validators[2].Commission.CommissionRates.Rate.String())
-	require.Equal(t, "0.330000000000000000", stakingGenesis.Validators[2].Commission.CommissionRates.MaxRate.String())
-	require.Equal(t, "0.038337453731274481", stakingGenesis.Validators[2].Commission.CommissionRates.MaxChangeRate.String())
+	require.Equal(t, "0.760000000000000000", stakingGenesis.Validators[2].Commission.CommissionRates.Rate.String())
+	require.Equal(t, "0.760000000000000000", stakingGenesis.Validators[2].Commission.CommissionRates.MaxRate.String())
+	require.Equal(t, "0.312739151653465930", stakingGenesis.Validators[2].Commission.CommissionRates.MaxChangeRate.String())
 	require.Equal(t, "1", stakingGenesis.Validators[2].MinSelfDelegation.String())
 }
 

x/staking/simulation/operations.go

@@ -164,11 +164,20 @@ func SimulateMsgCreateValidator(
 			simtypes.RandStringOfLength(r, 10),
 		)
 
-		maxCommission := math.LegacyNewDecWithPrec(int64(simtypes.RandIntBetween(r, 0, 100)), 2)
+		minCommRate, err := k.MinCommissionRate(ctx)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, msgType, "unable to get min commission rate"), nil, err
+		}
+		maxCommRate, err := k.MinCommissionRate(ctx)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, msgType, "unable to get max commission rate"), nil, err
+		}
+
+		commissionRate := simtypes.RandomDecAmount(r, maxCommRate.Sub(minCommRate)).Add(minCommRate)
 		commission := types.NewCommissionRates(
-			simtypes.RandomDecAmount(r, maxCommission),
-			maxCommission,
-			simtypes.RandomDecAmount(r, maxCommission),
+			commissionRate,
+			maxCommRate,
+			simtypes.RandomDecAmount(r, maxCommRate),
 		)
 
 		msg, err := types.NewMsgCreateValidator(address.String(), simAccount.ConsKey.PubKey(), selfDelegation, description, commission, math.OneInt())
@@ -219,8 +228,17 @@ func SimulateMsgEditValidator(
 		}
 
 		address := val.GetOperator()
-		newCommissionRate := simtypes.RandomDecAmount(r, val.Commission.MaxRate)
 
+		minCommRate, err := k.MinCommissionRate(ctx)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, msgType, "unable to get min commission rate"), nil, err
+		}
+		maxCommRate, err := k.MinCommissionRate(ctx)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, msgType, "unable to get max commission rate"), nil, err
+		}
+
+		newCommissionRate := simtypes.RandomDecAmount(r, maxCommRate.Sub(minCommRate)).Add(minCommRate)
 		if err := val.Commission.ValidateNewRate(newCommissionRate, ctx.BlockHeader().Time); err != nil {
 			// skip as the commission is invalid
 			return simtypes.NoOpMsg(types.ModuleName, msgType, "invalid commission rate"), nil, nil

x/staking/types/errors.go

@@ -48,4 +48,6 @@ var (
 	ErrInvalidSigner                   = errors.Register(ModuleName, 43, "expected authority account as only signer for proposal message")
 	ErrBadRedelegationSrc              = errors.Register(ModuleName, 44, "redelegation source validator not found")
 	ErrNoUnbondingType                 = errors.Register(ModuleName, 45, "unbonding type not found")
+	ErrCommissionLTMaxRate             = errors.Register(ModuleName, 46, "commission cannot be less than min rate")
+	ErrCommissionLTRateNotEqual        = errors.Register(ModuleName, 47, "commission cannot be different if than min and max rate are equal")
 )