reduce module interdependancy, /client refactor (#4415)

* abstract staking BuildCreateValidatorMsg, genutil defines its own flags

* client/ refactor

* staking move keys from keeper to types

x/staking/alias.go

@@ -61,30 +61,6 @@ var (
 	PositiveDelegationInvariant        = keeper.PositiveDelegationInvariant
 	DelegatorSharesInvariant           = keeper.DelegatorSharesInvariant
 	NewKeeper                          = keeper.NewKeeper
-	GetValidatorKey                    = keeper.GetValidatorKey
-	GetValidatorByConsAddrKey          = keeper.GetValidatorByConsAddrKey
-	AddressFromLastValidatorPowerKey   = keeper.AddressFromLastValidatorPowerKey
-	GetValidatorsByPowerIndexKey       = keeper.GetValidatorsByPowerIndexKey
-	GetLastValidatorPowerKey           = keeper.GetLastValidatorPowerKey
-	GetValidatorQueueTimeKey           = keeper.GetValidatorQueueTimeKey
-	GetDelegationKey                   = keeper.GetDelegationKey
-	GetDelegationsKey                  = keeper.GetDelegationsKey
-	GetUBDKey                          = keeper.GetUBDKey
-	GetUBDByValIndexKey                = keeper.GetUBDByValIndexKey
-	GetUBDKeyFromValIndexKey           = keeper.GetUBDKeyFromValIndexKey
-	GetUBDsKey                         = keeper.GetUBDsKey
-	GetUBDsByValIndexKey               = keeper.GetUBDsByValIndexKey
-	GetUnbondingDelegationTimeKey      = keeper.GetUnbondingDelegationTimeKey
-	GetREDKey                          = keeper.GetREDKey
-	GetREDByValSrcIndexKey             = keeper.GetREDByValSrcIndexKey
-	GetREDByValDstIndexKey             = keeper.GetREDByValDstIndexKey
-	GetREDKeyFromValSrcIndexKey        = keeper.GetREDKeyFromValSrcIndexKey
-	GetREDKeyFromValDstIndexKey        = keeper.GetREDKeyFromValDstIndexKey
-	GetRedelegationTimeKey             = keeper.GetRedelegationTimeKey
-	GetREDsKey                         = keeper.GetREDsKey
-	GetREDsFromValSrcIndexKey          = keeper.GetREDsFromValSrcIndexKey
-	GetREDsToValDstIndexKey            = keeper.GetREDsToValDstIndexKey
-	GetREDsByDelToValDstIndexKey       = keeper.GetREDsByDelToValDstIndexKey
 	ParamKeyTable                      = keeper.ParamKeyTable
 	ValEq                              = keeper.ValEq
 	MakeTestCodec                      = keeper.MakeTestCodec
@@ -170,6 +146,31 @@ var (
 	NewGenesisState                    = types.NewGenesisState
 	DefaultGenesisState                = types.DefaultGenesisState
 	NewMultiStakingHooks               = types.NewMultiStakingHooks
+	GetValidatorKey                    = types.GetValidatorKey
+	GetValidatorByConsAddrKey          = types.GetValidatorByConsAddrKey
+	AddressFromLastValidatorPowerKey   = types.AddressFromLastValidatorPowerKey
+	GetValidatorsByPowerIndexKey       = types.GetValidatorsByPowerIndexKey
+	GetLastValidatorPowerKey           = types.GetLastValidatorPowerKey
+	ParseValidatorPowerRankKey         = types.ParseValidatorPowerRankKey
+	GetValidatorQueueTimeKey           = types.GetValidatorQueueTimeKey
+	GetDelegationKey                   = types.GetDelegationKey
+	GetDelegationsKey                  = types.GetDelegationsKey
+	GetUBDKey                          = types.GetUBDKey
+	GetUBDByValIndexKey                = types.GetUBDByValIndexKey
+	GetUBDKeyFromValIndexKey           = types.GetUBDKeyFromValIndexKey
+	GetUBDsKey                         = types.GetUBDsKey
+	GetUBDsByValIndexKey               = types.GetUBDsByValIndexKey
+	GetUnbondingDelegationTimeKey      = types.GetUnbondingDelegationTimeKey
+	GetREDKey                          = types.GetREDKey
+	GetREDByValSrcIndexKey             = types.GetREDByValSrcIndexKey
+	GetREDByValDstIndexKey             = types.GetREDByValDstIndexKey
+	GetREDKeyFromValSrcIndexKey        = types.GetREDKeyFromValSrcIndexKey
+	GetREDKeyFromValDstIndexKey        = types.GetREDKeyFromValDstIndexKey
+	GetRedelegationTimeKey             = types.GetRedelegationTimeKey
+	GetREDsKey                         = types.GetREDsKey
+	GetREDsFromValSrcIndexKey          = types.GetREDsFromValSrcIndexKey
+	GetREDsToValDstIndexKey            = types.GetREDsToValDstIndexKey
+	GetREDsByDelToValDstIndexKey       = types.GetREDsByDelToValDstIndexKey
 	NewMsgCreateValidator              = types.NewMsgCreateValidator
 	NewMsgEditValidator                = types.NewMsgEditValidator
 	NewMsgDelegate                     = types.NewMsgDelegate
@@ -189,24 +190,24 @@ var (
 	NewDescription                     = types.NewDescription
 
 	// variable aliases
-	PoolKey                          = keeper.PoolKey
-	LastValidatorPowerKey            = keeper.LastValidatorPowerKey
-	LastTotalPowerKey                = keeper.LastTotalPowerKey
-	ValidatorsKey                    = keeper.ValidatorsKey
-	ValidatorsByConsAddrKey          = keeper.ValidatorsByConsAddrKey
-	ValidatorsByPowerIndexKey        = keeper.ValidatorsByPowerIndexKey
-	DelegationKey                    = keeper.DelegationKey
-	UnbondingDelegationKey           = keeper.UnbondingDelegationKey
-	UnbondingDelegationByValIndexKey = keeper.UnbondingDelegationByValIndexKey
-	RedelegationKey                  = keeper.RedelegationKey
-	RedelegationByValSrcIndexKey     = keeper.RedelegationByValSrcIndexKey
-	RedelegationByValDstIndexKey     = keeper.RedelegationByValDstIndexKey
-	UnbondingQueueKey                = keeper.UnbondingQueueKey
-	RedelegationQueueKey             = keeper.RedelegationQueueKey
-	ValidatorQueueKey                = keeper.ValidatorQueueKey
 	Addrs                            = keeper.Addrs
 	PKs                              = keeper.PKs
 	ModuleCdc                        = types.ModuleCdc
+	PoolKey                          = types.PoolKey
+	LastValidatorPowerKey            = types.LastValidatorPowerKey
+	LastTotalPowerKey                = types.LastTotalPowerKey
+	ValidatorsKey                    = types.ValidatorsKey
+	ValidatorsByConsAddrKey          = types.ValidatorsByConsAddrKey
+	ValidatorsByPowerIndexKey        = types.ValidatorsByPowerIndexKey
+	DelegationKey                    = types.DelegationKey
+	UnbondingDelegationKey           = types.UnbondingDelegationKey
+	UnbondingDelegationByValIndexKey = types.UnbondingDelegationByValIndexKey
+	RedelegationKey                  = types.RedelegationKey
+	RedelegationByValSrcIndexKey     = types.RedelegationByValSrcIndexKey
+	RedelegationByValDstIndexKey     = types.RedelegationByValDstIndexKey
+	UnbondingQueueKey                = types.UnbondingQueueKey
+	RedelegationQueueKey             = types.RedelegationQueueKey
+	ValidatorQueueKey                = types.ValidatorQueueKey
 	KeyUnbondingTime                 = types.KeyUnbondingTime
 	KeyMaxValidators                 = types.KeyMaxValidators
 	KeyMaxEntries                    = types.KeyMaxEntries

x/staking/client/cli/query.go

@@ -10,7 +10,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/version"
-	"github.com/cosmos/cosmos-sdk/x/staking"
+	"github.com/cosmos/cosmos-sdk/x/staking/querier"
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
@@ -37,7 +37,7 @@ $ %s query staking validator cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhff
 				return err
 			}
 
-			res, err := cliCtx.QueryStore(staking.GetValidatorKey(addr), storeName)
+			res, err := cliCtx.QueryStore(types.GetValidatorKey(addr), storeName)
 			if err != nil {
 				return err
 			}
@@ -69,12 +69,12 @@ $ %s query staking validators
 		RunE: func(cmd *cobra.Command, args []string) error {
 			cliCtx := context.NewCLIContext().WithCodec(cdc)
 
-			resKVs, err := cliCtx.QuerySubspace(staking.ValidatorsKey, storeName)
+			resKVs, err := cliCtx.QuerySubspace(types.ValidatorsKey, storeName)
 			if err != nil {
 				return err
 			}
 
-			var validators staking.Validators
+			var validators types.Validators
 			for _, kv := range resKVs {
 				validators = append(validators, types.MustUnmarshalValidator(cdc, kv.Value))
 			}
@@ -107,18 +107,18 @@ $ %s query staking unbonding-delegations-from cosmosvaloper1gghjut3ccd8ay0zduzj6
 				return err
 			}
 
-			bz, err := cdc.MarshalJSON(staking.NewQueryValidatorParams(valAddr))
+			bz, err := cdc.MarshalJSON(querier.NewQueryValidatorParams(valAddr))
 			if err != nil {
 				return err
 			}
 
-			route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryValidatorUnbondingDelegations)
+			route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryValidatorUnbondingDelegations)
 			res, err := cliCtx.QueryWithData(route, bz)
 			if err != nil {
 				return err
 			}
 
-			var ubds staking.UnbondingDelegations
+			var ubds types.UnbondingDelegations
 			cdc.MustUnmarshalJSON(res, &ubds)
 			return cliCtx.PrintOutput(ubds)
 		},
@@ -149,18 +149,18 @@ $ %s query staking redelegations-from cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fx
 				return err
 			}
 
-			bz, err := cdc.MarshalJSON(staking.QueryRedelegationParams{SrcValidatorAddr: valSrcAddr})
+			bz, err := cdc.MarshalJSON(querier.QueryRedelegationParams{SrcValidatorAddr: valSrcAddr})
 			if err != nil {
 				return err
 			}
 
-			route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryRedelegations)
+			route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryRedelegations)
 			res, err := cliCtx.QueryWithData(route, bz)
 			if err != nil {
 				return err
 			}
 
-			var resp staking.RedelegationResponses
+			var resp types.RedelegationResponses
 			if err := cdc.UnmarshalJSON(res, &resp); err != nil {
 				return err
 			}
@@ -198,18 +198,18 @@ $ %s query staking delegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p cosm
 				return err
 			}
 
-			bz, err := cdc.MarshalJSON(staking.NewQueryBondsParams(delAddr, valAddr))
+			bz, err := cdc.MarshalJSON(querier.NewQueryBondsParams(delAddr, valAddr))
 			if err != nil {
 				return err
 			}
 
-			route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryDelegation)
+			route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryDelegation)
 			res, err := cliCtx.QueryWithData(route, bz)
 			if err != nil {
 				return err
 			}
 
-			var resp staking.DelegationResponse
+			var resp types.DelegationResponse
 			if err := cdc.UnmarshalJSON(res, &resp); err != nil {
 				return err
 			}
@@ -243,18 +243,18 @@ $ %s query staking delegations cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p
 				return err
 			}
 
-			bz, err := cdc.MarshalJSON(staking.NewQueryDelegatorParams(delAddr))
+			bz, err := cdc.MarshalJSON(querier.NewQueryDelegatorParams(delAddr))
 			if err != nil {
 				return err
 			}
 
-			route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryDelegatorDelegations)
+			route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryDelegatorDelegations)
 			res, err := cliCtx.QueryWithData(route, bz)
 			if err != nil {
 				return err
 			}
 
-			var resp staking.DelegationResponses
+			var resp types.DelegationResponses
 			if err := cdc.UnmarshalJSON(res, &resp); err != nil {
 				return err
 			}
@@ -288,18 +288,18 @@ $ %s query staking delegations-to cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ld
 				return err
 			}
 
-			bz, err := cdc.MarshalJSON(staking.NewQueryValidatorParams(valAddr))
+			bz, err := cdc.MarshalJSON(querier.NewQueryValidatorParams(valAddr))
 			if err != nil {
 				return err
 			}
 
-			route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryValidatorDelegations)
+			route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryValidatorDelegations)
 			res, err := cliCtx.QueryWithData(route, bz)
 			if err != nil {
 				return err
 			}
 
-			var resp staking.DelegationResponses
+			var resp types.DelegationResponses
 			if err := cdc.UnmarshalJSON(res, &resp); err != nil {
 				return err
 			}
@@ -338,7 +338,7 @@ $ %s query staking unbonding-delegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld7
 				return err
 			}
 
-			res, err := cliCtx.QueryStore(staking.GetUBDKey(delAddr, valAddr), storeName)
+			res, err := cliCtx.QueryStore(types.GetUBDKey(delAddr, valAddr), storeName)
 			if err != nil {
 				return err
 			}
@@ -373,12 +373,12 @@ $ %s query staking unbonding-delegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld7
 				return err
 			}
 
-			resKVs, err := cliCtx.QuerySubspace(staking.GetUBDsKey(delegatorAddr), storeName)
+			resKVs, err := cliCtx.QuerySubspace(types.GetUBDsKey(delegatorAddr), storeName)
 			if err != nil {
 				return err
 			}
 
-			var ubds staking.UnbondingDelegations
+			var ubds types.UnbondingDelegations
 			for _, kv := range resKVs {
 				ubds = append(ubds, types.MustUnmarshalUBD(cdc, kv.Value))
 			}
@@ -422,18 +422,18 @@ $ %s query staking redelegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p co
 				return err
 			}
 
-			bz, err := cdc.MarshalJSON(staking.NewQueryRedelegationParams(delAddr, valSrcAddr, valDstAddr))
+			bz, err := cdc.MarshalJSON(querier.NewQueryRedelegationParams(delAddr, valSrcAddr, valDstAddr))
 			if err != nil {
 				return err
 			}
 
-			route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryRedelegations)
+			route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryRedelegations)
 			res, err := cliCtx.QueryWithData(route, bz)
 			if err != nil {
 				return err
 			}
 
-			var resp staking.RedelegationResponses
+			var resp types.RedelegationResponses
 			if err := cdc.UnmarshalJSON(res, &resp); err != nil {
 				return err
 			}
@@ -467,18 +467,18 @@ $ %s query staking redelegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p
 				return err
 			}
 
-			bz, err := cdc.MarshalJSON(staking.QueryRedelegationParams{DelegatorAddr: delAddr})
+			bz, err := cdc.MarshalJSON(querier.QueryRedelegationParams{DelegatorAddr: delAddr})
 			if err != nil {
 				return err
 			}
 
-			route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryRedelegations)
+			route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryRedelegations)
 			res, err := cliCtx.QueryWithData(route, bz)
 			if err != nil {
 				return err
 			}
 
-			var resp staking.RedelegationResponses
+			var resp types.RedelegationResponses
 			if err := cdc.UnmarshalJSON(res, &resp); err != nil {
 				return err
 			}
@@ -506,7 +506,7 @@ $ %s query staking pool
 		RunE: func(cmd *cobra.Command, args []string) error {
 			cliCtx := context.NewCLIContext().WithCodec(cdc)
 
-			res, err := cliCtx.QueryStore(staking.PoolKey, storeName)
+			res, err := cliCtx.QueryStore(types.PoolKey, storeName)
 			if err != nil {
 				return err
 			}
@@ -534,13 +534,13 @@ $ %s query staking params
 		RunE: func(cmd *cobra.Command, args []string) error {
 			cliCtx := context.NewCLIContext().WithCodec(cdc)
 
-			route := fmt.Sprintf("custom/%s/%s", storeName, staking.QueryParameters)
+			route := fmt.Sprintf("custom/%s/%s", storeName, querier.QueryParameters)
 			bz, err := cliCtx.QueryWithData(route, nil)
 			if err != nil {
 				return err
 			}
 
-			var params staking.Params
+			var params types.Params
 			cdc.MustUnmarshalJSON(bz, &params)
 			return cliCtx.PrintOutput(params)
 		},

x/staking/client/cli/tx.go

@@ -2,25 +2,28 @@ package cli
 
 import (
 	"fmt"
+	"os"
 	"strings"
 
-	"github.com/cosmos/cosmos-sdk/version"
-	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/spf13/cobra"
+	flag "github.com/spf13/pflag"
+	"github.com/spf13/viper"
+
+	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/crypto"
 
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/client/utils"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/version"
+	"github.com/cosmos/cosmos-sdk/x/auth"
 	authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
-	"github.com/cosmos/cosmos-sdk/x/staking"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 // GetCmdCreateValidator implements the create validator command handler.
-// TODO: Add full description
 func GetCmdCreateValidator(cdc *codec.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "create-validator",
@@ -70,7 +73,7 @@ func GetCmdEditValidator(cdc *codec.Codec) *cobra.Command {
 				WithAccountDecoder(cdc)
 
 			valAddr := cliCtx.GetFromAddress()
-			description := staking.Description{
+			description := types.Description{
 				Moniker:  viper.GetString(FlagMoniker),
 				Identity: viper.GetString(FlagIdentity),
 				Website:  viper.GetString(FlagWebsite),
@@ -95,12 +98,12 @@ func GetCmdEditValidator(cdc *codec.Codec) *cobra.Command {
 			if minSelfDelegationString != "" {
 				msb, ok := sdk.NewIntFromString(minSelfDelegationString)
 				if !ok {
-					return fmt.Errorf(staking.ErrMinSelfDelegationInvalid(staking.DefaultCodespace).Error())
+					return fmt.Errorf(types.ErrMinSelfDelegationInvalid(types.DefaultCodespace).Error())
 				}
 				newMinSelfDelegation = &msb
 			}
 
-			msg := staking.NewMsgEditValidator(sdk.ValAddress(valAddr), description, newRate, newMinSelfDelegation)
+			msg := types.NewMsgEditValidator(sdk.ValAddress(valAddr), description, newRate, newMinSelfDelegation)
 
 			// build and sign the transaction, then broadcast to Tendermint
 			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg})
@@ -145,7 +148,7 @@ $ %s tx staking delegate cosmosvaloper1l2rsakp388kuv9k8qzq6lrm9taddae7fpx59wm 10
 				return err
 			}
 
-			msg := staking.NewMsgDelegate(delAddr, valAddr, amount)
+			msg := types.NewMsgDelegate(delAddr, valAddr, amount)
 			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg})
 		},
 	}
@@ -188,7 +191,7 @@ $ %s tx staking redelegate cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
 				return err
 			}
 
-			msg := staking.NewMsgBeginRedelegate(delAddr, valSrcAddr, valDstAddr, amount)
+			msg := types.NewMsgBeginRedelegate(delAddr, valSrcAddr, valDstAddr, amount)
 			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg})
 		},
 	}
@@ -226,12 +229,96 @@ $ %s tx staking unbond cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj 100s
 				return err
 			}
 
-			msg := staking.NewMsgUndelegate(delAddr, valAddr, amount)
+			msg := types.NewMsgUndelegate(delAddr, valAddr, amount)
 			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg})
 		},
 	}
 }
 
+//__________________________________________________________
+
+var (
+	defaultTokens                  = sdk.TokensFromTendermintPower(100)
+	defaultAmount                  = defaultTokens.String() + sdk.DefaultBondDenom
+	defaultCommissionRate          = "0.1"
+	defaultCommissionMaxRate       = "0.2"
+	defaultCommissionMaxChangeRate = "0.01"
+	defaultMinSelfDelegation       = "1"
+)
+
+// Return the flagset, particular flags, and a description of defaults
+// this is anticipated to be used with the gen-tx
+func CreateValidatorMsgHelpers(ipDefault string) (fs *flag.FlagSet, nodeIDFlag, pubkeyFlag, amountFlag, defaultsDesc string) {
+
+	fsCreateValidator := flag.NewFlagSet("", flag.ContinueOnError)
+	fsCreateValidator.String(FlagIP, ipDefault, "The node's public IP")
+	fsCreateValidator.String(FlagNodeID, "", "The node's NodeID")
+	fsCreateValidator.String(FlagWebsite, "", "The validator's (optional) website")
+	fsCreateValidator.String(FlagDetails, "", "The validator's (optional) details")
+	fsCreateValidator.String(FlagIdentity, "", "The (optional) identity signature (ex. UPort or Keybase)")
+	fsCreateValidator.AddFlagSet(FsCommissionCreate)
+	fsCreateValidator.AddFlagSet(FsMinSelfDelegation)
+	fsCreateValidator.AddFlagSet(FsAmount)
+	fsCreateValidator.AddFlagSet(FsPk)
+
+	defaultsDesc = fmt.Sprintf(`
+	delegation amount:           %s
+	commission rate:             %s
+	commission max rate:         %s
+	commission max change rate:  %s
+	minimum self delegation:     %s
+`, defaultAmount, defaultCommissionRate,
+		defaultCommissionMaxRate, defaultCommissionMaxChangeRate,
+		defaultMinSelfDelegation)
+
+	return fsCreateValidator, FlagNodeID, FlagPubKey, FlagAmount, defaultsDesc
+}
+
+// prepare flags in config
+func PrepareFlagsForTxCreateValidator(
+	config *cfg.Config, nodeID, chainID string, valPubKey crypto.PubKey,
+) {
+
+	ip := viper.GetString(FlagIP)
+	if ip == "" {
+		fmt.Fprintf(os.Stderr, "couldn't retrieve an external IP; "+
+			"the tx's memo field will be unset")
+	}
+
+	website := viper.GetString(FlagWebsite)
+	details := viper.GetString(FlagDetails)
+	identity := viper.GetString(FlagIdentity)
+
+	viper.Set(client.FlagChainID, chainID)
+	viper.Set(client.FlagFrom, viper.GetString(client.FlagName))
+	viper.Set(FlagNodeID, nodeID)
+	viper.Set(FlagIP, ip)
+	viper.Set(FlagPubKey, sdk.MustBech32ifyConsPub(valPubKey))
+	viper.Set(FlagMoniker, config.Moniker)
+	viper.Set(FlagWebsite, website)
+	viper.Set(FlagDetails, details)
+	viper.Set(FlagIdentity, identity)
+
+	if config.Moniker == "" {
+		viper.Set(FlagMoniker, viper.GetString(client.FlagName))
+	}
+	if viper.GetString(FlagAmount) == "" {
+		viper.Set(FlagAmount, defaultAmount)
+	}
+	if viper.GetString(FlagCommissionRate) == "" {
+		viper.Set(FlagCommissionRate, defaultCommissionRate)
+	}
+	if viper.GetString(FlagCommissionMaxRate) == "" {
+		viper.Set(FlagCommissionMaxRate, defaultCommissionMaxRate)
+	}
+	if viper.GetString(FlagCommissionMaxChangeRate) == "" {
+		viper.Set(FlagCommissionMaxChangeRate, defaultCommissionMaxChangeRate)
+	}
+	if viper.GetString(FlagMinSelfDelegation) == "" {
+		viper.Set(FlagMinSelfDelegation, defaultMinSelfDelegation)
+	}
+}
+
 // BuildCreateValidatorMsg makes a new MsgCreateValidator.
 func BuildCreateValidatorMsg(cliCtx context.CLIContext, txBldr authtxb.TxBuilder) (authtxb.TxBuilder, sdk.Msg, error) {
 	amounstStr := viper.GetString(FlagAmount)
@@ -248,7 +335,7 @@ func BuildCreateValidatorMsg(cliCtx context.CLIContext, txBldr authtxb.TxBuilder
 		return txBldr, nil, err
 	}
 
-	description := staking.NewDescription(
+	description := types.NewDescription(
 		viper.GetString(FlagMoniker),
 		viper.GetString(FlagIdentity),
 		viper.GetString(FlagWebsite),
@@ -268,10 +355,10 @@ func BuildCreateValidatorMsg(cliCtx context.CLIContext, txBldr authtxb.TxBuilder
 	msbStr := viper.GetString(FlagMinSelfDelegation)
 	minSelfDelegation, ok := sdk.NewIntFromString(msbStr)
 	if !ok {
-		return txBldr, nil, fmt.Errorf(staking.ErrMinSelfDelegationInvalid(staking.DefaultCodespace).Error())
+		return txBldr, nil, fmt.Errorf(types.ErrMinSelfDelegationInvalid(types.DefaultCodespace).Error())
 	}
 
-	msg := staking.NewMsgCreateValidator(
+	msg := types.NewMsgCreateValidator(
 		sdk.ValAddress(valAddr), pk, amount, description, commissionMsg, minSelfDelegation,
 	)
 

x/staking/client/cli/tx_test.go

@@ -0,0 +1,84 @@
+package cli
+
+import (
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
+	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/libs/log"
+
+	"github.com/cosmos/cosmos-sdk/server"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func TestPrepareFlagsForTxCreateValidator(t *testing.T) {
+	defer server.SetupViper(t)()
+	config, err := tcmd.ParseConfig()
+	require.Nil(t, err)
+	logger := log.NewNopLogger()
+	ctx := server.NewContext(config, logger)
+
+	valPubKey, _ := sdk.GetConsPubKeyBech32("cosmosvalconspub1zcjduepq7jsrkl9fgqk0wj3ahmfr8pgxj6vakj2wzn656s8pehh0zhv2w5as5gd80a")
+
+	type args struct {
+		config    *cfg.Config
+		nodeID    string
+		chainID   string
+		valPubKey crypto.PubKey
+	}
+
+	type extraParams struct {
+		amount                  string
+		commissionRate          string
+		commissionMaxRate       string
+		commissionMaxChangeRate string
+		minSelfDelegation       string
+	}
+
+	type testcase struct {
+		name string
+		args args
+	}
+
+	runTest := func(t *testing.T, tt testcase, params extraParams) {
+		PrepareFlagsForTxCreateValidator(tt.args.config, tt.args.nodeID,
+			tt.args.chainID, tt.args.valPubKey)
+
+		require.Equal(t, params.amount, viper.GetString(FlagAmount))
+		require.Equal(t, params.commissionRate, viper.GetString(FlagCommissionRate))
+		require.Equal(t, params.commissionMaxRate, viper.GetString(FlagCommissionMaxRate))
+		require.Equal(t, params.commissionMaxChangeRate, viper.GetString(FlagCommissionMaxChangeRate))
+		require.Equal(t, params.minSelfDelegation, viper.GetString(FlagMinSelfDelegation))
+	}
+
+	tests := []testcase{
+		{"No parameters", args{ctx.Config, "X", "chainId", valPubKey}},
+	}
+
+	defaultParams := extraParams{
+		defaultAmount,
+		defaultCommissionRate,
+		defaultCommissionMaxRate,
+		defaultCommissionMaxChangeRate,
+		defaultMinSelfDelegation,
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Run(tt.name, func(t *testing.T) { runTest(t, tt, defaultParams) })
+		})
+	}
+
+	// Override default params
+	params := extraParams{"5stake", "1.0", "1.0", "1.0", "1.0"}
+	viper.Set(FlagAmount, params.amount)
+	viper.Set(FlagCommissionRate, params.commissionRate)
+	viper.Set(FlagCommissionMaxRate, params.commissionMaxRate)
+	viper.Set(FlagCommissionMaxChangeRate, params.commissionMaxChangeRate)
+	viper.Set(FlagMinSelfDelegation, params.minSelfDelegation)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) { runTest(t, tt, params) })
+	}
+}

x/staking/handler_test.go

@@ -55,8 +55,8 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	// verify that the by power index exists
 	validator, found := keeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
-	power := keep.GetValidatorsByPowerIndexKey(validator)
-	require.True(t, keep.ValidatorByPowerIndexExists(ctx, keeper, power))
+	power := GetValidatorsByPowerIndexKey(validator)
+	require.True(t, ValidatorByPowerIndexExists(ctx, keeper, power))
 
 	// create a second validator keep it bonded
 	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], initBond)

x/staking/keeper/alias_functions.go

@@ -13,7 +13,7 @@ var _ sdk.ValidatorSet = Keeper{}
 // iterate through the validator set and perform the provided function
 func (k Keeper) IterateValidators(ctx sdk.Context, fn func(index int64, validator sdk.Validator) (stop bool)) {
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, ValidatorsKey)
+	iterator := sdk.KVStorePrefixIterator(store, types.ValidatorsKey)
 	defer iterator.Close()
 	i := int64(0)
 	for ; iterator.Valid(); iterator.Next() {
@@ -31,7 +31,7 @@ func (k Keeper) IterateBondedValidatorsByPower(ctx sdk.Context, fn func(index in
 	store := ctx.KVStore(k.storeKey)
 	maxValidators := k.MaxValidators(ctx)
 
-	iterator := sdk.KVStoreReversePrefixIterator(store, ValidatorsByPowerIndexKey)
+	iterator := sdk.KVStoreReversePrefixIterator(store, types.ValidatorsByPowerIndexKey)
 	defer iterator.Close()
 
 	i := int64(0)
@@ -55,7 +55,7 @@ func (k Keeper) IterateLastValidators(ctx sdk.Context, fn func(index int64, vali
 	defer iterator.Close()
 	i := int64(0)
 	for ; iterator.Valid(); iterator.Next() {
-		address := AddressFromLastValidatorPowerKey(iterator.Key())
+		address := types.AddressFromLastValidatorPowerKey(iterator.Key())
 		validator, found := k.GetValidator(ctx, address)
 		if !found {
 			panic(fmt.Sprintf("validator record not found for address: %v\n", address))
@@ -136,7 +136,7 @@ func (k Keeper) IterateDelegations(ctx sdk.Context, delAddr sdk.AccAddress,
 	fn func(index int64, del sdk.Delegation) (stop bool)) {
 
 	store := ctx.KVStore(k.storeKey)
-	delegatorPrefixKey := GetDelegationsKey(delAddr)
+	delegatorPrefixKey := types.GetDelegationsKey(delAddr)
 	iterator := sdk.KVStorePrefixIterator(store, delegatorPrefixKey) // smallest to largest
 	defer iterator.Close()
 	for i := int64(0); iterator.Valid(); iterator.Next() {
@@ -153,7 +153,7 @@ func (k Keeper) IterateDelegations(ctx sdk.Context, delAddr sdk.AccAddress,
 // TODO: remove this func, change all usage for iterate functionality
 func (k Keeper) GetAllSDKDelegations(ctx sdk.Context) (delegations []sdk.Delegation) {
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, DelegationKey)
+	iterator := sdk.KVStorePrefixIterator(store, types.DelegationKey)
 	defer iterator.Close()
 
 	for ; iterator.Valid(); iterator.Next() {

x/staking/keeper/delegation.go

@@ -14,7 +14,7 @@ func (k Keeper) GetDelegation(ctx sdk.Context,
 	delegation types.Delegation, found bool) {
 
 	store := ctx.KVStore(k.storeKey)
-	key := GetDelegationKey(delAddr, valAddr)
+	key := types.GetDelegationKey(delAddr, valAddr)
 	value := store.Get(key)
 	if value == nil {
 		return delegation, false
@@ -27,7 +27,7 @@ func (k Keeper) GetDelegation(ctx sdk.Context,
 // return all delegations used during genesis dump
 func (k Keeper) GetAllDelegations(ctx sdk.Context) (delegations []types.Delegation) {
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, DelegationKey)
+	iterator := sdk.KVStorePrefixIterator(store, types.DelegationKey)
 	defer iterator.Close()
 
 	for ; iterator.Valid(); iterator.Next() {
@@ -40,7 +40,7 @@ func (k Keeper) GetAllDelegations(ctx sdk.Context) (delegations []types.Delegati
 // return all delegations to a specific validator. Useful for querier.
 func (k Keeper) GetValidatorDelegations(ctx sdk.Context, valAddr sdk.ValAddress) (delegations []types.Delegation) {
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, DelegationKey)
+	iterator := sdk.KVStorePrefixIterator(store, types.DelegationKey)
 	defer iterator.Close()
 
 	for ; iterator.Valid(); iterator.Next() {
@@ -59,7 +59,7 @@ func (k Keeper) GetDelegatorDelegations(ctx sdk.Context, delegator sdk.AccAddres
 	delegations = make([]types.Delegation, maxRetrieve)
 
 	store := ctx.KVStore(k.storeKey)
-	delegatorPrefixKey := GetDelegationsKey(delegator)
+	delegatorPrefixKey := types.GetDelegationsKey(delegator)
 	iterator := sdk.KVStorePrefixIterator(store, delegatorPrefixKey)
 	defer iterator.Close()
 
@@ -76,7 +76,7 @@ func (k Keeper) GetDelegatorDelegations(ctx sdk.Context, delegator sdk.AccAddres
 func (k Keeper) SetDelegation(ctx sdk.Context, delegation types.Delegation) {
 	store := ctx.KVStore(k.storeKey)
 	b := types.MustMarshalDelegation(k.cdc, delegation)
-	store.Set(GetDelegationKey(delegation.DelegatorAddress, delegation.ValidatorAddress), b)
+	store.Set(types.GetDelegationKey(delegation.DelegatorAddress, delegation.ValidatorAddress), b)
 }
 
 // remove a delegation
@@ -84,7 +84,7 @@ func (k Keeper) RemoveDelegation(ctx sdk.Context, delegation types.Delegation) {
 	// TODO: Consider calling hooks outside of the store wrapper functions, it's unobvious.
 	k.BeforeDelegationRemoved(ctx, delegation.DelegatorAddress, delegation.ValidatorAddress)
 	store := ctx.KVStore(k.storeKey)
-	store.Delete(GetDelegationKey(delegation.DelegatorAddress, delegation.ValidatorAddress))
+	store.Delete(types.GetDelegationKey(delegation.DelegatorAddress, delegation.ValidatorAddress))
 }
 
 // return a given amount of all the delegator unbonding-delegations
@@ -94,7 +94,7 @@ func (k Keeper) GetUnbondingDelegations(ctx sdk.Context, delegator sdk.AccAddres
 	unbondingDelegations = make([]types.UnbondingDelegation, maxRetrieve)
 
 	store := ctx.KVStore(k.storeKey)
-	delegatorPrefixKey := GetUBDsKey(delegator)
+	delegatorPrefixKey := types.GetUBDsKey(delegator)
 	iterator := sdk.KVStorePrefixIterator(store, delegatorPrefixKey)
 	defer iterator.Close()
 
@@ -112,7 +112,7 @@ func (k Keeper) GetUnbondingDelegation(ctx sdk.Context,
 	delAddr sdk.AccAddress, valAddr sdk.ValAddress) (ubd types.UnbondingDelegation, found bool) {
 
 	store := ctx.KVStore(k.storeKey)
-	key := GetUBDKey(delAddr, valAddr)
+	key := types.GetUBDKey(delAddr, valAddr)
 	value := store.Get(key)
 	if value == nil {
 		return ubd, false
@@ -125,11 +125,11 @@ func (k Keeper) GetUnbondingDelegation(ctx sdk.Context,
 // return all unbonding delegations from a particular validator
 func (k Keeper) GetUnbondingDelegationsFromValidator(ctx sdk.Context, valAddr sdk.ValAddress) (ubds []types.UnbondingDelegation) {
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, GetUBDsByValIndexKey(valAddr))
+	iterator := sdk.KVStorePrefixIterator(store, types.GetUBDsByValIndexKey(valAddr))
 	defer iterator.Close()
 
 	for ; iterator.Valid(); iterator.Next() {
-		key := GetUBDKeyFromValIndexKey(iterator.Key())
+		key := types.GetUBDKeyFromValIndexKey(iterator.Key())
 		value := store.Get(key)
 		ubd := types.MustUnmarshalUBD(k.cdc, value)
 		ubds = append(ubds, ubd)
@@ -140,7 +140,7 @@ func (k Keeper) GetUnbondingDelegationsFromValidator(ctx sdk.Context, valAddr sd
 // iterate through all of the unbonding delegations
 func (k Keeper) IterateUnbondingDelegations(ctx sdk.Context, fn func(index int64, ubd types.UnbondingDelegation) (stop bool)) {
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, UnbondingDelegationKey)
+	iterator := sdk.KVStorePrefixIterator(store, types.UnbondingDelegationKey)
 	defer iterator.Close()
 
 	for i := int64(0); iterator.Valid(); iterator.Next() {
@@ -167,17 +167,17 @@ func (k Keeper) HasMaxUnbondingDelegationEntries(ctx sdk.Context,
 func (k Keeper) SetUnbondingDelegation(ctx sdk.Context, ubd types.UnbondingDelegation) {
 	store := ctx.KVStore(k.storeKey)
 	bz := types.MustMarshalUBD(k.cdc, ubd)
-	key := GetUBDKey(ubd.DelegatorAddress, ubd.ValidatorAddress)
+	key := types.GetUBDKey(ubd.DelegatorAddress, ubd.ValidatorAddress)
 	store.Set(key, bz)
-	store.Set(GetUBDByValIndexKey(ubd.DelegatorAddress, ubd.ValidatorAddress), []byte{}) // index, store empty bytes
+	store.Set(types.GetUBDByValIndexKey(ubd.DelegatorAddress, ubd.ValidatorAddress), []byte{}) // index, store empty bytes
 }
 
 // remove the unbonding delegation object and associated index
 func (k Keeper) RemoveUnbondingDelegation(ctx sdk.Context, ubd types.UnbondingDelegation) {
 	store := ctx.KVStore(k.storeKey)
-	key := GetUBDKey(ubd.DelegatorAddress, ubd.ValidatorAddress)
+	key := types.GetUBDKey(ubd.DelegatorAddress, ubd.ValidatorAddress)
 	store.Delete(key)
-	store.Delete(GetUBDByValIndexKey(ubd.DelegatorAddress, ubd.ValidatorAddress))
+	store.Delete(types.GetUBDByValIndexKey(ubd.DelegatorAddress, ubd.ValidatorAddress))
 }
 
 // SetUnbondingDelegationEntry adds an entry to the unbonding delegation at
@@ -202,7 +202,7 @@ func (k Keeper) SetUnbondingDelegationEntry(ctx sdk.Context,
 // corresponding to unbonding delegations that expire at a certain time.
 func (k Keeper) GetUBDQueueTimeSlice(ctx sdk.Context, timestamp time.Time) (dvPairs []types.DVPair) {
 	store := ctx.KVStore(k.storeKey)
-	bz := store.Get(GetUnbondingDelegationTimeKey(timestamp))
+	bz := store.Get(types.GetUnbondingDelegationTimeKey(timestamp))
 	if bz == nil {
 		return []types.DVPair{}
 	}
@@ -214,7 +214,7 @@ func (k Keeper) GetUBDQueueTimeSlice(ctx sdk.Context, timestamp time.Time) (dvPa
 func (k Keeper) SetUBDQueueTimeSlice(ctx sdk.Context, timestamp time.Time, keys []types.DVPair) {
 	store := ctx.KVStore(k.storeKey)
 	bz := k.cdc.MustMarshalBinaryLengthPrefixed(keys)
-	store.Set(GetUnbondingDelegationTimeKey(timestamp), bz)
+	store.Set(types.GetUnbondingDelegationTimeKey(timestamp), bz)
 }
 
 // Insert an unbonding delegation to the appropriate timeslice in the unbonding queue
@@ -234,8 +234,8 @@ func (k Keeper) InsertUBDQueue(ctx sdk.Context, ubd types.UnbondingDelegation,
 // Returns all the unbonding queue timeslices from time 0 until endTime
 func (k Keeper) UBDQueueIterator(ctx sdk.Context, endTime time.Time) sdk.Iterator {
 	store := ctx.KVStore(k.storeKey)
-	return store.Iterator(UnbondingQueueKey,
-		sdk.InclusiveEndBytes(GetUnbondingDelegationTimeKey(endTime)))
+	return store.Iterator(types.UnbondingQueueKey,
+		sdk.InclusiveEndBytes(types.GetUnbondingDelegationTimeKey(endTime)))
 }
 
 // Returns a concatenated list of all the timeslices inclusively previous to
@@ -262,7 +262,7 @@ func (k Keeper) GetRedelegations(ctx sdk.Context, delegator sdk.AccAddress,
 	redelegations = make([]types.Redelegation, maxRetrieve)
 
 	store := ctx.KVStore(k.storeKey)
-	delegatorPrefixKey := GetREDsKey(delegator)
+	delegatorPrefixKey := types.GetREDsKey(delegator)
 	iterator := sdk.KVStorePrefixIterator(store, delegatorPrefixKey)
 	defer iterator.Close()
 
@@ -280,7 +280,7 @@ func (k Keeper) GetRedelegation(ctx sdk.Context,
 	delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) (red types.Redelegation, found bool) {
 
 	store := ctx.KVStore(k.storeKey)
-	key := GetREDKey(delAddr, valSrcAddr, valDstAddr)
+	key := types.GetREDKey(delAddr, valSrcAddr, valDstAddr)
 	value := store.Get(key)
 	if value == nil {
 		return red, false
@@ -293,11 +293,11 @@ func (k Keeper) GetRedelegation(ctx sdk.Context,
 // return all redelegations from a particular validator
 func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.ValAddress) (reds []types.Redelegation) {
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, GetREDsFromValSrcIndexKey(valAddr))
+	iterator := sdk.KVStorePrefixIterator(store, types.GetREDsFromValSrcIndexKey(valAddr))
 	defer iterator.Close()
 
 	for ; iterator.Valid(); iterator.Next() {
-		key := GetREDKeyFromValSrcIndexKey(iterator.Key())
+		key := types.GetREDKeyFromValSrcIndexKey(iterator.Key())
 		value := store.Get(key)
 		red := types.MustUnmarshalRED(k.cdc, value)
 		reds = append(reds, red)
@@ -310,7 +310,7 @@ func (k Keeper) HasReceivingRedelegation(ctx sdk.Context,
 	delAddr sdk.AccAddress, valDstAddr sdk.ValAddress) bool {
 
 	store := ctx.KVStore(k.storeKey)
-	prefix := GetREDsByDelToValDstIndexKey(delAddr, valDstAddr)
+	prefix := types.GetREDsByDelToValDstIndexKey(delAddr, valDstAddr)
 	iterator := sdk.KVStorePrefixIterator(store, prefix)
 	defer iterator.Close()
 
@@ -333,10 +333,10 @@ func (k Keeper) HasMaxRedelegationEntries(ctx sdk.Context,
 func (k Keeper) SetRedelegation(ctx sdk.Context, red types.Redelegation) {
 	store := ctx.KVStore(k.storeKey)
 	bz := types.MustMarshalRED(k.cdc, red)
-	key := GetREDKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress)
+	key := types.GetREDKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress)
 	store.Set(key, bz)
-	store.Set(GetREDByValSrcIndexKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress), []byte{})
-	store.Set(GetREDByValDstIndexKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress), []byte{})
+	store.Set(types.GetREDByValSrcIndexKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress), []byte{})
+	store.Set(types.GetREDByValDstIndexKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress), []byte{})
 }
 
 // SetUnbondingDelegationEntry adds an entry to the unbonding delegation at
@@ -361,7 +361,7 @@ func (k Keeper) SetRedelegationEntry(ctx sdk.Context,
 // iterate through all redelegations
 func (k Keeper) IterateRedelegations(ctx sdk.Context, fn func(index int64, red types.Redelegation) (stop bool)) {
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, RedelegationKey)
+	iterator := sdk.KVStorePrefixIterator(store, types.RedelegationKey)
 	defer iterator.Close()
 
 	for i := int64(0); iterator.Valid(); iterator.Next() {
@@ -376,10 +376,10 @@ func (k Keeper) IterateRedelegations(ctx sdk.Context, fn func(index int64, red t
 // remove a redelegation object and associated index
 func (k Keeper) RemoveRedelegation(ctx sdk.Context, red types.Redelegation) {
 	store := ctx.KVStore(k.storeKey)
-	redKey := GetREDKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress)
+	redKey := types.GetREDKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress)
 	store.Delete(redKey)
-	store.Delete(GetREDByValSrcIndexKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress))
-	store.Delete(GetREDByValDstIndexKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress))
+	store.Delete(types.GetREDByValSrcIndexKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress))
+	store.Delete(types.GetREDByValDstIndexKey(red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress))
 }
 
 // redelegation queue timeslice operations
@@ -388,7 +388,7 @@ func (k Keeper) RemoveRedelegation(ctx sdk.Context, red types.Redelegation) {
 // that expire at a certain time.
 func (k Keeper) GetRedelegationQueueTimeSlice(ctx sdk.Context, timestamp time.Time) (dvvTriplets []types.DVVTriplet) {
 	store := ctx.KVStore(k.storeKey)
-	bz := store.Get(GetRedelegationTimeKey(timestamp))
+	bz := store.Get(types.GetRedelegationTimeKey(timestamp))
 	if bz == nil {
 		return []types.DVVTriplet{}
 	}
@@ -400,7 +400,7 @@ func (k Keeper) GetRedelegationQueueTimeSlice(ctx sdk.Context, timestamp time.Ti
 func (k Keeper) SetRedelegationQueueTimeSlice(ctx sdk.Context, timestamp time.Time, keys []types.DVVTriplet) {
 	store := ctx.KVStore(k.storeKey)
 	bz := k.cdc.MustMarshalBinaryLengthPrefixed(keys)
-	store.Set(GetRedelegationTimeKey(timestamp), bz)
+	store.Set(types.GetRedelegationTimeKey(timestamp), bz)
 }
 
 // Insert an redelegation delegation to the appropriate timeslice in the redelegation queue
@@ -424,7 +424,7 @@ func (k Keeper) InsertRedelegationQueue(ctx sdk.Context, red types.Redelegation,
 // Returns all the redelegation queue timeslices from time 0 until endTime
 func (k Keeper) RedelegationQueueIterator(ctx sdk.Context, endTime time.Time) sdk.Iterator {
 	store := ctx.KVStore(k.storeKey)
-	return store.Iterator(RedelegationQueueKey, sdk.InclusiveEndBytes(GetRedelegationTimeKey(endTime)))
+	return store.Iterator(types.RedelegationQueueKey, sdk.InclusiveEndBytes(types.GetRedelegationTimeKey(endTime)))
 }
 
 // Returns a concatenated list of all the timeslices inclusively previous to

x/staking/keeper/invariants.go

@@ -120,7 +120,7 @@ func NonNegativePowerInvariant(k Keeper) sdk.Invariant {
 				panic(fmt.Sprintf("validator record not found for address: %X\n", iterator.Value()))
 			}
 
-			powerKey := GetValidatorsByPowerIndexKey(validator)
+			powerKey := types.GetValidatorsByPowerIndexKey(validator)
 
 			if !bytes.Equal(iterator.Key(), powerKey) {
 				return fmt.Errorf("power store invariance:\n\tvalidator.Power: %v"+

x/staking/keeper/keeper.go

@@ -65,7 +65,7 @@ func (k Keeper) Codespace() sdk.CodespaceType {
 // get the pool
 func (k Keeper) GetPool(ctx sdk.Context) (pool types.Pool) {
 	store := ctx.KVStore(k.storeKey)
-	b := store.Get(PoolKey)
+	b := store.Get(types.PoolKey)
 	if b == nil {
 		panic("stored pool should not have been nil")
 	}
@@ -77,13 +77,13 @@ func (k Keeper) GetPool(ctx sdk.Context) (pool types.Pool) {
 func (k Keeper) SetPool(ctx sdk.Context, pool types.Pool) {
 	store := ctx.KVStore(k.storeKey)
 	b := k.cdc.MustMarshalBinaryLengthPrefixed(pool)
-	store.Set(PoolKey, b)
+	store.Set(types.PoolKey, b)
 }
 
 // Load the last total validator power.
 func (k Keeper) GetLastTotalPower(ctx sdk.Context) (power sdk.Int) {
 	store := ctx.KVStore(k.storeKey)
-	b := store.Get(LastTotalPowerKey)
+	b := store.Get(types.LastTotalPowerKey)
 	if b == nil {
 		return sdk.ZeroInt()
 	}
@@ -95,5 +95,5 @@ func (k Keeper) GetLastTotalPower(ctx sdk.Context) (power sdk.Int) {
 func (k Keeper) SetLastTotalPower(ctx sdk.Context, power sdk.Int) {
 	store := ctx.KVStore(k.storeKey)
 	b := k.cdc.MustMarshalBinaryLengthPrefixed(power)
-	store.Set(LastTotalPowerKey, b)
+	store.Set(types.LastTotalPowerKey, b)
 }

x/staking/keeper/query_utils.go

@@ -11,7 +11,7 @@ func (k Keeper) GetDelegatorValidators(ctx sdk.Context, delegatorAddr sdk.AccAdd
 	validators = make([]types.Validator, maxRetrieve)
 
 	store := ctx.KVStore(k.storeKey)
-	delegatorPrefixKey := GetDelegationsKey(delegatorAddr)
+	delegatorPrefixKey := types.GetDelegationsKey(delegatorAddr)
 	iterator := sdk.KVStorePrefixIterator(store, delegatorPrefixKey) // smallest to largest
 	defer iterator.Close()
 
@@ -52,7 +52,7 @@ func (k Keeper) GetAllDelegatorDelegations(ctx sdk.Context, delegator sdk.AccAdd
 	delegations := make([]types.Delegation, 0)
 
 	store := ctx.KVStore(k.storeKey)
-	delegatorPrefixKey := GetDelegationsKey(delegator)
+	delegatorPrefixKey := types.GetDelegationsKey(delegator)
 	iterator := sdk.KVStorePrefixIterator(store, delegatorPrefixKey) //smallest to largest
 	defer iterator.Close()
 
@@ -71,12 +71,11 @@ func (k Keeper) GetAllUnbondingDelegations(ctx sdk.Context, delegator sdk.AccAdd
 	unbondingDelegations := make([]types.UnbondingDelegation, 0)
 
 	store := ctx.KVStore(k.storeKey)
-	delegatorPrefixKey := GetUBDsKey(delegator)
+	delegatorPrefixKey := types.GetUBDsKey(delegator)
 	iterator := sdk.KVStorePrefixIterator(store, delegatorPrefixKey) // smallest to largest
 	defer iterator.Close()
 
-	i := 0
-	for ; iterator.Valid(); iterator.Next() {
+	for i := 0; iterator.Valid(); iterator.Next() {
 		unbondingDelegation := types.MustUnmarshalUBD(k.cdc, iterator.Value())
 		unbondingDelegations = append(unbondingDelegations, unbondingDelegation)
 		i++
@@ -91,7 +90,7 @@ func (k Keeper) GetAllRedelegations(ctx sdk.Context, delegator sdk.AccAddress,
 	redelegations []types.Redelegation) {
 
 	store := ctx.KVStore(k.storeKey)
-	delegatorPrefixKey := GetREDsKey(delegator)
+	delegatorPrefixKey := types.GetREDsKey(delegator)
 	iterator := sdk.KVStorePrefixIterator(store, delegatorPrefixKey) // smallest to largest
 	defer iterator.Close()
 

x/staking/keeper/test_common.go

@@ -225,11 +225,11 @@ func TestingUpdateValidator(keeper Keeper, ctx sdk.Context, validator types.Vali
 	keeper.SetValidator(ctx, validator)
 	{ // Remove any existing power key for validator.
 		store := ctx.KVStore(keeper.storeKey)
-		iterator := sdk.KVStorePrefixIterator(store, ValidatorsByPowerIndexKey)
+		iterator := sdk.KVStorePrefixIterator(store, types.ValidatorsByPowerIndexKey)
 		defer iterator.Close()
 		deleted := false
 		for ; iterator.Valid(); iterator.Next() {
-			valAddr := parseValidatorPowerRankKey(iterator.Key())
+			valAddr := types.ParseValidatorPowerRankKey(iterator.Key())
 			if bytes.Equal(valAddr, validator.OperatorAddress) {
 				if deleted {
 					panic("found duplicate power index key")

x/staking/keeper/val_state_change.go

@@ -35,7 +35,7 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
 	last := k.getLastValidatorsByAddr(ctx)
 
 	// Iterate over validators, highest power to lowest.
-	iterator := sdk.KVStoreReversePrefixIterator(store, ValidatorsByPowerIndexKey)
+	iterator := sdk.KVStoreReversePrefixIterator(store, types.ValidatorsByPowerIndexKey)
 	defer iterator.Close()
 	for count := 0; iterator.Valid() && count < int(maxValidators); iterator.Next() {
 
@@ -245,7 +245,7 @@ type validatorsByAddr map[[sdk.AddrLen]byte][]byte
 func (k Keeper) getLastValidatorsByAddr(ctx sdk.Context) validatorsByAddr {
 	last := make(validatorsByAddr)
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, LastValidatorPowerKey)
+	iterator := sdk.KVStorePrefixIterator(store, types.LastValidatorPowerKey)
 	defer iterator.Close()
 	// iterate over the last validator set index
 	for ; iterator.Valid(); iterator.Next() {

x/staking/keeper/validator.go

@@ -28,7 +28,7 @@ func newCachedValidator(val types.Validator, marshalled string) cachedValidator
 // get a single validator
 func (k Keeper) GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator types.Validator, found bool) {
 	store := ctx.KVStore(k.storeKey)
-	value := store.Get(GetValidatorKey(addr))
+	value := store.Get(types.GetValidatorKey(addr))
 	if value == nil {
 		return validator, false
 	}
@@ -69,7 +69,7 @@ func (k Keeper) mustGetValidator(ctx sdk.Context, addr sdk.ValAddress) types.Val
 // get a single validator by consensus address
 func (k Keeper) GetValidatorByConsAddr(ctx sdk.Context, consAddr sdk.ConsAddress) (validator types.Validator, found bool) {
 	store := ctx.KVStore(k.storeKey)
-	opAddr := store.Get(GetValidatorByConsAddrKey(consAddr))
+	opAddr := store.Get(types.GetValidatorByConsAddrKey(consAddr))
 	if opAddr == nil {
 		return validator, false
 	}
@@ -88,14 +88,14 @@ func (k Keeper) mustGetValidatorByConsAddr(ctx sdk.Context, consAddr sdk.ConsAdd
 func (k Keeper) SetValidator(ctx sdk.Context, validator types.Validator) {
 	store := ctx.KVStore(k.storeKey)
 	bz := types.MustMarshalValidator(k.cdc, validator)
-	store.Set(GetValidatorKey(validator.OperatorAddress), bz)
+	store.Set(types.GetValidatorKey(validator.OperatorAddress), bz)
 }
 
 // validator index
 func (k Keeper) SetValidatorByConsAddr(ctx sdk.Context, validator types.Validator) {
 	store := ctx.KVStore(k.storeKey)
 	consAddr := sdk.ConsAddress(validator.ConsPubKey.Address())
-	store.Set(GetValidatorByConsAddrKey(consAddr), validator.OperatorAddress)
+	store.Set(types.GetValidatorByConsAddrKey(consAddr), validator.OperatorAddress)
 }
 
 // validator index
@@ -105,19 +105,19 @@ func (k Keeper) SetValidatorByPowerIndex(ctx sdk.Context, validator types.Valida
 		return
 	}
 	store := ctx.KVStore(k.storeKey)
-	store.Set(GetValidatorsByPowerIndexKey(validator), validator.OperatorAddress)
+	store.Set(types.GetValidatorsByPowerIndexKey(validator), validator.OperatorAddress)
 }
 
 // validator index
 func (k Keeper) DeleteValidatorByPowerIndex(ctx sdk.Context, validator types.Validator) {
 	store := ctx.KVStore(k.storeKey)
-	store.Delete(GetValidatorsByPowerIndexKey(validator))
+	store.Delete(types.GetValidatorsByPowerIndexKey(validator))
 }
 
 // validator index
 func (k Keeper) SetNewValidatorByPowerIndex(ctx sdk.Context, validator types.Validator) {
 	store := ctx.KVStore(k.storeKey)
-	store.Set(GetValidatorsByPowerIndexKey(validator), validator.OperatorAddress)
+	store.Set(types.GetValidatorsByPowerIndexKey(validator), validator.OperatorAddress)
 }
 
 // Update the tokens of an existing validator, update the validators power index key
@@ -199,9 +199,9 @@ func (k Keeper) RemoveValidator(ctx sdk.Context, address sdk.ValAddress) {
 
 	// delete the old validator record
 	store := ctx.KVStore(k.storeKey)
-	store.Delete(GetValidatorKey(address))
-	store.Delete(GetValidatorByConsAddrKey(sdk.ConsAddress(validator.ConsPubKey.Address())))
-	store.Delete(GetValidatorsByPowerIndexKey(validator))
+	store.Delete(types.GetValidatorKey(address))
+	store.Delete(types.GetValidatorByConsAddrKey(sdk.ConsAddress(validator.ConsPubKey.Address())))
+	store.Delete(types.GetValidatorsByPowerIndexKey(validator))
 
 	// call hooks
 	k.AfterValidatorRemoved(ctx, validator.ConsAddress(), validator.OperatorAddress)
@@ -212,7 +212,7 @@ func (k Keeper) RemoveValidator(ctx sdk.Context, address sdk.ValAddress) {
 // get the set of all validators with no limits, used during genesis dump
 func (k Keeper) GetAllValidators(ctx sdk.Context) (validators []types.Validator) {
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, ValidatorsKey)
+	iterator := sdk.KVStorePrefixIterator(store, types.ValidatorsKey)
 	defer iterator.Close()
 
 	for ; iterator.Valid(); iterator.Next() {
@@ -227,7 +227,7 @@ func (k Keeper) GetValidators(ctx sdk.Context, maxRetrieve uint16) (validators [
 	store := ctx.KVStore(k.storeKey)
 	validators = make([]types.Validator, maxRetrieve)
 
-	iterator := sdk.KVStorePrefixIterator(store, ValidatorsKey)
+	iterator := sdk.KVStorePrefixIterator(store, types.ValidatorsKey)
 	defer iterator.Close()
 
 	i := 0
@@ -245,7 +245,7 @@ func (k Keeper) GetBondedValidatorsByPower(ctx sdk.Context) []types.Validator {
 	maxValidators := k.MaxValidators(ctx)
 	validators := make([]types.Validator, maxValidators)
 
-	iterator := sdk.KVStoreReversePrefixIterator(store, ValidatorsByPowerIndexKey)
+	iterator := sdk.KVStoreReversePrefixIterator(store, types.ValidatorsByPowerIndexKey)
 	defer iterator.Close()
 
 	i := 0
@@ -264,7 +264,7 @@ func (k Keeper) GetBondedValidatorsByPower(ctx sdk.Context) []types.Validator {
 // returns an iterator for the current validator power store
 func (k Keeper) ValidatorsPowerStoreIterator(ctx sdk.Context) (iterator sdk.Iterator) {
 	store := ctx.KVStore(k.storeKey)
-	iterator = sdk.KVStoreReversePrefixIterator(store, ValidatorsByPowerIndexKey)
+	iterator = sdk.KVStoreReversePrefixIterator(store, types.ValidatorsByPowerIndexKey)
 	return iterator
 }
 
@@ -275,7 +275,7 @@ func (k Keeper) ValidatorsPowerStoreIterator(ctx sdk.Context) (iterator sdk.Iter
 // Returns zero if the operator was not a validator last block.
 func (k Keeper) GetLastValidatorPower(ctx sdk.Context, operator sdk.ValAddress) (power int64) {
 	store := ctx.KVStore(k.storeKey)
-	bz := store.Get(GetLastValidatorPowerKey(operator))
+	bz := store.Get(types.GetLastValidatorPowerKey(operator))
 	if bz == nil {
 		return 0
 	}
@@ -287,29 +287,29 @@ func (k Keeper) GetLastValidatorPower(ctx sdk.Context, operator sdk.ValAddress)
 func (k Keeper) SetLastValidatorPower(ctx sdk.Context, operator sdk.ValAddress, power int64) {
 	store := ctx.KVStore(k.storeKey)
 	bz := k.cdc.MustMarshalBinaryLengthPrefixed(power)
-	store.Set(GetLastValidatorPowerKey(operator), bz)
+	store.Set(types.GetLastValidatorPowerKey(operator), bz)
 }
 
 // Delete the last validator power.
 func (k Keeper) DeleteLastValidatorPower(ctx sdk.Context, operator sdk.ValAddress) {
 	store := ctx.KVStore(k.storeKey)
-	store.Delete(GetLastValidatorPowerKey(operator))
+	store.Delete(types.GetLastValidatorPowerKey(operator))
 }
 
 // returns an iterator for the consensus validators in the last block
 func (k Keeper) LastValidatorsIterator(ctx sdk.Context) (iterator sdk.Iterator) {
 	store := ctx.KVStore(k.storeKey)
-	iterator = sdk.KVStorePrefixIterator(store, LastValidatorPowerKey)
+	iterator = sdk.KVStorePrefixIterator(store, types.LastValidatorPowerKey)
 	return iterator
 }
 
 // Iterate over last validator powers.
 func (k Keeper) IterateLastValidatorPowers(ctx sdk.Context, handler func(operator sdk.ValAddress, power int64) (stop bool)) {
 	store := ctx.KVStore(k.storeKey)
-	iter := sdk.KVStorePrefixIterator(store, LastValidatorPowerKey)
+	iter := sdk.KVStorePrefixIterator(store, types.LastValidatorPowerKey)
 	defer iter.Close()
 	for ; iter.Valid(); iter.Next() {
-		addr := sdk.ValAddress(iter.Key()[len(LastValidatorPowerKey):])
+		addr := sdk.ValAddress(iter.Key()[len(types.LastValidatorPowerKey):])
 		var power int64
 		k.cdc.MustUnmarshalBinaryLengthPrefixed(iter.Value(), &power)
 		if handler(addr, power) {
@@ -326,7 +326,7 @@ func (k Keeper) GetLastValidators(ctx sdk.Context) (validators []types.Validator
 	maxValidators := k.MaxValidators(ctx)
 	validators = make([]types.Validator, maxValidators)
 
-	iterator := sdk.KVStorePrefixIterator(store, LastValidatorPowerKey)
+	iterator := sdk.KVStorePrefixIterator(store, types.LastValidatorPowerKey)
 	defer iterator.Close()
 
 	i := 0
@@ -336,7 +336,7 @@ func (k Keeper) GetLastValidators(ctx sdk.Context) (validators []types.Validator
 		if i >= int(maxValidators) {
 			panic("more validators than maxValidators found")
 		}
-		address := AddressFromLastValidatorPowerKey(iterator.Key())
+		address := types.AddressFromLastValidatorPowerKey(iterator.Key())
 		validator := k.mustGetValidator(ctx, address)
 
 		validators[i] = validator
@@ -352,7 +352,7 @@ func (k Keeper) GetLastValidators(ctx sdk.Context) (validators []types.Validator
 // that expire at a certain time.
 func (k Keeper) GetValidatorQueueTimeSlice(ctx sdk.Context, timestamp time.Time) (valAddrs []sdk.ValAddress) {
 	store := ctx.KVStore(k.storeKey)
-	bz := store.Get(GetValidatorQueueTimeKey(timestamp))
+	bz := store.Get(types.GetValidatorQueueTimeKey(timestamp))
 	if bz == nil {
 		return []sdk.ValAddress{}
 	}
@@ -364,13 +364,13 @@ func (k Keeper) GetValidatorQueueTimeSlice(ctx sdk.Context, timestamp time.Time)
 func (k Keeper) SetValidatorQueueTimeSlice(ctx sdk.Context, timestamp time.Time, keys []sdk.ValAddress) {
 	store := ctx.KVStore(k.storeKey)
 	bz := k.cdc.MustMarshalBinaryLengthPrefixed(keys)
-	store.Set(GetValidatorQueueTimeKey(timestamp), bz)
+	store.Set(types.GetValidatorQueueTimeKey(timestamp), bz)
 }
 
 // Deletes a specific validator queue timeslice.
 func (k Keeper) DeleteValidatorQueueTimeSlice(ctx sdk.Context, timestamp time.Time) {
 	store := ctx.KVStore(k.storeKey)
-	store.Delete(GetValidatorQueueTimeKey(timestamp))
+	store.Delete(types.GetValidatorQueueTimeKey(timestamp))
 }
 
 // Insert an validator address to the appropriate timeslice in the validator queue
@@ -404,8 +404,8 @@ func (k Keeper) DeleteValidatorQueue(ctx sdk.Context, val types.Validator) {
 // Returns all the validator queue timeslices from time 0 until endTime
 func (k Keeper) ValidatorQueueIterator(ctx sdk.Context, endTime time.Time) sdk.Iterator {
 	store := ctx.KVStore(k.storeKey)
-	return store.Iterator(ValidatorQueueKey,
-		sdk.InclusiveEndBytes(GetValidatorQueueTimeKey(endTime)))
+	return store.Iterator(types.ValidatorQueueKey,
+		sdk.InclusiveEndBytes(types.GetValidatorQueueTimeKey(endTime)))
 }
 
 // Returns a concatenated list of all the timeslices before currTime, and deletes the timeslices from the queue

x/staking/keeper/validator_test.go

@@ -92,7 +92,7 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
 	require.Equal(t, int64(100), validator.Tokens.Int64(), "\nvalidator %v\npool %v", validator, pool)
 
 	pool = keeper.GetPool(ctx)
-	power := GetValidatorsByPowerIndexKey(validator)
+	power := types.GetValidatorsByPowerIndexKey(validator)
 	require.True(t, validatorByPowerIndexExists(keeper, ctx, power))
 
 	// burn half the delegator shares
@@ -106,7 +106,7 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
 	pool = keeper.GetPool(ctx)
 	validator, found = keeper.GetValidator(ctx, addrVals[0])
 	require.True(t, found)
-	power = GetValidatorsByPowerIndexKey(validator)
+	power = types.GetValidatorsByPowerIndexKey(validator)
 	require.True(t, validatorByPowerIndexExists(keeper, ctx, power))
 }
 

x/staking/module.go

@@ -3,10 +3,18 @@ package staking
 import (
 	"encoding/json"
 
+	flag "github.com/spf13/pflag"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/crypto"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
+	"github.com/cosmos/cosmos-sdk/x/staking/client/cli"
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
-	abci "github.com/tendermint/tendermint/abci/types"
 )
 
 var (
@@ -44,6 +52,27 @@ func (AppModuleBasic) ValidateGenesis(bz json.RawMessage) error {
 	return ValidateGenesis(data)
 }
 
+//_____________________________________
+// extra helpers
+
+// CreateValidatorMsgHelpers - used for gen-tx
+func (AppModuleBasic) CreateValidatorMsgHelpers(ipDefault string) (
+	fs *flag.FlagSet, nodeIDFlag, pubkeyFlag, amountFlag, defaultsDesc string) {
+	return cli.CreateValidatorMsgHelpers(ipDefault)
+}
+
+// PrepareFlagsForTxCreateValidator - used for gen-tx
+func (AppModuleBasic) PrepareFlagsForTxCreateValidator(config *cfg.Config, nodeID,
+	chainID string, valPubKey crypto.PubKey) {
+	cli.PrepareFlagsForTxCreateValidator(config, nodeID, chainID, valPubKey)
+}
+
+// BuildCreateValidatorMsg - used for gen-tx
+func (AppModuleBasic) BuildCreateValidatorMsg(cliCtx context.CLIContext,
+	txBldr authtxb.TxBuilder) (authtxb.TxBuilder, sdk.Msg, error) {
+	return cli.BuildCreateValidatorMsg(cliCtx, txBldr)
+}
+
 // app module
 type AppModule struct {
 	AppModuleBasic

x/staking/types/delegation_test.go

@@ -12,13 +12,13 @@ import (
 )
 
 func TestDelegationEqual(t *testing.T) {
-	d1 := NewDelegation(sdk.AccAddress(addr1), addr2, sdk.NewDec(100))
+	d1 := NewDelegation(sdk.AccAddress(valAddr1), valAddr2, sdk.NewDec(100))
 	d2 := d1
 
 	ok := d1.Equal(d2)
 	require.True(t, ok)
 
-	d2.ValidatorAddress = addr3
+	d2.ValidatorAddress = valAddr3
 	d2.Shares = sdk.NewDec(200)
 
 	ok = d1.Equal(d2)
@@ -26,19 +26,19 @@ func TestDelegationEqual(t *testing.T) {
 }
 
 func TestDelegationString(t *testing.T) {
-	d := NewDelegation(sdk.AccAddress(addr1), addr2, sdk.NewDec(100))
+	d := NewDelegation(sdk.AccAddress(valAddr1), valAddr2, sdk.NewDec(100))
 	require.NotEmpty(t, d.String())
 }
 
 func TestUnbondingDelegationEqual(t *testing.T) {
-	ubd1 := NewUnbondingDelegation(sdk.AccAddress(addr1), addr2, 0,
+	ubd1 := NewUnbondingDelegation(sdk.AccAddress(valAddr1), valAddr2, 0,
 		time.Unix(0, 0), sdk.NewInt(0))
 	ubd2 := ubd1
 
 	ok := ubd1.Equal(ubd2)
 	require.True(t, ok)
 
-	ubd2.ValidatorAddress = addr3
+	ubd2.ValidatorAddress = valAddr3
 
 	ubd2.Entries[0].CompletionTime = time.Unix(20*20*2, 0)
 	ok = ubd1.Equal(ubd2)
@@ -46,17 +46,17 @@ func TestUnbondingDelegationEqual(t *testing.T) {
 }
 
 func TestUnbondingDelegationString(t *testing.T) {
-	ubd := NewUnbondingDelegation(sdk.AccAddress(addr1), addr2, 0,
+	ubd := NewUnbondingDelegation(sdk.AccAddress(valAddr1), valAddr2, 0,
 		time.Unix(0, 0), sdk.NewInt(0))
 
 	require.NotEmpty(t, ubd.String())
 }
 
 func TestRedelegationEqual(t *testing.T) {
-	r1 := NewRedelegation(sdk.AccAddress(addr1), addr2, addr3, 0,
+	r1 := NewRedelegation(sdk.AccAddress(valAddr1), valAddr2, valAddr3, 0,
 		time.Unix(0, 0), sdk.NewInt(0),
 		sdk.NewDec(0))
-	r2 := NewRedelegation(sdk.AccAddress(addr1), addr2, addr3, 0,
+	r2 := NewRedelegation(sdk.AccAddress(valAddr1), valAddr2, valAddr3, 0,
 		time.Unix(0, 0), sdk.NewInt(0),
 		sdk.NewDec(0))
 
@@ -71,7 +71,7 @@ func TestRedelegationEqual(t *testing.T) {
 }
 
 func TestRedelegationString(t *testing.T) {
-	r := NewRedelegation(sdk.AccAddress(addr1), addr2, addr3, 0,
+	r := NewRedelegation(sdk.AccAddress(valAddr1), valAddr2, valAddr3, 0,
 		time.Unix(0, 0), sdk.NewInt(0),
 		sdk.NewDec(10))
 
@@ -80,8 +80,8 @@ func TestRedelegationString(t *testing.T) {
 
 func TestDelegationResponses(t *testing.T) {
 	cdc := codec.New()
-	dr1 := NewDelegationResp(sdk.AccAddress(addr1), addr2, sdk.NewDec(5), sdk.NewInt(5))
-	dr2 := NewDelegationResp(sdk.AccAddress(addr1), addr3, sdk.NewDec(5), sdk.NewInt(5))
+	dr1 := NewDelegationResp(sdk.AccAddress(valAddr1), valAddr2, sdk.NewDec(5), sdk.NewInt(5))
+	dr2 := NewDelegationResp(sdk.AccAddress(valAddr1), valAddr3, sdk.NewDec(5), sdk.NewInt(5))
 	drs := DelegationResponses{dr1, dr2}
 
 	bz1, err := json.Marshal(dr1)
@@ -111,8 +111,8 @@ func TestRedelegationResponses(t *testing.T) {
 		NewRedelegationEntryResponse(0, time.Unix(0, 0), sdk.NewDec(5), sdk.NewInt(5), sdk.NewInt(5)),
 		NewRedelegationEntryResponse(0, time.Unix(0, 0), sdk.NewDec(5), sdk.NewInt(5), sdk.NewInt(5)),
 	}
-	rdr1 := NewRedelegationResponse(sdk.AccAddress(addr1), addr2, addr3, entries)
-	rdr2 := NewRedelegationResponse(sdk.AccAddress(addr2), addr1, addr3, entries)
+	rdr1 := NewRedelegationResponse(sdk.AccAddress(valAddr1), valAddr2, valAddr3, entries)
+	rdr2 := NewRedelegationResponse(sdk.AccAddress(valAddr2), valAddr1, valAddr3, entries)
 	rdrs := RedelegationResponses{rdr1, rdr2}
 
 	bz1, err := json.Marshal(rdr1)

x/staking/types/key.go

@@ -1,11 +1,10 @@
-package keeper
+package types
 
 import (
 	"encoding/binary"
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 // TODO remove some of these prefixes once have working multistore
@@ -36,7 +35,7 @@ var (
 )
 
 // gets the key for the validator with address
-// VALUE: staking/types.Validator
+// VALUE: staking/Validator
 func GetValidatorKey(operatorAddr sdk.ValAddress) []byte {
 	return append(ValidatorsKey, operatorAddr.Bytes()...)
 }
@@ -56,7 +55,7 @@ func AddressFromLastValidatorPowerKey(key []byte) []byte {
 // Power index is the key used in the power-store, and represents the relative
 // power ranking of the validator.
 // VALUE: validator operator address ([]byte)
-func GetValidatorsByPowerIndexKey(validator types.Validator) []byte {
+func GetValidatorsByPowerIndexKey(validator Validator) []byte {
 	// NOTE the address doesn't need to be stored because counter bytes must always be different
 	return getValidatorPowerRank(validator)
 }
@@ -69,7 +68,7 @@ func GetLastValidatorPowerKey(operator sdk.ValAddress) []byte {
 // get the power ranking of a validator
 // NOTE the larger values are of higher value
 // nolint: unparam
-func getValidatorPowerRank(validator types.Validator) []byte {
+func getValidatorPowerRank(validator Validator) []byte {
 
 	potentialPower := validator.Tokens
 
@@ -95,7 +94,8 @@ func getValidatorPowerRank(validator types.Validator) []byte {
 	return key
 }
 
-func parseValidatorPowerRankKey(key []byte) (operAddr []byte) {
+// parse the validators operator address from power rank key
+func ParseValidatorPowerRankKey(key []byte) (operAddr []byte) {
 	powerBytesLen := 8
 	if len(key) != 1+powerBytesLen+sdk.AddrLen {
 		panic("Invalid validator power rank key length")
@@ -116,7 +116,7 @@ func GetValidatorQueueTimeKey(timestamp time.Time) []byte {
 //______________________________________________________________________________
 
 // gets the key for delegator bond with validator
-// VALUE: staking/types.Delegation
+// VALUE: staking/Delegation
 func GetDelegationKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
 	return append(GetDelegationsKey(delAddr), valAddr.Bytes()...)
 }
@@ -129,7 +129,7 @@ func GetDelegationsKey(delAddr sdk.AccAddress) []byte {
 //______________________________________________________________________________
 
 // gets the key for an unbonding delegation by delegator and validator addr
-// VALUE: staking/types.UnbondingDelegation
+// VALUE: staking/UnbondingDelegation
 func GetUBDKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
 	return append(
 		GetUBDsKey(delAddr.Bytes()),
@@ -174,7 +174,7 @@ func GetUnbondingDelegationTimeKey(timestamp time.Time) []byte {
 //________________________________________________________________________________
 
 // gets the key for a redelegation
-// VALUE: staking/types.RedelegationKey
+// VALUE: staking/RedelegationKey
 func GetREDKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) []byte {
 	key := make([]byte, 1+sdk.AddrLen*3)
 

x/staking/types/key_test.go

@@ -1,4 +1,4 @@
-package keeper
+package types
 
 import (
 	"encoding/hex"
@@ -9,22 +9,21 @@ import (
 	"github.com/tendermint/tendermint/crypto/ed25519"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 var (
-	pk1   = ed25519.GenPrivKeyFromSecret([]byte{1}).PubKey()
-	pk2   = ed25519.GenPrivKeyFromSecret([]byte{2}).PubKey()
-	pk3   = ed25519.GenPrivKeyFromSecret([]byte{3}).PubKey()
-	addr1 = pk1.Address()
-	addr2 = pk2.Address()
-	addr3 = pk3.Address()
+	keysPK1   = ed25519.GenPrivKeyFromSecret([]byte{1}).PubKey()
+	keysPK2   = ed25519.GenPrivKeyFromSecret([]byte{2}).PubKey()
+	keysPK3   = ed25519.GenPrivKeyFromSecret([]byte{3}).PubKey()
+	keysAddr1 = keysPK1.Address()
+	keysAddr2 = keysPK2.Address()
+	keysAddr3 = keysPK3.Address()
 )
 
 func TestGetValidatorPowerRank(t *testing.T) {
-	valAddr1 := sdk.ValAddress(addr1)
-	emptyDesc := types.Description{}
-	val1 := types.NewValidator(valAddr1, pk1, emptyDesc)
+	valAddr1 := sdk.ValAddress(keysAddr1)
+	emptyDesc := Description{}
+	val1 := NewValidator(valAddr1, keysPK1, emptyDesc)
 	val1.Tokens = sdk.ZeroInt()
 	val2, val3, val4 := val1, val1, val1
 	val2.Tokens = sdk.NewInt(1)
@@ -33,7 +32,7 @@ func TestGetValidatorPowerRank(t *testing.T) {
 	val4.Tokens = sdk.NewIntFromBigInt(x)
 
 	tests := []struct {
-		validator types.Validator
+		validator Validator
 		wantHex   string
 	}{
 		{val1, "2300000000000000009c288ede7df62742fc3b7d0962045a8cef0f79f6"},
@@ -55,11 +54,11 @@ func TestGetREDByValDstIndexKey(t *testing.T) {
 		valDstAddr sdk.ValAddress
 		wantHex    string
 	}{
-		{sdk.AccAddress(addr1), sdk.ValAddress(addr1), sdk.ValAddress(addr1),
+		{sdk.AccAddress(keysAddr1), sdk.ValAddress(keysAddr1), sdk.ValAddress(keysAddr1),
 			"3663d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f08609"},
-		{sdk.AccAddress(addr1), sdk.ValAddress(addr2), sdk.ValAddress(addr3),
+		{sdk.AccAddress(keysAddr1), sdk.ValAddress(keysAddr2), sdk.ValAddress(keysAddr3),
 			"363ab62f0d93849be495e21e3e9013a517038f45bd63d771218209d8bd03c482f69dfba57310f086095ef3b5f25c54946d4a89fc0d09d2f126614540f2"},
-		{sdk.AccAddress(addr2), sdk.ValAddress(addr1), sdk.ValAddress(addr3),
+		{sdk.AccAddress(keysAddr2), sdk.ValAddress(keysAddr1), sdk.ValAddress(keysAddr3),
 			"363ab62f0d93849be495e21e3e9013a517038f45bd5ef3b5f25c54946d4a89fc0d09d2f126614540f263d771218209d8bd03c482f69dfba57310f08609"},
 	}
 	for i, tt := range tests {
@@ -76,11 +75,11 @@ func TestGetREDByValSrcIndexKey(t *testing.T) {
 		valDstAddr sdk.ValAddress
 		wantHex    string
 	}{
-		{sdk.AccAddress(addr1), sdk.ValAddress(addr1), sdk.ValAddress(addr1),
+		{sdk.AccAddress(keysAddr1), sdk.ValAddress(keysAddr1), sdk.ValAddress(keysAddr1),
 			"3563d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f08609"},
-		{sdk.AccAddress(addr1), sdk.ValAddress(addr2), sdk.ValAddress(addr3),
+		{sdk.AccAddress(keysAddr1), sdk.ValAddress(keysAddr2), sdk.ValAddress(keysAddr3),
 			"355ef3b5f25c54946d4a89fc0d09d2f126614540f263d771218209d8bd03c482f69dfba57310f086093ab62f0d93849be495e21e3e9013a517038f45bd"},
-		{sdk.AccAddress(addr2), sdk.ValAddress(addr1), sdk.ValAddress(addr3),
+		{sdk.AccAddress(keysAddr2), sdk.ValAddress(keysAddr1), sdk.ValAddress(keysAddr3),
 			"3563d771218209d8bd03c482f69dfba57310f086095ef3b5f25c54946d4a89fc0d09d2f126614540f23ab62f0d93849be495e21e3e9013a517038f45bd"},
 	}
 	for i, tt := range tests {

x/staking/types/msg_test.go

@@ -28,15 +28,15 @@ func TestMsgCreateValidator(t *testing.T) {
 		bond                                      sdk.Coin
 		expectPass                                bool
 	}{
-		{"basic good", "a", "b", "c", "d", commission1, sdk.OneInt(), addr1, pk1, coinPos, true},
-		{"partial description", "", "", "c", "", commission1, sdk.OneInt(), addr1, pk1, coinPos, true},
-		{"empty description", "", "", "", "", commission2, sdk.OneInt(), addr1, pk1, coinPos, false},
+		{"basic good", "a", "b", "c", "d", commission1, sdk.OneInt(), valAddr1, pk1, coinPos, true},
+		{"partial description", "", "", "c", "", commission1, sdk.OneInt(), valAddr1, pk1, coinPos, true},
+		{"empty description", "", "", "", "", commission2, sdk.OneInt(), valAddr1, pk1, coinPos, false},
 		{"empty address", "a", "b", "c", "d", commission2, sdk.OneInt(), emptyAddr, pk1, coinPos, false},
-		{"empty pubkey", "a", "b", "c", "d", commission1, sdk.OneInt(), addr1, emptyPubkey, coinPos, true},
-		{"empty bond", "a", "b", "c", "d", commission2, sdk.OneInt(), addr1, pk1, coinZero, false},
-		{"zero min self delegation", "a", "b", "c", "d", commission1, sdk.ZeroInt(), addr1, pk1, coinPos, false},
-		{"negative min self delegation", "a", "b", "c", "d", commission1, sdk.NewInt(-1), addr1, pk1, coinPos, false},
-		{"delegation less than min self delegation", "a", "b", "c", "d", commission1, coinPos.Amount.Add(sdk.OneInt()), addr1, pk1, coinPos, false},
+		{"empty pubkey", "a", "b", "c", "d", commission1, sdk.OneInt(), valAddr1, emptyPubkey, coinPos, true},
+		{"empty bond", "a", "b", "c", "d", commission2, sdk.OneInt(), valAddr1, pk1, coinZero, false},
+		{"zero min self delegation", "a", "b", "c", "d", commission1, sdk.ZeroInt(), valAddr1, pk1, coinPos, false},
+		{"negative min self delegation", "a", "b", "c", "d", commission1, sdk.NewInt(-1), valAddr1, pk1, coinPos, false},
+		{"delegation less than min self delegation", "a", "b", "c", "d", commission1, coinPos.Amount.Add(sdk.OneInt()), valAddr1, pk1, coinPos, false},
 	}
 
 	for _, tc := range tests {
@@ -57,9 +57,9 @@ func TestMsgEditValidator(t *testing.T) {
 		validatorAddr                             sdk.ValAddress
 		expectPass                                bool
 	}{
-		{"basic good", "a", "b", "c", "d", addr1, true},
-		{"partial description", "", "", "c", "", addr1, true},
-		{"empty description", "", "", "", "", addr1, false},
+		{"basic good", "a", "b", "c", "d", valAddr1, true},
+		{"partial description", "", "", "c", "", valAddr1, true},
+		{"empty description", "", "", "", "", valAddr1, false},
 		{"empty address", "a", "b", "c", "d", emptyAddr, false},
 	}
 
@@ -86,11 +86,11 @@ func TestMsgDelegate(t *testing.T) {
 		bond          sdk.Coin
 		expectPass    bool
 	}{
-		{"basic good", sdk.AccAddress(addr1), addr2, coinPos, true},
-		{"self bond", sdk.AccAddress(addr1), addr1, coinPos, true},
-		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, coinPos, false},
-		{"empty validator", sdk.AccAddress(addr1), emptyAddr, coinPos, false},
-		{"empty bond", sdk.AccAddress(addr1), addr2, coinZero, false},
+		{"basic good", sdk.AccAddress(valAddr1), valAddr2, coinPos, true},
+		{"self bond", sdk.AccAddress(valAddr1), valAddr1, coinPos, true},
+		{"empty delegator", sdk.AccAddress(emptyAddr), valAddr1, coinPos, false},
+		{"empty validator", sdk.AccAddress(valAddr1), emptyAddr, coinPos, false},
+		{"empty bond", sdk.AccAddress(valAddr1), valAddr2, coinZero, false},
 	}
 
 	for _, tc := range tests {
@@ -113,11 +113,11 @@ func TestMsgBeginRedelegate(t *testing.T) {
 		amount           sdk.Coin
 		expectPass       bool
 	}{
-		{"regular", sdk.AccAddress(addr1), addr2, addr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), true},
-		{"zero amount", sdk.AccAddress(addr1), addr2, addr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 0), false},
-		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, addr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
-		{"empty source validator", sdk.AccAddress(addr1), emptyAddr, addr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
-		{"empty destination validator", sdk.AccAddress(addr1), addr2, emptyAddr, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
+		{"regular", sdk.AccAddress(valAddr1), valAddr2, valAddr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), true},
+		{"zero amount", sdk.AccAddress(valAddr1), valAddr2, valAddr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 0), false},
+		{"empty delegator", sdk.AccAddress(emptyAddr), valAddr1, valAddr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
+		{"empty source validator", sdk.AccAddress(valAddr1), emptyAddr, valAddr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
+		{"empty destination validator", sdk.AccAddress(valAddr1), valAddr2, emptyAddr, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
 	}
 
 	for _, tc := range tests {
@@ -139,10 +139,10 @@ func TestMsgUndelegate(t *testing.T) {
 		amount        sdk.Coin
 		expectPass    bool
 	}{
-		{"regular", sdk.AccAddress(addr1), addr2, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), true},
-		{"zero amount", sdk.AccAddress(addr1), addr2, sdk.NewInt64Coin(sdk.DefaultBondDenom, 0), false},
-		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
-		{"empty validator", sdk.AccAddress(addr1), emptyAddr, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
+		{"regular", sdk.AccAddress(valAddr1), valAddr2, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), true},
+		{"zero amount", sdk.AccAddress(valAddr1), valAddr2, sdk.NewInt64Coin(sdk.DefaultBondDenom, 0), false},
+		{"empty delegator", sdk.AccAddress(emptyAddr), valAddr1, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
+		{"empty validator", sdk.AccAddress(valAddr1), emptyAddr, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
 	}
 
 	for _, tc := range tests {

x/staking/types/test_utils.go

@@ -8,12 +8,15 @@ import (
 )
 
 var (
-	pk1   = ed25519.GenPrivKey().PubKey()
-	pk2   = ed25519.GenPrivKey().PubKey()
-	pk3   = ed25519.GenPrivKey().PubKey()
-	addr1 = sdk.ValAddress(pk1.Address())
-	addr2 = sdk.ValAddress(pk2.Address())
-	addr3 = sdk.ValAddress(pk3.Address())
+	pk1      = ed25519.GenPrivKey().PubKey()
+	pk2      = ed25519.GenPrivKey().PubKey()
+	pk3      = ed25519.GenPrivKey().PubKey()
+	addr1    = pk1.Address()
+	addr2    = pk2.Address()
+	addr3    = pk3.Address()
+	valAddr1 = sdk.ValAddress(addr1)
+	valAddr2 = sdk.ValAddress(addr2)
+	valAddr3 = sdk.ValAddress(addr3)
 
 	emptyAddr   sdk.ValAddress
 	emptyPubkey crypto.PubKey

x/staking/types/validator_test.go

@@ -12,13 +12,13 @@ import (
 )
 
 func TestValidatorTestEquivalent(t *testing.T) {
-	val1 := NewValidator(addr1, pk1, Description{})
-	val2 := NewValidator(addr1, pk1, Description{})
+	val1 := NewValidator(valAddr1, pk1, Description{})
+	val2 := NewValidator(valAddr1, pk1, Description{})
 
 	ok := val1.TestEquivalent(val2)
 	require.True(t, ok)
 
-	val2 = NewValidator(addr2, pk2, Description{})
+	val2 = NewValidator(valAddr2, pk2, Description{})
 
 	ok = val1.TestEquivalent(val2)
 	require.False(t, ok)
@@ -54,7 +54,7 @@ func TestUpdateDescription(t *testing.T) {
 }
 
 func TestABCIValidatorUpdate(t *testing.T) {
-	validator := NewValidator(addr1, pk1, Description{})
+	validator := NewValidator(valAddr1, pk1, Description{})
 
 	abciVal := validator.ABCIValidatorUpdate()
 	require.Equal(t, tmtypes.TM2PB.PubKey(validator.ConsPubKey), abciVal.PubKey)
@@ -62,7 +62,7 @@ func TestABCIValidatorUpdate(t *testing.T) {
 }
 
 func TestABCIValidatorUpdateZero(t *testing.T) {
-	validator := NewValidator(addr1, pk1, Description{})
+	validator := NewValidator(valAddr1, pk1, Description{})
 
 	abciVal := validator.ABCIValidatorUpdateZero()
 	require.Equal(t, tmtypes.TM2PB.PubKey(validator.ConsPubKey), abciVal.PubKey)
@@ -71,7 +71,7 @@ func TestABCIValidatorUpdateZero(t *testing.T) {
 
 func TestShareTokens(t *testing.T) {
 	validator := Validator{
-		OperatorAddress: addr1,
+		OperatorAddress: valAddr1,
 		ConsPubKey:      pk1,
 		Status:          sdk.Bonded,
 		Tokens:          sdk.NewInt(100),
@@ -87,7 +87,7 @@ func TestShareTokens(t *testing.T) {
 func TestRemoveTokens(t *testing.T) {
 
 	validator := Validator{
-		OperatorAddress: addr1,
+		OperatorAddress: valAddr1,
 		ConsPubKey:      pk1,
 		Status:          sdk.Bonded,
 		Tokens:          sdk.NewInt(100),
@@ -122,7 +122,7 @@ func TestRemoveTokens(t *testing.T) {
 func TestAddTokensValidatorBonded(t *testing.T) {
 	pool := InitialPool()
 	pool.NotBondedTokens = sdk.NewInt(10)
-	validator := NewValidator(addr1, pk1, Description{})
+	validator := NewValidator(valAddr1, pk1, Description{})
 	validator, pool = validator.UpdateStatus(pool, sdk.Bonded)
 	validator, pool, delShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
 
@@ -134,7 +134,7 @@ func TestAddTokensValidatorBonded(t *testing.T) {
 func TestAddTokensValidatorUnbonding(t *testing.T) {
 	pool := InitialPool()
 	pool.NotBondedTokens = sdk.NewInt(10)
-	validator := NewValidator(addr1, pk1, Description{})
+	validator := NewValidator(valAddr1, pk1, Description{})
 	validator, pool = validator.UpdateStatus(pool, sdk.Unbonding)
 	validator, pool, delShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
 
@@ -147,7 +147,7 @@ func TestAddTokensValidatorUnbonding(t *testing.T) {
 func TestAddTokensValidatorUnbonded(t *testing.T) {
 	pool := InitialPool()
 	pool.NotBondedTokens = sdk.NewInt(10)
-	validator := NewValidator(addr1, pk1, Description{})
+	validator := NewValidator(valAddr1, pk1, Description{})
 	validator, pool = validator.UpdateStatus(pool, sdk.Unbonded)
 	validator, pool, delShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
 
@@ -160,7 +160,7 @@ func TestAddTokensValidatorUnbonded(t *testing.T) {
 // TODO refactor to make simpler like the AddToken tests above
 func TestRemoveDelShares(t *testing.T) {
 	valA := Validator{
-		OperatorAddress: addr1,
+		OperatorAddress: valAddr1,
 		ConsPubKey:      pk1,
 		Status:          sdk.Bonded,
 		Tokens:          sdk.NewInt(100),
@@ -187,7 +187,7 @@ func TestRemoveDelShares(t *testing.T) {
 	poolTokens := sdk.NewInt(5102)
 	delShares := sdk.NewDec(115)
 	validator := Validator{
-		OperatorAddress: addr1,
+		OperatorAddress: valAddr1,
 		ConsPubKey:      pk1,
 		Status:          sdk.Bonded,
 		Tokens:          poolTokens,
@@ -208,7 +208,7 @@ func TestRemoveDelShares(t *testing.T) {
 }
 
 func TestAddTokensFromDel(t *testing.T) {
-	val := NewValidator(addr1, pk1, Description{})
+	val := NewValidator(valAddr1, pk1, Description{})
 	pool := InitialPool()
 	pool.NotBondedTokens = sdk.NewInt(10)
 
@@ -231,7 +231,7 @@ func TestUpdateStatus(t *testing.T) {
 	pool := InitialPool()
 	pool.NotBondedTokens = sdk.NewInt(100)
 
-	validator := NewValidator(addr1, pk1, Description{})
+	validator := NewValidator(valAddr1, pk1, Description{})
 	validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(100))
 	require.Equal(t, sdk.Unbonded, validator.Status)
 	require.Equal(t, int64(100), validator.Tokens.Int64())
@@ -255,7 +255,7 @@ func TestPossibleOverflow(t *testing.T) {
 	poolTokens := sdk.NewInt(2159)
 	delShares := sdk.NewDec(391432570689183511).Quo(sdk.NewDec(40113011844664))
 	validator := Validator{
-		OperatorAddress: addr1,
+		OperatorAddress: valAddr1,
 		ConsPubKey:      pk1,
 		Status:          sdk.Bonded,
 		Tokens:          poolTokens,
@@ -273,7 +273,7 @@ func TestPossibleOverflow(t *testing.T) {
 }
 
 func TestValidatorMarshalUnmarshalJSON(t *testing.T) {
-	validator := NewValidator(addr1, pk1, Description{})
+	validator := NewValidator(valAddr1, pk1, Description{})
 	js, err := codec.Cdc.MarshalJSON(validator)
 	require.NoError(t, err)
 	require.NotEmpty(t, js)
@@ -285,7 +285,7 @@ func TestValidatorMarshalUnmarshalJSON(t *testing.T) {
 }
 
 func TestValidatorSetInitialCommission(t *testing.T) {
-	val := NewValidator(addr1, pk1, Description{})
+	val := NewValidator(valAddr1, pk1, Description{})
 	testCases := []struct {
 		validator   Validator
 		commission  Commission