diff --git a/store/gaskvstore_test.go b/store/gaskvstore_test.go
index c664535a02..ba77bae1f8 100644
--- a/store/gaskvstore_test.go
+++ b/store/gaskvstore_test.go
@@ -13,13 +13,13 @@ import (
 func newGasKVStore() KVStore {
 	meter := sdk.NewGasMeter(1000)
 	mem := dbStoreAdapter{dbm.NewMemDB()}
-	return NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
+	return NewGasKVStore(meter, sdk.KVGasConfig(), mem)
 }
 
 func TestGasKVStoreBasic(t *testing.T) {
 	mem := dbStoreAdapter{dbm.NewMemDB()}
 	meter := sdk.NewGasMeter(1000)
-	st := NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
+	st := NewGasKVStore(meter, sdk.KVGasConfig(), mem)
 	require.Empty(t, st.Get(keyFmt(1)), "Expected `key1` to be empty")
 	st.Set(keyFmt(1), valFmt(1))
 	require.Equal(t, valFmt(1), st.Get(keyFmt(1)))
@@ -31,7 +31,7 @@ func TestGasKVStoreBasic(t *testing.T) {
 func TestGasKVStoreIterator(t *testing.T) {
 	mem := dbStoreAdapter{dbm.NewMemDB()}
 	meter := sdk.NewGasMeter(1000)
-	st := NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
+	st := NewGasKVStore(meter, sdk.KVGasConfig(), mem)
 	require.Empty(t, st.Get(keyFmt(1)), "Expected `key1` to be empty")
 	require.Empty(t, st.Get(keyFmt(2)), "Expected `key2` to be empty")
 	st.Set(keyFmt(1), valFmt(1))
@@ -55,14 +55,14 @@ func TestGasKVStoreIterator(t *testing.T) {
 func TestGasKVStoreOutOfGasSet(t *testing.T) {
 	mem := dbStoreAdapter{dbm.NewMemDB()}
 	meter := sdk.NewGasMeter(0)
-	st := NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
+	st := NewGasKVStore(meter, sdk.KVGasConfig(), mem)
 	require.Panics(t, func() { st.Set(keyFmt(1), valFmt(1)) }, "Expected out-of-gas")
 }
 
 func TestGasKVStoreOutOfGasIterator(t *testing.T) {
 	mem := dbStoreAdapter{dbm.NewMemDB()}
 	meter := sdk.NewGasMeter(200)
-	st := NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
+	st := NewGasKVStore(meter, sdk.KVGasConfig(), mem)
 	st.Set(keyFmt(1), valFmt(1))
 	iterator := st.Iterator(nil, nil)
 	iterator.Next()
diff --git a/store/prefixstore_test.go b/store/prefixstore_test.go
index 7e5675d650..d1d534a8ac 100644
--- a/store/prefixstore_test.go
+++ b/store/prefixstore_test.go
@@ -81,7 +81,7 @@ func TestCacheKVStorePrefix(t *testing.T) {
 func TestGasKVStorePrefix(t *testing.T) {
 	meter := sdk.NewGasMeter(100000000)
 	mem := dbStoreAdapter{dbm.NewMemDB()}
-	gasStore := NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
+	gasStore := NewGasKVStore(meter, sdk.KVGasConfig(), mem)
 
 	testPrefixStore(t, gasStore, []byte("test"))
 }
diff --git a/x/gov/keeper.go b/x/gov/keeper.go
index 01029bada8..39a98336c5 100644
--- a/x/gov/keeper.go
+++ b/x/gov/keeper.go
@@ -13,10 +13,10 @@ const (
 )
 
 // Parameter store key
-const (
-	ParamStoreKeyDepositProcedure  = "depositprocedure"
-	ParamStoreKeyVotingProcedure   = "votingprocedure"
-	ParamStoreKeyTallyingProcedure = "tallyingprocedure"
+var (
+	ParamStoreKeyDepositProcedure  = []byte("depositprocedure")
+	ParamStoreKeyVotingProcedure   = []byte("votingprocedure")
+	ParamStoreKeyTallyingProcedure = []byte("tallyingprocedure")
 )
 
 // Governance Keeper
diff --git a/x/gov/keeper_test.go b/x/gov/keeper_test.go
index 5dc3b84040..91c41d7d7d 100644
--- a/x/gov/keeper_test.go
+++ b/x/gov/keeper_test.go
@@ -67,8 +67,8 @@ func TestDeposits(t *testing.T) {
 	fourSteak := sdk.Coins{sdk.NewInt64Coin("steak", 4)}
 	fiveSteak := sdk.Coins{sdk.NewInt64Coin("steak", 5)}
 
-	addr0Initial := keeper.bk.GetCoins(ctx, addrs[0])
-	addr1Initial := keeper.bk.GetCoins(ctx, addrs[1])
+	addr0Initial := keeper.ck.GetCoins(ctx, addrs[0])
+	addr1Initial := keeper.ck.GetCoins(ctx, addrs[1])
 
 	// require.True(t, addr0Initial.IsEqual(sdk.Coins{sdk.NewInt64Coin("steak", 42)}))
 	require.Equal(t, sdk.Coins{sdk.NewInt64Coin("steak", 42)}, addr0Initial)
@@ -90,7 +90,7 @@ func TestDeposits(t *testing.T) {
 	require.Equal(t, fourSteak, deposit.Amount)
 	require.Equal(t, addrs[0], deposit.Depositer)
 	require.Equal(t, fourSteak, keeper.GetProposal(ctx, proposalID).GetTotalDeposit())
-	require.Equal(t, addr0Initial.Minus(fourSteak), keeper.bk.GetCoins(ctx, addrs[0]))
+	require.Equal(t, addr0Initial.Minus(fourSteak), keeper.ck.GetCoins(ctx, addrs[0]))
 
 	// Check a second deposit from same address
 	err, votingStarted = keeper.AddDeposit(ctx, proposalID, addrs[0], fiveSteak)
@@ -101,7 +101,7 @@ func TestDeposits(t *testing.T) {
 	require.Equal(t, fourSteak.Plus(fiveSteak), deposit.Amount)
 	require.Equal(t, addrs[0], deposit.Depositer)
 	require.Equal(t, fourSteak.Plus(fiveSteak), keeper.GetProposal(ctx, proposalID).GetTotalDeposit())
-	require.Equal(t, addr0Initial.Minus(fourSteak).Minus(fiveSteak), keeper.bk.GetCoins(ctx, addrs[0]))
+	require.Equal(t, addr0Initial.Minus(fourSteak).Minus(fiveSteak), keeper.ck.GetCoins(ctx, addrs[0]))
 
 	// Check third deposit from a new address
 	err, votingStarted = keeper.AddDeposit(ctx, proposalID, addrs[1], fourSteak)
@@ -112,7 +112,7 @@ func TestDeposits(t *testing.T) {
 	require.Equal(t, addrs[1], deposit.Depositer)
 	require.Equal(t, fourSteak, deposit.Amount)
 	require.Equal(t, fourSteak.Plus(fiveSteak).Plus(fourSteak), keeper.GetProposal(ctx, proposalID).GetTotalDeposit())
-	require.Equal(t, addr1Initial.Minus(fourSteak), keeper.bk.GetCoins(ctx, addrs[1]))
+	require.Equal(t, addr1Initial.Minus(fourSteak), keeper.ck.GetCoins(ctx, addrs[1]))
 
 	// Check that proposal moved to voting period
 	require.True(t, keeper.GetProposal(ctx, proposalID).GetVotingStartTime().Equal(ctx.BlockHeader().Time))
@@ -140,8 +140,8 @@ func TestDeposits(t *testing.T) {
 	keeper.RefundDeposits(ctx, proposalID)
 	deposit, found = keeper.GetDeposit(ctx, proposalID, addrs[1])
 	require.False(t, found)
-	require.Equal(t, addr0Initial, keeper.bk.GetCoins(ctx, addrs[0]))
-	require.Equal(t, addr1Initial, keeper.bk.GetCoins(ctx, addrs[1]))
+	require.Equal(t, addr0Initial, keeper.ck.GetCoins(ctx, addrs[0]))
+	require.Equal(t, addr1Initial, keeper.ck.GetCoins(ctx, addrs[1]))
 
 }
 
diff --git a/x/params/client/utils/utils.go b/x/params/client/utils/utils.go
deleted file mode 100644
index d2c2040e68..0000000000
--- a/x/params/client/utils/utils.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package utils
-
-import (
-	"github.com/cosmos/cosmos-sdk/client/context"
-	"github.com/cosmos/cosmos-sdk/x/params"
-)
-
-// TODO: remove hardcoded storename
-const storeName = "params"
-
-// Query parameters from node with CLIContext
-func QueryParams(cliCtx context.CLIContext, subStoreName string, ps params.ParamStruct) error {
-	m := make(map[string][]byte)
-
-	for _, p := range ps.KeyFieldPairs() {
-		key := p.Key
-		bz, err := cliCtx.QueryStore([]byte(subStoreName+"/"+key), storeName)
-		if err != nil {
-			return err
-		}
-		m[key] = bz
-	}
-
-	return params.UnmarshalParamsFromMap(m, cliCtx.Codec, ps)
-}
diff --git a/x/params/keeper_test.go b/x/params/keeper_test.go
index 2de4b9010c..aecdc60313 100644
--- a/x/params/keeper_test.go
+++ b/x/params/keeper_test.go
@@ -59,19 +59,19 @@ func TestKeeper(t *testing.T) {
 	store := NewKeeper(codec.New(), skey, tkey).Substore("test")
 
 	for i, kv := range kvs {
-		require.NotPanics(t, func() { store.Set(ctx, kv.key, kv.param) }, "store.Set panics, tc #%d", i)
+		require.NotPanics(t, func() { store.Set(ctx, []byte(kv.key), kv.param) }, "store.Set panics, tc #%d", i)
 	}
 
 	for i, kv := range kvs {
 		var param int64
-		require.NotPanics(t, func() { store.Get(ctx, kv.key, &param) }, "store.Get panics, tc #%d", i)
+		require.NotPanics(t, func() { store.Get(ctx, []byte(kv.key), &param) }, "store.Get panics, tc #%d", i)
 		require.Equal(t, kv.param, param, "stored param not equal, tc #%d", i)
 	}
 
 	cdc := codec.New()
 	for i, kv := range kvs {
 		var param int64
-		bz := store.GetRaw(ctx, kv.key)
+		bz := store.GetRaw(ctx, []byte(kv.key))
 		err := cdc.UnmarshalJSON(bz, &param)
 		require.Nil(t, err, "err is not nil, tc #%d", i)
 		require.Equal(t, kv.param, param, "stored param not equal, tc #%d", i)
@@ -79,11 +79,11 @@ func TestKeeper(t *testing.T) {
 
 	for i, kv := range kvs {
 		var param bool
-		require.Panics(t, func() { store.Get(ctx, kv.key, &param) }, "invalid store.Get not panics, tc #%d", i)
+		require.Panics(t, func() { store.Get(ctx, []byte(kv.key), &param) }, "invalid store.Get not panics, tc #%d", i)
 	}
 
 	for i, kv := range kvs {
-		require.Panics(t, func() { store.Set(ctx, kv.key, true) }, "invalid store.Set not panics, tc #%d", i)
+		require.Panics(t, func() { store.Set(ctx, []byte(kv.key), true) }, "invalid store.Set not panics, tc #%d", i)
 	}
 }
 
@@ -116,26 +116,26 @@ func TestGet(t *testing.T) {
 	}
 
 	for i, kv := range kvs {
-		require.False(t, store.Modified(ctx, kv.key), "store.Modified returns true before setting, tc #%d", i)
-		require.NotPanics(t, func() { store.Set(ctx, kv.key, kv.param) }, "store.Set panics, tc #%d", i)
-		require.True(t, store.Modified(ctx, kv.key), "store.Modified returns false after setting, tc #%d", i)
+		require.False(t, store.Modified(ctx, []byte(kv.key)), "store.Modified returns true before setting, tc #%d", i)
+		require.NotPanics(t, func() { store.Set(ctx, []byte(kv.key), kv.param) }, "store.Set panics, tc #%d", i)
+		require.True(t, store.Modified(ctx, []byte(kv.key)), "store.Modified returns false after setting, tc #%d", i)
 	}
 
 	for i, kv := range kvs {
-		require.NotPanics(t, func() { store.GetIfExists(ctx, "invalid", kv.ptr) }, "store.GetIfExists panics when no value exists, tc #%d", i)
+		require.NotPanics(t, func() { store.GetIfExists(ctx, []byte("invalid"), kv.ptr) }, "store.GetIfExists panics when no value exists, tc #%d", i)
 		require.Equal(t, kv.zero, reflect.ValueOf(kv.ptr).Elem().Interface(), "store.GetIfExists unmarshalls when no value exists, tc #%d", i)
-		require.Panics(t, func() { store.Get(ctx, "invalid", kv.ptr) }, "invalid store.Get not panics when no value exists, tc #%d", i)
+		require.Panics(t, func() { store.Get(ctx, []byte("invalid"), kv.ptr) }, "invalid store.Get not panics when no value exists, tc #%d", i)
 		require.Equal(t, kv.zero, reflect.ValueOf(kv.ptr).Elem().Interface(), "invalid store.Get unmarshalls when no value exists, tc #%d", i)
 
-		require.NotPanics(t, func() { store.GetIfExists(ctx, kv.key, kv.ptr) }, "store.GetIfExists panics, tc #%d", i)
+		require.NotPanics(t, func() { store.GetIfExists(ctx, []byte(kv.key), kv.ptr) }, "store.GetIfExists panics, tc #%d", i)
 		require.Equal(t, kv.param, reflect.ValueOf(kv.ptr).Elem().Interface(), "stored param not equal, tc #%d", i)
-		require.NotPanics(t, func() { store.Get(ctx, kv.key, kv.ptr) }, "store.Get panics, tc #%d", i)
+		require.NotPanics(t, func() { store.Get(ctx, []byte(kv.key), kv.ptr) }, "store.Get panics, tc #%d", i)
 		require.Equal(t, kv.param, reflect.ValueOf(kv.ptr).Elem().Interface(), "stored param not equal, tc #%d", i)
 
-		require.Panics(t, func() { store.Get(ctx, "invalid", kv.ptr) }, "invalid store.Get not panics when no value exists, tc #%d", i)
+		require.Panics(t, func() { store.Get(ctx, []byte("invalid"), kv.ptr) }, "invalid store.Get not panics when no value exists, tc #%d", i)
 		require.Equal(t, kv.param, reflect.ValueOf(kv.ptr).Elem().Interface(), "invalid store.Get unmarshalls when no value existt, tc #%d", i)
 
-		require.Panics(t, func() { store.Get(ctx, kv.key, nil) }, "invalid store.Get not panics when the pointer is nil, tc #%d", i)
-		require.Panics(t, func() { store.Get(ctx, kv.key, new(invalid)) }, "invalid store.Get not panics when the pointer is different type, tc #%d", i)
+		require.Panics(t, func() { store.Get(ctx, []byte(kv.key), nil) }, "invalid store.Get not panics when the pointer is nil, tc #%d", i)
+		require.Panics(t, func() { store.Get(ctx, []byte(kv.key), new(invalid)) }, "invalid store.Get not panics when the pointer is different type, tc #%d", i)
 	}
 }
diff --git a/x/params/store/pair.go b/x/params/store/pair.go
index 97e56d2a74..05350a5e8d 100644
--- a/x/params/store/pair.go
+++ b/x/params/store/pair.go
@@ -6,7 +6,7 @@ import (
 
 // Used for associating paramstore key and field of param structs
 type KeyFieldPair struct {
-	Key   string
+	Key   []byte
 	Field interface{}
 }
 
@@ -22,7 +22,7 @@ type ParamStruct interface {
 // unmarshalles it to ParamStruct
 func UnmarshalParamsFromMap(m map[string][]byte, cdc *codec.Codec, ps ParamStruct) error {
 	for _, p := range ps.KeyFieldPairs() {
-		err := cdc.UnmarshalJSON(m[p.Key], p.Field)
+		err := cdc.UnmarshalJSON(m[string(p.Key)], p.Field)
 		if err != nil {
 			return err
 		}
diff --git a/x/params/store/store.go b/x/params/store/store.go
index 04530a88ae..7fbc640a0c 100644
--- a/x/params/store/store.go
+++ b/x/params/store/store.go
@@ -41,9 +41,9 @@ func (s Store) transientStore(ctx sdk.Context) sdk.KVStore {
 }
 
 // Get parameter from store
-func (s Store) Get(ctx sdk.Context, key string, ptr interface{}) {
+func (s Store) Get(ctx sdk.Context, key []byte, ptr interface{}) {
 	store := s.kvStore(ctx)
-	bz := store.Get([]byte(key))
+	bz := store.Get(key)
 	err := s.cdc.UnmarshalJSON(bz, ptr)
 	if err != nil {
 		panic(err)
@@ -51,9 +51,9 @@ func (s Store) Get(ctx sdk.Context, key string, ptr interface{}) {
 }
 
 // GetIfExists do not modify ptr if the stored parameter is nil
-func (s Store) GetIfExists(ctx sdk.Context, key string, ptr interface{}) {
+func (s Store) GetIfExists(ctx sdk.Context, key []byte, ptr interface{}) {
 	store := s.kvStore(ctx)
-	bz := store.Get([]byte(key))
+	bz := store.Get(key)
 	if bz == nil {
 		return
 	}
@@ -64,31 +64,30 @@ func (s Store) GetIfExists(ctx sdk.Context, key string, ptr interface{}) {
 }
 
 // Get raw bytes of parameter from store
-func (s Store) GetRaw(ctx sdk.Context, key string) []byte {
+func (s Store) GetRaw(ctx sdk.Context, key []byte) []byte {
 	store := s.kvStore(ctx)
-	res := store.Get([]byte(key))
+	res := store.Get(key)
 	return res
 }
 
 // Check if the parameter is set in the store
-func (s Store) Has(ctx sdk.Context, key string) bool {
+func (s Store) Has(ctx sdk.Context, key []byte) bool {
 	store := s.kvStore(ctx)
-	return store.Has([]byte(key))
+	return store.Has(key)
 }
 
 // Returns true if the parameter is set in the block
-func (s Store) Modified(ctx sdk.Context, key string) bool {
+func (s Store) Modified(ctx sdk.Context, key []byte) bool {
 	tstore := s.transientStore(ctx)
-	return tstore.Has([]byte(key))
+	return tstore.Has(key)
 }
 
 // Set parameter, return error if stored parameter has different type from input
 // Also set to the transient store to record change
-func (s Store) Set(ctx sdk.Context, key string, param interface{}) {
+func (s Store) Set(ctx sdk.Context, key []byte, param interface{}) {
 	store := s.kvStore(ctx)
-	keybz := []byte(key)
 
-	bz := store.Get(keybz)
+	bz := store.Get(key)
 
 	// To prevent invalid parameter set, we check the type of the stored parameter
 	// and try to match it with the provided parameter. It continues only if they matches.
@@ -106,22 +105,20 @@ func (s Store) Set(ctx sdk.Context, key string, param interface{}) {
 	if err != nil {
 		panic(err)
 	}
-	store.Set(keybz, bz)
+	store.Set(key, bz)
 
 	tstore := s.transientStore(ctx)
-	tstore.Set(keybz, []byte{})
+	tstore.Set(key, []byte{})
 }
 
 // Set raw bytes of parameter
 // Also set to the transient store to record change
-func (s Store) SetRaw(ctx sdk.Context, key string, param []byte) {
-	keybz := []byte(key)
-
+func (s Store) SetRaw(ctx sdk.Context, key []byte, param []byte) {
 	store := s.kvStore(ctx)
-	store.Set(keybz, param)
+	store.Set(key, param)
 
 	tstore := s.transientStore(ctx)
-	tstore.Set(keybz, []byte{})
+	tstore.Set(key, []byte{})
 }
 
 // Get to ParamStruct
@@ -154,22 +151,22 @@ type ReadOnlyStore struct {
 }
 
 // Exposes Get
-func (ros ReadOnlyStore) Get(ctx sdk.Context, key string, ptr interface{}) {
+func (ros ReadOnlyStore) Get(ctx sdk.Context, key []byte, ptr interface{}) {
 	ros.s.Get(ctx, key, ptr)
 }
 
 // Exposes GetRaw
-func (ros ReadOnlyStore) GetRaw(ctx sdk.Context, key string) []byte {
+func (ros ReadOnlyStore) GetRaw(ctx sdk.Context, key []byte) []byte {
 	return ros.s.GetRaw(ctx, key)
 }
 
 // Exposes Has
-func (ros ReadOnlyStore) Has(ctx sdk.Context, key string) bool {
+func (ros ReadOnlyStore) Has(ctx sdk.Context, key []byte) bool {
 	return ros.s.Has(ctx, key)
 }
 
 // Exposes Modified
-func (ros ReadOnlyStore) Modified(ctx sdk.Context, key string) bool {
+func (ros ReadOnlyStore) Modified(ctx sdk.Context, key []byte) bool {
 	return ros.s.Modified(ctx, key)
 }
 
diff --git a/x/slashing/params.go b/x/slashing/params.go
index dfc5237625..11f9406ca5 100644
--- a/x/slashing/params.go
+++ b/x/slashing/params.go
@@ -13,14 +13,14 @@ const (
 )
 
 // Parameter store key
-const (
-	KeyMaxEvidenceAge           = "MaxEvidenceAge"
-	KeySignedBlocksWindow       = "SignedBlocksWindow"
-	KeyMinSignedPerWindow       = "MinSignedPerWindow"
-	KeyDoubleSignUnbondDuration = "DoubleSignUnbondDuration"
-	KeyDowntimeUnbondDuration   = "DowntimeUnbondDuration"
-	KeySlashFractionDoubleSign  = "SlashFractionDoubleSign"
-	KeySlashFractionDowntime    = "SlashFractionDowntime"
+var (
+	KeyMaxEvidenceAge           = []byte("MaxEvidenceAge")
+	KeySignedBlocksWindow       = []byte("SignedBlocksWindow")
+	KeyMinSignedPerWindow       = []byte("MinSignedPerWindow")
+	KeyDoubleSignUnbondDuration = []byte("DoubleSignUnbondDuration")
+	KeyDowntimeUnbondDuration   = []byte("DowntimeUnbondDuration")
+	KeySlashFractionDoubleSign  = []byte("SlashFractionDoubleSign")
+	KeySlashFractionDowntime    = []byte("SlashFractionDowntime")
 )
 
 // Params - used for initializing default parameter for slashing at genesis
diff --git a/x/stake/client/cli/query.go b/x/stake/client/cli/query.go
index 0268472061..ad8030c931 100644
--- a/x/stake/client/cli/query.go
+++ b/x/stake/client/cli/query.go
@@ -10,7 +10,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	paramutils "github.com/cosmos/cosmos-sdk/x/params/client/utils"
 	"github.com/cosmos/cosmos-sdk/x/stake"
 	"github.com/cosmos/cosmos-sdk/x/stake/types"
 )
@@ -466,9 +465,13 @@ func GetCmdQueryParams(storeName string, cdc *codec.Codec) *cobra.Command {
 		Args:  cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			cliCtx := context.NewCLIContext().WithCodec(cdc)
+			bz, err := cliCtx.QueryWithData("custom/stake/"+stake.QueryParameters, nil)
+			if err != nil {
+				return err
+			}
 
-			var params types.Params
-			err := paramutils.QueryParams(cliCtx, storeName, &params)
+			var params stake.Params
+			err = cdc.UnmarshalJSON(bz, &params)
 			if err != nil {
 				return err
 			}
diff --git a/x/stake/stake.go b/x/stake/stake.go
index c518ad4d29..c7fb5afe32 100644
--- a/x/stake/stake.go
+++ b/x/stake/stake.go
@@ -90,6 +90,18 @@ var (
 	NewQuerier = querier.NewQuerier
 )
 
+const (
+	QueryValidators          = querier.QueryValidators
+	QueryValidator           = querier.QueryValidator
+	QueryDelegator           = querier.QueryDelegator
+	QueryDelegation          = querier.QueryDelegation
+	QueryUnbondingDelegation = querier.QueryUnbondingDelegation
+	QueryDelegatorValidators = querier.QueryDelegatorValidators
+	QueryDelegatorValidator  = querier.QueryDelegatorValidator
+	QueryPool                = querier.QueryPool
+	QueryParameters          = querier.QueryParameters
+)
+
 const (
 	DefaultCodespace      = types.DefaultCodespace
 	CodeInvalidValidator  = types.CodeInvalidValidator
diff --git a/x/stake/types/params.go b/x/stake/types/params.go
index c1a062df82..ccf7272f8c 100644
--- a/x/stake/types/params.go
+++ b/x/stake/types/params.go
@@ -15,14 +15,14 @@ import (
 const defaultUnbondingTime time.Duration = 60 * 60 * 24 * 3 * time.Second
 
 // nolint - Keys for parameter access
-const (
-	KeyInflationRateChange = "InflationRateChange"
-	KeyInflationMax        = "InflationMax"
-	KeyInflationMin        = "InflationMin"
-	KeyGoalBonded          = "GoalBonded"
-	KeyUnbondingTime       = "UnbondingTime"
-	KeyMaxValidators       = "MaxValidators"
-	KeyBondDenom           = "BondDenom"
+var (
+	KeyInflationRateChange = []byte("InflationRateChange")
+	KeyInflationMax        = []byte("InflationMax")
+	KeyInflationMin        = []byte("InflationMin")
+	KeyGoalBonded          = []byte("GoalBonded")
+	KeyUnbondingTime       = []byte("UnbondingTime")
+	KeyMaxValidators       = []byte("MaxValidators")
+	KeyBondDenom           = []byte("BondDenom")
 )
 
 // Params defines the high level settings for staking