diff --git a/types/account.go b/types/account.go
deleted file mode 100644
index 28f8d7b08f..0000000000
--- a/types/account.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package main
-
-import "fmt"
-
-func main() {
-	fmt.Println("vim-go")
-}
-
-type Account interface {
-	Get(key interface{}) (value interface{})
-	Address() []byte
-	PubKey() crypto.PubKey
-
-	// Serialize the Account to bytes.
-	Bytes() []byte
-}
-
-type AccountStore interface {
-	GetAccount(addr []byte) Account
-	SetAccount(acc Account)
-}
diff --git a/types/coins.go b/types/coins.go
deleted file mode 100644
index e34f7d1bdb..0000000000
--- a/types/coins.go
+++ /dev/null
@@ -1,197 +0,0 @@
-package types
-
-import (
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-type Coin struct {
-	Denom  string `json:"denom"`
-	Amount int64  `json:"amount"`
-}
-
-func (coin Coin) String() string {
-	return fmt.Sprintf("%v%v", coin.Amount, coin.Denom)
-}
-
-//regex codes for extracting coins from string
-var reDenom = regexp.MustCompile("([^\\d\\W]+)")
-var reAmt = regexp.MustCompile("(\\d+)")
-
-func ParseCoin(str string) (Coin, error) {
-
-	var coin Coin
-
-	if len(str) > 0 {
-		amt, err := strconv.Atoi(reAmt.FindString(str))
-		if err != nil {
-			return coin, err
-		}
-		denom := reDenom.FindString(str)
-		coin = Coin{denom, int64(amt)}
-	}
-
-	return coin, nil
-}
-
-//----------------------------------------
-
-type Coins []Coin
-
-func (coins Coins) String() string {
-	if len(coins) == 0 {
-		return ""
-	}
-
-	out := ""
-	for _, coin := range coins {
-		out += fmt.Sprintf("%v,", coin.String())
-	}
-	return out[:len(out)-1]
-}
-
-func ParseCoins(str string) (Coins, error) {
-
-	split := strings.Split(str, ",")
-	var coins []Coin
-
-	for _, el := range split {
-		if len(el) > 0 {
-			coin, err := ParseCoin(el)
-			if err != nil {
-				return coins, err
-			}
-			coins = append(coins, coin)
-		}
-	}
-
-	return coins, nil
-}
-
-// Must be sorted, and not have 0 amounts
-func (coins Coins) IsValid() bool {
-	switch len(coins) {
-	case 0:
-		return true
-	case 1:
-		return coins[0].Amount != 0
-	default:
-		lowDenom := coins[0].Denom
-		for _, coin := range coins[1:] {
-			if coin.Denom <= lowDenom {
-				return false
-			}
-			if coin.Amount == 0 {
-				return false
-			}
-			// we compare each coin against the last denom
-			lowDenom = coin.Denom
-		}
-		return true
-	}
-}
-
-// TODO: handle empty coins!
-// Currently appends an empty coin ...
-func (coinsA Coins) Plus(coinsB Coins) Coins {
-	sum := []Coin{}
-	indexA, indexB := 0, 0
-	lenA, lenB := len(coinsA), len(coinsB)
-	for {
-		if indexA == lenA {
-			if indexB == lenB {
-				return sum
-			} else {
-				return append(sum, coinsB[indexB:]...)
-			}
-		} else if indexB == lenB {
-			return append(sum, coinsA[indexA:]...)
-		}
-		coinA, coinB := coinsA[indexA], coinsB[indexB]
-		switch strings.Compare(coinA.Denom, coinB.Denom) {
-		case -1:
-			sum = append(sum, coinA)
-			indexA += 1
-		case 0:
-			if coinA.Amount+coinB.Amount == 0 {
-				// ignore 0 sum coin type
-			} else {
-				sum = append(sum, Coin{
-					Denom:  coinA.Denom,
-					Amount: coinA.Amount + coinB.Amount,
-				})
-			}
-			indexA += 1
-			indexB += 1
-		case 1:
-			sum = append(sum, coinB)
-			indexB += 1
-		}
-	}
-	return sum
-}
-
-func (coins Coins) Negative() Coins {
-	res := make([]Coin, 0, len(coins))
-	for _, coin := range coins {
-		res = append(res, Coin{
-			Denom:  coin.Denom,
-			Amount: -coin.Amount,
-		})
-	}
-	return res
-}
-
-func (coinsA Coins) Minus(coinsB Coins) Coins {
-	return coinsA.Plus(coinsB.Negative())
-}
-
-func (coinsA Coins) IsGTE(coinsB Coins) bool {
-	diff := coinsA.Minus(coinsB)
-	if len(diff) == 0 {
-		return true
-	}
-	return diff.IsNonnegative()
-}
-
-func (coins Coins) IsZero() bool {
-	return len(coins) == 0
-}
-
-func (coinsA Coins) IsEqual(coinsB Coins) bool {
-	if len(coinsA) != len(coinsB) {
-		return false
-	}
-	for i := 0; i < len(coinsA); i++ {
-		if coinsA[i] != coinsB[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (coins Coins) IsPositive() bool {
-	if len(coins) == 0 {
-		return false
-	}
-	for _, coinAmount := range coins {
-		if coinAmount.Amount <= 0 {
-			return false
-		}
-	}
-	return true
-}
-
-func (coins Coins) IsNonnegative() bool {
-	if len(coins) == 0 {
-		return true
-	}
-	for _, coinAmount := range coins {
-		if coinAmount.Amount < 0 {
-			return false
-		}
-	}
-	return true
-}
diff --git a/types/coins_test.go b/types/coins_test.go
deleted file mode 100644
index 8cbc708a49..0000000000
--- a/types/coins_test.go
+++ /dev/null
@@ -1,85 +0,0 @@
-package types
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestCoins(t *testing.T) {
-	assert := assert.New(t)
-
-	//Define the coins to be used in tests
-	good := Coins{
-		Coin{"GAS", 1},
-		Coin{"MINERAL", 1},
-		Coin{"TREE", 1},
-	}
-	neg := good.Negative()
-	sum := good.Plus(neg)
-	empty := Coins{
-		Coin{"GOLD", 0},
-	}
-	badSort1 := Coins{
-		Coin{"TREE", 1},
-		Coin{"GAS", 1},
-		Coin{"MINERAL", 1},
-	}
-	badSort2 := Coins{ // both are after the first one, but the second and third are in the wrong order
-		Coin{"GAS", 1},
-		Coin{"TREE", 1},
-		Coin{"MINERAL", 1},
-	}
-	badAmt := Coins{
-		Coin{"GAS", 1},
-		Coin{"TREE", 0},
-		Coin{"MINERAL", 1},
-	}
-	dup := Coins{
-		Coin{"GAS", 1},
-		Coin{"GAS", 1},
-		Coin{"MINERAL", 1},
-	}
-
-	assert.True(good.IsValid(), "Coins are valid")
-	assert.True(good.IsPositive(), "Expected coins to be positive: %v", good)
-	assert.True(good.IsGTE(empty), "Expected %v to be >= %v", good, empty)
-	assert.False(neg.IsPositive(), "Expected neg coins to not be positive: %v", neg)
-	assert.Zero(len(sum), "Expected 0 coins")
-	assert.False(badSort1.IsValid(), "Coins are not sorted")
-	assert.False(badSort2.IsValid(), "Coins are not sorted")
-	assert.False(badAmt.IsValid(), "Coins cannot include 0 amounts")
-	assert.False(dup.IsValid(), "Duplicate coin")
-
-}
-
-//Test the parse coin and parse coins functionality
-func TestParse(t *testing.T) {
-	assert, require := assert.New(t), require.New(t)
-
-	makeCoin := func(str string) Coin {
-		coin, err := ParseCoin(str)
-		require.Nil(err)
-		return coin
-	}
-
-	makeCoins := func(str string) Coins {
-		coin, err := ParseCoins(str)
-		require.Nil(err)
-		return coin
-	}
-
-	//testing ParseCoin Function
-	assert.Equal(Coin{}, makeCoin(""), "ParseCoin makes bad empty coin")
-	assert.Equal(Coin{"fooCoin", 1}, makeCoin("1fooCoin"), "ParseCoin makes bad coins")
-	assert.Equal(Coin{"barCoin", 10}, makeCoin("10 barCoin"), "ParseCoin makes bad coins")
-
-	//testing ParseCoins Function
-	assert.True(Coins{{"fooCoin", 1}}.IsEqual(makeCoins("1fooCoin")),
-		"ParseCoins doesn't parse a single coin")
-	assert.True(Coins{{"barCoin", 99}, {"fooCoin", 1}}.IsEqual(makeCoins("99barCoin,1fooCoin")),
-		"ParseCoins doesn't properly parse two coins")
-	assert.True(Coins{{"barCoin", 99}, {"fooCoin", 1}}.IsEqual(makeCoins("99 barCoin, 1 fooCoin")),
-		"ParseCoins doesn't properly parse two coins which use spaces")
-}
diff --git a/types/context.go b/types/context.go
new file mode 100644
index 0000000000..b12b81e63f
--- /dev/null
+++ b/types/context.go
@@ -0,0 +1,73 @@
+package types
+
+import (
+	"context"
+	tm "github.com/tendermint/tendermint/types"
+)
+
+/*
+
+NOTE: Golang's Context is embedded and relied on
+for compatibility w/ tools like monkit.
+(https://github.com/spacemonkeygo/monkit)
+
+Usage:
+
+defer mon.Task()(&ctx.Context)(&err)
+
+*/
+type SDKContext struct {
+	context.Context
+	// NOTE: adding fields here will break monkit compatibility
+	// use context.Context instead if possible.
+}
+
+func NewSDKContext(header tm.Header) SDKContext {
+	c := SDKContext{
+		Context: context.Background(),
+	}
+	c = c.setBlockHeader(header)
+	c = c.setBlockHeight(int64(header.Height))
+	c = c.setChainID(header.ChainID)
+	return c
+}
+
+func (c SDKContext) WithValueSDK(key interface{}, value interface{}) SDKContext {
+	return SDKContext{
+		Context: context.WithValue(c.Context, key, value),
+	}
+}
+
+func (c SDKContext) WithValue(key interface{}, value interface{}) Context {
+	return c
+}
+
+//----------------------------------------
+// Our extensions
+
+type contextKey int // local to the context module
+
+const (
+	contextKeyBlockHeader contextKey = iota
+	contextKeyBlockHeight
+	contextKeyChainID
+)
+
+func (c SDKContext) BlockHeader() tm.Header {
+	return c.Value(contextKeyBlockHeader).(tm.Header)
+}
+
+// Unexposed to prevent overriding.
+func (c SDKContext) setBlockHeader(header tm.Header) SDKContext {
+	return c.WithValueSDK(contextKeyBlockHeader, header)
+}
+
+// Unexposed to prevent overriding.
+func (c SDKContext) setBlockHeight(height int64) SDKContext {
+	return c.WithValueSDK(contextKeyBlockHeight, header)
+}
+
+// Unexposed to prevent overriding.
+func (c SDKContext) setChainID(chainID string) SDKContext {
+	return c.WithValueSDK(contextKeyChainID, header)
+}
diff --git a/types/msg.go b/types/msg.go
index e7738bd73d..d2fc6d1550 100644
--- a/types/msg.go
+++ b/types/msg.go
@@ -1,6 +1,6 @@
 package types
 
-import "github.com/tendermint/tmlibs/crypto"
+import crypto "github.com/tendermint/go-crypto"
 
 // The parsed tx bytes is called a Msg.
 type Msg interface {
diff --git a/util/chain.go b/util/chain.go
deleted file mode 100644
index e0681a903b..0000000000
--- a/util/chain.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package util
-
-import (
-	"regexp"
-
-	sdk "github.com/cosmos/cosmos-sdk"
-)
-
-var (
-	// ChainPattern must match any valid chain_id
-	ChainPattern = regexp.MustCompile("^[A-Za-z0-9_-]+$")
-)
-
-// ChainedTx interface should be implemented by any
-// message to bind it to one chain, with an optional
-// expiration height
-type ChainedTx interface {
-	GetChain() ChainData
-}
-
-// ChainData is info from the message to bind it to
-// chain and time
-type ChainData struct {
-	ChainID   string `json:"chain_id"`
-	ExpiresAt uint64 `json:"expires_at"`
-}
-
-// Chain enforces that this tx was bound to the named chain
-type Chain struct{}
-
-var _ sdk.Decorator = Chain{}
-
-// CheckTx makes sure we are on the proper chain
-// - fulfills Decorator interface
-func (c Chain) CheckTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}, next sdk.Checker) (res sdk.CheckResult, err error) {
-
-	err = c.checkChainTx(ctx.ChainID(), ctx.BlockHeight(), tx)
-	if err != nil {
-		return res, err
-	}
-	return next.CheckTx(ctx, store, tx)
-}
-
-// DeliverTx makes sure we are on the proper chain
-// - fulfills Decorator interface
-func (c Chain) DeliverTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}, next sdk.Deliverer) (res sdk.DeliverResult, err error) {
-
-	err = c.checkChainTx(ctx.ChainID(), ctx.BlockHeight(), tx)
-	if err != nil {
-		return res, err
-	}
-	return next.DeliverTx(ctx, store, tx)
-}
-
-// checkChainTx makes sure the tx is a ChainedTx,
-// it is on the proper chain, and it has not expired.
-func (c Chain) checkChainTx(chainID string, height uint64, tx interface{}) error {
-	// make sure it is a chaintx
-	ctx, ok := tx.(ChainedTx)
-	if !ok {
-		return ErrNoChain()
-	}
-
-	data := ctx.GetChain()
-
-	// compare against state
-	if data.ChainID != chainID {
-		return ErrWrongChain(data.ChainID)
-	}
-	if data.ExpiresAt != 0 && data.ExpiresAt <= height {
-		return ErrExpired()
-	}
-	return nil
-}
diff --git a/util/chain_test.go b/util/chain_test.go
deleted file mode 100644
index 8ec96fb860..0000000000
--- a/util/chain_test.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package util
-
-import (
-	"strconv"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	sdk "github.com/cosmos/cosmos-sdk"
-	"github.com/cosmos/cosmos-sdk/state"
-)
-
-func NewChainTx(name string, height uint64, data []byte) ChainedTx {
-	return chainTx{
-		ChainData: ChainData{name, height},
-		Data:      data,
-	}
-}
-
-type chainTx struct {
-	ChainData
-	Data []byte
-}
-
-func (c chainTx) GetChain() ChainData {
-	return c.ChainData
-}
-
-func (c chainTx) GetTx() interface{} {
-	return RawTx{c.Data}
-}
-
-func TestChain(t *testing.T) {
-	assert := assert.New(t)
-	msg := "got it"
-	chainID := "my-chain"
-	height := uint64(100)
-
-	raw := []byte{1, 2, 3, 4}
-	cases := []struct {
-		tx       interface{}
-		valid    bool
-		errorMsg string
-	}{
-		// check the chain ids are validated
-		{NewChainTx(chainID, 0, raw), true, ""},
-		// non-matching chainid, or impossible chain id
-		{NewChainTx("someone-else", 0, raw), false, "someone-else: Wrong chain"},
-		{NewChainTx("Inval$$d:CH%%n", 0, raw), false, "Wrong chain"},
-		// Wrong tx type
-		{raw, false, "No chain id provided"},
-		// Check different heights - must be 0 or higher than current height
-		{NewChainTx(chainID, height+1, raw), true, ""},
-		{NewChainTx(chainID, height, raw), false, "Tx expired"},
-		{NewChainTx(chainID, 1, raw), false, "expired"},
-		{NewChainTx(chainID, 0, raw), true, ""},
-	}
-
-	// generic args here...
-	ctx := MockContext(chainID, height)
-	store := state.NewMemKVStore()
-
-	// build the stack
-	ok := OKHandler{Log: msg}
-	app := sdk.ChainDecorators(Chain{}).WithHandler(ok)
-
-	for idx, tc := range cases {
-		i := strconv.Itoa(idx)
-
-		// make sure check returns error, not a panic crash
-		cres, err := app.CheckTx(ctx, store, tc.tx)
-		if tc.valid {
-			assert.Nil(err, "%d: %+v", idx, err)
-			assert.Equal(msg, cres.Log, i)
-		} else {
-			if assert.NotNil(err, i) {
-				assert.Contains(err.Error(), tc.errorMsg, i)
-			}
-		}
-
-		// make sure deliver returns error, not a panic crash
-		dres, err := app.DeliverTx(ctx, store, tc.tx)
-		if tc.valid {
-			assert.Nil(err, "%d: %+v", idx, err)
-			assert.Equal(msg, dres.Log, i)
-		} else {
-			if assert.NotNil(err, i) {
-				assert.Contains(err.Error(), tc.errorMsg, i)
-			}
-		}
-	}
-}
diff --git a/util/commands/wrap.go b/util/commands/wrap.go
deleted file mode 100644
index b9be03779f..0000000000
--- a/util/commands/wrap.go
+++ /dev/null
@@ -1,39 +0,0 @@
-package commands
-
-import (
-	"errors"
-
-	"github.com/spf13/pflag"
-	"github.com/spf13/viper"
-
-	sdk "github.com/cosmos/cosmos-sdk"
-	"github.com/cosmos/cosmos-sdk/client/commands"
-	txcmd "github.com/cosmos/cosmos-sdk/client/commands/txs"
-	"github.com/cosmos/cosmos-sdk/modules/base"
-)
-
-//nolint
-const (
-	FlagExpires = "expires"
-)
-
-// ChainWrapper wraps a tx with an chain info and optional expiration
-type ChainWrapper struct{}
-
-var _ txcmd.Wrapper = ChainWrapper{}
-
-// Wrap will wrap the tx with a ChainTx from the standard flags
-func (ChainWrapper) Wrap(tx sdk.Tx) (res sdk.Tx, err error) {
-	expires := viper.GetInt64(FlagExpires)
-	chain := commands.GetChainID()
-	if chain == "" {
-		return res, errors.New("No chain-id provided")
-	}
-	res = base.NewChainTx(chain, uint64(expires), tx)
-	return
-}
-
-// Register adds the sequence flags to the cli
-func (ChainWrapper) Register(fs *pflag.FlagSet) {
-	fs.Uint64(FlagExpires, 0, "Block height at which this tx expires")
-}
diff --git a/util/decorators.go b/util/decorators.go
deleted file mode 100644
index e9d9bd94d5..0000000000
--- a/util/decorators.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package util
-
-import (
-	sdk "github.com/cosmos/cosmos-sdk"
-	"github.com/cosmos/cosmos-sdk/errors"
-)
-
-// CheckDecorator returns an error if the tx doesn't have auth of this
-// Required Actor, otherwise passes along the call untouched
-type CheckDecorator struct {
-	Required sdk.Actor
-}
-
-var _ sdk.Decorator = CheckDecorator{}
-
-func (p CheckDecorator) CheckTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}, next sdk.Checker) (res sdk.CheckResult, err error) {
-
-	if !ctx.HasPermission(p.Required) {
-		return res, errors.ErrUnauthorized()
-	}
-	return next.CheckTx(ctx, store, tx)
-}
-
-func (p CheckDecorator) DeliverTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}, next sdk.Deliverer) (res sdk.DeliverResult, err error) {
-
-	if !ctx.HasPermission(p.Required) {
-		return res, errors.ErrUnauthorized()
-	}
-	return next.DeliverTx(ctx, store, tx)
-}
-
-// GrantDecorator tries to set the permission to this Actor, which may be prohibited
-type GrantDecorator struct {
-	Auth sdk.Actor
-}
-
-var _ sdk.Decorator = GrantDecorator{}
-
-func (g GrantDecorator) CheckTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}, next sdk.Checker) (res sdk.CheckResult, err error) {
-
-	ctx = ctx.WithPermissions(g.Auth)
-	return next.CheckTx(ctx, store, tx)
-}
-
-func (g GrantDecorator) DeliverTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}, next sdk.Deliverer) (res sdk.DeliverResult, err error) {
-
-	ctx = ctx.WithPermissions(g.Auth)
-	return next.DeliverTx(ctx, store, tx)
-}
diff --git a/util/doc.go b/util/doc.go
deleted file mode 100644
index 4a5a95bdfe..0000000000
--- a/util/doc.go
+++ /dev/null
@@ -1,5 +0,0 @@
-/**
-Package util contains various utility handlers, decorators,
-and test helpers that can be use by many modules and applications.
-**/
-package util
diff --git a/util/errors.go b/util/errors.go
deleted file mode 100644
index b3ef62a187..0000000000
--- a/util/errors.go
+++ /dev/null
@@ -1,37 +0,0 @@
-//nolint
-package util
-
-import (
-	"fmt"
-
-	abci "github.com/tendermint/abci/types"
-
-	"github.com/cosmos/cosmos-sdk/errors"
-)
-
-var (
-	errNoChain    = fmt.Errorf("No chain id provided") //move base
-	errWrongChain = fmt.Errorf("Wrong chain for tx")   //move base
-	errExpired    = fmt.Errorf("Tx expired")           //move base
-
-	unauthorized = abci.CodeType_Unauthorized
-)
-
-func ErrNoChain() errors.TMError {
-	return errors.WithCode(errNoChain, unauthorized)
-}
-func IsNoChainErr(err error) bool {
-	return errors.IsSameError(errNoChain, err)
-}
-func ErrWrongChain(chain string) errors.TMError {
-	return errors.WithMessage(chain, errWrongChain, unauthorized)
-}
-func IsWrongChainErr(err error) bool {
-	return errors.IsSameError(errWrongChain, err)
-}
-func ErrExpired() errors.TMError {
-	return errors.WithCode(errExpired, unauthorized)
-}
-func IsExpiredErr(err error) bool {
-	return errors.IsSameError(errExpired, err)
-}
diff --git a/util/errors_test.go b/util/errors_test.go
deleted file mode 100644
index 45cfa57cb1..0000000000
--- a/util/errors_test.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package util
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/cosmos/cosmos-sdk/errors"
-)
-
-func TestErrorMatches(t *testing.T) {
-	assert := assert.New(t)
-
-	cases := []struct {
-		pattern, err error
-		match        bool
-	}{
-		{errWrongChain, ErrWrongChain("hakz"), true},
-	}
-
-	for i, tc := range cases {
-		same := errors.IsSameError(tc.pattern, tc.err)
-		assert.Equal(tc.match, same, "%d: %#v / %#v", i, tc.pattern, tc.err)
-	}
-}
-
-func TestChecks(t *testing.T) {
-	// TODO: make sure the Is and Err methods match
-	assert := assert.New(t)
-
-	cases := []struct {
-		err   error
-		check func(error) bool
-		match bool
-	}{
-		// make sure WrongChain works properly
-		{ErrWrongChain("fooz"), errors.IsUnauthorizedErr, true},
-		{ErrWrongChain("barz"), IsWrongChainErr, true},
-	}
-
-	for i, tc := range cases {
-		match := tc.check(tc.err)
-		assert.Equal(tc.match, match, "%d", i)
-	}
-}
diff --git a/util/helpers.go b/util/helpers.go
deleted file mode 100644
index f8faeb376f..0000000000
--- a/util/helpers.go
+++ /dev/null
@@ -1,131 +0,0 @@
-package util
-
-import (
-	"github.com/tendermint/go-wire/data"
-
-	sdk "github.com/cosmos/cosmos-sdk"
-	"github.com/cosmos/cosmos-sdk/errors"
-)
-
-//nolint
-const (
-	// ByteRawTx   = 0xF0
-	// ByteCheckTx = 0xF1
-	// ByteFailTx  = 0xF2
-
-	// TypeRawTx   = NameOK + "/raw" // this will just say a-ok to RawTx
-	// TypeCheckTx = NameCheck + "/tx"
-	// TypeFailTx  = NameFail + "/tx"
-
-	rawMaxSize = 2000 * 1000
-)
-
-func init() {
-	// sdk.TxMapper.
-	// 	RegisterImplementation(RawTx{}, TypeRawTx, ByteRawTx).
-	// 	RegisterImplementation(CheckTx{}, TypeCheckTx, ByteCheckTx).
-	// 	RegisterImplementation(FailTx{}, TypeFailTx, ByteFailTx)
-}
-
-// RawTx just contains bytes that can be hex-ified
-type RawTx struct {
-	Data data.Bytes
-}
-
-// NewRawTx creates a RawTx object
-func NewRawTx(data []byte) RawTx {
-	return RawTx{Data: data}
-}
-
-// ValidateBasic can ensure a limited size of tx
-func (r RawTx) ValidateBasic() error {
-	if len(r.Data) > rawMaxSize {
-		return errors.ErrTooLarge()
-	}
-	return nil
-}
-
-// OKHandler just used to return okay to everything
-type OKHandler struct {
-	Log string
-}
-
-var _ sdk.Handler = OKHandler{}
-
-// CheckTx always returns an empty success tx
-func (ok OKHandler) CheckTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}) (res sdk.CheckResult, err error) {
-	return sdk.CheckResult{Log: ok.Log}, nil
-}
-
-// DeliverTx always returns an empty success tx
-func (ok OKHandler) DeliverTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}) (res sdk.DeliverResult, err error) {
-	return sdk.DeliverResult{Log: ok.Log}, nil
-}
-
-// EchoHandler returns success, echoing res.Data = tx bytes
-type EchoHandler struct{}
-
-var _ sdk.Handler = EchoHandler{}
-
-// CheckTx returns input if RawTx comes in, otherwise panic
-func (EchoHandler) CheckTx(ctx sdk.Context, store sdk.SimpleDB,
-	msg interface{}) (res sdk.CheckResult, err error) {
-	raw := sdk.MustGetTx(msg).(RawTx)
-	return sdk.CheckResult{Data: raw.Data}, nil
-}
-
-// DeliverTx returns input if RawTx comes in, otherwise panic
-func (EchoHandler) DeliverTx(ctx sdk.Context, store sdk.SimpleDB,
-	msg interface{}) (res sdk.DeliverResult, err error) {
-	raw := sdk.MustGetTx(msg).(RawTx)
-	return sdk.DeliverResult{Data: raw.Data}, nil
-}
-
-// FailHandler always returns an error
-type FailHandler struct {
-	Err error
-}
-
-var _ sdk.Handler = FailHandler{}
-
-// CheckTx always returns the given error
-func (f FailHandler) CheckTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}) (res sdk.CheckResult, err error) {
-	return res, errors.Wrap(f.Err)
-}
-
-// DeliverTx always returns the given error
-func (f FailHandler) DeliverTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}) (res sdk.DeliverResult, err error) {
-	return res, errors.Wrap(f.Err)
-}
-
-// PanicHandler always panics, using the given error (first choice) or msg (fallback)
-type PanicHandler struct {
-	Msg string
-	Err error
-}
-
-var _ sdk.Handler = PanicHandler{}
-
-// CheckTx always panics
-func (p PanicHandler) CheckTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}) (res sdk.CheckResult, err error) {
-
-	if p.Err != nil {
-		panic(p.Err)
-	}
-	panic(p.Msg)
-}
-
-// DeliverTx always panics
-func (p PanicHandler) DeliverTx(ctx sdk.Context, store sdk.SimpleDB,
-	tx interface{}) (res sdk.DeliverResult, err error) {
-
-	if p.Err != nil {
-		panic(p.Err)
-	}
-	panic(p.Msg)
-}
diff --git a/util/helpers_test.go b/util/helpers_test.go
deleted file mode 100644
index 9e036483c7..0000000000
--- a/util/helpers_test.go
+++ /dev/null
@@ -1,62 +0,0 @@
-package util
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	sdk "github.com/cosmos/cosmos-sdk"
-	"github.com/cosmos/cosmos-sdk/state"
-)
-
-func TestOK(t *testing.T) {
-	assert := assert.New(t)
-
-	ctx := MockContext("test-chain", 20)
-	store := state.NewMemKVStore()
-	data := "this looks okay"
-	tx := sdk.Tx{}
-
-	ok := OKHandler{Log: data}
-	res, err := ok.CheckTx(ctx, store, tx)
-	assert.Nil(err, "%+v", err)
-	assert.Equal(data, res.Log)
-
-	dres, err := ok.DeliverTx(ctx, store, tx)
-	assert.Nil(err, "%+v", err)
-	assert.Equal(data, dres.Log)
-}
-
-func TestFail(t *testing.T) {
-	assert := assert.New(t)
-
-	ctx := MockContext("test-chain", 20)
-	store := state.NewMemKVStore()
-	msg := "big problem"
-	tx := sdk.Tx{}
-
-	fail := FailHandler{Err: errors.New(msg)}
-	_, err := fail.CheckTx(ctx, store, tx)
-	if assert.NotNil(err) {
-		assert.Equal(msg, err.Error())
-	}
-
-	_, err = fail.DeliverTx(ctx, store, tx)
-	if assert.NotNil(err) {
-		assert.Equal(msg, err.Error())
-	}
-}
-
-func TestPanic(t *testing.T) {
-	assert := assert.New(t)
-
-	ctx := MockContext("test-chain", 20)
-	store := state.NewMemKVStore()
-	msg := "system crash!"
-	tx := sdk.Tx{}
-
-	fail := PanicHandler{Msg: msg}
-	assert.Panics(func() { fail.CheckTx(ctx, store, tx) })
-	assert.Panics(func() { fail.DeliverTx(ctx, store, tx) })
-}
diff --git a/util/mock.go b/util/mock.go
deleted file mode 100644
index b6f7975da5..0000000000
--- a/util/mock.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package util
-
-import (
-	"math/rand"
-
-	"github.com/tendermint/tmlibs/log"
-
-	sdk "github.com/cosmos/cosmos-sdk"
-)
-
-// store nonce as it's own type so no one can even try to fake it
-type nonce int64
-
-type naiveContext struct {
-	id     nonce
-	chain  string
-	height uint64
-	perms  []sdk.Actor
-	log.Logger
-}
-
-// MockContext returns a simple, non-checking context for test cases.
-//
-// Always use NewContext() for production code to sandbox malicious code better
-func MockContext(chain string, height uint64) sdk.Context {
-	return naiveContext{
-		id:     nonce(rand.Int63()),
-		chain:  chain,
-		height: height,
-		Logger: log.NewNopLogger(),
-	}
-}
-
-var _ sdk.Context = naiveContext{}
-
-func (c naiveContext) ChainID() string {
-	return c.chain
-}
-
-func (c naiveContext) BlockHeight() uint64 {
-	return c.height
-}
-
-// WithPermissions will panic if they try to set permission without the proper app
-func (c naiveContext) WithPermissions(perms ...sdk.Actor) sdk.Context {
-	return naiveContext{
-		id:     c.id,
-		chain:  c.chain,
-		height: c.height,
-		perms:  append(c.perms, perms...),
-		Logger: c.Logger,
-	}
-}
-
-func (c naiveContext) HasPermission(perm sdk.Actor) bool {
-	for _, p := range c.perms {
-		if p.Equals(perm) {
-			return true
-		}
-	}
-	return false
-}
-
-func (c naiveContext) GetPermissions(chain, app string) (res []sdk.Actor) {
-	for _, p := range c.perms {
-		if chain == p.ChainID {
-			if app == "" || app == p.App {
-				res = append(res, p)
-			}
-		}
-	}
-	return res
-}
-
-// IsParent ensures that this is derived from the given secureClient
-func (c naiveContext) IsParent(other sdk.Context) bool {
-	nc, ok := other.(naiveContext)
-	if !ok {
-		return false
-	}
-	return c.id == nc.id
-}
-
-// Reset should clear out all permissions,
-// but carry on knowledge that this is a child
-func (c naiveContext) Reset() sdk.Context {
-	return naiveContext{
-		id:     c.id,
-		chain:  c.chain,
-		height: c.height,
-		Logger: c.Logger,
-	}
-}
diff --git a/util/prefix.go b/util/prefix.go
deleted file mode 100644
index d81e551225..0000000000
--- a/util/prefix.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package util
-
-// PrefixedKey returns the absolute path to a given key in a particular
-// app's state-space
-//
-// This is useful for to set up queries for this particular app data
-func PrefixedKey(app string, key []byte) []byte {
-	prefix := append([]byte(app), byte(0))
-	return append(prefix, key...)
-}
diff --git a/util/logger.go b/x/logger/logger.go
similarity index 100%
rename from util/logger.go
rename to x/logger/logger.go
diff --git a/util/recovery.go b/x/recover/recovery.go
similarity index 100%
rename from util/recovery.go
rename to x/recover/recovery.go
diff --git a/util/recovery_test.go b/x/recover/recovery_test.go
similarity index 100%
rename from util/recovery_test.go
rename to x/recover/recovery_test.go