[DFI-960] param changed hooks

x/params/alias.go

@@ -31,6 +31,7 @@ var (
 	NewParameterChangeProposal = types.NewParameterChangeProposal
 	NewParamChange             = types.NewParamChange
 	ValidateChanges            = types.ValidateChanges
+	NewMultiParamsHooks        = types.NewMultiParamsHooks
 
 	// variable aliases
 	ModuleCdc = types.ModuleCdc
@@ -47,4 +48,6 @@ type (
 	ParamChange             = types.ParamChange
 	RestrictedParams        = types.RestrictedParams
 	RestrictedParam         = types.RestrictedParam
+	MultiParamsHooks        = types.MultiParamsHooks
+	ParametersHooks         = types.ParamsHooks
 )

x/params/keeper.go

@@ -12,13 +12,17 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 )
 
+// Implements ParametersHooks interface
+var _ types.ParamsHooks = Keeper{}
+
 // Keeper of the global paramstore
 type Keeper struct {
 	cdc              *codec.Codec
 	key              sdk.StoreKey
 	tkey             sdk.StoreKey
 	spaces           map[string]*Subspace
 	restrictedParams RestrictedParams
+	hooks            ParametersHooks
 }
 
 // NewKeeper constructs a params keeper
@@ -77,3 +81,30 @@ func (k Keeper) CheckRestrictions(subspace, key string) error {
 
 	return nil
 }
+
+// AfterParamChanged - call hook after changed a parameter
+func (k Keeper) AfterParamChanged(ctx sdk.Context, c ParamChange) error {
+	if k.hooks != nil {
+		return k.hooks.AfterParamChanged(ctx, c)
+	}
+
+	return nil
+}
+
+// BeforeParamChanged - call hook after changed a parameter
+func (k Keeper) BeforeParamChanged(ctx sdk.Context, c ParamChange) error {
+	if k.hooks != nil {
+		return k.hooks.BeforeParamChanged(ctx, c)
+	}
+
+	return nil
+}
+
+// SetHooks sets hooks for call on the param update
+func (k *Keeper) SetHooks(h ParametersHooks) *Keeper {
+	if k.hooks != nil {
+		panic("cannot set hooks twice")
+	}
+	k.hooks = h
+	return k
+}

x/params/proposal_handler.go

@@ -36,9 +36,17 @@ func handleParameterChangeProposal(ctx sdk.Context, k Keeper, p ParameterChangeP
 			fmt.Sprintf("attempt to set new parameter value; key: %s, value: %s", c.Key, c.Value),
 		)
 
+		if err := k.hooks.BeforeParamChanged(ctx, c); err != nil {
+			return sdkerrors.Wrapf(ErrSettingParameter, err.Error())
+		}
+
 		if err := ss.Update(ctx, []byte(c.Key), []byte(c.Value)); err != nil {
 			return sdkerrors.Wrapf(ErrSettingParameter, "key: %s, value: %s, err: %s", c.Key, c.Value, err.Error())
 		}
+
+		if err := k.hooks.AfterParamChanged(ctx, c); err != nil {
+			return sdkerrors.Wrapf(ErrSettingParameter, err.Error())
+		}
 	}
 
 	return nil

x/params/types/hooks.go

@@ -0,0 +1,40 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// ParamsHooks event hooks for params module
+type ParamsHooks interface {
+	AfterParamChanged(ctx sdk.Context, c ParamChange) error
+	BeforeParamChanged(ctx sdk.Context, c ParamChange) error
+}
+
+type MultiParamsHooks []ParamsHooks
+
+// NewMultiParamsHooks returns MultiParamsHooks container
+func NewMultiParamsHooks(hooks ...ParamsHooks) MultiParamsHooks {
+	return hooks
+}
+
+// nolint
+func (h MultiParamsHooks) AfterParamChanged(ctx sdk.Context, c ParamChange) error {
+	for i := range h {
+		if err := h[i].AfterParamChanged(ctx, c); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// nolint
+func (h MultiParamsHooks) BeforeParamChanged(ctx sdk.Context, c ParamChange) error {
+	for i := range h {
+		if err := h[i].BeforeParamChanged(ctx, c); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

x/staking/alias.go

@@ -131,6 +131,7 @@ var (
 	ErrMaxDelegationsLimit             = types.ErrMaxDelegationsLimit
 	ErrDeniedStakingOps                = types.ErrDeniedStakingOps
 	ErrMaxSelfDelegationLimit          = types.ErrMaxSelfDelegationLimit
+	ErrDeniedChangingParam             = types.ErrDeniedChangingParam
 	NewGenesisState                    = types.NewGenesisState
 	DefaultGenesisState                = types.DefaultGenesisState
 	NewMultiStakingHooks               = types.NewMultiStakingHooks

x/staking/keeper/param_hooks.go

@@ -0,0 +1,93 @@
+package keeper
+
+import (
+	"strconv"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/cosmos/cosmos-sdk/x/params"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+type ParamHooks struct {
+	k Keeper
+}
+
+var _ params.ParametersHooks = ParamHooks{}
+
+func (k Keeper) ParamHooks() ParamHooks { return ParamHooks{k} }
+
+// nolint:gocritic
+// BeforeParamChanged Implements BeforeParamChanged
+func (h ParamHooks) BeforeParamChanged(ctx sdk.Context, c params.ParamChange) (err error) {
+	if c.Subspace == DefaultParamspace {
+		switch c.Key {
+		case string(types.KeyMaxValidators):
+			err = beforeChangedMaxValidators(ctx, h.k, c)
+		}
+	}
+
+	return
+}
+
+// nolint:gocritic
+// AfterParamChanged Implements AfterParamChanged
+func (h ParamHooks) AfterParamChanged(ctx sdk.Context, c params.ParamChange) (err error) {
+	if c.Subspace == DefaultParamspace {
+		switch c.Key {
+		case string(types.KeyMaxDelegationsRatio):
+			err = afterChangedMaxDelegationsRatio(ctx, h.k)
+		}
+	}
+
+	return
+}
+
+// beforeChangedMaxValidators checks possibility for changing MaxValidators parameter
+func beforeChangedMaxValidators(ctx sdk.Context, k Keeper, c params.ParamChange) error {
+	vc := len(k.GetAllValidators(ctx))
+	value, err := strconv.Atoi(c.Value)
+	if err != nil {
+		return errors.Wrap(err, "can not convert value to the int")
+	}
+
+	if vc < value {
+		return errors.Wrap(types.ErrDeniedChangingParam, "can not reduce validator quantity less than current amount")
+	}
+
+	return nil
+}
+
+// afterChangedMaxDelegationsRatio reduces delegations to the validator if delegations is overflow.
+func afterChangedMaxDelegationsRatio(ctx sdk.Context, k Keeper) error {
+	for _, v := range k.GetAllValidators(ctx) {
+		selfStake, totalStake := k.GetValidatorStakingState(ctx, v.OperatorAddress).GetSelfAndTotalStakes(v)
+		if isOverflow, limit := k.HasValidatorDelegationsOverflow(ctx, selfStake, totalStake); isOverflow {
+			delegatedAmount := totalStake.Sub(selfStake)
+			needReduce := totalStake.Sub(limit)
+			reducedAmount := needReduce.ToDec()
+
+			delegators := k.GetValidatorDelegations(ctx, v.OperatorAddress)
+			for i, d := range delegators {
+				if d.DelegatorAddress.Equals(v.GetOperator()) {
+					continue
+				}
+
+				reducedShares := d.BondingShares.Mul(needReduce.ToDec()).Quo(delegatedAmount.ToDec())
+
+				if len(delegators) == i+1 {
+					reducedShares = reducedAmount
+				} else {
+					reducedAmount = reducedAmount.Sub(reducedShares)
+				}
+
+				_, err := k.Undelegate(ctx, d.DelegatorAddress, v.OperatorAddress, types.BondingDelOpType, reducedShares, true)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	return nil
+}

x/staking/types/errors.go

@@ -61,4 +61,5 @@ var (
 	ErrMaxDelegationsLimit             = sdkerrors.Register(ModuleName, 47, "validator max delegations level reached")
 	ErrDeniedStakingOps                = sdkerrors.Register(ModuleName, 48, "account cannot perform any staking operations (banned)")
 	ErrMaxSelfDelegationLimit          = sdkerrors.Register(ModuleName, 49, "validator max self-delegation level reached")
+	ErrDeniedChangingParam             = sdkerrors.Register(ModuleName, 50, "cannot change parameter")
 )