feat(WIP) : rotate operator key

proto/cosmos/staking/v1beta1/staking.proto

@@ -320,6 +320,12 @@ message Params {
     (amino.dont_omitempty) = true,
     (cosmos_proto.scalar)  = "cosmos.Dec"
   ];
+
+  // key_rotation_fee is fee to be spent when rotating validator's keys(either pubkey or operator key)
+  cosmos.base.v1beta1.Coin key_rotation_fee = 7 [
+    (gogoproto.nullable) = false,
+    (amino.dont_omitempty) = true
+  ];
 }
 
 // DelegationResponse is equivalent to Delegation except that it contains a
@@ -392,3 +398,24 @@ enum Infraction {
 message ValidatorUpdates {
   repeated tendermint.abci.ValidatorUpdate updates = 1 [(gogoproto.nullable) = false, (amino.dont_omitempty) = true];
 }
+
+// OperatorKeyRotationRecord contains a validator's operator key rotation history.
+message OperatorKeyRotationRecord {
+  option (gogoproto.equal)            = false;
+  option (gogoproto.goproto_getters)  = false;
+
+  // operator_address defines the address of the validator's operator; bech encoded in JSON.
+  string operator_address = 1 ;
+
+  // old_operator_address defines the previous address of the validator's operator; bech encoded in JSON.
+  string old_operator_address = 2 ;
+
+  // height defines the block height at which the rotation event occured.
+  uint64 height = 3;
+}
+
+// RotatedOperatorAddresses contains the array of addresses which rotated their keys
+// This is to block the validator's next rotation till unbonding period.
+message RotatedOperatorAddresses {
+  repeated string addresses = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+}

proto/cosmos/staking/v1beta1/tx.proto

@@ -45,6 +45,12 @@ service Msg {
   // parameters.
   // Since: cosmos-sdk 0.47
   rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse);
+
+  // RotateOperatorKey defines an operation for rotating the operator key
+  // of a validator.
+  // 
+  // Since: cosmos-sdk 0.48
+  rpc RotateOperatorKey(MsgRotateOperatorKey) returns (MsgRotateOperatorKeyResponse);
 }
 
 // MsgCreateValidator defines a SDK message for creating a new validator.
@@ -204,3 +210,23 @@ message MsgUpdateParams {
 //
 // Since: cosmos-sdk 0.47
 message MsgUpdateParamsResponse {};
+
+// MsgRotateOperatorKey is the Msg/RotateOperatorKey request type.
+//
+// Since: cosmos-sdk 0.48
+message MsgRotateOperatorKey {
+  option (cosmos.msg.v1.signer) = "validator_address";
+  option (amino.name)           = "cosmos-sdk/MsgRotateOperatorKey";
+
+  option (gogoproto.goproto_getters) = false;
+  option (gogoproto.equal)           = false;
+
+  string validator_address        = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+  string new_operator_key = 3;
+}
+
+// MsgRotateOperatorKeyResponse defines the response structure for executing a 
+// MsgRotateOperatorKey message.
+//
+// Since: cosmos-sdk 0.48
+message MsgRotateOperatorKeyResponse {}

x/staking/keeper/msg_server.go

@@ -15,6 +15,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/telemetry"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types"
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
@@ -489,3 +490,48 @@ func (k msgServer) UpdateParams(goCtx context.Context, msg *types.MsgUpdateParam
 
 	return &types.MsgUpdateParamsResponse{}, nil
 }
+
+func (k msgServer) RotateOperatorKey(goCtx context.Context, req *types.MsgRotateOperatorKey) (*types.MsgRotateOperatorKeyResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	curValAddr, err := sdk.ValAddressFromBech32(req.ValidatorAddress)
+	if err != nil {
+		return &types.MsgRotateOperatorKeyResponse{}, err
+	}
+
+	validator, found := k.Keeper.GetValidator(ctx, curValAddr)
+	if found {
+		return nil, types.ErrOperatorKeyAlreadyUsed
+	}
+
+	// checks if NewPubKey is not duplicated on ValidatorsByConsAddr
+	newValAddr, err := sdk.ValAddressFromBech32(req.NewOperatorKey)
+	if err != nil {
+		return &types.MsgRotateOperatorKeyResponse{}, err
+	}
+
+	_, found = k.Keeper.GetValidator(ctx, newValAddr)
+	if found {
+		return nil, types.ErrOperatorKeyAlreadyUsed
+	}
+
+	// checks if the signing account has enough balance to pay KeyRotationFee
+	// pays KeyRotationFee to community fund
+	rotationFee := k.OperatorKeyRotationFee(ctx)
+	sender := sdk.AccAddress(curValAddr)
+
+	err = k.Keeper.bankKeeper.SendCoinsFromAccountToModule(ctx, sender, distrtypes.ModuleName, sdk.NewCoins(rotationFee))
+	if err != nil {
+		return nil, err
+	}
+
+	validator.OperatorAddress = req.NewOperatorKey
+	k.SetValidator(ctx, validator)
+
+	// Add OperatorKeyRotationRecord for tracking rotations
+	if err := k.SetOperatorKeyRotationRecord(ctx, curValAddr, newValAddr, ctx.BlockHeight()); err != nil {
+		return &types.MsgRotateOperatorKeyResponse{}, err
+	}
+
+	return &types.MsgRotateOperatorKeyResponse{}, nil
+}

x/staking/keeper/operator_key.go

@@ -0,0 +1,117 @@
+package keeper
+
+import (
+	"time"
+
+	storetypes "cosmossdk.io/store/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+func (k Keeper) GetValidatorOperatorKeyRotationsHistory(ctx sdk.Context,
+	valAddr sdk.ValAddress) []types.OperatorKeyRotationRecord {
+
+	var historyObjs []types.OperatorKeyRotationRecord
+	store := ctx.KVStore(k.storeKey)
+
+	iterator := storetypes.KVStorePrefixIterator(store,
+		append([]byte(types.ValidatorOperatorKeyRotationRecordKey), valAddr...))
+	defer iterator.Close()
+
+	for ; iterator.Valid(); iterator.Next() {
+		var history types.OperatorKeyRotationRecord
+
+		k.cdc.MustUnmarshal(iterator.Value(), &history)
+		historyObjs = append(historyObjs, history)
+	}
+	return historyObjs
+}
+
+func (k Keeper) SetOperatorKeyRotationRecord(ctx sdk.Context, curValAddr, newValAddr sdk.ValAddress, height int64) error {
+	historyObj := types.OperatorKeyRotationRecord{
+		OperatorAddress:    newValAddr.String(),
+		OldOperatorAddress: curValAddr.String(),
+		Height:             uint64(ctx.BlockHeight()),
+	}
+
+	store := ctx.KVStore(k.storeKey)
+	key := types.GetOperKeyRotationHistoryKey(newValAddr, uint64(height))
+	bz, err := k.cdc.Marshal(&historyObj)
+
+	if err != nil {
+		return err
+	}
+
+	store.Set(key, bz)
+	k.SetVORQueue(ctx, ctx.BlockTime(), newValAddr)
+	k.SetVORIndex(ctx, newValAddr)
+
+	return nil
+}
+
+func (k Keeper) GetVORQueue(ctx sdk.Context, ts time.Time) types.RotatedOperatorAddresses {
+	var valAddrs types.RotatedOperatorAddresses
+	store := ctx.KVStore(k.storeKey)
+	key := types.GetOperatorRotationTimeKey(ts)
+	bz := store.Get(key)
+	if bz == nil {
+		return valAddrs
+	}
+	k.cdc.MustUnmarshal(bz, &valAddrs)
+	return valAddrs
+}
+
+func (k Keeper) SetVORQueue(ctx sdk.Context, ts time.Time, valAddr sdk.ValAddress) {
+	operKeys := k.GetVORQueue(ctx, ts)
+	operKeys.Addresses = append(operKeys.Addresses, valAddr.String())
+	key := types.GetOperatorRotationTimeKey(ts)
+	store := ctx.KVStore(k.storeKey)
+	bz := k.cdc.MustMarshal(&operKeys)
+	store.Set(key, bz)
+}
+
+func (k Keeper) SetVORIndex(ctx sdk.Context, valAddr sdk.ValAddress) {
+	store := ctx.KVStore(k.storeKey)
+	key := types.GetVORIndexKey(valAddr)
+	store.Set(key, []byte{})
+}
+
+func (k Keeper) GetVORIndex(ctx sdk.Context, valAddr sdk.ValAddress) bool {
+	store := ctx.KVStore(k.storeKey)
+	key := types.GetVORIndexKey(valAddr)
+	bz := store.Get(key)
+	return bz != nil
+}
+
+func (k Keeper) UpdateAllMaturedVORRotatedKeys(ctx sdk.Context, maturedTime time.Time) {
+	maturedRotatedValAddrs := k.GetAllMaturedRotatedKeys(ctx, maturedTime)
+	for _, valAddrStr := range maturedRotatedValAddrs {
+		valAddr, err := sdk.ValAddressFromBech32(valAddrStr)
+		if err != nil {
+			panic(err)
+		}
+
+		k.deleteVORIndexKey(ctx, valAddr)
+	}
+}
+
+func (k Keeper) GetAllMaturedRotatedKeys(ctx sdk.Context, matureTime time.Time) []string {
+	store := ctx.KVStore(k.storeKey)
+	var ValAddresses []string
+	prefixIterator := storetypes.KVStorePrefixIterator(store, storetypes.InclusiveEndBytes(types.GetOperatorRotationTimeKey(matureTime)))
+
+	for ; prefixIterator.Valid(); prefixIterator.Next() {
+		var operKey types.RotatedOperatorAddresses
+		k.cdc.MustUnmarshal(prefixIterator.Value(), &operKey)
+		ValAddresses = append(ValAddresses, operKey.Addresses...)
+		store.Delete(prefixIterator.Key())
+	}
+
+	return ValAddresses
+}
+
+func (k Keeper) deleteVORIndexKey(ctx sdk.Context, valAddr sdk.ValAddress) {
+	store := ctx.KVStore(k.storeKey)
+	key := types.GetVORIndexKey(valAddr)
+	store.Delete(key)
+}

x/staking/keeper/params.go

@@ -76,3 +76,13 @@ func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
 	k.cdc.MustUnmarshal(bz, &params)
 	return params
 }
+
+// // MaxOperatorKeyRotations - Maximum operator key rotations
+// func (k Keeper) MaxOperatorKeyRotations(ctx sdk.Context) (res uint64) {
+// 	return k.GetParams(ctx).MaxOperatorKeyRotations
+// }
+
+// OperatorKeyRotationFee - Fee to be paid for rotating a key
+func (k Keeper) OperatorKeyRotationFee(ctx sdk.Context) sdk.Coin {
+	return k.GetParams(ctx).KeyRotationFee
+}

x/staking/keeper/val_state_change.go

@@ -92,6 +92,8 @@ func (k Keeper) BlockValidatorUpdates(ctx sdk.Context) []abci.ValidatorUpdate {
 		)
 	}
 
+	k.UpdateAllMaturedVORRotatedKeys(ctx, ctx.BlockHeader().Time)
+
 	return validatorUpdates
 }
 

x/staking/types/errors.go

@@ -50,4 +50,6 @@ var (
 	ErrCommissionLTMinRate             = errors.Register(ModuleName, 40, "commission cannot be less than min rate")
 	ErrUnbondingNotFound               = errors.Register(ModuleName, 41, "unbonding operation not found")
 	ErrUnbondingOnHoldRefCountNegative = errors.Register(ModuleName, 42, "cannot un-hold unbonding operation that is not on hold")
+	ErrOperatorKeyAlreadyUsed          = errors.Register(ModuleName, 43, "operator key is already used for a validator")
+	ErrMaxOperatorKeyRotationsReached  = errors.Register(ModuleName, 44, "exceeding maximum consensus pubkey rotations")
 )