diff --git a/types/errors.go b/types/errors.go
index 059a0dd749..20d4524644 100644
--- a/types/errors.go
+++ b/types/errors.go
@@ -52,6 +52,7 @@ const (
 	CodeUnknownAddress    CodeType = 9
 	CodeInsufficientCoins CodeType = 10
 	CodeInvalidCoins      CodeType = 11
+	CodeOutOfGas          CodeType = 12
 
 	// CodespaceRoot is a codespace for error codes in this file only.
 	// Notice that 0 is an "unset" codespace, which can be overridden with
@@ -88,6 +89,8 @@ func CodeToDefaultMsg(code CodeType) string {
 		return "Insufficient coins"
 	case CodeInvalidCoins:
 		return "Invalid coins"
+	case CodeOutOfGas:
+		return "Out of gas"
 	default:
 		return fmt.Sprintf("Unknown code %d", code)
 	}
@@ -131,6 +134,9 @@ func ErrInsufficientCoins(msg string) Error {
 func ErrInvalidCoins(msg string) Error {
 	return newErrorWithRootCodespace(CodeInvalidCoins, msg)
 }
+func ErrOutOfGas(msg string) Error {
+	return newErrorWithRootCodespace(CodeOutOfGas, msg)
+}
 
 //----------------------------------------
 // Error & sdkError
diff --git a/x/bank/keeper.go b/x/bank/keeper.go
index d23167c3c5..8bcbb2c867 100644
--- a/x/bank/keeper.go
+++ b/x/bank/keeper.go
@@ -17,7 +17,7 @@ func NewKeeper(am sdk.AccountMapper) Keeper {
 }
 
 // GetCoins returns the coins at the addr.
-func (keeper Keeper) GetCoins(ctx sdk.Context, addr sdk.Address) sdk.Coins {
+func (keeper Keeper) GetCoins(ctx sdk.Context, addr sdk.Address) (sdk.Coins, sdk.Error) {
 	return getCoins(ctx, keeper.am, addr)
 }
 
@@ -27,7 +27,7 @@ func (keeper Keeper) SetCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins)
 }
 
 // HasCoins returns whether or not an account has at least amt coins.
-func (keeper Keeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) bool {
+func (keeper Keeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) (bool, sdk.Error) {
 	return hasCoins(ctx, keeper.am, addr, amt)
 }
 
@@ -64,12 +64,12 @@ func NewSendKeeper(am sdk.AccountMapper) SendKeeper {
 }
 
 // GetCoins returns the coins at the addr.
-func (keeper SendKeeper) GetCoins(ctx sdk.Context, addr sdk.Address) sdk.Coins {
+func (keeper SendKeeper) GetCoins(ctx sdk.Context, addr sdk.Address) (sdk.Coins, sdk.Error) {
 	return getCoins(ctx, keeper.am, addr)
 }
 
 // HasCoins returns whether or not an account has at least amt coins.
-func (keeper SendKeeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) bool {
+func (keeper SendKeeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) (bool, sdk.Error) {
 	return hasCoins(ctx, keeper.am, addr, amt)
 }
 
@@ -96,23 +96,26 @@ func NewViewKeeper(am sdk.AccountMapper) ViewKeeper {
 }
 
 // GetCoins returns the coins at the addr.
-func (keeper ViewKeeper) GetCoins(ctx sdk.Context, addr sdk.Address) sdk.Coins {
+func (keeper ViewKeeper) GetCoins(ctx sdk.Context, addr sdk.Address) (sdk.Coins, sdk.Error) {
 	return getCoins(ctx, keeper.am, addr)
 }
 
 // HasCoins returns whether or not an account has at least amt coins.
-func (keeper ViewKeeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) bool {
+func (keeper ViewKeeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) (bool, sdk.Error) {
 	return hasCoins(ctx, keeper.am, addr, amt)
 }
 
 //______________________________________________________________________________________________
 
-func getCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address) sdk.Coins {
+func getCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address) (sdk.Coins, sdk.Error) {
+	if ctx.GasMeter().ConsumeGasOrFail(10) {
+		return sdk.Coins{}, sdk.ErrOutOfGas("out of gas in getCoins")
+	}
 	acc := am.GetAccount(ctx, addr)
 	if acc == nil {
-		return sdk.Coins{}
+		return sdk.Coins{}, nil
 	}
-	return acc.GetCoins()
+	return acc.GetCoins(), nil
 }
 
 func setCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) sdk.Error {
@@ -126,8 +129,15 @@ func setCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.C
 }
 
 // HasCoins returns whether or not an account has at least amt coins.
-func hasCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) bool {
-	return getCoins(ctx, am, addr).IsGTE(amt)
+func hasCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) (bool, sdk.Error) {
+	if ctx.GasMeter().ConsumeGasOrFail(10) {
+		return false, sdk.ErrOutOfGas("out of gas in hasCoins")
+	}
+	coins, err := getCoins(ctx, am, addr)
+	if err != nil {
+		return false, err
+	}
+	return coins.IsGTE(amt), nil
 }
 
 // SubtractCoins subtracts amt from the coins at the addr.
diff --git a/x/bank/keeper_test.go b/x/bank/keeper_test.go
index 324152df26..430b87c736 100644
--- a/x/bank/keeper_test.go
+++ b/x/bank/keeper_test.go
@@ -31,7 +31,7 @@ func TestKeeper(t *testing.T) {
 	cdc := wire.NewCodec()
 	auth.RegisterBaseAccount(cdc)
 
-	ctx := sdk.NewContext(ms, abci.Header{}, false, nil, log.NewNopLogger(), 0)
+	ctx := sdk.NewContext(ms, abci.Header{}, false, nil, log.NewNopLogger(), 100000)
 	accountMapper := auth.NewAccountMapper(cdc, authKey, &auth.BaseAccount{})
 	coinKeeper := NewKeeper(accountMapper)
 
@@ -42,58 +42,79 @@ func TestKeeper(t *testing.T) {
 
 	// Test GetCoins/SetCoins
 	accountMapper.SetAccount(ctx, acc)
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
+	coins, err := coinKeeper.GetCoins(ctx, addr)
+	assert.Nil(t, err)
+	assert.True(t, coins.IsEqual(sdk.Coins{}))
 
 	coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}}))
 
 	// Test HasCoins
-	assert.True(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}))
-	assert.True(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}}))
-	assert.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}}))
-	assert.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}}))
+	foo, _ := coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
+	assert.True(t, foo)
+	foo, _ = coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}})
+	assert.True(t, foo)
+	foo, _ = coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}})
+	assert.False(t, foo)
+	bar, _ := coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}})
+	assert.False(t, bar)
 
 	// Test AddCoins
 	coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"foocoin", 15}})
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 25}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 25}}))
 
 	coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"barcoin", 15}})
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 15}, {"foocoin", 25}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 15}, {"foocoin", 25}}))
 
 	// Test SubtractCoins
 	coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
 	coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"barcoin", 5}})
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 15}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 15}}))
 
-	_, _, err := coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"barcoin", 11}})
+	_, err = coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"barcoin", 11}})
 	assert.Implements(t, (*sdk.Error)(nil), err)
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 15}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 15}}))
 
 	coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"barcoin", 10}})
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 15}}))
-	assert.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 1}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 15}}))
+	bar, _ = coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 1}})
+	assert.False(t, bar)
 
 	// Test SendCoins
 	coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 5}})
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
-	assert.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"foocoin", 5}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr2)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 5}}))
 
 	_, err2 := coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 50}})
 	assert.Implements(t, (*sdk.Error)(nil), err2)
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
-	assert.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"foocoin", 5}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr2)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 5}}))
 
 	coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"barcoin", 30}})
 	coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"barcoin", 10}, {"foocoin", 5}})
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 5}}))
-	assert.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 10}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 5}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr2)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 10}}))
 
 	// Test InputOutputCoins
 	input1 := NewInput(addr2, sdk.Coins{{"foocoin", 2}})
 	output1 := NewOutput(addr, sdk.Coins{{"foocoin", 2}})
 	coinKeeper.InputOutputCoins(ctx, []Input{input1}, []Output{output1})
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 7}}))
-	assert.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 8}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 7}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr2)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 8}}))
 
 	inputs := []Input{
 		NewInput(addr, sdk.Coins{{"foocoin", 3}}),
@@ -105,9 +126,12 @@ func TestKeeper(t *testing.T) {
 		NewOutput(addr3, sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}),
 	}
 	coinKeeper.InputOutputCoins(ctx, inputs, outputs)
-	assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 21}, {"foocoin", 4}}))
-	assert.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 7}, {"foocoin", 6}}))
-	assert.True(t, coinKeeper.GetCoins(ctx, addr3).IsEqual(sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 21}, {"foocoin", 4}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr2)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 7}, {"foocoin", 6}}))
+	coins, err = coinKeeper.GetCoins(ctx, addr3)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}))
 
 }
 
@@ -117,7 +141,7 @@ func TestSendKeeper(t *testing.T) {
 	cdc := wire.NewCodec()
 	auth.RegisterBaseAccount(cdc)
 
-	ctx := sdk.NewContext(ms, abci.Header{}, false, nil, log.NewNopLogger(), 0)
+	ctx := sdk.NewContext(ms, abci.Header{}, false, nil, log.NewNopLogger(), 100000)
 	accountMapper := auth.NewAccountMapper(cdc, authKey, &auth.BaseAccount{})
 	coinKeeper := NewKeeper(accountMapper)
 	sendKeeper := NewSendKeeper(accountMapper)
@@ -129,40 +153,55 @@ func TestSendKeeper(t *testing.T) {
 
 	// Test GetCoins/SetCoins
 	accountMapper.SetAccount(ctx, acc)
-	assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
+	coins, err := sendKeeper.GetCoins(ctx, addr)
+	assert.Nil(t, err)
+	assert.True(t, coins.IsEqual(sdk.Coins{}))
 
 	coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
-	assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}}))
 
 	// Test HasCoins
-	assert.True(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}))
-	assert.True(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}}))
-	assert.False(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}}))
-	assert.False(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}}))
+	foo, _ := sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
+	assert.True(t, foo)
+	foo, _ = sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}})
+	assert.True(t, foo)
+	foo, _ = sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}})
+	assert.False(t, foo)
+	bar, _ := sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}})
+	assert.False(t, bar)
 
 	coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 15}})
 
 	// Test SendCoins
 	sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 5}})
-	assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
-	assert.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"foocoin", 5}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr2)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 5}}))
 
 	_, err2 := sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 50}})
 	assert.Implements(t, (*sdk.Error)(nil), err2)
-	assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
-	assert.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"foocoin", 5}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr2)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 5}}))
 
 	coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"barcoin", 30}})
 	sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"barcoin", 10}, {"foocoin", 5}})
-	assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 5}}))
-	assert.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 10}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 5}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr2)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 10}}))
 
 	// Test InputOutputCoins
 	input1 := NewInput(addr2, sdk.Coins{{"foocoin", 2}})
 	output1 := NewOutput(addr, sdk.Coins{{"foocoin", 2}})
 	sendKeeper.InputOutputCoins(ctx, []Input{input1}, []Output{output1})
-	assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 7}}))
-	assert.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 8}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 7}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr2)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 8}}))
 
 	inputs := []Input{
 		NewInput(addr, sdk.Coins{{"foocoin", 3}}),
@@ -174,9 +213,12 @@ func TestSendKeeper(t *testing.T) {
 		NewOutput(addr3, sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}),
 	}
 	sendKeeper.InputOutputCoins(ctx, inputs, outputs)
-	assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 21}, {"foocoin", 4}}))
-	assert.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 7}, {"foocoin", 6}}))
-	assert.True(t, sendKeeper.GetCoins(ctx, addr3).IsEqual(sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 21}, {"foocoin", 4}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr2)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 7}, {"foocoin", 6}}))
+	coins, err = sendKeeper.GetCoins(ctx, addr3)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}))
 
 }
 
@@ -186,7 +228,7 @@ func TestViewKeeper(t *testing.T) {
 	cdc := wire.NewCodec()
 	auth.RegisterBaseAccount(cdc)
 
-	ctx := sdk.NewContext(ms, abci.Header{}, false, nil, log.NewNopLogger(), 0)
+	ctx := sdk.NewContext(ms, abci.Header{}, false, nil, log.NewNopLogger(), 100000)
 	accountMapper := auth.NewAccountMapper(cdc, authKey, &auth.BaseAccount{})
 	coinKeeper := NewKeeper(accountMapper)
 	viewKeeper := NewViewKeeper(accountMapper)
@@ -196,14 +238,21 @@ func TestViewKeeper(t *testing.T) {
 
 	// Test GetCoins/SetCoins
 	accountMapper.SetAccount(ctx, acc)
-	assert.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
+	coins, err := viewKeeper.GetCoins(ctx, addr)
+	assert.Nil(t, err)
+	assert.True(t, coins.IsEqual(sdk.Coins{}))
 
 	coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
-	assert.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
+	coins, err = viewKeeper.GetCoins(ctx, addr)
+	assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}}))
 
 	// Test HasCoins
-	assert.True(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}))
-	assert.True(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}}))
-	assert.False(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}}))
-	assert.False(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}}))
+	foo, _ := viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
+	assert.True(t, foo)
+	foo, _ = viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}})
+	assert.True(t, foo)
+	foo, _ = viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}})
+	assert.False(t, foo)
+	bar, _ := viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}})
+	assert.False(t, bar)
 }
diff --git a/x/ibc/ibc_test.go b/x/ibc/ibc_test.go
index 298b5b4620..e05245ff38 100644
--- a/x/ibc/ibc_test.go
+++ b/x/ibc/ibc_test.go
@@ -24,7 +24,7 @@ func defaultContext(key sdk.StoreKey) sdk.Context {
 	cms := store.NewCommitMultiStore(db)
 	cms.MountStoreWithDB(key, sdk.StoreTypeIAVL, db)
 	cms.LoadLatestVersion()
-	ctx := sdk.NewContext(cms, abci.Header{}, false, nil, log.NewNopLogger(), 0)
+	ctx := sdk.NewContext(cms, abci.Header{}, false, nil, log.NewNopLogger(), 10000)
 	return ctx
 }
 
diff --git a/x/stake/test_common.go b/x/stake/test_common.go
index 15c300d41c..5c1c387232 100644
--- a/x/stake/test_common.go
+++ b/x/stake/test_common.go
@@ -158,7 +158,7 @@ func createTestInput(t *testing.T, isCheckTx bool, initCoins int64) (sdk.Context
 	err := ms.LoadLatestVersion()
 	require.Nil(t, err)
 
-	ctx := sdk.NewContext(ms, abci.Header{ChainID: "foochainid"}, isCheckTx, nil, log.NewNopLogger(), 0)
+	ctx := sdk.NewContext(ms, abci.Header{ChainID: "foochainid"}, isCheckTx, nil, log.NewNopLogger(), 10000)
 	cdc := makeTestCodec()
 	accountMapper := auth.NewAccountMapper(
 		cdc,                 // amino codec