diff --git a/docs/guide/counter/plugins/counter/counter.go b/docs/guide/counter/plugins/counter/counter.go
index e9c2b503d7..6a17653d30 100644
--- a/docs/guide/counter/plugins/counter/counter.go
+++ b/docs/guide/counter/plugins/counter/counter.go
@@ -128,13 +128,13 @@ func (Handler) Name() string {
 func (Handler) AssertDispatcher() {}
 
 // CheckTx checks if the tx is properly structured
-func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, _ basecoin.Checker) (res basecoin.Result, err error) {
+func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, _ basecoin.Checker) (res basecoin.CheckResult, err error) {
 	_, err = checkTx(ctx, tx)
 	return
 }
 
 // DeliverTx executes the tx if valid
-func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, dispatch basecoin.Deliver) (res basecoin.Result, err error) {
+func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, dispatch basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 	ctr, err := checkTx(ctx, tx)
 	if err != nil {
 		return res, err
diff --git a/modules/auth/signature.go b/modules/auth/signature.go
index c80dc6998d..a10ebd5b98 100644
--- a/modules/auth/signature.go
+++ b/modules/auth/signature.go
@@ -39,7 +39,7 @@ type Signable interface {
 }
 
 // CheckTx verifies the signatures are correct - fulfills Middlware interface
-func (Signatures) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
+func (Signatures) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
 	sigs, tnext, err := getSigners(tx)
 	if err != nil {
 		return res, err
@@ -49,7 +49,7 @@ func (Signatures) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoi
 }
 
 // DeliverTx verifies the signatures are correct - fulfills Middlware interface
-func (Signatures) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
+func (Signatures) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 	sigs, tnext, err := getSigners(tx)
 	if err != nil {
 		return res, err
diff --git a/modules/base/chain.go b/modules/base/chain.go
index 1068fba572..98391e14b4 100644
--- a/modules/base/chain.go
+++ b/modules/base/chain.go
@@ -24,7 +24,7 @@ func (Chain) Name() string {
 var _ stack.Middleware = Chain{}
 
 // CheckTx makes sure we are on the proper chain - fulfills Middlware interface
-func (c Chain) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
+func (c Chain) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
 	stx, err := c.checkChainTx(ctx.ChainID(), ctx.BlockHeight(), tx)
 	if err != nil {
 		return res, err
@@ -33,7 +33,7 @@ func (c Chain) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.T
 }
 
 // DeliverTx makes sure we are on the proper chain - fulfills Middlware interface
-func (c Chain) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
+func (c Chain) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 	stx, err := c.checkChainTx(ctx.ChainID(), ctx.BlockHeight(), tx)
 	if err != nil {
 		return res, err
diff --git a/modules/base/logger.go b/modules/base/logger.go
index 2cd888386d..126e3d056a 100644
--- a/modules/base/logger.go
+++ b/modules/base/logger.go
@@ -26,7 +26,7 @@ func (Logger) Name() string {
 var _ stack.Middleware = Logger{}
 
 // CheckTx logs time and result - fulfills Middlware interface
-func (Logger) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
+func (Logger) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
 	start := time.Now()
 	res, err = next.CheckTx(ctx, store, tx)
 	delta := time.Now().Sub(start)
@@ -41,7 +41,7 @@ func (Logger) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx
 }
 
 // DeliverTx logs time and result - fulfills Middlware interface
-func (Logger) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
+func (Logger) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 	start := time.Now()
 	res, err = next.DeliverTx(ctx, store, tx)
 	delta := time.Now().Sub(start)
diff --git a/modules/base/multiplexer.go b/modules/base/multiplexer.go
index 92f3e9c188..4f2c4713a0 100644
--- a/modules/base/multiplexer.go
+++ b/modules/base/multiplexer.go
@@ -1,73 +1,73 @@
 package base
 
-import (
-	"strings"
+// import (
+// 	"strings"
 
-	wire "github.com/tendermint/go-wire"
-	"github.com/tendermint/go-wire/data"
+// 	wire "github.com/tendermint/go-wire"
+// 	"github.com/tendermint/go-wire/data"
 
-	"github.com/tendermint/basecoin"
-	"github.com/tendermint/basecoin/stack"
-	"github.com/tendermint/basecoin/state"
-)
+// 	"github.com/tendermint/basecoin"
+// 	"github.com/tendermint/basecoin/stack"
+// 	"github.com/tendermint/basecoin/state"
+// )
 
-//nolint
-const (
-	NameMultiplexer = "mplx"
-)
+// //nolint
+// const (
+// 	NameMultiplexer = "mplx"
+// )
 
-// Multiplexer grabs a MultiTx and sends them sequentially down the line
-type Multiplexer struct {
-	stack.PassOption
-}
+// // Multiplexer grabs a MultiTx and sends them sequentially down the line
+// type Multiplexer struct {
+// 	stack.PassOption
+// }
 
-// Name of the module - fulfills Middleware interface
-func (Multiplexer) Name() string {
-	return NameMultiplexer
-}
+// // Name of the module - fulfills Middleware interface
+// func (Multiplexer) Name() string {
+// 	return NameMultiplexer
+// }
 
-var _ stack.Middleware = Multiplexer{}
+// var _ stack.Middleware = Multiplexer{}
 
-// CheckTx splits the input tx and checks them all - fulfills Middlware interface
-func (Multiplexer) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
-	if mtx, ok := tx.Unwrap().(*MultiTx); ok {
-		return runAll(ctx, store, mtx.Txs, next.CheckTx)
-	}
-	return next.CheckTx(ctx, store, tx)
-}
+// // CheckTx splits the input tx and checks them all - fulfills Middlware interface
+// func (Multiplexer) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
+// 	if mtx, ok := tx.Unwrap().(*MultiTx); ok {
+// 		return runAll(ctx, store, mtx.Txs, next.CheckTx)
+// 	}
+// 	return next.CheckTx(ctx, store, tx)
+// }
 
-// DeliverTx splits the input tx and checks them all - fulfills Middlware interface
-func (Multiplexer) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
-	if mtx, ok := tx.Unwrap().(*MultiTx); ok {
-		return runAll(ctx, store, mtx.Txs, next.DeliverTx)
-	}
-	return next.DeliverTx(ctx, store, tx)
-}
+// // DeliverTx splits the input tx and checks them all - fulfills Middlware interface
+// func (Multiplexer) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
+// 	if mtx, ok := tx.Unwrap().(*MultiTx); ok {
+// 		return runAll(ctx, store, mtx.Txs, next.DeliverTx)
+// 	}
+// 	return next.DeliverTx(ctx, store, tx)
+// }
 
-func runAll(ctx basecoin.Context, store state.SimpleDB, txs []basecoin.Tx, next basecoin.CheckerFunc) (res basecoin.Result, err error) {
-	// store all results, unless anything errors
-	rs := make([]basecoin.Result, len(txs))
-	for i, stx := range txs {
-		rs[i], err = next(ctx, store, stx)
-		if err != nil {
-			return
-		}
-	}
-	// now combine the results into one...
-	return combine(rs), nil
-}
+// func runAll(ctx basecoin.Context, store state.SimpleDB, txs []basecoin.Tx, next basecoin.CheckerFunc) (res basecoin.Result, err error) {
+// 	// store all results, unless anything errors
+// 	rs := make([]basecoin.Result, len(txs))
+// 	for i, stx := range txs {
+// 		rs[i], err = next(ctx, store, stx)
+// 		if err != nil {
+// 			return
+// 		}
+// 	}
+// 	// now combine the results into one...
+// 	return combine(rs), nil
+// }
 
-// combines all data bytes as a go-wire array.
-// joins all log messages with \n
-func combine(all []basecoin.Result) basecoin.Result {
-	datas := make([]data.Bytes, len(all))
-	logs := make([]string, len(all))
-	for i, r := range all {
-		datas[i] = r.Data
-		logs[i] = r.Log
-	}
-	return basecoin.Result{
-		Data: wire.BinaryBytes(datas),
-		Log:  strings.Join(logs, "\n"),
-	}
-}
+// // combines all data bytes as a go-wire array.
+// // joins all log messages with \n
+// func combine(all []basecoin.Result) basecoin.Result {
+// 	datas := make([]data.Bytes, len(all))
+// 	logs := make([]string, len(all))
+// 	for i, r := range all {
+// 		datas[i] = r.Data
+// 		logs[i] = r.Log
+// 	}
+// 	return basecoin.Result{
+// 		Data: wire.BinaryBytes(datas),
+// 		Log:  strings.Join(logs, "\n"),
+// 	}
+// }
diff --git a/modules/base/tx.go b/modules/base/tx.go
index d365c1b7b8..b2f23db2aa 100644
--- a/modules/base/tx.go
+++ b/modules/base/tx.go
@@ -16,13 +16,13 @@ const (
 
 //nolint
 const (
-	TypeMultiTx = NameMultiplexer + "/tx"
+	// TypeMultiTx = NameMultiplexer + "/tx"
 	TypeChainTx = NameChain + "/tx"
 )
 
 func init() {
 	basecoin.TxMapper.
-		RegisterImplementation(MultiTx{}, TypeMultiTx, ByteMultiTx).
+		// RegisterImplementation(MultiTx{}, TypeMultiTx, ByteMultiTx).
 		RegisterImplementation(ChainTx{}, TypeChainTx, ByteChainTx)
 }
 
diff --git a/modules/coin/handler.go b/modules/coin/handler.go
index e22dacd265..cb1f4093dc 100644
--- a/modules/coin/handler.go
+++ b/modules/coin/handler.go
@@ -35,7 +35,7 @@ func (Handler) AssertDispatcher() {}
 
 // CheckTx checks if there is enough money in the account
 func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB,
-	tx basecoin.Tx, _ basecoin.Checker) (res basecoin.Result, err error) {
+	tx basecoin.Tx, _ basecoin.Checker) (res basecoin.CheckResult, err error) {
 
 	err = tx.ValidateBasic()
 	if err != nil {
@@ -46,14 +46,14 @@ func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB,
 	case SendTx:
 		return res, h.checkSendTx(ctx, store, t)
 	case CreditTx:
-		return h.creditTx(ctx, store, t)
+		return res, h.creditTx(ctx, store, t)
 	}
 	return res, errors.ErrUnknownTxType(tx.Unwrap())
 }
 
 // DeliverTx moves the money
 func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
-	tx basecoin.Tx, cb basecoin.Deliver) (res basecoin.Result, err error) {
+	tx basecoin.Tx, cb basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 
 	err = tx.ValidateBasic()
 	if err != nil {
@@ -62,9 +62,9 @@ func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
 
 	switch t := tx.Unwrap().(type) {
 	case SendTx:
-		return h.sendTx(ctx, store, t, cb)
+		return res, h.sendTx(ctx, store, t, cb)
 	case CreditTx:
-		return h.creditTx(ctx, store, t)
+		return res, h.creditTx(ctx, store, t)
 	}
 	return res, errors.ErrUnknownTxType(tx.Unwrap())
 }
@@ -85,11 +85,11 @@ func (h Handler) SetOption(l log.Logger, store state.SimpleDB,
 }
 
 func (h Handler) sendTx(ctx basecoin.Context, store state.SimpleDB,
-	send SendTx, cb basecoin.Deliver) (res basecoin.Result, err error) {
+	send SendTx, cb basecoin.Deliver) error {
 
-	err = checkTx(ctx, send)
+	err := checkTx(ctx, send)
 	if err != nil {
-		return res, err
+		return err
 	}
 
 	// deduct from all input accounts
@@ -97,7 +97,7 @@ func (h Handler) sendTx(ctx basecoin.Context, store state.SimpleDB,
 	for _, in := range send.Inputs {
 		_, err = ChangeCoins(store, in.Address, in.Coins.Negative())
 		if err != nil {
-			return res, err
+			return err
 		}
 		senders = append(senders, in.Address)
 	}
@@ -112,7 +112,7 @@ func (h Handler) sendTx(ctx basecoin.Context, store state.SimpleDB,
 
 		_, err = ChangeCoins(store, out.Address, out.Coins)
 		if err != nil {
-			return res, err
+			return err
 		}
 		// now send ibc packet if needed...
 		if out.Address.ChainID != "" {
@@ -133,46 +133,46 @@ func (h Handler) sendTx(ctx basecoin.Context, store state.SimpleDB,
 			ibcCtx := ctx.WithPermissions(ibc.AllowIBC(NameCoin))
 			_, err := cb.DeliverTx(ibcCtx, store, packet.Wrap())
 			if err != nil {
-				return res, err
+				return err
 			}
 		}
 	}
 
 	// a-ok!
-	return res, nil
+	return nil
 }
 
 func (h Handler) creditTx(ctx basecoin.Context, store state.SimpleDB,
-	credit CreditTx) (res basecoin.Result, err error) {
+	credit CreditTx) error {
 
 	// first check permissions!!
 	info, err := loadHandlerInfo(store)
 	if err != nil {
-		return res, err
+		return err
 	}
 	if info.Issuer.Empty() || !ctx.HasPermission(info.Issuer) {
-		return res, errors.ErrUnauthorized()
+		return errors.ErrUnauthorized()
 	}
 
 	// load up the account
 	addr := ChainAddr(credit.Debitor)
 	acct, err := GetAccount(store, addr)
 	if err != nil {
-		return res, err
+		return err
 	}
 
 	// make and check changes
 	acct.Coins = acct.Coins.Plus(credit.Credit)
 	if !acct.Coins.IsNonnegative() {
-		return res, ErrInsufficientFunds()
+		return ErrInsufficientFunds()
 	}
 	acct.Credit = acct.Credit.Plus(credit.Credit)
 	if !acct.Credit.IsNonnegative() {
-		return res, ErrInsufficientCredit()
+		return ErrInsufficientCredit()
 	}
 
 	err = storeAccount(store, addr.Bytes(), acct)
-	return res, err
+	return err
 }
 
 func checkTx(ctx basecoin.Context, send SendTx) error {
diff --git a/modules/fee/handler.go b/modules/fee/handler.go
index 19e9f9f8fb..1c597c7f41 100644
--- a/modules/fee/handler.go
+++ b/modules/fee/handler.go
@@ -45,40 +45,56 @@ func (SimpleFeeMiddleware) Name() string {
 }
 
 // CheckTx - check the transaction
-func (h SimpleFeeMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
-	return h.doTx(ctx, store, tx, next.CheckTx)
+func (h SimpleFeeMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
+	fee, err := h.verifyFee(ctx, tx)
+	if err != nil {
+		return res, err
+	}
+
+	if !fee.Fee.IsZero() { // now, try to make a IPC call to coins...
+		send := coin.NewSendOneTx(fee.Payer, h.Collector, coin.Coins{fee.Fee})
+		_, err = next.CheckTx(ctx, store, send)
+		if err != nil {
+			return res, err
+		}
+	}
+	return next.CheckTx(ctx, store, fee.Tx)
 }
 
 // DeliverTx - send the fee handler transaction
-func (h SimpleFeeMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
-	return h.doTx(ctx, store, tx, next.DeliverTx)
+func (h SimpleFeeMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
+	fee, err := h.verifyFee(ctx, tx)
+	if err != nil {
+		return res, err
+	}
+
+	if !fee.Fee.IsZero() { // now, try to make a IPC call to coins...
+		send := coin.NewSendOneTx(fee.Payer, h.Collector, coin.Coins{fee.Fee})
+		_, err = next.DeliverTx(ctx, store, send)
+		if err != nil {
+			return res, err
+		}
+	}
+	return next.DeliverTx(ctx, store, fee.Tx)
 }
 
-func (h SimpleFeeMiddleware) doTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.CheckerFunc) (res basecoin.Result, err error) {
+func (h SimpleFeeMiddleware) verifyFee(ctx basecoin.Context, tx basecoin.Tx) (Fee, error) {
 	feeTx, ok := tx.Unwrap().(Fee)
 	if !ok {
 		// the fee wrapper is not required if there is no minimum
 		if h.MinFee.IsZero() {
-			return next(ctx, store, tx)
+			return feeTx, nil
 		}
-		return res, errors.ErrInvalidFormat(TypeFees, tx)
+		return feeTx, errors.ErrInvalidFormat(TypeFees, tx)
 	}
 
 	// see if it is the proper denom and big enough
 	fee := feeTx.Fee
 	if fee.Denom != h.MinFee.Denom {
-		return res, ErrWrongFeeDenom(h.MinFee.Denom)
+		return feeTx, ErrWrongFeeDenom(h.MinFee.Denom)
 	}
 	if !fee.IsGTE(h.MinFee) {
-		return res, ErrInsufficientFees()
+		return feeTx, ErrInsufficientFees()
 	}
-
-	// now, try to make a IPC call to coins...
-	send := coin.NewSendOneTx(feeTx.Payer, h.Collector, coin.Coins{fee})
-	_, err = next(ctx, store, send)
-	if err != nil {
-		return res, err
-	}
-
-	return next(ctx, store, feeTx.Tx)
+	return feeTx, nil
 }
diff --git a/modules/ibc/handler.go b/modules/ibc/handler.go
index 4665f5f328..297957af9a 100644
--- a/modules/ibc/handler.go
+++ b/modules/ibc/handler.go
@@ -70,26 +70,27 @@ func (h Handler) SetOption(l log.Logger, store state.SimpleDB, module, key, valu
 
 // CheckTx verifies the packet is formated correctly, and has the proper sequence
 // for a registered chain
-func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
 	err = tx.ValidateBasic()
 	if err != nil {
 		return res, err
 	}
 
-	switch t := tx.Unwrap().(type) {
+	// TODO: better fee calculation (don't do complex crypto)
+	switch tx.Unwrap().(type) {
 	case RegisterChainTx:
-		return h.initSeed(ctx, store, t)
+		return res, nil
 	case UpdateChainTx:
-		return h.updateSeed(ctx, store, t)
+		return res, nil
 	case CreatePacketTx:
-		return h.createPacket(ctx, store, t)
+		return res, nil
 	}
 	return res, errors.ErrUnknownTxType(tx.Unwrap())
 }
 
 // DeliverTx verifies all signatures on the tx and updates the chain state
 // apropriately
-func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
 	err = tx.ValidateBasic()
 	if err != nil {
 		return res, err
@@ -111,7 +112,7 @@ func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx baseco
 //
 // only the registrar, if set, is allowed to do this
 func (h Handler) initSeed(ctx basecoin.Context, store state.SimpleDB,
-	t RegisterChainTx) (res basecoin.Result, err error) {
+	t RegisterChainTx) (res basecoin.DeliverResult, err error) {
 
 	info := LoadInfo(store)
 	if !info.Registrar.Empty() && !ctx.HasPermission(info.Registrar) {
@@ -135,7 +136,7 @@ func (h Handler) initSeed(ctx basecoin.Context, store state.SimpleDB,
 // updateSeed checks the seed against the existing chain data and rejects it if it
 // doesn't fit (or no chain data)
 func (h Handler) updateSeed(ctx basecoin.Context, store state.SimpleDB,
-	t UpdateChainTx) (res basecoin.Result, err error) {
+	t UpdateChainTx) (res basecoin.DeliverResult, err error) {
 
 	chainID := t.ChainID()
 	s := NewChainSet(store)
@@ -165,7 +166,7 @@ func (h Handler) updateSeed(ctx basecoin.Context, store state.SimpleDB,
 // createPacket makes sure all permissions are good and the destination
 // chain is registed.  If so, it appends it to the outgoing queue
 func (h Handler) createPacket(ctx basecoin.Context, store state.SimpleDB,
-	t CreatePacketTx) (res basecoin.Result, err error) {
+	t CreatePacketTx) (res basecoin.DeliverResult, err error) {
 
 	// make sure the chain is registed
 	dest := t.DestChain
@@ -203,6 +204,6 @@ func (h Handler) createPacket(ctx basecoin.Context, store state.SimpleDB,
 	packet.Sequence = q.Tail()
 	q.Push(packet.Bytes())
 
-	res = basecoin.Result{Log: fmt.Sprintf("Packet %s %d", dest, packet.Sequence)}
+	res = basecoin.DeliverResult{Log: fmt.Sprintf("Packet %s %d", dest, packet.Sequence)}
 	return
 }
diff --git a/modules/ibc/middleware.go b/modules/ibc/middleware.go
index fe6176964a..191a533134 100644
--- a/modules/ibc/middleware.go
+++ b/modules/ibc/middleware.go
@@ -26,7 +26,7 @@ func (Middleware) Name() string {
 
 // CheckTx verifies the named chain and height is present, and verifies
 // the merkle proof in the packet
-func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
+func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
 	// if it is not a PostPacket, just let it go through
 	post, ok := tx.Unwrap().(PostPacketTx)
 	if !ok {
@@ -43,7 +43,7 @@ func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basec
 
 // DeliverTx verifies the named chain and height is present, and verifies
 // the merkle proof in the packet
-func (m Middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
+func (m Middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 	// if it is not a PostPacket, just let it go through
 	post, ok := tx.Unwrap().(PostPacketTx)
 	if !ok {
diff --git a/modules/ibc/test_helpers.go b/modules/ibc/test_helpers.go
index 9d118141e2..089bc5d9f5 100644
--- a/modules/ibc/test_helpers.go
+++ b/modules/ibc/test_helpers.go
@@ -100,7 +100,7 @@ func (a *AppChain) IncrementHeight(delta int) int {
 
 // DeliverTx runs the tx and commits the new tree, incrementing height
 // by one.
-func (a *AppChain) DeliverTx(tx basecoin.Tx, perms ...basecoin.Actor) (basecoin.Result, error) {
+func (a *AppChain) DeliverTx(tx basecoin.Tx, perms ...basecoin.Actor) (basecoin.DeliverResult, error) {
 	ctx := stack.MockContext(a.chainID, uint64(a.height)).WithPermissions(perms...)
 	store := a.store.Checkpoint()
 	res, err := a.app.DeliverTx(ctx, store, tx)
diff --git a/modules/nonce/replaycheck.go b/modules/nonce/replaycheck.go
index bc57ded966..1a125dea9c 100644
--- a/modules/nonce/replaycheck.go
+++ b/modules/nonce/replaycheck.go
@@ -25,7 +25,7 @@ var _ stack.Middleware = ReplayCheck{}
 
 // CheckTx verifies tx is not being replayed - fulfills Middlware interface
 func (r ReplayCheck) CheckTx(ctx basecoin.Context, store state.SimpleDB,
-	tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
+	tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
 
 	stx, err := r.checkIncrementNonceTx(ctx, store, tx)
 	if err != nil {
@@ -39,7 +39,7 @@ func (r ReplayCheck) CheckTx(ctx basecoin.Context, store state.SimpleDB,
 // NOTE It is okay to modify the sequence before running the wrapped TX because if the
 // wrapped Tx fails, the state changes are not applied
 func (r ReplayCheck) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
-	tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
+	tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 
 	stx, err := r.checkIncrementNonceTx(ctx, store, tx)
 	if err != nil {
diff --git a/modules/roles/handler.go b/modules/roles/handler.go
index c6f785c14d..155ba056b7 100644
--- a/modules/roles/handler.go
+++ b/modules/roles/handler.go
@@ -27,7 +27,7 @@ func (Handler) Name() string {
 }
 
 // CheckTx verifies if the transaction is properly formated
-func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
 	var cr CreateRoleTx
 	cr, err = checkTx(ctx, tx)
 	if err != nil {
@@ -40,7 +40,7 @@ func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin
 // DeliverTx tries to create a new role.
 //
 // Returns an error if the role already exists
-func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
 	create, err := checkTx(ctx, tx)
 	if err != nil {
 		return res, err
diff --git a/modules/roles/middleware.go b/modules/roles/middleware.go
index 296f4fa1a6..c25382a62f 100644
--- a/modules/roles/middleware.go
+++ b/modules/roles/middleware.go
@@ -27,7 +27,7 @@ func (Middleware) Name() string {
 // CheckTx tries to assume the named role if requested.
 // If no role is requested, do nothing.
 // If insufficient authority to assume the role, return error.
-func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
+func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
 	// if this is not an AssumeRoleTx, then continue
 	assume, ok := tx.Unwrap().(AssumeRoleTx)
 	if !ok { // this also breaks the recursion below
@@ -46,7 +46,7 @@ func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basec
 // DeliverTx tries to assume the named role if requested.
 // If no role is requested, do nothing.
 // If insufficient authority to assume the role, return error.
-func (m Middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
+func (m Middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 	// if this is not an AssumeRoleTx, then continue
 	assume, ok := tx.Unwrap().(AssumeRoleTx)
 	if !ok { // this also breaks the recursion below
diff --git a/stack/checkpoint.go b/stack/checkpoint.go
index 00fbe61a17..66524ae54d 100644
--- a/stack/checkpoint.go
+++ b/stack/checkpoint.go
@@ -25,7 +25,7 @@ func (Checkpoint) Name() string {
 var _ Middleware = Checkpoint{}
 
 // CheckTx reverts all data changes if there was an error
-func (c Checkpoint) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
+func (c Checkpoint) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
 	if !c.OnCheck {
 		return next.CheckTx(ctx, store, tx)
 	}
@@ -38,7 +38,7 @@ func (c Checkpoint) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basec
 }
 
 // DeliverTx reverts all data changes if there was an error
-func (c Checkpoint) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
+func (c Checkpoint) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 	if !c.OnDeliver {
 		return next.DeliverTx(ctx, store, tx)
 	}
diff --git a/stack/context.go b/stack/context.go
index 7359adbe18..6fe31f244a 100644
--- a/stack/context.go
+++ b/stack/context.go
@@ -104,7 +104,7 @@ func withIBC(ctx basecoin.Context) basecoin.Context {
 }
 
 func secureCheck(h basecoin.Checker, parent basecoin.Context) basecoin.Checker {
-	next := func(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+	next := func(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
 		if !parent.IsParent(ctx) {
 			return res, errors.New("Passing in non-child Context")
 		}
@@ -114,7 +114,7 @@ func secureCheck(h basecoin.Checker, parent basecoin.Context) basecoin.Checker {
 }
 
 func secureDeliver(h basecoin.Deliver, parent basecoin.Context) basecoin.Deliver {
-	next := func(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+	next := func(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
 		if !parent.IsParent(ctx) {
 			return res, errors.New("Passing in non-child Context")
 		}
diff --git a/stack/dispatcher.go b/stack/dispatcher.go
index a8ff96c483..0efd7d3396 100644
--- a/stack/dispatcher.go
+++ b/stack/dispatcher.go
@@ -64,7 +64,7 @@ func (d *Dispatcher) Name() string {
 // Tries to find a registered module (Dispatchable) based on the name of the tx.
 // The tx name (as registered with go-data) should be in the form `<module name>/XXXX`,
 // where `module name` must match the name of a dispatchable and XXX can be any string.
-func (d *Dispatcher) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (d *Dispatcher) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
 	r, err := d.lookupTx(tx)
 	if err != nil {
 		return res, err
@@ -85,7 +85,7 @@ func (d *Dispatcher) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx base
 // Tries to find a registered module (Dispatchable) based on the name of the tx.
 // The tx name (as registered with go-data) should be in the form `<module name>/XXXX`,
 // where `module name` must match the name of a dispatchable and XXX can be any string.
-func (d *Dispatcher) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (d *Dispatcher) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
 	r, err := d.lookupTx(tx)
 	if err != nil {
 		return res, err
diff --git a/stack/helpers.go b/stack/helpers.go
index b38e86bc69..e91086d35d 100644
--- a/stack/helpers.go
+++ b/stack/helpers.go
@@ -105,13 +105,13 @@ func (OKHandler) Name() string {
 }
 
 // CheckTx always returns an empty success tx
-func (ok OKHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
-	return basecoin.Result{Log: ok.Log}, nil
+func (ok OKHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
+	return basecoin.CheckResult{Log: ok.Log}, nil
 }
 
 // DeliverTx always returns an empty success tx
-func (ok OKHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
-	return basecoin.Result{Log: ok.Log}, nil
+func (ok OKHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
+	return basecoin.DeliverResult{Log: ok.Log}, nil
 }
 
 // EchoHandler returns success, echoing res.Data = tx bytes
@@ -127,15 +127,15 @@ func (EchoHandler) Name() string {
 }
 
 // CheckTx always returns an empty success tx
-func (EchoHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (EchoHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
 	data, err := data.ToWire(tx)
-	return basecoin.Result{Data: data}, err
+	return basecoin.CheckResult{Data: data}, err
 }
 
 // DeliverTx always returns an empty success tx
-func (EchoHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (EchoHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
 	data, err := data.ToWire(tx)
-	return basecoin.Result{Data: data}, err
+	return basecoin.DeliverResult{Data: data}, err
 }
 
 // FailHandler always returns an error
@@ -152,12 +152,12 @@ func (FailHandler) Name() string {
 }
 
 // CheckTx always returns the given error
-func (f FailHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (f FailHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
 	return res, errors.Wrap(f.Err)
 }
 
 // DeliverTx always returns the given error
-func (f FailHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (f FailHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
 	return res, errors.Wrap(f.Err)
 }
 
@@ -176,7 +176,7 @@ func (PanicHandler) Name() string {
 }
 
 // CheckTx always panics
-func (p PanicHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (p PanicHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
 	if p.Err != nil {
 		panic(p.Err)
 	}
@@ -184,7 +184,7 @@ func (p PanicHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx bas
 }
 
 // DeliverTx always panics
-func (p PanicHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (p PanicHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
 	if p.Err != nil {
 		panic(p.Err)
 	}
@@ -204,7 +204,7 @@ func (CheckHandler) Name() string {
 }
 
 // CheckTx verifies the permissions
-func (c CheckHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (c CheckHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
 	check, ok := tx.Unwrap().(CheckTx)
 	if !ok {
 		return res, errors.ErrUnknownTxType(tx)
@@ -219,7 +219,16 @@ func (c CheckHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx bas
 }
 
 // DeliverTx verifies the permissions
-func (c CheckHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
-	// until something changes, just do the same as check
-	return c.CheckTx(ctx, store, tx)
+func (c CheckHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
+	check, ok := tx.Unwrap().(CheckTx)
+	if !ok {
+		return res, errors.ErrUnknownTxType(tx)
+	}
+
+	for _, perm := range check.Required {
+		if !ctx.HasPermission(perm) {
+			return res, errors.ErrUnauthorized()
+		}
+	}
+	return res, nil
 }
diff --git a/stack/helperware.go b/stack/helperware.go
index 353f909075..6fd2078a31 100644
--- a/stack/helperware.go
+++ b/stack/helperware.go
@@ -25,14 +25,14 @@ func (_ CheckMiddleware) Name() string {
 	return NameCheck
 }
 
-func (p CheckMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
+func (p CheckMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
 	if !ctx.HasPermission(p.Required) {
 		return res, errors.ErrUnauthorized()
 	}
 	return next.CheckTx(ctx, store, tx)
 }
 
-func (p CheckMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
+func (p CheckMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 	if !ctx.HasPermission(p.Required) {
 		return res, errors.ErrUnauthorized()
 	}
@@ -51,12 +51,12 @@ func (_ GrantMiddleware) Name() string {
 	return NameGrant
 }
 
-func (g GrantMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
+func (g GrantMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
 	ctx = ctx.WithPermissions(g.Auth)
 	return next.CheckTx(ctx, store, tx)
 }
 
-func (g GrantMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
+func (g GrantMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 	ctx = ctx.WithPermissions(g.Auth)
 	return next.DeliverTx(ctx, store, tx)
 }
diff --git a/stack/interface.go b/stack/interface.go
index fedf70401d..81cdbffad5 100644
--- a/stack/interface.go
+++ b/stack/interface.go
@@ -21,27 +21,27 @@ type Middleware interface {
 
 type CheckerMiddle interface {
 	CheckTx(ctx basecoin.Context, store state.SimpleDB,
-		tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error)
+		tx basecoin.Tx, next basecoin.Checker) (basecoin.CheckResult, error)
 }
 
 type CheckerMiddleFunc func(basecoin.Context, state.SimpleDB,
-	basecoin.Tx, basecoin.Checker) (basecoin.Result, error)
+	basecoin.Tx, basecoin.Checker) (basecoin.CheckResult, error)
 
 func (c CheckerMiddleFunc) CheckTx(ctx basecoin.Context, store state.SimpleDB,
-	tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) {
+	tx basecoin.Tx, next basecoin.Checker) (basecoin.CheckResult, error) {
 	return c(ctx, store, tx, next)
 }
 
 type DeliverMiddle interface {
 	DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx,
-		next basecoin.Deliver) (basecoin.Result, error)
+		next basecoin.Deliver) (basecoin.DeliverResult, error)
 }
 
 type DeliverMiddleFunc func(basecoin.Context, state.SimpleDB,
-	basecoin.Tx, basecoin.Deliver) (basecoin.Result, error)
+	basecoin.Tx, basecoin.Deliver) (basecoin.DeliverResult, error)
 
 func (d DeliverMiddleFunc) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
-	tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) {
+	tx basecoin.Tx, next basecoin.Deliver) (basecoin.DeliverResult, error) {
 	return d(ctx, store, tx, next)
 }
 
@@ -62,14 +62,14 @@ func (c SetOptionMiddleFunc) SetOption(l log.Logger, store state.SimpleDB,
 type PassCheck struct{}
 
 func (_ PassCheck) CheckTx(ctx basecoin.Context, store state.SimpleDB,
-	tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) {
+	tx basecoin.Tx, next basecoin.Checker) (basecoin.CheckResult, error) {
 	return next.CheckTx(ctx, store, tx)
 }
 
 type PassDeliver struct{}
 
 func (_ PassDeliver) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
-	tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) {
+	tx basecoin.Tx, next basecoin.Deliver) (basecoin.DeliverResult, error) {
 	return next.DeliverTx(ctx, store, tx)
 }
 
@@ -113,12 +113,12 @@ func (w wrapped) Name() string {
 }
 
 func (w wrapped) CheckTx(ctx basecoin.Context, store state.SimpleDB,
-	tx basecoin.Tx, _ basecoin.Checker) (basecoin.Result, error) {
+	tx basecoin.Tx, _ basecoin.Checker) (basecoin.CheckResult, error) {
 	return w.h.CheckTx(ctx, store, tx)
 }
 
 func (w wrapped) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
-	tx basecoin.Tx, _ basecoin.Deliver) (basecoin.Result, error) {
+	tx basecoin.Tx, _ basecoin.Deliver) (basecoin.DeliverResult, error) {
 	return w.h.DeliverTx(ctx, store, tx)
 }
 
diff --git a/stack/middleware.go b/stack/middleware.go
index c5f6a9b71c..e24e86bde0 100644
--- a/stack/middleware.go
+++ b/stack/middleware.go
@@ -31,7 +31,7 @@ func (m *middleware) wrapCtx(ctx basecoin.Context) basecoin.Context {
 }
 
 // CheckTx always returns an empty success tx
-func (m *middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (basecoin.Result, error) {
+func (m *middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (basecoin.CheckResult, error) {
 	// make sure we pass in proper context to child
 	next := secureCheck(m.next, ctx)
 	// set the permissions for this app
@@ -42,7 +42,7 @@ func (m *middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx base
 }
 
 // DeliverTx always returns an empty success tx
-func (m *middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (m *middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
 	// make sure we pass in proper context to child
 	next := secureDeliver(m.next, ctx)
 	// set the permissions for this app
diff --git a/stack/recovery.go b/stack/recovery.go
index 77ff09ef41..eae976ad0a 100644
--- a/stack/recovery.go
+++ b/stack/recovery.go
@@ -26,7 +26,7 @@ func (Recovery) Name() string {
 var _ Middleware = Recovery{}
 
 // CheckTx catches any panic and converts to error - fulfills Middlware interface
-func (Recovery) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) {
+func (Recovery) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			err = normalizePanic(r)
@@ -36,7 +36,7 @@ func (Recovery) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.
 }
 
 // DeliverTx catches any panic and converts to error - fulfills Middlware interface
-func (Recovery) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) {
+func (Recovery) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			err = normalizePanic(r)