diff --git a/examples/basecoin/.gitignore b/examples/basecoin/.gitignore
deleted file mode 100644
index 25e54fd6bb..0000000000
--- a/examples/basecoin/.gitignore
+++ /dev/null
@@ -1,12 +0,0 @@
-*.swp
-*.swo
-vendor
-build
-app/data
-
-
-### Vagrant ###
-.vagrant/
-*.box
-*.log
-vagrant
diff --git a/examples/basecoin/app/app.go b/examples/basecoin/app/app.go
index d315f977ef..77816ba40c 100644
--- a/examples/basecoin/app/app.go
+++ b/examples/basecoin/app/app.go
@@ -81,14 +81,14 @@ func MakeCodec() *wire.Codec {
 
 	const msgTypeSend = 0x1
 	const msgTypeIssue = 0x2
-	const msgTypeWhatCool = 0x3
-	const msgTypeSetWhatCool = 0x4
+	const msgTypeQuiz = 0x3
+	const msgTypeSetTrend = 0x4
 	var _ = oldwire.RegisterInterface(
 		struct{ sdk.Msg }{},
 		oldwire.ConcreteType{bank.SendMsg{}, msgTypeSend},
 		oldwire.ConcreteType{bank.IssueMsg{}, msgTypeIssue},
-		oldwire.ConcreteType{cool.WhatCoolMsg{}, msgTypeWhatCool},
-		oldwire.ConcreteType{cool.SetWhatCoolMsg{}, msgTypeSetWhatCool},
+		oldwire.ConcreteType{cool.QuizMsg{}, msgTypeQuiz},
+		oldwire.ConcreteType{cool.SetTrendMsg{}, msgTypeSetTrend},
 	)
 
 	const accTypeApp = 0x1
diff --git a/examples/basecoin/app/app_test.go b/examples/basecoin/app/app_test.go
index 148f0411fc..c2ef3e4547 100644
--- a/examples/basecoin/app/app_test.go
+++ b/examples/basecoin/app/app_test.go
@@ -23,6 +23,8 @@ import (
 
 // Construct some global addrs and txs for tests.
 var (
+	chainID = "" // TODO
+
 	priv1 = crypto.GenPrivKeyEd25519()
 	addr1 = priv1.PubKey().Address()
 	addr2 = crypto.GenPrivKeyEd25519().PubKey().Address()
@@ -33,19 +35,29 @@ var (
 		Outputs: []bank.Output{bank.NewOutput(addr2, coins)},
 	}
 
-	whatCoolMsg1 = cool.WhatCoolMsg{
-		Sender:         addr1,
-		CoolerThanCool: "icecold",
+	quizMsg1 = cool.QuizMsg{
+		Sender:     addr1,
+		CoolAnswer: "icecold",
 	}
 
-	whatCoolMsg2 = cool.WhatCoolMsg{
-		Sender:         addr1,
-		CoolerThanCool: "icecold",
+	quizMsg2 = cool.QuizMsg{
+		Sender:     addr1,
+		CoolAnswer: "badvibesonly",
 	}
 
-	setWhatCoolMsg = cool.SetWhatCoolMsg{
-		Sender:   addr1,
-		WhatCool: "goodbye",
+	setTrendMsg1 = cool.SetTrendMsg{
+		Sender: addr1,
+		Cool:   "icecold",
+	}
+
+	setTrendMsg2 = cool.SetTrendMsg{
+		Sender: addr1,
+		Cool:   "badvibesonly",
+	}
+
+	setTrendMsg3 = cool.SetTrendMsg{
+		Sender: addr1,
+		Cool:   "warmandkind",
 	}
 )
 
@@ -64,11 +76,10 @@ func TestMsgs(t *testing.T) {
 		msg sdk.Msg
 	}{
 		{sendMsg},
-		{whatCoolMsg1},
-		{setWhatCoolMsg},
+		{quizMsg1},
+		{setTrendMsg1},
 	}
 
-	chainID := ""
 	sequences := []int64{0}
 	for i, m := range msgs {
 		sig := priv1.Sign(sdk.StdSignBytes(chainID, sequences, m.msg))
@@ -168,7 +179,6 @@ func TestSendMsgWithAccounts(t *testing.T) {
 	assert.Equal(t, acc1, res1)
 
 	// Sign the tx
-	chainID := "" // TODO: InitChain should get the ChainID
 	sequences := []int64{0}
 	sig := priv1.Sign(sdk.StdSignBytes(chainID, sequences, sendMsg))
 	tx := sdk.NewStdTx(sendMsg, []sdk.StdSignature{{
@@ -209,56 +219,83 @@ func TestSendMsgWithAccounts(t *testing.T) {
 	assert.Equal(t, sdk.CodeOK, res.Code, res.Log)
 }
 
-//func TestWhatCoolMsg(t *testing.T) {
-//bapp := newBasecoinApp()
+func TestQuizMsg(t *testing.T) {
+	bapp := newBasecoinApp()
 
-//// Construct genesis state
-//// Construct some genesis bytes to reflect basecoin/types/AppAccount
-//// Give 77 foocoin to the first key
-//coins, err := sdk.ParseCoins("1icecold")
-//require.Nil(t, err)
-//baseAcc := auth.BaseAccount{
-//Address: addr1,
-//Coins:   coins,
-//}
-//acc1 := &types.AppAccount{baseAcc, "foobart"}
+	// Construct genesis state
+	// Construct some genesis bytes to reflect basecoin/types/AppAccount
+	coins := sdk.Coins{}
+	baseAcc := auth.BaseAccount{
+		Address: addr1,
+		Coins:   coins,
+	}
+	acc1 := &types.AppAccount{baseAcc, "foobart"}
 
-//// Construct genesis state
-//genesisState := types.GenesisState{
-//Accounts: []*types.GenesisAccount{
-//types.NewGenesisAccount(acc1),
-//},
-//}
-//stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
-//require.Nil(t, err)
+	// Construct genesis state
+	genesisState := types.GenesisState{
+		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{vals, stateBytes})
-//bapp.Commit()
+	// Initialize the chain (nil)
+	vals := []abci.Validator{}
+	bapp.InitChain(abci.RequestInitChain{vals, 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)
+	// 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
-//tx := sdk.NewStdTx(whatCoolMsg1, []sdk.StdSignature{{
-//PubKey:    priv1.PubKey(),
-//Signature: priv1.Sign(whatCoolMsg1.GetSignBytes()),
-//}})
+	// 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, true) // 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, true)     // 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
 
-//// Run a Check
-//res := bapp.Check(tx)
-//assert.Equal(t, sdk.CodeOK, res.Code, res.Log)
+}
 
-//// Simulate a Block
-//bapp.BeginBlock(abci.RequestBeginBlock{})
-//res = bapp.Deliver(tx)
-//assert.Equal(t, sdk.CodeOK, res.Code, res.Log)
+func SignCheckDeliver(t *testing.T, bapp *BasecoinApp, msg sdk.Msg, seq int64, expPass bool) {
 
-//// Check balances
-//ctxDeliver := bapp.BaseApp.NewContext(false, abci.Header{})
-//res2 := bapp.accountMapper.GetAccount(ctxDeliver, addr1)
-//assert.Equal(t, "70icecold", fmt.Sprintf("%v", res2.GetCoins()))
-//}
+	// Sign the tx
+	tx := sdk.NewStdTx(msg, []sdk.StdSignature{{
+		PubKey:    priv1.PubKey(),
+		Signature: priv1.Sign(sdk.StdSignBytes(chainID, []int64{seq}, msg)),
+		Sequence:  seq,
+	}})
+
+	// Run a Check
+	res := bapp.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
+	bapp.BeginBlock(abci.RequestBeginBlock{})
+	res = bapp.Deliver(tx)
+	if expPass {
+		require.Equal(t, sdk.CodeOK, res.Code, res.Log)
+	} else {
+		require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
+	}
+}
+
+func CheckBalance(t *testing.T, bapp *BasecoinApp, 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/examples/basecoin/cmd/basecli/main.go b/examples/basecoin/cmd/basecli/main.go
index 4a2cdd6f4b..1827b4d98e 100644
--- a/examples/basecoin/cmd/basecli/main.go
+++ b/examples/basecoin/cmd/basecli/main.go
@@ -58,11 +58,11 @@ func main() {
 		)...)
 	basecliCmd.AddCommand(
 		client.PostCommands(
-			coolcmd.WhatCoolTxCmd(cdc),
+			coolcmd.QuizTxCmd(cdc),
 		)...)
 	basecliCmd.AddCommand(
 		client.PostCommands(
-			coolcmd.SetWhatCoolTxCmd(cdc),
+			coolcmd.SetTrendTxCmd(cdc),
 		)...)
 
 	// add proxy, version and key info
diff --git a/examples/basecoin/x/cool/commands/cooltx.go b/examples/basecoin/x/cool/commands/tx.go
similarity index 82%
rename from examples/basecoin/x/cool/commands/cooltx.go
rename to examples/basecoin/x/cool/commands/tx.go
index c2a1acee97..2b16546806 100644
--- a/examples/basecoin/x/cool/commands/cooltx.go
+++ b/examples/basecoin/x/cool/commands/tx.go
@@ -12,10 +12,10 @@ import (
 	"github.com/cosmos/cosmos-sdk/examples/basecoin/x/cool"
 )
 
-// what cool transaction
-func WhatCoolTxCmd(cdc *wire.Codec) *cobra.Command {
+// take the coolness quiz transaction
+func QuizTxCmd(cdc *wire.Codec) *cobra.Command {
 	return &cobra.Command{
-		Use:   "whatcool [answer]",
+		Use:   "cool [answer]",
 		Short: "What's cooler than being cool?",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) != 1 || len(args[0]) == 0 {
@@ -29,7 +29,7 @@ func WhatCoolTxCmd(cdc *wire.Codec) *cobra.Command {
 			}
 
 			// create the message
-			msg := cool.NewWhatCoolMsg(from, args[0])
+			msg := cool.NewQuizMsg(from, args[0])
 
 			// build and sign the transaction, then broadcast to Tendermint
 			res, err := builder.SignBuildBroadcast(msg, cdc)
@@ -43,10 +43,10 @@ func WhatCoolTxCmd(cdc *wire.Codec) *cobra.Command {
 	}
 }
 
-// set what cool transaction
-func SetWhatCoolTxCmd(cdc *wire.Codec) *cobra.Command {
+// set a new cool trend transaction
+func SetTrendTxCmd(cdc *wire.Codec) *cobra.Command {
 	return &cobra.Command{
-		Use:   "setwhatcool [answer]",
+		Use:   "setcool [answer]",
 		Short: "You're so cool, tell us what is cool!",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) != 1 || len(args[0]) == 0 {
@@ -60,7 +60,7 @@ func SetWhatCoolTxCmd(cdc *wire.Codec) *cobra.Command {
 			}
 
 			// create the message
-			msg := cool.NewSetWhatCoolMsg(from, args[0])
+			msg := cool.NewSetTrendMsg(from, args[0])
 
 			// build and sign the transaction, then broadcast to Tendermint
 			res, err := builder.SignBuildBroadcast(msg, cdc)
diff --git a/examples/basecoin/x/cool/handler.go b/examples/basecoin/x/cool/handler.go
index 152ae2f339..c0aae11bba 100644
--- a/examples/basecoin/x/cool/handler.go
+++ b/examples/basecoin/x/cool/handler.go
@@ -22,10 +22,10 @@ import (
 func NewHandler(ck bank.CoinKeeper, cm Mapper) sdk.Handler {
 	return func(ctx sdk.Context, msg sdk.Msg) sdk.Result {
 		switch msg := msg.(type) {
-		case SetWhatCoolMsg:
-			return handleSetWhatCoolMsg(ctx, cm, msg)
-		case WhatCoolMsg:
-			return handleWhatCoolMsg(ctx, ck, cm, msg)
+		case SetTrendMsg:
+			return handleSetTrendMsg(ctx, cm, msg)
+		case QuizMsg:
+			return handleQuizMsg(ctx, ck, cm, msg)
 		default:
 			errMsg := fmt.Sprintf("Unrecognized cool Msg type: %v", reflect.TypeOf(msg).Name())
 			return sdk.ErrUnknownRequest(errMsg).Result()
@@ -33,20 +33,19 @@ func NewHandler(ck bank.CoinKeeper, cm Mapper) sdk.Handler {
 	}
 }
 
-// Handle WhatCoolMsg This is the engine of your module
-func handleSetWhatCoolMsg(ctx sdk.Context, cm Mapper, msg SetWhatCoolMsg) sdk.Result {
-	cm.SetWhatCool(ctx, msg.WhatCool)
+// Handle QuizMsg This is the engine of your module
+func handleSetTrendMsg(ctx sdk.Context, cm Mapper, msg SetTrendMsg) sdk.Result {
+	cm.SetTrend(ctx, msg.Cool)
 	return sdk.Result{}
 }
 
-// Handle WhatCoolMsg This is the engine of your module
-func handleWhatCoolMsg(ctx sdk.Context, ck bank.CoinKeeper, cm Mapper, msg WhatCoolMsg) sdk.Result {
+// Handle QuizMsg This is the engine of your module
+func handleQuizMsg(ctx sdk.Context, ck bank.CoinKeeper, cm Mapper, msg QuizMsg) sdk.Result {
 
-	whatsCool := cm.GetWhatCool(ctx)
+	currentTrend := cm.GetTrend(ctx)
 
-	if msg.CoolerThanCool == whatsCool {
-
-		bonusCoins := sdk.Coins{{whatsCool, 69}}
+	if msg.CoolAnswer == currentTrend {
+		bonusCoins := sdk.Coins{{currentTrend, 69}}
 		_, err := ck.AddCoins(ctx, msg.Sender, bonusCoins)
 		if err != nil {
 			return err.Result()
diff --git a/examples/basecoin/x/cool/mapper.go b/examples/basecoin/x/cool/mapper.go
index f437f8ca43..2e0a791fa6 100644
--- a/examples/basecoin/x/cool/mapper.go
+++ b/examples/basecoin/x/cool/mapper.go
@@ -13,18 +13,18 @@ func NewMapper(key sdk.StoreKey) Mapper {
 	return Mapper{key}
 }
 
-// Key to knowing whats cool
-var whatCoolKey = []byte("WhatsCoolKey")
+// Key to knowing the trend on the streets!
+var trendKey = []byte("TrendKey")
 
 // Implements sdk.AccountMapper.
-func (am Mapper) GetWhatCool(ctx sdk.Context) string {
+func (am Mapper) GetTrend(ctx sdk.Context) string {
 	store := ctx.KVStore(am.key)
-	bz := store.Get(whatCoolKey)
+	bz := store.Get(trendKey)
 	return string(bz)
 }
 
 // Implements sdk.AccountMapper.
-func (am Mapper) SetWhatCool(ctx sdk.Context, whatscool string) {
+func (am Mapper) SetTrend(ctx sdk.Context, newTrend string) {
 	store := ctx.KVStore(am.key)
-	store.Set(whatCoolKey, []byte(whatscool))
+	store.Set(trendKey, []byte(newTrend))
 }
diff --git a/examples/basecoin/x/cool/types.go b/examples/basecoin/x/cool/types.go
index 872afe7f8a..f721bfa19b 100644
--- a/examples/basecoin/x/cool/types.go
+++ b/examples/basecoin/x/cool/types.go
@@ -10,46 +10,46 @@ import (
 
 // A really cool msg type, these fields are can be entirely arbitrary and
 // custom to your message
-type SetWhatCoolMsg struct {
-	Sender   sdk.Address
-	WhatCool string
+type SetTrendMsg struct {
+	Sender sdk.Address
+	Cool   string
 }
 
 // New cool message
-func NewSetWhatCoolMsg(sender sdk.Address, whatcool string) SetWhatCoolMsg {
-	return SetWhatCoolMsg{
-		Sender:   sender,
-		WhatCool: whatcool,
+func NewSetTrendMsg(sender sdk.Address, cool string) SetTrendMsg {
+	return SetTrendMsg{
+		Sender: sender,
+		Cool:   cool,
 	}
 }
 
 // enforce the msg type at compile time
-var _ sdk.Msg = SetWhatCoolMsg{}
+var _ sdk.Msg = SetTrendMsg{}
 
 // nolint
-func (msg SetWhatCoolMsg) Type() string                            { return "cool" }
-func (msg SetWhatCoolMsg) Get(key interface{}) (value interface{}) { return nil }
-func (msg SetWhatCoolMsg) GetSigners() []sdk.Address               { return []sdk.Address{msg.Sender} }
-func (msg SetWhatCoolMsg) String() string {
-	return fmt.Sprintf("SetWhatCoolMsg{Sender: %v, WhatCool: %v}", msg.Sender, msg.WhatCool)
+func (msg SetTrendMsg) Type() string                            { return "cool" }
+func (msg SetTrendMsg) Get(key interface{}) (value interface{}) { return nil }
+func (msg SetTrendMsg) GetSigners() []sdk.Address               { return []sdk.Address{msg.Sender} }
+func (msg SetTrendMsg) String() string {
+	return fmt.Sprintf("SetTrendMsg{Sender: %v, Cool: %v}", msg.Sender, msg.Cool)
 }
 
 // Validate Basic is used to quickly disqualify obviously invalid messages quickly
-func (msg SetWhatCoolMsg) ValidateBasic() sdk.Error {
+func (msg SetTrendMsg) ValidateBasic() sdk.Error {
 	if len(msg.Sender) == 0 {
 		return sdk.ErrUnrecognizedAddress(msg.Sender).Trace("")
 	}
-	if strings.Contains(msg.WhatCool, "hot") {
+	if strings.Contains(msg.Cool, "hot") {
 		return sdk.ErrUnauthorized("").Trace("hot is not cool")
 	}
-	if strings.Contains(msg.WhatCool, "warm") {
+	if strings.Contains(msg.Cool, "warm") {
 		return sdk.ErrUnauthorized("").Trace("warm is not very cool")
 	}
 	return nil
 }
 
 // Get the bytes for the message signer to sign on
-func (msg SetWhatCoolMsg) GetSignBytes() []byte {
+func (msg SetTrendMsg) GetSignBytes() []byte {
 	b, err := json.Marshal(msg)
 	if err != nil {
 		panic(err)
@@ -59,34 +59,34 @@ func (msg SetWhatCoolMsg) GetSignBytes() []byte {
 
 //_______________________________________________________________________
 
-// A really cool msg type, these fields are can be entirely arbitrary and
-// custom to your message
-type WhatCoolMsg struct {
-	Sender         sdk.Address
-	CoolerThanCool string
+// A message type to quiz how cool you are. these fields are can be entirely
+// arbitrary and custom to your message
+type QuizMsg struct {
+	Sender     sdk.Address
+	CoolAnswer string
 }
 
 // New cool message
-func NewWhatCoolMsg(sender sdk.Address, coolerthancool string) WhatCoolMsg {
-	return WhatCoolMsg{
-		Sender:         sender,
-		CoolerThanCool: coolerthancool,
+func NewQuizMsg(sender sdk.Address, coolerthancool string) QuizMsg {
+	return QuizMsg{
+		Sender:     sender,
+		CoolAnswer: coolerthancool,
 	}
 }
 
 // enforce the msg type at compile time
-var _ sdk.Msg = WhatCoolMsg{}
+var _ sdk.Msg = QuizMsg{}
 
 // nolint
-func (msg WhatCoolMsg) Type() string                            { return "cool" }
-func (msg WhatCoolMsg) Get(key interface{}) (value interface{}) { return nil }
-func (msg WhatCoolMsg) GetSigners() []sdk.Address               { return []sdk.Address{msg.Sender} }
-func (msg WhatCoolMsg) String() string {
-	return fmt.Sprintf("WhatCoolMsg{Sender: %v, CoolerThanCool: %v}", msg.Sender, msg.CoolerThanCool)
+func (msg QuizMsg) Type() string                            { return "cool" }
+func (msg QuizMsg) Get(key interface{}) (value interface{}) { return nil }
+func (msg QuizMsg) GetSigners() []sdk.Address               { return []sdk.Address{msg.Sender} }
+func (msg QuizMsg) String() string {
+	return fmt.Sprintf("QuizMsg{Sender: %v, CoolAnswer: %v}", msg.Sender, msg.CoolAnswer)
 }
 
 // Validate Basic is used to quickly disqualify obviously invalid messages quickly
-func (msg WhatCoolMsg) ValidateBasic() sdk.Error {
+func (msg QuizMsg) ValidateBasic() sdk.Error {
 	if len(msg.Sender) == 0 {
 		return sdk.ErrUnrecognizedAddress(msg.Sender).Trace("")
 	}
@@ -94,7 +94,7 @@ func (msg WhatCoolMsg) ValidateBasic() sdk.Error {
 }
 
 // Get the bytes for the message signer to sign on
-func (msg WhatCoolMsg) GetSignBytes() []byte {
+func (msg QuizMsg) GetSignBytes() []byte {
 	b, err := json.Marshal(msg)
 	if err != nil {
 		panic(err)