Merge branch 'develop' into bianjie/lcd-lite-swagger-ui

cmd/cosmos-sdk-cli/cmd/init.go

@@ -60,6 +60,7 @@ func resolveProjectPath(remoteProjectPath string) string {
 	return gopath + string(os.PathSeparator) + "src" + string(os.PathSeparator) + remoteProjectPath
 }
 
+// nolint: unparam, errcheck
 func copyBasecoinTemplate(projectName string, projectPath string, remoteProjectPath string) {
 	basecoinProjectPath := resolveProjectPath(remoteBasecoinPath)
 	filepath.Walk(basecoinProjectPath, func(path string, f os.FileInfo, err error) error {
@@ -88,6 +89,7 @@ func copyBasecoinTemplate(projectName string, projectPath string, remoteProjectP
 	})
 }
 
+// nolint: errcheck
 func createGopkg(projectPath string) {
 	// Create gopkg.toml file
 	dependencies := map[string]string{
@@ -111,6 +113,7 @@ func createGopkg(projectPath string) {
 	ioutil.WriteFile(projectPath+"/Gopkg.toml", []byte(contents), os.ModePerm)
 }
 
+// nolint: errcheck
 func createMakefile(projectPath string) {
 	// Create makefile
 	// TODO: Should we use tools/ directory as in Cosmos-SDK to get tools for linting etc.

cmd/gaia/app/app.go

@@ -43,6 +43,7 @@ type GaiaApp struct {
 	keyAccount       *sdk.KVStoreKey
 	keyIBC           *sdk.KVStoreKey
 	keyStake         *sdk.KVStoreKey
+	tkeyStake        *sdk.TransientStoreKey
 	keySlashing      *sdk.KVStoreKey
 	keyGov           *sdk.KVStoreKey
 	keyFeeCollection *sdk.KVStoreKey
@@ -52,7 +53,7 @@ type GaiaApp struct {
 	// Manage getting and setting accounts
 	accountMapper       auth.AccountMapper
 	feeCollectionKeeper auth.FeeCollectionKeeper
-	coinKeeper          bank.Keeper
+	bankKeeper          bank.Keeper
 	ibcMapper           ibc.Mapper
 	stakeKeeper         stake.Keeper
 	slashingKeeper      slashing.Keeper
@@ -74,6 +75,7 @@ func NewGaiaApp(logger log.Logger, db dbm.DB, traceStore io.Writer, baseAppOptio
 		keyAccount:       sdk.NewKVStoreKey("acc"),
 		keyIBC:           sdk.NewKVStoreKey("ibc"),
 		keyStake:         sdk.NewKVStoreKey("stake"),
+		tkeyStake:        sdk.NewTransientStoreKey("transient_stake"),
 		keySlashing:      sdk.NewKVStoreKey("slashing"),
 		keyGov:           sdk.NewKVStoreKey("gov"),
 		keyFeeCollection: sdk.NewKVStoreKey("fee"),
@@ -89,19 +91,19 @@ func NewGaiaApp(logger log.Logger, db dbm.DB, traceStore io.Writer, baseAppOptio
 	)
 
 	// add handlers
-	app.coinKeeper = bank.NewKeeper(app.accountMapper)
+	app.bankKeeper = bank.NewBaseKeeper(app.accountMapper)
 	app.ibcMapper = ibc.NewMapper(app.cdc, app.keyIBC, app.RegisterCodespace(ibc.DefaultCodespace))
 	app.paramsKeeper = params.NewKeeper(app.cdc, app.keyParams)
-	app.stakeKeeper = stake.NewKeeper(app.cdc, app.keyStake, app.coinKeeper, app.RegisterCodespace(stake.DefaultCodespace))
+	app.stakeKeeper = stake.NewKeeper(app.cdc, app.keyStake, app.tkeyStake, app.bankKeeper, app.RegisterCodespace(stake.DefaultCodespace))
 	app.slashingKeeper = slashing.NewKeeper(app.cdc, app.keySlashing, app.stakeKeeper, app.paramsKeeper.Getter(), app.RegisterCodespace(slashing.DefaultCodespace))
 	app.stakeKeeper = app.stakeKeeper.WithValidatorHooks(app.slashingKeeper.ValidatorHooks())
-	app.govKeeper = gov.NewKeeper(app.cdc, app.keyGov, app.paramsKeeper.Setter(), app.coinKeeper, app.stakeKeeper, app.RegisterCodespace(gov.DefaultCodespace))
+	app.govKeeper = gov.NewKeeper(app.cdc, app.keyGov, app.paramsKeeper.Setter(), app.bankKeeper, app.stakeKeeper, app.RegisterCodespace(gov.DefaultCodespace))
 	app.feeCollectionKeeper = auth.NewFeeCollectionKeeper(app.cdc, app.keyFeeCollection)
 
 	// register message routes
 	app.Router().
-		AddRoute("bank", bank.NewHandler(app.coinKeeper)).
-		AddRoute("ibc", ibc.NewHandler(app.ibcMapper, app.coinKeeper)).
+		AddRoute("bank", bank.NewHandler(app.bankKeeper)).
+		AddRoute("ibc", ibc.NewHandler(app.ibcMapper, app.bankKeeper)).
 		AddRoute("stake", stake.NewHandler(app.stakeKeeper)).
 		AddRoute("slashing", slashing.NewHandler(app.slashingKeeper)).
 		AddRoute("gov", gov.NewHandler(app.govKeeper))
@@ -114,8 +116,9 @@ func NewGaiaApp(logger log.Logger, db dbm.DB, traceStore io.Writer, baseAppOptio
 	app.SetBeginBlocker(app.BeginBlocker)
 	app.SetEndBlocker(app.EndBlocker)
 	app.SetAnteHandler(auth.NewAnteHandler(app.accountMapper, app.feeCollectionKeeper))
-	app.MountStoresIAVL(app.keyMain, app.keyAccount, app.keyIBC, app.keyStake, app.keySlashing, app.keyGov, app.keyFeeCollection, app.keyParams)
-	app.MountStore(app.tkeyParams, sdk.StoreTypeTransient)
+	app.MountStoresIAVL(app.keyMain, app.keyAccount, app.keyIBC, app.keyStake,
+		app.keySlashing, app.keyGov, app.keyFeeCollection, app.keyParams)
+	app.MountStoresTransient(app.tkeyParams, app.tkeyStake)
 	err := app.LoadLatestVersion(app.keyMain)
 	if err != nil {
 		cmn.Exit(err.Error())
@@ -190,6 +193,11 @@ func (app *GaiaApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci
 	slashing.InitGenesis(ctx, app.slashingKeeper, genesisState.StakeData)
 
 	gov.InitGenesis(ctx, app.govKeeper, genesisState.GovData)
+	err = GaiaValidateGenesisState(genesisState)
+	if err != nil {
+		// TODO find a way to do this w/o panics
+		panic(err)
+	}
 
 	return abci.ResponseInitChain{
 		Validators: validators,

cmd/gaia/app/genesis.go

@@ -13,6 +13,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/stake"
+	stakeTypes "github.com/cosmos/cosmos-sdk/x/stake/types"
 
 	"github.com/spf13/pflag"
 
@@ -180,38 +181,12 @@ func GaiaAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (genesisState
 		}
 
 		// create the genesis account, give'm few steaks and a buncha token with there name
-		accAuth := auth.NewBaseAccountWithAddress(genTx.Address)
-		accAuth.Coins = sdk.Coins{
-			{genTx.Name + "Token", sdk.NewInt(1000)},
-			{"steak", freeFermionsAcc},
-		}
-		acc := NewGenesisAccount(&accAuth)
-		genaccs[i] = acc
+		genaccs[i] = genesisAccountFromGenTx(genTx)
 		stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewDecFromInt(freeFermionsAcc)) // increase the supply
 
 		// add the validator
 		if len(genTx.Name) > 0 {
-			desc := stake.NewDescription(genTx.Name, "", "", "")
-			validator := stake.NewValidator(
-				sdk.ValAddress(genTx.Address), sdk.MustGetConsPubKeyBech32(genTx.PubKey), desc,
-			)
-
-			stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewDec(freeFermionVal)) // increase the supply
-
-			// add some new shares to the validator
-			var issuedDelShares sdk.Dec
-			validator, stakeData.Pool, issuedDelShares = validator.AddTokensFromDel(stakeData.Pool, sdk.NewInt(freeFermionVal))
-			stakeData.Validators = append(stakeData.Validators, validator)
-
-			// create the self-delegation from the issuedDelShares
-			delegation := stake.Delegation{
-				DelegatorAddr: sdk.AccAddress(validator.Operator),
-				ValidatorAddr: validator.Operator,
-				Shares:        issuedDelShares,
-				Height:        0,
-			}
-
-			stakeData.Bonds = append(stakeData.Bonds, delegation)
+			stakeData = addValidatorToStakeData(genTx, stakeData)
 		}
 	}
 
@@ -224,6 +199,86 @@ func GaiaAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (genesisState
 	return
 }
 
+func addValidatorToStakeData(genTx GaiaGenTx, stakeData stake.GenesisState) stake.GenesisState {
+	desc := stake.NewDescription(genTx.Name, "", "", "")
+	validator := stake.NewValidator(
+		sdk.ValAddress(genTx.Address), sdk.MustGetConsPubKeyBech32(genTx.PubKey), desc,
+	)
+
+	stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewDec(freeFermionVal)) // increase the supply
+
+	// add some new shares to the validator
+	var issuedDelShares sdk.Dec
+	validator, stakeData.Pool, issuedDelShares = validator.AddTokensFromDel(stakeData.Pool, sdk.NewInt(freeFermionVal))
+	stakeData.Validators = append(stakeData.Validators, validator)
+
+	// create the self-delegation from the issuedDelShares
+	delegation := stake.Delegation{
+		DelegatorAddr: sdk.AccAddress(validator.OperatorAddr),
+		ValidatorAddr: validator.OperatorAddr,
+		Shares:        issuedDelShares,
+		Height:        0,
+	}
+
+	stakeData.Bonds = append(stakeData.Bonds, delegation)
+	return stakeData
+}
+
+func genesisAccountFromGenTx(genTx GaiaGenTx) GenesisAccount {
+	accAuth := auth.NewBaseAccountWithAddress(genTx.Address)
+	accAuth.Coins = sdk.Coins{
+		{genTx.Name + "Token", sdk.NewInt(1000)},
+		{"steak", freeFermionsAcc},
+	}
+	return NewGenesisAccount(&accAuth)
+}
+
+// GaiaValidateGenesisState ensures that the genesis state obeys the expected invariants
+// TODO: No validators are both bonded and revoked (#2088)
+// TODO: Error if there is a duplicate validator (#1708)
+// TODO: Ensure all state machine parameters are in genesis (#1704)
+func GaiaValidateGenesisState(genesisState GenesisState) (err error) {
+	err = validateGenesisStateAccounts(genesisState.Accounts)
+	if err != nil {
+		return
+	}
+	err = validateGenesisStateValidators(genesisState.StakeData.Validators)
+	if err != nil {
+		return
+	}
+	return
+}
+
+func validateGenesisStateValidators(validators []stakeTypes.Validator) (err error) {
+	addrMap := make(map[string]bool, len(validators))
+	for i := 0; i < len(validators); i++ {
+		val := validators[i]
+		strKey := string(val.ConsPubKey.Bytes())
+		if _, ok := addrMap[strKey]; ok {
+			return fmt.Errorf("Duplicate validator in genesis state: moniker %v, Address %v", val.Description.Moniker, val.ConsAddress())
+		}
+		if val.Jailed && val.Status == sdk.Bonded {
+			return fmt.Errorf("Validator is bonded and revoked in genesis state: moniker %v, Address %v", val.Description.Moniker, val.ConsAddress())
+		}
+		addrMap[strKey] = true
+	}
+	return
+}
+
+// Ensures that there are no duplicate accounts in the genesis state,
+func validateGenesisStateAccounts(accs []GenesisAccount) (err error) {
+	addrMap := make(map[string]bool, len(accs))
+	for i := 0; i < len(accs); i++ {
+		acc := accs[i]
+		strAddr := string(acc.Address)
+		if _, ok := addrMap[strAddr]; ok {
+			return fmt.Errorf("Duplicate account in genesis state: Address %v", acc.Address)
+		}
+		addrMap[strAddr] = true
+	}
+	return
+}
+
 // GaiaAppGenState but with JSON
 func GaiaAppGenStateJSON(cdc *wire.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error) {
 

cmd/gaia/app/genesis_test.go

@@ -5,10 +5,50 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/cosmos/cosmos-sdk/x/gov"
+	"github.com/cosmos/cosmos-sdk/x/stake"
+	stakeTypes "github.com/cosmos/cosmos-sdk/x/stake/types"
 	"github.com/stretchr/testify/require"
+	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 )
 
+var (
+	pk1   = ed25519.GenPrivKey().PubKey()
+	pk2   = ed25519.GenPrivKey().PubKey()
+	pk3   = ed25519.GenPrivKey().PubKey()
+	addr1 = sdk.ValAddress(pk1.Address())
+	addr2 = sdk.ValAddress(pk2.Address())
+	addr3 = sdk.ValAddress(pk3.Address())
+
+	emptyAddr   sdk.ValAddress
+	emptyPubkey crypto.PubKey
+)
+
+func makeGenesisState(genTxs []GaiaGenTx) GenesisState {
+	// start with the default staking genesis state
+	stakeData := stake.DefaultGenesisState()
+
+	// get genesis flag account information
+	genaccs := make([]GenesisAccount, len(genTxs))
+	for i, genTx := range genTxs {
+		genaccs[i] = genesisAccountFromGenTx(genTx)
+		stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewDecFromInt(freeFermionsAcc)) // increase the supply
+
+		// add the validator
+		if len(genTx.Name) > 0 {
+			stakeData = addValidatorToStakeData(genTx, stakeData)
+		}
+	}
+
+	// create the final app state
+	return GenesisState{
+		Accounts:  genaccs,
+		StakeData: stakeData,
+		GovData:   gov.DefaultGenesisState(),
+	}
+}
+
 func TestToAccount(t *testing.T) {
 	priv := ed25519.GenPrivKey()
 	addr := sdk.AccAddress(priv.PubKey().Address())
@@ -34,3 +74,30 @@ func TestGaiaAppGenState(t *testing.T) {
 	// TODO test with both one and two genesis transactions:
 	// TODO        correct: genesis account created, canididates created, pool token variance
 }
+
+func TestGaiaGenesisValidation(t *testing.T) {
+	genTxs := make([]GaiaGenTx, 2)
+	addr := pk1.Address()
+	// Test duplicate accounts fails
+	genTxs[0] = GaiaGenTx{"", sdk.AccAddress(addr), ""}
+	genTxs[1] = GaiaGenTx{"", sdk.AccAddress(addr), ""}
+	genesisState := makeGenesisState(genTxs)
+	err := GaiaValidateGenesisState(genesisState)
+	require.NotNil(t, err)
+	// Test bonded + revoked validator fails
+	genesisState = makeGenesisState(genTxs[:1])
+	val1 := stakeTypes.NewValidator(addr1, pk1, stakeTypes.Description{Moniker: "test #2"})
+	val1.Jailed = true
+	val1.Status = sdk.Bonded
+	genesisState.StakeData.Validators = append(genesisState.StakeData.Validators, val1)
+	err = GaiaValidateGenesisState(genesisState)
+	require.NotNil(t, err)
+	// Test duplicate validator fails
+	val1.Jailed = false
+	genesisState = makeGenesisState(genTxs[:1])
+	val2 := stakeTypes.NewValidator(addr1, pk1, stakeTypes.Description{Moniker: "test #3"})
+	genesisState.StakeData.Validators = append(genesisState.StakeData.Validators, val1)
+	genesisState.StakeData.Validators = append(genesisState.StakeData.Validators, val2)
+	err = GaiaValidateGenesisState(genesisState)
+	require.NotNil(t, err)
+}

cmd/gaia/app/sim_test.go

@@ -3,7 +3,9 @@ package app
 import (
 	"encoding/json"
 	"flag"
+	"fmt"
 	"math/rand"
+	"os"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -12,9 +14,9 @@ import (
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"
 
-	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	banksim "github.com/cosmos/cosmos-sdk/x/bank/simulation"
+	"github.com/cosmos/cosmos-sdk/x/gov"
 	govsim "github.com/cosmos/cosmos-sdk/x/gov/simulation"
 	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
 	slashingsim "github.com/cosmos/cosmos-sdk/x/slashing/simulation"
@@ -28,6 +30,7 @@ var (
 	blockSize int
 	enabled   bool
 	verbose   bool
+	commit    bool
 )
 
 func init() {
@@ -36,6 +39,7 @@ func init() {
 	flag.IntVar(&blockSize, "SimulationBlockSize", 200, "Operations per block")
 	flag.BoolVar(&enabled, "SimulationEnabled", false, "Enable the simulation")
 	flag.BoolVar(&verbose, "SimulationVerbose", false, "Verbose log output")
+	flag.BoolVar(&commit, "SimulationCommit", false, "Have the simulation commit")
 }
 
 func appStateFn(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json.RawMessage {
@@ -49,7 +53,7 @@ func appStateFn(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json
 			Coins:   coins,
 		})
 	}
-
+	govGenesis := gov.DefaultGenesisState()
 	// Default genesis state
 	stakeGenesis := stake.DefaultGenesisState()
 	var validators []stake.Validator
@@ -73,6 +77,7 @@ func appStateFn(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json
 	genesis := GenesisState{
 		Accounts:  genesisAccounts,
 		StakeData: stakeGenesis,
+		GovData:   govGenesis,
 	}
 
 	// Marshal genesis
@@ -84,31 +89,65 @@ func appStateFn(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json
 	return appState
 }
 
-func testAndRunTxs(app *GaiaApp) []simulation.Operation {
-	return []simulation.Operation{
-		banksim.SimulateSingleInputMsgSend(app.accountMapper),
-		govsim.SimulateMsgSubmitProposal(app.govKeeper, app.stakeKeeper),
-		govsim.SimulateMsgDeposit(app.govKeeper, app.stakeKeeper),
-		govsim.SimulateMsgVote(app.govKeeper, app.stakeKeeper),
-		stakesim.SimulateMsgCreateValidator(app.accountMapper, app.stakeKeeper),
-		stakesim.SimulateMsgEditValidator(app.stakeKeeper),
-		stakesim.SimulateMsgDelegate(app.accountMapper, app.stakeKeeper),
-		stakesim.SimulateMsgBeginUnbonding(app.accountMapper, app.stakeKeeper),
-		stakesim.SimulateMsgCompleteUnbonding(app.stakeKeeper),
-		stakesim.SimulateMsgBeginRedelegate(app.accountMapper, app.stakeKeeper),
-		stakesim.SimulateMsgCompleteRedelegate(app.stakeKeeper),
-		slashingsim.SimulateMsgUnjail(app.slashingKeeper),
+func testAndRunTxs(app *GaiaApp) []simulation.WeightedOperation {
+	return []simulation.WeightedOperation{
+		{100, banksim.SimulateSingleInputMsgSend(app.accountMapper)},
+		{5, govsim.SimulateSubmittingVotingAndSlashingForProposal(app.govKeeper, app.stakeKeeper)},
+		{100, govsim.SimulateMsgDeposit(app.govKeeper, app.stakeKeeper)},
+		{100, stakesim.SimulateMsgCreateValidator(app.accountMapper, app.stakeKeeper)},
+		{5, stakesim.SimulateMsgEditValidator(app.stakeKeeper)},
+		{100, stakesim.SimulateMsgDelegate(app.accountMapper, app.stakeKeeper)},
+		{100, stakesim.SimulateMsgBeginUnbonding(app.accountMapper, app.stakeKeeper)},
+		{100, stakesim.SimulateMsgCompleteUnbonding(app.stakeKeeper)},
+		{100, stakesim.SimulateMsgBeginRedelegate(app.accountMapper, app.stakeKeeper)},
+		{100, stakesim.SimulateMsgCompleteRedelegate(app.stakeKeeper)},
+		{100, slashingsim.SimulateMsgUnjail(app.slashingKeeper)},
 	}
 }
 
 func invariants(app *GaiaApp) []simulation.Invariant {
 	return []simulation.Invariant{
-		func(t *testing.T, baseapp *baseapp.BaseApp, log string) {
-			banksim.NonnegativeBalanceInvariant(app.accountMapper)(t, baseapp, log)
-			govsim.AllInvariants()(t, baseapp, log)
-			stakesim.AllInvariants(app.coinKeeper, app.stakeKeeper, app.accountMapper)(t, baseapp, log)
-			slashingsim.AllInvariants()(t, baseapp, log)
-		},
+		banksim.NonnegativeBalanceInvariant(app.accountMapper),
+		govsim.AllInvariants(),
+		stakesim.AllInvariants(app.bankKeeper, app.stakeKeeper, app.accountMapper),
+		slashingsim.AllInvariants(),
+	}
+}
+
+// Profile with:
+// /usr/local/go/bin/go test -benchmem -run=^$ github.com/cosmos/cosmos-sdk/cmd/gaia/app -bench ^BenchmarkFullGaiaSimulation$ -SimulationCommit=true -cpuprofile cpu.out
+func BenchmarkFullGaiaSimulation(b *testing.B) {
+	// Setup Gaia application
+	var logger log.Logger
+	logger = log.NewNopLogger()
+	var db dbm.DB
+	dir := os.TempDir()
+	db, _ = dbm.NewGoLevelDB("Simulation", dir)
+	defer func() {
+		db.Close()
+		os.RemoveAll(dir)
+	}()
+	app := NewGaiaApp(logger, db, nil)
+
+	// Run randomized simulation
+	// TODO parameterize numbers, save for a later PR
+	err := simulation.SimulateFromSeed(
+		b, app.BaseApp, appStateFn, seed,
+		testAndRunTxs(app),
+		[]simulation.RandSetup{},
+		invariants(app), // these shouldn't get ran
+		numBlocks,
+		blockSize,
+		commit,
+	)
+	if err != nil {
+		fmt.Println(err)
+		b.Fail()
+	}
+	if commit {
+		fmt.Println("GoLevelDB Stats")
+		fmt.Println(db.Stats()["leveldb.stats"])
+		fmt.Println("GoLevelDB cached block size", db.Stats()["leveldb.cachedblock"])
 	}
 }
 
@@ -129,16 +168,19 @@ func TestFullGaiaSimulation(t *testing.T) {
 	require.Equal(t, "GaiaApp", app.Name())
 
 	// Run randomized simulation
-	simulation.SimulateFromSeed(
+	err := simulation.SimulateFromSeed(
 		t, app.BaseApp, appStateFn, seed,
 		testAndRunTxs(app),
 		[]simulation.RandSetup{},
 		invariants(app),
 		numBlocks,
 		blockSize,
-		false,
+		commit,
 	)
-
+	if commit {
+		fmt.Println("Database Size", db.Stats()["database.size"])
+	}
+	require.Nil(t, err)
 }
 
 // TODO: Make another test for the fuzzer itself, which just has noOp txs
@@ -148,7 +190,7 @@ func TestAppStateDeterminism(t *testing.T) {
 		t.Skip("Skipping Gaia simulation")
 	}
 
-	numSeeds := 5
+	numSeeds := 3
 	numTimesToRunPerSeed := 5
 	appHashList := make([]json.RawMessage, numTimesToRunPerSeed)
 
@@ -165,10 +207,11 @@ func TestAppStateDeterminism(t *testing.T) {
 				testAndRunTxs(app),
 				[]simulation.RandSetup{},
 				[]simulation.Invariant{},
-				20,
-				20,
+				50,
+				100,
 				true,
 			)
+			//app.Commit()
 			appHash := app.LastCommitID().Hash
 			appHashList[j] = appHash
 		}

cmd/gaia/cli_test/cli_test.go

@@ -5,14 +5,17 @@ package clitest
 import (
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 
+	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto"
 	cmn "github.com/tendermint/tendermint/libs/common"
 
+	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/keys"
 	"github.com/cosmos/cosmos-sdk/cmd/gaia/app"
 	"github.com/cosmos/cosmos-sdk/server"
@@ -109,9 +112,26 @@ func TestGaiaCLIGasAuto(t *testing.T) {
 	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
 	require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64())
 
-	// Enable auto gas
+	// Test failure with negative gas
+	success = executeWrite(t, fmt.Sprintf("gaiacli send %v --gas=-100 --amount=10steak --to=%s --from=foo", flags, barAddr), app.DefaultKeyPass)
+	require.False(t, success)
+
+	// Test failure with 0 gas
 	success = executeWrite(t, fmt.Sprintf("gaiacli send %v --gas=0 --amount=10steak --to=%s --from=foo", flags, barAddr), app.DefaultKeyPass)
+	require.False(t, success)
+
+	// Enable auto gas
+	success, stdout, _ := executeWriteRetStdStreams(t, fmt.Sprintf("gaiacli send %v --json --gas=simulate --amount=10steak --to=%s --from=foo", flags, barAddr), app.DefaultKeyPass)
 	require.True(t, success)
+	// check that gas wanted == gas used
+	cdc := app.MakeCodec()
+	jsonOutput := struct {
+		Height   int64
+		TxHash   string
+		Response abci.ResponseDeliverTx
+	}{}
+	require.Nil(t, cdc.UnmarshalJSON([]byte(stdout), &jsonOutput))
+	require.Equal(t, jsonOutput.Response.GasWanted, jsonOutput.Response.GasUsed)
 	tests.WaitForNextNBlocksTM(2, port)
 	// Check state has changed accordingly
 	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
@@ -155,8 +175,18 @@ func TestGaiaCLICreateValidator(t *testing.T) {
 
 	initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewDec(1))
 
+	// Test --generate-only
+	success, stdout, stderr := executeWriteRetStdStreams(t, cvStr+" --generate-only", app.DefaultKeyPass)
+	require.True(t, success)
+	require.True(t, success)
+	require.Empty(t, stderr)
+	msg := unmarshalStdTx(t, stdout)
+	require.NotZero(t, msg.Fee.Gas)
+	require.Equal(t, len(msg.Msgs), 1)
+	require.Equal(t, 0, len(msg.GetSignatures()))
+
 	// Test --dry-run
-	success := executeWrite(t, cvStr+" --dry-run", app.DefaultKeyPass)
+	success = executeWrite(t, cvStr+" --dry-run", app.DefaultKeyPass)
 	require.True(t, success)
 
 	executeWrite(t, cvStr, app.DefaultKeyPass)
@@ -166,7 +196,7 @@ func TestGaiaCLICreateValidator(t *testing.T) {
 	require.Equal(t, int64(8), barAcc.GetCoins().AmountOf("steak").Int64(), "%v", barAcc)
 
 	validator := executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %s --output=json %v", sdk.ValAddress(barAddr), flags))
-	require.Equal(t, validator.Operator, sdk.ValAddress(barAddr))
+	require.Equal(t, validator.OperatorAddr, sdk.ValAddress(barAddr))
 	require.True(sdk.DecEq(t, sdk.NewDec(2), validator.Tokens))
 
 	// unbond a single share
@@ -222,8 +252,18 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 	spStr += fmt.Sprintf(" --title=%s", "Test")
 	spStr += fmt.Sprintf(" --description=%s", "test")
 
+	// Test generate only
+	success, stdout, stderr := executeWriteRetStdStreams(t, spStr+" --generate-only", app.DefaultKeyPass)
+	require.True(t, success)
+	require.True(t, success)
+	require.Empty(t, stderr)
+	msg := unmarshalStdTx(t, stdout)
+	require.NotZero(t, msg.Fee.Gas)
+	require.Equal(t, len(msg.Msgs), 1)
+	require.Equal(t, 0, len(msg.GetSignatures()))
+
 	// Test --dry-run
-	success := executeWrite(t, spStr+" --dry-run", app.DefaultKeyPass)
+	success = executeWrite(t, spStr+" --dry-run", app.DefaultKeyPass)
 	require.True(t, success)
 
 	executeWrite(t, spStr, app.DefaultKeyPass)
@@ -244,6 +284,16 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 	depositStr += fmt.Sprintf(" --deposit=%s", "10steak")
 	depositStr += fmt.Sprintf(" --proposal-id=%s", "1")
 
+	// Test generate only
+	success, stdout, stderr = executeWriteRetStdStreams(t, depositStr+" --generate-only", app.DefaultKeyPass)
+	require.True(t, success)
+	require.True(t, success)
+	require.Empty(t, stderr)
+	msg = unmarshalStdTx(t, stdout)
+	require.NotZero(t, msg.Fee.Gas)
+	require.Equal(t, len(msg.Msgs), 1)
+	require.Equal(t, 0, len(msg.GetSignatures()))
+
 	executeWrite(t, depositStr, app.DefaultKeyPass)
 	tests.WaitForNextNBlocksTM(2, port)
 
@@ -258,6 +308,16 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 	voteStr += fmt.Sprintf(" --proposal-id=%s", "1")
 	voteStr += fmt.Sprintf(" --option=%s", "Yes")
 
+	// Test generate only
+	success, stdout, stderr = executeWriteRetStdStreams(t, voteStr+" --generate-only", app.DefaultKeyPass)
+	require.True(t, success)
+	require.True(t, success)
+	require.Empty(t, stderr)
+	msg = unmarshalStdTx(t, stdout)
+	require.NotZero(t, msg.Fee.Gas)
+	require.Equal(t, len(msg.Msgs), 1)
+	require.Equal(t, 0, len(msg.GetSignatures()))
+
 	executeWrite(t, voteStr, app.DefaultKeyPass)
 	tests.WaitForNextNBlocksTM(2, port)
 
@@ -291,6 +351,101 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 	require.Equal(t, "  2 - Apples", proposalsQuery)
 }
 
+func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
+	chainID, servAddr, port := initializeFixtures(t)
+	flags := fmt.Sprintf("--home=%s --node=%v --chain-id=%v", gaiacliHome, servAddr, chainID)
+
+	// start gaiad server
+	proc := tests.GoExecuteTWithStdout(t, fmt.Sprintf("gaiad start --home=%s --rpc.laddr=%v", gaiadHome, servAddr))
+
+	defer proc.Stop(false)
+	tests.WaitForTMStart(port)
+	tests.WaitForNextNBlocksTM(2, port)
+
+	fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome))
+	barAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show bar --output=json --home=%s", gaiacliHome))
+
+	// Test generate sendTx with default gas
+	success, stdout, stderr := executeWriteRetStdStreams(t, fmt.Sprintf(
+		"gaiacli send %v --amount=10steak --to=%s --from=foo --generate-only",
+		flags, barAddr), []string{}...)
+	require.True(t, success)
+	require.Empty(t, stderr)
+	msg := unmarshalStdTx(t, stdout)
+	require.Equal(t, msg.Fee.Gas, int64(client.DefaultGasLimit))
+	require.Equal(t, len(msg.Msgs), 1)
+	require.Equal(t, 0, len(msg.GetSignatures()))
+
+	// Test generate sendTx with --gas=$amount
+	success, stdout, stderr = executeWriteRetStdStreams(t, fmt.Sprintf(
+		"gaiacli send %v --amount=10steak --to=%s --from=foo --gas=100 --generate-only",
+		flags, barAddr), []string{}...)
+	require.True(t, success)
+	require.Empty(t, stderr)
+	msg = unmarshalStdTx(t, stdout)
+	require.Equal(t, msg.Fee.Gas, int64(100))
+	require.Equal(t, len(msg.Msgs), 1)
+	require.Equal(t, 0, len(msg.GetSignatures()))
+
+	// Test generate sendTx, estimate gas
+	success, stdout, stderr = executeWriteRetStdStreams(t, fmt.Sprintf(
+		"gaiacli send %v --amount=10steak --to=%s --from=foo --gas=simulate --generate-only",
+		flags, barAddr), []string{}...)
+	require.True(t, success)
+	require.NotEmpty(t, stderr)
+	msg = unmarshalStdTx(t, stdout)
+	require.True(t, msg.Fee.Gas > 0)
+	require.Equal(t, len(msg.Msgs), 1)
+
+	// Write the output to disk
+	unsignedTxFile := writeToNewTempFile(t, stdout)
+	defer os.Remove(unsignedTxFile.Name())
+
+	// Test sign --print-sigs
+	success, stdout, _ = executeWriteRetStdStreams(t, fmt.Sprintf(
+		"gaiacli sign %v --print-sigs %v", flags, unsignedTxFile.Name()))
+	require.True(t, success)
+	require.Equal(t, fmt.Sprintf("Signers:\n 0: %v\n\nSignatures:\n", fooAddr.String()), stdout)
+
+	// Test sign
+	success, stdout, _ = executeWriteRetStdStreams(t, fmt.Sprintf(
+		"gaiacli sign %v --name=foo %v", flags, unsignedTxFile.Name()), app.DefaultKeyPass)
+	require.True(t, success)
+	msg = unmarshalStdTx(t, stdout)
+	require.Equal(t, len(msg.Msgs), 1)
+	require.Equal(t, 1, len(msg.GetSignatures()))
+	require.Equal(t, fooAddr.String(), msg.GetSigners()[0].String())
+
+	// Write the output to disk
+	signedTxFile := writeToNewTempFile(t, stdout)
+	defer os.Remove(signedTxFile.Name())
+
+	// Test sign --print-signatures
+	success, stdout, _ = executeWriteRetStdStreams(t, fmt.Sprintf(
+		"gaiacli sign %v --print-sigs %v", flags, signedTxFile.Name()))
+	require.True(t, success)
+	require.Equal(t, fmt.Sprintf("Signers:\n 0: %v\n\nSignatures:\n 0: %v\n", fooAddr.String(), fooAddr.String()), stdout)
+
+	// Test broadcast
+	fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
+	require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64())
+
+	success, stdout, _ = executeWriteRetStdStreams(t, fmt.Sprintf("gaiacli broadcast %v --json %v", flags, signedTxFile.Name()))
+	require.True(t, success)
+	var result struct {
+		Response abci.ResponseDeliverTx
+	}
+	require.Nil(t, app.MakeCodec().UnmarshalJSON([]byte(stdout), &result))
+	require.Equal(t, msg.Fee.Gas, result.Response.GasUsed)
+	require.Equal(t, msg.Fee.Gas, result.Response.GasWanted)
+	tests.WaitForNextNBlocksTM(2, port)
+
+	barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags))
+	require.Equal(t, int64(10), barAcc.GetCoins().AmountOf("steak").Int64())
+	fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
+	require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf("steak").Int64())
+}
+
 //___________________________________________________________________________________
 // helper methods
 
@@ -315,6 +470,20 @@ func initializeFixtures(t *testing.T) (chainID, servAddr, port string) {
 	return
 }
 
+func unmarshalStdTx(t *testing.T, s string) (stdTx auth.StdTx) {
+	cdc := app.MakeCodec()
+	require.Nil(t, cdc.UnmarshalJSON([]byte(s), &stdTx))
+	return
+}
+
+func writeToNewTempFile(t *testing.T, s string) *os.File {
+	fp, err := ioutil.TempFile(os.TempDir(), "cosmos_cli_test_")
+	require.Nil(t, err)
+	_, err = fp.WriteString(s)
+	require.Nil(t, err)
+	return fp
+}
+
 //___________________________________________________________________________________
 // executors
 

cmd/gaia/cmd/gaiacli/main.go

@@ -129,10 +129,12 @@ func main() {
 	rootCmd.AddCommand(
 		client.GetCommands(
 			authcmd.GetAccountCmd("acc", cdc, authcmd.GetAccountDecoder(cdc)),
+			authcmd.GetSignCommand(cdc, authcmd.GetAccountDecoder(cdc)),
 		)...)
 	rootCmd.AddCommand(
 		client.PostCommands(
 			bankcmd.SendTxCmd(cdc),
+			bankcmd.GetBroadcastCommand(cdc),
 		)...)
 
 	// add proxy, version and key info

cmd/gaia/cmd/gaiadebug/hack.go

@@ -65,7 +65,7 @@ func runHackCmd(cmd *cobra.Command, args []string) error {
 	// The following powerKey was there, but the corresponding "trouble" validator did not exist.
 	// So here we do a binary search on the past states to find when the powerKey first showed up ...
 
-	// owner of the validator the bonds, gets revoked, later unbonds, and then later is still found in the bypower store
+	// operator of the validator the bonds, gets revoked, later unbonds, and then later is still found in the bypower store
 	trouble := hexToBytes("D3DC0FF59F7C3B548B7AFA365561B87FD0208AF8")
 	// this is his "bypower" key
 	powerKey := hexToBytes("05303030303030303030303033FFFFFFFFFFFF4C0C0000FFFED3DC0FF59F7C3B548B7AFA365561B87FD0208AF8")
@@ -134,13 +134,14 @@ type GaiaApp struct {
 	keyAccount  *sdk.KVStoreKey
 	keyIBC      *sdk.KVStoreKey
 	keyStake    *sdk.KVStoreKey
+	tkeyStake   *sdk.TransientStoreKey
 	keySlashing *sdk.KVStoreKey
 	keyParams   *sdk.KVStoreKey
 
 	// Manage getting and setting accounts
 	accountMapper       auth.AccountMapper
 	feeCollectionKeeper auth.FeeCollectionKeeper
-	coinKeeper          bank.Keeper
+	bankKeeper          bank.Keeper
 	ibcMapper           ibc.Mapper
 	stakeKeeper         stake.Keeper
 	slashingKeeper      slashing.Keeper
@@ -161,6 +162,7 @@ func NewGaiaApp(logger log.Logger, db dbm.DB, baseAppOptions ...func(*bam.BaseAp
 		keyAccount:  sdk.NewKVStoreKey("acc"),
 		keyIBC:      sdk.NewKVStoreKey("ibc"),
 		keyStake:    sdk.NewKVStoreKey("stake"),
+		tkeyStake:   sdk.NewTransientStoreKey("transient_stake"),
 		keySlashing: sdk.NewKVStoreKey("slashing"),
 		keyParams:   sdk.NewKVStoreKey("params"),
 	}
@@ -173,16 +175,16 @@ func NewGaiaApp(logger log.Logger, db dbm.DB, baseAppOptions ...func(*bam.BaseAp
 	)
 
 	// add handlers
-	app.coinKeeper = bank.NewKeeper(app.accountMapper)
+	app.bankKeeper = bank.NewBaseKeeper(app.accountMapper)
 	app.ibcMapper = ibc.NewMapper(app.cdc, app.keyIBC, app.RegisterCodespace(ibc.DefaultCodespace))
 	app.paramsKeeper = params.NewKeeper(app.cdc, app.keyParams)
-	app.stakeKeeper = stake.NewKeeper(app.cdc, app.keyStake, app.coinKeeper, app.RegisterCodespace(stake.DefaultCodespace))
+	app.stakeKeeper = stake.NewKeeper(app.cdc, app.keyStake, app.tkeyStake, app.bankKeeper, app.RegisterCodespace(stake.DefaultCodespace))
 	app.slashingKeeper = slashing.NewKeeper(app.cdc, app.keySlashing, app.stakeKeeper, app.paramsKeeper.Getter(), app.RegisterCodespace(slashing.DefaultCodespace))
 
 	// register message routes
 	app.Router().
-		AddRoute("bank", bank.NewHandler(app.coinKeeper)).
-		AddRoute("ibc", ibc.NewHandler(app.ibcMapper, app.coinKeeper)).
+		AddRoute("bank", bank.NewHandler(app.bankKeeper)).
+		AddRoute("ibc", ibc.NewHandler(app.ibcMapper, app.bankKeeper)).
 		AddRoute("stake", stake.NewHandler(app.stakeKeeper))
 
 	// initialize BaseApp