Merge remote-tracking branch 'origin/develop' into rigel/new-hooks

2018-09-25 18:31:12 -04:00 · 2018-09-25 18:31:12 -04:00 · 9e9756a6a9
parent 910af2066f 2fb3493ff5
commit 9e9756a6a9
62 changed files with 682 additions and 372 deletions
--- a/Gopkg.lock
+++ b/Gopkg.lock
@ -229,6 +229,14 @@
  revision = "c12348ce28de40eed0136aa2b644d0ee0650e56c"
  version = "v1.0.1"

+[[projects]]
+  digest = "1:78bbb1ba5b7c3f2ed0ea1eab57bdd3859aec7e177811563edc41198a760b06af"
+  name = "github.com/mitchellh/go-homedir"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "ae18d6b8b3205b561c79e8e5f69bff09736185f4"
+  version = "v1.0.0"
+
 [[projects]]
  digest = "1:645110e089152bd0f4a011a2648fbb0e4df5977be73ca605781157ac297f50c4"
  name = "github.com/mitchellh/mapstructure"
@ -630,6 +638,8 @@
    "github.com/golang/protobuf/proto",
    "github.com/gorilla/mux",
    "github.com/mattn/go-isatty",
+    "github.com/mitchellh/go-homedir",
+    "github.com/pelletier/go-toml",
    "github.com/pkg/errors",
    "github.com/spf13/cobra",
    "github.com/spf13/pflag",
--- a/Gopkg.toml
+++ b/Gopkg.toml
@ -70,3 +70,7 @@
 [prune]
  go-tests = true
  unused-packages = true
+
+[[constraint]]
+  name = "github.com/mitchellh/go-homedir"
+  version = "1.0.0"
--- a/PENDING.md
+++ b/PENDING.md
@ -18,6 +18,8 @@ BREAKING CHANGES
    utilize a validator's operator address must now use the new Bech32 prefix,
    `cosmosvaloper`.
    * [cli] [\#2190](https://github.com/cosmos/cosmos-sdk/issues/2190) `gaiacli init --gen-txs` is now `gaiacli init --with-txs` to reduce confusion
+    * [cli] \#2073 --from can now be either an address or a key name
+

 * Gaia
    * Make the transient store key use a distinct store key. [#2013](https://github.com/cosmos/cosmos-sdk/pull/2013)
@ -36,6 +38,7 @@ BREAKING CHANGES
      * `cosmosvaladdr` / `cosmosvalpub` => `cosmosvaloper` / `cosmosvaloperpub`
    * [x/stake] [#1013] TendermintUpdates now uses transient store
    * [x/gov] [#2195] Governance uses BFT Time
+    * [x/gov] \#2256 Removed slashing for governance non-voting validators
    
 * SDK
    * [core] [\#1807](https://github.com/cosmos/cosmos-sdk/issues/1807) Switch from use of rational to decimal
@ -44,6 +47,7 @@ BREAKING CHANGES
    * [types] [\#2119](https://github.com/cosmos/cosmos-sdk/issues/2119) Parsed error messages and ABCI log errors to make them more human readable.
    * [simulation] Rename TestAndRunTx to Operation [#2153](https://github.com/cosmos/cosmos-sdk/pull/2153)
    * [simulation] Remove log and testing.TB from Operation and Invariants, in favor of using errors \#2282
+    * [simulation] Remove usage of keys and addrs in the types, in favor of simulation.Account \#2384
    * [tools] Removed gocyclo [#2211](https://github.com/cosmos/cosmos-sdk/issues/2211)
    * [baseapp] Remove `SetTxDecoder` in favor of requiring the decoder be set in baseapp initialization. [#1441](https://github.com/cosmos/cosmos-sdk/issues/1441)
    * [baseapp] [\#1921](https://github.com/cosmos/cosmos-sdk/issues/1921) Add minimumFees field to BaseApp.
@ -78,6 +82,7 @@ FEATURES
    * [\#966](https://github.com/cosmos/cosmos-sdk/issues/966) Add --generate-only flag to build an unsigned transaction and write it to STDOUT.
    * [\#1953](https://github.com/cosmos/cosmos-sdk/issues/1953) New `sign` command to sign transactions generated with the --generate-only flag.
    * [\#1954](https://github.com/cosmos/cosmos-sdk/issues/1954) New `broadcast` command to broadcast transactions generated offline and signed with the `sign` command.
+  * [cli] \#2220 Add `gaiacli config` feature to interactively create CLI config files to reduce the number of required flags
  * [stake][cli] [\#1672](https://github.com/cosmos/cosmos-sdk/issues/1672) Introduced
  new commission flags for validator commands `create-validator` and `edit-validator`.

--- a/client/config.go
+++ b/client/config.go
@ -0,0 +1,131 @@
+package client
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/mitchellh/go-homedir"
+	"bufio"
+	"path"
+	"os"
+	"io/ioutil"
+	"github.com/pelletier/go-toml"
+	"fmt"
+	"github.com/cosmos/cosmos-sdk/types"
+)
+
+type cliConfig struct {
+	Home      string `toml:"home"`
+	ChainID   string `toml:"chain_id"`
+	TrustNode bool   `toml:"trust_node"`
+	Encoding  string `toml:"encoding"`
+	Output    string `toml:"output"`
+	Node      string `toml:"node"`
+	Trace     bool   `toml:"trace"`
+}
+
+// ConfigCmd returns a CLI command to interactively create a
+// Gaia CLI config file.
+func ConfigCmd() *cobra.Command {
+	cfg := &cobra.Command{
+		Use:   "config",
+		Short: "Interactively creates a Gaia CLI config file",
+		RunE:  runConfigCmd,
+	}
+
+	return cfg
+}
+
+func runConfigCmd(cmd *cobra.Command, args [] string) error {
+	home, err := homedir.Dir()
+	if err != nil {
+		return err
+	}
+
+	stdin := BufferStdin()
+	gaiaCLIHome, err := handleGaiaCLIHome(home, stdin)
+	if err != nil {
+		return err
+	}
+	node, err := handleNode(stdin)
+	if err != nil {
+		return err
+	}
+	trustNode, err := handleTrustNode(stdin)
+	if err != nil {
+		return err
+	}
+
+	encoding := "btc"
+	output := "text"
+	var chainID string
+	chainID, err = types.DefaultChainID()
+	if err != nil {
+		fmt.Println("Couldn't populate ChainID, so using an empty one.")
+	}
+
+	cfg := &cliConfig{
+		Home:      gaiaCLIHome,
+		ChainID:   chainID,
+		TrustNode: trustNode,
+		Encoding:  encoding,
+		Output:    output,
+		Node:      node,
+		Trace:     false,
+	}
+
+	return createGaiaCLIConfig(cfg)
+}
+
+func handleGaiaCLIHome(dir string, stdin *bufio.Reader) (string, error) {
+	dirName := ".gaiacli"
+	home, err := GetString(fmt.Sprintf("Where is your gaiacli home directory? (Default: ~/%s)", dirName), stdin)
+	if err != nil {
+		return "", err
+	}
+
+	if home == "" {
+		home = path.Join(dir, dirName)
+	}
+
+	return home, nil
+}
+
+func handleNode(stdin *bufio.Reader) (string, error) {
+	defaultNode := "tcp://localhost:26657"
+	node, err := GetString(fmt.Sprintf("Where is your validator node running? (Default: %s)", defaultNode), stdin)
+	if err != nil {
+		return "", err
+	}
+
+	if node == "" {
+		node = defaultNode
+	}
+
+	return node, nil
+}
+
+func handleTrustNode(stdin *bufio.Reader) (bool, error) {
+	return GetConfirmation("Do you trust this node?", stdin)
+}
+
+func createGaiaCLIConfig(cfg *cliConfig) error {
+	cfgPath := path.Join(cfg.Home, "config")
+	err := os.MkdirAll(cfgPath, os.ModePerm)
+	if err != nil {
+		return err
+	}
+
+	data, err := toml.Marshal(*cfg)
+	if err != nil {
+		return err
+	}
+
+	cfgFile := path.Join(cfgPath, "config.toml")
+	if info, err := os.Stat(cfgFile); err == nil && !info.IsDir() {
+		err = os.Rename(cfgFile, path.Join(cfgPath, "config.toml-old"))
+		if err != nil {
+			return err
+		}
+	}
+
+	return ioutil.WriteFile(cfgFile, data, os.ModePerm)
+}
--- a/client/context/context.go
+++ b/client/context/context.go
@ -16,6 +16,9 @@ import (
 	tmliteProxy "github.com/tendermint/tendermint/lite/proxy"
 	rpcclient "github.com/tendermint/tendermint/rpc/client"
 	"os"
+	"github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/client/keys"
+	cskeys "github.com/cosmos/cosmos-sdk/crypto/keys"
 )

 const ctxAccStoreName = "acc"
@ -23,22 +26,24 @@ const ctxAccStoreName = "acc"
 // CLIContext implements a typical CLI context created in SDK modules for
 // transaction handling and queries.
 type CLIContext struct {
-	Codec           *codec.Codec
-	AccDecoder      auth.AccountDecoder
-	Client          rpcclient.Client
-	Logger          io.Writer
-	Height          int64
-	NodeURI         string
-	FromAddressName string
-	AccountStore    string
-	TrustNode       bool
-	UseLedger       bool
-	Async           bool
-	JSON            bool
-	PrintResponse   bool
-	Certifier       tmlite.Certifier
-	DryRun          bool
-	GenerateOnly    bool
+	Codec         *codec.Codec
+	AccDecoder    auth.AccountDecoder
+	Client        rpcclient.Client
+	Logger        io.Writer
+	Height        int64
+	NodeURI       string
+	From          string
+	AccountStore  string
+	TrustNode     bool
+	UseLedger     bool
+	Async         bool
+	JSON          bool
+	PrintResponse bool
+	Certifier     tmlite.Certifier
+	DryRun        bool
+	GenerateOnly  bool
+	fromAddress   types.AccAddress
+	fromName      string
 }

 // NewCLIContext returns a new initialized CLIContext with parameters from the
@ -51,20 +56,25 @@ func NewCLIContext() CLIContext {
 		rpc = rpcclient.NewHTTP(nodeURI, "/websocket")
 	}

+	from := viper.GetString(client.FlagFrom)
+	fromAddress, fromName := fromFields(from)
+
 	return CLIContext{
-		Client:          rpc,
-		NodeURI:         nodeURI,
-		AccountStore:    ctxAccStoreName,
-		FromAddressName: viper.GetString(client.FlagFrom),
-		Height:          viper.GetInt64(client.FlagHeight),
-		TrustNode:       viper.GetBool(client.FlagTrustNode),
-		UseLedger:       viper.GetBool(client.FlagUseLedger),
-		Async:           viper.GetBool(client.FlagAsync),
-		JSON:            viper.GetBool(client.FlagJson),
-		PrintResponse:   viper.GetBool(client.FlagPrintResponse),
-		Certifier:       createCertifier(),
-		DryRun:          viper.GetBool(client.FlagDryRun),
-		GenerateOnly:    viper.GetBool(client.FlagGenerateOnly),
+		Client:        rpc,
+		NodeURI:       nodeURI,
+		AccountStore:  ctxAccStoreName,
+		From:          viper.GetString(client.FlagFrom),
+		Height:        viper.GetInt64(client.FlagHeight),
+		TrustNode:     viper.GetBool(client.FlagTrustNode),
+		UseLedger:     viper.GetBool(client.FlagUseLedger),
+		Async:         viper.GetBool(client.FlagAsync),
+		JSON:          viper.GetBool(client.FlagJson),
+		PrintResponse: viper.GetBool(client.FlagPrintResponse),
+		Certifier:     createCertifier(),
+		DryRun:        viper.GetBool(client.FlagDryRun),
+		GenerateOnly:  viper.GetBool(client.FlagGenerateOnly),
+		fromAddress:   fromAddress,
+		fromName:      fromName,
 	}
 }

@ -108,6 +118,37 @@ func createCertifier() tmlite.Certifier {
 	return certifier
 }

+func fromFields(from string) (fromAddr types.AccAddress, fromName string) {
+	if from == "" {
+		return nil, ""
+	}
+
+	keybase, err := keys.GetKeyBase()
+	if err != nil {
+		fmt.Println("no keybase found")
+		os.Exit(1)
+	}
+
+	var info cskeys.Info
+	if addr, err := types.AccAddressFromBech32(from); err == nil {
+		info, err = keybase.GetByAddress(addr)
+		if err != nil {
+			fmt.Printf("could not find key %s\n", from)
+			os.Exit(1)
+		}
+	} else {
+		info, err = keybase.Get(from)
+		if err != nil {
+			fmt.Printf("could not find key %s\n", from)
+			os.Exit(1)
+		}
+	}
+
+	fromAddr = info.GetAddress()
+	fromName = info.GetName()
+	return
+}
+
 // WithCodec returns a copy of the context with an updated codec.
 func (ctx CLIContext) WithCodec(cdc *codec.Codec) CLIContext {
 	ctx.Codec = cdc
@ -133,10 +174,9 @@ func (ctx CLIContext) WithAccountStore(accountStore string) CLIContext {
 	return ctx
 }

-// WithFromAddressName returns a copy of the context with an updated from
-// address.
-func (ctx CLIContext) WithFromAddressName(addrName string) CLIContext {
-	ctx.FromAddressName = addrName
+// WithFrom returns a copy of the context with an updated from address or name.
+func (ctx CLIContext) WithFrom(from string) CLIContext {
+	ctx.From = from
 	return ctx
 }

--- a/client/context/query.go
+++ b/client/context/query.go
@ -4,7 +4,6 @@ import (
 	"fmt"
 	"io"

-	"github.com/cosmos/cosmos-sdk/client/keys"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"

@ -84,22 +83,13 @@ func (ctx CLIContext) GetAccount(address []byte) (auth.Account, error) {
 }

 // GetFromAddress returns the from address from the context's name.
-func (ctx CLIContext) GetFromAddress() (from sdk.AccAddress, err error) {
-	if ctx.FromAddressName == "" {
-		return nil, errors.Errorf("must provide a from address name")
-	}
+func (ctx CLIContext) GetFromAddress() (sdk.AccAddress, error) {
+	return ctx.fromAddress, nil
+}

-	keybase, err := keys.GetKeyBase()
-	if err != nil {
-		return nil, err
-	}
-
-	info, err := keybase.Get(ctx.FromAddressName)
-	if err != nil {
-		return nil, errors.Errorf("no key for: %s", ctx.FromAddressName)
-	}
-
-	return sdk.AccAddress(info.GetPubKey().Address()), nil
+// GetFromName returns the key name for the current context.
+func (ctx CLIContext) GetFromName() (string, error) {
+	return ctx.fromName, nil
 }

 // GetAccountNumber returns the next account number for the given account
--- a/client/flags.go
+++ b/client/flags.go
@ -5,6 +5,7 @@ import (
 	"strconv"

 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 )

 // nolint
@ -51,6 +52,10 @@ func GetCommands(cmds ...*cobra.Command) []*cobra.Command {
 		c.Flags().String(FlagChainID, "", "Chain ID of tendermint node")
 		c.Flags().String(FlagNode, "tcp://localhost:26657", "<host>:<port> to tendermint rpc interface for this chain")
 		c.Flags().Int64(FlagHeight, 0, "block height to query, omit to get most recent provable block")
+		viper.BindPFlag(FlagTrustNode, c.Flags().Lookup(FlagTrustNode))
+		viper.BindPFlag(FlagUseLedger, c.Flags().Lookup(FlagUseLedger))
+		viper.BindPFlag(FlagChainID, c.Flags().Lookup(FlagChainID))
+		viper.BindPFlag(FlagNode, c.Flags().Lookup(FlagNode))
 	}
 	return cmds
 }
@ -58,7 +63,7 @@ func GetCommands(cmds ...*cobra.Command) []*cobra.Command {
 // PostCommands adds common flags for commands to post tx
 func PostCommands(cmds ...*cobra.Command) []*cobra.Command {
 	for _, c := range cmds {
-		c.Flags().String(FlagFrom, "", "Name of private key with which to sign")
+		c.Flags().String(FlagFrom, "", "Name or address of private key with which to sign")
 		c.Flags().Int64(FlagAccountNumber, 0, "AccountNumber number to sign the tx")
 		c.Flags().Int64(FlagSequence, 0, "Sequence number to sign the tx")
 		c.Flags().String(FlagMemo, "", "Memo to send along with transaction")
@ -76,6 +81,10 @@ func PostCommands(cmds ...*cobra.Command) []*cobra.Command {
 		// --gas can accept integers and "simulate"
 		c.Flags().Var(&GasFlagVar, "gas", fmt.Sprintf(
 			"gas limit to set per-transaction; set to %q to calculate required gas automatically (default %d)", GasFlagSimulate, DefaultGasLimit))
+		viper.BindPFlag(FlagTrustNode, c.Flags().Lookup(FlagTrustNode))
+		viper.BindPFlag(FlagUseLedger, c.Flags().Lookup(FlagUseLedger))
+		viper.BindPFlag(FlagChainID, c.Flags().Lookup(FlagChainID))
+		viper.BindPFlag(FlagNode, c.Flags().Lookup(FlagNode))
 	}
 	return cmds
 }
--- a/client/input.go
+++ b/client/input.go
@ -100,6 +100,19 @@ func GetConfirmation(prompt string, buf *bufio.Reader) (bool, error) {
 	}
 }

+// GetString simply returns the trimmed string output of a given reader.
+func GetString(prompt string, buf *bufio.Reader) (string, error) {
+	if inputIsTty() && prompt != "" {
+		PrintPrefixed(prompt)
+	}
+
+	out, err := readLineFromBuf(buf)
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(out), nil
+}
+
 // inputIsTty returns true iff we have an interactive prompt,
 // where we can disable echo and request to repeat the password.
 // If false, we can optimize for piped input from another command
@ -117,3 +130,8 @@ func readLineFromBuf(buf *bufio.Reader) (string, error) {
 	}
 	return strings.TrimSpace(pass), nil
 }
+
+// PrintPrefixed prints a string with > prefixed for use in prompts.
+func PrintPrefixed(msg string) {
+	fmt.Printf("> %s\n", msg)
+}
--- a/client/keys/add.go
+++ b/client/keys/add.go
@ -46,7 +46,6 @@ phrase, otherwise, a new key will be generated.`,
 	return cmd
 }

-// nolint: gocyclo
 // TODO remove the above when addressing #1446
 func runAddCmd(cmd *cobra.Command, args []string) error {
 	var kb keys.Keybase
--- a/client/lcd/lcd_test.go
+++ b/client/lcd/lcd_test.go
@ -120,6 +120,11 @@ func TestKeys(t *testing.T) {
 }

 func TestVersion(t *testing.T) {
+	// skip the test if the VERSION environment variable has not been set
+	if version.Version == "" {
+		t.SkipNow()
+	}
+
 	cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
 	defer cleanup()

--- a/client/lcd/root.go
+++ b/client/lcd/root.go
@ -121,6 +121,9 @@ func ServeCommand(cdc *codec.Codec) *cobra.Command {
 	cmd.Flags().String(client.FlagNode, "tcp://localhost:26657", "Address of the node to connect to")
 	cmd.Flags().Int(flagMaxOpenConnections, 1000, "The number of maximum open connections")
 	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode))
+	viper.BindPFlag(client.FlagChainID, cmd.Flags().Lookup(client.FlagChainID))
+	viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))

 	return cmd
 }
--- a/client/rpc/block.go
+++ b/client/rpc/block.go
@ -10,6 +10,7 @@ import (

 	"github.com/gorilla/mux"
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 	tmliteProxy "github.com/tendermint/tendermint/lite/proxy"
 )

@ -22,7 +23,9 @@ func BlockCommand() *cobra.Command {
 		RunE:  printBlock,
 	}
 	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
+	viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
 	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode))
 	cmd.Flags().String(client.FlagChainID, "", "Chain ID of Tendermint node")
 	return cmd
 }
--- a/client/rpc/root.go
+++ b/client/rpc/root.go
@ -7,6 +7,7 @@ import (

 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/spf13/viper"
 )

 const (
@ -40,6 +41,9 @@ func initClientCommand() *cobra.Command {
 	cmd.Flags().String(flagGenesis, "", "Genesis file to verify header validity")
 	cmd.Flags().String(flagCommit, "", "File with trusted and signed header")
 	cmd.Flags().String(flagValHash, "", "Hash of trusted validator set (hex-encoded)")
+	viper.BindPFlag(client.FlagChainID, cmd.Flags().Lookup(client.FlagChainID))
+	viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
+
 	return cmd
 }

--- a/client/rpc/status.go
+++ b/client/rpc/status.go
@ -10,6 +10,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/context"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
+	"github.com/spf13/viper"
 )

 func statusCommand() *cobra.Command {
@ -20,6 +21,7 @@ func statusCommand() *cobra.Command {
 	}

 	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
+	viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
 	return cmd
 }

--- a/client/rpc/validators.go
+++ b/client/rpc/validators.go
@ -13,6 +13,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/context"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	tmtypes "github.com/tendermint/tendermint/types"
+	"github.com/spf13/viper"
 )

 // TODO these next two functions feel kinda hacky based on their placement
@ -26,8 +27,11 @@ func ValidatorCommand() *cobra.Command {
 		RunE:  printValidators,
 	}
 	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
+	viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
 	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode))
 	cmd.Flags().String(client.FlagChainID, "", "Chain ID of Tendermint node")
+	viper.BindPFlag(client.FlagChainID, cmd.Flags().Lookup(client.FlagChainID))
 	return cmd
 }

--- a/client/tx/query.go
+++ b/client/tx/query.go
@ -3,8 +3,8 @@ package tx
 import (
 	"encoding/hex"
 	"fmt"
-	"github.com/tendermint/tendermint/libs/common"
 	"net/http"
+	"github.com/tendermint/tendermint/libs/common"

 	"github.com/gorilla/mux"
 	"github.com/spf13/cobra"
@ -16,6 +16,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/spf13/viper"
 )

 // QueryTxCmd implements the default command for a tx query.
@ -41,8 +42,11 @@ func QueryTxCmd(cdc *codec.Codec) *cobra.Command {
 	}

 	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
-	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
 	cmd.Flags().String(client.FlagChainID, "", "Chain ID of Tendermint node")
+	viper.BindPFlag(client.FlagChainID, cmd.Flags().Lookup(client.FlagChainID))
+	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode))
 	return cmd
 }

--- a/client/tx/search.go
+++ b/client/tx/search.go
@ -62,8 +62,11 @@ $ gaiacli tendermint txs --tag test1,test2 --any
 	}

 	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
-	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
 	cmd.Flags().String(client.FlagChainID, "", "Chain ID of Tendermint node")
+	viper.BindPFlag(client.FlagChainID, cmd.Flags().Lookup(client.FlagChainID))
+	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode))
 	cmd.Flags().StringSlice(flagTags, nil, "Comma-separated list of tags that must match")
 	cmd.Flags().Bool(flagAny, false, "Return transactions that match ANY tag, rather than ALL")
 	return cmd
--- a/client/utils/utils.go
+++ b/client/utils/utils.go
@ -8,9 +8,9 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/client/keys"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	auth "github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/cosmos/cosmos-sdk/x/auth"
 	authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
-	amino "github.com/tendermint/go-amino"
+	"github.com/tendermint/go-amino"
 	"github.com/tendermint/tendermint/libs/common"
 )

@ -25,8 +25,13 @@ func SendTx(txBldr authtxb.TxBuilder, cliCtx context.CLIContext, msgs []sdk.Msg)
 		return err
 	}

+	name, err := cliCtx.GetFromName()
+	if err != nil {
+		return err
+	}
+
 	if txBldr.SimulateGas || cliCtx.DryRun {
-		txBldr, err = EnrichCtxWithGas(txBldr, cliCtx, cliCtx.FromAddressName, msgs)
+		txBldr, err = EnrichCtxWithGas(txBldr, cliCtx, name, msgs)
 		if err != nil {
 			return err
 		}
@ -36,13 +41,13 @@ func SendTx(txBldr authtxb.TxBuilder, cliCtx context.CLIContext, msgs []sdk.Msg)
 		return nil
 	}

-	passphrase, err := keys.GetPassphrase(cliCtx.FromAddressName)
+	passphrase, err := keys.GetPassphrase(name)
 	if err != nil {
 		return err
 	}

 	// build and sign the transaction
-	txBytes, err := txBldr.BuildAndSign(cliCtx.FromAddressName, passphrase, msgs)
+	txBytes, err := txBldr.BuildAndSign(name, passphrase, msgs)
 	if err != nil {
 		return err
 	}
@ -196,7 +201,13 @@ func buildUnsignedStdTx(txBldr authtxb.TxBuilder, cliCtx context.CLIContext, msg
 		return
 	}
 	if txBldr.SimulateGas {
-		txBldr, err = EnrichCtxWithGas(txBldr, cliCtx, cliCtx.FromAddressName, msgs)
+		var name string
+		name, err = cliCtx.GetFromName()
+		if err != nil {
+			return
+		}
+
+		txBldr, err = EnrichCtxWithGas(txBldr, cliCtx, name, msgs)
 		if err != nil {
 			return
 		}
--- a/cmd/gaia/app/sim_test.go
+++ b/cmd/gaia/app/sim_test.go
@ -10,7 +10,6 @@ import (

 	"github.com/stretchr/testify/require"

-	"github.com/tendermint/tendermint/crypto"
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"

@ -42,14 +41,14 @@ func init() {
 	flag.BoolVar(&commit, "SimulationCommit", false, "Have the simulation commit")
 }

-func appStateFn(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json.RawMessage {
+func appStateFn(r *rand.Rand, accs []simulation.Account) json.RawMessage {
 	var genesisAccounts []GenesisAccount

 	// Randomly generate some genesis accounts
 	for _, acc := range accs {
 		coins := sdk.Coins{sdk.Coin{"steak", sdk.NewInt(100)}}
 		genesisAccounts = append(genesisAccounts, GenesisAccount{
-			Address: acc,
+			Address: acc.Address,
 			Coins:   coins,
 		})
 	}
@ -61,10 +60,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(sdk.ValAddress(accs[i]), keys[i].PubKey(), stake.Description{})
+		validator := stake.NewValidator(sdk.ValAddress(accs[i].Address), accs[i].PubKey, stake.Description{})
 		validator.Tokens = sdk.NewDec(100)
 		validator.DelegatorShares = sdk.NewDec(100)
-		delegation := stake.Delegation{accs[i], sdk.ValAddress(accs[i]), sdk.NewDec(100), 0}
+		delegation := stake.Delegation{accs[i].Address, sdk.ValAddress(accs[i].Address), sdk.NewDec(100), 0}
 		validators = append(validators, validator)
 		delegations = append(delegations, delegation)
 	}
--- a/cmd/gaia/cli_test/cli_test.go
+++ b/cmd/gaia/cli_test/cli_test.go
@ -8,6 +8,7 @@ import (
 	"io/ioutil"
 	"os"
 	"testing"
+	"path"

 	"github.com/stretchr/testify/require"

@ -515,6 +516,48 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
 	require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf("steak").Int64())
 }

+func TestGaiaCLIConfig(t *testing.T) {
+	require.NoError(t, os.RemoveAll(gaiacliHome))
+	require.NoError(t, os.RemoveAll(gaiadHome))
+	servAddr, port, err := server.FreeTCPAddr()
+	require.NoError(t, err)
+	node := fmt.Sprintf("%s:%s", servAddr, port)
+	chainID := executeInit(t, fmt.Sprintf("gaiad init -o --name=foo --home=%s --home-client=%s", gaiadHome, gaiacliHome))
+	executeWrite(t, fmt.Sprintf("gaiacli --home=%s config", gaiadHome), gaiacliHome, node, "y")
+	config, err := ioutil.ReadFile(path.Join(gaiacliHome, "config", "config.toml"))
+	require.NoError(t, err)
+	expectedConfig := fmt.Sprintf(`chain_id = "%s"
+encoding = "btc"
+home = "%s"
+node = "%s"
+output = "text"
+trace = false
+trust_node = true
+`, chainID, gaiacliHome, node)
+	require.Equal(t, expectedConfig, string(config))
+	// ensure a backup gets created
+	executeWrite(t, "gaiacli config", gaiacliHome, node, "y", "y")
+	configBackup, err := ioutil.ReadFile(path.Join(gaiacliHome, "config", "config.toml-old"))
+	require.NoError(t, err)
+	require.Equal(t, expectedConfig, string(configBackup))
+
+	require.NoError(t, os.RemoveAll(gaiadHome))
+	executeWrite(t, "gaiacli config", gaiacliHome, node, "y")
+
+	// ensure it works without an initialized gaiad state
+	expectedConfig = fmt.Sprintf(`chain_id = ""
+encoding = "btc"
+home = "%s"
+node = "%s"
+output = "text"
+trace = false
+trust_node = true
+`, gaiacliHome, node)
+	config, err = ioutil.ReadFile(path.Join(gaiacliHome, "config", "config.toml"))
+	require.NoError(t, err)
+	require.Equal(t, expectedConfig, string(config))
+}
+
 //___________________________________________________________________________________
 // helper methods

--- a/cmd/gaia/cmd/gaiacli/main.go
+++ b/cmd/gaia/cmd/gaiacli/main.go
@ -18,6 +18,9 @@ import (
 	stakecmd "github.com/cosmos/cosmos-sdk/x/stake/client/cli"

 	"github.com/cosmos/cosmos-sdk/cmd/gaia/app"
+	"path"
+	"os"
+	"github.com/spf13/viper"
 )

 // rootCmd is the entry point for this binary
@ -35,6 +38,7 @@ func main() {
 	// TODO: setup keybase, viper object, etc. to be passed into
 	// the below functions and eliminate global vars, like we do
 	// with the cdc
+	rootCmd.AddCommand(client.ConfigCmd())

 	// add standard rpc commands
 	rpc.AddCommands(rootCmd)
@ -131,9 +135,35 @@ func main() {

 	// prepare and add flags
 	executor := cli.PrepareMainCmd(rootCmd, "GA", app.DefaultCLIHome)
-	err := executor.Execute()
+	err := initConfig(rootCmd)
+	if err != nil {
+		panic(err)
+	}
+
+	err = executor.Execute()
 	if err != nil {
 		// handle with #870
 		panic(err)
 	}
 }
+
+func initConfig(cmd *cobra.Command) error {
+	home, err := cmd.PersistentFlags().GetString(cli.HomeFlag)
+	if err != nil {
+		return err
+	}
+
+	cfgFile := path.Join(home, "config", "config.toml")
+	if _, err := os.Stat(cfgFile); err == nil {
+		viper.SetConfigFile(cfgFile)
+
+		if err := viper.ReadInConfig(); err != nil {
+			return err
+		}
+	}
+
+	if err := viper.BindPFlag(cli.EncodingFlag, cmd.PersistentFlags().Lookup(cli.EncodingFlag)); err != nil {
+	    return err
+	}
+	return viper.BindPFlag(cli.OutputFlag, cmd.PersistentFlags().Lookup(cli.OutputFlag))
+}
--- a/crypto/keys/keybase.go
+++ b/crypto/keys/keybase.go
@ -14,6 +14,7 @@ import (
 	"github.com/tendermint/tendermint/crypto/encoding/amino"
 	"github.com/tendermint/tendermint/crypto/secp256k1"
 	dbm "github.com/tendermint/tendermint/libs/db"
+	"github.com/cosmos/cosmos-sdk/types"
 )

 var _ Keybase = dbKeybase{}
@ -41,6 +42,8 @@ const (
 	French
 	// Italian is currently not supported.
 	Italian
+	addressSuffix = "address"
+	infoSuffix    = "info"
 )

 var (
@ -179,11 +182,16 @@ func (kb dbKeybase) List() ([]Info, error) {
 	iter := kb.db.Iterator(nil, nil)
 	defer iter.Close()
 	for ; iter.Valid(); iter.Next() {
-		info, err := readInfo(iter.Value())
-		if err != nil {
-			return nil, err
+		key := string(iter.Key())
+
+		// need to include only keys in storage that have an info suffix
+		if strings.HasSuffix(key, infoSuffix) {
+			info, err := readInfo(iter.Value())
+			if err != nil {
+				return nil, err
+			}
+			res = append(res, info)
 		}
-		res = append(res, info)
 	}
 	return res, nil
 }
@ -197,6 +205,15 @@ func (kb dbKeybase) Get(name string) (Info, error) {
 	return readInfo(bs)
 }

+func (kb dbKeybase) GetByAddress(address types.AccAddress) (Info, error) {
+	ik := kb.db.Get(addrKey(address))
+	if len(ik) == 0 {
+		return nil, fmt.Errorf("key with address %s not found", address)
+	}
+	bs := kb.db.Get(ik)
+	return readInfo(bs)
+}
+
 // Sign signs the msg with the named key.
 // It returns an error if the key doesn't exist or the decryption fails.
 func (kb dbKeybase) Sign(name, passphrase string, msg []byte) (sig []byte, pub tmcrypto.PubKey, err error) {
@ -347,6 +364,7 @@ func (kb dbKeybase) Delete(name, passphrase string) error {
 		if err != nil {
 			return err
 		}
+		kb.db.DeleteSync(addrKey(linfo.GetAddress()))
 		kb.db.DeleteSync(infoKey(name))
 		return nil
 	case ledgerInfo:
@ -354,9 +372,11 @@ func (kb dbKeybase) Delete(name, passphrase string) error {
 		if passphrase != "yes" {
 			return fmt.Errorf("enter 'yes' exactly to delete the key - this cannot be undone")
 		}
+		kb.db.DeleteSync(addrKey(info.GetAddress()))
 		kb.db.DeleteSync(infoKey(name))
 		return nil
 	}
+
 	return nil
 }

@ -413,9 +433,16 @@ func (kb dbKeybase) writeOfflineKey(pub tmcrypto.PubKey, name string) Info {

 func (kb dbKeybase) writeInfo(info Info, name string) {
 	// write the info by key
-	kb.db.SetSync(infoKey(name), writeInfo(info))
+	key := infoKey(name)
+	kb.db.SetSync(key, writeInfo(info))
+	// store a pointer to the infokey by address for fast lookup
+	kb.db.SetSync(addrKey(info.GetAddress()), key)
+}
+
+func addrKey(address types.AccAddress) []byte {
+	return []byte(fmt.Sprintf("%s.%s", address.String(), addressSuffix))
 }

 func infoKey(name string) []byte {
-	return []byte(fmt.Sprintf("%s.info", name))
+	return []byte(fmt.Sprintf("%s.%s", name, infoSuffix))
 }
--- a/crypto/keys/keybase_test.go
+++ b/crypto/keys/keybase_test.go
@ -11,6 +11,7 @@ import (
 	"github.com/tendermint/tendermint/crypto/ed25519"

 	dbm "github.com/tendermint/tendermint/libs/db"
+	"github.com/cosmos/cosmos-sdk/types"
 )

 func init() {
@ -20,8 +21,9 @@ func init() {
 // TestKeyManagement makes sure we can manipulate these keys well
 func TestKeyManagement(t *testing.T) {
 	// make the storage with reasonable defaults
+	db := dbm.NewMemDB()
 	cstore := New(
-		dbm.NewMemDB(),
+		db,
 	)

 	algo := Secp256k1
@ -51,6 +53,12 @@ func TestKeyManagement(t *testing.T) {
 	require.NoError(t, err)
 	_, err = cstore.Get(n3)
 	require.NotNil(t, err)
+	_, err = cstore.GetByAddress(accAddr(i2))
+	require.NoError(t, err)
+	addr, err := types.AccAddressFromBech32("cosmos1yq8lgssgxlx9smjhes6ryjasmqmd3ts2559g0t")
+	require.NoError(t, err)
+	_, err = cstore.GetByAddress(addr)
+	require.NotNil(t, err)

 	// list shows them in order
 	keyS, err := cstore.List()
@ -92,6 +100,11 @@ func TestKeyManagement(t *testing.T) {
 	keyS, err = cstore.List()
 	require.NoError(t, err)
 	require.Equal(t, 1, len(keyS))
+
+	// addr cache gets nuked
+	err = cstore.Delete(n2, p2)
+	require.NoError(t, err)
+	require.False(t, db.Has(addrKey(i2.GetAddress())))
 }

 // TestSignVerify does some detailed checks on how we sign and validate
@ -387,3 +400,7 @@ func ExampleNew() {
 	// Carl
 	// signed by Bob
 }
+
+func accAddr(info Info) types.AccAddress {
+	return (types.AccAddress)(info.GetPubKey().Address())
+}
--- a/crypto/keys/types.go
+++ b/crypto/keys/types.go
@ -5,14 +5,15 @@ import (
 	"github.com/tendermint/tendermint/crypto"

 	"github.com/cosmos/cosmos-sdk/crypto/keys/hd"
+	"github.com/cosmos/cosmos-sdk/types"
 )

 // Keybase exposes operations on a generic keystore
 type Keybase interface {
-
 	// CRUD on the keystore
 	List() ([]Info, error)
 	Get(name string) (Info, error)
+	GetByAddress(address types.AccAddress) (Info, error)
 	Delete(name, passphrase string) error

 	// Sign some bytes, looking up the private key to use
@ -73,6 +74,8 @@ type Info interface {
 	GetName() string
 	// Public key
 	GetPubKey() crypto.PubKey
+	// Address
+	GetAddress() types.AccAddress
 }

 var _ Info = &localInfo{}
@ -106,6 +109,10 @@ func (i localInfo) GetPubKey() crypto.PubKey {
 	return i.PubKey
 }

+func (i localInfo) GetAddress() types.AccAddress {
+	return i.PubKey.Address().Bytes()
+}
+
 // ledgerInfo is the public information about a Ledger key
 type ledgerInfo struct {
 	Name   string                 `json:"name"`
@ -133,6 +140,10 @@ func (i ledgerInfo) GetPubKey() crypto.PubKey {
 	return i.PubKey
 }

+func (i ledgerInfo) GetAddress() types.AccAddress {
+	return i.PubKey.Address().Bytes()
+}
+
 // offlineInfo is the public information about an offline key
 type offlineInfo struct {
 	Name   string        `json:"name"`
@ -158,6 +169,10 @@ func (i offlineInfo) GetPubKey() crypto.PubKey {
 	return i.PubKey
 }

+func (i offlineInfo) GetAddress() types.AccAddress {
+	return i.PubKey.Address().Bytes()
+}
+
 // encoding info
 func writeInfo(i Info) []byte {
 	return cdc.MustMarshalBinary(i)
--- a/docs/spec/bank/WIP_keeper.md
+++ b/docs/spec/bank/WIP_keeper.md
@ -0,0 +1,25 @@
+WORK IN PROGRESS 
+See PR comments here https://github.com/cosmos/cosmos-sdk/pull/2072
+
+# Keeper
+
+## Denom Metadata
+
+The BankKeeper contains a store that stores the metadata of different token denoms.  Denoms are referred to by their name, same as the `denom` field in sdk.Coin.  The different attributes of a denom are stored in the denom metadata store under the key `[denom name]:[attribute name]`.  The default attributes in the store are explained below.  However, this can be extended by the developer or through SoftwareUpgrade proposals.
+
+### Decimals `int8`
+
+- `Base Unit` = The common standard for the default "standard" size of a token. Examples: 1 Bitcoin or 1 Ether.
+- `Smallest Unit` = The smallest possible denomination of a token. A fraction of the base unit.  Examples: 1 satoshi or 1 wei.
+
+All amounts throughout the SDK are denominated in the smallest unit of a token, so that all amounts can be expressed as integers.  However, UIs typically want to display token values in the base unit, so the Decimals metadata field standardizes the number of digits that come after the decimal place in the base unit.
+
+`1 [Base Unit] = 10^(N) [Smallest Unit]`
+
+### TotalSupply `sdk.Integer`
+
+The TotalSupply of a denom is the total amount of a token that exists (known to the chain) across all accounts and modules.  It is denominated in the `smallest unit` of a denom.  It can be changed by the Keeper functions `MintCoins` and `BurnCoins`.  `AddCoins` and `SubtractCoins` are used when adding or subtracting coins for an account, but not removing them from total supply (for example, when moving the coins to the control of the staking module).
+
+### Aliases `[]string`
+
+Aliases is an array of strings that are "alternative names" for a token. As an example, while the Ether's denom name might be `ether`, a possible alias could be `ETH`.  This field can be useful for UIs and clients.  It is intended that this field can be modified by a governance mechanism.
--- a/docs/spec/bank/state.md
+++ b/docs/spec/bank/state.md
@ -1,2 +0,0 @@
- SDK related specifications (ie. how multistore, signatures, etc. work).
- Basecoin (SendTx)
--- a/docs/spec/governance/state.md
+++ b/docs/spec/governance/state.md
@ -28,7 +28,6 @@ type TallyingProcedure struct {
  Threshold         sdk.Dec   //  Minimum propotion of Yes votes for proposal to pass. Initial value: 0.5
  Veto              sdk.Dec   //  Minimum proportion of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3
  GovernancePenalty sdk.Dec             //  Penalty if validator does not vote
-  GracePeriod       time.Time               //  If validator entered validator set in this period of blocks before vote ended, governance penalty does not apply
 }
 ```

@ -192,14 +191,10 @@ And the pseudocode for the `ProposalProcessingQueue`:

      tallyingProcedure = load(GlobalParams, 'TallyingProcedure')

-      // Slash validators that did not vote, or update tally if they voted
+      // Update tally if validator voted they voted
      for each validator in validators
-        if (validator.bondTime < CurrentTime - tallyingProcedure.GracePeriod)
-        // only slash if validator entered validator set before grace period
-          if (!tmpValMap(validator).HasVoted)
-            slash validator by tallyingProcedure.GovernancePenalty
-          else
-            proposal.updateTally(tmpValMap(validator).Vote, (validator.TotalShares - tmpValMap(validator).Minus))
+        if tmpValMap(validator).HasVoted
+          proposal.updateTally(tmpValMap(validator).Vote, (validator.TotalShares - tmpValMap(validator).Minus))



--- a/tools/Makefile
+++ b/tools/Makefile
@ -12,7 +12,6 @@ INEFFASSIGN = github.com/gordonklaus/ineffassign
 MISSPELL = github.com/client9/misspell/cmd/misspell
 ERRCHECK = github.com/kisielk/errcheck
 UNPARAM = mvdan.cc/unparam
-GOCYCLO = github.com/alecthomas/gocyclo

 DEP_CHECK := $(shell command -v dep 2> /dev/null)
 GOLINT_CHECK := $(shell command -v golint 2> /dev/null)
@ -22,7 +21,6 @@ INEFFASSIGN_CHECK := $(shell command -v ineffassign 2> /dev/null)
 MISSPELL_CHECK := $(shell command -v misspell 2> /dev/null)
 ERRCHECK_CHECK := $(shell command -v errcheck 2> /dev/null)
 UNPARAM_CHECK := $(shell command -v unparam 2> /dev/null)
-# GOCYCLO_CHECK := $(shell command -v gocyclo 2> /dev/null)

 check_tools:
 ifndef DEP_CHECK
@ -68,11 +66,6 @@ ifndef UNPARAM_CHECK
 else
 	@echo "Found unparam in path."
 endif
-ifndef GOCYCLO_CHECK
-	@echo "No gocyclo in path.  Install with 'make get_tools'."
-else
-	@echo "Found gocyclo in path."
-endif

 get_tools:
 ifdef DEP_CHECK
@ -126,12 +119,6 @@ else
 	@echo "Installing unparam"
 	go get -v $(UNPARAM)
 endif
-# ifdef GOCYCLO_CHECK
-# 	@echo "gocyclo is already installed.  Run 'make update_tools' to update."
-# else
-# 	@echo "Installing gocyclo"
-# 	go get -v $(GOCYCLO)
-# endif

 update_tools:
 	@echo "Updating dep"
@ -153,8 +140,6 @@ update_dev_tools:
 	go get -u -v $(ERRCHECK)
 	@echo "Updating unparam"
 	go get -u -v $(UNPARAM)
-	# @echo "Updating goyclo"
-	# go get -u -v $(GOCYCLO)

 # To avoid unintended conflicts with file names, always add to .PHONY
 # unless there is a reason not to.
--- a/types/address_test.go
+++ b/types/address_test.go
@ -10,7 +10,7 @@ import (
 	"github.com/tendermint/tendermint/crypto/ed25519"

 	"github.com/cosmos/cosmos-sdk/types"
-)
+	)

 var invalidStrs = []string{
 	"",
--- a/types/errors.go
+++ b/types/errors.go
@ -73,7 +73,6 @@ func unknownCodeMsg(code CodeType) string {
 }

 // NOTE: Don't stringer this, we'll put better messages in later.
-// nolint: gocyclo
 func CodeToDefaultMsg(code CodeType) string {
 	switch code {
 	case CodeInternal:
--- a/types/utils.go
+++ b/types/utils.go
@ -1,6 +1,10 @@
 package types

-import "encoding/json"
+import (
+	"encoding/json"
+	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
+	tmtypes "github.com/tendermint/tendermint/types"
+)

 // SortedJSON takes any JSON and returns it sorted by keys. Also, all white-spaces
 // are removed.
@ -29,3 +33,22 @@ func MustSortJSON(toSortJSON []byte) []byte {
 	}
 	return js
 }
+
+// DefaultChainID returns the chain ID from the genesis file if present. An
+// error is returned if the file cannot be read or parsed.
+//
+// TODO: This should be removed and the chainID should always be provided by
+// the end user.
+func DefaultChainID() (string, error) {
+	cfg, err := tcmd.ParseConfig()
+	if err != nil {
+		return "", err
+	}
+
+	doc, err := tmtypes.GenesisDocFromFile(cfg.GenesisFile())
+	if err != nil {
+		return "", err
+	}
+
+	return doc.ChainID, nil
+}
--- a/x/auth/ante.go
+++ b/x/auth/ante.go
@ -23,7 +23,6 @@ const (
 // NewAnteHandler returns an AnteHandler that checks
 // and increments sequence numbers, checks signatures & account numbers,
 // and deducts fees from the first signer.
-// nolint: gocyclo
 func NewAnteHandler(am AccountMapper, fck FeeCollectionKeeper) sdk.AnteHandler {

 	return func(
--- a/x/auth/client/txbuilder/txbuilder.go
+++ b/x/auth/client/txbuilder/txbuilder.go
@ -30,7 +30,7 @@ func NewTxBuilderFromCLI() TxBuilder {
 	// if chain ID is not specified manually, read default chain ID
 	chainID := viper.GetString(client.FlagChainID)
 	if chainID == "" {
-		defaultChainID, err := defaultChainID()
+		defaultChainID, err := sdk.DefaultChainID()
 		if err != nil {
 			chainID = defaultChainID
 		}
--- a/x/auth/client/txbuilder/utils.go
+++ b/x/auth/client/txbuilder/utils.go
@ -1,25 +0,0 @@
-package context
-
-import (
-	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
-	tmtypes "github.com/tendermint/tendermint/types"
-)
-
-// defaultChainID returns the chain ID from the genesis file if present. An
-// error is returned if the file cannot be read or parsed.
-//
-// TODO: This should be removed and the chainID should always be provided by
-// the end user.
-func defaultChainID() (string, error) {
-	cfg, err := tcmd.ParseConfig()
-	if err != nil {
-		return "", err
-	}
-
-	doc, err := tmtypes.GenesisDocFromFile(cfg.GenesisFile())
-	if err != nil {
-		return "", err
-	}
-
-	return doc.ChainID, nil
-}
--- a/x/bank/client/rest/sendtx.go
+++ b/x/bank/client/rest/sendtx.go
@ -43,7 +43,6 @@ func init() {
 }

 // SendRequestHandlerFn - http request handler to send coins to a address
-// nolint: gocyclo
 func SendRequestHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		// collect data
--- a/x/bank/simulation/msgs.go
+++ b/x/bank/simulation/msgs.go
@ -18,19 +18,18 @@ import (
 // SimulateSingleInputMsgSend tests and runs a single msg send, with one input and one output, where both
 // accounts already exist.
 func SimulateSingleInputMsgSend(mapper auth.AccountMapper) simulation.Operation {
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
-		fromKey := simulation.RandomKey(r, keys)
-		fromAddr := sdk.AccAddress(fromKey.PubKey().Address())
-		toKey := simulation.RandomKey(r, keys)
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
+		fromAcc := simulation.RandomAcc(r, accs)
+		toAcc := simulation.RandomAcc(r, accs)
 		// Disallow sending money to yourself
 		for {
-			if !fromKey.Equals(toKey) {
+			if !fromAcc.PubKey.Equals(toAcc.PubKey) {
 				break
 			}
-			toKey = simulation.RandomKey(r, keys)
+			toAcc = simulation.RandomAcc(r, accs)
 		}
-		toAddr := sdk.AccAddress(toKey.PubKey().Address())
-		initFromCoins := mapper.GetAccount(ctx, fromAddr).GetCoins()
+		toAddr := toAcc.Address
+		initFromCoins := mapper.GetAccount(ctx, fromAcc.Address).GetCoins()

 		if len(initFromCoins) == 0 {
 			return "skipping, no coins at all", nil, nil
@ -43,7 +42,7 @@ func SimulateSingleInputMsgSend(mapper auth.AccountMapper) simulation.Operation
 		}

 		action = fmt.Sprintf("%s is sending %s %s to %s",
-			fromAddr.String(),
+			fromAcc.Address.String(),
 			amt.String(),
 			initFromCoins[denomIndex].Denom,
 			toAddr.String(),
@ -51,10 +50,10 @@ func SimulateSingleInputMsgSend(mapper auth.AccountMapper) simulation.Operation

 		coins := sdk.Coins{{initFromCoins[denomIndex].Denom, amt}}
 		var msg = bank.MsgSend{
-			Inputs:  []bank.Input{bank.NewInput(fromAddr, coins)},
+			Inputs:  []bank.Input{bank.NewInput(fromAcc.Address, coins)},
 			Outputs: []bank.Output{bank.NewOutput(toAddr, coins)},
 		}
-		goErr = sendAndVerifyMsgSend(app, mapper, msg, ctx, []crypto.PrivKey{fromKey})
+		goErr = sendAndVerifyMsgSend(app, mapper, msg, ctx, []crypto.PrivKey{fromAcc.PrivKey})
 		if goErr != nil {
 			return "", nil, goErr
 		}
--- a/x/bank/simulation/sim_test.go
+++ b/x/bank/simulation/sim_test.go
@ -5,8 +5,6 @@ import (
 	"math/rand"
 	"testing"

-	"github.com/tendermint/tendermint/crypto"
-
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/mock"
@ -26,8 +24,8 @@ func TestBankWithRandomMessages(t *testing.T) {
 		panic(err)
 	}

-	appStateFn := func(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json.RawMessage {
-		mock.RandomSetGenesis(r, mapp, accs, []string{"stake"})
+	appStateFn := func(r *rand.Rand, accs []simulation.Account) json.RawMessage {
+		simulation.RandomSetGenesis(r, mapp, accs, []string{"stake"})
 		return json.RawMessage("{}")
 	}

--- a/x/gov/client/cli/tx.go
+++ b/x/gov/client/cli/tx.go
@ -285,7 +285,6 @@ func GetCmdQueryProposal(queryRoute string, cdc *codec.Codec) *cobra.Command {
 	return cmd
 }

-// nolint: gocyclo
 // GetCmdQueryProposals implements a query proposals command.
 func GetCmdQueryProposals(queryRoute string, cdc *codec.Codec) *cobra.Command {
 	cmd := &cobra.Command{
--- a/x/gov/client/rest/rest.go
+++ b/x/gov/client/rest/rest.go
@ -334,7 +334,6 @@ func queryVoteHandlerFn(cdc *codec.Codec) http.HandlerFunc {
 	}
 }

-// nolint: gocyclo
 // todo: Split this functionality into helper functions to remove the above
 func queryVotesOnProposalHandlerFn(cdc *codec.Codec) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
@ -373,7 +372,6 @@ func queryVotesOnProposalHandlerFn(cdc *codec.Codec) http.HandlerFunc {
 	}
 }

-// nolint: gocyclo
 // todo: Split this functionality into helper functions to remove the above
 func queryProposalsWithParameterFn(cdc *codec.Codec) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
@ -439,7 +437,6 @@ func queryProposalsWithParameterFn(cdc *codec.Codec) http.HandlerFunc {
 	}
 }

-// nolint: gocyclo
 // todo: Split this functionality into helper functions to remove the above
 func queryTallyOnProposalHandlerFn(cdc *codec.Codec) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
--- a/x/gov/endblocker_test.go
+++ b/x/gov/endblocker_test.go
@ -7,7 +7,6 @@ import (
 	"github.com/stretchr/testify/require"

 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/stake"
 	abci "github.com/tendermint/tendermint/abci/types"
 )

@ -194,62 +193,3 @@ func TestTickPassedVotingPeriod(t *testing.T) {
 	require.Equal(t, StatusRejected, keeper.GetProposal(ctx, proposalID).GetStatus())
 	require.True(t, keeper.GetProposal(ctx, proposalID).GetTallyResult().Equals(EmptyTallyResult()))
 }
-
-func TestSlashing(t *testing.T) {
-	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10)
-	SortAddresses(addrs)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
-	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
-	govHandler := NewHandler(keeper)
-	stakeHandler := stake.NewHandler(sk)
-
-	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, 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)})
-
-	res := govHandler(ctx, newProposalMsg)
-	require.True(t, res.IsOK())
-	var proposalID int64
-	keeper.cdc.UnmarshalBinaryBare(res.Data, &proposalID)
-
-	newHeader := ctx.BlockHeader()
-	newHeader.Time = ctx.BlockHeader().Time.Add(time.Duration(1) * time.Second)
-	ctx = ctx.WithBlockHeader(newHeader)
-
-	require.Equal(t, StatusVotingPeriod, keeper.GetProposal(ctx, proposalID).GetStatus())
-
-	newVoteMsg := NewMsgVote(addrs[0], proposalID, OptionYes)
-	res = govHandler(ctx, newVoteMsg)
-	require.True(t, res.IsOK())
-
-	EndBlocker(ctx, keeper)
-
-	newHeader = ctx.BlockHeader()
-	newHeader.Time = ctx.BlockHeader().Time.Add(keeper.GetDepositProcedure(ctx).MaxDepositPeriod).Add(keeper.GetDepositProcedure(ctx).MaxDepositPeriod)
-	ctx = ctx.WithBlockHeader(newHeader)
-
-	require.Equal(t, StatusVotingPeriod, keeper.GetProposal(ctx, proposalID).GetStatus())
-
-	EndBlocker(ctx, keeper)
-
-	require.False(t, keeper.GetProposal(ctx, proposalID).GetTallyResult().Equals(EmptyTallyResult()))
-
-	endTotalPower := keeper.ds.GetValidatorSet().TotalPower(ctx)
-	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))
-	require.True(t, val2End.LT(val2Initial))
-}
--- a/x/gov/handler.go
+++ b/x/gov/handler.go
@ -134,7 +134,7 @@ func EndBlocker(ctx sdk.Context, keeper Keeper) (resTags sdk.Tags) {
 			continue
 		}

-		passes, tallyResults, nonVotingVals := tally(ctx, keeper, activeProposal)
+		passes, tallyResults := tally(ctx, keeper, activeProposal)
 		proposalIDBytes := keeper.cdc.MustMarshalBinaryBare(activeProposal.GetProposalID())
 		var action []byte
 		if passes {
@ -152,18 +152,6 @@ func EndBlocker(ctx sdk.Context, keeper Keeper) (resTags sdk.Tags) {
 		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)
-			keeper.ds.GetValidatorSet().Slash(ctx,
-				val.GetConsAddr(),
-				ctx.BlockHeight(),
-				val.GetPower().RoundInt64(),
-				keeper.GetTallyingProcedure(ctx).GovernancePenalty)
-
-			logger.Info(fmt.Sprintf("validator %s failed to vote on proposal %d; slashing",
-				val.GetOperator(), activeProposal.GetProposalID()))
-		}
-
 		resTags.AppendTag(tags.Action, action)
 		resTags.AppendTag(tags.ProposalID, proposalIDBytes)
 	}
--- a/x/gov/keeper.go
+++ b/x/gov/keeper.go
@ -106,7 +106,6 @@ func (keeper Keeper) DeleteProposal(ctx sdk.Context, proposal Proposal) {
 	store.Delete(KeyProposal(proposal.GetProposalID()))
 }

-// nolint: gocyclo
 // Get Proposal from store by ProposalID
 func (keeper Keeper) GetProposalsFiltered(ctx sdk.Context, voterAddr sdk.AccAddress, depositerAddr sdk.AccAddress, status ProposalStatus, numLatest int64) []Proposal {

--- a/x/gov/queryable.go
+++ b/x/gov/queryable.go
@ -220,7 +220,7 @@ func queryTally(ctx sdk.Context, path []string, req abci.RequestQuery, keeper Ke
 	} else if proposal.GetStatus() == StatusPassed || proposal.GetStatus() == StatusRejected {
 		tallyResult = proposal.GetTallyResult()
 	} else {
-		_, tallyResult, _ = tally(ctx, keeper, proposal)
+		_, tallyResult = tally(ctx, keeper, proposal)
 	}

 	bz, err2 := codec.MarshalJSONIndent(keeper.cdc, tallyResult)
--- a/x/gov/simulation/msgs.go
+++ b/x/gov/simulation/msgs.go
@ -6,8 +6,6 @@ import (
 	"math/rand"
 	"time"

-	"github.com/tendermint/tendermint/crypto"
-
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/gov"
@ -45,9 +43,9 @@ func SimulateSubmittingVotingAndSlashingForProposal(k gov.Keeper, sk stake.Keepe
 	})
 	statePercentageArray := []float64{1, .9, .75, .4, .15, 0}
 	curNumVotesState := 1
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
 		// 1) submit proposal now
-		sender := simulation.RandomKey(r, keys)
+		sender := simulation.RandomAcc(r, accs)
 		msg, err := simulationCreateMsgSubmitProposal(r, sender)
 		if err != nil {
 			return "", nil, err
@ -61,16 +59,16 @@ func SimulateSubmittingVotingAndSlashingForProposal(k gov.Keeper, sk stake.Keepe
 		// 2) Schedule operations for votes
 		// 2.1) first pick a number of people to vote.
 		curNumVotesState = numVotesTransitionMatrix.NextState(r, curNumVotesState)
-		numVotes := int(math.Ceil(float64(len(keys)) * statePercentageArray[curNumVotesState]))
+		numVotes := int(math.Ceil(float64(len(accs)) * statePercentageArray[curNumVotesState]))
 		// 2.2) select who votes and when
-		whoVotes := r.Perm(len(keys))
+		whoVotes := r.Perm(len(accs))
 		// didntVote := whoVotes[numVotes:]
 		whoVotes = whoVotes[:numVotes]
 		votingPeriod := k.GetVotingProcedure(ctx).VotingPeriod
 		fops := make([]simulation.FutureOperation, numVotes+1)
 		for i := 0; i < numVotes; i++ {
 			whenVote := ctx.BlockHeader().Time.Add(time.Duration(r.Int63n(int64(votingPeriod.Seconds()))) * time.Second)
-			fops[i] = simulation.FutureOperation{BlockTime: whenVote, Op: operationSimulateMsgVote(k, sk, keys[whoVotes[i]], proposalID)}
+			fops[i] = simulation.FutureOperation{BlockTime: whenVote, Op: operationSimulateMsgVote(k, sk, accs[whoVotes[i]], proposalID)}
 		}
 		// 3) Make an operation to ensure slashes were done correctly. (Really should be a future invariant)
 		// TODO: Find a way to check if a validator was slashed other than just checking their balance a block
@ -84,8 +82,8 @@ func SimulateSubmittingVotingAndSlashingForProposal(k gov.Keeper, sk stake.Keepe
 // Note: Currently doesn't ensure that the proposal txt is in JSON form
 func SimulateMsgSubmitProposal(k gov.Keeper, sk stake.Keeper) simulation.Operation {
 	handler := gov.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
-		sender := simulation.RandomKey(r, keys)
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
+		sender := simulation.RandomAcc(r, accs)
 		msg, err := simulationCreateMsgSubmitProposal(r, sender)
 		if err != nil {
 			return "", nil, err
@ -111,14 +109,13 @@ func simulateHandleMsgSubmitProposal(msg gov.MsgSubmitProposal, sk stake.Keeper,
 	return
 }

-func simulationCreateMsgSubmitProposal(r *rand.Rand, sender crypto.PrivKey) (msg gov.MsgSubmitProposal, err error) {
-	addr := sdk.AccAddress(sender.PubKey().Address())
+func simulationCreateMsgSubmitProposal(r *rand.Rand, sender simulation.Account) (msg gov.MsgSubmitProposal, err error) {
 	deposit := randomDeposit(r)
 	msg = gov.NewMsgSubmitProposal(
 		simulation.RandStringOfLength(r, 5),
 		simulation.RandStringOfLength(r, 5),
 		gov.ProposalTypeText,
-		addr,
+		sender.Address,
 		deposit,
 	)
 	if msg.ValidateBasic() != nil {
@ -129,15 +126,14 @@ func simulationCreateMsgSubmitProposal(r *rand.Rand, sender crypto.PrivKey) (msg

 // SimulateMsgDeposit
 func SimulateMsgDeposit(k gov.Keeper, sk stake.Keeper) simulation.Operation {
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
-		key := simulation.RandomKey(r, keys)
-		addr := sdk.AccAddress(key.PubKey().Address())
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+		acc := simulation.RandomAcc(r, accs)
 		proposalID, ok := randomProposalID(r, k, ctx)
 		if !ok {
 			return "no-operation", nil, nil
 		}
 		deposit := randomDeposit(r)
-		msg := gov.NewMsgDeposit(addr, proposalID, deposit)
+		msg := gov.NewMsgDeposit(acc.Address, proposalID, deposit)
 		if msg.ValidateBasic() != nil {
 			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
@ -159,14 +155,14 @@ func SimulateMsgDeposit(k gov.Keeper, sk stake.Keeper) simulation.Operation {
 // SimulateMsgVote
 // nolint: unparam
 func SimulateMsgVote(k gov.Keeper, sk stake.Keeper) simulation.Operation {
-	return operationSimulateMsgVote(k, sk, nil, -1)
+	return operationSimulateMsgVote(k, sk, simulation.Account{}, -1)
 }

 // nolint: unparam
-func operationSimulateMsgVote(k gov.Keeper, sk stake.Keeper, key crypto.PrivKey, proposalID int64) simulation.Operation {
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
-		if key == nil {
-			key = simulation.RandomKey(r, keys)
+func operationSimulateMsgVote(k gov.Keeper, sk stake.Keeper, acc simulation.Account, proposalID int64) simulation.Operation {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+		if acc.Equals(simulation.Account{}) {
+			acc = simulation.RandomAcc(r, accs)
 		}

 		var ok bool
@ -177,10 +173,9 @@ func operationSimulateMsgVote(k gov.Keeper, sk stake.Keeper, key crypto.PrivKey,
 				return "no-operation", nil, nil
 			}
 		}
-		addr := sdk.AccAddress(key.PubKey().Address())
 		option := randomVotingOption(r)

-		msg := gov.NewMsgVote(addr, proposalID, option)
+		msg := gov.NewMsgVote(acc.Address, proposalID, option)
 		if msg.ValidateBasic() != nil {
 			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
--- a/x/gov/simulation/sim_test.go
+++ b/x/gov/simulation/sim_test.go
@ -6,7 +6,6 @@ import (
 	"testing"

 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto"

 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/bank"
@ -43,12 +42,12 @@ func TestGovWithRandomMessages(t *testing.T) {
 		panic(err)
 	}

-	appStateFn := func(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json.RawMessage {
-		mock.RandomSetGenesis(r, mapp, accs, []string{"stake"})
+	appStateFn := func(r *rand.Rand, accs []simulation.Account) json.RawMessage {
+		simulation.RandomSetGenesis(r, mapp, accs, []string{"stake"})
 		return json.RawMessage("{}")
 	}

-	setup := func(r *rand.Rand, privKeys []crypto.PrivKey) {
+	setup := func(r *rand.Rand, accs []simulation.Account) {
 		ctx := mapp.NewContext(false, abci.Header{})
 		stake.InitGenesis(ctx, stakeKeeper, stake.DefaultGenesisState())
 		gov.InitGenesis(ctx, govKeeper, gov.DefaultGenesisState())
--- a/x/gov/tally.go
+++ b/x/gov/tally.go
@ -13,7 +13,7 @@ type validatorGovInfo struct {
 	Vote            VoteOption     // Vote of the validator
 }

-func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tallyResults TallyResult, nonVoting []sdk.ValAddress) {
+func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tallyResults TallyResult) {
 	results := make(map[VoteOption]sdk.Dec)
 	results[OptionYes] = sdk.ZeroDec()
 	results[OptionAbstain] = sdk.ZeroDec()
@ -70,12 +70,9 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 		keeper.deleteVote(ctx, vote.ProposalID, vote.Voter)
 	}

-	// iterate over the validators again to tally their voting power and see
-	// who didn't vote
-	nonVoting = []sdk.ValAddress{}
+	// iterate over the validators again to tally their voting power
 	for _, val := range currValidators {
 		if val.Vote == OptionEmpty {
-			nonVoting = append(nonVoting, val.Address)
 			continue
 		}

@ -98,19 +95,17 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall

 	// If no one votes, proposal fails
 	if totalVotingPower.Sub(results[OptionAbstain]).Equal(sdk.ZeroDec()) {
-		return false, tallyResults, nonVoting
+		return false, tallyResults
 	}
 	// If more than 1/3 of voters veto, proposal fails
 	if results[OptionNoWithVeto].Quo(totalVotingPower).GT(tallyingProcedure.Veto) {
-		return false, tallyResults, nonVoting
+		return false, tallyResults
 	}
 	// If more than 1/2 of non-abstaining voters vote Yes, proposal passes
 	if results[OptionYes].Quo(totalVotingPower.Sub(results[OptionAbstain])).GT(tallyingProcedure.Threshold) {
-		return true, tallyResults, nonVoting
+		return true, tallyResults
 	}
 	// If more than 1/2 of non-abstaining voters vote No, proposal fails

-	SortValAddresses(nonVoting)
-
-	return false, tallyResults, nonVoting
+	return false, tallyResults
 }
--- a/x/gov/tally_test.go
+++ b/x/gov/tally_test.go
@ -51,7 +51,7 @@ func TestTallyNoOneVotes(t *testing.T) {
 	proposal.SetStatus(StatusVotingPeriod)
 	keeper.SetProposal(ctx, proposal)

-	passes, tallyResults, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.False(t, passes)
 	require.True(t, tallyResults.Equals(EmptyTallyResult()))
@ -80,7 +80,7 @@ func TestTallyOnlyValidatorsAllYes(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionYes)
 	require.Nil(t, err)

-	passes, tallyResults, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.True(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@ -109,7 +109,7 @@ func TestTallyOnlyValidators51No(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionNo)
 	require.Nil(t, err)

-	passes, _, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.False(t, passes)
 }
@ -139,7 +139,7 @@ func TestTallyOnlyValidators51Yes(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNo)
 	require.Nil(t, err)

-	passes, tallyResults, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.True(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@ -170,7 +170,7 @@ func TestTallyOnlyValidatorsVetoed(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNoWithVeto)
 	require.Nil(t, err)

-	passes, tallyResults, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@ -201,7 +201,7 @@ func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionYes)
 	require.Nil(t, err)

-	passes, tallyResults, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.True(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@ -232,7 +232,7 @@ func TestTallyOnlyValidatorsAbstainFails(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNo)
 	require.Nil(t, err)

-	passes, tallyResults, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@ -261,11 +261,9 @@ func TestTallyOnlyValidatorsNonVoter(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNo)
 	require.Nil(t, err)

-	passes, tallyResults, nonVoting := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.False(t, passes)
-	require.Equal(t, 1, len(nonVoting))
-	require.Equal(t, sdk.ValAddress(addrs[0]), nonVoting[0])
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
 }

@ -299,7 +297,7 @@ func TestTallyDelgatorOverride(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[3], OptionNo)
 	require.Nil(t, err)

-	passes, tallyResults, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@ -333,10 +331,9 @@ func TestTallyDelgatorInherit(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionYes)
 	require.Nil(t, err)

-	passes, tallyResults, nonVoting := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.True(t, passes)
-	require.Equal(t, 0, len(nonVoting))
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
 }

@ -372,7 +369,7 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[3], OptionNo)
 	require.Nil(t, err)

-	passes, tallyResults, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@ -417,7 +414,7 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNo)
 	require.Nil(t, err)

-	passes, tallyResults, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@ -458,7 +455,7 @@ func TestTallyJailedValidator(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNo)
 	require.Nil(t, err)

-	passes, tallyResults, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))

 	require.True(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
--- a/x/ibc/client/cli/relay.go
+++ b/x/ibc/client/cli/relay.go
@ -91,11 +91,14 @@ func (c relayCommander) runIBCRelay(cmd *cobra.Command, args []string) {
 }

 // This is nolinted as someone is in the process of refactoring this to remove the goto
-// nolint: gocyclo
 func (c relayCommander) loop(fromChainID, fromChainNode, toChainID, toChainNode string) {
 	cliCtx := context.NewCLIContext()

-	passphrase, err := keys.ReadPassphraseFromStdin(cliCtx.FromAddressName)
+	name, err := cliCtx.GetFromName()
+	if err != nil {
+		panic(err)
+	}
+	passphrase, err := keys.ReadPassphraseFromStdin(name)
 	if err != nil {
 		panic(err)
 	}
@ -202,7 +205,12 @@ func (c relayCommander) refine(bz []byte, sequence int64, passphrase string) []b
 	txBldr := authtxb.NewTxBuilderFromCLI().WithSequence(sequence).WithCodec(c.cdc)
 	cliCtx := context.NewCLIContext()

-	res, err := txBldr.BuildAndSign(cliCtx.FromAddressName, passphrase, []sdk.Msg{msg})
+	name, err := cliCtx.GetFromName()
+	if err != nil {
+		panic(err)
+	}
+
+	res, err := txBldr.BuildAndSign(name, passphrase, []sdk.Msg{msg})
 	if err != nil {
 		panic(err)
 	}
--- a/x/ibc/client/rest/transfer.go
+++ b/x/ibc/client/rest/transfer.go
@ -35,7 +35,6 @@ type transferBody struct {

 // TransferRequestHandler - http request handler to transfer coins to a address
 // on a different chain via IBC
-// nolint: gocyclo
 func TransferRequestHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		vars := mux.Vars(r)
--- a/x/mock/simulation/random_simulate_blocks.go
+++ b/x/mock/simulation/random_simulate_blocks.go
@ -15,17 +15,15 @@ import (
 	"time"

 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto"
 	tmtypes "github.com/tendermint/tendermint/types"

 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/mock"
 )

 // Simulate tests application by sending random messages.
 func Simulate(t *testing.T, app *baseapp.BaseApp,
-	appStateFn func(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json.RawMessage,
+	appStateFn func(r *rand.Rand, accs []Account) json.RawMessage,
 	ops []WeightedOperation, setups []RandSetup,
 	invariants []Invariant, numBlocks int, blockSize int, commit bool) error {

@ -33,16 +31,16 @@ func Simulate(t *testing.T, app *baseapp.BaseApp,
 	return SimulateFromSeed(t, app, appStateFn, time, ops, setups, invariants, numBlocks, blockSize, commit)
 }

-func initChain(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress, setups []RandSetup, app *baseapp.BaseApp,
-	appStateFn func(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json.RawMessage) (validators map[string]mockValidator) {
-	res := app.InitChain(abci.RequestInitChain{AppStateBytes: appStateFn(r, keys, accs)})
+func initChain(r *rand.Rand, accounts []Account, setups []RandSetup, app *baseapp.BaseApp,
+	appStateFn func(r *rand.Rand, accounts []Account) json.RawMessage) (validators map[string]mockValidator) {
+	res := app.InitChain(abci.RequestInitChain{AppStateBytes: appStateFn(r, accounts)})
 	validators = make(map[string]mockValidator)
 	for _, validator := range res.Validators {
 		validators[string(validator.Address)] = mockValidator{validator, GetMemberOfInitialState(r, initialLivenessWeightings)}
 	}

 	for i := 0; i < len(setups); i++ {
-		setups[i](r, keys)
+		setups[i](r, accounts)
 	}

 	return
@ -56,7 +54,7 @@ func randTimestamp(r *rand.Rand) time.Time {
 // SimulateFromSeed tests an application by running the provided
 // operations, testing the provided invariants, but using the provided seed.
 func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
-	appStateFn func(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json.RawMessage,
+	appStateFn func(r *rand.Rand, accs []Account) json.RawMessage,
 	seed int64, ops []WeightedOperation, setups []RandSetup, invariants []Invariant,
 	numBlocks int, blockSize int, commit bool) (simError error) {

@ -69,7 +67,7 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 	fmt.Printf("Starting the simulation from time %v, unixtime %v\n", timestamp.UTC().Format(time.UnixDate), timestamp.Unix())
 	timeDiff := maxTimePerBlock - minTimePerBlock

-	keys, accs := mock.GeneratePrivKeyAddressPairsFromRand(r, numKeys)
+	accs := RandomAccounts(r, numKeys)

 	// Setup event stats
 	events := make(map[string]uint)
@ -77,7 +75,7 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 		events[what]++
 	}

-	validators := initChain(r, keys, accs, setups, app, appStateFn)
+	validators := initChain(r, accs, setups, app, appStateFn)

 	header := abci.Header{Height: 0, Time: timestamp}
 	opCount := 0
@ -139,10 +137,10 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 		thisBlockSize := getBlockSize(r, blockSize)

 		// Run queued operations. Ignores blocksize if blocksize is too small
-		numQueuedOpsRan := runQueuedOperations(operationQueue, int(header.Height), tb, r, app, ctx, keys, logWriter, displayLogs, event)
-		numQueuedTimeOpsRan := runQueuedTimeOperations(timeOperationQueue, header.Time, tb, r, app, ctx, keys, logWriter, displayLogs, event)
+		numQueuedOpsRan := runQueuedOperations(operationQueue, int(header.Height), tb, r, app, ctx, accs, logWriter, displayLogs, event)
+		numQueuedTimeOpsRan := runQueuedTimeOperations(timeOperationQueue, header.Time, tb, r, app, ctx, accs, logWriter, displayLogs, event)
 		thisBlockSize = thisBlockSize - numQueuedOpsRan - numQueuedTimeOpsRan
-		operations := blockSimulator(thisBlockSize, r, app, ctx, keys, header, logWriter)
+		operations := blockSimulator(thisBlockSize, r, app, ctx, accs, header, logWriter)
 		opCount += operations + numQueuedOpsRan + numQueuedTimeOpsRan

 		res := app.EndBlock(abci.RequestEndBlock{})
@ -176,7 +174,7 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 // Returns a function to simulate blocks. Written like this to avoid constant parameters being passed everytime, to minimize
 // memory overhead
 func createBlockSimulator(testingMode bool, tb testing.TB, t *testing.T, event func(string), invariants []Invariant, ops []WeightedOperation, operationQueue map[int][]Operation, timeOperationQueue []FutureOperation, totalNumBlocks int, displayLogs func()) func(
-	blocksize int, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, privKeys []crypto.PrivKey, header abci.Header, logWriter func(string)) (opCount int) {
+	blocksize int, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accounts []Account, header abci.Header, logWriter func(string)) (opCount int) {
 	totalOpWeight := 0
 	for i := 0; i < len(ops); i++ {
 		totalOpWeight += ops[i].Weight
@ -193,9 +191,9 @@ func createBlockSimulator(testingMode bool, tb testing.TB, t *testing.T, event f
 		return ops[0].Op
 	}
 	return func(blocksize int, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		keys []crypto.PrivKey, header abci.Header, logWriter func(string)) (opCount int) {
+		accounts []Account, header abci.Header, logWriter func(string)) (opCount int) {
 		for j := 0; j < blocksize; j++ {
-			logUpdate, futureOps, err := selectOp(r)(r, app, ctx, keys, event)
+			logUpdate, futureOps, err := selectOp(r)(r, app, ctx, accounts, event)
 			if err != nil {
 				displayLogs()
 				tb.Fatalf("error on operation %d within block %d, %v", header.Height, opCount, err)
@ -264,14 +262,14 @@ func queueOperations(queuedOperations map[int][]Operation, queuedTimeOperations

 // nolint: errcheck
 func runQueuedOperations(queueOperations map[int][]Operation, height int, tb testing.TB, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-	privKeys []crypto.PrivKey, logWriter func(string), displayLogs func(), event func(string)) (numOpsRan int) {
+	accounts []Account, logWriter func(string), displayLogs func(), event func(string)) (numOpsRan int) {
 	if queuedOps, ok := queueOperations[height]; ok {
 		numOps := len(queuedOps)
 		for i := 0; i < numOps; i++ {
 			// For now, queued operations cannot queue more operations.
 			// If a need arises for us to support queued messages to queue more messages, this can
 			// be changed.
-			logUpdate, _, err := queuedOps[i](r, app, ctx, privKeys, event)
+			logUpdate, _, err := queuedOps[i](r, app, ctx, accounts, event)
 			logWriter(logUpdate)
 			if err != nil {
 				displayLogs()
@ -285,14 +283,14 @@ func runQueuedOperations(queueOperations map[int][]Operation, height int, tb tes
 }

 func runQueuedTimeOperations(queueOperations []FutureOperation, currentTime time.Time, tb testing.TB, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-	privKeys []crypto.PrivKey, logWriter func(string), displayLogs func(), event func(string)) (numOpsRan int) {
+	accounts []Account, logWriter func(string), displayLogs func(), event func(string)) (numOpsRan int) {

 	numOpsRan = 0
 	for len(queueOperations) > 0 && currentTime.After(queueOperations[0].BlockTime) {
 		// For now, queued operations cannot queue more operations.
 		// If a need arises for us to support queued messages to queue more messages, this can
 		// be changed.
-		logUpdate, _, err := queueOperations[0].Op(r, app, ctx, privKeys, event)
+		logUpdate, _, err := queueOperations[0].Op(r, app, ctx, accounts, event)
 		logWriter(logUpdate)
 		if err != nil {
 			displayLogs()
--- a/x/mock/simulation/types.go
+++ b/x/mock/simulation/types.go
@ -23,11 +23,11 @@ type (
 	// Operations can optionally provide a list of "FutureOperations" to run later
 	// These will be ran at the beginning of the corresponding block.
 	Operation func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		privKeys []crypto.PrivKey, event func(string),
+		accounts []Account, event func(string),
 	) (action string, futureOperations []FutureOperation, err error)

 	// RandSetup performs the random setup the mock module needs.
-	RandSetup func(r *rand.Rand, privKeys []crypto.PrivKey)
+	RandSetup func(r *rand.Rand, accounts []Account)

 	// An Invariant is a function which tests a particular invariant.
 	// If the invariant has been broken, it should return an error
@ -35,6 +35,15 @@ type (
 	// The simulator will then halt and print the logs.
 	Invariant func(app *baseapp.BaseApp) error

+	// Account contains a privkey, pubkey, address tuple
+	// eventually more useful data can be placed in here.
+	// (e.g. number of coins)
+	Account struct {
+		PrivKey crypto.PrivKey
+		PubKey  crypto.PubKey
+		Address sdk.AccAddress
+	}
+
 	mockValidator struct {
 		val           abci.Validator
 		livenessState int
@ -70,3 +79,8 @@ func PeriodicInvariant(invariant Invariant, period int, offset int) Invariant {
 		return nil
 	}
 }
+
+// nolint
+func (acc Account) Equals(acc2 Account) bool {
+	return acc.Address.Equals(acc2.Address)
+}
--- a/x/mock/simulation/util.go
+++ b/x/mock/simulation/util.go
@ -9,10 +9,12 @@ import (
 	"testing"
 	"time"

-	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/ed25519"
+	"github.com/tendermint/tendermint/crypto/secp256k1"

 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/mock"
 )

 // shamelessly copied from https://stackoverflow.com/questions/22892120/how-to-generate-a-random-string-of-a-fixed-length-in-golang#31832326
@ -56,10 +58,10 @@ func DisplayEvents(events map[string]uint) {
 	}
 }

-// Pick a random key from an array
-func RandomKey(r *rand.Rand, keys []crypto.PrivKey) crypto.PrivKey {
-	return keys[r.Intn(
-		len(keys),
+// RandomAcc pick a random account from an array
+func RandomAcc(r *rand.Rand, accs []Account) Account {
+	return accs[r.Intn(
+		len(accs),
 	)]
 }

@ -68,6 +70,25 @@ func RandomAmount(r *rand.Rand, max sdk.Int) sdk.Int {
 	return sdk.NewInt(int64(r.Intn(int(max.Int64()))))
 }

+// RandomAccounts generates n random accounts
+func RandomAccounts(r *rand.Rand, n int) []Account {
+	accs := make([]Account, n)
+	for i := 0; i < n; i++ {
+		// don't need that much entropy for simulation
+		privkeySeed := make([]byte, 15)
+		r.Read(privkeySeed)
+		useSecp := r.Int63()%2 == 0
+		if useSecp {
+			accs[i].PrivKey = secp256k1.GenPrivKeySecp256k1(privkeySeed)
+		} else {
+			accs[i].PrivKey = ed25519.GenPrivKeyFromSecret(privkeySeed)
+		}
+		accs[i].PubKey = accs[i].PrivKey.PubKey()
+		accs[i].Address = sdk.AccAddress(accs[i].PubKey.Address())
+	}
+	return accs
+}
+
 // Builds a function to add logs for this particular block
 func addLogMessage(testingmode bool, blockLogBuilders []*strings.Builder, height int) func(string) {
 	if testingmode {
@ -92,6 +113,15 @@ func assertAllInvariants(t *testing.T, app *baseapp.BaseApp, invariants []Invari
 	}
 }

+// RandomSetGenesis wraps mock.RandomSetGenesis, but using simulation accounts
+func RandomSetGenesis(r *rand.Rand, app *mock.App, accs []Account, denoms []string) {
+	addrs := make([]sdk.AccAddress, len(accs))
+	for i := 0; i < len(accs); i++ {
+		addrs[i] = accs[i].Address
+	}
+	mock.RandomSetGenesis(r, app, addrs, denoms)
+}
+
 // Creates a function to print out the logs
 func logPrinter(testingmode bool, logs []*strings.Builder) func() {
 	if testingmode {
--- a/x/slashing/client/rest/tx.go
+++ b/x/slashing/client/rest/tx.go
@ -38,7 +38,6 @@ type UnjailBody struct {
 	ValidatorAddr    string `json:"validator_addr"`
 }

-// nolint: gocyclo
 func unjailRequestHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		var m UnjailBody
--- a/x/slashing/keeper.go
+++ b/x/slashing/keeper.go
@ -79,7 +79,6 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, addr crypto.Address, infractio

 // handle a validator signature, must be called once per validator per block
 // TODO refactor to take in a consensus address, additionally should maybe just take in the pubkey too
-// nolint gocyclo
 func (k Keeper) handleValidatorSignature(ctx sdk.Context, addr crypto.Address, power int64, signed bool) {
 	logger := ctx.Logger().With("module", "x/slashing")
 	height := ctx.BlockHeight()
--- a/x/slashing/simulation/msgs.go
+++ b/x/slashing/simulation/msgs.go
@ -4,8 +4,6 @@ import (
 	"fmt"
 	"math/rand"

-	"github.com/tendermint/tendermint/crypto"
-
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
@ -14,9 +12,9 @@ import (

 // SimulateMsgUnjail
 func SimulateMsgUnjail(k slashing.Keeper) simulation.Operation {
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
-		key := simulation.RandomKey(r, keys)
-		address := sdk.ValAddress(key.PubKey().Address())
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+		acc := simulation.RandomAcc(r, accs)
+		address := sdk.ValAddress(acc.Address)
 		msg := slashing.NewMsgUnjail(address)
 		if msg.ValidateBasic() != nil {
 			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
--- a/x/stake/client/rest/query.go
+++ b/x/stake/client/rest/query.go
@ -120,7 +120,6 @@ func delegatorHandlerFn(cliCtx context.CLIContext, cdc *codec.Codec) http.Handle
 	}
 }

-// nolint gocyclo
 // HTTP request handler to query all staking txs (msgs) from a delegator
 func delegatorTxsHandlerFn(cliCtx context.CLIContext, cdc *codec.Codec) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
--- a/x/stake/client/rest/tx.go
+++ b/x/stake/client/rest/tx.go
@ -69,7 +69,6 @@ type EditDelegationsBody struct {
 	CompleteRedelegates []msgCompleteRedelegateInput `json:"complete_redelegates"`
 }

-// nolint: gocyclo
 // TODO: Split this up into several smaller functions, and remove the above nolint
 // TODO: use sdk.ValAddress instead of sdk.AccAddress for validators in messages
 func delegationsRequestHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx context.CLIContext) http.HandlerFunc {
--- a/x/stake/keeper/slash.go
+++ b/x/stake/keeper/slash.go
@ -21,8 +21,6 @@ import (
 // CONTRACT:
 //    Infraction committed at the current height or at a past height,
 //    not at a height in the future
-//
-// nolint: gocyclo
 func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeight int64, power int64, slashFactor sdk.Dec) {
 	logger := ctx.Logger().With("module", "x/stake")

--- a/x/stake/keeper/validator.go
+++ b/x/stake/keeper/validator.go
@ -232,7 +232,6 @@ func (k Keeper) GetValidTendermintUpdates(ctx sdk.Context) (updates []abci.Valid
 // It may kick out validators if a new validator is entering the bonded validator
 // group.
 //
-// nolint: gocyclo
 // TODO: Remove above nolint, function needs to be simplified!
 func (k Keeper) UpdateValidator(ctx sdk.Context, validator types.Validator) types.Validator {
 	tstore := ctx.TransientStore(k.storeTKey)
@ -422,9 +421,6 @@ func (k Keeper) updateValidatorPower(ctx sdk.Context, oldFound bool, oldValidato
 // updated in store with the ValidatorsBondedIndexKey. This store is used to
 // determine if a validator is a validator without needing to iterate over all
 // validators.
-//
-// nolint: gocyclo
-// TODO: Remove the above golint
 func (k Keeper) UpdateBondedValidators(
 	ctx sdk.Context, affectedValidator types.Validator) (
 	updatedVal types.Validator, updated bool) {
--- a/x/stake/simulation/msgs.go
+++ b/x/stake/simulation/msgs.go
@ -11,13 +11,12 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
 	"github.com/cosmos/cosmos-sdk/x/stake"
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto"
 )

 // SimulateMsgCreateValidator
 func SimulateMsgCreateValidator(m auth.AccountMapper, k stake.Keeper) simulation.Operation {
 	handler := stake.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {

 		denom := k.GetParams(ctx).BondDenom
 		description := stake.Description{
@ -31,11 +30,9 @@ func SimulateMsgCreateValidator(m auth.AccountMapper, k stake.Keeper) simulation
 			sdk.NewDecWithPrec(simulation.RandomAmount(r, maxCommission).Int64(), 1),
 		)

-		key := simulation.RandomKey(r, keys)
-		pubkey := key.PubKey()
-		address := sdk.ValAddress(pubkey.Address())
-		amount := m.GetAccount(ctx, sdk.AccAddress(address)).GetCoins().AmountOf(denom)
-
+		acc := simulation.RandomAcc(r, accs)
+		address := sdk.ValAddress(acc.Address)
+		amount := m.GetAccount(ctx, acc.Address).GetCoins().AmountOf(denom)
 		if amount.GT(sdk.ZeroInt()) {
 			amount = simulation.RandomAmount(r, amount)
 		}
@ -48,8 +45,8 @@ func SimulateMsgCreateValidator(m auth.AccountMapper, k stake.Keeper) simulation
 			Description:   description,
 			Commission:    commission,
 			ValidatorAddr: address,
-			DelegatorAddr: sdk.AccAddress(address),
-			PubKey:        pubkey,
+			DelegatorAddr: acc.Address,
+			PubKey:        acc.PubKey,
 			Delegation:    sdk.NewCoin(denom, amount),
 		}

@ -74,7 +71,7 @@ func SimulateMsgCreateValidator(m auth.AccountMapper, k stake.Keeper) simulation
 // SimulateMsgEditValidator
 func SimulateMsgEditValidator(k stake.Keeper) simulation.Operation {
 	handler := stake.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {

 		description := stake.Description{
 			Moniker:  simulation.RandStringOfLength(r, 10),
@ -86,10 +83,8 @@ func SimulateMsgEditValidator(k stake.Keeper) simulation.Operation {
 		maxCommission := sdk.NewInt(10)
 		newCommissionRate := sdk.NewDecWithPrec(simulation.RandomAmount(r, maxCommission).Int64(), 1)

-		key := simulation.RandomKey(r, keys)
-		pubkey := key.PubKey()
-		address := sdk.ValAddress(pubkey.Address())
-
+		acc := simulation.RandomAcc(r, accs)
+		address := sdk.ValAddress(acc.Address)
 		msg := stake.MsgEditValidator{
 			Description:    description,
 			ValidatorAddr:  address,
@ -114,13 +109,13 @@ func SimulateMsgEditValidator(k stake.Keeper) simulation.Operation {
 // SimulateMsgDelegate
 func SimulateMsgDelegate(m auth.AccountMapper, k stake.Keeper) simulation.Operation {
 	handler := stake.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {

 		denom := k.GetParams(ctx).BondDenom
-		validatorKey := simulation.RandomKey(r, keys)
-		validatorAddress := sdk.ValAddress(validatorKey.PubKey().Address())
-		delegatorKey := simulation.RandomKey(r, keys)
-		delegatorAddress := sdk.AccAddress(delegatorKey.PubKey().Address())
+		validatorAcc := simulation.RandomAcc(r, accs)
+		validatorAddress := sdk.ValAddress(validatorAcc.Address)
+		delegatorAcc := simulation.RandomAcc(r, accs)
+		delegatorAddress := delegatorAcc.Address
 		amount := m.GetAccount(ctx, delegatorAddress).GetCoins().AmountOf(denom)
 		if amount.GT(sdk.ZeroInt()) {
 			amount = simulation.RandomAmount(r, amount)
@ -150,13 +145,13 @@ func SimulateMsgDelegate(m auth.AccountMapper, k stake.Keeper) simulation.Operat
 // SimulateMsgBeginUnbonding
 func SimulateMsgBeginUnbonding(m auth.AccountMapper, k stake.Keeper) simulation.Operation {
 	handler := stake.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {

 		denom := k.GetParams(ctx).BondDenom
-		validatorKey := simulation.RandomKey(r, keys)
-		validatorAddress := sdk.ValAddress(validatorKey.PubKey().Address())
-		delegatorKey := simulation.RandomKey(r, keys)
-		delegatorAddress := sdk.AccAddress(delegatorKey.PubKey().Address())
+		validatorAcc := simulation.RandomAcc(r, accs)
+		validatorAddress := sdk.ValAddress(validatorAcc.Address)
+		delegatorAcc := simulation.RandomAcc(r, accs)
+		delegatorAddress := delegatorAcc.Address
 		amount := m.GetAccount(ctx, delegatorAddress).GetCoins().AmountOf(denom)
 		if amount.GT(sdk.ZeroInt()) {
 			amount = simulation.RandomAmount(r, amount)
@ -186,12 +181,12 @@ func SimulateMsgBeginUnbonding(m auth.AccountMapper, k stake.Keeper) simulation.
 // SimulateMsgCompleteUnbonding
 func SimulateMsgCompleteUnbonding(k stake.Keeper) simulation.Operation {
 	handler := stake.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {

-		validatorKey := simulation.RandomKey(r, keys)
-		validatorAddress := sdk.ValAddress(validatorKey.PubKey().Address())
-		delegatorKey := simulation.RandomKey(r, keys)
-		delegatorAddress := sdk.AccAddress(delegatorKey.PubKey().Address())
+		validatorAcc := simulation.RandomAcc(r, accs)
+		validatorAddress := sdk.ValAddress(validatorAcc.Address)
+		delegatorAcc := simulation.RandomAcc(r, accs)
+		delegatorAddress := delegatorAcc.Address
 		msg := stake.MsgCompleteUnbonding{
 			DelegatorAddr: delegatorAddress,
 			ValidatorAddr: validatorAddress,
@ -213,15 +208,15 @@ func SimulateMsgCompleteUnbonding(k stake.Keeper) simulation.Operation {
 // SimulateMsgBeginRedelegate
 func SimulateMsgBeginRedelegate(m auth.AccountMapper, k stake.Keeper) simulation.Operation {
 	handler := stake.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {

 		denom := k.GetParams(ctx).BondDenom
-		sourceValidatorKey := simulation.RandomKey(r, keys)
-		sourceValidatorAddress := sdk.ValAddress(sourceValidatorKey.PubKey().Address())
-		destValidatorKey := simulation.RandomKey(r, keys)
-		destValidatorAddress := sdk.ValAddress(destValidatorKey.PubKey().Address())
-		delegatorKey := simulation.RandomKey(r, keys)
-		delegatorAddress := sdk.AccAddress(delegatorKey.PubKey().Address())
+		sourceValidatorAcc := simulation.RandomAcc(r, accs)
+		sourceValidatorAddress := sdk.ValAddress(sourceValidatorAcc.Address)
+		destValidatorAcc := simulation.RandomAcc(r, accs)
+		destValidatorAddress := sdk.ValAddress(destValidatorAcc.Address)
+		delegatorAcc := simulation.RandomAcc(r, accs)
+		delegatorAddress := delegatorAcc.Address
 		// TODO
 		amount := m.GetAccount(ctx, delegatorAddress).GetCoins().AmountOf(denom)
 		if amount.GT(sdk.ZeroInt()) {
@ -253,14 +248,14 @@ func SimulateMsgBeginRedelegate(m auth.AccountMapper, k stake.Keeper) simulation
 // SimulateMsgCompleteRedelegate
 func SimulateMsgCompleteRedelegate(k stake.Keeper) simulation.Operation {
 	handler := stake.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {

-		validatorSrcKey := simulation.RandomKey(r, keys)
-		validatorSrcAddress := sdk.ValAddress(validatorSrcKey.PubKey().Address())
-		validatorDstKey := simulation.RandomKey(r, keys)
-		validatorDstAddress := sdk.ValAddress(validatorDstKey.PubKey().Address())
-		delegatorKey := simulation.RandomKey(r, keys)
-		delegatorAddress := sdk.AccAddress(delegatorKey.PubKey().Address())
+		validatorSrcAcc := simulation.RandomAcc(r, accs)
+		validatorSrcAddress := sdk.ValAddress(validatorSrcAcc.Address)
+		validatorDstAcc := simulation.RandomAcc(r, accs)
+		validatorDstAddress := sdk.ValAddress(validatorDstAcc.Address)
+		delegatorAcc := simulation.RandomAcc(r, accs)
+		delegatorAddress := delegatorAcc.Address
 		msg := stake.MsgCompleteRedelegate{
 			DelegatorAddr:    delegatorAddress,
 			ValidatorSrcAddr: validatorSrcAddress,
@ -283,7 +278,7 @@ func SimulateMsgCompleteRedelegate(k stake.Keeper) simulation.Operation {
 // Setup
 // nolint: errcheck
 func Setup(mapp *mock.App, k stake.Keeper) simulation.RandSetup {
-	return func(r *rand.Rand, privKeys []crypto.PrivKey) {
+	return func(r *rand.Rand, accs []simulation.Account) {
 		ctx := mapp.NewContext(false, abci.Header{})
 		gen := stake.DefaultGenesisState()
 		gen.Params.InflationMax = sdk.NewDec(0)
--- a/x/stake/simulation/sim_test.go
+++ b/x/stake/simulation/sim_test.go
@ -6,7 +6,6 @@ import (
 	"testing"

 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto"

 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/bank"
@ -38,8 +37,8 @@ func TestStakeWithRandomMessages(t *testing.T) {
 		panic(err)
 	}

-	appStateFn := func(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json.RawMessage {
-		mock.RandomSetGenesis(r, mapp, accs, []string{"stake"})
+	appStateFn := func(r *rand.Rand, accs []simulation.Account) json.RawMessage {
+		simulation.RandomSetGenesis(r, mapp, accs, []string{"stake"})
 		return json.RawMessage("{}")
 	}

--- a/x/stake/types/inflation_test.go
+++ b/x/stake/types/inflation_test.go
@ -107,7 +107,6 @@ func updateProvisions(t *testing.T, pool Pool, params Params, hr int) (sdk.Dec,
 }

 // Checks that The inflation will correctly increase or decrease after an update to the pool
-// nolint: gocyclo
 func checkInflation(t *testing.T, pool Pool, previousInflation, updatedInflation sdk.Dec, msg string) {
 	inflationChange := updatedInflation.Sub(previousInflation)