diff --git a/CHANGELOG.md b/CHANGELOG.md
index f8157594ae..6d65416915 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,6 @@ FEATURES
 
 IMPROVEMENTS
 * export command now writes current validator set for Tendermint
-* [tests] Application module tests now use a mock application
 
 FIXES
 * [lcd] Switch to bech32 for addresses on all human readable inputs and outputs
diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
index 0f6bab134b..0fe1cfe5b9 100644
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@@ -1,16 +1,18 @@
 package app
 
 import (
+	"fmt"
 	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/cosmos/cosmos-sdk/x/auth/mock"
 	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"
 
 	abci "github.com/tendermint/abci/types"
@@ -19,13 +21,68 @@ import (
 	"github.com/tendermint/tmlibs/log"
 )
 
+// Construct some global addrs and txs for tests.
 var (
 	chainID = "" // TODO
 
-	priv1 = crypto.GenPrivKeyEd25519()
-	addr1 = priv1.PubKey().Address()
-	priv2 = crypto.GenPrivKeyEd25519()
-	addr2 = priv2.PubKey().Address()
+	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       = auth.StdFee{
+		sdk.Coins{{"foocoin", 0}},
+		100000,
+	}
+
+	sendMsg1 = bank.MsgSend{
+		Inputs:  []bank.Input{bank.NewInput(addr1, coins)},
+		Outputs: []bank.Output{bank.NewOutput(addr2, coins)},
+	}
+
+	sendMsg2 = bank.MsgSend{
+		Inputs: []bank.Input{bank.NewInput(addr1, coins)},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr2, halfCoins),
+			bank.NewOutput(addr3, halfCoins),
+		},
+	}
+
+	sendMsg3 = bank.MsgSend{
+		Inputs: []bank.Input{
+			bank.NewInput(addr1, coins),
+			bank.NewInput(addr4, coins),
+		},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr2, coins),
+			bank.NewOutput(addr3, coins),
+		},
+	}
+
+	sendMsg4 = bank.MsgSend{
+		Inputs: []bank.Input{
+			bank.NewInput(addr2, coins),
+		},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr1, coins),
+		},
+	}
+
+	sendMsg5 = bank.MsgSend{
+		Inputs: []bank.Input{
+			bank.NewInput(addr1, manyCoins),
+		},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr2, manyCoins),
+		},
+	}
 )
 
 func loggerAndDB() (log.Logger, dbm.DB) {
@@ -34,6 +91,11 @@ func loggerAndDB() (log.Logger, dbm.DB) {
 	return logger, db
 }
 
+func newGaiaApp() *GaiaApp {
+	logger, db := loggerAndDB()
+	return NewGaiaApp(logger, db)
+}
+
 func setGenesis(gapp *GaiaApp, accs ...*auth.BaseAccount) error {
 	genaccs := make([]GenesisAccount, len(accs))
 	for i, acc := range accs {
@@ -60,6 +122,22 @@ func setGenesis(gapp *GaiaApp, accs ...*auth.BaseAccount) error {
 
 //_______________________________________________________________________
 
+func TestMsgs(t *testing.T) {
+	gapp := newGaiaApp()
+	require.Nil(t, setGenesis(gapp))
+
+	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 TestGenesis(t *testing.T) {
 	logger, dbs := loggerAndDB()
 	gapp := NewGaiaApp(logger, dbs)
@@ -89,9 +167,271 @@ func TestGenesis(t *testing.T) {
 	assert.Equal(t, baseAcc, res1)
 }
 
+func TestMsgSendWithAccounts(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 = setGenesis(gapp, baseAcc)
+	require.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.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)
+}
+
+func TestMsgSendMultipleOut(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 = setGenesis(gapp, acc1, acc2)
+	require.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 = setGenesis(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 TestMsgSendDependent(t *testing.T) {
+	gapp := newGaiaApp()
+
+	genCoins, err := sdk.ParseCoins("42foocoin")
+	require.Nil(t, err)
+
+	acc1 := &auth.BaseAccount{
+		Address: addr1,
+		Coins:   genCoins,
+	}
+
+	err = setGenesis(gapp, acc1)
+	require.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 := setGenesis(gapp, baseAcc)
+	require.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 TestStakeMsgs(t *testing.T) {
+	gapp := newGaiaApp()
+
+	genCoins, err := sdk.ParseCoins("42steak")
+	require.Nil(t, err)
+	bondCoin, err := sdk.ParseCoin("10steak")
+	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)
+
+	// Create Validator
+
+	description := stake.NewDescription("foo_moniker", "", "", "")
+	createValidatorMsg := stake.NewMsgCreateValidator(
+		addr1, priv1.PubKey(), bondCoin, description,
+	)
+	SignCheckDeliver(t, gapp, createValidatorMsg, []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())
+	validator, found := gapp.stakeKeeper.GetValidator(ctxDeliver, addr1)
+	require.True(t, found)
+	require.Equal(t, addr1, validator.Owner)
+	require.Equal(t, sdk.Bonded, validator.Status())
+	require.True(sdk.RatEq(t, sdk.NewRat(10), validator.PoolShares.Bonded()))
+
+	// check the bond that should have been created as well
+	bond, found := gapp.stakeKeeper.GetDelegation(ctxDeliver, addr1, addr1)
+	require.True(sdk.RatEq(t, sdk.NewRat(10), bond.Shares))
+
+	// Edit Validator
+
+	description = stake.NewDescription("bar_moniker", "", "", "")
+	editValidatorMsg := stake.NewMsgEditValidator(
+		addr1, description,
+	)
+	SignDeliver(t, gapp, editValidatorMsg, []int64{1}, true, priv1)
+
+	validator, found = gapp.stakeKeeper.GetValidator(ctxDeliver, addr1)
+	require.True(t, found)
+	require.Equal(t, description, validator.Description)
+
+	// Delegate
+
+	delegateMsg := stake.NewMsgDelegate(
+		addr2, addr1, bondCoin,
+	)
+	SignDeliver(t, gapp, delegateMsg, []int64{0}, true, priv2)
+
+	res2 = gapp.accountMapper.GetAccount(ctxDeliver, addr2)
+	require.Equal(t, genCoins.Minus(sdk.Coins{bondCoin}), res2.GetCoins())
+	bond, found = gapp.stakeKeeper.GetDelegation(ctxDeliver, addr2, addr1)
+	require.True(t, found)
+	require.Equal(t, addr2, bond.DelegatorAddr)
+	require.Equal(t, addr1, bond.ValidatorAddr)
+	require.True(sdk.RatEq(t, sdk.NewRat(10), bond.Shares))
+
+	// Unbond
+
+	unbondMsg := stake.NewMsgUnbond(
+		addr2, addr1, "MAX",
+	)
+	SignDeliver(t, gapp, unbondMsg, []int64{1}, true, priv2)
+
+	res2 = gapp.accountMapper.GetAccount(ctxDeliver, addr2)
+	require.Equal(t, genCoins, res2.GetCoins())
+	_, found = gapp.stakeKeeper.GetDelegation(ctxDeliver, addr2, addr1)
+	require.False(t, found)
+}
+
 func TestExportValidators(t *testing.T) {
-	logger, dbs := loggerAndDB()
-	gapp := NewGaiaApp(logger, dbs)
+	gapp := newGaiaApp()
 
 	genCoins, err := sdk.ParseCoins("42steak")
 	require.Nil(t, err)
@@ -115,7 +455,7 @@ func TestExportValidators(t *testing.T) {
 	createValidatorMsg := stake.NewMsgCreateValidator(
 		addr1, priv1.PubKey(), bondCoin, description,
 	)
-	mock.SignCheckDeliver(t, gapp.BaseApp, createValidatorMsg, []int64{0}, true, priv1)
+	SignCheckDeliver(t, gapp, createValidatorMsg, []int64{0}, true, priv1)
 	gapp.Commit()
 
 	// Export validator set
@@ -125,3 +465,72 @@ func TestExportValidators(t *testing.T) {
 	require.Equal(t, priv1.PubKey(), validators[0].PubKey)
 	require.Equal(t, int64(10), validators[0].Power)
 }
+
+//____________________________________________________________________________________
+
+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) auth.StdTx {
+	sigs := make([]auth.StdSignature, len(priv))
+	for i, p := range priv {
+		sigs[i] = auth.StdSignature{
+			PubKey:    p.PubKey(),
+			Signature: p.Sign(auth.StdSignBytes(chainID, seq, fee, msg)),
+			Sequence:  seq[i],
+		}
+	}
+
+	return auth.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.ABCICodeOK, res.Code, res.Log)
+	} else {
+		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.ABCICodeOK, res.Code, res.Log)
+	} else {
+		require.NotEqual(t, sdk.ABCICodeOK, 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.ABCICodeOK, res.Code, res.Log)
+	} else {
+		require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log)
+	}
+	gapp.EndBlock(abci.RequestEndBlock{})
+}
diff --git a/examples/basecoin/app/app_test.go b/examples/basecoin/app/app_test.go
index a1f7d53702..3027a84707 100644
--- a/examples/basecoin/app/app_test.go
+++ b/examples/basecoin/app/app_test.go
@@ -1,23 +1,26 @@
 package app
 
 import (
+	"encoding/json"
+	"fmt"
 	"os"
 	"testing"
 
 	"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/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"
+
 	abci "github.com/tendermint/abci/types"
 	crypto "github.com/tendermint/go-crypto"
 	dbm "github.com/tendermint/tmlibs/db"
 	"github.com/tendermint/tmlibs/log"
-
-	"github.com/cosmos/cosmos-sdk/examples/basecoin/types"
-
-	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/stake"
 )
 
 // Construct some global addrs and txs for tests.
@@ -25,9 +28,66 @@ 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       = auth.StdFee{
+		sdk.Coins{{"foocoin", 0}},
+		100000,
+	}
+
+	sendMsg1 = bank.MsgSend{
+		Inputs:  []bank.Input{bank.NewInput(addr1, coins)},
+		Outputs: []bank.Output{bank.NewOutput(addr2, coins)},
+	}
+
+	sendMsg2 = bank.MsgSend{
+		Inputs: []bank.Input{bank.NewInput(addr1, coins)},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr2, halfCoins),
+			bank.NewOutput(addr3, halfCoins),
+		},
+	}
+
+	sendMsg3 = bank.MsgSend{
+		Inputs: []bank.Input{
+			bank.NewInput(addr1, coins),
+			bank.NewInput(addr4, coins),
+		},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr2, coins),
+			bank.NewOutput(addr3, coins),
+		},
+	}
+
+	sendMsg4 = bank.MsgSend{
+		Inputs: []bank.Input{
+			bank.NewInput(addr2, coins),
+		},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr1, coins),
+		},
+	}
+
+	sendMsg5 = bank.MsgSend{
+		Inputs: []bank.Input{
+			bank.NewInput(addr1, manyCoins),
+		},
+		Outputs: []bank.Output{
+			bank.NewOutput(addr2, manyCoins),
+		},
+	}
 )
 
-func setGenesis(t *testing.T, bapp *BasecoinApp, accs ...auth.BaseAccount) error {
+func setGenesis(bapp *BasecoinApp, accs ...auth.BaseAccount) error {
 	genaccs := make([]*types.GenesisAccount, len(accs))
 	for i, acc := range accs {
 		genaccs[i] = types.NewGenesisAccount(&types.AppAccount{acc, accName})
@@ -39,7 +99,9 @@ func setGenesis(t *testing.T, bapp *BasecoinApp, accs ...auth.BaseAccount) error
 	}
 
 	stateBytes, err := wire.MarshalJSONIndent(bapp.cdc, genesisState)
-	require.NoError(t, err)
+	if err != nil {
+		return err
+	}
 
 	// Initialize the chain
 	vals := []abci.Validator{}
@@ -49,24 +111,94 @@ func setGenesis(t *testing.T, bapp *BasecoinApp, accs ...auth.BaseAccount) error
 	return nil
 }
 
-//_______________________________________________________________________
-
-func TestGenesis(t *testing.T) {
+func loggerAndDB() (log.Logger, dbm.DB) {
 	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "sdk/app")
 	db := dbm.NewMemDB()
+	return logger, db
+}
+
+func newBasecoinApp() *BasecoinApp {
+	logger, db := loggerAndDB()
+	return NewBasecoinApp(logger, db)
+}
+
+//_______________________________________________________________________
+
+func TestMsgs(t *testing.T) {
+	bapp := newBasecoinApp()
+	require.Nil(t, setGenesis(bapp))
+
+	msgs := []struct {
+		msg sdk.Msg
+	}{
+		{sendMsg1},
+	}
+
+	for i, m := range msgs {
+		// Run a CheckDeliver
+		SignCheckDeliver(t, bapp, m.msg, []int64{int64(i)}, false, priv1)
+	}
+}
+
+func TestSortGenesis(t *testing.T) {
+	logger, db := loggerAndDB()
+	bapp := NewBasecoinApp(logger, db)
+
+	// Note the order: the coins are unsorted!
+	coinDenom1, coinDenom2 := "foocoin", "barcoin"
+
+	genState := fmt.Sprintf(`{
+      "accounts": [{
+        "address": "%s",
+        "coins": [
+          {
+            "denom": "%s",
+            "amount": 10
+          },
+          {
+            "denom": "%s",
+            "amount": 20
+          }
+        ]
+      }]
+    }`, addr1.String(), coinDenom1, coinDenom2)
+
+	// Initialize the chain
+	vals := []abci.Validator{}
+	bapp.InitChain(abci.RequestInitChain{Validators: vals, AppStateBytes: []byte(genState)})
+	bapp.Commit()
+
+	// Unsorted coins means invalid
+	err := sendMsg5.ValidateBasic()
+	require.Equal(t, sdk.CodeInvalidCoins, err.Code(), 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, bapp, sendMsg5, []int64{0}, true, priv1)
+}
+
+func TestGenesis(t *testing.T) {
+	logger, db := loggerAndDB()
 	bapp := NewBasecoinApp(logger, db)
 
 	// Construct some genesis bytes to reflect basecoin/types/AppAccount
 	pk := crypto.GenPrivKeyEd25519().PubKey()
 	addr := pk.Address()
-	coins := sdk.Coins{{"foocoin", 77}, {"barcoin", 99}}
+	coins, err := sdk.ParseCoins("77foocoin,99barcoin")
+	require.Nil(t, err)
 	baseAcc := auth.BaseAccount{
 		Address: addr,
 		Coins:   coins,
 	}
 	acc := &types.AppAccount{baseAcc, "foobart"}
 
-	setGenesis(t, bapp, baseAcc)
+	err = setGenesis(bapp, baseAcc)
+	require.Nil(t, err)
 
 	// A checkTx context
 	ctx := bapp.BaseApp.NewContext(true, abci.Header{})
@@ -79,3 +211,318 @@ func TestGenesis(t *testing.T) {
 	res1 = bapp.accountMapper.GetAccount(ctx, baseAcc.Address)
 	assert.Equal(t, acc, res1)
 }
+
+func TestMsgChangePubKey(t *testing.T) {
+
+	bapp := newBasecoinApp()
+
+	// Construct some genesis bytes to reflect basecoin/types/AppAccount
+	// 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 = setGenesis(bapp, baseAcc)
+	require.Nil(t, err)
+
+	// A checkTx context (true)
+	ctxCheck := bapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := bapp.accountMapper.GetAccount(ctxCheck, addr1)
+	assert.Equal(t, baseAcc, res1.(*types.AppAccount).BaseAccount)
+
+	// Run a CheckDeliver
+	SignCheckDeliver(t, bapp, sendMsg1, []int64{0}, true, priv1)
+
+	// Check balances
+	CheckBalance(t, bapp, addr1, "67foocoin")
+	CheckBalance(t, bapp, addr2, "10foocoin")
+
+	changePubKeyMsg := auth.MsgChangeKey{
+		Address:   addr1,
+		NewPubKey: priv2.PubKey(),
+	}
+
+	ctxDeliver := bapp.BaseApp.NewContext(false, abci.Header{})
+	acc := bapp.accountMapper.GetAccount(ctxDeliver, addr1)
+
+	// send a MsgChangePubKey
+	SignCheckDeliver(t, bapp, changePubKeyMsg, []int64{1}, true, priv1)
+	acc = bapp.accountMapper.GetAccount(ctxDeliver, addr1)
+
+	assert.True(t, priv2.PubKey().Equals(acc.GetPubKey()))
+
+	// signing a SendMsg with the old privKey should be an auth error
+	tx := genTx(sendMsg1, []int64{2}, priv1)
+	res := bapp.Deliver(tx)
+	assert.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, sdk.CodeUnauthorized), res.Code, res.Log)
+
+	// resigning the tx with the new correct priv key should work
+	SignCheckDeliver(t, bapp, sendMsg1, []int64{2}, true, priv2)
+
+	// Check balances
+	CheckBalance(t, bapp, addr1, "57foocoin")
+	CheckBalance(t, bapp, addr2, "20foocoin")
+}
+
+func TestMsgSendWithAccounts(t *testing.T) {
+	bapp := newBasecoinApp()
+
+	// Construct some genesis bytes to reflect basecoin/types/AppAccount
+	// 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 = setGenesis(bapp, baseAcc)
+	require.Nil(t, err)
+
+	// A checkTx context (true)
+	ctxCheck := bapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := bapp.accountMapper.GetAccount(ctxCheck, addr1)
+	assert.Equal(t, baseAcc, res1.(*types.AppAccount).BaseAccount)
+
+	// Run a CheckDeliver
+	SignCheckDeliver(t, bapp, sendMsg1, []int64{0}, true, priv1)
+
+	// Check balances
+	CheckBalance(t, bapp, addr1, "67foocoin")
+	CheckBalance(t, bapp, addr2, "10foocoin")
+
+	// Delivering again should cause replay error
+	SignCheckDeliver(t, bapp, 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 := bapp.Deliver(tx)
+
+	assert.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, sdk.CodeUnauthorized), res.Code, res.Log)
+
+	// resigning the tx with the bumped sequence should work
+	SignCheckDeliver(t, bapp, sendMsg1, []int64{1}, true, priv1)
+}
+
+func TestMsgSendMultipleOut(t *testing.T) {
+	bapp := newBasecoinApp()
+
+	genCoins, err := sdk.ParseCoins("42foocoin")
+	require.Nil(t, err)
+
+	acc1 := auth.BaseAccount{
+		Address: addr1,
+		Coins:   genCoins,
+	}
+
+	acc2 := auth.BaseAccount{
+		Address: addr2,
+		Coins:   genCoins,
+	}
+
+	// Construct genesis state
+	err = setGenesis(bapp, acc1, acc2)
+	require.Nil(t, err)
+
+	// Simulate a Block
+	SignCheckDeliver(t, bapp, sendMsg2, []int64{0}, true, priv1)
+
+	// Check balances
+	CheckBalance(t, bapp, addr1, "32foocoin")
+	CheckBalance(t, bapp, addr2, "47foocoin")
+	CheckBalance(t, bapp, addr3, "5foocoin")
+}
+
+func TestSengMsgMultipleInOut(t *testing.T) {
+	bapp := newBasecoinApp()
+
+	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 = setGenesis(bapp, acc1, acc2, acc4)
+	assert.Nil(t, err)
+
+	// CheckDeliver
+	SignCheckDeliver(t, bapp, sendMsg3, []int64{0, 0}, true, priv1, priv4)
+
+	// Check balances
+	CheckBalance(t, bapp, addr1, "32foocoin")
+	CheckBalance(t, bapp, addr4, "32foocoin")
+	CheckBalance(t, bapp, addr2, "52foocoin")
+	CheckBalance(t, bapp, addr3, "10foocoin")
+}
+
+func TestMsgSendDependent(t *testing.T) {
+	bapp := newBasecoinApp()
+
+	genCoins, err := sdk.ParseCoins("42foocoin")
+	require.Nil(t, err)
+
+	acc1 := auth.BaseAccount{
+		Address: addr1,
+		Coins:   genCoins,
+	}
+
+	// Construct genesis state
+	err = setGenesis(bapp, acc1)
+	require.Nil(t, err)
+
+	err = setGenesis(bapp, acc1)
+	assert.Nil(t, err)
+
+	// CheckDeliver
+	SignCheckDeliver(t, bapp, sendMsg1, []int64{0}, true, priv1)
+
+	// Check balances
+	CheckBalance(t, bapp, addr1, "32foocoin")
+	CheckBalance(t, bapp, addr2, "10foocoin")
+
+	// Simulate a Block
+	SignCheckDeliver(t, bapp, sendMsg4, []int64{0}, true, priv2)
+
+	// Check balances
+	CheckBalance(t, bapp, addr1, "42foocoin")
+}
+
+func TestMsgQuiz(t *testing.T) {
+	bapp := newBasecoinApp()
+
+	// Construct genesis state
+	// Construct some genesis bytes to reflect basecoin/types/AppAccount
+	baseAcc := auth.BaseAccount{
+		Address: addr1,
+		Coins:   nil,
+	}
+	acc1 := &types.AppAccount{baseAcc, "foobart"}
+
+	// Construct genesis state
+	genesisState := map[string]interface{}{
+		"accounts": []*types.GenesisAccount{
+			types.NewGenesisAccount(acc1),
+		},
+	}
+	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
+	require.Nil(t, err)
+
+	// Initialize the chain (nil)
+	vals := []abci.Validator{}
+	bapp.InitChain(abci.RequestInitChain{Validators: vals, AppStateBytes: stateBytes})
+	bapp.Commit()
+
+	// A checkTx context (true)
+	ctxCheck := bapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := bapp.accountMapper.GetAccount(ctxCheck, addr1)
+	assert.Equal(t, acc1, res1)
+
+}
+
+func TestIBCMsgs(t *testing.T) {
+	bapp := newBasecoinApp()
+
+	sourceChain := "source-chain"
+	destChain := "dest-chain"
+
+	baseAcc := auth.BaseAccount{
+		Address: addr1,
+		Coins:   coins,
+	}
+	acc1 := &types.AppAccount{baseAcc, "foobart"}
+
+	err := setGenesis(bapp, baseAcc)
+	assert.Nil(t, err)
+
+	// A checkTx context (true)
+	ctxCheck := bapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := bapp.accountMapper.GetAccount(ctxCheck, addr1)
+	assert.Equal(t, acc1, 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, bapp, transferMsg, []int64{0}, true, priv1)
+	CheckBalance(t, bapp, addr1, "")
+	SignCheckDeliver(t, bapp, transferMsg, []int64{1}, false, priv1)
+	SignCheckDeliver(t, bapp, receiveMsg, []int64{2}, true, priv1)
+	CheckBalance(t, bapp, addr1, "10foocoin")
+	SignCheckDeliver(t, bapp, receiveMsg, []int64{3}, false, priv1)
+}
+
+func genTx(msg sdk.Msg, seq []int64, priv ...crypto.PrivKeyEd25519) auth.StdTx {
+	sigs := make([]auth.StdSignature, len(priv))
+	for i, p := range priv {
+		sigs[i] = auth.StdSignature{
+			PubKey:    p.PubKey(),
+			Signature: p.Sign(auth.StdSignBytes(chainID, seq, fee, msg)),
+			Sequence:  seq[i],
+		}
+	}
+
+	return auth.NewStdTx(msg, fee, sigs)
+
+}
+
+func SignCheckDeliver(t *testing.T, bapp *BasecoinApp, msg sdk.Msg, seq []int64, expPass bool, priv ...crypto.PrivKeyEd25519) {
+
+	// Sign the tx
+	tx := genTx(msg, seq, priv...)
+	// Run a Check
+	res := bapp.Check(tx)
+	if expPass {
+		require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log)
+	} else {
+		require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log)
+	}
+
+	// Simulate a Block
+	bapp.BeginBlock(abci.RequestBeginBlock{})
+	res = bapp.Deliver(tx)
+	if expPass {
+		require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log)
+	} else {
+		require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log)
+	}
+	bapp.EndBlock(abci.RequestEndBlock{})
+	//bapp.Commit()
+}
+
+func CheckBalance(t *testing.T, bapp *BasecoinApp, addr sdk.Address, balExpected string) {
+	ctxDeliver := bapp.BaseApp.NewContext(false, abci.Header{})
+	res2 := bapp.accountMapper.GetAccount(ctxDeliver, addr)
+	assert.Equal(t, balExpected, fmt.Sprintf("%v", res2.GetCoins()))
+}
diff --git a/examples/democoin/app/app_test.go b/examples/democoin/app/app_test.go
index 01264399ae..ba041bcff1 100644
--- a/examples/democoin/app/app_test.go
+++ b/examples/democoin/app/app_test.go
@@ -2,6 +2,7 @@ package app
 
 import (
 	"encoding/json"
+	"fmt"
 	"os"
 	"testing"
 
@@ -9,8 +10,12 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/cosmos/cosmos-sdk/examples/democoin/types"
+	"github.com/cosmos/cosmos-sdk/examples/democoin/x/cool"
+	"github.com/cosmos/cosmos-sdk/examples/democoin/x/pow"
 	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"
@@ -18,9 +23,101 @@ import (
 	"github.com/tendermint/tmlibs/log"
 )
 
-func TestGenesis(t *testing.T) {
+// Construct some global addrs and txs for tests.
+var (
+	chainID = "" // TODO
+
+	priv1 = crypto.GenPrivKeyEd25519()
+	addr1 = priv1.PubKey().Address()
+	addr2 = crypto.GenPrivKeyEd25519().PubKey().Address()
+	coins = sdk.Coins{{"foocoin", 10}}
+	fee   = auth.StdFee{
+		sdk.Coins{{"foocoin", 0}},
+		1000000,
+	}
+
+	sendMsg = bank.MsgSend{
+		Inputs:  []bank.Input{bank.NewInput(addr1, coins)},
+		Outputs: []bank.Output{bank.NewOutput(addr2, coins)},
+	}
+
+	quizMsg1 = cool.MsgQuiz{
+		Sender:     addr1,
+		CoolAnswer: "icecold",
+	}
+
+	quizMsg2 = cool.MsgQuiz{
+		Sender:     addr1,
+		CoolAnswer: "badvibesonly",
+	}
+
+	setTrendMsg1 = cool.MsgSetTrend{
+		Sender: addr1,
+		Cool:   "icecold",
+	}
+
+	setTrendMsg2 = cool.MsgSetTrend{
+		Sender: addr1,
+		Cool:   "badvibesonly",
+	}
+
+	setTrendMsg3 = cool.MsgSetTrend{
+		Sender: addr1,
+		Cool:   "warmandkind",
+	}
+)
+
+func loggerAndDB() (log.Logger, dbm.DB) {
 	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "sdk/app")
 	db := dbm.NewMemDB()
+	return logger, db
+}
+
+func newDemocoinApp() *DemocoinApp {
+	logger, db := loggerAndDB()
+	return NewDemocoinApp(logger, db)
+}
+
+//_______________________________________________________________________
+
+func TestMsgs(t *testing.T) {
+	bapp := newDemocoinApp()
+
+	msgs := []struct {
+		msg sdk.Msg
+	}{
+		{sendMsg},
+		{quizMsg1},
+		{setTrendMsg1},
+	}
+
+	sequences := []int64{0}
+	for i, m := range msgs {
+		sig := priv1.Sign(auth.StdSignBytes(chainID, sequences, fee, m.msg))
+		tx := auth.NewStdTx(m.msg, fee, []auth.StdSignature{{
+			PubKey:    priv1.PubKey(),
+			Signature: sig,
+		}})
+
+		// just marshal/unmarshal!
+		txBytes, err := bapp.cdc.MarshalBinary(tx)
+		require.NoError(t, err, "i: %v", i)
+
+		// Run a Check
+		cres := bapp.CheckTx(txBytes)
+		assert.Equal(t, sdk.CodeUnknownAddress,
+			sdk.CodeType(cres.Code), "i: %v, log: %v", i, cres.Log)
+
+		// Simulate a Block
+		bapp.BeginBlock(abci.RequestBeginBlock{})
+		dres := bapp.DeliverTx(txBytes)
+		assert.Equal(t, sdk.CodeUnknownAddress,
+			sdk.CodeType(dres.Code), "i: %v, log: %v", i, dres.Log)
+	}
+}
+
+func TestGenesis(t *testing.T) {
+	logger, db := loggerAndDB()
 	bapp := NewDemocoinApp(logger, db)
 
 	// Construct some genesis bytes to reflect democoin/types/AppAccount
@@ -59,3 +156,272 @@ func TestGenesis(t *testing.T) {
 	res1 = bapp.accountMapper.GetAccount(ctx, baseAcc.Address)
 	assert.Equal(t, acc, res1)
 }
+
+func TestMsgSendWithAccounts(t *testing.T) {
+	bapp := newDemocoinApp()
+
+	// Construct some genesis bytes to reflect democoin/types/AppAccount
+	// Give 77 foocoin to the first key
+	coins, err := sdk.ParseCoins("77foocoin")
+	require.Nil(t, err)
+	baseAcc := auth.BaseAccount{
+		Address: addr1,
+		Coins:   coins,
+	}
+	acc1 := &types.AppAccount{baseAcc, "foobart"}
+
+	// Construct genesis state
+	genesisState := map[string]interface{}{
+		"accounts": []*types.GenesisAccount{
+			types.NewGenesisAccount(acc1),
+		},
+		"cool": map[string]string{
+			"trend": "ice-cold",
+		},
+	}
+	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
+	require.Nil(t, err)
+
+	// Initialize the chain
+	vals := []abci.Validator{}
+	bapp.InitChain(abci.RequestInitChain{Validators: vals, AppStateBytes: stateBytes})
+	bapp.Commit()
+
+	// A checkTx context (true)
+	ctxCheck := bapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := bapp.accountMapper.GetAccount(ctxCheck, addr1)
+	assert.Equal(t, acc1, res1)
+
+	// Sign the tx
+	sequences := []int64{0}
+	sig := priv1.Sign(auth.StdSignBytes(chainID, sequences, fee, sendMsg))
+	tx := auth.NewStdTx(sendMsg, fee, []auth.StdSignature{{
+		PubKey:    priv1.PubKey(),
+		Signature: sig,
+	}})
+
+	// Run a Check
+	res := bapp.Check(tx)
+	assert.Equal(t, sdk.ABCICodeOK, res.Code, res.Log)
+
+	// Simulate a Block
+	bapp.BeginBlock(abci.RequestBeginBlock{})
+	res = bapp.Deliver(tx)
+	assert.Equal(t, sdk.ABCICodeOK, res.Code, res.Log)
+
+	// Check balances
+	ctxDeliver := bapp.BaseApp.NewContext(false, abci.Header{})
+	res2 := bapp.accountMapper.GetAccount(ctxDeliver, addr1)
+	res3 := bapp.accountMapper.GetAccount(ctxDeliver, addr2)
+	assert.Equal(t, fmt.Sprintf("%v", res2.GetCoins()), "67foocoin")
+	assert.Equal(t, fmt.Sprintf("%v", res3.GetCoins()), "10foocoin")
+
+	// Delivering again should cause replay error
+	res = bapp.Deliver(tx)
+	assert.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, sdk.CodeInvalidSequence), sdk.ABCICodeType(res.Code), res.Log)
+
+	// bumping the txnonce number without resigning should be an auth error
+	tx.Signatures[0].Sequence = 1
+	res = bapp.Deliver(tx)
+	assert.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, sdk.CodeUnauthorized), sdk.ABCICodeType(res.Code), res.Log)
+
+	// resigning the tx with the bumped sequence should work
+	sequences = []int64{1}
+	sig = priv1.Sign(auth.StdSignBytes(chainID, sequences, fee, tx.Msg))
+	tx.Signatures[0].Signature = sig
+	res = bapp.Deliver(tx)
+	assert.Equal(t, sdk.ABCICodeOK, res.Code, res.Log)
+}
+
+func TestMsgMine(t *testing.T) {
+	bapp := newDemocoinApp()
+
+	// Construct genesis state
+	// Construct some genesis bytes to reflect democoin/types/AppAccount
+	baseAcc := auth.BaseAccount{
+		Address: addr1,
+		Coins:   nil,
+	}
+	acc1 := &types.AppAccount{baseAcc, "foobart"}
+
+	// Construct genesis state
+	genesisState := map[string]interface{}{
+		"accounts": []*types.GenesisAccount{
+			types.NewGenesisAccount(acc1),
+		},
+		"cool": map[string]string{
+			"trend": "ice-cold",
+		},
+		"pow": map[string]uint64{
+			"difficulty": 1,
+			"count":      0,
+		},
+	}
+	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
+	require.Nil(t, err)
+
+	// Initialize the chain (nil)
+	vals := []abci.Validator{}
+	bapp.InitChain(abci.RequestInitChain{Validators: vals, AppStateBytes: stateBytes})
+	bapp.Commit()
+
+	// A checkTx context (true)
+	ctxCheck := bapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := bapp.accountMapper.GetAccount(ctxCheck, addr1)
+	assert.Equal(t, acc1, res1)
+
+	// Mine and check for reward
+	mineMsg1 := pow.GenerateMsgMine(addr1, 1, 2)
+	SignCheckDeliver(t, bapp, mineMsg1, 0, true)
+	CheckBalance(t, bapp, "1pow")
+	// Mine again and check for reward
+	mineMsg2 := pow.GenerateMsgMine(addr1, 2, 3)
+	SignCheckDeliver(t, bapp, mineMsg2, 1, true)
+	CheckBalance(t, bapp, "2pow")
+	// Mine again - should be invalid
+	SignCheckDeliver(t, bapp, mineMsg2, 1, false)
+	CheckBalance(t, bapp, "2pow")
+
+}
+
+func TestMsgQuiz(t *testing.T) {
+	bapp := newDemocoinApp()
+
+	// Construct genesis state
+	// Construct some genesis bytes to reflect democoin/types/AppAccount
+	baseAcc := auth.BaseAccount{
+		Address: addr1,
+		Coins:   nil,
+	}
+	acc1 := &types.AppAccount{baseAcc, "foobart"}
+
+	// Construct genesis state
+	genesisState := map[string]interface{}{
+		"accounts": []*types.GenesisAccount{
+			types.NewGenesisAccount(acc1),
+		},
+		"cool": map[string]string{
+			"trend": "ice-cold",
+		},
+	}
+	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
+	require.Nil(t, err)
+
+	// Initialize the chain (nil)
+	vals := []abci.Validator{}
+	bapp.InitChain(abci.RequestInitChain{Validators: vals, AppStateBytes: stateBytes})
+	bapp.Commit()
+
+	// A checkTx context (true)
+	ctxCheck := bapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := bapp.accountMapper.GetAccount(ctxCheck, addr1)
+	assert.Equal(t, acc1, res1)
+
+	// Set the trend, submit a really cool quiz and check for reward
+	SignCheckDeliver(t, bapp, setTrendMsg1, 0, true)
+	SignCheckDeliver(t, bapp, quizMsg1, 1, true)
+	CheckBalance(t, bapp, "69icecold")
+	SignCheckDeliver(t, bapp, quizMsg2, 2, false) // result without reward
+	CheckBalance(t, bapp, "69icecold")
+	SignCheckDeliver(t, bapp, quizMsg1, 3, true)
+	CheckBalance(t, bapp, "138icecold")
+	SignCheckDeliver(t, bapp, setTrendMsg2, 4, true) // reset the trend
+	SignCheckDeliver(t, bapp, quizMsg1, 5, false)    // the same answer will nolonger do!
+	CheckBalance(t, bapp, "138icecold")
+	SignCheckDeliver(t, bapp, quizMsg2, 6, true) // earlier answer now relavent again
+	CheckBalance(t, bapp, "69badvibesonly,138icecold")
+	SignCheckDeliver(t, bapp, setTrendMsg3, 7, false) // expect to fail to set the trend to something which is not cool
+
+}
+
+func TestHandler(t *testing.T) {
+	bapp := newDemocoinApp()
+
+	sourceChain := "source-chain"
+	destChain := "dest-chain"
+
+	vals := []abci.Validator{}
+	baseAcc := auth.BaseAccount{
+		Address: addr1,
+		Coins:   coins,
+	}
+	acc1 := &types.AppAccount{baseAcc, "foobart"}
+	genesisState := map[string]interface{}{
+		"accounts": []*types.GenesisAccount{
+			types.NewGenesisAccount(acc1),
+		},
+		"cool": map[string]string{
+			"trend": "ice-cold",
+		},
+	}
+	stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
+	require.Nil(t, err)
+	bapp.InitChain(abci.RequestInitChain{Validators: vals, AppStateBytes: stateBytes})
+	bapp.Commit()
+
+	// A checkTx context (true)
+	ctxCheck := bapp.BaseApp.NewContext(true, abci.Header{})
+	res1 := bapp.accountMapper.GetAccount(ctxCheck, addr1)
+	assert.Equal(t, acc1, 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, bapp, transferMsg, 0, true)
+	CheckBalance(t, bapp, "")
+	SignCheckDeliver(t, bapp, transferMsg, 1, false)
+	SignCheckDeliver(t, bapp, receiveMsg, 2, true)
+	CheckBalance(t, bapp, "10foocoin")
+	SignCheckDeliver(t, bapp, receiveMsg, 3, false)
+}
+
+// TODO describe the use of this function
+func SignCheckDeliver(t *testing.T, bapp *DemocoinApp, msg sdk.Msg, seq int64, expPass bool) {
+
+	// Sign the tx
+	tx := auth.NewStdTx(msg, fee, []auth.StdSignature{{
+		PubKey:    priv1.PubKey(),
+		Signature: priv1.Sign(auth.StdSignBytes(chainID, []int64{seq}, fee, msg)),
+		Sequence:  seq,
+	}})
+
+	// Run a Check
+	res := bapp.Check(tx)
+	if expPass {
+		require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log)
+	} else {
+		require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log)
+	}
+
+	// Simulate a Block
+	bapp.BeginBlock(abci.RequestBeginBlock{})
+	res = bapp.Deliver(tx)
+	if expPass {
+		require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log)
+	} else {
+		require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log)
+	}
+	bapp.EndBlock(abci.RequestEndBlock{})
+	//bapp.Commit()
+}
+
+func CheckBalance(t *testing.T, bapp *DemocoinApp, balExpected string) {
+	ctxDeliver := bapp.BaseApp.NewContext(false, abci.Header{})
+	res2 := bapp.accountMapper.GetAccount(ctxDeliver, addr1)
+	assert.Equal(t, balExpected, fmt.Sprintf("%v", res2.GetCoins()))
+}
diff --git a/server/init_test.go b/server/init_test.go
index eca5295052..300decf334 100644
--- a/server/init_test.go
+++ b/server/init_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/tendermint/tmlibs/log"
 
-	"github.com/cosmos/cosmos-sdk/mock"
+	"github.com/cosmos/cosmos-sdk/server/mock"
 	"github.com/cosmos/cosmos-sdk/wire"
 	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
 )
diff --git a/mock/app.go b/server/mock/app.go
similarity index 100%
rename from mock/app.go
rename to server/mock/app.go
diff --git a/mock/app_test.go b/server/mock/app_test.go
similarity index 100%
rename from mock/app_test.go
rename to server/mock/app_test.go
diff --git a/mock/helpers.go b/server/mock/helpers.go
similarity index 100%
rename from mock/helpers.go
rename to server/mock/helpers.go
diff --git a/mock/store.go b/server/mock/store.go
similarity index 100%
rename from mock/store.go
rename to server/mock/store.go
diff --git a/mock/store_test.go b/server/mock/store_test.go
similarity index 100%
rename from mock/store_test.go
rename to server/mock/store_test.go
diff --git a/mock/tx.go b/server/mock/tx.go
similarity index 100%
rename from mock/tx.go
rename to server/mock/tx.go
diff --git a/server/start_test.go b/server/start_test.go
index 454f2d4922..1c1ad671ec 100644
--- a/server/start_test.go
+++ b/server/start_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/spf13/viper"
 	"github.com/stretchr/testify/require"
 
-	"github.com/cosmos/cosmos-sdk/mock"
+	"github.com/cosmos/cosmos-sdk/server/mock"
 	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/tendermint/abci/server"
 	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
diff --git a/x/auth/mock/app.go b/x/auth/mock/app.go
index 6ceff482bf..fcd130b44b 100644
--- a/x/auth/mock/app.go
+++ b/x/auth/mock/app.go
@@ -30,7 +30,7 @@ type App struct {
 	GenesisAccounts []auth.Account
 }
 
-// NewApp is used for testing the server. For the internal mock app stuff, it uses code in helpers.go
+// partially construct a new app on the memstore for module and genesis testing
 func NewApp() *App {
 	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "sdk/app")
 	db := dbm.NewMemDB()