From 9dc1c5e9b0ea07ad8e4c48eea55db163d18efcd2 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 14 Aug 2018 15:54:49 -0400
Subject: [PATCH 01/34] Add new account bech32 prefixes with godocs

---
 types/account.go | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/types/account.go b/types/account.go
index 92e2988f2470..51e6da2f02f0 100644
--- a/types/account.go
+++ b/types/account.go
@@ -12,16 +12,22 @@ import (
 	"github.com/tendermint/tendermint/libs/bech32"
 )
 
-// Bech32 prefixes
 const (
-	// expected address length
+	// AddrLen is the expected address length
 	AddrLen = 20
 
-	// Bech32 prefixes
+	// Bech32PrefixAccAddr defines the bech32 prefix of an account's address
 	Bech32PrefixAccAddr = "cosmosaccaddr"
-	Bech32PrefixAccPub  = "cosmosaccpub"
+	// Bech32PrefixAccPub defines the bech32 prefix of an account's public key
+	Bech32PrefixAccPub = "cosmosaccpub"
+	// Bech32PrefixValAddr defines the bech32 prefix of a validator's operator address
 	Bech32PrefixValAddr = "cosmosvaladdr"
-	Bech32PrefixValPub  = "cosmosvalpub"
+	// Bech32PrefixValPub defines the bech32 prefix of a validator's operator public key
+	Bech32PrefixValPub = "cosmosvalpub"
+	// Bech32PrefixTmAddr defines the bech32 prefix of a Tendermint node's address
+	Bech32PrefixTmAddr = "cosmostmaddr"
+	// Bech32PrefixTmPub defines the bech32 prefix of a Tendermint node's public key
+	Bech32PrefixTmPub = "cosmostmpub"
 )
 
 //__________________________________________________________

From 397a3aee055d0fae17801b9514741a9706506fdf Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 14 Aug 2018 16:01:41 -0400
Subject: [PATCH 02/34] Restructure spacing of existing account code

---
 types/account.go | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/types/account.go b/types/account.go
index 51e6da2f02f0..e90d30765585 100644
--- a/types/account.go
+++ b/types/account.go
@@ -30,7 +30,9 @@ const (
 	Bech32PrefixTmPub = "cosmostmpub"
 )
 
-//__________________________________________________________
+// ----------------------------------------------------------------------------
+// account
+// ----------------------------------------------------------------------------
 
 // AccAddress a wrapper around bytes meant to represent an account address
 // When marshaled to a string or json, it uses bech32
@@ -41,10 +43,12 @@ func AccAddressFromHex(address string) (addr AccAddress, err error) {
 	if len(address) == 0 {
 		return addr, errors.New("decoding bech32 address failed: must provide an address")
 	}
+
 	bz, err := hex.DecodeString(address)
 	if err != nil {
 		return nil, err
 	}
+
 	return AccAddress(bz), nil
 }
 
@@ -54,6 +58,7 @@ func AccAddressFromBech32(address string) (addr AccAddress, err error) {
 	if err != nil {
 		return nil, err
 	}
+
 	return AccAddress(bz), nil
 }
 
@@ -85,6 +90,7 @@ func (bz *AccAddress) UnmarshalJSON(data []byte) error {
 	if err != nil {
 		return err
 	}
+
 	*bz = bz2
 	return nil
 }
@@ -99,6 +105,7 @@ func (bz AccAddress) String() string {
 	if err != nil {
 		panic(err)
 	}
+
 	return bech32Addr
 }
 
@@ -114,7 +121,9 @@ func (bz AccAddress) Format(s fmt.State, verb rune) {
 	}
 }
 
-//__________________________________________________________
+// ----------------------------------------------------------------------------
+// validator owner
+// ----------------------------------------------------------------------------
 
 // AccAddress a wrapper around bytes meant to represent a validator address
 // (from over ABCI).  When marshaled to a string or json, it uses bech32
@@ -125,10 +134,12 @@ func ValAddressFromHex(address string) (addr ValAddress, err error) {
 	if len(address) == 0 {
 		return addr, errors.New("decoding bech32 address failed: must provide an address")
 	}
+
 	bz, err := hex.DecodeString(address)
 	if err != nil {
 		return nil, err
 	}
+
 	return ValAddress(bz), nil
 }
 
@@ -138,6 +149,7 @@ func ValAddressFromBech32(address string) (addr ValAddress, err error) {
 	if err != nil {
 		return nil, err
 	}
+
 	return ValAddress(bz), nil
 }
 
@@ -160,6 +172,7 @@ func (bz ValAddress) MarshalJSON() ([]byte, error) {
 // Unmarshals from JSON assuming Bech32 encoding
 func (bz *ValAddress) UnmarshalJSON(data []byte) error {
 	var s string
+
 	err := json.Unmarshal(data, &s)
 	if err != nil {
 		return nil
@@ -169,6 +182,7 @@ func (bz *ValAddress) UnmarshalJSON(data []byte) error {
 	if err != nil {
 		return err
 	}
+
 	*bz = bz2
 	return nil
 }
@@ -183,6 +197,7 @@ func (bz ValAddress) String() string {
 	if err != nil {
 		panic(err)
 	}
+
 	return bech32Addr
 }
 
@@ -198,6 +213,10 @@ func (bz ValAddress) Format(s fmt.State, verb rune) {
 	}
 }
 
+// ----------------------------------------------------------------------------
+// auxiliary
+// ----------------------------------------------------------------------------
+
 // Bech32ifyAccPub takes AccountPubKey and returns the bech32 encoded string
 func Bech32ifyAccPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixAccPub, pub.Bytes())
@@ -209,6 +228,7 @@ func MustBech32ifyAccPub(pub crypto.PubKey) string {
 	if err != nil {
 		panic(err)
 	}
+
 	return enc
 }
 
@@ -223,6 +243,7 @@ func MustBech32ifyValPub(pub crypto.PubKey) string {
 	if err != nil {
 		panic(err)
 	}
+
 	return enc
 }
 
@@ -247,6 +268,7 @@ func MustGetAccPubKeyBech32(address string) (pk crypto.PubKey) {
 	if err != nil {
 		panic(err)
 	}
+
 	return pk
 }
 
@@ -271,6 +293,7 @@ func MustGetValPubKeyBech32(address string) (pk crypto.PubKey) {
 	if err != nil {
 		panic(err)
 	}
+
 	return pk
 }
 
@@ -279,6 +302,7 @@ func GetFromBech32(bech32str, prefix string) ([]byte, error) {
 	if len(bech32str) == 0 {
 		return nil, errors.New("decoding bech32 address failed: must provide an address")
 	}
+
 	hrp, bz, err := bech32.DecodeAndConvert(bech32str)
 	if err != nil {
 		return nil, err

From 1a06ce4014a103ce9342d8e6c0a69cef9ff2fc63 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 14 Aug 2018 16:12:42 -0400
Subject: [PATCH 03/34] Update account godocs

---
 types/account.go | 55 ++++++++++++++++++++++++++----------------------
 1 file changed, 30 insertions(+), 25 deletions(-)

diff --git a/types/account.go b/types/account.go
index e90d30765585..da306397e0c2 100644
--- a/types/account.go
+++ b/types/account.go
@@ -38,7 +38,7 @@ const (
 // When marshaled to a string or json, it uses bech32
 type AccAddress []byte
 
-// create an AccAddress from a hex string
+// AccAddressFromHex createS an AccAddress from a hex string.
 func AccAddressFromHex(address string) (addr AccAddress, err error) {
 	if len(address) == 0 {
 		return addr, errors.New("decoding bech32 address failed: must provide an address")
@@ -52,7 +52,7 @@ func AccAddressFromHex(address string) (addr AccAddress, err error) {
 	return AccAddress(bz), nil
 }
 
-// create an AccAddress from a bech32 string
+// AccAddressFromBech32 createS an AccAddress from a bech32 string.
 func AccAddressFromBech32(address string) (addr AccAddress, err error) {
 	bz, err := GetFromBech32(address, Bech32PrefixAccAddr)
 	if err != nil {
@@ -62,23 +62,23 @@ func AccAddressFromBech32(address string) (addr AccAddress, err error) {
 	return AccAddress(bz), nil
 }
 
-// Marshal needed for protobuf compatibility
+// Marshal needed for protobuf compatibility.
 func (bz AccAddress) Marshal() ([]byte, error) {
 	return bz, nil
 }
 
-// Unmarshal needed for protobuf compatibility
+// Unmarshal needed for protobuf compatibility.
 func (bz *AccAddress) Unmarshal(data []byte) error {
 	*bz = data
 	return nil
 }
 
-// Marshals to JSON using Bech32
+// MarshalJSON marshals to JSON using Bech32.
 func (bz AccAddress) MarshalJSON() ([]byte, error) {
 	return json.Marshal(bz.String())
 }
 
-// Unmarshals from JSON assuming Bech32 encoding
+// UnmarshalJSON unmarshals from JSON assuming Bech32 encoding.
 func (bz *AccAddress) UnmarshalJSON(data []byte) error {
 	var s string
 	err := json.Unmarshal(data, &s)
@@ -95,11 +95,12 @@ func (bz *AccAddress) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// Allow it to fulfill various interfaces in light-client, etc...
+// Bytes returns the raw bytes.
 func (bz AccAddress) Bytes() []byte {
 	return bz
 }
 
+// String implements the Stringer interface.
 func (bz AccAddress) String() string {
 	bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixAccAddr, bz.Bytes())
 	if err != nil {
@@ -109,7 +110,7 @@ func (bz AccAddress) String() string {
 	return bech32Addr
 }
 
-// For Printf / Sprintf, returns bech32 when using %s
+// Format implements the fmt.Formatter interface.
 func (bz AccAddress) Format(s fmt.State, verb rune) {
 	switch verb {
 	case 's':
@@ -129,7 +130,7 @@ func (bz AccAddress) Format(s fmt.State, verb rune) {
 // (from over ABCI).  When marshaled to a string or json, it uses bech32
 type ValAddress []byte
 
-// create a ValAddress from a hex string
+// ValAddressFromHex creates a ValAddress from a hex string.
 func ValAddressFromHex(address string) (addr ValAddress, err error) {
 	if len(address) == 0 {
 		return addr, errors.New("decoding bech32 address failed: must provide an address")
@@ -143,7 +144,7 @@ func ValAddressFromHex(address string) (addr ValAddress, err error) {
 	return ValAddress(bz), nil
 }
 
-// create a ValAddress from a bech32 string
+// ValAddressFromBech32 creates a ValAddress from a bech32 string.
 func ValAddressFromBech32(address string) (addr ValAddress, err error) {
 	bz, err := GetFromBech32(address, Bech32PrefixValAddr)
 	if err != nil {
@@ -153,23 +154,23 @@ func ValAddressFromBech32(address string) (addr ValAddress, err error) {
 	return ValAddress(bz), nil
 }
 
-// Marshal needed for protobuf compatibility
+// Marshal needed for protobuf compatibility.
 func (bz ValAddress) Marshal() ([]byte, error) {
 	return bz, nil
 }
 
-// Unmarshal needed for protobuf compatibility
+// Unmarshal needed for protobuf compatibility.
 func (bz *ValAddress) Unmarshal(data []byte) error {
 	*bz = data
 	return nil
 }
 
-// Marshals to JSON using Bech32
+// MarshalJSON marshals to JSON using Bech32.
 func (bz ValAddress) MarshalJSON() ([]byte, error) {
 	return json.Marshal(bz.String())
 }
 
-// Unmarshals from JSON assuming Bech32 encoding
+// UnmarshalJSON unmarshals from JSON assuming Bech32 encoding.
 func (bz *ValAddress) UnmarshalJSON(data []byte) error {
 	var s string
 
@@ -187,11 +188,12 @@ func (bz *ValAddress) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// Allow it to fulfill various interfaces in light-client, etc...
+// Bytes returns the raw bytes.
 func (bz ValAddress) Bytes() []byte {
 	return bz
 }
 
+// String implements the Stringer interface.
 func (bz ValAddress) String() string {
 	bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixValAddr, bz.Bytes())
 	if err != nil {
@@ -201,7 +203,7 @@ func (bz ValAddress) String() string {
 	return bech32Addr
 }
 
-// For Printf / Sprintf, returns bech32 when using %s
+// Format implements the fmt.Formatter interface.
 func (bz ValAddress) Format(s fmt.State, verb rune) {
 	switch verb {
 	case 's':
@@ -217,12 +219,12 @@ func (bz ValAddress) Format(s fmt.State, verb rune) {
 // auxiliary
 // ----------------------------------------------------------------------------
 
-// Bech32ifyAccPub takes AccountPubKey and returns the bech32 encoded string
+// Bech32ifyAccPub takes AccountPubKey and returns the bech32 encoded string.
 func Bech32ifyAccPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixAccPub, pub.Bytes())
 }
 
-// MustBech32ifyAccPub panics on bech32-encoding failure
+// MustBech32ifyAccPub panics on bech32-encoding failure.
 func MustBech32ifyAccPub(pub crypto.PubKey) string {
 	enc, err := Bech32ifyAccPub(pub)
 	if err != nil {
@@ -232,12 +234,13 @@ func MustBech32ifyAccPub(pub crypto.PubKey) string {
 	return enc
 }
 
-// Bech32ifyValPub returns the bech32 encoded string for a validator pubkey
+// Bech32ifyValPub returns the bech32 encoded string for a validator's
+// crypto.PubKey.
 func Bech32ifyValPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixValPub, pub.Bytes())
 }
 
-// MustBech32ifyValPub panics on bech32-encoding failure
+// MustBech32ifyValPub panics on bech32-encoding failure.
 func MustBech32ifyValPub(pub crypto.PubKey) string {
 	enc, err := Bech32ifyValPub(pub)
 	if err != nil {
@@ -247,7 +250,7 @@ func MustBech32ifyValPub(pub crypto.PubKey) string {
 	return enc
 }
 
-// create a Pubkey from a string
+// GetAccPubKeyBech32 creates a crypto.PubKey from a string.
 func GetAccPubKeyBech32(address string) (pk crypto.PubKey, err error) {
 	bz, err := GetFromBech32(address, Bech32PrefixAccPub)
 	if err != nil {
@@ -262,7 +265,8 @@ func GetAccPubKeyBech32(address string) (pk crypto.PubKey, err error) {
 	return pk, nil
 }
 
-// create an Pubkey from a string, panics on error
+// MustGetAccPubKeyBech32 creates a crypto.PubKey from a string. It panics on
+// error.
 func MustGetAccPubKeyBech32(address string) (pk crypto.PubKey) {
 	pk, err := GetAccPubKeyBech32(address)
 	if err != nil {
@@ -272,7 +276,7 @@ func MustGetAccPubKeyBech32(address string) (pk crypto.PubKey) {
 	return pk
 }
 
-// decode a validator public key into a PubKey
+// GetValPubKeyBech32 decodes a validator public key into a crypto.PubKey.
 func GetValPubKeyBech32(pubkey string) (pk crypto.PubKey, err error) {
 	bz, err := GetFromBech32(pubkey, Bech32PrefixValPub)
 	if err != nil {
@@ -287,7 +291,8 @@ func GetValPubKeyBech32(pubkey string) (pk crypto.PubKey, err error) {
 	return pk, nil
 }
 
-// create an Pubkey from a string, panics on error
+// MustGetValPubKeyBech32 creates a crypto.PubKey from a string. It panics on
+// error.
 func MustGetValPubKeyBech32(address string) (pk crypto.PubKey) {
 	pk, err := GetValPubKeyBech32(address)
 	if err != nil {
@@ -297,7 +302,7 @@ func MustGetValPubKeyBech32(address string) (pk crypto.PubKey) {
 	return pk
 }
 
-// decode a bytestring from a bech32-encoded string
+// GetFromBech32 decodes a bytestring from a bech32-encoded string.
 func GetFromBech32(bech32str, prefix string) ([]byte, error) {
 	if len(bech32str) == 0 {
 		return nil, errors.New("decoding bech32 address failed: must provide an address")

From fce04b508d0a91449e146d4e4b23733ea5bf9808 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 14 Aug 2018 16:21:43 -0400
Subject: [PATCH 04/34] More account godoc updates + new tm pub/addr helpers

---
 types/account.go | 37 +++++++++++++++++++++++++------------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/types/account.go b/types/account.go
index da306397e0c2..38b66ae77550 100644
--- a/types/account.go
+++ b/types/account.go
@@ -219,12 +219,12 @@ func (bz ValAddress) Format(s fmt.State, verb rune) {
 // auxiliary
 // ----------------------------------------------------------------------------
 
-// Bech32ifyAccPub takes AccountPubKey and returns the bech32 encoded string.
+// Bech32ifyAccPub returns a bech32 encoded string for a given account PubKey.
 func Bech32ifyAccPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixAccPub, pub.Bytes())
 }
 
-// MustBech32ifyAccPub panics on bech32-encoding failure.
+// MustBech32ifyAccPub returns the result of Bech32ifyAccPub panicing on failure.
 func MustBech32ifyAccPub(pub crypto.PubKey) string {
 	enc, err := Bech32ifyAccPub(pub)
 	if err != nil {
@@ -234,13 +234,13 @@ func MustBech32ifyAccPub(pub crypto.PubKey) string {
 	return enc
 }
 
-// Bech32ifyValPub returns the bech32 encoded string for a validator's
-// crypto.PubKey.
+// Bech32ifyValPub returns a bech32 encoded string for a given validator
+// operator's PubKey.
 func Bech32ifyValPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixValPub, pub.Bytes())
 }
 
-// MustBech32ifyValPub panics on bech32-encoding failure.
+// MustBech32ifyValPub returns the result of Bech32ifyValPub panicing on failure.
 func MustBech32ifyValPub(pub crypto.PubKey) string {
 	enc, err := Bech32ifyValPub(pub)
 	if err != nil {
@@ -250,7 +250,22 @@ func MustBech32ifyValPub(pub crypto.PubKey) string {
 	return enc
 }
 
-// GetAccPubKeyBech32 creates a crypto.PubKey from a string.
+// Bech32ifyTmPub returns a bech32 encoded string for a given validator's PubKey.
+func Bech32ifyTmPub(pub crypto.PubKey) (string, error) {
+	return bech32.ConvertAndEncode(Bech32PrefixTmPub, pub.Bytes())
+}
+
+// MustBech32ifyTmPub returns the result of Bech32ifyTmPub panicing on failure.
+func MustBech32ifyTmPub(pub crypto.PubKey) string {
+	enc, err := Bech32ifyValPub(pub)
+	if err != nil {
+		panic(err)
+	}
+
+	return enc
+}
+
+// GetAccPubKeyBech32 creates a PubKey from a string.
 func GetAccPubKeyBech32(address string) (pk crypto.PubKey, err error) {
 	bz, err := GetFromBech32(address, Bech32PrefixAccPub)
 	if err != nil {
@@ -265,8 +280,7 @@ func GetAccPubKeyBech32(address string) (pk crypto.PubKey, err error) {
 	return pk, nil
 }
 
-// MustGetAccPubKeyBech32 creates a crypto.PubKey from a string. It panics on
-// error.
+// MustGetAccPubKeyBech32 creates a PubKey from a string. It panics on error.
 func MustGetAccPubKeyBech32(address string) (pk crypto.PubKey) {
 	pk, err := GetAccPubKeyBech32(address)
 	if err != nil {
@@ -276,7 +290,7 @@ func MustGetAccPubKeyBech32(address string) (pk crypto.PubKey) {
 	return pk
 }
 
-// GetValPubKeyBech32 decodes a validator public key into a crypto.PubKey.
+// GetValPubKeyBech32 decodes a validator public key into a PubKey.
 func GetValPubKeyBech32(pubkey string) (pk crypto.PubKey, err error) {
 	bz, err := GetFromBech32(pubkey, Bech32PrefixValPub)
 	if err != nil {
@@ -291,8 +305,7 @@ func GetValPubKeyBech32(pubkey string) (pk crypto.PubKey, err error) {
 	return pk, nil
 }
 
-// MustGetValPubKeyBech32 creates a crypto.PubKey from a string. It panics on
-// error.
+// MustGetValPubKeyBech32 creates a PubKey from a string. It panics on error.
 func MustGetValPubKeyBech32(address string) (pk crypto.PubKey) {
 	pk, err := GetValPubKeyBech32(address)
 	if err != nil {
@@ -302,7 +315,7 @@ func MustGetValPubKeyBech32(address string) (pk crypto.PubKey) {
 	return pk
 }
 
-// GetFromBech32 decodes a bytestring from a bech32-encoded string.
+// GetFromBech32 decodes a bytestring from a bech32 encoded string.
 func GetFromBech32(bech32str, prefix string) ([]byte, error) {
 	if len(bech32str) == 0 {
 		return nil, errors.New("decoding bech32 address failed: must provide an address")

From d62938c0b0267b157ed87bdfbbc3a1af5cb3f7ab Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 15 Aug 2018 08:38:43 -0400
Subject: [PATCH 05/34] Update validator type to use new account types/bech32
 prefixes

---
 x/stake/types/validator.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/x/stake/types/validator.go b/x/stake/types/validator.go
index 837b8f8e8a02..09b31425bbc6 100644
--- a/x/stake/types/validator.go
+++ b/x/stake/types/validator.go
@@ -21,7 +21,7 @@ import (
 // exchange rate. Voting power can be calculated as total bonds multiplied by
 // exchange rate.
 type Validator struct {
-	Owner   sdk.AccAddress `json:"owner"`   // sender of BondTx - UnbondTx returns here
+	Owner   sdk.ValAddress `json:"owner"`   // sender of BondTx - UnbondTx returns here
 	PubKey  crypto.PubKey  `json:"pub_key"` // pubkey of validator
 	Revoked bool           `json:"revoked"` // has the validator been revoked from bonded status?
 
@@ -44,7 +44,7 @@ type Validator struct {
 }
 
 // NewValidator - initialize a new validator
-func NewValidator(owner sdk.AccAddress, pubKey crypto.PubKey, description Description) Validator {
+func NewValidator(owner sdk.ValAddress, pubKey crypto.PubKey, description Description) Validator {
 	return Validator{
 		Owner:                 owner,
 		PubKey:                pubKey,
@@ -149,14 +149,14 @@ func UnmarshalValidator(cdc *wire.Codec, ownerAddr, value []byte) (validator Val
 // validator. An error is returned if the owner or the owner's public key
 // cannot be converted to Bech32 format.
 func (v Validator) HumanReadableString() (string, error) {
-	bechVal, err := sdk.Bech32ifyValPub(v.PubKey)
+	bechTmPubKey, err := sdk.Bech32ifyTmPub(v.PubKey)
 	if err != nil {
 		return "", err
 	}
 
 	resp := "Validator \n"
 	resp += fmt.Sprintf("Owner: %s\n", v.Owner)
-	resp += fmt.Sprintf("Validator: %s\n", bechVal)
+	resp += fmt.Sprintf("Validator: %s\n", bechTmPubKey)
 	resp += fmt.Sprintf("Revoked: %v\n", v.Revoked)
 	resp += fmt.Sprintf("Status: %s\n", sdk.BondStatusToString(v.Status))
 	resp += fmt.Sprintf("Tokens: %s\n", v.Tokens.FloatString())
@@ -177,7 +177,7 @@ func (v Validator) HumanReadableString() (string, error) {
 
 // validator struct for bech output
 type BechValidator struct {
-	Owner   sdk.AccAddress `json:"owner"`   // in bech32
+	Owner   sdk.ValAddress `json:"owner"`   // in bech32
 	PubKey  string         `json:"pub_key"` // in bech32
 	Revoked bool           `json:"revoked"` // has the validator been revoked from bonded status?
 
@@ -201,14 +201,14 @@ type BechValidator struct {
 
 // get the bech validator from the the regular validator
 func (v Validator) Bech32Validator() (BechValidator, error) {
-	bechValPubkey, err := sdk.Bech32ifyValPub(v.PubKey)
+	bechTmPubKey, err := sdk.Bech32ifyTmPub(v.PubKey)
 	if err != nil {
 		return BechValidator{}, err
 	}
 
 	return BechValidator{
 		Owner:   v.Owner,
-		PubKey:  bechValPubkey,
+		PubKey:  bechTmPubKey,
 		Revoked: v.Revoked,
 
 		Status:          v.Status,
@@ -432,7 +432,7 @@ var _ sdk.Validator = Validator{}
 func (v Validator) GetRevoked() bool            { return v.Revoked }
 func (v Validator) GetMoniker() string          { return v.Description.Moniker }
 func (v Validator) GetStatus() sdk.BondStatus   { return v.Status }
-func (v Validator) GetOwner() sdk.AccAddress    { return v.Owner }
+func (v Validator) GetOwner() sdk.ValAddress    { return v.Owner }
 func (v Validator) GetPubKey() crypto.PubKey    { return v.PubKey }
 func (v Validator) GetPower() sdk.Rat           { return v.BondedTokens() }
 func (v Validator) GetTokens() sdk.Rat          { return v.Tokens }

From 2c5782979f2684b0a42e4742ce01a738e542cfa6 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 15 Aug 2018 08:45:37 -0400
Subject: [PATCH 06/34] Fix account documentation errors

---
 types/account.go | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/types/account.go b/types/account.go
index 38b66ae77550..241e4c795da4 100644
--- a/types/account.go
+++ b/types/account.go
@@ -16,17 +16,17 @@ const (
 	// AddrLen is the expected address length
 	AddrLen = 20
 
-	// Bech32PrefixAccAddr defines the bech32 prefix of an account's address
+	// Bech32PrefixAccAddr defines the Bech32 prefix of an account's address
 	Bech32PrefixAccAddr = "cosmosaccaddr"
-	// Bech32PrefixAccPub defines the bech32 prefix of an account's public key
+	// Bech32PrefixAccPub defines the Bech32 prefix of an account's public key
 	Bech32PrefixAccPub = "cosmosaccpub"
-	// Bech32PrefixValAddr defines the bech32 prefix of a validator's operator address
+	// Bech32PrefixValAddr defines the Bech32 prefix of a validator's operator address
 	Bech32PrefixValAddr = "cosmosvaladdr"
-	// Bech32PrefixValPub defines the bech32 prefix of a validator's operator public key
+	// Bech32PrefixValPub defines the Bech32 prefix of a validator's operator public key
 	Bech32PrefixValPub = "cosmosvalpub"
-	// Bech32PrefixTmAddr defines the bech32 prefix of a Tendermint node's address
+	// Bech32PrefixTmAddr defines the Bech32 prefix of a Tendermint node's address
 	Bech32PrefixTmAddr = "cosmostmaddr"
-	// Bech32PrefixTmPub defines the bech32 prefix of a Tendermint node's public key
+	// Bech32PrefixTmPub defines the Bech32 prefix of a Tendermint node's public key
 	Bech32PrefixTmPub = "cosmostmpub"
 )
 
@@ -38,10 +38,10 @@ const (
 // When marshaled to a string or json, it uses bech32
 type AccAddress []byte
 
-// AccAddressFromHex createS an AccAddress from a hex string.
+// AccAddressFromHex creates an AccAddress from a hex string.
 func AccAddressFromHex(address string) (addr AccAddress, err error) {
 	if len(address) == 0 {
-		return addr, errors.New("decoding bech32 address failed: must provide an address")
+		return addr, errors.New("decoding Bech32 address failed: must provide an address")
 	}
 
 	bz, err := hex.DecodeString(address)
@@ -52,7 +52,7 @@ func AccAddressFromHex(address string) (addr AccAddress, err error) {
 	return AccAddress(bz), nil
 }
 
-// AccAddressFromBech32 createS an AccAddress from a bech32 string.
+// AccAddressFromBech32 creates an AccAddress from a Bech32 string.
 func AccAddressFromBech32(address string) (addr AccAddress, err error) {
 	bz, err := GetFromBech32(address, Bech32PrefixAccAddr)
 	if err != nil {
@@ -133,7 +133,7 @@ type ValAddress []byte
 // ValAddressFromHex creates a ValAddress from a hex string.
 func ValAddressFromHex(address string) (addr ValAddress, err error) {
 	if len(address) == 0 {
-		return addr, errors.New("decoding bech32 address failed: must provide an address")
+		return addr, errors.New("decoding Bech32 address failed: must provide an address")
 	}
 
 	bz, err := hex.DecodeString(address)
@@ -144,7 +144,7 @@ func ValAddressFromHex(address string) (addr ValAddress, err error) {
 	return ValAddress(bz), nil
 }
 
-// ValAddressFromBech32 creates a ValAddress from a bech32 string.
+// ValAddressFromBech32 creates a ValAddress from a Bech32 string.
 func ValAddressFromBech32(address string) (addr ValAddress, err error) {
 	bz, err := GetFromBech32(address, Bech32PrefixValAddr)
 	if err != nil {
@@ -219,7 +219,7 @@ func (bz ValAddress) Format(s fmt.State, verb rune) {
 // auxiliary
 // ----------------------------------------------------------------------------
 
-// Bech32ifyAccPub returns a bech32 encoded string for a given account PubKey.
+// Bech32ifyAccPub returns a Bech32 encoded string for a given account PubKey.
 func Bech32ifyAccPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixAccPub, pub.Bytes())
 }
@@ -234,7 +234,7 @@ func MustBech32ifyAccPub(pub crypto.PubKey) string {
 	return enc
 }
 
-// Bech32ifyValPub returns a bech32 encoded string for a given validator
+// Bech32ifyValPub returns a Bech32 encoded string for a given validator
 // operator's PubKey.
 func Bech32ifyValPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixValPub, pub.Bytes())
@@ -250,7 +250,7 @@ func MustBech32ifyValPub(pub crypto.PubKey) string {
 	return enc
 }
 
-// Bech32ifyTmPub returns a bech32 encoded string for a given validator's PubKey.
+// Bech32ifyTmPub returns a Bech32 encoded string for a given validator's PubKey.
 func Bech32ifyTmPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixTmPub, pub.Bytes())
 }
@@ -315,10 +315,10 @@ func MustGetValPubKeyBech32(address string) (pk crypto.PubKey) {
 	return pk
 }
 
-// GetFromBech32 decodes a bytestring from a bech32 encoded string.
+// GetFromBech32 decodes a bytestring from a Bech32 encoded string.
 func GetFromBech32(bech32str, prefix string) ([]byte, error) {
 	if len(bech32str) == 0 {
-		return nil, errors.New("decoding bech32 address failed: must provide an address")
+		return nil, errors.New("decoding Bech32 address failed: must provide an address")
 	}
 
 	hrp, bz, err := bech32.DecodeAndConvert(bech32str)
@@ -327,7 +327,7 @@ func GetFromBech32(bech32str, prefix string) ([]byte, error) {
 	}
 
 	if hrp != prefix {
-		return nil, fmt.Errorf("invalid bech32 prefix. Expected %s, Got %s", prefix, hrp)
+		return nil, fmt.Errorf("invalid Bech32 prefix. Expected %s, Got %s", prefix, hrp)
 	}
 
 	return bz, nil

From fd4bb7f1a190d8e095ac948bbfab8a87bdd3bd58 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 15 Aug 2018 08:54:39 -0400
Subject: [PATCH 07/34] Update Bech32 prefix for consensus nodes

---
 types/account.go           | 22 ++++++++++++----------
 types/stake.go             |  2 +-
 x/stake/types/validator.go |  4 ++--
 3 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/types/account.go b/types/account.go
index 241e4c795da4..1fdc06c035f9 100644
--- a/types/account.go
+++ b/types/account.go
@@ -13,7 +13,7 @@ import (
 )
 
 const (
-	// AddrLen is the expected address length
+	// AddrLen defines a valid address length
 	AddrLen = 20
 
 	// Bech32PrefixAccAddr defines the Bech32 prefix of an account's address
@@ -24,10 +24,10 @@ const (
 	Bech32PrefixValAddr = "cosmosvaladdr"
 	// Bech32PrefixValPub defines the Bech32 prefix of a validator's operator public key
 	Bech32PrefixValPub = "cosmosvalpub"
-	// Bech32PrefixTmAddr defines the Bech32 prefix of a Tendermint node's address
-	Bech32PrefixTmAddr = "cosmostmaddr"
-	// Bech32PrefixTmPub defines the Bech32 prefix of a Tendermint node's public key
-	Bech32PrefixTmPub = "cosmostmpub"
+	// Bech32PrefixConsAddr defines the Bech32 prefix of a consensus node address
+	Bech32PrefixConsAddr = "cosmosconsaddr"
+	// Bech32PrefixConsPub defines the Bech32 prefix of a consensus node public key
+	Bech32PrefixConsPub = "cosmosconspub"
 )
 
 // ----------------------------------------------------------------------------
@@ -250,13 +250,15 @@ func MustBech32ifyValPub(pub crypto.PubKey) string {
 	return enc
 }
 
-// Bech32ifyTmPub returns a Bech32 encoded string for a given validator's PubKey.
-func Bech32ifyTmPub(pub crypto.PubKey) (string, error) {
-	return bech32.ConvertAndEncode(Bech32PrefixTmPub, pub.Bytes())
+// Bech32ifyConsPub returns a Bech32 encoded string for a given consensus node's
+// PubKey.
+func Bech32ifyConsPub(pub crypto.PubKey) (string, error) {
+	return bech32.ConvertAndEncode(Bech32PrefixConsPub, pub.Bytes())
 }
 
-// MustBech32ifyTmPub returns the result of Bech32ifyTmPub panicing on failure.
-func MustBech32ifyTmPub(pub crypto.PubKey) string {
+// MustBech32ifyConsPub returns the result of Bech32ifyConsPub panicing on
+// failure.
+func MustBech32ifyConsPub(pub crypto.PubKey) string {
 	enc, err := Bech32ifyValPub(pub)
 	if err != nil {
 		panic(err)
diff --git a/types/stake.go b/types/stake.go
index 4e3cf38a3233..962f6807c325 100644
--- a/types/stake.go
+++ b/types/stake.go
@@ -40,7 +40,7 @@ type Validator interface {
 	GetRevoked() bool         // whether the validator is revoked
 	GetMoniker() string       // moniker of the validator
 	GetStatus() BondStatus    // status of the validator
-	GetOwner() AccAddress     // owner AccAddress to receive/return validators coins
+	GetOwner() ValAddress     // owner address to receive/return validators coins
 	GetPubKey() crypto.PubKey // validation pubkey
 	GetPower() Rat            // validation power
 	GetTokens() Rat           // validation tokens
diff --git a/x/stake/types/validator.go b/x/stake/types/validator.go
index 09b31425bbc6..9dec8509cc6b 100644
--- a/x/stake/types/validator.go
+++ b/x/stake/types/validator.go
@@ -149,7 +149,7 @@ func UnmarshalValidator(cdc *wire.Codec, ownerAddr, value []byte) (validator Val
 // validator. An error is returned if the owner or the owner's public key
 // cannot be converted to Bech32 format.
 func (v Validator) HumanReadableString() (string, error) {
-	bechTmPubKey, err := sdk.Bech32ifyTmPub(v.PubKey)
+	bechTmPubKey, err := sdk.Bech32ifyConsPub(v.PubKey)
 	if err != nil {
 		return "", err
 	}
@@ -201,7 +201,7 @@ type BechValidator struct {
 
 // get the bech validator from the the regular validator
 func (v Validator) Bech32Validator() (BechValidator, error) {
-	bechTmPubKey, err := sdk.Bech32ifyTmPub(v.PubKey)
+	bechTmPubKey, err := sdk.Bech32ifyConsPub(v.PubKey)
 	if err != nil {
 		return BechValidator{}, err
 	}

From a238db2c5cf5111150de98a2972990e6b359a8cc Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 15 Aug 2018 09:00:45 -0400
Subject: [PATCH 08/34] Update Bech32 spec doc

---
 docs/spec/other/bech32.md | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/docs/spec/other/bech32.md b/docs/spec/other/bech32.md
index 1d337ef6c355..45908247214c 100644
--- a/docs/spec/other/bech32.md
+++ b/docs/spec/other/bech32.md
@@ -1,25 +1,24 @@
 # Bech32 on Cosmos
 
-The Cosmos network prefers to use the Bech32 address format whereever users must handle binary data. Bech32 encoding provides robust integrity checks on data and the human readable part(HRP) provides contextual hints that can assist UI developers with providing informative error messages.
+The Cosmos network prefers to use the Bech32 address format wherever users must handle binary data. Bech32 encoding provides robust integrity checks on data and the human readable part(HRP) provides contextual hints that can assist UI developers with providing informative error messages.
 
 In the Cosmos network, keys and addresses may refer to a number of different roles in the network like accounts, validators etc.
 
+## HRP table
 
-## HRP table     
-
-| HRP        | Definition |
-| ------------- |:-------------:|
-| `cosmosaccaddr`     | Cosmos Account Address     |
-| `cosmosaccpub`      | Cosmos Account Public Key  |
-| `cosmosvaladdr`     | Cosmos Consensus Address   |
-| `cosmosvalpub`      | Cosmos Consensus Public Key|
+| HRP            | Definition                           |
+|----------------|--------------------------------------|
+| cosmosaccaddr  | Cosmos Account Address               |
+| cosmosaccpub   | Cosmos Account Public Key            |
+| cosmosconsaddr | Cosmos Consensus Address             |
+| cosmosconspub  | Cosmos Consensus Public Key          |
+| cosmosvaladdr  | Cosmos Validator Operator Address    |
+| cosmosvalpub   | Cosmos Validator Operator Public Key |
 
 ## Encoding
 
-While all user facing interfaces to Cosmos software should exposed bech32 interfaces, many internal interfaces encode binary value in hex or base64 encoded form.
-
-To covert between other binary reprsentation of addresses and keys, it is important to first apply the Amino enocoding process before bech32 encoding.
+While all user facing interfaces to Cosmos software should exposed Bech32 interfaces, many internal interfaces encode binary value in hex or base64 encoded form.
 
-A complete implementation of the Amino serialization format is unncessary in most cases. Simply prepending bytes from this [table](https://github.com/tendermint/tendermint/blob/master/docs/spec/blockchain/encoding.md#public-key-cryptography) to the bytestring payload before bech32 encoding will sufficient for compatible representation.
+To covert between other binary representation of addresses and keys, it is important to first apply the Amino encoding process before bech32 encoding.
 
- 
\ No newline at end of file
+A complete implementation of the Amino serialization format is unnecessary in most cases. Simply prepending bytes from this [table](https://github.com/tendermint/tendermint/blob/master/docs/spec/blockchain/encoding.md#public-key-cryptography) to the byte string payload before bech32 encoding will sufficient for compatible representation.

From 0a5fde8c79a3d5849b8cd34151b7786e72e82e80 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 15 Aug 2018 09:12:02 -0400
Subject: [PATCH 09/34] Fix account type tests

---
 types/account.go      |  2 +-
 types/account_test.go | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/types/account.go b/types/account.go
index 1fdc06c035f9..891ed24dce9b 100644
--- a/types/account.go
+++ b/types/account.go
@@ -259,7 +259,7 @@ func Bech32ifyConsPub(pub crypto.PubKey) (string, error) {
 // MustBech32ifyConsPub returns the result of Bech32ifyConsPub panicing on
 // failure.
 func MustBech32ifyConsPub(pub crypto.PubKey) string {
-	enc, err := Bech32ifyValPub(pub)
+	enc, err := Bech32ifyConsPub(pub)
 	if err != nil {
 		panic(err)
 	}
diff --git a/types/account_test.go b/types/account_test.go
index aa222ee7e991..f9a701838203 100644
--- a/types/account_test.go
+++ b/types/account_test.go
@@ -42,18 +42,18 @@ func TestRandBech32PubkeyConsistency(t *testing.T) {
 		require.Nil(t, err)
 		require.Equal(t, bech32accpub, mustbech32accpub)
 
-		mustbech32valpub := types.MustBech32ifyValPub(pub)
-		bech32valpub, err := types.Bech32ifyValPub(pub)
+		mustBech32ConsPub := types.MustBech32ifyConsPub(pub)
+		bech32ConsPub, err := types.Bech32ifyConsPub(pub)
 		require.Nil(t, err)
-		require.Equal(t, bech32valpub, mustbech32valpub)
+		require.Equal(t, bech32ConsPub, mustBech32ConsPub)
 
 		mustaccpub := types.MustGetAccPubKeyBech32(bech32accpub)
 		accpub, err := types.GetAccPubKeyBech32(bech32accpub)
 		require.Nil(t, err)
 		require.Equal(t, accpub, mustaccpub)
 
-		mustvalpub := types.MustGetValPubKeyBech32(bech32valpub)
-		valpub, err := types.GetValPubKeyBech32(bech32valpub)
+		mustvalpub := types.MustGetValPubKeyBech32(bech32ConsPub)
+		valpub, err := types.GetValPubKeyBech32(bech32ConsPub)
 		require.Nil(t, err)
 		require.Equal(t, valpub, mustvalpub)
 

From 61873958047aee023a84da4aab16dd33b2f2dd53 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 15 Aug 2018 10:41:09 -0400
Subject: [PATCH 10/34] Add missing account consensus functions, clear up
 godocs, and fix tests

---
 types/account.go      | 64 ++++++++++++++++++++++++++++++++-----------
 types/account_test.go | 30 +++++++++++++-------
 2 files changed, 68 insertions(+), 26 deletions(-)

diff --git a/types/account.go b/types/account.go
index 891ed24dce9b..e57778d27418 100644
--- a/types/account.go
+++ b/types/account.go
@@ -219,7 +219,8 @@ func (bz ValAddress) Format(s fmt.State, verb rune) {
 // auxiliary
 // ----------------------------------------------------------------------------
 
-// Bech32ifyAccPub returns a Bech32 encoded string for a given account PubKey.
+// Bech32ifyAccPub returns a Bech32 encoded string containing the
+// Bech32PrefixAccPub prefix for a given account PubKey.
 func Bech32ifyAccPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixAccPub, pub.Bytes())
 }
@@ -234,8 +235,8 @@ func MustBech32ifyAccPub(pub crypto.PubKey) string {
 	return enc
 }
 
-// Bech32ifyValPub returns a Bech32 encoded string for a given validator
-// operator's PubKey.
+// Bech32ifyValPub returns a Bech32 encoded string containing the
+// Bech32PrefixValPub prefix for a given validator operator's PubKey.
 func Bech32ifyValPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixValPub, pub.Bytes())
 }
@@ -250,8 +251,8 @@ func MustBech32ifyValPub(pub crypto.PubKey) string {
 	return enc
 }
 
-// Bech32ifyConsPub returns a Bech32 encoded string for a given consensus node's
-// PubKey.
+// Bech32ifyConsPub returns a Bech32 encoded string containing the
+// Bech32PrefixConsPub prefixfor a given consensus node's PubKey.
 func Bech32ifyConsPub(pub crypto.PubKey) (string, error) {
 	return bech32.ConvertAndEncode(Bech32PrefixConsPub, pub.Bytes())
 }
@@ -267,9 +268,10 @@ func MustBech32ifyConsPub(pub crypto.PubKey) string {
 	return enc
 }
 
-// GetAccPubKeyBech32 creates a PubKey from a string.
-func GetAccPubKeyBech32(address string) (pk crypto.PubKey, err error) {
-	bz, err := GetFromBech32(address, Bech32PrefixAccPub)
+// GetAccPubKeyBech32 creates a PubKey for an account with a given public key
+// string using the Bech32 Bech32PrefixAccPub prefix.
+func GetAccPubKeyBech32(pubkey string) (pk crypto.PubKey, err error) {
+	bz, err := GetFromBech32(pubkey, Bech32PrefixAccPub)
 	if err != nil {
 		return nil, err
 	}
@@ -282,9 +284,10 @@ func GetAccPubKeyBech32(address string) (pk crypto.PubKey, err error) {
 	return pk, nil
 }
 
-// MustGetAccPubKeyBech32 creates a PubKey from a string. It panics on error.
-func MustGetAccPubKeyBech32(address string) (pk crypto.PubKey) {
-	pk, err := GetAccPubKeyBech32(address)
+// MustGetAccPubKeyBech32 returns the result of GetAccPubKeyBech32 panicing on
+// failure.
+func MustGetAccPubKeyBech32(pubkey string) (pk crypto.PubKey) {
+	pk, err := GetAccPubKeyBech32(pubkey)
 	if err != nil {
 		panic(err)
 	}
@@ -292,7 +295,8 @@ func MustGetAccPubKeyBech32(address string) (pk crypto.PubKey) {
 	return pk
 }
 
-// GetValPubKeyBech32 decodes a validator public key into a PubKey.
+// GetValPubKeyBech32 creates a PubKey for a validator's operator with a given
+// public key string using the Bech32 Bech32PrefixValPub prefix.
 func GetValPubKeyBech32(pubkey string) (pk crypto.PubKey, err error) {
 	bz, err := GetFromBech32(pubkey, Bech32PrefixValPub)
 	if err != nil {
@@ -307,9 +311,37 @@ func GetValPubKeyBech32(pubkey string) (pk crypto.PubKey, err error) {
 	return pk, nil
 }
 
-// MustGetValPubKeyBech32 creates a PubKey from a string. It panics on error.
-func MustGetValPubKeyBech32(address string) (pk crypto.PubKey) {
-	pk, err := GetValPubKeyBech32(address)
+// MustGetValPubKeyBech32 returns the result of GetValPubKeyBech32 panicing on
+// failure.
+func MustGetValPubKeyBech32(pubkey string) (pk crypto.PubKey) {
+	pk, err := GetValPubKeyBech32(pubkey)
+	if err != nil {
+		panic(err)
+	}
+
+	return pk
+}
+
+// GetConsPubKeyBech32 creates a PubKey for a consensus node with a given public
+// key string using the Bech32 Bech32PrefixConsPub prefix.
+func GetConsPubKeyBech32(pubkey string) (pk crypto.PubKey, err error) {
+	bz, err := GetFromBech32(pubkey, Bech32PrefixConsPub)
+	if err != nil {
+		return nil, err
+	}
+
+	pk, err = cryptoAmino.PubKeyFromBytes(bz)
+	if err != nil {
+		return nil, err
+	}
+
+	return pk, nil
+}
+
+// MustGetConsPubKeyBech32 returns the result of GetConsPubKeyBech32 panicing on
+// failure.
+func MustGetConsPubKeyBech32(pubkey string) (pk crypto.PubKey) {
+	pk, err := GetConsPubKeyBech32(pubkey)
 	if err != nil {
 		panic(err)
 	}
@@ -329,7 +361,7 @@ func GetFromBech32(bech32str, prefix string) ([]byte, error) {
 	}
 
 	if hrp != prefix {
-		return nil, fmt.Errorf("invalid Bech32 prefix. Expected %s, Got %s", prefix, hrp)
+		return nil, fmt.Errorf("invalid Bech32 prefix; expected %s, got %s", prefix, hrp)
 	}
 
 	return bz, nil
diff --git a/types/account_test.go b/types/account_test.go
index f9a701838203..480beb405bd1 100644
--- a/types/account_test.go
+++ b/types/account_test.go
@@ -37,27 +37,37 @@ func TestRandBech32PubkeyConsistency(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		rand.Read(pub[:])
 
-		mustbech32accpub := types.MustBech32ifyAccPub(pub)
-		bech32accpub, err := types.Bech32ifyAccPub(pub)
+		mustBech32AccPub := types.MustBech32ifyAccPub(pub)
+		bech32AccPub, err := types.Bech32ifyAccPub(pub)
 		require.Nil(t, err)
-		require.Equal(t, bech32accpub, mustbech32accpub)
+		require.Equal(t, bech32AccPub, mustBech32AccPub)
+
+		mustBech32ValPub := types.MustBech32ifyValPub(pub)
+		bech32ValPub, err := types.Bech32ifyValPub(pub)
+		require.Nil(t, err)
+		require.Equal(t, bech32ValPub, mustBech32ValPub)
 
 		mustBech32ConsPub := types.MustBech32ifyConsPub(pub)
 		bech32ConsPub, err := types.Bech32ifyConsPub(pub)
 		require.Nil(t, err)
 		require.Equal(t, bech32ConsPub, mustBech32ConsPub)
 
-		mustaccpub := types.MustGetAccPubKeyBech32(bech32accpub)
-		accpub, err := types.GetAccPubKeyBech32(bech32accpub)
+		mustAccPub := types.MustGetAccPubKeyBech32(bech32AccPub)
+		accPub, err := types.GetAccPubKeyBech32(bech32AccPub)
+		require.Nil(t, err)
+		require.Equal(t, accPub, mustAccPub)
+
+		mustValPub := types.MustGetValPubKeyBech32(bech32ValPub)
+		valPub, err := types.GetValPubKeyBech32(bech32ValPub)
 		require.Nil(t, err)
-		require.Equal(t, accpub, mustaccpub)
+		require.Equal(t, valPub, mustValPub)
 
-		mustvalpub := types.MustGetValPubKeyBech32(bech32ConsPub)
-		valpub, err := types.GetValPubKeyBech32(bech32ConsPub)
+		mustConsPub := types.MustGetConsPubKeyBech32(bech32ConsPub)
+		consPub, err := types.GetConsPubKeyBech32(bech32ConsPub)
 		require.Nil(t, err)
-		require.Equal(t, valpub, mustvalpub)
+		require.Equal(t, consPub, mustConsPub)
 
-		require.Equal(t, valpub, accpub)
+		require.Equal(t, valPub, accPub)
 	}
 }
 

From 8756a08bfd3a2030e2f3bab6a4fcb08e862413d4 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 15 Aug 2018 12:59:22 -0400
Subject: [PATCH 11/34] Add to TestRandBech32PubkeyConsistency check

---
 types/account_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/types/account_test.go b/types/account_test.go
index 480beb405bd1..072fcaea26ea 100644
--- a/types/account_test.go
+++ b/types/account_test.go
@@ -68,6 +68,7 @@ func TestRandBech32PubkeyConsistency(t *testing.T) {
 		require.Equal(t, consPub, mustConsPub)
 
 		require.Equal(t, valPub, accPub)
+		require.Equal(t, valPub, consPub)
 	}
 }
 

From 0f634347331a23b6225b561b4c426ca8f3d60e0f Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 15 Aug 2018 13:43:08 -0400
Subject: [PATCH 12/34] Update initialization of validator public keys

---
 cmd/gaia/app/genesis.go    | 7 ++++---
 x/stake/types/msg.go       | 2 +-
 x/stake/types/validator.go | 8 ++++----
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/cmd/gaia/app/genesis.go b/cmd/gaia/app/genesis.go
index 1731fe2dc5d4..3634dfa2970c 100644
--- a/cmd/gaia/app/genesis.go
+++ b/cmd/gaia/app/genesis.go
@@ -140,7 +140,7 @@ func GaiaAppGenTxNF(cdc *wire.Codec, pk crypto.PubKey, addr sdk.AccAddress, name
 	gaiaGenTx := GaiaGenTx{
 		Name:    name,
 		Address: addr,
-		PubKey:  sdk.MustBech32ifyAccPub(pk),
+		PubKey:  sdk.MustBech32ifyConsPub(pk),
 	}
 	bz, err = wire.MarshalJSONIndent(cdc, gaiaGenTx)
 	if err != nil {
@@ -190,8 +190,9 @@ func GaiaAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (genesisState
 		// add the validator
 		if len(genTx.Name) > 0 {
 			desc := stake.NewDescription(genTx.Name, "", "", "")
-			validator := stake.NewValidator(genTx.Address,
-				sdk.MustGetAccPubKeyBech32(genTx.PubKey), desc)
+			validator := stake.NewValidator(
+				genTx.Address, sdk.MustGetConsPubKeyBech32(genTx.PubKey), desc,
+			)
 
 			stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewRat(freeFermionVal)) // increase the supply
 
diff --git a/x/stake/types/msg.go b/x/stake/types/msg.go
index 27edad5dd28b..34e26d2cc1a8 100644
--- a/x/stake/types/msg.go
+++ b/x/stake/types/msg.go
@@ -83,7 +83,7 @@ func (msg MsgCreateValidator) GetSignBytes() []byte {
 	}{
 		Description:   msg.Description,
 		ValidatorAddr: msg.ValidatorAddr,
-		PubKey:        sdk.MustBech32ifyValPub(msg.PubKey),
+		PubKey:        sdk.MustBech32ifyConsPub(msg.PubKey),
 		Delegation:    msg.Delegation,
 	})
 	if err != nil {
diff --git a/x/stake/types/validator.go b/x/stake/types/validator.go
index 9dec8509cc6b..34960e4e8b02 100644
--- a/x/stake/types/validator.go
+++ b/x/stake/types/validator.go
@@ -149,14 +149,14 @@ func UnmarshalValidator(cdc *wire.Codec, ownerAddr, value []byte) (validator Val
 // validator. An error is returned if the owner or the owner's public key
 // cannot be converted to Bech32 format.
 func (v Validator) HumanReadableString() (string, error) {
-	bechTmPubKey, err := sdk.Bech32ifyConsPub(v.PubKey)
+	bechConsPubKey, err := sdk.Bech32ifyConsPub(v.PubKey)
 	if err != nil {
 		return "", err
 	}
 
 	resp := "Validator \n"
 	resp += fmt.Sprintf("Owner: %s\n", v.Owner)
-	resp += fmt.Sprintf("Validator: %s\n", bechTmPubKey)
+	resp += fmt.Sprintf("Validator: %s\n", bechConsPubKey)
 	resp += fmt.Sprintf("Revoked: %v\n", v.Revoked)
 	resp += fmt.Sprintf("Status: %s\n", sdk.BondStatusToString(v.Status))
 	resp += fmt.Sprintf("Tokens: %s\n", v.Tokens.FloatString())
@@ -201,14 +201,14 @@ type BechValidator struct {
 
 // get the bech validator from the the regular validator
 func (v Validator) Bech32Validator() (BechValidator, error) {
-	bechTmPubKey, err := sdk.Bech32ifyConsPub(v.PubKey)
+	bechConsPubKey, err := sdk.Bech32ifyConsPub(v.PubKey)
 	if err != nil {
 		return BechValidator{}, err
 	}
 
 	return BechValidator{
 		Owner:   v.Owner,
-		PubKey:  bechTmPubKey,
+		PubKey:  bechConsPubKey,
 		Revoked: v.Revoked,
 
 		Status:          v.Status,

From 0cf73c1caea10b076faf9081b8a0c37d556e56c0 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 15 Aug 2018 14:06:09 -0400
Subject: [PATCH 13/34] Update query signing info command

---
 x/slashing/client/cli/query.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/x/slashing/client/cli/query.go b/x/slashing/client/cli/query.go
index 0901eef97085..9f6d834dda06 100644
--- a/x/slashing/client/cli/query.go
+++ b/x/slashing/client/cli/query.go
@@ -20,7 +20,7 @@ func GetCmdQuerySigningInfo(storeName string, cdc *wire.Codec) *cobra.Command {
 		Short: "Query a validator's signing information",
 		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			pk, err := sdk.GetValPubKeyBech32(args[0])
+			pk, err := sdk.GetConsPubKeyBech32(args[0])
 			if err != nil {
 				return err
 			}

From d4eba75279a487918c45d689ec51223fa84913f2 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 15 Aug 2018 18:39:28 -0400
Subject: [PATCH 14/34] Implement new ConsAddress type with associated unit
 tests

---
 types/account.go      | 187 ++++++++++++++++++++++++++++++++----------
 types/account_test.go |  43 +++++++++-
 2 files changed, 183 insertions(+), 47 deletions(-)

diff --git a/types/account.go b/types/account.go
index e57778d27418..1b86f3e944a3 100644
--- a/types/account.go
+++ b/types/account.go
@@ -34,8 +34,8 @@ const (
 // account
 // ----------------------------------------------------------------------------
 
-// AccAddress a wrapper around bytes meant to represent an account address
-// When marshaled to a string or json, it uses bech32
+// AccAddress a wrapper around bytes meant to represent an account address.
+// When marshaled to a string or JSON, it uses Bech32.
 type AccAddress []byte
 
 // AccAddressFromHex creates an AccAddress from a hex string.
@@ -62,47 +62,49 @@ func AccAddressFromBech32(address string) (addr AccAddress, err error) {
 	return AccAddress(bz), nil
 }
 
-// Marshal needed for protobuf compatibility.
-func (bz AccAddress) Marshal() ([]byte, error) {
-	return bz, nil
+// Marshal returns the raw address bytes. It is needed for protobuf
+// compatibility.
+func (aa AccAddress) Marshal() ([]byte, error) {
+	return aa, nil
 }
 
-// Unmarshal needed for protobuf compatibility.
-func (bz *AccAddress) Unmarshal(data []byte) error {
-	*bz = data
+// Unmarshal sets the address to the given data. It is needed for protobuf
+// compatibility.
+func (aa *AccAddress) Unmarshal(data []byte) error {
+	*aa = data
 	return nil
 }
 
 // MarshalJSON marshals to JSON using Bech32.
-func (bz AccAddress) MarshalJSON() ([]byte, error) {
-	return json.Marshal(bz.String())
+func (aa AccAddress) MarshalJSON() ([]byte, error) {
+	return json.Marshal(aa.String())
 }
 
 // UnmarshalJSON unmarshals from JSON assuming Bech32 encoding.
-func (bz *AccAddress) UnmarshalJSON(data []byte) error {
+func (aa *AccAddress) UnmarshalJSON(data []byte) error {
 	var s string
 	err := json.Unmarshal(data, &s)
 	if err != nil {
 		return nil
 	}
 
-	bz2, err := AccAddressFromBech32(s)
+	aa2, err := AccAddressFromBech32(s)
 	if err != nil {
 		return err
 	}
 
-	*bz = bz2
+	*aa = aa2
 	return nil
 }
 
-// Bytes returns the raw bytes.
-func (bz AccAddress) Bytes() []byte {
-	return bz
+// Bytes returns the raw address bytes.
+func (aa AccAddress) Bytes() []byte {
+	return aa
 }
 
 // String implements the Stringer interface.
-func (bz AccAddress) String() string {
-	bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixAccAddr, bz.Bytes())
+func (aa AccAddress) String() string {
+	bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixAccAddr, aa.Bytes())
 	if err != nil {
 		panic(err)
 	}
@@ -111,14 +113,14 @@ func (bz AccAddress) String() string {
 }
 
 // Format implements the fmt.Formatter interface.
-func (bz AccAddress) Format(s fmt.State, verb rune) {
+func (aa AccAddress) Format(s fmt.State, verb rune) {
 	switch verb {
 	case 's':
-		s.Write([]byte(fmt.Sprintf("%s", bz.String())))
+		s.Write([]byte(fmt.Sprintf("%s", aa.String())))
 	case 'p':
-		s.Write([]byte(fmt.Sprintf("%p", bz)))
+		s.Write([]byte(fmt.Sprintf("%p", aa)))
 	default:
-		s.Write([]byte(fmt.Sprintf("%X", []byte(bz))))
+		s.Write([]byte(fmt.Sprintf("%X", []byte(aa))))
 	}
 }
 
@@ -126,8 +128,8 @@ func (bz AccAddress) Format(s fmt.State, verb rune) {
 // validator owner
 // ----------------------------------------------------------------------------
 
-// AccAddress a wrapper around bytes meant to represent a validator address
-// (from over ABCI).  When marshaled to a string or json, it uses bech32
+// ValAddress defines a wrapper around bytes meant to present a validator's
+// operator. When marshaled to a string or JSON, it uses Bech32.
 type ValAddress []byte
 
 // ValAddressFromHex creates a ValAddress from a hex string.
@@ -154,24 +156,121 @@ func ValAddressFromBech32(address string) (addr ValAddress, err error) {
 	return ValAddress(bz), nil
 }
 
-// Marshal needed for protobuf compatibility.
-func (bz ValAddress) Marshal() ([]byte, error) {
-	return bz, nil
+// Marshal returns the raw address bytes. It is needed for protobuf
+// compatibility.
+func (va ValAddress) Marshal() ([]byte, error) {
+	return va, nil
+}
+
+// Unmarshal sets the address to the given data. It is needed for protobuf
+// compatibility.
+func (va *ValAddress) Unmarshal(data []byte) error {
+	*va = data
+	return nil
+}
+
+// MarshalJSON marshals to JSON using Bech32.
+func (va ValAddress) MarshalJSON() ([]byte, error) {
+	return json.Marshal(va.String())
+}
+
+// UnmarshalJSON unmarshals from JSON assuming Bech32 encoding.
+func (va *ValAddress) UnmarshalJSON(data []byte) error {
+	var s string
+
+	err := json.Unmarshal(data, &s)
+	if err != nil {
+		return nil
+	}
+
+	va2, err := ValAddressFromBech32(s)
+	if err != nil {
+		return err
+	}
+
+	*va = va2
+	return nil
+}
+
+// Bytes returns the raw address bytes.
+func (va ValAddress) Bytes() []byte {
+	return va
+}
+
+// String implements the Stringer interface.
+func (va ValAddress) String() string {
+	bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixValAddr, va.Bytes())
+	if err != nil {
+		panic(err)
+	}
+
+	return bech32Addr
+}
+
+// Format implements the fmt.Formatter interface.
+func (va ValAddress) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 's':
+		s.Write([]byte(fmt.Sprintf("%s", va.String())))
+	case 'p':
+		s.Write([]byte(fmt.Sprintf("%p", va)))
+	default:
+		s.Write([]byte(fmt.Sprintf("%X", []byte(va))))
+	}
+}
+
+// ----------------------------------------------------------------------------
+// consensus node
+// ----------------------------------------------------------------------------
+
+// ConsAddress defines a wrapper around bytes meant to present a consensus node.
+// When marshaled to a string or JSON, it uses Bech32.
+type ConsAddress []byte
+
+// ConsAddressFromHex creates a ConsAddress from a hex string.
+func ConsAddressFromHex(address string) (addr ConsAddress, err error) {
+	if len(address) == 0 {
+		return addr, errors.New("decoding Bech32 address failed: must provide an address")
+	}
+
+	bz, err := hex.DecodeString(address)
+	if err != nil {
+		return nil, err
+	}
+
+	return ConsAddress(bz), nil
+}
+
+// ConsAddressFromBech32 creates a ConsAddress from a Bech32 string.
+func ConsAddressFromBech32(address string) (addr ConsAddress, err error) {
+	bz, err := GetFromBech32(address, Bech32PrefixConsAddr)
+	if err != nil {
+		return nil, err
+	}
+
+	return ConsAddress(bz), nil
+}
+
+// Marshal returns the raw address bytes. It is needed for protobuf
+// compatibility.
+func (ca ConsAddress) Marshal() ([]byte, error) {
+	return ca, nil
 }
 
-// Unmarshal needed for protobuf compatibility.
-func (bz *ValAddress) Unmarshal(data []byte) error {
-	*bz = data
+// Unmarshal sets the address to the given data. It is needed for protobuf
+// compatibility.
+func (ca *ConsAddress) Unmarshal(data []byte) error {
+	*ca = data
 	return nil
 }
 
 // MarshalJSON marshals to JSON using Bech32.
-func (bz ValAddress) MarshalJSON() ([]byte, error) {
-	return json.Marshal(bz.String())
+func (ca ConsAddress) MarshalJSON() ([]byte, error) {
+	return json.Marshal(ca.String())
 }
 
 // UnmarshalJSON unmarshals from JSON assuming Bech32 encoding.
-func (bz *ValAddress) UnmarshalJSON(data []byte) error {
+func (ca *ConsAddress) UnmarshalJSON(data []byte) error {
 	var s string
 
 	err := json.Unmarshal(data, &s)
@@ -179,23 +278,23 @@ func (bz *ValAddress) UnmarshalJSON(data []byte) error {
 		return nil
 	}
 
-	bz2, err := ValAddressFromBech32(s)
+	ca2, err := ConsAddressFromBech32(s)
 	if err != nil {
 		return err
 	}
 
-	*bz = bz2
+	*ca = ca2
 	return nil
 }
 
-// Bytes returns the raw bytes.
-func (bz ValAddress) Bytes() []byte {
-	return bz
+// Bytes returns the raw address bytes.
+func (ca ConsAddress) Bytes() []byte {
+	return ca
 }
 
 // String implements the Stringer interface.
-func (bz ValAddress) String() string {
-	bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixValAddr, bz.Bytes())
+func (ca ConsAddress) String() string {
+	bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixConsAddr, ca.Bytes())
 	if err != nil {
 		panic(err)
 	}
@@ -204,14 +303,14 @@ func (bz ValAddress) String() string {
 }
 
 // Format implements the fmt.Formatter interface.
-func (bz ValAddress) Format(s fmt.State, verb rune) {
+func (ca ConsAddress) Format(s fmt.State, verb rune) {
 	switch verb {
 	case 's':
-		s.Write([]byte(fmt.Sprintf("%s", bz.String())))
+		s.Write([]byte(fmt.Sprintf("%s", ca.String())))
 	case 'p':
-		s.Write([]byte(fmt.Sprintf("%p", bz)))
+		s.Write([]byte(fmt.Sprintf("%p", ca)))
 	default:
-		s.Write([]byte(fmt.Sprintf("%X", []byte(bz))))
+		s.Write([]byte(fmt.Sprintf("%X", []byte(ca))))
 	}
 }
 
diff --git a/types/account_test.go b/types/account_test.go
index 072fcaea26ea..e2ec36876cd5 100644
--- a/types/account_test.go
+++ b/types/account_test.go
@@ -12,7 +12,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/types"
 )
 
-var invalidstrs = []string{
+var invalidStrs = []string{
 	"",
 	"hello, world!",
 	"0xAA",
@@ -21,6 +21,8 @@ var invalidstrs = []string{
 	types.Bech32PrefixAccPub + "1234",
 	types.Bech32PrefixValAddr + "5678",
 	types.Bech32PrefixValPub + "BBAB",
+	types.Bech32PrefixConsAddr + "FF04",
+	types.Bech32PrefixConsPub + "6789",
 }
 
 func testMarshal(t *testing.T, original interface{}, res interface{}, marshal func() ([]byte, error), unmarshal func([]byte) error) {
@@ -95,7 +97,7 @@ func TestRandBech32AccAddrConsistency(t *testing.T) {
 		require.Equal(t, acc, res)
 	}
 
-	for _, str := range invalidstrs {
+	for _, str := range invalidStrs {
 		_, err := types.AccAddressFromHex(str)
 		require.NotNil(t, err)
 
@@ -130,7 +132,7 @@ func TestValAddr(t *testing.T) {
 		require.Equal(t, acc, res)
 	}
 
-	for _, str := range invalidstrs {
+	for _, str := range invalidStrs {
 		_, err := types.ValAddressFromHex(str)
 		require.NotNil(t, err)
 
@@ -141,3 +143,38 @@ func TestValAddr(t *testing.T) {
 		require.NotNil(t, err)
 	}
 }
+
+func TestConsAddress(t *testing.T) {
+	var pub ed25519.PubKeyEd25519
+
+	for i := 0; i < 20; i++ {
+		rand.Read(pub[:])
+
+		acc := types.ConsAddress(pub.Address())
+		res := types.ConsAddress{}
+
+		testMarshal(t, &acc, &res, acc.MarshalJSON, (&res).UnmarshalJSON)
+		testMarshal(t, &acc, &res, acc.Marshal, (&res).Unmarshal)
+
+		str := acc.String()
+		res, err := types.ConsAddressFromBech32(str)
+		require.Nil(t, err)
+		require.Equal(t, acc, res)
+
+		str = hex.EncodeToString(acc)
+		res, err = types.ConsAddressFromHex(str)
+		require.Nil(t, err)
+		require.Equal(t, acc, res)
+	}
+
+	for _, str := range invalidStrs {
+		_, err := types.ConsAddressFromHex(str)
+		require.NotNil(t, err)
+
+		_, err = types.ConsAddressFromBech32(str)
+		require.NotNil(t, err)
+
+		err = (*types.ConsAddress)(nil).UnmarshalJSON([]byte("\"" + str + "\""))
+		require.NotNil(t, err)
+	}
+}

From 79aaaa4815669fdf4ee95fc49357146aa129864f Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Thu, 16 Aug 2018 09:20:33 -0400
Subject: [PATCH 15/34] [WIP] Update stake and slashing parameters

---
 types/stake.go                  | 2 +-
 x/slashing/client/rest/query.go | 2 +-
 x/stake/client/cli/tx.go        | 2 +-
 x/stake/keeper/delegation.go    | 6 ++++--
 x/stake/keeper/key.go           | 2 +-
 5 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/types/stake.go b/types/stake.go
index 962f6807c325..2bfd2f41af7c 100644
--- a/types/stake.go
+++ b/types/stake.go
@@ -81,7 +81,7 @@ type ValidatorSet interface {
 // delegation bond for a delegated proof of stake system
 type Delegation interface {
 	GetDelegator() AccAddress // delegator AccAddress for the bond
-	GetValidator() AccAddress // validator owner AccAddress for the bond
+	GetValidator() ValAddress // validator operator address
 	GetBondShares() Rat       // amount of validator's shares
 }
 
diff --git a/x/slashing/client/rest/query.go b/x/slashing/client/rest/query.go
index 5509ed1a8d4e..291679375b06 100644
--- a/x/slashing/client/rest/query.go
+++ b/x/slashing/client/rest/query.go
@@ -23,7 +23,7 @@ func signingInfoHandlerFn(cliCtx context.CLIContext, storeName string, cdc *wire
 	return func(w http.ResponseWriter, r *http.Request) {
 		vars := mux.Vars(r)
 
-		pk, err := sdk.GetValPubKeyBech32(vars["validator"])
+		pk, err := sdk.GetConsPubKeyBech32(vars["validator"])
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(err.Error()))
diff --git a/x/stake/client/cli/tx.go b/x/stake/client/cli/tx.go
index 4c86777f343d..15bec972382e 100644
--- a/x/stake/client/cli/tx.go
+++ b/x/stake/client/cli/tx.go
@@ -50,7 +50,7 @@ func GetCmdCreateValidator(cdc *wire.Codec) *cobra.Command {
 				return fmt.Errorf("must use --pubkey flag")
 			}
 
-			pk, err := sdk.GetValPubKeyBech32(pkStr)
+			pk, err := sdk.GetConsPubKeyBech32(pkStr)
 			if err != nil {
 				return err
 			}
diff --git a/x/stake/keeper/delegation.go b/x/stake/keeper/delegation.go
index 484e85ad5c42..b81e1e1c0621 100644
--- a/x/stake/keeper/delegation.go
+++ b/x/stake/keeper/delegation.go
@@ -8,8 +8,10 @@ import (
 )
 
 // load a delegation
-func (k Keeper) GetDelegation(ctx sdk.Context,
-	delegatorAddr, validatorAddr sdk.AccAddress) (delegation types.Delegation, found bool) {
+func (k Keeper) GetDelegation(
+	ctx sdk.Context,
+	delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress) (
+	delegation types.Delegation, found bool) {
 
 	store := ctx.KVStore(k.storeKey)
 	key := GetDelegationKey(delegatorAddr, validatorAddr)
diff --git a/x/stake/keeper/key.go b/x/stake/keeper/key.go
index 502ec2654419..0187705b51f9 100644
--- a/x/stake/keeper/key.go
+++ b/x/stake/keeper/key.go
@@ -105,7 +105,7 @@ func GetTendermintUpdatesKey(ownerAddr sdk.AccAddress) []byte {
 
 // gets the key for delegator bond with validator
 // VALUE: stake/types.Delegation
-func GetDelegationKey(delegatorAddr, validatorAddr sdk.AccAddress) []byte {
+func GetDelegationKey(delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress) []byte {
 	return append(GetDelegationsKey(delegatorAddr), validatorAddr.Bytes()...)
 }
 

From 3bce88878be4c4bed591380bc84e6c975ba7cc3a Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Thu, 16 Aug 2018 09:29:18 -0400
Subject: [PATCH 16/34] Update all calls to MustBech32ifyValPub

---
 client/lcd/lcd_test.go        | 6 +++---
 client/rpc/validators.go      | 2 +-
 cmd/gaia/cli_test/cli_test.go | 2 +-
 server/tm_cmds.go             | 4 +++-
 4 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/client/lcd/lcd_test.go b/client/lcd/lcd_test.go
index 9b8c5e439719..f924ec4b6af2 100644
--- a/client/lcd/lcd_test.go
+++ b/client/lcd/lcd_test.go
@@ -363,7 +363,7 @@ func TestValidatorsQuery(t *testing.T) {
 
 	// make sure all the validators were found (order unknown because sorted by owner addr)
 	foundVal := false
-	pkBech := sdk.MustBech32ifyValPub(pks[0])
+	pkBech := sdk.MustBech32ifyConsPub(pks[0])
 	if validators[0].PubKey == pkBech {
 		foundVal = true
 	}
@@ -378,7 +378,7 @@ func TestValidatorQuery(t *testing.T) {
 	validator1Owner := sdk.AccAddress(pks[0].Address())
 
 	validator := getValidator(t, port, validator1Owner)
-	bech32ValAddress, err := sdk.Bech32ifyValPub(pks[0])
+	bech32ValAddress, err := sdk.Bech32ifyConsPub(pks[0])
 	require.NoError(t, err)
 	assert.Equal(t, validator.PubKey, bech32ValAddress, "The returned validator does not hold the correct data")
 }
@@ -567,7 +567,7 @@ func TestUnrevoke(t *testing.T) {
 
 	// XXX: any less than this and it fails
 	tests.WaitForHeight(3, port)
-	pkString, _ := sdk.Bech32ifyValPub(pks[0])
+	pkString, _ := sdk.Bech32ifyConsPub(pks[0])
 	signingInfo := getSigningInfo(t, port, pkString)
 	tests.WaitForHeight(4, port)
 	require.Equal(t, true, signingInfo.IndexOffset > 0)
diff --git a/client/rpc/validators.go b/client/rpc/validators.go
index d2daa4ec5cab..cb002d3ea046 100644
--- a/client/rpc/validators.go
+++ b/client/rpc/validators.go
@@ -45,7 +45,7 @@ type ResultValidatorsOutput struct {
 }
 
 func bech32ValidatorOutput(validator *tmtypes.Validator) (ValidatorOutput, error) {
-	bechValPubkey, err := sdk.Bech32ifyValPub(validator.PubKey)
+	bechValPubkey, err := sdk.Bech32ifyConsPub(validator.PubKey)
 	if err != nil {
 		return ValidatorOutput{}, err
 	}
diff --git a/cmd/gaia/cli_test/cli_test.go b/cmd/gaia/cli_test/cli_test.go
index ea4f2e47de3b..fb13fc970a27 100644
--- a/cmd/gaia/cli_test/cli_test.go
+++ b/cmd/gaia/cli_test/cli_test.go
@@ -107,7 +107,7 @@ func TestGaiaCLICreateValidator(t *testing.T) {
 
 	fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome))
 	barAddr, barPubKey := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show bar --output=json --home=%s", gaiacliHome))
-	barCeshPubKey := sdk.MustBech32ifyValPub(barPubKey)
+	barCeshPubKey := sdk.MustBech32ifyConsPub(barPubKey)
 
 	executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%s --from=foo", flags, barAddr), app.DefaultKeyPass)
 	tests.WaitForNextNBlocksTM(2, port)
diff --git a/server/tm_cmds.go b/server/tm_cmds.go
index f852b4029ab6..ba81db7635c4 100644
--- a/server/tm_cmds.go
+++ b/server/tm_cmds.go
@@ -53,10 +53,12 @@ func ShowValidatorCmd(ctx *Context) *cobra.Command {
 				fmt.Println(string(pubKeyJSONBytes))
 				return nil
 			}
-			pubkey, err := sdk.Bech32ifyValPub(valPubKey)
+
+			pubkey, err := sdk.Bech32ifyConsPub(valPubKey)
 			if err != nil {
 				return err
 			}
+
 			fmt.Println(pubkey)
 			return nil
 		},

From 2cf75c4d01fc839499995570fd9ffa4eea89a574 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 21 Aug 2018 09:25:36 -0400
Subject: [PATCH 17/34] [WIP] Validator operator API updates

---
 types/stake.go                   |   2 +-
 x/gov/tally.go                   |   6 +-
 x/slashing/client/rest/tx.go     |   6 +-
 x/slashing/msg.go                |  10 +--
 x/slashing/test_common.go        |   4 +-
 x/stake/app_test.go              |  30 ++++-----
 x/stake/client/cli/query.go      |  12 ++--
 x/stake/client/cli/tx.go         |  56 +++++++++--------
 x/stake/client/rest/query.go     |  47 +++++++-------
 x/stake/client/rest/tx.go        |  59 +++++++++---------
 x/stake/client/rest/utils.go     |  25 +++++---
 x/stake/genesis_test.go          |  10 +--
 x/stake/handler_test.go          |  92 ++++++++++++++-------------
 x/stake/keeper/delegation.go     |  71 ++++++++++-----------
 x/stake/keeper/key.go            |  70 ++++++++++-----------
 x/stake/keeper/sdk_types.go      |   4 +-
 x/stake/keeper/test_common.go    |  12 ++--
 x/stake/keeper/validator.go      |   8 +--
 x/stake/keeper/validator_test.go |   4 +-
 x/stake/types/delegation.go      |   8 +--
 x/stake/types/msg.go             | 103 +++++++++++++++----------------
 21 files changed, 327 insertions(+), 312 deletions(-)

diff --git a/types/stake.go b/types/stake.go
index 89a9604e5300..f88c7aa232f3 100644
--- a/types/stake.go
+++ b/types/stake.go
@@ -66,7 +66,7 @@ type ValidatorSet interface {
 	IterateValidatorsBonded(Context,
 		func(index int64, validator Validator) (stop bool))
 
-	Validator(Context, AccAddress) Validator            // get a particular validator by owner AccAddress
+	Validator(Context, ValAddress) Validator            // get a particular validator by operator
 	ValidatorByPubKey(Context, crypto.PubKey) Validator // get a particular validator by signing PubKey
 	TotalPower(Context) Dec                             // total power of the validator set
 
diff --git a/x/gov/tally.go b/x/gov/tally.go
index d8d4c78703c1..299202c9e646 100644
--- a/x/gov/tally.go
+++ b/x/gov/tally.go
@@ -6,14 +6,14 @@ import (
 
 // validatorGovInfo used for tallying
 type validatorGovInfo struct {
-	Address         sdk.AccAddress // sdk.AccAddress of the validator owner
+	Address         sdk.ValAddress // sdk.AccAddress of the validator owner
 	Power           sdk.Dec        // Power of a Validator
 	DelegatorShares sdk.Dec        // Total outstanding delegator shares
 	Minus           sdk.Dec        // Minus of validator, used to compute validator's voting power
 	Vote            VoteOption     // Vote of the validator
 }
 
-func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tallyResults TallyResult, nonVoting []sdk.AccAddress) {
+func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tallyResults TallyResult, nonVoting []sdk.ValAddress) {
 	results := make(map[VoteOption]sdk.Dec)
 	results[OptionYes] = sdk.ZeroDec()
 	results[OptionAbstain] = sdk.ZeroDec()
@@ -67,7 +67,7 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 	votesIterator.Close()
 
 	// Iterate over the validators again to tally their voting power and see who didn't vote
-	nonVoting = []sdk.AccAddress{}
+	nonVoting = []sdk.ValAddress{}
 	for _, val := range currValidators {
 		if val.Vote == OptionEmpty {
 			nonVoting = append(nonVoting, val.Address)
diff --git a/x/slashing/client/rest/tx.go b/x/slashing/client/rest/tx.go
index 2ecec51ea851..477268a514fc 100644
--- a/x/slashing/client/rest/tx.go
+++ b/x/slashing/client/rest/tx.go
@@ -58,14 +58,14 @@ func unrevokeRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx context.C
 			return
 		}
 
-		validatorAddr, err := sdk.AccAddressFromBech32(m.ValidatorAddr)
+		valAddr, err := sdk.ValAddressFromBech32(m.ValidatorAddr)
 		if err != nil {
 			w.WriteHeader(http.StatusInternalServerError)
 			w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error())))
 			return
 		}
 
-		if !bytes.Equal(info.GetPubKey().Address(), validatorAddr) {
+		if !bytes.Equal(info.GetPubKey().Address(), valAddr.Bytes()) {
 			w.WriteHeader(http.StatusUnauthorized)
 			w.Write([]byte("Must use own validator address"))
 			return
@@ -79,7 +79,7 @@ func unrevokeRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx context.C
 			Gas:           m.Gas,
 		}
 
-		msg := slashing.NewMsgUnrevoke(validatorAddr)
+		msg := slashing.NewMsgUnrevoke(valAddr)
 
 		txBytes, err := txCtx.BuildAndSign(m.LocalAccountName, m.Password, []sdk.Msg{msg})
 		if err != nil {
diff --git a/x/slashing/msg.go b/x/slashing/msg.go
index 4b1483dce905..6da01c31d701 100644
--- a/x/slashing/msg.go
+++ b/x/slashing/msg.go
@@ -15,18 +15,20 @@ var _ sdk.Msg = &MsgUnrevoke{}
 
 // MsgUnrevoke - struct for unrevoking revoked validator
 type MsgUnrevoke struct {
-	ValidatorAddr sdk.AccAddress `json:"address"` // address of the validator owner
+	ValidatorAddr sdk.ValAddress `json:"address"` // address of the validator owner
 }
 
-func NewMsgUnrevoke(validatorAddr sdk.AccAddress) MsgUnrevoke {
+func NewMsgUnrevoke(validatorAddr sdk.ValAddress) MsgUnrevoke {
 	return MsgUnrevoke{
 		ValidatorAddr: validatorAddr,
 	}
 }
 
 //nolint
-func (msg MsgUnrevoke) Type() string                 { return MsgType }
-func (msg MsgUnrevoke) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.ValidatorAddr} }
+func (msg MsgUnrevoke) Type() string { return MsgType }
+func (msg MsgUnrevoke) GetSigners() []sdk.AccAddress {
+	return []sdk.AccAddress{sdk.AccAddress(msg.ValidatorAddr)}
+}
 
 // get the bytes for the message signer to sign on
 func (msg MsgUnrevoke) GetSignBytes() []byte {
diff --git a/x/slashing/test_common.go b/x/slashing/test_common.go
index 50c501d7e3bd..1053823786c2 100644
--- a/x/slashing/test_common.go
+++ b/x/slashing/test_common.go
@@ -99,10 +99,10 @@ func testAddr(addr string) sdk.AccAddress {
 	return res
 }
 
-func newTestMsgCreateValidator(address sdk.AccAddress, pubKey crypto.PubKey, amt sdk.Int) stake.MsgCreateValidator {
+func newTestMsgCreateValidator(address sdk.ValAddress, pubKey crypto.PubKey, amt sdk.Int) stake.MsgCreateValidator {
 	return stake.MsgCreateValidator{
 		Description:   stake.Description{},
-		DelegatorAddr: address,
+		DelegatorAddr: sdk.AccAddress(address),
 		ValidatorAddr: address,
 		PubKey:        pubKey,
 		Delegation:    sdk.Coin{"steak", amt},
diff --git a/x/stake/app_test.go b/x/stake/app_test.go
index 65c64fdef222..ce6cb736cbe1 100644
--- a/x/stake/app_test.go
+++ b/x/stake/app_test.go
@@ -79,7 +79,7 @@ func getInitChainer(mapp *mock.App, keeper Keeper) sdk.InitChainer {
 //__________________________________________________________________________________________
 
 func checkValidator(t *testing.T, mapp *mock.App, keeper Keeper,
-	addr sdk.AccAddress, expFound bool) Validator {
+	addr sdk.ValAddress, expFound bool) Validator {
 
 	ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{})
 	validator, found := keeper.GetValidator(ctxCheck, addr)
@@ -89,8 +89,8 @@ func checkValidator(t *testing.T, mapp *mock.App, keeper Keeper,
 }
 
 func checkDelegation(
-	t *testing.T, mapp *mock.App, keeper Keeper, delegatorAddr,
-	validatorAddr sdk.AccAddress, expFound bool, expShares sdk.Dec,
+	t *testing.T, mapp *mock.App, keeper Keeper, delegatorAddr sdk.AccAddress,
+	validatorAddr sdk.ValAddress, expFound bool, expShares sdk.Dec,
 ) {
 
 	ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{})
@@ -128,55 +128,57 @@ func TestStakeMsgs(t *testing.T) {
 	// create validator
 	description := NewDescription("foo_moniker", "", "", "")
 	createValidatorMsg := NewMsgCreateValidator(
-		addr1, priv1.PubKey(), bondCoin, description,
+		sdk.ValAddress(addr1), priv1.PubKey(), bondCoin, description,
 	)
 
 	mock.SignCheckDeliver(t, mApp.BaseApp, []sdk.Msg{createValidatorMsg}, []int64{0}, []int64{0}, true, priv1)
 	mock.CheckBalance(t, mApp, addr1, sdk.Coins{genCoin.Minus(bondCoin)})
 	mApp.BeginBlock(abci.RequestBeginBlock{})
 
-	validator := checkValidator(t, mApp, keeper, addr1, true)
+	validator := checkValidator(t, mApp, keeper, sdk.ValAddress(addr1), true)
 	require.Equal(t, addr1, validator.Operator)
 	require.Equal(t, sdk.Bonded, validator.Status)
 	require.True(sdk.DecEq(t, sdk.NewDec(10), validator.BondedTokens()))
 
 	// addr1 create validator on behalf of addr2
-	createValidatorMsgOnBehalfOf := NewMsgCreateValidatorOnBehalfOf(addr1, addr2, priv2.PubKey(), bondCoin, description)
+	createValidatorMsgOnBehalfOf := NewMsgCreateValidatorOnBehalfOf(
+		addr1, sdk.ValAddress(addr2), priv2.PubKey(), bondCoin, description,
+	)
 
 	mock.SignCheckDeliver(t, mApp.BaseApp, []sdk.Msg{createValidatorMsgOnBehalfOf}, []int64{0, 1}, []int64{1, 0}, true, priv1, priv2)
 	mock.CheckBalance(t, mApp, addr1, sdk.Coins{genCoin.Minus(bondCoin).Minus(bondCoin)})
 	mApp.BeginBlock(abci.RequestBeginBlock{})
 
-	validator = checkValidator(t, mApp, keeper, addr2, true)
+	validator = checkValidator(t, mApp, keeper, sdk.ValAddress(addr2), true)
 	require.Equal(t, addr2, validator.Operator)
 	require.Equal(t, sdk.Bonded, validator.Status)
 	require.True(sdk.DecEq(t, sdk.NewDec(10), validator.Tokens))
 
 	// check the bond that should have been created as well
-	checkDelegation(t, mApp, keeper, addr1, addr1, true, sdk.NewDec(10))
+	checkDelegation(t, mApp, keeper, addr1, sdk.ValAddress(addr1), true, sdk.NewDec(10))
 
 	// edit the validator
 	description = NewDescription("bar_moniker", "", "", "")
-	editValidatorMsg := NewMsgEditValidator(addr1, description)
+	editValidatorMsg := NewMsgEditValidator(sdk.ValAddress(addr1), description)
 
 	mock.SignCheckDeliver(t, mApp.BaseApp, []sdk.Msg{editValidatorMsg}, []int64{0}, []int64{2}, true, priv1)
-	validator = checkValidator(t, mApp, keeper, addr1, true)
+	validator = checkValidator(t, mApp, keeper, sdk.ValAddress(addr1), true)
 	require.Equal(t, description, validator.Description)
 
 	// delegate
 	mock.CheckBalance(t, mApp, addr2, sdk.Coins{genCoin})
-	delegateMsg := NewMsgDelegate(addr2, addr1, bondCoin)
+	delegateMsg := NewMsgDelegate(addr2, sdk.ValAddress(addr1), bondCoin)
 
 	mock.SignCheckDeliver(t, mApp.BaseApp, []sdk.Msg{delegateMsg}, []int64{1}, []int64{1}, true, priv2)
 	mock.CheckBalance(t, mApp, addr2, sdk.Coins{genCoin.Minus(bondCoin)})
-	checkDelegation(t, mApp, keeper, addr2, addr1, true, sdk.NewDec(10))
+	checkDelegation(t, mApp, keeper, addr2, sdk.ValAddress(addr1), true, sdk.NewDec(10))
 
 	// begin unbonding
-	beginUnbondingMsg := NewMsgBeginUnbonding(addr2, addr1, sdk.NewDec(10))
+	beginUnbondingMsg := NewMsgBeginUnbonding(addr2, sdk.ValAddress(addr1), sdk.NewDec(10))
 	mock.SignCheckDeliver(t, mApp.BaseApp, []sdk.Msg{beginUnbondingMsg}, []int64{1}, []int64{2}, true, priv2)
 
 	// delegation should exist anymore
-	checkDelegation(t, mApp, keeper, addr2, addr1, false, sdk.Dec{})
+	checkDelegation(t, mApp, keeper, addr2, sdk.ValAddress(addr1), false, sdk.Dec{})
 
 	// balance should be the same because bonding not yet complete
 	mock.CheckBalance(t, mApp, addr2, sdk.Coins{genCoin.Minus(bondCoin)})
diff --git a/x/stake/client/cli/query.go b/x/stake/client/cli/query.go
index dc2c8e30d279..00ee95ebc130 100644
--- a/x/stake/client/cli/query.go
+++ b/x/stake/client/cli/query.go
@@ -17,11 +17,11 @@ import (
 // GetCmdQueryValidator implements the validator query command.
 func GetCmdQueryValidator(storeName string, cdc *wire.Codec) *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "validator [owner-addr]",
+		Use:   "validator [operator-addr]",
 		Short: "Query a validator",
 		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			addr, err := sdk.AccAddressFromBech32(args[0])
+			addr, err := sdk.ValAddressFromBech32(args[0])
 			if err != nil {
 				return err
 			}
@@ -120,7 +120,7 @@ func GetCmdQueryDelegation(storeName string, cdc *wire.Codec) *cobra.Command {
 		Use:   "delegation",
 		Short: "Query a delegation based on address and validator address",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			valAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator))
+			valAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidator))
 			if err != nil {
 				return err
 			}
@@ -222,7 +222,7 @@ func GetCmdQueryUnbondingDelegation(storeName string, cdc *wire.Codec) *cobra.Co
 		Use:   "unbonding-delegation",
 		Short: "Query an unbonding-delegation record based on delegator and validator address",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			valAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator))
+			valAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidator))
 			if err != nil {
 				return err
 			}
@@ -321,12 +321,12 @@ func GetCmdQueryRedelegation(storeName string, cdc *wire.Codec) *cobra.Command {
 		Use:   "unbonding-delegation",
 		Short: "Query an unbonding-delegation record based on delegator and validator address",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			valSrcAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorSrc))
+			valSrcAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidatorSrc))
 			if err != nil {
 				return err
 			}
 
-			valDstAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorDst))
+			valDstAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidatorDst))
 			if err != nil {
 				return err
 			}
diff --git a/x/stake/client/cli/tx.go b/x/stake/client/cli/tx.go
index 710f52ae4f3e..defc2b1e23c9 100644
--- a/x/stake/client/cli/tx.go
+++ b/x/stake/client/cli/tx.go
@@ -40,7 +40,7 @@ func GetCmdCreateValidator(cdc *wire.Codec) *cobra.Command {
 				return err
 			}
 
-			validatorAddr, err := cliCtx.GetFromAddress()
+			valAddr, err := cliCtx.GetFromAddress()
 			if err != nil {
 				return err
 			}
@@ -68,14 +68,14 @@ func GetCmdCreateValidator(cdc *wire.Codec) *cobra.Command {
 
 			var msg sdk.Msg
 			if viper.GetString(FlagAddressDelegator) != "" {
-				delegatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressDelegator))
+				delAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressDelegator))
 				if err != nil {
 					return err
 				}
 
-				msg = stake.NewMsgCreateValidatorOnBehalfOf(delegatorAddr, validatorAddr, pk, amount, description)
+				msg = stake.NewMsgCreateValidatorOnBehalfOf(delAddr, sdk.ValAddress(valAddr), pk, amount, description)
 			} else {
-				msg = stake.NewMsgCreateValidator(validatorAddr, pk, amount, description)
+				msg = stake.NewMsgCreateValidator(sdk.ValAddress(valAddr), pk, amount, description)
 			}
 
 			// build and sign the transaction, then broadcast to Tendermint
@@ -103,7 +103,7 @@ func GetCmdEditValidator(cdc *wire.Codec) *cobra.Command {
 				WithLogger(os.Stdout).
 				WithAccountDecoder(authcmd.GetAccountDecoder(cdc))
 
-			validatorAddr, err := cliCtx.GetFromAddress()
+			valAddr, err := cliCtx.GetFromAddress()
 			if err != nil {
 				return err
 			}
@@ -114,7 +114,8 @@ func GetCmdEditValidator(cdc *wire.Codec) *cobra.Command {
 				Website:  viper.GetString(FlagWebsite),
 				Details:  viper.GetString(FlagDetails),
 			}
-			msg := stake.NewMsgEditValidator(validatorAddr, description)
+
+			msg := stake.NewMsgEditValidator(sdk.ValAddress(valAddr), description)
 
 			// build and sign the transaction, then broadcast to Tendermint
 			return utils.SendTx(txCtx, cliCtx, []sdk.Msg{msg})
@@ -143,17 +144,17 @@ func GetCmdDelegate(cdc *wire.Codec) *cobra.Command {
 				return err
 			}
 
-			delegatorAddr, err := cliCtx.GetFromAddress()
+			delAddr, err := cliCtx.GetFromAddress()
 			if err != nil {
 				return err
 			}
 
-			validatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator))
+			valAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidator))
 			if err != nil {
 				return err
 			}
 
-			msg := stake.NewMsgDelegate(delegatorAddr, validatorAddr, amount)
+			msg := stake.NewMsgDelegate(delAddr, valAddr, amount)
 
 			// build and sign the transaction, then broadcast to Tendermint
 			return utils.SendTx(txCtx, cliCtx, []sdk.Msg{msg})
@@ -195,17 +196,18 @@ func GetCmdBeginRedelegate(storeName string, cdc *wire.Codec) *cobra.Command {
 				WithAccountDecoder(authcmd.GetAccountDecoder(cdc))
 
 			var err error
-			delegatorAddr, err := cliCtx.GetFromAddress()
+
+			delAddr, err := cliCtx.GetFromAddress()
 			if err != nil {
 				return err
 			}
 
-			validatorSrcAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorSrc))
+			valSrcAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidatorSrc))
 			if err != nil {
 				return err
 			}
 
-			validatorDstAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorDst))
+			valDstAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidatorDst))
 			if err != nil {
 				return err
 			}
@@ -215,13 +217,13 @@ func GetCmdBeginRedelegate(storeName string, cdc *wire.Codec) *cobra.Command {
 			sharesPercentStr := viper.GetString(FlagSharesPercent)
 			sharesAmount, err := getShares(
 				storeName, cdc, sharesAmountStr, sharesPercentStr,
-				delegatorAddr, validatorSrcAddr,
+				delAddr, valSrcAddr,
 			)
 			if err != nil {
 				return err
 			}
 
-			msg := stake.NewMsgBeginRedelegate(delegatorAddr, validatorSrcAddr, validatorDstAddr, sharesAmount)
+			msg := stake.NewMsgBeginRedelegate(delAddr, valSrcAddr, valDstAddr, sharesAmount)
 
 			// build and sign the transaction, then broadcast to Tendermint
 			return utils.SendTx(txCtx, cliCtx, []sdk.Msg{msg})
@@ -238,7 +240,7 @@ func GetCmdBeginRedelegate(storeName string, cdc *wire.Codec) *cobra.Command {
 // TODO: Make this pass gocyclo linting
 func getShares(
 	storeName string, cdc *wire.Codec, sharesAmountStr,
-	sharesPercentStr string, delegatorAddr, validatorAddr sdk.AccAddress,
+	sharesPercentStr string, delAddr sdk.AccAddress, valAddr sdk.ValAddress,
 ) (sharesAmount sdk.Dec, err error) {
 	switch {
 	case sharesAmountStr != "" && sharesPercentStr != "":
@@ -264,7 +266,7 @@ func getShares(
 		}
 
 		// make a query to get the existing delegation shares
-		key := stake.GetDelegationKey(delegatorAddr, validatorAddr)
+		key := stake.GetDelegationKey(delAddr, valAddr)
 		cliCtx := context.NewCLIContext().
 			WithCodec(cdc).
 			WithAccountDecoder(authcmd.GetAccountDecoder(cdc))
@@ -294,22 +296,22 @@ func GetCmdCompleteRedelegate(cdc *wire.Codec) *cobra.Command {
 				WithLogger(os.Stdout).
 				WithAccountDecoder(authcmd.GetAccountDecoder(cdc))
 
-			delegatorAddr, err := cliCtx.GetFromAddress()
+			delAddr, err := cliCtx.GetFromAddress()
 			if err != nil {
 				return err
 			}
 
-			validatorSrcAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorSrc))
+			valSrcAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidatorSrc))
 			if err != nil {
 				return err
 			}
 
-			validatorDstAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorDst))
+			valDstAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidatorDst))
 			if err != nil {
 				return err
 			}
 
-			msg := stake.NewMsgCompleteRedelegate(delegatorAddr, validatorSrcAddr, validatorDstAddr)
+			msg := stake.NewMsgCompleteRedelegate(delAddr, valSrcAddr, valDstAddr)
 
 			// build and sign the transaction, then broadcast to Tendermint
 			return utils.SendTx(txCtx, cliCtx, []sdk.Msg{msg})
@@ -349,12 +351,12 @@ func GetCmdBeginUnbonding(storeName string, cdc *wire.Codec) *cobra.Command {
 				WithLogger(os.Stdout).
 				WithAccountDecoder(authcmd.GetAccountDecoder(cdc))
 
-			delegatorAddr, err := cliCtx.GetFromAddress()
+			delAddr, err := cliCtx.GetFromAddress()
 			if err != nil {
 				return err
 			}
 
-			validatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator))
+			valAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidator))
 			if err != nil {
 				return err
 			}
@@ -364,13 +366,13 @@ func GetCmdBeginUnbonding(storeName string, cdc *wire.Codec) *cobra.Command {
 			sharesPercentStr := viper.GetString(FlagSharesPercent)
 			sharesAmount, err := getShares(
 				storeName, cdc, sharesAmountStr, sharesPercentStr,
-				delegatorAddr, validatorAddr,
+				delAddr, valAddr,
 			)
 			if err != nil {
 				return err
 			}
 
-			msg := stake.NewMsgBeginUnbonding(delegatorAddr, validatorAddr, sharesAmount)
+			msg := stake.NewMsgBeginUnbonding(delAddr, valAddr, sharesAmount)
 
 			// build and sign the transaction, then broadcast to Tendermint
 			return utils.SendTx(txCtx, cliCtx, []sdk.Msg{msg})
@@ -395,17 +397,17 @@ func GetCmdCompleteUnbonding(cdc *wire.Codec) *cobra.Command {
 				WithLogger(os.Stdout).
 				WithAccountDecoder(authcmd.GetAccountDecoder(cdc))
 
-			delegatorAddr, err := cliCtx.GetFromAddress()
+			delAddr, err := cliCtx.GetFromAddress()
 			if err != nil {
 				return err
 			}
 
-			validatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator))
+			valAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidator))
 			if err != nil {
 				return err
 			}
 
-			msg := stake.NewMsgCompleteUnbonding(delegatorAddr, validatorAddr)
+			msg := stake.NewMsgCompleteUnbonding(delAddr, valAddr)
 
 			// build and sign the transaction, then broadcast to Tendermint
 			return utils.SendTx(txCtx, cliCtx, []sdk.Msg{msg})
diff --git a/x/stake/client/rest/query.go b/x/stake/client/rest/query.go
index 036a3b451144..c28af71b0e60 100644
--- a/x/stake/client/rest/query.go
+++ b/x/stake/client/rest/query.go
@@ -75,7 +75,7 @@ func registerQueryRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *wire.Cod
 // defines a delegation without type Rat for shares
 type DelegationWithoutRat struct {
 	DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
-	ValidatorAddr sdk.AccAddress `json:"validator_addr"`
+	ValidatorAddr sdk.ValAddress `json:"validator_addr"`
 	Shares        string         `json:"shares"`
 	Height        int64          `json:"height"`
 }
@@ -91,14 +91,14 @@ type DelegationSummary struct {
 func delegatorHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 
-		var validatorAddr sdk.AccAddress
+		var valAddr sdk.ValAddress
 		var delegationSummary = DelegationSummary{}
 
 		// read parameters
 		vars := mux.Vars(r)
 		bech32delegator := vars["delegatorAddr"]
 
-		delegatorAddr, err := sdk.AccAddressFromBech32(bech32delegator)
+		delAddr, err := sdk.AccAddressFromBech32(bech32delegator)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(err.Error()))
@@ -114,10 +114,10 @@ func delegatorHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.Handler
 		}
 
 		for _, validator := range validators {
-			validatorAddr = validator.Operator
+			valAddr = validator.Operator
 
 			// Delegations
-			delegations, statusCode, errMsg, err := getDelegatorDelegations(cliCtx, cdc, delegatorAddr, validatorAddr)
+			delegations, statusCode, errMsg, err := getDelegatorDelegations(cliCtx, cdc, delAddr, valAddr)
 			if err != nil {
 				w.WriteHeader(statusCode)
 				w.Write([]byte(fmt.Sprintf("%s%s", errMsg, err.Error())))
@@ -128,7 +128,7 @@ func delegatorHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.Handler
 			}
 
 			// Undelegations
-			unbondingDelegation, statusCode, errMsg, err := getDelegatorUndelegations(cliCtx, cdc, delegatorAddr, validatorAddr)
+			unbondingDelegation, statusCode, errMsg, err := getDelegatorUndelegations(cliCtx, cdc, delAddr, valAddr)
 			if err != nil {
 				w.WriteHeader(statusCode)
 				w.Write([]byte(fmt.Sprintf("%s%s", errMsg, err.Error())))
@@ -141,7 +141,7 @@ func delegatorHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.Handler
 			// Redelegations
 			// only querying redelegations to a validator as this should give us already all relegations
 			// if we also would put in redelegations from, we would have every redelegation double
-			redelegations, statusCode, errMsg, err := getDelegatorRedelegations(cliCtx, cdc, delegatorAddr, validatorAddr)
+			redelegations, statusCode, errMsg, err := getDelegatorRedelegations(cliCtx, cdc, delAddr, valAddr)
 			if err != nil {
 				w.WriteHeader(statusCode)
 				w.Write([]byte(fmt.Sprintf("%s%s", errMsg, err.Error())))
@@ -247,22 +247,21 @@ func unbondingDelegationsHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) h
 		bech32delegator := vars["delegatorAddr"]
 		bech32validator := vars["validatorAddr"]
 
-		delegatorAddr, err := sdk.AccAddressFromBech32(bech32delegator)
+		delAddr, err := sdk.AccAddressFromBech32(bech32delegator)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(err.Error()))
 			return
 		}
 
-		validatorAddr, err := sdk.AccAddressFromBech32(bech32validator)
+		valAddr, err := sdk.ValAddressFromBech32(bech32validator)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(err.Error()))
 			return
 		}
-		validatorAddrAcc := sdk.AccAddress(validatorAddr)
 
-		key := stake.GetUBDKey(delegatorAddr, validatorAddrAcc)
+		key := stake.GetUBDKey(delAddr, valAddr)
 
 		res, err := cliCtx.QueryStore(key, storeName)
 		if err != nil {
@@ -306,22 +305,21 @@ func delegationHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.Handle
 		bech32delegator := vars["delegatorAddr"]
 		bech32validator := vars["validatorAddr"]
 
-		delegatorAddr, err := sdk.AccAddressFromBech32(bech32delegator)
+		delAddr, err := sdk.AccAddressFromBech32(bech32delegator)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(err.Error()))
 			return
 		}
 
-		validatorAddr, err := sdk.AccAddressFromBech32(bech32validator)
+		valAddr, err := sdk.ValAddressFromBech32(bech32validator)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(err.Error()))
 			return
 		}
-		validatorAddrAcc := sdk.AccAddress(validatorAddr)
 
-		key := stake.GetDelegationKey(delegatorAddr, validatorAddrAcc)
+		key := stake.GetDelegationKey(delAddr, valAddr)
 
 		res, err := cliCtx.QueryStore(key, storeName)
 		if err != nil {
@@ -365,7 +363,7 @@ func delegationHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.Handle
 func delegatorValidatorsHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 
-		var validatorAccAddr sdk.AccAddress
+		var valAddr sdk.ValAddress
 		var bondedValidators []types.BechValidator
 
 		// read parameters
@@ -400,9 +398,9 @@ func delegatorValidatorsHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) ht
 
 		for _, validator := range validators {
 			// get all transactions from the delegator to val and append
-			validatorAccAddr = validator.Operator
+			valAddr = validator.Operator
 
-			validator, statusCode, errMsg, errRes := getDelegatorValidator(cliCtx, cdc, delegatorAddr, validatorAccAddr)
+			validator, statusCode, errMsg, errRes := getDelegatorValidator(cliCtx, cdc, delegatorAddr, valAddr)
 			if errRes != nil {
 				w.WriteHeader(statusCode)
 				w.Write([]byte(fmt.Sprintf("%s%s", errMsg, errRes.Error())))
@@ -432,8 +430,8 @@ func delegatorValidatorHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) htt
 		bech32delegator := vars["delegatorAddr"]
 		bech32validator := vars["validatorAddr"]
 
-		delegatorAddr, err := sdk.AccAddressFromBech32(bech32delegator)
-		validatorAccAddr, err := sdk.AccAddressFromBech32(bech32validator)
+		delAddr, err := sdk.AccAddressFromBech32(bech32delegator)
+		valAddr, err := sdk.ValAddressFromBech32(bech32validator)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(fmt.Sprintf("Error: %s", err.Error())))
@@ -442,7 +440,7 @@ func delegatorValidatorHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) htt
 
 		// Check if there if the delegator is bonded or redelegated to the validator
 
-		validator, statusCode, errMsg, err := getDelegatorValidator(cliCtx, cdc, delegatorAddr, validatorAccAddr)
+		validator, statusCode, errMsg, err := getDelegatorValidator(cliCtx, cdc, delAddr, valAddr)
 		if err != nil {
 			w.WriteHeader(statusCode)
 			w.Write([]byte(fmt.Sprintf("%s%s", errMsg, err.Error())))
@@ -504,14 +502,15 @@ func validatorHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.Handler
 		// read parameters
 		vars := mux.Vars(r)
 		bech32validatorAddr := vars["addr"]
-		valAddress, err := sdk.AccAddressFromBech32(bech32validatorAddr)
+
+		valAddr, err := sdk.ValAddressFromBech32(bech32validatorAddr)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(fmt.Sprintf("error: %s", err.Error())))
 			return
 		}
 
-		key := stake.GetValidatorKey(valAddress)
+		key := stake.GetValidatorKey(valAddr)
 
 		res, err := cliCtx.QueryStore(key, storeName)
 		if err != nil {
@@ -526,7 +525,7 @@ func validatorHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.Handler
 			return
 		}
 
-		validator, err := types.UnmarshalValidator(cdc, valAddress, res)
+		validator, err := types.UnmarshalValidator(cdc, valAddr, res)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(err.Error()))
diff --git a/x/stake/client/rest/tx.go b/x/stake/client/rest/tx.go
index d8b9b6011366..57fa07256b5f 100644
--- a/x/stake/client/rest/tx.go
+++ b/x/stake/client/rest/tx.go
@@ -103,29 +103,29 @@ func delegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx contex
 
 		i := 0
 		for _, msg := range m.Delegations {
-			delegatorAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
+			delAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error())))
 				return
 			}
 
-			validatorAddr, err := sdk.AccAddressFromBech32(msg.ValidatorAddr)
+			valAddr, err := sdk.ValAddressFromBech32(msg.ValidatorAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error())))
 				return
 			}
 
-			if !bytes.Equal(info.GetPubKey().Address(), delegatorAddr) {
+			if !bytes.Equal(info.GetPubKey().Address(), delAddr) {
 				w.WriteHeader(http.StatusUnauthorized)
 				w.Write([]byte("Must use own delegator address"))
 				return
 			}
 
 			messages[i] = stake.MsgDelegate{
-				DelegatorAddr: delegatorAddr,
-				ValidatorAddr: validatorAddr,
+				DelegatorAddr: delAddr,
+				ValidatorAddr: valAddr,
 				Delegation:    msg.Delegation,
 			}
 
@@ -133,26 +133,26 @@ func delegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx contex
 		}
 
 		for _, msg := range m.BeginRedelegates {
-			delegatorAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
+			delAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error())))
 				return
 			}
 
-			if !bytes.Equal(info.GetPubKey().Address(), delegatorAddr) {
+			if !bytes.Equal(info.GetPubKey().Address(), delAddr) {
 				w.WriteHeader(http.StatusUnauthorized)
 				w.Write([]byte("Must use own delegator address"))
 				return
 			}
 
-			validatorSrcAddr, err := sdk.AccAddressFromBech32(msg.ValidatorSrcAddr)
+			valSrcAddr, err := sdk.ValAddressFromBech32(msg.ValidatorSrcAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error())))
 				return
 			}
-			validatorDstAddr, err := sdk.AccAddressFromBech32(msg.ValidatorDstAddr)
+			valDstAddr, err := sdk.ValAddressFromBech32(msg.ValidatorDstAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error())))
@@ -167,9 +167,9 @@ func delegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx contex
 			}
 
 			messages[i] = stake.MsgBeginRedelegate{
-				DelegatorAddr:    delegatorAddr,
-				ValidatorSrcAddr: validatorSrcAddr,
-				ValidatorDstAddr: validatorDstAddr,
+				DelegatorAddr:    delAddr,
+				ValidatorSrcAddr: valSrcAddr,
+				ValidatorDstAddr: valDstAddr,
 				SharesAmount:     shares,
 			}
 
@@ -177,56 +177,57 @@ func delegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx contex
 		}
 
 		for _, msg := range m.CompleteRedelegates {
-			delegatorAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
+			delAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error())))
 				return
 			}
 
-			validatorSrcAddr, err := sdk.AccAddressFromBech32(msg.ValidatorSrcAddr)
+			valSrcAddr, err := sdk.ValAddressFromBech32(msg.ValidatorSrcAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error())))
 				return
 			}
-			validatorDstAddr, err := sdk.AccAddressFromBech32(msg.ValidatorDstAddr)
+
+			valDstAddr, err := sdk.ValAddressFromBech32(msg.ValidatorDstAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error())))
 				return
 			}
 
-			if !bytes.Equal(info.GetPubKey().Address(), delegatorAddr) {
+			if !bytes.Equal(info.GetPubKey().Address(), delAddr) {
 				w.WriteHeader(http.StatusUnauthorized)
 				w.Write([]byte("Must use own delegator address"))
 				return
 			}
 
 			messages[i] = stake.MsgCompleteRedelegate{
-				DelegatorAddr:    delegatorAddr,
-				ValidatorSrcAddr: validatorSrcAddr,
-				ValidatorDstAddr: validatorDstAddr,
+				DelegatorAddr:    delAddr,
+				ValidatorSrcAddr: valSrcAddr,
+				ValidatorDstAddr: valDstAddr,
 			}
 
 			i++
 		}
 
 		for _, msg := range m.BeginUnbondings {
-			delegatorAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
+			delAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error())))
 				return
 			}
 
-			if !bytes.Equal(info.GetPubKey().Address(), delegatorAddr) {
+			if !bytes.Equal(info.GetPubKey().Address(), delAddr) {
 				w.WriteHeader(http.StatusUnauthorized)
 				w.Write([]byte("Must use own delegator address"))
 				return
 			}
 
-			validatorAddr, err := sdk.AccAddressFromBech32(msg.ValidatorAddr)
+			valAddr, err := sdk.ValAddressFromBech32(msg.ValidatorAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error())))
@@ -241,8 +242,8 @@ func delegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx contex
 			}
 
 			messages[i] = stake.MsgBeginUnbonding{
-				DelegatorAddr: delegatorAddr,
-				ValidatorAddr: validatorAddr,
+				DelegatorAddr: delAddr,
+				ValidatorAddr: valAddr,
 				SharesAmount:  shares,
 			}
 
@@ -250,29 +251,29 @@ func delegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx contex
 		}
 
 		for _, msg := range m.CompleteUnbondings {
-			delegatorAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
+			delAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error())))
 				return
 			}
 
-			validatorAddr, err := sdk.AccAddressFromBech32(msg.ValidatorAddr)
+			valAddr, err := sdk.ValAddressFromBech32(msg.ValidatorAddr)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error())))
 				return
 			}
 
-			if !bytes.Equal(info.GetPubKey().Address(), delegatorAddr) {
+			if !bytes.Equal(info.GetPubKey().Address(), delAddr) {
 				w.WriteHeader(http.StatusUnauthorized)
 				w.Write([]byte("Must use own delegator address"))
 				return
 			}
 
 			messages[i] = stake.MsgCompleteUnbonding{
-				DelegatorAddr: delegatorAddr,
-				ValidatorAddr: validatorAddr,
+				DelegatorAddr: delAddr,
+				ValidatorAddr: valAddr,
 			}
 
 			i++
diff --git a/x/stake/client/rest/utils.go b/x/stake/client/rest/utils.go
index 96588f73b51b..171ded2b35f1 100644
--- a/x/stake/client/rest/utils.go
+++ b/x/stake/client/rest/utils.go
@@ -24,10 +24,10 @@ func contains(stringSlice []string, txType string) bool {
 	return false
 }
 
-func getDelegatorValidator(cliCtx context.CLIContext, cdc *wire.Codec, delegatorAddr sdk.AccAddress, validatorAddr sdk.AccAddress) (
+func getDelegatorValidator(cliCtx context.CLIContext, cdc *wire.Codec, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (
 	bech32Validator types.BechValidator, httpStatusCode int, errMsg string, err error) {
 
-	key := stake.GetDelegationKey(delegatorAddr, validatorAddr)
+	key := stake.GetDelegationKey(delAddr, valAddr)
 	res, err := cliCtx.QueryStore(key, storeName)
 	if err != nil {
 		return types.BechValidator{}, http.StatusInternalServerError, "couldn't query delegation. Error: ", err
@@ -36,7 +36,7 @@ func getDelegatorValidator(cliCtx context.CLIContext, cdc *wire.Codec, delegator
 		return types.BechValidator{}, http.StatusNoContent, "", nil
 	}
 
-	key = stake.GetValidatorKey(validatorAddr)
+	key = stake.GetValidatorKey(valAddr)
 	res, err = cliCtx.QueryStore(key, storeName)
 	if err != nil {
 		return types.BechValidator{}, http.StatusInternalServerError, "couldn't query validator. Error: ", err
@@ -44,7 +44,7 @@ func getDelegatorValidator(cliCtx context.CLIContext, cdc *wire.Codec, delegator
 	if len(res) == 0 {
 		return types.BechValidator{}, http.StatusNoContent, "", nil
 	}
-	validator, err := types.UnmarshalValidator(cdc, validatorAddr, res)
+	validator, err := types.UnmarshalValidator(cdc, valAddr, res)
 	if err != nil {
 		return types.BechValidator{}, http.StatusBadRequest, "", err
 	}
@@ -56,9 +56,11 @@ func getDelegatorValidator(cliCtx context.CLIContext, cdc *wire.Codec, delegator
 	return bech32Validator, http.StatusOK, "", nil
 }
 
-func getDelegatorDelegations(cliCtx context.CLIContext, cdc *wire.Codec, delegatorAddr sdk.AccAddress, validatorAddr sdk.AccAddress) (
+func getDelegatorDelegations(
+	cliCtx context.CLIContext, cdc *wire.Codec, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (
 	outputDelegation DelegationWithoutRat, httpStatusCode int, errMsg string, err error) {
-	delegationKey := stake.GetDelegationKey(delegatorAddr, validatorAddr)
+
+	delegationKey := stake.GetDelegationKey(delAddr, valAddr)
 	marshalledDelegation, err := cliCtx.QueryStore(delegationKey, storeName)
 	if err != nil {
 		return DelegationWithoutRat{}, http.StatusInternalServerError, "couldn't query delegation. Error: ", err
@@ -83,9 +85,11 @@ func getDelegatorDelegations(cliCtx context.CLIContext, cdc *wire.Codec, delegat
 	return outputDelegation, http.StatusOK, "", nil
 }
 
-func getDelegatorUndelegations(cliCtx context.CLIContext, cdc *wire.Codec, delegatorAddr sdk.AccAddress, validatorAddr sdk.AccAddress) (
+func getDelegatorUndelegations(
+	cliCtx context.CLIContext, cdc *wire.Codec, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (
 	unbonds types.UnbondingDelegation, httpStatusCode int, errMsg string, err error) {
-	undelegationKey := stake.GetUBDKey(delegatorAddr, validatorAddr)
+
+	undelegationKey := stake.GetUBDKey(delAddr, valAddr)
 	marshalledUnbondingDelegation, err := cliCtx.QueryStore(undelegationKey, storeName)
 	if err != nil {
 		return types.UnbondingDelegation{}, http.StatusInternalServerError, "couldn't query unbonding-delegation. Error: ", err
@@ -102,10 +106,11 @@ func getDelegatorUndelegations(cliCtx context.CLIContext, cdc *wire.Codec, deleg
 	return unbondingDelegation, http.StatusOK, "", nil
 }
 
-func getDelegatorRedelegations(cliCtx context.CLIContext, cdc *wire.Codec, delegatorAddr sdk.AccAddress, validatorAddr sdk.AccAddress) (
+func getDelegatorRedelegations(
+	cliCtx context.CLIContext, cdc *wire.Codec, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (
 	regelegations types.Redelegation, httpStatusCode int, errMsg string, err error) {
 
-	key := stake.GetREDsByDelToValDstIndexKey(delegatorAddr, validatorAddr)
+	key := stake.GetREDsByDelToValDstIndexKey(delAddr, valAddr)
 	marshalledRedelegations, err := cliCtx.QueryStore(key, storeName)
 	if err != nil {
 		return types.Redelegation{}, http.StatusInternalServerError, "couldn't query redelegation. Error: ", err
diff --git a/x/stake/genesis_test.go b/x/stake/genesis_test.go
index 9cdbe19826bc..ddd29f6f8498 100644
--- a/x/stake/genesis_test.go
+++ b/x/stake/genesis_test.go
@@ -23,8 +23,8 @@ func TestInitGenesis(t *testing.T) {
 	var delegations []Delegation
 
 	validators := []Validator{
-		NewValidator(keep.Addrs[0], keep.PKs[0], Description{Moniker: "hoop"}),
-		NewValidator(keep.Addrs[1], keep.PKs[1], Description{Moniker: "bloop"}),
+		NewValidator(sdk.ValAddress(keep.Addrs[0]), keep.PKs[0], Description{Moniker: "hoop"}),
+		NewValidator(sdk.ValAddress(keep.Addrs[1]), keep.PKs[1], Description{Moniker: "bloop"}),
 	}
 	genesisState := types.NewGenesisState(pool, params, validators, delegations)
 	_, err := InitGenesis(ctx, keeper, genesisState)
@@ -43,12 +43,12 @@ func TestInitGenesis(t *testing.T) {
 	require.NoError(t, err)
 
 	// now make sure the validators are bonded and intra-tx counters are correct
-	resVal, found := keeper.GetValidator(ctx, keep.Addrs[0])
+	resVal, found := keeper.GetValidator(ctx, sdk.ValAddress(keep.Addrs[0]))
 	require.True(t, found)
 	require.Equal(t, sdk.Bonded, resVal.Status)
 	require.Equal(t, int16(0), resVal.BondIntraTxCounter)
 
-	resVal, found = keeper.GetValidator(ctx, keep.Addrs[1])
+	resVal, found = keeper.GetValidator(ctx, sdk.ValAddress(keep.Addrs[1]))
 	require.True(t, found)
 	require.Equal(t, sdk.Bonded, resVal.Status)
 	require.Equal(t, int16(1), resVal.BondIntraTxCounter)
@@ -76,7 +76,7 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
 	validators := make([]Validator, size)
 
 	for i := range validators {
-		validators[i] = NewValidator(keep.Addrs[i], keep.PKs[i], Description{Moniker: fmt.Sprintf("#%d", i)})
+		validators[i] = NewValidator(sdk.ValAddress(keep.Addrs[i]), keep.PKs[i], Description{Moniker: fmt.Sprintf("#%d", i)})
 
 		validators[i].Status = sdk.Bonded
 		if i < 100 {
diff --git a/x/stake/handler_test.go b/x/stake/handler_test.go
index 9ff72090e114..98f00bd0576f 100644
--- a/x/stake/handler_test.go
+++ b/x/stake/handler_test.go
@@ -16,23 +16,23 @@ import (
 
 //______________________________________________________________________
 
-func newTestMsgCreateValidator(address sdk.AccAddress, pubKey crypto.PubKey, amt int64) MsgCreateValidator {
+func newTestMsgCreateValidator(address sdk.ValAddress, pubKey crypto.PubKey, amt int64) MsgCreateValidator {
 	return types.NewMsgCreateValidator(address, pubKey, sdk.Coin{"steak", sdk.NewInt(amt)}, Description{})
 }
 
-func newTestMsgDelegate(delegatorAddr, validatorAddr sdk.AccAddress, amt int64) MsgDelegate {
+func newTestMsgDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt int64) MsgDelegate {
 	return MsgDelegate{
-		DelegatorAddr: delegatorAddr,
-		ValidatorAddr: validatorAddr,
+		DelegatorAddr: delAddr,
+		ValidatorAddr: valAddr,
 		Delegation:    sdk.Coin{"steak", sdk.NewInt(amt)},
 	}
 }
 
-func newTestMsgCreateValidatorOnBehalfOf(delegatorAddr, validatorAddr sdk.AccAddress, valPubKey crypto.PubKey, amt int64) MsgCreateValidator {
+func newTestMsgCreateValidatorOnBehalfOf(delAddr sdk.AccAddress, valAddr sdk.ValAddress, valPubKey crypto.PubKey, amt int64) MsgCreateValidator {
 	return MsgCreateValidator{
 		Description:   Description{},
-		DelegatorAddr: delegatorAddr,
-		ValidatorAddr: validatorAddr,
+		DelegatorAddr: delAddr,
+		ValidatorAddr: valAddr,
 		PubKey:        valPubKey,
 		Delegation:    sdk.Coin{"steak", sdk.NewInt(amt)},
 	}
@@ -49,7 +49,7 @@ func setInstantUnbondPeriod(keeper keep.Keeper, ctx sdk.Context) types.Params {
 //______________________________________________________________________
 
 func TestValidatorByPowerIndex(t *testing.T) {
-	validatorAddr, validatorAddr3 := keep.Addrs[0], keep.Addrs[1]
+	validatorAddr, validatorAddr3 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1])
 
 	initBond := int64(1000000)
 	ctx, _, keeper := keep.CreateTestInput(t, false, initBond)
@@ -61,7 +61,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	require.True(t, got.IsOK(), "expected create-validator to be ok, got %v", got)
 
 	// verify the self-delegation exists
-	bond, found := keeper.GetDelegation(ctx, validatorAddr, validatorAddr)
+	bond, found := keeper.GetDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
 	require.True(t, found)
 	gotBond := bond.Shares.RoundInt64()
 	require.Equal(t, initBond, gotBond,
@@ -110,8 +110,8 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	require.Equal(t, power2, power3)
 
 	// unbond self-delegation
-	msgBeginUnbonding := NewMsgBeginUnbonding(validatorAddr, validatorAddr, sdk.NewDec(1000000))
-	msgCompleteUnbonding := NewMsgCompleteUnbonding(validatorAddr, validatorAddr)
+	msgBeginUnbonding := NewMsgBeginUnbonding(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(1000000))
+	msgCompleteUnbonding := NewMsgCompleteUnbonding(sdk.AccAddress(validatorAddr), validatorAddr)
 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 	require.True(t, got.IsOK(), "expected msg to be ok, got %v", got)
 	got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbonding, keeper)
@@ -126,7 +126,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
 func TestDuplicatesMsgCreateValidator(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
 
-	addr1, addr2 := keep.Addrs[0], keep.Addrs[1]
+	addr1, addr2 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1])
 	pk1, pk2 := keep.PKs[0], keep.PKs[1]
 
 	msgCreateValidator1 := newTestMsgCreateValidator(addr1, pk1, 10)
@@ -170,7 +170,7 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) {
 func TestDuplicatesMsgCreateValidatorOnBehalfOf(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
 
-	validatorAddr := keep.Addrs[0]
+	validatorAddr := sdk.ValAddress(keep.Addrs[0])
 	delegatorAddr := keep.Addrs[1]
 	pk := keep.PKs[0]
 	msgCreateValidatorOnBehalfOf := newTestMsgCreateValidatorOnBehalfOf(delegatorAddr, validatorAddr, pk, 10)
@@ -199,7 +199,7 @@ func TestIncrementsMsgDelegate(t *testing.T) {
 	params := keeper.GetParams(ctx)
 
 	bondAmount := int64(10)
-	validatorAddr, delegatorAddr := keep.Addrs[0], keep.Addrs[1]
+	validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1]
 
 	// first create validator
 	msgCreateValidator := newTestMsgCreateValidator(validatorAddr, keep.PKs[0], bondAmount)
@@ -215,7 +215,7 @@ func TestIncrementsMsgDelegate(t *testing.T) {
 	_, found = keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
 	require.False(t, found)
 
-	bond, found := keeper.GetDelegation(ctx, validatorAddr, validatorAddr)
+	bond, found := keeper.GetDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
 	require.True(t, found)
 	require.Equal(t, bondAmount, bond.Shares.RoundInt64())
 
@@ -271,7 +271,7 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 	denom := params.BondDenom
 
 	// create validator, delegate
-	validatorAddr, delegatorAddr := keep.Addrs[0], keep.Addrs[1]
+	validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1]
 
 	msgCreateValidator := newTestMsgCreateValidator(validatorAddr, keep.PKs[0], initBond)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
@@ -367,7 +367,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
 	ctx, accMapper, keeper := keep.CreateTestInput(t, false, initBond)
 	params := setInstantUnbondPeriod(keeper, ctx)
 
-	validatorAddrs := []sdk.AccAddress{keep.Addrs[0], keep.Addrs[1], keep.Addrs[2]}
+	validatorAddrs := []sdk.ValAddress{sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1]), sdk.ValAddress(keep.Addrs[2])}
 	delegatorAddrs := []sdk.AccAddress{keep.Addrs[3], keep.Addrs[4], keep.Addrs[5]}
 
 	// bond them all
@@ -414,7 +414,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
 
 func TestMultipleMsgDelegate(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
-	validatorAddr, delegatorAddrs := keep.Addrs[0], keep.Addrs[1:]
+	validatorAddr, delegatorAddrs := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1:]
 	_ = setInstantUnbondPeriod(keeper, ctx)
 
 	//first make a validator
@@ -451,7 +451,7 @@ func TestMultipleMsgDelegate(t *testing.T) {
 
 func TestRevokeValidator(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
-	validatorAddr, delegatorAddr := keep.Addrs[0], keep.Addrs[1]
+	validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1]
 	_ = setInstantUnbondPeriod(keeper, ctx)
 
 	// create the validator
@@ -467,8 +467,8 @@ func TestRevokeValidator(t *testing.T) {
 	validator, _ := keeper.GetValidator(ctx, validatorAddr)
 
 	// unbond the validators bond portion
-	msgBeginUnbondingValidator := NewMsgBeginUnbonding(validatorAddr, validatorAddr, sdk.NewDec(10))
-	msgCompleteUnbondingValidator := NewMsgCompleteUnbonding(validatorAddr, validatorAddr)
+	msgBeginUnbondingValidator := NewMsgBeginUnbonding(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
+	msgCompleteUnbondingValidator := NewMsgCompleteUnbonding(sdk.AccAddress(validatorAddr), validatorAddr)
 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbondingValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error")
 	got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbondingValidator, keeper)
@@ -497,7 +497,7 @@ func TestRevokeValidator(t *testing.T) {
 
 func TestUnbondingPeriod(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
-	validatorAddr := keep.Addrs[0]
+	validatorAddr := sdk.ValAddress(keep.Addrs[0])
 
 	// set the unbonding time
 	params := keeper.GetParams(ctx)
@@ -510,12 +510,12 @@ func TestUnbondingPeriod(t *testing.T) {
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
 	// begin unbonding
-	msgBeginUnbonding := NewMsgBeginUnbonding(validatorAddr, validatorAddr, sdk.NewDec(10))
+	msgBeginUnbonding := NewMsgBeginUnbonding(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 	require.True(t, got.IsOK(), "expected no error")
 
 	// cannot complete unbonding at same time
-	msgCompleteUnbonding := NewMsgCompleteUnbonding(validatorAddr, validatorAddr)
+	msgCompleteUnbonding := NewMsgCompleteUnbonding(sdk.AccAddress(validatorAddr), validatorAddr)
 	got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbonding, keeper)
 	require.True(t, !got.IsOK(), "expected an error")
 
@@ -537,7 +537,7 @@ func TestUnbondingPeriod(t *testing.T) {
 
 func TestRedelegationPeriod(t *testing.T) {
 	ctx, AccMapper, keeper := keep.CreateTestInput(t, false, 1000)
-	validatorAddr, validatorAddr2 := keep.Addrs[0], keep.Addrs[1]
+	validatorAddr, validatorAddr2 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1])
 	denom := keeper.GetParams(ctx).BondDenom
 
 	// set the unbonding time
@@ -549,32 +549,32 @@ func TestRedelegationPeriod(t *testing.T) {
 	msgCreateValidator := newTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
 
 	// initial balance
-	amt1 := AccMapper.GetAccount(ctx, validatorAddr).GetCoins().AmountOf(denom)
+	amt1 := AccMapper.GetAccount(ctx, sdk.AccAddress(validatorAddr)).GetCoins().AmountOf(denom)
 
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
 	// balance should have been subtracted after creation
-	amt2 := AccMapper.GetAccount(ctx, validatorAddr).GetCoins().AmountOf(denom)
+	amt2 := AccMapper.GetAccount(ctx, sdk.AccAddress(validatorAddr)).GetCoins().AmountOf(denom)
 	require.Equal(t, amt1.Sub(sdk.NewInt(10)).Int64(), amt2.Int64(), "expected coins to be subtracted")
 
 	msgCreateValidator = newTestMsgCreateValidator(validatorAddr2, keep.PKs[1], 10)
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
-	bal1 := AccMapper.GetAccount(ctx, validatorAddr).GetCoins()
+	bal1 := AccMapper.GetAccount(ctx, sdk.AccAddress(validatorAddr)).GetCoins()
 
 	// begin redelegate
-	msgBeginRedelegate := NewMsgBeginRedelegate(validatorAddr, validatorAddr, validatorAddr2, sdk.NewDec(10))
+	msgBeginRedelegate := NewMsgBeginRedelegate(sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2, sdk.NewDec(10))
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
 	// origin account should not lose tokens as with a regular delegation
-	bal2 := AccMapper.GetAccount(ctx, validatorAddr).GetCoins()
+	bal2 := AccMapper.GetAccount(ctx, sdk.AccAddress(validatorAddr)).GetCoins()
 	require.Equal(t, bal1, bal2)
 
 	// cannot complete redelegation at same time
-	msgCompleteRedelegate := NewMsgCompleteRedelegate(validatorAddr, validatorAddr, validatorAddr2)
+	msgCompleteRedelegate := NewMsgCompleteRedelegate(sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2)
 	got = handleMsgCompleteRedelegate(ctx, msgCompleteRedelegate, keeper)
 	require.True(t, !got.IsOK(), "expected an error")
 
@@ -596,7 +596,9 @@ func TestRedelegationPeriod(t *testing.T) {
 
 func TestTransitiveRedelegation(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
-	validatorAddr, validatorAddr2, validatorAddr3 := keep.Addrs[0], keep.Addrs[1], keep.Addrs[2]
+	validatorAddr := sdk.ValAddress(keep.Addrs[0])
+	validatorAddr2 := sdk.ValAddress(keep.Addrs[1])
+	validatorAddr3 := sdk.ValAddress(keep.Addrs[2])
 
 	// set the unbonding time
 	params := keeper.GetParams(ctx)
@@ -617,17 +619,17 @@ func TestTransitiveRedelegation(t *testing.T) {
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
 	// begin redelegate
-	msgBeginRedelegate := NewMsgBeginRedelegate(validatorAddr, validatorAddr, validatorAddr2, sdk.NewDec(10))
+	msgBeginRedelegate := NewMsgBeginRedelegate(sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2, sdk.NewDec(10))
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
 	// cannot redelegation to next validator while first delegation exists
-	msgBeginRedelegate = NewMsgBeginRedelegate(validatorAddr, validatorAddr2, validatorAddr3, sdk.NewDec(10))
+	msgBeginRedelegate = NewMsgBeginRedelegate(sdk.AccAddress(validatorAddr), validatorAddr2, validatorAddr3, sdk.NewDec(10))
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, !got.IsOK(), "expected an error, msg: %v", msgBeginRedelegate)
 
 	// complete first redelegation
-	msgCompleteRedelegate := NewMsgCompleteRedelegate(validatorAddr, validatorAddr, validatorAddr2)
+	msgCompleteRedelegate := NewMsgCompleteRedelegate(sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2)
 	got = handleMsgCompleteRedelegate(ctx, msgCompleteRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error")
 
@@ -638,7 +640,9 @@ func TestTransitiveRedelegation(t *testing.T) {
 
 func TestUnbondingWhenExcessValidators(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
-	validatorAddr1, validatorAddr2, validatorAddr3 := keep.Addrs[0], keep.Addrs[1], keep.Addrs[2]
+	validatorAddr1 := sdk.ValAddress(keep.Addrs[0])
+	validatorAddr2 := sdk.ValAddress(keep.Addrs[1])
+	validatorAddr3 := sdk.ValAddress(keep.Addrs[2])
 
 	// set the unbonding time
 	params := keeper.GetParams(ctx)
@@ -663,7 +667,7 @@ func TestUnbondingWhenExcessValidators(t *testing.T) {
 	require.Equal(t, 2, len(keeper.GetValidatorsBonded(ctx)))
 
 	// unbond the valdator-2
-	msgBeginUnbonding := NewMsgBeginUnbonding(validatorAddr2, validatorAddr2, sdk.NewDec(30))
+	msgBeginUnbonding := NewMsgBeginUnbonding(sdk.AccAddress(validatorAddr2), validatorAddr2, sdk.NewDec(30))
 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgBeginUnbonding")
 
@@ -679,7 +683,7 @@ func TestUnbondingWhenExcessValidators(t *testing.T) {
 
 func TestJoiningAsCliffValidator(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
-	validatorAddr1, validatorAddr2 := keep.Addrs[0], keep.Addrs[1]
+	validatorAddr1, validatorAddr2 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1])
 
 	// make sure that the cliff validator is nil to begin with
 	cliffVal := keeper.GetCliffValidator(ctx)
@@ -712,7 +716,7 @@ func TestJoiningAsCliffValidator(t *testing.T) {
 
 func TestJoiningToCreateFirstCliffValidator(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
-	validatorAddr1, validatorAddr2 := keep.Addrs[0], keep.Addrs[1]
+	validatorAddr1, validatorAddr2 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1])
 
 	// make sure that the cliff validator is nil to begin with
 	cliffVal := keeper.GetCliffValidator(ctx)
@@ -745,7 +749,9 @@ func TestJoiningToCreateFirstCliffValidator(t *testing.T) {
 
 func TestCliffValidator(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
-	validatorAddr1, validatorAddr2, validatorAddr3 := keep.Addrs[0], keep.Addrs[1], keep.Addrs[2]
+	validatorAddr1 := sdk.ValAddress(keep.Addrs[0])
+	validatorAddr2 := sdk.ValAddress(keep.Addrs[1])
+	validatorAddr3 := sdk.ValAddress(keep.Addrs[2])
 
 	// make sure that the cliff validator is nil to begin with
 	cliffVal := keeper.GetCliffValidator(ctx)
@@ -785,7 +791,7 @@ func TestCliffValidator(t *testing.T) {
 	require.Equal(t, validatorAddr2.Bytes(), cliffVal)
 
 	// unbond valdator-2
-	msgBeginUnbonding := NewMsgBeginUnbonding(validatorAddr2, validatorAddr2, sdk.NewDec(30))
+	msgBeginUnbonding := NewMsgBeginUnbonding(sdk.AccAddress(validatorAddr2), validatorAddr2, sdk.NewDec(30))
 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgBeginUnbonding")
 
@@ -798,7 +804,7 @@ func TestCliffValidator(t *testing.T) {
 	require.Equal(t, validatorAddr3.Bytes(), cliffVal)
 
 	// unbond valdator-1
-	msgBeginUnbonding = NewMsgBeginUnbonding(validatorAddr1, validatorAddr1, sdk.NewDec(50))
+	msgBeginUnbonding = NewMsgBeginUnbonding(sdk.AccAddress(validatorAddr1), validatorAddr1, sdk.NewDec(50))
 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgBeginUnbonding")
 
@@ -813,7 +819,7 @@ func TestCliffValidator(t *testing.T) {
 
 func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
-	valA, valB, del := keep.Addrs[0], keep.Addrs[1], keep.Addrs[2]
+	valA, valB, del := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1]), keep.Addrs[2]
 
 	msgCreateValidator := newTestMsgCreateValidator(valA, keep.PKs[0], 10)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
diff --git a/x/stake/keeper/delegation.go b/x/stake/keeper/delegation.go
index e472c346b05b..9725e55fabf9 100644
--- a/x/stake/keeper/delegation.go
+++ b/x/stake/keeper/delegation.go
@@ -8,13 +8,12 @@ import (
 )
 
 // load a delegation
-func (k Keeper) GetDelegation(
-	ctx sdk.Context,
-	delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress) (
+func (k Keeper) GetDelegation(ctx sdk.Context,
+	delAddr sdk.AccAddress, valAddr sdk.ValAddress) (
 	delegation types.Delegation, found bool) {
 
 	store := ctx.KVStore(k.storeKey)
-	key := GetDelegationKey(delegatorAddr, validatorAddr)
+	key := GetDelegationKey(delAddr, valAddr)
 	value := store.Get(key)
 	if value == nil {
 		return delegation, false
@@ -81,10 +80,10 @@ func (k Keeper) RemoveDelegation(ctx sdk.Context, delegation types.Delegation) {
 
 // load a unbonding delegation
 func (k Keeper) GetUnbondingDelegation(ctx sdk.Context,
-	DelegatorAddr sdk.AccAddress, ValidatorAddr sdk.ValAddress) (ubd types.UnbondingDelegation, found bool) {
+	delAddr sdk.AccAddress, valAddr sdk.ValAddress) (ubd types.UnbondingDelegation, found bool) {
 
 	store := ctx.KVStore(k.storeKey)
-	key := GetUBDKey(DelegatorAddr, ValidatorAddr)
+	key := GetUBDKey(delAddr, valAddr)
 	value := store.Get(key)
 	if value == nil {
 		return ubd, false
@@ -149,10 +148,10 @@ func (k Keeper) RemoveUnbondingDelegation(ctx sdk.Context, ubd types.UnbondingDe
 
 // load a redelegation
 func (k Keeper) GetRedelegation(ctx sdk.Context,
-	DelegatorAddr, ValidatorSrcAddr, ValidatorDstAddr sdk.AccAddress) (red types.Redelegation, found bool) {
+	delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) (red types.Redelegation, found bool) {
 
 	store := ctx.KVStore(k.storeKey)
-	key := GetREDKey(DelegatorAddr, ValidatorSrcAddr, ValidatorDstAddr)
+	key := GetREDKey(delAddr, valSrcAddr, valDstAddr)
 	value := store.Get(key)
 	if value == nil {
 		return red, false
@@ -163,7 +162,7 @@ func (k Keeper) GetRedelegation(ctx sdk.Context,
 }
 
 // load all redelegations from a particular validator
-func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.AccAddress) (reds []types.Redelegation) {
+func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.ValAddress) (reds []types.Redelegation) {
 	store := ctx.KVStore(k.storeKey)
 	iterator := sdk.KVStorePrefixIterator(store, GetREDsFromValSrcIndexKey(valAddr))
 	for {
@@ -182,10 +181,10 @@ func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.AccAd
 
 // has a redelegation
 func (k Keeper) HasReceivingRedelegation(ctx sdk.Context,
-	DelegatorAddr, ValidatorDstAddr sdk.AccAddress) bool {
+	delAddr sdk.AccAddress, valDstAddr sdk.ValAddress) bool {
 
 	store := ctx.KVStore(k.storeKey)
-	prefix := GetREDsByDelToValDstIndexKey(DelegatorAddr, ValidatorDstAddr)
+	prefix := GetREDsByDelToValDstIndexKey(delAddr, valDstAddr)
 	iterator := sdk.KVStorePrefixIterator(store, prefix) //smallest to largest
 
 	found := false
@@ -219,14 +218,14 @@ func (k Keeper) RemoveRedelegation(ctx sdk.Context, red types.Redelegation) {
 //_____________________________________________________________________________________
 
 // Perform a delegation, set/update everything necessary within the store.
-func (k Keeper) Delegate(ctx sdk.Context, delegatorAddr sdk.AccAddress, bondAmt sdk.Coin,
+func (k Keeper) Delegate(ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Coin,
 	validator types.Validator, subtractAccount bool) (newShares sdk.Dec, err sdk.Error) {
 
 	// Get or create the delegator delegation
-	delegation, found := k.GetDelegation(ctx, delegatorAddr, validator.Operator)
+	delegation, found := k.GetDelegation(ctx, delAddr, validator.Operator)
 	if !found {
 		delegation = types.Delegation{
-			DelegatorAddr: delegatorAddr,
+			DelegatorAddr: delAddr,
 			ValidatorAddr: validator.Operator,
 			Shares:        sdk.ZeroDec(),
 		}
@@ -255,11 +254,11 @@ func (k Keeper) Delegate(ctx sdk.Context, delegatorAddr sdk.AccAddress, bondAmt
 }
 
 // unbond the the delegation return
-func (k Keeper) unbond(ctx sdk.Context, delegatorAddr, validatorAddr sdk.ValAddress,
+func (k Keeper) unbond(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress,
 	shares sdk.Dec) (amount sdk.Dec, err sdk.Error) {
 
 	// check if delegation has any shares in it unbond
-	delegation, found := k.GetDelegation(ctx, delegatorAddr, validatorAddr)
+	delegation, found := k.GetDelegation(ctx, delAddr, valAddr)
 	if !found {
 		err = types.ErrNoDelegatorForAddress(k.Codespace())
 		return
@@ -272,7 +271,7 @@ func (k Keeper) unbond(ctx sdk.Context, delegatorAddr, validatorAddr sdk.ValAddr
 	}
 
 	// get validator
-	validator, found := k.GetValidator(ctx, validatorAddr)
+	validator, found := k.GetValidator(ctx, valAddr)
 	if !found {
 		err = types.ErrNoValidatorFound(k.Codespace())
 		return
@@ -314,15 +313,16 @@ func (k Keeper) unbond(ctx sdk.Context, delegatorAddr, validatorAddr sdk.ValAddr
 //______________________________________________________________________________________________________
 
 // complete unbonding an unbonding record
-func (k Keeper) BeginUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr sdk.ValAddress, sharesAmount sdk.Dec) sdk.Error {
+func (k Keeper) BeginUnbonding(ctx sdk.Context,
+	delAddr sdk.AccAddress, valAddr sdk.ValAddress, sharesAmount sdk.Dec) sdk.Error {
 
 	// TODO quick fix, instead we should use an index, see https://github.com/cosmos/cosmos-sdk/issues/1402
-	_, found := k.GetUnbondingDelegation(ctx, delegatorAddr, validatorAddr)
+	_, found := k.GetUnbondingDelegation(ctx, delAddr, valAddr)
 	if found {
 		return types.ErrExistingUnbondingDelegation(k.Codespace())
 	}
 
-	returnAmount, err := k.unbond(ctx, delegatorAddr, validatorAddr, sharesAmount)
+	returnAmount, err := k.unbond(ctx, delAddr, valAddr, sharesAmount)
 	if err != nil {
 		return err
 	}
@@ -333,8 +333,8 @@ func (k Keeper) BeginUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr sdk
 	balance := sdk.Coin{params.BondDenom, returnAmount.RoundInt()}
 
 	ubd := types.UnbondingDelegation{
-		DelegatorAddr:  delegatorAddr,
-		ValidatorAddr:  validatorAddr,
+		DelegatorAddr:  delAddr,
+		ValidatorAddr:  valAddr,
 		MinTime:        minTime,
 		Balance:        balance,
 		InitialBalance: balance,
@@ -344,9 +344,9 @@ func (k Keeper) BeginUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr sdk
 }
 
 // complete unbonding an unbonding record
-func (k Keeper) CompleteUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr sdk.AccAddress) sdk.Error {
+func (k Keeper) CompleteUnbonding(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) sdk.Error {
 
-	ubd, found := k.GetUnbondingDelegation(ctx, delegatorAddr, validatorAddr)
+	ubd, found := k.GetUnbondingDelegation(ctx, delAddr, valAddr)
 	if !found {
 		return types.ErrNoUnbondingDelegation(k.Codespace())
 	}
@@ -366,26 +366,26 @@ func (k Keeper) CompleteUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr
 }
 
 // complete unbonding an unbonding record
-func (k Keeper) BeginRedelegation(ctx sdk.Context, delegatorAddr sdk.AccAddress,
-	validatorSrcAddr, validatorDstAddr sdk.ValAddress, sharesAmount sdk.Dec) sdk.Error {
+func (k Keeper) BeginRedelegation(ctx sdk.Context, delAddr sdk.AccAddress,
+	valSrcAddr, valDstAddr sdk.ValAddress, sharesAmount sdk.Dec) sdk.Error {
 
 	// check if this is a transitive redelegation
-	if k.HasReceivingRedelegation(ctx, delegatorAddr, validatorSrcAddr) {
+	if k.HasReceivingRedelegation(ctx, delAddr, valSrcAddr) {
 		return types.ErrTransitiveRedelegation(k.Codespace())
 	}
 
-	returnAmount, err := k.unbond(ctx, delegatorAddr, validatorSrcAddr, sharesAmount)
+	returnAmount, err := k.unbond(ctx, delAddr, valSrcAddr, sharesAmount)
 	if err != nil {
 		return err
 	}
 
 	params := k.GetParams(ctx)
 	returnCoin := sdk.Coin{params.BondDenom, returnAmount.RoundInt()}
-	dstValidator, found := k.GetValidator(ctx, validatorDstAddr)
+	dstValidator, found := k.GetValidator(ctx, valDstAddr)
 	if !found {
 		return types.ErrBadRedelegationDst(k.Codespace())
 	}
-	sharesCreated, err := k.Delegate(ctx, delegatorAddr, returnCoin, dstValidator, false)
+	sharesCreated, err := k.Delegate(ctx, delAddr, returnCoin, dstValidator, false)
 	if err != nil {
 		return err
 	}
@@ -394,9 +394,9 @@ func (k Keeper) BeginRedelegation(ctx sdk.Context, delegatorAddr sdk.AccAddress,
 	minTime := ctx.BlockHeader().Time.Add(params.UnbondingTime)
 
 	red := types.Redelegation{
-		DelegatorAddr:    delegatorAddr,
-		ValidatorSrcAddr: validatorSrcAddr,
-		ValidatorDstAddr: validatorDstAddr,
+		DelegatorAddr:    delAddr,
+		ValidatorSrcAddr: valSrcAddr,
+		ValidatorDstAddr: valDstAddr,
 		MinTime:          minTime,
 		SharesDst:        sharesCreated,
 		SharesSrc:        sharesAmount,
@@ -408,9 +408,10 @@ func (k Keeper) BeginRedelegation(ctx sdk.Context, delegatorAddr sdk.AccAddress,
 }
 
 // complete unbonding an ongoing redelegation
-func (k Keeper) CompleteRedelegation(ctx sdk.Context, delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.AccAddress) sdk.Error {
+func (k Keeper) CompleteRedelegation(ctx sdk.Context, delAddr sdk.AccAddress,
+	valSrcAddr, valDstAddr sdk.ValAddress) sdk.Error {
 
-	red, found := k.GetRedelegation(ctx, delegatorAddr, validatorSrcAddr, validatorDstAddr)
+	red, found := k.GetRedelegation(ctx, delAddr, valSrcAddr, valDstAddr)
 	if !found {
 		return types.ErrNoRedelegation(k.Codespace())
 	}
diff --git a/x/stake/keeper/key.go b/x/stake/keeper/key.go
index a04350cd9759..8de14051a1a6 100644
--- a/x/stake/keeper/key.go
+++ b/x/stake/keeper/key.go
@@ -49,7 +49,7 @@ func GetValidatorByPubKeyIndexKey(pubkey crypto.PubKey) []byte {
 // gets the key for the current validator group
 // VALUE: none (key rearrangement with GetValKeyFromValBondedIndexKey)
 func GetValidatorsBondedIndexKey(operatorAddr sdk.ValAddress) []byte {
-	return append(ValidatorsBondedIndexKey, ownerAddr.Bytes()...)
+	return append(ValidatorsBondedIndexKey, operatorAddr.Bytes()...)
 }
 
 // Get the validator owner address from ValBondedIndexKey
@@ -105,29 +105,29 @@ func GetTendermintUpdatesKey(operatorAddr sdk.ValAddress) []byte {
 
 // gets the key for delegator bond with validator
 // VALUE: stake/types.Delegation
-func GetDelegationKey(delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress) []byte {
-	return append(GetDelegationsKey(delegatorAddr), validatorAddr.Bytes()...)
+func GetDelegationKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
+	return append(GetDelegationsKey(delAddr), valAddr.Bytes()...)
 }
 
 // gets the prefix for a delegator for all validators
-func GetDelegationsKey(delegatorAddr sdk.AccAddress) []byte {
-	return append(DelegationKey, delegatorAddr.Bytes()...)
+func GetDelegationsKey(delAddr sdk.AccAddress) []byte {
+	return append(DelegationKey, delAddr.Bytes()...)
 }
 
 //______________________________________________________________________________
 
 // gets the key for an unbonding delegation by delegator and validator addr
 // VALUE: stake/types.UnbondingDelegation
-func GetUBDKey(delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress) []byte {
+func GetUBDKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
 	return append(
-		GetUBDsKey(delegatorAddr.Bytes()),
-		validatorAddr.Bytes()...)
+		GetUBDsKey(delAddr.Bytes()),
+		valAddr.Bytes()...)
 }
 
 // gets the index-key for an unbonding delegation, stored by validator-index
 // VALUE: none (key rearrangement used)
-func GetUBDByValIndexKey(delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress) []byte {
-	return append(GetUBDsByValIndexKey(validatorAddr), delegatorAddr.Bytes()...)
+func GetUBDByValIndexKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
+	return append(GetUBDsByValIndexKey(valAddr), delAddr.Bytes()...)
 }
 
 // rearranges the ValIndexKey to get the UBDKey
@@ -144,42 +144,42 @@ func GetUBDKeyFromValIndexKey(IndexKey []byte) []byte {
 //______________
 
 // gets the prefix for all unbonding delegations from a delegator
-func GetUBDsKey(delegatorAddr sdk.AccAddress) []byte {
-	return append(UnbondingDelegationKey, delegatorAddr.Bytes()...)
+func GetUBDsKey(delAddr sdk.AccAddress) []byte {
+	return append(UnbondingDelegationKey, delAddr.Bytes()...)
 }
 
 // gets the prefix keyspace for the indexes of unbonding delegations for a validator
-func GetUBDsByValIndexKey(validatorAddr sdk.ValAddress) []byte {
-	return append(UnbondingDelegationByValIndexKey, validatorAddr.Bytes()...)
+func GetUBDsByValIndexKey(valAddr sdk.ValAddress) []byte {
+	return append(UnbondingDelegationByValIndexKey, valAddr.Bytes()...)
 }
 
 //________________________________________________________________________________
 
 // gets the key for a redelegation
 // VALUE: stake/types.RedelegationKey
-func GetREDKey(delegatorAddr sdk.AccAddress, validatorSrcAddr, validatorDstAddr sdk.ValAddress) []byte {
+func GetREDKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) []byte {
 	return append(append(
-		GetREDsKey(delegatorAddr.Bytes()),
-		validatorSrcAddr.Bytes()...),
-		validatorDstAddr.Bytes()...)
+		GetREDsKey(delAddr.Bytes()),
+		valSrcAddr.Bytes()...),
+		valDstAddr.Bytes()...)
 }
 
 // gets the index-key for a redelegation, stored by source-validator-index
 // VALUE: none (key rearrangement used)
-func GetREDByValSrcIndexKey(delegatorAddr sdk.AccAddress, validatorSrcAddr, validatorDstAddr sdk.ValAddress) []byte {
+func GetREDByValSrcIndexKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) []byte {
 	return append(append(
-		GetREDsFromValSrcIndexKey(validatorSrcAddr),
-		delegatorAddr.Bytes()...),
-		validatorDstAddr.Bytes()...)
+		GetREDsFromValSrcIndexKey(valSrcAddr),
+		delAddr.Bytes()...),
+		valDstAddr.Bytes()...)
 }
 
 // gets the index-key for a redelegation, stored by destination-validator-index
 // VALUE: none (key rearrangement used)
-func GetREDByValDstIndexKey(delegatorAddr sdk.AccAddress, validatorSrcAddr, validatorDstAddr sdk.ValAddress) []byte {
+func GetREDByValDstIndexKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) []byte {
 	return append(append(
-		GetREDsToValDstIndexKey(validatorDstAddr),
-		delegatorAddr.Bytes()...),
-		validatorSrcAddr.Bytes()...)
+		GetREDsToValDstIndexKey(valDstAddr),
+		delAddr.Bytes()...),
+		valSrcAddr.Bytes()...)
 }
 
 // rearranges the ValSrcIndexKey to get the REDKey
@@ -210,24 +210,24 @@ func GetREDKeyFromValDstIndexKey(IndexKey []byte) []byte {
 //______________
 
 // gets the prefix keyspace for redelegations from a delegator
-func GetREDsKey(delegatorAddr sdk.AccAddress) []byte {
-	return append(RedelegationKey, delegatorAddr.Bytes()...)
+func GetREDsKey(delAddr sdk.AccAddress) []byte {
+	return append(RedelegationKey, delAddr.Bytes()...)
 }
 
 // gets the prefix keyspace for all redelegations redelegating away from a source validator
-func GetREDsFromValSrcIndexKey(validatorSrcAddr sdk.ValAddress) []byte {
-	return append(RedelegationByValSrcIndexKey, validatorSrcAddr.Bytes()...)
+func GetREDsFromValSrcIndexKey(valSrcAddr sdk.ValAddress) []byte {
+	return append(RedelegationByValSrcIndexKey, valSrcAddr.Bytes()...)
 }
 
 // gets the prefix keyspace for all redelegations redelegating towards a destination validator
-func GetREDsToValDstIndexKey(validatorDstAddr sdk.ValAddress) []byte {
-	return append(RedelegationByValDstIndexKey, validatorDstAddr.Bytes()...)
+func GetREDsToValDstIndexKey(valDstAddr sdk.ValAddress) []byte {
+	return append(RedelegationByValDstIndexKey, valDstAddr.Bytes()...)
 }
 
 // gets the prefix keyspace for all redelegations redelegating towards a destination validator
 // from a particular delegator
-func GetREDsByDelToValDstIndexKey(delegatorAddr sdk.AccAddress, validatorDstAddr sdk.ValAddress) []byte {
+func GetREDsByDelToValDstIndexKey(delAddr sdk.AccAddress, valDstAddr sdk.ValAddress) []byte {
 	return append(
-		GetREDsToValDstIndexKey(validatorDstAddr),
-		delegatorAddr.Bytes()...)
+		GetREDsToValDstIndexKey(valDstAddr),
+		delAddr.Bytes()...)
 }
diff --git a/x/stake/keeper/sdk_types.go b/x/stake/keeper/sdk_types.go
index aeec44fae959..480df701b101 100644
--- a/x/stake/keeper/sdk_types.go
+++ b/x/stake/keeper/sdk_types.go
@@ -51,7 +51,7 @@ func (k Keeper) IterateValidatorsBonded(ctx sdk.Context, fn func(index int64, va
 }
 
 // get the sdk.validator for a particular address
-func (k Keeper) Validator(ctx sdk.Context, address sdk.AccAddress) sdk.Validator {
+func (k Keeper) Validator(ctx sdk.Context, address sdk.ValAddress) sdk.Validator {
 	val, found := k.GetValidator(ctx, address)
 	if !found {
 		return nil
@@ -86,7 +86,7 @@ func (k Keeper) GetValidatorSet() sdk.ValidatorSet {
 }
 
 // get the delegation for a particular set of delegator and validator addresses
-func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.AccAddress, addrVal sdk.AccAddress) sdk.Delegation {
+func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.AccAddress, addrVal sdk.ValAddress) sdk.Delegation {
 	bond, ok := k.GetDelegation(ctx, addrDel, addrVal)
 	if !ok {
 		return nil
diff --git a/x/stake/keeper/test_common.go b/x/stake/keeper/test_common.go
index 0470c28988a4..b84ce9d93a91 100644
--- a/x/stake/keeper/test_common.go
+++ b/x/stake/keeper/test_common.go
@@ -33,12 +33,12 @@ var (
 		Addrs[0],
 		Addrs[1],
 	}
-	addrVals = []sdk.AccAddress{
-		Addrs[2],
-		Addrs[3],
-		Addrs[4],
-		Addrs[5],
-		Addrs[6],
+	addrVals = []sdk.ValAddress{
+		sdk.ValAddress(Addrs[2]),
+		sdk.ValAddress(Addrs[3]),
+		sdk.ValAddress(Addrs[4]),
+		sdk.ValAddress(Addrs[5]),
+		sdk.ValAddress(Addrs[6]),
 	}
 )
 
diff --git a/x/stake/keeper/validator.go b/x/stake/keeper/validator.go
index 5f880ebabb6a..92e6456b1db8 100644
--- a/x/stake/keeper/validator.go
+++ b/x/stake/keeper/validator.go
@@ -12,7 +12,7 @@ import (
 )
 
 // get a single validator
-func (k Keeper) GetValidator(ctx sdk.Context, addr sdk.AccAddress) (validator types.Validator, found bool) {
+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))
 	if value == nil {
@@ -223,7 +223,7 @@ func (k Keeper) UpdateValidator(ctx sdk.Context, validator types.Validator) type
 		store.Set(GetTendermintUpdatesKey(validator.Operator), bz)
 
 		if cliffPower != nil {
-			cliffAddr := sdk.AccAddress(k.GetCliffValidator(ctx))
+			cliffAddr := sdk.ValAddress(k.GetCliffValidator(ctx))
 			if bytes.Equal(cliffAddr, validator.Operator) {
 				k.updateCliffValidator(ctx, validator)
 			}
@@ -273,7 +273,7 @@ func (k Keeper) updateCliffValidator(ctx sdk.Context, affectedVal types.Validato
 
 	store := ctx.KVStore(k.storeKey)
 	pool := k.GetPool(ctx)
-	cliffAddr := sdk.AccAddress(k.GetCliffValidator(ctx))
+	cliffAddr := sdk.ValAddress(k.GetCliffValidator(ctx))
 
 	oldCliffVal, found := k.GetValidator(ctx, cliffAddr)
 	if !found {
@@ -606,7 +606,7 @@ func (k Keeper) bondValidator(ctx sdk.Context, validator types.Validator) types.
 }
 
 // remove the validator record and associated indexes
-func (k Keeper) RemoveValidator(ctx sdk.Context, address sdk.AccAddress) {
+func (k Keeper) RemoveValidator(ctx sdk.Context, address sdk.ValAddress) {
 
 	// first retrieve the old validator record
 	validator, found := k.GetValidator(ctx, address)
diff --git a/x/stake/keeper/validator_test.go b/x/stake/keeper/validator_test.go
index 7f17b391bec5..de7d92a22bd2 100644
--- a/x/stake/keeper/validator_test.go
+++ b/x/stake/keeper/validator_test.go
@@ -128,7 +128,7 @@ func TestCliffValidatorChange(t *testing.T) {
 
 	// assert new cliff validator to be set to the second lowest bonded validator by power
 	newCliffVal := validators[numVals-maxVals+1]
-	require.Equal(t, newCliffVal.Operator, sdk.AccAddress(keeper.GetCliffValidator(ctx)))
+	require.Equal(t, newCliffVal.Operator, sdk.ValAddress(keeper.GetCliffValidator(ctx)))
 
 	// assert cliff validator power should have been updated
 	cliffPower := keeper.GetCliffValidatorPower(ctx)
@@ -141,7 +141,7 @@ func TestCliffValidatorChange(t *testing.T) {
 
 	// assert cliff validator has not change but increased in power
 	cliffPower = keeper.GetCliffValidatorPower(ctx)
-	require.Equal(t, newCliffVal.Operator, sdk.AccAddress(keeper.GetCliffValidator(ctx)))
+	require.Equal(t, newCliffVal.Operator, sdk.ValAddress(keeper.GetCliffValidator(ctx)))
 	require.Equal(t, GetValidatorsByPowerIndexKey(newCliffVal, pool), cliffPower)
 }
 
diff --git a/x/stake/types/delegation.go b/x/stake/types/delegation.go
index e02c3dfa9926..5a2274c3aee9 100644
--- a/x/stake/types/delegation.go
+++ b/x/stake/types/delegation.go
@@ -185,8 +185,8 @@ func (d UnbondingDelegation) HumanReadableString() (string, error) {
 // Redelegation reflects a delegation's passive re-delegation queue.
 type Redelegation struct {
 	DelegatorAddr    sdk.AccAddress `json:"delegator_addr"`     // delegator
-	ValidatorSrcAddr sdk.AccAddress `json:"validator_src_addr"` // validator redelegation source owner addr
-	ValidatorDstAddr sdk.AccAddress `json:"validator_dst_addr"` // validator redelegation destination owner addr
+	ValidatorSrcAddr sdk.ValAddress `json:"validator_src_addr"` // validator redelegation source operator addr
+	ValidatorDstAddr sdk.ValAddress `json:"validator_dst_addr"` // validator redelegation destination operator addr
 	CreationHeight   int64          `json:"creation_height"`    // height which the redelegation took place
 	MinTime          time.Time      `json:"min_time"`           // unix time for redelegation completion
 	InitialBalance   sdk.Coin       `json:"initial_balance"`    // initial balance when redelegation started
@@ -240,8 +240,8 @@ func UnmarshalRED(cdc *wire.Codec, key, value []byte) (red Redelegation, err err
 		return
 	}
 	delAddr := sdk.AccAddress(addrs[:sdk.AddrLen])
-	valSrcAddr := sdk.AccAddress(addrs[sdk.AddrLen : 2*sdk.AddrLen])
-	valDstAddr := sdk.AccAddress(addrs[2*sdk.AddrLen:])
+	valSrcAddr := sdk.ValAddress(addrs[sdk.AddrLen : 2*sdk.AddrLen])
+	valDstAddr := sdk.ValAddress(addrs[2*sdk.AddrLen:])
 
 	return Redelegation{
 		DelegatorAddr:    delAddr,
diff --git a/x/stake/types/msg.go b/x/stake/types/msg.go
index 248155e15223..71a8c86314a7 100644
--- a/x/stake/types/msg.go
+++ b/x/stake/types/msg.go
@@ -1,7 +1,7 @@
 package types
 
 import (
-	"reflect"
+	"bytes"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/tendermint/tendermint/crypto"
@@ -21,30 +21,27 @@ var _, _ sdk.Msg = &MsgBeginRedelegate{}, &MsgCompleteRedelegate{}
 type MsgCreateValidator struct {
 	Description
 	DelegatorAddr sdk.AccAddress `json:"delegator_address"`
-	ValidatorAddr sdk.AccAddress `json:"validator_address"`
+	ValidatorAddr sdk.ValAddress `json:"validator_address"`
 	PubKey        crypto.PubKey  `json:"pubkey"`
 	Delegation    sdk.Coin       `json:"delegation"`
 }
 
 // Default way to create validator. Delegator address and validator address are the same
-func NewMsgCreateValidator(validatorAddr sdk.AccAddress, pubkey crypto.PubKey,
+func NewMsgCreateValidator(valAddr sdk.ValAddress, pubkey crypto.PubKey,
 	selfDelegation sdk.Coin, description Description) MsgCreateValidator {
-	return MsgCreateValidator{
-		Description:   description,
-		DelegatorAddr: validatorAddr,
-		ValidatorAddr: validatorAddr,
-		PubKey:        pubkey,
-		Delegation:    selfDelegation,
-	}
+
+	return NewMsgCreateValidatorOnBehalfOf(
+		sdk.AccAddress(valAddr), valAddr, pubkey, selfDelegation, description,
+	)
 }
 
 // Creates validator msg by delegator address on behalf of validator address
-func NewMsgCreateValidatorOnBehalfOf(delegatorAddr, validatorAddr sdk.AccAddress, pubkey crypto.PubKey,
-	delegation sdk.Coin, description Description) MsgCreateValidator {
+func NewMsgCreateValidatorOnBehalfOf(delAddr sdk.AccAddress, valAddr sdk.ValAddress,
+	pubkey crypto.PubKey, delegation sdk.Coin, description Description) MsgCreateValidator {
 	return MsgCreateValidator{
 		Description:   description,
-		DelegatorAddr: delegatorAddr,
-		ValidatorAddr: validatorAddr,
+		DelegatorAddr: delAddr,
+		ValidatorAddr: valAddr,
 		PubKey:        pubkey,
 		Delegation:    delegation,
 	}
@@ -57,9 +54,11 @@ func (msg MsgCreateValidator) Type() string { return MsgType }
 func (msg MsgCreateValidator) GetSigners() []sdk.AccAddress {
 	// delegator is first signer so delegator pays fees
 	addrs := []sdk.AccAddress{msg.DelegatorAddr}
-	if !reflect.DeepEqual(msg.DelegatorAddr, msg.ValidatorAddr) {
-		// if validator addr is not same as delegator addr, validator must sign msg as well
-		addrs = append(addrs, msg.ValidatorAddr)
+
+	if !bytes.Equal(msg.DelegatorAddr.Bytes(), msg.ValidatorAddr.Bytes()) {
+		// if validator addr is not same as delegator addr, validator must sign
+		// msg as well
+		addrs = append(addrs, sdk.AccAddress(msg.ValidatorAddr))
 	}
 	return addrs
 }
@@ -69,7 +68,7 @@ func (msg MsgCreateValidator) GetSignBytes() []byte {
 	b, err := MsgCdc.MarshalJSON(struct {
 		Description
 		DelegatorAddr sdk.AccAddress `json:"delegator_address"`
-		ValidatorAddr sdk.AccAddress `json:"validator_address"`
+		ValidatorAddr sdk.ValAddress `json:"validator_address"`
 		PubKey        string         `json:"pubkey"`
 		Delegation    sdk.Coin       `json:"delegation"`
 	}{
@@ -107,27 +106,27 @@ func (msg MsgCreateValidator) ValidateBasic() sdk.Error {
 // MsgEditValidator - struct for editing a validator
 type MsgEditValidator struct {
 	Description
-	ValidatorAddr sdk.AccAddress `json:"address"`
+	ValidatorAddr sdk.ValAddress `json:"address"`
 }
 
-func NewMsgEditValidator(validatorAddr sdk.AccAddress, description Description) MsgEditValidator {
+func NewMsgEditValidator(valAddr sdk.ValAddress, description Description) MsgEditValidator {
 	return MsgEditValidator{
 		Description:   description,
-		ValidatorAddr: validatorAddr,
+		ValidatorAddr: valAddr,
 	}
 }
 
 //nolint
 func (msg MsgEditValidator) Type() string { return MsgType }
 func (msg MsgEditValidator) GetSigners() []sdk.AccAddress {
-	return []sdk.AccAddress{msg.ValidatorAddr}
+	return []sdk.AccAddress{sdk.AccAddress(msg.ValidatorAddr)}
 }
 
 // get the bytes for the message signer to sign on
 func (msg MsgEditValidator) GetSignBytes() []byte {
 	b, err := MsgCdc.MarshalJSON(struct {
 		Description
-		ValidatorAddr sdk.AccAddress `json:"address"`
+		ValidatorAddr sdk.ValAddress `json:"address"`
 	}{
 		Description:   msg.Description,
 		ValidatorAddr: msg.ValidatorAddr,
@@ -155,14 +154,14 @@ func (msg MsgEditValidator) ValidateBasic() sdk.Error {
 // MsgDelegate - struct for bonding transactions
 type MsgDelegate struct {
 	DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
-	ValidatorAddr sdk.AccAddress `json:"validator_addr"`
+	ValidatorAddr sdk.ValAddress `json:"validator_addr"`
 	Delegation    sdk.Coin       `json:"delegation"`
 }
 
-func NewMsgDelegate(delegatorAddr, validatorAddr sdk.AccAddress, delegation sdk.Coin) MsgDelegate {
+func NewMsgDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, delegation sdk.Coin) MsgDelegate {
 	return MsgDelegate{
-		DelegatorAddr: delegatorAddr,
-		ValidatorAddr: validatorAddr,
+		DelegatorAddr: delAddr,
+		ValidatorAddr: valAddr,
 		Delegation:    delegation,
 	}
 }
@@ -201,18 +200,18 @@ func (msg MsgDelegate) ValidateBasic() sdk.Error {
 // MsgDelegate - struct for bonding transactions
 type MsgBeginRedelegate struct {
 	DelegatorAddr    sdk.AccAddress `json:"delegator_addr"`
-	ValidatorSrcAddr sdk.AccAddress `json:"validator_src_addr"`
-	ValidatorDstAddr sdk.AccAddress `json:"validator_dst_addr"`
+	ValidatorSrcAddr sdk.ValAddress `json:"validator_src_addr"`
+	ValidatorDstAddr sdk.ValAddress `json:"validator_dst_addr"`
 	SharesAmount     sdk.Dec        `json:"shares_amount"`
 }
 
-func NewMsgBeginRedelegate(delegatorAddr, validatorSrcAddr,
-	validatorDstAddr sdk.AccAddress, sharesAmount sdk.Dec) MsgBeginRedelegate {
+func NewMsgBeginRedelegate(delAddr sdk.AccAddress, valSrcAddr,
+	valDstAddr sdk.ValAddress, sharesAmount sdk.Dec) MsgBeginRedelegate {
 
 	return MsgBeginRedelegate{
-		DelegatorAddr:    delegatorAddr,
-		ValidatorSrcAddr: validatorSrcAddr,
-		ValidatorDstAddr: validatorDstAddr,
+		DelegatorAddr:    delAddr,
+		ValidatorSrcAddr: valSrcAddr,
+		ValidatorDstAddr: valDstAddr,
 		SharesAmount:     sharesAmount,
 	}
 }
@@ -227,8 +226,8 @@ func (msg MsgBeginRedelegate) GetSigners() []sdk.AccAddress {
 func (msg MsgBeginRedelegate) GetSignBytes() []byte {
 	b, err := MsgCdc.MarshalJSON(struct {
 		DelegatorAddr    sdk.AccAddress `json:"delegator_addr"`
-		ValidatorSrcAddr sdk.AccAddress `json:"validator_src_addr"`
-		ValidatorDstAddr sdk.AccAddress `json:"validator_dst_addr"`
+		ValidatorSrcAddr sdk.ValAddress `json:"validator_src_addr"`
+		ValidatorDstAddr sdk.ValAddress `json:"validator_dst_addr"`
 		SharesAmount     string         `json:"shares"`
 	}{
 		DelegatorAddr:    msg.DelegatorAddr,
@@ -262,17 +261,15 @@ func (msg MsgBeginRedelegate) ValidateBasic() sdk.Error {
 // MsgDelegate - struct for bonding transactions
 type MsgCompleteRedelegate struct {
 	DelegatorAddr    sdk.AccAddress `json:"delegator_addr"`
-	ValidatorSrcAddr sdk.AccAddress `json:"validator_source_addr"`
-	ValidatorDstAddr sdk.AccAddress `json:"validator_destination_addr"`
+	ValidatorSrcAddr sdk.ValAddress `json:"validator_source_addr"`
+	ValidatorDstAddr sdk.ValAddress `json:"validator_destination_addr"`
 }
 
-func NewMsgCompleteRedelegate(delegatorAddr, validatorSrcAddr,
-	validatorDstAddr sdk.AccAddress) MsgCompleteRedelegate {
-
+func NewMsgCompleteRedelegate(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) MsgCompleteRedelegate {
 	return MsgCompleteRedelegate{
-		DelegatorAddr:    delegatorAddr,
-		ValidatorSrcAddr: validatorSrcAddr,
-		ValidatorDstAddr: validatorDstAddr,
+		DelegatorAddr:    delAddr,
+		ValidatorSrcAddr: valSrcAddr,
+		ValidatorDstAddr: valDstAddr,
 	}
 }
 
@@ -310,14 +307,14 @@ func (msg MsgCompleteRedelegate) ValidateBasic() sdk.Error {
 // MsgBeginUnbonding - struct for unbonding transactions
 type MsgBeginUnbonding struct {
 	DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
-	ValidatorAddr sdk.AccAddress `json:"validator_addr"`
+	ValidatorAddr sdk.ValAddress `json:"validator_addr"`
 	SharesAmount  sdk.Dec        `json:"shares_amount"`
 }
 
-func NewMsgBeginUnbonding(delegatorAddr, validatorAddr sdk.AccAddress, sharesAmount sdk.Dec) MsgBeginUnbonding {
+func NewMsgBeginUnbonding(delAddr sdk.AccAddress, valAddr sdk.ValAddress, sharesAmount sdk.Dec) MsgBeginUnbonding {
 	return MsgBeginUnbonding{
-		DelegatorAddr: delegatorAddr,
-		ValidatorAddr: validatorAddr,
+		DelegatorAddr: delAddr,
+		ValidatorAddr: valAddr,
 		SharesAmount:  sharesAmount,
 	}
 }
@@ -330,7 +327,7 @@ func (msg MsgBeginUnbonding) GetSigners() []sdk.AccAddress { return []sdk.AccAdd
 func (msg MsgBeginUnbonding) GetSignBytes() []byte {
 	b, err := MsgCdc.MarshalJSON(struct {
 		DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
-		ValidatorAddr sdk.AccAddress `json:"validator_addr"`
+		ValidatorAddr sdk.ValAddress `json:"validator_addr"`
 		SharesAmount  string         `json:"shares_amount"`
 	}{
 		DelegatorAddr: msg.DelegatorAddr,
@@ -360,13 +357,13 @@ func (msg MsgBeginUnbonding) ValidateBasic() sdk.Error {
 // MsgCompleteUnbonding - struct for unbonding transactions
 type MsgCompleteUnbonding struct {
 	DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
-	ValidatorAddr sdk.AccAddress `json:"validator_addr"`
+	ValidatorAddr sdk.ValAddress `json:"validator_addr"`
 }
 
-func NewMsgCompleteUnbonding(delegatorAddr, validatorAddr sdk.AccAddress) MsgCompleteUnbonding {
+func NewMsgCompleteUnbonding(delAddr sdk.AccAddress, valAddr sdk.ValAddress) MsgCompleteUnbonding {
 	return MsgCompleteUnbonding{
-		DelegatorAddr: delegatorAddr,
-		ValidatorAddr: validatorAddr,
+		DelegatorAddr: delAddr,
+		ValidatorAddr: valAddr,
 	}
 }
 

From 87d724f23aceea9aad6f6fab0521e93c92aacb61 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 21 Aug 2018 10:44:28 -0400
Subject: [PATCH 18/34] [WIP] Fix and update unit tests

---
 x/gov/endblocker_test.go         |  19 +++--
 x/gov/tally.go                   |   6 +-
 x/gov/tally_test.go              | 122 ++++++++++++++++++++++++-------
 x/slashing/app_test.go           |   8 +-
 x/slashing/client/cli/tx.go      |   2 +-
 x/slashing/handler_test.go       |   6 +-
 x/slashing/keeper_test.go        |  30 +++++---
 x/slashing/msg_test.go           |   4 +-
 x/slashing/tick_test.go          |   4 +-
 x/stake/app_test.go              |   4 +-
 x/stake/keeper/validator_test.go |  42 +++++------
 x/stake/simulation/msgs.go       |  22 +++---
 x/stake/types/delegation_test.go |  22 +++---
 x/stake/types/msg_test.go        |  92 +++++++++++------------
 x/stake/types/test_utils.go      |   8 +-
 15 files changed, 238 insertions(+), 153 deletions(-)

diff --git a/x/gov/endblocker_test.go b/x/gov/endblocker_test.go
index 9dd241aabda4..710ecb1dba2a 100644
--- a/x/gov/endblocker_test.go
+++ b/x/gov/endblocker_test.go
@@ -178,12 +178,17 @@ func TestSlashing(t *testing.T) {
 	govHandler := NewHandler(keeper)
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:3], []int64{25, 6, 7})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:3]))
+	for i, addr := range addrs[:3] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{25, 6, 7})
 
 	initTotalPower := keeper.ds.GetValidatorSet().TotalPower(ctx)
-	val0Initial := keeper.ds.GetValidatorSet().Validator(ctx, addrs[0]).GetPower().Quo(initTotalPower)
-	val1Initial := keeper.ds.GetValidatorSet().Validator(ctx, addrs[1]).GetPower().Quo(initTotalPower)
-	val2Initial := keeper.ds.GetValidatorSet().Validator(ctx, addrs[2]).GetPower().Quo(initTotalPower)
+	val0Initial := keeper.ds.GetValidatorSet().Validator(ctx, sdk.ValAddress(addrs[0])).GetPower().Quo(initTotalPower)
+	val1Initial := keeper.ds.GetValidatorSet().Validator(ctx, sdk.ValAddress(addrs[1])).GetPower().Quo(initTotalPower)
+	val2Initial := keeper.ds.GetValidatorSet().Validator(ctx, sdk.ValAddress(addrs[2])).GetPower().Quo(initTotalPower)
 
 	newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin("steak", 15)})
 
@@ -209,9 +214,9 @@ func TestSlashing(t *testing.T) {
 	require.False(t, keeper.GetProposal(ctx, proposalID).GetTallyResult().Equals(EmptyTallyResult()))
 
 	endTotalPower := keeper.ds.GetValidatorSet().TotalPower(ctx)
-	val0End := keeper.ds.GetValidatorSet().Validator(ctx, addrs[0]).GetPower().Quo(endTotalPower)
-	val1End := keeper.ds.GetValidatorSet().Validator(ctx, addrs[1]).GetPower().Quo(endTotalPower)
-	val2End := keeper.ds.GetValidatorSet().Validator(ctx, addrs[2]).GetPower().Quo(endTotalPower)
+	val0End := keeper.ds.GetValidatorSet().Validator(ctx, sdk.ValAddress(addrs[0])).GetPower().Quo(endTotalPower)
+	val1End := keeper.ds.GetValidatorSet().Validator(ctx, sdk.ValAddress(addrs[1])).GetPower().Quo(endTotalPower)
+	val2End := keeper.ds.GetValidatorSet().Validator(ctx, sdk.ValAddress(addrs[2])).GetPower().Quo(endTotalPower)
 
 	require.True(t, val0End.GTE(val0Initial))
 	require.True(t, val1End.LT(val1Initial))
diff --git a/x/gov/tally.go b/x/gov/tally.go
index 299202c9e646..aae98a07efc1 100644
--- a/x/gov/tally.go
+++ b/x/gov/tally.go
@@ -6,7 +6,7 @@ import (
 
 // validatorGovInfo used for tallying
 type validatorGovInfo struct {
-	Address         sdk.ValAddress // sdk.AccAddress of the validator owner
+	Address         sdk.ValAddress // address of the validator operator
 	Power           sdk.Dec        // Power of a Validator
 	DelegatorShares sdk.Dec        // Total outstanding delegator shares
 	Minus           sdk.Dec        // Minus of validator, used to compute validator's voting power
@@ -66,13 +66,15 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 	}
 	votesIterator.Close()
 
-	// Iterate over the validators again to tally their voting power and see who didn't vote
+	// iterate over the validators again to tally their voting power and see
+	// who didn't vote
 	nonVoting = []sdk.ValAddress{}
 	for _, val := range currValidators {
 		if val.Vote == OptionEmpty {
 			nonVoting = append(nonVoting, val.Address)
 			continue
 		}
+
 		sharesAfterMinus := val.DelegatorShares.Sub(val.Minus)
 		percentAfterMinus := sharesAfterMinus.Quo(val.DelegatorShares)
 		votingPower := val.Power.Mul(percentAfterMinus)
diff --git a/x/gov/tally_test.go b/x/gov/tally_test.go
index 730885266f84..8db306fbc097 100644
--- a/x/gov/tally_test.go
+++ b/x/gov/tally_test.go
@@ -17,7 +17,7 @@ var (
 	pubkeys = []crypto.PubKey{ed25519.GenPrivKey().PubKey(), ed25519.GenPrivKey().PubKey(), ed25519.GenPrivKey().PubKey()}
 )
 
-func createValidators(t *testing.T, stakeHandler sdk.Handler, ctx sdk.Context, addrs []sdk.AccAddress, coinAmt []int64) {
+func createValidators(t *testing.T, stakeHandler sdk.Handler, ctx sdk.Context, addrs []sdk.ValAddress, coinAmt []int64) {
 	require.True(t, len(addrs) <= len(pubkeys), "Not enough pubkeys specified at top of file.")
 	dummyDescription := stake.NewDescription("T", "E", "S", "T")
 	for i := 0; i < len(addrs); i++ {
@@ -33,7 +33,12 @@ func TestTallyNoOneVotes(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:2], []int64{5, 5})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:2]))
+	for i, addr := range addrs[:2] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{5, 5})
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
 	proposalID := proposal.GetProposalID()
@@ -52,7 +57,12 @@ func TestTallyOnlyValidatorsAllYes(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:2], []int64{5, 5})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:2]))
+	for i, addr := range addrs[:2] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{5, 5})
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
 	proposalID := proposal.GetProposalID()
@@ -76,7 +86,12 @@ func TestTallyOnlyValidators51No(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:2], []int64{5, 6})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:2]))
+	for i, addr := range addrs[:2] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{5, 6})
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
 	proposalID := proposal.GetProposalID()
@@ -99,7 +114,12 @@ func TestTallyOnlyValidators51Yes(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:3], []int64{6, 6, 7})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:3]))
+	for i, addr := range addrs[:3] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{6, 6, 7})
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
 	proposalID := proposal.GetProposalID()
@@ -125,7 +145,12 @@ func TestTallyOnlyValidatorsVetoed(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:3], []int64{6, 6, 7})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:3]))
+	for i, addr := range addrs[:3] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{6, 6, 7})
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
 	proposalID := proposal.GetProposalID()
@@ -151,7 +176,12 @@ func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:3], []int64{6, 6, 7})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:3]))
+	for i, addr := range addrs[:3] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{6, 6, 7})
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
 	proposalID := proposal.GetProposalID()
@@ -177,7 +207,12 @@ func TestTallyOnlyValidatorsAbstainFails(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:3], []int64{6, 6, 7})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:3]))
+	for i, addr := range addrs[:3] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{6, 6, 7})
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
 	proposalID := proposal.GetProposalID()
@@ -203,7 +238,12 @@ func TestTallyOnlyValidatorsNonVoter(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:3], []int64{6, 6, 7})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:3]))
+	for i, addr := range addrs[:3] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{6, 6, 7})
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
 	proposalID := proposal.GetProposalID()
@@ -229,9 +269,14 @@ func TestTallyDelgatorOverride(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:3], []int64{5, 6, 7})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:3]))
+	for i, addr := range addrs[:3] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{5, 6, 7})
 
-	delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewInt64Coin("steak", 30))
+	delegator1Msg := stake.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin("steak", 30))
 	stakeHandler(ctx, delegator1Msg)
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@@ -260,9 +305,14 @@ func TestTallyDelgatorInherit(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:3], []int64{5, 6, 7})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:3]))
+	for i, addr := range addrs[:3] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{5, 6, 7})
 
-	delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewInt64Coin("steak", 30))
+	delegator1Msg := stake.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin("steak", 30))
 	stakeHandler(ctx, delegator1Msg)
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@@ -290,11 +340,16 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:3], []int64{5, 6, 7})
+	valAddrs := make([]sdk.ValAddress, len(addrs[:3]))
+	for i, addr := range addrs[:3] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{5, 6, 7})
 
-	delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewInt64Coin("steak", 10))
+	delegator1Msg := stake.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin("steak", 10))
 	stakeHandler(ctx, delegator1Msg)
-	delegator1Msg2 := stake.NewMsgDelegate(addrs[3], addrs[1], sdk.NewInt64Coin("steak", 10))
+	delegator1Msg2 := stake.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewInt64Coin("steak", 10))
 	stakeHandler(ctx, delegator1Msg2)
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@@ -324,16 +379,26 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
 	stakeHandler := stake.NewHandler(sk)
 
 	dummyDescription := stake.NewDescription("T", "E", "S", "T")
-	val1CreateMsg := stake.NewMsgCreateValidator(addrs[0], ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin("steak", 25), dummyDescription)
+
+	val1CreateMsg := stake.NewMsgCreateValidator(
+		sdk.ValAddress(addrs[0]), ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin("steak", 25), dummyDescription,
+	)
 	stakeHandler(ctx, val1CreateMsg)
-	val2CreateMsg := stake.NewMsgCreateValidator(addrs[1], ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin("steak", 6), dummyDescription)
+
+	val2CreateMsg := stake.NewMsgCreateValidator(
+		sdk.ValAddress(addrs[1]), ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin("steak", 6), dummyDescription,
+	)
 	stakeHandler(ctx, val2CreateMsg)
-	val3CreateMsg := stake.NewMsgCreateValidator(addrs[2], ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin("steak", 7), dummyDescription)
+
+	val3CreateMsg := stake.NewMsgCreateValidator(
+		sdk.ValAddress(addrs[2]), ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin("steak", 7), dummyDescription,
+	)
 	stakeHandler(ctx, val3CreateMsg)
 
-	delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewInt64Coin("steak", 10))
+	delegator1Msg := stake.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin("steak", 10))
 	stakeHandler(ctx, delegator1Msg)
-	delegator1Msg2 := stake.NewMsgDelegate(addrs[3], addrs[1], sdk.NewInt64Coin("steak", 10))
+
+	delegator1Msg2 := stake.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewInt64Coin("steak", 10))
 	stakeHandler(ctx, delegator1Msg2)
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@@ -360,13 +425,20 @@ func TestTallyRevokedValidator(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakeHandler := stake.NewHandler(sk)
 
-	createValidators(t, stakeHandler, ctx, addrs[:3], []int64{25, 6, 7})
-	delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewInt64Coin("steak", 10))
+	valAddrs := make([]sdk.ValAddress, len(addrs[:3]))
+	for i, addr := range addrs[:3] {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	createValidators(t, stakeHandler, ctx, valAddrs, []int64{25, 6, 7})
+
+	delegator1Msg := stake.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin("steak", 10))
 	stakeHandler(ctx, delegator1Msg)
-	delegator1Msg2 := stake.NewMsgDelegate(addrs[3], addrs[1], sdk.NewInt64Coin("steak", 10))
+
+	delegator1Msg2 := stake.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewInt64Coin("steak", 10))
 	stakeHandler(ctx, delegator1Msg2)
 
-	val2, found := sk.GetValidator(ctx, addrs[1])
+	val2, found := sk.GetValidator(ctx, sdk.ValAddress(addrs[1]))
 	require.True(t, found)
 	sk.Revoke(ctx, val2.PubKey)
 
diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go
index e018c43e8b8e..26dd1ff0626f 100644
--- a/x/slashing/app_test.go
+++ b/x/slashing/app_test.go
@@ -73,7 +73,7 @@ func getInitChainer(mapp *mock.App, keeper stake.Keeper) sdk.InitChainer {
 func checkValidator(t *testing.T, mapp *mock.App, keeper stake.Keeper,
 	addr sdk.AccAddress, expFound bool) stake.Validator {
 	ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{})
-	validator, found := keeper.GetValidator(ctxCheck, addr1)
+	validator, found := keeper.GetValidator(ctxCheck, sdk.ValAddress(addr1))
 	require.Equal(t, expFound, found)
 	return validator
 }
@@ -100,17 +100,17 @@ func TestSlashingMsgs(t *testing.T) {
 	mock.SetGenesis(mapp, accs)
 	description := stake.NewDescription("foo_moniker", "", "", "")
 	createValidatorMsg := stake.NewMsgCreateValidator(
-		addr1, priv1.PubKey(), bondCoin, description,
+		sdk.ValAddress(addr1), priv1.PubKey(), bondCoin, description,
 	)
 	mock.SignCheckDeliver(t, mapp.BaseApp, []sdk.Msg{createValidatorMsg}, []int64{0}, []int64{0}, true, priv1)
 	mock.CheckBalance(t, mapp, addr1, sdk.Coins{genCoin.Minus(bondCoin)})
 	mapp.BeginBlock(abci.RequestBeginBlock{})
 
 	validator := checkValidator(t, mapp, stakeKeeper, addr1, true)
-	require.Equal(t, addr1, validator.Operator)
+	require.Equal(t, sdk.ValAddress(addr1), validator.Operator)
 	require.Equal(t, sdk.Bonded, validator.Status)
 	require.True(sdk.DecEq(t, sdk.NewDec(10), validator.BondedTokens()))
-	unrevokeMsg := MsgUnrevoke{ValidatorAddr: sdk.AccAddress(validator.PubKey.Address())}
+	unrevokeMsg := MsgUnrevoke{ValidatorAddr: sdk.ValAddress(validator.PubKey.Address())}
 
 	// no signing info yet
 	checkValidatorSigningInfo(t, mapp, keeper, sdk.ValAddress(addr1), false)
diff --git a/x/slashing/client/cli/tx.go b/x/slashing/client/cli/tx.go
index 5085f5aacce8..cf94077e688f 100644
--- a/x/slashing/client/cli/tx.go
+++ b/x/slashing/client/cli/tx.go
@@ -32,7 +32,7 @@ func GetCmdUnrevoke(cdc *wire.Codec) *cobra.Command {
 				return err
 			}
 
-			msg := slashing.NewMsgUnrevoke(validatorAddr)
+			msg := slashing.NewMsgUnrevoke(sdk.ValAddress(validatorAddr))
 
 			return utils.SendTx(txCtx, cliCtx, []sdk.Msg{msg})
 		},
diff --git a/x/slashing/handler_test.go b/x/slashing/handler_test.go
index 41cb5d19968c..621e8668033c 100644
--- a/x/slashing/handler_test.go
+++ b/x/slashing/handler_test.go
@@ -15,15 +15,15 @@ func TestCannotUnrevokeUnlessRevoked(t *testing.T) {
 	slh := NewHandler(keeper)
 	amtInt := int64(100)
 	addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
-	msg := newTestMsgCreateValidator(addr, val, amt)
+	msg := newTestMsgCreateValidator(sdk.ValAddress(addr), val, amt)
 	got := stake.NewHandler(sk)(ctx, msg)
 	require.True(t, got.IsOK())
 	stake.EndBlocker(ctx, sk)
 	require.Equal(t, ck.GetCoins(ctx, addr), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.Sub(amt)}})
-	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower()))
+	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, sdk.ValAddress(addr)).GetPower()))
 
 	// assert non-revoked validator can't be unrevoked
-	got = slh(ctx, NewMsgUnrevoke(addr))
+	got = slh(ctx, NewMsgUnrevoke(sdk.ValAddress(addr)))
 	require.False(t, got.IsOK(), "allowed unrevoke of non-revoked validator")
 	require.Equal(t, sdk.ToABCICode(DefaultCodespace, CodeValidatorNotRevoked), got.Code)
 }
diff --git a/x/slashing/keeper_test.go b/x/slashing/keeper_test.go
index 68de7a43c5e0..86108ce01ef0 100644
--- a/x/slashing/keeper_test.go
+++ b/x/slashing/keeper_test.go
@@ -26,12 +26,12 @@ func TestHandleDoubleSign(t *testing.T) {
 	ctx, ck, sk, _, keeper := createTestInput(t)
 	amtInt := int64(100)
 	addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
-	got := stake.NewHandler(sk)(ctx, newTestMsgCreateValidator(addr, val, amt))
+	got := stake.NewHandler(sk)(ctx, newTestMsgCreateValidator(sdk.ValAddress(addr), val, amt))
 	require.True(t, got.IsOK())
 	validatorUpdates := stake.EndBlocker(ctx, sk)
 	keeper.AddValidators(ctx, validatorUpdates)
 	require.Equal(t, ck.GetCoins(ctx, addr), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.Sub(amt)}})
-	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower()))
+	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, sdk.ValAddress(addr)).GetPower()))
 
 	// handle a signature to set signing info
 	keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
@@ -40,16 +40,22 @@ func TestHandleDoubleSign(t *testing.T) {
 	keeper.handleDoubleSign(ctx, val, 0, time.Unix(0, 0), amtInt)
 
 	// should be revoked
-	require.True(t, sk.Validator(ctx, addr).GetRevoked())
+	require.True(t, sk.Validator(ctx, sdk.ValAddress(addr)).GetRevoked())
 	// unrevoke to measure power
 	sk.Unrevoke(ctx, val)
 	// power should be reduced
-	require.Equal(t, sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20))), sk.Validator(ctx, addr).GetPower())
+	require.Equal(
+		t, sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20))),
+		sk.Validator(ctx, sdk.ValAddress(addr)).GetPower(),
+	)
 	ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(1, 0).Add(keeper.MaxEvidenceAge(ctx))})
 
 	// double sign past max age
 	keeper.handleDoubleSign(ctx, val, 0, time.Unix(0, 0), amtInt)
-	require.Equal(t, sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20))), sk.Validator(ctx, addr).GetPower())
+	require.Equal(
+		t, sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20))),
+		sk.Validator(ctx, sdk.ValAddress(addr)).GetPower(),
+	)
 }
 
 // Test a validator through uptime, downtime, revocation,
@@ -62,12 +68,12 @@ func TestHandleAbsentValidator(t *testing.T) {
 	addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
 	sh := stake.NewHandler(sk)
 	slh := NewHandler(keeper)
-	got := sh(ctx, newTestMsgCreateValidator(addr, val, amt))
+	got := sh(ctx, newTestMsgCreateValidator(sdk.ValAddress(addr), val, amt))
 	require.True(t, got.IsOK())
 	validatorUpdates := stake.EndBlocker(ctx, sk)
 	keeper.AddValidators(ctx, validatorUpdates)
 	require.Equal(t, ck.GetCoins(ctx, addr), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.Sub(amt)}})
-	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower()))
+	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, sdk.ValAddress(addr)).GetPower()))
 	info, found := keeper.getValidatorSigningInfo(ctx, sdk.ValAddress(val.Address()))
 	require.False(t, found)
 	require.Equal(t, int64(0), info.StartHeight)
@@ -117,12 +123,12 @@ func TestHandleAbsentValidator(t *testing.T) {
 	require.Equal(t, sdk.Unbonded, validator.GetStatus())
 
 	// unrevocation should fail prior to jail expiration
-	got = slh(ctx, NewMsgUnrevoke(addr))
+	got = slh(ctx, NewMsgUnrevoke(sdk.ValAddress(addr)))
 	require.False(t, got.IsOK())
 
 	// unrevocation should succeed after jail expiration
 	ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(1, 0).Add(keeper.DowntimeUnbondDuration(ctx))})
-	got = slh(ctx, NewMsgUnrevoke(addr))
+	got = slh(ctx, NewMsgUnrevoke(sdk.ValAddress(addr)))
 	require.True(t, got.IsOK())
 
 	// validator should be rebonded now
@@ -172,12 +178,12 @@ func TestHandleNewValidator(t *testing.T) {
 	ctx, ck, sk, _, keeper := createTestInput(t)
 	addr, val, amt := addrs[0], pks[0], int64(100)
 	sh := stake.NewHandler(sk)
-	got := sh(ctx, newTestMsgCreateValidator(addr, val, sdk.NewInt(amt)))
+	got := sh(ctx, newTestMsgCreateValidator(sdk.ValAddress(addr), val, sdk.NewInt(amt)))
 	require.True(t, got.IsOK())
 	validatorUpdates := stake.EndBlocker(ctx, sk)
 	keeper.AddValidators(ctx, validatorUpdates)
 	require.Equal(t, ck.GetCoins(ctx, addr), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.SubRaw(amt)}})
-	require.Equal(t, sdk.NewDec(amt), sk.Validator(ctx, addr).GetPower())
+	require.Equal(t, sdk.NewDec(amt), sk.Validator(ctx, sdk.ValAddress(addr)).GetPower())
 
 	// 1000 first blocks not a validator
 	ctx = ctx.WithBlockHeight(keeper.SignedBlocksWindow(ctx) + 1)
@@ -210,7 +216,7 @@ func TestHandleAlreadyRevoked(t *testing.T) {
 	amtInt := int64(100)
 	addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
 	sh := stake.NewHandler(sk)
-	got := sh(ctx, newTestMsgCreateValidator(addr, val, amt))
+	got := sh(ctx, newTestMsgCreateValidator(sdk.ValAddress(addr), val, amt))
 	require.True(t, got.IsOK())
 	validatorUpdates := stake.EndBlocker(ctx, sk)
 	keeper.AddValidators(ctx, validatorUpdates)
diff --git a/x/slashing/msg_test.go b/x/slashing/msg_test.go
index 287eb6c5c5fe..5c9ae76bf8af 100644
--- a/x/slashing/msg_test.go
+++ b/x/slashing/msg_test.go
@@ -10,7 +10,7 @@ import (
 
 func TestMsgUnrevokeGetSignBytes(t *testing.T) {
 	addr := sdk.AccAddress("abcd")
-	msg := NewMsgUnrevoke(addr)
+	msg := NewMsgUnrevoke(sdk.ValAddress(addr))
 	bytes := msg.GetSignBytes()
-	require.Equal(t, string(bytes), `{"address":"cosmosaccaddr1v93xxeqhyqz5v"}`)
+	require.Equal(t, string(bytes), `{"address":"cosmosvaladdr1v93xxeqamr0mv"}`)
 }
diff --git a/x/slashing/tick_test.go b/x/slashing/tick_test.go
index b230f9c94004..fd1ada4ddb40 100644
--- a/x/slashing/tick_test.go
+++ b/x/slashing/tick_test.go
@@ -17,12 +17,12 @@ func TestBeginBlocker(t *testing.T) {
 	addr, pk, amt := addrs[2], pks[2], sdk.NewInt(100)
 
 	// bond the validator
-	got := stake.NewHandler(sk)(ctx, newTestMsgCreateValidator(addr, pk, amt))
+	got := stake.NewHandler(sk)(ctx, newTestMsgCreateValidator(sdk.ValAddress(addr), pk, amt))
 	require.True(t, got.IsOK())
 	validatorUpdates := stake.EndBlocker(ctx, sk)
 	keeper.AddValidators(ctx, validatorUpdates)
 	require.Equal(t, ck.GetCoins(ctx, addr), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.Sub(amt)}})
-	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower()))
+	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, sdk.ValAddress(addr)).GetPower()))
 
 	val := abci.Validator{
 		Address: pk.Address(),
diff --git a/x/stake/app_test.go b/x/stake/app_test.go
index ce6cb736cbe1..587e90b46595 100644
--- a/x/stake/app_test.go
+++ b/x/stake/app_test.go
@@ -136,7 +136,7 @@ func TestStakeMsgs(t *testing.T) {
 	mApp.BeginBlock(abci.RequestBeginBlock{})
 
 	validator := checkValidator(t, mApp, keeper, sdk.ValAddress(addr1), true)
-	require.Equal(t, addr1, validator.Operator)
+	require.Equal(t, sdk.ValAddress(addr1), validator.Operator)
 	require.Equal(t, sdk.Bonded, validator.Status)
 	require.True(sdk.DecEq(t, sdk.NewDec(10), validator.BondedTokens()))
 
@@ -150,7 +150,7 @@ func TestStakeMsgs(t *testing.T) {
 	mApp.BeginBlock(abci.RequestBeginBlock{})
 
 	validator = checkValidator(t, mApp, keeper, sdk.ValAddress(addr2), true)
-	require.Equal(t, addr2, validator.Operator)
+	require.Equal(t, sdk.ValAddress(addr2), validator.Operator)
 	require.Equal(t, sdk.Bonded, validator.Status)
 	require.True(sdk.DecEq(t, sdk.NewDec(10), validator.Tokens))
 
diff --git a/x/stake/keeper/validator_test.go b/x/stake/keeper/validator_test.go
index de7d92a22bd2..18ebd4ed96e3 100644
--- a/x/stake/keeper/validator_test.go
+++ b/x/stake/keeper/validator_test.go
@@ -110,7 +110,7 @@ func TestCliffValidatorChange(t *testing.T) {
 	validators := make([]types.Validator, numVals)
 	for i := 0; i < len(validators); i++ {
 		moniker := fmt.Sprintf("val#%d", int64(i))
-		val := types.NewValidator(Addrs[i], PKs[i], types.Description{Moniker: moniker})
+		val := types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{Moniker: moniker})
 		val.BondHeight = int64(i)
 		val.BondIntraTxCounter = int16(i)
 		val, pool, _ = val.AddTokensFromDel(pool, int64((i+1)*10))
@@ -254,7 +254,7 @@ func GetValidatorSortingUnmixed(t *testing.T) {
 	n := len(amts)
 	var validators [5]types.Validator
 	for i, amt := range amts {
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i].Status = sdk.Bonded
 		validators[i].Tokens = sdk.NewDec(amt)
 		validators[i].DelegatorShares = sdk.NewDec(amt)
@@ -337,7 +337,7 @@ func GetValidatorSortingMixed(t *testing.T) {
 	n := len(amts)
 	var validators [5]types.Validator
 	for i, amt := range amts {
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i].DelegatorShares = sdk.NewDec(amt)
 	}
 
@@ -356,15 +356,15 @@ func GetValidatorSortingMixed(t *testing.T) {
 	for i := range amts {
 		keeper.UpdateValidator(ctx, validators[i])
 	}
-	val0, found := keeper.GetValidator(ctx, Addrs[0])
+	val0, found := keeper.GetValidator(ctx, sdk.ValAddress(Addrs[0]))
 	require.True(t, found)
-	val1, found := keeper.GetValidator(ctx, Addrs[1])
+	val1, found := keeper.GetValidator(ctx, sdk.ValAddress(Addrs[1]))
 	require.True(t, found)
-	val2, found := keeper.GetValidator(ctx, Addrs[2])
+	val2, found := keeper.GetValidator(ctx, sdk.ValAddress(Addrs[2]))
 	require.True(t, found)
-	val3, found := keeper.GetValidator(ctx, Addrs[3])
+	val3, found := keeper.GetValidator(ctx, sdk.ValAddress(Addrs[3]))
 	require.True(t, found)
-	val4, found := keeper.GetValidator(ctx, Addrs[4])
+	val4, found := keeper.GetValidator(ctx, sdk.ValAddress(Addrs[4]))
 	require.True(t, found)
 	require.Equal(t, sdk.Unbonded, val0.Status)
 	require.Equal(t, sdk.Unbonded, val1.Status)
@@ -403,7 +403,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	var validators [4]types.Validator
 	for i, amt := range amts {
 		pool := keeper.GetPool(ctx)
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt)
 		keeper.SetPool(ctx, pool)
 		validators[i] = keeper.UpdateValidator(ctx, validators[i])
@@ -476,9 +476,9 @@ func TestValidatorBondHeight(t *testing.T) {
 
 	// initialize some validators into the state
 	var validators [3]types.Validator
-	validators[0] = types.NewValidator(Addrs[0], PKs[0], types.Description{})
-	validators[1] = types.NewValidator(Addrs[1], PKs[1], types.Description{})
-	validators[2] = types.NewValidator(Addrs[2], PKs[2], types.Description{})
+	validators[0] = types.NewValidator(sdk.ValAddress(Addrs[0]), PKs[0], types.Description{})
+	validators[1] = types.NewValidator(sdk.ValAddress(Addrs[1]), PKs[1], types.Description{})
+	validators[2] = types.NewValidator(sdk.ValAddress(Addrs[2]), PKs[2], types.Description{})
 
 	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, 200)
 	validators[1], pool, _ = validators[1].AddTokensFromDel(pool, 100)
@@ -523,7 +523,7 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
 	var validators [5]types.Validator
 	for i, amt := range amts {
 		pool := keeper.GetPool(ctx)
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt)
 		keeper.SetPool(ctx, pool)
 		keeper.UpdateValidator(ctx, validators[i])
@@ -562,7 +562,7 @@ func TestClearTendermintUpdates(t *testing.T) {
 	validators := make([]types.Validator, len(amts))
 	for i, amt := range amts {
 		pool := keeper.GetPool(ctx)
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt)
 		keeper.SetPool(ctx, pool)
 		keeper.UpdateValidator(ctx, validators[i])
@@ -582,7 +582,7 @@ func TestGetTendermintUpdatesAllNone(t *testing.T) {
 	var validators [2]types.Validator
 	for i, amt := range amts {
 		pool := keeper.GetPool(ctx)
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt)
 		keeper.SetPool(ctx, pool)
 	}
@@ -621,7 +621,7 @@ func TestGetTendermintUpdatesIdentical(t *testing.T) {
 	var validators [2]types.Validator
 	for i, amt := range amts {
 		pool := keeper.GetPool(ctx)
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt)
 		keeper.SetPool(ctx, pool)
 	}
@@ -644,7 +644,7 @@ func TestGetTendermintUpdatesSingleValueChange(t *testing.T) {
 	var validators [2]types.Validator
 	for i, amt := range amts {
 		pool := keeper.GetPool(ctx)
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt)
 		keeper.SetPool(ctx, pool)
 	}
@@ -672,7 +672,7 @@ func TestGetTendermintUpdatesMultipleValueChange(t *testing.T) {
 	var validators [2]types.Validator
 	for i, amt := range amts {
 		pool := keeper.GetPool(ctx)
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt)
 		keeper.SetPool(ctx, pool)
 	}
@@ -703,7 +703,7 @@ func TestGetTendermintUpdatesInserted(t *testing.T) {
 	var validators [5]types.Validator
 	for i, amt := range amts {
 		pool := keeper.GetPool(ctx)
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt)
 		keeper.SetPool(ctx, pool)
 	}
@@ -746,7 +746,7 @@ func TestGetTendermintUpdatesWithCliffValidator(t *testing.T) {
 	var validators [5]types.Validator
 	for i, amt := range amts {
 		pool := keeper.GetPool(ctx)
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt)
 		keeper.SetPool(ctx, pool)
 	}
@@ -784,7 +784,7 @@ func TestGetTendermintUpdatesPowerDecrease(t *testing.T) {
 	var validators [2]types.Validator
 	for i, amt := range amts {
 		pool := keeper.GetPool(ctx)
-		validators[i] = types.NewValidator(Addrs[i], PKs[i], types.Description{})
+		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
 		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt)
 		keeper.SetPool(ctx, pool)
 	}
diff --git a/x/stake/simulation/msgs.go b/x/stake/simulation/msgs.go
index f402d765fc0e..b02fda9405a6 100644
--- a/x/stake/simulation/msgs.go
+++ b/x/stake/simulation/msgs.go
@@ -26,8 +26,8 @@ func SimulateMsgCreateValidator(m auth.AccountMapper, k stake.Keeper) simulation
 		}
 		key := simulation.RandomKey(r, keys)
 		pubkey := key.PubKey()
-		address := sdk.AccAddress(pubkey.Address())
-		amount := m.GetAccount(ctx, address).GetCoins().AmountOf(denom)
+		address := sdk.ValAddress(pubkey.Address())
+		amount := m.GetAccount(ctx, sdk.AccAddress(address)).GetCoins().AmountOf(denom)
 		if amount.GT(sdk.ZeroInt()) {
 			amount = simulation.RandomAmount(r, amount)
 		}
@@ -37,7 +37,7 @@ func SimulateMsgCreateValidator(m auth.AccountMapper, k stake.Keeper) simulation
 		msg := stake.MsgCreateValidator{
 			Description:   description,
 			ValidatorAddr: address,
-			DelegatorAddr: address,
+			DelegatorAddr: sdk.AccAddress(address),
 			PubKey:        pubkey,
 			Delegation:    sdk.NewCoin(denom, amount),
 		}
@@ -65,7 +65,7 @@ func SimulateMsgEditValidator(k stake.Keeper) simulation.TestAndRunTx {
 		}
 		key := simulation.RandomKey(r, keys)
 		pubkey := key.PubKey()
-		address := sdk.AccAddress(pubkey.Address())
+		address := sdk.ValAddress(pubkey.Address())
 		msg := stake.MsgEditValidator{
 			Description:   description,
 			ValidatorAddr: address,
@@ -87,7 +87,7 @@ func SimulateMsgDelegate(m auth.AccountMapper, k stake.Keeper) simulation.TestAn
 	return func(t *testing.T, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, log string, event func(string)) (action string, err sdk.Error) {
 		denom := k.GetParams(ctx).BondDenom
 		validatorKey := simulation.RandomKey(r, keys)
-		validatorAddress := sdk.AccAddress(validatorKey.PubKey().Address())
+		validatorAddress := sdk.ValAddress(validatorKey.PubKey().Address())
 		delegatorKey := simulation.RandomKey(r, keys)
 		delegatorAddress := sdk.AccAddress(delegatorKey.PubKey().Address())
 		amount := m.GetAccount(ctx, delegatorAddress).GetCoins().AmountOf(denom)
@@ -119,7 +119,7 @@ func SimulateMsgBeginUnbonding(m auth.AccountMapper, k stake.Keeper) simulation.
 	return func(t *testing.T, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, log string, event func(string)) (action string, err sdk.Error) {
 		denom := k.GetParams(ctx).BondDenom
 		validatorKey := simulation.RandomKey(r, keys)
-		validatorAddress := sdk.AccAddress(validatorKey.PubKey().Address())
+		validatorAddress := sdk.ValAddress(validatorKey.PubKey().Address())
 		delegatorKey := simulation.RandomKey(r, keys)
 		delegatorAddress := sdk.AccAddress(delegatorKey.PubKey().Address())
 		amount := m.GetAccount(ctx, delegatorAddress).GetCoins().AmountOf(denom)
@@ -150,7 +150,7 @@ func SimulateMsgBeginUnbonding(m auth.AccountMapper, k stake.Keeper) simulation.
 func SimulateMsgCompleteUnbonding(k stake.Keeper) simulation.TestAndRunTx {
 	return func(t *testing.T, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, log string, event func(string)) (action string, err sdk.Error) {
 		validatorKey := simulation.RandomKey(r, keys)
-		validatorAddress := sdk.AccAddress(validatorKey.PubKey().Address())
+		validatorAddress := sdk.ValAddress(validatorKey.PubKey().Address())
 		delegatorKey := simulation.RandomKey(r, keys)
 		delegatorAddress := sdk.AccAddress(delegatorKey.PubKey().Address())
 		msg := stake.MsgCompleteUnbonding{
@@ -174,9 +174,9 @@ func SimulateMsgBeginRedelegate(m auth.AccountMapper, k stake.Keeper) simulation
 	return func(t *testing.T, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, log string, event func(string)) (action string, err sdk.Error) {
 		denom := k.GetParams(ctx).BondDenom
 		sourceValidatorKey := simulation.RandomKey(r, keys)
-		sourceValidatorAddress := sdk.AccAddress(sourceValidatorKey.PubKey().Address())
+		sourceValidatorAddress := sdk.ValAddress(sourceValidatorKey.PubKey().Address())
 		destValidatorKey := simulation.RandomKey(r, keys)
-		destValidatorAddress := sdk.AccAddress(destValidatorKey.PubKey().Address())
+		destValidatorAddress := sdk.ValAddress(destValidatorKey.PubKey().Address())
 		delegatorKey := simulation.RandomKey(r, keys)
 		delegatorAddress := sdk.AccAddress(delegatorKey.PubKey().Address())
 		// TODO
@@ -209,9 +209,9 @@ func SimulateMsgBeginRedelegate(m auth.AccountMapper, k stake.Keeper) simulation
 func SimulateMsgCompleteRedelegate(k stake.Keeper) simulation.TestAndRunTx {
 	return func(t *testing.T, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, log string, event func(string)) (action string, err sdk.Error) {
 		validatorSrcKey := simulation.RandomKey(r, keys)
-		validatorSrcAddress := sdk.AccAddress(validatorSrcKey.PubKey().Address())
+		validatorSrcAddress := sdk.ValAddress(validatorSrcKey.PubKey().Address())
 		validatorDstKey := simulation.RandomKey(r, keys)
-		validatorDstAddress := sdk.AccAddress(validatorDstKey.PubKey().Address())
+		validatorDstAddress := sdk.ValAddress(validatorDstKey.PubKey().Address())
 		delegatorKey := simulation.RandomKey(r, keys)
 		delegatorAddress := sdk.AccAddress(delegatorKey.PubKey().Address())
 		msg := stake.MsgCompleteRedelegate{
diff --git a/x/stake/types/delegation_test.go b/x/stake/types/delegation_test.go
index 5624b71015e6..8e0dda7e247b 100644
--- a/x/stake/types/delegation_test.go
+++ b/x/stake/types/delegation_test.go
@@ -10,12 +10,12 @@ import (
 
 func TestDelegationEqual(t *testing.T) {
 	d1 := Delegation{
-		DelegatorAddr: addr1,
+		DelegatorAddr: sdk.AccAddress(addr1),
 		ValidatorAddr: addr2,
 		Shares:        sdk.NewDec(100),
 	}
 	d2 := Delegation{
-		DelegatorAddr: addr1,
+		DelegatorAddr: sdk.AccAddress(addr1),
 		ValidatorAddr: addr2,
 		Shares:        sdk.NewDec(100),
 	}
@@ -23,7 +23,7 @@ func TestDelegationEqual(t *testing.T) {
 	ok := d1.Equal(d2)
 	require.True(t, ok)
 
-	d2.ValidatorAddr = addr3
+	d2.ValidatorAddr = sdk.ValAddress(addr3)
 	d2.Shares = sdk.NewDec(200)
 
 	ok = d1.Equal(d2)
@@ -32,7 +32,7 @@ func TestDelegationEqual(t *testing.T) {
 
 func TestDelegationHumanReadableString(t *testing.T) {
 	d := Delegation{
-		DelegatorAddr: addr1,
+		DelegatorAddr: sdk.AccAddress(addr1),
 		ValidatorAddr: addr2,
 		Shares:        sdk.NewDec(100),
 	}
@@ -46,18 +46,18 @@ func TestDelegationHumanReadableString(t *testing.T) {
 
 func TestUnbondingDelegationEqual(t *testing.T) {
 	ud1 := UnbondingDelegation{
-		DelegatorAddr: addr1,
+		DelegatorAddr: sdk.AccAddress(addr1),
 		ValidatorAddr: addr2,
 	}
 	ud2 := UnbondingDelegation{
-		DelegatorAddr: addr1,
+		DelegatorAddr: sdk.AccAddress(addr1),
 		ValidatorAddr: addr2,
 	}
 
 	ok := ud1.Equal(ud2)
 	require.True(t, ok)
 
-	ud2.ValidatorAddr = addr3
+	ud2.ValidatorAddr = sdk.ValAddress(addr3)
 
 	ud2.MinTime = time.Unix(20*20*2, 0)
 	ok = ud1.Equal(ud2)
@@ -66,7 +66,7 @@ func TestUnbondingDelegationEqual(t *testing.T) {
 
 func TestUnbondingDelegationHumanReadableString(t *testing.T) {
 	ud := UnbondingDelegation{
-		DelegatorAddr: addr1,
+		DelegatorAddr: sdk.AccAddress(addr1),
 		ValidatorAddr: addr2,
 	}
 
@@ -79,12 +79,12 @@ func TestUnbondingDelegationHumanReadableString(t *testing.T) {
 
 func TestRedelegationEqual(t *testing.T) {
 	r1 := Redelegation{
-		DelegatorAddr:    addr1,
+		DelegatorAddr:    sdk.AccAddress(addr1),
 		ValidatorSrcAddr: addr2,
 		ValidatorDstAddr: addr3,
 	}
 	r2 := Redelegation{
-		DelegatorAddr:    addr1,
+		DelegatorAddr:    sdk.AccAddress(addr1),
 		ValidatorSrcAddr: addr2,
 		ValidatorDstAddr: addr3,
 	}
@@ -102,7 +102,7 @@ func TestRedelegationEqual(t *testing.T) {
 
 func TestRedelegationHumanReadableString(t *testing.T) {
 	r := Redelegation{
-		DelegatorAddr:    addr1,
+		DelegatorAddr:    sdk.AccAddress(addr1),
 		ValidatorSrcAddr: addr2,
 		ValidatorDstAddr: addr3,
 		SharesDst:        sdk.NewDec(10),
diff --git a/x/stake/types/msg_test.go b/x/stake/types/msg_test.go
index 2be34fb20754..eb66c04220bd 100644
--- a/x/stake/types/msg_test.go
+++ b/x/stake/types/msg_test.go
@@ -19,7 +19,7 @@ var (
 func TestMsgCreateValidator(t *testing.T) {
 	tests := []struct {
 		name, moniker, identity, website, details string
-		validatorAddr                             sdk.AccAddress
+		validatorAddr                             sdk.ValAddress
 		pubkey                                    crypto.PubKey
 		bond                                      sdk.Coin
 		expectPass                                bool
@@ -49,7 +49,7 @@ func TestMsgCreateValidator(t *testing.T) {
 func TestMsgEditValidator(t *testing.T) {
 	tests := []struct {
 		name, moniker, identity, website, details string
-		validatorAddr                             sdk.AccAddress
+		validatorAddr                             sdk.ValAddress
 		expectPass                                bool
 	}{
 		{"basic good", "a", "b", "c", "d", addr1, true},
@@ -74,20 +74,20 @@ func TestMsgCreateValidatorOnBehalfOf(t *testing.T) {
 	tests := []struct {
 		name, moniker, identity, website, details string
 		delegatorAddr                             sdk.AccAddress
-		validatorAddr                             sdk.AccAddress
+		validatorAddr                             sdk.ValAddress
 		validatorPubKey                           crypto.PubKey
 		bond                                      sdk.Coin
 		expectPass                                bool
 	}{
-		{"basic good", "a", "b", "c", "d", addr1, addr2, pk2, coinPos, true},
-		{"partial description", "", "", "c", "", addr1, addr2, pk2, coinPos, true},
-		{"empty description", "", "", "", "", addr1, addr2, pk2, coinPos, false},
-		{"empty delegator address", "a", "b", "c", "d", emptyAddr, addr2, pk2, coinPos, false},
-		{"empty validator address", "a", "b", "c", "d", addr1, emptyAddr, pk2, coinPos, false},
-		{"empty pubkey", "a", "b", "c", "d", addr1, addr2, emptyPubkey, coinPos, true},
-		{"empty bond", "a", "b", "c", "d", addr1, addr2, pk2, coinZero, false},
-		{"negative bond", "a", "b", "c", "d", addr1, addr2, pk2, coinNeg, false},
-		{"negative bond", "a", "b", "c", "d", addr1, addr2, pk2, coinNeg, false},
+		{"basic good", "a", "b", "c", "d", sdk.AccAddress(addr1), addr2, pk2, coinPos, true},
+		{"partial description", "", "", "c", "", sdk.AccAddress(addr1), addr2, pk2, coinPos, true},
+		{"empty description", "", "", "", "", sdk.AccAddress(addr1), addr2, pk2, coinPos, false},
+		{"empty delegator address", "a", "b", "c", "d", sdk.AccAddress(emptyAddr), addr2, pk2, coinPos, false},
+		{"empty validator address", "a", "b", "c", "d", sdk.AccAddress(addr1), emptyAddr, pk2, coinPos, false},
+		{"empty pubkey", "a", "b", "c", "d", sdk.AccAddress(addr1), addr2, emptyPubkey, coinPos, true},
+		{"empty bond", "a", "b", "c", "d", sdk.AccAddress(addr1), addr2, pk2, coinZero, false},
+		{"negative bond", "a", "b", "c", "d", sdk.AccAddress(addr1), addr2, pk2, coinNeg, false},
+		{"negative bond", "a", "b", "c", "d", sdk.AccAddress(addr1), addr2, pk2, coinNeg, false},
 	}
 
 	for _, tc := range tests {
@@ -102,11 +102,11 @@ func TestMsgCreateValidatorOnBehalfOf(t *testing.T) {
 
 	msg := NewMsgCreateValidator(addr1, pk1, coinPos, Description{})
 	addrs := msg.GetSigners()
-	require.Equal(t, []sdk.AccAddress{addr1}, addrs, "Signers on default msg is wrong")
+	require.Equal(t, []sdk.AccAddress{sdk.AccAddress(addr1)}, addrs, "Signers on default msg is wrong")
 
-	msg = NewMsgCreateValidatorOnBehalfOf(addr2, addr1, pk1, coinPos, Description{})
+	msg = NewMsgCreateValidatorOnBehalfOf(sdk.AccAddress(addr2), addr1, pk1, coinPos, Description{})
 	addrs = msg.GetSigners()
-	require.Equal(t, []sdk.AccAddress{addr2, addr1}, addrs, "Signers for onbehalfof msg is wrong")
+	require.Equal(t, []sdk.AccAddress{sdk.AccAddress(addr2), sdk.AccAddress(addr1)}, addrs, "Signers for onbehalfof msg is wrong")
 }
 
 // test ValidateBasic for MsgDelegate
@@ -114,16 +114,16 @@ func TestMsgDelegate(t *testing.T) {
 	tests := []struct {
 		name          string
 		delegatorAddr sdk.AccAddress
-		validatorAddr sdk.AccAddress
+		validatorAddr sdk.ValAddress
 		bond          sdk.Coin
 		expectPass    bool
 	}{
-		{"basic good", addr1, addr2, coinPos, true},
-		{"self bond", addr1, addr1, coinPos, true},
-		{"empty delegator", emptyAddr, addr1, coinPos, false},
-		{"empty validator", addr1, emptyAddr, coinPos, false},
-		{"empty bond", addr1, addr2, coinZero, false},
-		{"negative bond", addr1, addr2, coinNeg, false},
+		{"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},
+		{"negative bond", sdk.AccAddress(addr1), addr2, coinNeg, false},
 	}
 
 	for _, tc := range tests {
@@ -141,17 +141,17 @@ func TestMsgBeginRedelegate(t *testing.T) {
 	tests := []struct {
 		name             string
 		delegatorAddr    sdk.AccAddress
-		validatorSrcAddr sdk.AccAddress
-		validatorDstAddr sdk.AccAddress
+		validatorSrcAddr sdk.ValAddress
+		validatorDstAddr sdk.ValAddress
 		sharesAmount     sdk.Dec
 		expectPass       bool
 	}{
-		{"regular", addr1, addr2, addr3, sdk.NewDecWithPrec(1, 1), true},
-		{"negative decimal", addr1, addr2, addr3, sdk.NewDecWithPrec(-1, 1), false},
-		{"zero amount", addr1, addr2, addr3, sdk.ZeroDec(), false},
-		{"empty delegator", emptyAddr, addr1, addr3, sdk.NewDecWithPrec(1, 1), false},
-		{"empty source validator", addr1, emptyAddr, addr3, sdk.NewDecWithPrec(1, 1), false},
-		{"empty destination validator", addr1, addr2, emptyAddr, sdk.NewDecWithPrec(1, 1), false},
+		{"regular", sdk.AccAddress(addr1), addr2, addr3, sdk.NewDecWithPrec(1, 1), true},
+		{"negative decimal", sdk.AccAddress(addr1), addr2, addr3, sdk.NewDecWithPrec(-1, 1), false},
+		{"zero amount", sdk.AccAddress(addr1), addr2, addr3, sdk.ZeroDec(), false},
+		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, addr3, sdk.NewDecWithPrec(1, 1), false},
+		{"empty source validator", sdk.AccAddress(addr1), emptyAddr, addr3, sdk.NewDecWithPrec(1, 1), false},
+		{"empty destination validator", sdk.AccAddress(addr1), addr2, emptyAddr, sdk.NewDecWithPrec(1, 1), false},
 	}
 
 	for _, tc := range tests {
@@ -169,14 +169,14 @@ func TestMsgCompleteRedelegate(t *testing.T) {
 	tests := []struct {
 		name             string
 		delegatorAddr    sdk.AccAddress
-		validatorSrcAddr sdk.AccAddress
-		validatorDstAddr sdk.AccAddress
+		validatorSrcAddr sdk.ValAddress
+		validatorDstAddr sdk.ValAddress
 		expectPass       bool
 	}{
-		{"regular", addr1, addr2, addr3, true},
-		{"empty delegator", emptyAddr, addr1, addr3, false},
-		{"empty source validator", addr1, emptyAddr, addr3, false},
-		{"empty destination validator", addr1, addr2, emptyAddr, false},
+		{"regular", sdk.AccAddress(addr1), addr2, addr3, true},
+		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, addr3, false},
+		{"empty source validator", sdk.AccAddress(addr1), emptyAddr, addr3, false},
+		{"empty destination validator", sdk.AccAddress(addr1), addr2, emptyAddr, false},
 	}
 
 	for _, tc := range tests {
@@ -194,15 +194,15 @@ func TestMsgBeginUnbonding(t *testing.T) {
 	tests := []struct {
 		name          string
 		delegatorAddr sdk.AccAddress
-		validatorAddr sdk.AccAddress
+		validatorAddr sdk.ValAddress
 		sharesAmount  sdk.Dec
 		expectPass    bool
 	}{
-		{"regular", addr1, addr2, sdk.NewDecWithPrec(1, 1), true},
-		{"negative decimal", addr1, addr2, sdk.NewDecWithPrec(-1, 1), false},
-		{"zero amount", addr1, addr2, sdk.ZeroDec(), false},
-		{"empty delegator", emptyAddr, addr1, sdk.NewDecWithPrec(1, 1), false},
-		{"empty validator", addr1, emptyAddr, sdk.NewDecWithPrec(1, 1), false},
+		{"regular", sdk.AccAddress(addr1), addr2, sdk.NewDecWithPrec(1, 1), true},
+		{"negative decimal", sdk.AccAddress(addr1), addr2, sdk.NewDecWithPrec(-1, 1), false},
+		{"zero amount", sdk.AccAddress(addr1), addr2, sdk.ZeroDec(), false},
+		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, sdk.NewDecWithPrec(1, 1), false},
+		{"empty validator", sdk.AccAddress(addr1), emptyAddr, sdk.NewDecWithPrec(1, 1), false},
 	}
 
 	for _, tc := range tests {
@@ -220,12 +220,12 @@ func TestMsgCompleteUnbonding(t *testing.T) {
 	tests := []struct {
 		name          string
 		delegatorAddr sdk.AccAddress
-		validatorAddr sdk.AccAddress
+		validatorAddr sdk.ValAddress
 		expectPass    bool
 	}{
-		{"regular", addr1, addr2, true},
-		{"empty delegator", emptyAddr, addr1, false},
-		{"empty validator", addr1, emptyAddr, false},
+		{"regular", sdk.AccAddress(addr1), addr2, true},
+		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, false},
+		{"empty validator", sdk.AccAddress(addr1), emptyAddr, false},
 	}
 
 	for _, tc := range tests {
diff --git a/x/stake/types/test_utils.go b/x/stake/types/test_utils.go
index 02c4d4fca9a4..b9d77ce9f55a 100644
--- a/x/stake/types/test_utils.go
+++ b/x/stake/types/test_utils.go
@@ -10,10 +10,10 @@ var (
 	pk1   = ed25519.GenPrivKey().PubKey()
 	pk2   = ed25519.GenPrivKey().PubKey()
 	pk3   = ed25519.GenPrivKey().PubKey()
-	addr1 = sdk.AccAddress(pk1.Address())
-	addr2 = sdk.AccAddress(pk2.Address())
-	addr3 = sdk.AccAddress(pk3.Address())
+	addr1 = sdk.ValAddress(pk1.Address())
+	addr2 = sdk.ValAddress(pk2.Address())
+	addr3 = sdk.ValAddress(pk3.Address())
 
-	emptyAddr   sdk.AccAddress
+	emptyAddr   sdk.ValAddress
 	emptyPubkey crypto.PubKey
 )

From 27f160e6f3555fc79e1fdc966f8ed8c2f97aed1f Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 21 Aug 2018 11:02:12 -0400
Subject: [PATCH 19/34] Fix gov logs (helping to debug failing tests)

---
 x/gov/handler.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/x/gov/handler.go b/x/gov/handler.go
index 4fa3887296b9..6424bb0a1056 100644
--- a/x/gov/handler.go
+++ b/x/gov/handler.go
@@ -114,8 +114,8 @@ func EndBlocker(ctx sdk.Context, keeper Keeper) (resTags sdk.Tags) {
 		resTags.AppendTag(tags.Action, tags.ActionProposalDropped)
 		resTags.AppendTag(tags.ProposalID, proposalIDBytes)
 
-		logger.Info("Proposal %d - \"%s\" - didn't mean minimum deposit (had only %s), deleted",
-			inactiveProposal.GetProposalID(), inactiveProposal.GetTitle(), inactiveProposal.GetTotalDeposit())
+		logger.Info(fmt.Sprintf("Proposal %d - \"%s\" - didn't mean minimum deposit (had only %s), deleted",
+			inactiveProposal.GetProposalID(), inactiveProposal.GetTitle(), inactiveProposal.GetTotalDeposit()))
 	}
 
 	// Check if earliest Active Proposal ended voting period yet
@@ -143,8 +143,8 @@ func EndBlocker(ctx sdk.Context, keeper Keeper) (resTags sdk.Tags) {
 		activeProposal.SetTallyResult(tallyResults)
 		keeper.SetProposal(ctx, activeProposal)
 
-		logger.Info("Proposal %d - \"%s\" - tallied, passed: %v",
-			activeProposal.GetProposalID(), activeProposal.GetTitle(), passes)
+		logger.Info(fmt.Sprintf("Proposal %d - \"%s\" - tallied, passed: %v",
+			activeProposal.GetProposalID(), activeProposal.GetTitle(), passes))
 
 		for _, valAddr := range nonVotingVals {
 			val := keeper.ds.GetValidatorSet().Validator(ctx, valAddr)

From d547484a59399ba184e439147b718e67d5ed68c7 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 21 Aug 2018 11:53:34 -0400
Subject: [PATCH 20/34] Fix gov tally

---
 x/gov/tally.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/x/gov/tally.go b/x/gov/tally.go
index aae98a07efc1..a8a3e007a813 100644
--- a/x/gov/tally.go
+++ b/x/gov/tally.go
@@ -42,9 +42,10 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 
 		// if validator, just record it in the map
 		// if delegator tally voting power
-		if val, ok := currValidators[vote.Voter.String()]; ok {
+		valAddr := sdk.ValAddress(vote.Voter)
+		if val, ok := currValidators[valAddr.String()]; ok {
 			val.Vote = vote.Option
-			currValidators[vote.Voter.String()] = val
+			currValidators[valAddr.String()] = val
 		} else {
 
 			keeper.ds.IterateDelegations(ctx, vote.Voter, func(index int64, delegation sdk.Delegation) (stop bool) {

From 8ecc12e025a3b6d5777cf14759e00129d2f59274 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 21 Aug 2018 12:01:45 -0400
Subject: [PATCH 21/34] Fix all broken x/ unit tests

---
 x/gov/tally.go      | 14 +++++++++-----
 x/gov/tally_test.go |  2 +-
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/x/gov/tally.go b/x/gov/tally.go
index a8a3e007a813..df37194704b9 100644
--- a/x/gov/tally.go
+++ b/x/gov/tally.go
@@ -42,16 +42,18 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 
 		// if validator, just record it in the map
 		// if delegator tally voting power
-		valAddr := sdk.ValAddress(vote.Voter)
-		if val, ok := currValidators[valAddr.String()]; ok {
+		valAddrStr := sdk.ValAddress(vote.Voter).String()
+		if val, ok := currValidators[valAddrStr]; ok {
 			val.Vote = vote.Option
-			currValidators[valAddr.String()] = val
+			currValidators[valAddrStr] = val
 		} else {
 
 			keeper.ds.IterateDelegations(ctx, vote.Voter, func(index int64, delegation sdk.Delegation) (stop bool) {
-				if val, ok := currValidators[delegation.GetValidator().String()]; ok {
+				valAddrStr := delegation.GetValidator().String()
+
+				if val, ok := currValidators[valAddrStr]; ok {
 					val.Minus = val.Minus.Add(delegation.GetBondShares())
-					currValidators[delegation.GetValidator().String()] = val
+					currValidators[valAddrStr] = val
 
 					delegatorShare := delegation.GetBondShares().Quo(val.DelegatorShares)
 					votingPower := val.Power.Mul(delegatorShare)
@@ -59,12 +61,14 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 					results[vote.Option] = results[vote.Option].Add(votingPower)
 					totalVotingPower = totalVotingPower.Add(votingPower)
 				}
+
 				return false
 			})
 		}
 
 		keeper.deleteVote(ctx, vote.ProposalID, vote.Voter)
 	}
+
 	votesIterator.Close()
 
 	// iterate over the validators again to tally their voting power and see
diff --git a/x/gov/tally_test.go b/x/gov/tally_test.go
index 8db306fbc097..e418719b8a49 100644
--- a/x/gov/tally_test.go
+++ b/x/gov/tally_test.go
@@ -259,7 +259,7 @@ func TestTallyOnlyValidatorsNonVoter(t *testing.T) {
 
 	require.False(t, passes)
 	require.Equal(t, 1, len(nonVoting))
-	require.Equal(t, addrs[0], nonVoting[0])
+	require.Equal(t, sdk.ValAddress(addrs[0]), nonVoting[0])
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
 }
 

From 38618a3582d76b71765b72bd2c3b16174802f12c Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 21 Aug 2018 12:08:59 -0400
Subject: [PATCH 22/34] Update gaia app genesis address logic

---
 cmd/gaia/app/genesis.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmd/gaia/app/genesis.go b/cmd/gaia/app/genesis.go
index b439c0d3409d..ea40a56bda6b 100644
--- a/cmd/gaia/app/genesis.go
+++ b/cmd/gaia/app/genesis.go
@@ -191,7 +191,7 @@ func GaiaAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (genesisState
 		if len(genTx.Name) > 0 {
 			desc := stake.NewDescription(genTx.Name, "", "", "")
 			validator := stake.NewValidator(
-				genTx.Address, sdk.MustGetConsPubKeyBech32(genTx.PubKey), desc,
+				sdk.ValAddress(genTx.Address), sdk.MustGetConsPubKeyBech32(genTx.PubKey), desc,
 			)
 
 			stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewDec(freeFermionVal)) // increase the supply
@@ -203,7 +203,7 @@ func GaiaAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (genesisState
 
 			// create the self-delegation from the issuedDelShares
 			delegation := stake.Delegation{
-				DelegatorAddr: validator.Operator,
+				DelegatorAddr: sdk.AccAddress(validator.Operator),
 				ValidatorAddr: validator.Operator,
 				Shares:        issuedDelShares,
 				Height:        0,

From 5a4d0b201596aeb612ded1fbd525c24b3fdbaac9 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 21 Aug 2018 12:57:32 -0400
Subject: [PATCH 23/34] Fix linting errors

---
 client/lcd/lcd_test.go                     | 44 +++++++++++-----------
 cmd/gaia/app/sim_test.go                   |  4 +-
 examples/democoin/mock/validator.go        |  8 ++--
 examples/democoin/x/assoc/validator_set.go | 22 +++++------
 examples/democoin/x/oracle/handler.go      |  4 +-
 5 files changed, 42 insertions(+), 40 deletions(-)

diff --git a/client/lcd/lcd_test.go b/client/lcd/lcd_test.go
index 3fd766bd2fbe..5b2c15c830eb 100644
--- a/client/lcd/lcd_test.go
+++ b/client/lcd/lcd_test.go
@@ -422,7 +422,7 @@ func TestBonding(t *testing.T) {
 	cleanup, pks, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
 	defer cleanup()
 
-	validator1Operator := sdk.AccAddress(pks[0].Address())
+	validator1Operator := sdk.ValAddress(pks[0].Address())
 	validator := getValidator(t, port, validator1Operator)
 
 	// create bond TX
@@ -798,8 +798,8 @@ func getSigningInfo(t *testing.T, port string, validatorPubKey string) slashing.
 
 // ============= Stake Module ================
 
-func getDelegation(t *testing.T, port string, delegatorAddr, validatorAddr sdk.AccAddress) rest.DelegationWithoutRat {
-	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/delegations/%s", delegatorAddr, validatorAddr), nil)
+func getDelegation(t *testing.T, port string, delAddr sdk.AccAddress, valAddr sdk.ValAddress) rest.DelegationWithoutRat {
+	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/delegations/%s", delAddr, valAddr), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
 
 	var bond rest.DelegationWithoutRat
@@ -810,8 +810,8 @@ func getDelegation(t *testing.T, port string, delegatorAddr, validatorAddr sdk.A
 	return bond
 }
 
-func getUndelegations(t *testing.T, port string, delegatorAddr, validatorAddr sdk.AccAddress) []stake.UnbondingDelegation {
-	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/unbonding_delegations/%s", delegatorAddr, validatorAddr), nil)
+func getUndelegations(t *testing.T, port string, delAddr sdk.AccAddress, valAddr sdk.ValAddress) []stake.UnbondingDelegation {
+	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/unbonding_delegations/%s", delAddr, valAddr), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
 
 	var unbondings []stake.UnbondingDelegation
@@ -865,8 +865,8 @@ func getDelegatorValidators(t *testing.T, port string, delegatorAddr sdk.AccAddr
 	return bondedValidators
 }
 
-func getDelegatorValidator(t *testing.T, port string, delegatorAddr sdk.AccAddress, validatorAddr sdk.AccAddress) stake.BechValidator {
-	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/validators/%s", delegatorAddr, validatorAddr), nil)
+func getDelegatorValidator(t *testing.T, port string, delAddr sdk.AccAddress, valAddr sdk.ValAddress) stake.BechValidator {
+	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/validators/%s", delAddr, valAddr), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
 
 	var bondedValidator stake.BechValidator
@@ -876,8 +876,10 @@ func getDelegatorValidator(t *testing.T, port string, delegatorAddr sdk.AccAddre
 	return bondedValidator
 }
 
-func doDelegate(t *testing.T, port, seed, name, password string, delegatorAddr, validatorAddr sdk.AccAddress, amount int64) (resultTx ctypes.ResultBroadcastTxCommit) {
-	acc := getAccount(t, port, delegatorAddr)
+func doDelegate(t *testing.T, port, seed, name, password string,
+	delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount int64) (resultTx ctypes.ResultBroadcastTxCommit) {
+
+	acc := getAccount(t, port, delAddr)
 	accnum := acc.GetAccountNumber()
 	sequence := acc.GetSequence()
 	chainID := viper.GetString(client.FlagChainID)
@@ -900,9 +902,9 @@ func doDelegate(t *testing.T, port, seed, name, password string, delegatorAddr,
 		"complete_unbondings": [],
 		"begin_redelegates": [],
 		"complete_redelegates": []
-	}`, name, password, accnum, sequence, chainID, delegatorAddr, validatorAddr, "steak", amount))
+	}`, name, password, accnum, sequence, chainID, delAddr, valAddr, "steak", amount))
 
-	res, body := Request(t, port, "POST", fmt.Sprintf("/stake/delegators/%s/delegations", delegatorAddr), jsonStr)
+	res, body := Request(t, port, "POST", fmt.Sprintf("/stake/delegators/%s/delegations", delAddr), jsonStr)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
 
 	var results []ctypes.ResultBroadcastTxCommit
@@ -913,9 +915,9 @@ func doDelegate(t *testing.T, port, seed, name, password string, delegatorAddr,
 }
 
 func doBeginUnbonding(t *testing.T, port, seed, name, password string,
-	delegatorAddr, validatorAddr sdk.AccAddress, amount int64) (resultTx ctypes.ResultBroadcastTxCommit) {
+	delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount int64) (resultTx ctypes.ResultBroadcastTxCommit) {
 
-	acc := getAccount(t, port, delegatorAddr)
+	acc := getAccount(t, port, delAddr)
 	accnum := acc.GetAccountNumber()
 	sequence := acc.GetSequence()
 	chainID := viper.GetString(client.FlagChainID)
@@ -938,9 +940,9 @@ func doBeginUnbonding(t *testing.T, port, seed, name, password string,
 		"complete_unbondings": [],
 		"begin_redelegates": [],
 		"complete_redelegates": []
-	}`, name, password, accnum, sequence, chainID, delegatorAddr, validatorAddr, amount))
+	}`, name, password, accnum, sequence, chainID, delAddr, valAddr, amount))
 
-	res, body := Request(t, port, "POST", fmt.Sprintf("/stake/delegators/%s/delegations", delegatorAddr), jsonStr)
+	res, body := Request(t, port, "POST", fmt.Sprintf("/stake/delegators/%s/delegations", delAddr), jsonStr)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
 
 	var results []ctypes.ResultBroadcastTxCommit
@@ -951,9 +953,9 @@ func doBeginUnbonding(t *testing.T, port, seed, name, password string,
 }
 
 func doBeginRedelegation(t *testing.T, port, seed, name, password string,
-	delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.AccAddress) (resultTx ctypes.ResultBroadcastTxCommit) {
+	delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) (resultTx ctypes.ResultBroadcastTxCommit) {
 
-	acc := getAccount(t, port, delegatorAddr)
+	acc := getAccount(t, port, delAddr)
 	accnum := acc.GetAccountNumber()
 	sequence := acc.GetSequence()
 
@@ -978,9 +980,9 @@ func doBeginRedelegation(t *testing.T, port, seed, name, password string,
 			}
 		],
 		"complete_redelegates": []
-	}`, name, password, accnum, sequence, chainID, delegatorAddr, validatorSrcAddr, validatorDstAddr))
+	}`, name, password, accnum, sequence, chainID, delAddr, valSrcAddr, valDstAddr))
 
-	res, body := Request(t, port, "POST", fmt.Sprintf("/stake/delegators/%s/delegations", delegatorAddr), jsonStr)
+	res, body := Request(t, port, "POST", fmt.Sprintf("/stake/delegators/%s/delegations", delAddr), jsonStr)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
 
 	var results []ctypes.ResultBroadcastTxCommit
@@ -999,8 +1001,8 @@ func getValidators(t *testing.T, port string) []stake.BechValidator {
 	return validators
 }
 
-func getValidator(t *testing.T, port string, validatorAddr sdk.AccAddress) stake.BechValidator {
-	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/validators/%s", validatorAddr.String()), nil)
+func getValidator(t *testing.T, port string, valAddr sdk.ValAddress) stake.BechValidator {
+	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/validators/%s", valAddr.String()), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
 	var validator stake.BechValidator
 	err := cdc.UnmarshalJSON([]byte(body), &validator)
diff --git a/cmd/gaia/app/sim_test.go b/cmd/gaia/app/sim_test.go
index 051508e1a926..3734450dbbe5 100644
--- a/cmd/gaia/app/sim_test.go
+++ b/cmd/gaia/app/sim_test.go
@@ -58,10 +58,10 @@ func appStateFn(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json
 	// XXX Try different numbers of initially bonded validators
 	numInitiallyBonded := int64(50)
 	for i := 0; i < int(numInitiallyBonded); i++ {
-		validator := stake.NewValidator(accs[i], keys[i].PubKey(), stake.Description{})
+		validator := stake.NewValidator(sdk.ValAddress(accs[i]), keys[i].PubKey(), stake.Description{})
 		validator.Tokens = sdk.NewDec(100)
 		validator.DelegatorShares = sdk.NewDec(100)
-		delegation := stake.Delegation{accs[i], accs[i], sdk.NewDec(100), 0}
+		delegation := stake.Delegation{accs[i], sdk.ValAddress(accs[i]), sdk.NewDec(100), 0}
 		validators = append(validators, validator)
 		delegations = append(delegations, delegation)
 	}
diff --git a/examples/democoin/mock/validator.go b/examples/democoin/mock/validator.go
index f76f14803e96..64b236c90ec9 100644
--- a/examples/democoin/mock/validator.go
+++ b/examples/democoin/mock/validator.go
@@ -9,7 +9,7 @@ import (
 
 // Validator implements sdk.Validator
 type Validator struct {
-	Address sdk.AccAddress
+	Address sdk.ValAddress
 	Power   sdk.Dec
 }
 
@@ -19,7 +19,7 @@ func (v Validator) GetStatus() sdk.BondStatus {
 }
 
 // Implements sdk.Validator
-func (v Validator) GetOperator() sdk.AccAddress {
+func (v Validator) GetOperator() sdk.ValAddress {
 	return v.Address
 }
 
@@ -78,9 +78,9 @@ func (vs *ValidatorSet) IterateValidatorsBonded(ctx sdk.Context, fn func(index i
 }
 
 // Validator implements sdk.ValidatorSet
-func (vs *ValidatorSet) Validator(ctx sdk.Context, addr sdk.AccAddress) sdk.Validator {
+func (vs *ValidatorSet) Validator(ctx sdk.Context, addr sdk.ValAddress) sdk.Validator {
 	for _, val := range vs.Validators {
-		if bytes.Equal(val.Address, addr) {
+		if bytes.Equal(val.Address.Bytes(), addr.Bytes()) {
 			return val
 		}
 	}
diff --git a/examples/democoin/x/assoc/validator_set.go b/examples/democoin/x/assoc/validator_set.go
index 03ce506ea0f1..7a84c037facf 100644
--- a/examples/democoin/x/assoc/validator_set.go
+++ b/examples/democoin/x/assoc/validator_set.go
@@ -37,7 +37,7 @@ func NewValidatorSet(cdc *wire.Codec, store sdk.KVStore, valset sdk.ValidatorSet
 }
 
 // Implements sdk.ValidatorSet
-func (valset ValidatorSet) Validator(ctx sdk.Context, addr sdk.AccAddress) (res sdk.Validator) {
+func (valset ValidatorSet) Validator(ctx sdk.Context, addr sdk.ValAddress) (res sdk.Validator) {
 	base := valset.store.Get(GetBaseKey(addr))
 	res = valset.ValidatorSet.Validator(ctx, base)
 	if res == nil {
@@ -46,23 +46,23 @@ func (valset ValidatorSet) Validator(ctx sdk.Context, addr sdk.AccAddress) (res
 	return
 }
 
-// GetBaseKey :: sdk.AccAddress -> sdk.AccAddress
-func GetBaseKey(addr sdk.AccAddress) []byte {
+// GetBaseKey :: sdk.ValAddress -> sdk.ValAddress
+func GetBaseKey(addr sdk.ValAddress) []byte {
 	return append([]byte{0x00}, addr...)
 }
 
-// GetAssocPrefix :: sdk.AccAddress -> (sdk.AccAddress -> byte)
-func GetAssocPrefix(base sdk.AccAddress) []byte {
+// GetAssocPrefix :: sdk.ValAddress -> (sdk.ValAddress -> byte)
+func GetAssocPrefix(base sdk.ValAddress) []byte {
 	return append([]byte{0x01}, base...)
 }
 
-// GetAssocKey :: (sdk.AccAddress, sdk.AccAddress) -> byte
-func GetAssocKey(base sdk.AccAddress, assoc sdk.AccAddress) []byte {
+// GetAssocKey :: (sdk.ValAddress, sdk.ValAddress) -> byte
+func GetAssocKey(base sdk.ValAddress, assoc sdk.ValAddress) []byte {
 	return append(append([]byte{0x01}, base...), assoc...)
 }
 
 // Associate associates new address with validator address
-func (valset ValidatorSet) Associate(ctx sdk.Context, base sdk.AccAddress, assoc sdk.AccAddress) bool {
+func (valset ValidatorSet) Associate(ctx sdk.Context, base sdk.ValAddress, assoc sdk.ValAddress) bool {
 	if len(base) != valset.addrLen || len(assoc) != valset.addrLen {
 		return false
 	}
@@ -76,7 +76,7 @@ func (valset ValidatorSet) Associate(ctx sdk.Context, base sdk.AccAddress, assoc
 }
 
 // Dissociate removes association between addresses
-func (valset ValidatorSet) Dissociate(ctx sdk.Context, base sdk.AccAddress, assoc sdk.AccAddress) bool {
+func (valset ValidatorSet) Dissociate(ctx sdk.Context, base sdk.ValAddress, assoc sdk.ValAddress) bool {
 	if len(base) != valset.addrLen || len(assoc) != valset.addrLen {
 		return false
 	}
@@ -90,8 +90,8 @@ func (valset ValidatorSet) Dissociate(ctx sdk.Context, base sdk.AccAddress, asso
 }
 
 // Associations returns all associated addresses with a validator
-func (valset ValidatorSet) Associations(ctx sdk.Context, base sdk.AccAddress) (res []sdk.AccAddress) {
-	res = make([]sdk.AccAddress, valset.maxAssoc)
+func (valset ValidatorSet) Associations(ctx sdk.Context, base sdk.ValAddress) (res []sdk.ValAddress) {
+	res = make([]sdk.ValAddress, valset.maxAssoc)
 	iter := sdk.KVStorePrefixIterator(valset.store, GetAssocPrefix(base))
 	i := 0
 	for ; iter.Valid(); iter.Next() {
diff --git a/examples/democoin/x/oracle/handler.go b/examples/democoin/x/oracle/handler.go
index 3c78fc566be6..f20bda1be0c7 100644
--- a/examples/democoin/x/oracle/handler.go
+++ b/examples/democoin/x/oracle/handler.go
@@ -67,8 +67,8 @@ func (keeper Keeper) Handle(h Handler, ctx sdk.Context, o Msg, codespace sdk.Cod
 	}
 	info.LastSigned = ctx.BlockHeight()
 
-	// Check the signer is a validater
-	val := valset.Validator(ctx, signer)
+	// check the signer is a validator
+	val := valset.Validator(ctx, sdk.ValAddress(signer))
 	if val == nil {
 		return ErrNotValidator(codespace, signer).Result()
 	}

From 7382250e5f2380fe6b229cfc933785ab498861ca Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 21 Aug 2018 13:05:16 -0400
Subject: [PATCH 24/34] Fix broken LCD tests

---
 client/lcd/lcd_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/client/lcd/lcd_test.go b/client/lcd/lcd_test.go
index 5b2c15c830eb..a47966863b24 100644
--- a/client/lcd/lcd_test.go
+++ b/client/lcd/lcd_test.go
@@ -205,7 +205,7 @@ func TestValidators(t *testing.T) {
 	require.NotEqual(t, rpc.ResultValidatorsOutput{}, resultVals)
 
 	require.Contains(t, resultVals.Validators[0].Address.String(), "cosmosvaladdr")
-	require.Contains(t, resultVals.Validators[0].PubKey, "cosmosvalpub")
+	require.Contains(t, resultVals.Validators[0].PubKey, "cosmosconspub")
 
 	// --
 

From 8b164b4543bc4e215d1bf9f620856b2e980cb6f1 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Tue, 21 Aug 2018 14:30:10 -0400
Subject: [PATCH 25/34] Fix broken CLI tests

---
 cmd/gaia/cli_test/cli_test.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/cmd/gaia/cli_test/cli_test.go b/cmd/gaia/cli_test/cli_test.go
index 0b54d5bd88ef..b0423e246f84 100644
--- a/cmd/gaia/cli_test/cli_test.go
+++ b/cmd/gaia/cli_test/cli_test.go
@@ -137,14 +137,14 @@ func TestGaiaCLICreateValidator(t *testing.T) {
 	barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags))
 	require.Equal(t, int64(8), barAcc.GetCoins().AmountOf("steak").Int64(), "%v", barAcc)
 
-	validator := executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %s --output=json %v", barAddr, flags))
-	require.Equal(t, validator.Operator, barAddr)
+	validator := executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %s --output=json %v", sdk.ValAddress(barAddr), flags))
+	require.Equal(t, validator.Operator, sdk.ValAddress(barAddr))
 	require.True(sdk.DecEq(t, sdk.NewDec(2), validator.Tokens))
 
 	// unbond a single share
 	unbondStr := fmt.Sprintf("gaiacli stake unbond begin %v", flags)
 	unbondStr += fmt.Sprintf(" --from=%s", "bar")
-	unbondStr += fmt.Sprintf(" --validator=%s", barAddr)
+	unbondStr += fmt.Sprintf(" --validator=%s", sdk.ValAddress(barAddr))
 	unbondStr += fmt.Sprintf(" --shares-amount=%v", "1")
 
 	success := executeWrite(t, unbondStr, app.DefaultKeyPass)
@@ -155,7 +155,7 @@ func TestGaiaCLICreateValidator(t *testing.T) {
 	barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags))
 	require.Equal(t, int64(9), barAcc.GetCoins().AmountOf("steak").Int64(), "%v", barAcc)
 	*/
-	validator = executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %s --output=json %v", barAddr, flags))
+	validator = executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %s --output=json %v", sdk.ValAddress(barAddr), flags))
 	require.Equal(t, "1.0000000000", validator.Tokens.String())
 
 	params := executeGetParams(t, fmt.Sprintf("gaiacli stake parameters --output=json %v", flags))

From 5a030d35121cdb2552afbba243833c2fe1ee8656 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 22 Aug 2018 08:49:53 -0400
Subject: [PATCH 26/34] Implement command to get validator address and pubkey
 from key name

---
 client/keys/add.go   |  3 ++-
 client/keys/root.go  |  1 +
 client/keys/show.go  | 24 +++++++++++++++++++++++-
 client/keys/utils.go | 38 +++++++++++++++++++++++++++++---------
 client/keys/wire.go  |  3 +++
 types/account.go     | 11 +++++++++++
 6 files changed, 69 insertions(+), 11 deletions(-)

diff --git a/client/keys/add.go b/client/keys/add.go
index d462db1c0697..c4217281968e 100644
--- a/client/keys/add.go
+++ b/client/keys/add.go
@@ -128,7 +128,8 @@ func printCreate(info keys.Info, seed string) {
 	output := viper.Get(cli.OutputFlag)
 	switch output {
 	case "text":
-		printInfo(info)
+		printKeyInfo(info, Bech32KeyOutput)
+
 		// print seed unless requested not to.
 		if !viper.GetBool(client.FlagUseLedger) && !viper.GetBool(flagNoBackup) {
 			fmt.Println("**Important** write this seed phrase in a safe place.")
diff --git a/client/keys/root.go b/client/keys/root.go
index c8f6aea693af..3ff8cf0c1894 100644
--- a/client/keys/root.go
+++ b/client/keys/root.go
@@ -22,6 +22,7 @@ func Commands() *cobra.Command {
 		addKeyCommand(),
 		listKeysCmd,
 		showKeysCmd,
+		showValKeysCmd,
 		client.LineBreak,
 		deleteKeyCommand(),
 		updateKeyCommand(),
diff --git a/client/keys/show.go b/client/keys/show.go
index 873c45a4b605..c88a00d3a32d 100644
--- a/client/keys/show.go
+++ b/client/keys/show.go
@@ -19,12 +19,34 @@ var showKeysCmd = &cobra.Command{
 		name := args[0]
 		info, err := getKey(name)
 		if err == nil {
-			printInfo(info)
+			printKeyInfo(info, Bech32KeyOutput)
 		}
 		return err
 	},
 }
 
+var showValKeysCmd = &cobra.Command{
+	Use:   "show-validator <name>",
+	Short: "Show validator key info for the given name",
+	Long: `Return public key details of one local key for a given name that operates a validator
+
+Example:
+
+$ gaiacli keys show-validator node0
+`,
+	Args: cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		name := args[0]
+
+		info, err := getKey(name)
+		if err == nil {
+			printKeyInfo(info, Bech32ValKeyOutput)
+		}
+
+		return err
+	},
+}
+
 func getKey(name string) (keys.Info, error) {
 	kb, err := GetKeyBase()
 	if err != nil {
diff --git a/client/keys/utils.go b/client/keys/utils.go
index 907f9eda807c..e030855c9f83 100644
--- a/client/keys/utils.go
+++ b/client/keys/utils.go
@@ -97,11 +97,11 @@ func SetKeyBase(kb keys.Keybase) {
 
 // used for outputting keys.Info over REST
 type KeyOutput struct {
-	Name    string         `json:"name"`
-	Type    string         `json:"type"`
-	Address sdk.AccAddress `json:"address"`
-	PubKey  string         `json:"pub_key"`
-	Seed    string         `json:"seed,omitempty"`
+	Name    string      `json:"name"`
+	Type    string      `json:"type"`
+	Address sdk.Address `json:"address"`
+	PubKey  string      `json:"pub_key"`
+	Seed    string      `json:"seed,omitempty"`
 }
 
 // create a list of KeyOutput in bech32 format
@@ -119,24 +119,43 @@ func Bech32KeysOutput(infos []keys.Info) ([]KeyOutput, error) {
 
 // create a KeyOutput in bech32 format
 func Bech32KeyOutput(info keys.Info) (KeyOutput, error) {
-	account := sdk.AccAddress(info.GetPubKey().Address().Bytes())
+	accAddr := sdk.AccAddress(info.GetPubKey().Address().Bytes())
 	bechPubKey, err := sdk.Bech32ifyAccPub(info.GetPubKey())
 	if err != nil {
 		return KeyOutput{}, err
 	}
+
 	return KeyOutput{
 		Name:    info.GetName(),
 		Type:    info.GetType().String(),
-		Address: account,
+		Address: &accAddr,
 		PubKey:  bechPubKey,
 	}, nil
 }
 
-func printInfo(info keys.Info) {
-	ko, err := Bech32KeyOutput(info)
+// Bech32ValKeyOutput returns key output for a validator's key information.
+func Bech32ValKeyOutput(keyInfo keys.Info) (KeyOutput, error) {
+	valAddr := sdk.ValAddress(keyInfo.GetPubKey().Address().Bytes())
+
+	bechPubKey, err := sdk.Bech32ifyValPub(keyInfo.GetPubKey())
+	if err != nil {
+		return KeyOutput{}, err
+	}
+
+	return KeyOutput{
+		Name:    keyInfo.GetName(),
+		Type:    keyInfo.GetType().String(),
+		Address: &valAddr,
+		PubKey:  bechPubKey,
+	}, nil
+}
+
+func printKeyInfo(keyInfo keys.Info, bechKeyOut func(keyInfo keys.Info) (KeyOutput, error)) {
+	ko, err := bechKeyOut(keyInfo)
 	if err != nil {
 		panic(err)
 	}
+
 	switch viper.Get(cli.OutputFlag) {
 	case "text":
 		fmt.Printf("NAME:\tTYPE:\tADDRESS:\t\t\t\t\t\tPUBKEY:\n")
@@ -146,6 +165,7 @@ func printInfo(info keys.Info) {
 		if err != nil {
 			panic(err)
 		}
+
 		fmt.Println(string(out))
 	}
 }
diff --git a/client/keys/wire.go b/client/keys/wire.go
index a163f995a2ae..ed2902716f9f 100644
--- a/client/keys/wire.go
+++ b/client/keys/wire.go
@@ -1,6 +1,7 @@
 package keys
 
 import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/wire"
 )
 
@@ -8,6 +9,8 @@ var cdc *wire.Codec
 
 func init() {
 	cdc = wire.NewCodec()
+
+	cdc.RegisterInterface((*sdk.Address)(nil), nil)
 	wire.RegisterCrypto(cdc)
 }
 
diff --git a/types/account.go b/types/account.go
index 1b86f3e944a3..8e1e628ccefe 100644
--- a/types/account.go
+++ b/types/account.go
@@ -30,6 +30,17 @@ const (
 	Bech32PrefixConsPub = "cosmosconspub"
 )
 
+// Address defines an interface various implementations must implement
+type Address interface {
+	Marshal() ([]byte, error)
+	Unmarshal(data []byte) error
+	MarshalJSON() ([]byte, error)
+	UnmarshalJSON(data []byte) error
+	Bytes() []byte
+	String() string
+	Format(s fmt.State, verb rune)
+}
+
 // ----------------------------------------------------------------------------
 // account
 // ----------------------------------------------------------------------------

From 7e0460949092d5f95f7190e0cc1fc71bae5c76aa Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 22 Aug 2018 09:03:30 -0400
Subject: [PATCH 27/34] Add support for getting validator key information via
 REST endpoint

---
 client/keys/root.go  |  1 +
 client/keys/show.go  | 16 ++++++++++++++--
 client/keys/utils.go |  4 +++-
 3 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/client/keys/root.go b/client/keys/root.go
index 3ff8cf0c1894..f6469bbf0099 100644
--- a/client/keys/root.go
+++ b/client/keys/root.go
@@ -38,4 +38,5 @@ func RegisterRoutes(r *mux.Router) {
 	r.HandleFunc("/keys/{name}", GetKeyRequestHandler).Methods("GET")
 	r.HandleFunc("/keys/{name}", UpdateKeyRequestHandler).Methods("PUT")
 	r.HandleFunc("/keys/{name}", DeleteKeyRequestHandler).Methods("DELETE")
+	r.HandleFunc("/keys/validator/{name}", GetValKeyRequestHandler).Methods("GET")
 }
diff --git a/client/keys/show.go b/client/keys/show.go
index c88a00d3a32d..62a6f3dd9671 100644
--- a/client/keys/show.go
+++ b/client/keys/show.go
@@ -61,23 +61,35 @@ func getKey(name string) (keys.Info, error) {
 
 // get key REST handler
 func GetKeyRequestHandler(w http.ResponseWriter, r *http.Request) {
+	getKeyRequestHandler(w, r, Bech32KeyOutput)
+}
+
+// GetValKeyRequestHandler implements the request handler for getting a
+// validator's key information.
+func GetValKeyRequestHandler(w http.ResponseWriter, r *http.Request) {
+	getKeyRequestHandler(w, r, Bech32ValKeyOutput)
+}
+
+func getKeyRequestHandler(w http.ResponseWriter, r *http.Request, bechKeyOut bechKeyOutFn) {
 	vars := mux.Vars(r)
 	name := vars["name"]
 
 	info, err := getKey(name)
-	// TODO check for the error if key actually does not exist, instead of assuming this as the reason
+	// TODO: check for the error if key actually does not exist, instead of
+	// assuming this as the reason
 	if err != nil {
 		w.WriteHeader(404)
 		w.Write([]byte(err.Error()))
 		return
 	}
 
-	keyOutput, err := Bech32KeyOutput(info)
+	keyOutput, err := bechKeyOut(info)
 	if err != nil {
 		w.WriteHeader(500)
 		w.Write([]byte(err.Error()))
 		return
 	}
+
 	output, err := json.MarshalIndent(keyOutput, "", "  ")
 	if err != nil {
 		w.WriteHeader(500)
diff --git a/client/keys/utils.go b/client/keys/utils.go
index e030855c9f83..f4607029abc0 100644
--- a/client/keys/utils.go
+++ b/client/keys/utils.go
@@ -21,6 +21,8 @@ const KeyDBName = "keys"
 // keybase is used to make GetKeyBase a singleton
 var keybase keys.Keybase
 
+type bechKeyOutFn func(keyInfo keys.Info) (KeyOutput, error)
+
 // TODO make keybase take a database not load from the directory
 
 // initialize a keybase based on the configuration
@@ -150,7 +152,7 @@ func Bech32ValKeyOutput(keyInfo keys.Info) (KeyOutput, error) {
 	}, nil
 }
 
-func printKeyInfo(keyInfo keys.Info, bechKeyOut func(keyInfo keys.Info) (KeyOutput, error)) {
+func printKeyInfo(keyInfo keys.Info, bechKeyOut bechKeyOutFn) {
 	ko, err := bechKeyOut(keyInfo)
 	if err != nil {
 		panic(err)

From 394fdf83d2de3a71a88ce803e385cbb6c41c9ddd Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 22 Aug 2018 10:05:56 -0400
Subject: [PATCH 28/34] Update PENDING log

---
 PENDING.md | 41 +++++++++++++++++++++++------------------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/PENDING.md b/PENDING.md
index 7f297c0f3725..8cf169a478ad 100644
--- a/PENDING.md
+++ b/PENDING.md
@@ -3,23 +3,28 @@
 BREAKING CHANGES
 
 * Gaia REST API (`gaiacli advanced rest-server`)
-    * [x/stake] Validator.Owner renamed to Validator.Operator
+  * [x/stake] Validator.Owner renamed to Validator.Operator
 
 * Gaia CLI  (`gaiacli`)
-    * [x/stake] Validator.Owner renamed to Validator.Operator
-    * [cli] unsafe_reset_all, show_validator, and show_node_id have been renamed to unsafe-reset-all, show-validator, and show-node-id
+  * [x/stake] Validator.Owner renamed to Validator.Operator
+  * [cli] unsafe_reset_all, show_validator, and show_node_id have been renamed to unsafe-reset-all, show-validator, and show-node-id
+  * \#2040 All commands that utilize a validator's address must now use the new
+    bech32 prefix, `cosmosvaladdr`. A validator's Tendermint signing key and address
+    now use a new bech32 prefix, `cosmosconsaddr`.
 
 * Gaia
-    * Make the transient store key use a distinct store key. [#2013](https://github.com/cosmos/cosmos-sdk/pull/2013)
-    * [x/stake] \#1901 Validator type's Owner field renamed to Operator; Validator's GetOwner() renamed accordingly to comply with the SDK's Validator interface.
+  * Make the transient store key use a distinct store key. [#2013](https://github.com/cosmos/cosmos-sdk/pull/2013)
+  * [x/stake] \#1901 Validator type's Owner field renamed to Operator; Validator's GetOwner() renamed accordingly to comply with the SDK's Validator interface.
+  * [x/stake] \#2040 Validator operator type has now changed to `sdk.ValAddress`
+    * A new bech32 prefix has been introduced for Tendermint signing keys and
+    addresses, `cosmosconspub` and `cosmosconsaddr` respectively.
 
 * SDK
-    * [core] \#1807 Switch from use of rational to decimal
-    * [types] \#1901 Validator interface's GetOwner() renamed to GetOperator()
+  * [core] \#1807 Switch from use of rational to decimal
+  * [types] \#1901 Validator interface's GetOwner() renamed to GetOperator()
 
 * Tendermint
 
-
 FEATURES
 
 * Gaia REST API (`gaiacli advanced rest-server`)
@@ -27,6 +32,8 @@ FEATURES
 
 * Gaia CLI  (`gaiacli`)
   * [cli] Cmds to query staking pool and params
+  * \#2040 `gaiacli keys show-validator` and respective REST endpoint has been
+  introduced to provide validator operator key address and signing information.
 
 * Gaia
 
@@ -34,34 +41,32 @@ FEATURES
 
 * Tendermint
 
-
 IMPROVEMENTS
 
 * Gaia REST API (`gaiacli advanced rest-server`)
-    * [x/stake] \#2000 Added tests for new staking endpoints
+  * [x/stake] \#2000 Added tests for new staking endpoints
 
-* Gaia CLI  (`gaiacli`)
+* Gaia CLI (`gaiacli`)
 
 * Gaia
-    * [x/stake] [#2023](https://github.com/cosmos/cosmos-sdk/pull/2023) Terminate iteration loop in `UpdateBondedValidators` and `UpdateBondedValidatorsFull` when the first revoked validator is encountered and perform a sanity check. 
-    * [x/auth] Signature verification's gas cost now accounts for pubkey type. [#2046](https://github.com/tendermint/tendermint/pull/2046)
+  * [x/stake] [#2023](https://github.com/cosmos/cosmos-sdk/pull/2023) Terminate iteration loop in `UpdateBondedValidators` and `UpdateBondedValidatorsFull` when the first revoked validator is encountered and perform a sanity check. 
+  * [x/auth] Signature verification's gas cost now accounts for pubkey type. [#2046](https://github.com/tendermint/tendermint/pull/2046)
 
 * SDK
-    * [tools] Make get_vendor_deps deletes `.vendor-new` directories, in case scratch files are present.
+  * [tools] Make get_vendor_deps deletes `.vendor-new` directories, in case scratch files are present.
 
 * Tendermint
 
-
 BUG FIXES
 
 * Gaia REST API (`gaiacli advanced rest-server`)
 
-* Gaia CLI  (`gaiacli`)
-    * [cli] \#1997 Handle panics gracefully when `gaiacli stake {delegation,unbond}` fail to unmarshal delegation.
+* Gaia CLI (`gaiacli`)
+  * [cli] \#1997 Handle panics gracefully when `gaiacli stake {delegation,unbond}` fail to unmarshal delegation.
 
 * Gaia
 
 * SDK
-    *  \#1988 Make us compile on OpenBSD (disable ledger) [#1988] (https://github.com/cosmos/cosmos-sdk/issues/1988)
+  * \#1988 Make us compile on OpenBSD (disable ledger) [#1988] (https://github.com/cosmos/cosmos-sdk/issues/1988)
 
 * Tendermint

From ff92d76ab497326d74ebd3203e2a4d1d2dfca68f Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 22 Aug 2018 11:33:28 -0700
Subject: [PATCH 29/34] Update docs

---
 docs/sdk/clients.md                | 34 +++++++++++++++++++-----------
 docs/validators/validator-faq.md   | 15 +++++++------
 docs/validators/validator-setup.md |  6 +++---
 3 files changed, 33 insertions(+), 22 deletions(-)

diff --git a/docs/sdk/clients.md b/docs/sdk/clients.md
index be42a46dbaa9..74e106a8ae8b 100644
--- a/docs/sdk/clients.md
+++ b/docs/sdk/clients.md
@@ -22,13 +22,17 @@ There are three types of key representations that are used:
   - Derived from account keys generated by `gaiacli keys add`
   - Used to receive funds
   - e.g. `cosmosaccaddr15h6vd5f0wqps26zjlwrc6chah08ryu4hzzdwhc`
+* `cosmosvaladdr`
+  * Used to associate a validator to it's operator
+  * Used to invoke staking commands
+  * e.g. `cosmosvaladdr1carzvgq3e6y3z5kz5y6gxp3wpy3qdrv928vyah`
 - `cosmosaccpub`
   - Derived from account keys generated by `gaiacli keys add`
   - e.g. `cosmosaccpub1zcjduc3q7fu03jnlu2xpl75s2nkt7krm6grh4cc5aqth73v0zwmea25wj2hsqhlqzm`
-- `cosmosvalpub`
+- `cosmosconspub`
   - Generated when the node is created with `gaiad init`.
   - Get this value with `gaiad tendermint show-validator`
-  - e.g. `cosmosvalpub1zcjduc3qcyj09qc03elte23zwshdx92jm6ce88fgc90rtqhjx8v0608qh5ssp0w94c`
+  - e.g. `cosmosconspub1zcjduepq0ms2738680y72v44tfyqm3c9ppduku8fs6sr73fx7m666sjztznqzp2emf`
 
 #### Generate Keys
 
@@ -48,6 +52,12 @@ If you check your private keys, you'll now see `<account_name>`:
 gaiacli keys show <account_name>
 ```
 
+View the validator operator's address via:
+
+```shell
+gaiacli keys show-validator <account_name>
+```
+
 You can see all your available keys by typing:
 
 ```bash
@@ -131,7 +141,7 @@ gaiacli stake validators
 If you want to get the information of a single validator you can check it with:
 
 ```bash
-gaiacli stake validator <account_cosmosaccaddr>
+gaiacli stake validator <account_cosmosvaladdr>
 ```
 
 #### Bond Tokens
@@ -159,7 +169,7 @@ Once submitted a delegation to a validator, you can see it's information by usin
 ```bash
 gaiacli stake delegation \
 	--address-delegator=<account_cosmosaccaddr> \
-	--address-validator=$(gaiad tendermint show-validator)
+	--validator=<account_cosmosvaladdr>
 ```
 
 Or if you want to check all your current delegations with disctinct validators:
@@ -176,7 +186,7 @@ If for any reason the validator misbehaves, or you just want to unbond a certain
 
 ```bash
 gaiacli stake unbond begin \
-  --address-validator=$(gaiad tendermint show-validator) \
+  --validator=<account_cosmosvaladdr> \
   --shares-percent=100 \
   --from=<key_name> \
   --chain-id=<chain_id>
@@ -186,7 +196,7 @@ Later you must complete the unbonding process by using the `gaiacli stake unbond
 
 ```bash
 gaiacli stake unbond complete \
-  --address-validator=$(gaiad tendermint show-validator) \
+  --validator=<account_cosmosvaladdr> \
   --from=<key_name> \
   --chain-id=<chain_id>
 ```
@@ -198,7 +208,7 @@ Once you begin an unbonding-delegation, you can see it's information by using th
 ```bash
 gaiacli stake unbonding-delegation \
 	--address-delegator=<account_cosmosaccaddr> \
-	--address-validator=$(gaiad tendermint show-validator) \
+	--validator=<account_cosmosvaladdr> \
 ```
 
 Or if you want to check all your current unbonding-delegations with disctinct validators:
@@ -215,8 +225,8 @@ A redelegation is a type delegation that allows you to bond illiquid tokens from
 
 ```bash
 gaiacli stake redelegate begin \
-  --address-validator-source=$(gaiad tendermint show-validator) \
-  --address-validator-dest=<account_cosmosaccaddr> \
+  --address-validator-source=<account_cosmosvaladdr> \
+  --address-validator-dest=<account_cosmosvaladdr> \
   --shares-percent=50 \
   --from=<key_name> \
   --chain-id=<chain_id>
@@ -228,7 +238,7 @@ Later you must complete the redelegation process by using the `gaiacli stake red
 
 ```bash
 gaiacli stake unbond complete \
-  --address-validator=$(gaiad tendermint show-validator) \
+  --validator=<account_cosmosvaladdr> \
   --from=<key_name> \
   --chain-id=<chain_id>
 ```
@@ -240,8 +250,8 @@ Once you begin an redelegation, you can see it's information by using the follow
 ```bash
 gaiacli stake redelegation \
 	--address-delegator=<account_cosmosaccaddr> \
-	--address-validator-source=$(gaiad tendermint show-validator) \
-	--address-validator-dest=<account_cosmosaccaddr> \
+	--address-validator-source=<account_cosmosvaladdr> \
+	--address-validator-dest=<account_cosmosvaladdr> \
 ```
 
 Or if you want to check all your current unbonding-delegations with disctinct validators:
diff --git a/docs/validators/validator-faq.md b/docs/validators/validator-faq.md
index 6018ac3233ce..10e232077431 100644
--- a/docs/validators/validator-faq.md
+++ b/docs/validators/validator-faq.md
@@ -77,13 +77,14 @@ We view testnet participation as a great way to signal to the community that you
 
 In short, there are two types of keys:
 
-- **Tendermint Key**: This is a unique key used to sign block hashes. It is associated with a public key `cosmosvalpub`.
-    + Generated when the node is created with gaiad init.
-    + Get this value with gaiad tendermint show_validator
-    +M e.g. cosmosvalpub1zcjduc3qcyj09qc03elte23zwshdx92jm6ce88fgc90rtqhjx8v0608qh5ssp0w94c 
-
-- **Application keys**: These keys are created from the application and used to sign transactions. As a validator, you will probably use one key to sign staking-related transactions, and another key to sign governance-related transactions. Application keys are associated with a public key `cosmosaccpub` and an address `cosmosaccaddr`. Both are derived from account keys generated by `gaiacli keys add`.
-
+* **Tendermint Key**: This is a unique key used to sign block hashes. It is associated with a public key `cosmosconspub`.
+  * Generated when the node is created with gaiad init.
+  * Get this value with `gaiad tendermint show-validator`
+    e.g. `cosmosconspub1zcjduc3qcyj09qc03elte23zwshdx92jm6ce88fgc90rtqhjx8v0608qh5ssp0w94c`
+
+* **Application keys**: These keys are created from the application and used to sign transactions. As a validator, you will probably use one key to sign staking-related transactions, and another key to sign governance-related transactions. Application keys are associated with a public key `cosmosaccpub` and an address `cosmosaccaddr`. Both are derived from account keys generated by `gaiacli keys add`.
+  * Note: A validator's operator key is directly tied to an application key, but
+  uses reserved prefixes solely for this purpose: `cosmosvaladdr` and `cosmosvalpub`
 
 ### What are the different states a validator can be in?
 
diff --git a/docs/validators/validator-setup.md b/docs/validators/validator-setup.md
index 88a542dc03d3..e55191d31654 100644
--- a/docs/validators/validator-setup.md
+++ b/docs/validators/validator-setup.md
@@ -16,7 +16,7 @@ If you want to become a validator for the Hub's `mainnet`, you should [research
 
 ### Create Your Validator
 
-Your `cosmosvalpub` can be used to create a new validator by staking tokens. You can find your validator pubkey by running:
+Your `cosmosconspub` can be used to create a new validator by staking tokens. You can find your validator pubkey by running:
 
 ```bash
 gaiad tendermint show-validator
@@ -32,7 +32,7 @@ Don't use more `steak` thank you have! You can always get more by using the [Fau
 gaiacli stake create-validator \
   --amount=5steak \
   --pubkey=$(gaiad tendermint show-validator) \
-  --address-validator=<account_cosmosaccaddr>
+  --address-validator=<account_cosmosvaladdr>
   --moniker="choose a moniker" \
   --chain-id=<chain_id> \
   --name=<key_name>
@@ -80,7 +80,7 @@ When a validator is `Revoked` for downtime, you must submit an `Unrevoke` transa
 gaiacli stake unrevoke \
 	--from=<key_name> \
 	--chain-id=<chain_id>
-  --validator=<account_cosmosaccaddr> \
+  --validator=<account_cosmosvaladdr> \
   --chain-id=gaia-6002
 ```
 

From 867321f53bd1307d448a0c8804a249a510be896f Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 22 Aug 2018 11:37:44 -0700
Subject: [PATCH 30/34] Revert GaiaGenTx.PubKey bech32 prefix

---
 cmd/gaia/app/genesis.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/gaia/app/genesis.go b/cmd/gaia/app/genesis.go
index ea40a56bda6b..7ca98f6fcac5 100644
--- a/cmd/gaia/app/genesis.go
+++ b/cmd/gaia/app/genesis.go
@@ -140,7 +140,7 @@ func GaiaAppGenTxNF(cdc *wire.Codec, pk crypto.PubKey, addr sdk.AccAddress, name
 	gaiaGenTx := GaiaGenTx{
 		Name:    name,
 		Address: addr,
-		PubKey:  sdk.MustBech32ifyConsPub(pk),
+		PubKey:  sdk.MustBech32ifyAccPub(pk),
 	}
 	bz, err = wire.MarshalJSONIndent(cdc, gaiaGenTx)
 	if err != nil {

From 74cd3ec42ca9b95542836c288fdd508bcab5fc7c Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 22 Aug 2018 18:09:27 -0700
Subject: [PATCH 31/34] Fix broken docs and cli tests

---
 cmd/gaia/cli_test/cli_test.go | 5 ++++-
 docs/sdk/clients.md           | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/cmd/gaia/cli_test/cli_test.go b/cmd/gaia/cli_test/cli_test.go
index b0423e246f84..97daf55586a7 100644
--- a/cmd/gaia/cli_test/cli_test.go
+++ b/cmd/gaia/cli_test/cli_test.go
@@ -326,7 +326,10 @@ func executeGetAddrPK(t *testing.T, cmdStr string) (sdk.AccAddress, crypto.PubKe
 	pk, err := sdk.GetAccPubKeyBech32(ko.PubKey)
 	require.NoError(t, err)
 
-	return ko.Address, pk
+	accAddr, err := sdk.AccAddressFromBech32(ko.Address)
+	require.NoError(t, err)
+
+	return accAddr, pk
 }
 
 func executeGetAccount(t *testing.T, cmdStr string) auth.BaseAccount {
diff --git a/docs/sdk/clients.md b/docs/sdk/clients.md
index 74e106a8ae8b..5a3c3dd4e4e6 100644
--- a/docs/sdk/clients.md
+++ b/docs/sdk/clients.md
@@ -55,7 +55,7 @@ gaiacli keys show <account_name>
 View the validator operator's address via:
 
 ```shell
-gaiacli keys show-validator <account_name>
+gaiacli keys show <account_name> --bech=val
 ```
 
 You can see all your available keys by typing:

From ae612eec44caf3eaa2aff138234b9111d5669ec2 Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Thu, 23 Aug 2018 11:31:30 -0700
Subject: [PATCH 32/34] Update genesis to use correct Bech32 (cons) prefix for
 pubkeys

---
 cmd/gaia/app/genesis.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmd/gaia/app/genesis.go b/cmd/gaia/app/genesis.go
index 3ecf931932b6..1e7d3172cc02 100644
--- a/cmd/gaia/app/genesis.go
+++ b/cmd/gaia/app/genesis.go
@@ -142,7 +142,7 @@ func GaiaAppGenTxNF(cdc *wire.Codec, pk crypto.PubKey, addr sdk.AccAddress, name
 	gaiaGenTx := GaiaGenTx{
 		Name:    name,
 		Address: addr,
-		PubKey:  sdk.MustBech32ifyValPub(pk),
+		PubKey:  sdk.MustBech32ifyConsPub(pk),
 	}
 	bz, err = wire.MarshalJSONIndent(cdc, gaiaGenTx)
 	if err != nil {
@@ -193,7 +193,7 @@ func GaiaAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (genesisState
 		if len(genTx.Name) > 0 {
 			desc := stake.NewDescription(genTx.Name, "", "", "")
 			validator := stake.NewValidator(
-				sdk.ValAddress(genTx.Address), sdk.MustGetValPubKeyBech32(genTx.PubKey), desc,
+				sdk.ValAddress(genTx.Address), sdk.MustGetConsPubKeyBech32(genTx.PubKey), desc,
 			)
 
 			stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewDec(freeFermionVal)) // increase the supply

From 9c2370ef42bc041a438ed89e1a42c95e35f49e0a Mon Sep 17 00:00:00 2001
From: Aleksandr Bezobchuk <alex@tendermint.com>
Date: Wed, 29 Aug 2018 17:38:11 -0400
Subject: [PATCH 33/34] Update docs and unit tests to reflect new cosmos
 account bech32 prefix

---
 client/lcd/lcd_test.go                |  4 +-
 docs/clients/lcd-rest-api.yaml        |  6 +--
 docs/clients/ledger.md                |  2 +-
 docs/ics/ics-030-signed-messages.md   |  2 +-
 docs/light/api.md                     | 24 +++++-----
 docs/sdk/clients.md                   | 66 +++++++++++++--------------
 docs/validators/validator-faq.md      |  4 +-
 docs/validators/validator-setup.md    | 12 ++---
 examples/README.md                    | 20 ++++----
 examples/democoin/x/pow/types_test.go |  4 +-
 x/bank/msgs_test.go                   |  4 +-
 x/gov/tally.go                        |  2 +-
 x/gov/test_common.go                  | 14 ++++++
 x/slashing/msg_test.go                |  2 +-
 14 files changed, 90 insertions(+), 76 deletions(-)

diff --git a/client/lcd/lcd_test.go b/client/lcd/lcd_test.go
index 25b51c57ecb9..d68ba278c13f 100644
--- a/client/lcd/lcd_test.go
+++ b/client/lcd/lcd_test.go
@@ -204,7 +204,7 @@ func TestValidators(t *testing.T) {
 
 	require.NotEqual(t, rpc.ResultValidatorsOutput{}, resultVals)
 
-	require.Contains(t, resultVals.Validators[0].Address.String(), "cosmosvaladdr")
+	require.Contains(t, resultVals.Validators[0].Address.String(), "cosmosval")
 	require.Contains(t, resultVals.Validators[0].PubKey, "cosmosconspub")
 
 	// --
@@ -313,7 +313,7 @@ func TestTxs(t *testing.T) {
 	require.Equal(t, http.StatusBadRequest, res.StatusCode, body)
 
 	// query empty
-	res, body = Request(t, port, "GET", fmt.Sprintf("/txs?tag=sender_bech32='%s'", "cosmosaccaddr1jawd35d9aq4u76sr3fjalmcqc8hqygs9gtnmv3"), nil)
+	res, body = Request(t, port, "GET", fmt.Sprintf("/txs?tag=sender_bech32='%s'", "cosmos1jawd35d9aq4u76sr3fjalmcqc8hqygs90d0g0v"), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
 	require.Equal(t, "[]", body)
 
diff --git a/docs/clients/lcd-rest-api.yaml b/docs/clients/lcd-rest-api.yaml
index 5be69302d50e..4f402089ad9c 100644
--- a/docs/clients/lcd-rest-api.yaml
+++ b/docs/clients/lcd-rest-api.yaml
@@ -710,15 +710,15 @@ definitions:
   Address:
     type: string
     description: bech32 encoded addres
-    example: cosmosaccaddr:zgnkwr7eyyv643dllwfpdwensmgdtz89yu73zq
+    example: cosmos:zgnkwr7eyyv643dllwfpdwensmgdtz89yu73zq
   ValidatorAddress:
     type: string
     description: bech32 encoded addres
-    example: cosmosvaladdr:zgnkwr7eyyv643dllwfpdwensmgdtz89yu73zq
+    example: cosmosval:zgnkwr7eyyv643dllwfpdwensmgdtz89yu73zq
   PubKey:
     type: string
     description: bech32 encoded public key
-    example: cosmosaccpub:zgnkwr7eyyv643dllwfpdwensmgdtz89yu73zq
+    example: cosmospub:zgnkwr7eyyv643dllwfpdwensmgdtz89yu73zq
   ValidatorPubKey:
     type: string
     description: bech32 encoded public key
diff --git a/docs/clients/ledger.md b/docs/clients/ledger.md
index 5ea1224eaea9..26b0215b3dd1 100644
--- a/docs/clients/ledger.md
+++ b/docs/clients/ledger.md
@@ -17,7 +17,7 @@ Once you have the Cosmos app installed on your Ledger, and the Ledger is accessi
 ```bash
 $ gaiacli keys add {{ .Key.Name }} --ledger
 NAME:	          TYPE:	  ADDRESS:						                                  PUBKEY:
-{{ .Key.Name }}	ledger	cosmosaccaddr1aw64xxr80lwqqdk8u2xhlrkxqaxamkr3e2g943	cosmosaccpub1addwnpepqvhs678gh9aqrjc2tg2vezw86csnvgzqq530ujkunt5tkuc7lhjkz5mj629
+{{ .Key.Name }}	ledger	cosmos1aw64xxr80lwqqdk8u2xhlrkxqaxamkr3e2g943	cosmospub1addwnpepqvhs678gh9aqrjc2tg2vezw86csnvgzqq530ujkunt5tkuc7lhjkz5mj629
 ```
 
 This key will only be accessible while the Ledger is plugged in and unlocked. To send some coins with this key, run the following:
diff --git a/docs/ics/ics-030-signed-messages.md b/docs/ics/ics-030-signed-messages.md
index e73d9f5803ae..8f53238f7e23 100644
--- a/docs/ics/ics-030-signed-messages.md
+++ b/docs/ics/ics-030-signed-messages.md
@@ -186,7 +186,7 @@ data = {
   "text": "I hereby claim I am ABC on Keybase!"
 }
 
-cosmosSignBytes(data, "cosmosaccaddr1pvsch6cddahhrn5e8ekw0us50dpnugwnlfngt3")
+cosmosSignBytes(data, "cosmos1pvsch6cddahhrn5e8ekw0us50dpnugwnlfngt3")
 > "0x7fc4a495473045022100dec81a9820df0102381cdbf7e8b0f1e2cb64c58e0ecda1324543742e0388e41a02200df37905a6505c1b56a404e23b7473d2c0bc5bcda96771d2dda59df6ed2b98f8"
 ```
 
diff --git a/docs/light/api.md b/docs/light/api.md
index 6c5e8aa5f02a..7168cf9d743d 100644
--- a/docs/light/api.md
+++ b/docs/light/api.md
@@ -71,13 +71,13 @@ This API exposes all functionality needed for key creation, signing and manageme
         "account":[
            {
                 "name":"monkey",
-                "address":"cosmosaccaddr1fedh326uxqlxs8ph9ej7cf854gz7fd5zlym5pd",
-                "pub_key":"cosmosaccpub1zcjduc3q8s8ha96ry4xc5xvjp9tr9w9p0e5lk5y0rpjs5epsfxs4wmf72x3shvus0t"
+                "address":"cosmos1fedh326uxqlxs8ph9ej7cf854gz7fd5zlym5pd",
+                "pub_key":"cosmospub1zcjduc3q8s8ha96ry4xc5xvjp9tr9w9p0e5lk5y0rpjs5epsfxs4wmf72x3shvus0t"
             },
             {
                 "name":"test",
-                "address":"cosmosaccaddr1thlqhjqw78zvcy0ua4ldj9gnazqzavyw4eske2",
-                "pub_key":"cosmosaccpub1zcjduc3qyx6hlf825jcnj39adpkaxjer95q7yvy25yhfj3dmqy2ctev0rxmse9cuak"
+                "address":"cosmos1thlqhjqw78zvcy0ua4ldj9gnazqzavyw4eske2",
+                "pub_key":"cosmospub1zcjduc3qyx6hlf825jcnj39adpkaxjer95q7yvy25yhfj3dmqy2ctev0rxmse9cuak"
             }
         ],
         "block_height":5241
@@ -125,8 +125,8 @@ Returns on success:
     "error":"",
     "result":{
         "name":"test",
-            "address":"cosmosaccaddr1thlqhjqw78zvcy0ua4ldj9gnazqzavyw4eske2",
-            "pub_key":"cosmosaccpub1zcjduc3qyx6hlf825jcnj39adpkaxjer95q7yvy25yhfj3dmqy2ctev0rxmse9cuak"
+            "address":"cosmos1thlqhjqw78zvcy0ua4ldj9gnazqzavyw4eske2",
+            "pub_key":"cosmospub1zcjduc3qyx6hlf825jcnj39adpkaxjer95q7yvy25yhfj3dmqy2ctev0rxmse9cuak"
     }
 }
 ```
@@ -588,7 +588,7 @@ The GovernanceAPI exposes all functionality needed for casting votes on plain te
     "description": "string",
   	// PlainTextProposal supported now. SoftwareUpgradeProposal and other types may be supported soon
   	"proposal_type": "string",
-  	// A cosmosaccaddr address
+  	// A cosmos address
   	"proposer": "string",
   	"initial_deposit": [
         {
@@ -689,7 +689,7 @@ The GovernanceAPI exposes all functionality needed for casting votes on plain te
     "error":"",
     "result":{
         "amount": {"atom": 150},
-        "depositer": "cosmosaccaddr1fedh326uxqlxs8ph9ej7cf854gz7fd5zlym5pd",
+        "depositer": "cosmos1fedh326uxqlxs8ph9ej7cf854gz7fd5zlym5pd",
         "proposal-id": 16
     }
 }
@@ -731,12 +731,12 @@ The GovernanceAPI exposes all functionality needed for casting votes on plain te
     "result": [
         {
             "proposal-id": 1,
-        	"voter": "cosmosaccaddr1fedh326uxqlxs8ph9ej7cf854gz7fd5zlym5pd",
+        	"voter": "cosmos1fedh326uxqlxs8ph9ej7cf854gz7fd5zlym5pd",
         	"option": "no_with_veto"
     	},
         {
             "proposal-id": 1,
-        	"voter": "cosmosaccaddr1849m9wncrqp6v4tkss6a3j8uzvuv0cp7f75lrq",
+        	"voter": "cosmos1849m9wncrqp6v4tkss6a3j8uzvuv0cp7f75lrq",
         	"option": "yes"
     	},
     ]
@@ -761,7 +761,7 @@ The GovernanceAPI exposes all functionality needed for casting votes on plain te
     	"sequence": 0,
     	"gas": 0
   	},
-    // A cosmosaccaddr address
+    // A cosmos address
   	"voter": "string",
   	// Value of the vote option `Yes`, `No` `Abstain`, `NoWithVeto`
   	"option": "string",
@@ -794,7 +794,7 @@ The GovernanceAPI exposes all functionality needed for casting votes on plain te
     "error":"",
     "result":{
         "proposal-id": 1,
-        "voter": "cosmosaccaddr1fedh326uxqlxs8ph9ej7cf854gz7fd5zlym5pd",
+        "voter": "cosmos1fedh326uxqlxs8ph9ej7cf854gz7fd5zlym5pd",
         "option": "no_with_veto"
     }
 }
diff --git a/docs/sdk/clients.md b/docs/sdk/clients.md
index e57277c98ad2..7a23ba28acd1 100644
--- a/docs/sdk/clients.md
+++ b/docs/sdk/clients.md
@@ -18,17 +18,17 @@
 
 There are three types of key representations that are used:
 
-- `cosmosaccaddr`
+- `cosmos`
   - Derived from account keys generated by `gaiacli keys add`
   - Used to receive funds
-  - e.g. `cosmosaccaddr15h6vd5f0wqps26zjlwrc6chah08ryu4hzzdwhc`
-* `cosmosvaladdr`
+  - e.g. `cosmos15h6vd5f0wqps26zjlwrc6chah08ryu4hzzdwhc`
+* `cosmosval`
   * Used to associate a validator to it's operator
   * Used to invoke staking commands
-  * e.g. `cosmosvaladdr1carzvgq3e6y3z5kz5y6gxp3wpy3qdrv928vyah`
-- `cosmosaccpub`
+  * e.g. `cosmosval1carzvgq3e6y3z5kz5y6gxp3wpy3qdrv928vyah`
+- `cosmospub`
   - Derived from account keys generated by `gaiacli keys add`
-  - e.g. `cosmosaccpub1zcjduc3q7fu03jnlu2xpl75s2nkt7krm6grh4cc5aqth73v0zwmea25wj2hsqhlqzm`
+  - e.g. `cosmospub1zcjduc3q7fu03jnlu2xpl75s2nkt7krm6grh4cc5aqth73v0zwmea25wj2hsqhlqzm`
 - `cosmosconspub`
   - Generated when the node is created with `gaiad init`.
   - Get this value with `gaiad tendermint show-validator`
@@ -78,18 +78,18 @@ We strongly recommend _NOT_ using the same passphrase for multiple keys. The Ten
 
 #### Get Tokens
 
-The best way to get tokens is from the [Cosmos Testnet Faucet](https://faucetcosmos.network). If the faucet is not working for you, try asking [#cosmos-validators](https://riot.im/app/#/room/#cosmos-validators:matrix.org). The faucet needs the `cosmosaccaddr` from the account you wish to use for staking.
+The best way to get tokens is from the [Cosmos Testnet Faucet](https://faucetcosmos.network). If the faucet is not working for you, try asking [#cosmos-validators](https://riot.im/app/#/room/#cosmos-validators:matrix.org). The faucet needs the `cosmos` from the account you wish to use for staking.
 
 #### Query Account balance
 
 After receiving tokens to your address, you can view your account's balance by typing:
 
 ```bash
-gaiacli account <account_cosmosaccaddr>
+gaiacli account <account_cosmos>
 ```
 
 ::: warning Note
-When you query an account balance with zero tokens, you will get this error: `No account with address <account_cosmosaccaddr> was found in the state.` This can also happen if you fund the account before your node has fully synced with the chain. These are both normal.
+When you query an account balance with zero tokens, you will get this error: `No account with address <account_cosmos> was found in the state.` This can also happen if you fund the account before your node has fully synced with the chain. These are both normal.
 
 :::
 
@@ -100,7 +100,7 @@ gaiacli send \
   --amount=10faucetToken \
   --chain-id=<chain_id> \
   --name=<key_name> \
-  --to=<destination_cosmosaccaddr>
+  --to=<destination_cosmos>
 ```
 
 ::: warning Note
@@ -116,14 +116,14 @@ Gas estimate might be inaccurate as state changes could occur in between the end
 Now, view the updated balances of the origin and destination accounts:
 
 ```bash
-gaiacli account <account_cosmosaccaddr>
-gaiacli account <destination_cosmosaccaddr>
+gaiacli account <account_cosmos>
+gaiacli account <destination_cosmos>
 ```
 
 You can also check your balance at a given block by using the `--block` flag:
 
 ```bash
-gaiacli account <account_cosmosaccaddr> --block=<block_height>
+gaiacli account <account_cosmos> --block=<block_height>
 ```
 
 ### Staking
@@ -147,7 +147,7 @@ gaiacli stake validators
 If you want to get the information of a single validator you can check it with:
 
 ```bash
-gaiacli stake validator <account_cosmosvaladdr>
+gaiacli stake validator <account_cosmosval>
 ```
 
 #### Bond Tokens
@@ -174,14 +174,14 @@ Once submitted a delegation to a validator, you can see it's information by usin
 
 ```bash
 gaiacli stake delegation \
-	--address-delegator=<account_cosmosaccaddr> \
-	--validator=<account_cosmosvaladdr>
+	--address-delegator=<account_cosmos> \
+	--validator=<account_cosmosval>
 ```
 
 Or if you want to check all your current delegations with disctinct validators:
 
 ```bash
-gaiacli stake delegations <account_cosmosaccaddr>
+gaiacli stake delegations <account_cosmos>
 ```
 
 You can also get previous delegation(s) status by adding the `--height` flag.
@@ -192,7 +192,7 @@ If for any reason the validator misbehaves, or you just want to unbond a certain
 
 ```bash
 gaiacli stake unbond begin \
-  --validator=<account_cosmosvaladdr> \
+  --validator=<account_cosmosval> \
   --shares-percent=100 \
   --from=<key_name> \
   --chain-id=<chain_id>
@@ -202,7 +202,7 @@ Later you must complete the unbonding process by using the `gaiacli stake unbond
 
 ```bash
 gaiacli stake unbond complete \
-  --validator=<account_cosmosvaladdr> \
+  --validator=<account_cosmosval> \
   --from=<key_name> \
   --chain-id=<chain_id>
 ```
@@ -213,14 +213,14 @@ Once you begin an unbonding-delegation, you can see it's information by using th
 
 ```bash
 gaiacli stake unbonding-delegation \
-	--address-delegator=<account_cosmosaccaddr> \
-	--validator=<account_cosmosvaladdr> \
+	--address-delegator=<account_cosmos> \
+	--validator=<account_cosmosval> \
 ```
 
 Or if you want to check all your current unbonding-delegations with disctinct validators:
 
 ```bash
-gaiacli stake unbonding-delegations <account_cosmosaccaddr>
+gaiacli stake unbonding-delegations <account_cosmos>
 ```
 
 You can also get previous unbonding-delegation(s) status by adding the `--height` flag.
@@ -231,8 +231,8 @@ A redelegation is a type delegation that allows you to bond illiquid tokens from
 
 ```bash
 gaiacli stake redelegate begin \
-  --address-validator-source=<account_cosmosvaladdr> \
-  --address-validator-dest=<account_cosmosvaladdr> \
+  --address-validator-source=<account_cosmosval> \
+  --address-validator-dest=<account_cosmosval> \
   --shares-percent=50 \
   --from=<key_name> \
   --chain-id=<chain_id>
@@ -244,7 +244,7 @@ Later you must complete the redelegation process by using the `gaiacli stake red
 
 ```bash
 gaiacli stake unbond complete \
-  --validator=<account_cosmosvaladdr> \
+  --validator=<account_cosmosval> \
   --from=<key_name> \
   --chain-id=<chain_id>
 ```
@@ -255,15 +255,15 @@ Once you begin an redelegation, you can see it's information by using the follow
 
 ```bash
 gaiacli stake redelegation \
-	--address-delegator=<account_cosmosaccaddr> \
-	--address-validator-source=<account_cosmosvaladdr> \
-	--address-validator-dest=<account_cosmosvaladdr> \
+	--address-delegator=<account_cosmos> \
+	--address-validator-source=<account_cosmosval> \
+	--address-validator-dest=<account_cosmosval> \
 ```
 
 Or if you want to check all your current unbonding-delegations with disctinct validators:
 
 ```bash
-gaiacli stake redelegations <account_cosmosaccaddr>
+gaiacli stake redelegations <account_cosmos>
 ```
 
 You can also get previous redelegation(s) status by adding the `--height` flag.
@@ -296,7 +296,7 @@ gaiacli gov submit-proposal \
   --title=<title> \
   --description=<description> \
   --type=<Text/ParameterChange/SoftwareUpgrade> \
-  --proposer=<account_cosmosaccaddr> \
+  --proposer=<account_cosmos> \
   --deposit=<40steak> \
   --from=<name> \
   --chain-id=<chain_id>
@@ -326,7 +326,7 @@ In order for a proposal to be broadcasted to the network, the amount deposited m
 ```bash
 gaiacli gov deposit \
   --proposal-id=<proposal_id> \
-  --depositer=<account_cosmosaccaddr> \
+  --depositer=<account_cosmos> \
   --deposit=<200steak> \
   --from=<name> \
   --chain-id=<chain_id>
@@ -341,7 +341,7 @@ After a proposal's deposit reaches the `MinDeposit` value, the voting period ope
 ```bash
 gaiacli gov vote \
   --proposal-id=<proposal_id> \
-  --voter=<account_cosmosaccaddr> \
+  --voter=<account_cosmos> \
   --option=<Yes/No/NoWithVeto/Abstain> \
   --from=<name> \
   --chain-id=<chain_id>
@@ -354,7 +354,7 @@ Check the vote with the option you just submitted:
 ```bash
 gaiacli gov query-vote \
   --proposal-id=<proposal_id> \
-  --voter=<account_cosmosaccaddr>
+  --voter=<account_cosmos>
 ```
 
 #### Query Parameters
diff --git a/docs/validators/validator-faq.md b/docs/validators/validator-faq.md
index 10e232077431..470f139d43e5 100644
--- a/docs/validators/validator-faq.md
+++ b/docs/validators/validator-faq.md
@@ -82,9 +82,9 @@ In short, there are two types of keys:
   * Get this value with `gaiad tendermint show-validator`
     e.g. `cosmosconspub1zcjduc3qcyj09qc03elte23zwshdx92jm6ce88fgc90rtqhjx8v0608qh5ssp0w94c`
 
-* **Application keys**: These keys are created from the application and used to sign transactions. As a validator, you will probably use one key to sign staking-related transactions, and another key to sign governance-related transactions. Application keys are associated with a public key `cosmosaccpub` and an address `cosmosaccaddr`. Both are derived from account keys generated by `gaiacli keys add`.
+* **Application keys**: These keys are created from the application and used to sign transactions. As a validator, you will probably use one key to sign staking-related transactions, and another key to sign governance-related transactions. Application keys are associated with a public key `cosmospub` and an address `cosmos`. Both are derived from account keys generated by `gaiacli keys add`.
   * Note: A validator's operator key is directly tied to an application key, but
-  uses reserved prefixes solely for this purpose: `cosmosvaladdr` and `cosmosvalpub`
+  uses reserved prefixes solely for this purpose: `cosmosval` and `cosmosvalpub`
 
 ### What are the different states a validator can be in?
 
diff --git a/docs/validators/validator-setup.md b/docs/validators/validator-setup.md
index 0e16fd4793e9..8bf3e951ded4 100644
--- a/docs/validators/validator-setup.md
+++ b/docs/validators/validator-setup.md
@@ -32,7 +32,7 @@ Don't use more `steak` thank you have! You can always get more by using the [Fau
 gaiacli stake create-validator \
   --amount=5steak \
   --pubkey=$(gaiad tendermint show-validator) \
-  --address-validator=<account_cosmosvaladdr>
+  --address-validator=<account_cosmosval>
   --moniker="choose a moniker" \
   --chain-id=<chain_id> \
   --name=<key_name>
@@ -46,7 +46,7 @@ The `--identity` can be used as to verify identity with systems like Keybase or
 
 ```bash
 gaiacli stake edit-validator
-  --validator=<account_cosmosaccaddr>
+  --validator=<account_cosmos>
   --moniker="choose a moniker" \
   --website="https://cosmos.network" \
   --identity=6A0D65E29A4CBC8E
@@ -60,7 +60,7 @@ gaiacli stake edit-validator
 View the validator's information with this command:
 
 ```bash
-gaiacli stake validator <account_cosmosaccaddr>
+gaiacli stake validator <account_cosmos>
 ```
 
 ### Track Validator Signing Information
@@ -80,7 +80,7 @@ When a validator is "jailed" for downtime, you must submit an `Unjail` transacti
 gaiacli stake unjail \
 	--from=<key_name> \
 	--chain-id=<chain_id>
-  --validator=<account_cosmosvaladdr> \
+  --validator=<account_cosmosval> \
   --chain-id=gaia-6002
 ```
 
@@ -110,10 +110,10 @@ Here's how you can return the voting power back to your validator. First, if `ga
 gaiad start
 ```
 
-Wait for your full node to catch up to the latest block. Next, run the following command. Note that `<cosmosaccaddr>` is the address of your validator account, and `<name>` is the name of the validator account. You can find this info by running `gaiacli keys list`.
+Wait for your full node to catch up to the latest block. Next, run the following command. Note that `<cosmos>` is the address of your validator account, and `<name>` is the name of the validator account. You can find this info by running `gaiacli keys list`.
 
 ```bash
-gaiacli stake unjail <cosmosaccaddr> --chain-id=<chain_id> --name=<name>
+gaiacli stake unjail <cosmos> --chain-id=<chain_id> --name=<name>
 ```
 
 ::: danger Warning
diff --git a/examples/README.md b/examples/README.md
index d12e3d3fccdf..11aef9d280fd 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -103,10 +103,10 @@ basecli keys list
 You should now see alice, bob and charlie's account all show up.
 
 ```
-NAME: 	ADDRESS:					                PUBKEY:
-alice   cosmosaccaddr1khygs0qh7gz3p4m39u00mjhvgvc2dcpxhsuh5f	cosmosaccpub1addwnpepq0w037u5g7y7lvdvsred2dehg90j84k0weyss5ynysf0nnnax74agrsxns6
-bob     cosmosaccaddr18se8tz6kwwfga6k2yjsu7n64e9z52nen29rhzz	cosmosaccpub1addwnpepqwe97n8lryxrzvamrvjfj24jys3uzf8wndfvqa2l7mh5nsv4jrvdznvyeg6
-charlie cosmosaccaddr13wq5mklhn03ljpd4dkph5rflk5a3ssma2ag07q	cosmosaccpub1addwnpepqdmtxv35rrmv2dvcr3yhfyxj7dzrd4z4rnhmclksq4g55a4wpl54clvx33l
+NAME: 	ADDRESS:                                        PUBKEY:
+alice   cosmos1khygs0qh7gz3p4m39u00mjhvgvc2dcpxhsuh5f	cosmospub1addwnpepq0w037u5g7y7lvdvsred2dehg90j84k0weyss5ynysf0nnnax74agrsxns6
+bob     cosmos18se8tz6kwwfga6k2yjsu7n64e9z52nen29rhzz	cosmospub1addwnpepqwe97n8lryxrzvamrvjfj24jys3uzf8wndfvqa2l7mh5nsv4jrvdznvyeg6
+charlie cosmos13wq5mklhn03ljpd4dkph5rflk5a3ssma2ag07q	cosmospub1addwnpepqdmtxv35rrmv2dvcr3yhfyxj7dzrd4z4rnhmclksq4g55a4wpl54clvx33l
 ```
 
 
@@ -115,15 +115,15 @@ charlie cosmosaccaddr13wq5mklhn03ljpd4dkph5rflk5a3ssma2ag07q	cosmosaccpub1addwnp
 Lets send bob and charlie some tokens. First, lets query alice's account so we can see what kind of tokens she has:
 
 ```
-basecli account cosmosaccaddr1khygs0qh7gz3p4m39u00mjhvgvc2dcpxhsuh5f
+basecli account cosmos1khygs0qh7gz3p4m39u00mjhvgvc2dcpxhsuh5f
 ```
 
-Where `cosmosaccaddr1khygs0qh7gz3p4m39u00mjhvgvc2dcpxhsuh5f` is alice's address we got from running `basecli keys list`. You should see a large amount of "mycoin" there. If you search for bob's or charlie's address, the command will fail, because they haven't been added into the blockchain database yet since they have no coins. We need to send them some!
+Where `cosmos1khygs0qh7gz3p4m39u00mjhvgvc2dcpxhsuh5f` is alice's address we got from running `basecli keys list`. You should see a large amount of "mycoin" there. If you search for bob's or charlie's address, the command will fail, because they haven't been added into the blockchain database yet since they have no coins. We need to send them some!
 
 The following command will send coins from alice, to bob:
 
 ```
-basecli send --from=alice --amount=10000mycoin --to=cosmosaccaddr18se8tz6kwwfga6k2yjsu7n64e9z52nen29rhzz
+basecli send --from=alice --amount=10000mycoin --to=cosmos18se8tz6kwwfga6k2yjsu7n64e9z52nen29rhzz
 --sequence=0 --chain-id=test-chain-AE4XQo
 ```
 
@@ -136,13 +136,13 @@ Flag Descriptions:
 Now if we check bobs account, it should have `10000 mycoin`. You can do so by running :
 
 ```
-basecli account cosmosaccaddr18se8tz6kwwfga6k2yjsu7n64e9z52nen29rhzz
+basecli account cosmos18se8tz6kwwfga6k2yjsu7n64e9z52nen29rhzz
 ```
 
 Now lets send some from bob to charlie. Make sure you send less than bob has, otherwise the transaction will fail:
 
 ```
-basecli send --from=bob --amount=5000mycoin --to=cosmosaccaddr13wq5mklhn03ljpd4dkph5rflk5a3ssma2ag07q
+basecli send --from=bob --amount=5000mycoin --to=cosmos13wq5mklhn03ljpd4dkph5rflk5a3ssma2ag07q
 --sequence=0 --chain-id=test-chain-AE4XQo
 ```
 
@@ -151,7 +151,7 @@ Note how we use the ``--from`` flag to select a different account to send from.
 Lets now try to send from bob back to alice:
 
 ```
-basecli send --from=bob --amount=3000mycoin --to=cosmosaccaddr1khygs0qh7gz3p4m39u00mjhvgvc2dcpxhsuh5f
+basecli send --from=bob --amount=3000mycoin --to=cosmos1khygs0qh7gz3p4m39u00mjhvgvc2dcpxhsuh5f
 --sequence=1 --chain-id=test-chain-AE4XQo
 ```
 
diff --git a/examples/democoin/x/pow/types_test.go b/examples/democoin/x/pow/types_test.go
index be848d94089a..dbe6ad35e953 100644
--- a/examples/democoin/x/pow/types_test.go
+++ b/examples/democoin/x/pow/types_test.go
@@ -55,14 +55,14 @@ func TestMsgMineString(t *testing.T) {
 	addr := sdk.AccAddress([]byte("sender"))
 	msg := MsgMine{addr, 0, 0, 0, []byte("abc")}
 	res := msg.String()
-	require.Equal(t, res, "MsgMine{Sender: cosmosaccaddr1wdjkuer9wg4wml9c, Difficulty: 0, Count: 0, Nonce: 0, Proof: abc}")
+	require.Equal(t, res, "MsgMine{Sender: cosmos1wdjkuer9wgh76ts6, Difficulty: 0, Count: 0, Nonce: 0, Proof: abc}")
 }
 
 func TestMsgMineGetSignBytes(t *testing.T) {
 	addr := sdk.AccAddress([]byte("sender"))
 	msg := MsgMine{addr, 1, 1, 1, []byte("abc")}
 	res := msg.GetSignBytes()
-	require.Equal(t, string(res), `{"count":1,"difficulty":1,"nonce":1,"proof":"YWJj","sender":"cosmosaccaddr1wdjkuer9wg4wml9c"}`)
+	require.Equal(t, string(res), `{"count":1,"difficulty":1,"nonce":1,"proof":"YWJj","sender":"cosmos1wdjkuer9wgh76ts6"}`)
 }
 
 func TestMsgMineGetSigners(t *testing.T) {
diff --git a/x/bank/msgs_test.go b/x/bank/msgs_test.go
index ac16b1d0b1c7..e082bdac4227 100644
--- a/x/bank/msgs_test.go
+++ b/x/bank/msgs_test.go
@@ -187,7 +187,7 @@ func TestMsgSendGetSignBytes(t *testing.T) {
 	}
 	res := msg.GetSignBytes()
 
-	expected := `{"inputs":[{"address":"cosmosaccaddr1d9h8qat5e4ehc5","coins":[{"amount":"10","denom":"atom"}]}],"outputs":[{"address":"cosmosaccaddr1da6hgur4wse3jx32","coins":[{"amount":"10","denom":"atom"}]}]}`
+	expected := `{"inputs":[{"address":"cosmos1d9h8qat57ljhcm","coins":[{"amount":"10","denom":"atom"}]}],"outputs":[{"address":"cosmos1da6hgur4wsmpnjyg","coins":[{"amount":"10","denom":"atom"}]}]}`
 	require.Equal(t, expected, string(res))
 }
 
@@ -257,7 +257,7 @@ func TestMsgIssueGetSignBytes(t *testing.T) {
 	}
 	res := msg.GetSignBytes()
 
-	expected := `{"banker":"cosmosaccaddr1d9h8qat5e4ehc5","outputs":[{"address":"cosmosaccaddr1d3hkzm3dveex7mfdvfsku6cwsauqd","coins":[{"amount":"10","denom":"atom"}]}]}`
+	expected := `{"banker":"cosmos1d9h8qat57ljhcm","outputs":[{"address":"cosmos1d3hkzm3dveex7mfdvfsku6cjngpcj","coins":[{"amount":"10","denom":"atom"}]}]}`
 	require.Equal(t, expected, string(res))
 }
 
diff --git a/x/gov/tally.go b/x/gov/tally.go
index c3dc5a3d41c1..a756eaf92645 100644
--- a/x/gov/tally.go
+++ b/x/gov/tally.go
@@ -110,7 +110,7 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 	}
 	// If more than 1/2 of non-abstaining voters vote No, proposal fails
 
-	SortAddresses(nonVoting)
+	SortValAddresses(nonVoting)
 
 	return false, tallyResults, nonVoting
 }
diff --git a/x/gov/test_common.go b/x/gov/test_common.go
index 5e7977b50c34..502cfbbf0498 100644
--- a/x/gov/test_common.go
+++ b/x/gov/test_common.go
@@ -77,6 +77,20 @@ func getInitChainer(mapp *mock.App, keeper Keeper, stakeKeeper stake.Keeper) sdk
 	}
 }
 
+// TODO: Remove once address interface has been implemented (ref: #2186)
+func SortValAddresses(addrs []sdk.ValAddress) {
+	var byteAddrs [][]byte
+	for _, addr := range addrs {
+		byteAddrs = append(byteAddrs, addr.Bytes())
+	}
+
+	SortByteArrays(byteAddrs)
+
+	for i, byteAddr := range byteAddrs {
+		addrs[i] = byteAddr
+	}
+}
+
 // Sorts Addresses
 func SortAddresses(addrs []sdk.AccAddress) {
 	var byteAddrs [][]byte
diff --git a/x/slashing/msg_test.go b/x/slashing/msg_test.go
index fd7a629d5491..ff8619041e79 100644
--- a/x/slashing/msg_test.go
+++ b/x/slashing/msg_test.go
@@ -12,5 +12,5 @@ func TestMsgUnjailGetSignBytes(t *testing.T) {
 	addr := sdk.AccAddress("abcd")
 	msg := NewMsgUnjail(sdk.ValAddress(addr))
 	bytes := msg.GetSignBytes()
-	require.Equal(t, string(bytes), `{"address":"cosmosvaladdr1v93xxeqamr0mv"}`)
+	require.Equal(t, string(bytes), `{"address":"cosmosval1v93xxeq7xkcrf"}`)
 }

From fea1392a4daaeb90e9ac43e7ccb5e61643a87743 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Thu, 30 Aug 2018 23:50:10 -0400
Subject: [PATCH 34/34] minor formatting

---
 client/keys/show.go | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/client/keys/show.go b/client/keys/show.go
index 303d7115ee35..9710cac11e72 100644
--- a/client/keys/show.go
+++ b/client/keys/show.go
@@ -25,7 +25,7 @@ const (
 
 func showKeysCmd() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "show <name>",
+		Use:   "show [name]",
 		Short: "Show key info for the given name",
 		Long:  `Return public details of one local key.`,
 		Args:  cobra.ExactArgs(1),
@@ -43,7 +43,6 @@ func showKeysCmd() *cobra.Command {
 			if showAddress && showPublicKey {
 				return errors.New("cannot use both --address and --pubkey at once")
 			}
-
 			if outputSet && (showAddress || showPublicKey) {
 				return errors.New("cannot use --output with --address or --pubkey")
 			}
@@ -53,17 +52,14 @@ func showKeysCmd() *cobra.Command {
 				return err
 			}
 
-			if showAddress {
+			switch {
+			case showAddress:
 				printKeyAddress(info, bechKeyOut)
-				return nil
-			}
-
-			if showPublicKey {
+			case showPublicKey:
 				printPubKey(info, bechKeyOut)
-				return nil
+			default:
+				printKeyInfo(info, bechKeyOut)
 			}
-
-			printKeyInfo(info, bechKeyOut)
 			return nil
 		},
 	}