From f7437fd899edc54a4ec5e6d1a1467e69c21c493e Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Fri, 6 Apr 2018 14:35:54 -0400
Subject: [PATCH 01/26] connected stake cli

---
 examples/basecoin/app/app.go          |  7 ++++---
 examples/basecoin/app/app_test.go     |  5 +++--
 examples/basecoin/cmd/basecli/main.go | 21 +++++++++------------
 x/stake/commands/query.go             |  8 ++++----
 x/stake/commands/tx.go                |  4 ++--
 x/stake/handler.go                    |  3 +--
 x/stake/wire.go                       |  2 +-
 7 files changed, 24 insertions(+), 26 deletions(-)

diff --git a/examples/basecoin/app/app.go b/examples/basecoin/app/app.go
index bb3ef05ac..9ef48bfb5 100644
--- a/examples/basecoin/app/app.go
+++ b/examples/basecoin/app/app.go
@@ -15,6 +15,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/ibc"
 	"github.com/cosmos/cosmos-sdk/x/simplestake"
+	"github.com/cosmos/cosmos-sdk/x/stake"
 
 	"github.com/cosmos/cosmos-sdk/examples/basecoin/types"
 )
@@ -32,7 +33,7 @@ type BasecoinApp struct {
 	capKeyMainStore    *sdk.KVStoreKey
 	capKeyAccountStore *sdk.KVStoreKey
 	capKeyIBCStore     *sdk.KVStoreKey
-	capKeyStakingStore *sdk.KVStoreKey
+	capKeyStakeStore   *sdk.KVStoreKey
 
 	// Manage getting and setting accounts
 	accountMapper sdk.AccountMapper
@@ -53,7 +54,7 @@ func NewBasecoinApp(logger log.Logger, db dbm.DB) *BasecoinApp {
 		capKeyMainStore:    sdk.NewKVStoreKey("main"),
 		capKeyAccountStore: sdk.NewKVStoreKey("acc"),
 		capKeyIBCStore:     sdk.NewKVStoreKey("ibc"),
-		capKeyStakingStore: sdk.NewKVStoreKey("stake"),
+		capKeyStakeStore:   sdk.NewKVStoreKey("stake"),
 	}
 
 	// Define the accountMapper.
@@ -70,7 +71,7 @@ func NewBasecoinApp(logger log.Logger, db dbm.DB) *BasecoinApp {
 	app.Router().
 		AddRoute("bank", bank.NewHandler(coinKeeper)).
 		AddRoute("ibc", ibc.NewHandler(ibcMapper, coinKeeper)).
-		AddRoute("simplestake", simplestake.NewHandler(stakeKeeper))
+		AddRoute("stake", stake.NewHandler(stakeKeeper))
 
 	// Define the feeHandler.
 	app.feeHandler = auth.BurnFeeHandler
diff --git a/examples/basecoin/app/app_test.go b/examples/basecoin/app/app_test.go
index bc1735dde..1f635f53f 100644
--- a/examples/basecoin/app/app_test.go
+++ b/examples/basecoin/app/app_test.go
@@ -143,7 +143,7 @@ func TestSortGenesis(t *testing.T) {
 	// Note the order: the coins are unsorted!
 	coinDenom1, coinDenom2 := "foocoin", "barcoin"
 
-	genState := fmt.Sprintf(`{
+	str := `{
       "accounts": [{
         "address": "%s",
         "coins": [
@@ -157,7 +157,8 @@ func TestSortGenesis(t *testing.T) {
           }
         ]
       }]
-    }`, addr1.String(), coinDenom1, coinDenom2)
+    }`
+	genState := fmt.Sprintf(str, addr1.String(), coinDenom1, coinDenom2)
 
 	// Initialize the chain
 	vals := []abci.Validator{}
diff --git a/examples/basecoin/cmd/basecli/main.go b/examples/basecoin/cmd/basecli/main.go
index 6271adcec..bab24f91b 100644
--- a/examples/basecoin/cmd/basecli/main.go
+++ b/examples/basecoin/cmd/basecli/main.go
@@ -17,7 +17,7 @@ import (
 	authcmd "github.com/cosmos/cosmos-sdk/x/auth/commands"
 	bankcmd "github.com/cosmos/cosmos-sdk/x/bank/commands"
 	ibccmd "github.com/cosmos/cosmos-sdk/x/ibc/commands"
-	simplestakingcmd "github.com/cosmos/cosmos-sdk/x/simplestake/commands"
+	stakecmd "github.com/cosmos/cosmos-sdk/x/stake/commands"
 
 	"github.com/cosmos/cosmos-sdk/examples/basecoin/app"
 	"github.com/cosmos/cosmos-sdk/examples/basecoin/types"
@@ -52,23 +52,20 @@ func main() {
 	rootCmd.AddCommand(
 		client.GetCommands(
 			authcmd.GetAccountCmd("main", cdc, types.GetAccountDecoder(cdc)),
+			stakecmd.GetCmdQueryCandidates("stake", cdc),
+			stakecmd.GetCmdQueryCandidate("stake", cdc),
+			stakecmd.GetCmdQueryDelegatorBond("stake", cdc),
+			stakecmd.GetCmdQueryDelegatorBonds("stake", cdc),
 		)...)
 	rootCmd.AddCommand(
 		client.PostCommands(
 			bankcmd.SendTxCmd(cdc),
-		)...)
-	rootCmd.AddCommand(
-		client.PostCommands(
 			ibccmd.IBCTransferCmd(cdc),
-		)...)
-	rootCmd.AddCommand(
-		client.PostCommands(
 			ibccmd.IBCRelayCmd(cdc),
-			simplestakingcmd.BondTxCmd(cdc),
-		)...)
-	rootCmd.AddCommand(
-		client.PostCommands(
-			simplestakingcmd.UnbondTxCmd(cdc),
+			stakecmd.GetCmdDeclareCandidacy(cdc),
+			stakecmd.GetCmdEditCandidacy(cdc),
+			stakecmd.GetCmdDelegate(cdc),
+			stakecmd.GetCmdUnbond(cdc),
 		)...)
 
 	// add proxy, version and key info
diff --git a/x/stake/commands/query.go b/x/stake/commands/query.go
index 8cbb877ce..38e16f333 100644
--- a/x/stake/commands/query.go
+++ b/x/stake/commands/query.go
@@ -38,7 +38,7 @@ func init() {
 }
 
 // create command to query for all candidates
-func GetCmdQueryCandidates(cdc *wire.Codec, storeName string) *cobra.Command {
+func GetCmdQueryCandidates(storeName string, cdc *wire.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "candidates",
 		Short: "Query for the set of validator-candidates pubkeys",
@@ -74,7 +74,7 @@ func GetCmdQueryCandidates(cdc *wire.Codec, storeName string) *cobra.Command {
 }
 
 // get the command to query a candidate
-func GetCmdQueryCandidate(cdc *wire.Codec, storeName string) *cobra.Command {
+func GetCmdQueryCandidate(storeName string, cdc *wire.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "candidate",
 		Short: "Query a validator-candidate account",
@@ -116,7 +116,7 @@ func GetCmdQueryCandidate(cdc *wire.Codec, storeName string) *cobra.Command {
 }
 
 // get the command to query a single delegator bond
-func GetCmdQueryDelegatorBond(cdc *wire.Codec, storeName string) *cobra.Command {
+func GetCmdQueryDelegatorBond(storeName string, cdc *wire.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "delegator-bond",
 		Short: "Query a delegators bond based on address and candidate pubkey",
@@ -165,7 +165,7 @@ func GetCmdQueryDelegatorBond(cdc *wire.Codec, storeName string) *cobra.Command
 }
 
 // get the command to query all the candidates bonded to a delegator
-func GetCmdQueryDelegatorBonds(cdc *wire.Codec, storeName string) *cobra.Command {
+func GetCmdQueryDelegatorBonds(storeName string, cdc *wire.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "delegator-candidates",
 		Short: "Query all delegators candidates' pubkeys based on address",
diff --git a/x/stake/commands/tx.go b/x/stake/commands/tx.go
index 5cc9747b6..679e59b15 100644
--- a/x/stake/commands/tx.go
+++ b/x/stake/commands/tx.go
@@ -20,8 +20,8 @@ import (
 
 // nolint
 const (
-	FlagAddressDelegator = "addressD"
-	FlagAddressCandidate = "addressC"
+	FlagAddressDelegator = "address-delegator"
+	FlagAddressCandidate = "address-candidate"
 	FlagPubKey           = "pubkey"
 	FlagAmount           = "amount"
 	FlagShares           = "shares"
diff --git a/x/stake/handler.go b/x/stake/handler.go
index 5f80ecb37..e1f624f10 100644
--- a/x/stake/handler.go
+++ b/x/stake/handler.go
@@ -4,7 +4,6 @@ import (
 	"bytes"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/bank"
 	abci "github.com/tendermint/abci/types"
 )
 
@@ -18,7 +17,7 @@ const (
 
 //_______________________________________________________________________
 
-func NewHandler(k Keeper, ck bank.CoinKeeper) sdk.Handler {
+func NewHandler(k Keeper) sdk.Handler {
 	return func(ctx sdk.Context, msg sdk.Msg) sdk.Result {
 		// NOTE msg already has validate basic run
 		switch msg := msg.(type) {
diff --git a/x/stake/wire.go b/x/stake/wire.go
index 4516f89f2..f444ce14e 100644
--- a/x/stake/wire.go
+++ b/x/stake/wire.go
@@ -4,7 +4,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/wire"
 )
 
-// XXX complete
+// TODO complete when go-amino is ported
 func RegisterWire(cdc *wire.Codec) {
 	// TODO include option to always include prefix bytes.
 	//cdc.RegisterConcrete(SendMsg{}, "cosmos-sdk/SendMsg", nil)

From 179caa5768b1e35c25015f5b529c3729a104578a Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Sat, 7 Apr 2018 01:12:00 -0400
Subject: [PATCH 02/26] refactor gaia with stake

---
 Makefile                              |   4 +-
 cmd/gaia/app/account.go               |  32 ++
 cmd/gaia/app/app.go                   | 158 ++++++++++
 cmd/gaia/app/app_test.go              | 432 ++++++++++++++++++++++++++
 cmd/gaia/cmd/gaiacli/main.go          |  79 +++++
 cmd/{ => gaia/cmd}/gaiad/main.go      |  25 +-
 examples/basecoin/app/app.go          |   7 +-
 examples/basecoin/app/app_test.go     |   8 +-
 examples/basecoin/cmd/basecli/main.go |  21 +-
 x/stake/handler.go                    |  37 ---
 10 files changed, 744 insertions(+), 59 deletions(-)
 create mode 100644 cmd/gaia/app/account.go
 create mode 100644 cmd/gaia/app/app.go
 create mode 100644 cmd/gaia/app/app_test.go
 create mode 100644 cmd/gaia/cmd/gaiacli/main.go
 rename cmd/{ => gaia/cmd}/gaiad/main.go (60%)

diff --git a/Makefile b/Makefile
index b5177621a..4d21c61c5 100644
--- a/Makefile
+++ b/Makefile
@@ -36,8 +36,8 @@ else
 endif
 
 install: 
-	go install $(BUILD_FLAGS) ./cmd/gaiad
-	go install $(BUILD_FLAGS) ./cmd/gaiacli
+	go install $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiad
+	go install $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiacli
 
 install_examples: 
 	go install $(BUILD_FLAGS) ./examples/basecoin/cmd/basecoind
diff --git a/cmd/gaia/app/account.go b/cmd/gaia/app/account.go
new file mode 100644
index 000000000..3d5673b87
--- /dev/null
+++ b/cmd/gaia/app/account.go
@@ -0,0 +1,32 @@
+package app
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+)
+
+// State to Unmarshal
+type GenesisState struct {
+	Accounts []GenesisAccount `json:"accounts"`
+}
+
+// GenesisAccount doesn't need pubkey or sequence
+type GenesisAccount struct {
+	Address sdk.Address `json:"address"`
+	Coins   sdk.Coins   `json:"coins"`
+}
+
+func NewGenesisAccount(acc auth.BaseAccount) GenesisAccount {
+	return GenesisAccount{
+		Address: acc.Address,
+		Coins:   acc.Coins,
+	}
+}
+
+// convert GenesisAccount to GaiaAccount
+func (ga *GenesisAccount) ToAccount() (acc auth.BaseAccount) {
+	return auth.BaseAccount{
+		Address: ga.Address,
+		Coins:   ga.Coins.Sort(),
+	}
+}
diff --git a/cmd/gaia/app/app.go b/cmd/gaia/app/app.go
new file mode 100644
index 000000000..64b1619f8
--- /dev/null
+++ b/cmd/gaia/app/app.go
@@ -0,0 +1,158 @@
+package app
+
+import (
+	"encoding/json"
+
+	abci "github.com/tendermint/abci/types"
+	oldwire "github.com/tendermint/go-wire"
+	cmn "github.com/tendermint/tmlibs/common"
+	dbm "github.com/tendermint/tmlibs/db"
+	"github.com/tendermint/tmlibs/log"
+
+	bam "github.com/cosmos/cosmos-sdk/baseapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/cosmos/cosmos-sdk/x/bank"
+	"github.com/cosmos/cosmos-sdk/x/ibc"
+	"github.com/cosmos/cosmos-sdk/x/stake"
+)
+
+const (
+	appName = "GaiaApp"
+)
+
+// Extended ABCI application
+type GaiaApp struct {
+	*bam.BaseApp
+	cdc *wire.Codec
+
+	// keys to access the substores
+	capKeyMainStore    *sdk.KVStoreKey
+	capKeyAccountStore *sdk.KVStoreKey
+	capKeyIBCStore     *sdk.KVStoreKey
+	capKeyStakeStore   *sdk.KVStoreKey
+
+	// Manage getting and setting accounts
+	accountMapper sdk.AccountMapper
+}
+
+func NewGaiaApp(logger log.Logger, dbs map[string]dbm.DB) *GaiaApp {
+	// create your application object
+	var app = &GaiaApp{
+		BaseApp:            bam.NewBaseApp(appName, logger, dbs["main"]),
+		cdc:                MakeCodec(),
+		capKeyMainStore:    sdk.NewKVStoreKey("main"),
+		capKeyAccountStore: sdk.NewKVStoreKey("acc"),
+		capKeyIBCStore:     sdk.NewKVStoreKey("ibc"),
+		capKeyStakeStore:   sdk.NewKVStoreKey("stake"),
+	}
+
+	// define the accountMapper
+	app.accountMapper = auth.NewAccountMapperSealed(
+		app.capKeyMainStore, // target store
+		&auth.BaseAccount{}, // prototype
+	)
+
+	// add handlers
+	coinKeeper := bank.NewCoinKeeper(app.accountMapper)
+	ibcMapper := ibc.NewIBCMapper(app.cdc, app.capKeyIBCStore)
+	stakeKeeper := stake.NewKeeper(app.cdc, app.capKeyStakeStore, coinKeeper)
+	app.Router().
+		AddRoute("bank", bank.NewHandler(coinKeeper)).
+		AddRoute("ibc", ibc.NewHandler(ibcMapper, coinKeeper)).
+		AddRoute("stake", stake.NewHandler(stakeKeeper))
+
+	// initialize BaseApp
+	app.SetTxDecoder(app.txDecoder)
+	app.SetInitChainer(app.initChainer)
+	app.SetEndBlocker(stake.NewEndBlocker(stakeKeeper))
+	app.MountStoreWithDB(app.capKeyMainStore, sdk.StoreTypeIAVL, dbs["main"])
+	app.MountStoreWithDB(app.capKeyAccountStore, sdk.StoreTypeIAVL, dbs["acc"])
+	app.MountStoreWithDB(app.capKeyIBCStore, sdk.StoreTypeIAVL, dbs["ibc"])
+	app.MountStoreWithDB(app.capKeyStakeStore, sdk.StoreTypeIAVL, dbs["stake"])
+
+	// NOTE: Broken until #532 lands
+	//app.MountStoresIAVL(app.capKeyMainStore, app.capKeyIBCStore, app.capKeyStakingStore)
+	app.SetAnteHandler(auth.NewAnteHandler(app.accountMapper))
+	err := app.LoadLatestVersion(app.capKeyMainStore)
+	if err != nil {
+		cmn.Exit(err.Error())
+	}
+
+	return app
+}
+
+// custom tx codec
+// TODO: use new go-wire
+func MakeCodec() *wire.Codec {
+	const (
+		msgTypeSend           = 0x1
+		msgTypeIssue          = 0x2
+		msgTypeIBCTransferMsg = 0x3
+		msgTypeIBCReceiveMsg  = 0x4
+		msgDeclareCandidacy   = 0x5
+		msgEditCandidacy      = 0x6
+		msgDelegate           = 0x7
+		msgUnbond             = 0x8
+	)
+	var _ = oldwire.RegisterInterface(
+		struct{ sdk.Msg }{},
+		oldwire.ConcreteType{bank.SendMsg{}, msgTypeSend},
+		oldwire.ConcreteType{bank.IssueMsg{}, msgTypeIssue},
+		oldwire.ConcreteType{ibc.IBCTransferMsg{}, msgTypeIBCTransferMsg},
+		oldwire.ConcreteType{ibc.IBCReceiveMsg{}, msgTypeIBCReceiveMsg},
+		oldwire.ConcreteType{stake.MsgDeclareCandidacy{}, msgDeclareCandidacy},
+		oldwire.ConcreteType{stake.MsgEditCandidacy{}, msgEditCandidacy},
+		oldwire.ConcreteType{stake.MsgDelegate{}, msgDelegate},
+		oldwire.ConcreteType{stake.MsgUnbond{}, msgUnbond},
+	)
+
+	const accTypeApp = 0x1
+	var _ = oldwire.RegisterInterface(
+		struct{ sdk.Account }{},
+		oldwire.ConcreteType{&auth.BaseAccount{}, accTypeApp},
+	)
+	cdc := wire.NewCodec()
+
+	// cdc.RegisterInterface((*sdk.Msg)(nil), nil)
+	// bank.RegisterWire(cdc)   // Register bank.[SendMsg,IssueMsg]
+	// crypto.RegisterWire(cdc) // Register crypto.[PubKey,PrivKey,Signature]
+	// ibc.RegisterWire(cdc) // Register ibc.[IBCTransferMsg, IBCReceiveMsg]
+	return cdc
+}
+
+// custom logic for transaction decoding
+func (app *GaiaApp) txDecoder(txBytes []byte) (sdk.Tx, sdk.Error) {
+	var tx = sdk.StdTx{}
+
+	if len(txBytes) == 0 {
+		return nil, sdk.ErrTxDecode("txBytes are empty")
+	}
+
+	// StdTx.Msg is an interface. The concrete types
+	// are registered by MakeTxCodec in bank.RegisterWire.
+	err := app.cdc.UnmarshalBinary(txBytes, &tx)
+	if err != nil {
+		return nil, sdk.ErrTxDecode("").TraceCause(err, "")
+	}
+	return tx, nil
+}
+
+// custom logic for gaia initialization
+func (app *GaiaApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
+	stateJSON := req.AppStateBytes
+
+	genesisState := new(GenesisState)
+	err := json.Unmarshal(stateJSON, genesisState)
+	if err != nil {
+		panic(err) // TODO https://github.com/cosmos/cosmos-sdk/issues/468
+		// return sdk.ErrGenesisParse("").TraceCause(err, "")
+	}
+
+	for _, gacc := range genesisState.Accounts {
+		acc := gacc.ToAccount()
+		app.accountMapper.SetAccount(ctx, &acc)
+	}
+	return abci.ResponseInitChain{}
+}
diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
new file mode 100644
index 000000000..a440e7e38
--- /dev/null
+++ b/cmd/gaia/app/app_test.go
@@ -0,0 +1,432 @@
+package app
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/cosmos/cosmos-sdk/x/bank"
+	"github.com/cosmos/cosmos-sdk/x/ibc"
+
+	abci "github.com/tendermint/abci/types"
+	crypto "github.com/tendermint/go-crypto"
+	dbm "github.com/tendermint/tmlibs/db"
+	"github.com/tendermint/tmlibs/log"
+)
+
+// Construct some global addrs and txs for tests.
+var (
+	chainID = "" // TODO
+
+	accName = "foobart"
+
+	priv1     = crypto.GenPrivKeyEd25519()
+	addr1     = priv1.PubKey().Address()
+	priv2     = crypto.GenPrivKeyEd25519()
+	addr2     = priv2.PubKey().Address()
+	addr3     = crypto.GenPrivKeyEd25519().PubKey().Address()
+	priv4     = crypto.GenPrivKeyEd25519()
+	addr4     = priv4.PubKey().Address()
+	coins     = sdk.Coins{{"foocoin", 10}}
+	halfCoins = sdk.Coins{{"foocoin", 5}}
+	manyCoins = sdk.Coins{{"foocoin", 1}, {"barcoin", 1}}
+	fee       = sdk.StdFee{
+		sdk.Coins{{"foocoin", 0}},
+		0,
+	}
+
+	sendMsg1 = bank.SendMsg{
+		Inputs:  []bank.Input{bank.NewInput(addr1, coins)},
+		Outputs: []bank.Output{bank.NewOutput(addr2, coins)},
+	}
+
+	sendMsg2 = bank.SendMsg{
+		Inputs: []bank.Input{bank.NewInput(addr1, coins)},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr2, halfCoins),
+			bank.NewOutput(addr3, halfCoins),
+		},
+	}
+
+	sendMsg3 = bank.SendMsg{
+		Inputs: []bank.Input{
+			bank.NewInput(addr1, coins),
+			bank.NewInput(addr4, coins),
+		},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr2, coins),
+			bank.NewOutput(addr3, coins),
+		},
+	}
+
+	sendMsg4 = bank.SendMsg{
+		Inputs: []bank.Input{
+			bank.NewInput(addr2, coins),
+		},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr1, coins),
+		},
+	}
+
+	sendMsg5 = bank.SendMsg{
+		Inputs: []bank.Input{
+			bank.NewInput(addr1, manyCoins),
+		},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr2, manyCoins),
+		},
+	}
+)
+
+func loggerAndDBs() (log.Logger, map[string]dbm.DB) {
+	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "sdk/app")
+	dbs := map[string]dbm.DB{
+		"main":    dbm.NewMemDB(),
+		"acc":     dbm.NewMemDB(),
+		"ibc":     dbm.NewMemDB(),
+		"staking": dbm.NewMemDB(),
+	}
+	return logger, dbs
+}
+
+func newGaiaApp() *GaiaApp {
+	logger, dbs := loggerAndDBs()
+	return NewGaiaApp(logger, dbs)
+}
+
+func setGenesisAccounts(gapp *GaiaApp, accs ...auth.BaseAccount) error {
+	genaccs := make([]GenesisAccount, len(accs))
+	for i, acc := range accs {
+		genaccs[i] = NewGenesisAccount(acc)
+	}
+
+	genesisState := GenesisState{
+		Accounts: genaccs,
+	}
+
+	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
+	if err != nil {
+		return err
+	}
+
+	// Initialize the chain
+	vals := []abci.Validator{}
+	gapp.InitChain(abci.RequestInitChain{vals, stateBytes})
+	gapp.Commit()
+
+	return nil
+}
+
+//_______________________________________________________________________
+
+func TestMsgs(t *testing.T) {
+	gapp := newGaiaApp()
+
+	msgs := []struct {
+		msg sdk.Msg
+	}{
+		{sendMsg1},
+	}
+
+	for i, m := range msgs {
+		// Run a CheckDeliver
+		SignCheckDeliver(t, gapp, m.msg, []int64{int64(i)}, false, priv1)
+	}
+}
+
+func TestSortGenesis(t *testing.T) {
+	logger, dbs := loggerAndDBs()
+	gapp := NewGaiaApp(logger, dbs)
+
+	// Note the order: the coins are unsorted!
+	coinDenom1, coinDenom2 := "foocoin", "barcoin"
+
+	str := `{
+      "accounts": [{
+        "address": "%s",
+        "coins": [
+          {
+            "denom": "%s",
+            "amount": 10
+          },
+          {
+            "denom": "%s",
+            "amount": 20
+          }
+        ]
+      }]
+    }`
+	genState := fmt.Sprintf(str, addr1.String(), coinDenom1, coinDenom2)
+
+	// Initialize the chain
+	vals := []abci.Validator{}
+	gapp.InitChain(abci.RequestInitChain{vals, []byte(genState)})
+	gapp.Commit()
+
+	// Unsorted coins means invalid
+	err := sendMsg5.ValidateBasic()
+	require.Equal(t, sdk.CodeInvalidCoins, err.ABCICode(), err.ABCILog())
+
+	// Sort coins, should be valid
+	sendMsg5.Inputs[0].Coins.Sort()
+	sendMsg5.Outputs[0].Coins.Sort()
+	err = sendMsg5.ValidateBasic()
+	require.Nil(t, err)
+
+	// Ensure we can send
+	SignCheckDeliver(t, gapp, sendMsg5, []int64{0}, true, priv1)
+}
+
+func TestGenesis(t *testing.T) {
+	logger, dbs := loggerAndDBs()
+	gapp := NewGaiaApp(logger, dbs)
+
+	// Construct some genesis bytes to reflect GaiaAccount
+	pk := crypto.GenPrivKeyEd25519().PubKey()
+	addr := pk.Address()
+	coins, err := sdk.ParseCoins("77foocoin,99barcoin")
+	require.Nil(t, err)
+	baseAcc := auth.BaseAccount{
+		Address: addr,
+		Coins:   coins,
+	}
+
+	err = setGenesisAccounts(gapp, baseAcc)
+	assert.Nil(t, err)
+
+	// A checkTx context
+	ctx := gapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := gapp.accountMapper.GetAccount(ctx, baseAcc.Address)
+	assert.Equal(t, baseAcc, res1)
+
+	// reload app and ensure the account is still there
+	gapp = NewGaiaApp(logger, dbs)
+	ctx = gapp.BaseApp.NewContext(true, abci.Header{})
+	res1 = gapp.accountMapper.GetAccount(ctx, baseAcc.Address)
+	assert.Equal(t, baseAcc, res1)
+}
+
+func TestSendMsgWithAccounts(t *testing.T) {
+	gapp := newGaiaApp()
+
+	// Construct some genesis bytes to reflect GaiaAccount
+	// Give 77 foocoin to the first key
+	coins, err := sdk.ParseCoins("77foocoin")
+	require.Nil(t, err)
+	baseAcc := auth.BaseAccount{
+		Address: addr1,
+		Coins:   coins,
+	}
+
+	// Construct genesis state
+	err = setGenesisAccounts(gapp, baseAcc)
+	assert.Nil(t, err)
+	// A checkTx context (true)
+	ctxCheck := gapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := gapp.accountMapper.GetAccount(ctxCheck, addr1)
+	assert.Equal(t, baseAcc, res1.(*auth.BaseAccount))
+
+	// Run a CheckDeliver
+	SignCheckDeliver(t, gapp, sendMsg1, []int64{0}, true, priv1)
+
+	// Check balances
+	CheckBalance(t, gapp, addr1, "67foocoin")
+	CheckBalance(t, gapp, addr2, "10foocoin")
+
+	// Delivering again should cause replay error
+	SignCheckDeliver(t, gapp, sendMsg1, []int64{0}, false, priv1)
+
+	// bumping the txnonce number without resigning should be an auth error
+	tx := genTx(sendMsg1, []int64{0}, priv1)
+	tx.Signatures[0].Sequence = 1
+	res := gapp.Deliver(tx)
+
+	assert.Equal(t, sdk.CodeUnauthorized, res.Code, res.Log)
+
+	// resigning the tx with the bumped sequence should work
+	SignCheckDeliver(t, gapp, sendMsg1, []int64{1}, true, priv1)
+}
+
+func TestSendMsgMultipleOut(t *testing.T) {
+	gapp := newGaiaApp()
+
+	genCoins, err := sdk.ParseCoins("42foocoin")
+	require.Nil(t, err)
+
+	acc1 := auth.BaseAccount{
+		Address: addr1,
+		Coins:   genCoins,
+	}
+
+	acc2 := auth.BaseAccount{
+		Address: addr2,
+		Coins:   genCoins,
+	}
+
+	err = setGenesisAccounts(gapp, acc1, acc2)
+	assert.Nil(t, err)
+
+	// Simulate a Block
+	SignCheckDeliver(t, gapp, sendMsg2, []int64{0}, true, priv1)
+
+	// Check balances
+	CheckBalance(t, gapp, addr1, "32foocoin")
+	CheckBalance(t, gapp, addr2, "47foocoin")
+	CheckBalance(t, gapp, addr3, "5foocoin")
+}
+
+func TestSengMsgMultipleInOut(t *testing.T) {
+	gapp := newGaiaApp()
+
+	genCoins, err := sdk.ParseCoins("42foocoin")
+	require.Nil(t, err)
+
+	acc1 := auth.BaseAccount{
+		Address: addr1,
+		Coins:   genCoins,
+	}
+
+	acc2 := auth.BaseAccount{
+		Address: addr2,
+		Coins:   genCoins,
+	}
+
+	acc4 := auth.BaseAccount{
+		Address: addr4,
+		Coins:   genCoins,
+	}
+
+	err = setGenesisAccounts(gapp, acc1, acc2, acc4)
+	assert.Nil(t, err)
+
+	// CheckDeliver
+	SignCheckDeliver(t, gapp, sendMsg3, []int64{0, 0}, true, priv1, priv4)
+
+	// Check balances
+	CheckBalance(t, gapp, addr1, "32foocoin")
+	CheckBalance(t, gapp, addr4, "32foocoin")
+	CheckBalance(t, gapp, addr2, "52foocoin")
+	CheckBalance(t, gapp, addr3, "10foocoin")
+}
+
+func TestSendMsgDependent(t *testing.T) {
+	gapp := newGaiaApp()
+
+	genCoins, err := sdk.ParseCoins("42foocoin")
+	require.Nil(t, err)
+
+	acc1 := auth.BaseAccount{
+		Address: addr1,
+		Coins:   genCoins,
+	}
+
+	err = setGenesisAccounts(gapp, acc1)
+	assert.Nil(t, err)
+
+	// CheckDeliver
+	SignCheckDeliver(t, gapp, sendMsg1, []int64{0}, true, priv1)
+
+	// Check balances
+	CheckBalance(t, gapp, addr1, "32foocoin")
+	CheckBalance(t, gapp, addr2, "10foocoin")
+
+	// Simulate a Block
+	SignCheckDeliver(t, gapp, sendMsg4, []int64{0}, true, priv2)
+
+	// Check balances
+	CheckBalance(t, gapp, addr1, "42foocoin")
+}
+
+func TestIBCMsgs(t *testing.T) {
+	gapp := newGaiaApp()
+
+	sourceChain := "source-chain"
+	destChain := "dest-chain"
+
+	baseAcc := auth.BaseAccount{
+		Address: addr1,
+		Coins:   coins,
+	}
+
+	err := setGenesisAccounts(gapp, baseAcc)
+	assert.Nil(t, err)
+	// A checkTx context (true)
+	ctxCheck := gapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := gapp.accountMapper.GetAccount(ctxCheck, addr1)
+	assert.Equal(t, baseAcc, res1)
+
+	packet := ibc.IBCPacket{
+		SrcAddr:   addr1,
+		DestAddr:  addr1,
+		Coins:     coins,
+		SrcChain:  sourceChain,
+		DestChain: destChain,
+	}
+
+	transferMsg := ibc.IBCTransferMsg{
+		IBCPacket: packet,
+	}
+
+	receiveMsg := ibc.IBCReceiveMsg{
+		IBCPacket: packet,
+		Relayer:   addr1,
+		Sequence:  0,
+	}
+
+	SignCheckDeliver(t, gapp, transferMsg, []int64{0}, true, priv1)
+	CheckBalance(t, gapp, addr1, "")
+	SignCheckDeliver(t, gapp, transferMsg, []int64{1}, false, priv1)
+	SignCheckDeliver(t, gapp, receiveMsg, []int64{2}, true, priv1)
+	CheckBalance(t, gapp, addr1, "10foocoin")
+	SignCheckDeliver(t, gapp, receiveMsg, []int64{3}, false, priv1)
+}
+
+func genTx(msg sdk.Msg, seq []int64, priv ...crypto.PrivKeyEd25519) sdk.StdTx {
+	sigs := make([]sdk.StdSignature, len(priv))
+	for i, p := range priv {
+		sigs[i] = sdk.StdSignature{
+			PubKey:    p.PubKey(),
+			Signature: p.Sign(sdk.StdSignBytes(chainID, seq, fee, msg)),
+			Sequence:  seq[i],
+		}
+	}
+
+	return sdk.NewStdTx(msg, fee, sigs)
+
+}
+
+func SignCheckDeliver(t *testing.T, gapp *GaiaApp, msg sdk.Msg, seq []int64, expPass bool, priv ...crypto.PrivKeyEd25519) {
+
+	// Sign the tx
+	tx := genTx(msg, seq, priv...)
+	// Run a Check
+	res := gapp.Check(tx)
+	if expPass {
+		require.Equal(t, sdk.CodeOK, res.Code, res.Log)
+	} else {
+		require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
+	}
+
+	// Simulate a Block
+	gapp.BeginBlock(abci.RequestBeginBlock{})
+	res = gapp.Deliver(tx)
+	if expPass {
+		require.Equal(t, sdk.CodeOK, res.Code, res.Log)
+	} else {
+		require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
+	}
+	gapp.EndBlock(abci.RequestEndBlock{})
+	//gapp.Commit()
+}
+
+func CheckBalance(t *testing.T, gapp *GaiaApp, addr sdk.Address, balExpected string) {
+	ctxDeliver := gapp.BaseApp.NewContext(false, abci.Header{})
+	res2 := gapp.accountMapper.GetAccount(ctxDeliver, addr)
+	assert.Equal(t, balExpected, fmt.Sprintf("%v", res2.GetCoins()))
+}
diff --git a/cmd/gaia/cmd/gaiacli/main.go b/cmd/gaia/cmd/gaiacli/main.go
new file mode 100644
index 000000000..c5c3190c3
--- /dev/null
+++ b/cmd/gaia/cmd/gaiacli/main.go
@@ -0,0 +1,79 @@
+package main
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/tendermint/tmlibs/cli"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/keys"
+	"github.com/cosmos/cosmos-sdk/client/lcd"
+	"github.com/cosmos/cosmos-sdk/client/rpc"
+	"github.com/cosmos/cosmos-sdk/client/tx"
+
+	"github.com/cosmos/cosmos-sdk/version"
+	authcmd "github.com/cosmos/cosmos-sdk/x/auth/commands"
+	bankcmd "github.com/cosmos/cosmos-sdk/x/bank/commands"
+	ibccmd "github.com/cosmos/cosmos-sdk/x/ibc/commands"
+	stakecmd "github.com/cosmos/cosmos-sdk/x/stake/commands"
+
+	"github.com/cosmos/cosmos-sdk/cmd/gaia/app"
+)
+
+// rootCmd is the entry point for this binary
+var (
+	rootCmd = &cobra.Command{
+		Use:   "gaiacli",
+		Short: "Gaia light-client",
+	}
+)
+
+func main() {
+	cobra.EnableCommandSorting = false
+	cdc := app.MakeCodec()
+
+	// TODO: setup keybase, viper object, etc. to be passed into
+	// the below functions and eliminate global vars, like we do
+	// with the cdc
+
+	// add standard rpc, and tx commands
+	rpc.AddCommands(rootCmd)
+	rootCmd.AddCommand(client.LineBreak)
+	tx.AddCommands(rootCmd, cdc)
+	rootCmd.AddCommand(client.LineBreak)
+
+	// add query/post commands (custom to binary)
+	rootCmd.AddCommand(
+		client.GetCommands(
+			authcmd.GetAccountCmd("main", cdc, authcmd.GetAccountDecoder(cdc)),
+			stakecmd.GetCmdQueryCandidates("stake", cdc),
+			stakecmd.GetCmdQueryCandidate("stake", cdc),
+			stakecmd.GetCmdQueryDelegatorBond("stake", cdc),
+			stakecmd.GetCmdQueryDelegatorBonds("stake", cdc),
+		)...)
+	rootCmd.AddCommand(
+		client.PostCommands(
+			bankcmd.SendTxCmd(cdc),
+			ibccmd.IBCTransferCmd(cdc),
+			ibccmd.IBCRelayCmd(cdc),
+			stakecmd.GetCmdDeclareCandidacy(cdc),
+			stakecmd.GetCmdEditCandidacy(cdc),
+			stakecmd.GetCmdDelegate(cdc),
+			stakecmd.GetCmdUnbond(cdc),
+		)...)
+
+	// add proxy, version and key info
+	rootCmd.AddCommand(
+		client.LineBreak,
+		lcd.ServeCommand(cdc),
+		keys.Commands(),
+		client.LineBreak,
+		version.VersionCmd,
+	)
+
+	// prepare and add flags
+	executor := cli.PrepareMainCmd(rootCmd, "GA", os.ExpandEnv("$HOME/.gaiacli"))
+	executor.Execute()
+}
diff --git a/cmd/gaiad/main.go b/cmd/gaia/cmd/gaiad/main.go
similarity index 60%
rename from cmd/gaiad/main.go
rename to cmd/gaia/cmd/gaiad/main.go
index 9ebf196db..f966c446a 100644
--- a/cmd/gaiad/main.go
+++ b/cmd/gaia/cmd/gaiad/main.go
@@ -11,7 +11,7 @@ import (
 	dbm "github.com/tendermint/tmlibs/db"
 	"github.com/tendermint/tmlibs/log"
 
-	"github.com/cosmos/cosmos-sdk/examples/basecoin/app"
+	"github.com/cosmos/cosmos-sdk/cmd/gaia/app"
 	"github.com/cosmos/cosmos-sdk/server"
 )
 
@@ -25,7 +25,6 @@ var (
 	}
 )
 
-// TODO: distinguish from basecoin
 func generateApp(rootDir string, logger log.Logger) (abci.Application, error) {
 	dataDir := filepath.Join(rootDir, "data")
 	db, err := dbm.NewGoLevelDB("gaia", dataDir)
@@ -33,6 +32,25 @@ func generateApp(rootDir string, logger log.Logger) (abci.Application, error) {
 		return nil, err
 	}
 	bapp := app.NewBasecoinApp(logger, db)
+	//dbAcc, err := dbm.NewGoLevelDB("gaia-acc", dataDir)
+	//if err != nil {
+	//return nil, err
+	//}
+	//dbIBC, err := dbm.NewGoLevelDB("gaia-ibc", dataDir)
+	//if err != nil {
+	//return nil, err
+	//}
+	//dbStaking, err := dbm.NewGoLevelDB("gaia-staking", dataDir)
+	//if err != nil {
+	//return nil, err
+	//}
+	//dbs := map[string]dbm.DB{
+	//"main":    dbMain,
+	//"acc":     dbAcc,
+	//"ibc":     dbIBC,
+	//"staking": dbStaking,
+	//}
+	//bapp := app.NewGaiaApp(logger, dbs)
 	return bapp, nil
 }
 
@@ -40,6 +58,7 @@ func main() {
 	server.AddCommands(rootCmd, server.DefaultGenAppState, generateApp, context)
 
 	// prepare and add flags
-	executor := cli.PrepareBaseCmd(rootCmd, "GA", os.ExpandEnv("$HOME/.gaiad"))
+	rootDir := os.ExpandEnv("$HOME/.gaiad")
+	executor := cli.PrepareBaseCmd(rootCmd, "GA", rootDir)
 	executor.Execute()
 }
diff --git a/examples/basecoin/app/app.go b/examples/basecoin/app/app.go
index 9ef48bfb5..bb3ef05ac 100644
--- a/examples/basecoin/app/app.go
+++ b/examples/basecoin/app/app.go
@@ -15,7 +15,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/ibc"
 	"github.com/cosmos/cosmos-sdk/x/simplestake"
-	"github.com/cosmos/cosmos-sdk/x/stake"
 
 	"github.com/cosmos/cosmos-sdk/examples/basecoin/types"
 )
@@ -33,7 +32,7 @@ type BasecoinApp struct {
 	capKeyMainStore    *sdk.KVStoreKey
 	capKeyAccountStore *sdk.KVStoreKey
 	capKeyIBCStore     *sdk.KVStoreKey
-	capKeyStakeStore   *sdk.KVStoreKey
+	capKeyStakingStore *sdk.KVStoreKey
 
 	// Manage getting and setting accounts
 	accountMapper sdk.AccountMapper
@@ -54,7 +53,7 @@ func NewBasecoinApp(logger log.Logger, db dbm.DB) *BasecoinApp {
 		capKeyMainStore:    sdk.NewKVStoreKey("main"),
 		capKeyAccountStore: sdk.NewKVStoreKey("acc"),
 		capKeyIBCStore:     sdk.NewKVStoreKey("ibc"),
-		capKeyStakeStore:   sdk.NewKVStoreKey("stake"),
+		capKeyStakingStore: sdk.NewKVStoreKey("stake"),
 	}
 
 	// Define the accountMapper.
@@ -71,7 +70,7 @@ func NewBasecoinApp(logger log.Logger, db dbm.DB) *BasecoinApp {
 	app.Router().
 		AddRoute("bank", bank.NewHandler(coinKeeper)).
 		AddRoute("ibc", ibc.NewHandler(ibcMapper, coinKeeper)).
-		AddRoute("stake", stake.NewHandler(stakeKeeper))
+		AddRoute("simplestake", simplestake.NewHandler(stakeKeeper))
 
 	// Define the feeHandler.
 	app.feeHandler = auth.BurnFeeHandler
diff --git a/examples/basecoin/app/app_test.go b/examples/basecoin/app/app_test.go
index 1f635f53f..36461a8e3 100644
--- a/examples/basecoin/app/app_test.go
+++ b/examples/basecoin/app/app_test.go
@@ -143,7 +143,7 @@ func TestSortGenesis(t *testing.T) {
 	// Note the order: the coins are unsorted!
 	coinDenom1, coinDenom2 := "foocoin", "barcoin"
 
-	str := `{
+	genState := fmt.Sprintf(`{
       "accounts": [{
         "address": "%s",
         "coins": [
@@ -157,8 +157,7 @@ func TestSortGenesis(t *testing.T) {
           }
         ]
       }]
-    }`
-	genState := fmt.Sprintf(str, addr1.String(), coinDenom1, coinDenom2)
+    }`, addr1.String(), coinDenom1, coinDenom2)
 
 	// Initialize the chain
 	vals := []abci.Validator{}
@@ -345,9 +344,10 @@ func TestQuizMsg(t *testing.T) {
 
 	// Construct genesis state
 	// Construct some genesis bytes to reflect basecoin/types/AppAccount
+	coins := sdk.Coins{}
 	baseAcc := auth.BaseAccount{
 		Address: addr1,
-		Coins:   nil,
+		Coins:   coins,
 	}
 	acc1 := &types.AppAccount{baseAcc, "foobart"}
 
diff --git a/examples/basecoin/cmd/basecli/main.go b/examples/basecoin/cmd/basecli/main.go
index bab24f91b..6271adcec 100644
--- a/examples/basecoin/cmd/basecli/main.go
+++ b/examples/basecoin/cmd/basecli/main.go
@@ -17,7 +17,7 @@ import (
 	authcmd "github.com/cosmos/cosmos-sdk/x/auth/commands"
 	bankcmd "github.com/cosmos/cosmos-sdk/x/bank/commands"
 	ibccmd "github.com/cosmos/cosmos-sdk/x/ibc/commands"
-	stakecmd "github.com/cosmos/cosmos-sdk/x/stake/commands"
+	simplestakingcmd "github.com/cosmos/cosmos-sdk/x/simplestake/commands"
 
 	"github.com/cosmos/cosmos-sdk/examples/basecoin/app"
 	"github.com/cosmos/cosmos-sdk/examples/basecoin/types"
@@ -52,20 +52,23 @@ func main() {
 	rootCmd.AddCommand(
 		client.GetCommands(
 			authcmd.GetAccountCmd("main", cdc, types.GetAccountDecoder(cdc)),
-			stakecmd.GetCmdQueryCandidates("stake", cdc),
-			stakecmd.GetCmdQueryCandidate("stake", cdc),
-			stakecmd.GetCmdQueryDelegatorBond("stake", cdc),
-			stakecmd.GetCmdQueryDelegatorBonds("stake", cdc),
 		)...)
 	rootCmd.AddCommand(
 		client.PostCommands(
 			bankcmd.SendTxCmd(cdc),
+		)...)
+	rootCmd.AddCommand(
+		client.PostCommands(
 			ibccmd.IBCTransferCmd(cdc),
+		)...)
+	rootCmd.AddCommand(
+		client.PostCommands(
 			ibccmd.IBCRelayCmd(cdc),
-			stakecmd.GetCmdDeclareCandidacy(cdc),
-			stakecmd.GetCmdEditCandidacy(cdc),
-			stakecmd.GetCmdDelegate(cdc),
-			stakecmd.GetCmdUnbond(cdc),
+			simplestakingcmd.BondTxCmd(cdc),
+		)...)
+	rootCmd.AddCommand(
+		client.PostCommands(
+			simplestakingcmd.UnbondTxCmd(cdc),
 		)...)
 
 	// add proxy, version and key info
diff --git a/x/stake/handler.go b/x/stake/handler.go
index e1f624f10..af1ad291d 100644
--- a/x/stake/handler.go
+++ b/x/stake/handler.go
@@ -252,40 +252,3 @@ func handleMsgUnbond(ctx sdk.Context, msg MsgUnbond, k Keeper) sdk.Result {
 	k.setPool(ctx, p)
 	return sdk.Result{}
 }
-
-// TODO use or remove
-//// Perform all the actions required to bond tokens to a delegator bond from their account
-//func BondCoins(ctx sdk.Context, k Keeper, bond DelegatorBond,
-//candidate Candidate, amount sdk.Coin) (DelegatorBond, Candidate, Pool, sdk.Error) {
-
-//pool := k.GetPool(ctx)
-//_, err := k.coinKeeper.SubtractCoins(ctx, bond.DelegatorAddr, sdk.Coins{amount})
-//if err != nil {
-//return bond, candidate, pool, err
-//}
-//pool, candidate, newShares := pool.candidateAddTokens(candidate, amount.Amount)
-//bond.Shares = bond.Shares.Add(newShares)
-//return bond, candidate, pool, nil
-//}
-//// Perform all the actions required to bond tokens to a delegator bond from their account
-//func UnbondCoins(ctx sdk.Context, k Keeper, bond DelegatorBond,
-//candidate Candidate, shares sdk.Rat) (DelegatorBond, Candidate, Pool, sdk.Error) {
-
-//pool := k.GetPool(ctx)
-
-//// subtract bond tokens from delegator bond
-//if bond.Shares.LT(shares) {
-//errMsg := fmt.Sprintf("cannot unbond %v shares, only have %v shares available", shares, bond.Shares)
-//return bond, candidate, pool, sdk.ErrInsufficientFunds(errMsg)
-//}
-//bond.Shares = bond.Shares.Sub(shares)
-
-//pool, candidate, returnAmount := p.candidateRemoveShares(candidate, shares)
-//returnCoins := sdk.Coins{{k.GetParams(ctx).BondDenom, returnAmount}}
-
-//_, err := k.coinKeeper.AddCoins(ctx, candidate.Address, returnCoins)
-//if err != nil {
-//return err
-//}
-//return bond, candidate, pool, nil
-//}

From 8a34b91facbe8dd113163d4c92dfa66ae4caa9a9 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Sat, 7 Apr 2018 01:50:46 -0400
Subject: [PATCH 03/26] fix existing gaia tests

---
 cmd/gaia/app/account.go  | 32 ------------------------
 cmd/gaia/app/app.go      | 53 ++++++++++++++++++++++++++++++++++------
 cmd/gaia/app/app_test.go | 38 +++++++++++++++-------------
 x/stake/handler.go       | 16 +++++++++++-
 x/stake/handler_test.go  |  9 +++++++
 x/stake/keeper.go        | 12 ---------
 x/stake/keeper_test.go   | 29 ----------------------
 x/stake/test_common.go   | 25 +++++++++++++++++++
 x/stake/types.go         | 24 +++++++++---------
 9 files changed, 127 insertions(+), 111 deletions(-)
 delete mode 100644 cmd/gaia/app/account.go

diff --git a/cmd/gaia/app/account.go b/cmd/gaia/app/account.go
deleted file mode 100644
index 3d5673b87..000000000
--- a/cmd/gaia/app/account.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package app
-
-import (
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/auth"
-)
-
-// State to Unmarshal
-type GenesisState struct {
-	Accounts []GenesisAccount `json:"accounts"`
-}
-
-// GenesisAccount doesn't need pubkey or sequence
-type GenesisAccount struct {
-	Address sdk.Address `json:"address"`
-	Coins   sdk.Coins   `json:"coins"`
-}
-
-func NewGenesisAccount(acc auth.BaseAccount) GenesisAccount {
-	return GenesisAccount{
-		Address: acc.Address,
-		Coins:   acc.Coins,
-	}
-}
-
-// convert GenesisAccount to GaiaAccount
-func (ga *GenesisAccount) ToAccount() (acc auth.BaseAccount) {
-	return auth.BaseAccount{
-		Address: ga.Address,
-		Coins:   ga.Coins.Sort(),
-	}
-}
diff --git a/cmd/gaia/app/app.go b/cmd/gaia/app/app.go
index 64b1619f8..6cf67b0f2 100644
--- a/cmd/gaia/app/app.go
+++ b/cmd/gaia/app/app.go
@@ -35,6 +35,9 @@ type GaiaApp struct {
 
 	// Manage getting and setting accounts
 	accountMapper sdk.AccountMapper
+	coinKeeper    bank.CoinKeeper
+	ibcMapper     ibc.IBCMapper
+	stakeKeeper   stake.Keeper
 }
 
 func NewGaiaApp(logger log.Logger, dbs map[string]dbm.DB) *GaiaApp {
@@ -55,18 +58,18 @@ func NewGaiaApp(logger log.Logger, dbs map[string]dbm.DB) *GaiaApp {
 	)
 
 	// add handlers
-	coinKeeper := bank.NewCoinKeeper(app.accountMapper)
-	ibcMapper := ibc.NewIBCMapper(app.cdc, app.capKeyIBCStore)
-	stakeKeeper := stake.NewKeeper(app.cdc, app.capKeyStakeStore, coinKeeper)
+	app.coinKeeper = bank.NewCoinKeeper(app.accountMapper)
+	app.ibcMapper = ibc.NewIBCMapper(app.cdc, app.capKeyIBCStore)
+	app.stakeKeeper = stake.NewKeeper(app.cdc, app.capKeyStakeStore, app.coinKeeper)
 	app.Router().
-		AddRoute("bank", bank.NewHandler(coinKeeper)).
-		AddRoute("ibc", ibc.NewHandler(ibcMapper, coinKeeper)).
-		AddRoute("stake", stake.NewHandler(stakeKeeper))
+		AddRoute("bank", bank.NewHandler(app.coinKeeper)).
+		AddRoute("ibc", ibc.NewHandler(app.ibcMapper, app.coinKeeper)).
+		AddRoute("stake", stake.NewHandler(app.stakeKeeper))
 
 	// initialize BaseApp
 	app.SetTxDecoder(app.txDecoder)
 	app.SetInitChainer(app.initChainer)
-	app.SetEndBlocker(stake.NewEndBlocker(stakeKeeper))
+	app.SetEndBlocker(stake.NewEndBlocker(app.stakeKeeper))
 	app.MountStoreWithDB(app.capKeyMainStore, sdk.StoreTypeIAVL, dbs["main"])
 	app.MountStoreWithDB(app.capKeyAccountStore, sdk.StoreTypeIAVL, dbs["acc"])
 	app.MountStoreWithDB(app.capKeyIBCStore, sdk.StoreTypeIAVL, dbs["ibc"])
@@ -150,9 +153,43 @@ func (app *GaiaApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci
 		// return sdk.ErrGenesisParse("").TraceCause(err, "")
 	}
 
+	// load the accounts
 	for _, gacc := range genesisState.Accounts {
 		acc := gacc.ToAccount()
-		app.accountMapper.SetAccount(ctx, &acc)
+		app.accountMapper.SetAccount(ctx, acc)
 	}
+
+	// load the initial stake information
+	stake.InitGenesis(ctx, app.stakeKeeper, genesisState.StakeData)
+
 	return abci.ResponseInitChain{}
 }
+
+//__________________________________________________________
+
+// State to Unmarshal
+type GenesisState struct {
+	Accounts  []GenesisAccount `json:"accounts"`
+	StakeData json.RawMessage  `json:"stake"`
+}
+
+// GenesisAccount doesn't need pubkey or sequence
+type GenesisAccount struct {
+	Address sdk.Address `json:"address"`
+	Coins   sdk.Coins   `json:"coins"`
+}
+
+func NewGenesisAccount(acc *auth.BaseAccount) GenesisAccount {
+	return GenesisAccount{
+		Address: acc.Address,
+		Coins:   acc.Coins,
+	}
+}
+
+// convert GenesisAccount to GaiaAccount
+func (ga *GenesisAccount) ToAccount() (acc *auth.BaseAccount) {
+	return &auth.BaseAccount{
+		Address: ga.Address,
+		Coins:   ga.Coins.Sort(),
+	}
+}
diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
index a440e7e38..a9cc4b739 100644
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@@ -13,6 +13,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/ibc"
+	"github.com/cosmos/cosmos-sdk/x/stake"
 
 	abci "github.com/tendermint/abci/types"
 	crypto "github.com/tendermint/go-crypto"
@@ -100,14 +101,15 @@ func newGaiaApp() *GaiaApp {
 	return NewGaiaApp(logger, dbs)
 }
 
-func setGenesisAccounts(gapp *GaiaApp, accs ...auth.BaseAccount) error {
+func setGenesis(gapp *GaiaApp, accs ...*auth.BaseAccount) error {
 	genaccs := make([]GenesisAccount, len(accs))
 	for i, acc := range accs {
 		genaccs[i] = NewGenesisAccount(acc)
 	}
 
 	genesisState := GenesisState{
-		Accounts: genaccs,
+		Accounts:  genaccs,
+		StakeData: stake.GetGenesisJSON(),
 	}
 
 	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
@@ -127,6 +129,7 @@ func setGenesisAccounts(gapp *GaiaApp, accs ...auth.BaseAccount) error {
 
 func TestMsgs(t *testing.T) {
 	gapp := newGaiaApp()
+	assert.Nil(t, setGenesis(gapp))
 
 	msgs := []struct {
 		msg sdk.Msg
@@ -180,6 +183,7 @@ func TestSortGenesis(t *testing.T) {
 	require.Nil(t, err)
 
 	// Ensure we can send
+	assert.Nil(t, setGenesis(gapp)) // initialize the pool
 	SignCheckDeliver(t, gapp, sendMsg5, []int64{0}, true, priv1)
 }
 
@@ -192,12 +196,12 @@ func TestGenesis(t *testing.T) {
 	addr := pk.Address()
 	coins, err := sdk.ParseCoins("77foocoin,99barcoin")
 	require.Nil(t, err)
-	baseAcc := auth.BaseAccount{
+	baseAcc := &auth.BaseAccount{
 		Address: addr,
 		Coins:   coins,
 	}
 
-	err = setGenesisAccounts(gapp, baseAcc)
+	err = setGenesis(gapp, baseAcc)
 	assert.Nil(t, err)
 
 	// A checkTx context
@@ -219,13 +223,13 @@ func TestSendMsgWithAccounts(t *testing.T) {
 	// Give 77 foocoin to the first key
 	coins, err := sdk.ParseCoins("77foocoin")
 	require.Nil(t, err)
-	baseAcc := auth.BaseAccount{
+	baseAcc := &auth.BaseAccount{
 		Address: addr1,
 		Coins:   coins,
 	}
 
 	// Construct genesis state
-	err = setGenesisAccounts(gapp, baseAcc)
+	err = setGenesis(gapp, baseAcc)
 	assert.Nil(t, err)
 	// A checkTx context (true)
 	ctxCheck := gapp.BaseApp.NewContext(true, abci.Header{})
@@ -259,17 +263,17 @@ func TestSendMsgMultipleOut(t *testing.T) {
 	genCoins, err := sdk.ParseCoins("42foocoin")
 	require.Nil(t, err)
 
-	acc1 := auth.BaseAccount{
+	acc1 := &auth.BaseAccount{
 		Address: addr1,
 		Coins:   genCoins,
 	}
 
-	acc2 := auth.BaseAccount{
+	acc2 := &auth.BaseAccount{
 		Address: addr2,
 		Coins:   genCoins,
 	}
 
-	err = setGenesisAccounts(gapp, acc1, acc2)
+	err = setGenesis(gapp, acc1, acc2)
 	assert.Nil(t, err)
 
 	// Simulate a Block
@@ -287,22 +291,22 @@ func TestSengMsgMultipleInOut(t *testing.T) {
 	genCoins, err := sdk.ParseCoins("42foocoin")
 	require.Nil(t, err)
 
-	acc1 := auth.BaseAccount{
+	acc1 := &auth.BaseAccount{
 		Address: addr1,
 		Coins:   genCoins,
 	}
 
-	acc2 := auth.BaseAccount{
+	acc2 := &auth.BaseAccount{
 		Address: addr2,
 		Coins:   genCoins,
 	}
 
-	acc4 := auth.BaseAccount{
+	acc4 := &auth.BaseAccount{
 		Address: addr4,
 		Coins:   genCoins,
 	}
 
-	err = setGenesisAccounts(gapp, acc1, acc2, acc4)
+	err = setGenesis(gapp, acc1, acc2, acc4)
 	assert.Nil(t, err)
 
 	// CheckDeliver
@@ -321,12 +325,12 @@ func TestSendMsgDependent(t *testing.T) {
 	genCoins, err := sdk.ParseCoins("42foocoin")
 	require.Nil(t, err)
 
-	acc1 := auth.BaseAccount{
+	acc1 := &auth.BaseAccount{
 		Address: addr1,
 		Coins:   genCoins,
 	}
 
-	err = setGenesisAccounts(gapp, acc1)
+	err = setGenesis(gapp, acc1)
 	assert.Nil(t, err)
 
 	// CheckDeliver
@@ -349,12 +353,12 @@ func TestIBCMsgs(t *testing.T) {
 	sourceChain := "source-chain"
 	destChain := "dest-chain"
 
-	baseAcc := auth.BaseAccount{
+	baseAcc := &auth.BaseAccount{
 		Address: addr1,
 		Coins:   coins,
 	}
 
-	err := setGenesisAccounts(gapp, baseAcc)
+	err := setGenesis(gapp, baseAcc)
 	assert.Nil(t, err)
 	// A checkTx context (true)
 	ctxCheck := gapp.BaseApp.NewContext(true, abci.Header{})
diff --git a/x/stake/handler.go b/x/stake/handler.go
index af1ad291d..36b4509da 100644
--- a/x/stake/handler.go
+++ b/x/stake/handler.go
@@ -2,6 +2,7 @@ package stake
 
 import (
 	"bytes"
+	"encoding/json"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	abci "github.com/tendermint/abci/types"
@@ -35,7 +36,7 @@ func NewHandler(k Keeper) sdk.Handler {
 	}
 }
 
-//_______________________________________________
+//_____________________________________________________________________
 
 // NewEndBlocker generates sdk.EndBlocker
 // Performs tick functionality
@@ -48,6 +49,19 @@ func NewEndBlocker(k Keeper) sdk.EndBlocker {
 
 //_____________________________________________________________________
 
+// InitGenesis - store genesis parameters
+func InitGenesis(ctx sdk.Context, k Keeper, data json.RawMessage) error {
+	var state GenesisState
+	if err := json.Unmarshal(data, &state); err != nil {
+		return err
+	}
+	k.setPool(ctx, state.Pool)
+	k.setParams(ctx, state.Params)
+	return nil
+}
+
+//_____________________________________________________________________
+
 // These functions assume everything has been authenticated,
 // now we just perform action and save
 
diff --git a/x/stake/handler_test.go b/x/stake/handler_test.go
index 1f0bc6415..82b33cf2c 100644
--- a/x/stake/handler_test.go
+++ b/x/stake/handler_test.go
@@ -12,6 +12,15 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+func TestInitGenesis(t *testing.T) {
+	ctx, _, keeper := createTestInput(t, false, 0)
+	encoded := GetGenesisJSON()
+	err := InitGenesis(ctx, keeper, encoded)
+	require.Nil(t, err)
+	require.Equal(t, keeper.GetPool(ctx), initialPool())
+	require.Equal(t, keeper.GetParams(ctx), defaultParams())
+}
+
 //______________________________________________________________________
 
 func newTestMsgDeclareCandidacy(address sdk.Address, pubKey crypto.PubKey, amt int64) MsgDeclareCandidacy {
diff --git a/x/stake/keeper.go b/x/stake/keeper.go
index ae3dfb7c7..8b73e81db 100644
--- a/x/stake/keeper.go
+++ b/x/stake/keeper.go
@@ -2,7 +2,6 @@ package stake
 
 import (
 	"bytes"
-	"encoding/json"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/wire"
@@ -34,17 +33,6 @@ func NewKeeper(ctx sdk.Context, cdc *wire.Codec, key sdk.StoreKey, ck bank.CoinK
 	return keeper
 }
 
-// InitGenesis - store genesis parameters
-func (k Keeper) InitGenesis(ctx sdk.Context, data json.RawMessage) error {
-	var state GenesisState
-	if err := json.Unmarshal(data, &state); err != nil {
-		return err
-	}
-	k.setPool(ctx, state.Pool)
-	k.setParams(ctx, state.Params)
-	return nil
-}
-
 //_________________________________________________________________________
 
 // get a single candidate
diff --git a/x/stake/keeper_test.go b/x/stake/keeper_test.go
index 088bc5e30..e8d8e0594 100644
--- a/x/stake/keeper_test.go
+++ b/x/stake/keeper_test.go
@@ -2,7 +2,6 @@ package stake
 
 import (
 	"bytes"
-	"encoding/json"
 	"testing"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -584,31 +583,3 @@ func TestPool(t *testing.T) {
 	resPool = keeper.GetPool(ctx)
 	assert.Equal(t, expPool, resPool)
 }
-
-func TestInitGenesis(t *testing.T) {
-	ctx, _, keeper := createTestInput(t, false, 0)
-	jsonStr := `{
-  "params": {
-    "inflation_rate_change": {"num": 13, "denom": 100},
-    "inflation_max": {"num": 20, "denom": 100}, 
-    "inflation_min": {"num": 7, "denom": 100}, 
-    "goal_bonded": {"num": 67, "denom": 100}, 
-    "max_validators": 100,
-    "bond_denom": "fermion"
-  },
-  "pool": {
-    "total_supply": 0,
-    "bonded_shares": {"num": 0, "denom": 1}, 
-    "unbonded_shares": {"num": 0, "denom": 1}, 
-    "bonded_pool": 0,
-    "unbonded_pool": 0,
-    "inflation_last_time": 0,
-    "inflation": {"num": 7, "denom": 100}
-  }
-}`
-	encoded := json.RawMessage(jsonStr)
-	err := keeper.InitGenesis(ctx, encoded)
-	require.Nil(t, err)
-	require.Equal(t, keeper.GetPool(ctx), initialPool())
-	require.Equal(t, keeper.GetParams(ctx), defaultParams())
-}
diff --git a/x/stake/test_common.go b/x/stake/test_common.go
index 6470abbc7..5b0bc97e0 100644
--- a/x/stake/test_common.go
+++ b/x/stake/test_common.go
@@ -2,6 +2,7 @@ package stake
 
 import (
 	"encoding/hex"
+	"encoding/json"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -75,6 +76,30 @@ func initialPool() Pool {
 	}
 }
 
+// get raw genesis raw message for testing
+func GetGenesisJSON() json.RawMessage {
+	jsonStr := `{
+  "params": {
+    "inflation_rate_change": {"num": 13, "denom": 100},
+    "inflation_max": {"num": 20, "denom": 100}, 
+    "inflation_min": {"num": 7, "denom": 100}, 
+    "goal_bonded": {"num": 67, "denom": 100}, 
+    "max_validators": 100,
+    "bond_denom": "fermion"
+  },
+  "pool": {
+    "total_supply": 0,
+    "bonded_shares": {"num": 0, "denom": 1}, 
+    "unbonded_shares": {"num": 0, "denom": 1}, 
+    "bonded_pool": 0,
+    "unbonded_pool": 0,
+    "inflation_last_time": 0,
+    "inflation": {"num": 7, "denom": 100}
+  }
+}`
+	return json.RawMessage(jsonStr)
+}
+
 // XXX reference the common declaration of this function
 func subspace(prefix []byte) (start, end []byte) {
 	end = make([]byte, len(prefix))
diff --git a/x/stake/types.go b/x/stake/types.go
index 1154f7962..240f3fe2a 100644
--- a/x/stake/types.go
+++ b/x/stake/types.go
@@ -7,6 +7,14 @@ import (
 	crypto "github.com/tendermint/go-crypto"
 )
 
+// GenesisState - all staking state that must be provided at genesis
+type GenesisState struct {
+	Pool   Pool   `json:"pool"`
+	Params Params `json:"params"`
+}
+
+//_________________________________________________________________________
+
 // Params defines the high level settings for staking
 type Params struct {
 	InflationRateChange sdk.Rat `json:"inflation_rate_change"` // maximum annual change in inflation rate
@@ -31,13 +39,7 @@ type Pool struct {
 	Inflation         sdk.Rat `json:"inflation"`           // current annual inflation rate
 }
 
-// GenesisState - all staking state that must be provided at genesis
-type GenesisState struct {
-	Pool   Pool   `json:"pool"`
-	Params Params `json:"params"`
-}
-
-//_______________________________________________________________________________________________________
+//_________________________________________________________________________
 
 // CandidateStatus - status of a validator-candidate
 type CandidateStatus byte
@@ -65,6 +67,9 @@ type Candidate struct {
 	Description Description     `json:"description"` // Description terms for the candidate
 }
 
+// Candidates - list of Candidates
+type Candidates []Candidate
+
 // NewCandidate - initialize a new candidate
 func NewCandidate(address sdk.Address, pubKey crypto.PubKey, description Description) Candidate {
 	return Candidate{
@@ -151,11 +156,6 @@ func (v Validator) abciValidatorZero(cdc *wire.Codec) abci.Validator {
 
 //_________________________________________________________________________
 
-// Candidates - list of Candidates
-type Candidates []Candidate
-
-//_________________________________________________________________________
-
 // DelegatorBond represents the bond with tokens held by an account.  It is
 // owned by one delegator, and is associated with the voting power of one
 // pubKey.

From c4a1c12119e7c91f573a7f78a731e780aaed51ed Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Sat, 7 Apr 2018 02:11:08 -0400
Subject: [PATCH 04/26] gaia app_test for declare candidacy

---
 cmd/gaia/app/app_test.go | 65 +++++++++++++++++++++++++++++++---------
 1 file changed, 51 insertions(+), 14 deletions(-)

diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
index a9cc4b739..544249a8a 100644
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@@ -129,7 +129,7 @@ func setGenesis(gapp *GaiaApp, accs ...*auth.BaseAccount) error {
 
 func TestMsgs(t *testing.T) {
 	gapp := newGaiaApp()
-	assert.Nil(t, setGenesis(gapp))
+	require.Nil(t, setGenesis(gapp))
 
 	msgs := []struct {
 		msg sdk.Msg
@@ -183,7 +183,7 @@ func TestSortGenesis(t *testing.T) {
 	require.Nil(t, err)
 
 	// Ensure we can send
-	assert.Nil(t, setGenesis(gapp)) // initialize the pool
+	require.Nil(t, setGenesis(gapp)) // initialize the pool
 	SignCheckDeliver(t, gapp, sendMsg5, []int64{0}, true, priv1)
 }
 
@@ -230,7 +230,8 @@ func TestSendMsgWithAccounts(t *testing.T) {
 
 	// Construct genesis state
 	err = setGenesis(gapp, baseAcc)
-	assert.Nil(t, err)
+	require.Nil(t, err)
+
 	// A checkTx context (true)
 	ctxCheck := gapp.BaseApp.NewContext(true, abci.Header{})
 	res1 := gapp.accountMapper.GetAccount(ctxCheck, addr1)
@@ -274,7 +275,7 @@ func TestSendMsgMultipleOut(t *testing.T) {
 	}
 
 	err = setGenesis(gapp, acc1, acc2)
-	assert.Nil(t, err)
+	require.Nil(t, err)
 
 	// Simulate a Block
 	SignCheckDeliver(t, gapp, sendMsg2, []int64{0}, true, priv1)
@@ -295,12 +296,10 @@ func TestSengMsgMultipleInOut(t *testing.T) {
 		Address: addr1,
 		Coins:   genCoins,
 	}
-
 	acc2 := &auth.BaseAccount{
 		Address: addr2,
 		Coins:   genCoins,
 	}
-
 	acc4 := &auth.BaseAccount{
 		Address: addr4,
 		Coins:   genCoins,
@@ -331,7 +330,7 @@ func TestSendMsgDependent(t *testing.T) {
 	}
 
 	err = setGenesis(gapp, acc1)
-	assert.Nil(t, err)
+	require.Nil(t, err)
 
 	// CheckDeliver
 	SignCheckDeliver(t, gapp, sendMsg1, []int64{0}, true, priv1)
@@ -359,7 +358,8 @@ func TestIBCMsgs(t *testing.T) {
 	}
 
 	err := setGenesis(gapp, baseAcc)
-	assert.Nil(t, err)
+	require.Nil(t, err)
+
 	// A checkTx context (true)
 	ctxCheck := gapp.BaseApp.NewContext(true, abci.Header{})
 	res1 := gapp.accountMapper.GetAccount(ctxCheck, addr1)
@@ -391,6 +391,49 @@ func TestIBCMsgs(t *testing.T) {
 	SignCheckDeliver(t, gapp, receiveMsg, []int64{3}, false, priv1)
 }
 
+func TestStakeMsgs(t *testing.T) {
+	gapp := newGaiaApp()
+
+	genCoins, err := sdk.ParseCoins("42fermion")
+	require.Nil(t, err)
+	bondCoin, err := sdk.ParseCoin("10fermion")
+	require.Nil(t, err)
+
+	acc1 := &auth.BaseAccount{
+		Address: addr1,
+		Coins:   genCoins,
+	}
+	acc2 := &auth.BaseAccount{
+		Address: addr2,
+		Coins:   genCoins,
+	}
+
+	err = setGenesis(gapp, acc1, acc2)
+	require.Nil(t, err)
+
+	// A checkTx context (true)
+	ctxCheck := gapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := gapp.accountMapper.GetAccount(ctxCheck, addr1)
+	res2 := gapp.accountMapper.GetAccount(ctxCheck, addr2)
+	require.Equal(t, acc1, res1)
+	require.Equal(t, acc2, res2)
+
+	description := stake.NewDescription("foo_moniker", "", "", "")
+	declareCandidacyMsg := stake.NewMsgDeclareCandidacy(
+		addr1, priv1.PubKey(), bondCoin, description,
+	)
+
+	SignCheckDeliver(t, gapp, declareCandidacyMsg, []int64{0}, true, priv1)
+}
+
+//____________________________________________________________________________________
+
+func CheckBalance(t *testing.T, gapp *GaiaApp, addr sdk.Address, balExpected string) {
+	ctxDeliver := gapp.BaseApp.NewContext(false, abci.Header{})
+	res2 := gapp.accountMapper.GetAccount(ctxDeliver, addr)
+	assert.Equal(t, balExpected, fmt.Sprintf("%v", res2.GetCoins()))
+}
+
 func genTx(msg sdk.Msg, seq []int64, priv ...crypto.PrivKeyEd25519) sdk.StdTx {
 	sigs := make([]sdk.StdSignature, len(priv))
 	for i, p := range priv {
@@ -428,9 +471,3 @@ func SignCheckDeliver(t *testing.T, gapp *GaiaApp, msg sdk.Msg, seq []int64, exp
 	gapp.EndBlock(abci.RequestEndBlock{})
 	//gapp.Commit()
 }
-
-func CheckBalance(t *testing.T, gapp *GaiaApp, addr sdk.Address, balExpected string) {
-	ctxDeliver := gapp.BaseApp.NewContext(false, abci.Header{})
-	res2 := gapp.accountMapper.GetAccount(ctxDeliver, addr)
-	assert.Equal(t, balExpected, fmt.Sprintf("%v", res2.GetCoins()))
-}

From abce3850ec69a9053b3d3003bab21843a211985e Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Sat, 7 Apr 2018 11:11:47 -0400
Subject: [PATCH 05/26] build fixes

---
 Makefile | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Makefile b/Makefile
index 4d21c61c5..78a5c9dcc 100644
--- a/Makefile
+++ b/Makefile
@@ -15,11 +15,11 @@ ci: get_tools get_vendor_deps build test_cover
 # This can be unified later, here for easy demos
 build:
 ifeq ($(OS),Windows_NT)
-	go build $(BUILD_FLAGS) -o build/gaiad.exe ./cmd/gaiad
-	go build $(BUILD_FLAGS) -o build/gaiacli.exe ./cmd/gaiacli
+	go build $(BUILD_FLAGS) -o build/gaiad.exe ./cmd/gaia/cmd/gaiad
+	go build $(BUILD_FLAGS) -o build/gaiacli.exe ./cmd/gaia/cmd/gaiacli
 else
-	go build $(BUILD_FLAGS) -o build/gaiad ./cmd/gaiad
-	go build $(BUILD_FLAGS) -o build/gaiacli ./cmd/gaiacli
+	go build $(BUILD_FLAGS) -o build/gaiad ./cmd/gaia/cmd/gaiad
+	go build $(BUILD_FLAGS) -o build/gaiacli ./cmd/gaia/cmd/gaiacli
 endif
 
 build_examples:

From c90d62e03527462a83a374a740cabc1a87b33411 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Mon, 9 Apr 2018 23:08:00 -0400
Subject: [PATCH 06/26] rebase fixes

---
 cmd/gaia/app/app.go               | 56 ++++++++------------
 cmd/gaiacli/main.go               | 88 -------------------------------
 examples/basecoin/app/app_test.go |  3 +-
 3 files changed, 22 insertions(+), 125 deletions(-)
 delete mode 100644 cmd/gaiacli/main.go

diff --git a/cmd/gaia/app/app.go b/cmd/gaia/app/app.go
index 6cf67b0f2..49b5bc724 100644
--- a/cmd/gaia/app/app.go
+++ b/cmd/gaia/app/app.go
@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 
 	abci "github.com/tendermint/abci/types"
-	oldwire "github.com/tendermint/go-wire"
 	cmn "github.com/tendermint/tmlibs/common"
 	dbm "github.com/tendermint/tmlibs/db"
 	"github.com/tendermint/tmlibs/log"
@@ -52,10 +51,11 @@ func NewGaiaApp(logger log.Logger, dbs map[string]dbm.DB) *GaiaApp {
 	}
 
 	// define the accountMapper
-	app.accountMapper = auth.NewAccountMapperSealed(
+	app.accountMapper = auth.NewAccountMapper(
+		app.cdc,
 		app.capKeyMainStore, // target store
 		&auth.BaseAccount{}, // prototype
-	)
+	).Seal()
 
 	// add handlers
 	app.coinKeeper = bank.NewCoinKeeper(app.accountMapper)
@@ -87,41 +87,27 @@ func NewGaiaApp(logger log.Logger, dbs map[string]dbm.DB) *GaiaApp {
 }
 
 // custom tx codec
-// TODO: use new go-wire
 func MakeCodec() *wire.Codec {
-	const (
-		msgTypeSend           = 0x1
-		msgTypeIssue          = 0x2
-		msgTypeIBCTransferMsg = 0x3
-		msgTypeIBCReceiveMsg  = 0x4
-		msgDeclareCandidacy   = 0x5
-		msgEditCandidacy      = 0x6
-		msgDelegate           = 0x7
-		msgUnbond             = 0x8
-	)
-	var _ = oldwire.RegisterInterface(
-		struct{ sdk.Msg }{},
-		oldwire.ConcreteType{bank.SendMsg{}, msgTypeSend},
-		oldwire.ConcreteType{bank.IssueMsg{}, msgTypeIssue},
-		oldwire.ConcreteType{ibc.IBCTransferMsg{}, msgTypeIBCTransferMsg},
-		oldwire.ConcreteType{ibc.IBCReceiveMsg{}, msgTypeIBCReceiveMsg},
-		oldwire.ConcreteType{stake.MsgDeclareCandidacy{}, msgDeclareCandidacy},
-		oldwire.ConcreteType{stake.MsgEditCandidacy{}, msgEditCandidacy},
-		oldwire.ConcreteType{stake.MsgDelegate{}, msgDelegate},
-		oldwire.ConcreteType{stake.MsgUnbond{}, msgUnbond},
-	)
+	var cdc = wire.NewCodec()
 
-	const accTypeApp = 0x1
-	var _ = oldwire.RegisterInterface(
-		struct{ sdk.Account }{},
-		oldwire.ConcreteType{&auth.BaseAccount{}, accTypeApp},
-	)
-	cdc := wire.NewCodec()
+	// Register Msgs
+	cdc.RegisterInterface((*sdk.Msg)(nil), nil)
+	cdc.RegisterConcrete(bank.SendMsg{}, "gaia/Send", nil)
+	cdc.RegisterConcrete(bank.IssueMsg{}, "gaia/Issue", nil)
+	cdc.RegisterConcrete(ibc.IBCTransferMsg{}, "gaia/IBCTransferMsg", nil)
+	cdc.RegisterConcrete(ibc.IBCReceiveMsg{}, "gaia/IBCReceiveMsg", nil)
+	cdc.RegisterConcrete(stake.MsgDeclareCandidacy{}, "gaia/MsgDeclareCandidacy", nil)
+	cdc.RegisterConcrete(stake.MsgEditCandidacy{}, "gaia/MsgEditCandidacy", nil)
+	cdc.RegisterConcrete(stake.MsgDelegate{}, "gaia/MsgDelegate", nil)
+	cdc.RegisterConcrete(stake.MsgUnbond{}, "gaia/MsgUnbond", nil)
+
+	// Register AppAccount
+	cdc.RegisterInterface((*sdk.Account)(nil), nil)
+	cdc.RegisterConcrete(&auth.BaseAccount{}, "gaia/Account", nil)
+
+	// Register crypto.
+	wire.RegisterCrypto(cdc)
 
-	// cdc.RegisterInterface((*sdk.Msg)(nil), nil)
-	// bank.RegisterWire(cdc)   // Register bank.[SendMsg,IssueMsg]
-	// crypto.RegisterWire(cdc) // Register crypto.[PubKey,PrivKey,Signature]
-	// ibc.RegisterWire(cdc) // Register ibc.[IBCTransferMsg, IBCReceiveMsg]
 	return cdc
 }
 
diff --git a/cmd/gaiacli/main.go b/cmd/gaiacli/main.go
deleted file mode 100644
index 1c71d7829..000000000
--- a/cmd/gaiacli/main.go
+++ /dev/null
@@ -1,88 +0,0 @@
-package main
-
-import (
-	"os"
-
-	"github.com/spf13/cobra"
-
-	"github.com/tendermint/tmlibs/cli"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/client/keys"
-	"github.com/cosmos/cosmos-sdk/client/lcd"
-	"github.com/cosmos/cosmos-sdk/client/rpc"
-	"github.com/cosmos/cosmos-sdk/client/tx"
-
-	"github.com/cosmos/cosmos-sdk/version"
-	authcmd "github.com/cosmos/cosmos-sdk/x/auth/commands"
-	bankcmd "github.com/cosmos/cosmos-sdk/x/bank/commands"
-	ibccmd "github.com/cosmos/cosmos-sdk/x/ibc/commands"
-	simplestakingcmd "github.com/cosmos/cosmos-sdk/x/simplestake/commands"
-
-	"github.com/cosmos/cosmos-sdk/examples/basecoin/app"
-	"github.com/cosmos/cosmos-sdk/examples/basecoin/types"
-)
-
-// TODO: distinguish from basecli
-
-// rootCmd is the entry point for this binary
-var (
-	rootCmd = &cobra.Command{
-		Use:   "gaiacli",
-		Short: "Gaia light-client",
-	}
-)
-
-func main() {
-	// disable sorting
-	cobra.EnableCommandSorting = false
-
-	// get the codec
-	cdc := app.MakeCodec()
-
-	// TODO: setup keybase, viper object, etc. to be passed into
-	// the below functions and eliminate global vars, like we do
-	// with the cdc
-
-	// add standard rpc, and tx commands
-	rpc.AddCommands(rootCmd)
-	rootCmd.AddCommand(client.LineBreak)
-	tx.AddCommands(rootCmd, cdc)
-	rootCmd.AddCommand(client.LineBreak)
-
-	// add query/post commands (custom to binary)
-	rootCmd.AddCommand(
-		client.GetCommands(
-			authcmd.GetAccountCmd("main", cdc, types.GetAccountDecoder(cdc)),
-		)...)
-	rootCmd.AddCommand(
-		client.PostCommands(
-			bankcmd.SendTxCmd(cdc),
-		)...)
-	rootCmd.AddCommand(
-		client.PostCommands(
-			ibccmd.IBCTransferCmd(cdc),
-		)...)
-	rootCmd.AddCommand(
-		client.PostCommands(
-			ibccmd.IBCRelayCmd(cdc),
-			simplestakingcmd.BondTxCmd(cdc),
-		)...)
-	rootCmd.AddCommand(
-		client.PostCommands(
-			simplestakingcmd.UnbondTxCmd(cdc),
-		)...)
-
-	// add proxy, version and key info
-	rootCmd.AddCommand(
-		client.LineBreak,
-		lcd.ServeCommand(cdc),
-		keys.Commands(),
-		client.LineBreak,
-		version.VersionCmd,
-	)
-
-	// prepare and add flags
-	executor := cli.PrepareMainCmd(rootCmd, "BC", os.ExpandEnv("$HOME/.gaiacli"))
-	executor.Execute()
-}
diff --git a/examples/basecoin/app/app_test.go b/examples/basecoin/app/app_test.go
index 36461a8e3..bc1735dde 100644
--- a/examples/basecoin/app/app_test.go
+++ b/examples/basecoin/app/app_test.go
@@ -344,10 +344,9 @@ func TestQuizMsg(t *testing.T) {
 
 	// Construct genesis state
 	// Construct some genesis bytes to reflect basecoin/types/AppAccount
-	coins := sdk.Coins{}
 	baseAcc := auth.BaseAccount{
 		Address: addr1,
-		Coins:   coins,
+		Coins:   nil,
 	}
 	acc1 := &types.AppAccount{baseAcc, "foobart"}
 

From c63a5452064a8857b7c30d4b5179e15f0c06defe Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Tue, 10 Apr 2018 23:51:09 -0400
Subject: [PATCH 07/26] stake handler tests

---
 baseapp/baseapp.go       |  7 ++--
 cmd/gaia/app/app.go      |  2 +-
 cmd/gaia/app/app_test.go | 80 +++++++++++++++++++++++++++++++++++++---
 types/result.go          |  2 +-
 x/stake/handler.go       | 18 ++++-----
 x/stake/handler_test.go  |  8 ++--
 x/stake/keeper.go        |  5 ++-
 x/stake/keeper_test.go   | 24 ++++++------
 8 files changed, 107 insertions(+), 39 deletions(-)

diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go
index 115748ca5..3eebb1eb4 100644
--- a/baseapp/baseapp.go
+++ b/baseapp/baseapp.go
@@ -322,9 +322,8 @@ func (app *BaseApp) DeliverTx(txBytes []byte) (res abci.ResponseDeliverTx) {
 	if result.IsOK() {
 		app.valUpdates = append(app.valUpdates, result.ValidatorUpdates...)
 	} else {
-		// Even though the Code is not OK, there will be some side
-		// effects, like those caused by fee deductions or sequence
-		// incrementations.
+		// Even though the Result.Code is not OK, there are still effects,
+		// namely fee deductions and sequence incrementing.
 	}
 
 	// Tell the blockchain engine (i.e. Tendermint).
@@ -453,7 +452,7 @@ func (app *BaseApp) Commit() (res abci.ResponseCommit) {
 	// Use the header from this latest block.
 	app.setCheckState(header)
 
-	// Emtpy the Deliver state
+	// Empty the Deliver state
 	app.deliverState = nil
 
 	return abci.ResponseCommit{
diff --git a/cmd/gaia/app/app.go b/cmd/gaia/app/app.go
index 49b5bc724..0fa4f4181 100644
--- a/cmd/gaia/app/app.go
+++ b/cmd/gaia/app/app.go
@@ -76,7 +76,7 @@ func NewGaiaApp(logger log.Logger, dbs map[string]dbm.DB) *GaiaApp {
 	app.MountStoreWithDB(app.capKeyStakeStore, sdk.StoreTypeIAVL, dbs["stake"])
 
 	// NOTE: Broken until #532 lands
-	//app.MountStoresIAVL(app.capKeyMainStore, app.capKeyIBCStore, app.capKeyStakingStore)
+	//app.MountStoresIAVL(app.capKeyMainStore, app.capKeyIBCStore, app.capKeyStakeStore)
 	app.SetAnteHandler(auth.NewAnteHandler(app.accountMapper))
 	err := app.LoadLatestVersion(app.capKeyMainStore)
 	if err != nil {
diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
index 544249a8a..4ca1cd959 100644
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@@ -88,10 +88,10 @@ var (
 func loggerAndDBs() (log.Logger, map[string]dbm.DB) {
 	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "sdk/app")
 	dbs := map[string]dbm.DB{
-		"main":    dbm.NewMemDB(),
-		"acc":     dbm.NewMemDB(),
-		"ibc":     dbm.NewMemDB(),
-		"staking": dbm.NewMemDB(),
+		"main":  dbm.NewMemDB(),
+		"acc":   dbm.NewMemDB(),
+		"ibc":   dbm.NewMemDB(),
+		"stake": dbm.NewMemDB(),
 	}
 	return logger, dbs
 }
@@ -418,12 +418,59 @@ func TestStakeMsgs(t *testing.T) {
 	require.Equal(t, acc1, res1)
 	require.Equal(t, acc2, res2)
 
+	// Declare Candidacy
+
 	description := stake.NewDescription("foo_moniker", "", "", "")
 	declareCandidacyMsg := stake.NewMsgDeclareCandidacy(
 		addr1, priv1.PubKey(), bondCoin, description,
 	)
-
 	SignCheckDeliver(t, gapp, declareCandidacyMsg, []int64{0}, true, priv1)
+
+	ctxDeliver := gapp.BaseApp.NewContext(false, abci.Header{})
+	res1 = gapp.accountMapper.GetAccount(ctxDeliver, addr1)
+	require.Equal(t, genCoins.Minus(sdk.Coins{bondCoin}), res1.GetCoins())
+	candidate, found := gapp.stakeKeeper.GetCandidate(ctxDeliver, addr1)
+	require.True(t, found)
+	require.Equal(t, candidate.Address, addr1)
+
+	// Edit Candidacy
+
+	description = stake.NewDescription("bar_moniker", "", "", "")
+	editCandidacyMsg := stake.NewMsgEditCandidacy(
+		addr1, description,
+	)
+	SignDeliver(t, gapp, editCandidacyMsg, []int64{1}, true, priv1)
+
+	candidate, found = gapp.stakeKeeper.GetCandidate(ctxDeliver, addr1)
+	require.True(t, found)
+	require.Equal(t, candidate.Description, description)
+
+	// Delegate
+
+	delegateMsg := stake.NewMsgDelegate(
+		addr2, addr1, bondCoin,
+	)
+	SignDeliver(t, gapp, delegateMsg, []int64{0}, true, priv2)
+
+	ctxDeliver = gapp.BaseApp.NewContext(false, abci.Header{})
+	res2 = gapp.accountMapper.GetAccount(ctxDeliver, addr2)
+	require.Equal(t, genCoins.Minus(sdk.Coins{bondCoin}), res2.GetCoins())
+	bond, found := gapp.stakeKeeper.GetDelegatorBond(ctxDeliver, addr2, addr1)
+	require.True(t, found)
+	require.Equal(t, bond.DelegatorAddr, addr2)
+
+	// Unbond
+
+	unbondMsg := stake.NewMsgUnbond(
+		addr2, addr1, "MAX",
+	)
+	SignDeliver(t, gapp, unbondMsg, []int64{1}, true, priv2)
+
+	ctxDeliver = gapp.BaseApp.NewContext(false, abci.Header{})
+	res2 = gapp.accountMapper.GetAccount(ctxDeliver, addr2)
+	require.Equal(t, genCoins, res2.GetCoins())
+	_, found = gapp.stakeKeeper.GetDelegatorBond(ctxDeliver, addr2, addr1)
+	require.False(t, found)
 }
 
 //____________________________________________________________________________________
@@ -452,6 +499,7 @@ func SignCheckDeliver(t *testing.T, gapp *GaiaApp, msg sdk.Msg, seq []int64, exp
 
 	// Sign the tx
 	tx := genTx(msg, seq, priv...)
+
 	// Run a Check
 	res := gapp.Check(tx)
 	if expPass {
@@ -469,5 +517,27 @@ func SignCheckDeliver(t *testing.T, gapp *GaiaApp, msg sdk.Msg, seq []int64, exp
 		require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
 	}
 	gapp.EndBlock(abci.RequestEndBlock{})
+
+	// XXX fix code or add explaination as to why using commit breaks a bunch of these tests
 	//gapp.Commit()
 }
+
+// XXX the only reason we are using Sign Deliver here is because the tests
+// break on check tx the second time you use SignCheckDeliver in a test because
+// the checktx state has not been updated likely because commit is not being
+// called!
+func SignDeliver(t *testing.T, gapp *GaiaApp, msg sdk.Msg, seq []int64, expPass bool, priv ...crypto.PrivKeyEd25519) {
+
+	// Sign the tx
+	tx := genTx(msg, seq, priv...)
+
+	// Simulate a Block
+	gapp.BeginBlock(abci.RequestBeginBlock{})
+	res := gapp.Deliver(tx)
+	if expPass {
+		require.Equal(t, sdk.CodeOK, res.Code, res.Log)
+	} else {
+		require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
+	}
+	gapp.EndBlock(abci.RequestEndBlock{})
+}
diff --git a/types/result.go b/types/result.go
index 7b0c1a593..f4f7454e2 100644
--- a/types/result.go
+++ b/types/result.go
@@ -20,7 +20,7 @@ type Result struct {
 	// GasWanted is the maximum units of work we allow this tx to perform.
 	GasWanted int64
 
-	// GasUsed is the amount of gas actually consumed. NOTE: not used.
+	// GasUsed is the amount of gas actually consumed. NOTE: unimplemented
 	GasUsed int64
 
 	// Tx fee amount and denom.
diff --git a/x/stake/handler.go b/x/stake/handler.go
index 36b4509da..cf36cf10a 100644
--- a/x/stake/handler.go
+++ b/x/stake/handler.go
@@ -105,9 +105,6 @@ func handleMsgEditCandidacy(ctx sdk.Context, msg MsgEditCandidacy, k Keeper) sdk
 			GasUsed: GasEditCandidacy,
 		}
 	}
-	if candidate.Status == Unbonded { //candidate has been withdrawn
-		return ErrBondNotNominated(k.codespace).Result()
-	}
 
 	// XXX move to types
 	// replace all editable fields (clients should autofill existing values)
@@ -149,7 +146,7 @@ func delegate(ctx sdk.Context, k Keeper, delegatorAddr sdk.Address,
 	bondAmt sdk.Coin, candidate Candidate) sdk.Error {
 
 	// Get or create the delegator bond
-	bond, found := k.getDelegatorBond(ctx, delegatorAddr, candidate.Address)
+	bond, found := k.GetDelegatorBond(ctx, delegatorAddr, candidate.Address)
 	if !found {
 		bond = DelegatorBond{
 			DelegatorAddr: delegatorAddr,
@@ -176,7 +173,7 @@ func delegate(ctx sdk.Context, k Keeper, delegatorAddr sdk.Address,
 func handleMsgUnbond(ctx sdk.Context, msg MsgUnbond, k Keeper) sdk.Result {
 
 	// check if bond has any shares in it unbond
-	bond, found := k.getDelegatorBond(ctx, msg.DelegatorAddr, msg.CandidateAddr)
+	bond, found := k.GetDelegatorBond(ctx, msg.DelegatorAddr, msg.CandidateAddr)
 	if !found {
 		return ErrNoDelegatorForAddress(k.codespace).Result()
 	}
@@ -184,11 +181,7 @@ func handleMsgUnbond(ctx sdk.Context, msg MsgUnbond, k Keeper) sdk.Result {
 		return ErrInsufficientFunds(k.codespace).Result()
 	}
 
-	// test getting rational number from decimal provided
-	shares, err := sdk.NewRatFromDecimal(msg.Shares)
-	if err != nil {
-		return err.Result()
-	}
+	var shares sdk.Rat
 
 	// test that there are enough shares to unbond
 	if msg.Shares == "MAX" {
@@ -196,6 +189,11 @@ func handleMsgUnbond(ctx sdk.Context, msg MsgUnbond, k Keeper) sdk.Result {
 			return ErrNotEnoughBondShares(k.codespace, msg.Shares).Result()
 		}
 	} else {
+		var err sdk.Error
+		shares, err = sdk.NewRatFromDecimal(msg.Shares)
+		if err != nil {
+			return err.Result()
+		}
 		if bond.Shares.LT(shares) {
 			return ErrNotEnoughBondShares(k.codespace, msg.Shares).Result()
 		}
diff --git a/x/stake/handler_test.go b/x/stake/handler_test.go
index 82b33cf2c..00ec07712 100644
--- a/x/stake/handler_test.go
+++ b/x/stake/handler_test.go
@@ -92,7 +92,7 @@ func TestIncrementsMsgDelegate(t *testing.T) {
 		//Check that the accounts and the bond account have the appropriate values
 		candidate, found := keeper.GetCandidate(ctx, candidateAddr)
 		require.True(t, found)
-		bond, found := keeper.getDelegatorBond(ctx, delegatorAddr, candidateAddr)
+		bond, found := keeper.GetDelegatorBond(ctx, delegatorAddr, candidateAddr)
 		require.True(t, found)
 
 		expBond := int64(i+1) * bondAmount
@@ -148,7 +148,7 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 		//Check that the accounts and the bond account have the appropriate values
 		candidate, found = keeper.GetCandidate(ctx, candidateAddr)
 		require.True(t, found)
-		bond, found := keeper.getDelegatorBond(ctx, delegatorAddr, candidateAddr)
+		bond, found := keeper.GetDelegatorBond(ctx, delegatorAddr, candidateAddr)
 		require.True(t, found)
 
 		expBond := initBond - int64(i+1)*unbondShares
@@ -263,7 +263,7 @@ func TestMultipleMsgDelegate(t *testing.T) {
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
 
 		//Check that the account is bonded
-		bond, found := keeper.getDelegatorBond(ctx, delegatorAddr, candidateAddr)
+		bond, found := keeper.GetDelegatorBond(ctx, delegatorAddr, candidateAddr)
 		require.True(t, found)
 		require.NotNil(t, bond, "expected delegatee bond %d to exist", bond)
 	}
@@ -275,7 +275,7 @@ func TestMultipleMsgDelegate(t *testing.T) {
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
 
 		//Check that the account is unbonded
-		_, found := keeper.getDelegatorBond(ctx, delegatorAddr, candidateAddr)
+		_, found := keeper.GetDelegatorBond(ctx, delegatorAddr, candidateAddr)
 		require.False(t, found)
 	}
 }
diff --git a/x/stake/keeper.go b/x/stake/keeper.go
index 8b73e81db..c2b054eba 100644
--- a/x/stake/keeper.go
+++ b/x/stake/keeper.go
@@ -297,7 +297,8 @@ func (k Keeper) clearAccUpdateValidators(ctx sdk.Context) {
 
 //_____________________________________________________________________
 
-func (k Keeper) getDelegatorBond(ctx sdk.Context,
+// load a delegator bong
+func (k Keeper) GetDelegatorBond(ctx sdk.Context,
 	delegatorAddr, candidateAddr sdk.Address) (bond DelegatorBond, found bool) {
 
 	store := ctx.KVStore(k.storeKey)
@@ -314,7 +315,7 @@ func (k Keeper) getDelegatorBond(ctx sdk.Context,
 }
 
 // load all bonds of a delegator
-func (k Keeper) getDelegatorBonds(ctx sdk.Context, delegator sdk.Address, maxRetrieve int16) (bonds []DelegatorBond) {
+func (k Keeper) GetDelegatorBonds(ctx sdk.Context, delegator sdk.Address, maxRetrieve int16) (bonds []DelegatorBond) {
 	store := ctx.KVStore(k.storeKey)
 	delegatorPrefixKey := GetDelegatorBondsKey(delegator, k.cdc)
 	iterator := store.Iterator(subspace(delegatorPrefixKey)) //smallest to largest
diff --git a/x/stake/keeper_test.go b/x/stake/keeper_test.go
index e8d8e0594..9d6f69cc6 100644
--- a/x/stake/keeper_test.go
+++ b/x/stake/keeper_test.go
@@ -127,19 +127,19 @@ func TestBond(t *testing.T) {
 	}
 
 	// check the empty keeper first
-	_, found := keeper.getDelegatorBond(ctx, addrDels[0], addrVals[0])
+	_, found := keeper.GetDelegatorBond(ctx, addrDels[0], addrVals[0])
 	assert.False(t, found)
 
 	// set and retrieve a record
 	keeper.setDelegatorBond(ctx, bond1to1)
-	resBond, found := keeper.getDelegatorBond(ctx, addrDels[0], addrVals[0])
+	resBond, found := keeper.GetDelegatorBond(ctx, addrDels[0], addrVals[0])
 	assert.True(t, found)
 	assert.True(t, bondsEqual(bond1to1, resBond))
 
 	// modify a records, save, and retrieve
 	bond1to1.Shares = sdk.NewRat(99)
 	keeper.setDelegatorBond(ctx, bond1to1)
-	resBond, found = keeper.getDelegatorBond(ctx, addrDels[0], addrVals[0])
+	resBond, found = keeper.GetDelegatorBond(ctx, addrDels[0], addrVals[0])
 	assert.True(t, found)
 	assert.True(t, bondsEqual(bond1to1, resBond))
 
@@ -158,16 +158,16 @@ func TestBond(t *testing.T) {
 	keeper.setDelegatorBond(ctx, bond2to3)
 
 	// test all bond retrieve capabilities
-	resBonds := keeper.getDelegatorBonds(ctx, addrDels[0], 5)
+	resBonds := keeper.GetDelegatorBonds(ctx, addrDels[0], 5)
 	require.Equal(t, 3, len(resBonds))
 	assert.True(t, bondsEqual(bond1to1, resBonds[0]))
 	assert.True(t, bondsEqual(bond1to2, resBonds[1]))
 	assert.True(t, bondsEqual(bond1to3, resBonds[2]))
-	resBonds = keeper.getDelegatorBonds(ctx, addrDels[0], 3)
+	resBonds = keeper.GetDelegatorBonds(ctx, addrDels[0], 3)
 	require.Equal(t, 3, len(resBonds))
-	resBonds = keeper.getDelegatorBonds(ctx, addrDels[0], 2)
+	resBonds = keeper.GetDelegatorBonds(ctx, addrDels[0], 2)
 	require.Equal(t, 2, len(resBonds))
-	resBonds = keeper.getDelegatorBonds(ctx, addrDels[1], 5)
+	resBonds = keeper.GetDelegatorBonds(ctx, addrDels[1], 5)
 	require.Equal(t, 3, len(resBonds))
 	assert.True(t, bondsEqual(bond2to1, resBonds[0]))
 	assert.True(t, bondsEqual(bond2to2, resBonds[1]))
@@ -175,9 +175,9 @@ func TestBond(t *testing.T) {
 
 	// delete a record
 	keeper.removeDelegatorBond(ctx, bond2to3)
-	_, found = keeper.getDelegatorBond(ctx, addrDels[1], addrVals[2])
+	_, found = keeper.GetDelegatorBond(ctx, addrDels[1], addrVals[2])
 	assert.False(t, found)
-	resBonds = keeper.getDelegatorBonds(ctx, addrDels[1], 5)
+	resBonds = keeper.GetDelegatorBonds(ctx, addrDels[1], 5)
 	require.Equal(t, 2, len(resBonds))
 	assert.True(t, bondsEqual(bond2to1, resBonds[0]))
 	assert.True(t, bondsEqual(bond2to2, resBonds[1]))
@@ -185,11 +185,11 @@ func TestBond(t *testing.T) {
 	// delete all the records from delegator 2
 	keeper.removeDelegatorBond(ctx, bond2to1)
 	keeper.removeDelegatorBond(ctx, bond2to2)
-	_, found = keeper.getDelegatorBond(ctx, addrDels[1], addrVals[0])
+	_, found = keeper.GetDelegatorBond(ctx, addrDels[1], addrVals[0])
 	assert.False(t, found)
-	_, found = keeper.getDelegatorBond(ctx, addrDels[1], addrVals[1])
+	_, found = keeper.GetDelegatorBond(ctx, addrDels[1], addrVals[1])
 	assert.False(t, found)
-	resBonds = keeper.getDelegatorBonds(ctx, addrDels[1], 5)
+	resBonds = keeper.GetDelegatorBonds(ctx, addrDels[1], 5)
 	require.Equal(t, 0, len(resBonds))
 }
 

From 068ca5e3e6318e109248bd797892ef8320bab7a8 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Wed, 11 Apr 2018 11:58:11 -0400
Subject: [PATCH 08/26] fix gaia init genesis creation

int

int
---
 cmd/gaia/app/app.go        | 22 ++++++++++++++++++++++
 cmd/gaia/cmd/gaiad/main.go | 12 ++++++------
 2 files changed, 28 insertions(+), 6 deletions(-)

diff --git a/cmd/gaia/app/app.go b/cmd/gaia/app/app.go
index 0fa4f4181..792a6bbd9 100644
--- a/cmd/gaia/app/app.go
+++ b/cmd/gaia/app/app.go
@@ -179,3 +179,25 @@ func (ga *GenesisAccount) ToAccount() (acc *auth.BaseAccount) {
 		Coins:   ga.Coins.Sort(),
 	}
 }
+
+// DefaultGenAppState expects two args: an account address
+// and a coin denomination, and gives lots of coins to that address.
+func DefaultGenAppState(args []string, addr sdk.Address, coinDenom string) (json.RawMessage, error) {
+
+	accAuth := auth.NewBaseAccountWithAddress(addr)
+	accAuth.Coins = sdk.Coins{{"fermion", 100000}}
+	acc := NewGenesisAccount(&accAuth)
+	genaccs := []GenesisAccount{acc}
+
+	genesisState := GenesisState{
+		Accounts:  genaccs,
+		StakeData: stake.GetGenesisJSON(),
+	}
+
+	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
+	if err != nil {
+		return nil, err
+	}
+
+	return stateBytes, nil
+}
diff --git a/cmd/gaia/cmd/gaiad/main.go b/cmd/gaia/cmd/gaiad/main.go
index f966c446a..b84a4e20d 100644
--- a/cmd/gaia/cmd/gaiad/main.go
+++ b/cmd/gaia/cmd/gaiad/main.go
@@ -40,22 +40,22 @@ func generateApp(rootDir string, logger log.Logger) (abci.Application, error) {
 	//if err != nil {
 	//return nil, err
 	//}
-	//dbStaking, err := dbm.NewGoLevelDB("gaia-staking", dataDir)
+	//dbStake, err := dbm.NewGoLevelDB("gaia-stake", dataDir)
 	//if err != nil {
 	//return nil, err
 	//}
 	//dbs := map[string]dbm.DB{
-	//"main":    dbMain,
-	//"acc":     dbAcc,
-	//"ibc":     dbIBC,
-	//"staking": dbStaking,
+	//"main":  dbMain,
+	//"acc":   dbAcc,
+	//"ibc":   dbIBC,
+	//"stake": dbStake,
 	//}
 	//bapp := app.NewGaiaApp(logger, dbs)
 	return bapp, nil
 }
 
 func main() {
-	server.AddCommands(rootCmd, server.DefaultGenAppState, generateApp, context)
+	server.AddCommands(rootCmd, app.DefaultGenAppState, generateApp, context)
 
 	// prepare and add flags
 	rootDir := os.ExpandEnv("$HOME/.gaiad")

From 996cafe97223c6bda8e24f6e19e2837d4d393245 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Wed, 11 Apr 2018 13:27:36 -0400
Subject: [PATCH 09/26] register wire, stake changelog, stake genesis update

---
 CHANGELOG.md             |  5 +++++
 cmd/gaia/app/app.go      | 18 +++++++-----------
 cmd/gaia/app/app_test.go |  2 +-
 x/bank/wire.go           |  5 ++---
 x/ibc/wire.go            |  4 ++--
 x/stake/handler.go       | 12 +++---------
 x/stake/handler_test.go  |  9 ---------
 x/stake/test_common.go   | 27 +++++----------------------
 x/stake/wire.go          |  9 +++++----
 9 files changed, 30 insertions(+), 61 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 873824c48..2cfbe82dd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,7 +16,12 @@ BREAKING CHANGES
 * All module keepers now require a codespace, see basecoin or democoin for usage
 
 BUG FIXES
+* Gaia now uses stake, ported from github.com/cosmos/gaia
 
+FEATURES:
+
+* Add CacheContext
+* Gaia stake commands include, DeclareCandidacy, EditCandidacy, Delegate, Unbond
 * MountStoreWithDB without providing a custom store works.
 
 ## 0.14.1 (April 9, 2018)
diff --git a/cmd/gaia/app/app.go b/cmd/gaia/app/app.go
index 792a6bbd9..eeb64a7a7 100644
--- a/cmd/gaia/app/app.go
+++ b/cmd/gaia/app/app.go
@@ -92,14 +92,10 @@ func MakeCodec() *wire.Codec {
 
 	// Register Msgs
 	cdc.RegisterInterface((*sdk.Msg)(nil), nil)
-	cdc.RegisterConcrete(bank.SendMsg{}, "gaia/Send", nil)
-	cdc.RegisterConcrete(bank.IssueMsg{}, "gaia/Issue", nil)
-	cdc.RegisterConcrete(ibc.IBCTransferMsg{}, "gaia/IBCTransferMsg", nil)
-	cdc.RegisterConcrete(ibc.IBCReceiveMsg{}, "gaia/IBCReceiveMsg", nil)
-	cdc.RegisterConcrete(stake.MsgDeclareCandidacy{}, "gaia/MsgDeclareCandidacy", nil)
-	cdc.RegisterConcrete(stake.MsgEditCandidacy{}, "gaia/MsgEditCandidacy", nil)
-	cdc.RegisterConcrete(stake.MsgDelegate{}, "gaia/MsgDelegate", nil)
-	cdc.RegisterConcrete(stake.MsgUnbond{}, "gaia/MsgUnbond", nil)
+
+	ibc.RegisterWire(cdc)
+	bank.RegisterWire(cdc)
+	stake.RegisterWire(cdc)
 
 	// Register AppAccount
 	cdc.RegisterInterface((*sdk.Account)(nil), nil)
@@ -155,8 +151,8 @@ func (app *GaiaApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci
 
 // State to Unmarshal
 type GenesisState struct {
-	Accounts  []GenesisAccount `json:"accounts"`
-	StakeData json.RawMessage  `json:"stake"`
+	Accounts  []GenesisAccount   `json:"accounts"`
+	StakeData stake.GenesisState `json:"stake"`
 }
 
 // GenesisAccount doesn't need pubkey or sequence
@@ -191,7 +187,7 @@ func DefaultGenAppState(args []string, addr sdk.Address, coinDenom string) (json
 
 	genesisState := GenesisState{
 		Accounts:  genaccs,
-		StakeData: stake.GetGenesisJSON(),
+		StakeData: stake.GetDefaultGenesisState(),
 	}
 
 	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
index 4ca1cd959..ea10cebc5 100644
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@@ -109,7 +109,7 @@ func setGenesis(gapp *GaiaApp, accs ...*auth.BaseAccount) error {
 
 	genesisState := GenesisState{
 		Accounts:  genaccs,
-		StakeData: stake.GetGenesisJSON(),
+		StakeData: stake.GetDefaultGenesisState(),
 	}
 
 	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
diff --git a/x/bank/wire.go b/x/bank/wire.go
index 846103a52..c53f06564 100644
--- a/x/bank/wire.go
+++ b/x/bank/wire.go
@@ -6,7 +6,6 @@ import (
 
 // Register concrete types on wire codec
 func RegisterWire(cdc *wire.Codec) {
-	// TODO include option to always include prefix bytes.
-	//cdc.RegisterConcrete(SendMsg{}, "github.com/cosmos/cosmos-sdk/bank/SendMsg", nil)
-	//cdc.RegisterConcrete(IssueMsg{}, "github.com/cosmos/cosmos-sdk/bank/IssueMsg", nil)
+	cdc.RegisterConcrete(SendMsg{}, "cosmos-sdk/Send", nil)
+	cdc.RegisterConcrete(IssueMsg{}, "cosmos-sdk/Issue", nil)
 }
diff --git a/x/ibc/wire.go b/x/ibc/wire.go
index 91e6d88bb..f5644acc5 100644
--- a/x/ibc/wire.go
+++ b/x/ibc/wire.go
@@ -6,6 +6,6 @@ import (
 
 // Register concrete types on wire codec
 func RegisterWire(cdc *wire.Codec) {
-	//cdc.RegisterConcrete(IBCTransferMsg{}, "github.com/cosmos/cosmos-sdk/x/ibc/IBCTransferMsg", nil)
-	//cdc.RegisterConcrete(IBCReceiveMsg{}, "github.com/cosmos/cosmos-sdk/x/ibc/IBCReceiveMsg", nil)
+	cdc.RegisterConcrete(IBCTransferMsg{}, "cosmos-sdk/IBCTransferMsg", nil)
+	cdc.RegisterConcrete(IBCReceiveMsg{}, "cosmos-sdk/IBCReceiveMsg", nil)
 }
diff --git a/x/stake/handler.go b/x/stake/handler.go
index cf36cf10a..84eeca3c4 100644
--- a/x/stake/handler.go
+++ b/x/stake/handler.go
@@ -2,7 +2,6 @@ package stake
 
 import (
 	"bytes"
-	"encoding/json"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	abci "github.com/tendermint/abci/types"
@@ -50,14 +49,9 @@ func NewEndBlocker(k Keeper) sdk.EndBlocker {
 //_____________________________________________________________________
 
 // InitGenesis - store genesis parameters
-func InitGenesis(ctx sdk.Context, k Keeper, data json.RawMessage) error {
-	var state GenesisState
-	if err := json.Unmarshal(data, &state); err != nil {
-		return err
-	}
-	k.setPool(ctx, state.Pool)
-	k.setParams(ctx, state.Params)
-	return nil
+func InitGenesis(ctx sdk.Context, k Keeper, data GenesisState) {
+	k.setPool(ctx, data.Pool)
+	k.setParams(ctx, data.Params)
 }
 
 //_____________________________________________________________________
diff --git a/x/stake/handler_test.go b/x/stake/handler_test.go
index 00ec07712..538c664e9 100644
--- a/x/stake/handler_test.go
+++ b/x/stake/handler_test.go
@@ -12,15 +12,6 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func TestInitGenesis(t *testing.T) {
-	ctx, _, keeper := createTestInput(t, false, 0)
-	encoded := GetGenesisJSON()
-	err := InitGenesis(ctx, keeper, encoded)
-	require.Nil(t, err)
-	require.Equal(t, keeper.GetPool(ctx), initialPool())
-	require.Equal(t, keeper.GetParams(ctx), defaultParams())
-}
-
 //______________________________________________________________________
 
 func newTestMsgDeclareCandidacy(address sdk.Address, pubKey crypto.PubKey, amt int64) MsgDeclareCandidacy {
diff --git a/x/stake/test_common.go b/x/stake/test_common.go
index 5b0bc97e0..75781777a 100644
--- a/x/stake/test_common.go
+++ b/x/stake/test_common.go
@@ -2,7 +2,6 @@ package stake
 
 import (
 	"encoding/hex"
-	"encoding/json"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -77,27 +76,11 @@ func initialPool() Pool {
 }
 
 // get raw genesis raw message for testing
-func GetGenesisJSON() json.RawMessage {
-	jsonStr := `{
-  "params": {
-    "inflation_rate_change": {"num": 13, "denom": 100},
-    "inflation_max": {"num": 20, "denom": 100}, 
-    "inflation_min": {"num": 7, "denom": 100}, 
-    "goal_bonded": {"num": 67, "denom": 100}, 
-    "max_validators": 100,
-    "bond_denom": "fermion"
-  },
-  "pool": {
-    "total_supply": 0,
-    "bonded_shares": {"num": 0, "denom": 1}, 
-    "unbonded_shares": {"num": 0, "denom": 1}, 
-    "bonded_pool": 0,
-    "unbonded_pool": 0,
-    "inflation_last_time": 0,
-    "inflation": {"num": 7, "denom": 100}
-  }
-}`
-	return json.RawMessage(jsonStr)
+func GetDefaultGenesisState() GenesisState {
+	return GenesisState{
+		Pool:   initialPool(),
+		Params: defaultParams(),
+	}
 }
 
 // XXX reference the common declaration of this function
diff --git a/x/stake/wire.go b/x/stake/wire.go
index f444ce14e..e99c621fa 100644
--- a/x/stake/wire.go
+++ b/x/stake/wire.go
@@ -4,9 +4,10 @@ import (
 	"github.com/cosmos/cosmos-sdk/wire"
 )
 
-// TODO complete when go-amino is ported
+// Register concrete types on wire codec
 func RegisterWire(cdc *wire.Codec) {
-	// TODO include option to always include prefix bytes.
-	//cdc.RegisterConcrete(SendMsg{}, "cosmos-sdk/SendMsg", nil)
-	//cdc.RegisterConcrete(IssueMsg{}, "cosmos-sdk/IssueMsg", nil)
+	cdc.RegisterConcrete(MsgDeclareCandidacy{}, "cosmos-sdk/MsgDeclareCandidacy", nil)
+	cdc.RegisterConcrete(MsgEditCandidacy{}, "cosmos-sdk/MsgEditCandidacy", nil)
+	cdc.RegisterConcrete(MsgDelegate{}, "cosmos-sdk/MsgDelegate", nil)
+	cdc.RegisterConcrete(MsgUnbond{}, "cosmos-sdk/MsgUnbond", nil)
 }

From 8ab77e2ab5cea35f144103ef1c343d9183be450a Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Thu, 12 Apr 2018 22:51:14 -0400
Subject: [PATCH 10/26] started gaia go-bash cli testing

---
 cmd/gaia/cmd/app_test.go | 42 ++++++++++++++++++++++++++++++++++
 tests/gobash.go          | 49 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 91 insertions(+)
 create mode 100644 cmd/gaia/cmd/app_test.go
 create mode 100644 tests/gobash.go

diff --git a/cmd/gaia/cmd/app_test.go b/cmd/gaia/cmd/app_test.go
new file mode 100644
index 000000000..98cf2a0d2
--- /dev/null
+++ b/cmd/gaia/cmd/app_test.go
@@ -0,0 +1,42 @@
+package common
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/tests"
+)
+
+func TestGaiaCLI(t *testing.T) {
+
+	_, out := tests.ExecuteT(t, "gaiad init")
+	var initRes map[string]interface{}
+	outCut := "{" + strings.SplitN(out, "{", 2)[1]
+	err := json.Unmarshal([]byte(outCut), &initRes)
+	require.NoError(t, err, "out %v outCut %v err %v", out, outCut, err)
+	masterKey := (initRes["secret"]).(string)
+	_ = masterKey
+
+	//wc1, _ := tests.GoExecuteT(t, "gaiacli keys add foo --recover")
+	//time.Sleep(time.Second)
+	//_, err = wc1.Write([]byte("1234567890\n"))
+	//time.Sleep(time.Second)
+	//_, err = wc1.Write([]byte(masterKey + "\n"))
+	//time.Sleep(time.Second)
+	//out = <-outChan
+	//wc1.Close()
+	//fmt.Println(out)
+
+	//_, out = tests.ExecuteT(t, "gaiacli keys show foo")
+	//fooAddr := strings.TrimLeft(out, "foo\t")
+
+	//wc2, _ := tests.GoExecuteT(t, "gaiad start")
+	//defer wc2.Close()
+	//time.Sleep(time.Second)
+
+	//_, out = tests.ExecuteT(t, fmt.Sprintf("gaiacli account %v", fooAddr))
+	//fmt.Println(fooAddr)
+}
diff --git a/tests/gobash.go b/tests/gobash.go
new file mode 100644
index 000000000..edef7ccd5
--- /dev/null
+++ b/tests/gobash.go
@@ -0,0 +1,49 @@
+package tests
+
+import (
+	"io"
+	"os/exec"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func getCmd(t *testing.T, command string) *exec.Cmd {
+
+	//split command into command and args
+	split := strings.Split(command, " ")
+	require.True(t, len(split) > 0, "no command provided")
+
+	var cmd *exec.Cmd
+	if len(split) == 1 {
+		cmd = exec.Command(split[0])
+	} else {
+		cmd = exec.Command(split[0], split[1:]...)
+	}
+	return cmd
+}
+
+// Execute the command, return standard output and error
+func ExecuteT(t *testing.T, command string) (pipe io.WriteCloser, out string) {
+	cmd := getCmd(t, command)
+	pipe, err := cmd.StdinPipe()
+	require.NoError(t, err)
+	bz, err := cmd.CombinedOutput()
+	require.NoError(t, err)
+	out = strings.Trim(string(bz), "\n") //trim any new lines
+	return pipe, out
+}
+
+// Asynchronously execute the command, return standard output and error
+func GoExecuteT(t *testing.T, command string) (pipe io.WriteCloser, outChan chan string) {
+	cmd := getCmd(t, command)
+	pipe, err := cmd.StdinPipe()
+	require.NoError(t, err)
+	go func() {
+		bz, err := cmd.CombinedOutput()
+		require.NoError(t, err)
+		outChan <- strings.Trim(string(bz), "\n") //trim any new lines
+	}()
+	return pipe, outChan
+}

From 3ab032e1c671e885b9d2d48260b9518b9216b131 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Fri, 13 Apr 2018 16:08:06 -0400
Subject: [PATCH 11/26] cli testing

---
 cmd/gaia/cmd/app_test.go | 42 --------------------
 cmd/gaia/cmd/cli_test.go | 83 ++++++++++++++++++++++++++++++++++++++++
 tests/gobash.go          | 25 ++++++------
 3 files changed, 97 insertions(+), 53 deletions(-)
 delete mode 100644 cmd/gaia/cmd/app_test.go
 create mode 100644 cmd/gaia/cmd/cli_test.go

diff --git a/cmd/gaia/cmd/app_test.go b/cmd/gaia/cmd/app_test.go
deleted file mode 100644
index 98cf2a0d2..000000000
--- a/cmd/gaia/cmd/app_test.go
+++ /dev/null
@@ -1,42 +0,0 @@
-package common
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/cosmos/cosmos-sdk/tests"
-)
-
-func TestGaiaCLI(t *testing.T) {
-
-	_, out := tests.ExecuteT(t, "gaiad init")
-	var initRes map[string]interface{}
-	outCut := "{" + strings.SplitN(out, "{", 2)[1]
-	err := json.Unmarshal([]byte(outCut), &initRes)
-	require.NoError(t, err, "out %v outCut %v err %v", out, outCut, err)
-	masterKey := (initRes["secret"]).(string)
-	_ = masterKey
-
-	//wc1, _ := tests.GoExecuteT(t, "gaiacli keys add foo --recover")
-	//time.Sleep(time.Second)
-	//_, err = wc1.Write([]byte("1234567890\n"))
-	//time.Sleep(time.Second)
-	//_, err = wc1.Write([]byte(masterKey + "\n"))
-	//time.Sleep(time.Second)
-	//out = <-outChan
-	//wc1.Close()
-	//fmt.Println(out)
-
-	//_, out = tests.ExecuteT(t, "gaiacli keys show foo")
-	//fooAddr := strings.TrimLeft(out, "foo\t")
-
-	//wc2, _ := tests.GoExecuteT(t, "gaiad start")
-	//defer wc2.Close()
-	//time.Sleep(time.Second)
-
-	//_, out = tests.ExecuteT(t, fmt.Sprintf("gaiacli account %v", fooAddr))
-	//fmt.Println(fooAddr)
-}
diff --git a/cmd/gaia/cmd/cli_test.go b/cmd/gaia/cmd/cli_test.go
new file mode 100644
index 000000000..db5e272c1
--- /dev/null
+++ b/cmd/gaia/cmd/cli_test.go
@@ -0,0 +1,83 @@
+package common
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/tests"
+)
+
+func TestGaiaCLI(t *testing.T) {
+
+	// clear genesis/keys
+	_ = tests.ExecuteT(t, "gaiad unsafe_reset_all")
+	_, wc0, _ := tests.GoExecuteT(t, "gaiacli keys delete foo")
+	defer wc0.Close()
+	_, err := wc0.Write([]byte("1234567890\n"))
+	require.NoError(t, err)
+	_, wc1, _ := tests.GoExecuteT(t, "gaiacli keys delete bar")
+	defer wc1.Close()
+	_, err = wc1.Write([]byte("1234567890\n"))
+	require.NoError(t, err)
+	time.Sleep(time.Second)
+
+	// init genesis get master key
+	out := tests.ExecuteT(t, "gaiad init")
+	var initRes map[string]interface{}
+	outCut := "{" + strings.SplitN(out, "{", 2)[1]
+	err = json.Unmarshal([]byte(outCut), &initRes)
+	require.NoError(t, err, "out %v outCut %v err %v", out, outCut, err)
+	masterKey := (initRes["secret"]).(string)
+	chainID := (initRes["chain_id"]).(string)
+
+	// start gaiad server
+	_, wc2, _ := tests.GoExecuteT(t, "gaiad start")
+	defer wc2.Close()
+	time.Sleep(time.Second)
+
+	// add the master key
+	_, wc3, _ := tests.GoExecuteT(t, "gaiacli keys add foo --recover")
+	defer wc3.Close()
+	_, err = wc3.Write([]byte("1234567890\n"))
+	require.NoError(t, err)
+	_, err = wc3.Write([]byte(masterKey + "\n"))
+	require.NoError(t, err)
+	time.Sleep(time.Second)
+
+	// add a secondary key
+	_, wc4, _ := tests.GoExecuteT(t, "gaiacli keys add bar")
+	time.Sleep(time.Second * 5)
+	_, err = wc4.Write([]byte("1234567890\n"))
+	require.NoError(t, err)
+	time.Sleep(time.Second * 5)
+
+	// get addresses
+	out = tests.ExecuteT(t, "gaiacli keys show foo")
+	fooAddr := strings.TrimLeft(out, "foo\t")
+	out = tests.ExecuteT(t, "gaiacli keys show bar")
+	barAddr := strings.TrimLeft(out, "bar\t")
+	fmt.Printf("debug barAddr: %v\n", barAddr)
+
+	// send money from foo to bar
+	cmdStr := fmt.Sprintf("gaiacli send --sequence=0 --chain-id=%v --amount=10fermion --to=%v --name=foo", chainID, barAddr)
+	_, wc5, rc5 := tests.GoExecuteT(t, cmdStr)
+	_, err = wc5.Write([]byte("1234567890\n"))
+	require.NoError(t, err)
+	fmt.Printf("debug outCh: %v\n", out)
+	time.Sleep(time.Second)
+	bz := make([]byte, 1000000)
+	rc5.Read(bz)
+	fmt.Printf("debug ex: %v\n", string(bz))
+
+	// verify money sent to bar
+	time.Sleep(time.Second)
+	out = tests.ExecuteT(t, fmt.Sprintf("gaiacli account %v", fooAddr))
+	fmt.Printf("debug out: %v\n", out)
+	out = tests.ExecuteT(t, fmt.Sprintf("gaiacli account %v", barAddr))
+	require.Fail(t, "debug out: %v\n", out)
+}
diff --git a/tests/gobash.go b/tests/gobash.go
index edef7ccd5..8095a7d90 100644
--- a/tests/gobash.go
+++ b/tests/gobash.go
@@ -2,6 +2,7 @@ package tests
 
 import (
 	"io"
+	"os"
 	"os/exec"
 	"strings"
 	"testing"
@@ -25,25 +26,27 @@ func getCmd(t *testing.T, command string) *exec.Cmd {
 }
 
 // Execute the command, return standard output and error
-func ExecuteT(t *testing.T, command string) (pipe io.WriteCloser, out string) {
+func ExecuteT(t *testing.T, command string) (out string) {
 	cmd := getCmd(t, command)
-	pipe, err := cmd.StdinPipe()
-	require.NoError(t, err)
 	bz, err := cmd.CombinedOutput()
-	require.NoError(t, err)
+	require.NoError(t, err, string(bz))
 	out = strings.Trim(string(bz), "\n") //trim any new lines
-	return pipe, out
+	return out
 }
 
 // Asynchronously execute the command, return standard output and error
-func GoExecuteT(t *testing.T, command string) (pipe io.WriteCloser, outChan chan string) {
+func GoExecuteT(t *testing.T, command string) (proc *os.Process, pipeIn io.WriteCloser, pipeOut io.ReadCloser) {
 	cmd := getCmd(t, command)
-	pipe, err := cmd.StdinPipe()
+	pipeIn, err := cmd.StdinPipe()
 	require.NoError(t, err)
+	pipeOut, err = cmd.StdoutPipe()
+	require.NoError(t, err)
+
 	go func() {
-		bz, err := cmd.CombinedOutput()
-		require.NoError(t, err)
-		outChan <- strings.Trim(string(bz), "\n") //trim any new lines
+		cmd.Start()
+		//bz, _ := cmd.CombinedOutput()
+		//require.NoError(t, err, string(bz))
+		//outChan <- strings.Trim(string(bz), "\n") //trim any new lines
 	}()
-	return pipe, outChan
+	return nil, pipeIn, pipeOut
 }

From ebb2faabe07576584fd416ae2af6d6ee14947409 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Fri, 13 Apr 2018 19:45:26 -0400
Subject: [PATCH 12/26] go-bash working

---
 cmd/gaia/cmd/cli_test.go | 92 +++++++++++++++++++++++-----------------
 tests/gobash.go          | 10 +++--
 2 files changed, 58 insertions(+), 44 deletions(-)

diff --git a/cmd/gaia/cmd/cli_test.go b/cmd/gaia/cmd/cli_test.go
index db5e272c1..6d3e9db11 100644
--- a/cmd/gaia/cmd/cli_test.go
+++ b/cmd/gaia/cmd/cli_test.go
@@ -3,81 +3,93 @@ package common
 import (
 	"encoding/json"
 	"fmt"
+	"io"
 	"strings"
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/cosmos/cosmos-sdk/server"
 	"github.com/cosmos/cosmos-sdk/tests"
+	"github.com/cosmos/cosmos-sdk/x/auth"
 )
 
+func password(t *testing.T, wc io.WriteCloser) {
+	_, err := wc.Write([]byte("1234567890\n"))
+	require.NoError(t, err)
+}
+
 func TestGaiaCLI(t *testing.T) {
 
 	// clear genesis/keys
-	_ = tests.ExecuteT(t, "gaiad unsafe_reset_all")
-	_, wc0, _ := tests.GoExecuteT(t, "gaiacli keys delete foo")
-	defer wc0.Close()
-	_, err := wc0.Write([]byte("1234567890\n"))
-	require.NoError(t, err)
-	_, wc1, _ := tests.GoExecuteT(t, "gaiacli keys delete bar")
-	defer wc1.Close()
-	_, err = wc1.Write([]byte("1234567890\n"))
-	require.NoError(t, err)
-	time.Sleep(time.Second)
+	tests.ExecuteT(t, "gaiad unsafe_reset_all")
+	cmd, wc0, _ := tests.GoExecuteT(t, "gaiacli keys delete foo")
+	password(t, wc0)
+	cmd.Wait()
+	cmd, wc1, _ := tests.GoExecuteT(t, "gaiacli keys delete bar")
+	password(t, wc1)
+	cmd.Wait()
 
 	// init genesis get master key
 	out := tests.ExecuteT(t, "gaiad init")
 	var initRes map[string]interface{}
-	outCut := "{" + strings.SplitN(out, "{", 2)[1]
-	err = json.Unmarshal([]byte(outCut), &initRes)
+	outCut := "{" + strings.SplitN(out, "{", 2)[1] // weird I'm sorry
+	err := json.Unmarshal([]byte(outCut), &initRes)
 	require.NoError(t, err, "out %v outCut %v err %v", out, outCut, err)
 	masterKey := (initRes["secret"]).(string)
 	chainID := (initRes["chain_id"]).(string)
 
+	servAddr := server.FreeTCPAddr(t)
+	gaiacliFlags := fmt.Sprintf("--node=%v --chain-id=%v", servAddr, chainID)
+
 	// start gaiad server
-	_, wc2, _ := tests.GoExecuteT(t, "gaiad start")
-	defer wc2.Close()
-	time.Sleep(time.Second)
+	cmd, _, _ = tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
+	defer cmd.Process.Kill()
 
 	// add the master key
-	_, wc3, _ := tests.GoExecuteT(t, "gaiacli keys add foo --recover")
-	defer wc3.Close()
-	_, err = wc3.Write([]byte("1234567890\n"))
-	require.NoError(t, err)
+	cmd, wc3, _ := tests.GoExecuteT(t, "gaiacli keys add foo --recover")
+	password(t, wc3)
 	_, err = wc3.Write([]byte(masterKey + "\n"))
 	require.NoError(t, err)
-	time.Sleep(time.Second)
+	cmd.Wait()
 
 	// add a secondary key
-	_, wc4, _ := tests.GoExecuteT(t, "gaiacli keys add bar")
-	time.Sleep(time.Second * 5)
-	_, err = wc4.Write([]byte("1234567890\n"))
-	require.NoError(t, err)
-	time.Sleep(time.Second * 5)
+	cmd, wc4, _ := tests.GoExecuteT(t, "gaiacli keys add bar")
+	password(t, wc4)
+	cmd.Wait()
 
 	// get addresses
 	out = tests.ExecuteT(t, "gaiacli keys show foo")
 	fooAddr := strings.TrimLeft(out, "foo\t")
 	out = tests.ExecuteT(t, "gaiacli keys show bar")
 	barAddr := strings.TrimLeft(out, "bar\t")
-	fmt.Printf("debug barAddr: %v\n", barAddr)
 
 	// send money from foo to bar
-	cmdStr := fmt.Sprintf("gaiacli send --sequence=0 --chain-id=%v --amount=10fermion --to=%v --name=foo", chainID, barAddr)
-	_, wc5, rc5 := tests.GoExecuteT(t, cmdStr)
-	_, err = wc5.Write([]byte("1234567890\n"))
-	require.NoError(t, err)
-	fmt.Printf("debug outCh: %v\n", out)
-	time.Sleep(time.Second)
-	bz := make([]byte, 1000000)
-	rc5.Read(bz)
-	fmt.Printf("debug ex: %v\n", string(bz))
+	cmdStr := fmt.Sprintf("gaiacli send %v --sequence=0 --amount=10fermion --to=%v --name=foo", gaiacliFlags, barAddr)
+	cmd, wc5, _ := tests.GoExecuteT(t, cmdStr)
+	password(t, wc5)
+	cmd.Wait()
+	time.Sleep(time.Second * 3) // waiting for some blocks to pass
 
 	// verify money sent to bar
-	time.Sleep(time.Second)
-	out = tests.ExecuteT(t, fmt.Sprintf("gaiacli account %v", fooAddr))
-	fmt.Printf("debug out: %v\n", out)
-	out = tests.ExecuteT(t, fmt.Sprintf("gaiacli account %v", barAddr))
-	require.Fail(t, "debug out: %v\n", out)
+	out = tests.ExecuteT(t, fmt.Sprintf("gaiacli account %v %v", barAddr, gaiacliFlags))
+	barAcc := unmarshalBaseAccount(t, out)
+	assert.Equal(t, int64(10), barAcc.GetCoins().AmountOf("fermion"))
+
+	out = tests.ExecuteT(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, gaiacliFlags))
+	fooAcc := unmarshalBaseAccount(t, out)
+	assert.Equal(t, int64(99990), fooAcc.GetCoins().AmountOf("fermion"))
+}
+
+func unmarshalBaseAccount(t *testing.T, raw string) auth.BaseAccount {
+	var initRes map[string]json.RawMessage
+	err := json.Unmarshal([]byte(raw), &initRes)
+	require.NoError(t, err, "raw %v, err %v", raw, err)
+	value := initRes["value"]
+	var acc auth.BaseAccount
+	_ = json.Unmarshal(value, &acc) //XXX pubkey can't be decoded go amino issue
+	require.NoError(t, err, "value %v, err %v", string(value), err)
+	return acc
 }
diff --git a/tests/gobash.go b/tests/gobash.go
index 8095a7d90..5a177db94 100644
--- a/tests/gobash.go
+++ b/tests/gobash.go
@@ -2,10 +2,10 @@ package tests
 
 import (
 	"io"
-	"os"
 	"os/exec"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 )
@@ -31,12 +31,13 @@ func ExecuteT(t *testing.T, command string) (out string) {
 	bz, err := cmd.CombinedOutput()
 	require.NoError(t, err, string(bz))
 	out = strings.Trim(string(bz), "\n") //trim any new lines
+	time.Sleep(time.Second)
 	return out
 }
 
 // Asynchronously execute the command, return standard output and error
-func GoExecuteT(t *testing.T, command string) (proc *os.Process, pipeIn io.WriteCloser, pipeOut io.ReadCloser) {
-	cmd := getCmd(t, command)
+func GoExecuteT(t *testing.T, command string) (cmd *exec.Cmd, pipeIn io.WriteCloser, pipeOut io.ReadCloser) {
+	cmd = getCmd(t, command)
 	pipeIn, err := cmd.StdinPipe()
 	require.NoError(t, err)
 	pipeOut, err = cmd.StdoutPipe()
@@ -48,5 +49,6 @@ func GoExecuteT(t *testing.T, command string) (proc *os.Process, pipeIn io.Write
 		//require.NoError(t, err, string(bz))
 		//outChan <- strings.Trim(string(bz), "\n") //trim any new lines
 	}()
-	return nil, pipeIn, pipeOut
+	time.Sleep(time.Second)
+	return cmd, pipeIn, pipeOut
 }

From 59f86b42516d3102459886608968f3a8b6a1ce92 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Sat, 14 Apr 2018 03:16:49 -0400
Subject: [PATCH 13/26] interim borken

---
 cmd/gaia/cmd/cli_test.go | 106 ++++++++++++++++++++-------------------
 tests/gobash.go          |   8 +--
 2 files changed, 56 insertions(+), 58 deletions(-)

diff --git a/cmd/gaia/cmd/cli_test.go b/cmd/gaia/cmd/cli_test.go
index 6d3e9db11..d2e86d7f7 100644
--- a/cmd/gaia/cmd/cli_test.go
+++ b/cmd/gaia/cmd/cli_test.go
@@ -3,7 +3,6 @@ package common
 import (
 	"encoding/json"
 	"fmt"
-	"io"
 	"strings"
 	"testing"
 	"time"
@@ -16,77 +15,82 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth"
 )
 
-func password(t *testing.T, wc io.WriteCloser) {
-	_, err := wc.Write([]byte("1234567890\n"))
-	require.NoError(t, err)
-}
-
 func TestGaiaCLI(t *testing.T) {
 
-	// clear genesis/keys
 	tests.ExecuteT(t, "gaiad unsafe_reset_all")
-	cmd, wc0, _ := tests.GoExecuteT(t, "gaiacli keys delete foo")
-	password(t, wc0)
-	cmd.Wait()
-	cmd, wc1, _ := tests.GoExecuteT(t, "gaiacli keys delete bar")
-	password(t, wc1)
-	cmd.Wait()
-
-	// init genesis get master key
-	out := tests.ExecuteT(t, "gaiad init")
-	var initRes map[string]interface{}
-	outCut := "{" + strings.SplitN(out, "{", 2)[1] // weird I'm sorry
-	err := json.Unmarshal([]byte(outCut), &initRes)
-	require.NoError(t, err, "out %v outCut %v err %v", out, outCut, err)
-	masterKey := (initRes["secret"]).(string)
-	chainID := (initRes["chain_id"]).(string)
+	pass := "1234567890"
+	executeWrite(t, "gaiacli keys delete foo", pass)
+	executeWrite(t, "gaiacli keys delete bar", pass)
+	masterKey, chainID := executeInit(t, "gaiad init")
 
+	// get a free port, also setup some common flags
 	servAddr := server.FreeTCPAddr(t)
-	gaiacliFlags := fmt.Sprintf("--node=%v --chain-id=%v", servAddr, chainID)
+	flags := fmt.Sprintf("--node=%v --chain-id=%v", servAddr, chainID)
 
 	// start gaiad server
-	cmd, _, _ = tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
+	cmd, _, _ := tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
 	defer cmd.Process.Kill()
+	time.Sleep(time.Second) // waiting for some blocks to pass
 
-	// add the master key
+	//executeWrite(t, "gaiacli keys add foo --recover", pass, masterKey)
 	cmd, wc3, _ := tests.GoExecuteT(t, "gaiacli keys add foo --recover")
-	password(t, wc3)
+	time.Sleep(time.Second) // waiting for some blocks to pass
+	_, err := wc3.Write([]byte("1234567890\n"))
+	require.NoError(t, err)
 	_, err = wc3.Write([]byte(masterKey + "\n"))
 	require.NoError(t, err)
 	cmd.Wait()
+	time.Sleep(time.Second * 5) // waiting for some blocks to pass
+	fooAddr := executeGetAddr(t, "gaiacli keys show foo")
+	panic(fmt.Sprintf("debug fooAddr: %v\n", fooAddr))
 
-	// add a secondary key
-	cmd, wc4, _ := tests.GoExecuteT(t, "gaiacli keys add bar")
-	password(t, wc4)
-	cmd.Wait()
-
-	// get addresses
-	out = tests.ExecuteT(t, "gaiacli keys show foo")
-	fooAddr := strings.TrimLeft(out, "foo\t")
-	out = tests.ExecuteT(t, "gaiacli keys show bar")
-	barAddr := strings.TrimLeft(out, "bar\t")
-
-	// send money from foo to bar
-	cmdStr := fmt.Sprintf("gaiacli send %v --sequence=0 --amount=10fermion --to=%v --name=foo", gaiacliFlags, barAddr)
-	cmd, wc5, _ := tests.GoExecuteT(t, cmdStr)
-	password(t, wc5)
-	cmd.Wait()
+	executeWrite(t, "gaiacli keys add bar", pass)
+	barAddr := executeGetAddr(t, "gaiacli keys show bar")
+	executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10fermion --to=%v --name=foo", flags, barAddr), pass)
 	time.Sleep(time.Second * 3) // waiting for some blocks to pass
 
-	// verify money sent to bar
-	out = tests.ExecuteT(t, fmt.Sprintf("gaiacli account %v %v", barAddr, gaiacliFlags))
-	barAcc := unmarshalBaseAccount(t, out)
+	barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barAddr, flags))
 	assert.Equal(t, int64(10), barAcc.GetCoins().AmountOf("fermion"))
-
-	out = tests.ExecuteT(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, gaiacliFlags))
-	fooAcc := unmarshalBaseAccount(t, out)
+	fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
 	assert.Equal(t, int64(99990), fooAcc.GetCoins().AmountOf("fermion"))
+
+	// declare candidacy
+	//executeWrite(t, "gaiacli declare-candidacy -", pass)
 }
 
-func unmarshalBaseAccount(t *testing.T, raw string) auth.BaseAccount {
+func executeWrite(t *testing.T, cmdStr string, writes ...string) {
+	cmd, wc, _ := tests.GoExecuteT(t, cmdStr)
+	for _, write := range writes {
+		_, err := wc.Write([]byte(write + "\n"))
+		require.NoError(t, err)
+	}
+	cmd.Wait()
+}
+
+func executeInit(t *testing.T, cmdStr string) (masterKey, chainID string) {
+	tests.GoExecuteT(t, cmdStr)
+	out := tests.ExecuteT(t, cmdStr)
+	outCut := "{" + strings.SplitN(out, "{", 2)[1] // weird I'm sorry
+
 	var initRes map[string]json.RawMessage
-	err := json.Unmarshal([]byte(raw), &initRes)
-	require.NoError(t, err, "raw %v, err %v", raw, err)
+	err := json.Unmarshal([]byte(outCut), &initRes)
+	require.NoError(t, err, "out %v outCut %v err %v", out, outCut, err)
+	masterKey = string(initRes["secret"])
+	chainID = string(initRes["chain_id"])
+	return
+}
+
+func executeGetAddr(t *testing.T, cmdStr string) (addr string) {
+	out := tests.ExecuteT(t, cmdStr)
+	name := strings.SplitN(cmdStr, " show ", 2)[1]
+	return strings.TrimLeft(out, name+"\t")
+}
+
+func executeGetAccount(t *testing.T, cmdStr string) auth.BaseAccount {
+	out := tests.ExecuteT(t, cmdStr)
+	var initRes map[string]json.RawMessage
+	err := json.Unmarshal([]byte(out), &initRes)
+	require.NoError(t, err, "out %v, err %v", out, err)
 	value := initRes["value"]
 	var acc auth.BaseAccount
 	_ = json.Unmarshal(value, &acc) //XXX pubkey can't be decoded go amino issue
diff --git a/tests/gobash.go b/tests/gobash.go
index 5a177db94..12b3da085 100644
--- a/tests/gobash.go
+++ b/tests/gobash.go
@@ -42,13 +42,7 @@ func GoExecuteT(t *testing.T, command string) (cmd *exec.Cmd, pipeIn io.WriteClo
 	require.NoError(t, err)
 	pipeOut, err = cmd.StdoutPipe()
 	require.NoError(t, err)
-
-	go func() {
-		cmd.Start()
-		//bz, _ := cmd.CombinedOutput()
-		//require.NoError(t, err, string(bz))
-		//outChan <- strings.Trim(string(bz), "\n") //trim any new lines
-	}()
+	go cmd.Start()
 	time.Sleep(time.Second)
 	return cmd, pipeIn, pipeOut
 }

From 158e9dd12d2e5b81a0dc88bd7bd525e9786b9915 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Sat, 14 Apr 2018 13:06:54 -0400
Subject: [PATCH 14/26] fixed cli tests

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

diff --git a/cmd/gaia/cmd/cli_test.go b/cmd/gaia/cmd/cli_test.go
index d2e86d7f7..eb31aaad1 100644
--- a/cmd/gaia/cmd/cli_test.go
+++ b/cmd/gaia/cmd/cli_test.go
@@ -30,21 +30,11 @@ func TestGaiaCLI(t *testing.T) {
 	// start gaiad server
 	cmd, _, _ := tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
 	defer cmd.Process.Kill()
-	time.Sleep(time.Second) // waiting for some blocks to pass
-
-	//executeWrite(t, "gaiacli keys add foo --recover", pass, masterKey)
-	cmd, wc3, _ := tests.GoExecuteT(t, "gaiacli keys add foo --recover")
-	time.Sleep(time.Second) // waiting for some blocks to pass
-	_, err := wc3.Write([]byte("1234567890\n"))
-	require.NoError(t, err)
-	_, err = wc3.Write([]byte(masterKey + "\n"))
-	require.NoError(t, err)
-	cmd.Wait()
-	time.Sleep(time.Second * 5) // waiting for some blocks to pass
-	fooAddr := executeGetAddr(t, "gaiacli keys show foo")
-	panic(fmt.Sprintf("debug fooAddr: %v\n", fooAddr))
 
+	executeWrite(t, "gaiacli keys add foo --recover", pass, masterKey)
 	executeWrite(t, "gaiacli keys add bar", pass)
+
+	fooAddr := executeGetAddr(t, "gaiacli keys show foo")
 	barAddr := executeGetAddr(t, "gaiacli keys show bar")
 	executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10fermion --to=%v --name=foo", flags, barAddr), pass)
 	time.Sleep(time.Second * 3) // waiting for some blocks to pass
@@ -68,15 +58,16 @@ func executeWrite(t *testing.T, cmdStr string, writes ...string) {
 }
 
 func executeInit(t *testing.T, cmdStr string) (masterKey, chainID string) {
-	tests.GoExecuteT(t, cmdStr)
 	out := tests.ExecuteT(t, cmdStr)
 	outCut := "{" + strings.SplitN(out, "{", 2)[1] // weird I'm sorry
 
 	var initRes map[string]json.RawMessage
 	err := json.Unmarshal([]byte(outCut), &initRes)
-	require.NoError(t, err, "out %v outCut %v err %v", out, outCut, err)
-	masterKey = string(initRes["secret"])
-	chainID = string(initRes["chain_id"])
+	require.NoError(t, err)
+	err = json.Unmarshal(initRes["secret"], &masterKey)
+	require.NoError(t, err)
+	err = json.Unmarshal(initRes["chain_id"], &chainID)
+	require.NoError(t, err)
 	return
 }
 

From e584d5acacc96108a1f028e69810946295a9aa10 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Sat, 14 Apr 2018 16:52:58 -0400
Subject: [PATCH 15/26] ci build -> install

pubkey issue

...

rebase fixes

...
---
 Makefile                   |  2 +-
 client/keys/wire.go        |  6 ++++
 cmd/gaia/app/app.go        | 14 +++-----
 cmd/gaia/app/app_test.go   | 19 ++++-------
 cmd/gaia/cmd/cli_test.go   | 68 ++++++++++++++++++++++++++++++--------
 cmd/gaia/cmd/gaiad/main.go |  2 +-
 x/stake/commands/tx.go     |  4 ++-
 x/stake/types.go           | 26 ++++++++++++---
 8 files changed, 98 insertions(+), 43 deletions(-)

diff --git a/Makefile b/Makefile
index 78a5c9dcc..daa0361fc 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ all: check_tools get_vendor_deps build build_examples test
 ########################################
 ### CI
 
-ci: get_tools get_vendor_deps build test_cover
+ci: get_tools get_vendor_deps install test_cover
 
 ########################################
 ### Build
diff --git a/client/keys/wire.go b/client/keys/wire.go
index 225e60ae7..a163f995a 100644
--- a/client/keys/wire.go
+++ b/client/keys/wire.go
@@ -11,6 +11,12 @@ func init() {
 	wire.RegisterCrypto(cdc)
 }
 
+// marshal keys
 func MarshalJSON(o interface{}) ([]byte, error) {
 	return cdc.MarshalJSON(o)
 }
+
+// unmarshal json
+func UnmarshalJSON(bz []byte, ptr interface{}) error {
+	return cdc.UnmarshalJSON(bz, ptr)
+}
diff --git a/cmd/gaia/app/app.go b/cmd/gaia/app/app.go
index eeb64a7a7..0c9ef8b55 100644
--- a/cmd/gaia/app/app.go
+++ b/cmd/gaia/app/app.go
@@ -39,10 +39,10 @@ type GaiaApp struct {
 	stakeKeeper   stake.Keeper
 }
 
-func NewGaiaApp(logger log.Logger, dbs map[string]dbm.DB) *GaiaApp {
+func NewGaiaApp(logger log.Logger, db dbm.DB) *GaiaApp {
 	// create your application object
 	var app = &GaiaApp{
-		BaseApp:            bam.NewBaseApp(appName, logger, dbs["main"]),
+		BaseApp:            bam.NewBaseApp(appName, logger, db),
 		cdc:                MakeCodec(),
 		capKeyMainStore:    sdk.NewKVStoreKey("main"),
 		capKeyAccountStore: sdk.NewKVStoreKey("acc"),
@@ -70,13 +70,7 @@ func NewGaiaApp(logger log.Logger, dbs map[string]dbm.DB) *GaiaApp {
 	app.SetTxDecoder(app.txDecoder)
 	app.SetInitChainer(app.initChainer)
 	app.SetEndBlocker(stake.NewEndBlocker(app.stakeKeeper))
-	app.MountStoreWithDB(app.capKeyMainStore, sdk.StoreTypeIAVL, dbs["main"])
-	app.MountStoreWithDB(app.capKeyAccountStore, sdk.StoreTypeIAVL, dbs["acc"])
-	app.MountStoreWithDB(app.capKeyIBCStore, sdk.StoreTypeIAVL, dbs["ibc"])
-	app.MountStoreWithDB(app.capKeyStakeStore, sdk.StoreTypeIAVL, dbs["stake"])
-
-	// NOTE: Broken until #532 lands
-	//app.MountStoresIAVL(app.capKeyMainStore, app.capKeyIBCStore, app.capKeyStakeStore)
+	app.MountStoresIAVL(app.capKeyMainStore, app.capKeyAccountStore, app.capKeyIBCStore, app.capKeyStakeStore)
 	app.SetAnteHandler(auth.NewAnteHandler(app.accountMapper))
 	err := app.LoadLatestVersion(app.capKeyMainStore)
 	if err != nil {
@@ -116,7 +110,7 @@ func (app *GaiaApp) txDecoder(txBytes []byte) (sdk.Tx, sdk.Error) {
 	}
 
 	// StdTx.Msg is an interface. The concrete types
-	// are registered by MakeTxCodec in bank.RegisterWire.
+	// are registered by MakeTxCodec
 	err := app.cdc.UnmarshalBinary(txBytes, &tx)
 	if err != nil {
 		return nil, sdk.ErrTxDecode("").TraceCause(err, "")
diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
index ea10cebc5..5c8450138 100644
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@@ -85,20 +85,15 @@ var (
 	}
 )
 
-func loggerAndDBs() (log.Logger, map[string]dbm.DB) {
+func loggerAndDB() (log.Logger, dbm.DB) {
 	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "sdk/app")
-	dbs := map[string]dbm.DB{
-		"main":  dbm.NewMemDB(),
-		"acc":   dbm.NewMemDB(),
-		"ibc":   dbm.NewMemDB(),
-		"stake": dbm.NewMemDB(),
-	}
-	return logger, dbs
+	db := dbm.NewMemDB()
+	return logger, db
 }
 
 func newGaiaApp() *GaiaApp {
-	logger, dbs := loggerAndDBs()
-	return NewGaiaApp(logger, dbs)
+	logger, db := loggerAndDB()
+	return NewGaiaApp(logger, db)
 }
 
 func setGenesis(gapp *GaiaApp, accs ...*auth.BaseAccount) error {
@@ -144,7 +139,7 @@ func TestMsgs(t *testing.T) {
 }
 
 func TestSortGenesis(t *testing.T) {
-	logger, dbs := loggerAndDBs()
+	logger, dbs := loggerAndDB()
 	gapp := NewGaiaApp(logger, dbs)
 
 	// Note the order: the coins are unsorted!
@@ -188,7 +183,7 @@ func TestSortGenesis(t *testing.T) {
 }
 
 func TestGenesis(t *testing.T) {
-	logger, dbs := loggerAndDBs()
+	logger, dbs := loggerAndDB()
 	gapp := NewGaiaApp(logger, dbs)
 
 	// Construct some genesis bytes to reflect GaiaAccount
diff --git a/cmd/gaia/cmd/cli_test.go b/cmd/gaia/cmd/cli_test.go
index eb31aaad1..c537ae0a5 100644
--- a/cmd/gaia/cmd/cli_test.go
+++ b/cmd/gaia/cmd/cli_test.go
@@ -1,6 +1,7 @@
 package common
 
 import (
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"strings"
@@ -10,17 +11,20 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/cosmos/cosmos-sdk/client/keys"
 	"github.com/cosmos/cosmos-sdk/server"
 	"github.com/cosmos/cosmos-sdk/tests"
 	"github.com/cosmos/cosmos-sdk/x/auth"
+	crypto "github.com/tendermint/go-crypto"
+	crkeys "github.com/tendermint/go-crypto/keys"
 )
 
 func TestGaiaCLI(t *testing.T) {
 
 	tests.ExecuteT(t, "gaiad unsafe_reset_all")
 	pass := "1234567890"
-	executeWrite(t, "gaiacli keys delete foo", pass)
-	executeWrite(t, "gaiacli keys delete bar", pass)
+	executeWrite(t, false, "gaiacli keys delete foo", pass)
+	executeWrite(t, false, "gaiacli keys delete bar", pass)
 	masterKey, chainID := executeInit(t, "gaiad init")
 
 	// get a free port, also setup some common flags
@@ -31,25 +35,55 @@ func TestGaiaCLI(t *testing.T) {
 	cmd, _, _ := tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
 	defer cmd.Process.Kill()
 
-	executeWrite(t, "gaiacli keys add foo --recover", pass, masterKey)
-	executeWrite(t, "gaiacli keys add bar", pass)
+	executeWrite(t, false, "gaiacli keys add foo --recover", pass, masterKey)
+	executeWrite(t, false, "gaiacli keys add bar", pass)
 
-	fooAddr := executeGetAddr(t, "gaiacli keys show foo")
-	barAddr := executeGetAddr(t, "gaiacli keys show bar")
-	executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10fermion --to=%v --name=foo", flags, barAddr), pass)
+	fooAddr, fooPubKey := executeGetAddr(t, "gaiacli keys show foo --output=json")
+	barAddr, _ := executeGetAddr(t, "gaiacli keys show bar --output=json")
+
+	fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
+	assert.Equal(t, int64(100000), fooAcc.GetCoins().AmountOf("fermion"))
+
+	executeWrite(t, false, fmt.Sprintf("gaiacli send %v --amount=10fermion --to=%v --name=foo", flags, barAddr), pass)
 	time.Sleep(time.Second * 3) // waiting for some blocks to pass
 
 	barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barAddr, flags))
 	assert.Equal(t, int64(10), barAcc.GetCoins().AmountOf("fermion"))
-	fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
+	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
 	assert.Equal(t, int64(99990), fooAcc.GetCoins().AmountOf("fermion"))
 
 	// declare candidacy
-	//executeWrite(t, "gaiacli declare-candidacy -", pass)
+	//--address-candidate string   hex address of the validator/candidate
+	//--amount string              Amount of coins to bond (default "1fermion")
+	//--chain-id string            Chain ID of tendermint node
+	//--fee string                 Fee to pay along with transaction
+	//--keybase-sig string         optional keybase signature
+	//--moniker string             validator-candidate name
+	//--name string                Name of private key with which to sign
+	//--node string                <host>:<port> to tendermint rpc interface for this chain (default "tcp://localhost:46657")
+	//--pubkey string              PubKey of the validator-candidate
+	//--sequence int               Sequence number to sign the tx
+	//--website string             optional website
+	_ = fooPubKey
+	//declStr := fmt.Sprintf("gaiacli declare-candidacy %v", flags)
+	//declStr += fmt.Sprintf(" --name=%v", "foo")
+	//declStr += fmt.Sprintf(" --address-candidate=%v", fooAddr)
+	//declStr += fmt.Sprintf(" --pubkey=%v", fooPubKey)
+	//declStr += fmt.Sprintf(" --amount=%v", "3fermion")
+	//declStr += fmt.Sprintf(" --moniker=%v", "foo-vally")
+	//fmt.Printf("debug declStr: %v\n", declStr)
+	//executeWrite(t, true, declStr, pass)
 }
 
-func executeWrite(t *testing.T, cmdStr string, writes ...string) {
-	cmd, wc, _ := tests.GoExecuteT(t, cmdStr)
+func executeWrite(t *testing.T, print bool, cmdStr string, writes ...string) {
+	cmd, wc, rc := tests.GoExecuteT(t, cmdStr)
+
+	if print {
+		bz := make([]byte, 100000)
+		rc.Read(bz)
+		fmt.Printf("debug read: %v\n", string(bz))
+	}
+
 	for _, write := range writes {
 		_, err := wc.Write([]byte(write + "\n"))
 		require.NoError(t, err)
@@ -71,10 +105,16 @@ func executeInit(t *testing.T, cmdStr string) (masterKey, chainID string) {
 	return
 }
 
-func executeGetAddr(t *testing.T, cmdStr string) (addr string) {
+func executeGetAddr(t *testing.T, cmdStr string) (addr, pubKey string) {
 	out := tests.ExecuteT(t, cmdStr)
-	name := strings.SplitN(cmdStr, " show ", 2)[1]
-	return strings.TrimLeft(out, name+"\t")
+	var info crkeys.Info
+	keys.UnmarshalJSON([]byte(out), &info)
+	pubKey = hex.EncodeToString(info.PubKey.(crypto.PubKeyEd25519).Bytes())
+	pubKey = strings.TrimLeft(pubKey, "1624de6220")
+	fmt.Printf("debug pubKey: %v\n", pubKey)
+	addr = info.PubKey.Address().String()
+	fmt.Printf("debug addr: %v\n", addr)
+	return
 }
 
 func executeGetAccount(t *testing.T, cmdStr string) auth.BaseAccount {
diff --git a/cmd/gaia/cmd/gaiad/main.go b/cmd/gaia/cmd/gaiad/main.go
index b84a4e20d..91ea778f7 100644
--- a/cmd/gaia/cmd/gaiad/main.go
+++ b/cmd/gaia/cmd/gaiad/main.go
@@ -31,7 +31,7 @@ func generateApp(rootDir string, logger log.Logger) (abci.Application, error) {
 	if err != nil {
 		return nil, err
 	}
-	bapp := app.NewBasecoinApp(logger, db)
+	bapp := app.NewGaiaApp(logger, db)
 	//dbAcc, err := dbm.NewGoLevelDB("gaia-acc", dataDir)
 	//if err != nil {
 	//return nil, err
diff --git a/x/stake/commands/tx.go b/x/stake/commands/tx.go
index 679e59b15..76220aeb6 100644
--- a/x/stake/commands/tx.go
+++ b/x/stake/commands/tx.go
@@ -269,9 +269,11 @@ func GetPubKey(pubKeyStr string) (pk crypto.PubKey, err error) {
 		return
 	}
 	if len(pubKeyStr) != 64 { //if len(pkBytes) != 32 {
-		err = fmt.Errorf("pubkey must be Ed25519 hex encoded string which is 64 characters long")
+		err = fmt.Errorf("pubkey must be Ed25519 hex encoded string which is 64 characters, this pubkey is %v characters", len(pubKeyStr))
 		return
 	}
+
+	// TODO: bech32 ...
 	var pkBytes []byte
 	pkBytes, err = hex.DecodeString(pubKeyStr)
 	if err != nil {
diff --git a/x/stake/types.go b/x/stake/types.go
index 240f3fe2a..14978ce35 100644
--- a/x/stake/types.go
+++ b/x/stake/types.go
@@ -1,6 +1,8 @@
 package stake
 
 import (
+	"encoding/hex"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/wire"
 	abci "github.com/tendermint/abci/types"
@@ -131,12 +133,20 @@ type Validator struct {
 
 // abci validator from stake validator type
 func (v Validator) abciValidator(cdc *wire.Codec) abci.Validator {
-	pkBytes, err := cdc.MarshalBinary(v.PubKey)
+	//pkBytes, err := cdc.MarshalBinary(v.PubKey)
+	//if err != nil {
+	//panic(err)
+	//}
+	//return abci.Validator{
+	//PubKey: pkBytes,
+	//Power:  v.Power.Evaluate(),
+	//}
+	TypeDistinguisher, err := hex.DecodeString("1624de6220")
 	if err != nil {
 		panic(err)
 	}
 	return abci.Validator{
-		PubKey: pkBytes,
+		PubKey: append(TypeDistinguisher, v.PubKey.Bytes()...),
 		Power:  v.Power.Evaluate(),
 	}
 }
@@ -144,12 +154,20 @@ func (v Validator) abciValidator(cdc *wire.Codec) abci.Validator {
 // abci validator from stake validator type
 // with zero power used for validator updates
 func (v Validator) abciValidatorZero(cdc *wire.Codec) abci.Validator {
-	pkBytes, err := cdc.MarshalBinary(v.PubKey)
+	//pkBytes, err := cdc.MarshalBinary(v.PubKey)
+	//if err != nil {
+	//panic(err)
+	//}
+	//return abci.Validator{
+	//PubKey: pkBytes,
+	//Power:  0,
+	//}
+	TypeDistinguisher, err := hex.DecodeString("1624de6220")
 	if err != nil {
 		panic(err)
 	}
 	return abci.Validator{
-		PubKey: pkBytes,
+		PubKey: append(TypeDistinguisher, v.PubKey.Bytes()...),
 		Power:  0,
 	}
 }

From 265670297cf5864cd34893366f4310949c27a58b Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Mon, 16 Apr 2018 16:47:28 -0400
Subject: [PATCH 16/26] fix PK encodings

---
 cmd/gaia/cmd/cli_test.go | 42 ++++++++++++++++++++--------------------
 x/stake/keeper_test.go   | 20 +++++--------------
 x/stake/types.go         | 30 ++--------------------------
 3 files changed, 28 insertions(+), 64 deletions(-)

diff --git a/cmd/gaia/cmd/cli_test.go b/cmd/gaia/cmd/cli_test.go
index c537ae0a5..a2bf5a3ca 100644
--- a/cmd/gaia/cmd/cli_test.go
+++ b/cmd/gaia/cmd/cli_test.go
@@ -23,8 +23,8 @@ func TestGaiaCLI(t *testing.T) {
 
 	tests.ExecuteT(t, "gaiad unsafe_reset_all")
 	pass := "1234567890"
-	executeWrite(t, false, "gaiacli keys delete foo", pass)
-	executeWrite(t, false, "gaiacli keys delete bar", pass)
+	executeWrite(t, "gaiacli keys delete foo", pass)
+	executeWrite(t, "gaiacli keys delete bar", pass)
 	masterKey, chainID := executeInit(t, "gaiad init")
 
 	// get a free port, also setup some common flags
@@ -35,8 +35,8 @@ func TestGaiaCLI(t *testing.T) {
 	cmd, _, _ := tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
 	defer cmd.Process.Kill()
 
-	executeWrite(t, false, "gaiacli keys add foo --recover", pass, masterKey)
-	executeWrite(t, false, "gaiacli keys add bar", pass)
+	executeWrite(t, "gaiacli keys add foo --recover", pass, masterKey)
+	executeWrite(t, "gaiacli keys add bar", pass)
 
 	fooAddr, fooPubKey := executeGetAddr(t, "gaiacli keys show foo --output=json")
 	barAddr, _ := executeGetAddr(t, "gaiacli keys show bar --output=json")
@@ -44,7 +44,7 @@ func TestGaiaCLI(t *testing.T) {
 	fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
 	assert.Equal(t, int64(100000), fooAcc.GetCoins().AmountOf("fermion"))
 
-	executeWrite(t, false, fmt.Sprintf("gaiacli send %v --amount=10fermion --to=%v --name=foo", flags, barAddr), pass)
+	executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10fermion --to=%v --name=foo", flags, barAddr), pass)
 	time.Sleep(time.Second * 3) // waiting for some blocks to pass
 
 	barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barAddr, flags))
@@ -64,25 +64,25 @@ func TestGaiaCLI(t *testing.T) {
 	//--pubkey string              PubKey of the validator-candidate
 	//--sequence int               Sequence number to sign the tx
 	//--website string             optional website
-	_ = fooPubKey
-	//declStr := fmt.Sprintf("gaiacli declare-candidacy %v", flags)
-	//declStr += fmt.Sprintf(" --name=%v", "foo")
-	//declStr += fmt.Sprintf(" --address-candidate=%v", fooAddr)
-	//declStr += fmt.Sprintf(" --pubkey=%v", fooPubKey)
-	//declStr += fmt.Sprintf(" --amount=%v", "3fermion")
-	//declStr += fmt.Sprintf(" --moniker=%v", "foo-vally")
-	//fmt.Printf("debug declStr: %v\n", declStr)
-	//executeWrite(t, true, declStr, pass)
+	//_ = fooPubKey
+	declStr := fmt.Sprintf("gaiacli declare-candidacy %v", flags)
+	declStr += fmt.Sprintf(" --name=%v", "foo")
+	declStr += fmt.Sprintf(" --address-candidate=%v", fooAddr)
+	declStr += fmt.Sprintf(" --pubkey=%v", fooPubKey)
+	declStr += fmt.Sprintf(" --amount=%v", "3fermion")
+	declStr += fmt.Sprintf(" --moniker=%v", "foo-vally")
+	fmt.Printf("debug declStr: %v\n", declStr)
+	executeWrite(t, declStr, pass)
 }
 
-func executeWrite(t *testing.T, print bool, cmdStr string, writes ...string) {
-	cmd, wc, rc := tests.GoExecuteT(t, cmdStr)
+func executeWrite(t *testing.T, cmdStr string, writes ...string) {
+	cmd, wc, _ := tests.GoExecuteT(t, cmdStr)
 
-	if print {
-		bz := make([]byte, 100000)
-		rc.Read(bz)
-		fmt.Printf("debug read: %v\n", string(bz))
-	}
+	//if print {
+	//bz := make([]byte, 100000)
+	//rc.Read(bz)
+	//fmt.Printf("debug read: %v\n", string(bz))
+	//}
 
 	for _, write := range writes {
 		_, err := wc.Write([]byte(write + "\n"))
diff --git a/x/stake/keeper_test.go b/x/stake/keeper_test.go
index 9d6f69cc6..e01df1aae 100644
--- a/x/stake/keeper_test.go
+++ b/x/stake/keeper_test.go
@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	crypto "github.com/tendermint/go-crypto"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -315,15 +314,6 @@ func TestGetAccUpdateValidators(t *testing.T) {
 		}
 	}
 
-	// to compare pubkeys between abci pubkey and crypto.PubKey
-	wirePK := func(pk crypto.PubKey) []byte {
-		pkBytes, err := keeper.cdc.MarshalBinary(pk)
-		if err != nil {
-			panic(err)
-		}
-		return pkBytes
-	}
-
 	// test from nothing to something
 	//  candidate set: {} -> {c1, c3}
 	//  validator set: {} -> {c1, c3}
@@ -478,7 +468,7 @@ func TestGetAccUpdateValidators(t *testing.T) {
 	acc = keeper.getAccUpdateValidators(ctx)
 	require.Equal(t, 2, len(acc), "%v", acc)
 
-	assert.Equal(t, wirePK(candidatesIn[0].PubKey), acc[0].PubKey)
+	assert.Equal(t, candidatesIn[0].PubKey.Bytes(), acc[0].PubKey)
 	assert.Equal(t, int64(0), acc[0].Power)
 	assert.Equal(t, vals[0].abciValidator(keeper.cdc), acc[1])
 
@@ -503,10 +493,10 @@ func TestGetAccUpdateValidators(t *testing.T) {
 	require.Equal(t, 0, len(candidates))
 	acc = keeper.getAccUpdateValidators(ctx)
 	require.Equal(t, 4, len(acc))
-	assert.Equal(t, wirePK(candidatesIn[1].PubKey), acc[0].PubKey)
-	assert.Equal(t, wirePK(candidatesIn[2].PubKey), acc[1].PubKey)
-	assert.Equal(t, wirePK(candidatesIn[3].PubKey), acc[2].PubKey)
-	assert.Equal(t, wirePK(candidatesIn[4].PubKey), acc[3].PubKey)
+	assert.Equal(t, candidatesIn[1].PubKey.Bytes(), acc[0].PubKey)
+	assert.Equal(t, candidatesIn[2].PubKey.Bytes(), acc[1].PubKey)
+	assert.Equal(t, candidatesIn[3].PubKey.Bytes(), acc[2].PubKey)
+	assert.Equal(t, candidatesIn[4].PubKey.Bytes(), acc[3].PubKey)
 	assert.Equal(t, int64(0), acc[0].Power)
 	assert.Equal(t, int64(0), acc[1].Power)
 	assert.Equal(t, int64(0), acc[2].Power)
diff --git a/x/stake/types.go b/x/stake/types.go
index 14978ce35..b0dbc0b1f 100644
--- a/x/stake/types.go
+++ b/x/stake/types.go
@@ -1,8 +1,6 @@
 package stake
 
 import (
-	"encoding/hex"
-
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/wire"
 	abci "github.com/tendermint/abci/types"
@@ -133,20 +131,8 @@ type Validator struct {
 
 // abci validator from stake validator type
 func (v Validator) abciValidator(cdc *wire.Codec) abci.Validator {
-	//pkBytes, err := cdc.MarshalBinary(v.PubKey)
-	//if err != nil {
-	//panic(err)
-	//}
-	//return abci.Validator{
-	//PubKey: pkBytes,
-	//Power:  v.Power.Evaluate(),
-	//}
-	TypeDistinguisher, err := hex.DecodeString("1624de6220")
-	if err != nil {
-		panic(err)
-	}
 	return abci.Validator{
-		PubKey: append(TypeDistinguisher, v.PubKey.Bytes()...),
+		PubKey: v.PubKey.Bytes(),
 		Power:  v.Power.Evaluate(),
 	}
 }
@@ -154,20 +140,8 @@ func (v Validator) abciValidator(cdc *wire.Codec) abci.Validator {
 // abci validator from stake validator type
 // with zero power used for validator updates
 func (v Validator) abciValidatorZero(cdc *wire.Codec) abci.Validator {
-	//pkBytes, err := cdc.MarshalBinary(v.PubKey)
-	//if err != nil {
-	//panic(err)
-	//}
-	//return abci.Validator{
-	//PubKey: pkBytes,
-	//Power:  0,
-	//}
-	TypeDistinguisher, err := hex.DecodeString("1624de6220")
-	if err != nil {
-		panic(err)
-	}
 	return abci.Validator{
-		PubKey: append(TypeDistinguisher, v.PubKey.Bytes()...),
+		PubKey: v.PubKey.Bytes(),
 		Power:  0,
 	}
 }

From 09fe4c0262cd9a8160e6dd31ee107411e98e507a Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Mon, 16 Apr 2018 19:17:09 -0400
Subject: [PATCH 17/26] fix stake query keys

---
 cmd/gaia/cmd/cli_test.go   | 72 +++++++++++++++++++++++++++-----------
 cmd/gaia/cmd/gaiad/main.go | 19 ----------
 x/stake/commands/query.go  | 16 +++------
 x/stake/commands/tx.go     |  8 ++---
 4 files changed, 61 insertions(+), 54 deletions(-)

diff --git a/cmd/gaia/cmd/cli_test.go b/cmd/gaia/cmd/cli_test.go
index a2bf5a3ca..225c2bd07 100644
--- a/cmd/gaia/cmd/cli_test.go
+++ b/cmd/gaia/cmd/cli_test.go
@@ -19,12 +19,45 @@ import (
 	crkeys "github.com/tendermint/go-crypto/keys"
 )
 
-func TestGaiaCLI(t *testing.T) {
+//func TestGaiaCLISend(t *testing.T) {
+
+//tests.ExecuteT(t, "gaiad unsafe_reset_all")
+//pass := "1234567890"
+//executeWrite(t, "gaiacli keys delete foo", pass)
+//executeWrite(t, "gaiacli keys delete bar", pass)
+//masterKey, chainID := executeInit(t, "gaiad init")
+
+//// get a free port, also setup some common flags
+//servAddr := server.FreeTCPAddr(t)
+//flags := fmt.Sprintf("--node=%v --chain-id=%v", servAddr, chainID)
+
+//// start gaiad server
+//cmd, _, _ := tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
+//defer cmd.Process.Kill()
+
+//executeWrite(t, "gaiacli keys add foo --recover", pass, masterKey)
+//executeWrite(t, "gaiacli keys add bar", pass)
+
+//fooAddr, _ := executeGetAddr(t, "gaiacli keys show foo --output=json")
+//barAddr, _ := executeGetAddr(t, "gaiacli keys show bar --output=json")
+
+//fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
+//assert.Equal(t, int64(100000), fooAcc.GetCoins().AmountOf("fermion"))
+
+//executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10fermion --to=%v --name=foo", flags, barAddr), pass)
+//time.Sleep(time.Second * 3) // waiting for some blocks to pass
+
+//barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barAddr, flags))
+//assert.Equal(t, int64(10), barAcc.GetCoins().AmountOf("fermion"))
+//fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
+//assert.Equal(t, int64(99990), fooAcc.GetCoins().AmountOf("fermion"))
+//}
+
+func TestGaiaCLIDeclareCandidacy(t *testing.T) {
 
 	tests.ExecuteT(t, "gaiad unsafe_reset_all")
 	pass := "1234567890"
 	executeWrite(t, "gaiacli keys delete foo", pass)
-	executeWrite(t, "gaiacli keys delete bar", pass)
 	masterKey, chainID := executeInit(t, "gaiad init")
 
 	// get a free port, also setup some common flags
@@ -36,22 +69,10 @@ func TestGaiaCLI(t *testing.T) {
 	defer cmd.Process.Kill()
 
 	executeWrite(t, "gaiacli keys add foo --recover", pass, masterKey)
-	executeWrite(t, "gaiacli keys add bar", pass)
-
 	fooAddr, fooPubKey := executeGetAddr(t, "gaiacli keys show foo --output=json")
-	barAddr, _ := executeGetAddr(t, "gaiacli keys show bar --output=json")
-
 	fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
 	assert.Equal(t, int64(100000), fooAcc.GetCoins().AmountOf("fermion"))
 
-	executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10fermion --to=%v --name=foo", flags, barAddr), pass)
-	time.Sleep(time.Second * 3) // waiting for some blocks to pass
-
-	barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barAddr, flags))
-	assert.Equal(t, int64(10), barAcc.GetCoins().AmountOf("fermion"))
-	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
-	assert.Equal(t, int64(99990), fooAcc.GetCoins().AmountOf("fermion"))
-
 	// declare candidacy
 	//--address-candidate string   hex address of the validator/candidate
 	//--amount string              Amount of coins to bond (default "1fermion")
@@ -73,17 +94,14 @@ func TestGaiaCLI(t *testing.T) {
 	declStr += fmt.Sprintf(" --moniker=%v", "foo-vally")
 	fmt.Printf("debug declStr: %v\n", declStr)
 	executeWrite(t, declStr, pass)
+	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
+	time.Sleep(time.Second * 3) // waiting for some blocks to pass
+	assert.Equal(t, int64(99997), fooAcc.GetCoins().AmountOf("fermion"))
 }
 
 func executeWrite(t *testing.T, cmdStr string, writes ...string) {
 	cmd, wc, _ := tests.GoExecuteT(t, cmdStr)
 
-	//if print {
-	//bz := make([]byte, 100000)
-	//rc.Read(bz)
-	//fmt.Printf("debug read: %v\n", string(bz))
-	//}
-
 	for _, write := range writes {
 		_, err := wc.Write([]byte(write + "\n"))
 		require.NoError(t, err)
@@ -91,6 +109,20 @@ func executeWrite(t *testing.T, cmdStr string, writes ...string) {
 	cmd.Wait()
 }
 
+func executeWritePrint(t *testing.T, cmdStr string, writes ...string) {
+	cmd, wc, rc := tests.GoExecuteT(t, cmdStr)
+
+	for _, write := range writes {
+		_, err := wc.Write([]byte(write + "\n"))
+		require.NoError(t, err)
+	}
+	cmd.Wait()
+
+	bz := make([]byte, 100000)
+	rc.Read(bz)
+	fmt.Printf("debug read: %v\n", string(bz))
+}
+
 func executeInit(t *testing.T, cmdStr string) (masterKey, chainID string) {
 	out := tests.ExecuteT(t, cmdStr)
 	outCut := "{" + strings.SplitN(out, "{", 2)[1] // weird I'm sorry
diff --git a/cmd/gaia/cmd/gaiad/main.go b/cmd/gaia/cmd/gaiad/main.go
index 91ea778f7..199a06152 100644
--- a/cmd/gaia/cmd/gaiad/main.go
+++ b/cmd/gaia/cmd/gaiad/main.go
@@ -32,25 +32,6 @@ func generateApp(rootDir string, logger log.Logger) (abci.Application, error) {
 		return nil, err
 	}
 	bapp := app.NewGaiaApp(logger, db)
-	//dbAcc, err := dbm.NewGoLevelDB("gaia-acc", dataDir)
-	//if err != nil {
-	//return nil, err
-	//}
-	//dbIBC, err := dbm.NewGoLevelDB("gaia-ibc", dataDir)
-	//if err != nil {
-	//return nil, err
-	//}
-	//dbStake, err := dbm.NewGoLevelDB("gaia-stake", dataDir)
-	//if err != nil {
-	//return nil, err
-	//}
-	//dbs := map[string]dbm.DB{
-	//"main":  dbMain,
-	//"acc":   dbAcc,
-	//"ibc":   dbIBC,
-	//"stake": dbStake,
-	//}
-	//bapp := app.NewGaiaApp(logger, dbs)
 	return bapp, nil
 }
 
diff --git a/x/stake/commands/query.go b/x/stake/commands/query.go
index 38e16f333..187de702c 100644
--- a/x/stake/commands/query.go
+++ b/x/stake/commands/query.go
@@ -16,12 +16,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/stake"
 )
 
-// XXX remove dependancy
-func PrefixedKey(app string, key []byte) []byte {
-	prefix := append([]byte(app), byte(0))
-	return append(prefix, key...)
-}
-
 //nolint
 var (
 	fsValAddr         = flag.NewFlagSet("", flag.ContinueOnError)
@@ -44,7 +38,7 @@ func GetCmdQueryCandidates(storeName string, cdc *wire.Codec) *cobra.Command {
 		Short: "Query for the set of validator-candidates pubkeys",
 		RunE: func(cmd *cobra.Command, args []string) error {
 
-			key := PrefixedKey(stake.MsgType, stake.CandidatesKey)
+			key := stake.CandidatesKey
 
 			ctx := context.NewCoreContextFromViper()
 			res, err := ctx.Query(key, storeName)
@@ -54,7 +48,7 @@ func GetCmdQueryCandidates(storeName string, cdc *wire.Codec) *cobra.Command {
 
 			// parse out the candidates
 			candidates := new(stake.Candidates)
-			err = cdc.UnmarshalJSON(res, candidates)
+			err = cdc.UnmarshalBinary(res, candidates)
 			if err != nil {
 				return err
 			}
@@ -85,7 +79,7 @@ func GetCmdQueryCandidate(storeName string, cdc *wire.Codec) *cobra.Command {
 				return err
 			}
 
-			key := PrefixedKey(stake.MsgType, stake.GetCandidateKey(addr))
+			key := stake.GetCandidateKey(addr)
 
 			ctx := context.NewCoreContextFromViper()
 
@@ -133,7 +127,7 @@ func GetCmdQueryDelegatorBond(storeName string, cdc *wire.Codec) *cobra.Command
 			}
 			delegator := crypto.Address(bz)
 
-			key := PrefixedKey(stake.MsgType, stake.GetDelegatorBondKey(delegator, addr, cdc))
+			key := stake.GetDelegatorBondKey(delegator, addr, cdc)
 
 			ctx := context.NewCoreContextFromViper()
 
@@ -177,7 +171,7 @@ func GetCmdQueryDelegatorBonds(storeName string, cdc *wire.Codec) *cobra.Command
 			}
 			delegator := crypto.Address(bz)
 
-			key := PrefixedKey(stake.MsgType, stake.GetDelegatorBondsKey(delegator, cdc))
+			key := stake.GetDelegatorBondsKey(delegator, cdc)
 
 			ctx := context.NewCoreContextFromViper()
 
diff --git a/x/stake/commands/tx.go b/x/stake/commands/tx.go
index 76220aeb6..bc8f93e8f 100644
--- a/x/stake/commands/tx.go
+++ b/x/stake/commands/tx.go
@@ -268,10 +268,10 @@ func GetPubKey(pubKeyStr string) (pk crypto.PubKey, err error) {
 		err = fmt.Errorf("must use --pubkey flag")
 		return
 	}
-	if len(pubKeyStr) != 64 { //if len(pkBytes) != 32 {
-		err = fmt.Errorf("pubkey must be Ed25519 hex encoded string which is 64 characters, this pubkey is %v characters", len(pubKeyStr))
-		return
-	}
+	//if len(pubKeyStr) != 64 { //if len(pkBytes) != 32 {
+	//err = fmt.Errorf("pubkey must be Ed25519 hex encoded string which is 64 characters, this pubkey is %v characters", len(pubKeyStr))
+	//return
+	//}
 
 	// TODO: bech32 ...
 	var pkBytes []byte

From d344de3b629e11cf423c988cd06b8c069f97ba03 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Mon, 16 Apr 2018 19:49:00 -0400
Subject: [PATCH 18/26] stake test candidate query

---
 cmd/gaia/cmd/cli_test.go | 69 +++++++++++++++++++++++++---------------
 1 file changed, 43 insertions(+), 26 deletions(-)

diff --git a/cmd/gaia/cmd/cli_test.go b/cmd/gaia/cmd/cli_test.go
index 225c2bd07..8011d7a69 100644
--- a/cmd/gaia/cmd/cli_test.go
+++ b/cmd/gaia/cmd/cli_test.go
@@ -12,46 +12,48 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/cosmos/cosmos-sdk/client/keys"
+	"github.com/cosmos/cosmos-sdk/cmd/gaia/app"
 	"github.com/cosmos/cosmos-sdk/server"
 	"github.com/cosmos/cosmos-sdk/tests"
 	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/cosmos/cosmos-sdk/x/stake"
 	crypto "github.com/tendermint/go-crypto"
 	crkeys "github.com/tendermint/go-crypto/keys"
 )
 
-//func TestGaiaCLISend(t *testing.T) {
+func TestGaiaCLISend(t *testing.T) {
 
-//tests.ExecuteT(t, "gaiad unsafe_reset_all")
-//pass := "1234567890"
-//executeWrite(t, "gaiacli keys delete foo", pass)
-//executeWrite(t, "gaiacli keys delete bar", pass)
-//masterKey, chainID := executeInit(t, "gaiad init")
+	tests.ExecuteT(t, "gaiad unsafe_reset_all")
+	pass := "1234567890"
+	executeWrite(t, "gaiacli keys delete foo", pass)
+	executeWrite(t, "gaiacli keys delete bar", pass)
+	masterKey, chainID := executeInit(t, "gaiad init")
 
-//// get a free port, also setup some common flags
-//servAddr := server.FreeTCPAddr(t)
-//flags := fmt.Sprintf("--node=%v --chain-id=%v", servAddr, chainID)
+	// get a free port, also setup some common flags
+	servAddr := server.FreeTCPAddr(t)
+	flags := fmt.Sprintf("--node=%v --chain-id=%v", servAddr, chainID)
 
-//// start gaiad server
-//cmd, _, _ := tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
-//defer cmd.Process.Kill()
+	// start gaiad server
+	cmd, _, _ := tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
+	defer cmd.Process.Kill()
 
-//executeWrite(t, "gaiacli keys add foo --recover", pass, masterKey)
-//executeWrite(t, "gaiacli keys add bar", pass)
+	executeWrite(t, "gaiacli keys add foo --recover", pass, masterKey)
+	executeWrite(t, "gaiacli keys add bar", pass)
 
-//fooAddr, _ := executeGetAddr(t, "gaiacli keys show foo --output=json")
-//barAddr, _ := executeGetAddr(t, "gaiacli keys show bar --output=json")
+	fooAddr, _ := executeGetAddr(t, "gaiacli keys show foo --output=json")
+	barAddr, _ := executeGetAddr(t, "gaiacli keys show bar --output=json")
 
-//fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
-//assert.Equal(t, int64(100000), fooAcc.GetCoins().AmountOf("fermion"))
+	fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
+	assert.Equal(t, int64(100000), fooAcc.GetCoins().AmountOf("fermion"))
 
-//executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10fermion --to=%v --name=foo", flags, barAddr), pass)
-//time.Sleep(time.Second * 3) // waiting for some blocks to pass
+	executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10fermion --to=%v --name=foo", flags, barAddr), pass)
+	time.Sleep(time.Second * 3) // waiting for some blocks to pass
 
-//barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barAddr, flags))
-//assert.Equal(t, int64(10), barAcc.GetCoins().AmountOf("fermion"))
-//fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
-//assert.Equal(t, int64(99990), fooAcc.GetCoins().AmountOf("fermion"))
-//}
+	barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barAddr, flags))
+	assert.Equal(t, int64(10), barAcc.GetCoins().AmountOf("fermion"))
+	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
+	assert.Equal(t, int64(99990), fooAcc.GetCoins().AmountOf("fermion"))
+}
 
 func TestGaiaCLIDeclareCandidacy(t *testing.T) {
 
@@ -94,9 +96,11 @@ func TestGaiaCLIDeclareCandidacy(t *testing.T) {
 	declStr += fmt.Sprintf(" --moniker=%v", "foo-vally")
 	fmt.Printf("debug declStr: %v\n", declStr)
 	executeWrite(t, declStr, pass)
-	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
 	time.Sleep(time.Second * 3) // waiting for some blocks to pass
+	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
 	assert.Equal(t, int64(99997), fooAcc.GetCoins().AmountOf("fermion"))
+	candidate := executeGetCandidate(t, fmt.Sprintf("gaiacli candidate %v --address=%v", flags, fooAddr))
+	assert.Equal(t, candidate.Address.String(), fooAddr)
 }
 
 func executeWrite(t *testing.T, cmdStr string, writes ...string) {
@@ -142,7 +146,11 @@ func executeGetAddr(t *testing.T, cmdStr string) (addr, pubKey string) {
 	var info crkeys.Info
 	keys.UnmarshalJSON([]byte(out), &info)
 	pubKey = hex.EncodeToString(info.PubKey.(crypto.PubKeyEd25519).Bytes())
+
+	// TODO this is really wierd, also error that not 64 characters!
 	pubKey = strings.TrimLeft(pubKey, "1624de6220")
+	pubKey = fmt.Sprintf("%064v", pubKey)
+
 	fmt.Printf("debug pubKey: %v\n", pubKey)
 	addr = info.PubKey.Address().String()
 	fmt.Printf("debug addr: %v\n", addr)
@@ -160,3 +168,12 @@ func executeGetAccount(t *testing.T, cmdStr string) auth.BaseAccount {
 	require.NoError(t, err, "value %v, err %v", string(value), err)
 	return acc
 }
+
+func executeGetCandidate(t *testing.T, cmdStr string) stake.Candidate {
+	out := tests.ExecuteT(t, cmdStr)
+	var candidate stake.Candidate
+	cdc := app.MakeCodec()
+	err := cdc.UnmarshalJSON([]byte(out), &candidate)
+	require.NoError(t, err, "out %v, err %v", out, err)
+	return candidate
+}

From 45723733bcb58525e172ce47a4208ae77dcddfac Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Tue, 17 Apr 2018 13:38:14 -0400
Subject: [PATCH 19/26] fix staking flags

---
 x/stake/commands/tx.go | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/x/stake/commands/tx.go b/x/stake/commands/tx.go
index bc8f93e8f..55e009db0 100644
--- a/x/stake/commands/tx.go
+++ b/x/stake/commands/tx.go
@@ -49,6 +49,7 @@ func init() {
 	fsCandidate.String(FlagIdentity, "", "optional keybase signature")
 	fsCandidate.String(FlagWebsite, "", "optional website")
 	fsCandidate.String(FlagAddressCandidate, "", "hex address of the validator/candidate")
+	fsDelegator.String(FlagAddressCandidate, "", "hex address of the delegator")
 	fsDelegator.String(FlagAddressDelegator, "", "hex address of the delegator")
 }
 
@@ -155,7 +156,6 @@ func GetCmdEditCandidacy(cdc *wire.Codec) *cobra.Command {
 		},
 	}
 
-	cmd.Flags().AddFlagSet(fsPk)
 	cmd.Flags().AddFlagSet(fsCandidate)
 	return cmd
 }
@@ -198,7 +198,6 @@ func GetCmdDelegate(cdc *wire.Codec) *cobra.Command {
 		},
 	}
 
-	cmd.Flags().AddFlagSet(fsPk)
 	cmd.Flags().AddFlagSet(fsAmount)
 	cmd.Flags().AddFlagSet(fsDelegator)
 	return cmd
@@ -252,7 +251,6 @@ func GetCmdUnbond(cdc *wire.Codec) *cobra.Command {
 		},
 	}
 
-	cmd.Flags().AddFlagSet(fsPk)
 	cmd.Flags().AddFlagSet(fsShares)
 	cmd.Flags().AddFlagSet(fsDelegator)
 	return cmd
@@ -268,10 +266,10 @@ func GetPubKey(pubKeyStr string) (pk crypto.PubKey, err error) {
 		err = fmt.Errorf("must use --pubkey flag")
 		return
 	}
-	//if len(pubKeyStr) != 64 { //if len(pkBytes) != 32 {
-	//err = fmt.Errorf("pubkey must be Ed25519 hex encoded string which is 64 characters, this pubkey is %v characters", len(pubKeyStr))
-	//return
-	//}
+	if len(pubKeyStr) != 64 { //if len(pkBytes) != 32 {
+		err = fmt.Errorf("pubkey must be Ed25519 hex encoded string which is 64 characters, this pubkey is %v characters", len(pubKeyStr))
+		return
+	}
 
 	// TODO: bech32 ...
 	var pkBytes []byte

From c80b9674cddbaa5c62e8c3c6b61f749fdc190ac3 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Wed, 18 Apr 2018 00:33:33 -0400
Subject: [PATCH 20/26] stake CLI various fixes, confirmed working

---
 cmd/gaia/cmd/cli_test.go     |  43 +++++-----
 cmd/gaia/cmd/gaiacli/main.go |   4 +-
 server/init.go               |   2 +-
 tests/gobash.go              |  10 ++-
 x/stake/commands/flags.go    |  41 +++++++++
 x/stake/commands/query.go    | 160 ++++++++++++++++-------------------
 x/stake/commands/tx.go       |  52 +-----------
 x/stake/types.go             |   2 +-
 8 files changed, 153 insertions(+), 161 deletions(-)
 create mode 100644 x/stake/commands/flags.go

diff --git a/cmd/gaia/cmd/cli_test.go b/cmd/gaia/cmd/cli_test.go
index 8011d7a69..b1af5f7b7 100644
--- a/cmd/gaia/cmd/cli_test.go
+++ b/cmd/gaia/cmd/cli_test.go
@@ -23,7 +23,7 @@ import (
 
 func TestGaiaCLISend(t *testing.T) {
 
-	tests.ExecuteT(t, "gaiad unsafe_reset_all")
+	tests.ExecuteT(t, "gaiad unsafe_reset_all", 1)
 	pass := "1234567890"
 	executeWrite(t, "gaiacli keys delete foo", pass)
 	executeWrite(t, "gaiacli keys delete bar", pass)
@@ -57,7 +57,7 @@ func TestGaiaCLISend(t *testing.T) {
 
 func TestGaiaCLIDeclareCandidacy(t *testing.T) {
 
-	tests.ExecuteT(t, "gaiad unsafe_reset_all")
+	tests.ExecuteT(t, "gaiad unsafe_reset_all", 1)
 	pass := "1234567890"
 	executeWrite(t, "gaiacli keys delete foo", pass)
 	masterKey, chainID := executeInit(t, "gaiad init")
@@ -76,18 +76,6 @@ func TestGaiaCLIDeclareCandidacy(t *testing.T) {
 	assert.Equal(t, int64(100000), fooAcc.GetCoins().AmountOf("fermion"))
 
 	// declare candidacy
-	//--address-candidate string   hex address of the validator/candidate
-	//--amount string              Amount of coins to bond (default "1fermion")
-	//--chain-id string            Chain ID of tendermint node
-	//--fee string                 Fee to pay along with transaction
-	//--keybase-sig string         optional keybase signature
-	//--moniker string             validator-candidate name
-	//--name string                Name of private key with which to sign
-	//--node string                <host>:<port> to tendermint rpc interface for this chain (default "tcp://localhost:46657")
-	//--pubkey string              PubKey of the validator-candidate
-	//--sequence int               Sequence number to sign the tx
-	//--website string             optional website
-	//_ = fooPubKey
 	declStr := fmt.Sprintf("gaiacli declare-candidacy %v", flags)
 	declStr += fmt.Sprintf(" --name=%v", "foo")
 	declStr += fmt.Sprintf(" --address-candidate=%v", fooAddr)
@@ -99,8 +87,25 @@ func TestGaiaCLIDeclareCandidacy(t *testing.T) {
 	time.Sleep(time.Second * 3) // waiting for some blocks to pass
 	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
 	assert.Equal(t, int64(99997), fooAcc.GetCoins().AmountOf("fermion"))
-	candidate := executeGetCandidate(t, fmt.Sprintf("gaiacli candidate %v --address=%v", flags, fooAddr))
+	candidate := executeGetCandidate(t, fmt.Sprintf("gaiacli candidate %v --address-candidate=%v", flags, fooAddr))
 	assert.Equal(t, candidate.Address.String(), fooAddr)
+	assert.Equal(t, int64(3), candidate.Assets.Evaluate())
+
+	// TODO figure out why this times out with connection refused errors in go-bash
+	// unbond a single share
+	//unbondStr := fmt.Sprintf("gaiacli unbond %v", flags)
+	//unbondStr += fmt.Sprintf(" --name=%v", "foo")
+	//unbondStr += fmt.Sprintf(" --address-candidate=%v", fooAddr)
+	//unbondStr += fmt.Sprintf(" --address-delegator=%v", fooAddr)
+	//unbondStr += fmt.Sprintf(" --shares=%v", "1")
+	//unbondStr += fmt.Sprintf(" --sequence=%v", "1")
+	//fmt.Printf("debug unbondStr: %v\n", unbondStr)
+	//executeWrite(t, unbondStr, pass)
+	//time.Sleep(time.Second * 3) // waiting for some blocks to pass
+	//fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
+	//assert.Equal(t, int64(99998), fooAcc.GetCoins().AmountOf("fermion"))
+	//candidate = executeGetCandidate(t, fmt.Sprintf("gaiacli candidate %v --address-candidate=%v", flags, fooAddr))
+	//assert.Equal(t, int64(2), candidate.Assets.Evaluate())
 }
 
 func executeWrite(t *testing.T, cmdStr string, writes ...string) {
@@ -128,7 +133,7 @@ func executeWritePrint(t *testing.T, cmdStr string, writes ...string) {
 }
 
 func executeInit(t *testing.T, cmdStr string) (masterKey, chainID string) {
-	out := tests.ExecuteT(t, cmdStr)
+	out := tests.ExecuteT(t, cmdStr, 1)
 	outCut := "{" + strings.SplitN(out, "{", 2)[1] // weird I'm sorry
 
 	var initRes map[string]json.RawMessage
@@ -142,7 +147,7 @@ func executeInit(t *testing.T, cmdStr string) (masterKey, chainID string) {
 }
 
 func executeGetAddr(t *testing.T, cmdStr string) (addr, pubKey string) {
-	out := tests.ExecuteT(t, cmdStr)
+	out := tests.ExecuteT(t, cmdStr, 2)
 	var info crkeys.Info
 	keys.UnmarshalJSON([]byte(out), &info)
 	pubKey = hex.EncodeToString(info.PubKey.(crypto.PubKeyEd25519).Bytes())
@@ -158,7 +163,7 @@ func executeGetAddr(t *testing.T, cmdStr string) (addr, pubKey string) {
 }
 
 func executeGetAccount(t *testing.T, cmdStr string) auth.BaseAccount {
-	out := tests.ExecuteT(t, cmdStr)
+	out := tests.ExecuteT(t, cmdStr, 2)
 	var initRes map[string]json.RawMessage
 	err := json.Unmarshal([]byte(out), &initRes)
 	require.NoError(t, err, "out %v, err %v", out, err)
@@ -170,7 +175,7 @@ func executeGetAccount(t *testing.T, cmdStr string) auth.BaseAccount {
 }
 
 func executeGetCandidate(t *testing.T, cmdStr string) stake.Candidate {
-	out := tests.ExecuteT(t, cmdStr)
+	out := tests.ExecuteT(t, cmdStr, 2)
 	var candidate stake.Candidate
 	cdc := app.MakeCodec()
 	err := cdc.UnmarshalJSON([]byte(out), &candidate)
diff --git a/cmd/gaia/cmd/gaiacli/main.go b/cmd/gaia/cmd/gaiacli/main.go
index c5c3190c3..1e5528308 100644
--- a/cmd/gaia/cmd/gaiacli/main.go
+++ b/cmd/gaia/cmd/gaiacli/main.go
@@ -48,10 +48,10 @@ func main() {
 	rootCmd.AddCommand(
 		client.GetCommands(
 			authcmd.GetAccountCmd("main", cdc, authcmd.GetAccountDecoder(cdc)),
-			stakecmd.GetCmdQueryCandidates("stake", cdc),
 			stakecmd.GetCmdQueryCandidate("stake", cdc),
+			//stakecmd.GetCmdQueryCandidates("stake", cdc),
 			stakecmd.GetCmdQueryDelegatorBond("stake", cdc),
-			stakecmd.GetCmdQueryDelegatorBonds("stake", cdc),
+			//stakecmd.GetCmdQueryDelegatorBonds("stake", cdc),
 		)...)
 	rootCmd.AddCommand(
 		client.PostCommands(
diff --git a/server/init.go b/server/init.go
index 8c82d2796..f2578cb19 100644
--- a/server/init.go
+++ b/server/init.go
@@ -70,7 +70,7 @@ func (c initCmd) run(cmd *cobra.Command, args []string) error {
 		return nil
 	}
 
-	// generate secrete and address
+	// generate secret and address
 	addr, secret, err := GenerateCoinKey()
 	if err != nil {
 		return err
diff --git a/tests/gobash.go b/tests/gobash.go
index 12b3da085..c106c1f3f 100644
--- a/tests/gobash.go
+++ b/tests/gobash.go
@@ -1,6 +1,7 @@
 package tests
 
 import (
+	"fmt"
 	"io"
 	"os/exec"
 	"strings"
@@ -25,10 +26,15 @@ func getCmd(t *testing.T, command string) *exec.Cmd {
 	return cmd
 }
 
-// Execute the command, return standard output and error
-func ExecuteT(t *testing.T, command string) (out string) {
+// Execute the command, return standard output and error, try a few times if requested
+func ExecuteT(t *testing.T, command string, trials int) (out string) {
 	cmd := getCmd(t, command)
 	bz, err := cmd.CombinedOutput()
+	if err != nil && trials > 1 {
+		fmt.Printf("trial %v, retrying: %v\n", trials, command)
+		time.Sleep(time.Second * 10)
+		return ExecuteT(t, command, trials-1)
+	}
 	require.NoError(t, err, string(bz))
 	out = strings.Trim(string(bz), "\n") //trim any new lines
 	time.Sleep(time.Second)
diff --git a/x/stake/commands/flags.go b/x/stake/commands/flags.go
new file mode 100644
index 000000000..e5b97d62c
--- /dev/null
+++ b/x/stake/commands/flags.go
@@ -0,0 +1,41 @@
+package commands
+
+import (
+	flag "github.com/spf13/pflag"
+)
+
+// nolint
+const (
+	FlagAddressDelegator = "address-delegator"
+	FlagAddressCandidate = "address-candidate"
+	FlagPubKey           = "pubkey"
+	FlagAmount           = "amount"
+	FlagShares           = "shares"
+
+	FlagMoniker  = "moniker"
+	FlagIdentity = "keybase-sig"
+	FlagWebsite  = "website"
+	FlagDetails  = "details"
+)
+
+// common flagsets to add to various functions
+var (
+	fsPk          = flag.NewFlagSet("", flag.ContinueOnError)
+	fsAmount      = flag.NewFlagSet("", flag.ContinueOnError)
+	fsShares      = flag.NewFlagSet("", flag.ContinueOnError)
+	fsDescription = flag.NewFlagSet("", flag.ContinueOnError)
+	fsCandidate   = flag.NewFlagSet("", flag.ContinueOnError)
+	fsDelegator   = flag.NewFlagSet("", flag.ContinueOnError)
+)
+
+func init() {
+	fsPk.String(FlagPubKey, "", "PubKey of the validator-candidate")
+	fsAmount.String(FlagAmount, "1fermion", "Amount of coins to bond")
+	fsShares.String(FlagShares, "", "Amount of shares to unbond, either in decimal or keyword MAX (ex. 1.23456789, 99, MAX)")
+	fsDescription.String(FlagMoniker, "", "validator-candidate name")
+	fsDescription.String(FlagIdentity, "", "optional keybase signature")
+	fsDescription.String(FlagWebsite, "", "optional website")
+	fsDescription.String(FlagDetails, "", "optional details")
+	fsCandidate.String(FlagAddressCandidate, "", "hex address of the validator/candidate")
+	fsDelegator.String(FlagAddressDelegator, "", "hex address of the delegator")
+}
diff --git a/x/stake/commands/query.go b/x/stake/commands/query.go
index 187de702c..3bc2cffa7 100644
--- a/x/stake/commands/query.go
+++ b/x/stake/commands/query.go
@@ -5,7 +5,6 @@ import (
 	"fmt"
 
 	"github.com/spf13/cobra"
-	flag "github.com/spf13/pflag"
 	"github.com/spf13/viper"
 
 	crypto "github.com/tendermint/go-crypto"
@@ -16,56 +15,41 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/stake"
 )
 
-//nolint
-var (
-	fsValAddr         = flag.NewFlagSet("", flag.ContinueOnError)
-	fsDelAddr         = flag.NewFlagSet("", flag.ContinueOnError)
-	FlagValidatorAddr = "address"
-	FlagDelegatorAddr = "delegator-address"
-)
+//// create command to query for all candidates
+//func GetCmdQueryCandidates(storeName string, cdc *wire.Codec) *cobra.Command {
+//cmd := &cobra.Command{
+//Use:   "candidates",
+//Short: "Query for the set of validator-candidates pubkeys",
+//RunE: func(cmd *cobra.Command, args []string) error {
 
-func init() {
-	//Add Flags
-	fsValAddr.String(FlagValidatorAddr, "", "Address of the validator/candidate")
-	fsDelAddr.String(FlagDelegatorAddr, "", "Delegator hex address")
+//key := stake.CandidatesKey
 
-}
+//ctx := context.NewCoreContextFromViper()
+//res, err := ctx.Query(key, storeName)
+//if err != nil {
+//return err
+//}
 
-// create command to query for all candidates
-func GetCmdQueryCandidates(storeName string, cdc *wire.Codec) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "candidates",
-		Short: "Query for the set of validator-candidates pubkeys",
-		RunE: func(cmd *cobra.Command, args []string) error {
+//// parse out the candidates
+//candidates := new(stake.Candidates)
+//err = cdc.UnmarshalBinary(res, candidates)
+//if err != nil {
+//return err
+//}
+//output, err := wire.MarshalJSONIndent(cdc, candidates)
+//if err != nil {
+//return err
+//}
+//fmt.Println(string(output))
+//return nil
 
-			key := stake.CandidatesKey
+//// TODO output with proofs / machine parseable etc.
+//},
+//}
 
-			ctx := context.NewCoreContextFromViper()
-			res, err := ctx.Query(key, storeName)
-			if err != nil {
-				return err
-			}
-
-			// parse out the candidates
-			candidates := new(stake.Candidates)
-			err = cdc.UnmarshalBinary(res, candidates)
-			if err != nil {
-				return err
-			}
-			output, err := wire.MarshalJSONIndent(cdc, candidates)
-			if err != nil {
-				return err
-			}
-			fmt.Println(string(output))
-			return nil
-
-			// TODO output with proofs / machine parseable etc.
-		},
-	}
-
-	cmd.Flags().AddFlagSet(fsDelAddr)
-	return cmd
-}
+//cmd.Flags().AddFlagSet(fsDelegator)
+//return cmd
+//}
 
 // get the command to query a candidate
 func GetCmdQueryCandidate(storeName string, cdc *wire.Codec) *cobra.Command {
@@ -74,7 +58,7 @@ func GetCmdQueryCandidate(storeName string, cdc *wire.Codec) *cobra.Command {
 		Short: "Query a validator-candidate account",
 		RunE: func(cmd *cobra.Command, args []string) error {
 
-			addr, err := sdk.GetAddress(viper.GetString(FlagValidatorAddr))
+			addr, err := sdk.GetAddress(viper.GetString(FlagAddressCandidate))
 			if err != nil {
 				return err
 			}
@@ -105,7 +89,7 @@ func GetCmdQueryCandidate(storeName string, cdc *wire.Codec) *cobra.Command {
 		},
 	}
 
-	cmd.Flags().AddFlagSet(fsValAddr)
+	cmd.Flags().AddFlagSet(fsCandidate)
 	return cmd
 }
 
@@ -116,12 +100,12 @@ func GetCmdQueryDelegatorBond(storeName string, cdc *wire.Codec) *cobra.Command
 		Short: "Query a delegators bond based on address and candidate pubkey",
 		RunE: func(cmd *cobra.Command, args []string) error {
 
-			addr, err := sdk.GetAddress(viper.GetString(FlagValidatorAddr))
+			addr, err := sdk.GetAddress(viper.GetString(FlagAddressCandidate))
 			if err != nil {
 				return err
 			}
 
-			bz, err := hex.DecodeString(viper.GetString(FlagDelegatorAddr))
+			bz, err := hex.DecodeString(viper.GetString(FlagAddressDelegator))
 			if err != nil {
 				return err
 			}
@@ -137,7 +121,7 @@ func GetCmdQueryDelegatorBond(storeName string, cdc *wire.Codec) *cobra.Command
 			}
 
 			// parse out the bond
-			var bond stake.DelegatorBond
+			bond := new(stake.DelegatorBond)
 			err = cdc.UnmarshalBinary(res, bond)
 			if err != nil {
 				return err
@@ -153,49 +137,49 @@ func GetCmdQueryDelegatorBond(storeName string, cdc *wire.Codec) *cobra.Command
 		},
 	}
 
-	cmd.Flags().AddFlagSet(fsValAddr)
-	cmd.Flags().AddFlagSet(fsDelAddr)
+	cmd.Flags().AddFlagSet(fsCandidate)
+	cmd.Flags().AddFlagSet(fsDelegator)
 	return cmd
 }
 
-// get the command to query all the candidates bonded to a delegator
-func GetCmdQueryDelegatorBonds(storeName string, cdc *wire.Codec) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "delegator-candidates",
-		Short: "Query all delegators candidates' pubkeys based on address",
-		RunE: func(cmd *cobra.Command, args []string) error {
+//// get the command to query all the candidates bonded to a delegator
+//func GetCmdQueryDelegatorBonds(storeName string, cdc *wire.Codec) *cobra.Command {
+//cmd := &cobra.Command{
+//Use:   "delegator-candidates",
+//Short: "Query all delegators bond's candidate-addresses based on delegator-address",
+//RunE: func(cmd *cobra.Command, args []string) error {
 
-			bz, err := hex.DecodeString(viper.GetString(FlagDelegatorAddr))
-			if err != nil {
-				return err
-			}
-			delegator := crypto.Address(bz)
+//bz, err := hex.DecodeString(viper.GetString(FlagAddressDelegator))
+//if err != nil {
+//return err
+//}
+//delegator := crypto.Address(bz)
 
-			key := stake.GetDelegatorBondsKey(delegator, cdc)
+//key := stake.GetDelegatorBondsKey(delegator, cdc)
 
-			ctx := context.NewCoreContextFromViper()
+//ctx := context.NewCoreContextFromViper()
 
-			res, err := ctx.Query(key, storeName)
-			if err != nil {
-				return err
-			}
+//res, err := ctx.Query(key, storeName)
+//if err != nil {
+//return err
+//}
 
-			// parse out the candidates list
-			var candidates []crypto.PubKey
-			err = cdc.UnmarshalBinary(res, candidates)
-			if err != nil {
-				return err
-			}
-			output, err := wire.MarshalJSONIndent(cdc, candidates)
-			if err != nil {
-				return err
-			}
-			fmt.Println(string(output))
-			return nil
+//// parse out the candidates list
+//var candidates []crypto.PubKey
+//err = cdc.UnmarshalBinary(res, candidates)
+//if err != nil {
+//return err
+//}
+//output, err := wire.MarshalJSONIndent(cdc, candidates)
+//if err != nil {
+//return err
+//}
+//fmt.Println(string(output))
+//return nil
 
-			// TODO output with proofs / machine parseable etc.
-		},
-	}
-	cmd.Flags().AddFlagSet(fsDelAddr)
-	return cmd
-}
+//// TODO output with proofs / machine parseable etc.
+//},
+//}
+//cmd.Flags().AddFlagSet(fsDelegator)
+//return cmd
+//}
diff --git a/x/stake/commands/tx.go b/x/stake/commands/tx.go
index 55e009db0..4a1983743 100644
--- a/x/stake/commands/tx.go
+++ b/x/stake/commands/tx.go
@@ -5,12 +5,10 @@ import (
 	"fmt"
 
 	"github.com/spf13/cobra"
-	flag "github.com/spf13/pflag"
 	"github.com/spf13/viper"
 
 	crypto "github.com/tendermint/go-crypto"
 
-	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/context"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/wire"
@@ -18,52 +16,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/stake"
 )
 
-// nolint
-const (
-	FlagAddressDelegator = "address-delegator"
-	FlagAddressCandidate = "address-candidate"
-	FlagPubKey           = "pubkey"
-	FlagAmount           = "amount"
-	FlagShares           = "shares"
-
-	FlagMoniker  = "moniker"
-	FlagIdentity = "keybase-sig"
-	FlagWebsite  = "website"
-	FlagDetails  = "details"
-)
-
-// common flagsets to add to various functions
-var (
-	fsPk        = flag.NewFlagSet("", flag.ContinueOnError)
-	fsAmount    = flag.NewFlagSet("", flag.ContinueOnError)
-	fsShares    = flag.NewFlagSet("", flag.ContinueOnError)
-	fsCandidate = flag.NewFlagSet("", flag.ContinueOnError)
-	fsDelegator = flag.NewFlagSet("", flag.ContinueOnError)
-)
-
-func init() {
-	fsPk.String(FlagPubKey, "", "PubKey of the validator-candidate")
-	fsAmount.String(FlagAmount, "1fermion", "Amount of coins to bond")
-	fsShares.String(FlagShares, "", "Amount of shares to unbond, either in decimal or keyword MAX (ex. 1.23456789, 99, MAX)")
-	fsCandidate.String(FlagMoniker, "", "validator-candidate name")
-	fsCandidate.String(FlagIdentity, "", "optional keybase signature")
-	fsCandidate.String(FlagWebsite, "", "optional website")
-	fsCandidate.String(FlagAddressCandidate, "", "hex address of the validator/candidate")
-	fsDelegator.String(FlagAddressCandidate, "", "hex address of the delegator")
-	fsDelegator.String(FlagAddressDelegator, "", "hex address of the delegator")
-}
-
-//TODO refactor to common functionality
-func getNamePassword() (name, passphrase string, err error) {
-	name = viper.GetString(client.FlagName)
-	buf := client.BufferStdin()
-	prompt := fmt.Sprintf("Password to sign with '%s':", name)
-	passphrase, err = client.GetPassword(prompt, buf)
-	return
-}
-
-//_________________________________________________________________________________________
-
 // create declare candidacy command
 func GetCmdDeclareCandidacy(cdc *wire.Codec) *cobra.Command {
 	cmd := &cobra.Command{
@@ -114,6 +66,7 @@ func GetCmdDeclareCandidacy(cdc *wire.Codec) *cobra.Command {
 
 	cmd.Flags().AddFlagSet(fsPk)
 	cmd.Flags().AddFlagSet(fsAmount)
+	cmd.Flags().AddFlagSet(fsDescription)
 	cmd.Flags().AddFlagSet(fsCandidate)
 	return cmd
 }
@@ -156,6 +109,7 @@ func GetCmdEditCandidacy(cdc *wire.Codec) *cobra.Command {
 		},
 	}
 
+	cmd.Flags().AddFlagSet(fsDescription)
 	cmd.Flags().AddFlagSet(fsCandidate)
 	return cmd
 }
@@ -200,6 +154,7 @@ func GetCmdDelegate(cdc *wire.Codec) *cobra.Command {
 
 	cmd.Flags().AddFlagSet(fsAmount)
 	cmd.Flags().AddFlagSet(fsDelegator)
+	cmd.Flags().AddFlagSet(fsCandidate)
 	return cmd
 }
 
@@ -253,6 +208,7 @@ func GetCmdUnbond(cdc *wire.Codec) *cobra.Command {
 
 	cmd.Flags().AddFlagSet(fsShares)
 	cmd.Flags().AddFlagSet(fsDelegator)
+	cmd.Flags().AddFlagSet(fsCandidate)
 	return cmd
 }
 
diff --git a/x/stake/types.go b/x/stake/types.go
index b0dbc0b1f..9f7d97ae5 100644
--- a/x/stake/types.go
+++ b/x/stake/types.go
@@ -153,7 +153,7 @@ func (v Validator) abciValidatorZero(cdc *wire.Codec) abci.Validator {
 // pubKey.
 // TODO better way of managing space
 type DelegatorBond struct {
-	DelegatorAddr sdk.Address `json:"delegatoraddr"`
+	DelegatorAddr sdk.Address `json:"delegator_addr"`
 	CandidateAddr sdk.Address `json:"candidate_addr"`
 	Shares        sdk.Rat     `json:"shares"`
 }

From 2994af56c9589711c192cf7ef8a4811567c84771 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Wed, 18 Apr 2018 12:36:55 -0400
Subject: [PATCH 21/26] gaia new error codetype

---
 cmd/gaia/app/app.go      | 15 +++++++---
 cmd/gaia/app/app_test.go | 64 ++++++++++++++--------------------------
 x/stake/keeper.go        |  2 +-
 x/stake/test_common.go   |  2 +-
 4 files changed, 35 insertions(+), 48 deletions(-)

diff --git a/cmd/gaia/app/app.go b/cmd/gaia/app/app.go
index 0c9ef8b55..57a5d672c 100644
--- a/cmd/gaia/app/app.go
+++ b/cmd/gaia/app/app.go
@@ -37,6 +37,9 @@ type GaiaApp struct {
 	coinKeeper    bank.CoinKeeper
 	ibcMapper     ibc.IBCMapper
 	stakeKeeper   stake.Keeper
+
+	// Handle fees
+	feeHandler sdk.FeeHandler
 }
 
 func NewGaiaApp(logger log.Logger, db dbm.DB) *GaiaApp {
@@ -59,19 +62,23 @@ func NewGaiaApp(logger log.Logger, db dbm.DB) *GaiaApp {
 
 	// add handlers
 	app.coinKeeper = bank.NewCoinKeeper(app.accountMapper)
-	app.ibcMapper = ibc.NewIBCMapper(app.cdc, app.capKeyIBCStore)
-	app.stakeKeeper = stake.NewKeeper(app.cdc, app.capKeyStakeStore, app.coinKeeper)
+	app.ibcMapper = ibc.NewIBCMapper(app.cdc, app.capKeyIBCStore, app.RegisterCodespace(ibc.DefaultCodespace))
+	app.stakeKeeper = stake.NewKeeper(app.cdc, app.capKeyStakeStore, app.coinKeeper, app.RegisterCodespace(stake.DefaultCodespace))
+
 	app.Router().
 		AddRoute("bank", bank.NewHandler(app.coinKeeper)).
 		AddRoute("ibc", ibc.NewHandler(app.ibcMapper, app.coinKeeper)).
 		AddRoute("stake", stake.NewHandler(app.stakeKeeper))
 
+	// Define the feeHandler.
+	app.feeHandler = auth.BurnFeeHandler
+
 	// initialize BaseApp
 	app.SetTxDecoder(app.txDecoder)
 	app.SetInitChainer(app.initChainer)
 	app.SetEndBlocker(stake.NewEndBlocker(app.stakeKeeper))
 	app.MountStoresIAVL(app.capKeyMainStore, app.capKeyAccountStore, app.capKeyIBCStore, app.capKeyStakeStore)
-	app.SetAnteHandler(auth.NewAnteHandler(app.accountMapper))
+	app.SetAnteHandler(auth.NewAnteHandler(app.accountMapper, app.feeHandler))
 	err := app.LoadLatestVersion(app.capKeyMainStore)
 	if err != nil {
 		cmn.Exit(err.Error())
@@ -113,7 +120,7 @@ func (app *GaiaApp) txDecoder(txBytes []byte) (sdk.Tx, sdk.Error) {
 	// are registered by MakeTxCodec
 	err := app.cdc.UnmarshalBinary(txBytes, &tx)
 	if err != nil {
-		return nil, sdk.ErrTxDecode("").TraceCause(err, "")
+		return nil, sdk.ErrTxDecode("").Trace(err.Error())
 	}
 	return tx, nil
 }
diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
index 5c8450138..bd339c75a 100644
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@@ -9,6 +9,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/cosmos/cosmos-sdk/examples/basecoin/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
@@ -138,48 +139,27 @@ func TestMsgs(t *testing.T) {
 	}
 }
 
-func TestSortGenesis(t *testing.T) {
-	logger, dbs := loggerAndDB()
-	gapp := NewGaiaApp(logger, dbs)
+func setGenesisAccounts(gapp *GaiaApp, accs ...auth.BaseAccount) error {
+	genaccs := make([]*types.GenesisAccount, len(accs))
+	for i, acc := range accs {
+		genaccs[i] = types.NewGenesisAccount(&types.AppAccount{acc, accName})
+	}
 
-	// Note the order: the coins are unsorted!
-	coinDenom1, coinDenom2 := "foocoin", "barcoin"
+	genesisState := types.GenesisState{
+		Accounts: genaccs,
+	}
 
-	str := `{
-      "accounts": [{
-        "address": "%s",
-        "coins": [
-          {
-            "denom": "%s",
-            "amount": 10
-          },
-          {
-            "denom": "%s",
-            "amount": 20
-          }
-        ]
-      }]
-    }`
-	genState := fmt.Sprintf(str, addr1.String(), coinDenom1, coinDenom2)
+	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
+	if err != nil {
+		return err
+	}
 
 	// Initialize the chain
 	vals := []abci.Validator{}
-	gapp.InitChain(abci.RequestInitChain{vals, []byte(genState)})
+	gapp.InitChain(abci.RequestInitChain{vals, stateBytes})
 	gapp.Commit()
 
-	// Unsorted coins means invalid
-	err := sendMsg5.ValidateBasic()
-	require.Equal(t, sdk.CodeInvalidCoins, err.ABCICode(), err.ABCILog())
-
-	// Sort coins, should be valid
-	sendMsg5.Inputs[0].Coins.Sort()
-	sendMsg5.Outputs[0].Coins.Sort()
-	err = sendMsg5.ValidateBasic()
-	require.Nil(t, err)
-
-	// Ensure we can send
-	require.Nil(t, setGenesis(gapp)) // initialize the pool
-	SignCheckDeliver(t, gapp, sendMsg5, []int64{0}, true, priv1)
+	return nil
 }
 
 func TestGenesis(t *testing.T) {
@@ -247,7 +227,7 @@ func TestSendMsgWithAccounts(t *testing.T) {
 	tx.Signatures[0].Sequence = 1
 	res := gapp.Deliver(tx)
 
-	assert.Equal(t, sdk.CodeUnauthorized, res.Code, res.Log)
+	assert.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, sdk.CodeUnauthorized), res.Code, res.Log)
 
 	// resigning the tx with the bumped sequence should work
 	SignCheckDeliver(t, gapp, sendMsg1, []int64{1}, true, priv1)
@@ -498,18 +478,18 @@ func SignCheckDeliver(t *testing.T, gapp *GaiaApp, msg sdk.Msg, seq []int64, exp
 	// Run a Check
 	res := gapp.Check(tx)
 	if expPass {
-		require.Equal(t, sdk.CodeOK, res.Code, res.Log)
+		require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log)
 	} else {
-		require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
+		require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log)
 	}
 
 	// Simulate a Block
 	gapp.BeginBlock(abci.RequestBeginBlock{})
 	res = gapp.Deliver(tx)
 	if expPass {
-		require.Equal(t, sdk.CodeOK, res.Code, res.Log)
+		require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log)
 	} else {
-		require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
+		require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log)
 	}
 	gapp.EndBlock(abci.RequestEndBlock{})
 
@@ -530,9 +510,9 @@ func SignDeliver(t *testing.T, gapp *GaiaApp, msg sdk.Msg, seq []int64, expPass
 	gapp.BeginBlock(abci.RequestBeginBlock{})
 	res := gapp.Deliver(tx)
 	if expPass {
-		require.Equal(t, sdk.CodeOK, res.Code, res.Log)
+		require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log)
 	} else {
-		require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
+		require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log)
 	}
 	gapp.EndBlock(abci.RequestEndBlock{})
 }
diff --git a/x/stake/keeper.go b/x/stake/keeper.go
index c2b054eba..751b84017 100644
--- a/x/stake/keeper.go
+++ b/x/stake/keeper.go
@@ -23,7 +23,7 @@ type Keeper struct {
 	codespace sdk.CodespaceType
 }
 
-func NewKeeper(ctx sdk.Context, cdc *wire.Codec, key sdk.StoreKey, ck bank.CoinKeeper, codespace sdk.CodespaceType) Keeper {
+func NewKeeper(cdc *wire.Codec, key sdk.StoreKey, ck bank.CoinKeeper, codespace sdk.CodespaceType) Keeper {
 	keeper := Keeper{
 		storeKey:   key,
 		cdc:        cdc,
diff --git a/x/stake/test_common.go b/x/stake/test_common.go
index 75781777a..1de86c912 100644
--- a/x/stake/test_common.go
+++ b/x/stake/test_common.go
@@ -140,7 +140,7 @@ func createTestInput(t *testing.T, isCheckTx bool, initCoins int64) (sdk.Context
 		&auth.BaseAccount{}, // prototype
 	).Seal()
 	ck := bank.NewCoinKeeper(accountMapper)
-	keeper := NewKeeper(ctx, cdc, keyStake, ck, DefaultCodespace)
+	keeper := NewKeeper(cdc, keyStake, ck, DefaultCodespace)
 	keeper.setPool(ctx, initialPool())
 	keeper.setParams(ctx, defaultParams())
 

From 8c59ced191c96e51355aca0a79b20488f341b429 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Wed, 18 Apr 2018 12:39:59 -0400
Subject: [PATCH 22/26] changelog

---
 CHANGELOG.md | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2cfbe82dd..d31ce6cbb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,10 +7,13 @@ FEATURES:
 * Add CacheContext
 * Add auto sequencing to client
 * Add FeeHandler to ante handler
+* Gaia stake commands include, DeclareCandidacy, EditCandidacy, Delegate, Unbond
+* MountStoreWithDB without providing a custom store works.
 
 BREAKING CHANGES
 
 * Remove go-wire, use go-amino
+* Gaia simple-staking bond and unbond functions replaced 
 * [store] Add `SubspaceIterator` and `ReverseSubspaceIterator` to `KVStore` interface
 * [basecoin] NewBasecoinApp takes a `dbm.DB` and uses namespaced DBs for substores
 * All module keepers now require a codespace, see basecoin or democoin for usage
@@ -18,12 +21,6 @@ BREAKING CHANGES
 BUG FIXES
 * Gaia now uses stake, ported from github.com/cosmos/gaia
 
-FEATURES:
-
-* Add CacheContext
-* Gaia stake commands include, DeclareCandidacy, EditCandidacy, Delegate, Unbond
-* MountStoreWithDB without providing a custom store works.
-
 ## 0.14.1 (April 9, 2018)
 
 BUG FIXES

From be93b760e779c21925dd4d76d0b081d9797ec1a6 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Wed, 18 Apr 2018 13:23:47 -0400
Subject: [PATCH 23/26] circle make install

int
---
 .circleci/config.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 6754ebc05..c6cb56a1e 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -31,7 +31,7 @@ jobs:
           name: binaries
           command: |
             export PATH="$GOBIN:$PATH"
-            make build
+            make install
       - persist_to_workspace:
           root: /tmp/workspace
           paths:
@@ -59,6 +59,8 @@ jobs:
       - run:
           name: Run tests
           command: |
+            export PATH="$GOBIN:$PATH"
+            make install
             for pkg in $(go list github.com/cosmos/cosmos-sdk/... | grep -v /vendor/ | circleci tests split --split-by=timings); do
               id=$(basename "$pkg")
 

From 6f65867154f73051a53be6b8cc0cdd59282782e6 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Wed, 18 Apr 2018 14:06:49 -0400
Subject: [PATCH 24/26] comment out go-bash race condition

---
 .circleci/config.yml                   | 2 +-
 cmd/gaia/{cmd => cli_test}/cli_test.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename cmd/gaia/{cmd => cli_test}/cli_test.go (99%)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index c6cb56a1e..47cb5661d 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -61,7 +61,7 @@ jobs:
           command: |
             export PATH="$GOBIN:$PATH"
             make install
-            for pkg in $(go list github.com/cosmos/cosmos-sdk/... | grep -v /vendor/ | circleci tests split --split-by=timings); do
+            for pkg in $(go list github.com/cosmos/cosmos-sdk/... | grep -v /vendor/ | grep -v github.com/cosmos/cosmos-sdk/cmd/gaia/cli_test | circleci tests split --split-by=timings); do
               id=$(basename "$pkg")
 
               go test -timeout 5m -race -coverprofile=/tmp/workspace/profiles/$id.out -covermode=atomic "$pkg"
diff --git a/cmd/gaia/cmd/cli_test.go b/cmd/gaia/cli_test/cli_test.go
similarity index 99%
rename from cmd/gaia/cmd/cli_test.go
rename to cmd/gaia/cli_test/cli_test.go
index b1af5f7b7..4b4a17dcd 100644
--- a/cmd/gaia/cmd/cli_test.go
+++ b/cmd/gaia/cli_test/cli_test.go
@@ -1,4 +1,4 @@
-package common
+package clitest
 
 import (
 	"encoding/hex"

From d36efcd4171ab8c747e9672e87a06a9f6b9ecd97 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Wed, 18 Apr 2018 14:21:07 -0400
Subject: [PATCH 25/26] unbond in gaia cli test

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

diff --git a/cmd/gaia/cli_test/cli_test.go b/cmd/gaia/cli_test/cli_test.go
index 4b4a17dcd..0d9a89578 100644
--- a/cmd/gaia/cli_test/cli_test.go
+++ b/cmd/gaia/cli_test/cli_test.go
@@ -93,19 +93,19 @@ func TestGaiaCLIDeclareCandidacy(t *testing.T) {
 
 	// TODO figure out why this times out with connection refused errors in go-bash
 	// unbond a single share
-	//unbondStr := fmt.Sprintf("gaiacli unbond %v", flags)
-	//unbondStr += fmt.Sprintf(" --name=%v", "foo")
-	//unbondStr += fmt.Sprintf(" --address-candidate=%v", fooAddr)
-	//unbondStr += fmt.Sprintf(" --address-delegator=%v", fooAddr)
-	//unbondStr += fmt.Sprintf(" --shares=%v", "1")
-	//unbondStr += fmt.Sprintf(" --sequence=%v", "1")
-	//fmt.Printf("debug unbondStr: %v\n", unbondStr)
-	//executeWrite(t, unbondStr, pass)
-	//time.Sleep(time.Second * 3) // waiting for some blocks to pass
-	//fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
-	//assert.Equal(t, int64(99998), fooAcc.GetCoins().AmountOf("fermion"))
-	//candidate = executeGetCandidate(t, fmt.Sprintf("gaiacli candidate %v --address-candidate=%v", flags, fooAddr))
-	//assert.Equal(t, int64(2), candidate.Assets.Evaluate())
+	unbondStr := fmt.Sprintf("gaiacli unbond %v", flags)
+	unbondStr += fmt.Sprintf(" --name=%v", "foo")
+	unbondStr += fmt.Sprintf(" --address-candidate=%v", fooAddr)
+	unbondStr += fmt.Sprintf(" --address-delegator=%v", fooAddr)
+	unbondStr += fmt.Sprintf(" --shares=%v", "1")
+	unbondStr += fmt.Sprintf(" --sequence=%v", "1")
+	fmt.Printf("debug unbondStr: %v\n", unbondStr)
+	executeWrite(t, unbondStr, pass)
+	time.Sleep(time.Second * 3) // waiting for some blocks to pass
+	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooAddr, flags))
+	assert.Equal(t, int64(99998), fooAcc.GetCoins().AmountOf("fermion"))
+	candidate = executeGetCandidate(t, fmt.Sprintf("gaiacli candidate %v --address-candidate=%v", flags, fooAddr))
+	assert.Equal(t, int64(2), candidate.Assets.Evaluate())
 }
 
 func executeWrite(t *testing.T, cmdStr string, writes ...string) {

From 0e8c3e4a5b3a806b0c3a200570a57e7258eb1239 Mon Sep 17 00:00:00 2001
From: rigelrozanski <rigel.rozanski@gmail.com>
Date: Wed, 18 Apr 2018 14:32:40 -0400
Subject: [PATCH 26/26] remove gaia basecoin reference

---
 cmd/gaia/app/app_test.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
index bd339c75a..b3350b503 100644
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@@ -9,7 +9,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/cosmos/cosmos-sdk/examples/basecoin/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
@@ -139,14 +138,15 @@ func TestMsgs(t *testing.T) {
 	}
 }
 
-func setGenesisAccounts(gapp *GaiaApp, accs ...auth.BaseAccount) error {
-	genaccs := make([]*types.GenesisAccount, len(accs))
+func setGenesisAccounts(gapp *GaiaApp, accs ...*auth.BaseAccount) error {
+	genaccs := make([]GenesisAccount, len(accs))
 	for i, acc := range accs {
-		genaccs[i] = types.NewGenesisAccount(&types.AppAccount{acc, accName})
+		genaccs[i] = NewGenesisAccount(acc)
 	}
 
-	genesisState := types.GenesisState{
-		Accounts: genaccs,
+	genesisState := GenesisState{
+		Accounts:  genaccs,
+		StakeData: stake.GetDefaultGenesisState(),
 	}
 
 	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")