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/delegation.go

@@ -353,6 +353,23 @@ func (k Keeper) SetUnbondingDelegationEntry(
 	return ubd
 }
 
+func (k Keeper) updateUBDToNewValAddr(ctx sdk.Context, delAddr sdk.AccAddress, oldValAddr, newValAddr sdk.ValAddress) {
+	store := ctx.KVStore(k.storeKey)
+	oldKey := types.GetUBDKey(delAddr, oldValAddr)
+	bz := store.Get(oldKey)
+
+	var ubd types.UnbondingDelegation
+	k.cdc.MustUnmarshal(bz, &ubd)
+	k.RemoveUnbondingDelegation(ctx, ubd)
+	ubd.ValidatorAddress = newValAddr.String()
+	k.SetUnbondingDelegation(ctx, ubd)
+
+	// over ride the existing ubd entries with unbonding id
+	for _, entry := range ubd.Entries {
+		k.SetUnbondingDelegationByUnbondingID(ctx, ubd, entry.UnbondingId)
+	}
+}
+
 // unbonding delegation queue timeslice operations
 
 // GetUBDQueueTimeSlice gets a specific unbonding queue timeslice. A timeslice
@@ -422,6 +439,29 @@ func (k Keeper) DequeueAllMatureUBDQueue(ctx sdk.Context, currTime time.Time) (m
 	return matureUnbonds
 }
 
+func (k Keeper) updateAllUBDQueue(ctx sdk.Context, oldValAddr, newValAddr sdk.ValAddress, t time.Time) {
+	store := ctx.KVStore(k.storeKey)
+
+	// gets an iterator for all timeslices from time 0 until the given time
+	unbondingTimesliceIterator := k.UBDQueueIterator(ctx, t)
+	defer unbondingTimesliceIterator.Close()
+
+	for ; unbondingTimesliceIterator.Valid(); unbondingTimesliceIterator.Next() {
+		timeslice := types.DVPairs{}
+		value := unbondingTimesliceIterator.Value()
+		k.cdc.MustUnmarshal(value, &timeslice)
+
+		for i := 0; i < len(timeslice.Pairs); i++ {
+			if timeslice.Pairs[i].ValidatorAddress == oldValAddr.String() {
+				timeslice.Pairs[i].ValidatorAddress = newValAddr.String()
+			}
+		}
+
+		bz := k.cdc.MustMarshal(&timeslice)
+		store.Set(unbondingTimesliceIterator.Key(), bz)
+	}
+}
+
 // GetRedelegations returns a given amount of all the delegator redelegations.
 func (k Keeper) GetRedelegations(ctx sdk.Context, delegator sdk.AccAddress, maxRetrieve uint16) (redelegations []types.Redelegation) {
 	redelegations = make([]types.Redelegation, maxRetrieve)
@@ -586,6 +626,40 @@ func (k Keeper) RemoveRedelegation(ctx sdk.Context, red types.Redelegation) {
 	store.Delete(types.GetREDByValDstIndexKey(delegatorAddress, valSrcAddr, valDestAddr))
 }
 
+func (k Keeper) updateRedelegationSrcVal(ctx sdk.Context, delAddr sdk.AccAddress, oldSrcVal, newSrcVal, dstVal sdk.ValAddress) {
+	store := ctx.KVStore(k.storeKey)
+	oldKey := types.GetREDKey(delAddr, oldSrcVal, dstVal)
+	bz := store.Get(oldKey)
+
+	var red types.Redelegation
+	k.cdc.MustUnmarshal(bz, &red)
+	k.RemoveRedelegation(ctx, red)
+	red.ValidatorSrcAddress = newSrcVal.String()
+	k.SetRedelegation(ctx, red)
+
+	// over ride the existing ubd entries with unbonding id
+	for _, entry := range red.Entries {
+		k.SetRedelegationByUnbondingID(ctx, red, entry.UnbondingId)
+	}
+}
+
+func (k Keeper) updateRedelegationDstVal(ctx sdk.Context, delAddr sdk.AccAddress, srcVal, oldDstVal, newDstVal sdk.ValAddress) {
+	store := ctx.KVStore(k.storeKey)
+	oldKey := types.GetREDKey(delAddr, srcVal, oldDstVal)
+	bz := store.Get(oldKey)
+
+	var red types.Redelegation
+	k.cdc.MustUnmarshal(bz, &red)
+	k.RemoveRedelegation(ctx, red)
+	red.ValidatorDstAddress = newDstVal.String()
+	k.SetRedelegation(ctx, red)
+
+	// over ride the existing ubd entries with unbonding id
+	for _, entry := range red.Entries {
+		k.SetRedelegationByUnbondingID(ctx, red, entry.UnbondingId)
+	}
+}
+
 // redelegation queue timeslice operations
 
 // GetRedelegationQueueTimeSlice gets a specific redelegation queue timeslice. A
@@ -660,6 +734,31 @@ func (k Keeper) DequeueAllMatureRedelegationQueue(ctx sdk.Context, currTime time
 	return matureRedelegations
 }
 
+func (k Keeper) updateRedelegationQueue(ctx sdk.Context, oldValAddr, newValAddr sdk.ValAddress, t time.Time) {
+	store := ctx.KVStore(k.storeKey)
+
+	// gets an iterator for all timeslices from time 0 until the current Blockheader time
+	redelegationTimesliceIterator := k.RedelegationQueueIterator(ctx, t)
+	defer redelegationTimesliceIterator.Close()
+
+	for ; redelegationTimesliceIterator.Valid(); redelegationTimesliceIterator.Next() {
+		timeslice := types.DVVTriplets{}
+		value := redelegationTimesliceIterator.Value()
+		k.cdc.MustUnmarshal(value, &timeslice)
+
+		for i := 0; i < len(timeslice.Triplets); i++ {
+			if timeslice.Triplets[i].ValidatorSrcAddress == oldValAddr.String() {
+				timeslice.Triplets[i].ValidatorSrcAddress = newValAddr.String()
+			} else if timeslice.Triplets[i].ValidatorDstAddress == oldValAddr.String() {
+				timeslice.Triplets[i].ValidatorDstAddress = newValAddr.String()
+			}
+		}
+
+		bz := k.cdc.MustMarshal(&timeslice)
+		store.Set(redelegationTimesliceIterator.Key(), bz)
+	}
+}
+
 // Delegate performs a delegation, set/update everything necessary within the store.
 // tokenSrc indicates the bond status of the incoming funds.
 func (k Keeper) Delegate(

x/staking/keeper/msg_server.go

@@ -16,6 +16,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"
 )
@@ -558,3 +559,47 @@ 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)
+	delAddr := sdk.AccAddress(curValAddr)
+
+	err = k.Keeper.bankKeeper.SendCoinsFromAccountToModule(ctx, delAddr, distrtypes.ModuleName, sdk.NewCoins(rotationFee))
+	if err != nil {
+		return nil, err
+	}
+
+	k.updateValidatorOperatorKey(ctx, validator, delAddr, newValAddr, curValAddr)
+
+	// Add OperatorKeyRotationRecord for tracking rotations
+	if err := k.SetOperatorKeyRotationRecord(ctx, curValAddr, newValAddr, ctx.BlockHeight()); err != nil {
+		return &types.MsgRotateOperatorKeyResponse{}, err
+	}
+
+	return &types.MsgRotateOperatorKeyResponse{}, nil
+}