Merge remote-tracking branch 'origin/develop' into rigel/fee-distribution

2018-09-17 17:53:42 -04:00 · 2018-09-17 17:53:42 -04:00 · 2eff69a575
commit 2eff69a575
parent d60f620787 b09e8599d9
193 changed files with 2661 additions and 1760 deletions
--- a/Gopkg.lock
+++ b/Gopkg.lock
@ -34,7 +34,7 @@

 [[projects]]
  branch = "master"
-  digest = "1:6aabc1566d6351115d561d038da82a4c19b46c3b6e17f4a0a2fa60260663dc79"
+  digest = "1:2c00f064ba355903866cbfbf3f7f4c0fe64af6638cc7d1b8bdcf3181bc67f1d8"
  name = "github.com/btcsuite/btcd"
  packages = ["btcec"]
  pruneopts = "UT"
@ -71,7 +71,7 @@
  version = "v1.4.7"

 [[projects]]
-  digest = "1:fa30c0652956e159cdb97dcb2ef8b8db63ed668c02a5c3a40961c8f0641252fe"
+  digest = "1:fdf5169073fb0ad6dc12a70c249145e30f4058647bea25f0abd48b6d9f228a11"
  name = "github.com/go-kit/kit"
  packages = [
    "log",
@ -103,7 +103,7 @@
  version = "v1.7.0"

 [[projects]]
-  digest = "1:212285efb97b9ec2e20550d81f0446cb7897e57cbdfd7301b1363ab113d8be45"
+  digest = "1:35621fe20f140f05a0c4ef662c26c0ab4ee50bca78aa30fe87d33120bd28165e"
  name = "github.com/gogo/protobuf"
  packages = [
    "gogoproto",
@ -118,7 +118,7 @@
  version = "v1.1.1"

 [[projects]]
-  digest = "1:cb22af0ed7c72d495d8be1106233ee553898950f15fd3f5404406d44c2e86888"
+  digest = "1:17fe264ee908afc795734e8c4e63db2accabaf57326dbf21763a7d6b86096260"
  name = "github.com/golang/protobuf"
  packages = [
    "proto",
@ -165,7 +165,7 @@

 [[projects]]
  branch = "master"
-  digest = "1:8951fe6e358876736d8fa1f3992624fdbb2dec6bc49401c1381d1ef8abbb544f"
+  digest = "1:12247a2e99a060cc692f6680e5272c8adf0b8f572e6bce0d7095e624c958a240"
  name = "github.com/hashicorp/hcl"
  packages = [
    ".",
@ -262,7 +262,7 @@
  version = "v1.0.0"

 [[projects]]
-  digest = "1:98225904b7abff96c052b669b25788f18225a36673fba022fb93514bb9a2a64e"
+  digest = "1:c1a04665f9613e082e1209cf288bf64f4068dcd6c87a64bf1c4ff006ad422ba0"
  name = "github.com/prometheus/client_golang"
  packages = [
    "prometheus",
@ -273,7 +273,7 @@

 [[projects]]
  branch = "master"
-  digest = "1:0f37e09b3e92aaeda5991581311f8dbf38944b36a3edec61cc2d1991f527554a"
+  digest = "1:2d5cd61daa5565187e1d96bae64dbbc6080dacf741448e9629c64fd93203b0d4"
  name = "github.com/prometheus/client_model"
  packages = ["go"]
  pruneopts = "UT"
@ -281,7 +281,7 @@

 [[projects]]
  branch = "master"
-  digest = "1:dad2e5a2153ee7a6c9ab8fc13673a16ee4fb64434a7da980965a3741b0c981a3"
+  digest = "1:63b68062b8968092eb86bedc4e68894bd096ea6b24920faca8b9dcf451f54bb5"
  name = "github.com/prometheus/common"
  packages = [
    "expfmt",
@ -293,7 +293,7 @@

 [[projects]]
  branch = "master"
-  digest = "1:a37c98f4b7a66bb5c539c0539f0915a74ef1c8e0b3b6f45735289d94cae92bfd"
+  digest = "1:8c49953a1414305f2ff5465147ee576dd705487c35b15918fcd4efdc0cb7a290"
  name = "github.com/prometheus/procfs"
  packages = [
    ".",
@ -312,7 +312,7 @@
  revision = "e2704e165165ec55d062f5919b4b29494e9fa790"

 [[projects]]
-  digest = "1:37ace7f35375adec11634126944bdc45a673415e2fcc07382d03b75ec76ea94c"
+  digest = "1:bd1ae00087d17c5a748660b8e89e1043e1e5479d0fea743352cda2f8dd8c4f84"
  name = "github.com/spf13/afero"
  packages = [
    ".",
@ -331,7 +331,7 @@
  version = "v1.2.0"

 [[projects]]
-  digest = "1:627ab2f549a6a55c44f46fa24a4307f4d0da81bfc7934ed0473bf38b24051d26"
+  digest = "1:7ffc0983035bc7e297da3688d9fe19d60a420e9c38bef23f845c53788ed6a05e"
  name = "github.com/spf13/cobra"
  packages = ["."]
  pruneopts = "UT"
@ -363,7 +363,7 @@
  version = "v1.0.0"

 [[projects]]
-  digest = "1:73697231b93fb74a73ebd8384b68b9a60c57ea6b13c56d2425414566a72c8e6d"
+  digest = "1:7e8d267900c7fa7f35129a2a37596e38ed0f11ca746d6d9ba727980ee138f9f6"
  name = "github.com/stretchr/testify"
  packages = [
    "assert",
@ -375,7 +375,7 @@

 [[projects]]
  branch = "master"
-  digest = "1:442d2ffa75ffae302ce8800bf4144696b92bef02917923ea132ce2d39efe7d65"
+  digest = "1:f2ffd421680b0a3f7887501b3c6974bcf19217ecd301d0e2c9b681940ec363d5"
  name = "github.com/syndtr/goleveldb"
  packages = [
    "leveldb",
@ -396,7 +396,7 @@

 [[projects]]
  branch = "master"
-  digest = "1:203b409c21115233a576f99e8f13d8e07ad82b25500491f7e1cca12588fb3232"
+  digest = "1:087aaa7920e5d0bf79586feb57ce01c35c830396ab4392798112e8aae8c47722"
  name = "github.com/tendermint/ed25519"
  packages = [
    ".",
@ -423,7 +423,7 @@
  version = "v0.11.0"

 [[projects]]
-  digest = "1:963f6c04345ce36f900c1d6367200eebc3cc2db6ee632ff865ea8dcf64b748a0"
+  digest = "1:4f15e95fe3888cc75dd34f407d6394cbc7fd3ff24920851b92b295f6a8b556e6"
  name = "github.com/tendermint/tendermint"
  packages = [
    "abci/client",
@ -490,7 +490,7 @@
  version = "v0.23.1-rc0"

 [[projects]]
-  digest = "1:ad879bb8c71020a3f92f0c61f414d93eae1d5dc2f37023b6abaa3cc84b00165e"
+  digest = "1:bf6d9a827ea3cad964c2f863302e4f6823170d0b5ed16f72cf1184a7c615067e"
  name = "github.com/tendermint/tmlibs"
  packages = ["cli"]
  pruneopts = "UT"
@ -507,7 +507,7 @@

 [[projects]]
  branch = "master"
-  digest = "1:2a3ce1f08dcae8bac666deb6e4c88b5d7170c510da38fd746231144cac351704"
+  digest = "1:27507554c6d4f060d8d700c31c624a43d3a92baa634e178ddc044bdf7d13b44a"
  name = "golang.org/x/crypto"
  packages = [
    "blowfish",
@ -529,7 +529,7 @@
  revision = "614d502a4dac94afa3a6ce146bd1736da82514c6"

 [[projects]]
-  digest = "1:04dda8391c3e2397daf254ac68003f30141c069b228d06baec8324a5f81dc1e9"
+  digest = "1:d36f55a999540d29b6ea3c2ea29d71c76b1d9853fdcd3e5c5cb4836f2ba118f1"
  name = "golang.org/x/net"
  packages = [
    "context",
@ -546,7 +546,7 @@

 [[projects]]
  branch = "master"
-  digest = "1:9d9e5fc87553258c36ee18d38023587edd61e4b2521f4473da34b47a83a492e5"
+  digest = "1:ead82e3e398388679f3ad77633a087ac31a47a6be59ae20841e1d1b3a3fbbd22"
  name = "golang.org/x/sys"
  packages = [
    "cpu",
@ -556,7 +556,7 @@
  revision = "4ea2f632f6e912459fe60b26b1749377f0d889d5"

 [[projects]]
-  digest = "1:7509ba4347d1f8de6ae9be8818b0cd1abc3deeffe28aeaf4be6d4b6b5178d9ca"
+  digest = "1:a2ab62866c75542dd18d2b069fec854577a20211d7c0ea6ae746072a1dccdd18"
  name = "golang.org/x/text"
  packages = [
    "collate",
@ -587,7 +587,7 @@
  revision = "c66870c02cf823ceb633bcd05be3c7cda29976f4"

 [[projects]]
-  digest = "1:4515e3030c440845b046354fd5d57671238428b820deebce2e9dabb5cd3c51ac"
+  digest = "1:2dab32a43451e320e49608ff4542fdfc653c95dcc35d0065ec9c6c3dd540ed74"
  name = "google.golang.org/grpc"
  packages = [
    ".",
@ -665,6 +665,7 @@
    "github.com/tendermint/tendermint/libs/db",
    "github.com/tendermint/tendermint/libs/log",
    "github.com/tendermint/tendermint/lite",
+    "github.com/tendermint/tendermint/lite/errors",
    "github.com/tendermint/tendermint/lite/proxy",
    "github.com/tendermint/tendermint/node",
    "github.com/tendermint/tendermint/p2p",
--- a/4
+++ b/4
@ -160,8 +160,8 @@ test_sim_gaia_fast:
 	@go test ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationEnabled=true -SimulationNumBlocks=400 -SimulationBlockSize=200 -SimulationCommit=true -v -timeout 24h

 test_sim_gaia_slow:
-	@echo "Running full Gaia simulation. This may take awhile!"
-	@go test ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationEnabled=true -SimulationNumBlocks=1000 -SimulationVerbose=true -SimulationCommit=true -v -timeout 24h 
+	@echo "Running full Gaia simulation. This may take a while!"
+	@go test ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationEnabled=true -SimulationNumBlocks=1000 -SimulationVerbose=true -SimulationCommit=true -v -timeout 24h

 SIM_NUM_BLOCKS ?= 210
 SIM_BLOCK_SIZE ?= 200
--- a/PENDING.md
+++ b/PENDING.md
@ -45,6 +45,8 @@ BREAKING CHANGES
    * [tools] Removed gocyclo [#2211](https://github.com/cosmos/cosmos-sdk/issues/2211)
    * [baseapp] Remove `SetTxDecoder` in favor of requiring the decoder be set in baseapp initialization. [#1441](https://github.com/cosmos/cosmos-sdk/issues/1441)
    * [store] Change storeInfo within the root multistore to use tmhash instead of ripemd160 \#2308
+    * [codec] \#2324 All referrences to wire have been renamed to codec. Additionally, wire.NewCodec is now codec.New().
+    * [types] \#2343 Make sdk.Msg have a names field, to facilitate automatic tagging.

 * Tendermint

@ -100,7 +102,7 @@ IMPROVEMENTS
    * [x/stake] Improve speed of GetValidator, which was shown to be a performance bottleneck. [#2046](https://github.com/tendermint/tendermint/pull/2200)
    * [genesis] \#2229 Ensure that there are no duplicate accounts or validators in the genesis state.
    * Add SDK validation to `config.toml` (namely disabling `create_empty_blocks`) \#1571
-    
+
 * SDK
    * [tools] Make get_vendor_deps deletes `.vendor-new` directories, in case scratch files are present.
    * [spec] Added simple piggy bank distribution spec
@ -112,6 +114,7 @@ IMPROVEMENTS
    * [simulation] Add a concept of weighting the operations \#2303
    * [simulation] Logs get written to file if large, and also get printed on panics \#2285
    * [gaiad] \#1992 Add optional flag to `gaiad testnet` to make config directory of daemon (default `gaiad`) and cli (default `gaiacli`) configurable
+    * [x/stake] Add stake `Queriers` for Gaia-lite endpoints. This increases the staking endpoints performance by reusing the staking `keeper` logic for queries. [#2249](https://github.com/cosmos/cosmos-sdk/pull/2149)

 * Tendermint

--- a/baseapp/baseapp.go
+++ b/baseapp/baseapp.go
@ -14,10 +14,10 @@ import (
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/store"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/version"
-	"github.com/cosmos/cosmos-sdk/wire"
 )

 // Key to store the header in the DB itself.
@ -331,7 +331,7 @@ func handleQueryApp(app *BaseApp, path []string, req abci.RequestQuery) (res abc
 		}

 		// Encode with json
-		value := wire.Cdc.MustMarshalBinary(result)
+		value := codec.Cdc.MustMarshalBinary(result)
 		return abci.ResponseQuery{
 			Code:  uint32(sdk.ABCICodeOK),
 			Value: value,
--- a/baseapp/baseapp_test.go
+++ b/baseapp/baseapp_test.go
@ -14,8 +14,8 @@ import (
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"

+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 )

 var (
@ -34,14 +34,14 @@ func defaultLogger() log.Logger {
 func newBaseApp(name string, options ...func(*BaseApp)) *BaseApp {
 	logger := defaultLogger()
 	db := dbm.NewMemDB()
-	codec := wire.NewCodec()
+	codec := codec.New()
 	registerTestCodec(codec)
 	return NewBaseApp(name, logger, db, testTxDecoder(codec), options...)
 }

-func registerTestCodec(cdc *wire.Codec) {
+func registerTestCodec(cdc *codec.Codec) {
 	// register Tx, Msg
-	sdk.RegisterWire(cdc)
+	sdk.RegisterCodec(cdc)

 	// register test types
 	cdc.RegisterConcrete(&txTest{}, "cosmos-sdk/baseapp/txTest", nil)
@ -302,6 +302,7 @@ type msgCounter struct {

 // Implements Msg
 func (msg msgCounter) Type() string                 { return typeMsgCounter }
+func (msg msgCounter) Name() string                 { return "counter1" }
 func (msg msgCounter) GetSignBytes() []byte         { return nil }
 func (msg msgCounter) GetSigners() []sdk.AccAddress { return nil }
 func (msg msgCounter) ValidateBasic() sdk.Error {
@ -340,6 +341,7 @@ type msgCounter2 struct {

 // Implements Msg
 func (msg msgCounter2) Type() string                 { return typeMsgCounter2 }
+func (msg msgCounter2) Name() string                 { return "counter2" }
 func (msg msgCounter2) GetSignBytes() []byte         { return nil }
 func (msg msgCounter2) GetSigners() []sdk.AccAddress { return nil }
 func (msg msgCounter2) ValidateBasic() sdk.Error {
@ -350,7 +352,7 @@ func (msg msgCounter2) ValidateBasic() sdk.Error {
 }

 // amino decode
-func testTxDecoder(cdc *wire.Codec) sdk.TxDecoder {
+func testTxDecoder(cdc *codec.Codec) sdk.TxDecoder {
 	return func(txBytes []byte) (sdk.Tx, sdk.Error) {
 		var tx txTest
 		if len(txBytes) == 0 {
@ -448,7 +450,7 @@ func TestCheckTx(t *testing.T) {
 	app.InitChain(abci.RequestInitChain{})

 	// Create same codec used in txDecoder
-	codec := wire.NewCodec()
+	codec := codec.New()
 	registerTestCodec(codec)

 	for i := int64(0); i < nTxs; i++ {
@ -489,7 +491,7 @@ func TestDeliverTx(t *testing.T) {
 	app := setupBaseApp(t, anteOpt, routerOpt)

 	// Create same codec used in txDecoder
-	codec := wire.NewCodec()
+	codec := codec.New()
 	registerTestCodec(codec)

 	nBlocks := 3
@ -532,7 +534,7 @@ func TestMultiMsgDeliverTx(t *testing.T) {
 	app := setupBaseApp(t, anteOpt, routerOpt)

 	// Create same codec used in txDecoder
-	codec := wire.NewCodec()
+	codec := codec.New()
 	registerTestCodec(codec)

 	// run a multi-msg tx
@ -613,8 +615,8 @@ func TestSimulateTx(t *testing.T) {
 	app.InitChain(abci.RequestInitChain{})

 	// Create same codec used in txDecoder
-	codec := wire.NewCodec()
-	registerTestCodec(codec)
+	cdc := codec.New()
+	registerTestCodec(cdc)

 	nBlocks := 3
 	for blockN := 0; blockN < nBlocks; blockN++ {
@ -634,7 +636,7 @@ func TestSimulateTx(t *testing.T) {
 		require.Equal(t, gasConsumed, result.GasUsed)

 		// simulate by calling Query with encoded tx
-		txBytes, err := codec.MarshalBinary(tx)
+		txBytes, err := cdc.MarshalBinary(tx)
 		require.Nil(t, err)
 		query := abci.RequestQuery{
 			Path: "/app/simulate",
@ -644,7 +646,7 @@ func TestSimulateTx(t *testing.T) {
 		require.True(t, queryResult.IsOK(), queryResult.Log)

 		var res sdk.Result
-		wire.Cdc.MustUnmarshalBinary(queryResult.Value, &res)
+		codec.Cdc.MustUnmarshalBinary(queryResult.Value, &res)
 		require.Nil(t, err, "Result unmarshalling failed")
 		require.True(t, res.IsOK(), res.Log)
 		require.Equal(t, gasConsumed, res.GasUsed, res.Log)
@ -721,7 +723,7 @@ func TestRunInvalidTransaction(t *testing.T) {
 		tx.Msgs = append(tx.Msgs, msgNoDecode{})

 		// new codec so we can encode the tx, but we shouldn't be able to decode
-		newCdc := wire.NewCodec()
+		newCdc := codec.New()
 		registerTestCodec(newCdc)
 		newCdc.RegisterConcrete(&msgNoDecode{}, "cosmos-sdk/baseapp/msgNoDecode", nil)

--- a/client/context/context.go
+++ b/client/context/context.go
@ -6,7 +6,7 @@ import (
 	"io"

 	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/x/auth"

 	"github.com/spf13/viper"
@ -15,6 +15,7 @@ import (
 	tmlite "github.com/tendermint/tendermint/lite"
 	tmliteProxy "github.com/tendermint/tendermint/lite/proxy"
 	rpcclient "github.com/tendermint/tendermint/rpc/client"
+	"os"
 )

 const ctxAccStoreName = "acc"
@ -22,7 +23,7 @@ const ctxAccStoreName = "acc"
 // CLIContext implements a typical CLI context created in SDK modules for
 // transaction handling and queries.
 type CLIContext struct {
-	Codec           *wire.Codec
+	Codec           *codec.Codec
 	AccDecoder      auth.AccountDecoder
 	Client          rpcclient.Client
 	Logger          io.Writer
@ -68,37 +69,45 @@ func NewCLIContext() CLIContext {
 }

 func createCertifier() tmlite.Certifier {
+	trustNodeDefined := viper.IsSet(client.FlagTrustNode)
+	if !trustNodeDefined {
+		return nil
+	}
+
 	trustNode := viper.GetBool(client.FlagTrustNode)
 	if trustNode {
 		return nil
 	}
+
 	chainID := viper.GetString(client.FlagChainID)
 	home := viper.GetString(cli.HomeFlag)
 	nodeURI := viper.GetString(client.FlagNode)

 	var errMsg bytes.Buffer
 	if chainID == "" {
-		errMsg.WriteString("chain-id ")
+		errMsg.WriteString("--chain-id ")
 	}
 	if home == "" {
-		errMsg.WriteString("home ")
+		errMsg.WriteString("--home ")
 	}
 	if nodeURI == "" {
-		errMsg.WriteString("node ")
+		errMsg.WriteString("--node ")
 	}
-	// errMsg is not empty
 	if errMsg.Len() != 0 {
-		panic(fmt.Errorf("can't create certifier for distrust mode, empty values from these options: %s", errMsg.String()))
+		fmt.Printf("must specify these options: %s when --trust-node is false\n", errMsg.String())
+		os.Exit(1)
 	}
+
 	certifier, err := tmliteProxy.GetCertifier(chainID, home, nodeURI)
 	if err != nil {
 		panic(err)
 	}
+
 	return certifier
 }

 // WithCodec returns a copy of the context with an updated codec.
-func (ctx CLIContext) WithCodec(cdc *wire.Codec) CLIContext {
+func (ctx CLIContext) WithCodec(cdc *codec.Codec) CLIContext {
 	ctx.Codec = cdc
 	return ctx
 }
--- a/client/context/errors.go
+++ b/client/context/errors.go
@ -11,3 +11,11 @@ func ErrInvalidAccount(addr sdk.AccAddress) error {
 	return errors.Errorf(`No account with address %s was found in the state.
 Are you sure there has been a transaction involving it?`, addr)
 }
+
+// ErrVerifyCommit returns a common error reflecting that the blockchain commit at a given
+// height can't be verified. The reason is that the base checkpoint of the certifier is
+// newer than the given height
+func ErrVerifyCommit(height int64) error {
+	return errors.Errorf(`The height of base truststore in gaia-lite is higher than height %d. 
+Can't verify blockchain proof at this height. Please set --trust-node to true and try again`, height)
+}
--- a/client/context/query.go
+++ b/client/context/query.go
@ -12,10 +12,12 @@ import (

 	"strings"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/store"
-	"github.com/cosmos/cosmos-sdk/wire"
 	abci "github.com/tendermint/tendermint/abci/types"
 	cmn "github.com/tendermint/tendermint/libs/common"
+	"github.com/tendermint/tendermint/lite"
+	tmliteErr "github.com/tendermint/tendermint/lite/errors"
 	tmliteProxy "github.com/tendermint/tendermint/lite/proxy"
 	rpcclient "github.com/tendermint/tendermint/rpc/client"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
@ -310,7 +312,7 @@ func (ctx CLIContext) query(path string, key cmn.HexBytes) (res []byte, err erro
 		return res, errors.Errorf("query failed: (%d) %s", resp.Code, resp.Log)
 	}

-	// Data from trusted node or subspace query doesn't need verification
+	// Data from trusted node or subspace query doesn't need verification.
 	if ctx.TrustNode || !isQueryStoreWithProof(path) {
 		return resp.Value, nil
 	}
@ -323,6 +325,17 @@ func (ctx CLIContext) query(path string, key cmn.HexBytes) (res []byte, err erro
 	return resp.Value, nil
 }

+// Certify verifies the consensus proof at given height
+func (ctx CLIContext) Certify(height int64) (lite.Commit, error) {
+	check, err := tmliteProxy.GetCertifiedCommit(height, ctx.Client, ctx.Certifier)
+	if tmliteErr.IsCommitNotFoundErr(err) {
+		return lite.Commit{}, ErrVerifyCommit(height)
+	} else if err != nil {
+		return lite.Commit{}, err
+	}
+	return check, nil
+}
+
 // verifyProof perform response proof verification
 // nolint: unparam
 func (ctx CLIContext) verifyProof(path string, resp abci.ResponseQuery) error {
@ -331,34 +344,31 @@ func (ctx CLIContext) verifyProof(path string, resp abci.ResponseQuery) error {
 		return fmt.Errorf("missing valid certifier to verify data from untrusted node")
 	}

-	node, err := ctx.GetNode()
-	if err != nil {
-		return err
-	}
-
 	// AppHash for height H is in header H+1
-	commit, err := tmliteProxy.GetCertifiedCommit(resp.Height+1, node, ctx.Certifier)
+	commit, err := ctx.Certify(resp.Height + 1)
 	if err != nil {
 		return err
 	}

 	var multiStoreProof store.MultiStoreProof
-	cdc := wire.NewCodec()
+	cdc := codec.New()
 	err = cdc.UnmarshalBinary(resp.Proof, &multiStoreProof)
 	if err != nil {
 		return errors.Wrap(err, "failed to unmarshalBinary rangeProof")
 	}

 	// Verify the substore commit hash against trusted appHash
-	substoreCommitHash, err := store.VerifyMultiStoreCommitInfo(multiStoreProof.StoreName,
-		multiStoreProof.StoreInfos, commit.Header.AppHash)
+	substoreCommitHash, err := store.VerifyMultiStoreCommitInfo(
+		multiStoreProof.StoreName, multiStoreProof.StoreInfos, commit.Header.AppHash)
 	if err != nil {
 		return errors.Wrap(err, "failed in verifying the proof against appHash")
 	}
+
 	err = store.VerifyRangeProof(resp.Key, resp.Value, substoreCommitHash, &multiStoreProof.RangeProof)
 	if err != nil {
 		return errors.Wrap(err, "failed in the range proof verification")
 	}
+
 	return nil
 }

--- a/client/flags.go
+++ b/client/flags.go
@ -46,8 +46,7 @@ var (
 // GetCommands adds common flags to query commands
 func GetCommands(cmds ...*cobra.Command) []*cobra.Command {
 	for _, c := range cmds {
-		// TODO: make this default false when we support proofs
-		c.Flags().Bool(FlagTrustNode, true, "Don't verify proofs for responses")
+		c.Flags().Bool(FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
 		c.Flags().Bool(FlagUseLedger, false, "Use a connected Ledger device")
 		c.Flags().String(FlagChainID, "", "Chain ID of tendermint node")
 		c.Flags().String(FlagNode, "tcp://localhost:26657", "<host>:<port> to tendermint rpc interface for this chain")
@ -71,7 +70,7 @@ func PostCommands(cmds ...*cobra.Command) []*cobra.Command {
 		c.Flags().Bool(FlagAsync, false, "broadcast transactions asynchronously")
 		c.Flags().Bool(FlagJson, false, "return output in json format")
 		c.Flags().Bool(FlagPrintResponse, true, "return tx response (only works with async = false)")
-		c.Flags().Bool(FlagTrustNode, true, "Don't verify proofs for query responses")
+		c.Flags().Bool(FlagTrustNode, true, "Trust connected full node (don't verify proofs for responses)")
 		c.Flags().Bool(FlagDryRun, false, "ignore the --gas flag and perform a simulation of a transaction, but don't broadcast it")
 		c.Flags().Bool(FlagGenerateOnly, false, "build an unsigned transaction and write it to STDOUT")
 		// --gas can accept integers and "simulate"
--- a/client/keys/codec.go
+++ b/client/keys/codec.go
@ -1,14 +1,14 @@
 package keys

 import (
-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 )

-var cdc *wire.Codec
+var cdc *codec.Codec

 func init() {
-	cdc = wire.NewCodec()
-	wire.RegisterCrypto(cdc)
+	cdc = codec.New()
+	codec.RegisterCrypto(cdc)
 }

 // marshal keys
--- a/client/lcd/codec.go
+++ b/client/lcd/codec.go
--- a/client/lcd/lcd_test.go
+++ b/client/lcd/lcd_test.go
@ -22,15 +22,14 @@ import (
 	client "github.com/cosmos/cosmos-sdk/client"
 	keys "github.com/cosmos/cosmos-sdk/client/keys"
 	rpc "github.com/cosmos/cosmos-sdk/client/rpc"
+	"github.com/cosmos/cosmos-sdk/codec"
 	tests "github.com/cosmos/cosmos-sdk/tests"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	authrest "github.com/cosmos/cosmos-sdk/x/auth/client/rest"
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/slashing"
 	"github.com/cosmos/cosmos-sdk/x/stake"
-	"github.com/cosmos/cosmos-sdk/x/stake/client/rest"
 )

 func init() {
@ -61,7 +60,7 @@ func TestKeys(t *testing.T) {

 	require.Equal(t, http.StatusOK, res.StatusCode, body)
 	var resp keys.KeyOutput
-	err = wire.Cdc.UnmarshalJSON([]byte(body), &resp)
+	err = codec.Cdc.UnmarshalJSON([]byte(body), &resp)
 	require.Nil(t, err, body)

 	addr2Bech32 := resp.Address
@ -178,10 +177,10 @@ func TestBlock(t *testing.T) {

 	// --

-	res, body = Request(t, port, "GET", "/blocks/1", nil)
+	res, body = Request(t, port, "GET", "/blocks/2", nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)

-	err = wire.Cdc.UnmarshalJSON([]byte(body), &resultBlock)
+	err = codec.Cdc.UnmarshalJSON([]byte(body), &resultBlock)
 	require.Nil(t, err, "Couldn't parse block")

 	require.NotEqual(t, ctypes.ResultBlock{}, resultBlock)
@ -211,7 +210,7 @@ func TestValidators(t *testing.T) {

 	// --

-	res, body = Request(t, port, "GET", "/validatorsets/1", nil)
+	res, body = Request(t, port, "GET", "/validatorsets/2", nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)

 	err = cdc.UnmarshalJSON([]byte(body), &resultVals)
@ -510,6 +509,7 @@ func TestBonding(t *testing.T) {
 	cleanup, pks, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
 	defer cleanup()

+	amt := sdk.NewDec(60)
 	validator1Operator := sdk.ValAddress(pks[0].Address())
 	validator := getValidator(t, port, validator1Operator)

@ -527,18 +527,18 @@ func TestBonding(t *testing.T) {

 	// query validator
 	bond := getDelegation(t, port, addr, validator1Operator)
-	require.Equal(t, "60.0000000000", bond.Shares)
+	require.Equal(t, amt, bond.Shares)

 	summary := getDelegationSummary(t, port, addr)

 	require.Len(t, summary.Delegations, 1, "Delegation summary holds all delegations")
-	require.Equal(t, "60.0000000000", summary.Delegations[0].Shares)
+	require.Equal(t, amt, summary.Delegations[0].Shares)
 	require.Len(t, summary.UnbondingDelegations, 0, "Delegation summary holds all unbonding-delegations")

 	bondedValidators := getDelegatorValidators(t, port, addr)
 	require.Len(t, bondedValidators, 1)
 	require.Equal(t, validator1Operator, bondedValidators[0].OperatorAddr)
-	require.Equal(t, validator.DelegatorShares.Add(sdk.NewDec(60)).String(), bondedValidators[0].DelegatorShares.String())
+	require.Equal(t, validator.DelegatorShares.Add(amt).String(), bondedValidators[0].DelegatorShares.String())

 	bondedValidator := getDelegatorValidator(t, port, addr, validator1Operator)
 	require.Equal(t, validator1Operator, bondedValidator.OperatorAddr)
@ -558,9 +558,8 @@ func TestBonding(t *testing.T) {
 	coins = acc.GetCoins()
 	require.Equal(t, int64(40), coins.AmountOf("steak").Int64())

-	unbondings := getUndelegations(t, port, addr, validator1Operator)
-	require.Len(t, unbondings, 1, "Unbondings holds all unbonding-delegations")
-	require.Equal(t, "60", unbondings[0].Balance.Amount.String())
+	unbonding := getUndelegation(t, port, addr, validator1Operator)
+	require.Equal(t, "60", unbonding.Balance.Amount.String())

 	summary = getDelegationSummary(t, port, addr)

@ -895,43 +894,43 @@ func doIBCTransfer(t *testing.T, port, seed, name, password string, addr sdk.Acc
 func getSigningInfo(t *testing.T, port string, validatorPubKey string) slashing.ValidatorSigningInfo {
 	res, body := Request(t, port, "GET", fmt.Sprintf("/slashing/signing_info/%s", validatorPubKey), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
+
 	var signingInfo slashing.ValidatorSigningInfo
 	err := cdc.UnmarshalJSON([]byte(body), &signingInfo)
 	require.Nil(t, err)
+
 	return signingInfo
 }

 // ============= Stake Module ================

-func getDelegation(t *testing.T, port string, delAddr sdk.AccAddress, valAddr sdk.ValAddress) rest.DelegationWithoutRat {
-	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/delegations/%s", delAddr, valAddr), nil)
+func getDelegation(t *testing.T, port string, delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress) stake.Delegation {
+	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/delegations/%s", delegatorAddr, validatorAddr), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)

-	var bond rest.DelegationWithoutRat
-
+	var bond stake.Delegation
 	err := cdc.UnmarshalJSON([]byte(body), &bond)
 	require.Nil(t, err)

 	return bond
 }

-func getUndelegations(t *testing.T, port string, delAddr sdk.AccAddress, valAddr sdk.ValAddress) []stake.UnbondingDelegation {
-	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/unbonding_delegations/%s", delAddr, valAddr), nil)
+func getUndelegation(t *testing.T, port string, delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress) stake.UnbondingDelegation {
+	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/unbonding_delegations/%s", delegatorAddr, validatorAddr), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)

-	var unbondings []stake.UnbondingDelegation
-
+	var unbondings stake.UnbondingDelegation
 	err := cdc.UnmarshalJSON([]byte(body), &unbondings)
 	require.Nil(t, err)

 	return unbondings
 }

-func getDelegationSummary(t *testing.T, port string, delegatorAddr sdk.AccAddress) rest.DelegationSummary {
+func getDelegationSummary(t *testing.T, port string, delegatorAddr sdk.AccAddress) stake.DelegationSummary {
 	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s", delegatorAddr), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)

-	var summary rest.DelegationSummary
+	var summary stake.DelegationSummary

 	err := cdc.UnmarshalJSON([]byte(body), &summary)
 	require.Nil(t, err)
@ -970,8 +969,8 @@ func getDelegatorValidators(t *testing.T, port string, delegatorAddr sdk.AccAddr
 	return bondedValidators
 }

-func getDelegatorValidator(t *testing.T, port string, delAddr sdk.AccAddress, valAddr sdk.ValAddress) stake.Validator {
-	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/validators/%s", delAddr, valAddr), nil)
+func getDelegatorValidator(t *testing.T, port string, delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress) stake.Validator {
+	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/delegators/%s/validators/%s", delegatorAddr, validatorAddr), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)

 	var bondedValidator stake.Validator
@ -1097,18 +1096,22 @@ func doBeginRedelegation(t *testing.T, port, seed, name, password string,
 func getValidators(t *testing.T, port string) []stake.Validator {
 	res, body := Request(t, port, "GET", "/stake/validators", nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
+
 	var validators []stake.Validator
 	err := cdc.UnmarshalJSON([]byte(body), &validators)
 	require.Nil(t, err)
+
 	return validators
 }

-func getValidator(t *testing.T, port string, valAddr sdk.ValAddress) stake.Validator {
-	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/validators/%s", valAddr.String()), nil)
+func getValidator(t *testing.T, port string, validatorAddr sdk.ValAddress) stake.Validator {
+	res, body := Request(t, port, "GET", fmt.Sprintf("/stake/validators/%s", validatorAddr.String()), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
+
 	var validator stake.Validator
 	err := cdc.UnmarshalJSON([]byte(body), &validator)
 	require.Nil(t, err)
+
 	return validator
 }

@ -1284,7 +1287,6 @@ func doVote(t *testing.T, port, seed, name, password string, proposerAddr sdk.Ac
 		}
 	}`, proposerAddr, name, password, chainID, accnum, sequence))
 	res, body := Request(t, port, "POST", fmt.Sprintf("/gov/proposals/%d/votes", proposalID), jsonStr)
-	fmt.Println(res)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)

 	var results ctypes.ResultBroadcastTxCommit
--- a/client/lcd/root.go
+++ b/client/lcd/root.go
@ -9,7 +9,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/keys"
 	"github.com/cosmos/cosmos-sdk/client/rpc"
 	"github.com/cosmos/cosmos-sdk/client/tx"
-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 	auth "github.com/cosmos/cosmos-sdk/x/auth/client/rest"
 	bank "github.com/cosmos/cosmos-sdk/x/bank/client/rest"
 	gov "github.com/cosmos/cosmos-sdk/x/gov/client/rest"
@ -27,7 +27,7 @@ import (
 // ServeCommand will generate a long-running rest server
 // (aka Light Client Daemon) that exposes functionality similar
 // to the cli, but over rest
-func ServeCommand(cdc *wire.Codec) *cobra.Command {
+func ServeCommand(cdc *codec.Codec) *cobra.Command {
 	flagListenAddr := "laddr"
 	flagCORS := "cors"
 	flagMaxOpenConnections := "max-open"
@ -63,15 +63,15 @@ func ServeCommand(cdc *wire.Codec) *cobra.Command {

 	cmd.Flags().String(flagListenAddr, "tcp://localhost:1317", "The address for the server to listen on")
 	cmd.Flags().String(flagCORS, "", "Set the domains that can make CORS requests (* for all)")
-	cmd.Flags().String(client.FlagChainID, "", "The chain ID to connect to")
+	cmd.Flags().String(client.FlagChainID, "", "Chain ID of Tendermint node")
 	cmd.Flags().String(client.FlagNode, "tcp://localhost:26657", "Address of the node to connect to")
 	cmd.Flags().Int(flagMaxOpenConnections, 1000, "The number of maximum open connections")
-	cmd.Flags().Bool(client.FlagTrustNode, false, "Whether trust connected full node")
+	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")

 	return cmd
 }

-func createHandler(cdc *wire.Codec) http.Handler {
+func createHandler(cdc *codec.Codec) http.Handler {
 	r := mux.NewRouter()

 	kb, err := keys.GetKeyBase() //XXX
--- a/client/lcd/test_helpers.go
+++ b/client/lcd/test_helpers.go
@ -15,11 +15,11 @@ import (
 	"github.com/cosmos/cosmos-sdk/client"
 	keys "github.com/cosmos/cosmos-sdk/client/keys"
 	gapp "github.com/cosmos/cosmos-sdk/cmd/gaia/app"
+	"github.com/cosmos/cosmos-sdk/codec"
 	crkeys "github.com/cosmos/cosmos-sdk/crypto/keys"
 	"github.com/cosmos/cosmos-sdk/server"
 	"github.com/cosmos/cosmos-sdk/tests"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"

 	"github.com/spf13/viper"
@ -176,7 +176,7 @@ func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress
 		genesisState.StakeData.Pool.LooseTokens = genesisState.StakeData.Pool.LooseTokens.Add(sdk.NewDec(100))
 	}

-	appState, err := wire.MarshalJSONIndent(cdc, genesisState)
+	appState, err := codec.MarshalJSONIndent(cdc, genesisState)
 	require.NoError(t, err)
 	genDoc.AppState = appState

@ -186,6 +186,10 @@ func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress
 	// XXX: Need to set this so LCD knows the tendermint node address!
 	viper.Set(client.FlagNode, config.RPC.ListenAddress)
 	viper.Set(client.FlagChainID, genDoc.ChainID)
+	viper.Set(client.FlagTrustNode, false)
+	dir, err := ioutil.TempDir("", "lcd_test")
+	require.NoError(t, err)
+	viper.Set(cli.HomeFlag, dir)

 	node, err := startTM(config, logger, genDoc, privVal, app)
 	require.NoError(t, err)
@ -245,7 +249,7 @@ func startTM(
 // startLCD starts the LCD.
 //
 // NOTE: This causes the thread to block.
-func startLCD(logger log.Logger, listenAddr string, cdc *wire.Codec) (net.Listener, error) {
+func startLCD(logger log.Logger, listenAddr string, cdc *codec.Codec) (net.Listener, error) {
 	return tmrpc.StartHTTPServer(listenAddr, createHandler(cdc), logger, tmrpc.Config{})
 }

--- a/client/rpc/block.go
+++ b/client/rpc/block.go
@ -10,6 +10,7 @@ import (

 	"github.com/gorilla/mux"
 	"github.com/spf13/cobra"
+	tmliteProxy "github.com/tendermint/tendermint/lite/proxy"
 )

 //BlockCommand returns the verified block data for a given heights
@ -21,8 +22,8 @@ func BlockCommand() *cobra.Command {
 		RunE:  printBlock,
 	}
 	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
-	// TODO: change this to false when we can
-	cmd.Flags().Bool(client.FlagTrustNode, true, "Don't verify proofs for responses")
+	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	cmd.Flags().String(client.FlagChainID, "", "Chain ID of Tendermint node")
 	return cmd
 }

@ -41,8 +42,25 @@ func getBlock(cliCtx context.CLIContext, height *int64) ([]byte, error) {
 		return nil, err
 	}

+	if !cliCtx.TrustNode {
+		check, err := cliCtx.Certify(res.Block.Height)
+		if err != nil {
+			return nil, err
+		}
+
+		err = tmliteProxy.ValidateBlockMeta(res.BlockMeta, check)
+		if err != nil {
+			return nil, err
+		}
+
+		err = tmliteProxy.ValidateBlock(res.Block, check)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	// TODO move maarshalling into cmd/rest functions
-	// output, err := tmwire.MarshalJSON(res)
+	// output, err := tmcodec.MarshalJSON(res)
 	output, err := cdc.MarshalJSON(res)
 	if err != nil {
 		return nil, err
--- a/client/rpc/codec.go
+++ b/client/rpc/codec.go
--- a/client/rpc/validators.go
+++ b/client/rpc/validators.go
@ -8,9 +8,11 @@ import (
 	"github.com/gorilla/mux"
 	"github.com/spf13/cobra"

+	"bytes"
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/context"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	tmTypes "github.com/tendermint/tendermint/types"
 	tmtypes "github.com/tendermint/tendermint/types"
 )

@ -25,8 +27,8 @@ func ValidatorCommand() *cobra.Command {
 		RunE:  printValidators,
 	}
 	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
-	// TODO: change this to false when we can
-	cmd.Flags().Bool(client.FlagTrustNode, true, "Don't verify proofs for responses")
+	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	cmd.Flags().String(client.FlagChainID, "", "Chain ID of Tendermint node")
 	return cmd
 }

@ -70,6 +72,17 @@ func getValidators(cliCtx context.CLIContext, height *int64) ([]byte, error) {
 		return nil, err
 	}

+	if !cliCtx.TrustNode {
+		check, err := cliCtx.Certify(validatorsRes.BlockHeight)
+		if err != nil {
+			return nil, err
+		}
+
+		if !bytes.Equal(check.ValidatorsHash(), tmTypes.NewValidatorSet(validatorsRes.Validators).Hash()) {
+			return nil, fmt.Errorf("got invalid validatorset")
+		}
+	}
+
 	outputValidatorsRes := ResultValidatorsOutput{
 		BlockHeight: validatorsRes.BlockHeight,
 		Validators:  make([]ValidatorOutput, len(validatorsRes.Validators)),
--- a/client/tx/query.go
+++ b/client/tx/query.go
@ -3,26 +3,23 @@ package tx
 import (
 	"encoding/hex"
 	"fmt"
-	"net/http"
-	"strconv"
-
 	"github.com/tendermint/tendermint/libs/common"
+	"net/http"

 	"github.com/gorilla/mux"
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 	abci "github.com/tendermint/tendermint/abci/types"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"

 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 )

 // QueryTxCmd implements the default command for a tx query.
-func QueryTxCmd(cdc *wire.Codec) *cobra.Command {
+func QueryTxCmd(cdc *codec.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "tx [hash]",
 		Short: "Matches this txhash over all committed blocks",
@ -30,11 +27,10 @@ func QueryTxCmd(cdc *wire.Codec) *cobra.Command {
 		RunE: func(cmd *cobra.Command, args []string) error {
 			// find the key to look up the account
 			hashHexStr := args[0]
-			trustNode := viper.GetBool(client.FlagTrustNode)

 			cliCtx := context.NewCLIContext().WithCodec(cdc)

-			output, err := queryTx(cdc, cliCtx, hashHexStr, trustNode)
+			output, err := queryTx(cdc, cliCtx, hashHexStr)
 			if err != nil {
 				return err
 			}
@ -45,13 +41,12 @@ func QueryTxCmd(cdc *wire.Codec) *cobra.Command {
 	}

 	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
-
-	// TODO: change this to false when we can
-	cmd.Flags().Bool(client.FlagTrustNode, true, "Don't verify proofs for responses")
+	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	cmd.Flags().String(client.FlagChainID, "", "Chain ID of Tendermint node")
 	return cmd
 }

-func queryTx(cdc *wire.Codec, cliCtx context.CLIContext, hashHexStr string, trustNode bool) ([]byte, error) {
+func queryTx(cdc *codec.Codec, cliCtx context.CLIContext, hashHexStr string) ([]byte, error) {
 	hash, err := hex.DecodeString(hashHexStr)
 	if err != nil {
 		return nil, err
@ -62,21 +57,41 @@ func queryTx(cdc *wire.Codec, cliCtx context.CLIContext, hashHexStr string, trus
 		return nil, err
 	}

-	res, err := node.Tx(hash, !trustNode)
+	res, err := node.Tx(hash, !cliCtx.TrustNode)
 	if err != nil {
 		return nil, err
 	}

+	if !cliCtx.TrustNode {
+		err := ValidateTxResult(cliCtx, res)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	info, err := formatTxResult(cdc, res)
 	if err != nil {
 		return nil, err
 	}

-	return wire.MarshalJSONIndent(cdc, info)
+	return codec.MarshalJSONIndent(cdc, info)
 }

-func formatTxResult(cdc *wire.Codec, res *ctypes.ResultTx) (Info, error) {
-	// TODO: verify the proof if requested
+// ValidateTxResult performs transaction verification
+func ValidateTxResult(cliCtx context.CLIContext, res *ctypes.ResultTx) error {
+	check, err := cliCtx.Certify(res.Height)
+	if err != nil {
+		return err
+	}
+
+	err = res.Proof.Validate(check.Header.DataHash)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func formatTxResult(cdc *codec.Codec, res *ctypes.ResultTx) (Info, error) {
 	tx, err := parseTx(cdc, res.Tx)
 	if err != nil {
 		return Info{}, err
@ -98,7 +113,7 @@ type Info struct {
 	Result abci.ResponseDeliverTx `json:"result"`
 }

-func parseTx(cdc *wire.Codec, txBytes []byte) (sdk.Tx, error) {
+func parseTx(cdc *codec.Codec, txBytes []byte) (sdk.Tx, error) {
 	var tx auth.StdTx

 	err := cdc.UnmarshalBinary(txBytes, &tx)
@ -112,17 +127,12 @@ func parseTx(cdc *wire.Codec, txBytes []byte) (sdk.Tx, error) {
 // REST

 // transaction query REST handler
-func QueryTxRequestHandlerFn(cdc *wire.Codec, cliCtx context.CLIContext) http.HandlerFunc {
+func QueryTxRequestHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		vars := mux.Vars(r)
 		hashHexStr := vars["hash"]
-		trustNode, err := strconv.ParseBool(r.FormValue("trust_node"))
-		// trustNode defaults to true
-		if err != nil {
-			trustNode = true
-		}

-		output, err := queryTx(cdc, cliCtx, hashHexStr, trustNode)
+		output, err := queryTx(cdc, cliCtx, hashHexStr)
 		if err != nil {
 			w.WriteHeader(500)
 			w.Write([]byte(err.Error()))
--- a/client/tx/root.go
+++ b/client/tx/root.go
@ -5,11 +5,11 @@ import (
 	"github.com/spf13/cobra"

 	"github.com/cosmos/cosmos-sdk/client/context"
-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 )

 // AddCommands adds a number of tx-query related subcommands
-func AddCommands(cmd *cobra.Command, cdc *wire.Codec) {
+func AddCommands(cmd *cobra.Command, cdc *codec.Codec) {
 	cmd.AddCommand(
 		SearchTxCmd(cdc),
 		QueryTxCmd(cdc),
@ -17,7 +17,7 @@ func AddCommands(cmd *cobra.Command, cdc *wire.Codec) {
 }

 // register REST routes
-func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *wire.Codec) {
+func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec) {
 	r.HandleFunc("/txs/{hash}", QueryTxRequestHandlerFn(cdc, cliCtx)).Methods("GET")
 	r.HandleFunc("/txs", SearchTxRequestHandlerFn(cliCtx, cdc)).Methods("GET")
 	// r.HandleFunc("/txs/sign", SignTxRequstHandler).Methods("POST")
--- a/client/tx/search.go
+++ b/client/tx/search.go
@ -9,8 +9,8 @@ import (

 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"

 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@ -24,7 +24,7 @@ const (
 )

 // default client command to search through tagged transactions
-func SearchTxCmd(cdc *wire.Codec) *cobra.Command {
+func SearchTxCmd(cdc *codec.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "txs",
 		Short: "Search for all transactions that match the given tags.",
@ -62,15 +62,14 @@ $ gaiacli tendermint txs --tag test1,test2 --any
 	}

 	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
-
-	// TODO: change this to false once proofs built in
-	cmd.Flags().Bool(client.FlagTrustNode, true, "Don't verify proofs for responses")
+	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	cmd.Flags().String(client.FlagChainID, "", "Chain ID of Tendermint node")
 	cmd.Flags().StringSlice(flagTags, nil, "Comma-separated list of tags that must match")
 	cmd.Flags().Bool(flagAny, false, "Return transactions that match ANY tag, rather than ALL")
 	return cmd
 }

-func searchTxs(cliCtx context.CLIContext, cdc *wire.Codec, tags []string) ([]Info, error) {
+func searchTxs(cliCtx context.CLIContext, cdc *codec.Codec, tags []string) ([]Info, error) {
 	if len(tags) == 0 {
 		return nil, errors.New("must declare at least one tag to search")
 	}
@ -84,7 +83,7 @@ func searchTxs(cliCtx context.CLIContext, cdc *wire.Codec, tags []string) ([]Inf
 		return nil, err
 	}

-	prove := !viper.GetBool(client.FlagTrustNode)
+	prove := !cliCtx.TrustNode

 	// TODO: take these as args
 	page := 0
@ -94,6 +93,15 @@ func searchTxs(cliCtx context.CLIContext, cdc *wire.Codec, tags []string) ([]Inf
 		return nil, err
 	}

+	if prove {
+		for _, tx := range res.Txs {
+			err := ValidateTxResult(cliCtx, tx)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
 	info, err := FormatTxResults(cdc, res.Txs)
 	if err != nil {
 		return nil, err
@ -103,7 +111,7 @@ func searchTxs(cliCtx context.CLIContext, cdc *wire.Codec, tags []string) ([]Inf
 }

 // parse the indexed txs into an array of Info
-func FormatTxResults(cdc *wire.Codec, res []*ctypes.ResultTx) ([]Info, error) {
+func FormatTxResults(cdc *codec.Codec, res []*ctypes.ResultTx) ([]Info, error) {
 	var err error
 	out := make([]Info, len(res))
 	for i := range res {
@ -119,7 +127,7 @@ func FormatTxResults(cdc *wire.Codec, res []*ctypes.ResultTx) ([]Info, error) {
 // REST

 // Search Tx REST Handler
-func SearchTxRequestHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.HandlerFunc {
+func SearchTxRequestHandlerFn(cliCtx context.CLIContext, cdc *codec.Codec) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		tag := r.FormValue("tag")
 		if tag == "" {
--- a/client/utils/utils.go
+++ b/client/utils/utils.go
@ -133,6 +133,7 @@ func SignStdTx(txBldr authtxb.TxBuilder, cliCtx context.CLIContext, name string,
 	return txBldr.SignStdTx(name, passphrase, stdTx, appendSig)
 }

+// nolint
 // SimulateMsgs simulates the transaction and returns the gas estimate and the adjusted value.
 func simulateMsgs(txBldr authtxb.TxBuilder, cliCtx context.CLIContext, name string, msgs []sdk.Msg) (estimated, adjusted int64, err error) {
 	txBytes, err := txBldr.BuildWithPubKey(name, msgs)
--- a/cmd/gaia/app/app.go
+++ b/cmd/gaia/app/app.go
@ -12,8 +12,8 @@ import (
 	tmtypes "github.com/tendermint/tendermint/types"

 	bam "github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/gov"
@ -36,7 +36,7 @@ var (
 // Extended ABCI application
 type GaiaApp struct {
 	*bam.BaseApp
-	cdc *wire.Codec
+	cdc *codec.Codec

 	// keys to access the substores
 	keyMain          *sdk.KVStoreKey
@ -109,7 +109,8 @@ func NewGaiaApp(logger log.Logger, db dbm.DB, traceStore io.Writer, baseAppOptio
 		AddRoute("gov", gov.NewHandler(app.govKeeper))

 	app.QueryRouter().
-		AddRoute("gov", gov.NewQuerier(app.govKeeper))
+		AddRoute("gov", gov.NewQuerier(app.govKeeper)).
+		AddRoute("stake", stake.NewQuerier(app.stakeKeeper, app.cdc))

 	// initialize BaseApp
 	app.SetInitChainer(app.initChainer)
@ -128,16 +129,16 @@ func NewGaiaApp(logger log.Logger, db dbm.DB, traceStore io.Writer, baseAppOptio
 }

 // custom tx codec
-func MakeCodec() *wire.Codec {
-	var cdc = wire.NewCodec()
-	ibc.RegisterWire(cdc)
-	bank.RegisterWire(cdc)
-	stake.RegisterWire(cdc)
-	slashing.RegisterWire(cdc)
-	gov.RegisterWire(cdc)
-	auth.RegisterWire(cdc)
-	sdk.RegisterWire(cdc)
-	wire.RegisterCrypto(cdc)
+func MakeCodec() *codec.Codec {
+	var cdc = codec.New()
+	ibc.RegisterCodec(cdc)
+	bank.RegisterCodec(cdc)
+	stake.RegisterCodec(cdc)
+	slashing.RegisterCodec(cdc)
+	gov.RegisterCodec(cdc)
+	auth.RegisterCodec(cdc)
+	sdk.RegisterCodec(cdc)
+	codec.RegisterCrypto(cdc)
 	return cdc
 }

@ -222,7 +223,7 @@ func (app *GaiaApp) ExportAppStateAndValidators() (appState json.RawMessage, val
 		StakeData: stake.WriteGenesis(ctx, app.stakeKeeper),
 		GovData:   gov.WriteGenesis(ctx, app.govKeeper),
 	}
-	appState, err = wire.MarshalJSONIndent(app.cdc, genState)
+	appState, err = codec.MarshalJSONIndent(app.cdc, genState)
 	if err != nil {
 		return nil, nil, err
 	}
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@ -4,7 +4,7 @@ import (
 	"os"
 	"testing"

-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/stake"
 	"github.com/stretchr/testify/require"
@ -25,7 +25,7 @@ func setGenesis(gapp *GaiaApp, accs ...*auth.BaseAccount) error {
 		StakeData: stake.DefaultGenesisState(),
 	}

-	stateBytes, err := wire.MarshalJSONIndent(gapp.cdc, genesisState)
+	stateBytes, err := codec.MarshalJSONIndent(gapp.cdc, genesisState)
 	if err != nil {
 		return err
 	}
--- a/cmd/gaia/app/genesis.go
+++ b/cmd/gaia/app/genesis.go
@ -6,10 +6,10 @@ import (
 	"fmt"

 	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/server"
 	"github.com/cosmos/cosmos-sdk/server/config"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/stake"
@ -92,7 +92,7 @@ type GaiaGenTx struct {

 // GaiaAppGenTx generates a Gaia genesis transaction.
 func GaiaAppGenTx(
-	cdc *wire.Codec, pk crypto.PubKey, genTxConfig config.GenTx,
+	cdc *codec.Codec, pk crypto.PubKey, genTxConfig config.GenTx,
 ) (appGenTx, cliPrint json.RawMessage, validator tmtypes.GenesisValidator, err error) {
 	if genTxConfig.Name == "" {
 		return nil, nil, tmtypes.GenesisValidator{}, errors.New("Must specify --name (validator moniker)")
@ -136,7 +136,7 @@ func GaiaAppGenTx(
 }

 // Generate a gaia genesis transaction without flags
-func GaiaAppGenTxNF(cdc *wire.Codec, pk crypto.PubKey, addr sdk.AccAddress, name string) (
+func GaiaAppGenTxNF(cdc *codec.Codec, pk crypto.PubKey, addr sdk.AccAddress, name string) (
 	appGenTx, cliPrint json.RawMessage, validator tmtypes.GenesisValidator, err error) {

 	var bz []byte
@ -145,7 +145,7 @@ func GaiaAppGenTxNF(cdc *wire.Codec, pk crypto.PubKey, addr sdk.AccAddress, name
 		Address: addr,
 		PubKey:  sdk.MustBech32ifyConsPub(pk),
 	}
-	bz, err = wire.MarshalJSONIndent(cdc, gaiaGenTx)
+	bz, err = codec.MarshalJSONIndent(cdc, gaiaGenTx)
 	if err != nil {
 		return
 	}
@ -160,7 +160,7 @@ func GaiaAppGenTxNF(cdc *wire.Codec, pk crypto.PubKey, addr sdk.AccAddress, name

 // Create the core parameters for genesis initialization for gaia
 // note that the pubkey input is this machines pubkey
-func GaiaAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (genesisState GenesisState, err error) {
+func GaiaAppGenState(cdc *codec.Codec, appGenTxs []json.RawMessage) (genesisState GenesisState, err error) {

 	if len(appGenTxs) == 0 {
 		err = errors.New("must provide at least genesis transaction")
@ -234,7 +234,7 @@ func genesisAccountFromGenTx(genTx GaiaGenTx) GenesisAccount {
 }

 // GaiaValidateGenesisState ensures that the genesis state obeys the expected invariants
-// TODO: No validators are both bonded and revoked (#2088)
+// TODO: No validators are both bonded and jailed (#2088)
 // TODO: Error if there is a duplicate validator (#1708)
 // TODO: Ensure all state machine parameters are in genesis (#1704)
 func GaiaValidateGenesisState(genesisState GenesisState) (err error) {
@ -258,7 +258,7 @@ func validateGenesisStateValidators(validators []stakeTypes.Validator) (err erro
 			return fmt.Errorf("Duplicate validator in genesis state: moniker %v, Address %v", val.Description.Moniker, val.ConsAddress())
 		}
 		if val.Jailed && val.Status == sdk.Bonded {
-			return fmt.Errorf("Validator is bonded and revoked in genesis state: moniker %v, Address %v", val.Description.Moniker, val.ConsAddress())
+			return fmt.Errorf("Validator is bonded and jailed in genesis state: moniker %v, Address %v", val.Description.Moniker, val.ConsAddress())
 		}
 		addrMap[strKey] = true
 	}
@ -280,13 +280,13 @@ func validateGenesisStateAccounts(accs []GenesisAccount) (err error) {
 }

 // GaiaAppGenState but with JSON
-func GaiaAppGenStateJSON(cdc *wire.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error) {
+func GaiaAppGenStateJSON(cdc *codec.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error) {

 	// create the final app state
 	genesisState, err := GaiaAppGenState(cdc, appGenTxs)
 	if err != nil {
 		return nil, err
 	}
-	appState, err = wire.MarshalJSONIndent(cdc, genesisState)
+	appState, err = codec.MarshalJSONIndent(cdc, genesisState)
 	return
 }
--- a/cmd/gaia/app/genesis_test.go
+++ b/cmd/gaia/app/genesis_test.go
@ -84,7 +84,7 @@ func TestGaiaGenesisValidation(t *testing.T) {
 	genesisState := makeGenesisState(genTxs)
 	err := GaiaValidateGenesisState(genesisState)
 	require.NotNil(t, err)
-	// Test bonded + revoked validator fails
+	// Test bonded + jailed validator fails
 	genesisState = makeGenesisState(genTxs[:1])
 	val1 := stakeTypes.NewValidator(addr1, pk1, stakeTypes.Description{Moniker: "test #2"})
 	val1.Jailed = true
--- a/cmd/gaia/cli_test/cli_test.go
+++ b/cmd/gaia/cli_test/cli_test.go
@ -18,10 +18,10 @@ import (
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/keys"
 	"github.com/cosmos/cosmos-sdk/cmd/gaia/app"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/server"
 	"github.com/cosmos/cosmos-sdk/tests"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/stake"
@ -549,8 +549,8 @@ func executeGetAccount(t *testing.T, cmdStr string) auth.BaseAccount {
 	require.NoError(t, err, "out %v, err %v", out, err)
 	value := initRes["value"]
 	var acc auth.BaseAccount
-	cdc := wire.NewCodec()
-	wire.RegisterCrypto(cdc)
+	cdc := codec.New()
+	codec.RegisterCrypto(cdc)
 	err = cdc.UnmarshalJSON(value, &acc)
 	require.NoError(t, err, "value %v, err %v", string(value), err)
 	return acc
--- a/cmd/gaia/cmd/gaiadebug/hack.go
+++ b/cmd/gaia/cmd/gaiadebug/hack.go
@ -21,7 +21,7 @@ import (
 	bam "github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"

-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/ibc"
@ -65,7 +65,7 @@ func runHackCmd(cmd *cobra.Command, args []string) error {
 	// The following powerKey was there, but the corresponding "trouble" validator did not exist.
 	// So here we do a binary search on the past states to find when the powerKey first showed up ...

-	// operator of the validator the bonds, gets revoked, later unbonds, and then later is still found in the bypower store
+	// operator of the validator the bonds, gets jailed, later unbonds, and then later is still found in the bypower store
 	trouble := hexToBytes("D3DC0FF59F7C3B548B7AFA365561B87FD0208AF8")
 	// this is his "bypower" key
 	powerKey := hexToBytes("05303030303030303030303033FFFFFFFFFFFF4C0C0000FFFED3DC0FF59F7C3B548B7AFA365561B87FD0208AF8")
@ -127,7 +127,7 @@ var (
 // Extended ABCI application
 type GaiaApp struct {
 	*bam.BaseApp
-	cdc *wire.Codec
+	cdc *codec.Codec

 	// keys to access the substores
 	keyMain     *sdk.KVStoreKey
@ -204,15 +204,15 @@ func NewGaiaApp(logger log.Logger, db dbm.DB, baseAppOptions ...func(*bam.BaseAp
 }

 // custom tx codec
-func MakeCodec() *wire.Codec {
-	var cdc = wire.NewCodec()
-	ibc.RegisterWire(cdc)
-	bank.RegisterWire(cdc)
-	stake.RegisterWire(cdc)
-	slashing.RegisterWire(cdc)
-	auth.RegisterWire(cdc)
-	sdk.RegisterWire(cdc)
-	wire.RegisterCrypto(cdc)
+func MakeCodec() *codec.Codec {
+	var cdc = codec.New()
+	ibc.RegisterCodec(cdc)
+	bank.RegisterCodec(cdc)
+	stake.RegisterCodec(cdc)
+	slashing.RegisterCodec(cdc)
+	auth.RegisterCodec(cdc)
+	sdk.RegisterCodec(cdc)
+	codec.RegisterCrypto(cdc)
 	cdc.Seal()
 	return cdc
 }
--- a/cmd/gaia/testnets/STATUS.md
+++ b/cmd/gaia/testnets/STATUS.md
@ -34,7 +34,7 @@ See [testnets repo](https://github.com/cosmos/testnets).
 ## *June 13, 2018, 17:00 EST* - Gaia-6002 is making blocks!

 - Gaia-6002 is live and making blocks
- Absent validators have been slashed and revoked 
+- Absent validators have been slashed and jailed 
 - Currently live with 17 validators

 ## *June 13, 2018, 4:30 EST* - New Testnet Gaia-6002
--- a/codec/codec.go
+++ b/codec/codec.go
@ -1,4 +1,4 @@
-package wire
+package codec

 import (
 	"bytes"
@ -11,7 +11,7 @@ import (
 // amino codec to marshal/unmarshal
 type Codec = amino.Codec

-func NewCodec() *Codec {
+func New() *Codec {
 	cdc := amino.NewCodec()
 	return cdc
 }
@ -42,7 +42,7 @@ func MarshalJSONIndent(cdc *Codec, obj interface{}) ([]byte, error) {
 var Cdc *Codec

 func init() {
-	cdc := NewCodec()
+	cdc := New()
 	RegisterCrypto(cdc)
 	Cdc = cdc.Seal()
 }
--- a/crypto/keys/codec.go
+++ b/crypto/keys/codec.go
--- a/docs/architecture/decision-records/README.md
+++ b/docs/architecture/decision-records/README.md
@ -0,0 +1,22 @@
+# Architecture Decision Records (ADR)
+
+This is a location to record all high-level architecture decisions in the cosmos-sdk project.
+
+You can read more about the ADR concept in this [blog post](https://product.reverb.com/documenting-architecture-decisions-the-reverb-way-a3563bb24bd0#.78xhdix6t).
+
+An ADR should provide:
+
+- Context on the relevant goals and the current state
+- Proposed changes to achieve the goals
+- Summary of pros and cons
+- References
+- Changelog
+
+Note the distinction between an ADR and a spec. The ADR provides the context, intuition, reasoning, and
+justification for a change in architecture, or for the architecture of something
+new. The spec is much more compressed and streamlined summary of everything as
+it stands today.
+
+If recorded decisions turned out to be lacking, convene a discussion, record the new decisions here, and then modify the code to match.
+
+Note the context/background should be written in the present tense.
--- a/docs/architecture/decision-records/adr-001-message-counter.md
+++ b/docs/architecture/decision-records/adr-001-message-counter.md
@ -0,0 +1,54 @@
+# ADR 001: Global Message Counter
+
+## Context
+
+There is a desire for modules to have a concept of orderings between messages.
+
+One such example is in staking, we currently use an "intra bond tx counter" and
+bond height.
+The purpose these two serve is to providing an ordering for validators with equal stake,
+for usage in the power-ranking of validators.
+We can't use address here, as that would create a bad incentive to grind
+addresses that optimized the sort function, which lowers the private key's
+security.
+Instead we order by whose transaction appeared first, as tracked by bondHeight
+and intra bond tx counter. 
+
+This logic however should not be unique to staking.
+It is very conceivable that many modules in the future will want to be able to
+know the ordering of messages / objects after they were initially created.
+
+## Decision
+
+Create a global message counter field of type int64.
+Note that with int64's, there is no fear of overflow under normal use,
+as it is only getting incremented by one,
+and thus has a space of 9 quintillion values to go through.
+
+This counter must be persisted in state, but can just be read and written on 
+begin/end block respectively.
+This field will get incremented upon every DeliverTx,
+regardless if the transaction succeeds or not. 
+It must also be incremented within the check state for CheckTx.
+The global message ordering field should be set within the context
+so that modules can access it.
+
+## Corollary - Intra block ordering
+In the event that there is desire to just have an intra block msg counter,
+this can easily be derived from the global message counter.
+Simply subtract current counter from first global message counter in the block.
+Thus the relevant module could easily implement this.
+
+## Status
+Proposed
+
+## Consequences
+
+### Positive
+* Moves message ordering out of the set of things staking must keep track of
+* Abstracts the logic well so other modules can use it
+
+### Negative
+* Another thing to implement prelaunch. (Though this should be easy to implement)
+
+### Neutral
--- a/docs/architecture/decision-records/adr-template.md
+++ b/docs/architecture/decision-records/adr-template.md
@ -0,0 +1,32 @@
+# ADR {ADR-NUMBER}: {TITLE}
+
+## Changelog
+* {date}: {changelog}
+
+## Context
+> This section contains all the context one needs to understand the current state, and why there is a problem. It should be as succinct as possible and introduce the high level idea behind the solution. 
+
+## Decision
+> This section explains all of the details of the proposed solution, including implementation details.
+It should also describe affects / corollary items that may need to be changed as a part of this.
+If the proposed change will be large, please also indicate a way to do the change to maximize ease of review.
+(e.g. the optimal split of things to do between separate PR's)
+
+## Status
+> A decision may be "proposed" if it hasn't been agreed upon yet, or "accepted" once it is agreed upon. If a later ADR changes or reverses a decision, it may be marked as "deprecated" or "superseded" with a reference to its replacement.
+
+{Deprecated|Proposed|Accepted}
+
+## Consequences
+> This section describes the consequences, after applying the decision. All consequences should be summarized here, not just the "positive" ones.
+
+### Positive
+
+### Negative
+
+### Neutral
+
+## References
+> Are there any relevant PR comments, issues that led up to this, or articles referrenced for why we made the given design choice? If so link them here!
+
+* {reference link}
--- a/docs/resources/whitepaper-zh-CN.md
+++ b/docs/resources/whitepaper-zh-CN.md
--- a/docs/resources/whitepaper.md
+++ b/docs/resources/whitepaper.md
@ -1003,7 +1003,7 @@ where the processes that caused the consensus to fail (ie. caused clients of
 the protocol to accept different values - a fork) can be identified and punished
 according to the rules of the protocol, or, possibly, the legal system. When
 the legal system is unreliable or excessively expensive to invoke, validators can be forced to make security
-deposits in order to participate, and those deposits can be revoked, or slashed,
+deposits in order to participate, and those deposits can be jailed, or slashed,
 when malicious behaviour is detected [\[10\]][10].

 Note this is unlike Bitcoin, where forking is a regular occurence due to
--- a/docs/sdk/core/app2.md
+++ b/docs/sdk/core/app2.md
@ -139,8 +139,8 @@ Amino can also be used for persistent storage of interfaces.
 To use Amino, simply create a codec, and then register types:

 ```
-func NewCodec() *wire.Codec {
-	cdc := wire.NewCodec()
+func NewCodec() *codec.Codec {
+	cdc := codec.New()
 	cdc.RegisterInterface((*sdk.Msg)(nil), nil)
 	cdc.RegisterConcrete(MsgSend{}, "example/MsgSend", nil)
 	cdc.RegisterConcrete(MsgIssue{}, "example/MsgIssue", nil)
@ -175,7 +175,7 @@ func (tx app2Tx) GetMsgs() []sdk.Msg {
 }

 // Amino decode app2Tx. Capable of decoding both MsgSend and MsgIssue
-func tx2Decoder(cdc *wire.Codec) sdk.TxDecoder {
+func tx2Decoder(cdc *codec.Codec) sdk.TxDecoder {
 	return func(txBytes []byte) (sdk.Tx, sdk.Error) {
 		var tx app2Tx
 		err := cdc.UnmarshalBinary(txBytes, &tx)
--- a/docs/sdk/core/examples/app1.go
+++ b/docs/sdk/core/examples/app1.go
@ -57,6 +57,7 @@ func NewMsgSend(from, to sdk.AccAddress, amt sdk.Coins) MsgSend {

 // Implements Msg.
 func (msg MsgSend) Type() string { return "send" }
+func (msg MsgSend) Name() string { return "send" }

 // Implements Msg. Ensure the addresses are good and the
 // amount is positive.
--- a/docs/sdk/core/examples/app2.go
+++ b/docs/sdk/core/examples/app2.go
@ -13,8 +13,8 @@ import (
 	"github.com/tendermint/tendermint/libs/log"

 	bapp "github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 )

 const (
@ -25,8 +25,8 @@ var (
 	issuer = ed25519.GenPrivKey().PubKey().Address()
 )

-func NewCodec() *wire.Codec {
-	cdc := wire.NewCodec()
+func NewCodec() *codec.Codec {
+	cdc := codec.New()
 	cdc.RegisterInterface((*sdk.Msg)(nil), nil)
 	cdc.RegisterConcrete(MsgSend{}, "example/MsgSend", nil)
 	cdc.RegisterConcrete(MsgIssue{}, "example/MsgIssue", nil)
@ -77,6 +77,7 @@ type MsgIssue struct {

 // Implements Msg.
 func (msg MsgIssue) Type() string { return "issue" }
+func (msg MsgIssue) Name() string { return "issue" }

 // Implements Msg. Ensures addresses are valid and Coin is positive
 func (msg MsgIssue) ValidateBasic() sdk.Error {
@ -196,7 +197,7 @@ func (tx app2Tx) GetSignature() []byte {
 }

 // Amino decode app2Tx. Capable of decoding both MsgSend and MsgIssue
-func tx2Decoder(cdc *wire.Codec) sdk.TxDecoder {
+func tx2Decoder(cdc *codec.Codec) sdk.TxDecoder {
 	return func(txBytes []byte) (sdk.Tx, sdk.Error) {
 		var tx app2Tx
 		err := cdc.UnmarshalBinary(txBytes, &tx)
--- a/docs/sdk/core/examples/app3.go
+++ b/docs/sdk/core/examples/app3.go
@ -7,8 +7,8 @@ import (
 	"github.com/tendermint/tendermint/libs/log"

 	bapp "github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 )
@ -51,12 +51,12 @@ func NewApp3(logger log.Logger, db dbm.DB) *bapp.BaseApp {
 }

 // Update codec from app2 to register imported modules
-func UpdatedCodec() *wire.Codec {
-	cdc := wire.NewCodec()
+func UpdatedCodec() *codec.Codec {
+	cdc := codec.New()
 	cdc.RegisterInterface((*sdk.Msg)(nil), nil)
 	cdc.RegisterConcrete(MsgSend{}, "example/MsgSend", nil)
 	cdc.RegisterConcrete(MsgIssue{}, "example/MsgIssue", nil)
-	auth.RegisterWire(cdc)
+	auth.RegisterCodec(cdc)
 	cryptoAmino.RegisterAmino(cdc)
 	return cdc
 }
--- a/docs/sdk/core/examples/app4.go
+++ b/docs/sdk/core/examples/app4.go
@ -7,8 +7,8 @@ import (
 	"github.com/tendermint/tendermint/libs/log"

 	bapp "github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 )
@ -76,7 +76,7 @@ func (ga *GenesisAccount) ToAccount() (acc *auth.BaseAccount, err error) {

 // InitChainer will set initial balances for accounts as well as initial coin metadata
 // MsgIssue can no longer be used to create new coin
-func NewInitChainer(cdc *wire.Codec, accountMapper auth.AccountMapper) sdk.InitChainer {
+func NewInitChainer(cdc *codec.Codec, accountMapper auth.AccountMapper) sdk.InitChainer {
 	return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
 		stateJSON := req.AppStateBytes

--- a/docs/sdk/sdk-by-examples/simple-governance/app-codec.md
+++ b/docs/sdk/sdk-by-examples/simple-governance/app-codec.md
@ -5,13 +5,13 @@
 Finally, we need to define the `MakeCodec()` function and register the concrete types and interface from the various modules.

 ```go
-func MakeCodec() *wire.Codec {
-    var cdc = wire.NewCodec()
-    wire.RegisterCrypto(cdc) // Register crypto.
-    sdk.RegisterWire(cdc)    // Register Msgs
-    bank.RegisterWire(cdc)
-    simplestake.RegisterWire(cdc)
-    simpleGov.RegisterWire(cdc)
+func MakeCodec() *codec.Codec {
+    var cdc = codec.New()
+    codec.RegisterCrypto(cdc) // Register crypto.
+    sdk.RegisterCodec(cdc)    // Register Msgs
+    bank.RegisterCodec(cdc)
+    simplestake.RegisterCodec(cdc)
+    simpleGov.RegisterCodec(cdc)

    // Register AppAccount
    cdc.RegisterInterface((*auth.Account)(nil), nil)
--- a/docs/sdk/sdk-by-examples/simple-governance/app-rest.md
+++ b/docs/sdk/sdk-by-examples/simple-governance/app-rest.md
@ -13,7 +13,7 @@ var SimpleGovAppInit = server.AppInit{
 }

 // SimpleGovAppGenState sets up the app_state and appends the simpleGov app state
-func SimpleGovAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error) {
+func SimpleGovAppGenState(cdc *codec.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error) {
 	appState, err = server.SimpleAppGenState(cdc, appGenTxs)
 	if err != nil {
 		return
--- a/docs/sdk/sdk-by-examples/simple-governance/app-structure.md
+++ b/docs/sdk/sdk-by-examples/simple-governance/app-structure.md
@ -28,7 +28,7 @@ Then, let us define the structure of our application.
 // Extended ABCI application
 type SimpleGovApp struct {
    *bam.BaseApp
-    cdc *wire.Codec
+    cdc *codec.Codec

    // keys to access the substores
    capKeyMainStore      *sdk.KVStoreKey
--- a/docs/sdk/sdk-by-examples/simple-governance/intro.md
+++ b/docs/sdk/sdk-by-examples/simple-governance/intro.md
@ -28,7 +28,7 @@ Before getting in the bulk of the code, we will start by some introductory conte
    + [Types](module-types.md)
    + [Keeper](module-keeper.md)
    + [Handler](module-handler.md)
-    + [Wire](module-wire.md)
+    + [Wire](module-codec.md)
    + [Errors](module-errors.md)
    + Command-Line Interface and Rest API
        * [Command-Line Interface](module-cli.md)
--- a/docs/sdk/sdk-by-examples/simple-governance/module-cli.md
+++ b/docs/sdk/sdk-by-examples/simple-governance/module-cli.md
@ -14,7 +14,7 @@ The CLI builds on top of [Cobra](https://github.com/spf13/cobra). Here is the sc
    )

    // Main command function. One function for each command.
-    func Command(codec *wire.Codec) *cobra.Command {
+    func Command(codec *codec.Codec) *cobra.Command {
        // Create the command to return
        command := &cobra.Command{
            Use: "actual command",
--- a/docs/sdk/sdk-by-examples/simple-governance/module-codec.md
+++ b/docs/sdk/sdk-by-examples/simple-governance/module-codec.md
@ -0,0 +1,13 @@
+## Codec
+
+**File: [`x/simple_governance/codec.go`](https://github.com/cosmos/cosmos-sdk/blob/fedekunze/module_tutorial/examples/simpleGov/x/simple_governance/codec.go)**
+
+The `codec.go` file allows developers to register the concrete message types of their module into the codec. In our case, we have two messages to declare:
+
+```go
+func RegisterCodec(cdc *codec.Codec) {
+    cdc.RegisterConcrete(SubmitProposalMsg{}, "simple_governance/SubmitProposalMsg", nil)
+    cdc.RegisterConcrete(VoteMsg{}, "simple_governance/VoteMsg", nil)
+}
+```
+Don't forget to call this function in `app.go` (see [Application - Bridging it all together](app-structure.md)) for more).
--- a/docs/sdk/sdk-by-examples/simple-governance/module-init.md
+++ b/docs/sdk/sdk-by-examples/simple-governance/module-init.md
@ -7,7 +7,7 @@ cd x/
 mkdir simple_governance
 cd simple_governance
 mkdir -p client/cli client/rest
-touch client/cli/simple_governance.go client/rest/simple_governance.go errors.go handler.go handler_test.go keeper_keys.go keeper_test.go keeper.go test_common.go test_types.go types.go wire.go
+touch client/cli/simple_governance.go client/rest/simple_governance.go errors.go handler.go handler_test.go keeper_keys.go keeper_test.go keeper.go test_common.go test_types.go types.go codec.go
 ```

 Let us start by adding the files we will need. Your module's folder should look something like that:
@ -25,7 +25,7 @@ x
      ├─── keeper_keys.go
      ├─── keeper.go
      ├─── types.go
-      └─── wire.go
+      └─── codec.go
 ```

 Let us go into the detail of each of these files.
--- a/docs/sdk/sdk-by-examples/simple-governance/module-keeper.md
+++ b/docs/sdk/sdk-by-examples/simple-governance/module-keeper.md
@ -47,7 +47,7 @@ With all that in mind, we can define the structure of our `Keeper`:
 ```go
    type Keeper struct {
        SimpleGov    sdk.StoreKey        // Key to our module's store
-        cdc                 *wire.Codec         // Codec to encore/decode structs
+        cdc                 *codec.Codec         // Codec to encore/decode structs
        ck                  bank.Keeper         // Needed to handle deposits. This module onlyl requires read/writes to Atom balance
        sm                  stake.Keeper        // Needed to compute voting power. This module only needs read access to the staking store.
        codespace           sdk.CodespaceType   // Reserves space for error codes
--- a/docs/sdk/sdk-by-examples/simple-governance/module-wire.md
+++ b/docs/sdk/sdk-by-examples/simple-governance/module-wire.md
@ -1,13 +0,0 @@
-## Wire 
-
-**File: [`x/simple_governance/wire.go`](https://github.com/cosmos/cosmos-sdk/blob/fedekunze/module_tutorial/examples/simpleGov/x/simple_governance/wire.go)**
-
-The `wire.go` file allows developers to register the concrete message types of their module into the codec. In our case, we have two messages to declare:
-
-```go
-func RegisterWire(cdc *wire.Codec) {
-    cdc.RegisterConcrete(SubmitProposalMsg{}, "simple_governance/SubmitProposalMsg", nil)
-    cdc.RegisterConcrete(VoteMsg{}, "simple_governance/VoteMsg", nil)
-}
-```
-Don't forget to call this function in `app.go` (see [Application - Bridging it all together](app-structure.md)) for more).
--- a/docs/spec/ibc/appendices.md
+++ b/docs/spec/ibc/appendices.md
@ -8,7 +8,7 @@ The specification has focused on semantics and functionality of the IBC protocol

 In defining a standard binary encoding for all the "universal" components, we wish to make use of a standardized library, with efficient serialization and support in multiple languages. We considered two main formats: Ethereum's RLP[[6](./references.md#6)] and Google's Protobuf[[7](./references.md#7)]. We decided for protobuf, as it is more widely supported, is more expressive for different data types, and supports code generation for very efficient (de)serialization codecs. It does have a learning curve and more setup to generate the code from the type specifications, but the ibc data types should not change often and this code generation setup only needs to happen once per language (and can be exposed in a common repo), so this is not a strong counter-argument. Efficiency, expressiveness, and wider support rule in its favor. It is also widely used in gRPC and in many microservice architectures.

-The tendermint-specific data structures are encoded with go-wire[[8](./references.md#8)], the native binary encoding used inside of tendermint. Most blockchains define their own formats, and until some universal format for headers and signatures among blockchains emerge, it seems very premature to enforce any encoding here. These are defined as arbitrary byte slices in the protocol, to be parsed in an consensus engine-dependent manner.
+The tendermint-specific data structures are encoded with go-amino[[8](./references.md#8)], the native binary encoding used inside of tendermint. Most blockchains define their own formats, and until some universal format for headers and signatures among blockchains emerge, it seems very premature to enforce any encoding here. These are defined as arbitrary byte slices in the protocol, to be parsed in an consensus engine-dependent manner.

 For the following appendixes, the data structure specifications will be in proto3[[9](./references.md#9)] format.

@ -61,7 +61,7 @@ The IBC protocol does not handle these kinds of errors. They must be handled ind

 **TODO: clean this all up**

-This is a mess now, we need to figure out what formats we use, define go-wire, etc. or just point to the source???? Will do more later, need help here from the tendermint core team.
+This is a mess now, we need to figure out what formats we use, define go-amino, etc. or just point to the source???? Will do more later, need help here from the tendermint core team.

 In order to prove a merkle root, we must fully define the headers, signatures, and validator information returned from the Tendermint consensus engine, as well as the rules by which to verify a header. We also define here the messages used for creating and removing connections to other blockchains as well as how to handle forks.

--- a/docs/spec/ibc/channels-and-packets.md
+++ b/docs/spec/ibc/channels-and-packets.md
@ -28,7 +28,7 @@ Every transaction on the same chain already has a well-defined causality relatio

 For example, an application may wish to allow a single tokenized asset to be transferred between and held on multiple blockchains while preserving fungibility and conservation of supply. The application can mint asset vouchers on chain `B` when a particular IBC packet is committed to chain `B`, and require outgoing sends of that packet on chain `A` to escrow an equal amount of the asset on chain `A` until the vouchers are later redeemed back to chain `A` with an IBC packet in the reverse direction. This ordering guarantee along with correct application logic can ensure that total supply is preserved across both chains and that any vouchers minted on chain `B` can later be redeemed back to chain `A`.

-This section provides definitions for packets and channels, a high-level specification of the queue interface, and a list of the necessary proofs. To implement wire-compatible IBC, chain `A` and chain `B` must also use a common encoding format. An example binary encoding format can be found in [Appendix C](appendices.md#appendix-c-merkle-proof-formats).
+This section provides definitions for packets and channels, a high-level specification of the queue interface, and a list of the necessary proofs. To implement amino-compatible IBC, chain `A` and chain `B` must also use a common encoding format. An example binary encoding format can be found in [Appendix C](appendices.md#appendix-c-merkle-proof-formats).

 ### 3.2 Definitions

--- a/docs/spec/ibc/conclusion.md
+++ b/docs/spec/ibc/conclusion.md
@ -6,4 +6,4 @@ We have demonstrated a secure, performant, and flexible protocol for cross-block

 This document defines solely a message queue protocol - not the application-level semantics which must sit on top of it to enable asset transfer between two chains. We will shortly release a separate paper on Cosmos IBC that defines the application logic used for direct value transfer as well as routing over the Cosmos hub. That paper builds upon the IBC protocol defined here and provides a first example of how to reason about application logic and global invariants in the context of IBC.

-There is a reference implementation of the Cosmos IBC protocol as part of the Cosmos SDK, written in Golang and released under the Apache license. To facilitate implementations in other langauages which are wire-compatible with the Cosmos implementation, the following appendices define exact message and binary encoding formats.
+There is a reference implementation of the Cosmos IBC protocol as part of the Cosmos SDK, written in Golang and released under the Apache license. To facilitate implementations in other langauages which are amino-compatible with the Cosmos implementation, the following appendices define exact message and binary encoding formats.
--- a/docs/spec/ibc/references.md
+++ b/docs/spec/ibc/references.md
@ -24,7 +24,7 @@
 [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)

 ##### 8:
-[https://github.com/tendermint/go-wire](https://github.com/tendermint/go-wire)
+[https://github.com/tendermint/go-amino](https://github.com/tendermint/go-amino)

 ##### 9:
 [https://developers.google.com/protocol-buffers/docs/proto3](https://developers.google.com/protocol-buffers/docs/proto3)
--- a/docs/spec/staking/transactions.md
+++ b/docs/spec/staking/transactions.md
@ -100,7 +100,7 @@ type TxDelegate struct {

 delegate(tx TxDelegate):
    pool = getPool()
-    if validator.Status == Revoked return
+    if validator.Status == Jailed return

    delegation = getDelegatorBond(DelegatorAddr, ValidatorAddr)
    if delegation == nil then delegation = NewDelegation(DelegatorAddr, ValidatorAddr)
@ -141,7 +141,7 @@ startUnbonding(tx TxStartUnbonding):
 	revokeCandidacy = false
 	if bond.Shares.IsZero() {

-		if bond.DelegatorAddr == validator.Operator && validator.Revoked == false
+		if bond.DelegatorAddr == validator.Operator && validator.Jailed == false
 			revokeCandidacy = true

 		removeDelegation( bond)
@ -157,7 +157,7 @@ startUnbonding(tx TxStartUnbonding):
    setUnbondingDelegation(unbondingDelegation)

 	if revokeCandidacy
-		validator.Revoked = true
+		validator.Jailed = true

 	validator = updateValidator(validator)

@ -279,9 +279,9 @@ updateBondedValidators(newValidator Validator) (updatedVal Validator)
        else
 			validator = getValidator(operatorAddr)

-		// if not previously a validator (and unrevoked),
+		// if not previously a validator (and unjailed),
 		// kick the cliff validator / bond this new validator
-		if validator.Status() != Bonded && !validator.Revoked {
+		if validator.Status() != Bonded && !validator.Jailed {
 			kickCliffValidator = true

 			validator = bondValidator(ctx, store, validator)
--- a/examples/basecoin/app/app.go
+++ b/examples/basecoin/app/app.go
@ -4,9 +4,9 @@ import (
 	"encoding/json"

 	bam "github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/examples/basecoin/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/ibc"
@ -27,7 +27,7 @@ const (
 // integral app types.
 type BasecoinApp struct {
 	*bam.BaseApp
-	cdc *wire.Codec
+	cdc *codec.Codec

 	// keys to access the multistore
 	keyMain    *sdk.KVStoreKey
@ -93,16 +93,16 @@ func NewBasecoinApp(logger log.Logger, db dbm.DB, baseAppOptions ...func(*bam.Ba
 	return app
 }

-// MakeCodec creates a new wire codec and registers all the necessary types
+// MakeCodec creates a new codec codec and registers all the necessary types
 // with the codec.
-func MakeCodec() *wire.Codec {
-	cdc := wire.NewCodec()
+func MakeCodec() *codec.Codec {
+	cdc := codec.New()

-	wire.RegisterCrypto(cdc)
-	sdk.RegisterWire(cdc)
-	bank.RegisterWire(cdc)
-	ibc.RegisterWire(cdc)
-	auth.RegisterWire(cdc)
+	codec.RegisterCrypto(cdc)
+	sdk.RegisterCodec(cdc)
+	bank.RegisterCodec(cdc)
+	ibc.RegisterCodec(cdc)
+	auth.RegisterCodec(cdc)

 	// register custom type
 	cdc.RegisterConcrete(&types.AppAccount{}, "basecoin/Account", nil)
@ -173,7 +173,7 @@ func (app *BasecoinApp) ExportAppStateAndValidators() (appState json.RawMessage,
 	app.accountMapper.IterateAccounts(ctx, appendAccountsFn)

 	genState := types.GenesisState{Accounts: accounts}
-	appState, err = wire.MarshalJSONIndent(app.cdc, genState)
+	appState, err = codec.MarshalJSONIndent(app.cdc, genState)
 	if err != nil {
 		return nil, nil, err
 	}
--- a/examples/basecoin/app/app_test.go
+++ b/examples/basecoin/app/app_test.go
@ -4,9 +4,9 @@ import (
 	"os"
 	"testing"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/examples/basecoin/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/stretchr/testify/require"
 	abci "github.com/tendermint/tendermint/abci/types"
@ -22,7 +22,7 @@ func setGenesis(baseApp *BasecoinApp, accounts ...*types.AppAccount) (types.Gene
 	}

 	genesisState := types.GenesisState{Accounts: genAccts}
-	stateBytes, err := wire.MarshalJSONIndent(baseApp.cdc, genesisState)
+	stateBytes, err := codec.MarshalJSONIndent(baseApp.cdc, genesisState)
 	if err != nil {
 		return types.GenesisState{}, err
 	}
@ -67,7 +67,7 @@ func TestGenesis(t *testing.T) {
 	// reload app and ensure the account is still there
 	baseApp = NewBasecoinApp(logger, db)

-	stateBytes, err := wire.MarshalJSONIndent(baseApp.cdc, genState)
+	stateBytes, err := codec.MarshalJSONIndent(baseApp.cdc, genState)
 	require.Nil(t, err)

 	// initialize the chain with the expected genesis state
--- a/examples/basecoin/types/account.go
+++ b/examples/basecoin/types/account.go
@ -1,8 +1,8 @@
 package types

 import (
+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 )

@ -30,7 +30,7 @@ func NewAppAccount(name string, baseAcct auth.BaseAccount) *AppAccount {

 // GetAccountDecoder returns the AccountDecoder function for the custom
 // AppAccount.
-func GetAccountDecoder(cdc *wire.Codec) auth.AccountDecoder {
+func GetAccountDecoder(cdc *codec.Codec) auth.AccountDecoder {
 	return func(accBytes []byte) (auth.Account, error) {
 		if len(accBytes) == 0 {
 			return nil, sdk.ErrTxDecode("accBytes are empty")
--- a/examples/democoin/app/app.go
+++ b/examples/democoin/app/app.go
@ -10,8 +10,8 @@ import (
 	tmtypes "github.com/tendermint/tendermint/types"

 	bam "github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/ibc"
@ -30,7 +30,7 @@ const (
 // Extended ABCI application
 type DemocoinApp struct {
 	*bam.BaseApp
-	cdc *wire.Codec
+	cdc *codec.Codec

 	// keys to access the substores
 	capKeyMainStore    *sdk.KVStoreKey
@ -103,15 +103,15 @@ func NewDemocoinApp(logger log.Logger, db dbm.DB) *DemocoinApp {
 }

 // custom tx codec
-func MakeCodec() *wire.Codec {
-	var cdc = wire.NewCodec()
-	wire.RegisterCrypto(cdc) // Register crypto.
-	sdk.RegisterWire(cdc)    // Register Msgs
-	cool.RegisterWire(cdc)
-	pow.RegisterWire(cdc)
-	bank.RegisterWire(cdc)
-	ibc.RegisterWire(cdc)
-	simplestake.RegisterWire(cdc)
+func MakeCodec() *codec.Codec {
+	var cdc = codec.New()
+	codec.RegisterCrypto(cdc) // Register crypto.
+	sdk.RegisterCodec(cdc)    // Register Msgs
+	cool.RegisterCodec(cdc)
+	pow.RegisterCodec(cdc)
+	bank.RegisterCodec(cdc)
+	ibc.RegisterCodec(cdc)
+	simplestake.RegisterCodec(cdc)

 	// Register AppAccount
 	cdc.RegisterInterface((*auth.Account)(nil), nil)
@ -182,7 +182,7 @@ func (app *DemocoinApp) ExportAppStateAndValidators() (appState json.RawMessage,
 		POWGenesis:  pow.WriteGenesis(ctx, app.powKeeper),
 		CoolGenesis: cool.WriteGenesis(ctx, app.coolKeeper),
 	}
-	appState, err = wire.MarshalJSONIndent(app.cdc, genState)
+	appState, err = codec.MarshalJSONIndent(app.cdc, genState)
 	if err != nil {
 		return nil, nil, err
 	}
--- a/examples/democoin/app/app_test.go
+++ b/examples/democoin/app/app_test.go
@ -4,10 +4,10 @@ import (
 	"os"
 	"testing"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/examples/democoin/types"
 	"github.com/cosmos/cosmos-sdk/examples/democoin/x/cool"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/stretchr/testify/require"
 	abci "github.com/tendermint/tendermint/abci/types"
@ -27,7 +27,7 @@ func setGenesis(bapp *DemocoinApp, trend string, accs ...auth.BaseAccount) error
 		CoolGenesis: cool.Genesis{trend},
 	}

-	stateBytes, err := wire.MarshalJSONIndent(bapp.cdc, genesisState)
+	stateBytes, err := codec.MarshalJSONIndent(bapp.cdc, genesisState)
 	if err != nil {
 		return err
 	}
--- a/examples/democoin/cmd/democoind/main.go
+++ b/examples/democoin/cmd/democoind/main.go
@ -13,9 +13,9 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	tmtypes "github.com/tendermint/tendermint/types"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/examples/democoin/app"
 	"github.com/cosmos/cosmos-sdk/server"
-	"github.com/cosmos/cosmos-sdk/wire"
 )

 // init parameters
@ -25,7 +25,7 @@ var CoolAppInit = server.AppInit{
 }

 // coolGenAppParams sets up the app_state and appends the cool app state
-func CoolAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error) {
+func CoolAppGenState(cdc *codec.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error) {
 	appState, err = server.SimpleAppGenState(cdc, appGenTxs)
 	if err != nil {
 		return
--- a/examples/democoin/types/account.go
+++ b/examples/democoin/types/account.go
@ -1,8 +1,8 @@
 package types

 import (
+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"

 	"github.com/cosmos/cosmos-sdk/examples/democoin/x/cool"
@ -31,7 +31,7 @@ func (acc AppAccount) GetName() string      { return acc.Name }
 func (acc *AppAccount) SetName(name string) { acc.Name = name }

 // Get the AccountDecoder function for the custom AppAccount
-func GetAccountDecoder(cdc *wire.Codec) auth.AccountDecoder {
+func GetAccountDecoder(cdc *codec.Codec) auth.AccountDecoder {
 	return func(accBytes []byte) (res auth.Account, err error) {
 		if len(accBytes) == 0 {
 			return nil, sdk.ErrTxDecode("accBytes are empty")
--- a/examples/democoin/x/assoc/validator_set.go
+++ b/examples/democoin/x/assoc/validator_set.go
@ -3,8 +3,8 @@ package assoc
 import (
 	"bytes"

+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 )

 // ValidatorSet defines
@ -12,7 +12,7 @@ type ValidatorSet struct {
 	sdk.ValidatorSet

 	store sdk.KVStore
-	cdc   *wire.Codec
+	cdc   *codec.Codec

 	maxAssoc int
 	addrLen  int
@ -21,7 +21,7 @@ type ValidatorSet struct {
 var _ sdk.ValidatorSet = ValidatorSet{}

 // NewValidatorSet returns new ValidatorSet with underlying ValidatorSet
-func NewValidatorSet(cdc *wire.Codec, store sdk.KVStore, valset sdk.ValidatorSet, maxAssoc int, addrLen int) ValidatorSet {
+func NewValidatorSet(cdc *codec.Codec, store sdk.KVStore, valset sdk.ValidatorSet, maxAssoc int, addrLen int) ValidatorSet {
 	if maxAssoc < 0 || addrLen < 0 {
 		panic("Cannot use negative integer for NewValidatorSet")
 	}
--- a/examples/democoin/x/assoc/validator_set_test.go
+++ b/examples/democoin/x/assoc/validator_set_test.go
@ -9,10 +9,10 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	dbm "github.com/tendermint/tendermint/libs/db"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/examples/democoin/mock"
 	"github.com/cosmos/cosmos-sdk/store"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 )

 func defaultContext(key sdk.StoreKey) sdk.Context {
@ -36,7 +36,7 @@ func TestValidatorSet(t *testing.T) {
 		{addr2, sdk.NewDec(2)},
 	}}

-	valset := NewValidatorSet(wire.NewCodec(), ctx.KVStore(key).Prefix([]byte("assoc")), base, 1, 5)
+	valset := NewValidatorSet(codec.New(), ctx.KVStore(key).Prefix([]byte("assoc")), base, 1, 5)

 	require.Equal(t, base.Validator(ctx, addr1), valset.Validator(ctx, addr1))
 	require.Equal(t, base.Validator(ctx, addr2), valset.Validator(ctx, addr2))
--- a/examples/democoin/x/cool/app_test.go
+++ b/examples/democoin/x/cool/app_test.go
@ -47,7 +47,7 @@ var (
 func getMockApp(t *testing.T) *mock.App {
 	mapp := mock.NewApp()

-	RegisterWire(mapp.Cdc)
+	RegisterCodec(mapp.Cdc)
 	keyCool := sdk.NewKVStoreKey("cool")
 	bankKeeper := bank.NewBaseKeeper(mapp.AccountMapper)
 	keeper := NewKeeper(keyCool, bankKeeper, mapp.RegisterCodespace(DefaultCodespace))
--- a/examples/democoin/x/cool/client/cli/tx.go
+++ b/examples/democoin/x/cool/client/cli/tx.go
@ -7,15 +7,15 @@ import (

 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/client/utils"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/examples/democoin/x/cool"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli"
 	authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
 )

 // QuizTxCmd invokes the coolness quiz transaction.
-func QuizTxCmd(cdc *wire.Codec) *cobra.Command {
+func QuizTxCmd(cdc *codec.Codec) *cobra.Command {
 	return &cobra.Command{
 		Use:   "cool [answer]",
 		Short: "What's cooler than being cool?",
@ -40,7 +40,7 @@ func QuizTxCmd(cdc *wire.Codec) *cobra.Command {
 }

 // SetTrendTxCmd sends a new cool trend transaction.
-func SetTrendTxCmd(cdc *wire.Codec) *cobra.Command {
+func SetTrendTxCmd(cdc *codec.Codec) *cobra.Command {
 	return &cobra.Command{
 		Use:   "setcool [answer]",
 		Short: "You're so cool, tell us what is cool!",
--- a/examples/democoin/x/cool/codec.go
+++ b/examples/democoin/x/cool/codec.go
@ -1,11 +1,11 @@
 package cool

 import (
-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 )

-// Register concrete types on wire codec
-func RegisterWire(cdc *wire.Codec) {
+// Register concrete types on codec codec
+func RegisterCodec(cdc *codec.Codec) {
 	cdc.RegisterConcrete(MsgQuiz{}, "cool/Quiz", nil)
 	cdc.RegisterConcrete(MsgSetTrend{}, "cool/SetTrend", nil)
 }
--- a/examples/democoin/x/cool/keeper_test.go
+++ b/examples/democoin/x/cool/keeper_test.go
@ -8,9 +8,9 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	dbm "github.com/tendermint/tendermint/libs/db"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/store"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	auth "github.com/cosmos/cosmos-sdk/x/auth"
 	bank "github.com/cosmos/cosmos-sdk/x/bank"
 )
@ -26,7 +26,7 @@ func setupMultiStore() (sdk.MultiStore, *sdk.KVStoreKey) {

 func TestCoolKeeper(t *testing.T) {
 	ms, capKey := setupMultiStore()
-	cdc := wire.NewCodec()
+	cdc := codec.New()
 	auth.RegisterBaseAccount(cdc)

 	am := auth.NewAccountMapper(cdc, capKey, auth.ProtoBaseAccount)
--- a/examples/democoin/x/cool/types.go
+++ b/examples/democoin/x/cool/types.go
@ -33,6 +33,7 @@ var _ sdk.Msg = MsgSetTrend{}

 // nolint
 func (msg MsgSetTrend) Type() string                 { return "cool" }
+func (msg MsgSetTrend) Name() string                 { return "set_trend" }
 func (msg MsgSetTrend) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Sender} }
 func (msg MsgSetTrend) String() string {
 	return fmt.Sprintf("MsgSetTrend{Sender: %v, Cool: %v}", msg.Sender, msg.Cool)
@ -83,6 +84,7 @@ var _ sdk.Msg = MsgQuiz{}

 // nolint
 func (msg MsgQuiz) Type() string                 { return "cool" }
+func (msg MsgQuiz) Name() string                 { return "quiz" }
 func (msg MsgQuiz) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Sender} }
 func (msg MsgQuiz) String() string {
 	return fmt.Sprintf("MsgQuiz{Sender: %v, CoolAnswer: %v}", msg.Sender, msg.CoolAnswer)
--- a/examples/democoin/x/oracle/README.md
+++ b/examples/democoin/x/oracle/README.md
@ -38,7 +38,7 @@ func NewHandler(keeper Keeper) sdk.Handler {
 In the previous example, the keeper has an `oracle.Keeper`. `oracle.Keeper`s are generated by `NewKeeper`.

 ```go
-func NewKeeper(key sdk.StoreKey, cdc *wire.Codec, valset sdk.ValidatorSet, supermaj sdk.Dec, timeout int64) Keeper {
+func NewKeeper(key sdk.StoreKey, cdc *codec.Codec, valset sdk.ValidatorSet, supermaj sdk.Dec, timeout int64) Keeper {
    return Keeper {
        cdc: cdc,
        key: key,
--- a/examples/democoin/x/oracle/keeper.go
+++ b/examples/democoin/x/oracle/keeper.go
@ -1,7 +1,7 @@
 package oracle

 import (
-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"

 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@ -9,7 +9,7 @@ import (
 // Keeper of the oracle store
 type Keeper struct {
 	key sdk.StoreKey
-	cdc *wire.Codec
+	cdc *codec.Codec

 	valset sdk.ValidatorSet

@ -18,7 +18,7 @@ type Keeper struct {
 }

 // NewKeeper constructs a new keeper
-func NewKeeper(key sdk.StoreKey, cdc *wire.Codec, valset sdk.ValidatorSet, supermaj sdk.Dec, timeout int64) Keeper {
+func NewKeeper(key sdk.StoreKey, cdc *codec.Codec, valset sdk.ValidatorSet, supermaj sdk.Dec, timeout int64) Keeper {
 	if timeout < 0 {
 		panic("Timeout should not be negative")
 	}
--- a/examples/democoin/x/oracle/keeper_keys.go
+++ b/examples/democoin/x/oracle/keeper_keys.go
@ -1,23 +1,23 @@
 package oracle

 import (
+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 )

 // GetInfoKey returns the key for OracleInfo
-func GetInfoKey(p Payload, cdc *wire.Codec) []byte {
+func GetInfoKey(p Payload, cdc *codec.Codec) []byte {
 	bz := cdc.MustMarshalBinary(p)
 	return append([]byte{0x00}, bz...)
 }

 // GetSignPrefix returns the prefix for signs
-func GetSignPrefix(p Payload, cdc *wire.Codec) []byte {
+func GetSignPrefix(p Payload, cdc *codec.Codec) []byte {
 	bz := cdc.MustMarshalBinary(p)
 	return append([]byte{0x01}, bz...)
 }

 // GetSignKey returns the key for sign
-func GetSignKey(p Payload, signer sdk.AccAddress, cdc *wire.Codec) []byte {
+func GetSignKey(p Payload, signer sdk.AccAddress, cdc *codec.Codec) []byte {
 	return append(GetSignPrefix(p, cdc), signer...)
 }
--- a/examples/democoin/x/oracle/oracle_test.go
+++ b/examples/democoin/x/oracle/oracle_test.go
@ -9,10 +9,10 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	dbm "github.com/tendermint/tendermint/libs/db"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/examples/democoin/mock"
 	"github.com/cosmos/cosmos-sdk/store"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 )

 func defaultContext(keys ...sdk.StoreKey) sdk.Context {
@ -34,13 +34,16 @@ type seqOracle struct {
 func (o seqOracle) Type() string {
 	return "seq"
 }
+func (o seqOracle) Name() string {
+	return "seq"
+}

 func (o seqOracle) ValidateBasic() sdk.Error {
 	return nil
 }

-func makeCodec() *wire.Codec {
-	var cdc = wire.NewCodec()
+func makeCodec() *codec.Codec {
+	var cdc = codec.New()

 	cdc.RegisterInterface((*sdk.Msg)(nil), nil)
 	cdc.RegisterConcrete(Msg{}, "test/Oracle", nil)
@ -79,7 +82,7 @@ func getSequence(ctx sdk.Context, key sdk.StoreKey) int {
 	if seqbz == nil {
 		seq = 0
 	} else {
-		wire.NewCodec().MustUnmarshalBinary(seqbz, &seq)
+		codec.New().MustUnmarshalBinary(seqbz, &seq)
 	}

 	return seq
@ -93,7 +96,7 @@ func handleSeqOracle(ctx sdk.Context, key sdk.StoreKey, o seqOracle) sdk.Error {
 		return sdk.NewError(sdk.CodespaceRoot, 1, "")
 	}

-	bz := wire.NewCodec().MustMarshalBinary(seq + 1)
+	bz := codec.New().MustMarshalBinary(seq + 1)
 	store.Set([]byte("seq"), bz)

 	return nil
--- a/examples/democoin/x/oracle/types.go
+++ b/examples/democoin/x/oracle/types.go
@ -29,5 +29,6 @@ func (msg Msg) GetSigners() []sdk.AccAddress {
 // Payload defines inner data for actual execution
 type Payload interface {
 	Type() string
+	Name() string
 	ValidateBasic() sdk.Error
 }
--- a/examples/democoin/x/pow/app_test.go
+++ b/examples/democoin/x/pow/app_test.go
@ -23,7 +23,7 @@ var (
 func getMockApp(t *testing.T) *mock.App {
 	mapp := mock.NewApp()

-	RegisterWire(mapp.Cdc)
+	RegisterCodec(mapp.Cdc)
 	keyPOW := sdk.NewKVStoreKey("pow")
 	bankKeeper := bank.NewBaseKeeper(mapp.AccountMapper)
 	config := Config{"pow", 1}
--- a/examples/democoin/x/pow/client/cli/tx.go
+++ b/examples/democoin/x/pow/client/cli/tx.go
@ -6,9 +6,9 @@ import (

 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/client/utils"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/examples/democoin/x/pow"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli"
 	authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"

@ -16,7 +16,7 @@ import (
 )

 // command to mine some pow!
-func MineCmd(cdc *wire.Codec) *cobra.Command {
+func MineCmd(cdc *codec.Codec) *cobra.Command {
 	return &cobra.Command{
 		Use:   "mine [difficulty] [count] [nonce] [solution]",
 		Short: "Mine some coins with proof-of-work!",
--- a/examples/democoin/x/pow/codec.go
+++ b/examples/democoin/x/pow/codec.go
@ -0,0 +1,10 @@
+package pow
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+)
+
+// Register concrete types on codec codec
+func RegisterCodec(cdc *codec.Codec) {
+	cdc.RegisterConcrete(MsgMine{}, "pow/Mine", nil)
+}
--- a/examples/democoin/x/pow/handler_test.go
+++ b/examples/democoin/x/pow/handler_test.go
@ -8,15 +8,15 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/log"

+	codec "github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	wire "github.com/cosmos/cosmos-sdk/wire"
 	auth "github.com/cosmos/cosmos-sdk/x/auth"
 	bank "github.com/cosmos/cosmos-sdk/x/bank"
 )

 func TestPowHandler(t *testing.T) {
 	ms, capKey := setupMultiStore()
-	cdc := wire.NewCodec()
+	cdc := codec.New()
 	auth.RegisterBaseAccount(cdc)

 	am := auth.NewAccountMapper(cdc, capKey, auth.ProtoBaseAccount)
--- a/examples/democoin/x/pow/keeper_test.go
+++ b/examples/democoin/x/pow/keeper_test.go
@ -9,9 +9,9 @@ import (
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/store"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	auth "github.com/cosmos/cosmos-sdk/x/auth"
 	bank "github.com/cosmos/cosmos-sdk/x/bank"
 )
@ -29,7 +29,7 @@ func setupMultiStore() (sdk.MultiStore, *sdk.KVStoreKey) {

 func TestPowKeeperGetSet(t *testing.T) {
 	ms, capKey := setupMultiStore()
-	cdc := wire.NewCodec()
+	cdc := codec.New()
 	auth.RegisterBaseAccount(cdc)

 	am := auth.NewAccountMapper(cdc, capKey, auth.ProtoBaseAccount)
--- a/examples/democoin/x/pow/types.go
+++ b/examples/democoin/x/pow/types.go
@ -32,6 +32,7 @@ func NewMsgMine(sender sdk.AccAddress, difficulty uint64, count uint64, nonce ui

 // nolint
 func (msg MsgMine) Type() string                 { return "pow" }
+func (msg MsgMine) Name() string                 { return "mine" }
 func (msg MsgMine) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Sender} }
 func (msg MsgMine) String() string {
 	return fmt.Sprintf("MsgMine{Sender: %s, Difficulty: %d, Count: %d, Nonce: %d, Proof: %s}", msg.Sender, msg.Difficulty, msg.Count, msg.Nonce, msg.Proof)
--- a/examples/democoin/x/pow/wire.go
+++ b/examples/democoin/x/pow/wire.go
@ -1,10 +0,0 @@
-package pow
-
-import (
-	"github.com/cosmos/cosmos-sdk/wire"
-)
-
-// Register concrete types on wire codec
-func RegisterWire(cdc *wire.Codec) {
-	cdc.RegisterConcrete(MsgMine{}, "pow/Mine", nil)
-}
--- a/examples/democoin/x/simplestake/client/cli/commands.go
+++ b/examples/democoin/x/simplestake/client/cli/commands.go
@ -7,9 +7,9 @@ import (

 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/client/utils"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/examples/democoin/x/simplestake"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli"
 	authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"

@ -25,7 +25,7 @@ const (
 )

 // simple bond tx
-func BondTxCmd(cdc *wire.Codec) *cobra.Command {
+func BondTxCmd(cdc *codec.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "bond",
 		Short: "Bond to a validator",
@ -79,7 +79,7 @@ func BondTxCmd(cdc *wire.Codec) *cobra.Command {
 }

 // simple unbond tx
-func UnbondTxCmd(cdc *wire.Codec) *cobra.Command {
+func UnbondTxCmd(cdc *codec.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "unbond",
 		Short: "Unbond from a validator",
--- a/examples/democoin/x/simplestake/codec.go
+++ b/examples/democoin/x/simplestake/codec.go
@ -1,11 +1,11 @@
 package simplestake

 import (
-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 )

-// Register concrete types on wire codec
-func RegisterWire(cdc *wire.Codec) {
+// Register concrete types on codec codec
+func RegisterCodec(cdc *codec.Codec) {
 	cdc.RegisterConcrete(MsgBond{}, "simplestake/BondMsg", nil)
 	cdc.RegisterConcrete(MsgUnbond{}, "simplestake/UnbondMsg", nil)
 }
--- a/examples/democoin/x/simplestake/keeper.go
+++ b/examples/democoin/x/simplestake/keeper.go
@ -3,8 +3,8 @@ package simplestake
 import (
 	"github.com/tendermint/tendermint/crypto"

+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 )

@ -17,13 +17,13 @@ type Keeper struct {
 	ck bank.Keeper

 	key       sdk.StoreKey
-	cdc       *wire.Codec
+	cdc       *codec.Codec
 	codespace sdk.CodespaceType
 }

 func NewKeeper(key sdk.StoreKey, bankKeeper bank.Keeper, codespace sdk.CodespaceType) Keeper {
-	cdc := wire.NewCodec()
-	wire.RegisterCrypto(cdc)
+	cdc := codec.New()
+	codec.RegisterCrypto(cdc)
 	return Keeper{
 		key:       key,
 		cdc:       cdc,
--- a/examples/democoin/x/simplestake/keeper_test.go
+++ b/examples/democoin/x/simplestake/keeper_test.go
@ -12,9 +12,9 @@ import (
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/store"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 )
@ -32,7 +32,7 @@ func setupMultiStore() (sdk.MultiStore, *sdk.KVStoreKey, *sdk.KVStoreKey) {

 func TestKeeperGetSet(t *testing.T) {
 	ms, authKey, capKey := setupMultiStore()
-	cdc := wire.NewCodec()
+	cdc := codec.New()
 	auth.RegisterBaseAccount(cdc)

 	accountMapper := auth.NewAccountMapper(cdc, authKey, auth.ProtoBaseAccount)
@ -60,7 +60,7 @@ func TestKeeperGetSet(t *testing.T) {

 func TestBonding(t *testing.T) {
 	ms, authKey, capKey := setupMultiStore()
-	cdc := wire.NewCodec()
+	cdc := codec.New()
 	auth.RegisterBaseAccount(cdc)

 	ctx := sdk.NewContext(ms, abci.Header{}, false, log.NewNopLogger())
--- a/examples/democoin/x/simplestake/msgs.go
+++ b/examples/democoin/x/simplestake/msgs.go
@ -27,6 +27,7 @@ func NewMsgBond(addr sdk.AccAddress, stake sdk.Coin, pubKey crypto.PubKey) MsgBo

 //nolint
 func (msg MsgBond) Type() string                 { return moduleName } //TODO update "stake/createvalidator"
+func (msg MsgBond) Name() string                 { return "bond" }
 func (msg MsgBond) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Address} }

 // basic validation of the bond message
@ -66,6 +67,7 @@ func NewMsgUnbond(addr sdk.AccAddress) MsgUnbond {

 //nolint
 func (msg MsgUnbond) Type() string                 { return moduleName } //TODO update "stake/createvalidator"
+func (msg MsgUnbond) Name() string                 { return "unbond" }
 func (msg MsgUnbond) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Address} }
 func (msg MsgUnbond) ValidateBasic() sdk.Error     { return nil }

--- a/examples/kvstore/kvstore
+++ b/examples/kvstore/kvstore
--- a/examples/kvstore/tx.go
+++ b/examples/kvstore/tx.go
@ -18,6 +18,10 @@ func (tx kvstoreTx) Type() string {
 	return "kvstore"
 }

+func (tx kvstoreTx) Name() string {
+	return "kvstore"
+}
+
 func (tx kvstoreTx) GetMsgs() []sdk.Msg {
 	return []sdk.Msg{tx}
 }
--- a/server/export.go
+++ b/server/export.go
@ -7,14 +7,14 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"

-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 	tmtypes "github.com/tendermint/tendermint/types"
 	"io/ioutil"
 	"path"
 )

 // ExportCmd dumps app state to JSON.
-func ExportCmd(ctx *Context, cdc *wire.Codec, appExporter AppExporter) *cobra.Command {
+func ExportCmd(ctx *Context, cdc *codec.Codec, appExporter AppExporter) *cobra.Command {
 	return &cobra.Command{
 		Use:   "export",
 		Short: "Export state to JSON",
@ -50,7 +50,7 @@ func ExportCmd(ctx *Context, cdc *wire.Codec, appExporter AppExporter) *cobra.Co
 			doc.AppState = appState
 			doc.Validators = validators

-			encoded, err := wire.MarshalJSONIndent(cdc, doc)
+			encoded, err := codec.MarshalJSONIndent(cdc, doc)
 			if err != nil {
 				return err
 			}
--- a/server/export_test.go
+++ b/server/export_test.go
@ -2,8 +2,8 @@ package server

 import (
 	"bytes"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/server/mock"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/stretchr/testify/require"
 	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
 	"github.com/tendermint/tendermint/libs/log"
@ -18,7 +18,7 @@ func TestEmptyState(t *testing.T) {
 	cfg, err := tcmd.ParseConfig()
 	require.Nil(t, err)
 	ctx := NewContext(cfg, logger)
-	cdc := wire.NewCodec()
+	cdc := codec.New()
 	appInit := AppInit{
 		AppGenTx:    mock.AppGenTx,
 		AppGenState: mock.AppGenStateEmpty,
--- a/server/init.go
+++ b/server/init.go
@ -26,9 +26,9 @@ import (
 	tmtypes "github.com/tendermint/tendermint/types"

 	clkeys "github.com/cosmos/cosmos-sdk/client/keys"
+	"github.com/cosmos/cosmos-sdk/codec"
 	serverconfig "github.com/cosmos/cosmos-sdk/server/config"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 )

 //Parameter names, for init gen-tx command
@ -63,7 +63,7 @@ type InitConfig struct {
 }

 // get cmd to initialize all files for tendermint and application
-func GenTxCmd(ctx *Context, cdc *wire.Codec, appInit AppInit) *cobra.Command {
+func GenTxCmd(ctx *Context, cdc *codec.Codec, appInit AppInit) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "gen-tx",
 		Short: "Create genesis transaction file (under [--home]/config/gentx/gentx-[nodeID].json)",
@ -99,7 +99,7 @@ func GenTxCmd(ctx *Context, cdc *wire.Codec, appInit AppInit) *cobra.Command {
 				cliPrint,
 				genTxFile,
 			}
-			out, err := wire.MarshalJSONIndent(cdc, toPrint)
+			out, err := codec.MarshalJSONIndent(cdc, toPrint)
 			if err != nil {
 				return err
 			}
@ -112,7 +112,7 @@ func GenTxCmd(ctx *Context, cdc *wire.Codec, appInit AppInit) *cobra.Command {
 	return cmd
 }

-func gentxWithConfig(cdc *wire.Codec, appInit AppInit, config *cfg.Config, genTxConfig serverconfig.GenTx) (
+func gentxWithConfig(cdc *codec.Codec, appInit AppInit, config *cfg.Config, genTxConfig serverconfig.GenTx) (
 	cliPrint json.RawMessage, genTxFile json.RawMessage, err error) {
 	nodeKey, err := p2p.LoadOrGenNodeKey(config.NodeKeyFile())
 	if err != nil {
@ -132,7 +132,7 @@ func gentxWithConfig(cdc *wire.Codec, appInit AppInit, config *cfg.Config, genTx
 		Validator: validator,
 		AppGenTx:  appGenTx,
 	}
-	bz, err := wire.MarshalJSONIndent(cdc, tx)
+	bz, err := codec.MarshalJSONIndent(cdc, tx)
 	if err != nil {
 		return
 	}
@ -158,7 +158,7 @@ func gentxWithConfig(cdc *wire.Codec, appInit AppInit, config *cfg.Config, genTx
 }

 // get cmd to initialize all files for tendermint and application
-func InitCmd(ctx *Context, cdc *wire.Codec, appInit AppInit) *cobra.Command {
+func InitCmd(ctx *Context, cdc *codec.Codec, appInit AppInit) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "init",
 		Short: "Initialize genesis config, priv-validator file, and p2p-node file",
@ -188,7 +188,7 @@ func InitCmd(ctx *Context, cdc *wire.Codec, appInit AppInit) *cobra.Command {
 				nodeID,
 				appMessage,
 			}
-			out, err := wire.MarshalJSONIndent(cdc, toPrint)
+			out, err := codec.MarshalJSONIndent(cdc, toPrint)
 			if err != nil {
 				return err
 			}
@ -205,7 +205,7 @@ func InitCmd(ctx *Context, cdc *wire.Codec, appInit AppInit) *cobra.Command {
 	return cmd
 }

-func initWithConfig(cdc *wire.Codec, appInit AppInit, config *cfg.Config, initConfig InitConfig) (
+func initWithConfig(cdc *codec.Codec, appInit AppInit, config *cfg.Config, initConfig InitConfig) (
 	chainID string, nodeID string, appMessage json.RawMessage, err error) {
 	nodeKey, err := p2p.LoadOrGenNodeKey(config.NodeKeyFile())
 	if err != nil {
@ -273,7 +273,7 @@ func initWithConfig(cdc *wire.Codec, appInit AppInit, config *cfg.Config, initCo
 }

 // append a genesis-piece
-func processGenTxs(genTxsDir string, cdc *wire.Codec) (
+func processGenTxs(genTxsDir string, cdc *codec.Codec) (
 	validators []tmtypes.GenesisValidator, appGenTxs []json.RawMessage, persistentPeers string, err error) {

 	var fos []os.FileInfo
@ -345,7 +345,7 @@ func readOrCreatePrivValidator(tmConfig *cfg.Config) crypto.PubKey {
 // writeGenesisFile creates and writes the genesis configuration to disk. An
 // error is returned if building or writing the configuration to file fails.
 // nolint: unparam
-func writeGenesisFile(cdc *wire.Codec, genesisFile, chainID string, validators []tmtypes.GenesisValidator, appState json.RawMessage) error {
+func writeGenesisFile(cdc *codec.Codec, genesisFile, chainID string, validators []tmtypes.GenesisValidator, appState json.RawMessage) error {
 	genDoc := tmtypes.GenesisDoc{
 		ChainID:    chainID,
 		Validators: validators,
@ -369,12 +369,12 @@ type AppInit struct {
 	FlagsAppGenTx    *pflag.FlagSet

 	// create the application genesis tx
-	AppGenTx func(cdc *wire.Codec, pk crypto.PubKey, genTxConfig serverconfig.GenTx) (
+	AppGenTx func(cdc *codec.Codec, pk crypto.PubKey, genTxConfig serverconfig.GenTx) (
 		appGenTx, cliPrint json.RawMessage, validator tmtypes.GenesisValidator, err error)

 	// AppGenState creates the core parameters initialization. It takes in a
 	// pubkey meant to represent the pubkey of the validator of this machine.
-	AppGenState func(cdc *wire.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error)
+	AppGenState func(cdc *codec.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error)
 }

 //_____________________________________________________________________
@ -391,7 +391,7 @@ type SimpleGenTx struct {
 }

 // Generate a genesis transaction
-func SimpleAppGenTx(cdc *wire.Codec, pk crypto.PubKey, genTxConfig serverconfig.GenTx) (
+func SimpleAppGenTx(cdc *codec.Codec, pk crypto.PubKey, genTxConfig serverconfig.GenTx) (
 	appGenTx, cliPrint json.RawMessage, validator tmtypes.GenesisValidator, err error) {

 	var addr sdk.AccAddress
@ -424,7 +424,7 @@ func SimpleAppGenTx(cdc *wire.Codec, pk crypto.PubKey, genTxConfig serverconfig.
 }

 // create the genesis app state
-func SimpleAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error) {
+func SimpleAppGenState(cdc *codec.Codec, appGenTxs []json.RawMessage) (appState json.RawMessage, err error) {

 	if len(appGenTxs) != 1 {
 		err = errors.New("must provide a single genesis transaction")
--- a/server/init_test.go
+++ b/server/init_test.go
@ -7,8 +7,8 @@ import (

 	"github.com/tendermint/tendermint/libs/log"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/server/mock"
-	"github.com/cosmos/cosmos-sdk/wire"
 	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
 )

@ -20,7 +20,7 @@ func TestInitCmd(t *testing.T) {
 	cfg, err := tcmd.ParseConfig()
 	require.Nil(t, err)
 	ctx := NewContext(cfg, logger)
-	cdc := wire.NewCodec()
+	cdc := codec.New()
 	appInit := AppInit{
 		AppGenState: mock.AppGenState,
 		AppGenTx:    mock.AppGenTx,
--- a/server/mock/app.go
+++ b/server/mock/app.go
@ -12,9 +12,9 @@ import (
 	tmtypes "github.com/tendermint/tendermint/types"

 	bam "github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/codec"
 	gc "github.com/cosmos/cosmos-sdk/server/config"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/wire"
 )

 // NewApp creates a simple mock kvstore app for testing. It should work
@ -105,7 +105,7 @@ func InitChainer(key sdk.StoreKey) func(sdk.Context, abci.RequestInitChain) abci

 // AppGenState can be passed into InitCmd, returns a static string of a few
 // key-values that can be parsed by InitChainer
-func AppGenState(_ *wire.Codec, _ []json.RawMessage) (appState json.RawMessage, err error) {
+func AppGenState(_ *codec.Codec, _ []json.RawMessage) (appState json.RawMessage, err error) {
 	appState = json.RawMessage(`{
  "values": [
    {
@ -122,13 +122,13 @@ func AppGenState(_ *wire.Codec, _ []json.RawMessage) (appState json.RawMessage,
 }

 // AppGenStateEmpty returns an empty transaction state for mocking.
-func AppGenStateEmpty(_ *wire.Codec, _ []json.RawMessage) (appState json.RawMessage, err error) {
+func AppGenStateEmpty(_ *codec.Codec, _ []json.RawMessage) (appState json.RawMessage, err error) {
 	appState = json.RawMessage(``)
 	return
 }

 // Return a validator, not much else
-func AppGenTx(_ *wire.Codec, pk crypto.PubKey, genTxConfig gc.GenTx) (
+func AppGenTx(_ *codec.Codec, pk crypto.PubKey, genTxConfig gc.GenTx) (
 	appGenTx, cliPrint json.RawMessage, validator tmtypes.GenesisValidator, err error) {

 	validator = tmtypes.GenesisValidator{
--- a/server/mock/tx.go
+++ b/server/mock/tx.go
@ -31,6 +31,10 @@ func (tx kvstoreTx) Type() string {
 	return "kvstore"
 }

+func (tx kvstoreTx) Name() string {
+	return "kvstore_tx"
+}
+
 func (tx kvstoreTx) GetMsgs() []sdk.Msg {
 	return []sdk.Msg{tx}
 }
--- a/server/start_test.go
+++ b/server/start_test.go
@ -8,8 +8,8 @@ import (

 	"github.com/stretchr/testify/require"

+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/server/mock"
-	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/tendermint/tendermint/abci/server"
 	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
 	"github.com/tendermint/tendermint/libs/log"
@ -26,7 +26,7 @@ func TestStartStandAlone(t *testing.T) {
 	cfg, err := tcmd.ParseConfig()
 	require.Nil(t, err)
 	ctx := NewContext(cfg, logger)
-	cdc := wire.NewCodec()
+	cdc := codec.New()
 	appInit := AppInit{
 		AppGenState: mock.AppGenState,
 		AppGenTx:    mock.AppGenTx,
--- a/server/testnet.go
+++ b/server/testnet.go
@ -11,7 +11,7 @@ import (

 	"os"

-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/spf13/viper"
 	cfg "github.com/tendermint/tendermint/config"
 	cmn "github.com/tendermint/tendermint/libs/common"
@ -30,7 +30,7 @@ var (
 const nodeDirPerm = 0755

 // get cmd to initialize all files for tendermint testnet and application
-func TestnetFilesCmd(ctx *Context, cdc *wire.Codec, appInit AppInit) *cobra.Command {
+func TestnetFilesCmd(ctx *Context, cdc *codec.Codec, appInit AppInit) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "testnet",
 		Short: "Initialize files for a Gaiad testnet",
@ -65,7 +65,7 @@ Example:
 	return cmd
 }

-func testnetWithConfig(config *cfg.Config, cdc *wire.Codec, appInit AppInit) error {
+func testnetWithConfig(config *cfg.Config, cdc *codec.Codec, appInit AppInit) error {
 	outDir := viper.GetString(outputDir)
 	numValidators := viper.GetInt(nValidators)

--- a/server/tm_cmds.go
+++ b/server/tm_cmds.go
@ -3,7 +3,7 @@ package server
 import (
 	"fmt"

-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"

@ -83,8 +83,8 @@ func ShowAddressCmd(ctx *Context) *cobra.Command {
 }

 func printlnJSON(v interface{}) error {
-	cdc := wire.NewCodec()
-	wire.RegisterCrypto(cdc)
+	cdc := codec.New()
+	codec.RegisterCrypto(cdc)
 	marshalled, err := cdc.MarshalJSON(v)
 	if err != nil {
 		return err
--- a/server/util.go
+++ b/server/util.go
@ -11,8 +11,8 @@ import (
 	"github.com/spf13/viper"

 	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/version"
-	"github.com/cosmos/cosmos-sdk/wire"
 	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/cli"
@ -110,7 +110,7 @@ func validateConfig(conf *cfg.Config) error {

 // add server commands
 func AddCommands(
-	ctx *Context, cdc *wire.Codec,
+	ctx *Context, cdc *codec.Codec,
 	rootCmd *cobra.Command, appInit AppInit,
 	appCreator AppCreator, appExport AppExporter) {

@ -147,7 +147,7 @@ func AddCommands(
 //
 // NOTE: The ordering of the keys returned as the resulting JSON message is
 // non-deterministic, so the client should not rely on key ordering.
-func InsertKeyJSON(cdc *wire.Codec, baseJSON []byte, key string, value json.RawMessage) ([]byte, error) {
+func InsertKeyJSON(cdc *codec.Codec, baseJSON []byte, key string, value json.RawMessage) ([]byte, error) {
 	var jsonMap map[string]json.RawMessage

 	if err := cdc.UnmarshalJSON(baseJSON, &jsonMap); err != nil {
@ -155,7 +155,7 @@ func InsertKeyJSON(cdc *wire.Codec, baseJSON []byte, key string, value json.RawM
 	}

 	jsonMap[key] = value
-	bz, err := wire.MarshalJSONIndent(cdc, jsonMap)
+	bz, err := codec.MarshalJSONIndent(cdc, jsonMap)

 	return json.RawMessage(bz), err
 }
--- a/server/util_test.go
+++ b/server/util_test.go
@ -4,12 +4,12 @@ import (
 	"encoding/json"
 	"testing"

-	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/stretchr/testify/require"
 )

 func TestInsertKeyJSON(t *testing.T) {
-	cdc := wire.NewCodec()
+	cdc := codec.New()

 	foo := map[string]string{"foo": "foofoo"}
 	bar := map[string]string{"barInner": "barbar"}
--- a/store/codec.go
+++ b/store/codec.go
--- a/store/rootmultistore.go
+++ b/store/rootmultistore.go
@ -119,28 +119,28 @@ func (rs *rootMultiStore) LoadVersion(ver int64) error {
 		return err
 	}

+	// Convert StoreInfos slice to map
+	infos := make(map[StoreKey]storeInfo)
+	for _, storeInfo := range cInfo.StoreInfos {
+		infos[rs.nameToKey(storeInfo.Name)] = storeInfo
+	}
+
 	// Load each Store
 	var newStores = make(map[StoreKey]CommitStore)
-	for _, storeInfo := range cInfo.StoreInfos {
-		key, commitID := rs.nameToKey(storeInfo.Name), storeInfo.Core.CommitID
-		storeParams := rs.storesParams[key]
-		store, err := rs.loadCommitStoreFromParams(key, commitID, storeParams)
+	for key, storeParams := range rs.storesParams {
+		var id CommitID
+		info, ok := infos[key]
+		if ok {
+			id = info.Core.CommitID
+		}
+
+		store, err := rs.loadCommitStoreFromParams(key, id, storeParams)
 		if err != nil {
 			return fmt.Errorf("failed to load rootMultiStore: %v", err)
 		}
 		newStores[key] = store
 	}

-	// TODO: detecting transient is quite adhoc
-	// If any nontransient CommitStoreLoaders were not used, return error.
-	for key, param := range rs.storesParams {
-		if param.typ != sdk.StoreTypeTransient {
-			if _, ok := newStores[key]; !ok {
-				return fmt.Errorf("unused CommitStoreLoader: %v", key)
-			}
-		}
-	}
-
 	// Success.
 	rs.lastCommitID = cInfo.CommitID()
 	rs.stores = newStores
--- a/Show More
+++ b/Show More